@pirireis/webglobeplugins 0.16.0 → 0.16.2

package/dist/timetracks/programpoint-line-strip.js

@@ -1,151 +0,0 @@
-import { createProgram, shaderfunctions } from "../util";
-import { CameraUniformBlockTotem, globeProgramCache } from "../programs";
-const vertexShader = `#version 300 es
-
-layout(std140) uniform GlobeCamera {
-    mat4 view; // 64 bytes           0
-    mat4 projection; // 64 bytes     64
-    vec3 translate; // 12 bytes      128
-    bool is3D; // 4 bytes            140
-    vec2 mapWH; // 8 bytes           144
-    vec2 screenWH; //  8 bytes       152
-    float z_level; // 4 bytes        160
-};
-
-layout(std140) uniform Globals {
-    float head_time;
-    float final_opacity;
-    float point_size;
-};
-
-in vec3 start_position;
-in float start_time;
-in vec3 start_color;
-in vec3 end_position;
-in float end_time;
-in vec3 end_color;
-out vec4 v_color;
-
-` + shaderfunctions.pixelXYToCartesian3DPoint + shaderfunctions.pixelXYToCartesian2DPoint + `
-
-void main() {
-    if (head_time < start_time || head_time > end_time) { return; }
-    if ( start_color.r < 0.0 || end_color.r < 0.0) { return; }
-    float t = (head_time - start_time) / (end_time - start_time);
-    vec3 position = mix(start_position, end_position, t);
-    if (is3D){
-        vec3 pos = pixelXYToCartesian3DPoint(position);
-        gl_Position = projection * view * vec4(pos - translate, 1.0);
-    }  else {
-        vec2 xy = pixelXYToCartesian2DPoint(position.xy, translate.xy, mapWH, screenWH);
-        gl_Position = projection * vec4(xy.x, xy.y, 0.0, 1.0);
-    }
-    v_color = vec4(mix(start_color, end_color, t), final_opacity);
-    gl_PointSize = point_size;
-}`;
-const fragmentShader = `#version 300 es
-precision highp float;
-in vec4 v_color;
-out vec4 outColor;
-void main() {
-    // circle point
-    vec2 cxy = 2.0 * gl_PointCoord - 1.0;
-    float cc = dot(cxy, cxy);
-    outColor = v_color;
-    if (cc > 0.5) {
-        outColor.a = 0.0;    
- }
-}`;
-export default class {
-    constructor(gl, globe, attrBuffer, options) {
-        this.gl = gl;
-        this._cameraBlockBindingPoint = 0;
-        this._globalsBlockBindingPoint = 1;
-        this.cameraUniformBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
-        this._vao = gl.createVertexArray();
-        this._attbuffer = attrBuffer;
-        this.program = this._createProgram();
-        this._drawCount = 0;
-        this._globalsbuffer = gl.createBuffer();
-        {
-            const { gl, _globalsbuffer } = this;
-            gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-            gl.bufferData(gl.UNIFORM_BUFFER, 12, gl.STREAM_DRAW);
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([0, options.opacity, options.pointSize]));
-            gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, _globalsbuffer);
-            gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-        }
-    }
-    _createProgram() {
-        const gl = this.gl;
-        const program = createProgram(gl, vertexShader, fragmentShader);
-        const ubo = this.cameraUniformBlockTotem.getUBO(); // ubo bl
-        const cameraBlockIndex = gl.getUniformBlockIndex(program, "GlobeCamera");
-        gl.uniformBlockBinding(program, cameraBlockIndex, this._cameraBlockBindingPoint);
-        const globalsBlockIndex = gl.getUniformBlockIndex(program, "Globals");
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._cameraBlockBindingPoint, ubo);
-        gl.uniformBlockBinding(program, globalsBlockIndex, this._globalsBlockBindingPoint);
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, this._globalsbuffer);
-        // numaralarda yanlışlık olabilir
-        const start_position = gl.getAttribLocation(program, "start_position");
-        const start_time = gl.getAttribLocation(program, "start_time");
-        const start_color = gl.getAttribLocation(program, "start_color");
-        const end_position = gl.getAttribLocation(program, "end_position");
-        const end_time = gl.getAttribLocation(program, "end_time");
-        const end_color = gl.getAttribLocation(program, "end_color");
-        gl.bindVertexArray(this._vao);
-        gl.bindBuffer(gl.ARRAY_BUFFER, this._attbuffer);
-        gl.enableVertexAttribArray(start_position);
-        gl.vertexAttribPointer(start_position, 3, gl.FLOAT, false, 36, 0);
-        gl.enableVertexAttribArray(start_time);
-        gl.vertexAttribPointer(start_time, 1, gl.FLOAT, false, 36, 12);
-        gl.enableVertexAttribArray(start_color);
-        gl.vertexAttribPointer(start_color, 3, gl.FLOAT, false, 36, 16);
-        gl.enableVertexAttribArray(end_position);
-        gl.vertexAttribPointer(end_position, 3, gl.FLOAT, false, 36, 36);
-        gl.enableVertexAttribArray(end_time);
-        gl.vertexAttribPointer(end_time, 1, gl.FLOAT, false, 36, 48);
-        gl.enableVertexAttribArray(end_color);
-        gl.vertexAttribPointer(end_color, 3, gl.FLOAT, false, 36, 52);
-        gl.bindVertexArray(null);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return program;
-    }
-    setOpacity(opacity) {
-        const { gl, _globalsbuffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 4, new Float32Array([opacity]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    setDrawCount(count) {
-        this._drawCount = count;
-    }
-    setPointSize(size) {
-        const { gl, _globalsbuffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array([size]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    setHeadTime(time) {
-        const { gl, _globalsbuffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([time]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    draw() {
-        const { gl, program, _vao, _drawCount } = this;
-        gl.useProgram(program);
-        gl.bindVertexArray(_vao);
-        gl.disable(gl.DEPTH_TEST);
-        gl.drawArrays(gl.POINTS, 0, _drawCount);
-        gl.enable(gl.DEPTH_TEST);
-        gl.bindVertexArray(null);
-    }
-    free() {
-        const { gl, _vao, _globalsbuffer, program } = this;
-        gl.deleteVertexArray(_vao);
-        // gl.deleteBuffer(_attbuffer);
-        gl.deleteBuffer(_globalsbuffer);
-        gl.deleteProgram(program);
-    }
-}

package/dist/util/account/bufferoffsetmanager.js

@@ -1,176 +0,0 @@
-/**
- * BufferOffsetManager
- * Purpose: To manage the offset of the buffer. Plus extend and defrag the buffer.
- * -------------------------------------------------------------------------------------------------------------------------------------------
- * Functions:
- * 1. getOffet(key) : return the offset of the key if not found return false.
- * 2. setOffset(key, offset) : set the offset of the key.
- * 3. nextOffset() : return the next available offset if not return false.
- * 4. delete(key) : delete the key and return true if not found return false.
- * 5. defragBuffer(gl, buffer, bufferType, newCapacity = null) : defrag the buffer. if newCapacity is not provided the buffer is vacumed.
- * 6. extendBuffer(gl, buffer, bufferType, newCapacity) : extend the buffer.
- * -------------------------------------------------------------------------------------------------------------------------------------------
- * What this class does NOT do:
- * ADD, DELETE, READ
- * ADD, inputs needs to be turn into a block and put into buffer. Bulk will be more performant.
- * DELETE, might be a set to single byte to indicate the tombstone.
- * READ, most of the time is not needed to be read, unless for defraging.
- * This unpredicatable behavior is not handled by this class.
- */
-export default class {
-    constructor(itemSize, { capacity = 10, bufferType = "STATIC_DRAW" } = {}) {
-        this.itemSize = itemSize;
-        this.bufferType = bufferType;
-        this.offSetMap = new Map();
-        this.tombstoneOffSet = [];
-        this._capacity = capacity;
-        this._length = 0;
-    }
-    get length() {
-        return this._length;
-    }
-    get capacity() {
-        return this._capacity;
-    }
-    getOffset(key) {
-        return this.offSetMap.get(key);
-    }
-    setOffset(key, offset) {
-        this.offSetMap.set(key, offset);
-    }
-    nextOffset() {
-        if (this.tombstoneOffSet.length > 0) {
-            const offset = this.tombstoneOffSet.pop();
-            return offset;
-        }
-        if (this._length < this._capacity) {
-            return this._length++ * this.itemSize * 4;
-        }
-        return false;
-    }
-    get spaceLeft() {
-        return this._capacity - (this._length - this.tombstoneOffSet.length);
-    }
-    get itemCount() {
-        return this._length - this.tombstoneOffSet.length;
-    }
-    deleteFromAccount(key) {
-        const offSet = this.offSetMap.get(key);
-        if (offSet !== undefined) {
-            this.tombstoneOffSet.push(offSet);
-            this.offSetMap.delete(key);
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    _deleteBulk(keys) {
-        const { gl, buffer } = this;
-        const emptyBlock = new Float32Array(this.itemSize).fill(0);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        for (let key of keys) {
-            const offset = this.getOffset(key);
-            if (offset !== undefined) {
-                this.deleteFromAccount(key);
-                gl.bufferSubData(gl.ARRAY_BUFFER, offset, emptyBlock);
-            }
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-    offsetMapIterator() {
-        return this.offSetMap.entries();
-    }
-    // TODO: this is broken
-    defrag(newCapacity = null) {
-        const { gl, buffer, bufferType } = this;
-        if (gl === undefined || buffer === undefined || bufferType === undefined) {
-            throw new Error("gl, buffer, bufferType are required");
-        }
-        const itemSize = this.itemSize;
-        const itemCount = this.itemCount;
-        const capacity = (newCapacity && newCapacity > itemCount) ? newCapacity : itemCount;
-        const newArray = new Float32Array(itemCount * itemSize);
-        const bufferData = this._getBufferData();
-        let newOffSet = 0;
-        const newOffSetMap = new Map();
-        for (const [key, offSet] of this.offSetMap) {
-            const itemOffSet = offSet / 4;
-            newArray.set(bufferData.slice(itemOffSet, itemOffSet + itemSize), newOffSet);
-            // this.offSetMap.set(key, newOffSet * 4);
-            newOffSetMap.set(key, newOffSet * 4);
-            newOffSet += itemSize;
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        this._capacity = capacity;
-        this.tombstoneOffSet = [];
-        this._length = itemCount;
-        this.offSetMap = newOffSetMap;
-    }
-    autoExtendBuffer(payloadSize) {
-        if (payloadSize <= this.spaceLeft)
-            return;
-        const newCapacity = Math.ceil((payloadSize + this.length));
-        this.extendBuffer(newCapacity);
-    }
-    extendBuffer(newCapacity) {
-        const { gl, buffer, bufferType } = this;
-        const itemSize = this.itemSize;
-        const bufferData = this._getBufferData();
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        this._capacity = newCapacity;
-    }
-    /** implicit methods to be used by the child class */
-    /**
-     * @typedef {Float32Array} payload
-     * @param {Array<{key, payload}>} items
-     * @param {number} partOffset
-     * @returns
-     */
-    _updatePartial(items, partOffset) {
-        const { gl, buffer } = this;
-        const partStart = partOffset * 4;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        for (let { key, payload } of items) {
-            let offset = this.getOffset(key);
-            if (offset !== undefined) {
-                gl.bufferSubData(gl.ARRAY_BUFFER, offset + partStart, payload);
-            }
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-    _getBufferData() {
-        const { gl, buffer } = this;
-        const size = new Float32Array(this.length * this.itemSize);
-        const bufferData = new Float32Array(size);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.getBufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return bufferData;
-    }
-    _removeFromBuffer(keys) {
-        const { gl, buffer } = this;
-        const emptyBlock = new Float32Array(this.itemSize).fill(0);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        for (let key of keys) {
-            let offset = this.getOffset(key);
-            if (offset !== undefined) {
-                this.deleteFromAccount(key);
-                gl.bufferSubData(gl.ARRAY_BUFFER, offset, emptyBlock);
-            }
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-    free() {
-        this.gl.deleteBuffer(this.buffer);
-        this.buffer = null;
-        this.vao = null;
-        this.gl = null;
-    }
-}

package/dist/util/account/index.js

@@ -1,3 +0,0 @@
-// import BufferOffsetManager from './bufferoffsetmanager';
-// export { BufferOffsetManager };
-export * from './single-attribute-buffer-management/index';

package/dist/util/account/util.js

@@ -1,18 +0,0 @@
-export const vaoAttributeLoader = (gl, buffer, index, size, stride, offset, divisor = null, type = null) => {
-    if (!gl || !buffer) {
-        throw new Error("Invalid WebGL context or buffer");
-    }
-    if (index < 0) {
-        throw new Error("Attribute index must be non-negative");
-    }
-    if (stride < 0 || offset < 0) {
-        throw new Error("Stride and offset must be non-negative");
-    }
-    const attribType = type === null ? gl.FLOAT : type;
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    gl.enableVertexAttribArray(index);
-    gl.vertexAttribPointer(index, size, attribType, false, stride, offset);
-    if (divisor !== null) {
-        gl.vertexAttribDivisor(index, divisor);
-    }
-};

package/dist/util/algorithms/index.js

@@ -1 +0,0 @@
-"use strict";

package/dist/util/algorithms/search-binary.js

@@ -1,25 +0,0 @@
-/**
- * @typedef {Array<number>} ListLike
- * @typedef {number || null} Index
- */
-/**
- * @param {ListLike} container
- * @param {number} value
- * @returns {Index}
- */
-const findFirstIndexInRange = (container, value) => {
-    let start = 0;
-    let end = container.length - 1;
-    let mid = 0;
-    while (start <= end) {
-        mid = Math.floor((start + end) / 2);
-        if (container[mid] <= value && value <= container[mid + 1])
-            return mid;
-        if (container[mid] < value)
-            start = mid + 1;
-        else
-            end = mid - 1;
-    }
-    return null;
-};
-export { findFirstIndexInRange };

package/dist/util/check/index.js

@@ -1 +0,0 @@
-"use strict";

package/dist/util/geometry/index.js

@@ -1,47 +0,0 @@
-function latLongToPixelXY(latitude, longitude) {
-    return {
-        x: (longitude + 180) / 360,
-        y: (90 - latitude) / 180
-    };
-}
-/**
- * createBBoxMatrix( minX, maxX, minY, maxY)
- * use this matrix to transform a point from 0 to 1 range to the bounding box
- * for example: Transform image coordinates to map coordinates
- * glsl`vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);`
- */
-function createBBoxMatrix(minX, maxX, minY, maxY) {
-    return new Float32Array([
-        maxX - minX, 0, 0,
-        0, maxY - minY, 0,
-        minX, minY, 1
-    ]);
-}
-function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
-    const minXY = latLongToPixelXY(minY, minX);
-    const maxXY = latLongToPixelXY(maxY, maxX);
-    return createBBoxMatrix(minXY.x, maxXY.x, minXY.y, maxXY.y);
-}
-/**
- *
- * @param array - The array to normalize
- * @param newLength - The target length for the normalized array
- * @returns Normalized Float32Array
- */
-function normalize(array, newLength = 1) {
-    let total = 0;
-    for (let i = 0; i < array.length; i++) {
-        total += array[i] * array[i];
-    }
-    const len = newLength / Math.sqrt(total);
-    const result = new Float32Array(array.length);
-    for (let i = 0; i < array.length; i++) {
-        result[i] = array[i] * len;
-    }
-    return result;
-}
-// TODO carry the usefull content to math module. 
-function sphereCoord(long, lat, globe, height = 0) {
-    return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, false), 6378.137 + height);
-}
-export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize };

package/dist/util/gl-util/uniform-block/shader.js

@@ -1 +0,0 @@
-"use strict";

package/dist/util/heatwavedatamanager/datamanager.js

@@ -1,149 +0,0 @@
-/**
- * todo:
- * data must be processed before being set to the cache
- */
-export default class DataManager {
-    /**
-     *
-     * @param {Array<number>} timeEpocs | array of time epocs
-     * @param {Function} fetchMethod | fetchMethod(time) => Promise<data>
-     * @param {boolean} autoDownload | auto download data or not
-    */
-    constructor(timeEpocs, fetchMethod, { autoDownload = true } = {}) {
-        this._timeEpocs = timeEpocs.sort((a, b) => a - b);
-        this._datas = [];
-        this._datas.length = timeEpocs.length;
-        // in construction
-        this._dataPromises = [];
-        this._dataPromises.length = timeEpocs.length;
-        this._fetchMethod = fetchMethod;
-        this._callbackmethods = [];
-        this._callbackmethodOwners = [];
-        this._lastTime = -1;
-        this._lastIndex = -1;
-        this.autoDownload(autoDownload);
-    }
-    autoDownload(bool, time) {
-        if (!bool) {
-            this._autoDownload = false;
-            return;
-        }
-        let index = this._lastIndex === -1 ? 0 : this._lastIndex;
-        if (time !== undefined) {
-            if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
-                this._autoDownload = bool;
-                return;
-            }
-            index = this._findIndex(time);
-        }
-        if (this._downloadStartIndex === index && this._autoDownload === bool)
-            return;
-        this._downloadStartIndex = index;
-        this._autoDownload = bool;
-        const recursion = (startId, currentDownloadId) => {
-            if (startId !== this._downloadStartIndex)
-                return;
-            if (currentDownloadId < this._timeEpocs.length && this._autoDownload) {
-                this._getData(currentDownloadId).then(() => {
-                    recursion(startId, currentDownloadId + 1);
-                });
-            }
-        };
-        recursion(index, index);
-        // save index as start index
-        //start recursive download
-        // use started id as a flag to stop the download
-    }
-    /**
-     * @param {number} time
-     * It looks like async function is not needed here. changes just overwrites the previous changes.
-     */
-    updateTime(time) {
-        if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
-            this._dontRender();
-            return;
-        }
-        this._lastTime = time;
-        const index = this._findIndex(time);
-        const ratio = this._getRatio(time, index);
-        Promise.all([this._getData(index - 1), this._getData(index)]).then((datas) => {
-            if (this._lastTime === time) {
-                this._lastIndex = index;
-                this._ratio = ratio;
-                this._pushCallback(ratio, datas);
-            }
-        });
-    }
-    register(key, callback) {
-        if (this._callbackmethodOwners.indexOf(key) !== -1) {
-            console.warn("key already registered, old one is unregistered");
-            this.unregister(key);
-        }
-        this._callbackmethods.push(callback);
-        this._callbackmethodOwners.push(key);
-        if (this._lastIndex !== -1)
-            callback(this._ratio, this._datas[this._lastIndex - 1], this._datas[this._lastIndex]);
-    }
-    /**
-     * @param {*} key | id of the owner of the callback
-     */
-    unregister(key) {
-        let index = this._callbackmethodOwners.indexOf(key);
-        if (index !== -1) {
-            this._callbackmethods.splice(index, 1);
-            this._callbackmethodOwners.splice(index, 1);
-        }
-        if (this._callbackmethods.length === 0) {
-            this.free();
-        }
-    }
-    free() {
-        this._callbackmethods = [];
-        this._callbackmethodOwners = [];
-        this._autoDownload = false;
-    }
-    _findIndex(time) {
-        const { _timeEpocs } = this;
-        let index = this._lastIndex === -1 ? 1 : this._lastIndex;
-        if (this)
-            if (time < _timeEpocs[index - 1]) {
-                while (index > 1 && time < _timeEpocs[index - 1]) {
-                    index--;
-                }
-            }
-            else if (time > _timeEpocs[index]) {
-                while (index < _timeEpocs.length - 1 && time > _timeEpocs[index]) {
-                    index++;
-                }
-            }
-        return index;
-    }
-    _getRatio(time, index) {
-        return (time - this._timeEpocs[index - 1]) / (this._timeEpocs[index] - this._timeEpocs[index - 1]);
-    }
-    _pushCallback(ratio, datas) {
-        for (let i = 0; i < this._callbackmethods.length; i++) {
-            this._callbackmethods[i](ratio, ...datas);
-        }
-    }
-    async _getData(index) {
-        if (index < 0 || index >= this._timeEpocs.length) {
-            throw new Error("Index out of range");
-        }
-        if (!this._datas[index]) {
-            if (!this._dataPromises[index])
-                this._dataPromises[index] = this._fetchMethod(this._timeEpocs[index]).then((data) => {
-                    this._datas[index] = data;
-                }, (error) => {
-                    console.error("error", error);
-                }).finally(() => {
-                    this._dataPromises[index] = null;
-                });
-        }
-        await this._dataPromises[index];
-        return this._datas[index];
-    }
-    _dontRender() {
-        this._pushCallback(0, [null, null]);
-    }
-}

package/dist/util/heatwavedatamanager/index.js

@@ -1,2 +0,0 @@
-import HeatWaveDataManager from "./datamanager";
-export { HeatWaveDataManager };

package/dist/util/index.js

@@ -1,13 +0,0 @@
-import * as webglobjectbuilders from './webglobjectbuilders';
-import * as shaderfunctions from './shaderfunctions';
-import * as geometry from './geometry';
-import * as webglobe from './webglobe';
-import * as programs from './programs';
-import * as heatwavedatamanager from './heatwavedatamanager';
-export { webglobjectbuilders, shaderfunctions, geometry, webglobe, programs, heatwavedatamanager };
-export * from './webglobe';
-export * from './webglobjectbuilders';
-export * from './shaderfunctions';
-export * from './geometry';
-export * from './programs';
-export * from './heatwavedatamanager';

package/dist/util/interpolation/index.js

@@ -1 +0,0 @@
-"use strict";

package/dist/util/interpolation/timetrack/index.js

@@ -1,2 +0,0 @@
-const createWorker = () => new Worker(new URL('./web-worker.js', import.meta.url), { type: 'module' });
-export { createWorker };