@lesjoursfr/gifsicle-wrapper 4.1.5

package/install/install.js

@@ -0,0 +1,45 @@
+import { execa } from "execa";
+import { mkdir, rm } from "fs/promises";
+import process from "process";
+import { x as extract } from "tar";
+import { temporaryFile } from "tempy";
+import { gifsicleSourcePath, gifsicleWrapper } from "./wrapper.js";
+async function buildFromSource(file, cmd) {
+    const temporary = temporaryFile();
+    console.log(`use the temporary folder : ${temporary}`);
+    await mkdir(temporary, { recursive: true });
+    await extract({ file: file, cwd: temporary, strip: 1 });
+    for (const x of cmd) {
+        await execa(x, { cwd: temporary, shell: true });
+    }
+    await rm(temporary, { recursive: true });
+}
+(async () => {
+    try {
+        await gifsicleWrapper.run(["--version"]);
+        console.log("gifsicle pre-build test passed successfully");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.warn(error.message);
+        }
+        console.warn("gifsicle pre-build test failed");
+        console.info("compiling from source");
+        try {
+            const source = gifsicleSourcePath;
+            const destination = gifsicleWrapper.dest;
+            await buildFromSource(source, [
+                "autoreconf -ivf",
+                `./configure --disable-gifview --disable-gifdiff --prefix="${destination}" --bindir="${destination}"`,
+                "make install",
+            ]);
+            console.log("gifsicle built successfully");
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(error.stack);
+            }
+            process.exit(1);
+        }
+    }
+})();

package/install/wrapper.js

@@ -0,0 +1,11 @@
+import BinWrapper from "@lesjoursfr/bin-wrapper";
+import { platform } from "process";
+import { fileURLToPath } from "url";
+const version = "1.94";
+const base = `https://raw.githubusercontent.com/lesjoursfr/gifsicle-wrapper/main/vendor/v${version}`;
+export const gifsicleWrapper = new BinWrapper({ strip: 0 });
+gifsicleWrapper.addSrc(`${base}/linux/x64/gifsicle.tar.gz`, "linux", "x64");
+gifsicleWrapper.setDest(fileURLToPath(new URL("../vendor", import.meta.url)));
+gifsicleWrapper.setUse(platform === "win32" ? "gifsicle.exe" : "gifsicle");
+gifsicleWrapper.setVersion(`>=${version}`);
+export const gifsicleSourcePath = fileURLToPath(new URL(`../vendor/v${version}/source/gifsicle.tar.gz`, import.meta.url));

package/lib/core/color.d.ts

@@ -0,0 +1,17 @@
+import { Gifsicle } from "../gifsicle.js";
+/**
+ * Convert to 8-bit greyscale.
+ *
+ * @param {Boolean} [greyscale=true]
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export declare function greyscale(this: Gifsicle, greyscale: boolean | undefined): Gifsicle;
+/**
+ * Alternative spelling of `greyscale`.
+ *
+ * @param {Boolean} [grayscale=true]
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export declare function grayscale(this: Gifsicle, grayscale: boolean | undefined): Gifsicle;

package/lib/core/color.js

@@ -0,0 +1,26 @@
+/**
+ * Convert to 8-bit greyscale.
+ *
+ * @param {Boolean} [greyscale=true]
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function greyscale(greyscale) {
+    if (greyscale !== undefined) {
+        this.options.greyscale = greyscale;
+    }
+    else {
+        this.options.greyscale = true;
+    }
+    return this;
+}
+/**
+ * Alternative spelling of `greyscale`.
+ *
+ * @param {Boolean} [grayscale=true]
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function grayscale(grayscale) {
+    return this.greyscale(grayscale);
+}

package/lib/core/input.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function readFile(input: string | Buffer): Buffer;

package/lib/core/input.js

@@ -0,0 +1,11 @@
+import { readFileSync } from "fs";
+import { isGif } from "../toolbox/is-gif.js";
+export function readFile(input) {
+    if (typeof input === "string") {
+        input = readFileSync(input);
+    }
+    if (!isGif(input)) {
+        throw new TypeError("Expected 'input' to be a gif file");
+    }
+    return input;
+}

package/lib/core/optimize.d.ts

@@ -0,0 +1,26 @@
+import { Gifsicle } from "../gifsicle.js";
+/**
+ * Optimization levels.
+ */
+export declare enum OptimizationLevel {
+    O1 = "O1",
+    O2 = "O2",
+    O3 = "O3"
+}
+/**
+ * Optimization options.
+ */
+export type OptimizeOptions = {
+    level?: OptimizationLevel;
+    lossiness?: number;
+};
+/**
+ * Optimize the gif.
+ *
+ * @param {Object} [options]
+ * @param {OptimizationLevel} [options.level=OptimizationLevel.O1] - the optimization level.
+ * @param {Number} [options.lossiness=20] - the lossiness value to shrink the number of colors [0,200].
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export declare function optimize(this: Gifsicle, options: OptimizeOptions | undefined): Gifsicle;

package/lib/core/optimize.js

@@ -0,0 +1,40 @@
+/**
+ * Optimization levels.
+ */
+/* eslint-disable no-unused-vars */
+export var OptimizationLevel;
+(function (OptimizationLevel) {
+    OptimizationLevel["O1"] = "O1";
+    OptimizationLevel["O2"] = "O2";
+    OptimizationLevel["O3"] = "O3";
+})(OptimizationLevel || (OptimizationLevel = {}));
+/**
+ * Optimize the gif.
+ *
+ * @param {Object} [options]
+ * @param {OptimizationLevel} [options.level=OptimizationLevel.O1] - the optimization level.
+ * @param {Number} [options.lossiness=20] - the lossiness value to shrink the number of colors [0,200].
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function optimize(options) {
+    // Default options
+    this.options.optimize = { level: OptimizationLevel.O1, lossiness: 20 };
+    // Process parameters
+    if (options !== undefined) {
+        // Level
+        if (options.level !== undefined) {
+            this.options.optimize.level = options.level;
+        }
+        // Lossiness
+        if (options.lossiness !== undefined) {
+            if (Number.isInteger(options.lossiness) && options.lossiness > 0 && options.lossiness < 200) {
+                this.options.optimize.lossiness = options.lossiness;
+            }
+            else {
+                throw new TypeError("Expected 'lossiness' to be an integer in the range [0,200]");
+            }
+        }
+    }
+    return this;
+}

package/lib/core/output.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { Gifsicle } from "../gifsicle.js";
+/**
+ * Save the result in a file.
+ *
+ * @param {String} [fileOut]
+ */
+export declare function toFile(this: Gifsicle, fileOut: string): Promise<void>;
+/**
+ * Get the result file as a Buffer.
+ *
+ * @returns {Buffer}
+ */
+export declare function toBuffer(this: Gifsicle): Promise<Buffer>;

