isard 0.0.0-stage → 0.2.1

package/dist/wasm/isard.d.ts

@@ -0,0 +1,612 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/** A primitive of a tile decoded by `decodeTile`: vertices x, y, z, u, v around the anchor; the image still encoded */
+export interface EncodedPrimitive {
+    vertices: Float32Array<ArrayBuffer>;
+    indices: Uint32Array<ArrayBuffer>;
+    image?: Uint8Array<ArrayBuffer>;
+    mime?: string;
+}
+
+/** A tile decoded by `decodeTile` */
+export interface EncodedTile {
+    /** ECEF origin of the vertices (metres) */
+    anchor: Float64Array<ArrayBuffer>;
+    primitives: EncodedPrimitive[];
+}
+
+/** A texture transcoded for the GPU (KTX2 / Basis Universal): a WebGL internal format and its mip levels */
+export interface CompressedTexture {
+    /** WebGL internal format (compressed, or RGBA8 when the GPU supports none of the targets) */
+    format: number;
+    levels: { width: number; height: number; data: Uint8Array<ArrayBuffer> }[];
+}
+
+/** A primitive ready for the GPU: its image decoded (bitmap) or transcoded (texture) */
+export interface DecodedPrimitive {
+    vertices: Float32Array<ArrayBuffer>;
+    indices: Uint32Array<ArrayBuffer>;
+    bitmap: ImageBitmap | null;
+    texture?: CompressedTexture;
+}
+
+/** A Draco-compressed primitive of a tile (`KHR_draco_mesh_compression`), to decode with the Draco module */
+export interface DracoRequest {
+    mesh: number;
+    primitive: number;
+    data: Uint8Array<ArrayBuffer>;
+    /** Draco attribute ids */
+    position: number;
+    uv?: number;
+}
+
+/** The Draco module's output for a request: positions and uv as stored, triangles */
+export interface DracoGeometry {
+    mesh: number;
+    primitive: number;
+    positions: Float32Array;
+    uvs?: Float32Array;
+    indices: Uint32Array;
+}
+
+/** Compressed texture formats supported by the GPU */
+export interface TextureFormats {
+    astc: boolean;
+    bptc: boolean;
+    etc: boolean;
+    s3tc: boolean;
+}
+
+/** A tile ready for the GPU, as the decoding workers deliver it */
+export interface DecodedTile {
+    anchor: Float64Array<ArrayBuffer>;
+    primitives: DecodedPrimitive[];
+}
+
+/** What the engine expects from a pool of decoding workers (`Engine.setTileLoader`) */
+export interface TileLoaderLike {
+    /**
+     * `reload`: bypass the HTTP cache (the tile failed before: the cache may hold the error); `priority`: the Fetch
+     * Priority for the download (the first tiles in view of a frame are urgent)
+     */
+    load(
+    id: number,
+    url: string,
+    transform: Float64Array,
+    yUp: boolean,
+    reload: boolean,
+    priority?: 'high' | 'low',
+    ): Promise<DecodedTile>;
+    abort(id: number): void;
+}
+
+
+
+/** Camera, with the conventions of MapLibre */
+export interface Camera {
+    center: [lon: number, lat: number];
+    zoom: number;
+    /** Degrees from the vertical, 0 to 70 */
+    pitch: number;
+    /** Degrees clockwise from the north */
+    bearing: number;
+}
+
+/** The feature under a screen point */
+export interface PickHit {
+    /** Id of the layer */
+    layer: number;
+    /** Index of the feature in the layer (the edge of a network) */
+    index: number;
+}
+
+/** Tile counters of a raster layer */
+export interface RasterLayerStats {
+    id: number;
+    /** Tiles drawn in the last frame (stand-ins included) */
+    drawn: number;
+    /** Tiles held on the GPU */
+    loaded: number;
+    /** Requests in flight */
+    inFlight: number;
+    /** Arrived tiles waiting for their upload */
+    queued: number;
+    /** Drawn with an ancestor's texture: the tile itself is not loaded yet */
+    standIns: number;
+    /** Waiting before a new attempt after errors */
+    cooling: number;
+    /** Not served (404), covered by an ancestor */
+    missing: number;
+}
+
+
+
+/** Counters of a 3D Tiles layer */
+export interface Tiles3dStats {
+    /** Tiles drawn in the last frame */
+    drawn: number;
+    /** Meshes held on the GPU */
+    loaded: number;
+    /** Downloads of tiles in view */
+    inFlight: number;
+    /** Downloads of tiles just out of view (siblings of refined tiles), in the background */
+    prefetching: number;
+    /** GPU memory of the meshes, MB */
+    gpuMb: number;
+    /** Tiles known in the tree (external tilesets included once loaded) */
+    tiles: number;
+}
+
+
+
+/** Pieces of a network layer: its edges cut along their lines, sorted by square; only the squares in view are drawn */
+export interface NetworkStats {
+    pieces: number;
+    /** Drawn in the last frame */
+    drawn: number;
+}
+
+
+
+/** The answer to `requestPick`, from `pollPick` */
+export interface PickResult {
+    /** The screen point asked about (CSS pixels) */
+    x: number;
+    y: number;
+    /** The feature there, if any */
+    hit?: PickHit;
+    /** The position there, on the relief; undefined above the horizon */
+    lonLat?: [lon: number, lat: number];
+}
+
+
+
+export class Engine {
+    free(): void;
+    /**
+     * Circle layer of `feature_count` features: points (Mercator [0, 1], interleaved) and the feature of each
+     */
+    addCircles(points: Float64Array, feature: Uint32Array, feature_count: number): number;
+    /**
+     * An empty extrusion layer: its blocks come in batches (`setExtrusionBatch`)
+     */
+    addExtrusions(): number;
+    /**
+     * Fill layer of `feature_count` features: polygons given by their points (Mercator [0, 1], interleaved), the first
+     * point of each ring (`ring_start`, one more entry than rings), the first ring of each polygon (`polygon_start`,
+     * one more entry than polygons; the first ring is the outer one, the others holes) and the feature of each polygon
+     */
+    addFills(points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, feature: Uint32Array, feature_count: number): number;
+    /**
+     * Ground layer running `code` (GLSL ES 3.0 defining `vec4 ground(vec2 offset)`, see `render::ground`) over the
+     * ground; `anchor`: Mercator point the offsets are taken from; bounds: Mercator box it shows in. Compilation errors
+     * come back with the shader's info log (line numbers of `code`)
+     */
+    addGround(code: string, anchor_x: number, anchor_y: number, min_x: number, min_y: number, max_x: number, max_y: number): number;
+    /**
+     * Line layer of `feature_count` features: polylines given by their points (Mercator [0, 1], interleaved), the
+     * first point of each (`start`, one more entry than lines) and the feature each one belongs to
+     */
+    addLines(points: Float64Array, start: Uint32Array, feature: Uint32Array, feature_count: number): number;
+    /**
+     * Network of `mercator.length / 2` nodes (Mercator [0, 1], y towards the south, interleaved: converted by the
+     * JavaScript side, where `Math.tan` and `Math.log` are much faster than in WebAssembly) and `edges.length / 2`
+     * edges (node index pairs, interleaved). `line_start` and `line_points`: the line of each edge from A to B, points
+     * `line_start[e] .. line_start[e + 1]` of `line_points` (Mercator, interleaved; straight if fewer than two). `costs`: per edge, the
+     * cost of travelling it from A to B then from B to A; without, values are interpolated along the edges.
+     */
+    addNetwork(mercator: Float64Array, edges: Uint32Array, line_start: Uint32Array | null | undefined, line_points: Float64Array | null | undefined, costs: Float32Array | null | undefined, style: Float32Array): number;
+    /**
+     * Raster tiles in Web Mercator; `url` holds {z}, {x} and {y}. `size`: side of the tiles' textures (256 by
+     * default); `loader`: draws each tile instead of fetching `url`, `(z, x, y, signal) => Promise<ImageBitmap |
+     * null>`, an image of `size` × `size` (null: nothing there)
+     */
+    addRaster(url: string, min_z: number, max_z: number, opacity: number, saturation: number, size: number | null | undefined, loader: ((z: number, x: number, y: number, signal: AbortSignal) => Promise<ImageBitmap | null>) | undefined): number;
+    /**
+     * An empty symbol layer
+     */
+    addSymbols(): number;
+    /**
+     * 3D Tiles (b3dm / glb textured meshes, external tilesets) from the URL of a `tileset.json`. `max_error`:
+     * screen-space error (CSS pixels) above which a tile is refined; 16 is the usual value, lower is finer.
+     */
+    addTiles3d(url: string, max_error: number): number;
+    /**
+     * Longitudes and latitudes the view covers on the ground, `[west, south, east, north]` (degrees): the screen's
+     * border cast on the ground, or on the far plane where it passes the horizon
+     */
+    bounds(): Float64Array;
+    camera(): Camera;
+    clearPreload(): void;
+    /**
+     * Position under a screen point (CSS pixels), undefined above the horizon; on the relief itself
+     */
+    ground(x: number, y: number): [lon: number, lat: number] | undefined;
+    /**
+     * Colors an extrusion layer by the node values of network layer `network` (undefined: by its own values):
+     * each block takes min(value(A) + cost from A, value(B) + cost from B) from its anchors (`setExtrusionAnchors`),
+     * through the layer's ramp, up to `max` (above: its own color)
+     */
+    linkExtrusionNetwork(id: number, network: number | null | undefined, max: number): void;
+    /**
+     * Moves a layer to a drawing position (0 = bottom)
+     */
+    moveLayer(id: number, index: number): void;
+    /**
+     * Pieces of a network in all and drawn in the last frame (only the squares in view are)
+     */
+    networkStats(id: number): NetworkStats | undefined;
+    /**
+     * `redraw` is called when the engine needs a new frame (a tile arrived)
+     */
+    constructor(canvas: HTMLCanvasElement, redraw: () => void);
+    /**
+     * Drags the ground from one screen point to another (CSS pixels); in relief, the ground point grabbed stays
+     * under the cursor
+     */
+    pan(x0: number, y0: number, x1: number, y1: number): void;
+    /**
+     * Feature under a screen point (CSS pixels), or the nearest one within `radius` CSS pixels: its layer and its
+     * index there (the edge of a network, the feature of a line, circle or fill layer), undefined if none. The
+     * pickable layers are drawn with each feature colored by its number; then the fills are tested on the ground.
+     * `only`: the ids of the layers to look in (all if undefined): the others are not drawn and hide nothing.
+     * Reads the pixels back at once (the GPU finishes its work first): for clicks; `requestPick` for the hover
+     */
+    pick(x: number, y: number, radius?: number | null, only?: Uint32Array | null): PickHit | undefined;
+    /**
+     * The answer to the last `requestPick` once the GPU has delivered it (then forgotten), undefined while it is not
+     * there yet (or nothing was asked, or the context was lost)
+     */
+    pollPick(): PickResult | undefined;
+    /**
+     * Loads in advance the tiles of a camera flight's destination; `clearPreload` when the flight ends
+     */
+    preload(lon: number, lat: number, zoom: number, pitch: number, bearing: number): void;
+    /**
+     * Screen point (CSS pixels) of a ground position, undefined behind the camera
+     */
+    project(lon: number, lat: number): [x: number, y: number] | undefined;
+    removeExtrusionBatch(id: number, key: number): void;
+    removeLayer(id: number): void;
+    /**
+     * Draws a frame; returns true while tiles are still loading (a new frame will be asked through `redraw`)
+     */
+    render(): boolean;
+    /**
+     * Asks what is under a screen point without waiting for the GPU (as `pick`, with the position there): the
+     * picking pass is drawn now and read back into a buffer; `pollPick` gives the answer on a later frame. A new
+     * request replaces the one in flight. Returns false if nothing could be asked (no WebGL2 fence)
+     */
+    requestPick(x: number, y: number, radius?: number | null, only?: Uint32Array | null): boolean;
+    /**
+     * Viewport in CSS pixels and device pixel ratio
+     */
+    resize(width: number, height: number, pixel_ratio: number): void;
+    /**
+     * Turns and tilts around the screen center, in degrees
+     */
+    rotate(bearing: number, pitch: number): void;
+    /**
+     * Sky over the plane (`MapLibre`'s `setSky`): colors of the sky, the horizon and the fog (RGB 0-1, 9 numbers),
+     * then the sky-horizon, horizon-fog and fog-ground blends; `undefined` for none (the background color shows)
+     */
+    setAtmosphere(settings?: Float32Array | null): void;
+    setBackground(r: number, g: number, b: number): void;
+    /**
+     * The body the map is drawn on: its equatorial radius (metres) and flattening (0 for a sphere), the halo of its
+     * atmosphere around the globe (RGB 0-1 and its strength, 4 numbers; `undefined` for an airless body), and the
+     * lowest and highest altitudes of its ground (metres: what its relief may raise into view). WGS 84, the Earth's
+     * blue halo and the range of its relief worldwide (-450 m to 8900 m) by default; set before the layers and the
+     * relief, whose shaders may take its size (`ISARD_EARTH` of the ground layers)
+     */
+    setBody(radius: number, flattening: number, halo: Float32Array | null | undefined, lowest: number, highest: number): void;
+    setCamera(lon: number, lat: number, zoom: number, pitch: number, bearing: number): void;
+    /**
+     * Circles lying on the ground (true) or facing the screen
+     */
+    setCircleAlignment(id: number, on_ground: boolean): void;
+    /**
+     * New points for a circle layer (same features)
+     */
+    setCircles(id: number, points: Float64Array, feature: Uint32Array): void;
+    /**
+     * Anchors of batch `key` on the linked network: per feature, node A, node B, cost from A, cost from B
+     */
+    setExtrusionAnchors(id: number, key: number, anchors: Float32Array): void;
+    /**
+     * Adds or replaces batch `key` of an extrusion layer: polygons as for `addFills`, `feature_count` features (the
+     * feature style gives each its height and base height as its two sizes, metres)
+     */
+    setExtrusionBatch(id: number, key: number, points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, feature: Uint32Array, feature_count: number): void;
+    /**
+     * Layer-wide style of a feature layer: opacity as zoom stops (four zooms then four values), the zoom range it
+     * shows in (`min_zoom` included, `max_zoom` excluded), whether it shows at all
+     */
+    setFeatureLayer(id: number, opacity: Float32Array, min_zoom: number, max_zoom: number, visible: boolean): void;
+    /**
+     * One byte per feature, 0 hiding it (the filter)
+     */
+    setFeatureMask(id: number, mask: Uint8Array, key?: number | null): void;
+    /**
+     * Colors of the values `min` to `max`, 256 RGBA texels (1024 bytes); undefined: none
+     */
+    setFeatureRamp(id: number, rgba: Uint8Array | null | undefined, min: number, max: number): void;
+    /**
+     * Style of the features of a line, circle, fill or extrusion layer (batch `key` of the latter): 32 floats per
+     * feature, its color (RGBA 0-1), its second color (a circle's stroke), then two sizes as zoom stops (four zooms,
+     * four values each): a line's width; a circle's radius and stroke width, CSS pixels; a block's height and base
+     * height, metres
+     */
+    setFeatureStyle(id: number, style: Float32Array, key?: number | null): void;
+    /**
+     * One value per feature, colored through the layer's ramp (`setFeatureRamp`); 1e30 or NaN: its own color
+     */
+    setFeatureValues(id: number, values: Float32Array, key?: number | null): void;
+    /**
+     * New polygons for a fill layer (same arguments as `addFills`, the same features)
+     */
+    setFills(id: number, points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, feature: Uint32Array): void;
+    /**
+     * Color of the globe under the tiles (polar caps)
+     */
+    setGlobeColor(r: number, g: number, b: number): void;
+    /**
+     * Globe (true) or Web Mercator (false)
+     */
+    setGlobe(globe: boolean): void;
+    /**
+     * The glyph atlas shared by the symbol layers, one page: `width` × `height` bytes of signed distances
+     * (allocated again, filled with `data` if given)
+     */
+    setGlyphAtlas(width: number, height: number, data?: Uint8Array | null): void;
+    /**
+     * The glyph atlas shared by the symbol layers, `pages` pages of `width` × `height` bytes of signed distances,
+     * allocated again and empty (`updateGlyphPage` fills them). A glyph on page `p` at row `v` has the atlas
+     * coordinate `v + p × height`
+     */
+    setGlyphPages(width: number, height: number, pages: number): void;
+    setGroundBounds(id: number, min_x: number, min_y: number, max_x: number, max_y: number): void;
+    /**
+     * Creates the texture of sampler `name` (`format`: r8, r8ui, r16ui, r16i, r32ui, r32f, rg16ui, rg32f, rgba8,
+     * rgba8ui, rgba16ui, rgba32f; `depth` 0 for 2D, else a 2D array of that many layers; `linear` filtering for the
+     * non-integer formats); `data`: its texels as bytes, or undefined for an empty texture
+     */
+    setGroundTexture(id: number, name: string, format: string, width: number, height: number, depth: number, linear: boolean, data?: Uint8Array | null): void;
+    /**
+     * A uniform of a ground layer's code, as numbers
+     */
+    setGroundUniform(id: number, name: string, values: Float64Array): void;
+    setGroundVisible(id: number, visible: boolean): void;
+    /**
+     * How tiles load and show: `true`, immediately (everything visible loads, no fade, the default); `false`,
+     * smoothly (levels skipped during flights, off-center tiles waiting while the camera moves, fade-in)
+     */
+    setImmediateLoading(immediate: boolean): void;
+    /**
+     * Dashes of a line layer, in line widths (`MapLibre`'s `line-dasharray`); 0, 0: solid
+     */
+    setLineDash(id: number, dash: number, gap: number): void;
+    /**
+     * New lines for a line layer (same arguments as `addLines`, the same features)
+     */
+    setLines(id: number, points: Float64Array, start: Uint32Array, feature: Uint32Array): void;
+    /**
+     * Highest pitch the camera accepts, degrees (up to 85)
+     */
+    setMaxPitch(max: number): void;
+    /**
+     * Costs of a network's edges (see `addNetwork`), when the way it is travelled changes; null: interpolated values
+     */
+    setNetworkCosts(id: number, costs?: Float32Array | null): void;
+    /**
+     * Colors of the values from 0 to the maximum, 256 RGBA texels (1024 bytes); undefined: green to red
+     */
+    setNetworkRamp(id: number, rgba?: Uint8Array | null): void;
+    /**
+     * Width factor of each edge (1 without): rail lines wider than streets
+     */
+    setNetworkScales(id: number, scales?: Float32Array | null): void;
+    /**
+     * Style of a network: width (CSS pixels) and halo width as zoom stops (8 numbers each: four zooms, four values),
+     * then the maximum, the contour interval, the opacity, the halo opacity, the color of the unreached parts (RGBA
+     * 0-1) and the share of the maximum over which the colors fade out: 25 numbers
+     */
+    setNetworkStyle(id: number, style: Float32Array): void;
+    /**
+     * One value per node; negative = unreached
+     */
+    setNetworkValues(id: number, values: Float32Array): void;
+    setRasterStyle(id: number, opacity: number, saturation: number): void;
+    /**
+     * Space behind the globe (stars, atmosphere halo), in the globe projection
+     */
+    setSky(enabled: boolean): void;
+    /**
+     * Layer-wide style of a symbol layer: size scale and opacity as zoom stops (four zooms then four values each),
+     * zoom range, visibility
+     */
+    setSymbolLayer(id: number, size: Float32Array, opacity: Float32Array, min_zoom: number, max_zoom: number, visible: boolean): void;
+    /**
+     * Labels of a symbol layer, shaped by the page: anchors (Mercator, interleaved), boxes (min x, min y, max x, max y,
+     * CSS pixels from the anchor), styles (20 floats each, see `LABEL_FLOATS`) and glyph quads (10 floats each: label, x, y, width, height from the anchor, atlas u0, v0, u1, v1 in
+     * texels, font scale)
+     */
+    setSymbols(id: number, anchors: Float64Array, boxes: Float32Array, styles: Float32Array, quads: Float32Array): void;
+    /**
+     * Relief under the raster layers, from raw altitudes (`image/x-bil;bits=32`, 256 × 256, or the same followed by
+     * the validity mask of an `ArcGIS` raw grid): `url` is a template with `{bbox}` (WMS `GetMap` in EPSG:3857, or in
+     * the Mercator metres of another body) or `{z}/{x}/{y}`; `undefined` turns it off. `exaggeration` scales the
+     * heights (1: true relief); `max_z`: finest level loaded (up to 15, from 6 on the Earth, coarser on bodies of a
+     * larger relief for their size: `terrain_levels`); `geoid`: altitudes raised by the RAF20 geoid height (heights
+     * above the ellipsoid, those of 3D Tiles; over France, on the Earth only), else left as served (the default);
+     * `loader`: gives the
+     * altitudes of each tile instead of fetching `url` (an encoding decoded by the page: Terrarium, Terrain-RGB)
+     */
+    setTerrain(url: string | null | undefined, exaggeration: number, max_z: number | null | undefined, geoid: boolean | null | undefined, loader: ((z: number, x: number, y: number, signal: AbortSignal) => Promise<Float32Array | null>) | undefined): void;
+    /**
+     * Pool of workers that fetch and decode 3D Tiles content off the main thread: an object with
+     * `load(id, url, transform, yUp, reload, priority) → Promise<{ anchor, primitives }>` and `abort(id)`. Without
+     * it, tiles are decoded on the main thread. Set it before adding 3D Tiles layers.
+     */
+    setTileLoader(loader: TileLoaderLike | null): void;
+    /**
+     * Screen-space error threshold and opacity of a 3D Tiles layer
+     */
+    setTiles3dStyle(id: number, max_error: number, opacity: number): void;
+    setZoomRange(min: number, max: number): void;
+    /**
+     * Tile counters of the raster layers, for diagnostics
+     */
+    stats(): RasterLayerStats[];
+    /**
+     * Compressed texture formats of the GPU (their WebGL extensions get enabled), for the KTX2 transcoding
+     */
+    textureFormats(): TextureFormats;
+    /**
+     * Counters of a 3D Tiles layer, undefined if there is none with this id
+     */
+    tiles3dStats(id: number): Tiles3dStats | undefined;
+    /**
+     * A region of the first page of the glyph atlas: `width` × `height` bytes at (`x`, `y`)
+     */
+    updateGlyphAtlas(x: number, y: number, width: number, height: number, data: Uint8Array): void;
+    /**
+     * A region of a page of the glyph atlas: `width` × `height` bytes at (`x`, `y`) of the page
+     */
+    updateGlyphPage(page: number, x: number, y: number, width: number, height: number, data: Uint8Array): void;
+    /**
+     * Replaces a region of a ground layer's texture (one layer of a 2D array)
+     */
+    updateGroundTexture(id: number, name: string, x: number, y: number, layer: number, width: number, height: number, data: Uint8Array): void;
+    zoomAt(delta: number, x: number, y: number): void;
+}
+
+/**
+ * Decodes a `.b3dm` / `.glb` tile: `{ anchor: Float64Array(3), primitives: [{ vertices: Float32Array (x, y, z, u,
+ * v per vertex, relative to the anchor), indices: Uint32Array, image?: Uint8Array, mime?: string }] }`.
+ * `transform`: the tile's world transform (16 numbers, column-major).
+ * `draco`: the decoded geometries of its Draco primitives (`dracoRequests`), if any.
+ */
+export function decodeTile(bytes: Uint8Array, transform: Float64Array, y_up: boolean, draco: DracoGeometry[] | undefined): EncodedTile;
+
+/**
+ * The Draco-compressed primitives of a tile, to decode before `decodeTile`
+ */
+export function dracoRequests(bytes: Uint8Array): DracoRequest[];
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_engine_free: (a: number, b: number) => void;
+    readonly decodeTile: (a: number, b: number, c: number, d: number, e: number, f: any) => [number, number, number];
+    readonly dracoRequests: (a: number, b: number) => [number, number, number];
+    readonly engine_addCircles: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly engine_addExtrusions: (a: number) => [number, number, number];
+    readonly engine_addFills: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number];
+    readonly engine_addGround: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+    readonly engine_addLines: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
+    readonly engine_addNetwork: (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) => [number, number, number];
+    readonly engine_addRaster: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+    readonly engine_addSymbols: (a: number) => [number, number, number];
+    readonly engine_addTiles3d: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly engine_bounds: (a: number) => [number, number];
+    readonly engine_camera: (a: number) => any;
+    readonly engine_clearPreload: (a: number) => void;
+    readonly engine_ground: (a: number, b: number, c: number) => any;
+    readonly engine_linkExtrusionNetwork: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_moveLayer: (a: number, b: number, c: number) => void;
+    readonly engine_networkStats: (a: number, b: number) => any;
+    readonly engine_new: (a: any, b: any) => [number, number, number];
+    readonly engine_pan: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly engine_pick: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+    readonly engine_pollPick: (a: number) => any;
+    readonly engine_preload: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_project: (a: number, b: number, c: number) => any;
+    readonly engine_removeExtrusionBatch: (a: number, b: number, c: number) => void;
+    readonly engine_removeLayer: (a: number, b: number) => void;
+    readonly engine_render: (a: number) => number;
+    readonly engine_requestPick: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly engine_resize: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_rotate: (a: number, b: number, c: number) => void;
+    readonly engine_setAtmosphere: (a: number, b: number, c: number) => void;
+    readonly engine_setBackground: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setBody: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_setCamera: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_setCircleAlignment: (a: number, b: number, c: number) => void;
+    readonly engine_setCircles: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_setExtrusionAnchors: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly engine_setExtrusionBatch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => [number, number];
+    readonly engine_setFeatureLayer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_setFeatureMask: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly engine_setFeatureRamp: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_setFeatureStyle: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly engine_setFeatureValues: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly engine_setFills: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+    readonly engine_setGlobe: (a: number, b: number) => void;
+    readonly engine_setGlobeColor: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setGlyphAtlas: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly engine_setGlyphPages: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly engine_setGroundBounds: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_setGroundTexture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => [number, number];
+    readonly engine_setGroundUniform: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly engine_setGroundVisible: (a: number, b: number, c: number) => void;
+    readonly engine_setImmediateLoading: (a: number, b: number) => void;
+    readonly engine_setLineDash: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setLines: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+    readonly engine_setMaxPitch: (a: number, b: number) => void;
+    readonly engine_setNetworkCosts: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setNetworkRamp: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setNetworkScales: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setNetworkStyle: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setNetworkValues: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setRasterStyle: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setSky: (a: number, b: number) => void;
+    readonly engine_setSymbolLayer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly engine_setSymbols: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly engine_setTerrain: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly engine_setTileLoader: (a: number, b: any) => void;
+    readonly engine_setTiles3dStyle: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setZoomRange: (a: number, b: number, c: number) => void;
+    readonly engine_stats: (a: number) => any;
+    readonly engine_textureFormats: (a: number) => any;
+    readonly engine_tiles3dStats: (a: number, b: number) => any;
+    readonly engine_updateGlyphAtlas: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_updateGlyphPage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly engine_updateGroundTexture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
+    readonly engine_zoomAt: (a: number, b: number, c: number, d: number) => void;
+    readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_: (a: number, b: number, c: any) => [number, number];
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;