inibase 1.0.0-rc.65 → 1.0.0-rc.67

package/README.md

@@ -68,42 +68,9 @@ This structure ensures efficient storage, retrieval, and updates, making our sys
 
 ```shell
 npx inibase -p <databaseFolderPath>
+# by default it will diplay a list of available commands (or type 'help')
 ```
 
-<blockquote>
-<details>
-<summary>GET</summary>
-
-```shell 
-get <tableName> -w <ID|LineNumber|Criteria> -p <pageNumber> -l <perPage> -c <columnName1>  -c <columnName2>
-```
-</details>
-
-<details>
-<summary>POST</summary>
-
-```shell 
-post <tableName> -d <InisonStrigifedData>
-```
-</details>
-
-<details>
-<summary>PUT</summary>
-
-```shell 
-put <tableName> -d <InisonStrigifedData> -w <ID|LineNumber|Criteria>
-```
-</details>
-
-<details>
-<summary>DELETE</summary>
-
-```shell 
-delete <tableName> -w <ID|LineNumber|Criteria>
-```
-</details>
-</blockquote>
-
 ## Examples
 
 <details>

package/dist/cli.js

@@ -2,90 +2,262 @@
 import "dotenv/config";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
-import { basename } from "node:path";
+import { basename, join } from "node:path";
+import { readFileSync } from "node:fs";
 import Inison from "inison";
 import Inibase from "./index.js";
-import { isJSON, isNumber } from "./utils.js";
-const { path } = parseArgs({
+import { isJSON, isNumber, setField, unsetField } from "./utils.js";
+import { isExists } from "./file.js";
+const textGreen = (input) => `\u001b[1;32m${input}\u001b[0m`;
+const textRed = (input) => `\u001b[1;31m${input}\u001b[0m`;
+const textBlue = (input) => `\u001b[1;34m${input}\u001b[0m`;
+const textMagenta = (input) => `\u001b[1;35m${input}\u001b[0m`;
+let { path, version } = parseArgs({
     options: {
         path: { type: "string", short: "p" },
+        version: { type: "boolean", short: "v" },
     },
 }).values;
-if (!path)
-    throw new Error("Please specify database folder path --path <databasePath> or -p <databasePath>");
-const db = new Inibase(basename(path));
+if (version) {
+    console.log(JSON.parse(readFileSync("package.json", "utf8")).version);
+    process.exit();
+}
 const rl = createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: "\u001b[1;36m>  \u001b[0m",
+    prompt: textBlue(">  "),
 });
+const setPath = async (firstTime) => {
+    if (!path)
+        path = await rl.question(firstTime ? "Database path: " : "Please type a valid database path: ");
+    if (!path || !(await isExists(basename(path))))
+        await setPath();
+};
+console.clear();
+await setPath(true);
+const db = new Inibase(basename(path));
+process.stdout.write("\u001b[3J\u001b[2J\u001b[1J");
 console.clear();
 rl.prompt();
