@goplasmatic/datalogic 4.0.6 → 4.0.8

package/README.md

@@ -19,15 +19,15 @@ import init, { evaluate, CompiledRule } from '@goplasmatic/datalogic';
 await init();
 
 // Simple evaluation
-const result = evaluate('{"==": [1, 1]}', '{}');
+const result = evaluate('{"==": [1, 1]}', '{}', false);
 console.log(result); // "true"
 
 // With data
-const result2 = evaluate('{"var": "user.age"}', '{"user": {"age": 25}}');
+const result2 = evaluate('{"var": "user.age"}', '{"user": {"age": 25}}', false);
 console.log(result2); // "25"
 
 // Compiled rule for repeated evaluation (better performance)
-const rule = new CompiledRule('{"+": [{"var": "a"}, {"var": "b"}]}');
+const rule = new CompiledRule('{"+": [{"var": "a"}, {"var": "b"}]}', false);
 console.log(rule.evaluate('{"a": 1, "b": 2}')); // "3"
 console.log(rule.evaluate('{"a": 10, "b": 20}')); // "30"
 ```
@@ -45,7 +45,7 @@ async function run() {
     await init();
 
     // Now you can use evaluate and CompiledRule
-    const result = evaluate('{"and": [true, {"var": "active"}]}', '{"active": true}');
+    const result = evaluate('{"and": [true, {"var": "active"}]}', '{"active": true}', false);
     console.log(result); // "true"
 }
 
@@ -60,11 +60,11 @@ run();
 import { evaluate, CompiledRule } from '@goplasmatic/datalogic';
 
 // No init() needed for Node.js
-const result = evaluate('{"==": [1, 1]}', '{}');
+const result = evaluate('{"==": [1, 1]}', '{}', false);
 console.log(result); // "true"
 
 // Compiled rule
-const rule = new CompiledRule('{"if": [{"var": "premium"}, "VIP", "Standard"]}');
+const rule = new CompiledRule('{"if": [{"var": "premium"}, "VIP", "Standard"]}', false);
 console.log(rule.evaluate('{"premium": true}')); // "\"VIP\""
 console.log(rule.evaluate('{"premium": false}')); // "\"Standard\""
 ```
@@ -77,7 +77,7 @@ import init, { evaluate, CompiledRule } from '@goplasmatic/datalogic';
 // For bundlers, you may need to initialize
 await init();
 
-const result = evaluate('{">=": [{"var": "score"}, 80]}', '{"score": 85}');
+const result = evaluate('{">=": [{"var": "score"}, 80]}', '{"score": 85}', false);
 console.log(result); // "true"
 ```
 
@@ -98,31 +98,37 @@ import { evaluate } from '@goplasmatic/datalogic/nodejs';
 
 ## API Reference
 
-### `evaluate(logic: string, data: string): string`
+### `evaluate(logic: string, data: string, preserve_structure: boolean): string`
 
 Evaluate a JSONLogic expression against data.
 
 **Parameters:**
 - `logic` - JSON string containing the JSONLogic expression
 - `data` - JSON string containing the data to evaluate against
+- `preserve_structure` - If `true`, preserves object structure for JSON templates with embedded JSONLogic (templating mode)
 
 **Returns:** JSON string result
 
 **Throws:** Error string on invalid JSON or evaluation error
 
 ```javascript
