@windborne/grapher 1.0.0

package/src/rust/pkg/grapher_rs.js

@@ -0,0 +1,351 @@
+import * as wasm from './grapher_rs_bg.wasm';
+
+const heap = new Array(32).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let WASM_VECTOR_LEN = 0;
+
+let cachegetUint8Memory0 = null;
+function getUint8Memory0() {
+    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
+        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachegetUint8Memory0;
+}
+
+const lTextEncoder = typeof TextEncoder === 'undefined' ? require('util').TextEncoder : TextEncoder;
+
+let cachedTextEncoder = new lTextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length);
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len);
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachegetInt32Memory0 = null;
+function getInt32Memory0() {
+    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
+        cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachegetInt32Memory0;
+}
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+const lTextDecoder = typeof TextDecoder === 'undefined' ? require('util').TextDecoder : TextDecoder;
+
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+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;
+}
+
+let cachegetFloat64Memory0 = null;
+function getFloat64Memory0() {
+    if (cachegetFloat64Memory0 === null || cachegetFloat64Memory0.buffer !== wasm.memory.buffer) {
+        cachegetFloat64Memory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachegetFloat64Memory0;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8);
+    getFloat64Memory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1);
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let stack_pointer = 32;
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+/**
+* @param {number} length
+* @param {Float64Array} data
+* @param {Uint8Array} data_null_mask
+* @param {any} params
+* @param {Uint8Array} null_mask
+* @param {Float64Array} y_values
+* @param {Float64Array} min_y_values
+* @param {Float64Array} max_y_values
+*/
+export function selected_space_to_render_space(length, data, data_null_mask, params, null_mask, y_values, min_y_values, max_y_values) {
+    try {
+        var ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = passArray8ToWasm0(data_null_mask, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = passArray8ToWasm0(null_mask, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        var ptr3 = passArrayF64ToWasm0(y_values, wasm.__wbindgen_malloc);
+        var len3 = WASM_VECTOR_LEN;
+        var ptr4 = passArrayF64ToWasm0(min_y_values, wasm.__wbindgen_malloc);
+        var len4 = WASM_VECTOR_LEN;
+        var ptr5 = passArrayF64ToWasm0(max_y_values, wasm.__wbindgen_malloc);
+        var len5 = WASM_VECTOR_LEN;
+        wasm.selected_space_to_render_space(length, ptr0, len0, ptr1, len1, addBorrowedObject(params), ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
+    } finally {
+        heap[stack_pointer++] = undefined;
+        null_mask.set(getUint8Memory0().subarray(ptr2 / 1, ptr2 / 1 + len2));
+        wasm.__wbindgen_free(ptr2, len2 * 1);
+        y_values.set(getFloat64Memory0().subarray(ptr3 / 8, ptr3 / 8 + len3));
+        wasm.__wbindgen_free(ptr3, len3 * 8);
+        min_y_values.set(getFloat64Memory0().subarray(ptr4 / 8, ptr4 / 8 + len4));
+        wasm.__wbindgen_free(ptr4, len4 * 8);
+        max_y_values.set(getFloat64Memory0().subarray(ptr5 / 8, ptr5 / 8 + len5));
+        wasm.__wbindgen_free(ptr5, len5 * 8);
+    }
+}
+
+let cachegetFloat32Memory0 = null;
+function getFloat32Memory0() {
+    if (cachegetFloat32Memory0 === null || cachegetFloat32Memory0.buffer !== wasm.memory.buffer) {
+        cachegetFloat32Memory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachegetFloat32Memory0;
+}
+
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4);
+    getFloat32Memory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let cachegetUint32Memory0 = null;
+function getUint32Memory0() {
+    if (cachegetUint32Memory0 === null || cachegetUint32Memory0.buffer !== wasm.memory.buffer) {
+        cachegetUint32Memory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachegetUint32Memory0;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4);
+    getUint32Memory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+* @param {number} dpi_increase
+* @param {Uint8Array} null_mask
+* @param {Float64Array} y_values
+* @param {Float64Array} min_y_values
+* @param {Float64Array} max_y_values
+* @param {Float32Array} positions
+* @param {Float32Array} prev_positions
+* @param {Float32Array} vertices
+* @param {Uint32Array} indices
+* @param {boolean} dashed
+* @param {number} dash0
+* @param {number} dash1
+*/
+export function extract_vertices(dpi_increase, null_mask, y_values, min_y_values, max_y_values, positions, prev_positions, vertices, indices, dashed, dash0, dash1) {
+    try {
+        var ptr0 = passArray8ToWasm0(null_mask, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = passArrayF64ToWasm0(y_values, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = passArrayF64ToWasm0(min_y_values, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        var ptr3 = passArrayF64ToWasm0(max_y_values, wasm.__wbindgen_malloc);
+        var len3 = WASM_VECTOR_LEN;
+        var ptr4 = passArrayF32ToWasm0(positions, wasm.__wbindgen_malloc);
+        var len4 = WASM_VECTOR_LEN;
+        var ptr5 = passArrayF32ToWasm0(prev_positions, wasm.__wbindgen_malloc);
+        var len5 = WASM_VECTOR_LEN;
+        var ptr6 = passArrayF32ToWasm0(vertices, wasm.__wbindgen_malloc);
+        var len6 = WASM_VECTOR_LEN;
+        var ptr7 = passArray32ToWasm0(indices, wasm.__wbindgen_malloc);
+        var len7 = WASM_VECTOR_LEN;
+        wasm.extract_vertices(dpi_increase, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, dashed, dash0, dash1);
+    } finally {
+        positions.set(getFloat32Memory0().subarray(ptr4 / 4, ptr4 / 4 + len4));
+        wasm.__wbindgen_free(ptr4, len4 * 4);
+        prev_positions.set(getFloat32Memory0().subarray(ptr5 / 4, ptr5 / 4 + len5));
+        wasm.__wbindgen_free(ptr5, len5 * 4);
+        vertices.set(getFloat32Memory0().subarray(ptr6 / 4, ptr6 / 4 + len6));
+        wasm.__wbindgen_free(ptr6, len6 * 4);
+        indices.set(getUint32Memory0().subarray(ptr7 / 4, ptr7 / 4 + len7));
+        wasm.__wbindgen_free(ptr7, len7 * 4);
+    }
+}
+
+/**
+*/
+export function main_js() {
+    wasm.main_js();
+}
+
+/**
+* @param {Uint8Array} null_mask
+* @param {Float64Array} y_values
+* @param {Float64Array} min_y_values
+* @param {Float64Array} max_y_values
+* @param {boolean} dashed
+* @param {number} dash0
+* @param {number} dash1
+* @returns {number}
+*/
+export function get_point_number(null_mask, y_values, min_y_values, max_y_values, dashed, dash0, dash1) {
+    var ptr0 = passArray8ToWasm0(null_mask, wasm.__wbindgen_malloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = passArrayF64ToWasm0(y_values, wasm.__wbindgen_malloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = passArrayF64ToWasm0(min_y_values, wasm.__wbindgen_malloc);
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = passArrayF64ToWasm0(max_y_values, wasm.__wbindgen_malloc);
+    var len3 = WASM_VECTOR_LEN;
+    var ret = wasm.get_point_number(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, dashed, dash0, dash1);
+    return ret;
+}
+
+export const __wbg_minx_3675eb59ca2b1c04 = function(arg0) {
+    var ret = getObject(arg0).minX;
+    return ret;
+};
+
+export const __wbg_maxx_add7a3e35c2f52a9 = function(arg0) {
+    var ret = getObject(arg0).maxX;
+    return ret;
+};
+
+export const __wbg_miny_9972d9159e80fde8 = function(arg0) {
+    var ret = getObject(arg0).minY;
+    return ret;
+};
+
+export const __wbg_maxy_1c5b27cf1988c667 = function(arg0) {
+    var ret = getObject(arg0).maxY;
+    return ret;
+};
+
+export const __wbg_renderwidth_a0b0f18a85207529 = function(arg0) {
+    var ret = getObject(arg0).renderWidth;
+    return ret;
+};
+
+export const __wbg_renderheight_36b17e8bfc037fc9 = function(arg0) {
+    var ret = getObject(arg0).renderHeight;
+    return ret;
+};
+
+export const __wbg_scale_5e6438f0fcc08bc0 = function(arg0) {
+    var ret = getObject(arg0).scale;
+    return addHeapObject(ret);
+};
+
+export const __wbindgen_string_get = function(arg0, arg1) {
+    const obj = getObject(arg1);
+    var ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len0;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+};
+
+export const __wbindgen_object_drop_ref = function(arg0) {
+    takeObject(arg0);
+};
+
+export const __wbindgen_string_new = function(arg0, arg1) {
+    var ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+export const __wbg_log_6a5797c4bb0f636c = function(arg0) {
+    console.log(getObject(arg0));
+};
+
+export const __wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+wasm.__wbindgen_start();
+

package/src/rust/pkg/grapher_rs_bg.d.ts

@@ -0,0 +1,11 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export function selected_space_to_render_space(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number): void;
+export function extract_vertices(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number): void;
+export function main_js(): void;
+export function get_point_number(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number): number;
+export function __wbindgen_malloc(a: number): number;
+export function __wbindgen_realloc(a: number, b: number, c: number): number;
+export function __wbindgen_free(a: number, b: number): void;
+export function __wbindgen_start(): void;

package/src/rust/pkg/index.js

@@ -0,0 +1,342 @@
+import * as wasm from './index_bg.wasm';
+
+const heap = new Array(32).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let WASM_VECTOR_LEN = 0;
+
+let cachegetUint8Memory0 = null;
+function getUint8Memory0() {
+    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
+        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachegetUint8Memory0;
+}
+
+const lTextEncoder = typeof TextEncoder === 'undefined' ? require('util').TextEncoder : TextEncoder;
+
+let cachedTextEncoder = new lTextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length);
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len);
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachegetInt32Memory0 = null;
+function getInt32Memory0() {
+    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
+        cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachegetInt32Memory0;
+}
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+const lTextDecoder = typeof TextDecoder === 'undefined' ? require('util').TextDecoder : TextDecoder;
+
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+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;
+}
+
+let cachegetFloat64Memory0 = null;
+function getFloat64Memory0() {
+    if (cachegetFloat64Memory0 === null || cachegetFloat64Memory0.buffer !== wasm.memory.buffer) {
+        cachegetFloat64Memory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachegetFloat64Memory0;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8);
+    getFloat64Memory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1);
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let stack_pointer = 32;
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+/**
+* @param {number} length
+* @param {Float64Array} data
+* @param {Uint8Array} data_null_mask
+* @param {any} params
+* @param {Uint8Array} null_mask
+* @param {Float64Array} y_values
+* @param {Float64Array} min_y_values
+* @param {Float64Array} max_y_values
+*/
+export function selected_space_to_render_space(length, data, data_null_mask, params, null_mask, y_values, min_y_values, max_y_values) {
+    try {
+        var ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = passArray8ToWasm0(data_null_mask, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = passArray8ToWasm0(null_mask, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        var ptr3 = passArrayF64ToWasm0(y_values, wasm.__wbindgen_malloc);
+        var len3 = WASM_VECTOR_LEN;
+        var ptr4 = passArrayF64ToWasm0(min_y_values, wasm.__wbindgen_malloc);
+        var len4 = WASM_VECTOR_LEN;
+        var ptr5 = passArrayF64ToWasm0(max_y_values, wasm.__wbindgen_malloc);
+        var len5 = WASM_VECTOR_LEN;
+        wasm.selected_space_to_render_space(length, ptr0, len0, ptr1, len1, addBorrowedObject(params), ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
+    } finally {
+        heap[stack_pointer++] = undefined;
+        null_mask.set(getUint8Memory0().subarray(ptr2 / 1, ptr2 / 1 + len2));
+        wasm.__wbindgen_free(ptr2, len2 * 1);
+        y_values.set(getFloat64Memory0().subarray(ptr3 / 8, ptr3 / 8 + len3));
+        wasm.__wbindgen_free(ptr3, len3 * 8);
+        min_y_values.set(getFloat64Memory0().subarray(ptr4 / 8, ptr4 / 8 + len4));
+        wasm.__wbindgen_free(ptr4, len4 * 8);
+        max_y_values.set(getFloat64Memory0().subarray(ptr5 / 8, ptr5 / 8 + len5));
+        wasm.__wbindgen_free(ptr5, len5 * 8);
+    }
+}
+
+let cachegetFloat32Memory0 = null;
+function getFloat32Memory0() {
+    if (cachegetFloat32Memory0 === null || cachegetFloat32Memory0.buffer !== wasm.memory.buffer) {
+        cachegetFloat32Memory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachegetFloat32Memory0;
+}
+
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4);
+    getFloat32Memory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let cachegetUint32Memory0 = null;
+function getUint32Memory0() {
+    if (cachegetUint32Memory0 === null || cachegetUint32Memory0.buffer !== wasm.memory.buffer) {
+        cachegetUint32Memory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachegetUint32Memory0;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4);
+    getUint32Memory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+* @param {number} dpi_increase
+* @param {Uint8Array} null_mask
+* @param {Float64Array} y_values
+* @param {Float64Array} min_y_values
+* @param {Float64Array} max_y_values
+* @param {Float32Array} positions
+* @param {Float32Array} prev_positions
+* @param {Float32Array} vertices
+* @param {Uint32Array} indices
+* @param {boolean} dashed
+* @param {number} dash0
+* @param {number} dash1
+*/
+export function extract_vertices(dpi_increase, null_mask, y_values, min_y_values, max_y_values, positions, prev_positions, vertices, indices, dashed, dash0, dash1) {
+    try {
+        var ptr0 = passArray8ToWasm0(null_mask, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = passArrayF64ToWasm0(y_values, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = passArrayF64ToWasm0(min_y_values, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        var ptr3 = passArrayF64ToWasm0(max_y_values, wasm.__wbindgen_malloc);
+        var len3 = WASM_VECTOR_LEN;
+        var ptr4 = passArrayF32ToWasm0(positions, wasm.__wbindgen_malloc);
+        var len4 = WASM_VECTOR_LEN;
+        var ptr5 = passArrayF32ToWasm0(prev_positions, wasm.__wbindgen_malloc);
+        var len5 = WASM_VECTOR_LEN;
+        var ptr6 = passArrayF32ToWasm0(vertices, wasm.__wbindgen_malloc);
+        var len6 = WASM_VECTOR_LEN;
+        var ptr7 = passArray32ToWasm0(indices, wasm.__wbindgen_malloc);
+        var len7 = WASM_VECTOR_LEN;
+        wasm.extract_vertices(dpi_increase, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, dashed, dash0, dash1);
+    } finally {
+        positions.set(getFloat32Memory0().subarray(ptr4 / 4, ptr4 / 4 + len4));
+        wasm.__wbindgen_free(ptr4, len4 * 4);
+        prev_positions.set(getFloat32Memory0().subarray(ptr5 / 4, ptr5 / 4 + len5));
+        wasm.__wbindgen_free(ptr5, len5 * 4);
+        vertices.set(getFloat32Memory0().subarray(ptr6 / 4, ptr6 / 4 + len6));
+        wasm.__wbindgen_free(ptr6, len6 * 4);
+        indices.set(getUint32Memory0().subarray(ptr7 / 4, ptr7 / 4 + len7));
+        wasm.__wbindgen_free(ptr7, len7 * 4);
+    }
+}
+
+/**
+* @param {Uint8Array} null_mask
+* @param {Float64Array} y_values
+* @param {Float64Array} min_y_values
+* @param {Float64Array} max_y_values
+* @param {boolean} dashed
+* @param {number} dash0
+* @param {number} dash1
+* @returns {number}
+*/
+export function get_point_number(null_mask, y_values, min_y_values, max_y_values, dashed, dash0, dash1) {
+    var ptr0 = passArray8ToWasm0(null_mask, wasm.__wbindgen_malloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = passArrayF64ToWasm0(y_values, wasm.__wbindgen_malloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = passArrayF64ToWasm0(min_y_values, wasm.__wbindgen_malloc);
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = passArrayF64ToWasm0(max_y_values, wasm.__wbindgen_malloc);
+    var len3 = WASM_VECTOR_LEN;
+    var ret = wasm.get_point_number(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, dashed, dash0, dash1);
+    return ret;
+}
+
+/**
+*/
+export function main_js() {
+    wasm.main_js();
+}
+
+export const __wbg_minx_3675eb59ca2b1c04 = function(arg0) {
+    var ret = getObject(arg0).minX;
+    return ret;
+};
+
+export const __wbg_maxx_add7a3e35c2f52a9 = function(arg0) {
+    var ret = getObject(arg0).maxX;
+    return ret;
+};
+
+export const __wbg_miny_9972d9159e80fde8 = function(arg0) {
+    var ret = getObject(arg0).minY;
+    return ret;
+};
+
+export const __wbg_maxy_1c5b27cf1988c667 = function(arg0) {
+    var ret = getObject(arg0).maxY;
+    return ret;
+};
+
+export const __wbg_renderwidth_a0b0f18a85207529 = function(arg0) {
+    var ret = getObject(arg0).renderWidth;
+    return ret;
+};
+
+export const __wbg_renderheight_36b17e8bfc037fc9 = function(arg0) {
+    var ret = getObject(arg0).renderHeight;
+    return ret;
+};
+
+export const __wbg_scale_5e6438f0fcc08bc0 = function(arg0) {
+    var ret = getObject(arg0).scale;
+    return addHeapObject(ret);
+};
+
+export const __wbindgen_string_get = function(arg0, arg1) {
+    const obj = getObject(arg1);
+    var ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len0;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+};
+
+export const __wbindgen_object_drop_ref = function(arg0) {
+    takeObject(arg0);
+};
+
+export const __wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+wasm.__wbindgen_start();
+