recker 1.0.20 → 1.0.21-next.b21cd45

package/dist/plugins/hls.js

@@ -1,225 +1,395 @@
 import { createWriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { mkdir, readdir, readFile, rm } from 'node:fs/promises';
-function parseM3u8(content, baseUrl) {
+function parseAttributes(line, prefix) {
+    const attrs = {};
+    const content = line.substring(prefix.length);
+    const regex = /([A-Z0-9-]+)=(?:"([^"]*)"|([^,]*))/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        attrs[match[1]] = match[2] ?? match[3];
+    }
+    return attrs;
+}
+function resolveUrl(url, baseUrl) {
+    if (url.startsWith('http://') || url.startsWith('https://')) {
+        return url;
+    }
+    try {
+        const base = new URL(baseUrl);
+        const basePath = base.pathname.substring(0, base.pathname.lastIndexOf('/') + 1);
+        return new URL(url, base.origin + basePath).toString();
+    }
+    catch {
+        return url;
+    }
+}
+function parseMasterPlaylist(content, baseUrl) {
+    const lines = content.split('\n');
+    const variants = [];
+    let pendingVariant = {};
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (line.startsWith('#EXT-X-STREAM-INF:')) {
+            const attrs = parseAttributes(line, '#EXT-X-STREAM-INF:');
+            pendingVariant = {
+                bandwidth: attrs.BANDWIDTH ? parseInt(attrs.BANDWIDTH, 10) : undefined,
+                resolution: attrs.RESOLUTION,
+                codecs: attrs.CODECS,
+                name: attrs.NAME,
+            };
+        }
+        else if (!line.startsWith('#') && pendingVariant.bandwidth !== undefined) {
+            variants.push({
+                ...pendingVariant,
+                url: resolveUrl(line, baseUrl),
+            });
+            pendingVariant = {};
+        }
+    }
+    return { variants, isMaster: true };
+}
+function parseMediaPlaylist(content, baseUrl) {
     const lines = content.split('\n');
     const segments = [];
-    let currentDuration = 0;
-    let mediaSequence = 0;
     let targetDuration = 5;
+    let mediaSequence = 0;
+    let discontinuitySequence = 0;
     let endList = false;
+    let playlistType;
+    let currentDuration = 0;
     let currentKey;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
+    let currentDiscontinuity = false;
+    let currentProgramDateTime;
+    let segmentIndex = 0;
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
         if (!line)
             continue;
         if (line.startsWith('#EXT-X-TARGETDURATION:')) {
-            targetDuration = parseFloat(line.split(':')[1]);
+            targetDuration = parseInt(line.split(':')[1], 10);
         }
         else if (line.startsWith('#EXT-X-MEDIA-SEQUENCE:')) {
             mediaSequence = parseInt(line.split(':')[1], 10);
         }
-        else if (line.startsWith('#EXT-X-ENDLIST')) {
+        else if (line.startsWith('#EXT-X-DISCONTINUITY-SEQUENCE:')) {
+            discontinuitySequence = parseInt(line.split(':')[1], 10);
+        }
+        else if (line.startsWith('#EXT-X-PLAYLIST-TYPE:')) {
+            playlistType = line.split(':')[1];
+        }
+        else if (line === '#EXT-X-ENDLIST') {
             endList = true;
         }
+        else if (line === '#EXT-X-DISCONTINUITY') {
+            currentDiscontinuity = true;
+        }
+        else if (line.startsWith('#EXT-X-PROGRAM-DATE-TIME:')) {
+            currentProgramDateTime = new Date(line.split(':').slice(1).join(':'));
+        }
         else if (line.startsWith('#EXT-X-KEY:')) {
-            const attrs = line.substring(11);
-            const methodMatch = attrs.match(/METHOD=([^,]+)/);
-            const uriMatch = attrs.match(/URI="([^"]+)"/);
-            const ivMatch = attrs.match(/IV=([^,]+)/);
-            if (methodMatch) {
+            const attrs = parseAttributes(line, '#EXT-X-KEY:');
+            if (attrs.METHOD === 'NONE') {
+                currentKey = undefined;
+            }
+            else {
                 currentKey = {
-                    method: methodMatch[1],
-                    uri: uriMatch ? uriMatch[1] : undefined,
-                    iv: ivMatch ? ivMatch[1] : undefined
+                    method: attrs.METHOD,
+                    uri: attrs.URI ? resolveUrl(attrs.URI, baseUrl) : undefined,
+                    iv: attrs.IV,
                 };
             }
         }
         else if (line.startsWith('#EXTINF:')) {
-            const durationStr = line.substring(8).split(',', 1)[0];
+            const durationStr = line.substring(8).split(',')[0];
             currentDuration = parseFloat(durationStr);
         }
         else if (!line.startsWith('#')) {
-            let url = line;
-            if (!url.startsWith('http')) {
-                try {
-                    const base = new URL(baseUrl);
-                    const basePath = base.pathname.substring(0, base.pathname.lastIndexOf('/') + 1);
-                    url = new URL(url, base.origin + basePath).toString();
-                }
-                catch {
-                }
-            }
             segments.push({
-                url,
+                url: resolveUrl(line, baseUrl),
                 duration: currentDuration,
-                sequence: 0,
-                key: currentKey
+                sequence: mediaSequence + segmentIndex,
+                key: currentKey,
+                discontinuity: currentDiscontinuity,
+                programDateTime: currentProgramDateTime,
             });
+            segmentIndex++;
+            currentDiscontinuity = false;
+            currentProgramDateTime = undefined;
         }
     }
-    segments.forEach((seg, idx) => {
-        seg.sequence = mediaSequence + idx;
-    });
-    return { segments, targetDuration, endList, mediaSequence };
+    return {
+        segments,
+        targetDuration,
+        mediaSequence,
+        endList,
+        playlistType,
+        discontinuitySequence,
+    };
 }
