@realsee/five 6.8.0-alpha.1 → 6.8.0-alpha.11

package/five/thirdparty/meshopt_decoder.d.ts

@@ -0,0 +1,15 @@
+// This file is part of meshoptimizer library and is distributed under the terms of MIT License.
+// Copyright (C) 2016-2023, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+export const meshoptDecoder: {
+	supported: boolean;
+	ready: Promise<void>;
+
+	decodeVertexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, filter?: string) => void;
+	decodeIndexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
+	decodeIndexSequence: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
+
+	decodeGltfBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string) => void;
+
+	useWorkers: (count: number) => void;
+	decodeGltfBufferAsync: (count: number, size: number, source: Uint8Array, mode: string, filter?: string) => Promise<Uint8Array>;
+};

package/five/three-version-check.d.ts

@@ -0,0 +1 @@
+export {};

package/five/types/addableObject.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+interface AddableObject extends THREE.Object3D {
+    /** 是否需要渲染一次 */
+    needsRender?: boolean;
+    /** 动画 */
+    mixer?: THREE.AnimationMixer;
+    /** 设置当前分辨率 */
+    setResolution?(width: number, height: number): void;
+    /** 设置当前时间 */
+    setTime?(time: number): void;
+}
+export { AddableObject };

package/five/types/cube.d.ts

@@ -0,0 +1 @@
+export type CubeFace = 'right' | 'left' | 'up' | 'down' | 'front' | 'back';

package/five/types/gestureInput.d.ts

@@ -0,0 +1,24 @@
+interface GestureInput {
+    type: string;
+    target: EventTarget | null;
+    pointerType: string;
+    srcEvent: MouseEvent | TouchEvent | PointerEvent;
+    pointers: {
+        x: number;
+        y: number;
+        delta?: number;
+    }[];
+    isFirst: boolean;
+    isFinal: boolean;
+    scale: number;
+    center: {
+        x: number;
+        y: number;
+        delta?: number;
+    };
+    velocityX: number;
+    velocityY: number;
+    overallVelocityX: number;
+    overallVelocityY: number;
+}
+export { GestureInput };

package/five/types/imageOptions.d.ts

@@ -0,0 +1,20 @@
+import type { ImageURLOptions } from "../utils/imageURL";
+/**
+ * 图片参数
+ */
+export interface ImageOptions extends Omit<ImageURLOptions, 'key'> {
+    /**
+     * url 地址转化
+     * @param url - 原始地址
+     * @param options - 当前地址参数
+     * @returns 转化后地址
+     */
+    transform?: (url: string, options: ImageURLOptions) => string;
+}
+/**
+ * 材质的图片参数
+ */
+export interface TextureOptions extends ImageOptions {
+    /** 针对 textureOptions 是否自动通过模型贴图的数量计算需要的模型贴图的尺寸 默认 true */
+    autoResize?: boolean;
+}

package/five/types/intersectMeshInterface.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from "three";
+/**
+ * 地面提示点位接口
+ */
+interface IntersectMeshInterface extends THREE.Object3D {
+    dispose(): void;
+}
+export { IntersectMeshInterface };

package/five/types/movePanoEffect.d.ts

@@ -0,0 +1,13 @@
+/**
+   * 动画模式
+   * @description
+   * - `fly` 通过相机移动方式变化
+   * - `instant` 直接变化
+   * - `fade` 通过渐变方式变化
+   * - `montage` 通过渐变穿插到黑屏方式变化
+   * - `spread` 通过扩散方式变化
+   * - `zoomin` 通过放大变化
+   * - `zoomout` 通过缩小变化
+   * - `model` 通过过度到模型
+   */
+export type MovePanoEffect = "fly" | "instant" | "fade" | "montage" | "spread" | "zoomin" | "zoomout" | "model";

package/five/types/movePanoOptions.d.ts