package/lib/core/output.js

@@ -0,0 +1,53 @@
+import { execa } from "execa";
+import { writeFileSync } from "fs";
+import { gifsicleWrapper } from "../wrapper.js";
+import { computeCroppingPoint } from "./resize.js";
+async function processFile(input, options) {
+    const args = ["--no-warnings", "--no-app-extensions"];
+    if (options.greyscale === true) {
+        args.push("--use-colormap=gray");
+    }
+    if (options.crop !== undefined) {
+        const { x, y } = computeCroppingPoint(input, options.crop);
+        args.push(`--crop=${x}, ${y}+${options.crop.width}x${options.crop.height}`);
+    }
+    if (options.resize !== undefined) {
+        if (options.resize.width !== undefined || options.resize.height !== undefined) {
+            if (options.resize.withoutEnlargement === true) {
+                args.push(`--resize-fit=${options.resize.width || "_"}x${options.resize.height || "_"}`);
+            }
+            else {
+                args.push(`--resize-touch=${options.resize.width || "_"}x${options.resize.height || "_"}`);
+            }
+        }
+    }
+    if (options.optimize !== undefined) {
+        if (options.optimize.level !== undefined) {
+            args.push(`-${options.optimize.level}`);
+        }
+        if (options.optimize.lossiness !== undefined) {
+            args.push(`--lossy=${options.optimize.lossiness}`);
+        }
+    }
+    const { stdout } = await execa(gifsicleWrapper.path, args, {
+        encoding: null,
+        input,
+    });
+    return stdout;
+}
+/**
+ * Save the result in a file.
+ *
+ * @param {String} [fileOut]
+ */
+export async function toFile(fileOut) {
+    writeFileSync(fileOut, await processFile(this.input, this.options));
+}
+/**
+ * Get the result file as a Buffer.
+ *
+ * @returns {Buffer}
+ */
+export async function toBuffer() {
+    return processFile(this.input, this.options);
+}