-evaluate('{"==": [{"var": "x"}, 5]}', '{"x": 5}'); // "true"
-evaluate('{"+": [1, 2, 3]}', '{}'); // "6"
-evaluate('{"map": [[1,2,3], {"+": [{"var": ""}, 1]}]}', '{}'); // "[2,3,4]"
+evaluate('{"==": [{"var": "x"}, 5]}', '{"x": 5}', false); // "true"
+evaluate('{"+": [1, 2, 3]}', '{}', false); // "6"
+evaluate('{"map": [[1,2,3], {"+": [{"var": ""}, 1]}]}', '{}', false); // "[2,3,4]"
+
+// With preserve_structure for templating
+evaluate('{"name": {"var": "user"}, "active": true}', '{"user": "Alice"}', true);
+// '{"name":"Alice","active":true}'
 ```
 
-### `evaluate_with_trace(logic: string, data: string): string`
+### `evaluate_with_trace(logic: string, data: string, preserve_structure: boolean): string`
 
 Evaluate with execution trace for debugging. Returns detailed step-by-step information about how the expression was evaluated.
 
 **Parameters:**
 - `logic` - JSON string containing the JSONLogic expression
 - `data` - JSON string containing the data to evaluate against
+- `preserve_structure` - If `true`, preserves object structure for JSON templates with embedded JSONLogic (templating mode)
 
 **Returns:** JSON string containing `TracedResult` with:
 - `result` - The evaluation result
@@ -130,7 +136,7 @@ Evaluate with execution trace for debugging. Returns detailed step-by-step infor
 - `steps` - Array of execution steps with context and intermediate results
 
 ```javascript
-const trace = evaluate_with_trace('{"and": [true, {"var": "x"}]}', '{"x": true}');
+const trace = evaluate_with_trace('{"and": [true, {"var": "x"}]}', '{"x": true}', false);
 console.log(JSON.parse(trace));
 // {
 //   "result": true,
@@ -143,12 +149,16 @@ console.log(JSON.parse(trace));
 
 A compiled JSONLogic rule for repeated evaluation. Pre-compiling rules provides better performance when evaluating the same logic against different data.
 
-#### `new CompiledRule(logic: string)`
+#### `new CompiledRule(logic: string, preserve_structure: boolean)`
 
 Create a new compiled rule.
 
+**Parameters:**
+- `logic` - JSON string containing the JSONLogic expression
+- `preserve_structure` - If `true`, preserves object structure for JSON templates with embedded JSONLogic (templating mode)
+
 ```javascript
-const rule = new CompiledRule('{">=": [{"var": "age"}, 18]}');
+const rule = new CompiledRule('{">=": [{"var": "age"}, 18]}', false);
 ```
 
 #### `evaluate(data: string): string`
@@ -206,7 +216,7 @@ rustup target add wasm32-unknown-unknown
 ### Build
 
 ```bash
-cd datalogic-wasm
+cd wasm
 ./build.sh
 ```
 
@@ -226,8 +236,13 @@ wasm-pack test --headless --firefox
 
 Apache-2.0
 