@@ -0,0 +1,35 @@
+import { State } from "./state";
+import { MovePanoEffect } from './movePanoEffect';
+/**
+ * 点位移动参数
+ */
+interface MovePanoOptions extends Partial<Omit<State, "offset" | 'distance' | 'mode'>> {
+    /**
+     * 动画模式
+     */
+    effect?: MovePanoEffect;
+    /** 走点图片过度策略 */
+    effectEasing?: (progress: number) => number;
+    /**
+     * 运动耗时
+     * @description
+     * - `数字或者字符串类型` 直接当作运动耗时
+     * - `函数类型` 传入 距离和速度（速度为five初始化设置） 返回运动耗时
+     * - `不传或者null` 通过距离和速度（速度为five初始化设置）
+     */
+    duration?: number | ((distance: number, speed: number) => number) | string | null;
+    /** 运动开始回调 */
+    moveStartCallback?: (toState: State) => void;
+    /** 运动结束回调 */
+    moveEndCallback?: (state: State) => void;
+    /**
+     * 运动被取消回调
+     * @description
+     * 这个有一些情况会导致
+     * - 移动过程中切换模态
+     * - 移动过程中 five 被析构
+     * - 移动过程点击切换到另一个点位
+     */
+    moveCancelCallback?: () => void;
+}
+export { MovePanoOptions };

package/five/types/panoCircleMeshInterface.d.ts

@@ -0,0 +1,34 @@
+import * as THREE from "three";
+/**
+ * 地面提示点位接口
+ *
+ * 点位状态
+ *  1. 默认状态: 无任何操作的情况
+ *  2. 高亮状态: 高亮，认为是合适的下一个点位，或者设备选中了某个点位
+ *  3. 进度状态: 点位加载中，存在进度的情况
+ *  4. 加载状态: 点位加载中，不存在进度的情况
+ *  5. 不可用状态：点位不可用，存在点位，但是点位是个摆设
+ *  6. 点击动画： 点位被选择，触发全景图切换
+ *  7. 透明度改变： 一般会处理为近的点位透明度高，远的点位透明度低
+ */
+interface PanoCircleMeshInterface extends THREE.Object3D {
+    needsRender: boolean;
+    hitTestMesh?: THREE.Mesh;
+    /** 当前高亮 */
+    current: boolean;
+    /** 是否当前高亮 */
+    setCurrent(current: boolean): void;
+    loading: boolean;
+    setLoading(loading: boolean): void;
+    disabled: boolean;
+    setDisabled(disabled: boolean): void;
+    progress: number;
+    setProgress(progress: number): void;
+    opacity: number;
+    setOpacity(opacity: number): void;
+    updateTime?(time: number, deltaTime: number): void;
+    /** 点击交互 */
+    tap?(): Promise<void>;
+    dispose(): void;
+}
+export { PanoCircleMeshInterface };

package/five/types/plugin.d.ts

@@ -0,0 +1,25 @@
+import type { Five } from "../application/five";
+/**
+ * Five 插件
+ * @template Parameters - 插件参数, 没有参数则为 void
+ * @template Returns - 如果有参数则插件暴露的 api，没有参数则不传
+ */
+type FivePlugin<Parameters = void, Returns = void> = Parameters extends void ? ((five: Five) => Returns) : ((five: Five, parameters: Parameters) => Returns);
+/**
+ * 获取插件暴露的 api
+ * @template T - Five 插件
+ */
+type FivePluginInstance<T extends FivePlugin<any, any>> = ReturnType<T>;
+/**
+ * 获取插件在Five中的初始化结构
+ * @template T - Five 插件
+ */
+type FivePluginInit<T extends FivePlugin<any, any>> = Parameters<T>[1] extends undefined ? [
+    Plugin: T,
+    instanceName: null | string
+] : [
+    Plugin: T,
+    instanceName: null | string,
+    parameters: Parameters<T>[1]
+];
+export { FivePlugin, FivePluginInstance, FivePluginInit, };

package/five/types/pose.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from "three";
+/**
+ * 相机位姿
+ */
+interface Pose {
+    /** 相机偏航角 */
+    longitude: number;
+    /** 相机俯仰角 */
+    latitude: number;
+    /** 相机可视角度（垂直）*/
+    fov: number;
+    /** 相机位置*/
+    offset: THREE.Vector3;
+    /** 相机距离 */
+    distance: number;
+}
+export { Pose };

package/five/types/state.d.ts