package/lib/core/resize.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+import { Gifsicle } from "../gifsicle.js";
+/**
+ * Reduction kernels.
+ */
+export declare enum ReductionKernel {
+    sample = "sample",
+    mix = "mix",
+    catrom = "catrom",
+    mitchell = "mitchell",
+    lanczos2 = "lanczos2",
+    lanczos3 = "lanczos3"
+}
+/**
+ * Position modes for cropping.
+ */
+export declare enum CroppingPosition {
+    center = "center",
+    top = "top",
+    right = "right",
+    bottom = "bottom",
+    left = "left",
+    topRight = "topRight",
+    bottomRight = "bottomRight",
+    bottomLeft = "bottomLeft",
+    topLeft = "topLeft"
+}
+/**
+ * Resize options.
+ */
+export type ResizeOptions = {
+    kernel: ReductionKernel | undefined;
+    withoutEnlargement: boolean | undefined;
+};
+/**
+ * Cropping options.
+ */
+export type CroppingOptions = {
+    position: CroppingPosition | undefined;
+};
+/**
+ * Resize image to `width`, `height` or `width x height`.
+ *
+ * @param {Number} [width] - pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
+ * @param {Number} [height] - pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
+ * @param {Object} [options]
+ * @param {ReductionKernel} [options.kernel=ReductionKernel.lanczos3] - the kernel to use for image reduction.
+ * @param {Boolean} [options.withoutEnlargement=false] - do not enlarge if the width *or* height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option. *
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export declare function resize(this: Gifsicle, width: number | undefined, height: number | undefined, options: ResizeOptions | undefined): Gifsicle;
+/**
+ * Crop the image to `width x height`.
+ *
+ * @param {number} [width] - pixels wide the resultant image should be.
+ * @param {number} [height] - pixels high the resultant image should be.
+ * @param {Object} [options]
+ * @param {CroppingPosition} [options.position=CroppingPosition.center] - position of the cropping rectangle.
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export declare function crop(this: Gifsicle, width: number, height: number, options: CroppingOptions | undefined): Gifsicle;
+export declare function computeCroppingPoint(input: Buffer, crop: {
+    width: number;
+    height: number;
+    position: CroppingPosition;
+}): {
+    x: number;
+    y: number;
+};

package/lib/core/resize.js

@@ -0,0 +1,155 @@
+import sizeOf from "image-size";
+/**
+ * Reduction kernels.
+ */
+/* eslint-disable no-unused-vars */
+export var ReductionKernel;
+(function (ReductionKernel) {
+    ReductionKernel["sample"] = "sample";
+    ReductionKernel["mix"] = "mix";
+    ReductionKernel["catrom"] = "catrom";
+    ReductionKernel["mitchell"] = "mitchell";
+    ReductionKernel["lanczos2"] = "lanczos2";
+    ReductionKernel["lanczos3"] = "lanczos3";
+})(ReductionKernel || (ReductionKernel = {}));
+/* eslint-enable no-unused-vars */
+/**
+ * Position modes for cropping.
+ */
+/* eslint-disable no-unused-vars */
+export var CroppingPosition;
+(function (CroppingPosition) {
+    CroppingPosition["center"] = "center";
+    CroppingPosition["top"] = "top";
+    CroppingPosition["right"] = "right";
+    CroppingPosition["bottom"] = "bottom";
+    CroppingPosition["left"] = "left";
+    CroppingPosition["topRight"] = "topRight";
+    CroppingPosition["bottomRight"] = "bottomRight";
+    CroppingPosition["bottomLeft"] = "bottomLeft";
+    CroppingPosition["topLeft"] = "topLeft";
+})(CroppingPosition || (CroppingPosition = {}));
+/**
+ * Resize image to `width`, `height` or `width x height`.
+ *
+ * @param {Number} [width] - pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
+ * @param {Number} [height] - pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
+ * @param {Object} [options]
+ * @param {ReductionKernel} [options.kernel=ReductionKernel.lanczos3] - the kernel to use for image reduction.
+ * @param {Boolean} [options.withoutEnlargement=false] - do not enlarge if the width *or* height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option. *
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function resize(width, height, options) {
+    // Default options
+    this.options.resize = { kernel: ReductionKernel.lanczos3, withoutEnlargement: false };
+    // Process parameters
+    if (width !== undefined) {
+        if (Number.isInteger(width) && width > 0) {
+            this.options.resize.width = width;
+        }
+        else {
+            throw new TypeError("Expected 'width' to be a positive integer");
+        }
+    }
+    if (height !== undefined) {
+        if (Number.isInteger(height) && height > 0) {
+            this.options.resize.height = height;
+        }
+        else {
+            throw new TypeError("Expected 'height' to be a positive integer");
+        }
+    }
+    if (options !== undefined) {
+        // Kernel
+        if (options.kernel !== undefined) {
+            this.options.resize.kernel = options.kernel;
+        }
+        // Without enlargement
+        if (options.withoutEnlargement !== undefined) {
+            this.options.resize.withoutEnlargement = options.withoutEnlargement;
+        }
+    }
+    return this;
+}
+/**
+ * Crop the image to `width x height`.
+ *
+ * @param {number} [width] - pixels wide the resultant image should be.
+ * @param {number} [height] - pixels high the resultant image should be.
+ * @param {Object} [options]
+ * @param {CroppingPosition} [options.position=CroppingPosition.center] - position of the cropping rectangle.
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function crop(width, height, options) {
+    // Default options
+    this.options.crop = { width: 0, height: 0, position: CroppingPosition.center };
+    // Process parameters
+    if (Number.isInteger(width) && width > 0) {
+        this.options.crop.width = width;
+    }
+    else {
+        throw new TypeError("Expected 'width' to be a positive integer");
+    }
+    if (Number.isInteger(height) && height > 0) {
+        this.options.crop.height = height;
+    }
+    else {
+        throw new TypeError("Expected 'height' to be a positive integer");
+    }
+    if (options !== undefined) {
+        // Position
+        if (options.position !== undefined) {
+            this.options.crop.position = options.position;
+        }
+    }
+    return this;
+}
+export function computeCroppingPoint(input, crop) {
+    const size = sizeOf(input);
+    if (size.width === undefined || size.height === undefined) {
+        throw new Error("Can't compute the image size");
+    }
+    let px = 0;
+    let py = 0;
+    switch (crop.position) {
+        case CroppingPosition.center:
+            px = Math.floor((size.width - crop.width) / 2);
+            py = Math.floor((size.height - crop.height) / 2);
+            break;
+        case CroppingPosition.top:
+            px = Math.floor((size.width - crop.width) / 2);
+            py = 0;
+            break;
+        case CroppingPosition.right:
+            px = size.width - crop.width;
+            py = Math.floor((size.height - crop.height) / 2);
+            break;
+        case CroppingPosition.bottom:
+            px = Math.floor((size.width - crop.width) / 2);
+            py = size.height - crop.height;
+            break;
+        case CroppingPosition.left:
+            px = 0;
+            py = Math.floor((size.height - crop.height) / 2);
+            break;
+        case CroppingPosition.topRight:
+            px = size.width - crop.width;
+            py = 0;
+            break;
+        case CroppingPosition.bottomRight:
+            px = size.width - crop.width;
+            py = size.height - crop.height;
+            break;
+        case CroppingPosition.bottomLeft:
+            px = 0;
+            py = size.height - crop.height;
+            break;
+        case CroppingPosition.topLeft:
+            px = 0;
+            py = 0;
+            break;
+    }
+    return { x: px, y: py };
+}

package/lib/gifsicle.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import { grayscale, greyscale } from "./core/color.js";
+import { OptimizeOptions, optimize } from "./core/optimize.js";
+import { toBuffer, toFile } from "./core/output.js";
+import { CroppingPosition, ReductionKernel, crop, resize } from "./core/resize.js";
+export interface GifsicleInternalOptions {
+    greyscale?: boolean;
+    resize?: {
+        width?: number;
+        height?: number;
+        kernel: ReductionKernel;
+        withoutEnlargement: boolean;
+    };
+    crop?: {
+        width: number;
+        height: number;
+        position: CroppingPosition;
+    };
+    optimize?: OptimizeOptions;
+}
+/**
+ * Export Gifsicle class.
+ */
+export declare class Gifsicle {
+    options: GifsicleInternalOptions;
+    input: Buffer;
+    constructor(input: string | Buffer);
+    greyscale: typeof greyscale;
+    grayscale: typeof grayscale;
+    resize: typeof resize;
+    crop: typeof crop;
+    optimize: typeof optimize;
+    toFile: typeof toFile;
+    toBuffer: typeof toBuffer;
+}

