isard 1.2.0 → 1.4.0

package/dist/wasm/isard_tess.js

@@ -0,0 +1,398 @@
+/* @ts-self-types="./isard_tess.d.ts" */
+
+/**
+ * A vector tile ready for the GPU (`geo::mesh::vector_tiles::TileMesh`), as the engine's `setVectorTileMesh` takes it
+ */
+export class TessellatedTile {
+    static __wrap(ptr) {
+        const obj = Object.create(TessellatedTile.prototype);
+        obj.__wbg_ptr = ptr;
+        TessellatedTileFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TessellatedTileFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tessellatedtile_free(ptr, 0);
+    }
+    /**
+     * Their triangles
+     * @returns {Uint32Array}
+     */
+    blockIndices() {
+        const ret = wasm.tessellatedtile_blockIndices(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Per sublayer: its blocks' indices, first and end
+     * @returns {Uint32Array}
+     */
+    blockRanges() {
+        const ret = wasm.tessellatedtile_blockRanges(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * The blocks of the raised sublayers (`shapes::Block`, 32 bytes each), as bytes
+     * @returns {Uint8Array}
+     */
+    blocks() {
+        const ret = wasm.tessellatedtile_blocks(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The extent of the tile's points: min x, min y, max x, max y
+     * @returns {Float64Array}
+     */
+    bounds() {
+        const ret = wasm.tessellatedtile_bounds(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Per sublayer: its top cap and the rest of its prism, first and end of each (four numbers)
+     * @returns {Uint32Array}
+     */
+    fillRanges() {
+        const ret = wasm.tessellatedtile_fillRanges(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * The fill triangles
+     * @returns {Uint32Array}
+     */
+    indices() {
+        const ret = wasm.tessellatedtile_indices(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Per sublayer: its pieces, first and end
+     * @returns {Uint32Array}
+     */
+    lineRanges() {
+        const ret = wasm.tessellatedtile_lineRanges(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Feature and length of each line
+     * @returns {Float32Array}
+     */
+    lineTable() {
+        const ret = wasm.tessellatedtile_lineTable(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The line pieces (`pieces::Piece`, 28 bytes each), as bytes
+     * @returns {Uint8Array}
+     */
+    pieces() {
+        const ret = wasm.tessellatedtile_pieces(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether the prisms were built
+     * @returns {boolean}
+     */
+    prism() {
+        const ret = wasm.tessellatedtile_prism(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * The fill vertices (`shapes::Vertex`, 24 bytes each), as bytes
+     * @returns {Uint8Array}
+     */
+    vertices() {
+        const ret = wasm.tessellatedtile_vertices(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) TessellatedTile.prototype[Symbol.dispose] = TessellatedTile.prototype.free;
+
+/**
+ * The geometry of a vector tile made ready for the GPU, as the engine's `setVectorTile` takes it: its polygons
+ * (interleaved points, `ring_start`, `polygon_start`, the feature of each, `fill_start`: the first polygon of each
+ * sublayer and the end), its lines (interleaved points, `line_first`: the first point of each, the feature of each,
+ * `line_start`: the first line of each sublayer and the end); `raised`: per sublayer, whether its polygons are extruded
+ * into blocks rather than filled; `prism`: with the prisms the fills need over the relief; `tile`: the corners of the
+ * tile they are cut to (west, north, east, south, Mercator; empty: none), along whose edges no wall of a block rises
+ * @param {Float64Array} points
+ * @param {Uint32Array} ring_start
+ * @param {Uint32Array} polygon_start
+ * @param {Uint32Array} polygon_feature
+ * @param {Uint32Array} fill_start
+ * @param {Float64Array} line_points
+ * @param {Uint32Array} line_first
+ * @param {Uint32Array} line_feature
+ * @param {Uint32Array} line_start
+ * @param {Uint8Array} raised
+ * @param {boolean} prism
+ * @param {Float64Array} tile
+ * @returns {TessellatedTile}
+ */
+export function tessellateVectorTile(points, ring_start, polygon_start, polygon_feature, fill_start, line_points, line_first, line_feature, line_start, raised, prism, tile) {
+    const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(ring_start, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray32ToWasm0(polygon_start, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray32ToWasm0(polygon_feature, wasm.__wbindgen_malloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ptr4 = passArray32ToWasm0(fill_start, wasm.__wbindgen_malloc);
+    const len4 = WASM_VECTOR_LEN;
+    const ptr5 = passArrayF64ToWasm0(line_points, wasm.__wbindgen_malloc);
+    const len5 = WASM_VECTOR_LEN;
+    const ptr6 = passArray32ToWasm0(line_first, wasm.__wbindgen_malloc);
+    const len6 = WASM_VECTOR_LEN;
+    const ptr7 = passArray32ToWasm0(line_feature, wasm.__wbindgen_malloc);
+    const len7 = WASM_VECTOR_LEN;
+    const ptr8 = passArray32ToWasm0(line_start, wasm.__wbindgen_malloc);
+    const len8 = WASM_VECTOR_LEN;
+    const ptr9 = passArray8ToWasm0(raised, wasm.__wbindgen_malloc);
+    const len9 = WASM_VECTOR_LEN;
+    const ptr10 = passArrayF64ToWasm0(tile, wasm.__wbindgen_malloc);
+    const len10 = WASM_VECTOR_LEN;
+    const ret = wasm.tessellateVectorTile(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, prism, ptr10, len10);
+    return TessellatedTile.__wrap(ret);
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_new_from_slice_37a3c3a194266cb8: function(arg0, arg1) {
+            const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_from_slice_ca6ad97db1f4779a: function(arg0, arg1) {
+            const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __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);
+        },
+    };
+    return {
+        __proto__: null,
+        "./isard_tess_bg.js": import0,
+    };
+}
+
+const TessellatedTileFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tessellatedtile_free(ptr, 1));
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, 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) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('isard_tess_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/dist/workers/basemap/geometry.d.ts

@@ -0,0 +1,72 @@
+/** A vector tile cut into geometry for the engine: the polygons of the extrusions, the fills, lines and buildings of
+ * `vectors()` with their style per feature, made ready for the GPU by the tessellation module */
+import type { Value } from '../../basemap/mvt.ts';
+import type { Priority, TileMesh, TileVectors } from '../basemap.worker.ts';
+import { type Renderer } from './tiles.ts';
+/**
+ * The polygons of a tile's features in the renderer's fill layers (each feature once, whichever layers keep it), in
+ * Mercator [0, 1]: a ring turning clockwise in tile units (y down) starts a polygon, the others are its holes (the
+ * vector tile specification)
+ */
+export declare const polygons: (r: Renderer, z: number, x: number, y: number, id: number, priority?: Priority) => Promise<{
+    arrays: {
+        points: Float64Array<ArrayBuffer>;
+        ringStart: Uint32Array<ArrayBuffer>;
+        polygonStart: Uint32Array<ArrayBuffer>;
+        feature: Uint32Array<ArrayBuffer>;
+    };
+    properties: Record<string, Value>[];
+} | undefined>;
+/**
+ * A ring cut to the square [0, `extent`] (Sutherland–Hodgman), its points interleaved, unclosed: a polygon lying
+ * across the tile's edge keeps its part in the tile, along the edge
+ */
+export declare const clipRing: (ring: readonly number[], extent: number) => number[];
+/** A line cut to the square [0, `extent`] (Liang–Barsky per segment): its runs inside, each two points at least */
+export declare const clipLine: (line: readonly number[], extent: number) => number[][];
+/**
+ * The geometry of a feature of a tile of the source's level in the units of its tile `d` levels deeper at (`ox`, `oy`)
+ * among the `2^d × 2^d` it holds (overzoom); undefined if none of it lies in that tile (its points' bounds outside
+ * it or along its edge: nothing left once cut to it)
+ */
+export declare const overzoomed: (geometry: readonly (readonly number[])[], extent: number, d: number, ox: number, oy: number) => number[][] | undefined;
+/**
+ * The fills and lines of a tile's features in the renderer's layers, cut to the tile, in Mercator [0, 1], each with
+ * its style (color, its opacity folded in; a line's width, its gap folded in as the casing drawn by `draw`, at four
+ * zooms over the range the tile is drawn at); with `stylesOnly`, the styles alone. Patterns, outlines and circles are
+ * left to the raster path
+ */
+export declare const vectors: (r: Renderer, { z, x, y, deepest }: {
+    z: number;
+    x: number;
+    y: number;
+    deepest?: number;
+}, id: number, stylesOnly: boolean, priority?: Priority) => Promise<Float32Array<ArrayBuffer> | {
+    fills: {
+        points: Float64Array<ArrayBuffer>;
+        ringStart: Uint32Array<ArrayBuffer>;
+        polygonStart: Uint32Array<ArrayBuffer>;
+        feature: Uint32Array<ArrayBuffer>;
+        fillStart: Uint32Array<ArrayBuffer>;
+    };
+    lines: {
+        points: Float64Array<ArrayBuffer>;
+        start: Uint32Array<ArrayBuffer>;
+        feature: Uint32Array<ArrayBuffer>;
+        lineStart: Uint32Array<ArrayBuffer>;
+    };
+    styles: Float32Array<ArrayBuffer>;
+    tile: Float64Array<ArrayBuffer>;
+    properties: Record<string, Value>[];
+    sublayer: Uint16Array<ArrayBuffer>;
+} | undefined>;
+/** The tessellation module: where it is, and once loaded whether it works (false: the main thread does its work) */
+export declare const tess: {
+    url?: string;
+    ready?: Promise<boolean>;
+};
+/** The tessellation module loaded, once; false without one or if it failed */
+export declare const tessellator: () => Promise<boolean>;
+/** A cut tile made ready for the GPU by the tessellation module (`raised`: per sublayer, whether its polygons are
+ * extruded into blocks); undefined if it fails (it is then left aside) */
+export declare const tessellate: (out: TileVectors, raised: Uint8Array, prism: boolean) => TileMesh | undefined;

package/dist/workers/basemap/labels.d.ts

@@ -0,0 +1,8 @@
+/** The label candidates of a tile: the texts and icons of the style's symbol layers, for the page to shape and place */
+import { type LabelCandidate } from '../../basemap/vectorstyle.ts';
+import type { Priority } from '../basemap.worker.ts';
+import { type Renderer } from './tiles.ts';
+/** Points every `spacing` along a line (tile units, x and y interleaved), the first half a spacing in (the middle of a
+ * shorter line): each point and the segment it lies on (x, y, x0, y0, x1, y1) */
+export declare const lineAnchors: (line: readonly number[], spacing: number) => number[][];
+export declare const labels: (r: Renderer, z: number, x: number, y: number, id: number, priority?: Priority, zoom?: number) => Promise<LabelCandidate[]>;

package/dist/workers/basemap/raster.d.ts

@@ -0,0 +1,10 @@
+/** A vector tile drawn into an image with its style (Canvas 2D), for the raster pool */
+import type { Priority } from '../basemap.worker.ts';
+import { type Renderer } from './tiles.ts';
+/**
+ * The image of a drawn canvas, its alpha straight (the engine blends straight alpha). An opaque tile (a background
+ * of full opacity, as a basemap's) is moved out of the canvas as it is, premultiplied and straight being the same
+ * there; another one is read back unpremultiplied, copied
+ */
+export declare const tileImage: (canvas: OffscreenCanvas, g: OffscreenCanvasRenderingContext2D, opaque: boolean) => Promise<ImageBitmap>;
+export declare const render: (r: Renderer, z: number, x: number, y: number, size: number, id: number, priority?: Priority) => Promise<ImageBitmap | null | undefined>;

package/dist/workers/basemap/street.d.ts

@@ -0,0 +1,19 @@
+/** The wind of a city's streets: the buildings of the vector tiles around a square, laid on its grid of cells, and
+ * the flow round them for a wind towards the east and one towards the north (the grid module) */
+import { type StreetFlows } from '../../grid-module.ts';
+import type { Priority } from '../basemap.worker.ts';
+import type { Renderer } from './tiles.ts';
+/** What a street flow is asked with: its square (Mercator: west, north, east, south) and grid, the tiles of level `z`
+ * over it (x, y pairs), the sweeps, the grid module's URL */
+export interface StreetWork {
+    module: string;
+    z: number;
+    tiles: number[];
+    bounds: [x0: number, y0: number, x1: number, y1: number];
+    width: number;
+    height: number;
+    iterations: number;
+    priority?: Priority;
+}
+/** The streets' flows of a square: the buildings of its tiles in cells (those away from it left out), then solved */
+export declare const streetFlowOf: (r: Renderer, work: StreetWork, id: number) => Promise<StreetFlows>;

package/dist/workers/basemap/tiles.d.ts

@@ -0,0 +1,65 @@
+/** The state a basemap worker shares among its jobs: the renderers (a style's layers over a source), the decoded vector
+ * tiles and raster images it keeps, the requests in progress, and the style's values as its jobs read them */
+import { type TileLayer } from '../../basemap/mvt.ts';
+import { type Context, type RasterSource, type StyleLayer } from '../../basemap/vectorstyle.ts';
+import { Lru } from '../../util/lru.ts';
+import type { Priority } from '../basemap.worker.ts';
+export interface Renderer {
+    tiles: string;
+    maxzoom: number;
+    layers: StyleLayer[];
+    rasters: Record<string, RasterSource>;
+    sprites: Sprite[];
+    /** Fill patterns by icon name, cut from the sprites once */
+    patterns: Map<string, OffscreenCanvas | undefined>;
+}
+/** A sprite of the style: its images by name (`id:name` but in the default sprite) and its sheet */
+export interface Sprite {
+    image: ImageBitmap;
+    icons: Record<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        pixelRatio?: number;
+    }>;
+}
+/** An image of the sprites and its sheet */
+export declare const spriteIcon: (r: Renderer, name: string) => {
+    icon: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        pixelRatio?: number;
+    };
+    image: ImageBitmap;
+} | undefined;
+export declare const renderers: Map<string, Renderer>;
+/** Decoded tiles by URL; this worker's share of them, set by the renderers */
+export declare const cache: Lru<string, Promise<Map<string, TileLayer> | undefined>>;
+/** The decoded tiles one worker of `workers` keeps */
+export declare const cacheShare: (workers: number) => number;
+/** Requests in progress, and those of them aborted (both forgotten once answered) */
+export declare const active: Set<number>;
+export declare const aborted: Set<number>;
+/** An image of a raster source (shared by every renderer); undefined where the source has none */
+export declare const image: (url: string, priority?: Priority) => Promise<ImageBitmap | undefined>;
+/** A vector tile, decoded (shared by every renderer of its URL); the first request's priority fetches it */
+export declare const tile: (url: string, priority?: Priority) => Promise<Map<string, TileLayer> | undefined>;
+/** The vector tile to draw a raster tile from, and where the raster tile lies in it (tile units) */
+export declare const source: (r: Renderer, z: number, x: number, y: number) => {
+    url: string;
+    vz: number;
+    vx: number;
+    vy: number;
+    part: number;
+    ox: number;
+    oy: number;
+};
+export declare const value: (layer: StyleLayer, group: "paint" | "layout", key: string, ctx: Context, fallback: unknown) => unknown;
+/** A color with an opacity, for the canvas */
+export declare const paint: (c: unknown, opacity: number) => string;
+export declare const shown: (layer: StyleLayer, zoom: number) => boolean;
+/** Longitude and latitude of a point of tile (z, x, y) in tile units */
+export declare const lonLat: (z: number, x: number, y: number, extent: number, px: number, py: number) => [number, number];

package/dist/workers/basemap/trees.d.ts

@@ -0,0 +1,19 @@
+/** The trees of a tile: points scattered over the woods of its polygons, the same each time the tile is cut */
+import type { Priority } from '../basemap.worker.ts';
+import { type Renderer } from './tiles.ts';
+/** A number in [0, 1) from four integers, the same for the same ones: where a tree stands in its cell, its size */
+export declare const treeHash: (a: number, b: number, c: number, d: number) => number;
+/** Whether a point lies in rings (interleaved points, unclosed or closed), even-odd: the holes cut out */
+export declare const inRings: (rings: readonly (readonly number[])[], px: number, py: number) => boolean;
+/**
+ * Points scattered over a polygon (its rings, tile units) on a jittered grid of `cell` tile units, the grid and the
+ * jitter fixed by the tile (`seed`): the same trees whenever the tile is cut again, none twice across tiles (the points
+ * past the tile's edge left to its neighbour). Past `maxCells` cells over the polygon (a tile of a coarse level), the
+ * cells grow until they are no more. Each point with a number in [0, 1) for its size and heading
+ */
+export declare const scatter: (rings: readonly (readonly number[])[], extent: number, spacing: number, seed: [number, number, number], maxCells?: number) => [x: number, y: number, k: number][];
+/**
+ * Trees over the polygons of the renderer's layers in a tile: longitude, latitude, scale (0.75 to 1.25), heading
+ * (degrees) and rank (in [0, 1): the page keeps the lowest far from the view) of each, `spacing[s]` metres apart in layer `s` on a jittered grid; past `maxTrees`, thinned evenly
+ */
+export declare const trees: (r: Renderer, z: number, x: number, y: number, id: number, spacing: number[], maxTrees: number, priority?: Priority) => Promise<Float64Array<ArrayBuffer> | undefined>;