@e-mc/compress 0.0.1

package/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2023 An Pham
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,5 @@
+### @e-mc/compress
+
+### LICENSE
+
+BSD 3-Clause

package/index.d.ts

@@ -0,0 +1,5 @@
+import type { CompressConstructor } from '../types/lib';
+
+declare const Compress: CompressConstructor;
+
+export = Compress;

package/index.js

@@ -0,0 +1,626 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const stream = require("stream");
+const zlib = require("zlib");
+const wawoff2 = require("wawoff2");
+const { toSfnt, toWoff } = require('woff2sfnt-sfnt2woff');
+const types_1 = require("../types");
+const lib_v4_1 = require("../module/lib-v4");
+const module_1 = require("../module");
+const CACHE_FONT = {};
+const CACHE_FONTFROM = {};
+const CACHE_FONTTO = {};
+const CACHE_TINIFY = {};
+let SINGLETON_INSTANCE;
+let CACHE_INIT = false;
+let TEMP_DIR = '';
+const GZIP_ZOPFLI = (function () {
+    try {
+        return require('node-zopfli');
+    }
+    catch {
+    }
+    return null;
+})();
+function setCacheData() {
+    if (!CACHE_INIT) {
+        TEMP_DIR = this.getTempDir({ moduleDir: true, createDir: true, increment: 5 });
+        const settings = this.settings;
+        const expires = (0, types_1.parseExpires)(settings.cache_expires || 0);
+        if (expires === 0) {
+            settings.cache_expires = 0;
+        }
+        if (TEMP_DIR) {
+            if (expires === 0) {
+                module_1.default.removeDir(TEMP_DIR, true);
+            }
+            else {
+                const current = Date.now();
+                (function recurse(paths) {
+                    const srcDir = path.join(TEMP_DIR, ...paths);
+                    try {
+                        fs.readdirSync(srcDir, { withFileTypes: true }).forEach(item => {
+                            const filename = item.name;
+                            if (item.isFile()) {
+                                const pathname = path.join(srcDir, filename);
+                                try {
+                                    if (fs.lstatSync(pathname).atimeMs + expires > current) {
+                                        CACHE_FONT[paths.concat(filename).join('_')] = pathname;
+                                        CACHE_FONTFROM[filename] = paths[0];
+                                        CACHE_FONTTO[filename] = paths[1];
+                                        return;
+                                    }
+                                }
+                                catch {
+                                }
+                                removeFile(pathname);
+                            }
+                            else if (item.isDirectory()) {
+                                recurse(paths.concat(filename));
+                            }
+                        });
+                    }
+                    catch {
+                    }
+                })([]);
+            }
+        }
+        CACHE_INIT = true;
+    }
+    return true;
+}
+const removeFile = (pathname) => fs.unlink(pathname, () => { });
+const checkChunkSize = (value) => typeof value === 'number' && value > 0 && value % 1024 === 0;
+class Compress extends module_1.default {
+    static singleton() {
+        if (!SINGLETON_INSTANCE) {
+            SINGLETON_INSTANCE = new Compress();
+            Object.defineProperty(SINGLETON_INSTANCE, "_logEnabled", { value: false, enumerable: true, writable: false });
+            Object.defineProperty(SINGLETON_INSTANCE, "_logFlushed", { value: true, enumerable: true, writable: false });
+            Object.defineProperty(SINGLETON_INSTANCE, "host", { set(value) { }, get() { return null; } });
+        }
+        return SINGLETON_INSTANCE;
+    }
+    constructor(module = {}) {
+        super();
+        this.module = module;
+        this.level = {
+            gz: 9,
+            br: 11,
+            zopfli: 15
+        };
+        this.compressors = {};
+        this._moduleName = 'compress';
+    }
+    init(...args) {
+        let { gzip_level, brotli_quality, zopfli_iterations, chunk_size } = (0, types_1.isPlainObject)(args[0]) && args[0].settings || this.settings;
+        if (gzip_level !== undefined && (gzip_level = Math.floor(+gzip_level)) >= -1 && gzip_level <= 9) {
+            this.level.gz = Math.floor(gzip_level);
+        }
+        if (brotli_quality !== undefined && (brotli_quality = Math.floor(+brotli_quality)) >= 0 && brotli_quality <= 11) {
+            this.level.br = brotli_quality;
+        }
+        if (zopfli_iterations && (zopfli_iterations = Math.floor(+zopfli_iterations)) > 0) {
+            this.level.zopfli = zopfli_iterations;
+        }
+        if (chunk_size && checkChunkSize(chunk_size = +chunk_size)) {
+            this.chunkSize = chunk_size;
+        }
+        return this;
+    }
+    register(format, callback, level) {
+        this.compressors[format = format.toLowerCase()] = callback;
+        if (level !== undefined) {
+            this.level[format] = level;
+        }
+    }
+    getLevel(value, fallback) {
+        const result = this.level[value = value.toLowerCase()] ?? this.level[value = path.extname(value).substring(1)];
+        if (!isNaN(result)) {
+            return result;
+        }
+        if (fallback !== undefined) {
+            return fallback;
+        }
+        switch (value) {
+            case 'gz':
+                return zlib.constants.Z_DEFAULT_LEVEL;
+            case 'br':
+                return zlib.constants.BROTLI_DEFAULT_QUALITY;
+        }
+    }
+    getReadable(file) {
+        return file instanceof Buffer ? stream.Readable.from(file) : fs.createReadStream(file);
+    }
+    createGzip(file, options) {
+        let algorithm, level, chunkSize;
+        if (options) {
+            ({ algorithm, level, chunkSize } = options);
+        }
+        if (algorithm === 'zopfli') {
+            if (GZIP_ZOPFLI) {
+                const zopfli = (0, types_1.isPlainObject)(this.module.zopfli) ? { ...this.module.zopfli } : {};
+                if (typeof level === 'number') {
+                    zopfli.numiterations = level;
+                }
+                else {
+                    zopfli.numiterations ?? (zopfli.numiterations = this.level.zopfli);
+                }
+                return this.getReadable(file).pipe(GZIP_ZOPFLI.createGzip(zopfli));
+            }
+            level = undefined;
+        }
+        let gzip = this.module.gzip;
+        gzip = (0, types_1.isPlainObject)(gzip) ? { ...gzip } : {};
+        if (typeof level === 'number') {
+            gzip.level = level;
+        }
+        else {
+            gzip.level ?? (gzip.level = this.level.gz);
+        }
+        if (checkChunkSize(chunkSize)) {
+            gzip.chunkSize = chunkSize;
+        }
+        else {
+            gzip.chunkSize ?? (gzip.chunkSize = this.chunkSize);
+        }
+        return this.getReadable(file).pipe(zlib.createGzip(gzip));
+    }
+    createBrotliCompress(file, options) {
+        let level, chunkSize, mimeType;
+        if (options) {
+            ({ level, chunkSize, mimeType } = options);
+        }
+        const params = { [zlib.constants.BROTLI_PARAM_QUALITY]: level ?? this.level.br };
+        let brotli = this.module.brotli;
+        if ((0, types_1.isPlainObject)(brotli)) {
+            brotli = (0, types_1.isPlainObject)(brotli.params) ? { ...brotli, params: Object.assign(params, brotli.params) } : { ...brotli, params };
+        }
+        else {
+            brotli = { params };
+        }
+        params[zlib.constants.BROTLI_PARAM_MODE] = (mimeType || (mimeType = '')).includes('text/') ? zlib.constants.BROTLI_MODE_TEXT : mimeType.includes('font/') ? zlib.constants.BROTLI_MODE_FONT : zlib.constants.BROTLI_MODE_GENERIC;
+        params[zlib.constants.BROTLI_PARAM_SIZE_HINT] = (0, lib_v4_1.byteLength)(file);
+        if (checkChunkSize(chunkSize)) {
+            brotli.chunkSize = chunkSize;
+        }
+        else {
+            brotli.chunkSize ?? (brotli.chunkSize = this.chunkSize);
+        }
+        return this.getReadable(file).pipe(zlib.createBrotliCompress(brotli));
+    }
+    createWriteStreamAsGzip(file, output, options) {
+        return this.createGzip(file, options).pipe(fs.createWriteStream(output));
+    }
+    createWriteStreamAsBrotli(file, output, options) {
+        return this.createBrotliCompress(file, options).pipe(fs.createWriteStream(output));
+    }
+    tryFile(file, output, config, callback) {
+        if (typeof config === 'function') {
+            callback = config;
+            config = undefined;
+        }
+        if ((0, types_1.isObject)(output)) {
+            config = output;
+            output = '';
+        }
+        if (!(0, types_1.isString)(output)) {
+            output = typeof file === 'string' ? file : '';
+        }
+        config || (config = {});
+        const { filename, startTime = process.hrtime(), timeout = 0, sessionId, broadcastId } = config;
+        let format = config.format;
+        if (!(0, types_1.isString)(format)) {
+            return Promise.reject((0, types_1.errorValue)('Missing option "format"', output || filename));
+        }
+        let hash = config.etag;
+        const cache = this.settings.cache ? !!(hash && (hash = module_1.default.asHash(hash)) || Buffer.isBuffer(file) && (hash = module_1.default.asHash(file))) : false;
+        return new Promise((resolve, reject) => {
+            let timer = null, aborted;
+            const endProcess = (err, data = null, ext, result, fromCache) => {
+                if (timer) {
+                    clearTimeout(timer);
+                }
+                if (err) {
+                    if (typeof callback === 'function') {
+                        callback(err);
+                        resolve(null);
+                    }
+                    else {
+                        reject(err);
+                    }
+                }
+                else {
+                    if (!fromCache) {
+                        this.writeTimeProcess(ext || format, (0, types_1.isString)(result) ? path.basename(result) : filename || 'Completed', startTime, { type: 8 /* LOG_TYPE.COMPRESS */, sessionId, broadcastId });
+                    }
+                    if (callback) {
+                        callback(null, result || data, ext);
+                    }
+                    resolve(data);
+                }
+            };
+            const startProcess = (compressing) => {
+                if (timeout > 0) {
+                    timer = setTimeout(() => {
+                        aborted = true;
+                        endProcess((0, types_1.errorValue)("Timeout was exceeded" /* ERR_MESSAGE.TIMEOUT */, format));
+                    }, timeout);
+                }
+                this.formatMessage(8 /* LOG_TYPE.COMPRESS */, format, [compressing ? 'Compressing file...' : 'Decompressing file...', filename || (output ? path.basename(output) : '')], (0, types_1.isString)(file) ? file : '', { titleColor: 'magenta', sessionId, broadcastId });
+            };
+            try {
+                const writeFont = (data, ext, from) => {
+                    if (output) {
+                        const pathname = (0, types_1.renameExt)(output, ext);
+                        fs.writeFile(pathname, data, err => {
+                            if (!err) {
+                                endProcess(null, data, ext, pathname);
+                            }
+                            else {
+                                endProcess(err);
+                            }
+                        });
+                    }
+                    else {
+                        endProcess(null, data, ext);
+                    }
+                    if (cache) {
+                        const pathname = path.join(from, ext);
+                        let tempFont;
+                        if (TEMP_DIR && module_1.default.createDir(tempFont = path.join(TEMP_DIR, pathname))) {
+                            tempFont = path.join(tempFont, hash);
+                        }
+                        else {
+                            tempFont = this.getTempDir({ pathname, filename: hash, moduleDir: true, createDir: true });
+                        }
+                        fs.writeFile(tempFont, data, err => {
+                            if (!err) {
+                                CACHE_FONT[from + '_' + ext + '_' + hash] = tempFont;
+                                CACHE_FONTTO[hash] = ext;
+                            }
+                        });
+                    }
+                };
+                const hasFont = () => {
+                    let from, to;
+                    if (cache && (CACHE_INIT || setCacheData.call(this)) && (from = CACHE_FONTFROM[hash]) && (to = CACHE_FONTTO[hash])) {
+                        const cacheKey = from + `_${to}_` + hash;
+                        const tempFont = CACHE_FONT[cacheKey];
+                        if (tempFont) {
+                            if (module_1.default.isPath(tempFont)) {
+                                try {
+                                    const data = fs.readFileSync(tempFont);
+                                    let pathname;
+                                    if (output) {
+                                        fs.writeFileSync(pathname = (0, types_1.renameExt)(output, to), data);
+                                        endProcess(null, data, to, pathname, true);
+                                    }
+                                    else {
+                                        endProcess(null, data, to, '', true);
+                                    }
+                                    this.formatMessage(8 /* LOG_TYPE.COMPRESS */, from, [pathname ? path.basename(pathname) : `Completed -> font/${to}`, 'cache'], tempFont, { ...module_1.default.LOG_STYLE_NOTICE, hintBold: true, sessionId, broadcastId });
+                                    return true;
+                                }
+                                catch {
+                                }
+                            }
+                            delete CACHE_FONT[cacheKey];
+                        }
+                        return false;
+                    }
+                };
+                const errorResponse = (font) => endProcess((0, types_1.errorValue)('Invalid MIME', (font ? font.mime : "Unknown" /* ERR_MESSAGE.UNKNOWN */) + ': ' + (output || filename || "Unknown" /* ERR_MESSAGE.UNKNOWN */)));
+                const data = Buffer.isBuffer(file) ? file : fs.readFileSync(file);
+                switch (format = format.toLowerCase()) {
+                    case 'gz':
+                    case 'br': {
+                        startProcess(true);
+                        let transform, chunks;
+                        if (output) {
+                            transform = this[format === 'gz' ? 'createWriteStreamAsGzip' : 'createWriteStreamAsBrotli'](data, output, config);
+                        }
+                        else {
+                            chunks = [];
+                            transform = this[format === 'gz' ? 'createGzip' : 'createBrotliCompress'](data, config).on('data', chunk => chunks.push(chunk));
+                        }
+                        transform
+                            .on('finish', () => {
+                            if (!aborted) {
+                                endProcess(null, chunks && Buffer.concat(chunks), format, output);
+                            }
+                        })
+                            .on('error', err => {
+                            aborted = true;
+                            endProcess(err);
+                        });
+                        break;
+                    }
+                    case 'ttf':
+                    case 'otf': {
+                        if (hasFont()) {
+                            return;
+                        }
+                        startProcess(false);
+                        const checkResult = (result, from) => {
+                            module_1.default.resolveMime(result).then(font => {
+                                switch (font?.mime) {
+                                    case 'font/ttf':
+                                    case 'font/otf':
+                                        writeFont(result, font.ext, from);
+                                        break;
+                                    default:
+                                        errorResponse(font);
+                                        break;
+                                }
+                            });
+                        };
+                        module_1.default.resolveMime(data).then(font => {
+                            try {
+                                switch (font?.mime) {
+                                    case 'font/woff':
+                                        if (cache) {
+                                            CACHE_FONTFROM[hash] = 'woff';
+                                        }
+                                        checkResult(toSfnt(data), 'woff');
+                                        break;
+                                    case 'font/woff2':
+                                        if (cache) {
+                                            CACHE_FONTFROM[hash] = 'woff2';
+                                        }
+                                        wawoff2.decompress(data).then(woff => checkResult(woff, 'woff2'));
+                                        break;
+                                    default:
+                                        errorResponse(font);
+                                        break;
+                                }
+                            }
+                            catch (err) {
+                                endProcess(err);
+                            }
+                        });
+                        break;
+                    }
+                    case 'woff':
+                    case 'woff2': {
+                        if (hasFont()) {
+                            return;
+                        }
+                        const checkResult = (result, mimeType, from) => {
+                            module_1.default.resolveMime(result).then(font => {
+                                if (font?.mime === mimeType) {
+                                    writeFont(result, font.ext, from);
+                                }
+                                else {
+                                    errorResponse(font);
+                                }
+                            });
+                        };
+                        startProcess(true);
+                        module_1.default.resolveMime(data).then(font => {
+                            try {
+                                switch (font?.mime) {
+                                    case 'font/ttf':
+                                        if (cache) {
+                                            CACHE_FONTFROM[hash] = 'ttf';
+                                        }
+                                        wawoff2.compress(data).then(result => checkResult(result, 'font/woff2', 'ttf'));
+                                        break;
+                                    case 'font/otf':
+                                        if (cache) {
+                                            CACHE_FONTFROM[hash] = 'otf';
+                                        }
+                                        checkResult(toWoff(data), 'font/woff', 'otf');
+                                        break;
+                                    default:
+                                        errorResponse(font);
+                                        break;
+                                }
+                            }
+                            catch (err) {
+                                endProcess(err);
+                            }
+                        });
+                        break;
+                    }
+                    default: {
+                        const compressor = this.compressors[format]?.bind(this);
+                        if (typeof compressor === 'function') {
+                            startProcess(true);
+                            if (compressor.toString().startsWith('async')) {
+                                compressor.call(this, file, output, config)
+                                    .then(result => {
+                                    if (typeof result === 'string') {
+                                        endProcess(null, null, format, result);
+                                    }
+                                    else {
+                                        endProcess(null, result, format);
+                                    }
+                                })
+                                    .catch(err => endProcess(err));
+                            }
+                            else {
+                                compressor.call(this, file, output, config, endProcess);
+                            }
+                        }
+                        else {
+                            throw (0, types_1.errorValue)('Missing compression plugin', format);
+                        }
+                        break;
+                    }
+                }
+            }
+            catch (err) {
+                endProcess(err);
+            }
+        });
+    }
+    tryImage(file, output, config, callback) {
+        if (typeof config === 'function') {
+            callback = config;
+            config = undefined;
+        }
+        if ((0, types_1.isObject)(output)) {
+            config = output;
+            output = '';
+        }
+        else {
+            config || (config = {});
+        }
+        const { plugin = 'tinify', filename, startTime = process.hrtime(), timeout = 0, proxyUrl, sessionId, broadcastId } = config;
+        if (!(0, types_1.isString)(output)) {
+            output = typeof file === 'string' ? file : '';
+        }
+        const ext = output ? path.extname(output).substring(1) : config.format || "Unknown" /* ERR_MESSAGE.UNKNOWN */;
+        const format = config.format || ext;
+        this.formatMessage(8 /* LOG_TYPE.COMPRESS */, ext, ['Compressing image...', plugin], filename || output, { titleColor: 'magenta', sessionId, broadcastId });
+        return new Promise((resolve, reject) => {
+            let timer = null, aborted, apiKey;
+            const failed = (err) => {
+                aborted = true;
+                if (timer) {
+                    clearTimeout(timer);
+                }
+                if (typeof callback === 'function') {
+                    callback(err, null);
+                    resolve(null);
+                }
+                else {
+                    reject(err);
+                }
+            };
+            const success = (result) => {
+                if (aborted) {
+                    return;
+                }
+                if (timer) {
+                    clearTimeout(timer);
+                }
+                const complete = (err) => {
+                    const value = output ? path.basename(output) : filename;
+                    this.writeTimeProcess(ext, value ? plugin + '@' + value : 'Completed', startTime, { type: 8 /* LOG_TYPE.COMPRESS */, sessionId, broadcastId });
+                    if (callback) {
+                        callback(err, result);
+                    }
+                    resolve(result);
+                };
+                if (output) {
+                    fs.writeFile(output, result, err => complete(err));
+                }
+                else {
+                    complete(null);
+                }
+            };
+            const getFormat = () => output ? path.basename(output) : ext;
+            if (plugin === 'tinify') {
+                switch (format) {
+                    case 'png':
+                    case 'jpg':
+                    case 'jpeg':
+                    case 'webp':
+                        apiKey = config.options?.apiKey || (module_1.default.enabled("process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */) ? process.env.TINIFY_KEY : '');
+                        break;
+                    default:
+                        failed((0, types_1.errorMessage)(plugin, 'Unsupported MIME', format));
+                        return;
+                }
+                if (!(0, types_1.isString)(apiKey)) {
+                    failed((0, types_1.errorMessage)(plugin, 'Missing API key'));
+                    return;
+                }
+                switch (module_1.default.lookupMime(ext)) {
+                    case 'image/jpeg':
+                    case 'image/png':
+                    case 'image/webp':
+                        break;
+                    default:
+                        failed((0, types_1.errorMessage)(plugin, 'Unsupported format', getFormat()));
+                        return;
+                }
+            }
+            if (timeout > 0) {
+                timer = setTimeout(() => failed((0, types_1.errorMessage)(plugin, "Timeout was exceeded" /* ERR_MESSAGE.TIMEOUT */)), timeout);
+            }
+            let data;
+            try {
+                data = Buffer.isBuffer(file) ? file : fs.readFileSync(file);
+            }
+            catch (err) {
+                failed(err);
+                return;
+            }
+            if (apiKey) {
+                const apiProxy = proxyUrl && (typeof proxyUrl === 'function' ? proxyUrl("https://api.tinify.com" /* VALUES.TINIFY_API_ENDPOINT */) : proxyUrl) || this.module.tinify?.proxy || module_1.default.enabled("process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */) && process.env.TINIFY_PROXY || '';
+                const cacheKey = apiKey + apiProxy;
+                let tinypng = CACHE_TINIFY[cacheKey];
+                const validate = () => {
+                    tinypng = require('tinify');
+                    tinypng.key = apiKey;
+                    if (apiProxy) {
+                        tinypng.proxy = apiProxy;
+                    }
+                    tinypng.validate(err => {
+                        if (!err) {
+                            fromBuffer();
+                            CACHE_TINIFY[cacheKey] = tinypng;
+                        }
+                        else {
+                            if (err instanceof tinypng.AccountError) {
+                                delete CACHE_TINIFY[cacheKey];
+                            }
+                            failed(err);
+                        }
+                    });
+                };
+                const fromBuffer = (cache) => {
+                    tinypng.fromBuffer(data).toBuffer((err, result) => {
+                        if (!err && result) {
+                            success(result);
+                        }
+                        else if (cache) {
+                            delete CACHE_TINIFY[cacheKey];
+                            validate();
+                        }
+                        else {
+                            failed(err || new Error("Unknown" /* ERR_MESSAGE.UNKNOWN */));
+                        }
+                    });
+                };
+                if (!tinypng) {
+                    validate();
+                }
+                else {
+                    fromBuffer(true);
+                }
+            }
+            else {
+                try {
+                    const transform = require(plugin);
+                    transform(config.options)(data).then(result => {
+                        if (result !== data) {
+                            success(result);
+                        }
+                        else {
+                            failed((0, types_1.errorMessage)(plugin, 'Unsupported MIME', getFormat()));
+                        }
+                    });
+                }
+                catch (err) {
+                    failed(err);
+                }
+            }
+        });
+    }
+    get settings() {
+        var _a;
+        return (_a = this.module).settings || (_a.settings = {});
+    }
+}
+exports.default = Compress;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@e-mc/compress",
+  "version": "0.0.1",
+  "description": "Compress constructor for e-mc.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/e-mc.git",
+    "directory": "src/compress"
+  },
+  "keywords": [
+    "squared",
+    "squared-functions"
+  ],
+  "author": {
+    "name": "An Pham",
+    "email": "anpham6@gmail.com"
+  },
+  "license": "BSD 3-Clause",
+  "homepage": "https://github.com/anpham6/e-mc#readme",
+  "dependencies": {
+    "@e-mc/module": "0.0.1",
+    "@e-mc/types": "0.0.1",
+    "tinify": "^1.7.1",
+    "wawoff2": "^2.0.1",
+    "woff2sfnt-sfnt2woff": "^1.0.0"
+  }
+}