package/lib/gifsicle.js

@@ -0,0 +1,23 @@
+import { grayscale, greyscale } from "./core/color.js";
+import { readFile } from "./core/input.js";
+import { optimize } from "./core/optimize.js";
+import { toBuffer, toFile } from "./core/output.js";
+import { crop, resize } from "./core/resize.js";
+/**
+ * Export Gifsicle class.
+ */
+export class Gifsicle {
+    options;
+    input;
+    constructor(input) {
+        this.input = readFile(input);
+        this.options = {};
+    }
+    greyscale = greyscale;
+    grayscale = grayscale;
+    resize = resize;
+    crop = crop;
+    optimize = optimize;
+    toFile = toFile;
+    toBuffer = toBuffer;
+}

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { OptimizationLevel } from "./core/optimize.js";
+import { CroppingPosition, ReductionKernel } from "./core/resize.js";
+import { Gifsicle } from "./gifsicle.js";
+declare function gifsicle(input: string | Buffer): Gifsicle;
+declare namespace gifsicle {
+    var kernel: typeof ReductionKernel;
+    var position: typeof CroppingPosition;
+    var level: typeof OptimizationLevel;
+}
+export default gifsicle;

package/lib/index.js

@@ -0,0 +1,10 @@
+import { OptimizationLevel } from "./core/optimize.js";
+import { CroppingPosition, ReductionKernel } from "./core/resize.js";
+import { Gifsicle } from "./gifsicle.js";
+function gifsicle(input) {
+    return new Gifsicle(input);
+}
+gifsicle.kernel = ReductionKernel;
+gifsicle.position = CroppingPosition;
+gifsicle.level = OptimizationLevel;
+export default gifsicle;

package/lib/toolbox/is-gif.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function isGif(buffer: Buffer): boolean;

package/lib/toolbox/is-gif.js

@@ -0,0 +1,8 @@
+// Based on isGif function from https://github.com/sindresorhus/is-gif
+// https://github.com/sindresorhus/is-gif/blob/main/index.js
+export function isGif(buffer) {
+    if (!buffer || buffer.length < 3) {
+        return false;
+    }
+    return buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46;
+}

package/lib/wrapper.d.ts

@@ -0,0 +1,3 @@
+import BinWrapper from "@lesjoursfr/bin-wrapper";
+export declare const gifsicleWrapper: BinWrapper;
+export declare const gifsicleSourcePath: string;

package/lib/wrapper.js

