deboa 1.0.0

package/dist/cjs/utils/createFileHeader.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createFileHeader", {
+    enumerable: true,
+    get: ()=>createFileHeader
+});
+function createFileHeader(options) {
+    const { fileName , ...numericOptions } = options;
+    const { timestamp =String(Math.trunc(new Date().getTime() / 1000)) , ownerID ='0' , groupID ='0' , fileMode ='100644' , fileSize ,  } = numericOptions;
+    if (!fileName) {
+        throw new Error('filename is required');
+    }
+    const maxLengthMap = {
+        fileName: {
+            maxLength: 16,
+            value: fileName
+        },
+        timestamp: {
+            maxLength: 12,
+            value: String(timestamp)
+        },
+        ownerID: {
+            maxLength: 6,
+            value: String(ownerID)
+        },
+        groupID: {
+            maxLength: 6,
+            value: String(groupID)
+        },
+        fileMode: {
+            maxLength: 8,
+            value: String(fileMode)
+        },
+        fileSize: {
+            maxLength: 10,
+            value: String(fileSize)
+        }
+    };
+    const paddedFields = Object.entries(maxLengthMap).map(([optionName, { maxLength , value  }])=>{
+        // checks if the numeric options are correct
+        if (optionName in numericOptions) {
+            const asNumber = +value;
+            if (Number.isNaN(asNumber)) {
+                throw new Error(`The \`${optionName}\` option must be a numeric value`);
+            }
+            if (!Number.isInteger(asNumber)) {
+                throw new Error(`The \`${optionName}\` option must be a integer`);
+            }
+        }
+        // checks if the option length is correct
+        if (value.length > maxLength) {
+            throw new Error(`The \`${optionName}\` option must be at most ${maxLength} characters`);
+        }
+        return value.padEnd(maxLength);
+    });
+    // ending sequence
+    paddedFields.push('`\n');
+    return paddedFields.join('');
+}

package/dist/cjs/utils/writeFileFromLines.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "writeFileFromLines", {
+    enumerable: true,
+    get: ()=>writeFileFromLines
+});
+const _fs = require("fs");
+async function writeFileFromLines({ filePath , lines  }) {
+    const joined = lines.join('\n') + '\n';
+    await _fs.promises.writeFile(filePath, joined);
+}

package/dist/cjs/utils/writeToArchive.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "writeToArchive", {
+    enumerable: true,
+    get: ()=>writeToArchive
+});
+const _createFileHeader = require("./createFileHeader");
+/**
+ * Writes the .ar archive signature. If it's a .deb file,
+ * also writes the `debian-control` file and its header.
+ */ async function writeArchiveHeader({ writeStream , isARFile =false  }) {
+    return new Promise((resolve, reject)=>{
+        const arArchiveSignature = '!<arch>\n';
+        const header = [
+            arArchiveSignature
+        ];
+        // this part is .deb-specific, so we don't need it in plain .ar files
+        if (!isARFile) {
+            const debianBinaryFile = '2.0\n';
+            const debianBinaryIdentifier = (0, _createFileHeader.createFileHeader)({
+                fileName: 'debian-binary',
+                fileSize: debianBinaryFile.length
+            });
+            header.push(debianBinaryIdentifier, debianBinaryFile);
+        }
+        writeStream.write(Buffer.concat(header.map(Buffer.from)), (headerErr)=>{
+            if (headerErr) {
+                reject(`Error writing the archive header: ${headerErr}`);
+            }
+            resolve();
+        });
+    });
+}
+async function writeToArchive({ header , isARFile =false , readStream , writeStream  }) {
+    const shouldWriteArchiveHeader = writeStream.bytesWritten === 0;
+    if (shouldWriteArchiveHeader) {
+        console.log('Writing the archive header...\n');
+        await writeArchiveHeader({
+            writeStream,
+            isARFile
+        });
+        console.log('Archive header successfully written\n');
+    }
+    return new Promise((resolve, reject)=>{
+        const fileNameIdentifier = header.toString('utf-8').slice(0, 16).trim();
+        writeStream.write(header, (identifierErr)=>{
+            console.log(`Writing the identifier header for ${fileNameIdentifier}...\n`);
+            if (identifierErr) {
+                reject(`Error writing the identifier header for ${fileNameIdentifier}: ${identifierErr}`);
+            }
+            console.log(`Identifier header for ${fileNameIdentifier} successfully written\n`);
+            const initialBytesWritten = writeStream.bytesWritten;
+            console.log(`Writing file ${fileNameIdentifier}...\n`);
+            readStream.on('error', (fileError)=>reject(`Error writing file ${fileNameIdentifier}: ${fileError}`));
+            readStream.pipe(writeStream, {
+                end: false
+            });
+            readStream.on('end', ()=>{
+                const readStreamSize = writeStream.bytesWritten - initialBytesWritten;
+                const shouldWritePaddingByte = readStreamSize % 2 !== 0;
+                if (!shouldWritePaddingByte) {
+                    console.log(`File ${fileNameIdentifier} successfully written\n`);
+                    return resolve();
+                }
+                console.log(`Writing padding byte for ${fileNameIdentifier}...\n`);
+                writeStream.write(Buffer.from('\n'), (paddingError)=>{
+                    if (paddingError) {
+                        reject(`Error writing padding byte for ${fileNameIdentifier}: ${identifierErr}`);
+                    }
+                    console.log(`File ${fileNameIdentifier} successfully written\n`);
+                    return resolve();
+                });
+            });
+        });
+    });
+}

