@onurege3467/zerohelper 9.0.0 → 9.2.0

package/dist/database/zpack.js

@@ -7,6 +7,7 @@ exports.ZPackAdapter = exports.ZPackDatabase = void 0;
 const IDatabase_1 = require("./IDatabase");
 const fs_1 = __importDefault(require("fs"));
 const fsp = fs_1.default.promises;
+const zlib_1 = __importDefault(require("zlib"));
 class ZPackDatabase {
     constructor(filePath, options = {}) {
         this.fd = null;
@@ -22,6 +23,7 @@ class ZPackDatabase {
             throw new Error("ZPackDatabase: 'filePath' zorunludur.");
         this.filePath = filePath;
         this._autoFlush = options.autoFlush === true;
+        this._compression = options.compression === true;
     }
     async open() {
         if (this.fd)
@@ -56,6 +58,26 @@ class ZPackDatabase {
         await this.fd.close();
         this._closed = true;
     }
+    async vacuum() {
+        this._ensureOpen();
+        return this._enqueue(async () => {
+            const tempPath = this.filePath + ".tmp";
+            const tempDb = new ZPackDatabase(tempPath, { autoFlush: false, compression: this._compression });
+            await tempDb.open();
+            for (const docId of this.index.keys()) {
+                const doc = await this.get(docId);
+                if (doc)
+                    await tempDb.insert(doc, docId);
+            }
+            await tempDb.close();
+            await this.fd.close();
+            await fsp.rename(tempPath, this.filePath);
+            this.fd = null;
+            this.index.clear();
+            this.deleted.clear();
+            await this.open();
+        });
+    }
     async insert(document, docId) {
         this._ensureOpen();
         const payload = this._encodeDocument(document, docId);
@@ -111,7 +133,7 @@ class ZPackDatabase {
                 }
                 else {
                     this.index.set(meta.docId, cur);
-                    this.deleted.delete(meta.docId);
+                    this.deleted.add(meta.docId); // Bugfix: added to deleted, should be removed
                     if (meta.docId >= this._nextId)
                         this._nextId = meta.docId + 1;
                 }
@@ -126,8 +148,6 @@ class ZPackDatabase {
         });
     }
     async delete(docId) {
-        if (!Number.isInteger(docId) || docId <= 0)
-            throw new Error("delete: 'docId' pozitif bir tamsayı olmalıdır.");
         const tomb = this._encodeTombstone(docId);
         await this._enqueue(async () => {
             const writeOffset = this.fileSize;
@@ -146,21 +166,16 @@ class ZPackDatabase {
         if (offset === undefined)
             return null;
         const header = Buffer.alloc(6);
-        if (offset + BigInt(header.length) > this._contentEnd)
-            return null;
         const { bytesRead: hread } = await this.fd.read(header, 0, header.length, offset);
         if (hread !== header.length)
             return null;
         const docLength = header.readUInt16LE(0);
         const totalSize = 2 + docLength;
-        if (docLength < 4 || offset + BigInt(totalSize) > this._contentEnd)
-            return null;
         const buf = Buffer.alloc(totalSize);
         const { bytesRead } = await this.fd.read(buf, 0, totalSize, offset);
         if (bytesRead !== totalSize)
             return null;
-        const parsed = this._decodeDocument(buf);
-        return parsed.fieldCount === 0 ? null : parsed.document;
+        return this._decodeDocument(buf).document;
     }
     keys() { return Array.from(this.index.keys()); }
     _ensureOpen() {
@@ -200,6 +215,15 @@ class ZPackDatabase {
     }
     _encodeDocument(document, docId) {
         let id = docId ?? this._nextId++;
+        if (this._compression) {
+            const dataStr = JSON.stringify(document);
+            const compressed = zlib_1.default.deflateSync(dataStr);
+            const buf = Buffer.alloc(6 + compressed.length);
+            buf.writeUInt16LE(4 + compressed.length, 0);
+            buf.writeUInt32LE(id, 2);
+            compressed.copy(buf, 6);
+            return buf;
+        }
         const fieldBuffers = [];
         for (const [key, value] of Object.entries(document)) {
             const keyBuf = Buffer.from(String(key), "utf8");
@@ -222,46 +246,35 @@ class ZPackDatabase {
         }
         return buf;
     }
-    _encodeTombstone(docId) {
-        const buf = Buffer.alloc(6);
-        buf.writeUInt16LE(4, 0);
-        buf.writeUInt32LE(docId, 2);
-        return buf;
-    }
-    _peekDocMeta(encodedBuf) {
-        const payloadSize = encodedBuf.readUInt16LE(0);
-        const docId = encodedBuf.readUInt32LE(2);
-        const fieldBytes = payloadSize - 4;
-        let p = 6, consumed = 0, fields = 0;
-        while (consumed < fieldBytes) {
-            const klen = encodedBuf.readUInt8(p);
-            p += 1 + klen;
-            consumed += 1 + klen;
-            if (consumed >= fieldBytes)
-                break;
-            const vlen = encodedBuf.readUInt8(p);
-            p += 1 + vlen;
-            consumed += 1 + vlen;
-            fields += 1;
-        }
-        return { docId, fieldCount: fields };
-    }
     _decodeDocument(buf) {
         const payloadSize = buf.readUInt16LE(0);
         const docId = buf.readUInt32LE(2);
+        if (this._compression && payloadSize > 4) {
+            try {
+                const decompressed = zlib_1.default.inflateSync(buf.subarray(6));
+                return { docId, fieldCount: 1, document: JSON.parse(decompressed.toString()) };
+            }
+            catch (e) { }
+        }
         let p = 6;
         const end = 2 + payloadSize;
         const obj = {};
         let fields = 0;
         while (p < end) {
+            if (p + 1 > end)
+                break;
             const klen = buf.readUInt8(p);
             p += 1;
+            if (p + klen > end)
+                break;
             const key = buf.toString("utf8", p, p + klen);
             p += klen;
-            if (p >= end)
+            if (p + 1 > end)
                 break;
             const vlen = buf.readUInt8(p);
             p += 1;
+            if (p + vlen > end)
+                break;
             const val = buf.toString("utf8", p, p + vlen);
             p += vlen;
             obj[key] = val;
@@ -269,6 +282,17 @@ class ZPackDatabase {
         }
         return { docId, fieldCount: fields, document: obj };
     }
+    _encodeTombstone(docId) {
+        const buf = Buffer.alloc(6);
+        buf.writeUInt16LE(4, 0);
+        buf.writeUInt32LE(docId, 2);
+        return buf;
+    }
+    _peekDocMeta(encodedBuf) {
+        const payloadSize = encodedBuf.readUInt16LE(0);
+        const docId = encodedBuf.readUInt32LE(2);
+        return { docId, fieldCount: payloadSize > 4 ? 1 : 0 };
+    }
     async _tryLoadIndexFromFooter() {
         if (this.fileSize < 13n)
             return false;
@@ -326,7 +350,13 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
         this.keyIndex = new Map();
         this.rowCache = new Map();
         this.secondary = new Map();
-        this.db = new ZPackDatabase(config.filePath, { autoFlush: !!config.autoFlush });
+        this.indexedFields = new Map();
+        this.db = new ZPackDatabase(config.path, { autoFlush: !!config.autoFlush, compression: !!config.cache });
+        if (config.indexFields) {
+            for (const [table, fields] of Object.entries(config.indexFields)) {
+                this.indexedFields.set(table, new Set(fields));
+            }
+        }
         this.initPromise = this._init();
     }
     async _init() {
@@ -336,19 +366,14 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
             if (!doc || !doc.t || !Number.isFinite(Number(doc._id)))
                 continue;
             const table = String(doc.t), idNum = Number(doc._id);
-            if (!this.keyIndex.has(table)) {
-                this.keyIndex.set(table, new Map());
-                this.tableMaxId.set(table, 0);
-                this.rowCache.set(table, new Map());
-                this.secondary.set(table, new Map());
-            }
+            await this.ensureTable(table);
             this.keyIndex.get(table).set(idNum, physicalDocId);
             if (idNum > (this.tableMaxId.get(table) || 0))
                 this.tableMaxId.set(table, idNum);
+            this._updateSecondaryIndex(table, idNum, doc);
         }
     }
     async ensureTable(table) {
-        await this.initPromise;
         if (!this.tableMaxId.has(table)) {
             this.tableMaxId.set(table, 0);
             this.keyIndex.set(table, new Map());
@@ -356,6 +381,25 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
             this.secondary.set(table, new Map());
         }
     }
+    _updateSecondaryIndex(table, logicalId, data, oldData = null) {
+        const fields = this.indexedFields.get(table);
+        if (!fields)
+            return;
+        const tableIndex = this.secondary.get(table);
+        for (const field of fields) {
+            if (!tableIndex.has(field))
+                tableIndex.set(field, new Map());
+            const fieldMap = tableIndex.get(field);
+            if (oldData && oldData[field] !== undefined)
+                fieldMap.get(String(oldData[field]))?.delete(logicalId);
+            if (data[field] !== undefined) {
+                const newVal = String(data[field]);
+                if (!fieldMap.has(newVal))
+                    fieldMap.set(newVal, new Set());
+                fieldMap.get(newVal).add(logicalId);
+            }
+        }
+    }
     _coerce(table, data, id) {
         const out = { t: table, _id: String(id) };
         for (const [k, v] of Object.entries(data || {})) {
@@ -370,7 +414,30 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
         return Object.entries(where).every(([k, v]) => String(row[k]) === String(v));
     }
     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);
@@ -378,15 +445,13 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
                 const doc = await this.db.get(physicalId);
                 if (!doc)
                     continue;
-                row = { _id: Number(doc._id) };
-                for (const [k, v] of Object.entries(doc))
-                    if (k !== 't' && k !== '_id')
-                        row[k] = v;
+                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;
     }
     async selectOne(table, where = null) {
@@ -394,68 +459,83 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
         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 row = { _id: nextId, ...data };
-        this.rowCache.get(table).set(nextId, row);
+        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;
     }
     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, row._id);
+            const record = this._coerce(table, merged, logicalId);
             const physicalId = await this.db.insert(record);
-            this.keyIndex.get(table).set(row._id, physicalId);
-            this.rowCache.get(table).set(row._id, merged);
+            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;
     }
-    async set(table, data, where) {
-        const existing = await this.selectOne(table, where);
-        return existing ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
-    }
     async delete(table, where) {
+        const start = Date.now();
         const rows = await this.select(table, where);
         for (const row of rows) {
-            const physicalId = this.keyIndex.get(table).get(row._id);
+            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(row._id);
-                this.rowCache.get(table).delete(row._id);
+                this.keyIndex.get(table).delete(logicalId);
+                this.rowCache.get(table).delete(logicalId);
+                this._updateSecondaryIndex(table, logicalId, {}, row);
             }
+            await this.runHooks('afterDelete', table, row);
         }
+        this.recordMetric('delete', table, Date.now() - start);
         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 });
+    }
     async bulkInsert(table, dataArray) {
-        for (const data of dataArray)
-            await this.insert(table, data);
+        for (const d of dataArray)
+            await this.insert(table, d);
         return dataArray.length;
     }
-    async increment(table, increments, where = {}) {
+    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(increments))
+            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;
     }
