@onurege3467/zerohelper 9.2.0 → 10.0.0

package/dist/database/zpack.js

@@ -8,6 +8,9 @@ const IDatabase_1 = require("./IDatabase");
 const fs_1 = __importDefault(require("fs"));
 const fsp = fs_1.default.promises;
 const zlib_1 = __importDefault(require("zlib"));
+/**
+ * ZPackDatabase: Low-level Binary Storage
+ */
 class ZPackDatabase {
     constructor(filePath, options = {}) {
         this.fd = null;
@@ -56,6 +59,7 @@ class ZPackDatabase {
             return;
         await this._writeFooter();
         await this.fd.close();
+        this.fd = null;
         this._closed = true;
     }
     async vacuum() {
@@ -83,7 +87,7 @@ class ZPackDatabase {
         const payload = this._encodeDocument(document, docId);
         return this._enqueue(async () => {
             const writeOffset = this.fileSize;
-            await this.fd.write(payload, 0, payload.length, writeOffset);
+            await this.fd.write(payload, 0, payload.length, Number(writeOffset));
             this.fileSize = writeOffset + BigInt(payload.length);
             this._contentEnd = this.fileSize;
             const parsed = this._peekDocMeta(payload);
@@ -122,7 +126,7 @@ class ZPackDatabase {
         }
         return this._enqueue(async () => {
             const writeOffset = this.fileSize;
-            await this.fd.write(buffer, 0, buffer.length, writeOffset);
+            await this.fd.write(buffer, 0, buffer.length, Number(writeOffset));
             let cur = writeOffset;
             const ids = [];
             for (let i = 0; i < payloads.length; i++) {
@@ -133,7 +137,7 @@ class ZPackDatabase {
                 }
                 else {
                     this.index.set(meta.docId, cur);
-                    this.deleted.add(meta.docId); // Bugfix: added to deleted, should be removed
+                    this.deleted.delete(meta.docId);
                     if (meta.docId >= this._nextId)
                         this._nextId = meta.docId + 1;
                 }
@@ -151,7 +155,7 @@ class ZPackDatabase {
         const tomb = this._encodeTombstone(docId);
         await this._enqueue(async () => {
             const writeOffset = this.fileSize;
-            await this.fd.write(tomb, 0, tomb.length, writeOffset);
+            await this.fd.write(tomb, 0, tomb.length, Number(writeOffset));
             this.fileSize = writeOffset + BigInt(tomb.length);
             this._contentEnd = this.fileSize;
             this.index.delete(docId);
@@ -166,13 +170,13 @@ class ZPackDatabase {
         if (offset === undefined)
             return null;
         const header = Buffer.alloc(6);
-        const { bytesRead: hread } = await this.fd.read(header, 0, header.length, offset);
+        const { bytesRead: hread } = await this.fd.read(header, 0, header.length, Number(offset));
         if (hread !== header.length)
             return null;
         const docLength = header.readUInt16LE(0);
         const totalSize = 2 + docLength;
         const buf = Buffer.alloc(totalSize);
-        const { bytesRead } = await this.fd.read(buf, 0, totalSize, offset);
+        const { bytesRead } = await this.fd.read(buf, 0, totalSize, Number(offset));
         if (bytesRead !== totalSize)
             return null;
         return this._decodeDocument(buf).document;
@@ -206,7 +210,7 @@ class ZPackDatabase {
         }
         footer.writeUInt32LE(footerSize, p);
         const writeOffset = this.fileSize;
-        await this.fd.write(footer, 0, footer.length, writeOffset);
+        await this.fd.write(footer, 0, footer.length, Number(writeOffset));
         this._contentEnd = writeOffset;
         this.fileSize = writeOffset + BigInt(footer.length);
     }
@@ -297,13 +301,13 @@ class ZPackDatabase {
         if (this.fileSize < 13n)
             return false;
         const sizeBuf = Buffer.alloc(4);
-        await this.fd.read(sizeBuf, 0, 4, this.fileSize - 4n);
+        await this.fd.read(sizeBuf, 0, 4, Number(this.fileSize - 4n));
         const footerSize = sizeBuf.readUInt32LE(0);
         if (footerSize < 9 || BigInt(footerSize) + 4n > this.fileSize)
             return false;
         const footerStart = this.fileSize - 4n - BigInt(footerSize);
         const footer = Buffer.alloc(footerSize);
-        await this.fd.read(footer, 0, footerSize, footerStart);
+        await this.fd.read(footer, 0, footerSize, Number(footerStart));
         if (footer.toString("utf8", 0, 4) !== "ZPCK" || footer.readUInt8(4) !== this.version)
             return false;
         const count = footer.readUInt32LE(5);
@@ -327,12 +331,12 @@ class ZPackDatabase {
         let offset = 0n;
         const headerBuf = Buffer.alloc(2);
         while (offset + 2n <= this.fileSize) {
-            const { bytesRead } = await this.fd.read(headerBuf, 0, 2, offset);
+            const { bytesRead } = await this.fd.read(headerBuf, 0, 2, Number(offset));
             if (bytesRead < 2)
                 break;
             const payloadSize = headerBuf.readUInt16LE(0);
             const idBuf = Buffer.alloc(4);
-            await this.fd.read(idBuf, 0, 4, offset + 2n);
+            await this.fd.read(idBuf, 0, 4, Number(offset + 2n));
             const docId = idBuf.readUInt32LE(0);
             if (payloadSize === 4)
                 this.index.delete(docId);
@@ -343,6 +347,9 @@ class ZPackDatabase {
     }
 }
 exports.ZPackDatabase = ZPackDatabase;
+/**
+ * ZPackAdapter: IDatabase Implementation
+ */
 class ZPackAdapter extends IDatabase_1.IDatabase {
     constructor(config) {
         super();
@@ -351,6 +358,8 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
         this.rowCache = new Map();
         this.secondary = new Map();
         this.indexedFields = new Map();
+        this._isClosing = false;
+        this._executing = Promise.resolve();
         this.db = new ZPackDatabase(config.path, { autoFlush: !!config.autoFlush, compression: !!config.cache });
         if (config.indexFields) {
             for (const [table, fields] of Object.entries(config.indexFields)) {
@@ -363,16 +372,66 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
         await this.db.open();
         for (const physicalDocId of this.db.keys()) {
             const doc = await this.db.get(physicalDocId);
-            if (!doc || !doc.t || !Number.isFinite(Number(doc._id)))
+            if (!doc || !doc.t || isNaN(Number(doc._id)))
                 continue;
             const table = String(doc.t), idNum = Number(doc._id);
             await this.ensureTable(table);
-            this.keyIndex.get(table).set(idNum, physicalDocId);
+            this.keyIndex.get(table).set(idNum, BigInt(physicalDocId));
             if (idNum > (this.tableMaxId.get(table) || 0))
                 this.tableMaxId.set(table, idNum);
             this._updateSecondaryIndex(table, idNum, doc);
         }
     }
+    async _execute(fn) {
+        if (this._isClosing)
+            throw new Error("ZPack: Adaptör kapanıyor.");
+        const next = this._executing.then(async () => {
+            if (this._isClosing)
+                return;
+            await this.initPromise;
+            return fn();
+        });
+        this._executing = next.catch(() => { });
+        return next;
+    }
+    // --- INTERNAL RAW METHODS (No Queue) to prevent deadlocks ---
+    async _rawSelect(table, where = null) {
+        await this.ensureTable(table);
+        if (where && Object.keys(where).length === 1) {
+            const [field, value] = Object.entries(where)[0];
+            const index = this.secondary.get(table)?.get(field);
+            if (index) {
+                const matches = index.get(String(value));
+                if (matches) {
+                    const results = [];
+                    for (const logicalId of matches) {
+                        const physicalId = this.keyIndex.get(table).get(logicalId);
+                        if (physicalId !== undefined) {
+                            const doc = await this.db.get(Number(physicalId));
+                            if (doc)
+                                results.push(doc);
+                        }
+                    }
+                    return results;
+                }
+                return [];
+            }
+        }
+        const results = [];
+        for (const [logicalId, physicalId] of this.keyIndex.get(table).entries()) {
+            let row = this.rowCache.get(table).get(logicalId);
+            if (!row) {
+                const doc = await this.db.get(Number(physicalId));
+                if (!doc)
+                    continue;
+                row = doc;
+                this.rowCache.get(table).set(logicalId, row);
+            }
+            if (this._matches(row, where))
+                results.push({ ...row });
+        }
+        return results;
+    }
     async ensureTable(table) {
         if (!this.tableMaxId.has(table)) {
             this.tableMaxId.set(table, 0);
@@ -409,125 +468,129 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
         return out;
     }
     _matches(row, where) {
-        if (!where)
+        if (!where || Object.keys(where).length === 0)
             return true;
         return Object.entries(where).every(([k, v]) => String(row[k]) === String(v));
     }
+    // --- PUBLIC METHODS (With Queue) ---
     async select(table, where = null) {
-        const start = Date.now();
-        await this.initPromise;
-        await this.ensureTable(table);
-        if (where && Object.keys(where).length === 1) {
-            const [field, value] = Object.entries(where)[0];
-            const index = this.secondary.get(table)?.get(field);
-            if (index) {
-                const matches = index.get(String(value));
-                if (matches) {
-                    const results = [];
-                    for (const logicalId of matches) {
-                        const physicalId = this.keyIndex.get(table).get(logicalId);
-                        if (physicalId !== undefined) {
-                            const doc = await this.db.get(physicalId);
-                            if (doc)
-                                results.push(doc);
-                        }
-                    }
-                    this.recordMetric('select', table, Date.now() - start);
-                    return results;
-                }
-                return [];
-            }
-        }
-        const results = [];
-        for (const [logicalId, physicalId] of this.keyIndex.get(table).entries()) {
-            let row = this.rowCache.get(table).get(logicalId);
-            if (!row) {
-                const doc = await this.db.get(physicalId);
-                if (!doc)
-                    continue;
-                row = doc;
-                this.rowCache.get(table).set(logicalId, row);
-            }
-            if (this._matches(row, where))
-                results.push({ ...row });
-        }
-        this.recordMetric('select', table, Date.now() - start);
-        return results;
+        return this._execute(() => this._rawSelect(table, where));
     }
     async selectOne(table, where = null) {
         const res = await this.select(table, where);
         return res[0] || null;
     }
     async insert(table, data) {
-        const start = Date.now();
-        await this.initPromise;
-        await this.ensureTable(table);
-        await this.runHooks('beforeInsert', table, data);
-        const nextId = (this.tableMaxId.get(table) || 0) + 1;
-        const record = this._coerce(table, data, nextId);
-        const physicalId = await this.db.insert(record);
-        this.tableMaxId.set(table, nextId);
-        this.keyIndex.get(table).set(nextId, physicalId);
-        const fullRow = { _id: nextId, ...data };
-        this.rowCache.get(table).set(nextId, fullRow);
-        this._updateSecondaryIndex(table, nextId, fullRow);
-        await this.runHooks('afterInsert', table, fullRow);
-        this.recordMetric('insert', table, Date.now() - start);
-        return nextId;
+        return this._execute(async () => {
+            await this.ensureTable(table);
+            await this.runHooks('beforeInsert', table, data);
+            const nextId = (this.tableMaxId.get(table) || 0) + 1;
+            const record = this._coerce(table, data, nextId);
+            const physicalId = await this.db.insert(record);
+            this.tableMaxId.set(table, nextId);
+            this.keyIndex.get(table).set(nextId, BigInt(physicalId));
+            const fullRow = { _id: nextId, ...data };
+            this.rowCache.get(table).set(nextId, fullRow);
+            this._updateSecondaryIndex(table, nextId, fullRow);
+            await this.runHooks('afterInsert', table, fullRow);
+            return nextId;
+        });
     }
     async update(table, data, where) {
-        const start = Date.now();
-        const rows = await this.select(table, where);
-        for (const row of rows) {
-            const logicalId = row._id;
-            await this.runHooks('beforeUpdate', table, { old: row, new: data });
-            const merged = { ...row, ...data };
-            const record = this._coerce(table, merged, logicalId);
-            const physicalId = await this.db.insert(record);
-            this.keyIndex.get(table).set(logicalId, physicalId);
-            this.rowCache.get(table).set(logicalId, merged);
-            this._updateSecondaryIndex(table, logicalId, merged, row);
-            await this.runHooks('afterUpdate', table, merged);
-        }
-        this.recordMetric('update', table, Date.now() - start);
-        return rows.length;
+        return this._execute(async () => {
+            const rows = await this._rawSelect(table, where);
+            for (const row of rows) {
+                const logicalId = Number(row._id);
+                await this.runHooks('beforeUpdate', table, { old: row, new: data });
+                const merged = { ...row, ...data };
+                const record = this._coerce(table, merged, logicalId);
+                const physicalId = await this.db.insert(record);
+                this.keyIndex.get(table).set(logicalId, BigInt(physicalId));
+                this.rowCache.get(table).set(logicalId, merged);
+                this._updateSecondaryIndex(table, logicalId, merged, row);
+                await this.runHooks('afterUpdate', table, merged);
+            }
+            return rows.length;
+        });
     }
     async delete(table, where) {
-        const start = Date.now();
-        const rows = await this.select(table, where);
-        for (const row of rows) {
-            const logicalId = row._id;
-            await this.runHooks('beforeDelete', table, row);
-            const physicalId = this.keyIndex.get(table).get(logicalId);
-            if (physicalId !== undefined) {
-                await this.db.delete(physicalId);
-                this.keyIndex.get(table).delete(logicalId);
-                this.rowCache.get(table).delete(logicalId);
-                this._updateSecondaryIndex(table, logicalId, {}, row);
+        return this._execute(async () => {
+            const rows = await this._rawSelect(table, where);
+            for (const row of rows) {
+                const logicalId = Number(row._id);
+                await this.runHooks('beforeDelete', table, row);
+                const physicalId = this.keyIndex.get(table).get(logicalId);
+                if (physicalId !== undefined) {
+                    await this.db.delete(Number(physicalId));
+                    this.keyIndex.get(table).delete(logicalId);
+                    this.rowCache.get(table).delete(logicalId);
+                    this._updateSecondaryIndex(table, logicalId, {}, row);
+                }
+                await this.runHooks('afterDelete', table, row);
             }
-            await this.runHooks('afterDelete', table, row);
-        }
-        this.recordMetric('delete', table, Date.now() - start);
-        return rows.length;
+            return rows.length;
+        });
     }
     async set(table, data, where) {
-        const ex = await this.selectOne(table, where);
-        return ex ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
+        return this._execute(async () => {
+            const existing = await this._rawSelect(table, where);
+            if (existing.length > 0) {
+                // Update logic here directly using _raw logic
+                const row = existing[0];
+                const logicalId = Number(row._id);
+                const merged = { ...row, ...data };
+                const record = this._coerce(table, merged, logicalId);
+                const physicalId = await this.db.insert(record);
+                this.keyIndex.get(table).set(logicalId, BigInt(physicalId));
+                this.rowCache.get(table).set(logicalId, merged);
+                this._updateSecondaryIndex(table, logicalId, merged, row);
+                return logicalId;
+            }
+            else {
+                // Insert logic here directly
+                const nextId = (this.tableMaxId.get(table) || 0) + 1;
+                const record = this._coerce(table, { ...where, ...data }, nextId);
+                const physicalId = await this.db.insert(record);
+                this.tableMaxId.set(table, nextId);
+                this.keyIndex.get(table).set(nextId, BigInt(physicalId));
+                const fullRow = { _id: nextId, ...where, ...data };
+                this.rowCache.get(table).set(nextId, fullRow);
+                this._updateSecondaryIndex(table, nextId, fullRow);
+                return nextId;
+            }
+        });
     }
     async bulkInsert(table, dataArray) {
-        for (const d of dataArray)
-            await this.insert(table, d);
-        return dataArray.length;
+        return this._execute(async () => {
+            for (const d of dataArray) {
+                const nextId = (this.tableMaxId.get(table) || 0) + 1;
+                const record = this._coerce(table, d, nextId);
+                const physicalId = await this.db.insert(record);
+                this.tableMaxId.set(table, nextId);
+                this.keyIndex.get(table).set(nextId, BigInt(physicalId));
+                const fullRow = { _id: nextId, ...d };
+                this.rowCache.get(table).set(nextId, fullRow);
+                this._updateSecondaryIndex(table, nextId, fullRow);
+            }
+            return dataArray.length;
+        });
     }
     async increment(table, incs, where = {}) {
-        const rows = await this.select(table, where);
-        for (const row of rows) {
-            const updated = { ...row };
-            for (const [f, v] of Object.entries(incs))
-                updated[f] = (Number(updated[f]) || 0) + v;
-            await this.update(table, updated, { _id: row._id });
-        }
-        return rows.length;
+        return this._execute(async () => {
+            const rows = await this._rawSelect(table, where);
+            for (const row of rows) {
+                const logicalId = Number(row._id);
+                const merged = { ...row };
+                for (const [f, v] of Object.entries(incs))
+                    merged[f] = (Number(merged[f]) || 0) + v;
+                const record = this._coerce(table, merged, logicalId);
+                const physicalId = await this.db.insert(record);
+                this.keyIndex.get(table).set(logicalId, BigInt(physicalId));
+                this.rowCache.get(table).set(logicalId, merged);
+                this._updateSecondaryIndex(table, logicalId, merged, row);
+            }
+            return rows.length;
+        });
     }
     async decrement(table, decs, where = {}) {
         const incs = {};
@@ -535,8 +598,19 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
             incs[k] = -decs[k];
         return this.increment(table, incs, where);
     }
-    async vacuum() { await this.db.vacuum(); }
-    async close() { await this.db.close(); }
+    async vacuum() {
+        return this._execute(async () => {
+            await this.db.vacuum();
+        });
+    }
+    async close() {
+        this._isClosing = true;
+        try {
+            await this._executing;
+            await this.db.close();
+        }
+        catch (e) { }
+    }
 }
 exports.ZPackAdapter = ZPackAdapter;
 exports.default = ZPackAdapter;

package/dist/functions/toon.d.ts

@@ -4,4 +4,7 @@
  * API matches standard JSON object (stringify/parse).
  */
 export declare function stringify(data: any, indent?: number): string;
+/**
+ * Advanced TOON Parser with Indentation Support for Deep Nesting
+ */
 export declare function parse(toonStr: string): any;

package/dist/functions/toon.js

@@ -14,7 +14,7 @@ function stringify(data, indent = 0) {
     if (typeof data === 'boolean' || typeof data === 'number')
         return String(data);
     if (typeof data === 'string') {
-        const hasSpecial = new RegExp('[\,\n:]').test(data);
+        const hasSpecial = new RegExp('[\,\n: ]').test(data);
         if (hasSpecial)
             return '"' + data.replace(/"/g, '\\"') + '"';
         return data;
@@ -36,7 +36,7 @@ function stringify(data, indent = 0) {
                         if (val === null)
                             return 'null';
                         const valStr = String(val);
-                        const hasSpecialRow = new RegExp('[\,\n:]').test(valStr);
+                        const hasSpecialRow = new RegExp('[\,\n: ]').test(valStr);
                         return (typeof val === 'string' && hasSpecialRow) ? '"' + valStr + '"' : valStr;
                     }).join(',');
                     return space + '  ' + rowValues;
@@ -59,60 +59,86 @@ function stringify(data, indent = 0) {
     }
     return '';
 }
+/**
+ * Advanced TOON Parser with Indentation Support for Deep Nesting
+ */
 function parse(toonStr) {
     if (!toonStr || toonStr.trim() === '')
         return {};
-    const lines = toonStr.split('\n').filter(l => l.trim() !== '');
-    const result = {};
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i].trim();
-        const tabularMatch = line.match(/^(\w+)\[(\d+)\]\{(.*)\}:$/);
-        if (tabularMatch) {
-            const tableName = tabularMatch[1];
-            const rowCount = parseInt(tabularMatch[2]);
-            const fields = tabularMatch[3].split(',');
-            const rows = [];
-            for (let j = 0; j < rowCount; j++) {
+    const lines = toonStr.split('\n').filter(l => l.trim() !== '' || l.startsWith(' '));
+    function parseValue(val) {
+        const trimmed = val.trim().replace(/^"|"$/g, '');
+        if (trimmed === 'true')
+            return true;
+        if (trimmed === 'false')
+            return false;
+        if (trimmed === 'null')
+            return null;
+        if (trimmed === '[]')
+            return [];
+        if (trimmed === '{}')
+            return {};
+        if (!isNaN(Number(trimmed)) && trimmed !== '')
+            return Number(trimmed);
+        return trimmed;
+    }
+    function getIndent(line) {
+        const match = line.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+    }
+    function processLines(startIndex, currentIndent) {
+        const result = {};
+        let i = startIndex;
+        while (i < lines.length) {
+            const line = lines[i];
+            const indent = getIndent(line);
+            const content = line.trim();
+            if (content === '') {
                 i++;
-                if (!lines[i])
-                    break;
-                const values = lines[i].trim().split(',').map(v => {
-                    const trimmed = v.trim();
-                    if (trimmed === 'true')
-                        return true;
-                    if (trimmed === 'false')
-                        return false;
-                    if (trimmed === 'null')
-                        return null;
-                    if (!isNaN(Number(trimmed)) && trimmed !== '')
-                        return Number(trimmed);
-                    return trimmed.replace(/^"|"$/g, '');
-                });
-                const row = {};
-                fields.forEach((f, idx) => row[f] = values[idx]);
-                rows.push(row);
+                continue;
             }
-            result[tableName] = rows;
-        }
-        else {
-            const kvMatch = line.match(/^(\w+):\s*(.*)$/);
+            if (indent < currentIndent)
+                break;
+            // Tabular Array Match: key[count]{fields}:
+            const tabularMatch = content.match(/^(\w+)\[(\d+)\]\{(.*)\}:$/);
+            if (tabularMatch) {
+                const key = tabularMatch[1];
+                const rowCount = parseInt(tabularMatch[2]);
+                const fields = tabularMatch[3].split(',');
+                const rows = [];
+                for (let j = 0; j < rowCount; j++) {
+                    i++;
+                    if (!lines[i])
+                        break;
+                    const values = lines[i].trim().split(',').map(v => parseValue(v));
+                    const row = {};
+                    fields.forEach((f, idx) => row[f] = values[idx]);
+                    rows.push(row);
+                }
+                result[key] = rows;
+                i++;
+                continue;
+            }
+            // Standard Key-Value or Nested Object: key: value
+            const kvMatch = content.match(/^(\w+):(.*)$/);
             if (kvMatch) {
                 const key = kvMatch[1];
-                const value = kvMatch[2];
-                let parsedVal = value.trim();
-                if (parsedVal === 'true')
-                    parsedVal = true;
-                else if (parsedVal === 'false')
-                    parsedVal = false;
-                else if (parsedVal === 'null')
-                    parsedVal = null;
-                else if (!isNaN(Number(parsedVal)) && parsedVal !== '')
-                    parsedVal = Number(parsedVal);
-                result[key] = parsedVal;
+                const valuePart = kvMatch[2].trim();
+                if (valuePart === '' && i + 1 < lines.length && getIndent(lines[i + 1]) > indent) {
+                    // It's a nested object
+                    const [nestedObj, nextIndex] = processLines(i + 1, getIndent(lines[i + 1]));
+                    result[key] = nestedObj;
+                    i = nextIndex;
+                    continue;
+                }
+                else {
+                    result[key] = parseValue(valuePart);
+                }
             }
+            i++;
         }
-        i++;
+        return [result, i];
     }
-    return result;
+    const [finalResult] = processLines(0, 0);
+    return finalResult;
 }

package/dist/tests/test.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_1 = __importDefault(require("../database"));
+const run = async () => {
+    const db = (0, database_1.default)({
+        adapter: 'toon',
+        config: {
+            path: './data.toon',
+            cache: {
+                type: 'memory',
+                ttl: 1000,
+                max: 1000,
+            }
+        }
+    });
+    await db.set('testTable', { userName: 'Onur Ege', age: 21 }, { userName: 'Onur Ege' });
+    console.log(await db.selectOne('testTable', { age: 21 }));
+};
+run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onurege3467/zerohelper",
-  "version": "9.2.0",
+  "version": "10.0.0",
   "description": "ZeroHelper is a versatile high-performance utility library and database framework for Node.js, fully written in TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/functions/temp_isphone.d.ts

@@ -1 +0,0 @@
-export declare function isPhone(phone: string): boolean;

package/dist/functions/temp_isphone.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPhone = isPhone;
-function isPhone(phone) {
-    const phoneRegex = /^[\+]?[1-9][\d]{0,15}$/;
-    return phoneRegex.test(phone.replace(/[\s\-\(\)]/g, ''));
-}