package/dist/esm/classes/Deboa.js

@@ -0,0 +1,439 @@
+import { once } from 'events';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import fsExtra from 'fs-extra';
+import { promisify } from 'util';
+import fastFolderSize from 'fast-folder-size';
+import tar from 'tar-fs';
+import { writeFileFromLines } from '../utils/writeFileFromLines';
+import { DeboaFromFile } from './DeboaFromFile';
+import { PassThrough as PassThroughStream } from 'stream';
+import { addTarEntries } from '../utils/addTarEntries';
+/**
+ * @return IDeboa
+ */ class Deboa {
+    /** See {@link IDeboa.additionalTarEntries} */ additionalTarEntries = [];
+    /** See {@link IDeboa.beforeCreateDesktopEntry} */ beforeCreateDesktopEntry = null;
+    /** See {@link IDeboa.beforePackage} */ beforePackage = null;
+    /** See {@link IDeboa.controlFileOptions} */ controlFileOptions = {
+        /** See {@link IDeboa.architecture} */ architecture: null,
+        /** See {@link IDeboa.builtUsing} */ builtUsing: null,
+        /** See {@link IDeboa.conflicts} */ conflicts: null,
+        /** See {@link IDeboa.depends} */ depends: null,
+        /** See {@link IDeboa.essential} */ essential: null,
+        /** See {@link IDeboa.extendedDescription} */ extendedDescription: null,
+        /** See {@link IDeboa.homepage} */ homepage: null,
+        /** See {@link IDeboa.maintainer} */ maintainer: null,
+        /** See {@link IDeboa.maintainerScripts} */ maintainerScripts: {
+            preinst: null,
+            postinst: null,
+            prerm: null,
+            postrm: null
+        },
+        /** See {@link IDeboa.packageName} */ packageName: null,
+        /** See {@link IDeboa.preDepends} */ preDepends: null,
+        /** See {@link IDeboa.priority} */ priority: null,
+        /** See {@link IDeboa.recommends} */ recommends: null,
+        /** See {@link IDeboa.section} */ section: null,
+        /** See {@link IDeboa.shortDescription} */ shortDescription: null,
+        /** See {@link IDeboa.source} */ source: null,
+        /** See {@link IDeboa.suggests} */ suggests: null,
+        /** See {@link IDeboa.version} */ version: null
+    };
+    /** See {@link IDeboa.icon} */ icon = null;
+    /** See {@link IDeboa.modifyTarHeader} */ modifyTarHeader = null;
+    /** See {@link IDeboa.sourceDir} */ sourceDir = null;
+    /** See {@link IDeboa.tarballFormat} */ tarballFormat = null;
+    /** See {@link IDeboa.targetDir} */ targetDir = null;
+    #appFolderDestination = null;
+    #controlFolderDestination = null;
+    #dataFolderDestination = null;
+    #hooksLoaded = false;
+    #outputFile = null;
+    #tempDir = null;
+    constructor(options){
+        if (!Object.keys(options || {}).length) {
+            throw new Error('No configuration options provided');
+        }
+        const { sourceDir , targetDir  } = options;
+        if (!sourceDir) {
+            throw new Error('The `sourceDir` field is mandatory');
+        }
+        if (!targetDir) {
+            throw new Error('The `targetDir` field is mandatory');
+        }
+        Deboa.#validateOptions(options);
+        const { controlFileOptions  } = options;
+        const osArch = os.arch();
+        // default values
+        options = {
+            ...options,
+            controlFileOptions: {
+                ...controlFileOptions,
+                ...!controlFileOptions.architecture && {
+                    architecture: osArch === 'x64' ? 'amd64' : osArch
+                },
+                ...!controlFileOptions.maintainerScripts && {
+                    maintainerScripts: {}
+                },
+                ...!controlFileOptions.priority && {
+                    priority: 'optional'
+                },
+                ...!controlFileOptions.extendedDescription && {
+                    extendedDescription: controlFileOptions.shortDescription
+                }
+            },
+            tarballFormat: [
+                'tar',
+                'tar.gz',
+                'tar.xz'
+            ].includes(options.tarballFormat) ? options.tarballFormat : 'tar.gz'
+        };
+        for (const [property, value] of Object.entries(options)){
+            this[property] = value;
+        }
+        this.#tempDir = path.join(os.tmpdir(), 'deboa_temp');
+        const { architecture , packageName , version  } = this.controlFileOptions;
+        this.#outputFile = path.join(this.targetDir, `${packageName}_${version}_${architecture}.deb`);
+        this.#controlFolderDestination = path.join(this.#tempDir, 'control');
+        this.#dataFolderDestination = path.join(this.#tempDir, 'data');
+        this.#appFolderDestination = path.join(this.#dataFolderDestination, 'usr', 'lib', packageName);
+    }
+    /**
+   * Ensures that all required options are present and that the `packageName`
+   * and `maintainer` fields are provided in the right format.
+   */ static  #validateOptions(options) {
+        console.log('Validating options...\n');
+        const { controlFileOptions: { shortDescription , maintainer , packageName , version ,  } ,  } = options;
+        if (!packageName) {
+            throw new Error('The controlFileOptions.`packageName` field is mandatory');
+        }
+        if (!version) {
+            throw new Error('The `controlFileOptions.version` field is mandatory');
+        }
+        if (!maintainer) {
+            throw new Error('The `controlFileOptions.maintainer` field is mandatory');
+        }
+        if (!shortDescription) {
+            throw new Error('The `controlFileOptions.description` field is mandatory');
+        }
+        if (packageName.length < 2) {
+            throw new Error('The `controlFileOptions.packageName` field must be at least two characters long');
+        }
+        if (packageName.replace(/[^a-z\d\-+.]/g, '').replace(/^[-+.]/g, '').toLowerCase() !== packageName) {
+            throw new Error('The `controlFileOptions.packageName` field contains illegal characters');
+        }
+        /*
+     if (!maintainer.match(/^(\p{L}+ ?)+ ?<(.*?)@(.*?)>$/u)) {
+     throw new Error(
+     'The `controlFileOptions.maintainer` field does not match the expected format `John Doe <johndoe@example.com>`',
+     )
+     }
+     */ const { postinst , prerm , postrm , preinst  } = options.controlFileOptions.maintainerScripts || {};
+        for (const [scriptName, scriptPath] of Object.entries({
+            postinst,
+            postrm,
+            preinst,
+            prerm
+        })){
+            if (scriptPath) {
+                try {
+                    fs.accessSync(path.resolve(scriptPath));
+                } catch (e) {
+                    throw new Error(`Error accessing \`${scriptPath}\` (provided in \`controlFileOptions.maintainerScripts.${scriptName}\`). Make sure that this file exists and is accessible by the current user.`);
+                }
+            }
+        }
+    }
+    /**
+   * Creates the .deb file.
+   * @return {Promise<string>} outputFile - Absolute path to the generated .deb
+   */ async package() {
+        const startTime = process.hrtime.bigint();
+        const tempDir = this.#tempDir;
+        await fsExtra.ensureDir(tempDir);
+        if (!this.#hooksLoaded) {
+            await this.loadHooks();
+        }
+        await this.#copyFolderTree();
+        await this.#copyMaintainerScripts();
+        await this.#copyPackageFiles();
+        await this.#createControlFile();
+        await this.#copyIconAndDesktopEntryFile();
+        if (typeof this.beforePackage === 'function') {
+            await this.beforePackage(this.#dataFolderDestination);
+        }
+        await this.#createTarballs();
+        await this.#createDeb();
+        console.log('Removing temporary files...\n');
+        await fs.promises.rm(this.#tempDir, {
+            recursive: true
+        });
+        const endTime = process.hrtime.bigint();
+        const duration = parseInt(String(endTime - startTime));
+        console.log(`.deb created in ${(duration / 1e9).toFixed(2)}s`);
+        return this.#outputFile;
+    }
+    /**
+   * Creates the tarballs for the control and data files.
+   */ async #createTarballs() {
+        console.log('Packaging files....\n');
+        const { tarballFormat  } = this;
+        const dataFileLocation = this.#dataFolderDestination + `.${tarballFormat}`;
+        const controlFileLocation = this.#controlFolderDestination + `.${tarballFormat}`;
+        let dataFileCompressor;
+        let controlFileCompressor;
+        switch(tarballFormat){
+            case 'tar':
+                {
+                    dataFileCompressor = new PassThroughStream();
+                    controlFileCompressor = new PassThroughStream();
+                    break;
+                }
+            case 'tar.gz':
+                {
+                    const zlib = (await import('zlib')).default;
+                    dataFileCompressor = zlib.createGzip();
+                    controlFileCompressor = zlib.createGzip();
+                    break;
+                }
+            case 'tar.xz':
+                {
+                    const lzma = (await import('lzma-native')).default;
+                    dataFileCompressor = lzma.createCompressor({
+                        threads: 0
+                    });
+                    controlFileCompressor = lzma.createCompressor({
+                        threads: 0
+                    });
+                    break;
+                }
+        }
+        const dataFileWriteStream = fs.createWriteStream(dataFileLocation);
+        const controlFileWriteStream = fs.createWriteStream(controlFileLocation);
+        tar.pack(this.#dataFolderDestination, {
+            map: (header)=>{
+                // sensible defaults for Windows users
+                if (process.platform === 'win32') {
+                    const defaultFilePermission = parseInt('0644', 8);
+                    const defaultFolderPermission = parseInt('0755', 8);
+                    switch(header.type){
+                        case 'file':
+                            {
+                                header.mode = defaultFilePermission;
+                                break;
+                            }
+                        case 'directory':
+                            {
+                                header.mode = defaultFolderPermission;
+                                break;
+                            }
+                    }
+                }
+                if (typeof this.modifyTarHeader === 'function') {
+                    header = this.modifyTarHeader(header);
+                }
+                return header;
+            },
+            ...this.additionalTarEntries.length && {
+                finalize: false,
+                finish: async (pack)=>{
+                    await addTarEntries({
+                        entries: this.additionalTarEntries,
+                        pack
+                    });
+                    pack.finalize();
+                }
+            }
+        }).pipe(dataFileCompressor).pipe(dataFileWriteStream);
+        tar.pack(this.#controlFolderDestination, {
+            map: (header)=>{
+                const maintainerScripts = [
+                    'postinst',
+                    'postrm',
+                    'preinst',
+                    'prerm', 
+                ];
+                // maintainer scripts must be executable
+                if (maintainerScripts.includes(header.name)) {
+                    header.mode = parseInt('0755', 8);
+                }
+                return header;
+            }
+        }).pipe(controlFileCompressor).pipe(controlFileWriteStream);
+        await Promise.all([
+            once(dataFileWriteStream, 'finish'),
+            once(controlFileWriteStream, 'finish'), 
+        ]);
+    }
+    /**
+   * Copies the empty folders to the temporary location.
+   */ async #copyFolderTree() {
+        console.log('Creating directory structure in the temporary folder...\n');
+        await fsExtra.ensureDir(this.#appFolderDestination);
+        await fsExtra.ensureDir(this.#controlFolderDestination);
+    }
+    /**
+   * Copies the source files to the temporary folder.
+   */ async #copyPackageFiles() {
+        console.log('Copying source directory...\n');
+        await fsExtra.copy(this.sourceDir, this.#appFolderDestination);
+    }
+    /**
+   * Copies the maintainer scripts to the temporary folder.
+   */ async #copyMaintainerScripts() {
+        console.log('Copying maintainer scripts...\n');
+        const { controlFileOptions: { maintainerScripts: { postinst: postinst1 , postrm: postrm1 , preinst: preinst1 , prerm: prerm1  } = {} ,  } ,  } = this;
+        const scripts = Object.entries({
+            postinst: postinst1,
+            postrm: postrm1,
+            preinst: preinst1,
+            prerm: prerm1
+        }).filter(([, scriptPath])=>scriptPath);
+        for (const [scriptName1, scriptPath1] of scripts){
+            await fs.promises.copyFile(path.resolve(scriptPath1), path.join(this.#controlFolderDestination, scriptName1));
+        }
+    }
+    /**
+   * Creates the control file and writes it to the temporary folder.
+   */ async #createControlFile() {
+        console.log('Creating control file...\n');
+        const { controlFileOptions: { packageName: packageName1 , version: version1 , section , priority , architecture , maintainer: maintainer1 , homepage , suggests =[] , depends =[] , recommends =[] , shortDescription: shortDescription1 , extendedDescription , builtUsing , conflicts =[] , essential , preDepends =[] ,  } ,  } = this;
+        const fastFolderSizeAsync = promisify(fastFolderSize);
+        const installedSize = await fastFolderSizeAsync(this.sourceDir);
+        const lines = [
+            `Package: ${packageName1}`,
+            `Version: ${version1}`,
+            section && `Section: ${section}`,
+            `Priority: ${priority}`,
+            `Architecture: ${architecture}`,
+            `Maintainer: ${maintainer1}`,
+            Array.isArray(depends) && depends.length && `Depends: ${depends.join(', ')}`,
+            preDepends.length && `Pre-Depends: ${preDepends.join(', ')}`,
+            recommends.length && `Recommends: ${recommends.join(', ')}`,
+            suggests.length && `Suggests: ${suggests.join(', ')}`,
+            conflicts.length && `Conflicts: ${conflicts.join(', ')}`,
+            `Installed-Size: ${Math.ceil(installedSize / 1024)}`,
+            homepage && `Homepage: ${homepage}`,
+            builtUsing && `Built-Using: ${builtUsing}`,
+            essential && `Essential: ${essential}`,
+            `Description: ${shortDescription1}`,
+            ` ${extendedDescription}`, 
+        ].filter(Boolean);
+        await writeFileFromLines({
+            filePath: path.join(this.#controlFolderDestination, 'control'),
+            lines
+        });
+    }
+    /**
+   * Copies the provided icon to the temporary folder
+   * and writes the desktop entry file.
+   */ async #copyIconAndDesktopEntryFile() {
+        let iconFileExists = false;
+        let iconDestination = null;
+        const { packageName: packageName2 , shortDescription: shortDescription2  } = this.controlFileOptions;
+        if (this.icon) {
+            const iconPath = path.resolve(this.icon);
+            iconFileExists = await fsExtra.pathExists(iconPath);
+            const { ext: extension  } = path.parse(iconPath);
+            if (iconFileExists) {
+                iconDestination = path.join(this.#dataFolderDestination, 'usr/share/pixmaps', packageName2 + extension);
+                await fsExtra.ensureDir(path.resolve(iconDestination, '../'));
+                await fsExtra.copy(iconPath, iconDestination);
+                console.log(`App icon saved to ${iconDestination}`);
+            } else {
+                console.warn(`\nWARNING: file \`${iconPath}\` not found, skipping app icon...\n`);
+            }
+        }
+        let desktopEntries = {
+            Comment: shortDescription2,
+            GenericName: packageName2,
+            Name: packageName2,
+            Type: 'Application',
+            ...iconFileExists && {
+                Icon: packageName2
+            }
+        };
+        if (typeof this.beforeCreateDesktopEntry === 'function') {
+            desktopEntries = await this.beforeCreateDesktopEntry(desktopEntries);
+        }
+        if (!Object.keys(desktopEntries).length) {
+            return;
+        }
+        const lines1 = Object.entries(desktopEntries).reduce((acc, entry)=>[
+                ...acc,
+                entry.join('=')
+            ], []);
+        const desktopFileDestination = path.join(this.#dataFolderDestination, 'usr/share/applications', `${packageName2}.desktop`);
+        await fsExtra.ensureDir(path.resolve(desktopFileDestination, '../'));
+        await writeFileFromLines({
+            filePath: desktopFileDestination,
+            lines: [
+                '[Desktop Entry]',
+                ...lines1
+            ]
+        });
+        console.log(`Desktop entries file saved to ${desktopFileDestination}`);
+    }
+    /**
+   * Checks if the values provided to the hook options are file paths
+   * and imports the actual functions from them if necessary.
+   */ async loadHooks() {
+        const { beforePackage , modifyTarHeader , beforeCreateDesktopEntry  } = this;
+        const hooks = {
+            beforeCreateDesktopEntry,
+            beforePackage,
+            modifyTarHeader
+        };
+        for (const [hookName, hookValue] of Object.entries(hooks)){
+            if (hookValue) {
+                switch(typeof hookValue){
+                    case 'function':
+                        {
+                            this[hookName] = hookValue;
+                            break;
+                        }
+                    case 'string':
+                        {
+                            const filePath = path.resolve(hookValue);
+                            const fileExists = await fsExtra.pathExists(filePath);
+                            if (!fileExists) {
+                                throw new Error(`The file \`${hookValue}\` doesn't exist or cannot be accessed by the current user.`);
+                            }
+                            const importedFn = (await import(filePath)).default;
+                            if (typeof importedFn === 'function') {
+                                this[hookName] = importedFn;
+                            } else {
+                                throw new Error(`The file \`${filePath}\` must have a function as its default export.`);
+                            }
+                            break;
+                        }
+                    default:
+                        {
+                            throw new Error(`Invalid type provided for the \`${hookName}\` option, expected a function or a path to a file that has a function as its default export.`);
+                        }
+                }
+            }
+        }
+        this.#hooksLoaded = true;
+    }
+    /**
+   * Writes the .deb to the output folder.
+   */ async #createDeb() {
+        console.log('Writing .deb file...\n');
+        await fsExtra.ensureDir(this.targetDir);
+        const deBoaFromFile = new DeboaFromFile({
+            outputFile: this.#outputFile
+        });
+        try {
+            await deBoaFromFile.writeFromFile(this.#controlFolderDestination + `.${this.tarballFormat}`);
+            await deBoaFromFile.writeFromFile(this.#dataFolderDestination + `.${this.tarballFormat}`);
+            deBoaFromFile.writeStream.close();
+        } catch (e1) {
+            console.log('ERROR: ', e1);
+            throw e1;
+        }
+    }
+}
+export { Deboa };

package/dist/esm/classes/DeboaFromFile.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import path from 'path';
+import { createFileHeader } from '../utils/createFileHeader';
+import { writeToArchive } from '../utils/writeToArchive';
+/**
+ * @return IDeboaFromFile
+ */ export class DeboaFromFile {
+    #header = null;
+    isARFile = false;
+    outputFile = null;
+    writeStream = null;
+    constructor(options){
+        const { outputFile , isARFile  } = options;
+        this.isARFile = isARFile;
+        this.outputFile = outputFile;
+        this.writeStream = fs.createWriteStream(outputFile, {
+            encoding: 'binary'
+        });
+    }
+    /**
+   * Creates a ReadStream from the input file.
+   * Useful if you need access to the underlying stream.
+   */ async createReadStream(inputFile) {
+        if (this.#header !== null) {
+            throw new Error('You can only have one ReadStream at a time.');
+        }
+        const readStream = fs.createReadStream(inputFile, {
+            encoding: 'binary'
+        });
+        const stats = await fs.promises.lstat(inputFile);
+        this.#header = createFileHeader({
+            fileName: path.basename(inputFile),
+            fileSize: stats.size
+        });
+        return readStream;
+    }
+    async writeFromStream(readStream) {
+        if (this.#header === null) {
+            throw new Error('Missing header, please create the ReadStream using the `createReadStream` method.');
+        }
+        await writeToArchive({
+            header: Buffer.from(this.#header),
+            isARFile: this.isARFile,
+            readStream,
+            writeStream: this.writeStream
+        });
+        this.#header = null;
+    }
+    /**
+   * Writes the input file to the .deb.
+   */ async writeFromFile(inputFile) {
+        const readStream = await this.createReadStream(inputFile);
+        return this.writeFromStream(readStream);
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+import { Deboa } from './classes/Deboa';
+import { DeboaFromFile } from './classes/DeboaFromFile';
+export { Deboa, DeboaFromFile };
+export * from './types';

package/dist/esm/types/IAddTarEntriesParams.js

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

package/dist/esm/types/IControlFileOptions.js

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

package/dist/esm/types/IDeboa.js

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

package/dist/esm/types/IDeboaFromFile.js

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

package/dist/esm/types/INormalizeOptionsLength.js

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

package/dist/esm/types/IWriteFileFromLinesArgs.js

@@ -0,0 +1,4 @@
+/**
+ * @property {string} filePath - Path to the output file.
+ * @property {string[]} lines - Lines to be written.
+ */ export { };

package/dist/esm/types/IWriteToArchive.js

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

package/dist/esm/types/MaintainerScript.js

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