sane-wasm 0.1.1 → 0.2.0

package/README.md

@@ -1,8 +1,8 @@
 # SANE WebAssembly (sane-wasm)
 
-A project to bring the [SANE API](http://www.sane-project.org/intro.html) to the web.
+A project to bring the [SANE API](http://www.sane-project.org/intro.html) to Node.js and the Web using WebAssembly.
 
-Currently, it only supports USB scanners and is only tested on a browser environment (WebUSB).
+It supports USB scanners on browser environments through the [WebUSB API](https://developer.mozilla.org/en-US/docs/Web/API/WebUSB_API) and on Node.js using [node-usb](https://github.com/node-usb/node-usb).
 
 This works by compiling all SANE backends (and required dependencies) to WebAssembly using Emscripten. The other key piece is @RReverser's [bridge from libusb to WebUSB](https://github.com/libusb/libusb/pull/1057) ([1](https://web.dev/porting-libusb-to-webusb/)/[2](https://web.dev/porting-gphoto2-to-the-web/)) with [some patching](https://github.com/goncalomb/sane-wasm/issues/1) to support multi-threading.
 
@@ -10,15 +10,67 @@ Right now, it includes [all backends](http://www.sane-project.org/lists/sane-bac
 
 ## WebScan
 
-**Check [webscan.goncalomb.com](https://webscan.goncalomb.com/) for a demo of sane-wasm.** This is a React application that uses sane-wasm for document/image scanning directly in the browser. Exposes all scanning options to the user for full control.
+**Check [webscan.goncalomb.com](https://webscan.goncalomb.com/) for a demo of sane-wasm.** This is a React application that uses sane-wasm for document/image scanning directly in the browser. It exposes all scanning options to the user for full control.
 
-If you are interested in seeing the compiled output of sane-wasm, check:
+## Usage
 
-* [webscan.goncalomb.com/sane-wasm/](https://webscan.goncalomb.com/sane-wasm/): all files
-* [webscan.goncalomb.com/sane-wasm/libsane.html](https://webscan.goncalomb.com/sane-wasm/libsane.html): test page
+The pre-compiled WebAssembly package for sane-wasm is published on NPM:
+
+https://www.npmjs.com/package/sane-wasm?activeTab=code
+
+### For Web Environments (e.g. Webpack)
+
+```
+npm install -D sane-wasm
+```
+
+The main .js will not be bundled with your application. A loader ([lib/loader.js](lib/loader.js)) is provided to automatically load the .js/.wasm files from a CDN ([jsdelivr.com](https://www.jsdelivr.com/)). You can configure the loader to serve the files from your server if you want.
+
+See [examples/webpack/](examples/webpack/) for a working example.
+
+### For Node.js
+
+```
+npm install sane-wasm usb
+```
+
+The usb package ([node-usb](https://github.com/node-usb/node-usb)) is required to provide USB functionality.
+
+See [examples/node/](examples/node/) for a working example.
+
+### As Git Submodule (not recommended) / Custom Build
+
+As an alternative, you can add sane-wasm as a [submodule](https://git-scm.com/book/en/v2/Git-Tools-Submodules) to your application and integrate `./build.sh` with your build process. This is not recommended as it relies on some magical/dubious code on `./build.sh` to make the build work.
+
+You can also just build sane-wasm independently and use the build artifacts...
+
+```
+<script src="build/libsane.js"></script>
+<script>
+    window.LibSANE().then(lib => {
+        // your code
+        console.log(lib.sane_init());
+    });
+</script>
+```
+
+```
+const { libsane } = require('./sane-wasm');
+libsane().then(lib => {
+    console.log(lib.sane_init());
+});
+```
+
+```
+import { libsane } from './sane-wasm';
+const lib = await libsane();
+console.log(lib.sane_init());
+```
 
 ## Building
 
+### SANE Only
+
 Building requires [emscripten](https://github.com/emscripten-core/emscripten) and all the required tools to build the dependencies.
 
 The preferred way is just to use the pre-configured Docker image:
@@ -33,7 +85,7 @@ Start the test server with:
 
 Check the test page at: http://localhost:6931/libsane.html.
 
-### build.sh
+#### build.sh
 
 The `./build.sh` script has other options for debugging:
 
@@ -47,24 +99,9 @@ usage: build.sh [options]
   --shell        run debug shell (depends on --with-docker)
 ```
 
-## Using
-
-For now, this project has only been used on a browser environment, usage with Node.js or other environments is untested/unsupported.
-
-The recommended way to use this project is to add it as a [submodule](https://git-scm.com/book/en/v2/Git-Tools-Submodules) to your application. Integrate `./build.sh` with your build process. And include the main .js file:
-
-```
-<script src="build/libsane.js"></script>
-<script>
-    window.LibSANE().then(LibSANE => {
-        window.LibSANE = LibSANE;
-        // your code
-        console.log(LibSANE.sane_init());
-    });
-</script>
-```
+### Full Build (SANE + TypeScript)
 
-This will be improved in the future.
+To do a full build use `npm run build`.
 
 ## Exposed API
 
@@ -80,7 +117,7 @@ The most important difference with the underlying SANE API is that **device hand
 
 ### Documentation
 
-For now, check the [libsane.d.ts](libsane.d.ts) for the API declaration.
+For now, check the [src/index.ts](src/index.ts) for the API declaration.
 
 ## License
 

package/build/libsane.js

@@ -80,6 +80,7 @@ Module["ready"] = new Promise(function(resolve, reject) {
    obj.__proto__ = this.prototype;
    obj[this.reverseObject] = {};
    Object.keys(obj).forEach(k => {
+    obj[obj[k]] = k;
     obj[this.reverseObject][obj[k]] = k;
    });
   }

package/dist/index.d.ts

@@ -0,0 +1,197 @@
+export declare enum SANEStatus {
+    GOOD = 0,
+    UNSUPPORTED = 1,
+    CANCELLED = 2,
+    DEVICE_BUSY = 3,
+    INVAL = 4,
+    EOF = 5,
+    JAMMED = 6,
+    NO_DOCS = 7,
+    COVER_OPEN = 8,
+    IO_ERROR = 9,
+    NO_MEM = 10,
+    ACCESS_DENIED = 11
+}
+export declare enum SANEValueType {
+    BOOL = 0,
+    INT = 1,
+    FIXED = 2,
+    STRING = 3,
+    BUTTON = 4,
+    GROUP = 5
+}
+export declare enum SANEUnit {
+    NONE = 0,
+    PIXEL = 1,
+    BIT = 2,
+    MM = 3,
+    DPI = 4,
+    PERCENT = 5,
+    MICROSECOND = 6
+}
+export declare enum SANEConstraintType {
+    NONE = 0,
+    RANGE = 1,
+    WORD_LIST = 2,
+    STRING_LIST = 3
+}
+export declare enum SANEFrame {
+    GRAY = 0,
+    RGB = 1,
+    RED = 2,
+    GREEN = 3,
+    BLUE = 4
+}
+export type SANEState = {
+    initialized: boolean;
+    version_code: number;
+    version: {
+        major: number;
+        minor: number;
+        build: number;
+    };
+    open: boolean;
+};
+export type SANEDevice = {
+    name: string;
+    vendor: string;
+    model: string;
+    type: string;
+};
+export type SANEOptionDescriptor = {
+    name: string;
+    title: string;
+    desc: string;
+    type: SANEValueType;
+    unit: SANEUnit;
+    size: number;
+    cap: {
+        SOFT_SELECT: boolean;
+        HARD_SELECT: boolean;
+        SOFT_DETECT: boolean;
+        EMULATED: boolean;
+        AUTOMATIC: boolean;
+        INACTIVE: boolean;
+        ADVANCED: boolean;
+    };
+} & ({
+    constraint_type: SANEConstraintType.NONE;
+    constraint: null;
+} | {
+    constraint_type: SANEConstraintType.RANGE;
+    constraint: {
+        min: number;
+        max: number;
+        quant: number;
+    };
+} | {
+    constraint_type: SANEConstraintType.WORD_LIST;
+    constraint: number[];
+} | {
+    constraint_type: SANEConstraintType.STRING_LIST;
+    constraint: string[];
+});
+export type SANEInfo = {
+    INEXACT: boolean;
+    RELOAD_OPTIONS: boolean;
+    RELOAD_PARAMS: boolean;
+};
+export type SANEParameters = {
+    format: SANEFrame;
+    last_frame: boolean;
+    bytes_per_line: number;
+    pixels_per_line: number;
+    lines: number;
+    depth: number;
+};
+type SANEEnum<E, TE> = E & {
+    /**
+     * @deprecated Use reverse map already built into TS enums.
+     */
+    asString: (value: TE) => string;
+};
+export interface LibSANE {
+    SANE_WASM_COMMIT: string;
+    SANE_WASM_VERSION: string;
+    SANE_WASM_BACKENDS: string;
+    SANE_CURRENT_MAJOR: number;
+    SANE_CURRENT_MINOR: number;
+    SANE_STATUS: SANEEnum<typeof SANEStatus, SANEStatus>;
+    SANE_TYPE: SANEEnum<typeof SANEValueType, SANEValueType>;
+    SANE_UNIT: SANEEnum<typeof SANEUnit, SANEUnit>;
+    SANE_CONSTRAINT: SANEEnum<typeof SANEConstraintType, SANEConstraintType>;
+    SANE_FRAME: SANEEnum<typeof SANEFrame, SANEFrame>;
+    sane_get_state: () => SANEState;
+    sane_init: () => {
+        status: SANEStatus;
+        version_code: number;
+    };
+    sane_exit: () => Promise<{
+        status: SANEStatus;
+    }>;
+    sane_get_devices: () => Promise<{
+        status: SANEStatus;
+        devices: SANEDevice[];
+    }>;
+    sane_open: (devicename: string) => Promise<{
+        status: SANEStatus;
+    }>;
+    sane_close: () => Promise<{
+        status: SANEStatus;
+    }>;
+    sane_get_option_descriptor: (option: number) => {
+        status: SANEStatus;
+        option_descriptor: SANEOptionDescriptor | null;
+    };
+    sane_control_option_get_value: (option: number) => Promise<{
+        status: SANEStatus;
+        value: any;
+    }>;
+    sane_control_option_set_value: (option: number, value: any) => Promise<{
+        status: SANEStatus;
+        info: SANEInfo;
+    }>;
+    sane_control_option_set_auto: (option: number) => Promise<{
+        status: SANEStatus;
+        info: SANEInfo;
+    }>;
+    sane_get_parameters: () => {
+        status: SANEStatus;
+        parameters: SANEParameters;
+    };
+    sane_start: () => {
+        status: SANEStatus;
+    };
+    sane_read: () => Promise<{
+        status: SANEStatus;
+        data: Uint8Array;
+    }>;
+    sane_cancel: () => Promise<{
+        status: SANEStatus;
+    }>;
+    sane_strstatus: (status: SANEStatus) => string;
+}
+export type LibSANEFactory = (option?: {
+    sane?: {
+        loaderURL: string;
+        loaderPrefetchToBlob: boolean;
+        loaderRemoveGlobal: boolean;
+        debugSANE?: boolean;
+        debugUSB?: boolean;
+        debugFunctionCalls?: boolean;
+        debugTestDevices?: number;
+        promisify?: boolean;
+        promisifyQueue?: boolean;
+    };
+} & {
+    [k: string]: any;
+}) => Promise<LibSANE>;
+/**
+ * Main LibSANE factory.
+ */
+export declare const libsane: LibSANEFactory;
+/**
+ * @deprecated The default export may be removed in the future.
+ * Use the 'libsane' named export.
+ */
+export default libsane;

package/dist/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.libsane = exports.SANEFrame = exports.SANEConstraintType = exports.SANEUnit = exports.SANEValueType = exports.SANEStatus = void 0;
+var SANEStatus;
+(function (SANEStatus) {
+    SANEStatus[SANEStatus["GOOD"] = 0] = "GOOD";
+    SANEStatus[SANEStatus["UNSUPPORTED"] = 1] = "UNSUPPORTED";
+    SANEStatus[SANEStatus["CANCELLED"] = 2] = "CANCELLED";
+    SANEStatus[SANEStatus["DEVICE_BUSY"] = 3] = "DEVICE_BUSY";
+    SANEStatus[SANEStatus["INVAL"] = 4] = "INVAL";
+    SANEStatus[SANEStatus["EOF"] = 5] = "EOF";
+    SANEStatus[SANEStatus["JAMMED"] = 6] = "JAMMED";
+    SANEStatus[SANEStatus["NO_DOCS"] = 7] = "NO_DOCS";
+    SANEStatus[SANEStatus["COVER_OPEN"] = 8] = "COVER_OPEN";
+    SANEStatus[SANEStatus["IO_ERROR"] = 9] = "IO_ERROR";
+    SANEStatus[SANEStatus["NO_MEM"] = 10] = "NO_MEM";
+    SANEStatus[SANEStatus["ACCESS_DENIED"] = 11] = "ACCESS_DENIED";
+})(SANEStatus || (exports.SANEStatus = SANEStatus = {}));
+var SANEValueType;
+(function (SANEValueType) {
+    SANEValueType[SANEValueType["BOOL"] = 0] = "BOOL";
+    SANEValueType[SANEValueType["INT"] = 1] = "INT";
+    SANEValueType[SANEValueType["FIXED"] = 2] = "FIXED";
+    SANEValueType[SANEValueType["STRING"] = 3] = "STRING";
+    SANEValueType[SANEValueType["BUTTON"] = 4] = "BUTTON";
+    SANEValueType[SANEValueType["GROUP"] = 5] = "GROUP";
+})(SANEValueType || (exports.SANEValueType = SANEValueType = {}));
+var SANEUnit;
+(function (SANEUnit) {
+    SANEUnit[SANEUnit["NONE"] = 0] = "NONE";
+    SANEUnit[SANEUnit["PIXEL"] = 1] = "PIXEL";
+    SANEUnit[SANEUnit["BIT"] = 2] = "BIT";
+    SANEUnit[SANEUnit["MM"] = 3] = "MM";
+    SANEUnit[SANEUnit["DPI"] = 4] = "DPI";
+    SANEUnit[SANEUnit["PERCENT"] = 5] = "PERCENT";
+    SANEUnit[SANEUnit["MICROSECOND"] = 6] = "MICROSECOND";
+})(SANEUnit || (exports.SANEUnit = SANEUnit = {}));
+var SANEConstraintType;
+(function (SANEConstraintType) {
+    SANEConstraintType[SANEConstraintType["NONE"] = 0] = "NONE";
+    SANEConstraintType[SANEConstraintType["RANGE"] = 1] = "RANGE";
+    SANEConstraintType[SANEConstraintType["WORD_LIST"] = 2] = "WORD_LIST";
+    SANEConstraintType[SANEConstraintType["STRING_LIST"] = 3] = "STRING_LIST";
+})(SANEConstraintType || (exports.SANEConstraintType = SANEConstraintType = {}));
+var SANEFrame;
+(function (SANEFrame) {
+    SANEFrame[SANEFrame["GRAY"] = 0] = "GRAY";
+    SANEFrame[SANEFrame["RGB"] = 1] = "RGB";
+    SANEFrame[SANEFrame["RED"] = 2] = "RED";
+    SANEFrame[SANEFrame["GREEN"] = 3] = "GREEN";
+    SANEFrame[SANEFrame["BLUE"] = 4] = "BLUE";
+})(SANEFrame || (exports.SANEFrame = SANEFrame = {}));
+/**
+ * Main LibSANE factory.
+ */
+exports.libsane = require('../lib');
+/**
+ * @deprecated The default export may be removed in the future.
+ * Use the 'libsane' named export.
+ */
+exports.default = exports.libsane;

package/lib/index.js

@@ -0,0 +1,7 @@
+if (globalThis.window && globalThis.window.document) {
+    // browser environment (e.g. webpack)
+    module.exports = require('./loader.js');
+} else {
+    // local environment (e.g. node)
+    module.exports = eval('require')('../build/libsane.js');
+}

package/lib/loader.js

@@ -0,0 +1,80 @@
+const { version } = require('../package.json');
+
+// we cannot use unpkg as a CDN because they don't set CORP
+// Cross-Origin-Resource-Policy: cross-origin
+// const cdnURL = `https://unpkg.com/sane-wasm@${version}/build`;
+
+// use good old jsdelivr
+const cdnURL = `https://cdn.jsdelivr.net/npm/sane-wasm@${version}/build`;
+
+let libPromise = null;
+
+function loadScript(src) {
+    return new Promise((resolve, reject) => {
+        document.head.append(Object.assign(
+            document.createElement('script'),
+            { src, onload: resolve, onerror: reject }
+        ));
+    });
+}
+
+function fetchFileToBlobURL(src) {
+    return fetch(src).then(res => res.ok ? res.blob() : new Blob()).then(blob => URL.createObjectURL(blob));
+}
+
+async function prepareLib(options) {
+    const jsURL = `${options.sane.loaderURL}/libsane.js`;
+    const jsWorkerURL = `${options.sane.loaderURL}/libsane.worker.js`;
+    const jsWasmURL = `${options.sane.loaderURL}/libsane.wasm`;
+
+    const filesToPrefetch = options.sane.loaderPrefetchToBlob ? [
+        // because of security restrictions around the Worker constructor
+        // we need to prefetch the worker js and serve it from a blob
+        // see: https://github.com/emscripten-core/emscripten/issues/8338
+        jsWorkerURL,
+        // since we are already doing all this work to fetch the files in
+        // parallel, might as well prefetch the wasm file
+        jsWasmURL,
+    ] : [];
+
+    const [lib, prefetchResult] = await Promise.all([
+        loadScript(jsURL).then(() => {
+            const lib = window.LibSANE;
+            if (options.sane.loaderRemoveGlobal) {
+                window.LibSANE = undefined; // nuke global variable
+            }
+            return lib;
+        }),
+        Promise.all(filesToPrefetch.map(url => fetchFileToBlobURL(url).then(urlBlob => ({ url, urlBlob })))),
+    ]);
+
+    const preFetchedFiles = prefetchResult.reduce((obj, { url, urlBlob }) => {
+        obj[url] = urlBlob;
+        return obj;
+    }, {});
+
+    return { lib, preFetchedFiles };
+}
+
+module.exports = async (options) => {
+    options = options || {};
+    options.sane = {
+        loaderURL: cdnURL,
+        loaderPrefetchToBlob: true,
+        loaderRemoveGlobal: true,
+        ...(options.sane || {}),
+    };
+
+    if (!libPromise) {
+        libPromise = prepareLib(options);
+    }
+
+    const { lib, preFetchedFiles } = await libPromise;
+    return lib({
+        ...(options || {}),
+        locateFile: (path, prefix) => {
+            const fullUrl = `${prefix}${path}`;
+            return preFetchedFiles[fullUrl] ? preFetchedFiles[fullUrl] : (options.locateFile ? options.locateFile(path, prefix) : fullUrl);
+        },
+    });
+};

package/package.json

@@ -1,15 +1,23 @@
 {
   "name": "sane-wasm",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A project to bring the SANE API to the web.",
-  "main": "build/libsane.js",
-  "types": "libsane.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "clean": "./build.sh --with-docker --no-build --clean",
-    "build": "./build.sh --with-docker --clean",
-    "build-debug": "./build.sh --with-docker --debug --emrun"
+    "test": "jest",
+    "clean": "npm run clean:tsc && npm run clean:sane",
+    "clean:tsc": "rm -rf dist/",
+    "clean:sane": "./build.sh --no-build --clean",
+    "prebuild": "rm -rf dist/ build/",
+    "build": "npm run build:tsc && npm run build:sane",
+    "build:tsc": "tsc",
+    "build:sane": "./build.sh --with-docker --clean",
+    "debug:sane": "./build.sh --with-docker --debug --emrun"
   },
   "files": [
+    "dist/",
+    "lib/",
     "build/",
     "libsane.d.ts",
     "LICENSE-LGPL.txt",
@@ -25,7 +33,22 @@
     "url": "https://github.com/goncalomb/sane-wasm/issues"
   },
   "homepage": "https://github.com/goncalomb/sane-wasm#readme",
-  "dependencies": {
+  "jest": {
+    "setupFilesAfterEnv": [
+      "jest-extended/all"
+    ]
+  },
+  "peerDependencies": {
     "usb": "^2.10.0"
+  },
+  "peerDependenciesMeta": {
+    "usb": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "jest": "^29.6.4",
+    "jest-extended": "^4.0.1",
+    "typescript": "^5.2.2"
   }
 }

package/libsane.d.ts

@@ -1,163 +0,0 @@
-export enum SANEStatus {
-    GOOD = 0,
-    UNSUPPORTED,
-    CANCELLED,
-    DEVICE_BUSY,
-    INVAL,
-    EOF,
-    JAMMED,
-    NO_DOCS,
-    COVER_OPEN,
-    IO_ERROR,
-    NO_MEM,
-    ACCESS_DENIED,
-}
-
-export enum SANEValueType {
-    BOOL = 0,
-    INT,
-    FIXED,
-    STRING,
-    BUTTON,
-    GROUP,
-}
-
-export enum SANEUnit {
-    NONE = 0,
-    PIXEL,
-    BIT,
-    MM,
-    DPI,
-    PERCENT,
-    MICROSECOND,
-}
-
-export enum SANEConstraintType {
-    NONE = 0,
-    RANGE,
-    WORD_LIST,
-    STRING_LIST,
-}
-
-export enum SANEFrame {
-    GRAY = 0,
-    RGB,
-    RED,
-    GREEN,
-    BLUE,
-}
-
-export type SANEState = {
-    initialized: boolean;
-    version_code: number;
-    version: {
-        major: number;
-        minor: number;
-        build: number;
-    },
-    open: boolean;
-}
-
-export type SANEDevice = {
-    name: string;
-    vendor: string;
-    model: string;
-    type: string;
-}
-
-export type SANEOptionDescriptor = {
-    name: string;
-    title: string;
-    desc: string;
-    type: SANEValueType;
-    unit: SANEUnit;
-    size: number;
-    cap: {
-        SOFT_SELECT: boolean;
-        HARD_SELECT: boolean;
-        SOFT_DETECT: boolean;
-        EMULATED: boolean;
-        AUTOMATIC: boolean;
-        INACTIVE: boolean;
-        ADVANCED: boolean;
-    };
-} & ({
-    constraint_type: SANEConstraintType.NONE
-    constraint: null
-} | {
-    constraint_type: SANEConstraintType.RANGE
-    constraint: {
-        min: number;
-        max: number;
-        quant: number;
-    }
-} | {
-    constraint_type: SANEConstraintType.WORD_LIST
-    constraint: number[]
-} | {
-    constraint_type: SANEConstraintType.STRING_LIST
-    constraint: string[]
-})
-
-export type SANEInfo = {
-    INEXACT: boolean;
-    RELOAD_OPTIONS: boolean;
-    RELOAD_PARAMS: boolean;
-}
-
-export type SANEParameters = {
-    format: SANEFrame;
-    last_frame: boolean;
-    bytes_per_line: number;
-    pixels_per_line: number;
-    lines: number;
-    depth: number;
-}
-
-type SANEEnum<E, TE> = E & {
-    asString: (value: TE) => string;
-}
-
-export interface LibSANE {
-    SANE_WASM_COMMIT: string;
-    SANE_WASM_VERSION: string;
-    SANE_WASM_BACKENDS: string;
-
-    SANE_CURRENT_MAJOR: number;
-    SANE_CURRENT_MINOR: number;
-
-    SANE_STATUS: SANEEnum<typeof SANEStatus, SANEStatus>;
-    SANE_TYPE: SANEEnum<typeof SANEValueType, SANEValueType>;
-    SANE_UNIT: SANEEnum<typeof SANEUnit, SANEUnit>;
-    SANE_CONSTRAINT: SANEEnum<typeof SANEConstraintType, SANEConstraintType>;
-    SANE_FRAME: SANEEnum<typeof SANEFrame, SANEFrame>;
-
-    sane_get_state: () => SANEState;
-    sane_init: () => { status: SANEStatus; version_code: number };
-    sane_exit: () => Promise<{ status: SANEStatus; }>;
-    sane_get_devices: () => Promise<{ status: SANEStatus; devices: SANEDevice[] }>;
-    sane_open: (devicename: string) => Promise<{ status: SANEStatus; }>;
-    sane_close: () => Promise<{ status: SANEStatus; }>;
-    sane_get_option_descriptor: (option: number) => { status: SANEStatus; option_descriptor: SANEOptionDescriptor | null };
-    sane_control_option_get_value: (option: number) => Promise<{ status: SANEStatus; value: any }>;
-    sane_control_option_set_value: (option: number, value: any) => Promise<{ status: SANEStatus; info: SANEInfo }>;
-    sane_control_option_set_auto: (option: number) => Promise<{ status: SANEStatus; info: SANEInfo }>;
-    sane_get_parameters: () => { status: SANEStatus; parameters: SANEParameters };
-    sane_start: () => { status: SANEStatus; };
-    sane_read: () => Promise<{ status: SANEStatus; data: Uint8Array }>;
-    sane_cancel: () => Promise<{ status: SANEStatus; }>;
-    sane_strstatus: (status: SANEStatus) => string;
-}
-
-export type LibSANEFactory = (option?: {
-    sane?: {
-        debugSANE?: boolean;
-        debugUSB?: boolean;
-        debugFunctionCalls?: boolean;
-        debugTestDevices?: number;
-        promisify?: boolean;
-        promisifyQueue?: boolean;
-    }
-} & {
-    [k: string]: any
-}) => Promise<LibSANE>