jc-printer-sdk-ts 0.1.0 → 0.1.1

package/dist/webBluetoothTransport.js

@@ -0,0 +1,648 @@
+import { JCPrintApi } from "./client.js";
+import { createConnectFrame, createFrame, createRowFrames, fallbackProfile, identifyProfile, parseFrame, parseModelId, parseProtocolVersion, rasterizeDocumentPage, } from "./niimbotProtocol.js";
+export const NIIMBOT_WEB_BLUETOOTH_SERVICE_UUID = "e7810a71-73ae-499d-8c15-faa9aef0c3f2";
+export const NIIMBOT_WEB_BLUETOOTH_CHARACTERISTIC_UUID = "bef8d6c9-9c21-4c9e-b632-bd58c1009f9f";
+export const DEFAULT_WEB_BLUETOOTH_PRINTER_TRANSPORT_OPTIONS = {
+    serviceUuid: NIIMBOT_WEB_BLUETOOTH_SERVICE_UUID,
+    characteristicUuid: NIIMBOT_WEB_BLUETOOTH_CHARACTERISTIC_UUID,
+    deviceNameFilter: "",
+    scanMode: "all",
+    optionalServices: [],
+    chunkSize: 180,
+};
+function clone(value) {
+    if (typeof globalThis.structuredClone === "function") {
+        return globalThis.structuredClone(value);
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+function normalizeUuid(uuid) {
+    return uuid.trim().toLowerCase();
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.map((value) => value?.trim()).filter((value) => !!value)));
+}
+function resolveOptions(options = {}) {
+    const chunkSize = Number.isFinite(options.chunkSize)
+        ? Math.trunc(Number(options.chunkSize))
+        : DEFAULT_WEB_BLUETOOTH_PRINTER_TRANSPORT_OPTIONS.chunkSize;
+    return {
+        serviceUuid: options.serviceUuid ?? DEFAULT_WEB_BLUETOOTH_PRINTER_TRANSPORT_OPTIONS.serviceUuid,
+        characteristicUuid: options.characteristicUuid ?? DEFAULT_WEB_BLUETOOTH_PRINTER_TRANSPORT_OPTIONS.characteristicUuid,
+        deviceNameFilter: options.deviceNameFilter?.trim() ?? DEFAULT_WEB_BLUETOOTH_PRINTER_TRANSPORT_OPTIONS.deviceNameFilter,
+        scanMode: options.scanMode ?? DEFAULT_WEB_BLUETOOTH_PRINTER_TRANSPORT_OPTIONS.scanMode,
+        optionalServices: [...(options.optionalServices ?? DEFAULT_WEB_BLUETOOTH_PRINTER_TRANSPORT_OPTIONS.optionalServices)],
+        chunkSize: Math.max(20, chunkSize),
+    };
+}
+function defaultPrinterInfo() {
+    return {
+        deviceType: 2,
+        deviceName: "",
+        deviceVersion: "",
+        softwareVersion: "web-bluetooth",
+        deviceAddress: "",
+        deviceAddrType: 2,
+        deviceDPI: 0,
+        deviceWidth: 0,
+        manufacturer: "",
+        seriesName: "",
+        devIntName: "",
+        peripheralFlags: 0,
+        hardwareFlags: 0,
+        softwareFlags: 0,
+    };
+}
+function defaultPaperInfo() {
+    return {
+        state: 0,
+        gapHeightPixel: 0,
+        totalHeightPixel: 0,
+        paperType: 0,
+        gapHeight: 0,
+        totalHeight: 0,
+        paperWidthPixel: 0,
+        paperWidth: 0,
+        direction: 0,
+        tailLengthPixel: 0,
+        tailLength: 0,
+    };
+}
+export class WebBluetoothPrinterTransport {
+    constructor(options = {}) {
+        this.printerName = "";
+        this.printerInfo = defaultPrinterInfo();
+        this.paperInfo = defaultPaperInfo();
+        this.printerState = "Disconnected";
+        this.lastAddress = "";
+        this.reconnecting = false;
+        this.connectedProfile = null;
+        this.b1HandshakeDone = false;
+        this.responseQueue = [];
+        this.handleDisconnect = () => {
+            this.printerState = "Disconnected";
+            this.server = undefined;
+            this.characteristic = undefined;
+            this.sdkCallback?.onDisConnect();
+        };
+        this.handleCharacteristicChanged = (event) => {
+            const characteristic = event.target;
+            const value = characteristic?.value;
+            if (!value) {
+                return;
+            }
+            const frame = parseFrame(value);
+            if (!frame) {
+                return;
+            }
+            const response = { cmd: frame.cmd, data: frame.data };
+            const pending = this.pendingResponse;
+            if (pending && pending.expected.has(response.cmd)) {
+                clearTimeout(pending.timeoutId);
+                this.pendingResponse = undefined;
+                pending.resolve(response);
+                return;
+            }
+            this.responseQueue.push(response);
+        };
+        this.options = resolveOptions(options);
+    }
+    configure(options) {
+        this.options = resolveOptions({
+            ...this.options,
+            ...options,
+        });
+    }
+    getLastPayload() {
+        return this.lastPayload ? clone(this.lastPayload) : undefined;
+    }
+    setSdkCallback(callback) {
+        this.sdkCallback = callback;
+        if (callback && this.printerState !== "Disconnected" && this.lastAddress) {
+            callback.onConnectSuccess(this.lastAddress, 20);
+        }
+    }
+    async initSdk() {
+        return true;
+    }
+    async init() {
+        return true;
+    }
+    async connectBluetoothPrinter(address) {
+        if (!navigator.bluetooth) {
+            throw new Error("Web Bluetooth is not available in this browser.");
+        }
+        const deviceFilter = this.options.deviceNameFilter?.trim() || address.trim();
+        const serviceUuid = normalizeUuid(this.options.serviceUuid);
+        const characteristicUuid = normalizeUuid(this.options.characteristicUuid);
+        if (!serviceUuid || !characteristicUuid) {
+            throw new Error("Service UUID and characteristic UUID are required for Web Bluetooth printing.");
+        }
+        const optionalServices = uniqueStrings([serviceUuid, ...(this.options.optionalServices ?? [])]);
+        const useNameFilter = this.options.scanMode === "name" && deviceFilter;
+        const requestOptions = useNameFilter
+            ? {
+                filters: [{ namePrefix: deviceFilter }],
+                optionalServices,
+            }
+            : {
+                acceptAllDevices: true,
+                optionalServices,
+            };
+        const device = await navigator.bluetooth.requestDevice(requestOptions);
+        const server = await device.gatt?.connect();
+        if (!server) {
+            throw new Error("Failed to open the selected Bluetooth device.");
+        }
+        const service = await server.getPrimaryService(serviceUuid);
+        const characteristic = await service.getCharacteristic(characteristicUuid);
+        this.device = device;
+        this.server = server;
+        this.characteristic = characteristic;
+        this.lastAddress = device.name || device.id || deviceFilter || serviceUuid;
+        this.printerName = this.lastAddress;
+        this.printerState = "Connected";
+        this.printerInfo = {
+            ...defaultPrinterInfo(),
+            deviceName: this.printerName,
+            deviceAddress: this.lastAddress,
+            softwareVersion: "web-bluetooth",
+            deviceAddrType: 2,
+        };
+        this.paperInfo = defaultPaperInfo();
+        device.addEventListener("gattserverdisconnected", this.handleDisconnect);
+        characteristic.addEventListener("characteristicvaluechanged", this.handleCharacteristicChanged);
+        await characteristic.startNotifications();
+        await this.handshakeAndIdentify();
+        this.sdkCallback?.onConnectSuccess(this.lastAddress, 20);
+        return 0;
+    }
+    async openPrinterByAddress(address) {
+        return this.connectBluetoothPrinter(address);
+    }
+    async openPrinterSync(address) {
+        return this.connectBluetoothPrinter(address);
+    }
+    async connectWifiPrinter() {
+        throw new Error("Wi-Fi printing is not implemented in the browser transport.");
+    }
+    async configurationWifi() {
+        return 0;
+    }
+    async getConfigurationWifiName() {
+        return "";
+    }
+    async scanWifiPrinter(callback) {
+        callback.onFinish();
+    }
+    async setPrinterAutoShutdownTime() {
+        return 0;
+    }
+    async setTotalPrintQuantity() {
+        return;
+    }
+    async setTotalQuantityOfPrints() {
+        return;
+    }
+    async startPrintJob(density, paperType, printMode, callback) {
+        this.currentJob = { density, paperType, printMode, callback };
+        this.printerState = "Printing";
+        callback.onProgress(0, 0, {
+            phase: "start",
+            density,
+            paperType,
+            printMode,
+        });
+    }
+    async commitData(jsonPages, infoPages) {
+        await this.writePayload({
+            kind: "jc-printer-sdk-ts/web-bluetooth",
+            sentAt: new Date().toISOString(),
+            job: {
+                density: this.currentJob?.density ?? 0,
+                paperType: this.currentJob?.paperType ?? 0,
+                printMode: this.currentJob?.printMode ?? 0,
+            },
+            jsonPages: clone(jsonPages),
+            infoPages: clone(infoPages),
+        });
+    }
+    async commitDocument(document, infoPages) {
+        const profile = await this.resolveProfile(document);
+        this.lastPayload = {
+            kind: "jc-printer-sdk-ts/web-bluetooth",
+            sentAt: new Date().toISOString(),
+            job: {
+                density: document.job.density ?? this.currentJob?.density ?? 0,
+                paperType: document.job.paperType ?? this.currentJob?.paperType ?? 0,
+                printMode: document.job.printMode ?? this.currentJob?.printMode ?? 0,
+            },
+            document: clone(document),
+            infoPages: clone(infoPages),
+            profile: { ...profile },
+        };
+        await this.printNiimbotDocument(document, profile);
+        this.currentJob?.callback?.onProgress(document.pages.length, document.job.totalQuantity ?? 1, {
+            pages: document.pages.length,
+            profile: profile.label,
+            task: profile.task,
+            dpi: profile.dpi,
+        });
+        this.currentJob?.callback?.onBufferFree(document.pages.length, profile.printheadWidthPx);
+    }
+    async endJob() {
+        return this.endPrintJob();
+    }
+    async endPrintJob() {
+        this.printerState = this.server?.connected ? "Connected" : "Disconnected";
+        this.currentJob = undefined;
+        return true;
+    }
+    async cancelJob() {
+        this.currentJob?.callback?.onCancelJob(true);
+        this.currentJob = undefined;
+        this.printerState = this.server?.connected ? "Connected" : "Disconnected";
+        return true;
+    }
+    async cancel() {
+        await this.cancelJob();
+    }
+    async reopenPrinter() {
+        if (this.reconnecting || !this.device?.gatt || this.server?.connected) {
+            return !!this.server?.connected;
+        }
+        this.reconnecting = true;
+        try {
+            const server = await this.device.gatt.connect();
+            this.server = server;
+            const service = await server.getPrimaryService(normalizeUuid(this.options.serviceUuid));
+            const characteristic = await service.getCharacteristic(normalizeUuid(this.options.characteristicUuid));
+            this.characteristic = characteristic;
+            characteristic.addEventListener("characteristicvaluechanged", this.handleCharacteristicChanged);
+            await characteristic.startNotifications();
+            await this.handshakeAndIdentify();
+            this.printerState = "Connected";
+            this.sdkCallback?.onConnectSuccess(this.lastAddress, 20);
+            return true;
+        }
+        finally {
+            this.reconnecting = false;
+        }
+    }
+    async reopenPrinterSync() {
+        return this.reopenPrinter();
+    }
+    async close() {
+        this.currentJob?.callback?.onCancelJob(true);
+        this.currentJob = undefined;
+        this.printerState = "Disconnected";
+        if (this.device) {
+            this.device.removeEventListener("gattserverdisconnected", this.handleDisconnect);
+        }
+        if (this.characteristic) {
+            this.characteristic.removeEventListener("characteristicvaluechanged", this.handleCharacteristicChanged);
+            try {
+                await this.characteristic.stopNotifications();
+            }
+            catch {
+                // Some browsers reject when the device is already gone.
+            }
+        }
+        if (this.server?.connected) {
+            this.server.disconnect();
+        }
+        this.server = undefined;
+        this.characteristic = undefined;
+        this.printerName = "";
+        this.lastAddress = "";
+        this.sdkCallback?.onDisConnect();
+    }
+    async quit() {
+        await this.close();
+    }
+    async printBitmap(bitmap, _bundle = {}) {
+        await this.writeJson({
+            kind: "jc-printer-sdk-ts/web-bluetooth-bitmap",
+            sentAt: new Date().toISOString(),
+            bitmap,
+        });
+        return true;
+    }
+    async printATBitmap(bitmap, _bundle = {}) {
+        await this.writeJson({
+            kind: "jc-printer-sdk-ts/web-bluetooth-at-bitmap",
+            sentAt: new Date().toISOString(),
+            bitmap,
+        });
+        return true;
+    }
+    async getPaperInfo() {
+        return clone(this.paperInfo);
+    }
+    async isConnection() {
+        return this.server?.connected ? 0 : -1;
+    }
+    async getPrintScaleMultiplier() {
+        return 1;
+    }
+    async getPrinterName() {
+        return this.printerName;
+    }
+    async getPrinterInfo() {
+        return clone(this.printerInfo);
+    }
+    async getPrinterState() {
+        return this.printerState;
+    }
+    async waitPrinterState(state, timeoutMs) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            if (this.printerState === state) {
+                return true;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        return false;
+    }
+    async measureFontHeight(text, _x, _y, _width, _height, _rotation, fontSize) {
+        const lines = text.split(/\r?\n/).length;
+        return Math.max(fontSize, Math.ceil(fontSize * 1.2 * lines));
+    }
+    async generatePreviewImage(json, info) {
+        return {
+            width: 0,
+            height: 0,
+            description: "web-bluetooth-preview",
+            meta: { json, info },
+        };
+    }
+    async generatePrintPreviewImage(json, widthMm, heightMm, orientation) {
+        return {
+            width: widthMm,
+            height: heightMm,
+            description: "web-bluetooth-print-preview",
+            meta: { json, orientation },
+        };
+    }
+    setPrinterState(state) {
+        this.printerState = state;
+    }
+    setPrinterInfo(info) {
+        this.printerInfo = clone(info);
+    }
+    setPaperInfo(info) {
+        this.paperInfo = clone(info);
+    }
+    setScanResults(_results) {
+        return;
+    }
+    emitPrintProgress(pageIndex, quantityIndex, meta) {
+        this.currentJob?.callback?.onProgress(pageIndex, quantityIndex, meta ?? {});
+    }
+    emitPrintError(errorCode, printState) {
+        this.currentJob?.callback?.onError(errorCode, printState);
+    }
+    emitBufferFree(pageIndex, bufferSize) {
+        this.currentJob?.callback?.onBufferFree(pageIndex, bufferSize);
+    }
+    emitCancel(success) {
+        this.currentJob?.callback?.onCancelJob(success);
+    }
+    async writePayload(payload) {
+        this.lastPayload = clone(payload);
+        await this.writeJson(payload);
+        this.currentJob?.callback?.onProgress(1, 1, {
+            bytes: JSON.stringify(payload).length,
+        });
+        this.currentJob?.callback?.onBufferFree(1, JSON.stringify(payload).length);
+    }
+    async writeJson(payload) {
+        const characteristic = this.characteristic;
+        if (!characteristic) {
+            throw new Error("No writable Bluetooth characteristic is connected.");
+        }
+        const text = JSON.stringify(payload);
+        const encoded = new TextEncoder().encode(text);
+        const chunkSize = Math.max(20, this.options.chunkSize ?? 180);
+        const canWriteWithoutResponse = typeof characteristic.writeValueWithoutResponse === "function";
+        for (let offset = 0; offset < encoded.length; offset += chunkSize) {
+            const chunk = encoded.slice(offset, offset + chunkSize);
+            await this.writeBytes(chunk, 0, characteristic, canWriteWithoutResponse);
+        }
+    }
+    async handshakeAndIdentify() {
+        this.responseQueue = [];
+        this.connectedProfile = null;
+        this.b1HandshakeDone = false;
+        await this.writeBytes(createConnectFrame());
+        await this.waitForCommand([0xc2], 1500, true);
+        const status = await this.sendCommand(0xa5, [0x01], [0xb5], 1500, true);
+        const protocolVersion = status ? parseProtocolVersion(status.data) : undefined;
+        const model = await this.sendCommand(0x40, [0x08], [0x48], 1500, true);
+        const modelId = model ? parseModelId(model.data) : undefined;
+        this.connectedProfile = identifyProfile(modelId, protocolVersion);
+        if (this.connectedProfile?.task === "b1") {
+            await this.finishB1Handshake();
+        }
+        const profile = this.connectedProfile;
+        if (profile) {
+            this.printerInfo = {
+                ...this.printerInfo,
+                deviceType: profile.modelId ?? 0,
+                deviceDPI: profile.dpi,
+                deviceWidth: profile.printheadWidthPx,
+                seriesName: profile.label,
+                hardwareFlags: profile.modelId ?? 0,
+                softwareFlags: profile.protocolVersion ?? 0,
+            };
+        }
+    }
+    async finishB1Handshake() {
+        if (this.b1HandshakeDone) {
+            return;
+        }
+        for (const subCode of [0x0b, 0x0d, 0x0a, 0x07, 0x03, 0x0c, 0x09]) {
+            await this.sendCommand(0x40, [subCode], [0x40 + subCode], 1500, true);
+        }
+        await this.sendCommand(0xdc, [0x04], [0xd9], 1500, true);
+        this.b1HandshakeDone = true;
+    }
+    async resolveProfile(document) {
+        const requestedTask = document.job.meta?.printTask;
+        const task = requestedTask === "b1" || requestedTask === "v4" ? requestedTask : "auto";
+        const requestedDpi = Number(document.job.meta?.dpi ?? 0);
+        if (task === "auto" && this.connectedProfile) {
+            return clone(this.connectedProfile);
+        }
+        const fallback = fallbackProfile(task, requestedDpi);
+        if (fallback.task === "b1") {
+            await this.finishB1Handshake();
+        }
+        return fallback;
+    }
+    async printNiimbotDocument(document, profile) {
+        if (!document.pages.length) {
+            throw new Error("The print document has no pages.");
+        }
+        const copies = Math.max(1, Math.trunc(Number(document.job.totalQuantity ?? 1)));
+        const physicalPages = document.pages.length * copies;
+        const density = this.normalizeDensity(Number(document.job.density ?? 3), profile.task);
+        const speed = this.normalizeSpeed(Number(document.job.meta?.speed ?? 2));
+        this.currentJob?.callback?.onProgress(0, 0, {
+            phase: "protocol-start",
+            task: profile.task,
+            profile: profile.label,
+            dpi: profile.dpi,
+            physicalPages,
+        });
+        await this.sendCommand(0x21, [density], [0x31], 2000);
+        await this.sendCommand(0x23, [Number(document.job.paperType ?? 1) & 0xff], [0x33], 2000);
+        const startPayload = profile.task === "v4"
+            ? [physicalPages >> 8, physicalPages & 0xff, 0, 0, 0, 0, 0, speed, 0]
+            : [physicalPages >> 8, physicalPages & 0xff, 0, 0, 0, 0, 0];
+        await this.sendCommand(0x01, startPayload, [0x02], 3000);
+        if (profile.task === "v4") {
+            await this.sendCommand(0xa3, [0x01], undefined, 0, true);
+            await delay(30);
+        }
+        let printedPage = 0;
+        for (let copyIndex = 0; copyIndex < copies; copyIndex += 1) {
+            for (let pageIndex = 0; pageIndex < document.pages.length; pageIndex += 1) {
+                const page = document.pages[pageIndex];
+                const raster = await rasterizeDocumentPage(page, document, profile);
+                if (profile.task === "b1") {
+                    await this.sendCommand(0x03, [0x01], [0x04], 3000);
+                }
+                else {
+                    await this.sendCommand(0xa3, [0x01], undefined, 0, true);
+                    await delay(30);
+                }
+                const sizePayload = profile.task === "v4"
+                    ? [
+                        raster.heightPx >> 8,
+                        raster.heightPx & 0xff,
+                        raster.widthPx >> 8,
+                        raster.widthPx & 0xff,
+                        0x00,
+                        0x01,
+                        0x00,
+                        0x00,
+                        0x00,
+                        0x00,
+                        0x00,
+                        0x00,
+                        0x00,
+                    ]
+                    : [
+                        raster.heightPx >> 8,
+                        raster.heightPx & 0xff,
+                        raster.widthPx >> 8,
+                        raster.widthPx & 0xff,
+                        0x00,
+                        0x01,
+                    ];
+                await this.sendCommand(0x13, sizePayload, [0x14], 3000);
+                await this.writeRows(createRowFrames(raster), profile.paceMs);
+                await this.sendCommand(0xe3, [0x01], [0xe4], 8000);
+                printedPage += 1;
+                this.currentJob?.callback?.onProgress(pageIndex + 1, copyIndex + 1, {
+                    phase: "page-sent",
+                    page: printedPage,
+                    total: physicalPages,
+                    widthPx: raster.widthPx,
+                    heightPx: raster.heightPx,
+                    stride: raster.stride,
+                });
+            }
+        }
+        await this.waitUntilPrinted(physicalPages);
+        await this.sendCommand(0xf3, [0x01], [0xf4], 8000);
+        if (profile.task === "v4") {
+            await this.sendCommand(0xdc, [0x01], undefined, 0, true);
+        }
+    }
+    async waitUntilPrinted(pageNumber) {
+        const startedAt = Date.now();
+        this.responseQueue = this.responseQueue.filter((response) => response.cmd !== 0xb3);
+        while (Date.now() - startedAt < 25000) {
+            const response = await this.sendCommand(0xa3, [0x01], [0xb3], 1200, true);
+            if (response?.data && response.data.length >= 2) {
+                const page = (response.data[0] << 8) | response.data[1];
+                if (page >= pageNumber) {
+                    return;
+                }
+            }
+            await delay(400);
+        }
+    }
+    async writeRows(frames, paceMs) {
+        for (const frame of frames) {
+            await this.writeBytes(frame, paceMs);
+        }
+    }
+    async sendCommand(cmd, data, expected, timeoutMs = 2000, optional = false) {
+        const wait = expected?.length ? this.waitForCommand(expected, timeoutMs, optional) : Promise.resolve(null);
+        await this.writeBytes(createFrame(cmd, data));
+        return wait;
+    }
+    async waitForCommand(expected, timeoutMs, optional) {
+        const expectedSet = new Set(expected.map((cmd) => cmd & 0xff));
+        const queuedIndex = this.responseQueue.findIndex((response) => expectedSet.has(response.cmd));
+        if (queuedIndex >= 0) {
+            const [queued] = this.responseQueue.splice(queuedIndex, 1);
+            return queued;
+        }
+        return new Promise((resolve, reject) => {
+            this.pendingResponse = {
+                expected: expectedSet,
+                resolve,
+                reject,
+                optional,
+                timeoutId: window.setTimeout(() => {
+                    this.pendingResponse = undefined;
+                    if (optional) {
+                        resolve(null);
+                    }
+                    else {
+                        reject(new Error(`Timed out waiting for printer response 0x${expected[0].toString(16)}.`));
+                    }
+                }, timeoutMs),
+            };
+        });
+    }
+    async writeBytes(bytes, paceMs = 0, characteristic = this.characteristic, canWriteWithoutResponse = !!characteristic && typeof characteristic.writeValueWithoutResponse === "function") {
+        if (!characteristic) {
+            throw new Error("No writable Bluetooth characteristic is connected.");
+        }
+        const payload = new ArrayBuffer(bytes.byteLength);
+        new Uint8Array(payload).set(bytes);
+        if (canWriteWithoutResponse) {
+            await characteristic.writeValueWithoutResponse(payload);
+        }
+        else {
+            await characteristic.writeValue(payload);
+        }
+        if (paceMs > 0) {
+            await delay(paceMs);
+        }
+    }
+    normalizeDensity(value, task) {
+        if (task === "b1") {
+            return Math.max(1, Math.min(5, Math.round(value)));
+        }
+        return Math.max(1, Math.min(14, Math.round(value)));
+    }
+    normalizeSpeed(value) {
+        return Math.max(0, Math.min(4, Math.round(value)));
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => window.setTimeout(resolve, ms));
+}
+export function createWebBluetoothPrinterTransport(options = {}) {
+    return new WebBluetoothPrinterTransport(options);
+}
+export function createWebBluetoothPrinterClient(options = {}, sdkCallback) {
+    return new JCPrintApi(createWebBluetoothPrinterTransport(options), sdkCallback);
+}
+//# sourceMappingURL=webBluetoothTransport.js.map