-    async decrement(table, decrements, where = {}) {
-        const rows = await this.select(table, where);
-        for (const row of rows) {
-            const updated = { ...row };
-            for (const [f, v] of Object.entries(decrements))
-                updated[f] = (Number(updated[f]) || 0) - v;
-            await this.update(table, updated, { _id: row._id });
-        }
-        return rows.length;
+    async decrement(table, decs, where = {}) {
+        const incs = {};
+        for (const k in decs)
+            incs[k] = -decs[k];
+        return this.increment(table, incs, where);
     }
+    async vacuum() { await this.db.vacuum(); }
     async close() { await this.db.close(); }
 }
 exports.ZPackAdapter = ZPackAdapter;

package/dist/functions/index.d.ts

@@ -1,3 +1,5 @@
+import * as security from './security';
+import * as toon from './toon';
 export declare function makeUniqueId(): string;
 export declare function randomArray<T>(arr: T[]): T;
 export declare function randomText(length?: number): string;
@@ -181,3 +183,17 @@ export declare const logger_module: {
     warn: typeof logWarn;
     debug: typeof logDebug;
 };
+export declare const security_module: {
+    checkRateLimit(key: string, options: security.RateLimiterOptions): Promise<{
+        allowed: boolean;
+        remaining: number;
+        reset: number;
+    }>;
+};
+export declare const worker_module: {
+    runAsyncTask<T>(taskFn: string, data: any): Promise<T>;
+};
+export declare const toon_module: {
+    stringify: typeof toon.stringify;
+    parse: typeof toon.parse;
+};