@@ -0,0 +1,20 @@
+import { Mode } from "../application/mode";
+import { Pose } from "./pose";
+/**
+ * 状态
+ * @description
+ * ```text
+ * 可以通过 five.state 和 five.setState 来获取和设置。
+ * 通过 state 设置后，five 会通过合适的动画运动来达到设置的位置。
+ * 来迎合一些通过数据驱动的场景。
+ * ```
+ */
+interface State extends Pose {
+    /** 模态 */
+    mode: Mode;
+    /** workCode */
+    workCode: string;
+    /** 观察点序号 */
+    panoIndex: number;
+}
+export { State };

package/five/types/viewport.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 显示区域裁剪参数
+ * @description
+ * 可通过初始化，或者 setScissor 方式设置
+ * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
+ * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
+ */
+export interface Viewport {
+    /** 距离左侧 */
+    left: number;
+    /** 距离下侧 */
+    bottom: number;
+    /** 宽度 */
+    width: number;
+    /** 高度 */
+    height: number;
+}
+/**
+ * @deprecated
+ * use Viewport instead
+ */
+export type Scissor = Viewport;

package/five/utils/ajax.d.ts

@@ -0,0 +1,66 @@
+import { Subscribe } from "./subscribe";
+type NetWorkMeta = {
+    origin: string;
+    source: string;
+    headers: {
+        [name: string]: string;
+    };
+    requestTime: number;
+    responseTime: number;
+    costs: number;
+    size?: number;
+};
+type NetworkResponse<T = any, E extends NetWorkMeta | NetWorkMeta[] = NetWorkMeta> = {
+    body: T;
+    meta: E;
+};
+type NetworkType = "XMLHttpRequest" | "Image" | "Link";
+type NetworkState = "ok" | "preload" | "error" | "timeout" | "forbidden";
+declare class NetworkProxyError extends Error {
+    constructor(source: string, type: NetworkType, reason: string);
+}
+declare class NetworkResponseError extends Error {
+    httpStatus: number;
+    constructor(source: string, type: NetworkType, status: number);
+}
+declare class NetworkAbortError extends Error {
+    constructor(source: string, type: NetworkType);
+}
+declare class NetworkTimeoutError extends Error {
+    constructor(source: string, type: NetworkType, timeout: number);
+}
+declare class NetworkFirbiddenError extends Error {
+    constructor(source: string, type: NetworkType, reason: string);
+}
+type NetworkError = NetworkResponseError | NetworkAbortError | NetworkTimeoutError | NetworkFirbiddenError;
+type NetworkCallback = (error: NetworkError | null, response: NetworkResponse | null) => void;
+type NetworkSuccessCallback<T = any> = (response: NetworkResponse<T>) => void;
+type NetworkErrorCallback = (error: NetworkError) => void;
+type NetworkProgressCallback = (percent: number, loaded?: number, total?: number) => void;
+declare class NetworkSubscribe extends Subscribe<{
+    network(source: string, type: NetworkType, state: NetworkState, detail: string): void;
+}> {
+}
+interface NetworkOptions {
+    /** 超时时间 */
+    timeout?: number;
+    /** 请求代理 */
+    requestProxy?: (url: string) => string | Promise<string>;
+    /** 网络消息追踪 */
+    networkSubscribe?: NetworkSubscribe;
+}
+type AjaxResponseType = "arraybuffer" | "blob" | "text";
+type AjaxResponseTypeMapping<K extends AjaxResponseType> = K extends "arraybuffer" ? ArrayBuffer : K extends "blob" ? Blob : K extends "text" ? string : never;
+interface AjaxOptions<T extends AjaxResponseType = AjaxResponseType> extends NetworkOptions {
+    /** 数据返回类型 */
+    responseType?: T;
+}
+declare class Fetcher {
+    private options;
+    constructor(options?: NetworkOptions);
+    ajax<T extends AjaxResponseType = "text">(source: string, options?: AjaxOptions<T>, onLoad?: NetworkSuccessCallback<AjaxResponseTypeMapping<T>>, onError?: NetworkErrorCallback, onProgress?: NetworkProgressCallback): Promise<NetworkResponse<AjaxResponseTypeMapping<T>>>;
+    loadImage<T extends HTMLImageElement = HTMLImageElement>(source: string, options?: NetworkOptions, onLoad?: NetworkSuccessCallback, onError?: NetworkErrorCallback, onProgress?: NetworkProgressCallback, target?: T): Promise<NetworkResponse<T>>;
+    preload(source: string, options?: NetworkOptions): Promise<void>;
+}
+declare const internalFetcher: Fetcher;
+export { internalFetcher, Fetcher, AjaxResponseType, AjaxResponseTypeMapping, NetworkSubscribe, NetworkState, NetworkType, NetworkOptions, AjaxOptions, NetworkResponseError, NetworkTimeoutError, NetworkAbortError, NetworkFirbiddenError, NetworkError, NetworkProxyError, NetworkCallback, NetworkSuccessCallback, NetworkErrorCallback, NetworkProgressCallback, NetworkResponse, NetWorkMeta, };