+## Documentation
+
+For complete documentation including advanced usage, framework integration, and API details, see the [full documentation](https://goplasmatic.github.io/datalogic-rs/javascript/installation.html).
+
 ## Links
 
 - [GitHub Repository](https://github.com/GoPlasmatic/datalogic-rs)
+- [Full Documentation](https://goplasmatic.github.io/datalogic-rs/)
+- [Online Playground](https://goplasmatic.github.io/datalogic-rs/playground/)
 - [JSONLogic Specification](https://jsonlogic.com/)
-- [Documentation](https://goplasmatic.github.io/datalogic-rs/)

package/bundler/datalogic_wasm.d.ts

@@ -9,8 +9,9 @@ export class CompiledRule {
    *
    * # Arguments
    * * `logic` - JSON string containing the JSONLogic expression
+   * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
    */
-  constructor(logic: string);
+  constructor(logic: string, preserve_structure: boolean);
   /**
    * Evaluate the compiled rule against data.
    *
@@ -29,11 +30,12 @@ export class CompiledRule {
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string result or error message
  */
-export function evaluate(logic: string, data: string): string;
+export function evaluate(logic: string, data: string, preserve_structure: boolean): string;
 
 /**
  * Evaluate a JSONLogic expression with execution trace for debugging.
@@ -44,6 +46,7 @@ export function evaluate(logic: string, data: string): string;
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string containing TracedResult (result, expression_tree, steps) or error message
@@ -64,6 +67,6 @@ export function evaluate(logic: string, data: string): string;
  * }
  * ```
  */
-export function evaluate_with_trace(logic: string, data: string): string;
+export function evaluate_with_trace(logic: string, data: string, preserve_structure: boolean): string;
 
 export function init(): void;

package/bundler/datalogic_wasm_bg.js

@@ -3,6 +3,21 @@ export function __wbg_set_wasm(val) {
     wasm = val;
 }
 
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -24,6 +39,13 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -61,10 +83,10 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
 }
 
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -122,18 +144,28 @@ export class CompiledRule {
      *
      * # Arguments
      * * `logic` - JSON string containing the JSONLogic expression
+     * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
      * @param {string} logic
+     * @param {boolean} preserve_structure
      */
-    constructor(logic) {
-        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.compiledrule_new(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    constructor(logic, preserve_structure) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.compiledrule_new(retptr, ptr0, len0, preserve_structure);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            CompiledRuleFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        CompiledRuleFinalization.register(this, this.__wbg_ptr, this);
-        return this;
     }
     /**
      * Evaluate the compiled rule against data.
@@ -150,20 +182,26 @@ export class CompiledRule {
         let deferred3_0;
         let deferred3_1;
         try {
-            const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ret = wasm.compiledrule_evaluate(this.__wbg_ptr, ptr0, len0);
-            var ptr2 = ret[0];
-            var len2 = ret[1];
-            if (ret[3]) {
+            wasm.compiledrule_evaluate(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
                 ptr2 = 0; len2 = 0;
-                throw takeFromExternrefTable0(ret[2]);
+                throw takeObject(r2);
             }
             deferred3_0 = ptr2;
             deferred3_1 = len2;
             return getStringFromWasm0(ptr2, len2);
         } finally {
-            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred3_0, deferred3_1, 1);
         }
     }
 }
@@ -175,33 +213,41 @@ if (Symbol.dispose) CompiledRule.prototype[Symbol.dispose] = CompiledRule.protot
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string result or error message
  * @param {string} logic
  * @param {string} data
+ * @param {boolean} preserve_structure
  * @returns {string}
  */
-export function evaluate(logic, data) {
+export function evaluate(logic, data, preserve_structure) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.evaluate(ptr0, len0, ptr1, len1);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
-        if (ret[3]) {
+        wasm.evaluate(retptr, ptr0, len0, ptr1, len1, preserve_structure);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
             ptr3 = 0; len3 = 0;
-            throw takeFromExternrefTable0(ret[2]);
+            throw takeObject(r2);
         }
         deferred4_0 = ptr3;
         deferred4_1 = len3;
         return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
     }
 }
 
@@ -214,6 +260,7 @@ export function evaluate(logic, data) {
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string containing TracedResult (result, expression_tree, steps) or error message
@@ -235,28 +282,35 @@ export function evaluate(logic, data) {
  * ```
  * @param {string} logic
  * @param {string} data
+ * @param {boolean} preserve_structure
  * @returns {string}
  */
-export function evaluate_with_trace(logic, data) {
+export function evaluate_with_trace(logic, data, preserve_structure) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.evaluate_with_trace(ptr0, len0, ptr1, len1);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
-        if (ret[3]) {
+        wasm.evaluate_with_trace(retptr, ptr0, len0, ptr1, len1, preserve_structure);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
             ptr3 = 0; len3 = 0;
-            throw takeFromExternrefTable0(ret[2]);
+            throw takeObject(r2);
         }
         deferred4_0 = ptr3;
         deferred4_1 = len3;
         return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
     }
 }
 
@@ -276,18 +330,28 @@ export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
         deferred0_1 = arg1;
         console.error(getStringFromWasm0(arg0, arg1));
     } finally {
-        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        wasm.__wbindgen_export(deferred0_0, deferred0_1, 1);
     }
 };
 
+export function __wbg_getTime_ad1e9878a735af08(arg0) {
+    const ret = getObject(arg0).getTime();
+    return ret;
+};
+
+export function __wbg_new_0_23cedd11d9b40c9d() {
+    const ret = new Date();
+    return addHeapObject(ret);
+};
+
 export function __wbg_new_8a6f238a6ece86ea() {
     const ret = new Error();
-    return ret;
+    return addHeapObject(ret);
 };
 
 export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
-    const ret = arg1.stack;
-    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -296,15 +360,9 @@ export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
 export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
+    return addHeapObject(ret);
 };
 
-export function __wbindgen_init_externref_table() {
-    const table = wasm.__wbindgen_externrefs;
-    const offset = table.grow(4);
-    table.set(0, undefined);
-    table.set(offset + 0, undefined);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
 };

package/bundler/datalogic_wasm_bg.wasm.d.ts

@@ -2,14 +2,13 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_compiledrule_free: (a: number, b: number) => void;
-export const compiledrule_evaluate: (a: number, b: number, c: number) => [number, number, number, number];
-export const compiledrule_new: (a: number, b: number) => [number, number, number];
-export const evaluate: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-export const evaluate_with_trace: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const compiledrule_evaluate: (a: number, b: number, c: number, d: number) => void;
+export const compiledrule_new: (a: number, b: number, c: number, d: number) => void;
+export const evaluate: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const evaluate_with_trace: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const init: () => void;
-export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __wbindgen_malloc: (a: number, b: number) => number;
-export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-export const __wbindgen_externrefs: WebAssembly.Table;
-export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_export: (a: number, b: number, c: number) => void;
+export const __wbindgen_export2: (a: number, b: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
 export const __wbindgen_start: () => void;

package/nodejs/datalogic_wasm.d.ts

@@ -9,8 +9,9 @@ export class CompiledRule {
    *
    * # Arguments
    * * `logic` - JSON string containing the JSONLogic expression
+   * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
    */
-  constructor(logic: string);
+  constructor(logic: string, preserve_structure: boolean);
   /**
    * Evaluate the compiled rule against data.
    *
@@ -29,11 +30,12 @@ export class CompiledRule {
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string result or error message
  */
-export function evaluate(logic: string, data: string): string;
+export function evaluate(logic: string, data: string, preserve_structure: boolean): string;
 
 /**
  * Evaluate a JSONLogic expression with execution trace for debugging.
@@ -44,6 +46,7 @@ export function evaluate(logic: string, data: string): string;
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string containing TracedResult (result, expression_tree, steps) or error message
@@ -64,6 +67,6 @@ export function evaluate(logic: string, data: string): string;
  * }
  * ```
  */
-export function evaluate_with_trace(logic: string, data: string): string;
+export function evaluate_with_trace(logic: string, data: string, preserve_structure: boolean): string;
 
 export function init(): void;

package/nodejs/datalogic_wasm.js

@@ -2,6 +2,21 @@
 let imports = {};
 imports['__wbindgen_placeholder__'] = module.exports;
 
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -23,6 +38,13 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -60,10 +82,10 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
 }
 
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -113,18 +135,28 @@ class CompiledRule {
      *
      * # Arguments
      * * `logic` - JSON string containing the JSONLogic expression
+     * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
      * @param {string} logic
+     * @param {boolean} preserve_structure
      */
-    constructor(logic) {
-        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.compiledrule_new(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    constructor(logic, preserve_structure) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.compiledrule_new(retptr, ptr0, len0, preserve_structure);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            CompiledRuleFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        CompiledRuleFinalization.register(this, this.__wbg_ptr, this);
-        return this;
     }
     /**
      * Evaluate the compiled rule against data.
@@ -141,20 +173,26 @@ class CompiledRule {
         let deferred3_0;
         let deferred3_1;
         try {
-            const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ret = wasm.compiledrule_evaluate(this.__wbg_ptr, ptr0, len0);
-            var ptr2 = ret[0];
-            var len2 = ret[1];
-            if (ret[3]) {
+            wasm.compiledrule_evaluate(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
                 ptr2 = 0; len2 = 0;
-                throw takeFromExternrefTable0(ret[2]);
+                throw takeObject(r2);
             }
             deferred3_0 = ptr2;
             deferred3_1 = len2;
             return getStringFromWasm0(ptr2, len2);
         } finally {
-            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred3_0, deferred3_1, 1);
         }
     }
 }
@@ -167,33 +205,41 @@ exports.CompiledRule = CompiledRule;
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string result or error message
  * @param {string} logic
  * @param {string} data
+ * @param {boolean} preserve_structure
  * @returns {string}
  */
-function evaluate(logic, data) {
+function evaluate(logic, data, preserve_structure) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.evaluate(ptr0, len0, ptr1, len1);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
-        if (ret[3]) {
+        wasm.evaluate(retptr, ptr0, len0, ptr1, len1, preserve_structure);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
             ptr3 = 0; len3 = 0;
-            throw takeFromExternrefTable0(ret[2]);
+            throw takeObject(r2);
         }
         deferred4_0 = ptr3;
         deferred4_1 = len3;
         return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
     }
 }
 exports.evaluate = evaluate;
@@ -207,6 +253,7 @@ exports.evaluate = evaluate;
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string containing TracedResult (result, expression_tree, steps) or error message
@@ -228,28 +275,35 @@ exports.evaluate = evaluate;
  * ```
  * @param {string} logic
  * @param {string} data
+ * @param {boolean} preserve_structure
  * @returns {string}
  */
-function evaluate_with_trace(logic, data) {
+function evaluate_with_trace(logic, data, preserve_structure) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.evaluate_with_trace(ptr0, len0, ptr1, len1);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
-        if (ret[3]) {
+        wasm.evaluate_with_trace(retptr, ptr0, len0, ptr1, len1, preserve_structure);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
             ptr3 = 0; len3 = 0;
-            throw takeFromExternrefTable0(ret[2]);
+            throw takeObject(r2);
         }
         deferred4_0 = ptr3;
         deferred4_1 = len3;
         return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
     }
 }
 exports.evaluate_with_trace = evaluate_with_trace;
@@ -271,18 +325,28 @@ exports.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
         deferred0_1 = arg1;
         console.error(getStringFromWasm0(arg0, arg1));
     } finally {
-        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        wasm.__wbindgen_export(deferred0_0, deferred0_1, 1);
     }
 };
 
+exports.__wbg_getTime_ad1e9878a735af08 = function(arg0) {
+    const ret = getObject(arg0).getTime();
+    return ret;
+};
+
+exports.__wbg_new_0_23cedd11d9b40c9d = function() {
+    const ret = new Date();
+    return addHeapObject(ret);
+};
+
 exports.__wbg_new_8a6f238a6ece86ea = function() {
     const ret = new Error();
-    return ret;
+    return addHeapObject(ret);
 };
 
 exports.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
-    const ret = arg1.stack;
-    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -291,17 +355,11 @@ exports.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
 exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
+    return addHeapObject(ret);
 };
 
-exports.__wbindgen_init_externref_table = function() {
-    const table = wasm.__wbindgen_externrefs;
-    const offset = table.grow(4);
-    table.set(0, undefined);
-    table.set(offset + 0, undefined);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
+exports.__wbindgen_object_drop_ref = function(arg0) {
+    takeObject(arg0);
 };
 
 const wasmPath = `${__dirname}/datalogic_wasm_bg.wasm`;

package/nodejs/datalogic_wasm_bg.wasm.d.ts

@@ -2,14 +2,13 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_compiledrule_free: (a: number, b: number) => void;
-export const compiledrule_evaluate: (a: number, b: number, c: number) => [number, number, number, number];
-export const compiledrule_new: (a: number, b: number) => [number, number, number];
-export const evaluate: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-export const evaluate_with_trace: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const compiledrule_evaluate: (a: number, b: number, c: number, d: number) => void;
+export const compiledrule_new: (a: number, b: number, c: number, d: number) => void;
+export const evaluate: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const evaluate_with_trace: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const init: () => void;
-export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __wbindgen_malloc: (a: number, b: number) => number;
-export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-export const __wbindgen_externrefs: WebAssembly.Table;
-export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_export: (a: number, b: number, c: number) => void;
+export const __wbindgen_export2: (a: number, b: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
 export const __wbindgen_start: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goplasmatic/datalogic",
-  "version": "4.0.6",
+  "version": "4.0.8",
   "description": "High-performance JSONLogic engine for JavaScript/TypeScript - WebAssembly powered",
   "license": "Apache-2.0",
   "repository": {

package/web/datalogic_wasm.d.ts

@@ -9,8 +9,9 @@ export class CompiledRule {
    *
    * # Arguments
    * * `logic` - JSON string containing the JSONLogic expression
+   * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
    */
-  constructor(logic: string);
+  constructor(logic: string, preserve_structure: boolean);
   /**
    * Evaluate the compiled rule against data.
    *
@@ -29,11 +30,12 @@ export class CompiledRule {
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string result or error message
  */
-export function evaluate(logic: string, data: string): string;
+export function evaluate(logic: string, data: string, preserve_structure: boolean): string;
 
 /**
  * Evaluate a JSONLogic expression with execution trace for debugging.
@@ -44,6 +46,7 @@ export function evaluate(logic: string, data: string): string;
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string containing TracedResult (result, expression_tree, steps) or error message
@@ -64,7 +67,7 @@ export function evaluate(logic: string, data: string): string;
  * }
  * ```
  */
-export function evaluate_with_trace(logic: string, data: string): string;
+export function evaluate_with_trace(logic: string, data: string, preserve_structure: boolean): string;
 
 export function init(): void;
 
@@ -73,16 +76,15 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_compiledrule_free: (a: number, b: number) => void;
-  readonly compiledrule_evaluate: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly compiledrule_new: (a: number, b: number) => [number, number, number];
-  readonly evaluate: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  readonly evaluate_with_trace: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly compiledrule_evaluate: (a: number, b: number, c: number, d: number) => void;
+  readonly compiledrule_new: (a: number, b: number, c: number, d: number) => void;
+  readonly evaluate: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly evaluate_with_trace: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly init: () => void;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_malloc: (a: number, b: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-  readonly __wbindgen_externrefs: WebAssembly.Table;
-  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_export: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_export2: (a: number, b: number) => number;
+  readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
   readonly __wbindgen_start: () => void;
 }
 

package/web/datalogic_wasm.js

@@ -1,5 +1,20 @@
 let wasm;
 
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -21,6 +36,13 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -58,10 +80,10 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
 }
 
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -119,18 +141,28 @@ export class CompiledRule {
      *
      * # Arguments
      * * `logic` - JSON string containing the JSONLogic expression
+     * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
      * @param {string} logic
+     * @param {boolean} preserve_structure
      */
-    constructor(logic) {
-        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.compiledrule_new(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    constructor(logic, preserve_structure) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.compiledrule_new(retptr, ptr0, len0, preserve_structure);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            CompiledRuleFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        CompiledRuleFinalization.register(this, this.__wbg_ptr, this);
-        return this;
     }
     /**
      * Evaluate the compiled rule against data.
@@ -147,20 +179,26 @@ export class CompiledRule {
         let deferred3_0;
         let deferred3_1;
         try {
-            const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ret = wasm.compiledrule_evaluate(this.__wbg_ptr, ptr0, len0);
-            var ptr2 = ret[0];
-            var len2 = ret[1];
-            if (ret[3]) {
+            wasm.compiledrule_evaluate(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
                 ptr2 = 0; len2 = 0;
-                throw takeFromExternrefTable0(ret[2]);
+                throw takeObject(r2);
             }
             deferred3_0 = ptr2;
             deferred3_1 = len2;
             return getStringFromWasm0(ptr2, len2);
         } finally {
-            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred3_0, deferred3_1, 1);
         }
     }
 }
@@ -172,33 +210,41 @@ if (Symbol.dispose) CompiledRule.prototype[Symbol.dispose] = CompiledRule.protot
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string result or error message
  * @param {string} logic
  * @param {string} data
+ * @param {boolean} preserve_structure
  * @returns {string}
  */
-export function evaluate(logic, data) {
+export function evaluate(logic, data, preserve_structure) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.evaluate(ptr0, len0, ptr1, len1);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
-        if (ret[3]) {
+        wasm.evaluate(retptr, ptr0, len0, ptr1, len1, preserve_structure);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
             ptr3 = 0; len3 = 0;
-            throw takeFromExternrefTable0(ret[2]);
+            throw takeObject(r2);
         }
         deferred4_0 = ptr3;
         deferred4_1 = len3;
         return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
     }
 }
 
@@ -211,6 +257,7 @@ export function evaluate(logic, data) {
  * # Arguments
  * * `logic` - JSON string containing the JSONLogic expression
  * * `data` - JSON string containing the data to evaluate against
+ * * `preserve_structure` - If true, preserves object structure for JSON templates with embedded JSONLogic
  *
  * # Returns
  * JSON string containing TracedResult (result, expression_tree, steps) or error message
@@ -232,28 +279,35 @@ export function evaluate(logic, data) {
  * ```
  * @param {string} logic
  * @param {string} data
+ * @param {boolean} preserve_structure
  * @returns {string}
  */
-export function evaluate_with_trace(logic, data) {
+export function evaluate_with_trace(logic, data, preserve_structure) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(logic, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr1 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.evaluate_with_trace(ptr0, len0, ptr1, len1);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
-        if (ret[3]) {
+        wasm.evaluate_with_trace(retptr, ptr0, len0, ptr1, len1, preserve_structure);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
             ptr3 = 0; len3 = 0;
-            throw takeFromExternrefTable0(ret[2]);
+            throw takeObject(r2);
         }
         deferred4_0 = ptr3;
         deferred4_1 = len3;
         return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
     }
 }
 
@@ -307,16 +361,24 @@ function __wbg_get_imports() {
             deferred0_1 = arg1;
             console.error(getStringFromWasm0(arg0, arg1));
         } finally {
-            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            wasm.__wbindgen_export(deferred0_0, deferred0_1, 1);
         }
     };
+    imports.wbg.__wbg_getTime_ad1e9878a735af08 = function(arg0) {
+        const ret = getObject(arg0).getTime();
+        return ret;
+    };
+    imports.wbg.__wbg_new_0_23cedd11d9b40c9d = function() {
+        const ret = new Date();
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
         const ret = new Error();
-        return ret;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
-        const ret = arg1.stack;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ret = getObject(arg1).stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -324,16 +386,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
-        return ret;
+        return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_externrefs;
-        const offset = table.grow(4);
-        table.set(0, undefined);
-        table.set(offset + 0, undefined);
-        table.set(offset + 1, null);
-        table.set(offset + 2, true);
-        table.set(offset + 3, false);
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
     };
 
     return imports;

package/web/datalogic_wasm_bg.wasm.d.ts

@@ -2,14 +2,13 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_compiledrule_free: (a: number, b: number) => void;
-export const compiledrule_evaluate: (a: number, b: number, c: number) => [number, number, number, number];
-export const compiledrule_new: (a: number, b: number) => [number, number, number];
-export const evaluate: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-export const evaluate_with_trace: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const compiledrule_evaluate: (a: number, b: number, c: number, d: number) => void;
+export const compiledrule_new: (a: number, b: number, c: number, d: number) => void;
+export const evaluate: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const evaluate_with_trace: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const init: () => void;
-export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __wbindgen_malloc: (a: number, b: number) => number;
-export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-export const __wbindgen_externrefs: WebAssembly.Table;
-export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_export: (a: number, b: number, c: number) => void;
+export const __wbindgen_export2: (a: number, b: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
 export const __wbindgen_start: () => void;