taffy-js 0.1.2 → 0.1.3

package/taffy_js.js

@@ -77,9 +77,9 @@ function debugString(val) {
     return className;
 }
 
-function getArrayU32FromWasm0(ptr, len) {
+function getArrayU64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+    return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
 function getArrayU8FromWasm0(ptr, len) {
@@ -87,6 +87,14 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedBigUint64ArrayMemory0 = null;
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64ArrayMemory0;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -100,14 +108,6 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
-let cachedUint32ArrayMemory0 = null;
-function getUint32ArrayMemory0() {
-    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
-        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
-    }
-    return cachedUint32ArrayMemory0;
-}
-
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -129,9 +129,9 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-function passArray32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getUint32ArrayMemory0().set(arg, ptr / 4);
+function passArray64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getBigUint64ArrayMemory0().set(arg, ptr / 8);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
@@ -328,37 +328,41 @@ export const AlignItems = Object.freeze({
 
 /**
  * How a single item is aligned along the cross axis, overriding `AlignItems`.
- * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6}
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7}
  */
 export const AlignSelf = Object.freeze({
+    /**
+     * Auto
+     */
+    Auto: 0, "0": "Auto",
     /**
      * items are aligned at the start of the cross axis.
      */
-    Start: 0, "0": "Start",
+    Start: 1, "1": "Start",
     /**
      * Items are aligned at the end of the cross axis.
      */
-    End: 1, "1": "End",
+    End: 2, "2": "End",
     /**
      * Items are aligned at the start of the flex-direction cross axis.
      */
-    FlexStart: 2, "2": "FlexStart",
+    FlexStart: 3, "3": "FlexStart",
     /**
      * Items are aligned at the end of the flex-direction cross axis.
      */
-    FlexEnd: 3, "3": "FlexEnd",
+    FlexEnd: 4, "4": "FlexEnd",
     /**
      * Items are aligned at the center of the cross axis.
      */
-    Center: 4, "4": "Center",
+    Center: 5, "5": "Center",
     /**
      * Items are aligned based on their baselines.
      */
-    Baseline: 5, "5": "Baseline",
+    Baseline: 6, "6": "Baseline",
     /**
      * Items are stretched to fill the container along the cross axis.
      */
-    Stretch: 6, "6": "Stretch",
+    Stretch: 7, "7": "Stretch",
 });
 
 /**
@@ -409,6 +413,7 @@ export class AvailableSpace {
 if (Symbol.dispose) AvailableSpace.prototype[Symbol.dispose] = AvailableSpace.prototype.free;
 
 /**
+ * Represents a length value in CSS.
  * Represents a length value in CSS.
  *
  * This struct corresponds to a dimension value that can be specified in pixels, percentage, or auto.
@@ -512,6 +517,22 @@ export const Display = Object.freeze({
     Block: 3, "3": "Block",
 });
 
+/**
+ * Start and End are used for logical positioning (e.g. paddingStart).
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8}
+ */
+export const Edge = Object.freeze({
+    Left: 0, "0": "Left",
+    Right: 1, "1": "Right",
+    Top: 2, "2": "Top",
+    Bottom: 3, "3": "Bottom",
+    Start: 4, "4": "Start",
+    End: 5, "5": "End",
+    Horizontal: 6, "6": "Horizontal",
+    Vertical: 7, "7": "Vertical",
+    All: 8, "8": "All",
+});
+
 /**
  * The direction of the main axis for a flex container.
  * @enum {0 | 1 | 2 | 3}
@@ -577,6 +598,15 @@ export const GridAutoFlow = Object.freeze({
     ColumnDense: 3, "3": "ColumnDense",
 });
 
+/**
+ * @enum {0 | 1 | 2}
+ */
+export const Gutter = Object.freeze({
+    Column: 0, "0": "Column",
+    Row: 1, "1": "Row",
+    All: 2, "2": "All",
+});
+
 /**
  * How items are distributed along the main axis.
  * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7}
@@ -1468,14 +1498,14 @@ export class Style {
      */
     get align_self() {
         const ret = wasm.__wbg_get_style_align_self(this.__wbg_ptr);
-        return ret === 7 ? undefined : ret;
+        return ret === 8 ? undefined : ret;
     }
     /**
      * How a single item is aligned along the cross axis.
      * @param {AlignSelf | null} [arg0]
      */
     set align_self(arg0) {
-        wasm.__wbg_set_style_align_self(this.__wbg_ptr, isLikeNone(arg0) ? 7 : arg0);
+        wasm.__wbg_set_style_align_self(this.__wbg_ptr, isLikeNone(arg0) ? 8 : arg0);
     }
     /**
      * How lines of content are aligned along the cross axis.
@@ -1577,14 +1607,14 @@ export class TaffyNode {
         wasm.__wbg_taffynode_free(ptr, 0);
     }
     /**
-     * @returns {number}
+     * @returns {bigint}
      */
     get id() {
         const ret = wasm.__wbg_get_taffynode_id(this.__wbg_ptr);
-        return ret >>> 0;
+        return BigInt.asUintN(64, ret);
     }
     /**
-     * @param {number} arg0
+     * @param {bigint} arg0
      */
     set id(arg0) {
         wasm.__wbg_set_taffynode_id(this.__wbg_ptr, arg0);
@@ -1592,30 +1622,122 @@ export class TaffyNode {
     /**
      * @returns {Layout}
      */
-    get_layout() {
-        const ret = wasm.taffynode_get_layout(this.__wbg_ptr);
+    getLayout() {
+        const ret = wasm.taffynode_getLayout(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Layout.__wrap(ret[0]);
     }
+    markDirty() {
+        const ret = wasm.taffynode_markDirty(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Edge} edge
+     * @param {number} value
+     */
+    setBorder(edge, value) {
+        const ret = wasm.taffynode_setBorder(this.__wbg_ptr, edge, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setHeight(value) {
+        const ret = wasm.taffynode_setHeight(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Edge} edge
+     * @param {number} value
+     */
+    setMargin(edge, value) {
+        const ret = wasm.taffynode_setMargin(this.__wbg_ptr, edge, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Display} display
+     */
+    setDisplay(display) {
+        const ret = wasm.taffynode_setDisplay(this.__wbg_ptr, display);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Edge} edge
+     * @param {number} value
+     */
+    setPadding(edge, value) {
+        const ret = wasm.taffynode_setPadding(this.__wbg_ptr, edge, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {TaffyNode} child
+     * @param {number} index
+     */
+    insertChild(child, index) {
+        _assertClass(child, TaffyNode);
+        const ret = wasm.taffynode_insertChild(this.__wbg_ptr, child.__wbg_ptr, index);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {TaffyNode} child
      */
-    remove_child(child) {
+    removeChild(child) {
         _assertClass(child, TaffyNode);
-        const ret = wasm.taffynode_remove_child(this.__wbg_ptr, child.__wbg_ptr);
+        const ret = wasm.taffynode_removeChild(this.__wbg_ptr, child.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * @param {Uint32Array} children
+     * @param {BigUint64Array} children
      */
-    set_children(children) {
-        const ptr0 = passArray32ToWasm0(children, wasm.__wbindgen_malloc);
+    setChildren(children) {
+        const ptr0 = passArray64ToWasm0(children, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.taffynode_set_children(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.taffynode_setChildren(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setFlexGrow(value) {
+        const ret = wasm.taffynode_setFlexGrow(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {FlexWrap} wrap
+     */
+    setFlexWrap(wrap) {
+        const ret = wasm.taffynode_setFlexWrap(this.__wbg_ptr, wrap);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setMinWidth(value) {
+        const ret = wasm.taffynode_setMinWidth(this.__wbg_ptr, value);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -1623,8 +1745,161 @@ export class TaffyNode {
     /**
      * @param {any} available_space
      */
-    compute_layout(available_space) {
-        const ret = wasm.taffynode_compute_layout(this.__wbg_ptr, available_space);
+    computeLayout(available_space) {
+        const ret = wasm.taffynode_computeLayout(this.__wbg_ptr, available_space);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {AlignSelf} align
+     */
+    setAlignSelf(align) {
+        const ret = wasm.taffynode_setAlignSelf(this.__wbg_ptr, align);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setFlexBasis(value) {
+        const ret = wasm.taffynode_setFlexBasis(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setMinHeight(value) {
+        const ret = wasm.taffynode_setMinHeight(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    setWidthAuto() {
+        const ret = wasm.taffynode_setWidthAuto(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {AlignItems} align
+     */
+    setAlignItems(align) {
+        const ret = wasm.taffynode_setAlignItems(this.__wbg_ptr, align);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setFlexShrink(value) {
+        const ret = wasm.taffynode_setFlexShrink(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    setHeightAuto() {
+        const ret = wasm.taffynode_setHeightAuto(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Edge} edge
+     */
+    setMarginAuto(edge) {
+        const ret = wasm.taffynode_setMarginAuto(this.__wbg_ptr, edge);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Function} js_func
+     */
+    setMeasureFunc(js_func) {
+        const ret = wasm.taffynode_setMeasureFunc(this.__wbg_ptr, js_func);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Position} position
+     */
+    setPositionType(position) {
+        const ret = wasm.taffynode_setPositionType(this.__wbg_ptr, position);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setWidthPercent(value) {
+        const ret = wasm.taffynode_setWidthPercent(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {FlexDirection} direction
+     */
+    setFlexDirection(direction) {
+        const ret = wasm.taffynode_setFlexDirection(this.__wbg_ptr, direction);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setHeightPercent(value) {
+        const ret = wasm.taffynode_setHeightPercent(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    setFlexBasisAuto() {
+        const ret = wasm.taffynode_setFlexBasisAuto(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {JustifyContent} justify
+     */
+    setJustifyContent(justify) {
+        const ret = wasm.taffynode_setJustifyContent(this.__wbg_ptr, justify);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setMinWidthPercent(value) {
+        const ret = wasm.taffynode_setMinWidthPercent(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setFlexBasisPercent(value) {
+        const ret = wasm.taffynode_setFlexBasisPercent(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    setMinHeightPercent(value) {
+        const ret = wasm.taffynode_setMinHeightPercent(this.__wbg_ptr, value);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -1658,12 +1933,22 @@ export class TaffyNode {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @param {Gutter} gutter
+     * @param {number} value
+     */
+    setGap(gutter, value) {
+        const ret = wasm.taffynode_setGap(this.__wbg_ptr, gutter, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {TaffyNode} child
      */
-    add_child(child) {
+    addChild(child) {
         _assertClass(child, TaffyNode);
-        const ret = wasm.taffynode_add_child(this.__wbg_ptr, child.__wbg_ptr);
+        const ret = wasm.taffynode_addChild(this.__wbg_ptr, child.__wbg_ptr);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -1677,6 +1962,15 @@ export class TaffyNode {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * @param {number} value
+     */
+    setWidth(value) {
+        const ret = wasm.taffynode_setWidth(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
 }
 if (Symbol.dispose) TaffyNode.prototype[Symbol.dispose] = TaffyNode.prototype.free;
 
@@ -1781,8 +2075,8 @@ export const TrackUnit = Object.freeze({
  * # Errors
  *
  * Returns a `JsValue` error if the operation fails (e.g., recursive hierarchy).
- * @param {number} parent
- * @param {number} child
+ * @param {bigint} parent
+ * @param {bigint} child
  */
 export function add_child(parent, child) {
     const ret = wasm.add_child(parent, child);
@@ -1801,7 +2095,10 @@ export function auto() {
 }
 
 /**
- * Clear all nodes
+ * Clear all nodes from the layout tree.
+ *
+ * This removes all nodes and resets the tree to an empty state.
+ * Any existing node IDs become invalid after this call.
  */
 export function clear() {
     const ret = wasm.clear();
@@ -1821,7 +2118,7 @@ export function clear() {
  * # Errors
  *
  * Returns a `JsValue` error if the layout computation fails.
- * @param {number} root
+ * @param {bigint} root
  * @param {any} available_space
  */
 export function compute_layout(root, available_space) {
@@ -1856,16 +2153,16 @@ export function dimension(value, unit) {
  * # Errors
  *
  * Returns a `JsValue` error if the node does not exist.
- * @param {number} parent
- * @returns {Uint32Array}
+ * @param {bigint} parent
+ * @returns {BigUint64Array}
  */
 export function get_children(parent) {
     const ret = wasm.get_children(parent);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
-    var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    var v1 = getArrayU64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v1;
 }
 
@@ -1883,7 +2180,7 @@ export function get_children(parent) {
  * # Errors
  *
  * Returns a `JsValue` error if the node does not exist or layout information is unavailable.
- * @param {number} node
+ * @param {bigint} node
  * @returns {any}
  */
 export function get_layout(node) {
@@ -1908,19 +2205,22 @@ export function get_layout(node) {
  * # Errors
  *
  * Returns a `JsValue` error if internal tree access fails.
- * @param {number} node
- * @returns {number | undefined}
+ * @param {bigint} node
+ * @returns {bigint | undefined}
  */
 export function get_parent(node) {
     const ret = wasm.get_parent(node);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
     }
-    return ret[0] === 0x100000001 ? undefined : ret[0];
+    return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
 }
 
 /**
- * Initialize console error panic hook
+ * Initialize the WASM module.
+ *
+ * This function is automatically called when the WASM module is loaded.
+ * It sets up the console error panic hook for better error messages in development.
  */
 export function init() {
     wasm.init();
@@ -1936,7 +2236,7 @@ export function init() {
  * # Errors
  *
  * Returns a `JsValue` error if the node does not exist.
- * @param {number} node
+ * @param {bigint} node
  */
 export function mark_dirty(node) {
     const ret = wasm.mark_dirty(node);
@@ -1960,14 +2260,14 @@ export function mark_dirty(node) {
  *
  * Returns a `JsValue` error if the style cannot be deserialized or if node creation fails.
  * @param {any} style
- * @returns {number}
+ * @returns {bigint}
  */
 export function new_leaf(style) {
     const ret = wasm.new_leaf(style);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ret[0] >>> 0;
+    return BigInt.asUintN(64, ret[0]);
 }
 
 /**
@@ -1986,21 +2286,25 @@ export function new_leaf(style) {
  *
  * Returns a `JsValue` error if the style cannot be deserialized or if node creation fails.
  * @param {any} style
- * @param {Uint32Array} children
- * @returns {number}
+ * @param {BigUint64Array} children
+ * @returns {bigint}
  */
 export function new_with_children(style, children) {
-    const ptr0 = passArray32ToWasm0(children, wasm.__wbindgen_malloc);
+    const ptr0 = passArray64ToWasm0(children, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.new_with_children(style, ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ret[0] >>> 0;
+    return BigInt.asUintN(64, ret[0]);
 }
 
 /**
- * Get the total number of nodes
+ * Get the total number of nodes currently in the layout tree.
+ *
+ * # Returns
+ *
+ * The total count of all nodes in the tree.
  * @returns {number}
  */
 export function node_count() {
@@ -2039,8 +2343,8 @@ export function px(value) {
  * # Errors
  *
  * Returns a `JsValue` error if the child is not found in the parent.
- * @param {number} parent
- * @param {number} child
+ * @param {bigint} parent
+ * @param {bigint} child
  */
 export function remove_child(parent, child) {
     const ret = wasm.remove_child(parent, child);
@@ -2059,7 +2363,7 @@ export function remove_child(parent, child) {
  * # Errors
  *
  * Returns a `JsValue` error if the node does not exist or cannot be removed.
- * @param {number} node
+ * @param {bigint} node
  */
 export function remove_node(node) {
     const ret = wasm.remove_node(node);
@@ -2079,11 +2383,11 @@ export function remove_node(node) {
  * # Errors
  *
  * Returns a `JsValue` error if the operation fails.
- * @param {number} parent
- * @param {Uint32Array} children
+ * @param {bigint} parent
+ * @param {BigUint64Array} children
  */
 export function set_children(parent, children) {
-    const ptr0 = passArray32ToWasm0(children, wasm.__wbindgen_malloc);
+    const ptr0 = passArray64ToWasm0(children, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.set_children(parent, ptr0, len0);
     if (ret[1]) {
@@ -2102,7 +2406,7 @@ export function set_children(parent, children) {
  * # Errors
  *
  * Returns a `JsValue` error if the style cannot be deserialized or if the node does not exist.
- * @param {number} node
+ * @param {bigint} node
  * @param {any} style
  */
 export function set_style(node, style) {
@@ -2182,6 +2486,10 @@ function __wbg_get_imports() {
         const ret = typeof(arg0) === 'function';
         return ret;
     };
+    imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
+        const ret = arg0 === null;
+        return ret;
+    };
     imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
         const val = arg0;
         const ret = typeof(val) === 'object' && val !== null;
@@ -2216,6 +2524,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
+    imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
         const ret = arg0.call(arg1);
         return ret;
@@ -2239,6 +2551,9 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
+    imports.wbg.__wbg_error_7bc7d576a6aaf855 = function(arg0) {
+        console.error(arg0);
+    };
     imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
         const ret = arg0[arg1 >>> 0];
         return ret;
@@ -2328,6 +2643,9 @@ function __wbg_get_imports() {
         const ret = arg0.value;
         return ret;
     };
+    imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
+        console.warn(arg0);
+    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
@@ -2354,8 +2672,8 @@ function __wbg_get_imports() {
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
+    cachedBigUint64ArrayMemory0 = null;
     cachedDataViewMemory0 = null;
-    cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;