@ecobridge.xyz/devicemanager 3.0.2

package/dist_ts/plugins.js

@@ -0,0 +1,30 @@
+// native scope
+import * as path from 'path';
+import * as net from 'net';
+import * as dgram from 'dgram';
+import * as events from 'events';
+export { path, net, dgram, events };
+// @push.rocks scope
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartnetwork from '@push.rocks/smartnetwork';
+// Re-export SmartRequest for HTTP
+import { SmartRequest } from '@push.rocks/smartrequest';
+export { SmartRequest };
+export { smartpath, smartpromise, smartdelay, smartnetwork, };
+// third party
+import * as bonjourService from 'bonjour-service';
+import ipp from 'ipp';
+import nodeSsdpModule from 'node-ssdp';
+import * as netSnmp from 'net-snmp';
+import * as sonos from 'sonos';
+import * as castv2Client from 'castv2-client';
+import WebSocket from 'ws';
+// node-ssdp exports Client/Server under default in ESM
+const nodeSsdp = {
+    Client: nodeSsdpModule.Client,
+    Server: nodeSsdpModule.Server,
+};
+export { bonjourService, ipp, nodeSsdp, netSnmp, sonos, castv2Client, WebSocket };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZTtBQUNmLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBQy9CLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBRWpDLE9BQU8sRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBQztBQUVwQyxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUV6RCxrQ0FBa0M7QUFDbEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxZQUFZLEVBQUUsQ0FBQztBQUV4QixPQUFPLEVBQ0wsU0FBUyxFQUNULFlBQVksRUFDWixVQUFVLEVBQ1YsWUFBWSxHQUNiLENBQUM7QUFFRixjQUFjO0FBQ2QsT0FBTyxLQUFLLGNBQWMsTUFBTSxpQkFBaUIsQ0FBQztBQUNsRCxPQUFPLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDdEIsT0FBTyxjQUFjLE1BQU0sV0FBVyxDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxPQUFPLE1BQU0sVUFBVSxDQUFDO0FBQ3BDLE9BQU8sS0FBSyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBQy9CLE9BQU8sS0FBSyxZQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzlDLE9BQU8sU0FBUyxNQUFNLElBQUksQ0FBQztBQUUzQix1REFBdUQ7QUFDdkQsTUFBTSxRQUFRLEdBQUc7SUFDZixNQUFNLEVBQUUsY0FBYyxDQUFDLE1BQU07SUFDN0IsTUFBTSxFQUFFLGNBQWMsQ0FBQyxNQUFNO0NBQzlCLENBQUM7QUFFRixPQUFPLEVBQUUsY0FBYyxFQUFFLEdBQUcsRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxZQUFZLEVBQUUsU0FBUyxFQUFFLENBQUMifQ==

package/dist_ts/protocols/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Protocol implementations
+ * All network communication protocols for device interaction
+ */
+export { EsclProtocol } from './protocol.escl.js';
+export { SaneProtocol } from './protocol.sane.js';
+export { IppProtocol } from './protocol.ipp.js';
+export { SnmpProtocol, SNMP_OIDS, type TSnmpValueType, type ISnmpVarbind, type ISnmpOptions, } from './protocol.snmp.js';
+export { NutProtocol, NUT_VARIABLES, NUT_COMMANDS, type TNutStatusFlag, type INutUpsInfo, type INutVariable, } from './protocol.nut.js';
+export { UpnpSoapClient, UPNP_SERVICE_TYPES, UPNP_DEVICE_TYPES, type TDlnaTransportState, type TDlnaTransportStatus, type IDlnaPositionInfo, type IDlnaTransportInfo, type IDlnaMediaInfo, type IDlnaContentItem, type IDlnaBrowseResult, } from './protocol.upnp.js';
+export { UpsSnmpHandler, UPS_SNMP_OIDS, type TUpsBatteryStatus, type TUpsOutputSource, type TUpsTestResult, type IUpsSnmpStatus, } from './protocol.upssnmp.js';
+export { HomeAssistantProtocol } from './protocol.homeassistant.js';

package/dist_ts/protocols/index.js