package/five/utils/animationFrameLoop.d.ts

@@ -0,0 +1,45 @@
+export type RequestAnimationFrameArgs<Args extends any[] = any[]> = [domHighResTimeStamp: number, ...args: Args];
+export interface AnimationFrameContext<Args extends any[] = any[], RequestId = any> {
+    requestAnimationFrame(fn: (...args: RequestAnimationFrameArgs<Args>) => void): RequestId;
+    cancelAnimationFrame(requestId: RequestId): void;
+}
+export type AnimationFrameLoopType = 'raf' | 'sto';
+interface AnimationFrame {
+    callback: (time: number, deltaTime: number, ...requestAnimationFrameArgs: RequestAnimationFrameArgs) => void;
+    once: boolean;
+    delay: number;
+    order: number;
+    calls: number;
+}
+declare class AnimationFrameLoop {
+    private frames;
+    private loopType;
+    private isAnimating;
+    private context;
+    private requestId;
+    private loop;
+    private static sharedInstance?;
+    static get shared(): AnimationFrameLoop;
+    static getFrameTime(): number;
+    constructor();
+    start(): void;
+    stop(): void;
+    setContext(context: AnimationFrameContext | null): void;
+    getContext<T extends AnimationFrameContext = AnimationFrameContext>(): T | null;
+    setLoopType(type: AnimationFrameLoopType): void;
+    getLoopType(): AnimationFrameLoopType;
+    private requestAnimationFrame;
+    private cancelAnimationFrame;
+    private remove;
+    /**
+     * 添加到动画循环
+     * @param callback - 动画循环回调
+     * @param once - 是否只回调一次
+     * @param delay - 延迟多少个动画循环回调
+     * @param order - 优先级，数字越小越早被调用
+     * @returns 移除动画循环函数
+     */
+    add(callback: AnimationFrame["callback"], once?: boolean, delay?: number, order?: number): () => void;
+    clear(): void;
+}
+export { AnimationFrameLoop, AnimationFrame };

package/five/utils/array.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 获取数组中的计算后的最大值
+ * @param array - 原数组
+ * @param iterator - 计算方法
+ * @param needResult - 是否需要计算结果
+ * @returns 如果需要计算结果 直接返回最大值的 item, 不然 返回 [item, 以及这个item 调用 iterator 的结果]
+ */
+export declare function arrayMax<T, N extends false>(array: readonly T[], iterator: (item: T) => number, needResult: N): T | undefined;
+export declare function arrayMax<T, Y extends true>(array: readonly T[], iterator: (item: T) => number, needResult: Y): [T | undefined, number];
+/**
+ * 获取数组中的计算后的最小值
+ * @param array - 原数组
+ * @param iterator - 计算方法
+ * @param needResult - 是否需要计算结果
+ * @returns 如果需要计算结果 直接返回最小值的 item, 不然 返回 [item, 以及这个item 调用 iterator 的结果]
+ */
+export declare function arrayMin<T>(array: readonly T[], iterator: (item: T) => number): T | undefined;
+export declare function arrayMin<T, N extends false>(array: readonly T[], iterator: (item: T) => number, needResult: N): T | undefined;
+export declare function arrayMin<T, Y extends true>(array: readonly T[], iterator: (item: T) => number, needResult: Y): [T | undefined, number];
+/**
+ * 判定两个数字内容相同
+ * @param array0 - 数组
+ * @param array1 - 数组
+ * @param equalFn - 比较函数，默认 ===
+ * @returns
+ */
+export declare function arrayEqual(array0: readonly any[], array1: readonly any[], equalFn?: (value0: any, value1: any) => boolean): boolean;
+/**
+ * 数组去重
+ */
+export declare function arrayUnique<T>(array: T[]): T[];

