@luma.gl/core 9.0.0-alpha.16 → 9.0.0-alpha.19

package/dist/dist.dev.js

@@ -0,0 +1,1315 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+  if (typeof exports === 'object' && typeof module === 'object')
+    module.exports = factory();
+  else if (typeof define === 'function' && define.amd) define([], factory);
+        else if (typeof exports === 'object') exports['luma'] = factory();
+  else root['luma'] = factory();})(globalThis, function () {
+var __exports__ = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    Device: () => Device,
+    Timeline: () => Timeline,
+    assert: () => assert2,
+    log: () => log,
+    luma: () => luma,
+    uid: () => uid
+  });
+
+  // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
+  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;
+  }
+
+  // ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
+  function isBrowser() {
+    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    return !isNode || isElectron();
+  }
+
+  // ../../node_modules/@probe.gl/env/dist/lib/globals.js
+  var self_ = globalThis.self || globalThis.window || globalThis.global;
+  var window_ = globalThis.window || globalThis.self || globalThis.global;
+  var document_ = globalThis.document || {};
+  var process_ = globalThis.process || {};
+  var console_ = globalThis.console;
+  var navigator_ = globalThis.navigator || {};
+
+  // ../../node_modules/@probe.gl/env/dist/utils/globals.js
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+  var isBrowser2 = isBrowser();
+
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
+  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;
+    }
+  }
+  var LocalStorage = class {
+    constructor(id, defaultConfig) {
+      let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
+      _defineProperty(this, "storage", void 0);
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "config", void 0);
+      this.storage = getStorage(type);
+      this.id = id;
+      this.config = defaultConfig;
+      this._loadConfiguration();
+    }
+    getConfiguration() {
+      return this.config;
+    }
+    setConfiguration(configuration) {
+      Object.assign(this.config, configuration);
+      if (this.storage) {
+        const serialized = JSON.stringify(this.config);
+        this.storage.setItem(this.id, serialized);
+      }
+    }
+    _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;
+    }
+  };
+
+  // ../../node_modules/@probe.gl/log/dist/utils/formatters.js
+  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 < 1e3) {
+      formatted = "".concat(ms.toFixed(0), "ms");
+    } else {
+      formatted = "".concat((ms / 1e3).toFixed(2), "s");
+    }
+    return formatted;
+  }
+  function leftPad(string) {
+    let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
+    const padLength = Math.max(length - string.length, 0);
+    return "".concat(" ".repeat(padLength)).concat(string);
+  }
+  function formatImage(image, message, scale) {
+    let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 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];
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/color.js
+  var COLOR;
+  (function(COLOR2) {
+    COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+    COLOR2[COLOR2["RED"] = 31] = "RED";
+    COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+    COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+    COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+    COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+    COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+    COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+    COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+    COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+    COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+    COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+    COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+    COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+    COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+    COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+  })(COLOR || (COLOR = {}));
+  var BACKGROUND_INCREMENT = 10;
+  function getColor(color) {
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
+  }
+  function addColor(string, color, background) {
+    if (!isBrowser && typeof string === "string") {
+      if (color) {
+        const colorCode = getColor(color);
+        string = "\x1B[".concat(colorCode, "m").concat(string, "\x1B[39m");
+      }
+      if (background) {
+        const colorCode = getColor(background);
+        string = "\x1B[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "\x1B[49m");
+      }
+    }
+    return string;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
+  function autobind(obj) {
+    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
+    const proto = Object.getPrototypeOf(obj);
+    const propNames = Object.getOwnPropertyNames(proto);
+    const object = obj;
+    for (const key of propNames) {
+      const value = object[key];
+      if (typeof value === "function") {
+        if (!predefined.find((name) => key === name)) {
+          object[key] = value.bind(obj);
+        }
+      }
+    }
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
+    }
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp() {
+    let timestamp;
+    if (isBrowser() && window_.performance) {
+      var _window$performance, _window$performance$n;
+      timestamp = window_ === null || window_ === void 0 ? void 0 : (_window$performance = window_.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance);
+    } else if ("hrtime" in process_) {
+      var _process$hrtime;
+      const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_);
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/log.js
+  var originalConsole = {
+    debug: isBrowser() ? console.debug || console.log : console.log,
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  var DEFAULT_LOG_CONFIGURATION = {
+    enabled: true,
+    level: 0
+  };
+  function noop() {
+  }
+  var cache = {};
+  var ONCE = {
+    once: true
+  };
+  var Log = class {
+    constructor() {
+      let {
+        id
+      } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+        id: ""
+      };
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "VERSION", VERSION);
+      _defineProperty(this, "_startTs", getHiResTimestamp());
+      _defineProperty(this, "_deltaTs", getHiResTimestamp());
+      _defineProperty(this, "_storage", void 0);
+      _defineProperty(this, "userData", {});
+      _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
+      this.id = id;
+      this.userData = {};
+      this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_LOG_CONFIGURATION);
+      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() {
+      let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+      this._storage.setConfiguration({
+        enabled
+      });
+      return this;
+    }
+    setLevel(level) {
+      this._storage.setConfiguration({
+        level
+      });
+      return this;
+    }
+    get(setting) {
+      return this._storage.config[setting];
+    }
+    set(setting, value) {
+      this._storage.setConfiguration({
+        [setting]: value
+      });
+    }
+    settings() {
+      if (console.table) {
+        console.table(this._storage.config);
+      } else {
+        console.log(this._storage.config);
+      }
+    }
+    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(_ref) {
+      let {
+        logLevel,
+        priority,
+        image,
+        message = "",
+        scale = 1
+      } = _ref;
+      if (!this._shouldLog(logLevel || priority)) {
+        return noop;
+      }
+      return isBrowser() ? logImageInBrowser({
+        image,
+        message,
+        scale
+      }) : logImageInNode({
+        image,
+        message,
+        scale
+      });
+    }
+    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) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+        collapsed: false
+      };
+      const options = normalizeArguments({
+        logLevel,
+        message,
+        opts
+      });
+      const {
+        collapsed
+      } = opts;
+      options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+      return this._getLogFunction(options);
+    }
+    groupCollapsed(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      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 && tag) {
+          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;
+    }
+  };
+  _defineProperty(Log, "VERSION", VERSION);
+  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) {
+    }
+    switch (typeof logLevel) {
+      case "string":
+      case "function":
+        if (message !== void 0) {
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
+    }
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
+    }
+    const messageType = typeof opts.message;
+    assert(messageType === "string" || messageType === "object");
+    return Object.assign(opts, {
+      args
+    }, 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(_ref2) {
+    let {
+      image,
+      message = "",
+      scale = 1
+    } = _ref2;
+    console.warn("removed");
+    return noop;
+  }
+  function logImageInBrowser(_ref3) {
+    let {
+      image,
+      message = "",
+      scale = 1
+    } = _ref3;
+    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;
+  }
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
+    }
+    return "empty";
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/index.js
+  var dist_default = new Log({
+    id: "@probe.gl/log"
+  });
+
+  // ../api/src/lib/utils/log.ts
+  var log = new Log({
+    id: "luma.gl"
+  });
+
+  // ../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp2() {
+    let timestamp;
+    if (typeof window !== "undefined" && window.performance) {
+      timestamp = window.performance.now();
+    } else if (typeof process !== "undefined" && process.hrtime) {
+      const timeParts = process.hrtime();
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+
+  // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
+  var Stat = class {
+    constructor(name, type) {
+      _defineProperty(this, "name", void 0);
+      _defineProperty(this, "type", void 0);
+      _defineProperty(this, "sampleSize", 1);
+      _defineProperty(this, "time", 0);
+      _defineProperty(this, "count", 0);
+      _defineProperty(this, "samples", 0);
+      _defineProperty(this, "lastTiming", 0);
+      _defineProperty(this, "lastSampleTime", 0);
+      _defineProperty(this, "lastSampleCount", 0);
+      _defineProperty(this, "_count", 0);
+      _defineProperty(this, "_time", 0);
+      _defineProperty(this, "_samples", 0);
+      _defineProperty(this, "_startTime", 0);
+      _defineProperty(this, "_timerPending", false);
+      this.name = name;
+      this.type = type;
+      this.reset();
+    }
+    reset() {
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      return this;
+    }
+    setSampleSize(samples) {
+      this.sampleSize = samples;
+      return this;
+    }
+    incrementCount() {
+      this.addCount(1);
+      return this;
+    }
+    decrementCount() {
+      this.subtractCount(1);
+      return this;
+    }
+    addCount(value) {
+      this._count += value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    subtractCount(value) {
+      this._count -= value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    addTime(time) {
+      this._time += time;
+      this.lastTiming = time;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    timeStart() {
+      this._startTime = getHiResTimestamp2();
+      this._timerPending = true;
+      return this;
+    }
+    timeEnd() {
+      if (!this._timerPending) {
+        return this;
+      }
+      this.addTime(getHiResTimestamp2() - this._startTime);
+      this._timerPending = false;
+      this._checkSampling();
+      return this;
+    }
+    getSampleAverageCount() {
+      return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
+    }
+    getSampleAverageTime() {
+      return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
+    }
+    getSampleHz() {
+      return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
+    }
+    getAverageCount() {
+      return this.samples > 0 ? this.count / this.samples : 0;
+    }
+    getAverageTime() {
+      return this.samples > 0 ? this.time / this.samples : 0;
+    }
+    getHz() {
+      return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
+    }
+    _checkSampling() {
+      if (this._samples === this.sampleSize) {
+        this.lastSampleTime = this._time;
+        this.lastSampleCount = this._count;
+        this.count += this._count;
+        this.time += this._time;
+        this.samples += this._samples;
+        this._time = 0;
+        this._count = 0;
+        this._samples = 0;
+      }
+    }
+  };
+
+  // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
+  var Stats = class {
+    constructor(options) {
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "stats", {});
+      this.id = options.id;
+      this.stats = {};
+      this._initializeStats(options.stats);
+      Object.seal(this);
+    }
+    get(name) {
+      let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
+      return this._getOrCreate({
+        name,
+        type
+      });
+    }
+    get size() {
+      return Object.keys(this.stats).length;
+    }
+    reset() {
+      for (const stat of Object.values(this.stats)) {
+        stat.reset();
+      }
+      return this;
+    }
+    forEach(fn) {
+      for (const stat of Object.values(this.stats)) {
+        fn(stat);
+      }
+    }
+    getTable() {
+      const table = {};
+      this.forEach((stat) => {
+        table[stat.name] = {
+          time: stat.time || 0,
+          count: stat.count || 0,
+          average: stat.getAverageTime() || 0,
+          hz: stat.getHz() || 0
+        };
+      });
+      return table;
+    }
+    _initializeStats() {
+      let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+      stats.forEach((stat) => this._getOrCreate(stat));
+    }
+    _getOrCreate(stat) {
+      const {
+        name,
+        type
+      } = stat;
+      let result = this.stats[name];
+      if (!result) {
+        if (stat instanceof Stat) {
+          result = stat;
+        } else {
+          result = new Stat(name, type);
+        }
+        this.stats[name] = result;
+      }
+      return result;
+    }
+  };
+
+  // ../api/src/lib/utils/stats-manager.ts
+  var StatsManager = class {
+    stats = /* @__PURE__ */ new Map();
+    getStats(name) {
+      return this.get(name);
+    }
+    get(name) {
+      if (!this.stats.has(name)) {
+        this.stats.set(name, new Stats({
+          id: name
+        }));
+      }
+      return this.stats.get(name);
+    }
+  };
+  var lumaStats = new StatsManager();
+
+  // ../api/src/init.ts
+  function init() {
+    const VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+    const STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering";
+    if (globalThis.luma && globalThis.luma.VERSION !== VERSION3) {
+      throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION3}`);
+    }
+    if (!globalThis.luma) {
+      if (isBrowser()) {
+        log.log(1, `luma.gl ${VERSION3} - ${STARTUP_MESSAGE}`)();
+      }
+      globalThis.luma = globalThis.luma || {
+        VERSION: VERSION3,
+        version: VERSION3,
+        log,
+        // A global stats object that various components can add information to
+        // E.g. see webgl/resource.js
+        stats: lumaStats
+      };
+    }
+    return VERSION3;
+  }
+  var VERSION2 = init();
+  var init_default = globalThis.luma;
+
+  // ../api/src/lib/utils/utils.ts
+  var uidCounters = {};
+  function uid(id = "id") {
+    uidCounters[id] = uidCounters[id] || 1;
+    const count = uidCounters[id]++;
+    return `${id}-${count}`;
+  }
+
+  // ../api/src/adapter/resources/resource.ts
+  var DEFAULT_RESOURCE_PROPS = {
+    id: "undefined",
+    handle: void 0,
+    userData: {}
+  };
+  var Resource = class {
+    /** props.id, for debugging. */
+    userData = {};
+    destroyed = false;
+    /** For resources that allocate GPU memory */
+    allocatedBytes = 0;
+    /**
+     * Create a new Resource. Called from Subclass
+     */
+    constructor(device, props, defaultProps) {
+      if (!device) {
+        throw new Error("no device");
+      }
+      this._device = device;
+      this.props = selectivelyMerge(props, defaultProps);
+      const id = this.props.id !== "undefined" ? this.props.id : uid(this[Symbol.toStringTag]);
+      this.props.id = id;
+      this.id = id;
+      this.userData = this.props.userData || {};
+      this.addStats();
+    }
+    /**
+     * destroy can be called on any resource to release it before it is garbage collected.
+     */
+    destroy() {
+      this.removeStats();
+    }
+    /** @deprecated Use destroy() */
+    delete() {
+      this.destroy();
+      return this;
+    }
+    toString() {
+      return `${this[Symbol.toStringTag] || this.constructor.name}(${this.id})`;
+    }
+    /**
+     * Combines a map of user props and default props, only including props from defaultProps
+     * @returns returns a map of overridden default props
+     */
+    getProps() {
+      return this.props;
+    }
+    // PROTECTED METHODS
+    /** Called by resource constructor to track object creation */
+    addStats() {
+      const stats = this._device.statsManager.getStats("Resource Counts");
+      const name = this[Symbol.toStringTag];
+      stats.get("Resources Created").incrementCount();
+      stats.get(`${name}s Created`).incrementCount();
+      stats.get(`${name}s Active`).incrementCount();
+    }
+    /** Called by .destroy() to track object destruction. Subclass must call if overriding destroy() */
+    removeStats() {
+      const stats = this._device.statsManager.getStats("Resource Counts");
+      const name = this[Symbol.toStringTag];
+      stats.get(`${name}s Active`).decrementCount();
+    }
+    /** Called by subclass to track memory allocations */
+    trackAllocatedMemory(bytes, name = this[Symbol.toStringTag]) {
+      const stats = this._device.statsManager.getStats("Resource Counts");
+      stats.get("GPU Memory").addCount(bytes);
+      stats.get(`${name} Memory`).addCount(bytes);
+      this.allocatedBytes = bytes;
+    }
+    /** Called by subclass to track memory deallocations */
+    trackDeallocatedMemory(name = this[Symbol.toStringTag]) {
+      const stats = this._device.statsManager.getStats("Resource Counts");
+      stats.get("GPU Memory").subtractCount(this.allocatedBytes);
+      stats.get(`${name} Memory`).subtractCount(this.allocatedBytes);
+      this.allocatedBytes = 0;
+    }
+  };
+  function selectivelyMerge(props, defaultProps) {
+    const mergedProps = {
+      ...defaultProps
+    };
+    for (const key in props) {
+      if (props[key] !== void 0) {
+        mergedProps[key] = props[key];
+      }
+    }
+    return mergedProps;
+  }
+
+  // ../api/src/adapter/resources/buffer.ts
+  var DEFAULT_BUFFER_PROPS = {
+    ...DEFAULT_RESOURCE_PROPS,
+    usage: 0,
+    // Buffer.COPY_DST | Buffer.COPY_SRC
+    byteLength: 0,
+    byteOffset: 0,
+    data: null,
+    indexType: "uint16",
+    mappedAtCreation: false
+  };
+  var _Buffer = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "Buffer";
+    }
+    constructor(device, props) {
+      const deducedProps = {
+        ...props
+      };
+      if ((props.usage || 0) & _Buffer.INDEX && !props.indexType) {
+        if (props.data instanceof Uint32Array) {
+          deducedProps.indexType = "uint32";
+        } else if (props.data instanceof Uint16Array) {
+          deducedProps.indexType = "uint16";
+        }
+      }
+      super(device, deducedProps, DEFAULT_BUFFER_PROPS);
+    }
+    write(data, byteOffset) {
+      throw new Error("not implemented");
+    }
+    readAsync(byteOffset, byteLength) {
+      throw new Error("not implemented");
+    }
+    // TODO - can sync read be supported in WebGPU?
+    getData() {
+      throw new Error("not implemented");
+    }
+    // Convenience API
+    /** Read data from the buffer *
+    async readAsync(options: {
+      byteOffset?: number,
+      byteLength?: number,
+      map?: boolean,
+      unmap?: boolean
+    }): Promise<ArrayBuffer> {
+      if (options.map ?? true) {
+        await this.mapAsync(Buffer.MAP_READ, options.byteOffset, options.byteLength);
+      }
+      const arrayBuffer = this.getMappedRange(options.byteOffset, options.byteLength);
+      if (options.unmap ?? true) {
+        this.unmap();
+      }
+      return arrayBuffer;
+    }
+     /** Write data to the buffer *
+    async writeAsync(options: {
+      data: ArrayBuffer,
+      byteOffset?: number,
+      byteLength?: number,
+      map?: boolean,
+      unmap?: boolean
+    }): Promise<void> {
+      if (options.map ?? true) {
+        await this.mapAsync(Buffer.MAP_WRITE, options.byteOffset, options.byteLength);
+      }
+      const arrayBuffer = this.getMappedRange(options.byteOffset, options.byteLength);
+      const destArray = new Uint8Array(arrayBuffer);
+      const srcArray = new Uint8Array(options.data);
+      destArray.set(srcArray);
+      if (options.unmap ?? true) {
+        this.unmap();
+      }
+    }
+    */
+    // Mapped API (WebGPU)
+    /** Maps the memory so that it can be read */
+    // abstract mapAsync(mode, byteOffset, byteLength): Promise<void>
+    /** Get the mapped range of data for reading or writing */
+    // abstract getMappedRange(byteOffset, byteLength): ArrayBuffer;
+    /** unmap makes the contents of the buffer available to the GPU again */
+    // abstract unmap(): void;
+  };
+  var Buffer2 = _Buffer;
+  // Usage Flags
+  __publicField(Buffer2, "MAP_READ", 1);
+  __publicField(Buffer2, "MAP_WRITE", 2);
+  __publicField(Buffer2, "COPY_SRC", 4);
+  __publicField(Buffer2, "COPY_DST", 8);
+  __publicField(Buffer2, "INDEX", 16);
+  __publicField(Buffer2, "VERTEX", 32);
+  __publicField(Buffer2, "UNIFORM", 64);
+  __publicField(Buffer2, "STORAGE", 128);
+  __publicField(Buffer2, "INDIRECT", 256);
+  __publicField(Buffer2, "QUERY_RESOLVE", 512);
+
+  // ../api/src/adapter/device.ts
+  var DEFAULT_DEVICE_PROPS = {
+    id: null,
+    type: "best-available",
+    canvas: null,
+    container: null,
+    webgl2: true,
+    // Attempt to create a WebGL2 context
+    webgl1: true,
+    // Attempt to create a WebGL1 context (false to fail if webgl2 not available)
+    manageState: true,
+    width: 800,
+    // width are height are only used by headless gl
+    height: 600,
+    debug: Boolean(log.get("debug")),
+    // Instrument context (at the expense of performance)
+    break: [],
+    // alpha: undefined,
+    // depth: undefined,
+    // stencil: undefined,
+    // antialias: undefined,
+    // premultipliedAlpha: undefined,
+    // preserveDrawingBuffer: undefined,
+    // failIfMajorPerformanceCaveat: undefined
+    gl: null
+  };
+  var Device = class {
+    get [Symbol.toStringTag]() {
+      return "Device";
+    }
+    constructor(props) {
+      this.props = {
+        ...DEFAULT_DEVICE_PROPS,
+        ...props
+      };
+      this.id = this.props.id || uid(this[Symbol.toStringTag].toLowerCase());
+    }
+    statsManager = lumaStats;
+    userData = {};
+    /** Information about the device (vendor, versions etc) */
+    /** Optional capability discovery */
+    /** WebGPU style device limits */
+    /** Check if device supports a specific texture format (creation and `nearest` sampling) */
+    /** Check if linear filtering (sampler interpolation) is supported for a specific texture format */
+    /** Check if device supports rendering to a specific texture format */
+    /** True context is already lost */
+    /** Promise that resolves when context is lost */
+    /** default canvas context */
+    /** Creates a new CanvasContext (WebGPU only) */
+    /** Call after rendering a frame (necessary e.g. on WebGL OffscreenCanvas) */
+    // Resource creation
+    /** Create a buffer */
+    createBuffer(props) {
+      if (props instanceof ArrayBuffer || ArrayBuffer.isView(props)) {
+        return this._createBuffer({
+          data: props
+        });
+      }
+      if ((props.usage || 0) & Buffer2.INDEX && !props.indexType) {
+        if (props.data instanceof Uint32Array) {
+          props.indexType = "uint32";
+        } else if (props.data instanceof Uint16Array) {
+          props.indexType = "uint16";
+        }
+      }
+      return this._createBuffer(props);
+    }
+    /** Create a texture */
+    createTexture(props) {
+      if (props instanceof Promise || typeof props === "string") {
+        props = {
+          data: props
+        };
+      }
+      return this._createTexture(props);
+    }
+    /** Create a temporary texture view of a video source */
+    /** Create a sampler */
+    /** Create a shader */
+    /** Create a render pipeline (aka program) */
+    /** Create a compute pipeline (aka program) */
+    /** Create a RenderPass */
+    /** Create a ComputePass */
+    // Implementation
+  };
+  __publicField(Device, "VERSION", VERSION2);
+
+  // ../api/src/lib/luma.ts
+  var deviceList = /* @__PURE__ */ new Map();
+  var luma = class {
+    static registerDevices(deviceClasses) {
+      for (const deviceClass of deviceClasses) {
+        assert2(deviceClass.type && deviceClass.isSupported && deviceClass.create);
+        deviceList.set(deviceClass.type, deviceClass);
+      }
+    }
+    static getAvailableDevices() {
+      return Array.from(deviceList).map((Device2) => Device2.type);
+    }
+    static getSupportedDevices() {
+      return Array.from(deviceList).filter((Device2) => Device2.isSupported()).map((Device2) => Device2.type);
+    }
+    static setDefaultDeviceProps(props) {
+      Object.assign(DEFAULT_DEVICE_PROPS, props);
+    }
+    /** Creates a device. Asynchronously. */
+    static async createDevice(props = {}) {
+      props = {
+        ...DEFAULT_DEVICE_PROPS,
+        ...props
+      };
+      if (props.gl) {
+        props.type = "webgl";
+      }
+      let Device2;
+      switch (props.type) {
+        case "webgpu":
+          Device2 = deviceList.get("webgpu");
+          if (Device2) {
+            return await Device2.create(props);
+          }
+          break;
+        case "webgl":
+        case "webgl1":
+        case "webgl2":
+          Device2 = deviceList.get("webgl");
+          if (Device2) {
+            return await Device2.create(props);
+          }
+          break;
+        case "best-available":
+          Device2 = deviceList.get("webgl");
+          if (Device2 && Device2.isSupported()) {
+            return await Device2.create(props);
+          }
+          break;
+      }
+      throw new Error("No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.");
+    }
+  };
+  /** Global stats for all devices */
+  __publicField(luma, "stats", lumaStats);
+  /** Global log */
+  __publicField(luma, "log", log);
+
+  // ../api/src/lib/utils/assert.ts
+  function assert2(condition, message) {
+    if (!condition) {
+      throw new Error(message || "luma.gl: assertion failed.");
+    }
+  }
+
+  // ../engine/src/animation/timeline.ts
+  var channelHandles = 1;
+  var animationHandles = 1;
+  var Timeline = class {
+    time = 0;
+    channels = /* @__PURE__ */ new Map();
+    animations = /* @__PURE__ */ new Map();
+    playing = false;
+    lastEngineTime = -1;
+    constructor() {
+    }
+    addChannel(props) {
+      const {
+        delay = 0,
+        duration = Number.POSITIVE_INFINITY,
+        rate = 1,
+        repeat = 1
+      } = props;
+      const handle = channelHandles++;
+      const channel = {
+        time: 0,
+        delay,
+        duration,
+        rate,
+        repeat
+      };
+      this._setChannelTime(channel, this.time);
+      this.channels.set(handle, channel);
+      return handle;
+    }
+    removeChannel(handle) {
+      this.channels.delete(handle);
+      for (const [animationHandle, animation] of this.animations) {
+        if (animation.channel === handle) {
+          this.detachAnimation(animationHandle);
+        }
+      }
+    }
+    isFinished(handle) {
+      const channel = this.channels.get(handle);
+      if (channel === void 0) {
+        return false;
+      }
+      return this.time >= channel.delay + channel.duration * channel.repeat;
+    }
+    getTime(handle) {
+      if (handle === void 0) {
+        return this.time;
+      }
+      const channel = this.channels.get(handle);
+      if (channel === void 0) {
+        return -1;
+      }
+      return channel.time;
+    }
+    setTime(time) {
+      this.time = Math.max(0, time);
+      const channels = this.channels.values();
+      for (const channel of channels) {
+        this._setChannelTime(channel, this.time);
+      }
+      const animations = this.animations.values();
+      for (const animationData of animations) {
+        const {
+          animation,
+          channel
+        } = animationData;
+        animation.setTime(this.getTime(channel));
+      }
+    }
+    play() {
+      this.playing = true;
+    }
+    pause() {
+      this.playing = false;
+      this.lastEngineTime = -1;
+    }
+    reset() {
+      this.setTime(0);
+    }
+    attachAnimation(animation, channelHandle) {
+      const animationHandle = animationHandles++;
+      this.animations.set(animationHandle, {
+        animation,
+        channel: channelHandle
+      });
+      animation.setTime(this.getTime(channelHandle));
+      return animationHandle;
+    }
+    detachAnimation(handle) {
+      this.animations.delete(handle);
+    }
+    update(engineTime) {
+      if (this.playing) {
+        if (this.lastEngineTime === -1) {
+          this.lastEngineTime = engineTime;
+        }
+        this.setTime(this.time + (engineTime - this.lastEngineTime));
+        this.lastEngineTime = engineTime;
+      }
+    }
+    _setChannelTime(channel, time) {
+      const offsetTime = time - channel.delay;
+      const totalDuration = channel.duration * channel.repeat;
+      if (offsetTime >= totalDuration) {
+        channel.time = channel.duration * channel.rate;
+      } else {
+        channel.time = Math.max(0, offsetTime) % channel.duration;
+        channel.time *= channel.rate;
+      }
+    }
+  };
+  return __toCommonJS(src_exports);
+})();
+      return __exports__;
+      });