nbis-wrapper-js 0.0.1 → 0.1.0

package/dist/src/cjpegl.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cjpegl = 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) {
@@ -50,5 +51,32 @@ class Cjpegl {
             stderr: result.stderr
         };
     }
+    async compressStream(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));
+            }
+            if (options.commentFile) {
+                args.push(options.commentFile);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('cjpegl', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'cjpegl');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Cjpegl = Cjpegl;

package/dist/src/cwsq.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type CwsqOptions = {
     rawIn?: {
         width: number;
@@ -12,7 +13,14 @@ export type CwsqResult = {
     stdout: string;
     stderr: string;
 };
+export type CwsqStreamOptions = CwsqOptions & StreamIoOptions;
+export type CwsqStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Cwsq {
     version(): string;
     compress(bitrate: number, outputExtension: string, imagePath: string, options?: CwsqOptions): CwsqResult;
+    compressStream(bitrate: number, outputExtension: string, input: StreamInput, options?: CwsqStreamOptions): Promise<CwsqStreamResult>;
 }

package/dist/src/cwsq.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cwsq = 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) {
@@ -40,5 +41,26 @@ class Cwsq {
             stderr: result.stderr
         };
     }
+    async compressStream(bitrate, outputExtension, input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const args = [String(bitrate), outputExtension, inputPath];
+            if (options.rawIn) {
+                args.push('-raw_in', buildRawAttr(options.rawIn));
+            }
+            if (options.commentFile) {
+                args.push(options.commentFile);
+            }
+            const result = (0, nbis_runtime_1.runNbis)('cwsq', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'cwsq');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Cwsq = Cwsq;

package/dist/src/datainfo.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamInputOptions } from './temp-io';
 export type DatainfoResult = {
     stdout: string;
     stderr: string;
@@ -5,4 +6,5 @@ export type DatainfoResult = {
 export declare class Datainfo {
     version(): string;
     report(dataFile: string): DatainfoResult;
+    reportStream(input: StreamInput, options?: StreamInputOptions): Promise<DatainfoResult>;
 }

package/dist/src/datainfo.js

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

package/dist/src/djp2k.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type Djp2kOptions = {
     inputPath?: string;
     outputPath?: string;
@@ -14,7 +15,16 @@ export type Djp2kResult = {
     stdout: string;
     stderr: string;
 };
+export type Djp2kStreamOptions = Omit<Djp2kOptions, 'inputPath' | 'outputPath' | 'imageDir'> & StreamIoOptions & {
+    outputExtension?: string;
+};
+export type Djp2kStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Djp2k {
     version(): string;
     decompress(options: Djp2kOptions): Djp2kResult;
+    decompressStream(input: StreamInput, options?: Djp2kStreamOptions): Promise<Djp2kStreamResult>;
 }

package/dist/src/djp2k.js

@@ -1,7 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Djp2k = void 0;
+const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
+function normalizeExtension(extension) {
+    if (!extension) {
+        return '';
+    }
+    return extension.startsWith('.') ? extension : `.${extension}`;
+}
 class Djp2k {
     version() {
         const result = (0, nbis_runtime_1.runNbis)('djp2k', ['-h']);
@@ -49,5 +60,46 @@ class Djp2k {
             stderr: result.stderr
         };
     }
+    async decompressStream(input, options = {}) {
+        return (0, temp_io_1.withTempDir)(async (tempDir) => {
+            const inputPath = await (0, temp_io_1.writeTempInput)(tempDir, input, options);
+            const outputExtension = options.outputExtension || options.outputFormat;
+            if (!outputExtension) {
+                throw new Error('djp2k stream output requires outputExtension or outputFormat.');
+            }
+            const outputPath = path_1.default.join(tempDir, `output${normalizeExtension(outputExtension)}`);
+            const args = [];
+            if (options.outputFormat) {
+                args.push('-OutFor', options.outputFormat);
+            }
+            if (options.reduceFactor != null) {
+                args.push('-r', String(options.reduceFactor));
+            }
+            if (options.layers != null) {
+                args.push('-l', String(options.layers));
+            }
+            if (options.indexFile) {
+                args.push('-x', options.indexFile);
+            }
+            if (options.decodeArea) {
+                args.push('-d', options.decodeArea);
+            }
+            if (options.tileNumber != null) {
+                args.push('-t', String(options.tileNumber));
+            }
+            if (options.extraArgs) {
+                args.push(...options.extraArgs);
+            }
+            args.push('-i', inputPath, '-o', outputPath);
+            const result = (0, nbis_runtime_1.runNbis)('djp2k', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'djp2k');
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Djp2k = Djp2k;

package/dist/src/djpeg.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type DjpegOptions = {
     colors?: number;
     fast?: boolean;
@@ -20,6 +21,13 @@ export type DjpegResult = {
     stderr: string;
     outputPath?: string;
 };
+export type DjpegStreamOptions = Omit<DjpegOptions, 'outputPath'> & StreamIoOptions;
+export type DjpegStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+};
 export declare class Djpeg {
     decompress(inputPath: string, options?: DjpegOptions): DjpegResult;
+    decompressStream(input: StreamInput, options?: DjpegStreamOptions): Promise<DjpegStreamResult>;
 }

package/dist/src/djpeg.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.Djpeg = void 0;
+const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 class Djpeg {
     decompress(inputPath, options = {}) {
         const args = [];
@@ -59,5 +64,64 @@ class Djpeg {
             outputPath: options.outputPath
         };
     }
+    async decompressStream(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');
+            const args = [];
+            if (options.colors != null) {
+                args.push('-colors', String(options.colors));
+            }
+            if (options.fast) {
+                args.push('-fast');
+            }
+            if (options.grayscale) {
+                args.push('-grayscale');
+            }
+            if (options.scale) {
+                args.push('-scale', options.scale);
+            }
+            if (options.format) {
+                args.push(`-${options.format}`);
+            }
+            if (options.dct) {
+                args.push('-dct', options.dct);
+            }
+            if (options.dither) {
+                args.push('-dither', options.dither);
+            }
+            if (options.mapFile) {
+                args.push('-map', options.mapFile);
+            }
+            if (options.noSmooth) {
+                args.push('-nosmooth');
+            }
+            if (options.onePass) {
+                args.push('-onepass');
+            }
+            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)('djpeg', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'djpeg');
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer
+            };
+        });
+    }
 }
 exports.Djpeg = Djpeg;

package/dist/src/djpegb.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type DjpegbOptions = {
     rawOut?: boolean;
     nonInterleaved?: boolean;
@@ -8,7 +9,15 @@ export type DjpegbResult = {
     stdout: string;
     stderr: string;
 };
+export type DjpegbStreamOptions = DjpegbOptions & StreamIoOptions;
+export type DjpegbStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+    nistcomBuffer?: Buffer;
+};
 export declare class Djpegb {
     version(): string;
     decompress(outputExtension: string, imagePath: string, options?: DjpegbOptions): DjpegbResult;
+    decompressStream(outputExtension: string, input: StreamInput, options?: DjpegbStreamOptions): Promise<DjpegbStreamResult>;
 }

package/dist/src/djpegb.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Djpegb = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function replaceExtension(inputPath, outputExtension) {
     const parsed = path_1.default.parse(inputPath);
     const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
@@ -35,5 +36,30 @@ class Djpegb {
             stderr: result.stderr
         };
     }
+    async decompressStream(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.rawOut) {
+                args.push('-raw_out');
+            }
+            if (options.nonInterleaved) {
+                args.push('-nonintrlv');
+            }
+            const result = (0, nbis_runtime_1.runNbis)('djpegb', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'djpegb');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const parsed = path_1.default.parse(inputPath);
+            const nistcomPath = path_1.default.join(parsed.dir, `${parsed.name}.ncm`);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            const nistcomBuffer = await (0, temp_io_1.readFileIfExists)(nistcomPath);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer,
+                nistcomBuffer
+            };
+        });
+    }
 }
 exports.Djpegb = Djpegb;