package/five/utils/asyncTaskQueue.d.ts

@@ -0,0 +1,8 @@
+export declare class AsyncTaskQueue {
+    concurrency: number;
+    private queue;
+    private dequeuing;
+    constructor(concurrency: number);
+    add<T>(task: (() => Promise<T>) | (() => T), timeout?: number): Promise<T>;
+    dequeue(): void;
+}

package/five/utils/bufferGeometry.d.ts

@@ -0,0 +1,33 @@
+import * as THREE from "three";
+export declare function createSimpleBoxBufferGeometry(width?: number, height?: number, depth?: number): THREE.BufferGeometry;
+/**
+ * 计算 Tangents
+ * @param geometry
+ * @returns
+ */
+export declare function computeTangents(geometry: THREE.BufferGeometry): void;
+/**
+ * 合并 Geometries
+ * @param geometries
+ * @param useGroups
+ * @return
+ */
+export declare function mergeBufferGeometries(geometries: THREE.BufferGeometry[], useGroups: any): null | THREE.BufferGeometry;
+/**
+ * 合并 GeometryAttributes
+ * @param attributes
+ * @return
+ */
+export declare function mergeBufferAttributes(attributes: THREE.BufferAttribute[]): null | THREE.BufferAttribute;
+/** Attributes to InterleavedAttribute
+ * @param attributes
+ * @return
+ */
+export declare function interleaveAttributes(attributes: THREE.BufferAttribute[]): null | THREE.InterleavedBufferAttribute[];
+/**
+ * 定点合并
+ * @param geometry
+ * @param tolerance
+ * @return
+ */
+export declare function mergeVertices(geometry: THREE.BufferGeometry, tolerance?: number): THREE.BufferGeometry;

package/five/utils/calculateProgress.d.ts

@@ -0,0 +1,39 @@
+import * as THREE from "three";
+/**
+ * 线性过程值
+ * @param from - 初始值
+ * @param to - 结束值
+ * @param pst - 完成度(0-1)
+ * @returns 计算值
+ */
+declare function progressNumber(from: number, to: number, pst: number): number;
+/**
+ * 弧度过程值
+ * @param from - 初始值
+ * @param to - 结束值
+ * @param pst - 完成度(0-1)
+ * @returns 计算值
+ */
+declare function progressRad(from: number, to: number, pst: number): number;
+/**
+ * 线性一步过程
+ * @param from - 初始值
+ * @param to - 结束值
+ * @param step - 步径
+ * @returns 计算值
+ */
+declare function stepNumber(from: number, to: number, step: number): number;
+declare function stepVector(from: THREE.Vector3, to: THREE.Vector3, step: number): THREE.Vector3;
+type coordinates = {
+    longitude: number;
+    latitude: number;
+};
+/**
+ * 坐标一步过程
+ * @param from - 初始值
+ * @param to - 结束值
+ * @param step - 步径
+ * @returns 计算值
+ */
+declare function stepCoordinates(from: coordinates, to: coordinates, step: number): coordinates;
+export { progressNumber, progressRad, stepNumber, stepVector, stepCoordinates, };

package/five/utils/calculateThreeMouse.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import { Viewport } from "../types/viewport";
+/**
+ * 计算 three 中的 mouse 的值
+ * @param  mouseXY - 鼠标相对屏幕位置
+ * @param  element - canvas元素（three的展示元素）
+ * @param  viewport - 屏幕剪裁
+ */
+declare function calculateThreeMouse(mouseXY: {
+    x: number;
+    y: number;
+}, element: HTMLElement, viewport?: Viewport): THREE.Vector2;
+export { calculateThreeMouse };