@@ -0,0 +1,21 @@
+/**
+ * Protocol implementations
+ * All network communication protocols for device interaction
+ */
+// eSCL/AirScan scanner protocol
+export { EsclProtocol } from './protocol.escl.js';
+// SANE network scanner protocol
+export { SaneProtocol } from './protocol.sane.js';
+// IPP printer protocol
+export { IppProtocol } from './protocol.ipp.js';
+// SNMP query protocol
+export { SnmpProtocol, SNMP_OIDS, } from './protocol.snmp.js';
+// Network UPS Tools protocol
+export { NutProtocol, NUT_VARIABLES, NUT_COMMANDS, } from './protocol.nut.js';
+// UPnP/DLNA SOAP protocol
+export { UpnpSoapClient, UPNP_SERVICE_TYPES, UPNP_DEVICE_TYPES, } from './protocol.upnp.js';
+// UPS SNMP (UPS-MIB RFC 1628)
+export { UpsSnmpHandler, UPS_SNMP_OIDS, } from './protocol.upssnmp.js';
+// Home Assistant WebSocket protocol
+export { HomeAssistantProtocol } from './protocol.homeassistant.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wcm90b2NvbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgsZ0NBQWdDO0FBQ2hDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUVsRCxnQ0FBZ0M7QUFDaEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWxELHVCQUF1QjtBQUN2QixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFaEQsc0JBQXNCO0FBQ3RCLE9BQU8sRUFDTCxZQUFZLEVBQ1osU0FBUyxHQUlWLE1BQU0sb0JBQW9CLENBQUM7QUFFNUIsNkJBQTZCO0FBQzdCLE9BQU8sRUFDTCxXQUFXLEVBQ1gsYUFBYSxFQUNiLFlBQVksR0FJYixNQUFNLG1CQUFtQixDQUFDO0FBRTNCLDBCQUEwQjtBQUMxQixPQUFPLEVBQ0wsY0FBYyxFQUNkLGtCQUFrQixFQUNsQixpQkFBaUIsR0FRbEIsTUFBTSxvQkFBb0IsQ0FBQztBQUU1Qiw4QkFBOEI7QUFDOUIsT0FBTyxFQUNMLGNBQWMsRUFDZCxhQUFhLEdBS2QsTUFBTSx1QkFBdUIsQ0FBQztBQUUvQixvQ0FBb0M7QUFDcEMsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sNkJBQTZCLENBQUMifQ==

package/dist_ts/protocols/protocol.escl.d.ts

@@ -0,0 +1,58 @@
+import type { IEsclCapabilities, IEsclScanStatus, IScanOptions, IScanResult } from '../interfaces/index.js';
+/**
+ * eSCL/AirScan protocol client for network scanners
+ */
+export declare class EsclProtocol {
+    private baseUrl;
+    private capabilities;
+    constructor(address: string, port: number, secure?: boolean);
+    /**
+     * Get scanner capabilities
+     */
+    getCapabilities(): Promise<IEsclCapabilities>;
+    /**
+     * Get scanner status
+     */
+    getStatus(): Promise<IEsclScanStatus>;
+    /**
+     * Submit a scan job
+     * Returns the job URI for tracking
+     */
+    submitScanJob(options: IScanOptions): Promise<string>;
+    /**
+     * Wait for scan job to complete and download the result
+     *
+     * Note: Many scanners (including Brother) don't start scanning until
+     * NextDocument is requested. The request triggers the scan and blocks
+     * until complete. We try direct download first, then fall back to polling.
+     */
+    waitForScanComplete(jobUri: string, options: IScanOptions, pollInterval?: number): Promise<IScanResult>;
+    /**
+     * Download scanned document
+     */
+    downloadScan(jobUri: string, options: IScanOptions): Promise<IScanResult>;
+    /**
+     * Cancel a scan job
+     */
+    cancelJob(jobUri: string): Promise<void>;
+    /**
+     * Build XML scan settings
+     */
+    private buildScanSettings;
+    /**
+     * Map source to eSCL format
+     */
+    private mapSource;
+    /**
+     * Parse capabilities XML response
+     */
+    private parseCapabilities;
+    /**
+     * Parse status XML response
+     */
+    private parseStatus;
+    /**
+     * Perform a complete scan operation
+     */
+    scan(options: IScanOptions): Promise<IScanResult>;
+}

package/dist_ts/protocols/protocol.escl.js