package/dist/src/djpegl.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type DjpeglOptions = {
     rawOut?: boolean;
     nonInterleaved?: boolean;
@@ -8,7 +9,15 @@ export type DjpeglResult = {
     stdout: string;
     stderr: string;
 };
+export type DjpeglStreamOptions = DjpeglOptions & StreamIoOptions;
+export type DjpeglStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+    nistcomBuffer?: Buffer;
+};
 export declare class Djpegl {
     version(): string;
     decompress(outputExtension: string, imagePath: string, options?: DjpeglOptions): DjpeglResult;
+    decompressStream(outputExtension: string, input: StreamInput, options?: DjpeglStreamOptions): Promise<DjpeglStreamResult>;
 }

package/dist/src/djpegl.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Djpegl = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function replaceExtension(inputPath, outputExtension) {
     const parsed = path_1.default.parse(inputPath);
     const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
@@ -35,5 +36,30 @@ class Djpegl {
             stderr: result.stderr
         };
     }
+    async decompressStream(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.rawOut) {
+                args.push('-raw_out');
+            }
+            if (options.nonInterleaved) {
+                args.push('-nonintrlv');
+            }
+            const result = (0, nbis_runtime_1.runNbis)('djpegl', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'djpegl');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const parsed = path_1.default.parse(inputPath);
+            const nistcomPath = path_1.default.join(parsed.dir, `${parsed.name}.ncm`);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            const nistcomBuffer = await (0, temp_io_1.readFileIfExists)(nistcomPath);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer,
+                nistcomBuffer
+            };
+        });
+    }
 }
 exports.Djpegl = Djpegl;