@@ -0,0 +1,11 @@
+import BinWrapper from "@lesjoursfr/bin-wrapper";
+import { platform } from "process";
+import { fileURLToPath } from "url";
+const version = "1.94";
+const base = `https://raw.githubusercontent.com/lesjoursfr/gifsicle-wrapper/main/vendor/v${version}`;
+export const gifsicleWrapper = new BinWrapper({ strip: 0 });
+gifsicleWrapper.addSrc(`${base}/linux/x64/gifsicle.tar.gz`, "linux", "x64");
+gifsicleWrapper.setDest(fileURLToPath(new URL("../vendor", import.meta.url)));
+gifsicleWrapper.setUse(platform === "win32" ? "gifsicle.exe" : "gifsicle");
+gifsicleWrapper.setVersion(`>=${version}`);
+export const gifsicleSourcePath = fileURLToPath(new URL(`../vendor/v${version}/source/gifsicle.tar.gz`, import.meta.url));

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Les Jours (github.com/lesjoursfr)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,73 @@
+{
+	"name": "@lesjoursfr/gifsicle-wrapper",
+	"version": "4.1.5",
+	"description": "Wrapper for Gifsicle",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/lesjoursfr/gifsicle-wrapper.git"
+	},
+	"homepage": "https://github.com/lesjoursfr/gifsicle-wrapper#readme",
+	"bugs": {
+		"url": "https://github.com/lesjoursfr/gifsicle-wrapper/issues"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"engines": {
+		"node": "18.x || 20.x"
+	},
+	"exports": "./lib/index.js",
+	"types": "./lib/index.d.ts",
+	"files": [
+		"install/**/*",
+		"vendor/v1.94/source/gifsicle.tar.gz",
+		"lib/**/*",
+		"src/**/*"
+	],
+	"scripts": {
+		"freshlock": "rm -rf node_modules/ && rm .yarn/install-state.gz && rm yarn.lock && yarn",
+		"postinstall": "node install/install.js",
+		"check-lint": "eslint . --ext .js,.jsx,.ts,.tsx",
+		"check-format": "prettier --check \"**/*.{ts,js,cjs,mjs,json,yml,md}\"",
+		"check-tsc": "tsc --noEmit",
+		"lint": "eslint . --fix --ext .js,.jsx,.ts,.tsx",
+		"format": "prettier --write \"**/*.{ts,js,cjs,mjs,json,yml,md}\"",
+		"build-postinstall": "tsc --project tsconfig.install.json",
+		"build": "tsc",
+		"test": "NODE_OPTIONS='--loader=ts-node/esm' mocha"
+	},
+	"keywords": [
+		"gif",
+		"gifsicle",
+		"image",
+		"img",
+		"compress",
+		"resize",
+		"minify",
+		"optimize"
+	],
+	"type": "module",
+	"dependencies": {
+		"@lesjoursfr/bin-wrapper": "^12.1.5",
+		"execa": "^8.0.1",
+		"image-size": "^1.1.1",
+		"tar": "^6.2.0",
+		"tempy": "^3.1.0"
+	},
+	"devDependencies": {
+		"@tsconfig/node18": "^18.2.2",
+		"@types/mocha": "^10.0.6",
+		"@types/node": "^20.11.15",
+		"@types/tar": "^6.1.11",
+		"@typescript-eslint/eslint-plugin": "^6.20.0",
+		"@typescript-eslint/parser": "^6.20.0",
+		"eslint": "^8.56.0",
+		"eslint-config-prettier": "^9.1.0",
+		"mocha": "^10.2.0",
+		"prettier": "^3.2.4",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.3.3"
+	},
+	"packageManager": "yarn@4.1.0"
+}

package/readme.md

