@divriots/jampack 0.1.2 → 0.1.4

package/dist/compress.d.ts

@@ -1,4 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
 import sharp from 'sharp';
-import type { Result } from './types.js';
 export declare const compressImage: (data: Buffer, resize: sharp.ResizeOptions) => Promise<Buffer | undefined>;
-export declare function compress(dir: string, initResult: Result[]): Promise<void>;
+export declare function compress(glob: string): Promise<void>;

package/dist/compress.js

@@ -4,79 +4,28 @@ import { optimize as svgo } from "svgo";
 import { minify as htmlminifier } from 'html-minifier-terser';
 import { minify as csso } from "csso";
 import { formatBytes } from './utils.js';
-import { table } from 'table';
 import sharp from 'sharp';
 import swc from '@swc/core';
-let state;
-let compressedFiles = [];
-const beginProgress = (initResults) => {
-    state = {
-        total: {
-            nbFiles: 0,
-            nbFilesCompressed: 0,
-            dataLenUncompressed: 0,
-            dataLenCompressed: 0
-        },
-        detailsByExtension: {},
-    };
-    initResults.forEach(r => {
-        addProgress(r);
-        compressedFiles.push(r.file);
-    });
+import globalState from './state.js';
+import { globby } from 'globby';
+const beginProgress = () => {
 };
-const addProgress = (r) => {
-    const isCompressed = r.compressedSize < r.originalSize ? 1 : 0;
-    state.total.nbFiles++;
-    state.total.nbFilesCompressed += isCompressed;
-    state.total.dataLenUncompressed += r.originalSize;
-    state.total.dataLenCompressed += r.compressedSize;
-    const ext = path.extname(r.file);
-    if (ext) {
-        var summary = state.detailsByExtension[ext];
-        if (!summary) {
-            summary = {
-                nbFiles: 0,
-                nbFilesCompressed: 0,
-                dataLenUncompressed: 0,
-                dataLenCompressed: 0
-            };
-            state.detailsByExtension[ext] = summary;
-        }
-        summary.nbFiles++;
-        summary.nbFilesCompressed += isCompressed;
-        summary.dataLenUncompressed += r.originalSize;
-        summary.dataLenCompressed += r.compressedSize;
+const printProgress = () => {
+    const gain = globalState.summary.dataLenUncompressed - globalState.summary.dataLenCompressed;
+    const msg = `${globalState.summary.nbFiles} files | ${formatBytes(globalState.summary.dataLenUncompressed)} → ${formatBytes(globalState.summary.dataLenCompressed)} | -${formatBytes(gain)} `;
+    if (!process.stdout.clearLine || !process.stdout.cursorTo) {
+        // In CI we don't have access to clearLine or cursorTo
+        // Just don't log any progress
+    }
+    else {
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        process.stdout.write(msg);
     }
-};
-const printProgress = (r) => {
-    addProgress(r);
-    process.stdout.cursorTo(0);
-    process.stdout.write(`${state.total.nbFiles} files | ${formatBytes(state.total.dataLenUncompressed)} → ${formatBytes(state.total.dataLenCompressed)}`);
 };
 const endProgress = () => {
     process.stdout.write('\n');
 };
-const printDetails = () => {
-    const dataTable = [['Extension', 'Files', 'Compressed', 'Original', 'Compressed', 'Gain']];
-    const config = {
-        columns: [
-            { alignment: 'left' },
-            { alignment: 'right' },
-            { alignment: 'right' },
-            { alignment: 'right' },
-            { alignment: 'right' }
-        ],
-    };
-    Object.entries(state.detailsByExtension).forEach(([ext, summary]) => {
-        if (summary.dataLenCompressed < summary.dataLenUncompressed) {
-            const row = [ext, summary.nbFiles, summary.nbFilesCompressed, formatBytes(summary.dataLenUncompressed), formatBytes(summary.dataLenCompressed), '-' + formatBytes(summary.dataLenUncompressed - summary.dataLenCompressed)];
-            dataTable.push(row);
-        }
-    });
-    const total = ['Total', state.total.nbFiles, state.total.nbFilesCompressed, formatBytes(state.total.dataLenUncompressed), formatBytes(state.total.dataLenCompressed), '-' + formatBytes(state.total.dataLenUncompressed - state.total.dataLenCompressed)];
-    dataTable.push(total);
-    console.log(table(dataTable, config));
-};
 const processFile = async (file, stats) => {
     const result = {
         file,
@@ -122,18 +71,21 @@ const processFile = async (file, stats) => {
     }
     catch (e) {
         // console error for the moment
+        console.error(`\n${file}`);
         console.error(e);
     }
     // Writedata
     if (writeData && writeData.length < result.originalSize) {
         result.compressedSize = writeData.length;
-        await fs.writeFile(file, writeData);
+        if (!globalState.args.nowrite) {
+            await fs.writeFile(file, writeData);
+        }
     }
-    printProgress(result);
-    return result;
+    globalState.addFile(result);
+    printProgress();
 };
 export const compressImage = async (data, resize) => {
-    const sharpFile = await sharp(data);
+    const sharpFile = await sharp(data, { animated: true });
     const meta = await sharpFile.metadata();
     switch (meta.format) {
         case 'svg':
@@ -148,7 +100,7 @@ export const compressImage = async (data, resize) => {
         case 'jpeg':
         case 'webp':
         case 'gif':
-            return await sharpFile.resize(resize).toBuffer();
+            return await sharpFile.resize({ ...resize, fit: 'fill', withoutEnlargement: true }).toBuffer();
     }
     return undefined;
 };
@@ -156,26 +108,14 @@ const compressImageFile = async (file) => {
     const buffer = await fs.readFile(file);
     return compressImage(buffer, {});
 };
-const processDirectory = async (directoryPath) => {
-    const filesInDirectory = await fs.readdir(directoryPath);
-    const files = await Promise.all(filesInDirectory.map(async (file) => {
-        const filePath = path.join(directoryPath, file);
-        const stats = await fs.stat(filePath);
-        if (stats.isDirectory()) {
-            return processDirectory(filePath);
-        }
-        else {
-            if (compressedFiles.includes(filePath)) {
-                return [];
-            }
-            return [await processFile(filePath, stats)];
+export async function compress(glob) {
+    beginProgress();
+    const paths = await globby(glob, { cwd: globalState.dir, absolute: true });
+    // "Parallel" processing
+    await Promise.all(paths.map(async (file) => {
+        if (!globalState.compressedFiles.has(file)) {
+            await processFile(file, await fs.stat(file));
         }
     }));
-    return files.filter((file) => file.length).flat(1); // Remove empty dir and flat it all
-};
-export async function compress(dir, initResult) {
-    beginProgress(initResult);
-    await processDirectory(dir);
     endProgress();
-    printDetails();
 }

package/dist/index.js

@@ -2,6 +2,19 @@
 import { Command } from 'commander';
 import { compress } from './compress.js';
 import { optimize } from './optimize.js';
+import kleur from 'kleur';
+import globalState from './state.js';
+import { table } from 'table';
+import { formatBytes } from './utils.js';
+const logo = `     __                                    __    
+    |__|____    _____ ___________    ____ |  | __
+    |  \\__  \\  /     \\\\____ \\__  \\ _/ ___\\|  |/ /
+    |  |/ __ \\|  Y Y  \\  |_> > __ \\\\  \\___|    < 
+/\\__|  (____  /__|_|  /   __(____  /\\___  >__|_ \\
+\\______|    \\/      \\/|  |       \\/     \\/     \\/
+                      |__| by ‹div›RIOTS (c)2022
+`;
+console.log(logo);
 const program = new Command();
 program
     .name('jampack')
@@ -10,11 +23,44 @@ program
 program.command('pack', { isDefault: true })
     .description('todo')
     .argument('<dir>', 'Directory to pack')
-    .action(async (str, options) => {
-    let compressedResults = [];
-    console.log(`PASS 1 - Optimizing...`);
-    compressedResults = await optimize(str);
-    console.log(`PASS 2 - Compressing...`);
-    await compress(str, compressedResults);
+    .option('--nowrite', 'No write')
+    .option('--onlycomp', 'Only compress')
+    .option('--onlyoptim', 'Only optimize')
+    .action(async (dir, options) => {
+    globalState.dir = dir;
+    globalState.args = options;
+    if (!options.onlyoptim && !options.onlycomp) {
+        console.log(kleur.bgGreen(kleur.black(`\n PASS 1 - Compressing embeddables `)));
+        await compress("**/*.{css,svg,js}");
+    }
+    if (!options.onlycomp) {
+        console.log(kleur.bgGreen(kleur.black(`\n PASS 2 - Optimizing `)));
+        await optimize();
+    }
+    if (!options.onlyoptim) {
+        console.log(kleur.bgGreen(kleur.black(`\n PASS 3 - Compressing the rest`)));
+        await compress("**/**");
+    }
+    printDetails();
 });
 program.parse();
+function printDetails() {
+    const dataTable = [['Extension', 'Compressed', 'Original', 'Compressed', 'Gain']];
+    const config = {
+        columns: [
+            { alignment: 'left' },
+            { alignment: 'right' },
+            { alignment: 'right' },
+            { alignment: 'right' }
+        ],
+    };
+    Object.entries(globalState.summaryByExtension).forEach(([ext, summary]) => {
+        if (summary.dataLenCompressed < summary.dataLenUncompressed) {
+            const row = [ext, `${summary.nbFilesCompressed} / ${summary.nbFiles}`, formatBytes(summary.dataLenUncompressed), formatBytes(summary.dataLenCompressed), '-' + formatBytes(summary.dataLenUncompressed - summary.dataLenCompressed)];
+            dataTable.push(row);
+        }
+    });
+    const total = ['Total', `${globalState.summary.nbFilesCompressed} / ${globalState.summary.nbFiles}`, formatBytes(globalState.summary.dataLenUncompressed), formatBytes(globalState.summary.dataLenCompressed), '-' + formatBytes(globalState.summary.dataLenUncompressed - globalState.summary.dataLenCompressed)];
+    dataTable.push(total);
+    console.log(table(dataTable, config));
+}

package/dist/logger.d.ts

@@ -0,0 +1,3 @@
+export declare function info(message: string): void;
+export declare function warn(message: string): void;
+export declare function error(message: string): void;

package/dist/logger.js

@@ -0,0 +1,9 @@
+export function info(message) {
+    console.info(message);
+}
+export function warn(message) {
+    console.warn(message);
+}
+export function error(message) {
+    console.error(message);
+}

package/dist/optimize.d.ts

@@ -1,2 +1 @@
-import type { Result } from './types.js';
-export declare function optimize(dir: string): Promise<Result[]>;
+export declare function optimize(): Promise<void>;

package/dist/optimize.js

@@ -7,11 +7,11 @@ import sharp from "sharp";
 import options from './options.js';
 import { compressImage } from './compress.js';
 import svgToMiniDataURI from 'mini-svg-data-uri';
-const compressedImages = [];
-const compressedResults = [];
-async function analyse(dir, file) {
+import globalState from './state.js';
+import { exit } from 'process';
+async function analyse(file) {
     console.log('Processing ' + file);
-    const html = (await fs.readFile(path.join(dir, file))).toString();
+    const html = (await fs.readFile(path.join(globalState.dir, file))).toString();
     const $ = cheerio.load(html, {});
     const imgs = $('img');
     const imgsArray = [];
@@ -21,138 +21,178 @@ async function analyse(dir, file) {
     // Process images sequentially
     await imgsArray.reduce(async (previousPromise, imgElement) => {
         await previousPromise;
-        return processImage(dir, file, $, imgElement);
+        return processImage(file, $, imgElement);
     }, Promise.resolve());
-    await fs.writeFile(path.join(dir, file), $.html());
-}
-async function processImage(dir, file, $, imgElement) {
-    const img = $(imgElement);
-    /*
-     * Attribute 'alt'
-     */
-    const attrib_alt = img.attr('alt');
-    if (attrib_alt === undefined) {
-        console.warn('<img> has no alt attribute - adding an empty but you should fix it');
-        img.attr('alt', "");
-    }
-    /*
-     * Attribute 'src'
-     */
-    const attrib_src = img.attr('src');
-    console.log(`- Image ${attrib_src}`);
-    if (!attrib_src) {
-        console.warn('<img> has no src attribute');
-        return;
-    }
-    if (attrib_src.startsWith('data:')) {
-        // Data URI image
-        // TODO: try to compress it
-        return;
-    }
-    if (!isLocal(attrib_src)) {
-        // Image not local, don't touch it
-        return;
+    if (!globalState.args.nowrite) {
+        await fs.writeFile(path.join(globalState.dir, file), $.html());
     }
-    /*
-     * Attribute 'loading'
-     */
-    const attr_loading = img.attr('loading');
-    switch (attr_loading) {
-        case undefined:
-            // Go lazy by default
-            img.attr('loading', 'lazy');
-            break;
-        case 'eager':
-            img.removeAttr('loading');
-            break;
-        case 'lazy':
-            // Don't touch it
-            break;
-        default:
-            console.warn(`Invalid loading attribute ${attr_loading}`);
-    }
-    /*
-     * Attribute 'decoding'
-     */
-    img.attr('decoding', 'async');
-    /*
-     * Loading image
-     */
-    const absoluteImgPath = translateSrc(dir, path.dirname(file), attrib_src);
-    // file exists?
+}
+async function processImage(file, $, imgElement) {
     try {
-        const stats = await fs.stat(absoluteImgPath);
-    }
-    catch (e) {
-        console.error(`Missing img ${absoluteImgPath}`);
-        return;
-    }
-    const sharpFile = sharp(absoluteImgPath);
-    const meta = await sharpFile.metadata();
-    const originalData = await fs.readFile(absoluteImgPath);
-    /*
-     * Embed small images
-     *
-     * Note: This check is done pre-compression so more opportunities could
-     * be done if done post compression.
-     */
-    let isEmbed = false;
-    if (originalData.length <= options.image.embed_size) {
-        let datauri = undefined;
-        switch (meta.format) {
-            case 'svg':
-                const compressedData = await compressImage(originalData, {});
-                const svgEmbed = (compressedData && compressedData.length < originalData.length) ? compressedData : originalData;
-                datauri = svgToMiniDataURI(svgEmbed.toString());
+        const img = $(imgElement);
+        /*
+        * Attribute 'alt'
+        */
+        const attrib_alt = img.attr('alt');
+        if (attrib_alt === undefined) {
+            console.warn('<img> has no alt attribute - adding an empty but you should fix it');
+            img.attr('alt', "");
+        }
+        /*
+        * Attribute 'src'
+        */
+        const attrib_src = img.attr('src');
+        console.log(`- Image ${attrib_src}`);
+        if (!attrib_src) {
+            console.warn('<img> has no src attribute');
+            return;
+        }
+        if (attrib_src.startsWith('data:')) {
+            // Data URI image
+            // TODO: try to compress it
+            return;
+        }
+        if (!isLocal(attrib_src)) {
+            // Image not local, don't touch it
+            return;
+        }
+        /*
+        * Attribute 'loading'
+        */
+        const attr_loading = img.attr('loading');
+        switch (attr_loading) {
+            case undefined:
+                // Go lazy by default
+                img.attr('loading', 'lazy');
+                break;
+            case 'eager':
+                img.removeAttr('loading');
                 break;
-            case 'jpg':
-            case 'jpeg':
-            case 'png':
-            case 'webp':
-            case 'gif':
-                // TODO
+            case 'lazy':
+                // Don't touch it
                 break;
+            default:
+                console.warn(`Invalid loading attribute ${attr_loading}`);
         }
-        if (datauri) {
-            img.attr('src', datauri);
-            isEmbed = true;
-            img.removeAttr('loading');
-            img.removeAttr('decoding');
+        /*
+        * Attribute 'decoding'
+        */
+        img.attr('decoding', 'async');
+        /*
+        * Loading image
+        */
+        const absoluteImgPath = translateSrc(globalState.dir, path.dirname(file), attrib_src);
+        // file exists?
+        try {
+            const stats = await fs.stat(absoluteImgPath);
+        }
+        catch (e) {
+            console.error(`Missing img ${absoluteImgPath}`);
+            return;
+        }
+        const sharpFile = sharp(absoluteImgPath);
+        const meta = await sharpFile.metadata();
+        const originalData = await fs.readFile(absoluteImgPath);
+        /*
+        * Embed small images
+        */
+        let isEmbed = false;
+        if (originalData.length <= options.image.embed_size) {
+            let datauri = undefined;
+            switch (meta.format) {
+                case 'svg':
+                    const compressedData = await compressImage(originalData, {});
+                    const svgEmbed = (compressedData && compressedData.length < originalData.length) ? compressedData : originalData;
+                    datauri = svgToMiniDataURI(svgEmbed.toString());
+                    break;
+                case 'jpg':
+                case 'jpeg':
+                case 'png':
+                case 'webp':
+                case 'gif':
+                    // TODO
+                    break;
+            }
+            if (datauri) {
+                isEmbed = true;
+                img.attr('src', datauri);
+                img.removeAttr('loading');
+                img.removeAttr('decoding');
+            }
+        }
+        if (isEmbed) {
+            // Image is embed, no need for more processing
+            return;
+        }
+        /*
+        * Attribute 'width' & 'height'
+        */
+        const [w, h] = setImageSize(img, meta);
+        if (w < 0 || h < 0) {
+            console.warn(`Unexpected error in image size calculation - some optimizations can't be done`);
+            return;
+        }
+        /*
+        * Compress image
+        */
+        if (!globalState.compressedFiles.has(absoluteImgPath)) {
+            // Image not already compressed before
+            const result = {
+                file: absoluteImgPath,
+                originalSize: originalData.length,
+                compressedSize: originalData.length
+            };
+            const newImage = await compressImage(originalData, { width: w, height: h });
+            if (newImage && newImage.length < originalData.length) {
+                if (!globalState.args.nowrite) {
+                    fs.writeFile(absoluteImgPath, newImage);
+                }
+                result.compressedSize = newImage.length;
+            }
+            globalState.addFile(result);
+        }
+        const attr_srcset = img.attr('srcset');
+        if (attr_srcset) {
+            // If srcset is set, don't touch it.
+            // Just compress files
+            // TODO
+        }
+        else {
+            // Generate image set
+            const ext = path.extname(attrib_src);
+            const fullbasename = attrib_src.slice(0, -(ext.length));
+            const imageSrc = (addition) => `${fullbasename}${addition}${ext}`;
+            // Start from original image
+            let new_srcset = '';
+            // Start reduction
+            const step = 300; //px
+            const ratio = w / h;
+            let valueW = w - step;
+            let valueH = Math.trunc(valueW / ratio);
+            while (valueW > options.image.srcset_min_width) {
+                const src = imageSrc(`@${valueW}w`);
+                const absoluteFilename = translateSrc(globalState.dir, path.dirname(file), src);
+                const compressedData = await compressImage(originalData, { width: valueW, height: valueH });
+                if (compressedData && !globalState.args.nowrite) {
+                    fs.writeFile(absoluteFilename, compressedData);
+                }
+                // Add file to list avoid recompression
+                globalState.compressedFiles.add(absoluteFilename);
+                new_srcset += `, ${src} ${valueW}w`;
+                // reduce size
+                valueW -= step;
+                valueH = Math.trunc(valueW / ratio);
+            }
+            if (new_srcset) {
+                img.attr('srcset', `${attrib_src} ${w}w` + new_srcset);
+            }
         }
     }
-    if (isEmbed) {
-        // Image is embed, no need for more processing
-        return;
-    }
-    /*
-     * Attribute 'width' & 'height'
-     */
-    const [w, h] = setImageSize(img, meta);
-    if (w < 0 || h < 0) {
-        console.warn(`Unexpected error in image size calculation - some optimizations can't be done`);
-        return;
-    }
-    /*
-     * Compress image
-     */
-    if (compressedImages.includes(absoluteImgPath)) {
-        // Image already compressed. Skip.
-        return;
-    }
-    const fileWidth = meta.width;
-    const fileHeight = meta.height;
-    const newImage = await compressImage(originalData, { width: w, height: h });
-    if (newImage && newImage.length < originalData.length) {
-        fs.writeFile(absoluteImgPath, newImage);
-        compressedImages.push(absoluteImgPath);
-        compressedResults.push({ file: absoluteImgPath, originalSize: originalData.length, compressedSize: newImage.length });
-    }
-    const attr_srcset = img.attr('srcset');
-    if (attr_srcset) {
-        // If srcset is set, don't touch it
-    }
-    else {
-        // Generate image set
+    catch (e) {
+        console.error('Error while processing image');
+        console.error(e);
+        // exit here until we cover all the issues
+        exit(1);
     }
 }
 function setImageSize(img, meta) {
@@ -169,7 +209,7 @@ function setImageSize(img, meta) {
     }
     if (height !== undefined) {
         if (!isNumeric(height)) {
-            console.warn(`Invalid width attribute "${height}" - overriding`);
+            console.warn(`Invalid height attribute "${height}" - overriding`);
             height = undefined;
         }
     }
@@ -214,12 +254,11 @@ function setImageSize(img, meta) {
     // Something when wrong
     throw new Error('Unexpected issue when resolving image sizes');
 }
-export async function optimize(dir) {
-    const paths = await globby('**/*.{htm,html}', { cwd: dir });
+export async function optimize() {
+    const paths = await globby('**/*.{htm,html}', { cwd: globalState.dir });
     // Sequential async
     await paths.reduce(async (previousPromise, item) => {
         await previousPromise;
-        return analyse(dir, item);
+        return analyse(item);
     }, Promise.resolve());
-    return compressedResults;
 }

package/dist/options.js

@@ -1,7 +1,7 @@
 const default_options = {
     image: {
-        embed_size: 800,
-        srcset_min_width: 640 * 2,
+        embed_size: 0,
+        srcset_min_width: 400,
         srcset_max_width: 5120
     }
 };

package/dist/state.d.ts

@@ -0,0 +1,25 @@
+export declare type Args = {
+    nowrite?: boolean;
+};
+export declare type Result = {
+    file: string;
+    originalSize: number;
+    compressedSize: number;
+};
+export declare type Summary = {
+    nbFiles: number;
+    nbFilesCompressed: number;
+    dataLenUncompressed: number;
+    dataLenCompressed: number;
+};
+export declare class GlobalState {
+    dir: string;
+    args: Args;
+    compressedFiles: Set<string>;
+    compressedFilesResult: Result[];
+    summary: Summary;
+    summaryByExtension: Record<string, Summary>;
+    addFile(r: Result): void;
+}
+declare const state: GlobalState;
+export default state;

package/dist/state.js

@@ -0,0 +1,45 @@
+import path from "path";
+export class GlobalState {
+    constructor() {
+        this.dir = 'dist';
+        this.args = {};
+        this.compressedFiles = new Set();
+        this.compressedFilesResult = [];
+        this.summary = {
+            nbFiles: 0,
+            nbFilesCompressed: 0,
+            dataLenCompressed: 0,
+            dataLenUncompressed: 0
+        };
+        this.summaryByExtension = {};
+    }
+    addFile(r) {
+        const isCompressed = r.compressedSize < r.originalSize ? 1 : 0;
+        this.compressedFiles.add(r.file);
+        this.compressedFilesResult.push(r);
+        this.summary.nbFiles++;
+        state.summary.nbFilesCompressed += isCompressed;
+        state.summary.dataLenUncompressed += r.originalSize;
+        state.summary.dataLenCompressed += r.compressedSize;
+        const ext = path.extname(r.file);
+        if (ext) {
+            let summary = this.summaryByExtension[ext];
+            if (!summary) {
+                summary = {
+                    nbFiles: 0,
+                    nbFilesCompressed: 0,
+                    dataLenUncompressed: 0,
+                    dataLenCompressed: 0
+                };
+                this.summaryByExtension[ext] = summary;
+            }
+            summary.nbFiles++;
+            summary.nbFilesCompressed += isCompressed;
+            summary.dataLenUncompressed += r.originalSize;
+            summary.dataLenCompressed += r.compressedSize;
+        }
+    }
+    ;
+}
+const state = new GlobalState();
+export default state;

package/dist/utils.js

@@ -7,7 +7,7 @@ export function formatBytes(bytes, decimals = 2) {
     const dm = decimals < 0 ? 0 : decimals;
     const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
     const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+    return `${(bytes / Math.pow(k, i)).toFixed(dm)} ${sizes[i]}`;
 }
 export function isLocal(src) {
     const u = url.parse(src);
@@ -18,7 +18,7 @@ export function translateSrc(projectRoot, htmlRelativePath, src) {
         throw new Error('Source should be local');
     }
     const srcAbsolutePath = path.join(projectRoot, src.startsWith('/') ? '' : htmlRelativePath, src);
-    return srcAbsolutePath;
+    return path.resolve(srcAbsolutePath);
 }
 export function isNumeric(value) {
     return /^\d+$/.test(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divriots/jampack",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Packer for static websites",
   "author": "Georges Gomes @georges-gomes",
   "bin": {
@@ -24,11 +24,13 @@
     "@types/sharp": "^0.31.0",
     "@types/svgo": "^2.6.4",
     "@types/table": "^6.3.2",
+    "chalk": "^5.0.1",
     "cheerio": "0.22.0",
     "commander": "^9.4.0",
     "csso": "^5.0.5",
     "globby": "^13.1.2",
     "html-minifier-terser": "^7.0.0",
+    "kleur": "^4.1.5",
     "mini-svg-data-uri": "^1.4.4",
     "sharp": "^0.31.0",
     "svgo": "^2.8.0",

package/dist/types.d.ts

@@ -1,5 +0,0 @@
-export declare type Result = {
-    file: string;
-    originalSize: number;
-    compressedSize: number;
-};

package/dist/types.js

@@ -1 +0,0 @@
-export {};