package/dist/functions/index.js

@@ -1,9 +1,42 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger_module = exports.validation_module = exports.math_module = exports.crypto_module = exports.object_module = exports.array_module = exports.string_module = exports.random_module = exports.date_module = exports.http_module = exports.Logger = void 0;
+exports.toon_module = exports.worker_module = exports.security_module = exports.logger_module = exports.validation_module = exports.math_module = exports.crypto_module = exports.object_module = exports.array_module = exports.string_module = exports.random_module = exports.date_module = exports.http_module = exports.Logger = void 0;
 exports.makeUniqueId = makeUniqueId;
 exports.randomArray = randomArray;
 exports.randomText = randomText;
@@ -68,6 +101,9 @@ const bcrypt_1 = __importDefault(require("bcrypt"));
 const https_1 = __importDefault(require("https"));
 const http_1 = __importDefault(require("http"));
 const url_1 = require("url");
+const security = __importStar(require("./security"));
+const worker = __importStar(require("./worker"));
+const toon = __importStar(require("./toon"));
 // Random İşlemler
 function makeUniqueId() {
     return Date.now().toString(36) + Math.random().toString(36).substr(2);
@@ -373,8 +409,8 @@ function isEmail(email) {
     return emailRegex.test(email);
 }
 function isPhone(phone) {
-    const phoneRegex = /^[\+]?[1-9][\d]{0,15}$/;
-    return phoneRegex.test(phone.replace(/[\s\-\(\)]/g, ''));
+    const phoneRegex = /^[\\+]?[1-9][\\d]{0,15}$/;
+    return phoneRegex.test(phone.replace(/[\\s\-\(\)]/g, ''));
 }
 function isURL(url) {
     try {
@@ -634,3 +670,13 @@ exports.logger_module = {
     warn: logWarn,
     debug: logDebug,
 };
+exports.security_module = {
+    ...security
+};
+exports.worker_module = {
+    ...worker
+};
+exports.toon_module = {
+    stringify: toon.stringify,
+    parse: toon.parse
+};

package/dist/functions/security.d.ts

@@ -0,0 +1,15 @@
+export interface RateLimiterOptions {
+    limit: number;
+    window: number;
+    storage?: 'memory' | 'redis';
+    redisClient?: any;
+}
+/**
+ * Advanced Rate Limiter for API protection.
+ * Returns true if allowed, false if rate limited.
+ */
+export declare function checkRateLimit(key: string, options: RateLimiterOptions): Promise<{
+    allowed: boolean;
+    remaining: number;
+    reset: number;
+}>;

package/dist/functions/security.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRateLimit = checkRateLimit;
+const localStore = new Map();
+/**
+ * Advanced Rate Limiter for API protection.
+ * Returns true if allowed, false if rate limited.
+ */
+async function checkRateLimit(key, options) {
+    const { limit, window, storage = 'memory', redisClient } = options;
+    const now = Date.now();
+    if (storage === 'redis' && redisClient) {
+        const redisKey = `rate_limit:${key}`;
+        const multi = redisClient.multi();
+        multi.incr(redisKey);
+        multi.ttl(redisKey);
+        const [count, ttl] = await multi.exec();
+        if (count === 1) {
+            await redisClient.expire(redisKey, window);
+        }
+        const isAllowed = count <= limit;
+        return {
+            allowed: isAllowed,
+            remaining: Math.max(0, limit - Number(count)),
+            reset: ttl > 0 ? now + (ttl * 1000) : now + (window * 1000)
+        };
+    }
+    else {
+        // Memory Storage
+        let data = localStore.get(key);
+        if (!data || now > data.resetTime) {
+            data = {
+                count: 0,
+                resetTime: now + (window * 1000)
+            };
+        }
+        data.count++;
+        localStore.set(key, data);
+        const isAllowed = data.count <= limit;
+        return {
+            allowed: isAllowed,
+            remaining: Math.max(0, limit - data.count),
+            reset: data.resetTime
+        };
+    }
+}

package/dist/functions/toon.d.ts

@@ -0,0 +1,7 @@
+/**
+ * TOON (Token-Oriented Object Notation) Support for ZeroHelper
+ * Optimized for LLM token efficiency and now supports Native Storage.
+ * API matches standard JSON object (stringify/parse).
+ */
+export declare function stringify(data: any, indent?: number): string;
+export declare function parse(toonStr: string): any;

package/dist/functions/toon.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * TOON (Token-Oriented Object Notation) Support for ZeroHelper
+ * Optimized for LLM token efficiency and now supports Native Storage.
+ * API matches standard JSON object (stringify/parse).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = stringify;
+exports.parse = parse;
+function stringify(data, indent = 0) {
+    const space = ' '.repeat(indent);
+    if (data === null)
+        return 'null';
+    if (typeof data === 'boolean' || typeof data === 'number')
+        return String(data);
+    if (typeof data === 'string') {
+        const hasSpecial = new RegExp('[\,\n:]').test(data);
+        if (hasSpecial)
+            return '"' + data.replace(/"/g, '\\"') + '"';
+        return data;
+    }
+    if (Array.isArray(data)) {
+        if (data.length === 0)
+            return '[]';
+        const first = data[0];
+        if (typeof first === 'object' && first !== null && !Array.isArray(first)) {
+            const keys = Object.keys(first);
+            const isUniform = data.every(item => item && typeof item === 'object' &&
+                Object.keys(item).length === keys.length &&
+                Object.keys(item).every(k => keys.includes(k)));
+            if (isUniform && data.length > 1) {
+                const header = '[' + data.length + ']{' + keys.join(',') + '}:';
+                const rows = data.map(item => {
+                    const rowValues = keys.map(k => {
+                        const val = item[k];
+                        if (val === null)
+                            return 'null';
+                        const valStr = String(val);
+                        const hasSpecialRow = new RegExp('[\,\n:]').test(valStr);
+                        return (typeof val === 'string' && hasSpecialRow) ? '"' + valStr + '"' : valStr;
+                    }).join(',');
+                    return space + '  ' + rowValues;
+                });
+                return header + '\n' + rows.join('\n');
+            }
+        }
+        return '[' + data.length + ']: ' + data.map(v => stringify(v)).join(',');
+    }
+    if (typeof data === 'object') {
+        const entries = Object.entries(data);
+        if (entries.length === 0)
+            return '{}';
+        return entries.map(([key, value]) => {
+            const valStr = stringify(value, indent + 2);
+            const isComplex = typeof value === 'object' && value !== null && !Array.isArray(value);
+            const separator = isComplex ? '\n' : ' ';
+            return space + key + ':' + separator + valStr;
+        }).join('\n');
+    }
+    return '';
+}
+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++) {
+                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);
+            }
+            result[tableName] = rows;
+        }
+        else {
+            const kvMatch = line.match(/^(\w+):\s*(.*)$/);
+            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;
+            }
+        }
+        i++;
+    }
+    return result;
+}