-function parseVariants(content, baseUrl) {
-    const lines = content.split('\n');
-    const variants = [];
-    let currentBandwidth;
-    let currentResolution;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        if (!line)
-            continue;
-        if (line.startsWith('#EXT-X-STREAM-INF:')) {
-            const bwMatch = line.match(/BANDWIDTH=(\d+)/);
-            const resMatch = line.match(/RESOLUTION=(\d+x\d+)/);
-            if (bwMatch)
-                currentBandwidth = parseInt(bwMatch[1], 10);
-            if (resMatch)
-                currentResolution = resMatch[1];
-        }
-        else if (!line.startsWith('#')) {
-            let url = line;
-            if (!url.startsWith('http')) {
-                try {
-                    const base = new URL(baseUrl);
-                    const basePath = base.pathname.substring(0, base.pathname.lastIndexOf('/') + 1);
-                    url = new URL(url, base.origin + basePath).toString();
-                }
-                catch { }
-            }
-            variants.push({
-                url,
-                bandwidth: currentBandwidth,
-                resolution: currentResolution
-            });
-        }
+function isMasterPlaylist(content) {
+    return content.includes('#EXT-X-STREAM-INF');
+}
+function selectVariant(variants, quality) {
+    if (!variants.length) {
+        throw new Error('No variants found in master playlist');
+    }
+    const sorted = [...variants].sort((a, b) => (a.bandwidth ?? 0) - (b.bandwidth ?? 0));
+    if (quality === 'lowest') {
+        return sorted[0];
     }
-    return variants;
+    if (quality === 'highest' || quality === undefined) {
+        return sorted[sorted.length - 1];
+    }
+    if (quality.resolution) {
+        const match = variants.find((v) => v.resolution === quality.resolution);
+        if (match)
+            return match;
+    }
+    if (quality.bandwidth) {
+        const target = quality.bandwidth;
+        return sorted.reduce((prev, curr) => {
+            const prevDiff = Math.abs((prev.bandwidth ?? 0) - target);
+            const currDiff = Math.abs((curr.bandwidth ?? 0) - target);
+            return currDiff < prevDiff ? curr : prev;
+        });
+    }
+    return sorted[sorted.length - 1];
 }
-export async function downloadHls(client, manifestUrl, outputPath, options = {}) {
-    const merge = options.merge !== false;
-    const concurrency = options.concurrency || 5;
-    const isLive = options.live === true;
-    const maxDuration = options.duration || (isLive ? Infinity : 0);
-    const info = options.onInfo || (() => { });
-    const error = options.onError || ((err) => { throw err; });
-    const seenSegments = new Set();
-    const outputDir = merge ? dirname(outputPath) : outputPath;
-    await mkdir(outputDir, { recursive: true });
-    const tempDir = join(outputDir, `.tmp_${Date.now()}_${Math.random().toString(36).slice(2)}`);
-    if (merge) {
-        await mkdir(tempDir, { recursive: true });
-    }
-    let currentManifestUrl = manifestUrl;
-    try {
-        let initialManifest = await client.get(currentManifestUrl).text();
-        if (options.onManifest) {
-            const modified = options.onManifest(initialManifest, currentManifestUrl);
-            if (typeof modified === 'string')
-                initialManifest = modified;
-        }
-        if (initialManifest.includes('#EXT-X-STREAM-INF')) {
-            const variants = parseVariants(initialManifest, currentManifestUrl);
-            if (variants.length > 0) {
-                let selected = variants[variants.length - 1];
-                if (options.onVariantSelected) {
-                    const userSelected = options.onVariantSelected(variants, selected);
-                    if (userSelected)
-                        selected = userSelected;
-                }
-                currentManifestUrl = selected.url;
-                info(`Master playlist detected. Switching to variant: ${currentManifestUrl}`);
-            }
+export class HlsPromise {
+    client;
+    manifestUrl;
+    options;
+    seenSequences = new Set();
+    downloadedBytes = 0;
+    downloadedSegments = 0;
+    startTime = 0;
+    aborted = false;
+    abortController = new AbortController();
+    constructor(client, manifestUrl, options = {}) {
+        this.client = client;
+        this.manifestUrl = manifestUrl;
+        this.options = {
+            mode: 'merge',
+            format: 'ts',
+            concurrency: 5,
+            ...options,
+        };
+        if (this.options.format !== 'ts') {
+            throw new Error(`Format '${this.options.format}' requires ffmpeg. Use format: 'ts' or install ffmpeg.`);
         }
     }
-    catch (err) {
-        error(new Error(`Failed to fetch initial manifest: ${err}`));
-        return;
+    get [Symbol.toStringTag]() {
+        return 'HlsPromise';
     }
-    const { RequestRunner } = await import('../runner/request-runner.js');
-    const runner = new RequestRunner({ concurrency });
-    const startTime = Date.now();
-    let recording = true;
-    while (recording) {
-        try {
-            let content = await client.get(currentManifestUrl).text();
-            if (options.onManifest) {
-                const modified = options.onManifest(content, currentManifestUrl);
-                if (typeof modified === 'string')
-                    content = modified;
+    then(onfulfilled, onrejected) {
+        return Promise.reject(new Error('HlsPromise requires .download(), .stream(), or .pipe() to execute')).then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.then(null, onrejected);
+    }
+    finally(onfinally) {
+        return this.then(() => {
+            onfinally?.();
+        }, () => {
+            onfinally?.();
+        });
+    }
+    cancel() {
+        this.aborted = true;
+        this.abortController.abort();
+    }
+    async download(dest) {
+        this.startTime = Date.now();
+        const mediaPlaylistUrl = await this.resolveMediaPlaylist();
+        if (this.options.mode === 'chunks') {
+            await this.downloadChunks(mediaPlaylistUrl, dest);
+        }
+        else {
+            if (typeof dest !== 'string') {
+                throw new Error('Merge mode requires a string path, not a function');
             }
-            const playlist = parseM3u8(content, currentManifestUrl);
-            let newSegments = playlist.segments.filter(s => !seenSegments.has(s.url));
-            if (options.onSegment) {
-                const filtered = [];
-                for (const seg of newSegments) {
-                    if (seg.key && options.onKey) {
-                        const modifiedKey = options.onKey(seg.key);
-                        if (modifiedKey)
-                            seg.key = modifiedKey;
-                    }
-                    const res = options.onSegment(seg);
-                    if (res === null)
-                        continue;
-                    if (res)
-                        filtered.push(res);
-                    else
-                        filtered.push(seg);
+            await this.downloadMerged(mediaPlaylistUrl, dest);
+        }
+    }
+    async *stream() {
+        this.startTime = Date.now();
+        const mediaPlaylistUrl = await this.resolveMediaPlaylist();
+        const isLive = this.isLiveMode();
+        const maxDuration = this.getMaxDuration();
+        while (!this.aborted) {
+            const playlist = await this.fetchMediaPlaylist(mediaPlaylistUrl);
+            const newSegments = playlist.segments.filter((s) => !this.seenSequences.has(s.sequence));
+            for (const segment of newSegments) {
+                if (this.aborted)
+                    break;
+                if (maxDuration && Date.now() - this.startTime > maxDuration) {
+                    return;
                 }
-                newSegments = filtered;
-            }
-            if (newSegments.length > 0) {
-                info(`Found ${newSegments.length} new segments.`);
-                await runner.run(newSegments, async (seg) => {
-                    seenSegments.add(seg.url);
-                    const fileDest = merge
-                        ? join(tempDir, `${seg.sequence.toString().padStart(10, '0')}.ts`)
-                        : join(outputDir, `segment_${seg.sequence}.ts`);
-                    await client.get(seg.url).write(fileDest);
-                });
+                this.seenSequences.add(segment.sequence);
+                const data = await this.downloadSegment(segment);
+                const segmentData = {
+                    sequence: segment.sequence,
+                    duration: segment.duration,
+                    data,
+                    url: segment.url,
+                    downloadedAt: new Date(),
+                };
+                this.downloadedSegments++;
+                this.downloadedBytes += data.byteLength;
+                this.emitProgress(playlist, isLive);
+                if (this.options.onSegment) {
+                    await this.options.onSegment(segmentData);
+                }
+                yield segmentData;
             }
             if (!isLive || playlist.endList) {
-                recording = false;
                 break;
             }
-            if (maxDuration > 0 && (Date.now() - startTime) > maxDuration) {
-                info('Max duration reached. Stopping.');
-                recording = false;
+            if (maxDuration && Date.now() - this.startTime > maxDuration) {
                 break;
             }
-            const waitTime = Math.max(1000, (playlist.targetDuration * 1000) / 2);
-            await new Promise(r => setTimeout(r, waitTime));
-        }
-        catch (err) {
-            if (isLive) {
-                info(`Error fetching live manifest, retrying: ${err.message}`);
-                const waitTime = 5000;
-                await new Promise(r => setTimeout(r, waitTime));
+            const pollInterval = Math.max(1000, (playlist.targetDuration * 1000) / 2);
+            await this.sleep(pollInterval);
+        }
+    }
+    async pipe(writable) {
+        try {
+            for await (const segment of this.stream()) {
+                const canContinue = writable.write(segment.data);
+                if (!canContinue) {
+                    await new Promise((resolve) => writable.once('drain', resolve));
+                }
             }
-            else {
-                error(new Error(`HLS download failed: ${err.message}`));
-                recording = false;
+        }
+        finally {
+            if ('end' in writable && typeof writable.end === 'function') {
+                writable.end();
             }
         }
     }
-    if (merge) {
-        info('Merging segments...');
-        const dest = createWriteStream(outputPath);
-        const files = (await readdir(tempDir)).sort();
-        for (const file of files) {
-            if (!file.endsWith('.ts'))
-                continue;
-            const chunk = await readFile(join(tempDir, file));
-            dest.write(chunk);
+    async info() {
+        const content = await this.client.get(this.manifestUrl).text();
+        if (isMasterPlaylist(content)) {
+            const master = parseMasterPlaylist(content, this.manifestUrl);
+            const selectedVariant = selectVariant(master.variants, this.options.quality);
+            const playlistContent = await this.client.get(selectedVariant.url).text();
+            const playlist = parseMediaPlaylist(playlistContent, selectedVariant.url);
+            const totalDuration = playlist.endList
+                ? playlist.segments.reduce((sum, s) => sum + s.duration, 0)
+                : undefined;
+            return {
+                master,
+                playlist,
+                selectedVariant,
+                isLive: !playlist.endList,
+                totalDuration,
+            };
+        }
+        const playlist = parseMediaPlaylist(content, this.manifestUrl);
+        const totalDuration = playlist.endList
+            ? playlist.segments.reduce((sum, s) => sum + s.duration, 0)
+            : undefined;
+        return {
+            playlist,
+            isLive: !playlist.endList,
+            totalDuration,
+        };
+    }
+    async resolveMediaPlaylist() {
+        const content = await this.client.get(this.manifestUrl).text();
+        if (!isMasterPlaylist(content)) {
+            return this.manifestUrl;
+        }
+        const master = parseMasterPlaylist(content, this.manifestUrl);
+        const variant = selectVariant(master.variants, this.options.quality);
+        return variant.url;
+    }
+    async fetchMediaPlaylist(url) {
+        const content = await this.client.get(url).text();
+        return parseMediaPlaylist(content, url);
+    }
+    async downloadSegment(segment) {
+        if (segment.key && segment.key.method !== 'NONE') {
+            throw new Error(`Encrypted HLS (${segment.key.method}) requires ffmpeg. Use unencrypted streams or install ffmpeg.`);
+        }
+        const response = await this.client.get(segment.url, {
+            headers: this.options.headers,
+            signal: this.abortController.signal,
+        });
+        const blob = await response.blob();
+        return new Uint8Array(await blob.arrayBuffer());
+    }
+    async downloadMerged(playlistUrl, outputPath) {
+        await mkdir(dirname(outputPath), { recursive: true });
+        const output = createWriteStream(outputPath);
+        try {
+            await this.pipe(output);
+        }
+        catch (error) {
+            output.destroy();
+            throw error;
+        }
+    }
+    async downloadChunks(playlistUrl, dest) {
+        const getPath = typeof dest === 'string'
+            ? (seg) => join(dest, `segment-${seg.sequence}.ts`)
+            : dest;
+        const baseDir = typeof dest === 'string' ? dest : dirname(getPath({ sequence: 0, duration: 0, url: '' }));
+        await mkdir(baseDir, { recursive: true });
+        for await (const segment of this.stream()) {
+            const filePath = getPath({
+                sequence: segment.sequence,
+                duration: segment.duration,
+                url: segment.url,
+            });
+            await mkdir(dirname(filePath), { recursive: true });
+            const output = createWriteStream(filePath);
+            await new Promise((resolve, reject) => {
+                output.write(segment.data, (err) => {
+                    if (err)
+                        reject(err);
+                    else {
+                        output.end();
+                        resolve();
+                    }
+                });
+            });
         }
-        dest.end();
-        await rm(tempDir, { recursive: true, force: true });
-        info(`Saved to ${outputPath}`);
     }
-    else {
-        info(`Download complete.`);
+    isLiveMode() {
+        return this.options.live === true || typeof this.options.live === 'object';
     }
+    getMaxDuration() {
+        if (typeof this.options.live === 'object' && this.options.live.duration) {
+            return this.options.live.duration;
+        }
+        return undefined;
+    }
+    emitProgress(playlist, isLive) {
+        if (!this.options.onProgress)
+            return;
+        this.options.onProgress({
+            downloadedSegments: this.downloadedSegments,
+            totalSegments: isLive ? undefined : playlist.segments.length,
+            downloadedBytes: this.downloadedBytes,
+            currentSegment: Math.max(...this.seenSequences),
+            isLive,
+            elapsed: Date.now() - this.startTime,
+        });
+    }
+    sleep(ms) {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(resolve, ms);
+            this.abortController.signal.addEventListener('abort', () => {
+                clearTimeout(timeout);
+                resolve();
+            }, { once: true });
+        });
+    }
+}
+export function hls(client, manifestUrl, options = {}) {
+    return new HlsPromise(client, manifestUrl, options);
 }

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

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

package/dist/plugins/http3.d.ts

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

package/dist/plugins/index.d.ts

@@ -0,0 +1,27 @@
+export * from './auth/index.js';
+export { retryPlugin, type RetryOptions } from './retry.js';
+export { circuitBreakerPlugin, type CircuitBreakerOptions, CircuitBreakerError } from './circuit-breaker.js';
+export { rateLimitPlugin, type RateLimitOptions, RateLimitExceededError } from './rate-limit.js';
+export { cachePlugin, type CacheOptions } from './cache.js';
+export { dedupPlugin, type DedupOptions } from './dedup.js';
+export { compression } from './compression.js';
+export { loggerPlugin, type LoggerPluginOptions as LoggerOptions } from './logger.js';
+export { serverTimingPlugin } from './server-timing.js';
+export { harRecorderPlugin } from './har-recorder.js';
+export { harPlayerPlugin } from './har-player.js';
+export { xsrfPlugin, type XSRFPluginOptions as XsrfOptions } from './xsrf.js';
+export { certificatePinning, certificatePinningPlugin, type CertificatePinningOptions } from './certificate-pinning.js';
+export { parseXML, serializeXML } from './xml.js';
+export { soap, type SoapOptions } from './soap.js';
+export { graphqlPlugin, type GraphQLOptions as GraphqlOptions } from './graphql.js';
+export { jsonrpc } from './jsonrpc.js';
+export { odata, type ODataOptions } from './odata.js';
+export { proxyRotatorPlugin, type ProxyRotatorOptions } from './proxy-rotator.js';
+export { interfaceRotatorPlugin } from './interface-rotator.js';
+export { userAgentRotatorPlugin, type UserAgentOptions } from './user-agent.js';
+export { cookieJarPlugin } from './cookie-jar.js';
+export { hls, type HlsOptions } from './hls.js';
+export { http2Push } from './http2-push.js';
+export { http3 } from './http3.js';
+export { grpcWeb } from './grpc-web.js';
+export { scrape, type ScrapeOptions } from './scrape.js';

package/dist/plugins/index.js

@@ -0,0 +1,27 @@
+export * from './auth/index.js';
+export { retryPlugin } from './retry.js';
+export { circuitBreakerPlugin, CircuitBreakerError } from './circuit-breaker.js';
+export { rateLimitPlugin, RateLimitExceededError } from './rate-limit.js';
+export { cachePlugin } from './cache.js';
+export { dedupPlugin } from './dedup.js';
+export { compression } from './compression.js';
+export { loggerPlugin } from './logger.js';
+export { serverTimingPlugin } from './server-timing.js';
+export { harRecorderPlugin } from './har-recorder.js';
+export { harPlayerPlugin } from './har-player.js';
+export { xsrfPlugin } from './xsrf.js';
+export { certificatePinning, certificatePinningPlugin } from './certificate-pinning.js';
+export { parseXML, serializeXML } from './xml.js';
+export { soap } from './soap.js';
+export { graphqlPlugin } from './graphql.js';
+export { jsonrpc } from './jsonrpc.js';
+export { odata } from './odata.js';
+export { proxyRotatorPlugin } from './proxy-rotator.js';
+export { interfaceRotatorPlugin } from './interface-rotator.js';
+export { userAgentRotatorPlugin } from './user-agent.js';
+export { cookieJarPlugin } from './cookie-jar.js';
+export { hls } from './hls.js';
+export { http2Push } from './http2-push.js';
+export { http3 } from './http3.js';
+export { grpcWeb } from './grpc-web.js';
+export { scrape } from './scrape.js';

package/dist/plugins/interface-rotator.d.ts

@@ -6,5 +6,4 @@ export interface InterfaceRotatorOptions {
     excludeInternal?: boolean;
     ips?: string[];
 }
-export declare function interfaceRotator(options?: InterfaceRotatorOptions): Plugin;
-//# sourceMappingURL=interface-rotator.d.ts.map
+export declare function interfaceRotatorPlugin(options?: InterfaceRotatorOptions): Plugin;

package/dist/plugins/interface-rotator.js

@@ -1,6 +1,6 @@
 import { Agent } from 'undici';
 import { networkInterfaces } from 'node:os';
-export function interfaceRotator(options = {}) {
+export function interfaceRotatorPlugin(options = {}) {
     const strategy = options.strategy || 'round-robin';
     const familyFilter = options.family || 'IPv4';
     const excludeInternal = options.excludeInternal !== false;

package/dist/plugins/jsonrpc.d.ts

@@ -73,4 +73,3 @@ declare module '../core/client.js' {
         jsonrpc(endpoint: string, options?: Omit<JsonRpcClientOptions, 'endpoint'>): JsonRpcClient;
     }
 }
-//# sourceMappingURL=jsonrpc.d.ts.map