nbis-wrapper-js 0.0.1

package/dist/src/cjpegl.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cjpegl = void 0;
+const path_1 = __importDefault(require("path"));
+const nbis_runtime_1 = require("./nbis-runtime");
+function buildRawAttr(raw) {
+    const attrs = [raw.width, raw.height, raw.depth];
+    if (raw.ppi != null) {
+        attrs.push(raw.ppi);
+    }
+    return attrs.join(',');
+}
+function buildYCbCr(components) {
+    const { y, cb, cr } = components;
+    return `${y[0]},${y[1]}:${cb[0]},${cb[1]}:${cr[0]},${cr[1]}`;
+}
+function replaceExtension(inputPath, outputExtension) {
+    const parsed = path_1.default.parse(inputPath);
+    const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
+    return path_1.default.join(parsed.dir, `${parsed.name}${ext}`);
+}
+class Cjpegl {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('cjpegl', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'cjpegl -version');
+        return result.stdout + result.stderr;
+    }
+    compress(outputExtension, imagePath, options = {}) {
+        const args = [outputExtension, imagePath];
+        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');
+        return {
+            outputPath: replaceExtension(imagePath, outputExtension),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Cjpegl = Cjpegl;

package/dist/src/cwsq.d.ts

@@ -0,0 +1,18 @@
+export type CwsqOptions = {
+    rawIn?: {
+        width: number;
+        height: number;
+        depth: number;
+        ppi?: number;
+    };
+    commentFile?: string;
+};
+export type CwsqResult = {
+    outputPath: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Cwsq {
+    version(): string;
+    compress(bitrate: number, outputExtension: string, imagePath: string, options?: CwsqOptions): CwsqResult;
+}

package/dist/src/cwsq.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cwsq = void 0;
+const path_1 = __importDefault(require("path"));
+const nbis_runtime_1 = require("./nbis-runtime");
+function buildRawAttr(raw) {
+    const attrs = [raw.width, raw.height, raw.depth];
+    if (raw.ppi != null) {
+        attrs.push(raw.ppi);
+    }
+    return attrs.join(',');
+}
+function replaceExtension(inputPath, outputExtension) {
+    const parsed = path_1.default.parse(inputPath);
+    const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
+    return path_1.default.join(parsed.dir, `${parsed.name}${ext}`);
+}
+class Cwsq {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('cwsq', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'cwsq -version');
+        return result.stdout + result.stderr;
+    }
+    compress(bitrate, outputExtension, imagePath, options = {}) {
+        const args = [String(bitrate), outputExtension, imagePath];
+        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');
+        return {
+            outputPath: replaceExtension(imagePath, outputExtension),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Cwsq = Cwsq;

package/dist/src/datainfo.d.ts

@@ -0,0 +1,8 @@
+export type DatainfoResult = {
+    stdout: string;
+    stderr: string;
+};
+export declare class Datainfo {
+    version(): string;
+    report(dataFile: string): DatainfoResult;
+}

package/dist/src/datainfo.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Datainfo = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+class Datainfo {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('datainfo', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'datainfo -version');
+        return result.stdout + result.stderr;
+    }
+    report(dataFile) {
+        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

@@ -0,0 +1,20 @@
+export type Djp2kOptions = {
+    inputPath?: string;
+    outputPath?: string;
+    imageDir?: string;
+    outputFormat?: string;
+    reduceFactor?: number;
+    layers?: number;
+    indexFile?: string;
+    decodeArea?: string;
+    tileNumber?: number;
+    extraArgs?: string[];
+};
+export type Djp2kResult = {
+    stdout: string;
+    stderr: string;
+};
+export declare class Djp2k {
+    version(): string;
+    decompress(options: Djp2kOptions): Djp2kResult;
+}

package/dist/src/djp2k.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Djp2k = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+class Djp2k {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('djp2k', ['-h']);
+        if (result.error) {
+            throw result.error;
+        }
+        return result.stdout + result.stderr;
+    }
+    decompress(options) {
+        const args = [];
+        if (options.imageDir) {
+            args.push('-ImgDir', options.imageDir);
+        }
+        if (options.outputFormat) {
+            args.push('-OutFor', options.outputFormat);
+        }
+        if (options.inputPath) {
+            args.push('-i', options.inputPath);
+        }
+        if (options.outputPath) {
+            args.push('-o', options.outputPath);
+        }
+        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);
+        }
+        const result = (0, nbis_runtime_1.runNbis)('djp2k', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'djp2k');
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Djp2k = Djp2k;

package/dist/src/djpeg.d.ts

@@ -0,0 +1,25 @@
+export type DjpegOptions = {
+    colors?: number;
+    fast?: boolean;
+    grayscale?: boolean;
+    scale?: string;
+    format?: 'bmp' | 'gif' | 'os2' | 'pnm' | 'rle' | 'targa';
+    dct?: 'int' | 'fast' | 'float';
+    dither?: 'fs' | 'ordered' | 'none';
+    mapFile?: string;
+    noSmooth?: boolean;
+    onePass?: boolean;
+    maxMemory?: string;
+    outputPath?: string;
+    verbose?: boolean;
+    debug?: boolean;
+    extraArgs?: string[];
+};
+export type DjpegResult = {
+    stdout: string;
+    stderr: string;
+    outputPath?: string;
+};
+export declare class Djpeg {
+    decompress(inputPath: string, options?: DjpegOptions): DjpegResult;
+}

package/dist/src/djpeg.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Djpeg = void 0;
+const nbis_runtime_1 = require("./nbis-runtime");
+class Djpeg {
+    decompress(inputPath, options = {}) {
+        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);
+        }
+        if (options.outputPath) {
+            args.push('-outfile', options.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');
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            outputPath: options.outputPath
+        };
+    }
+}
+exports.Djpeg = Djpeg;

package/dist/src/djpegb.d.ts

@@ -0,0 +1,14 @@
+export type DjpegbOptions = {
+    rawOut?: boolean;
+    nonInterleaved?: boolean;
+};
+export type DjpegbResult = {
+    outputPath: string;
+    nistcomPath: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Djpegb {
+    version(): string;
+    decompress(outputExtension: string, imagePath: string, options?: DjpegbOptions): DjpegbResult;
+}

package/dist/src/djpegb.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Djpegb = void 0;
+const path_1 = __importDefault(require("path"));
+const nbis_runtime_1 = require("./nbis-runtime");
+function replaceExtension(inputPath, outputExtension) {
+    const parsed = path_1.default.parse(inputPath);
+    const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
+    return path_1.default.join(parsed.dir, `${parsed.name}${ext}`);
+}
+class Djpegb {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('djpegb', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'djpegb -version');
+        return result.stdout + result.stderr;
+    }
+    decompress(outputExtension, imagePath, options = {}) {
+        const args = [outputExtension, imagePath];
+        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 parsed = path_1.default.parse(imagePath);
+        return {
+            outputPath: replaceExtension(imagePath, outputExtension),
+            nistcomPath: path_1.default.join(parsed.dir, `${parsed.name}.ncm`),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Djpegb = Djpegb;

package/dist/src/djpegl.d.ts

@@ -0,0 +1,14 @@
+export type DjpeglOptions = {
+    rawOut?: boolean;
+    nonInterleaved?: boolean;
+};
+export type DjpeglResult = {
+    outputPath: string;
+    nistcomPath: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Djpegl {
+    version(): string;
+    decompress(outputExtension: string, imagePath: string, options?: DjpeglOptions): DjpeglResult;
+}

package/dist/src/djpegl.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Djpegl = void 0;
+const path_1 = __importDefault(require("path"));
+const nbis_runtime_1 = require("./nbis-runtime");
+function replaceExtension(inputPath, outputExtension) {
+    const parsed = path_1.default.parse(inputPath);
+    const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
+    return path_1.default.join(parsed.dir, `${parsed.name}${ext}`);
+}
+class Djpegl {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('djpegl', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'djpegl -version');
+        return result.stdout + result.stderr;
+    }
+    decompress(outputExtension, imagePath, options = {}) {
+        const args = [outputExtension, imagePath];
+        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 parsed = path_1.default.parse(imagePath);
+        return {
+            outputPath: replaceExtension(imagePath, outputExtension),
+            nistcomPath: path_1.default.join(parsed.dir, `${parsed.name}.ncm`),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Djpegl = Djpegl;

package/dist/src/dwsq.d.ts

@@ -0,0 +1,13 @@
+export type DwsqOptions = {
+    rawOut?: boolean;
+};
+export type DwsqResult = {
+    outputPath: string;
+    nistcomPath: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Dwsq {
+    version(): string;
+    decompress(outputExtension: string, imagePath: string, options?: DwsqOptions): DwsqResult;
+}

package/dist/src/dwsq.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dwsq = void 0;
+const path_1 = __importDefault(require("path"));
+const nbis_runtime_1 = require("./nbis-runtime");
+function replaceExtension(inputPath, outputExtension) {
+    const parsed = path_1.default.parse(inputPath);
+    const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
+    return path_1.default.join(parsed.dir, `${parsed.name}${ext}`);
+}
+class Dwsq {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('dwsq', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'dwsq -version');
+        return result.stdout + result.stderr;
+    }
+    decompress(outputExtension, imagePath, options = {}) {
+        const args = [outputExtension, imagePath];
+        if (options.rawOut) {
+            args.push('-raw_out');
+        }
+        const result = (0, nbis_runtime_1.runNbis)('dwsq', args);
+        (0, nbis_runtime_1.assertSuccess)(result, 'dwsq');
+        const parsed = path_1.default.parse(imagePath);
+        return {
+            outputPath: replaceExtension(imagePath, outputExtension),
+            nistcomPath: path_1.default.join(parsed.dir, `${parsed.name}.ncm`),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Dwsq = Dwsq;

package/dist/src/index.d.ts

@@ -0,0 +1,26 @@
+export { getNbisRoot, getNbisDataPath, resolveBinPath } from './nbis-runtime';
+export { Mindtct } from './mindtct';
+export { Bozorth3 } from './bozorth3';
+export { Nfiq } from './nfiq';
+export { Cwsq } from './cwsq';
+export { Dwsq } from './dwsq';
+export { An2kTool } from './an2ktool';
+export { Chkan2k } from './chkan2k';
+export { Datainfo } from './datainfo';
+export { Cjpeg } from './cjpeg';
+export { Djpeg } from './djpeg';
+export { Cjpegb } from './cjpegb';
+export { Djpegb } from './djpegb';
+export { Cjpegl } from './cjpegl';
+export { Djpegl } from './djpegl';
+export { Cjp2k } from './cjp2k';
+export { Djp2k } from './djp2k';
+export { Rdwsqcom } from './rdwsqcom';
+export { Wrwsqcom } from './wrwsqcom';
+export { Rdjpgcom } from './rdjpgcom';
+export { Wrjpgcom } from './wrjpgcom';
+export { Rgb2ycc } from './rgb2ycc';
+export { Ycc2rgb } from './ycc2rgb';
+export { Intr2not } from './intr2not';
+export { Not2intr } from './not2intr';
+export { Jpegtran } from './jpegtran';

package/dist/src/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jpegtran = exports.Not2intr = exports.Intr2not = exports.Ycc2rgb = exports.Rgb2ycc = exports.Wrjpgcom = exports.Rdjpgcom = exports.Wrwsqcom = exports.Rdwsqcom = exports.Djp2k = exports.Cjp2k = exports.Djpegl = exports.Cjpegl = exports.Djpegb = exports.Cjpegb = exports.Djpeg = exports.Cjpeg = exports.Datainfo = exports.Chkan2k = exports.An2kTool = exports.Dwsq = exports.Cwsq = exports.Nfiq = exports.Bozorth3 = exports.Mindtct = exports.resolveBinPath = exports.getNbisDataPath = exports.getNbisRoot = void 0;
+var nbis_runtime_1 = require("./nbis-runtime");
+Object.defineProperty(exports, "getNbisRoot", { enumerable: true, get: function () { return nbis_runtime_1.getNbisRoot; } });
+Object.defineProperty(exports, "getNbisDataPath", { enumerable: true, get: function () { return nbis_runtime_1.getNbisDataPath; } });
+Object.defineProperty(exports, "resolveBinPath", { enumerable: true, get: function () { return nbis_runtime_1.resolveBinPath; } });
+var mindtct_1 = require("./mindtct");
+Object.defineProperty(exports, "Mindtct", { enumerable: true, get: function () { return mindtct_1.Mindtct; } });
+var bozorth3_1 = require("./bozorth3");
+Object.defineProperty(exports, "Bozorth3", { enumerable: true, get: function () { return bozorth3_1.Bozorth3; } });
+var nfiq_1 = require("./nfiq");
+Object.defineProperty(exports, "Nfiq", { enumerable: true, get: function () { return nfiq_1.Nfiq; } });
+var cwsq_1 = require("./cwsq");
+Object.defineProperty(exports, "Cwsq", { enumerable: true, get: function () { return cwsq_1.Cwsq; } });
+var dwsq_1 = require("./dwsq");
+Object.defineProperty(exports, "Dwsq", { enumerable: true, get: function () { return dwsq_1.Dwsq; } });
+var an2ktool_1 = require("./an2ktool");
+Object.defineProperty(exports, "An2kTool", { enumerable: true, get: function () { return an2ktool_1.An2kTool; } });
+var chkan2k_1 = require("./chkan2k");
+Object.defineProperty(exports, "Chkan2k", { enumerable: true, get: function () { return chkan2k_1.Chkan2k; } });
+var datainfo_1 = require("./datainfo");
+Object.defineProperty(exports, "Datainfo", { enumerable: true, get: function () { return datainfo_1.Datainfo; } });
+var cjpeg_1 = require("./cjpeg");
+Object.defineProperty(exports, "Cjpeg", { enumerable: true, get: function () { return cjpeg_1.Cjpeg; } });
+var djpeg_1 = require("./djpeg");
+Object.defineProperty(exports, "Djpeg", { enumerable: true, get: function () { return djpeg_1.Djpeg; } });
+var cjpegb_1 = require("./cjpegb");
+Object.defineProperty(exports, "Cjpegb", { enumerable: true, get: function () { return cjpegb_1.Cjpegb; } });
+var djpegb_1 = require("./djpegb");
+Object.defineProperty(exports, "Djpegb", { enumerable: true, get: function () { return djpegb_1.Djpegb; } });
+var cjpegl_1 = require("./cjpegl");
+Object.defineProperty(exports, "Cjpegl", { enumerable: true, get: function () { return cjpegl_1.Cjpegl; } });
+var djpegl_1 = require("./djpegl");
+Object.defineProperty(exports, "Djpegl", { enumerable: true, get: function () { return djpegl_1.Djpegl; } });
+var cjp2k_1 = require("./cjp2k");
+Object.defineProperty(exports, "Cjp2k", { enumerable: true, get: function () { return cjp2k_1.Cjp2k; } });
+var djp2k_1 = require("./djp2k");
+Object.defineProperty(exports, "Djp2k", { enumerable: true, get: function () { return djp2k_1.Djp2k; } });
+var rdwsqcom_1 = require("./rdwsqcom");
+Object.defineProperty(exports, "Rdwsqcom", { enumerable: true, get: function () { return rdwsqcom_1.Rdwsqcom; } });
+var wrwsqcom_1 = require("./wrwsqcom");
+Object.defineProperty(exports, "Wrwsqcom", { enumerable: true, get: function () { return wrwsqcom_1.Wrwsqcom; } });
+var rdjpgcom_1 = require("./rdjpgcom");
+Object.defineProperty(exports, "Rdjpgcom", { enumerable: true, get: function () { return rdjpgcom_1.Rdjpgcom; } });
+var wrjpgcom_1 = require("./wrjpgcom");
+Object.defineProperty(exports, "Wrjpgcom", { enumerable: true, get: function () { return wrjpgcom_1.Wrjpgcom; } });
+var rgb2ycc_1 = require("./rgb2ycc");
+Object.defineProperty(exports, "Rgb2ycc", { enumerable: true, get: function () { return rgb2ycc_1.Rgb2ycc; } });
+var ycc2rgb_1 = require("./ycc2rgb");
+Object.defineProperty(exports, "Ycc2rgb", { enumerable: true, get: function () { return ycc2rgb_1.Ycc2rgb; } });
+var intr2not_1 = require("./intr2not");
+Object.defineProperty(exports, "Intr2not", { enumerable: true, get: function () { return intr2not_1.Intr2not; } });
+var not2intr_1 = require("./not2intr");
+Object.defineProperty(exports, "Not2intr", { enumerable: true, get: function () { return not2intr_1.Not2intr; } });
+var jpegtran_1 = require("./jpegtran");
+Object.defineProperty(exports, "Jpegtran", { enumerable: true, get: function () { return jpegtran_1.Jpegtran; } });

package/dist/src/intr2not.d.ts

@@ -0,0 +1,22 @@
+export type Intr2notOptions = {
+    rawIn?: {
+        width: number;
+        height: number;
+        depth: number;
+        ppi?: number;
+    };
+    yCbCr?: {
+        y: [number, number];
+        cb: [number, number];
+        cr: [number, number];
+    };
+};
+export type Intr2notResult = {
+    outputPath: string;
+    stdout: string;
+    stderr: string;
+};
+export declare class Intr2not {
+    version(): string;
+    convert(outputExtension: string, imagePath: string, options?: Intr2notOptions): Intr2notResult;
+}

package/dist/src/intr2not.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Intr2not = void 0;
+const path_1 = __importDefault(require("path"));
+const nbis_runtime_1 = require("./nbis-runtime");
+function buildRawAttr(raw) {
+    const attrs = [raw.width, raw.height, raw.depth];
+    if (raw.ppi != null) {
+        attrs.push(raw.ppi);
+    }
+    return attrs.join(',');
+}
+function buildYCbCr(components) {
+    const { y, cb, cr } = components;
+    return `${y[0]},${y[1]}:${cb[0]},${cb[1]}:${cr[0]},${cr[1]}`;
+}
+function replaceExtension(inputPath, outputExtension) {
+    const parsed = path_1.default.parse(inputPath);
+    const ext = outputExtension.startsWith('.') ? outputExtension : `.${outputExtension}`;
+    return path_1.default.join(parsed.dir, `${parsed.name}${ext}`);
+}
+class Intr2not {
+    version() {
+        const result = (0, nbis_runtime_1.runNbis)('intr2not', ['-version']);
+        (0, nbis_runtime_1.assertSuccess)(result, 'intr2not -version');
+        return result.stdout + result.stderr;
+    }
+    convert(outputExtension, imagePath, options = {}) {
+        const args = [outputExtension, imagePath];
+        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');
+        return {
+            outputPath: replaceExtension(imagePath, outputExtension),
+            stdout: result.stdout,
+            stderr: result.stderr
+        };
+    }
+}
+exports.Intr2not = Intr2not;

package/dist/src/jpegtran.d.ts

@@ -0,0 +1,24 @@
+export type JpegtranOptions = {
+    optimize?: boolean;
+    progressive?: boolean;
+    restart?: string | number;
+    scansFile?: string;
+    transform?: 'flip-horizontal' | 'flip-vertical' | 'rotate-90' | 'rotate-180' | 'rotate-270' | 'transpose' | 'transverse';
+    trim?: boolean;
+    grayscale?: boolean;
+    copy?: 'none' | 'comments' | 'all';
+    maxMemory?: string;
+    outputPath?: string;
+    verbose?: boolean;
+    debug?: boolean;
+    extraArgs?: string[];
+};
+export type JpegtranResult = {
+    stdout: string;
+    stderr: string;
+    outputPath?: string;
+};
+export declare class Jpegtran {
+    version(): string;
+    transform(inputPath: string, options?: JpegtranOptions): JpegtranResult;
+}