nbis-wrapper-js 0.0.1 → 0.2.0

package/dist/src/intr2not.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Intr2not = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function buildRawAttr(raw) {
     const attrs = [raw.width, raw.height, raw.depth];
     if (raw.ppi != null) {
@@ -44,5 +45,26 @@ class Intr2not {
             stderr: result.stderr
         };
     }
+    async convertStream(outputExtension, input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [outputExtension, inputPath];
+            if (options.rawIn) {
+                args.push('-raw_in', buildRawAttr(options.rawIn));
+            }
+            if (options.yCbCr) {
+                args.push('-YCbCr', buildYCbCr(options.yCbCr));
+            }
+            const result = (0, nbis_runtime_1.runNbis)('intr2not', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'intr2not');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Intr2not = Intr2not;

package/dist/src/jpegtran.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type JpegtranOptions = {
     optimize?: boolean;
     progressive?: boolean;
@@ -18,7 +19,14 @@ export type JpegtranResult = {
     stderr: string;
     outputPath?: string;
 };
+export type JpegtranStreamOptions = Omit<JpegtranOptions, 'outputPath'> & StreamIoOptions;
+export type JpegtranStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Jpegtran {
     version(): string;
     transform(inputPath: string, options?: JpegtranOptions): JpegtranResult;
+    transformStream(input: StreamInput, options?: JpegtranStreamOptions): Promise<JpegtranStreamResult>;
 }

package/dist/src/jpegtran.js

@@ -1,7 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Jpegtran = void 0;
+const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Jpegtran {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('jpegtran', ['-version']);
@@ -84,5 +89,82 @@ class Jpegtran {
             outputPath: options.outputPath
         };
     }
+    async transformStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const outputPath = path_1.default.join(tempDir, 'output.jpg');
+            const args = [];
+            if (options.optimize) {
+                args.push('-optimize');
+            }
+            if (options.progressive) {
+                args.push('-progressive');
+            }
+            if (options.restart != null) {
+                args.push('-restart', String(options.restart));
+            }
+            if (options.scansFile) {
+                args.push('-scans', options.scansFile);
+            }
+            if (options.transform) {
+                switch (options.transform) {
+                    case 'flip-horizontal':
+                        args.push('-flip', 'horizontal');
+                        break;
+                    case 'flip-vertical':
+                        args.push('-flip', 'vertical');
+                        break;
+                    case 'rotate-90':
+                        args.push('-rotate', '90');
+                        break;
+                    case 'rotate-180':
+                        args.push('-rotate', '180');
+                        break;
+                    case 'rotate-270':
+                        args.push('-rotate', '270');
+                        break;
+                    case 'transpose':
+                        args.push('-transpose');
+                        break;
+                    case 'transverse':
+                        args.push('-transverse');
+                        break;
+                    default:
+                        break;
+                }
+            }
+            if (options.trim) {
+                args.push('-trim');
+            }
+            if (options.grayscale) {
+                args.push('-grayscale');
+            }
+            if (options.copy) {
+                args.push('-copy', options.copy);
+            }
+            if (options.maxMemory) {
+                args.push('-maxmemory', options.maxMemory);
+            }
+            args.push('-outfile', outputPath);
+            if (options.verbose) {
+                args.push('-verbose');
+            }
+            if (options.debug) {
+                args.push('-debug');
+            }
+            if (options.extraArgs) {
+                args.push(...options.extraArgs);
+            }
+            args.push(inputPath);
+            const result = (0, nbis_runtime_1.runNbis)('jpegtran', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'jpegtran');
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Jpegtran = Jpegtran;

package/dist/src/mindtct.d.ts

@@ -1,3 +1,5 @@
+import type { AutoConvertConfig } from './image-convert';
+import type { StreamInput, StreamInputOptions, StreamOutput } from './temp-io';
 export type MindtctDetectOptions = {
     enhanceLowContrast?: boolean;
     useM1?: boolean;
@@ -18,7 +20,23 @@ export type MindtctDetectResult = {
     stdout: string;
     stderr: string;
 };
+export type MindtctConstructorOptions = {
+    autoConvert?: boolean | AutoConvertConfig;
+};
+export type MindtctStreamOutputs = Partial<Record<keyof MindtctDetectResult['outputs'], StreamOutput>>;
+export type MindtctStreamOptions = MindtctDetectOptions & StreamInputOptions & {
+    outputs?: MindtctStreamOutputs;
+    outputToBuffer?: boolean;
+};
+export type MindtctStreamResult = {
+    outputBuffers?: Partial<Record<keyof MindtctDetectResult['outputs'], Buffer>>;
+    stdout: string;
+    stderr: string;
+};
 export declare class Mindtct {
+    private autoConvert;
+    constructor(options?: MindtctConstructorOptions);
     version(): string;
     detect(fingerImagePath: string, outputRoot: string, options?: MindtctDetectOptions): MindtctDetectResult;
+    detectStream(input: StreamInput, options?: MindtctStreamOptions): Promise<MindtctStreamResult>;
 }

package/dist/src/mindtct.js

@@ -6,40 +6,95 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mindtct = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const image_convert_1 = require("./image-convert");
+const temp_io_1 = require("./temp-io");
 class Mindtct {
+    constructor(options = {}) {
+        this.autoConvert = (0, image_convert_1.normalizeAutoConvertConfig)(options.autoConvert);
+    }
     version() {
         const result = (0, nbis_runtime_1.runNbis)('mindtct', ['-version']);
         (0, nbis_runtime_1.assertSuccess)(result, 'mindtct -version');
         return result.stdout + result.stderr;
     }
     detect(fingerImagePath, outputRoot, options = {}) {
-        const args = [];
-        if (options.enhanceLowContrast) {
-            args.push('-b');
+        const prepared = (0, image_convert_1.prepareFingerprintImageSync)(fingerImagePath, this.autoConvert);
+        try {
+            const args = [];
+            if (options.enhanceLowContrast) {
+                args.push('-b');
+            }
+            if (options.useM1) {
+                args.push('-m1');
+            }
+            args.push(prepared.path, outputRoot);
+            const result = (0, nbis_runtime_1.runNbis)('mindtct', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'mindtct');
+            const outputs = {
+                mdt: `${outputRoot}.mdt`,
+                xyt: `${outputRoot}.xyt`,
+                brw: `${outputRoot}.brw`,
+                dm: `${outputRoot}.dm`,
+                hcm: `${outputRoot}.hcm`,
+                lcm: `${outputRoot}.lcm`,
+                lfm: `${outputRoot}.lfm`,
+                qm: `${outputRoot}.qm`,
+                min: `${outputRoot}.min`
+            };
+            return {
+                outputs,
+                outputRoot: path_1.default.resolve(outputRoot),
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
         }
-        if (options.useM1) {
-            args.push('-m1');
+        finally {
+            prepared.cleanup?.();
         }
-        args.push(fingerImagePath, outputRoot);
-        const result = (0, nbis_runtime_1.runNbis)('mindtct', args);
-        (0, nbis_runtime_1.assertSuccess)(result, 'mindtct');
-        const outputs = {
-            mdt: `${outputRoot}.mdt`,
-            xyt: `${outputRoot}.xyt`,
-            brw: `${outputRoot}.brw`,
-            dm: `${outputRoot}.dm`,
-            hcm: `${outputRoot}.hcm`,
-            lcm: `${outputRoot}.lcm`,
-            lfm: `${outputRoot}.lfm`,
-            qm: `${outputRoot}.qm`,
-            min: `${outputRoot}.min`
-        };
-        return {
-            outputs,
-            outputRoot: path_1.default.resolve(outputRoot),
-            stdout: result.stdout,
-            stderr: result.stderr
-        };
+    }
+    async detectStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const fingerImagePath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const prepared = (0, image_convert_1.prepareFingerprintImageSync)(fingerImagePath, this.autoConvert, tempDir);
+            const outputRoot = path_1.default.join(tempDir, 'output');
+            const outputToBuffer = options.outputToBuffer ?? false;
+            const args = [];
+            if (options.enhanceLowContrast) {
+                args.push('-b');
+            }
+            if (options.useM1) {
+                args.push('-m1');
+            }
+            args.push(prepared.path, outputRoot);
+            const result = (0, nbis_runtime_1.runNbis)('mindtct', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'mindtct');
+            const outputs = {
+                mdt: `${outputRoot}.mdt`,
+                xyt: `${outputRoot}.xyt`,
+                brw: `${outputRoot}.brw`,
+                dm: `${outputRoot}.dm`,
+                hcm: `${outputRoot}.hcm`,
+                lcm: `${outputRoot}.lcm`,
+                lfm: `${outputRoot}.lfm`,
+                qm: `${outputRoot}.qm`,
+                min: `${outputRoot}.min`
+            };
+            const outputBuffers = {};
+            for (const key of Object.keys(outputs)) {
+                const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputs[key], {
+                    output: options.outputs?.[key],
+                    outputToBuffer
+                });
+                if (outputBuffer) {
+                    outputBuffers[key] = outputBuffer;
+                }
+            }
+            return {
+                outputBuffers: Object.keys(outputBuffers).length ? outputBuffers : undefined,
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
+        });
     }
 }
 exports.Mindtct = Mindtct;

package/dist/src/nfiq.d.ts

@@ -1,3 +1,5 @@
+import type { AutoConvertConfig } from './image-convert';
+import type { StreamInput, StreamInputOptions, StreamOutputOptions } from './temp-io';
 export type NfiqRecordSelectors = {
     fingerPosition?: string[];
     impressionType?: string[];
@@ -30,7 +32,19 @@ export type NfiqResult = {
     stdout: string;
     stderr: string;
 };
+export type NfiqConstructorOptions = {
+    autoConvert?: boolean | AutoConvertConfig;
+};
+export type NfiqStreamOptions = Omit<NfiqOptions, 'ansiNistOutputPath'> & StreamInputOptions & {
+    ansiNistOutput?: StreamOutputOptions;
+};
+export type NfiqStreamResult = NfiqResult & {
+    ansiNistBuffer?: Buffer;
+};
 export declare class Nfiq {
+    private autoConvert;
+    constructor(options?: NfiqConstructorOptions);
     version(): string;
     score(imagePath: string, options?: NfiqOptions): NfiqResult;
+    scoreStream(input: StreamInput, options?: NfiqStreamOptions): Promise<NfiqStreamResult>;
 }

package/dist/src/nfiq.js

@@ -1,7 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Nfiq = void 0;
+const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const image_convert_1 = require("./image-convert");
+const temp_io_1 = require("./temp-io");
 function buildRawAttr(raw) {
     const attrs = [raw.width, raw.height, raw.depth];
     if (raw.ppi != null) {
@@ -59,35 +65,79 @@ function parseScores(output) {
     });
 }
 class Nfiq {
+    constructor(options = {}) {
+        this.autoConvert = (0, image_convert_1.normalizeAutoConvertConfig)(options.autoConvert);
+    }
     version() {
         const result = (0, nbis_runtime_1.runNbis)('nfiq', ['-version']);
         (0, nbis_runtime_1.assertSuccess)(result, 'nfiq -version');
         return result.stdout + result.stderr;
     }
     score(imagePath, options = {}) {
-        const args = [];
-        if (options.mode === 'verbose') {
-            args.push('-v');
-        }
-        if (options.oldBehavior) {
-            args.push('-o');
-        }
-        if (options.raw) {
-            args.push('-raw', buildRawAttr(options.raw));
+        const prepared = (0, image_convert_1.prepareFingerprintImageSync)(imagePath, this.autoConvert);
+        try {
+            const args = [];
+            if (options.mode === 'verbose') {
+                args.push('-v');
+            }
+            if (options.oldBehavior) {
+                args.push('-o');
+            }
+            if (options.raw) {
+                args.push('-raw', buildRawAttr(options.raw));
+            }
+            addSelectors(args, options.selectors);
+            args.push(prepared.path);
+            if (options.ansiNistOutputPath) {
+                args.push(options.ansiNistOutputPath);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('nfiq', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'nfiq');
+            const output = result.stdout + result.stderr;
+            return {
+                scores: options.mode === 'verbose' ? [] : parseScores(output),
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
         }
-        addSelectors(args, options.selectors);
-        args.push(imagePath);
-        if (options.ansiNistOutputPath) {
-            args.push(options.ansiNistOutputPath);
+        finally {
+            prepared.cleanup?.();
         }
-        const result = (0, nbis_runtime_1.runNbis)('nfiq', args);
-        (0, nbis_runtime_1.assertSuccess)(result, 'nfiq');
-        const output = result.stdout + result.stderr;
-        return {
-            scores: options.mode === 'verbose' ? [] : parseScores(output),
-            stdout: result.stdout,
-            stderr: result.stderr
-        };
+    }
+    async scoreStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const imagePath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const prepared = (0, image_convert_1.prepareFingerprintImageSync)(imagePath, this.autoConvert, tempDir);
+            const args = [];
+            if (options.mode === 'verbose') {
+                args.push('-v');
+            }
+            if (options.oldBehavior) {
+                args.push('-o');
+            }
+            if (options.raw) {
+                args.push('-raw', buildRawAttr(options.raw));
+            }
+            addSelectors(args, options.selectors);
+            args.push(prepared.path);
+            let ansiNistPath;
+            if (options.ansiNistOutput) {
+                ansiNistPath = path_1.default.join(tempDir, 'output.an2k');
+                args.push(ansiNistPath);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('nfiq', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'nfiq');
+            const output = result.stdout + result.stderr;
+            const ansiNistBuffer = ansiNistPath
+                ? await (0, temp_io_1.deliverTempOutput)(ansiNistPath, options.ansiNistOutput)
+                : undefined;
+            return {
+                scores: options.mode === 'verbose' ? [] : parseScores(output),
+                stdout: result.stdout,
+                stderr: result.stderr,
+                ansiNistBuffer
+            };
+        });
     }
 }
 exports.Nfiq = Nfiq;

package/dist/src/not2intr.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type Not2intrOptions = {
     rawOut?: boolean;
     yCbCr?: {
@@ -11,6 +12,12 @@ export type Not2intrResult = {
     stdout: string;
     stderr: string;
 };
+export type Not2intrStreamOptions = Not2intrOptions & StreamIoOptions;
+export type Not2intrStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Not2intr {
     version(): string;
     convert(outputExtension: string, imagePath: string, rawIn: {
@@ -19,4 +26,10 @@ export declare class Not2intr {
         depth: number;
         ppi?: number;
     }, options?: Not2intrOptions): Not2intrResult;
+    convertStream(outputExtension: string, input: StreamInput, rawIn: {
+        width: number;
+        height: number;
+        depth: number;
+        ppi?: number;
+    }, options?: Not2intrStreamOptions): Promise<Not2intrStreamResult>;
 }

package/dist/src/not2intr.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Not2intr = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function buildRawAttr(raw) {
     const attrs = [raw.width, raw.height, raw.depth];
     if (raw.ppi != null) {
@@ -44,5 +45,26 @@ class Not2intr {
             stderr: result.stderr
         };
     }
+    async convertStream(outputExtension, input, rawIn, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [outputExtension, inputPath, buildRawAttr(rawIn)];
+            if (options.rawOut) {
+                args.push('-raw_out');
+            }
+            if (options.yCbCr) {
+                args.push('-YCbCr', buildYCbCr(options.yCbCr));
+            }
+            const result = (0, nbis_runtime_1.runNbis)('not2intr', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'not2intr');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Not2intr = Not2intr;

package/dist/src/rdjpgcom.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamInputOptions } from './temp-io';
 export type RdjpgcomOptions = {
     verbose?: boolean;
 };
@@ -5,7 +6,9 @@ export type RdjpgcomResult = {
     stdout: string;
     stderr: string;
 };
+export type RdjpgcomStreamOptions = RdjpgcomOptions & StreamInputOptions;
 export declare class Rdjpgcom {
     version(): string;
     read(imagePath: string, options?: RdjpgcomOptions): RdjpgcomResult;
+    readStream(input: StreamInput, options?: RdjpgcomStreamOptions): Promise<RdjpgcomResult>;
 }

package/dist/src/rdjpgcom.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Rdjpgcom = void 0;
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Rdjpgcom {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('rdjpgcom', ['-version']);
@@ -23,5 +24,21 @@ class Rdjpgcom {
             stderr: result.stderr
         };
     }
+    async readStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const imagePath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [];
+            if (options.verbose) {
+                args.push('-verbose');
+            }
+            args.push(imagePath);
+            const result = (0, nbis_runtime_1.runNbis)('rdjpgcom', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'rdjpgcom');
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
+        });
+    }
 }
 exports.Rdjpgcom = Rdjpgcom;

package/dist/src/rdwsqcom.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamInputOptions } from './temp-io';
 export type RdwsqcomResult = {
     stdout: string;
     stderr: string;
@@ -5,4 +6,5 @@ export type RdwsqcomResult = {
 export declare class Rdwsqcom {
     version(): string;
     read(imagePath: string): RdwsqcomResult;
+    readStream(input: StreamInput, options?: StreamInputOptions): Promise<RdwsqcomResult>;
 }

package/dist/src/rdwsqcom.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Rdwsqcom = void 0;
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Rdwsqcom {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('rdwsqcom', ['-version']);
@@ -16,5 +17,16 @@ class Rdwsqcom {
             stderr: result.stderr
         };
     }
+    async readStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const imagePath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const result = (0, nbis_runtime_1.runNbis)('rdwsqcom', [imagePath]);
+            (0, nbis_runtime_1.assertSuccess)(result, 'rdwsqcom');
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
+        });
+    }
 }
 exports.Rdwsqcom = Rdwsqcom;

package/dist/src/rgb2ycc.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type Rgb2yccOptions = {
     rawIn?: {
         width: number;
@@ -17,7 +18,14 @@ export type Rgb2yccResult = {
     stdout: string;
     stderr: string;
 };
+export type Rgb2yccStreamOptions = Rgb2yccOptions & StreamIoOptions;
+export type Rgb2yccStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Rgb2ycc {
     version(): string;
     convert(outputExtension: string, imagePath: string, options?: Rgb2yccOptions): Rgb2yccResult;
+    convertStream(outputExtension: string, input: StreamInput, options?: Rgb2yccStreamOptions): Promise<Rgb2yccStreamResult>;
 }

package/dist/src/rgb2ycc.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Rgb2ycc = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function buildRawAttr(raw) {
     const attrs = [raw.width, raw.height, raw.depth];
     if (raw.ppi != null) {
@@ -47,5 +48,29 @@ class Rgb2ycc {
             stderr: result.stderr
         };
     }
+    async convertStream(outputExtension, input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [outputExtension, inputPath];
+            if (options.rawIn) {
+                args.push('-raw_in', buildRawAttr(options.rawIn));
+            }
+            if (options.nonInterleaved) {
+                args.push('-nonintrlv');
+            }
+            if (options.yCbCr) {
+                args.push('-YCbCr', buildYCbCr(options.yCbCr));
+            }
+            const result = (0, nbis_runtime_1.runNbis)('rgb2ycc', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'rgb2ycc');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Rgb2ycc = Rgb2ycc;

package/dist/src/temp-io.d.ts

@@ -0,0 +1,15 @@
+export type StreamInput = Buffer | Uint8Array | NodeJS.ReadableStream;
+export type StreamOutput = NodeJS.WritableStream;
+export type StreamInputOptions = {
+    inputName?: string;
+    inputExtension?: string;
+};
+export type StreamOutputOptions = {
+    output?: StreamOutput;
+    outputToBuffer?: boolean;
+};
+export type StreamIoOptions = StreamInputOptions & StreamOutputOptions;
+export declare function withTempDir<T>(fn: (tempDir: string) => Promise<T>): Promise<T>;
+export declare function writeTempInput(tempDir: string, input: StreamInput, nameOrOptions?: string | StreamInputOptions): Promise<string>;
+export declare function deliverTempOutput(outputPath: string, options?: StreamOutputOptions): Promise<Buffer | undefined>;
+export declare function readFileIfExists(filePath: string): Promise<Buffer | undefined>;