package/five/utils/canplayVideo.d.ts

@@ -0,0 +1,2 @@
+declare function canplayVideo(): Promise<boolean>;
+export { canplayVideo };

package/five/utils/clamp.d.ts

@@ -0,0 +1,2 @@
+declare function clamp(value: number, min: number, max?: number): number;
+export { clamp };

package/five/utils/clock.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+declare class Clock implements THREE.Clock {
+    readonly autoUpdate: boolean;
+    autoStart: boolean;
+    running: boolean;
+    currentTime: number;
+    startTime: number;
+    oldTime: number;
+    elapsedTime: number;
+    constructor(autoStart?: boolean, autoUpdate?: false);
+    update(time: number): void;
+    start(): void;
+    stop(): void;
+    getElapsedTime(): number;
+    getDelta(): number;
+}
+export { Clock };

package/five/utils/createSymbol.d.ts

@@ -0,0 +1,5 @@
+type UniqueSymbol = ReturnType<(a: string) => {
+    readonly 0: unique symbol;
+}[0]>;
+declare function createSymbol(description: string): UniqueSymbol;
+export { createSymbol, UniqueSymbol };

package/five/utils/decodeText.d.ts

@@ -0,0 +1,2 @@
+declare function decodeText(array: Uint8Array): string;
+export { decodeText };

package/five/utils/deepEqual.d.ts

@@ -0,0 +1,2 @@
+declare function equal(a: any, b: any): boolean;
+export { equal as deepEqual };

package/five/utils/deepFreeze.d.ts

@@ -0,0 +1,2 @@
+declare function deepFreeze<T extends Record<string, any>>(object: T): T;
+export { deepFreeze };

package/five/utils/defineProperty.d.ts

@@ -0,0 +1,9 @@
+export interface PropertyDescriptor<T, V> {
+    configurable?: boolean;
+    enumerable?: boolean;
+    value?: V;
+    writable?: boolean;
+    get?(this: T): V;
+    set?(this: T, value: V): void;
+}
+export declare function defineProperty<T extends Object, K extends keyof T>(obj: T, property: K, propertyDescriptor: PropertyDescriptor<T, T[K]>): T;

package/five/utils/detector.d.ts

@@ -0,0 +1,14 @@
+declare const userAgent: string;
+/**
+ * 是否可以使用 webgl
+ */
+declare const canWebGL: boolean;
+/**
+ * 是否可以 pushState
+ */
+declare const canPushState: boolean;
+/**
+ * 是否是通过手机访问
+ */
+declare const isMobile: boolean;
+export { userAgent, canWebGL, canPushState, isMobile, };

package/five/utils/distance.d.ts

@@ -0,0 +1,10 @@
+declare function distance<T extends {
+    x: number;
+    y: number;
+}>(p0: T, p1: T): number;
+declare function distance<T extends {
+    x: number;
+    y: number;
+    z: number;
+}>(p0: T, p1: T): number;
+export { distance };

package/five/utils/draco.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+export declare class Draco {
+    decoderPath: string;
+    private decoderPending;
+    private decoderConfig;
+    private workerLimit;
+    private workerNextTaskID;
+    private workerSourceURL;
+    private workerPool;
+    constructor();
+    setDecoderPath(decoderPath: string): void;
+    setDecoderConfig(config: any): this;
+    setWorkerLimit(workerLimit: number): this;
+    decodeDracoFile(buffer: ArrayBuffer, callback: (geometry: THREE.BufferGeometry) => void, attributeIDs: Record<string, string>, attributeTypes: Record<string, any>): void;
+    decodeGeometry(buffer: ArrayBuffer, taskConfig?: {
+        attributeIDs: Record<string, string>;
+        attributeTypes: Record<string, any>;
+        useUniqueIDs: boolean;
+    }): Promise<THREE.BufferGeometry>;
+    _createGeometry(geometryData: any): THREE.BufferGeometry;
+    _initDecoder(): Promise<void>;
+    _getWorker(taskID: number, taskCost: number): Promise<Worker>;
+    _releaseTask(worker: Worker, taskID: number): void;
+    dispose(): this;
+}
+export declare const draco: Draco;