UNPKG

@giro3d/giro3d

Version:

A JS/WebGL framework for 3D geospatial data visualization

giro3d.org

7 lines (6 loc) • 615 kB
1
2
3
4
5
6
7
import { getLazPerfPath } from './config'; // Note: this function has to be in its own file to avoid circular dependencies // when using webpack (and possibly other bundlers) // It cannot be in worker.ts nor in config.ts, unfortunately. export default function createWorker() { const worker = new Worker(URL.createObjectURL(new Blob([atob('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