@xeokit/xeokit-sdk 2.0.16 → 2.0.17

package/dist/xeokit-sdk.es.js

@@ -6790,7 +6790,7 @@ function isSameComponent(c1, c2) {
  @returns {boolean}
  @private
  */
-function isFunction(value) {
+function isFunction$1(value) {
     return (typeof value === "function");
 }
 
@@ -6800,7 +6800,7 @@ function isFunction(value) {
  @returns {boolean}
  @private
  */
-function isObject(value) {
+function isObject$1(value) {
     const objectConstructor = {}.constructor;
     return (!!value && value.constructor === objectConstructor);
 }
@@ -6935,8 +6935,8 @@ const utils = {
     isNumeric: isNumeric,
     isID: isID,
     isSameComponent: isSameComponent,
-    isFunction: isFunction,
-    isObject: isObject,
+    isFunction: isFunction$1,
+    isObject: isObject$1,
     copy: copy,
     apply: apply,
     apply2: apply2,
@@ -39406,6 +39406,8 @@ class DistanceMeasurementsPlugin extends Plugin {
  * {@link Viewer} plugin that improves interactivity by temporarily switching to fast and simple rendering while the
  * {@link Camera} is moving or the {@link Canvas} is resizing.
  *
+ * [<img src="https://xeokit.io/img/docs/FastNavPlugin/FastNavPlugin.gif">](https://xeokit.github.io/xeokit-sdk/examples/#performance_FastNavPlugin)
+ *
  * FastNavPlugin works by disabling specified rendering features, and optionally down-scaling the canvas, whenever we
  * move the Camera or resize the Canvas. Then, once the Camera or Canvas has been at rest after a certain time, FastNavPlugin
  * restores those rendering features and original canvas scale again.
@@ -39428,7 +39430,7 @@ class DistanceMeasurementsPlugin extends Plugin {
  * * disable physically-based materials (switching to non-PBR),
  * * hide transparent objects, and
  * * down-scale the canvas by 0.5, causing 75% less pixels to render.
- *
+ * <br><br>
  * We'll also configure a 0.5 second delay before we transition back to high-quality each time we stop moving, so that we're
  * not continually flipping between low and high quality as we interact.
  *
@@ -64977,7 +64979,21 @@ class PerformanceModel extends Component {
 
             let needNewBatchingLayers = false;
 
-            const origin = (cfg.origin || cfg.rtcCenter) ? math.addVec3(this._origin, cfg.origin || cfg.rtcCenter, tempVec3a$8) : null;
+            const cellSize = 100000;
+
+            let origin = null;
+
+            if (cfg.origin || cfg.rtcCenter) {
+                origin = math.addVec3(this._origin, cfg.origin || cfg.rtcCenter, tempVec3a$8);
+            } else if (!cfg.positionsDecodeMatrix) { // TODO: Assumes we never quantize double-precision coordinates
+                const rtcCenter = math.vec3();
+                const rtcPositions = [];
+                const rtcNeeded = worldToRTCPositions(positions, rtcPositions, rtcCenter, cellSize);
+                if (rtcNeeded) {
+                    positions = rtcPositions;
+                    origin = math.addVec3(this._origin, rtcCenter, rtcCenter);
+                }
+            }
 
             if (origin) {
                 if (!this._lastOrigin) {
@@ -75960,7 +75976,7 @@ class STLSceneGraphLoader {
         spinner.processes++;
 
         plugin.dataSource.getSTL(src, function (data) { // OK
-                parse(plugin, modelNode, data, options);
+                parse$1(plugin, modelNode, data, options);
                 try {
                     const binData = ensureBinary(data);
                     if (isBinary(binData)) {
@@ -76015,7 +76031,7 @@ class STLSceneGraphLoader {
     }
 }
 
-function parse(plugin, modelNode, data, options) {
+function parse$1(plugin, modelNode, data, options) {
     try {
         const binData = ensureBinary(data);
         if (isBinary(binData)) {
@@ -130843,7 +130859,7 @@ class LocaleService {
         if (!localeMessages) {
             return null;
         }
-        const localeMessage = resolvePath(msg, localeMessages);
+        const localeMessage = resolvePath$1(msg, localeMessages);
         if (localeMessage) {
             if (args) {
                 return vsprintf(localeMessage, args);
@@ -130868,7 +130884,7 @@ class LocaleService {
         if (!localeMessages) {
             return null;
         }
-        let localeMessage = resolvePath(msg, localeMessages);
+        let localeMessage = resolvePath$1(msg, localeMessages);
         count = parseInt("" + count, 10);
         if (count === 0) {
             localeMessage = localeMessage.zero;
@@ -130977,7 +130993,7 @@ class LocaleService {
     }
 }
 
-function resolvePath(key, json) {
+function resolvePath$1(key, json) {
     if (json[key]) {
         return json[key];
     }
@@ -143080,4 +143096,2831 @@ class IFCLoaderPlugin extends Plugin {
     }
 }
 
-export { AmbientLight, AngleMeasurementsPlugin, AnnotationsPlugin, AxisGizmoPlugin, BCFViewpointsPlugin, CameraMemento, CameraPath, CameraPathAnimation, Component, Configs, ContextMenu, CubicBezierCurve, Curve, DirLight, DistanceMeasurementsPlugin, EdgeMaterial, EmphasisMaterial, FastNavPlugin, Fresnel, GLTFDefaultDataSource, GLTFLoaderPlugin, IFCLoaderPlugin, ImagePlane, LambertMaterial, LightMap, LocaleService, Map$1 as Map, Marker, Mesh, MetallicMaterial, ModelMemento, NavCubePlugin, Node, OBJLoaderPlugin, ObjectsMemento, Path, PerformanceModel, PhongMaterial, Plugin, PointLight, QuadraticBezierCurve, Queue, ReadableGeometry, ReflectionMap, STLDefaultDataSource, STLLoaderPlugin, SectionPlane, SectionPlanesPlugin, Skybox, SkyboxesPlugin, SpecularMaterial, SplineCurve, SpriteMarker, StoreyViewsPlugin, Texture, TreeViewPlugin, VBOGeometry, ViewCullPlugin, Viewer, XKTDefaultDataSource, XKTLoaderPlugin, XML3DLoaderPlugin, buildBoxGeometry, buildBoxLinesGeometry, buildCylinderGeometry, buildGridGeometry, buildPlaneGeometry, buildSphereGeometry, buildTorusGeometry, buildVectorTextGeometry, load3DSGeometry, loadOBJGeometry, math, utils };
+/**
+ * Default data access strategy for {@link LASLoaderPlugin}.
+ */
+class LASDefaultDataSource {
+
+    constructor() {
+    }
+
+    /**
+     * Gets the contents of the given LAS file in an arraybuffer.
+     *
+     * @param {String|Number} src Path or ID of an LAS file.
+     * @param {Function} ok Callback fired on success, argument is the LAS file in an arraybuffer.
+     * @param {Function} error Callback fired on error.
+     */
+    getLAS(src, ok, error) {
+        var defaultCallback = () => {
+        };
+        ok = ok || defaultCallback;
+        error = error || defaultCallback;
+        const dataUriRegex = /^data:(.*?)(;base64)?,(.*)$/;
+        const dataUriRegexResult = src.match(dataUriRegex);
+        if (dataUriRegexResult) { // Safari can't handle data URIs through XMLHttpRequest
+            const isBase64 = !!dataUriRegexResult[2];
+            var data = dataUriRegexResult[3];
+            data = window.decodeURIComponent(data);
+            if (isBase64) {
+                data = window.atob(data);
+            }
+            try {
+                const buffer = new ArrayBuffer(data.length);
+                const view = new Uint8Array(buffer);
+                for (var i = 0; i < data.length; i++) {
+                    view[i] = data.charCodeAt(i);
+                }
+                ok(buffer);
+            } catch (errMsg) {
+                error(errMsg);
+            }
+        } else {
+            const request = new XMLHttpRequest();
+            request.open('GET', src, true);
+            request.responseType = 'arraybuffer';
+            request.onreadystatechange = function () {
+                if (request.readyState === 4) {
+                    if (request.status === 200) {
+                        ok(request.response);
+                    } else {
+                        error('getXKT error : ' + request.response);
+                    }
+                }
+            };
+            request.send(null);
+        }
+    }
+}
+
+function assert$2(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'loader assertion failed.');
+  }
+}
+
+const globals$1 = {
+  self: typeof self !== 'undefined' && self,
+  window: typeof window !== 'undefined' && window,
+  global: typeof global !== 'undefined' && global,
+  document: typeof document !== 'undefined' && document
+};
+const global_ = globals$1.global || globals$1.self || globals$1.window || {};
+const isBrowser$2 = typeof process !== 'object' || String(process) !== '[object process]' || process.browser;
+const matches$1 = typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
+matches$1 && parseFloat(matches$1[1]) || 0;
+
+const VERSION$2 = "3.0.13" ;
+
+function assert$1(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'loaders.gl assertion failed.');
+  }
+}
+
+typeof process !== 'object' || String(process) !== '[object process]' || process.browser;
+const isMobile = typeof window !== 'undefined' && typeof window.orientation !== 'undefined';
+const matches = typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
+matches && parseFloat(matches[1]) || 0;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+class WorkerJob {
+  constructor(jobName, workerThread) {
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "workerThread", void 0);
+
+    _defineProperty(this, "isRunning", void 0);
+
+    _defineProperty(this, "result", void 0);
+
+    _defineProperty(this, "_resolve", void 0);
+
+    _defineProperty(this, "_reject", void 0);
+
+    this.name = jobName;
+    this.workerThread = workerThread;
+    this.isRunning = true;
+
+    this._resolve = () => {};
+
+    this._reject = () => {};
+
+    this.result = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+
+  postMessage(type, payload) {
+    this.workerThread.postMessage({
+      source: 'loaders.gl',
+      type,
+      payload
+    });
+  }
+
+  done(value) {
+    assert$1(this.isRunning);
+    this.isRunning = false;
+
+    this._resolve(value);
+  }
+
+  error(error) {
+    assert$1(this.isRunning);
+    this.isRunning = false;
+
+    this._reject(error);
+  }
+
+}
+
+const workerURLCache = new Map();
+function getLoadableWorkerURL(props) {
+  assert$1(props.source && !props.url || !props.source && props.url);
+  let workerURL = workerURLCache.get(props.source || props.url);
+
+  if (!workerURL) {
+    if (props.url) {
+      workerURL = getLoadableWorkerURLFromURL(props.url);
+      workerURLCache.set(props.url, workerURL);
+    }
+
+    if (props.source) {
+      workerURL = getLoadableWorkerURLFromSource(props.source);
+      workerURLCache.set(props.source, workerURL);
+    }
+  }
+
+  assert$1(workerURL);
+  return workerURL;
+}
+
+function getLoadableWorkerURLFromURL(url) {
+  if (!url.startsWith('http')) {
+    return url;
+  }
+
+  const workerSource = buildScriptSource(url);
+  return getLoadableWorkerURLFromSource(workerSource);
+}
+
+function getLoadableWorkerURLFromSource(workerSource) {
+  const blob = new Blob([workerSource], {
+    type: 'application/javascript'
+  });
+  return URL.createObjectURL(blob);
+}
+
+function buildScriptSource(workerUrl) {
+  return "try {\n  importScripts('".concat(workerUrl, "');\n} catch (error) {\n  console.error(error);\n  throw error;\n}");
+}
+
+function getTransferList(object, recursive = true, transfers) {
+  const transfersSet = transfers || new Set();
+
+  if (!object) ; else if (isTransferable(object)) {
+    transfersSet.add(object);
+  } else if (isTransferable(object.buffer)) {
+    transfersSet.add(object.buffer);
+  } else if (ArrayBuffer.isView(object)) ; else if (recursive && typeof object === 'object') {
+    for (const key in object) {
+      getTransferList(object[key], recursive, transfersSet);
+    }
+  }
+
+  return transfers === undefined ? Array.from(transfersSet) : [];
+}
+
+function isTransferable(object) {
+  if (!object) {
+    return false;
+  }
+
+  if (object instanceof ArrayBuffer) {
+    return true;
+  }
+
+  if (typeof MessagePort !== 'undefined' && object instanceof MessagePort) {
+    return true;
+  }
+
+  if (typeof ImageBitmap !== 'undefined' && object instanceof ImageBitmap) {
+    return true;
+  }
+
+  if (typeof OffscreenCanvas !== 'undefined' && object instanceof OffscreenCanvas) {
+    return true;
+  }
+
+  return false;
+}
+
+const NOOP = () => {};
+
+class WorkerThread {
+  static isSupported() {
+    return typeof Worker !== 'undefined';
+  }
+
+  constructor(props) {
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "source", void 0);
+
+    _defineProperty(this, "url", void 0);
+
+    _defineProperty(this, "terminated", false);
+
+    _defineProperty(this, "worker", void 0);
+
+    _defineProperty(this, "onMessage", void 0);
+
+    _defineProperty(this, "onError", void 0);
+
+    _defineProperty(this, "_loadableURL", '');
+
+    const {
+      name,
+      source,
+      url
+    } = props;
+    assert$1(source || url);
+    this.name = name;
+    this.source = source;
+    this.url = url;
+    this.onMessage = NOOP;
+
+    this.onError = error => console.log(error);
+
+    this.worker = this._createBrowserWorker();
+  }
+
+  destroy() {
+    this.onMessage = NOOP;
+    this.onError = NOOP;
+    this.worker.terminate();
+    this.terminated = true;
+  }
+
+  get isRunning() {
+    return Boolean(this.onMessage);
+  }
+
+  postMessage(data, transferList) {
+    transferList = transferList || getTransferList(data);
+    this.worker.postMessage(data, transferList);
+  }
+
+  _getErrorFromErrorEvent(event) {
+    let message = 'Failed to load ';
+    message += "worker ".concat(this.name, ". ");
+
+    if (event.message) {
+      message += "".concat(event.message, " in ");
+    }
+
+    if (event.lineno) {
+      message += ":".concat(event.lineno, ":").concat(event.colno);
+    }
+
+    return new Error(message);
+  }
+
+  _createBrowserWorker() {
+    this._loadableURL = getLoadableWorkerURL({
+      source: this.source,
+      url: this.url
+    });
+    const worker = new Worker(this._loadableURL, {
+      name: this.name
+    });
+
+    worker.onmessage = event => {
+      if (!event.data) {
+        this.onError(new Error('No data received'));
+      } else {
+        this.onMessage(event.data);
+      }
+    };
+
+    worker.onerror = error => {
+      this.onError(this._getErrorFromErrorEvent(error));
+      this.terminated = true;
+    };
+
+    worker.onmessageerror = event => console.error(event);
+
+    return worker;
+  }
+
+}
+
+class WorkerPool {
+  constructor(props) {
+    _defineProperty(this, "name", 'unnamed');
+
+    _defineProperty(this, "source", void 0);
+
+    _defineProperty(this, "url", void 0);
+
+    _defineProperty(this, "maxConcurrency", 1);
+
+    _defineProperty(this, "maxMobileConcurrency", 1);
+
+    _defineProperty(this, "onDebug", () => {});
+
+    _defineProperty(this, "reuseWorkers", true);
+
+    _defineProperty(this, "props", {});
+
+    _defineProperty(this, "jobQueue", []);
+
+    _defineProperty(this, "idleQueue", []);
+
+    _defineProperty(this, "count", 0);
+
+    _defineProperty(this, "isDestroyed", false);
+
+    this.source = props.source;
+    this.url = props.url;
+    this.setProps(props);
+  }
+
+  destroy() {
+    this.idleQueue.forEach(worker => worker.destroy());
+    this.isDestroyed = true;
+  }
+
+  setProps(props) {
+    this.props = { ...this.props,
+      ...props
+    };
+
+    if (props.name !== undefined) {
+      this.name = props.name;
+    }
+
+    if (props.maxConcurrency !== undefined) {
+      this.maxConcurrency = props.maxConcurrency;
+    }
+
+    if (props.maxMobileConcurrency !== undefined) {
+      this.maxMobileConcurrency = props.maxMobileConcurrency;
+    }
+
+    if (props.reuseWorkers !== undefined) {
+      this.reuseWorkers = props.reuseWorkers;
+    }
+
+    if (props.onDebug !== undefined) {
+      this.onDebug = props.onDebug;
+    }
+  }
+
+  async startJob(name, onMessage = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+    const startPromise = new Promise(onStart => {
+      this.jobQueue.push({
+        name,
+        onMessage,
+        onError,
+        onStart
+      });
+      return this;
+    });
+
+    this._startQueuedJob();
+
+    return await startPromise;
+  }
+
+  async _startQueuedJob() {
+    if (!this.jobQueue.length) {
+      return;
+    }
+
+    const workerThread = this._getAvailableWorker();
+
+    if (!workerThread) {
+      return;
+    }
+
+    const queuedJob = this.jobQueue.shift();
+
+    if (queuedJob) {
+      this.onDebug({
+        message: 'Starting job',
+        name: queuedJob.name,
+        workerThread,
+        backlog: this.jobQueue.length
+      });
+      const job = new WorkerJob(queuedJob.name, workerThread);
+
+      workerThread.onMessage = data => queuedJob.onMessage(job, data.type, data.payload);
+
+      workerThread.onError = error => queuedJob.onError(job, error);
+
+      queuedJob.onStart(job);
+
+      try {
+        await job.result;
+      } finally {
+        this.returnWorkerToQueue(workerThread);
+      }
+    }
+  }
+
+  returnWorkerToQueue(worker) {
+    const shouldDestroyWorker = this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
+
+    if (shouldDestroyWorker) {
+      worker.destroy();
+      this.count--;
+    } else {
+      this.idleQueue.push(worker);
+    }
+
+    if (!this.isDestroyed) {
+      this._startQueuedJob();
+    }
+  }
+
+  _getAvailableWorker() {
+    if (this.idleQueue.length > 0) {
+      return this.idleQueue.shift() || null;
+    }
+
+    if (this.count < this._getMaxConcurrency()) {
+      this.count++;
+      const name = "".concat(this.name.toLowerCase(), " (#").concat(this.count, " of ").concat(this.maxConcurrency, ")");
+      return new WorkerThread({
+        name,
+        source: this.source,
+        url: this.url
+      });
+    }
+
+    return null;
+  }
+
+  _getMaxConcurrency() {
+    return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+  }
+
+}
+
+const DEFAULT_PROPS = {
+  maxConcurrency: 3,
+  maxMobileConcurrency: 1,
+  onDebug: () => {},
+  reuseWorkers: true
+};
+class WorkerFarm {
+  static isSupported() {
+    return WorkerThread.isSupported();
+  }
+
+  static getWorkerFarm(props = {}) {
+    WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
+
+    WorkerFarm._workerFarm.setProps(props);
+
+    return WorkerFarm._workerFarm;
+  }
+
+  constructor(props) {
+    _defineProperty(this, "props", void 0);
+
+    _defineProperty(this, "workerPools", new Map());
+
+    this.props = { ...DEFAULT_PROPS
+    };
+    this.setProps(props);
+    this.workerPools = new Map();
+  }
+
+  destroy() {
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.destroy();
+    }
+  }
+
+  setProps(props) {
+    this.props = { ...this.props,
+      ...props
+    };
+
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.setProps(this._getWorkerPoolProps());
+    }
+  }
+
+  getWorkerPool(options) {
+    const {
+      name,
+      source,
+      url
+    } = options;
+    let workerPool = this.workerPools.get(name);
+
+    if (!workerPool) {
+      workerPool = new WorkerPool({
+        name,
+        source,
+        url
+      });
+      workerPool.setProps(this._getWorkerPoolProps());
+      this.workerPools.set(name, workerPool);
+    }
+
+    return workerPool;
+  }
+
+  _getWorkerPoolProps() {
+    return {
+      maxConcurrency: this.props.maxConcurrency,
+      maxMobileConcurrency: this.props.maxMobileConcurrency,
+      reuseWorkers: this.props.reuseWorkers,
+      onDebug: this.props.onDebug
+    };
+  }
+
+}
+
+_defineProperty(WorkerFarm, "_workerFarm", void 0);
+
+const NPM_TAG = 'latest';
+function getWorkerURL(worker, options = {}) {
+  const workerOptions = options[worker.id] || {};
+  const workerFile = "".concat(worker.id, "-worker.js");
+  let url = workerOptions.workerUrl;
+
+  if (!url && worker.id === 'compression') {
+    url = options.workerUrl;
+  }
+
+  if (options._workerType === 'test') {
+    url = "modules/".concat(worker.module, "/dist/").concat(workerFile);
+  }
+
+  if (!url) {
+    let version = worker.version;
+
+    if (version === 'latest') {
+      version = NPM_TAG;
+    }
+
+    const versionTag = version ? "@".concat(version) : '';
+    url = "https://unpkg.com/@loaders.gl/".concat(worker.module).concat(versionTag, "/dist/").concat(workerFile);
+  }
+
+  assert$1(url);
+  return url;
+}
+
+function validateWorkerVersion(worker, coreVersion = VERSION$2) {
+  assert$1(worker, 'no worker provided');
+  const workerVersion = worker.version;
+
+  if (!coreVersion || !workerVersion) {
+    return false;
+  }
+
+  return true;
+}
+
+var makeNodeStream = {};
+
+var node = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    'default': makeNodeStream
+});
+
+function canParseWithWorker(loader, options) {
+  if (!WorkerFarm.isSupported()) {
+    return false;
+  }
+
+  return loader.worker && (options === null || options === void 0 ? void 0 : options.worker);
+}
+async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
+  const name = loader.id;
+  const url = getWorkerURL(loader, options);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const workerPool = workerFarm.getWorkerPool({
+    name,
+    url
+  });
+  options = JSON.parse(JSON.stringify(options));
+  const job = await workerPool.startJob('process-on-worker', onMessage.bind(null, parseOnMainThread));
+  job.postMessage('process', {
+    input: data,
+    options
+  });
+  const result = await job.result;
+  return await result.result;
+}
+
+async function onMessage(parseOnMainThread, job, type, payload) {
+  switch (type) {
+    case 'done':
+      job.done(payload);
+      break;
+
+    case 'error':
+      job.error(payload.error);
+      break;
+
+    case 'process':
+      const {
+        id,
+        input,
+        options
+      } = payload;
+
+      try {
+        const result = await parseOnMainThread(input, options);
+        job.postMessage('done', {
+          id,
+          result
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : 'unknown error';
+        job.postMessage('error', {
+          id,
+          error: message
+        });
+      }
+
+      break;
+
+    default:
+      console.warn("parse-with-worker unknown message ".concat(type));
+  }
+}
+
+function isBuffer$1(value) {
+  return value && typeof value === 'object' && value.isBuffer;
+}
+function bufferToArrayBuffer(data) {
+  if (undefined) {
+    return undefined(data);
+  }
+
+  return data;
+}
+
+function toArrayBuffer(data) {
+  if (isBuffer$1(data)) {
+    data = bufferToArrayBuffer(data);
+  }
+
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+
+  if (ArrayBuffer.isView(data)) {
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return data.buffer;
+    }
+
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+
+  if (typeof data === 'string') {
+    const text = data;
+    const uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+
+  if (data && typeof data === 'object' && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+
+  throw new Error('toArrayBuffer');
+}
+function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+  byteLength = byteLength || arrayBuffer1.byteLength;
+
+  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+    return false;
+  }
+
+  const array1 = new Uint8Array(arrayBuffer1);
+  const array2 = new Uint8Array(arrayBuffer2);
+
+  for (let i = 0; i < array1.length; ++i) {
+    if (array1[i] !== array2[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+function concatenateArrayBuffers(...sources) {
+  const sourceArrays = sources.map(source2 => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
+  }
+
+  return result.buffer;
+}
+
+async function concatenateArrayBuffersAsync(asyncIterator) {
+  const arrayBuffers = [];
+
+  for await (const chunk of asyncIterator) {
+    arrayBuffers.push(chunk);
+  }
+
+  return concatenateArrayBuffers(...arrayBuffers);
+}
+
+let pathPrefix = '';
+const fileAliases = {};
+function resolvePath(filename) {
+  for (const alias in fileAliases) {
+    if (filename.startsWith(alias)) {
+      const replacement = fileAliases[alias];
+      filename = filename.replace(alias, replacement);
+    }
+  }
+
+  if (!filename.startsWith('http://') && !filename.startsWith('https://')) {
+    filename = "".concat(pathPrefix).concat(filename);
+  }
+
+  return filename;
+}
+
+const isBoolean = x => typeof x === 'boolean';
+
+const isFunction = x => typeof x === 'function';
+
+const isObject = x => x !== null && typeof x === 'object';
+const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
+const isIterable = x => x && typeof x[Symbol.iterator] === 'function';
+const isAsyncIterable = x => x && typeof x[Symbol.asyncIterator] === 'function';
+const isResponse = x => typeof Response !== 'undefined' && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
+const isBlob = x => typeof Blob !== 'undefined' && x instanceof Blob;
+const isReadableDOMStream = x => typeof ReadableStream !== 'undefined' && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
+const isBuffer = x => x && typeof x === 'object' && x.isBuffer;
+const isReadableNodeStream = x => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+const isReadableStream = x => isReadableDOMStream(x) || isReadableNodeStream(x);
+
+const DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
+const MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
+function parseMIMEType(mimeString) {
+  const matches = MIME_TYPE_PATTERN.exec(mimeString);
+
+  if (matches) {
+    return matches[1];
+  }
+
+  return mimeString;
+}
+function parseMIMETypeFromURL(url) {
+  const matches = DATA_URL_PATTERN.exec(url);
+
+  if (matches) {
+    return matches[1];
+  }
+
+  return '';
+}
+
+const QUERY_STRING_PATTERN = /\?.*/;
+function getResourceUrlAndType(resource) {
+  if (isResponse(resource)) {
+    const url = stripQueryString(resource.url || '');
+    const contentTypeHeader = resource.headers.get('content-type') || '';
+    return {
+      url,
+      type: parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(url)
+    };
+  }
+
+  if (isBlob(resource)) {
+    return {
+      url: stripQueryString(resource.name || ''),
+      type: resource.type || ''
+    };
+  }
+
+  if (typeof resource === 'string') {
+    return {
+      url: stripQueryString(resource),
+      type: parseMIMETypeFromURL(resource)
+    };
+  }
+
+  return {
+    url: '',
+    type: ''
+  };
+}
+function getResourceContentLength(resource) {
+  if (isResponse(resource)) {
+    return resource.headers['content-length'] || -1;
+  }
+
+  if (isBlob(resource)) {
+    return resource.size;
+  }
+
+  if (typeof resource === 'string') {
+    return resource.length;
+  }
+
+  if (resource instanceof ArrayBuffer) {
+    return resource.byteLength;
+  }
+
+  if (ArrayBuffer.isView(resource)) {
+    return resource.byteLength;
+  }
+
+  return -1;
+}
+
+function stripQueryString(url) {
+  return url.replace(QUERY_STRING_PATTERN, '');
+}
+
+async function makeResponse(resource) {
+  if (isResponse(resource)) {
+    return resource;
+  }
+
+  const headers = {};
+  const contentLength = getResourceContentLength(resource);
+
+  if (contentLength >= 0) {
+    headers['content-length'] = String(contentLength);
+  }
+
+  const {
+    url,
+    type
+  } = getResourceUrlAndType(resource);
+
+  if (type) {
+    headers['content-type'] = type;
+  }
+
+  const initialDataUrl = await getInitialDataUrl(resource);
+
+  if (initialDataUrl) {
+    headers['x-first-bytes'] = initialDataUrl;
+  }
+
+  if (typeof resource === 'string') {
+    resource = new TextEncoder().encode(resource);
+  }
+
+  const response = new Response(resource, {
+    headers
+  });
+  Object.defineProperty(response, 'url', {
+    value: url
+  });
+  return response;
+}
+async function checkResponse(response) {
+  if (!response.ok) {
+    const message = await getResponseError(response);
+    throw new Error(message);
+  }
+}
+
+async function getResponseError(response) {
+  let message = "Failed to fetch resource ".concat(response.url, " (").concat(response.status, "): ");
+
+  try {
+    const contentType = response.headers.get('Content-Type');
+    let text = response.statusText;
+
+    if (contentType.includes('application/json')) {
+      text += " ".concat(await response.text());
+    }
+
+    message += text;
+    message = message.length > 60 ? "".concat(message.slice(60), "...") : message;
+  } catch (error) {}
+
+  return message;
+}
+
+async function getInitialDataUrl(resource) {
+  const INITIAL_DATA_LENGTH = 5;
+
+  if (typeof resource === 'string') {
+    return "data:,".concat(resource.slice(0, INITIAL_DATA_LENGTH));
+  }
+
+  if (resource instanceof Blob) {
+    const blobSlice = resource.slice(0, 5);
+    return await new Promise(resolve => {
+      const reader = new FileReader();
+
+      reader.onload = event => {
+        var _event$target;
+
+        return resolve(event === null || event === void 0 ? void 0 : (_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.result);
+      };
+
+      reader.readAsDataURL(blobSlice);
+    });
+  }
+
+  if (resource instanceof ArrayBuffer) {
+    const slice = resource.slice(0, INITIAL_DATA_LENGTH);
+    const base64 = arrayBufferToBase64(slice);
+    return "data:base64,".concat(base64);
+  }
+
+  return null;
+}
+
+function arrayBufferToBase64(buffer) {
+  let binary = '';
+  const bytes = new Uint8Array(buffer);
+
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+
+  return btoa(binary);
+}
+
+async function fetchFile(url, options) {
+  if (typeof url === 'string') {
+    url = resolvePath(url);
+    let fetchOptions = options;
+
+    if (options !== null && options !== void 0 && options.fetch && typeof (options === null || options === void 0 ? void 0 : options.fetch) !== 'function') {
+      fetchOptions = options.fetch;
+    }
+
+    return await fetch(url, fetchOptions);
+  }
+
+  return await makeResponse(url);
+}
+
+function isElectron(mockUserAgent) {
+  if (typeof window !== 'undefined' && typeof window.process === 'object' && window.process.type === 'renderer') {
+    return true;
+  }
+
+  if (typeof process !== 'undefined' && typeof process.versions === 'object' && Boolean(process.versions.electron)) {
+    return true;
+  }
+
+  const realUserAgent = typeof navigator === 'object' && typeof navigator.userAgent === 'string' && navigator.userAgent;
+  const userAgent = mockUserAgent || realUserAgent;
+
+  if (userAgent && userAgent.indexOf('Electron') >= 0) {
+    return true;
+  }
+
+  return false;
+}
+
+function isBrowser$1() {
+  const isNode = typeof process === 'object' && String(process) === '[object process]' && !process.browser;
+  return !isNode || isElectron();
+}
+
+const globals = {
+  self: typeof self !== 'undefined' && self,
+  window: typeof window !== 'undefined' && window,
+  global: typeof global !== 'undefined' && global,
+  document: typeof document !== 'undefined' && document,
+  process: typeof process === 'object' && process
+};
+const window_ = globals.window || globals.self || globals.global;
+const process_ = globals.process || {};
+
+const VERSION$1 = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'untranspiled source';
+const isBrowser = isBrowser$1();
+
+function getStorage(type) {
+  try {
+    const storage = window[type];
+    const x = '__storage_test__';
+    storage.setItem(x, x);
+    storage.removeItem(x);
+    return storage;
+  } catch (e) {
+    return null;
+  }
+}
+
+class LocalStorage {
+  constructor(id, defaultSettings, type = 'sessionStorage') {
+    this.storage = getStorage(type);
+    this.id = id;
+    this.config = {};
+    Object.assign(this.config, defaultSettings);
+
+    this._loadConfiguration();
+  }
+
+  getConfiguration() {
+    return this.config;
+  }
+
+  setConfiguration(configuration) {
+    this.config = {};
+    return this.updateConfiguration(configuration);
+  }
+
+  updateConfiguration(configuration) {
+    Object.assign(this.config, configuration);
+
+    if (this.storage) {
+      const serialized = JSON.stringify(this.config);
+      this.storage.setItem(this.id, serialized);
+    }
+
+    return this;
+  }
+
+  _loadConfiguration() {
+    let configuration = {};
+
+    if (this.storage) {
+      const serializedConfiguration = this.storage.getItem(this.id);
+      configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+    }
+
+    Object.assign(this.config, configuration);
+    return this;
+  }
+
+}
+
+function formatTime(ms) {
+  let formatted;
+
+  if (ms < 10) {
+    formatted = "".concat(ms.toFixed(2), "ms");
+  } else if (ms < 100) {
+    formatted = "".concat(ms.toFixed(1), "ms");
+  } else if (ms < 1000) {
+    formatted = "".concat(ms.toFixed(0), "ms");
+  } else {
+    formatted = "".concat((ms / 1000).toFixed(2), "s");
+  }
+
+  return formatted;
+}
+function leftPad(string, length = 8) {
+  const padLength = Math.max(length - string.length, 0);
+  return "".concat(' '.repeat(padLength)).concat(string);
+}
+
+function formatImage(image, message, scale, maxWidth = 600) {
+  const imageUrl = image.src.replace(/\(/g, '%28').replace(/\)/g, '%29');
+
+  if (image.width > maxWidth) {
+    scale = Math.min(scale, maxWidth / image.width);
+  }
+
+  const width = image.width * scale;
+  const height = image.height * scale;
+  const style = ['font-size:1px;', "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), 'color:transparent;'].join('');
+  return ["".concat(message, " %c+"), style];
+}
+
+const COLOR = {
+  BLACK: 30,
+  RED: 31,
+  GREEN: 32,
+  YELLOW: 33,
+  BLUE: 34,
+  MAGENTA: 35,
+  CYAN: 36,
+  WHITE: 37,
+  BRIGHT_BLACK: 90,
+  BRIGHT_RED: 91,
+  BRIGHT_GREEN: 92,
+  BRIGHT_YELLOW: 93,
+  BRIGHT_BLUE: 94,
+  BRIGHT_MAGENTA: 95,
+  BRIGHT_CYAN: 96,
+  BRIGHT_WHITE: 97
+};
+
+function getColor(color) {
+  return typeof color === 'string' ? COLOR[color.toUpperCase()] || COLOR.WHITE : color;
+}
+
+function addColor(string, color, background) {
+  if (!isBrowser && typeof string === 'string') {
+    if (color) {
+      color = getColor(color);
+      string = "\x1B[".concat(color, "m").concat(string, "\x1B[39m");
+    }
+
+    if (background) {
+      color = getColor(background);
+      string = "\x1B[".concat(background + 10, "m").concat(string, "\x1B[49m");
+    }
+  }
+
+  return string;
+}
+
+function autobind(obj, predefined = ['constructor']) {
+  const proto = Object.getPrototypeOf(obj);
+  const propNames = Object.getOwnPropertyNames(proto);
+
+  for (const key of propNames) {
+    if (typeof obj[key] === 'function') {
+      if (!predefined.find(name => key === name)) {
+        obj[key] = obj[key].bind(obj);
+      }
+    }
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'Assertion failed');
+  }
+}
+
+function getHiResTimestamp() {
+  let timestamp;
+
+  if (isBrowser && window_.performance) {
+    timestamp = window_.performance.now();
+  } else if (process_.hrtime) {
+    const timeParts = process_.hrtime();
+    timestamp = timeParts[0] * 1000 + timeParts[1] / 1e6;
+  } else {
+    timestamp = Date.now();
+  }
+
+  return timestamp;
+}
+
+const originalConsole = {
+  debug: isBrowser ? console.debug || console.log : console.log,
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error
+};
+const DEFAULT_SETTINGS = {
+  enabled: true,
+  level: 0
+};
+
+function noop() {}
+
+const cache = {};
+const ONCE = {
+  once: true
+};
+
+function getTableHeader(table) {
+  for (const key in table) {
+    for (const title in table[key]) {
+      return title || 'untitled';
+    }
+  }
+
+  return 'empty';
+}
+
+class Log {
+  constructor({
+    id
+  } = {
+    id: ''
+  }) {
+    this.id = id;
+    this.VERSION = VERSION$1;
+    this._startTs = getHiResTimestamp();
+    this._deltaTs = getHiResTimestamp();
+    this.LOG_THROTTLE_TIMEOUT = 0;
+    this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_SETTINGS);
+    this.userData = {};
+    this.timeStamp("".concat(this.id, " started"));
+    autobind(this);
+    Object.seal(this);
+  }
+
+  set level(newLevel) {
+    this.setLevel(newLevel);
+  }
+
+  get level() {
+    return this.getLevel();
+  }
+
+  isEnabled() {
+    return this._storage.config.enabled;
+  }
+
+  getLevel() {
+    return this._storage.config.level;
+  }
+
+  getTotal() {
+    return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
+  }
+
+  getDelta() {
+    return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
+  }
+
+  set priority(newPriority) {
+    this.level = newPriority;
+  }
+
+  get priority() {
+    return this.level;
+  }
+
+  getPriority() {
+    return this.level;
+  }
+
+  enable(enabled = true) {
+    this._storage.updateConfiguration({
+      enabled
+    });
+
+    return this;
+  }
+
+  setLevel(level) {
+    this._storage.updateConfiguration({
+      level
+    });
+
+    return this;
+  }
+
+  assert(condition, message) {
+    assert(condition, message);
+  }
+
+  warn(message) {
+    return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);
+  }
+
+  error(message) {
+    return this._getLogFunction(0, message, originalConsole.error, arguments);
+  }
+
+  deprecated(oldUsage, newUsage) {
+    return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead"));
+  }
+
+  removed(oldUsage, newUsage) {
+    return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead"));
+  }
+
+  probe(logLevel, message) {
+    return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {
+      time: true,
+      once: true
+    });
+  }
+
+  log(logLevel, message) {
+    return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);
+  }
+
+  info(logLevel, message) {
+    return this._getLogFunction(logLevel, message, console.info, arguments);
+  }
+
+  once(logLevel, message) {
+    return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);
+  }
+
+  table(logLevel, table, columns) {
+    if (table) {
+      return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
+        tag: getTableHeader(table)
+      });
+    }
+
+    return noop;
+  }
+
+  image({
+    logLevel,
+    priority,
+    image,
+    message = '',
+    scale = 1
+  }) {
+    if (!this._shouldLog(logLevel || priority)) {
+      return noop;
+    }
+
+    return isBrowser ? logImageInBrowser({
+      image,
+      message,
+      scale
+    }) : logImageInNode({
+      image,
+      message,
+      scale
+    });
+  }
+
+  settings() {
+    if (console.table) {
+      console.table(this._storage.config);
+    } else {
+      console.log(this._storage.config);
+    }
+  }
+
+  get(setting) {
+    return this._storage.config[setting];
+  }
+
+  set(setting, value) {
+    this._storage.updateConfiguration({
+      [setting]: value
+    });
+  }
+
+  time(logLevel, message) {
+    return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+  }
+
+  timeEnd(logLevel, message) {
+    return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+  }
+
+  timeStamp(logLevel, message) {
+    return this._getLogFunction(logLevel, message, console.timeStamp || noop);
+  }
+
+  group(logLevel, message, opts = {
+    collapsed: false
+  }) {
+    opts = normalizeArguments({
+      logLevel,
+      message,
+      opts
+    });
+    const {
+      collapsed
+    } = opts;
+    opts.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+    return this._getLogFunction(opts);
+  }
+
+  groupCollapsed(logLevel, message, opts = {}) {
+    return this.group(logLevel, message, Object.assign({}, opts, {
+      collapsed: true
+    }));
+  }
+
+  groupEnd(logLevel) {
+    return this._getLogFunction(logLevel, '', console.groupEnd || noop);
+  }
+
+  withGroup(logLevel, message, func) {
+    this.group(logLevel, message)();
+
+    try {
+      func();
+    } finally {
+      this.groupEnd(logLevel)();
+    }
+  }
+
+  trace() {
+    if (console.trace) {
+      console.trace();
+    }
+  }
+
+  _shouldLog(logLevel) {
+    return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
+  }
+
+  _getLogFunction(logLevel, message, method, args = [], opts) {
+    if (this._shouldLog(logLevel)) {
+      opts = normalizeArguments({
+        logLevel,
+        message,
+        args,
+        opts
+      });
+      method = method || opts.method;
+      assert(method);
+      opts.total = this.getTotal();
+      opts.delta = this.getDelta();
+      this._deltaTs = getHiResTimestamp();
+      const tag = opts.tag || opts.message;
+
+      if (opts.once) {
+        if (!cache[tag]) {
+          cache[tag] = getHiResTimestamp();
+        } else {
+          return noop;
+        }
+      }
+
+      message = decorateMessage(this.id, opts.message, opts);
+      return method.bind(console, message, ...opts.args);
+    }
+
+    return noop;
+  }
+
+}
+Log.VERSION = VERSION$1;
+
+function normalizeLogLevel(logLevel) {
+  if (!logLevel) {
+    return 0;
+  }
+
+  let resolvedLevel;
+
+  switch (typeof logLevel) {
+    case 'number':
+      resolvedLevel = logLevel;
+      break;
+
+    case 'object':
+      resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+      break;
+
+    default:
+      return 0;
+  }
+
+  assert(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+  return resolvedLevel;
+}
+
+function normalizeArguments(opts) {
+  const {
+    logLevel,
+    message
+  } = opts;
+  opts.logLevel = normalizeLogLevel(logLevel);
+  const args = opts.args ? Array.from(opts.args) : [];
+
+  while (args.length && args.shift() !== message) {}
+
+  opts.args = args;
+
+  switch (typeof logLevel) {
+    case 'string':
+    case 'function':
+      if (message !== undefined) {
+        args.unshift(message);
+      }
+
+      opts.message = logLevel;
+      break;
+
+    case 'object':
+      Object.assign(opts, logLevel);
+      break;
+  }
+
+  if (typeof opts.message === 'function') {
+    opts.message = opts.message();
+  }
+
+  const messageType = typeof opts.message;
+  assert(messageType === 'string' || messageType === 'object');
+  return Object.assign(opts, opts.opts);
+}
+
+function decorateMessage(id, message, opts) {
+  if (typeof message === 'string') {
+    const time = opts.time ? leftPad(formatTime(opts.total)) : '';
+    message = opts.time ? "".concat(id, ": ").concat(time, "  ").concat(message) : "".concat(id, ": ").concat(message);
+    message = addColor(message, opts.color, opts.background);
+  }
+
+  return message;
+}
+
+function logImageInNode({
+  image,
+  message = '',
+  scale = 1
+}) {
+  let asciify = null;
+
+  try {
+    asciify = module.require('asciify-image');
+  } catch (error) {}
+
+  if (asciify) {
+    return () => asciify(image, {
+      fit: 'box',
+      width: "".concat(Math.round(80 * scale), "%")
+    }).then(data => console.log(data));
+  }
+
+  return noop;
+}
+
+function logImageInBrowser({
+  image,
+  message = '',
+  scale = 1
+}) {
+  if (typeof image === 'string') {
+    const img = new Image();
+
+    img.onload = () => {
+      const args = formatImage(img, message, scale);
+      console.log(...args);
+    };
+
+    img.src = image;
+    return noop;
+  }
+
+  const element = image.nodeName || '';
+
+  if (element.toLowerCase() === 'img') {
+    console.log(...formatImage(image, message, scale));
+    return noop;
+  }
+
+  if (element.toLowerCase() === 'canvas') {
+    const img = new Image();
+
+    img.onload = () => console.log(...formatImage(img, message, scale));
+
+    img.src = image.toDataURL();
+    return noop;
+  }
+
+  return noop;
+}
+
+const probeLog = new Log({
+  id: 'loaders.gl'
+});
+class NullLog {
+  log() {
+    return () => {};
+  }
+
+  info() {
+    return () => {};
+  }
+
+  warn() {
+    return () => {};
+  }
+
+  error() {
+    return () => {};
+  }
+
+}
+class ConsoleLog {
+  constructor() {
+    _defineProperty(this, "console", void 0);
+
+    this.console = console;
+  }
+
+  log(...args) {
+    return this.console.log.bind(this.console, ...args);
+  }
+
+  info(...args) {
+    return this.console.info.bind(this.console, ...args);
+  }
+
+  warn(...args) {
+    return this.console.warn.bind(this.console, ...args);
+  }
+
+  error(...args) {
+    return this.console.error.bind(this.console, ...args);
+  }
+
+}
+
+const DEFAULT_LOADER_OPTIONS = {
+  fetch: null,
+  mimeType: undefined,
+  nothrow: false,
+  log: new ConsoleLog(),
+  CDN: 'https://unpkg.com/@loaders.gl',
+  worker: true,
+  maxConcurrency: 3,
+  maxMobileConcurrency: 1,
+  reuseWorkers: true,
+  _workerType: '',
+  limit: 0,
+  _limitMB: 0,
+  batchSize: 'auto',
+  batchDebounceMs: 0,
+  metadata: false,
+  transforms: []
+};
+const REMOVED_LOADER_OPTIONS = {
+  throws: 'nothrow',
+  dataType: '(no longer used)',
+  uri: 'baseUri',
+  method: 'fetch.method',
+  headers: 'fetch.headers',
+  body: 'fetch.body',
+  mode: 'fetch.mode',
+  credentials: 'fetch.credentials',
+  cache: 'fetch.cache',
+  redirect: 'fetch.redirect',
+  referrer: 'fetch.referrer',
+  referrerPolicy: 'fetch.referrerPolicy',
+  integrity: 'fetch.integrity',
+  keepalive: 'fetch.keepalive',
+  signal: 'fetch.signal'
+};
+
+function getGlobalLoaderState() {
+  global_.loaders = global_.loaders || {};
+  const {
+    loaders
+  } = global_;
+  loaders._state = loaders._state || {};
+  return loaders._state;
+}
+
+const getGlobalLoaderOptions = () => {
+  const state = getGlobalLoaderState();
+  state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS
+  };
+  return state.globalOptions;
+};
+function normalizeOptions(options, loader, loaders, url) {
+  loaders = loaders || [];
+  loaders = Array.isArray(loaders) ? loaders : [loaders];
+  validateOptions(options, loaders);
+  return normalizeOptionsInternal(loader, options, url);
+}
+function getFetchFunction(options, context) {
+  const globalOptions = getGlobalLoaderOptions();
+  const fetchOptions = options || globalOptions;
+
+  if (typeof fetchOptions.fetch === 'function') {
+    return fetchOptions.fetch;
+  }
+
+  if (isObject(fetchOptions.fetch)) {
+    return url => fetchFile(url, fetchOptions);
+  }
+
+  if (context !== null && context !== void 0 && context.fetch) {
+    return context === null || context === void 0 ? void 0 : context.fetch;
+  }
+
+  return fetchFile;
+}
+
+function validateOptions(options, loaders) {
+  validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);
+
+  for (const loader of loaders) {
+    const idOptions = options && options[loader.id] || {};
+    const loaderOptions = loader.options && loader.options[loader.id] || {};
+    const deprecatedOptions = loader.deprecatedOptions && loader.deprecatedOptions[loader.id] || {};
+    validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
+  }
+}
+
+function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) {
+  const loaderName = id || 'Top level';
+  const prefix = id ? "".concat(id, ".") : '';
+
+  for (const key in options) {
+    const isSubOptions = !id && isObject(options[key]);
+    const isBaseUriOption = key === 'baseUri' && !id;
+    const isWorkerUrlOption = key === 'workerUrl' && id;
+
+    if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
+      if (key in deprecatedOptions) {
+        probeLog.warn("".concat(loaderName, " loader option '").concat(prefix).concat(key, "' no longer supported, use '").concat(deprecatedOptions[key], "'"))();
+      } else if (!isSubOptions) {
+        const suggestion = findSimilarOption(key, loaders);
+        probeLog.warn("".concat(loaderName, " loader option '").concat(prefix).concat(key, "' not recognized. ").concat(suggestion))();
+      }
+    }
+  }
+}
+
+function findSimilarOption(optionKey, loaders) {
+  const lowerCaseOptionKey = optionKey.toLowerCase();
+  let bestSuggestion = '';
+
+  for (const loader of loaders) {
+    for (const key in loader.options) {
+      if (optionKey === key) {
+        return "Did you mean '".concat(loader.id, ".").concat(key, "'?");
+      }
+
+      const lowerCaseKey = key.toLowerCase();
+      const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey);
+
+      if (isPartialMatch) {
+        bestSuggestion = bestSuggestion || "Did you mean '".concat(loader.id, ".").concat(key, "'?");
+      }
+    }
+  }
+
+  return bestSuggestion;
+}
+
+function normalizeOptionsInternal(loader, options, url) {
+  const loaderDefaultOptions = loader.options || {};
+  const mergedOptions = { ...loaderDefaultOptions
+  };
+  addUrlOptions(mergedOptions, url);
+
+  if (mergedOptions.log === null) {
+    mergedOptions.log = new NullLog();
+  }
+
+  mergeNestedFields(mergedOptions, getGlobalLoaderOptions());
+  mergeNestedFields(mergedOptions, options);
+  return mergedOptions;
+}
+
+function mergeNestedFields(mergedOptions, options) {
+  for (const key in options) {
+    if (key in options) {
+      const value = options[key];
+
+      if (isPureObject(value) && isPureObject(mergedOptions[key])) {
+        mergedOptions[key] = { ...mergedOptions[key],
+          ...options[key]
+        };
+      } else {
+        mergedOptions[key] = options[key];
+      }
+    }
+  }
+}
+
+function addUrlOptions(options, url) {
+  if (url && !('baseUri' in options)) {
+    options.baseUri = url;
+  }
+}
+
+function isLoaderObject(loader) {
+  var _loader;
+
+  if (!loader) {
+    return false;
+  }
+
+  if (Array.isArray(loader)) {
+    loader = loader[0];
+  }
+
+  const hasExtensions = Array.isArray((_loader = loader) === null || _loader === void 0 ? void 0 : _loader.extensions);
+  return hasExtensions;
+}
+function normalizeLoader(loader) {
+  var _loader2, _loader3;
+
+  assert$2(loader, 'null loader');
+  assert$2(isLoaderObject(loader), 'invalid loader');
+  let options;
+
+  if (Array.isArray(loader)) {
+    options = loader[1];
+    loader = loader[0];
+    loader = { ...loader,
+      options: { ...loader.options,
+        ...options
+      }
+    };
+  }
+
+  if ((_loader2 = loader) !== null && _loader2 !== void 0 && _loader2.parseTextSync || (_loader3 = loader) !== null && _loader3 !== void 0 && _loader3.parseText) {
+    loader.text = true;
+  }
+
+  if (!loader.text) {
+    loader.binary = true;
+  }
+
+  return loader;
+}
+
+const getGlobalLoaderRegistry = () => {
+  const state = getGlobalLoaderState();
+  state.loaderRegistry = state.loaderRegistry || [];
+  return state.loaderRegistry;
+};
+function getRegisteredLoaders() {
+  return getGlobalLoaderRegistry();
+}
+
+const EXT_PATTERN = /\.([^.]+)$/;
+async function selectLoader(data, loaders = [], options, context) {
+  if (!validHTTPResponse(data)) {
+    return null;
+  }
+
+  let loader = selectLoaderSync(data, loaders, { ...options,
+    nothrow: true
+  }, context);
+
+  if (loader) {
+    return loader;
+  }
+
+  if (isBlob(data)) {
+    data = await data.slice(0, 10).arrayBuffer();
+    loader = selectLoaderSync(data, loaders, options, context);
+  }
+
+  if (!loader && !(options !== null && options !== void 0 && options.nothrow)) {
+    throw new Error(getNoValidLoaderMessage(data));
+  }
+
+  return loader;
+}
+function selectLoaderSync(data, loaders = [], options, context) {
+  if (!validHTTPResponse(data)) {
+    return null;
+  }
+
+  if (loaders && !Array.isArray(loaders)) {
+    return normalizeLoader(loaders);
+  }
+
+  let candidateLoaders = [];
+
+  if (loaders) {
+    candidateLoaders = candidateLoaders.concat(loaders);
+  }
+
+  if (!(options !== null && options !== void 0 && options.ignoreRegisteredLoaders)) {
+    candidateLoaders.push(...getRegisteredLoaders());
+  }
+
+  normalizeLoaders(candidateLoaders);
+  const loader = selectLoaderInternal(data, candidateLoaders, options, context);
+
+  if (!loader && !(options !== null && options !== void 0 && options.nothrow)) {
+    throw new Error(getNoValidLoaderMessage(data));
+  }
+
+  return loader;
+}
+
+function selectLoaderInternal(data, loaders, options, context) {
+  const {
+    url,
+    type
+  } = getResourceUrlAndType(data);
+  const testUrl = url || (context === null || context === void 0 ? void 0 : context.url);
+  let loader = null;
+
+  if (options !== null && options !== void 0 && options.mimeType) {
+    loader = findLoaderByMIMEType(loaders, options === null || options === void 0 ? void 0 : options.mimeType);
+  }
+
+  loader = loader || findLoaderByUrl(loaders, testUrl);
+  loader = loader || findLoaderByMIMEType(loaders, type);
+  loader = loader || findLoaderByInitialBytes(loaders, data);
+  loader = loader || findLoaderByMIMEType(loaders, options === null || options === void 0 ? void 0 : options.fallbackMimeType);
+  return loader;
+}
+
+function validHTTPResponse(data) {
+  if (data instanceof Response) {
+    if (data.status === 204) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function getNoValidLoaderMessage(data) {
+  const {
+    url,
+    type
+  } = getResourceUrlAndType(data);
+  let message = 'No valid loader found';
+
+  if (data) {
+    message += " data: \"".concat(getFirstCharacters(data), "\", contentType: \"").concat(type, "\"");
+  }
+
+  if (url) {
+    message += " url: ".concat(url);
+  }
+
+  return message;
+}
+
+function normalizeLoaders(loaders) {
+  for (const loader of loaders) {
+    normalizeLoader(loader);
+  }
+}
+
+function findLoaderByUrl(loaders, url) {
+  const match = url && EXT_PATTERN.exec(url);
+  const extension = match && match[1];
+  return extension ? findLoaderByExtension(loaders, extension) : null;
+}
+
+function findLoaderByExtension(loaders, extension) {
+  extension = extension.toLowerCase();
+
+  for (const loader of loaders) {
+    for (const loaderExtension of loader.extensions) {
+      if (loaderExtension.toLowerCase() === extension) {
+        return loader;
+      }
+    }
+  }
+
+  return null;
+}
+
+function findLoaderByMIMEType(loaders, mimeType) {
+  for (const loader of loaders) {
+    if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
+      return loader;
+    }
+
+    if (mimeType === "application/x.".concat(loader.id)) {
+      return loader;
+    }
+  }
+
+  return null;
+}
+
+function findLoaderByInitialBytes(loaders, data) {
+  if (!data) {
+    return null;
+  }
+
+  for (const loader of loaders) {
+    if (typeof data === 'string') {
+      if (testDataAgainstText(data, loader)) {
+        return loader;
+      }
+    } else if (ArrayBuffer.isView(data)) {
+      if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {
+        return loader;
+      }
+    } else if (data instanceof ArrayBuffer) {
+      const byteOffset = 0;
+
+      if (testDataAgainstBinary(data, byteOffset, loader)) {
+        return loader;
+      }
+    }
+  }
+
+  return null;
+}
+
+function testDataAgainstText(data, loader) {
+  if (loader.testText) {
+    return loader.testText(data);
+  }
+
+  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
+  return tests.some(test => data.startsWith(test));
+}
+
+function testDataAgainstBinary(data, byteOffset, loader) {
+  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
+  return tests.some(test => testBinary(data, byteOffset, loader, test));
+}
+
+function testBinary(data, byteOffset, loader, test) {
+  if (test instanceof ArrayBuffer) {
+    return compareArrayBuffers(test, data, test.byteLength);
+  }
+
+  switch (typeof test) {
+    case 'function':
+      return test(data, loader);
+
+    case 'string':
+      const magic = getMagicString(data, byteOffset, test.length);
+      return test === magic;
+
+    default:
+      return false;
+  }
+}
+
+function getFirstCharacters(data, length = 5) {
+  if (typeof data === 'string') {
+    return data.slice(0, length);
+  } else if (ArrayBuffer.isView(data)) {
+    return getMagicString(data.buffer, data.byteOffset, length);
+  } else if (data instanceof ArrayBuffer) {
+    const byteOffset = 0;
+    return getMagicString(data, byteOffset, length);
+  }
+
+  return '';
+}
+
+function getMagicString(arrayBuffer, byteOffset, length) {
+  if (arrayBuffer.byteLength < byteOffset + length) {
+    return '';
+  }
+
+  const dataView = new DataView(arrayBuffer);
+  let magic = '';
+
+  for (let i = 0; i < length; i++) {
+    magic += String.fromCharCode(dataView.getUint8(byteOffset + i));
+  }
+
+  return magic;
+}
+
+const DEFAULT_CHUNK_SIZE$2 = 256 * 1024;
+function* makeStringIterator(string, options) {
+  const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE$2;
+  let offset = 0;
+  const textEncoder = new TextEncoder();
+
+  while (offset < string.length) {
+    const chunkLength = Math.min(string.length - offset, chunkSize);
+    const chunk = string.slice(offset, offset + chunkLength);
+    offset += chunkLength;
+    yield textEncoder.encode(chunk);
+  }
+}
+
+const DEFAULT_CHUNK_SIZE$1 = 256 * 1024;
+function* makeArrayBufferIterator(arrayBuffer, options = {}) {
+  const {
+    chunkSize = DEFAULT_CHUNK_SIZE$1
+  } = options;
+  let byteOffset = 0;
+
+  while (byteOffset < arrayBuffer.byteLength) {
+    const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);
+    const chunk = new ArrayBuffer(chunkByteLength);
+    const sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);
+    const chunkArray = new Uint8Array(chunk);
+    chunkArray.set(sourceArray);
+    byteOffset += chunkByteLength;
+    yield chunk;
+  }
+}
+
+const DEFAULT_CHUNK_SIZE = 1024 * 1024;
+async function* makeBlobIterator(blob, options) {
+  const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
+  let offset = 0;
+
+  while (offset < blob.size) {
+    const end = offset + chunkSize;
+    const chunk = await blob.slice(offset, end).arrayBuffer();
+    offset = end;
+    yield chunk;
+  }
+}
+
+function makeStreamIterator(stream, options) {
+  return isBrowser$2 ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream);
+}
+
+async function* makeBrowserStreamIterator(stream, options) {
+  const reader = stream.getReader();
+  let nextBatchPromise;
+
+  try {
+    while (true) {
+      const currentBatchPromise = nextBatchPromise || reader.read();
+
+      if (options !== null && options !== void 0 && options._streamReadAhead) {
+        nextBatchPromise = reader.read();
+      }
+
+      const {
+        done,
+        value
+      } = await currentBatchPromise;
+
+      if (done) {
+        return;
+      }
+
+      yield toArrayBuffer(value);
+    }
+  } catch (error) {
+    reader.releaseLock();
+  }
+}
+
+async function* makeNodeStreamIterator(stream, options) {
+  for await (const chunk of stream) {
+    yield toArrayBuffer(chunk);
+  }
+}
+
+function makeIterator(data, options) {
+  if (typeof data === 'string') {
+    return makeStringIterator(data, options);
+  }
+
+  if (data instanceof ArrayBuffer) {
+    return makeArrayBufferIterator(data, options);
+  }
+
+  if (isBlob(data)) {
+    return makeBlobIterator(data, options);
+  }
+
+  if (isReadableStream(data)) {
+    return makeStreamIterator(data, options);
+  }
+
+  if (isResponse(data)) {
+    const response = data;
+    return makeStreamIterator(response.body, options);
+  }
+
+  throw new Error('makeIterator');
+}
+
+const ERR_DATA = 'Cannot convert supplied data type';
+function getArrayBufferOrStringFromDataSync(data, loader, options) {
+  if (loader.text && typeof data === 'string') {
+    return data;
+  }
+
+  if (isBuffer(data)) {
+    data = data.buffer;
+  }
+
+  if (data instanceof ArrayBuffer) {
+    const arrayBuffer = data;
+
+    if (loader.text && !loader.binary) {
+      const textDecoder = new TextDecoder('utf8');
+      return textDecoder.decode(arrayBuffer);
+    }
+
+    return arrayBuffer;
+  }
+
+  if (ArrayBuffer.isView(data)) {
+    if (loader.text && !loader.binary) {
+      const textDecoder = new TextDecoder('utf8');
+      return textDecoder.decode(data);
+    }
+
+    let arrayBuffer = data.buffer;
+    const byteLength = data.byteLength || data.length;
+
+    if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {
+      arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);
+    }
+
+    return arrayBuffer;
+  }
+
+  throw new Error(ERR_DATA);
+}
+async function getArrayBufferOrStringFromData(data, loader, options) {
+  const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);
+
+  if (typeof data === 'string' || isArrayBuffer) {
+    return getArrayBufferOrStringFromDataSync(data, loader);
+  }
+
+  if (isBlob(data)) {
+    data = await makeResponse(data);
+  }
+
+  if (isResponse(data)) {
+    const response = data;
+    await checkResponse(response);
+    return loader.binary ? await response.arrayBuffer() : await response.text();
+  }
+
+  if (isReadableStream(data)) {
+    data = makeIterator(data, options);
+  }
+
+  if (isIterable(data) || isAsyncIterable(data)) {
+    return concatenateArrayBuffersAsync(data);
+  }
+
+  throw new Error(ERR_DATA);
+}
+
+function getLoaderContext(context, options, previousContext = null) {
+  if (previousContext) {
+    return previousContext;
+  }
+
+  const resolvedContext = {
+    fetch: getFetchFunction(options, context),
+    ...context
+  };
+
+  if (!Array.isArray(resolvedContext.loaders)) {
+    resolvedContext.loaders = null;
+  }
+
+  return resolvedContext;
+}
+function getLoadersFromContext(loaders, context) {
+  if (!context && loaders && !Array.isArray(loaders)) {
+    return loaders;
+  }
+
+  let candidateLoaders;
+
+  if (loaders) {
+    candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+  }
+
+  if (context && context.loaders) {
+    const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
+    candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+  }
+
+  return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+}
+
+async function parse(data, loaders, options, context) {
+  assert$1(!context || typeof context === 'object');
+
+  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
+    context = undefined;
+    options = loaders;
+    loaders = undefined;
+  }
+
+  data = await data;
+  options = options || {};
+  const {
+    url
+  } = getResourceUrlAndType(data);
+  const typedLoaders = loaders;
+  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+  const loader = await selectLoader(data, candidateLoaders, options);
+
+  if (!loader) {
+    return null;
+  }
+
+  options = normalizeOptions(options, loader, candidateLoaders, url);
+  context = getLoaderContext({
+    url,
+    parse,
+    loaders: candidateLoaders
+  }, options, context);
+  return await parseWithLoader(loader, data, options, context);
+}
+
+async function parseWithLoader(loader, data, options, context) {
+  validateWorkerVersion(loader);
+  data = await getArrayBufferOrStringFromData(data, loader, options);
+
+  if (loader.parseTextSync && typeof data === 'string') {
+    options.dataType = 'text';
+    return loader.parseTextSync(data, options, context, loader);
+  }
+
+  if (canParseWithWorker(loader, options)) {
+    return await parseWithWorker(loader, data, options, context, parse);
+  }
+
+  if (loader.parseText && typeof data === 'string') {
+    return await loader.parseText(data, options, context, loader);
+  }
+
+  if (loader.parse) {
+    return await loader.parse(data, options, context, loader);
+  }
+
+  assert$1(!loader.parseSync);
+  throw new Error("".concat(loader.id, " loader - no parser found and worker is disabled"));
+}
+
+const VERSION = "3.0.13" ;
+const DEFAULT_LAS_OPTIONS = {
+  las: {
+    fp64: false,
+    skip: 1,
+    colorDepth: 8
+  }
+};
+const LASLoader = {
+  name: 'LAS',
+  id: 'las',
+  module: 'las',
+  version: VERSION,
+  worker: true,
+  extensions: ['las', 'laz'],
+  mimeTypes: ['application/octet-stream'],
+  text: true,
+  binary: true,
+  tests: ['LAS'],
+  options: DEFAULT_LAS_OPTIONS
+};
+
+/**
+ * {@link Viewer} plugin that loads lidar point cloud geometry from LAS files.
+ *
+ * <a href="/examples/#loading_LASLoaderPlugin_Autzen"><img src="/assets/images/autzen.png"></a>
+ *
+ * [[Run this example](/examples/#loading_LASLoaderPlugin_Autzen)]
+ *
+ * ## Summary
+ *
+ * * Loads [LAS 1.4 Format](https://www.asprs.org/divisions-committees/lidar-division/laser-las-file-format-exchange-activities) from both *.las* and *.laz* files.
+ * * Loads lidar point cloud positions, colors and intensities.
+ * * Supports 32 and 64-bit positions.
+ * * Supports 8 and 16-bit color depths.
+ * * Option to load every *n* points.
+ * * Does not (yet) load [point classifications](https://www.usna.edu/Users/oceano/pguth/md_help/html/las_format_classification_codes.htm).
+ *
+ * ## Performance
+ *
+ * If you need faster loading, consider pre-converting your LAS files to XKT format using [xeokit-convert](https://github.com/xeokit/xeokit-convert), then loading them
+ * with {@link XKTLoaderPlugin}.
+ *
+ * ## Scene and metadata representation
+ *
+ * When LASLoaderPlugin loads a LAS file, it creates two {@link Entity}s, a {@link MetaModel} and a {@link MetaObject}.
+ *
+ * The first Entity represents the file as a model within the Viewer's {@link Scene}. To indicate that it represents a model,
+ * this Entity will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}.
+ *
+ * The second Entity represents the the point cloud itself, as an object within the Scene. To indicate that it
+ * represents an object, this Entity will have {@link Entity#isObject} set ````true```` and will be registered
+ * by {@link Entity#id} in {@link Scene#objects}.
+ *
+ * The MetaModel registers the LAS file as a model within the Viewer's {@link MetaScene}. The MetaModel will be registered
+ * by {@link MetaModel#id} in {@link MetaScene#metaModels} .
+ *
+ * Finally, the MetaObject registers the point cloud as an object within the {@link MetaScene}. The MetaObject will be registered
+ * by {@link MetaObject#id} in {@link MetaScene#metaObjects}.
+ *
+ * ## Usage
+ *
+ * In the example below we'll load the Autzen model from
+ * a [LAS file](https://github.com/xeokit/xeokit-sdk/tree/master/examples/models/las/Duplex.las). Once the model has
+ * loaded, we'll then find its {@link MetaModel}, and the {@link MetaObject} and {@link Entity} that represent its point cloud.
+ *
+ * * [[Run this example](/examples/#loading_LASLoaderPlugin_Autzen)]
+ *
+ * ````javascript
+ * import {Viewer, LASLoaderPlugin} from "xeokit-sdk.es.js";
+ *
+ * const viewer = new Viewer({
+ *      canvasId: "myCanvas",
+ *      transparent: true
+ * });
+ *
+ * viewer.camera.eye = [-2.56, 8.38, 8.27];
+ * viewer.camera.look = [13.44, 3.31, -14.83];
+ * viewer.camera.up = [0.10, 0.98, -0.14];
+ *
+ * const lasLoader = new LASLoaderPlugin(viewer, {
+ *     colorDepth: 8, // Default
+ *     fp64: false,   // Default
+ *     skip: 1        // Default
+ * });
+ *
+ * const modelEntity = lasLoader.load({
+ *     id: "myModel",
+ *     src: "../assets/models/las/autzen.laz"
+ * });
+ *
+ * modelEntity.on("loaded", () => {
+ *
+ *      const metaModel = viewer.metaScene.metaModels[modelEntity.id];
+ *      const pointCloudMetaObject = metaModel.rootMetaObject;
+ *
+ *      const pointCloudEntity = viewer.scene.objects[pointCloudMetaObject.id];
+ *
+ *      //...
+ * });
+ * ````
+ *
+ * ## Transforming
+ *
+ * We have the option to rotate, scale and translate each LAS model as we load it.
+ *
+ * In the example below, we'll scale our model to half its size, rotate it 90 degrees about its local X-axis, then
+ * translate it 100 units along its X axis.
+ *
+ * ````javascript
+ * const modelEntity = lasLoader.load({
+ *      id: "myModel",
+ *      src: "../assets/models/las/autzen.laz"
+ *      rotation: [90,0,0],
+ *      scale: [0.5, 0.5, 0.5],
+ *      origin: [100, 0, 0]
+ * });
+ * ````
+ *
+ * ## Configuring a custom data source
+ *
+ * By default, LASLoaderPlugin will load LAS files over HTTP.
+ *
+ * In the example below, we'll customize the way LASLoaderPlugin loads the files by configuring it with our own data source
+ * object. For simplicity, our custom data source example also uses HTTP, using a couple of xeokit utility functions.
+ *
+ * ````javascript
+ * import {utils} from "xeokit-sdk.es.js";
+ *
+ * class MyDataSource {
+ *
+ *      constructor() {
+ *      }
+ *
+ *      // Gets the contents of the given LAS file in an arraybuffer
+ *      getLAS(src, ok, error) {
+ *          utils.loadArraybuffer(src,
+ *              (arraybuffer) => {
+ *                  ok(arraybuffer);
+ *              },
+ *              (errMsg) => {
+ *                  error(errMsg);
+ *              });
+ *      }
+ * }
+ *
+ * const lasLoader = new LASLoaderPlugin(viewer, {
+ *       dataSource: new MyDataSource()
+ * });
+ *
+ * const modelEntity = lasLoader.load({
+ *      id: "myModel",
+ *      src: "../assets/models/las/autzen.laz"
+ * });
+ * ````
+ *
+ * @class LASLoaderPlugin
+ * @since 2.0.13
+ */
+class LASLoaderPlugin extends Plugin {
+
+    /**
+     * @constructor
+     *
+     * @param {Viewer} viewer The Viewer.
+     * @param {Object} cfg  Plugin configuration.
+     * @param {String} [cfg.id="lasLoader"] Optional ID for this plugin, so that we can find it within {@link Viewer#plugins}.
+     * @param {Object} [cfg.dataSource] A custom data source through which the LASLoaderPlugin can load model and metadata files. Defaults to an instance of {@link LASDefaultDataSource}, which loads uover HTTP.
+     * @param {Number} [cfg.skip=1] Configures LASLoaderPlugin to load every **n** points.
+     * @param {Number} [cfg.fp64=false] Configures if LASLoaderPlugin assumes that LAS positions are stored in 64-bit floats instead of 32-bit.
+     * @param {Number} [cfg.colorDepth=8] Configures whether LASLoaderPlugin assumes that LAS colors are encoded using 8 or 16 bits. Accepted values are 8, 16 an "auto".
+     */
+    constructor(viewer, cfg = {}) {
+
+        super("lasLoader", viewer, cfg);
+
+        this.dataSource = cfg.dataSource;
+        this.skip = cfg.skip;
+        this.fp64 = cfg.fp64;
+        this.colorDepth = cfg.colorDepth;
+    }
+
+    /**
+     * Gets the custom data source through which the LASLoaderPlugin can load LAS files.
+     *
+     * Default value is {@link LASDefaultDataSource}, which loads via HTTP.
+     *
+     * @type {Object}
+     */
+    get dataSource() {
+        return this._dataSource;
+    }
+
+    /**
+     * Sets a custom data source through which the LASLoaderPlugin can load LAS files.
+     *
+     * Default value is {@link LASDefaultDataSource}, which loads via HTTP.
+     *
+     * @type {Object}
+     */
+    set dataSource(value) {
+        this._dataSource = value || new LASDefaultDataSource();
+    }
+
+    /**
+     * When LASLoaderPlugin is configured to load every **n** points, returns the value of **n**.
+     *
+     * Default value is ````1````.
+     *
+     * @returns {Number} The **n**th point that LASLoaderPlugin will read.
+     */
+    get skip() {
+        return this._skip;
+    }
+
+    /**
+     * Configures LASLoaderPlugin to load every **n** points.
+     *
+     * Default value is ````1````.
+     *
+     * @param {Number} value The **n**th point that LASLoaderPlugin will read.
+     */
+    set skip(value) {
+        this._skip = value || 1;
+    }
+
+    /**
+     * Gets if LASLoaderPlugin assumes that LAS positions are stored in 64-bit floats instead of 32-bit.
+     *
+     * Default value is ````false````.
+     *
+     * @returns {Boolean} True if LASLoaderPlugin assumes that positions are stored in 64-bit floats instead of 32-bit.
+     */
+    get fp64() {
+        return this._fp64;
+    }
+
+    /**
+     * Configures if LASLoaderPlugin assumes that LAS positions are stored in 64-bit floats instead of 32-bit.
+     *
+     * Default value is ````false````.
+     *
+     * @param {Boolean} value True if LASLoaderPlugin assumes that positions are stored in 64-bit floats instead of 32-bit.
+     */
+    set fp64(value) {
+        this._fp64 = !!value;
+    }
+
+    /**
+     * Gets whether LASLoaderPlugin assumes that LAS colors are encoded using 8 or 16 bits.
+     *
+     * Default value is ````8````.
+     *
+     * Note: LAS specification recommends 16 bits.
+     *
+     * @returns {Number|String} Possible returned values are 8, 16 and "auto".
+     */
+    get colorDepth() {
+        return this._colorDepth;
+    }
+
+    /**
+     * Configures whether LASLoaderPlugin assumes that LAS colors are encoded using 8 or 16 bits.
+     *
+     * Default value is ````8````.
+     *
+     * Note: LAS specification recommends 16 bits.
+     *
+     * @param {Number|String} value Valid values are 8, 16 and "auto".
+     */
+    set colorDepth(value) {
+        this._colorDepth = !!value;
+    }
+
+    /**
+     * Loads an ````LAS```` model into this LASLoaderPlugin's {@link Viewer}.
+     *
+     * @param {*} params Loading parameters.
+     * @param {String} [params.id] ID to assign to the root {@link Entity#id}, unique among all components in the Viewer's {@link Scene}, generated automatically by default.
+     * @param {String} [params.src] Path to a LAS file, as an alternative to the ````las```` parameter.
+     * @param {ArrayBuffer} [params.las] The LAS file data, as an alternative to the ````src```` parameter.
+     * @param {Number[]} [params.position=[0,0,0]] The model World-space 3D position.
+     * @param {Number[]} [params.scale=[1,1,1]] The model's World-space scale.
+     * @param {Number[]} [params.rotation=[0,0,0]] The model's World-space rotation, as Euler angles given in degrees, for each of the X, Y and Z axis.
+     * @param {Number[]} [params.matrix=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]] The model's world transform matrix. Overrides the position, scale and rotation parameters.
+     * @param {Object} [params.stats] Collects model statistics.
+     * @returns {Entity} Entity representing the model, which will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}.
+     */
+    load(params = {}) {
+
+        if (params.id && this.viewer.scene.components[params.id]) {
+            this.error("Component with this ID already exists in viewer: " + params.id + " - will autogenerate this ID");
+            delete params.id;
+        }
+
+        const performanceModel = new PerformanceModel(this.viewer.scene, utils.apply(params, {
+            isModel: true,
+            maxGeometryBatchSize: this._maxGeometryBatchSize
+        }));
+
+        if (!params.src && !params.las) {
+            this.error("load() param expected: src or las");
+            return performanceModel; // Return new empty model
+        }
+
+        const options = {
+            skip: this._skip,
+            fp64: this._fp64,
+            colorDepth: this._colorDepth
+        };
+
+        if (params.src) {
+            this._loadModel(params.src, params, options, performanceModel);
+        } else {
+            const spinner = this.viewer.scene.canvas.spinner;
+            spinner.processes++;
+            this._parseModel(params.las, params, options, performanceModel).then(() => {
+                spinner.processes--;
+            }, (errMsg) => {
+                spinner.processes--;
+                this.error(errMsg);
+                performanceModel.fire("error", errMsg);
+            });
+        }
+
+        return performanceModel;
+    }
+
+    _loadModel(src, params, options, performanceModel) {
+        const spinner = this.viewer.scene.canvas.spinner;
+        spinner.processes++;
+        this._dataSource.getLAS(params.src, (arrayBuffer) => {
+                this._parseModel(arrayBuffer, params, options, performanceModel).then(() => {
+                    spinner.processes--;
+                }, (errMsg) => {
+                    spinner.processes--;
+                    this.error(errMsg);
+                    performanceModel.fire("error", errMsg);
+                });
+            },
+            (errMsg) => {
+                spinner.processes--;
+                this.error(errMsg);
+                performanceModel.fire("error", errMsg);
+            });
+    }
+
+    _parseModel(arrayBuffer, params, options, performanceModel) {
+
+        return new Promise((resolve, reject) => {
+
+            if (performanceModel.destroyed) {
+                reject();
+                return;
+            }
+
+            const stats = params.stats || {};
+            stats.sourceFormat = "LAS";
+            stats.schemaVersion = "";
+            stats.title = "";
+            stats.author = "";
+            stats.created = "";
+            stats.numMetaObjects = 0;
+            stats.numPropertySets = 0;
+            stats.numObjects = 0;
+            stats.numGeometries = 0;
+            stats.numTriangles = 0;
+            stats.numVertices = 0;
+
+            try {
+                parse(arrayBuffer, LASLoader, options).then((parsedData) => {
+
+                    const attributes = parsedData.attributes;
+                    const attributesPosition = attributes.POSITION;
+                    const attributesColor = attributes.COLOR_0;
+                    //  const attributesColor_0 = attributes.COLOR_0;
+                    const attributesIntensity = attributes.intensity;
+                    const attributesClassification = attributes.classification;
+
+                    if (!attributesPosition) {
+                        performanceModel.finalize();
+                        reject("No positions found in file");
+                        return;
+                    }
+
+                    const positionsValue = attributesPosition.value;
+
+                    if (params.rotateX) {
+                        if (positionsValue) {
+                            for (let i = 0, len = positionsValue.length; i < len; i += 3) {
+                                const temp = positionsValue[i + 1];
+                                positionsValue[i + 1] = positionsValue[i + 2];
+                                positionsValue[i + 2] = temp;
+                            }
+                        }
+                    }
+
+                    let colorsCompressed = null;
+
+                    if (attributesColor) {
+                        colorsCompressed = attributesColor.value;
+                    } else {
+
+                    }
+
+                    if (attributesIntensity) {
+                        const intensities = attributesIntensity.value;
+                        colorsCompressed = new Uint8Array(intensities.length * 4);
+
+                        if (attributesColor) { // Intensities with colors
+                            const colors = attributesColor.value;
+                            const colorsSize = attributesColor.size;
+                            for (let i = 0, j = 0, len = intensities.length; i < len; i++, j += 4) {
+                                const intensity = Math.round((intensities[i] / 65536) * 255); // FIXME: Precision loss converting intensity from 16 to 8 bits
+                                colorsCompressed[j + 0] = colors[i * colorsSize];
+                                colorsCompressed[j + 1] = colors[i * colorsSize + 1];
+                                colorsCompressed[j + 2] = colors[i * colorsSize + 2];
+                                colorsCompressed[j + 3] = intensity;
+                            }
+                        } else { // Intensities without colors
+                            for (let i = 0, j = 0, len = intensities.length; i < len; i++, j += 4) {
+                                const intensity = Math.round((intensities[i] / 65536) * 255);
+                                colorsCompressed[j + 0] = 125; // Gray
+                                colorsCompressed[j + 1] = 125;
+                                colorsCompressed[j + 2] = 125;
+                                colorsCompressed[j + 3] = intensity;
+                            }
+                        }
+                    } else if (attributesColor) { // Colors without intensities
+                        const colors = attributesColor.value;
+                        const colorsSize = attributesColor.size;
+                        for (let i = 0, j = 0, len = colors.length / colorsSize; i < len; i++, j += 4) {
+                            colorsCompressed[j + 0] = colors[i * colorsSize];
+                            colorsCompressed[j + 1] = colors[i * colorsSize + 1];
+                            colorsCompressed[j + 2] = colors[i * colorsSize + 2];
+                            colorsCompressed[j + 3] = (colorsSize === 4) ? colors[i * colorsSize + 3] : 255;
+                        }
+                    }
+
+                    performanceModel.createMesh({
+                        id: "pointsMesh",
+                        primitive: "points",
+                        positions: positionsValue,
+                        colorsCompressed
+                    });
+
+                    performanceModel.createEntity({
+                        id: math.createUUID(),
+                        meshIds: ["pointsMesh"],
+                        isObject: true
+                    });
+
+                    performanceModel.finalize();
+
+                    // TODO: Create metamodel
+
+
+                    performanceModel.scene.once("tick", () => {
+                        if (performanceModel.destroyed) {
+                            return;
+                        }
+                        performanceModel.scene.fire("modelLoaded", performanceModel.id); // FIXME: Assumes listeners know order of these two events
+                        performanceModel.fire("loaded", true, false); // Don't forget the event, for late subscribers
+                    });
+
+                    resolve();
+                });
+            } catch (e) {
+                performanceModel.finalize();
+                reject(e);
+            }
+        });
+    }
+}
+
+export { AmbientLight, AngleMeasurementsPlugin, AnnotationsPlugin, AxisGizmoPlugin, BCFViewpointsPlugin, CameraMemento, CameraPath, CameraPathAnimation, Component, Configs, ContextMenu, CubicBezierCurve, Curve, DirLight, DistanceMeasurementsPlugin, EdgeMaterial, EmphasisMaterial, FastNavPlugin, Fresnel, GLTFDefaultDataSource, GLTFLoaderPlugin, IFCLoaderPlugin, ImagePlane, LASLoaderPlugin, LambertMaterial, LightMap, LocaleService, Map$1 as Map, Marker, Mesh, MetallicMaterial, ModelMemento, NavCubePlugin, Node, OBJLoaderPlugin, ObjectsMemento, Path, PerformanceModel, PhongMaterial, Plugin, PointLight, QuadraticBezierCurve, Queue, ReadableGeometry, ReflectionMap, STLDefaultDataSource, STLLoaderPlugin, SectionPlane, SectionPlanesPlugin, Skybox, SkyboxesPlugin, SpecularMaterial, SplineCurve, SpriteMarker, StoreyViewsPlugin, Texture, TreeViewPlugin, VBOGeometry, ViewCullPlugin, Viewer, XKTDefaultDataSource, XKTLoaderPlugin, XML3DLoaderPlugin, buildBoxGeometry, buildBoxLinesGeometry, buildCylinderGeometry, buildGridGeometry, buildPlaneGeometry, buildSphereGeometry, buildTorusGeometry, buildVectorTextGeometry, load3DSGeometry, loadOBJGeometry, math, utils };