@@ -0,0 +1,47 @@
+[![NPM version](https://badge.fury.io/js/@lesjoursfr%2Fgifsicle-wrapper.svg)](http://badge.fury.io/js/@lesjoursfr%2Fgifsicle-wrapper)
+[![QC Checks](https://github.com/lesjoursfr/gifsicle-wrapper/actions/workflows/quality-control.yml/badge.svg)](https://github.com/lesjoursfr/gifsicle-wrapper/actions/workflows/quality-control.yml)
+
+# @lesjoursfr/gifsicle-wrapper
+
+[Gifsicle](https://www.lcdf.org/gifsicle/) wrapper
+
+## Usage
+
+Resize a Gif :
+
+```javascript
+const Gifsicle = require("@lesjoursfr/gifsicle-wrapper");
+
+(async () => {
+	await Gifsicle(path.join(__dirname, "test.gif"))
+		.resize(600, 600, {
+			kernel: gifsicle.kernel.lanczos3,
+			withoutEnlargement: true,
+		})
+		.toFile(path.join(__dirname, "test-resized.gif"));
+})();
+```
+
+Change colors to greyscale :
+
+```javascript
+const Gifsicle = require("@lesjoursfr/gifsicle-wrapper");
+
+(async () => {
+	await Gifsicle(path.join(__dirname, "test.gif"))
+		.greyscale(true)
+		.toFile(path.join(__dirname, "test-resized.gif"));
+})();
+```
+
+Optimize the output :
+
+```javascript
+const Gifsicle = require("@lesjoursfr/gifsicle-wrapper");
+
+(async () => {
+	await Gifsicle(path.join(__dirname, "test.gif"))
+		.optimize({ level: gifsicle.level.O2, lossiness: 20 })
+		.toFile(path.join(__dirname, "test-optimized.gif"));
+})();
+```

package/src/core/color.ts

@@ -0,0 +1,28 @@
+import { Gifsicle } from "../gifsicle.js";
+
+/**
+ * Convert to 8-bit greyscale.
+ *
+ * @param {Boolean} [greyscale=true]
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function greyscale(this: Gifsicle, greyscale: boolean | undefined): Gifsicle {
+  if (greyscale !== undefined) {
+    this.options.greyscale = greyscale;
+  } else {
+    this.options.greyscale = true;
+  }
+  return this;
+}
+
+/**
+ * Alternative spelling of `greyscale`.
+ *
+ * @param {Boolean} [grayscale=true]
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function grayscale(this: Gifsicle, grayscale: boolean | undefined) {
+  return this.greyscale(grayscale);
+}

package/src/core/input.ts

@@ -0,0 +1,14 @@
+import { readFileSync } from "fs";
+import { isGif } from "../toolbox/is-gif.js";
+
+export function readFile(input: string | Buffer): Buffer {
+  if (typeof input === "string") {
+    input = readFileSync(input);
+  }
+
+  if (!isGif(input)) {
+    throw new TypeError("Expected 'input' to be a gif file");
+  }
+
+  return input;
+}

package/src/core/optimize.ts

@@ -0,0 +1,51 @@
+import { Gifsicle } from "../gifsicle.js";
+
+/**
+ * Optimization levels.
+ */
+/* eslint-disable no-unused-vars */
+export enum OptimizationLevel {
+  O1 = "O1",
+  O2 = "O2",
+  O3 = "O3",
+}
+/* eslint-enable no-unused-vars */
+
+/**
+ * Optimization options.
+ */
+export type OptimizeOptions = {
+  level?: OptimizationLevel;
+  lossiness?: number;
+};
+
+/**
+ * Optimize the gif.
+ *
+ * @param {Object} [options]
+ * @param {OptimizationLevel} [options.level=OptimizationLevel.O1] - the optimization level.
+ * @param {Number} [options.lossiness=20] - the lossiness value to shrink the number of colors [0,200].
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function optimize(this: Gifsicle, options: OptimizeOptions | undefined): Gifsicle {
+  // Default options
+  this.options.optimize = { level: OptimizationLevel.O1, lossiness: 20 };
+
+  // Process parameters
+  if (options !== undefined) {
+    // Level
+    if (options.level !== undefined) {
+      this.options.optimize.level = options.level;
+    }
+    // Lossiness
+    if (options.lossiness !== undefined) {
+      if (Number.isInteger(options.lossiness) && options.lossiness > 0 && options.lossiness < 200) {
+        this.options.optimize.lossiness = options.lossiness;
+      } else {
+        throw new TypeError("Expected 'lossiness' to be an integer in the range [0,200]");
+      }
+    }
+  }
+  return this;
+}

package/src/core/output.ts

@@ -0,0 +1,62 @@
+import { execa } from "execa";
+import { writeFileSync } from "fs";
+import { Gifsicle, GifsicleInternalOptions } from "../gifsicle.js";
+import { gifsicleWrapper } from "../wrapper.js";
+import { computeCroppingPoint } from "./resize.js";
+
+async function processFile(input: Buffer, options: GifsicleInternalOptions) {
+  const args = ["--no-warnings", "--no-app-extensions"];
+
+  if (options.greyscale === true) {
+    args.push("--use-colormap=gray");
+  }
+
+  if (options.crop !== undefined) {
+    const { x, y } = computeCroppingPoint(input, options.crop);
+    args.push(`--crop=${x}, ${y}+${options.crop.width}x${options.crop.height}`);
+  }
+
+  if (options.resize !== undefined) {
+    if (options.resize.width !== undefined || options.resize.height !== undefined) {
+      if (options.resize.withoutEnlargement === true) {
+        args.push(`--resize-fit=${options.resize.width || "_"}x${options.resize.height || "_"}`);
+      } else {
+        args.push(`--resize-touch=${options.resize.width || "_"}x${options.resize.height || "_"}`);
+      }
+    }
+  }
+
+  if (options.optimize !== undefined) {
+    if (options.optimize.level !== undefined) {
+      args.push(`-${options.optimize.level}`);
+    }
+    if (options.optimize.lossiness !== undefined) {
+      args.push(`--lossy=${options.optimize.lossiness}`);
+    }
+  }
+
+  const { stdout } = await execa(gifsicleWrapper.path, args, {
+    encoding: null,
+    input,
+  });
+
+  return stdout;
+}
+
+/**
+ * Save the result in a file.
+ *
+ * @param {String} [fileOut]
+ */
+export async function toFile(this: Gifsicle, fileOut: string) {
+  writeFileSync(fileOut, await processFile(this.input, this.options));
+}
+
+/**
+ * Get the result file as a Buffer.
+ *
+ * @returns {Buffer}
+ */
+export async function toBuffer(this: Gifsicle) {
+  return processFile(this.input, this.options);
+}

package/src/core/resize.ts

@@ -0,0 +1,182 @@
+import sizeOf from "image-size";
+import { Gifsicle } from "../gifsicle.js";
+
+/**
+ * Reduction kernels.
+ */
+/* eslint-disable no-unused-vars */
+export enum ReductionKernel {
+  sample = "sample",
+  mix = "mix",
+  catrom = "catrom",
+  mitchell = "mitchell",
+  lanczos2 = "lanczos2",
+  lanczos3 = "lanczos3",
+}
+/* eslint-enable no-unused-vars */
+
+/**
+ * Position modes for cropping.
+ */
+/* eslint-disable no-unused-vars */
+export enum CroppingPosition {
+  center = "center",
+  top = "top",
+  right = "right",
+  bottom = "bottom",
+  left = "left",
+  topRight = "topRight",
+  bottomRight = "bottomRight",
+  bottomLeft = "bottomLeft",
+  topLeft = "topLeft",
+}
+/* eslint-enable no-unused-vars */
+
+/**
+ * Resize options.
+ */
+export type ResizeOptions = {
+  kernel: ReductionKernel | undefined;
+  withoutEnlargement: boolean | undefined;
+};
+
+/**
+ * Cropping options.
+ */
+export type CroppingOptions = {
+  position: CroppingPosition | undefined;
+};
+
+/**
+ * Resize image to `width`, `height` or `width x height`.
+ *
+ * @param {Number} [width] - pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
+ * @param {Number} [height] - pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
+ * @param {Object} [options]
+ * @param {ReductionKernel} [options.kernel=ReductionKernel.lanczos3] - the kernel to use for image reduction.
+ * @param {Boolean} [options.withoutEnlargement=false] - do not enlarge if the width *or* height are already less than the specified dimensions, equivalent to GraphicsMagick's `>` geometry option. *
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function resize(
+  this: Gifsicle,
+  width: number | undefined,
+  height: number | undefined,
+  options: ResizeOptions | undefined
+): Gifsicle {
+  // Default options
+  this.options.resize = { kernel: ReductionKernel.lanczos3, withoutEnlargement: false };
+
+  // Process parameters
+  if (width !== undefined) {
+    if (Number.isInteger(width) && width > 0) {
+      this.options.resize.width = width;
+    } else {
+      throw new TypeError("Expected 'width' to be a positive integer");
+    }
+  }
+  if (height !== undefined) {
+    if (Number.isInteger(height) && height > 0) {
+      this.options.resize.height = height;
+    } else {
+      throw new TypeError("Expected 'height' to be a positive integer");
+    }
+  }
+  if (options !== undefined) {
+    // Kernel
+    if (options.kernel !== undefined) {
+      this.options.resize.kernel = options.kernel;
+    }
+    // Without enlargement
+    if (options.withoutEnlargement !== undefined) {
+      this.options.resize.withoutEnlargement = options.withoutEnlargement;
+    }
+  }
+  return this;
+}
+
+/**
+ * Crop the image to `width x height`.
+ *
+ * @param {number} [width] - pixels wide the resultant image should be.
+ * @param {number} [height] - pixels high the resultant image should be.
+ * @param {Object} [options]
+ * @param {CroppingPosition} [options.position=CroppingPosition.center] - position of the cropping rectangle.
+ * @returns {Gifsicle}
+ * @throws {TypeError} Invalid parameters
+ */
+export function crop(this: Gifsicle, width: number, height: number, options: CroppingOptions | undefined): Gifsicle {
+  // Default options
+  this.options.crop = { width: 0, height: 0, position: CroppingPosition.center };
+
+  // Process parameters
+  if (Number.isInteger(width) && width > 0) {
+    this.options.crop.width = width;
+  } else {
+    throw new TypeError("Expected 'width' to be a positive integer");
+  }
+  if (Number.isInteger(height) && height > 0) {
+    this.options.crop.height = height;
+  } else {
+    throw new TypeError("Expected 'height' to be a positive integer");
+  }
+  if (options !== undefined) {
+    // Position
+    if (options.position !== undefined) {
+      this.options.crop.position = options.position;
+    }
+  }
+  return this;
+}
+
+export function computeCroppingPoint(
+  input: Buffer,
+  crop: { width: number; height: number; position: CroppingPosition }
+): { x: number; y: number } {
+  const size = sizeOf(input);
+  if (size.width === undefined || size.height === undefined) {
+    throw new Error("Can't compute the image size");
+  }
+
+  let px = 0;
+  let py = 0;
+  switch (crop.position) {
+    case CroppingPosition.center:
+      px = Math.floor((size.width - crop.width) / 2);
+      py = Math.floor((size.height - crop.height) / 2);
+      break;
+    case CroppingPosition.top:
+      px = Math.floor((size.width - crop.width) / 2);
+      py = 0;
+      break;
+    case CroppingPosition.right:
+      px = size.width - crop.width;
+      py = Math.floor((size.height - crop.height) / 2);
+      break;
+    case CroppingPosition.bottom:
+      px = Math.floor((size.width - crop.width) / 2);
+      py = size.height - crop.height;
+      break;
+    case CroppingPosition.left:
+      px = 0;
+      py = Math.floor((size.height - crop.height) / 2);
+      break;
+    case CroppingPosition.topRight:
+      px = size.width - crop.width;
+      py = 0;
+      break;
+    case CroppingPosition.bottomRight:
+      px = size.width - crop.width;
+      py = size.height - crop.height;
+      break;
+    case CroppingPosition.bottomLeft:
+      px = 0;
+      py = size.height - crop.height;
+      break;
+    case CroppingPosition.topLeft:
+      px = 0;
+      py = 0;
+      break;
+  }
+  return { x: px, y: py };
+}

package/src/gifsicle.ts

@@ -0,0 +1,33 @@
+import { grayscale, greyscale } from "./core/color.js";
+import { readFile } from "./core/input.js";
+import { OptimizeOptions, optimize } from "./core/optimize.js";
+import { toBuffer, toFile } from "./core/output.js";
+import { CroppingPosition, ReductionKernel, crop, resize } from "./core/resize.js";
+
+export interface GifsicleInternalOptions {
+  greyscale?: boolean;
+  resize?: { width?: number; height?: number; kernel: ReductionKernel; withoutEnlargement: boolean };
+  crop?: { width: number; height: number; position: CroppingPosition };
+  optimize?: OptimizeOptions;
+}
+
+/**
+ * Export Gifsicle class.
+ */
+export class Gifsicle {
+  options: GifsicleInternalOptions;
+  input: Buffer;
+
+  constructor(input: string | Buffer) {
+    this.input = readFile(input);
+    this.options = {};
+  }
+
+  public greyscale = greyscale;
+  public grayscale = grayscale;
+  public resize = resize;
+  public crop = crop;
+  public optimize = optimize;
+  public toFile = toFile;
+  public toBuffer = toBuffer;
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+import { OptimizationLevel } from "./core/optimize.js";
+import { CroppingPosition, ReductionKernel } from "./core/resize.js";
+import { Gifsicle } from "./gifsicle.js";
+
+function gifsicle(input: string | Buffer): Gifsicle {
+  return new Gifsicle(input);
+}
+
+gifsicle.kernel = ReductionKernel;
+gifsicle.position = CroppingPosition;
+gifsicle.level = OptimizationLevel;
+
+export default gifsicle;

package/src/install.ts

@@ -0,0 +1,51 @@
+import { execa } from "execa";
+import { mkdir, rm } from "fs/promises";
+import process from "process";
+import { x as extract } from "tar";
+import { temporaryFile } from "tempy";
+import { gifsicleSourcePath, gifsicleWrapper } from "./wrapper.js";
+
+async function buildFromSource(file: string, cmd: Array<string>): Promise<void> {
+  const temporary = temporaryFile();
+  console.log(`use the temporary folder : ${temporary}`);
+  await mkdir(temporary, { recursive: true });
+
+  await extract({ file: file, cwd: temporary, strip: 1 });
+
+  for (const x of cmd) {
+    await execa(x, { cwd: temporary, shell: true });
+  }
+
+  await rm(temporary, { recursive: true });
+}
+
+(async () => {
+  try {
+    await gifsicleWrapper.run(["--version"]);
+    console.log("gifsicle pre-build test passed successfully");
+  } catch (error) {
+    if (error instanceof Error) {
+      console.warn(error.message);
+    }
+    console.warn("gifsicle pre-build test failed");
+    console.info("compiling from source");
+
+    try {
+      const source = gifsicleSourcePath;
+      const destination = gifsicleWrapper.dest;
+      await buildFromSource(source, [
+        "autoreconf -ivf",
+        `./configure --disable-gifview --disable-gifdiff --prefix="${destination}" --bindir="${destination}"`,
+        "make install",
+      ]);
+
+      console.log("gifsicle built successfully");
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(error.stack);
+      }
+
+      process.exit(1);
+    }
+  }
+})();

package/src/toolbox/is-gif.ts

@@ -0,0 +1,9 @@
+// Based on isGif function from https://github.com/sindresorhus/is-gif
+// https://github.com/sindresorhus/is-gif/blob/main/index.js
+export function isGif(buffer: Buffer) {
+  if (!buffer || buffer.length < 3) {
+    return false;
+  }
+
+  return buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46;
+}

package/src/wrapper.ts

@@ -0,0 +1,16 @@
+import BinWrapper from "@lesjoursfr/bin-wrapper";
+import { platform } from "process";
+import { fileURLToPath } from "url";
+
+const version = "1.94";
+const base = `https://raw.githubusercontent.com/lesjoursfr/gifsicle-wrapper/main/vendor/v${version}`;
+
+export const gifsicleWrapper = new BinWrapper({ strip: 0 });
+gifsicleWrapper.addSrc(`${base}/linux/x64/gifsicle.tar.gz`, "linux", "x64");
+gifsicleWrapper.setDest(fileURLToPath(new URL("../vendor", import.meta.url)));
+gifsicleWrapper.setUse(platform === "win32" ? "gifsicle.exe" : "gifsicle");
+gifsicleWrapper.setVersion(`>=${version}`);
+
+export const gifsicleSourcePath = fileURLToPath(
+  new URL(`../vendor/v${version}/source/gifsicle.tar.gz`, import.meta.url)
+);