+let table;
 rl.on("line", async (input) => {
-    const trimedInput = input.trim();
-    if (trimedInput === "clear") {
-        process.stdout.write("\x1Bc");
-        rl.prompt();
-    }
-    if (trimedInput === "exit")
-        process.exit();
-    const splitedInput = trimedInput.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g);
-    if (["get", "post", "delete", "put"].includes(splitedInput[0].toLocaleLowerCase())) {
-        const table = splitedInput[1];
-        if (!table)
-            throw new Error("Please specify table name");
-        let { where, page, perPage, columns, data } = parseArgs({
-            args: splitedInput.toSpliced(0, 2),
-            options: {
-                where: { type: "string", short: "w" },
-                page: { type: "string", short: "p" },
-                perPage: { type: "string", short: "l" },
-                columns: { type: "string", short: "c", multiple: true },
-                data: { type: "string", short: "d" },
-            },
-        }).values;
-        if (where) {
-            if (where === "'-1'" || where === '"-1"')
-                where = -1;
-            else if (isNumber(where))
-                where = Number(where);
-            else if (isJSON(where))
-                where = Inison.unstringify(where);
+    const splitedInput = input
+        .trim()
+        .match(/[^\s"']+|"([^"]*)"|'([^']*)'/g);
+    switch (splitedInput[0].toLocaleLowerCase()) {
+        case "clear":
+            process.stdout.write("\u001b[3J\u001b[2J\u001b[1J");
+            console.clear();
+            rl.prompt();
+            break;
+        case "exit":
+            return process.exit();
+        // biome-ignore format:
+        case "help": {
+            if (!table)
+                console.log(` ${textBlue("table")} | ${textBlue("t")} ${textRed("<")}tableName${textRed(">*")}`);
+            console.log(`   ${textGreen("config")} | ${textGreen("c")}
+   	${textMagenta("get")} | ${textMagenta("g")} (compression|cache|prepend)?
+   	${textMagenta("set")} | ${textMagenta("s")} (compression true|false)? (cache true|false)? (prepend true|false)?
+   ${textGreen("schema")} | ${textGreen("s")}
+   	${textMagenta("get")} | ${textMagenta("g")}  ${textRed("<")}keyName${textRed(">*")}	
+	${textMagenta("set")} | ${textMagenta("s")}  ${textRed("<")}keyName${textRed(">*")} {{ Inison.stringify(Field) }}
+   ${textGreen("get")} | ${textGreen("g")}
+   ${textGreen("delete")} | ${textGreen("d")}
+   ${textGreen("post")} | ${textGreen("p")}
+   ${textGreen("put")} | ${textGreen("pu")}
+	${textMagenta("--where")} | ${textMagenta("-w")}  (ID|Inison.stringify(Criteria)|LineNumber)?
+	${textMagenta("--page")} | ${textMagenta("-p")}  number?	
+	${textMagenta("--per-page")} | ${textMagenta("-l")}  number?
+	${textMagenta("--columns")} | ${textMagenta("-c")}  columnName[]?
+	${textMagenta("--data")} | ${textMagenta("-d")}  Inison.stringify(Data) ${textRed("* POST & PUT")}`);
+            break;
         }
-        if (data) {
-            if (isJSON(data))
-                data = Inison.unstringify(data);
-            else
-                data = undefined;
+        case "c":
+        case "config": {
+            if (!table) {
+                console.log(`${textRed("  Err:")} Please specify table name`);
+                break;
+            }
+            const config = (await db.getTable(table)).config;
+            if (!splitedInput[1]) {
+                console.log(JSON.stringify(config, undefined, 2));
+                break;
+            }
+            switch (splitedInput[1].toLocaleLowerCase()) {
+                case "g":
+                case "get": {
+                    if (!splitedInput[2])
+                        console.log(JSON.stringify(config, undefined, 2));
+                    else
+                        console.log(JSON.stringify(config[splitedInput[2]], undefined, 2));
+                    break;
+                }
+                case "s":
+                case "set": {
+                    const newConfigObject = {};
+                    splitedInput.splice(0, 2);
+                    for (let index = 0; index < splitedInput.length; index++) {
+                        const configName = splitedInput[index].toLocaleLowerCase();
+                        if (["true", "false"].includes(configName))
+                            continue;
+                        if (!["compression", "cache", "prepend"].includes(configName)) {
+                            console.log(`${textRed("  Err:")} '${configName}' is not a valid config`);
+                            break;
+                        }
+                        newConfigObject[configName] =
+                            splitedInput[index + 1].trim() === "true";
+                    }
+                    await db.updateTable(table, undefined, newConfigObject);
+                    break;
+                }
+                default:
+                    break;
+            }
+            break;
         }
-        switch (splitedInput[0].toLocaleLowerCase()) {
-            case "get":
-                console.log(await db.get(table, where, {
-                    page: Number(page) ?? 1,
-                    perPage: Number(perPage) ?? 15,
-                    columns,
-                }));
+        case "s":
+        case "schema": {
+            if (!table) {
+                console.log(`${textRed("  Err:")} Please specify table name`);
                 break;
-            case "post":
-                console.log(await db.post(table, data, {
-                    page: Number(page) ?? 1,
-                    perPage: Number(perPage) ?? 15,
-                    columns,
-                }, true));
+            }
+            const schema = (await db.getTable(table)).schema;
+            if (!splitedInput[1] || !splitedInput[2]) {
+                console.log(JSON.stringify(schema, undefined, 2));
                 break;
-            case "put":
-                console.log(await db.put(table, data, where, {
-                    page: Number(page) ?? 1,
-                    perPage: Number(perPage) ?? 15,
-                    columns,
-                }, true));
+            }
+            const key = splitedInput[2];
+            if (!key) {
+                console.log(`${textRed("  Err:")} Please specify key name`);
                 break;
-            case "delete":
-                console.log(await db.delete(table, where));
+            }
+            const field = {};
+            field.key = key;
+            switch (splitedInput[1].toLocaleLowerCase()) {
+                case "p":
+                case "push":
+                    await db.updateTable(table, [...(schema ?? []), field]);
+                    break;
+                case "u":
+                case "unset":
+                case "s":
+                case "set": {
+                    if (!schema) {
+                        console.log(`${textRed("  Err:")} Schema is empty, please push first`);
+                        break;
+                    }
+                    if (["set", "s"].includes(splitedInput[1].toLocaleLowerCase())) {
+                        if (!splitedInput[2]) {
+                            console.log(`${textRed("  Err:")} Give the field a schema`);
+                            break;
+                        }
+                        try {
+                            Object.assign(field, Inison.unstringify(splitedInput[2]));
+                            setField(key, schema, field);
+                        }
+                        catch {
+                            console.log(`${textRed("  Err:")} Give the field a valid schema`);
+                            break;
+                        }
+                    }
+                    else
+                        unsetField(key, schema);
+                    await db.updateTable(table, schema);
+                    break;
+                }
+                default:
+                    break;
+            }
+            break;
+        }
+        case "t":
+        case "table":
+            if (!splitedInput[1]) {
+                console.log(`${textRed("  Err:")} Please specify table name`);
                 break;
-            default:
+            }
+            if (!(await isExists(join(path, splitedInput[1]))))
+                console.log(`${textRed("  Err:")} Table doesn't exist`);
+            else {
+                table = splitedInput[1];
+                rl.setPrompt(textBlue(`${table} >  `));
+            }
+            break;
+        case "p":
+        case "post":
+        case "g":
+        case "get":
+        case "pu":
+        case "put":
+        case "d":
+        case "delete": {
+            if (!table) {
+                console.log(`${textRed("  Err:")} Please specify table name`);
                 break;
+            }
+            let where = undefined, page = undefined, perPage = undefined, columns = undefined, data = undefined;
+            if (splitedInput.toSpliced(0, 1).length) {
+                const parsedArgs = parseArgs({
+                    args: splitedInput.toSpliced(0, table ? 1 : 2),
+                    options: {
+                        where: { type: "string", short: "w" },
+                        page: { type: "string", short: "p" },
+                        perPage: { type: "string", short: "l" },
+                        columns: { type: "string", short: "c", multiple: true },
+                        data: { type: "string", short: "d" },
+                    },
+                }).values;
+                if (parsedArgs.where) {
+                    if (parsedArgs.where === "'-1'" || parsedArgs.where === '"-1"')
+                        where = -1;
+                    else if (isNumber(parsedArgs.where))
+                        where = Number(parsedArgs.where);
+                    else if (isJSON(parsedArgs.where))
+                        where = Inison.unstringify(parsedArgs.where);
+                }
+                page = Number(parsedArgs.page) ?? undefined;
+                perPage = Number(parsedArgs.perPage) ?? undefined;
+                columns = parsedArgs.columns;
+                if (parsedArgs.data && isJSON(parsedArgs.data))
+                    data = Inison.unstringify(parsedArgs.data);
+            }
+            switch (splitedInput[0].toLocaleLowerCase()) {
+                case "g":
+                case "get":
+                    console.log(await db.get(table, where, {
+                        page: Number(page) ?? 1,
+                        perPage: Number(perPage) ?? 15,
+                        columns,
+                    }));
+                    break;
+                case "p":
+                case "post":
+                    console.log(await db.post(table, data, {
+                        page: Number(page) ?? 1,
+                        perPage: Number(perPage) ?? 15,
+                        columns,
+                    }, true));
+                    break;
+                case "pu":
+                case "put":
+                    console.log(await db.put(table, data, where, {
+                        page: Number(page) ?? 1,
+                        perPage: Number(perPage) ?? 15,
+                        columns,
+                    }, true));
+                    break;
+                case "d":
+                case "delete":
+                    console.log(await db.delete(table, where));
+                    break;
+                default:
+                    break;
+            }
+            break;
         }
+        default:
+            break;
     }
     rl.prompt();
 });

package/dist/file.d.ts

@@ -61,14 +61,23 @@ export declare function get(filePath: string, lineNumbers: undefined | number |
  */
 export declare const replace: (filePath: string, replacements: string | number | boolean | null | (string | number | boolean | null)[] | Record<number, string | boolean | number | null | (string | boolean | number | null)[]>) => Promise<string[]>;
 /**
- * Asynchronously appends data to the beginning of a file.
+ * Asynchronously appends data to the end of a file.
  *
  * @param filePath - Path of the file to append to.
  * @param data - Data to append. Can be a string, number, or an array of strings/numbers.
  * @returns Promise<string[]>. Modifies the file by appending data.
  *
  */
-export declare const append: (filePath: string, data: string | number | (string | number)[], prepend?: boolean) => Promise<string[]>;
+export declare const append: (filePath: string, data: string | number | (string | number)[]) => Promise<string[]>;
+/**
+ * Asynchronously prepends data to the beginning of a file.
+ *
+ * @param filePath - Path of the file to append to.
+ * @param data - Data to append. Can be a string, number, or an array of strings/numbers.
+ * @returns Promise<string[]>. Modifies the file by appending data.
+ *
+ */
+export declare const prepend: (filePath: string, data: string | number | (string | number)[]) => Promise<string[]>;
 /**
  * Asynchronously removes specified lines from a file.
  *

package/dist/file.js

@@ -281,21 +281,42 @@ export const replace = async (filePath, replacements) => {
     return [];
 };
 /**
- * Asynchronously appends data to the beginning of a file.
+ * Asynchronously appends data to the end of a file.
  *
  * @param filePath - Path of the file to append to.
  * @param data - Data to append. Can be a string, number, or an array of strings/numbers.
  * @returns Promise<string[]>. Modifies the file by appending data.
  *
  */
-export const append = async (filePath, data, prepend) => {
+export const append = async (filePath, data) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
     if (await isExists(filePath)) {
-        if (!prepend && !filePath.endsWith(".gz")) {
-            await copyFile(filePath, fileTempPath);
+        await copyFile(filePath, fileTempPath);
+        if (!filePath.endsWith(".gz")) {
             await appendFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
         }
         else {
+            await exec(`echo $'${(Array.isArray(data) ? data.join("\n") : data)
+                .toString()
+                .replace(/'/g, "\\'")}' | gzip - >> ${fileTempPath}`);
+        }
+    }
+    else
+        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+    return [fileTempPath, filePath];
+};
+/**
+ * Asynchronously prepends data to the beginning of a file.
+ *
+ * @param filePath - Path of the file to append to.
+ * @param data - Data to append. Can be a string, number, or an array of strings/numbers.
+ * @returns Promise<string[]>. Modifies the file by appending data.
+ *
+ */
+export const prepend = async (filePath, data) => {
+    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
+    if (await isExists(filePath)) {
+        if (!filePath.endsWith(".gz")) {
             let fileHandle = null;
             let fileTempHandle = null;
             try {
@@ -319,6 +340,16 @@ export const append = async (filePath, data, prepend) => {
                 await fileTempHandle?.close();
             }
         }
+        else {
+            const fileChildTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/tmp_$1");
+            try {
+                await write(fileChildTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+                await exec(`cat ${fileChildTempPath} ${filePath} > ${fileTempPath}`);
+            }
+            finally {
+                await unlink(fileChildTempPath);
+            }
+        }
     }
     else
         await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);

package/dist/index.d.ts

@@ -149,8 +149,7 @@ export default class Inibase {
      * Delete item(s) in a table
      *
      * @param {string} tableName
-     * @param {(number | string)} [where]
-     * @param {(string | string[])} [_id]
+     * @param {(number | string | (number | string)[] | Criteria)} [where]
      * @return {*}  {(Promise<string | number | (string | number)[] | null>)}
      */
     delete(tableName: string, where?: number | string, _id?: string | string[]): Promise<string | null>;

package/dist/index.js

@@ -25,7 +25,7 @@ export default class Inibase {
         if (!process.env.INIBASE_SECRET) {
             if (existsSync(".env") &&
                 readFileSync(".env").includes("INIBASE_SECRET="))
-                this.throwError("NO_ENV");
+                throw this.throwError("NO_ENV");
             this.salt = scryptSync(randomBytes(16), randomBytes(16), 32);
             appendFileSync(".env", `\nINIBASE_SECRET=${this.salt.toString("hex")}\n`);
         }
@@ -91,9 +91,16 @@ export default class Inibase {
     async createTable(tableName, schema, config) {
         const tablePath = join(this.databasePath, tableName);
         if (await File.isExists(tablePath))
-            this.throwError("TABLE_EXISTS", tableName);
+            throw this.throwError("TABLE_EXISTS", tableName);
         await mkdir(join(tablePath, ".tmp"), { recursive: true });
         await mkdir(join(tablePath, ".cache"));
+        // if config not set => load default global env config
+        if (!config)
+            config = {
+                compression: process.env.INIBASE_COMPRESSION === "true",
+                cache: process.env.INIBASE_CACHE === "true",
+                prepend: process.env.INIBASE_PREPEND === "true",
+            };
         if (config) {
             if (config.compression)
                 await writeFile(join(tablePath, ".compression.config"), "");
@@ -115,40 +122,52 @@ export default class Inibase {
     async updateTable(tableName, schema, config) {
         const table = await this.getTable(tableName), tablePath = join(this.databasePath, tableName);
         if (config) {
-            if (config.compression !== undefined) {
-                if (!config.compression && table.config.compression) {
-                    try {
-                        await UtilsServer.exec(`find ${tablePath} -type f -name '*${this.fileExtension}.gz' -exec gunzip -f {} +`);
-                    }
-                    catch { }
-                    await unlink(join(tablePath, ".compression.config"));
-                }
-                else if (config.compression && !table.config.compression) {
-                    try {
-                        await UtilsServer.exec(`find ${tablePath} -type f -name '*${this.fileExtension}' -exec gzip -f {} +`);
-                    }
-                    catch { }
+            if (config.compression !== undefined &&
+                config.compression !== table.config.compression) {
+                await UtilsServer.execFile("find", [
+                    tableName,
+                    "-type",
+                    "f",
+                    "-name",
+                    `*${this.fileExtension}${config.compression ? "" : ".gz"}`,
+                    "-exec",
+                    config.compression ? "gzip" : "gunzip",
+                    "-f",
+                    "{}",
+                    "+",
+                ], { cwd: this.databasePath });
+                if (config.compression)
                     await writeFile(join(tablePath, ".compression.config"), "");
-                }
+                else
+                    await unlink(join(tablePath, ".compression.config"));
             }
-            if (config.cache !== undefined) {
-                if (config.cache && !table.config.cache)
+            if (config.cache !== undefined && config.cache !== table.config.cache) {
+                if (config.cache)
                     await writeFile(join(tablePath, ".cache.config"), "");
-                else if (!config.cache && table.config.cache)
+                else
                     await unlink(join(tablePath, ".cache.config"));
             }
-            if (config.prepend !== undefined) {
-                if (config.prepend !== table.config.prepend) {
-                    try {
-                        await UtilsServer.exec(config.compression || table.config.compression
-                            ? `find ${tablePath} -type f -name '*${this.fileExtension}.gz' -exec sh -c 'zcat "$0" | tac | gzip > "$0.reversed" && mv "$0.reversed" "$0"' {} +`
-                            : `find ${tablePath} -type f -name '*${this.fileExtension}' -exec sh -c 'tac "$0" > "$0.reversed" && mv "$0.reversed" "$0"' {} +`);
-                    }
-                    catch { }
-                }
-                if (config.prepend && !table.config.prepend)
+            if (config.prepend !== undefined &&
+                config.prepend !== table.config.prepend) {
+                await UtilsServer.execFile("find", [
+                    tableName,
+                    "-type",
+                    "f",
+                    "-name",
+                    `*${this.fileExtension}${config.compression ? ".gz" : ""}`,
+                    "-exec",
+                    "sh",
+                    "-c",
+                    `for file; do ${config.compression
+                        ? 'zcat "$file" | tac | gzip > "$file.reversed" && mv "$file.reversed" "$file"'
+                        : 'tac "$file" > "$file.reversed" && mv "$file.reversed" "$file"'}; done`,
+                    "_",
+                    "{}",
+                    "+",
+                ], { cwd: this.databasePath });
+                if (config.prepend)
                     await writeFile(join(tablePath, ".prepend.config"), "");
-                else if (!config.prepend && table.config.prepend)
+                else
                     await unlink(join(tablePath, ".prepend.config"));
             }
         }
@@ -184,7 +203,7 @@ export default class Inibase {
     async getTable(tableName) {
         const tablePath = join(this.databasePath, tableName);
         if (!(await File.isExists(tablePath)))
-            this.throwError("TABLE_NOT_EXISTS", tableName);
+            throw this.throwError("TABLE_NOT_EXISTS", tableName);
         if (!this.tables[tableName])
             this.tables[tableName] = {
                 schema: await this.getTableSchema(tableName),
@@ -961,7 +980,9 @@ export default class Inibase {
                     ? RETURN.toReversed()
                     : RETURN
                 : RETURN);
-            await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.append(path, content, this.tables[tableName].config.prepend))));
+            await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.tables[tableName].config.prepend
+                ? await File.prepend(path, content)
+                : await File.append(path, content))));
             await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
             renameList = [];
             totalItems += Array.isArray(RETURN) ? RETURN.length : 1;

package/dist/utils.js

@@ -253,7 +253,7 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
         case "string":
             return isString(value);
         case "password":
-            return isNumber(value) || isPassword(value) || isString(value);
+            return true; // accept
         case "number":
             return isNumber(value);
         case "html":

package/dist/utils.server.d.ts

@@ -2,9 +2,10 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import type { ComparisonOperator, FieldType, Schema } from "./index.js";
-import { exec as execAsync } from "node:child_process";
+import { exec as execAsync, execFile as execFileAsync } from "node:child_process";
 import { gunzip as gunzipAsync, gzip as gzipAsync } from "node:zlib";
 export declare const exec: typeof execAsync.__promisify__;
+export declare const execFile: typeof execFileAsync.__promisify__;
 export declare const gzip: typeof gzipAsync.__promisify__;
 export declare const gunzip: typeof gunzipAsync.__promisify__;
 /**

package/dist/utils.server.js

@@ -1,9 +1,10 @@
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync, createHash, } from "node:crypto";
 import { detectFieldType, isArrayOfObjects, isNumber, isPassword, isValidID, } from "./utils.js";
 import { promisify } from "node:util";
-import { exec as execAsync } from "node:child_process";
+import { exec as execAsync, execFile as execFileAsync, } from "node:child_process";
 import { gunzip as gunzipAsync, gzip as gzipAsync } from "node:zlib";
 export const exec = promisify(execAsync);
+export const execFile = promisify(execFileAsync);
 export const gzip = promisify(gzipAsync);
 export const gunzip = promisify(gunzipAsync);
 /**

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.65",
+  "version": "1.0.0-rc.67",
+  "type": "module",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"
@@ -49,7 +50,6 @@
   "bin": {
     "inibase": "./dist/cli.js"
   },
-  "type": "module",
   "types": "./dist",
   "typesVersions": {
     "*": {