@@ -0,0 +1,364 @@
+import * as plugins from '../plugins.js'; // Used for smartdelay
+/**
+ * eSCL XML namespaces
+ */
+const NAMESPACES = {
+    scan: 'http://schemas.hp.com/imaging/escl/2011/05/03',
+    pwg: 'http://www.pwg.org/schemas/2010/12/sm',
+};
+/**
+ * Color mode mappings
+ */
+const COLOR_MODE_MAP = {
+    color: 'RGB24',
+    grayscale: 'Grayscale8',
+    blackwhite: 'BlackAndWhite1',
+};
+/**
+ * Format MIME type mappings
+ */
+const FORMAT_MIME_MAP = {
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    pdf: 'application/pdf',
+    tiff: 'image/tiff',
+};
+/**
+ * Helper to make HTTP requests using native fetch (available in Node.js 18+)
+ */
+async function httpRequest(url, method, body) {
+    const options = { method };
+    if (body) {
+        options.headers = { 'Content-Type': 'text/xml; charset=utf-8' };
+        options.body = body;
+    }
+    const response = await fetch(url, options);
+    const responseBody = await response.text();
+    const headers = {};
+    response.headers.forEach((value, key) => {
+        headers[key.toLowerCase()] = value;
+    });
+    return {
+        status: response.status,
+        headers,
+        body: responseBody,
+    };
+}
+/**
+ * eSCL/AirScan protocol client for network scanners
+ */
+export class EsclProtocol {
+    baseUrl;
+    capabilities = null;
+    constructor(address, port, secure = false) {
+        const protocol = secure ? 'https' : 'http';
+        this.baseUrl = `${protocol}://${address}:${port}/eSCL`;
+    }
+    /**
+     * Get scanner capabilities
+     */
+    async getCapabilities() {
+        const response = await httpRequest(`${this.baseUrl}/ScannerCapabilities`, 'GET');
+        if (response.status !== 200) {
+            throw new Error(`Failed to get capabilities: HTTP ${response.status}`);
+        }
+        this.capabilities = this.parseCapabilities(response.body);
+        return this.capabilities;
+    }
+    /**
+     * Get scanner status
+     */
+    async getStatus() {
+        const response = await httpRequest(`${this.baseUrl}/ScannerStatus`, 'GET');
+        if (response.status !== 200) {
+            throw new Error(`Failed to get status: HTTP ${response.status}`);
+        }
+        return this.parseStatus(response.body);
+    }
+    /**
+     * Submit a scan job
+     * Returns the job URI for tracking
+     */
+    async submitScanJob(options) {
+        const scanSettings = this.buildScanSettings(options);
+        // Use fetch for POST with body since SmartRequest API may not support raw body
+        const response = await fetch(`${this.baseUrl}/ScanJobs`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'text/xml; charset=utf-8',
+            },
+            body: scanSettings,
+        });
+        if (response.status !== 201) {
+            throw new Error(`Failed to submit scan job: HTTP ${response.status}`);
+        }
+        // Get job URI from Location header
+        const location = response.headers.get('location');
+        if (!location) {
+            throw new Error('No job location returned from scanner');
+        }
+        return location;
+    }
+    /**
+     * Wait for scan job to complete and download the result
+     *
+     * Note: Many scanners (including Brother) don't start scanning until
+     * NextDocument is requested. The request triggers the scan and blocks
+     * until complete. We try direct download first, then fall back to polling.
+     */
+    async waitForScanComplete(jobUri, options, pollInterval = 500) {
+        // Try direct download first - this triggers the scan on many scanners
+        // (including Brother) and blocks until the scan completes
+        try {
+            const result = await this.downloadScan(jobUri, options);
+            if (result.data.length > 0) {
+                return result;
+            }
+        }
+        catch (err) {
+            // Direct download failed, fall back to polling
+        }
+        // Fall back to polling for scanners that need it
+        let attempts = 0;
+        const maxAttempts = 120; // 60 seconds max
+        while (attempts < maxAttempts) {
+            const status = await this.getStatus();
+            const job = status.jobs?.find((j) => jobUri.includes(j.jobUuid) || j.jobUri === jobUri);
+            if (job) {
+                if (job.jobState === 'Completed') {
+                    break;
+                }
+                else if (job.jobState === 'Canceled' || job.jobState === 'Aborted') {
+                    throw new Error(`Scan job ${job.jobState}: ${job.jobStateReason || 'Unknown reason'}`);
+                }
+            }
+            await plugins.smartdelay.delayFor(pollInterval);
+            attempts++;
+        }
+        if (attempts >= maxAttempts) {
+            throw new Error('Scan job timed out');
+        }
+        // Download the scanned document
+        return this.downloadScan(jobUri, options);
+    }
+    /**
+     * Download scanned document
+     */
+    async downloadScan(jobUri, options) {
+        const downloadUrl = `${jobUri}/NextDocument`;
+        const response = await fetch(downloadUrl, { method: 'GET' });
+        if (response.status !== 200) {
+            throw new Error(`Failed to download scan: HTTP ${response.status}`);
+        }
+        const format = options.format ?? 'jpeg';
+        const contentType = response.headers.get('content-type') ?? FORMAT_MIME_MAP[format];
+        // Get image dimensions from headers if available
+        const width = parseInt(response.headers.get('x-image-width') || '0') || 0;
+        const height = parseInt(response.headers.get('x-image-height') || '0') || 0;
+        const arrayBuffer = await response.arrayBuffer();
+        const data = Buffer.from(arrayBuffer);
+        return {
+            data: data,
+            format: format,
+            width: width,
+            height: height,
+            resolution: options.resolution ?? 300,
+            colorMode: options.colorMode ?? 'color',
+            mimeType: contentType,
+        };
+    }
+    /**
+     * Cancel a scan job
+     */
+    async cancelJob(jobUri) {
+        const response = await fetch(jobUri, { method: 'DELETE' });
+        // 204 No Content or 200 OK are both acceptable
+        if (response.status !== 200 && response.status !== 204) {
+            throw new Error(`Failed to cancel job: HTTP ${response.status}`);
+        }
+    }
+    /**
+     * Build XML scan settings
+     */
+    buildScanSettings(options) {
+        const resolution = options.resolution ?? 300;
+        const colorMode = COLOR_MODE_MAP[options.colorMode ?? 'color'];
+        const format = FORMAT_MIME_MAP[options.format ?? 'jpeg'];
+        const source = this.mapSource(options.source ?? 'flatbed');
+        const intent = options.intent ?? 'TextAndPhoto';
+        let xml = `<?xml version="1.0" encoding="UTF-8"?>
+<scan:ScanSettings xmlns:scan="${NAMESPACES.scan}" xmlns:pwg="${NAMESPACES.pwg}">
+  <pwg:Version>2.0</pwg:Version>
+  <scan:Intent>${intent}</scan:Intent>
+  <pwg:ScanRegions>
+    <pwg:ScanRegion>`;
+        if (options.area) {
+            // Convert mm to 300ths of an inch (eSCL uses 300dpi as base unit)
+            const toUnits = (mm) => Math.round((mm / 25.4) * 300);
+            xml += `
+      <pwg:XOffset>${toUnits(options.area.x)}</pwg:XOffset>
+      <pwg:YOffset>${toUnits(options.area.y)}</pwg:YOffset>
+      <pwg:Width>${toUnits(options.area.width)}</pwg:Width>
+      <pwg:Height>${toUnits(options.area.height)}</pwg:Height>`;
+        }
+        else {
+            // Full page (A4 default: 210x297mm)
+            xml += `
+      <pwg:XOffset>0</pwg:XOffset>
+      <pwg:YOffset>0</pwg:YOffset>
+      <pwg:Width>2480</pwg:Width>
+      <pwg:Height>3508</pwg:Height>`;
+        }
+        xml += `
+      <pwg:ContentRegionUnits>escl:ThreeHundredthsOfInches</pwg:ContentRegionUnits>
+    </pwg:ScanRegion>
+  </pwg:ScanRegions>
+  <scan:DocumentFormatExt>${format}</scan:DocumentFormatExt>
+  <scan:XResolution>${resolution}</scan:XResolution>
+  <scan:YResolution>${resolution}</scan:YResolution>
+  <scan:ColorMode>${colorMode}</scan:ColorMode>
+  <scan:InputSource>${source}</scan:InputSource>`;
+        if (options.format === 'jpeg' && options.quality) {
+            xml += `
+  <scan:CompressionFactor>${100 - options.quality}</scan:CompressionFactor>`;
+        }
+        xml += `
+</scan:ScanSettings>`;
+        return xml;
+    }
+    /**
+     * Map source to eSCL format
+     */
+    mapSource(source) {
+        switch (source) {
+            case 'flatbed':
+                return 'Platen';
+            case 'adf':
+                return 'Feeder';
+            case 'adf-duplex':
+                return 'Duplex';
+            default:
+                return 'Platen';
+        }
+    }
+    /**
+     * Parse capabilities XML response
+     */
+    parseCapabilities(body) {
+        const xml = body;
+        // Simple XML parsing without full XML parser
+        const getTagContent = (tag) => {
+            const regex = new RegExp(`<[^:]*:?${tag}[^>]*>([^<]*)<`, 'i');
+            const match = xml.match(regex);
+            return match?.[1]?.trim() ?? '';
+        };
+        const getAllTagContents = (tag) => {
+            const regex = new RegExp(`<[^:]*:?${tag}[^>]*>([^<]*)<`, 'gi');
+            const matches = [];
+            let match;
+            while ((match = regex.exec(xml)) !== null) {
+                if (match[1]?.trim()) {
+                    matches.push(match[1].trim());
+                }
+            }
+            return matches;
+        };
+        const parseResolutions = () => {
+            const resolutions = getAllTagContents('XResolution');
+            return [...new Set(resolutions.map((r) => parseInt(r)).filter((r) => !isNaN(r)))];
+        };
+        return {
+            version: getTagContent('Version') || '2.0',
+            makeAndModel: getTagContent('MakeAndModel') || getTagContent('Make') || 'Unknown',
+            serialNumber: getTagContent('SerialNumber') || undefined,
+            uuid: getTagContent('UUID') || undefined,
+            adminUri: getTagContent('AdminURI') || undefined,
+            iconUri: getTagContent('IconURI') || undefined,
+            platen: xml.includes('Platen')
+                ? {
+                    minWidth: parseInt(getTagContent('MinWidth')) || 0,
+                    maxWidth: parseInt(getTagContent('MaxWidth')) || 2550,
+                    minHeight: parseInt(getTagContent('MinHeight')) || 0,
+                    maxHeight: parseInt(getTagContent('MaxHeight')) || 3508,
+                    maxScanRegions: parseInt(getTagContent('MaxScanRegions')) || 1,
+                    supportedResolutions: parseResolutions(),
+                    colorModes: getAllTagContents('ColorMode'),
+                    documentFormats: getAllTagContents('DocumentFormatExt'),
+                }
+                : undefined,
+            adf: xml.includes('Adf') || xml.includes('ADF') || xml.includes('Feeder')
+                ? {
+                    minWidth: 0,
+                    maxWidth: 2550,
+                    minHeight: 0,
+                    maxHeight: 4200,
+                    maxScanRegions: 1,
+                    supportedResolutions: parseResolutions(),
+                    colorModes: getAllTagContents('ColorMode'),
+                    documentFormats: getAllTagContents('DocumentFormatExt'),
+                }
+                : undefined,
+        };
+    }
+    /**
+     * Parse status XML response
+     */
+    parseStatus(body) {
+        const xml = body;
+        const getTagContent = (tag) => {
+            const regex = new RegExp(`<[^:]*:?${tag}[^>]*>([^<]*)<`, 'i');
+            const match = xml.match(regex);
+            return match?.[1]?.trim() ?? '';
+        };
+        const state = getTagContent('State') || getTagContent('ScannerState') || 'Idle';
+        const adfState = getTagContent('AdfState') || undefined;
+        // Parse jobs if present
+        const jobs = [];
+        const jobMatches = xml.match(/<[^:]*:?JobInfo[^>]*>[\s\S]*?<\/[^:]*:?JobInfo>/gi);
+        if (jobMatches) {
+            for (const jobXml of jobMatches) {
+                const getJobTag = (tag) => {
+                    const regex = new RegExp(`<[^:]*:?${tag}[^>]*>([^<]*)<`, 'i');
+                    const match = jobXml.match(regex);
+                    return match?.[1]?.trim() ?? '';
+                };
+                jobs.push({
+                    jobUri: getJobTag('JobUri') || getJobTag('JobURI') || '',
+                    jobUuid: getJobTag('JobUuid') || getJobTag('JobUUID') || '',
+                    age: parseInt(getJobTag('Age')) || 0,
+                    imagesCompleted: parseInt(getJobTag('ImagesCompleted')) || 0,
+                    imagesToTransfer: parseInt(getJobTag('ImagesToTransfer')) || 0,
+                    jobState: getJobTag('JobState') || 'Pending',
+                    jobStateReason: getJobTag('JobStateReason') || undefined,
+                });
+            }
+        }
+        return {
+            state: state,
+            adfState: adfState,
+            jobs: jobs.length > 0 ? jobs : undefined,
+        };
+    }
+    /**
+     * Perform a complete scan operation
+     */
+    async scan(options) {
+        // Submit the job
+        const jobUri = await this.submitScanJob(options);
+        try {
+            // Wait for completion and download
+            return await this.waitForScanComplete(jobUri, options);
+        }
+        catch (error) {
+            // Try to cancel the job on error
+            try {
+                await this.cancelJob(jobUri);
+            }
+            catch {
+                // Ignore cancel errors
+            }
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.escl.js","sourceRoot":"","sources":["../../ts/protocols/protocol.escl.ts"],"names":[],"mappings":"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"}