package/dist/src/dwsq.d.ts

@@ -1,3 +1,4 @@
+import type { StreamInput, StreamIoOptions } from './temp-io';
 export type DwsqOptions = {
     rawOut?: boolean;
 };
@@ -7,7 +8,15 @@ export type DwsqResult = {
     stdout: string;
     stderr: string;
 };
+export type DwsqStreamOptions = DwsqOptions & StreamIoOptions;
+export type DwsqStreamResult = {
+    stdout: string;
+    stderr: string;
+    outputBuffer?: Buffer;
+    nistcomBuffer?: Buffer;
+};
 export declare class Dwsq {
     version(): string;
     decompress(outputExtension: string, imagePath: string, options?: DwsqOptions): DwsqResult;
+    decompressStream(outputExtension: string, input: StreamInput, options?: DwsqStreamOptions): Promise<DwsqStreamResult>;
 }

package/dist/src/dwsq.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dwsq = void 0;
 const path_1 = __importDefault(require("path"));
 const nbis_runtime_1 = require("./nbis-runtime");
+const temp_io_1 = require("./temp-io");
 function replaceExtension(inputPath, outputExtension) {
     const parsed = path_1.default.parse(inputPath);
     const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
@@ -32,5 +33,27 @@ class Dwsq {
             stderr: result.stderr
         };
     }
+    async decompressStream(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.rawOut) {
+                args.push('-raw_out');
+            }
+            const result = (0, nbis_runtime_1.runNbis)('dwsq', args);
+            (0, nbis_runtime_1.assertSuccess)(result, 'dwsq');
+            const outputPath = replaceExtension(inputPath, outputExtension);
+            const parsed = path_1.default.parse(inputPath);
+            const nistcomPath = path_1.default.join(parsed.dir, `${parsed.name}.ncm`);
+            const outputBuffer = await (0, temp_io_1.deliverTempOutput)(outputPath, options);
+            const nistcomBuffer = await (0, temp_io_1.readFileIfExists)(nistcomPath);
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outputBuffer,
+                nistcomBuffer
+            };
+        });
+    }
 }
 exports.Dwsq = Dwsq;

package/dist/src/intr2not.d.ts

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

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;