@luma.gl/core 9.0.17 → 9.1.0-alpha.10

package/dist/index.cjs

@@ -25,6 +25,7 @@ var __publicField = (obj, key, value) => {
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  Adapter: () => Adapter,
   Buffer: () => Buffer2,
   CanvasContext: () => CanvasContext,
   CommandBuffer: () => CommandBuffer,
@@ -42,62 +43,27 @@ __export(dist_exports, {
   Resource: () => Resource,
   Sampler: () => Sampler,
   Shader: () => Shader,
-  StatsManager: () => StatsManager,
   Texture: () => Texture,
   TextureView: () => TextureView,
   TransformFeedback: () => TransformFeedback,
   UniformBlock: () => UniformBlock,
   UniformBufferLayout: () => UniformBufferLayout,
   UniformStore: () => UniformStore,
-  VERSION: () => VERSION,
   VertexArray: () => VertexArray,
-  assert: () => assert,
-  cancelAnimationFrame: () => cancelAnimationFrame,
-  cast: () => cast,
-  checkProps: () => checkProps,
   decodeShaderAttributeType: () => decodeShaderAttributeType,
   decodeShaderUniformType: () => decodeShaderUniformType,
   decodeTextureFormat: () => decodeTextureFormat,
   decodeVertexFormat: () => decodeVertexFormat,
-  deepEqual: () => deepEqual,
-  fillArray: () => fillArray,
-  formatCompilerLog: () => formatCompilerLog,
-  formatValue: () => formatValue,
   getAttributeInfosFromLayouts: () => getAttributeInfosFromLayouts,
   getDataTypeFromTypedArray: () => getDataTypeFromTypedArray,
   getScratchArray: () => getScratchArray,
-  getScratchArrayBuffer: () => getScratchArrayBuffer,
   getTypedArrayFromDataType: () => getTypedArrayFromDataType,
   getVertexFormatFromAttribute: () => getVertexFormatFromAttribute,
-  glsl: () => glsl,
-  isNumberArray: () => isNumberArray,
-  isObjectEmpty: () => isObjectEmpty,
-  isTypedArray: () => isTypedArray,
-  isUniformValue: () => isUniformValue,
-  loadFile: () => loadFile,
-  loadImage: () => loadImage,
-  loadImageBitmap: () => loadImageBitmap,
-  loadScript: () => loadScript,
   log: () => log,
-  luma: () => luma,
-  makeRandomNumberGenerator: () => makeRandomNumberGenerator,
-  mergeShaderLayout: () => mergeShaderLayout,
-  random: () => random,
-  requestAnimationFrame: () => requestAnimationFrame,
-  setPathPrefix: () => setPathPrefix,
-  splitUniformsAndBindings: () => splitUniformsAndBindings,
-  stubRemovedMethods: () => stubRemovedMethods,
-  uid: () => uid
+  luma: () => luma
 });
 module.exports = __toCommonJS(dist_exports);
 
-// dist/init.js
-var import_env = require("@probe.gl/env");
-
-// dist/utils/log.js
-var import_log = require("@probe.gl/log");
-var log = new import_log.Log({ id: "luma.gl" });
-
 // dist/utils/stats-manager.js
 var import_stats = require("@probe.gl/stats");
 var StatsManager = class {
@@ -114,56 +80,17 @@ var StatsManager = class {
 };
 var lumaStats = new StatsManager();
 
-// dist/init.js
-function initializeLuma() {
-  const VERSION2 = true ? "9.0.17" : "running from source";
-  const STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering";
-  if (globalThis.luma && globalThis.luma.VERSION !== VERSION2) {
-    throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION2}`);
-  }
-  if (!globalThis.luma) {
-    if ((0, import_env.isBrowser)()) {
-      log.log(1, `${VERSION2} - ${STARTUP_MESSAGE}`)();
-    }
-    globalThis.luma = globalThis.luma || {
-      VERSION: VERSION2,
-      version: VERSION2,
-      log,
-      // A global stats object that various components can add information to
-      // E.g. see webgl/resource.js
-      stats: lumaStats
-    };
-  }
-  return VERSION2;
-}
-var VERSION = initializeLuma();
-
-// dist/utils/is-array.js
-function isTypedArray(value) {
-  return ArrayBuffer.isView(value) && !(value instanceof DataView) ? value : null;
-}
-function isNumberArray(value) {
-  if (Array.isArray(value)) {
-    return value.length === 0 || typeof value[0] === "number" ? value : null;
-  }
-  return isTypedArray(value);
-}
+// dist/utils/log.js
+var import_log = require("@probe.gl/log");
+var log = new import_log.Log({ id: "luma.gl" });
 
-// dist/utils/utils.js
+// dist/utils/uid.js
 var uidCounters = {};
 function uid(id = "id") {
   uidCounters[id] = uidCounters[id] || 1;
   const count = uidCounters[id]++;
   return `${id}-${count}`;
 }
-function isObjectEmpty(obj) {
-  let isEmpty = true;
-  for (const key in obj) {
-    isEmpty = false;
-    break;
-  }
-  return isEmpty;
-}
 
 // dist/adapter/resources/resource.js
 var Resource = class {
@@ -328,14 +255,14 @@ var _Buffer = class extends Resource {
   debugData = new ArrayBuffer(0);
   /** This doesn't handle partial non-zero offset updates correctly */
   _setDebugData(data, byteOffset, byteLength) {
-    const buffer = ArrayBuffer.isView(data) ? data.buffer : data;
+    const arrayBuffer2 = ArrayBuffer.isView(data) ? data.buffer : data;
     const debugDataLength = Math.min(data ? data.byteLength : byteLength, _Buffer.DEBUG_DATA_MAX_LENGTH);
-    if (data === null) {
+    if (arrayBuffer2 === null) {
       this.debugData = new ArrayBuffer(debugDataLength);
-    } else if (byteOffset === 0 && byteLength === data.byteLength) {
-      this.debugData = buffer.slice(0, debugDataLength);
+    } else if (byteOffset === 0 && byteLength === arrayBuffer2.byteLength) {
+      this.debugData = arrayBuffer2.slice(0, debugDataLength);
     } else {
-      this.debugData = buffer.slice(byteOffset, byteOffset + debugDataLength);
+      this.debugData = arrayBuffer2.slice(byteOffset, byteOffset + debugDataLength);
     }
   }
 };
@@ -369,7 +296,7 @@ __publicField(Buffer2, "QUERY_RESOLVE", 512);
 /** Max amount of debug data saved. Two vec4's */
 __publicField(Buffer2, "DEBUG_DATA_MAX_LENGTH", 32);
 
-// dist/adapter/type-utils/decode-data-type.js
+// dist/gpu-type-utils/decode-data-type.js
 function decodeVertexType(type) {
   const dataType = TYPE_MAP[type];
   const bytes = getDataTypeBytes(dataType);
@@ -413,7 +340,7 @@ var TYPE_SIZES = {
   sint32: 4
 };
 
-// dist/adapter/type-utils/decode-texture-format.js
+// dist/gpu-type-utils/decode-texture-format.js
 var COMPRESSED_TEXTURE_FORMAT_PREFIXES = [
   "bc1",
   "bc2",
@@ -429,64 +356,98 @@ var COMPRESSED_TEXTURE_FORMAT_PREFIXES = [
   "astc",
   "pvrtc"
 ];
-var REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/;
+var REGEX = /^(r|rg|rgb|rgba|bgra)([0-9]*)([a-z]*)(-srgb)?(-webgl)?$/;
 function isTextureFormatCompressed(textureFormat) {
   return COMPRESSED_TEXTURE_FORMAT_PREFIXES.some((prefix) => textureFormat.startsWith(prefix));
 }
 function decodeTextureFormat(format) {
   const matches = REGEX.exec(format);
   if (matches) {
-    const [, format2, length, type, srgb, suffix] = matches;
-    if (format2) {
+    const [, channels, length, type, srgb, suffix] = matches;
+    if (format) {
       const dataType = `${type}${length}`;
       const decodedType = decodeVertexType(dataType);
-      return {
-        format: format2,
-        components: format2.length,
-        // dataType - overwritten by decodedType
-        srgb: srgb === "-srgb",
-        unsized: suffix === "-unsized",
-        webgl: suffix === "-webgl",
-        ...decodedType
+      const info = {
+        channels,
+        components: channels.length,
+        bitsPerChannel: decodedType.byteLength * 8,
+        bytesPerPixel: decodedType.byteLength * channels.length,
+        dataType: decodedType.dataType,
+        integer: decodedType.integer,
+        signed: decodedType.signed,
+        normalized: decodedType.normalized
       };
+      if (suffix === "-webgl") {
+        info.webgl = true;
+      }
+      if (srgb === "-srgb") {
+        info.srgb = true;
+      }
+      return info;
     }
   }
   return decodeNonStandardFormat(format);
 }
 var EXCEPTIONS = {
   // Packed 16 bit formats
-  "rgba4unorm-webgl": { format: "rgba", bpp: 2 },
-  "rgb565unorm-webgl": { format: "rgb", bpp: 2 },
-  "rgb5a1unorm-webgl": { format: "rgba", bbp: 2 },
+  "rgba4unorm-webgl": { channels: "rgba", bytesPerPixel: 2, packed: true },
+  "rgb565unorm-webgl": { channels: "rgb", bytesPerPixel: 2, packed: true },
+  "rgb5a1unorm-webgl": { channels: "rgba", bytesPerPixel: 2, packed: true },
   // Packed 32 bit formats
-  rgb9e5ufloat: { format: "rgb", bbp: 4 },
-  rg11b10ufloat: { format: "rgb", bbp: 4 },
-  rgb10a2unorm: { format: "rgba", bbp: 4 },
-  "rgb10a2uint-webgl": { format: "rgba", bbp: 4 },
+  rgb9e5ufloat: { channels: "rgb", bytesPerPixel: 4, packed: true },
+  rg11b10ufloat: { channels: "rgb", bytesPerPixel: 4, packed: true },
+  rgb10a2unorm: { channels: "rgba", bytesPerPixel: 4, packed: true },
+  "rgb10a2uint-webgl": { channels: "rgba", bytesPerPixel: 4, packed: true },
   // Depth/stencil
-  stencil8: { components: 1, bpp: 1, a: "stencil" },
-  depth16unorm: { components: 1, bpp: 2, a: "depth" },
-  depth24plus: { components: 1, bpp: 3, a: "depth" },
-  depth32float: { components: 1, bpp: 4, a: "depth" },
-  "depth24plus-stencil8": { components: 2, bpp: 4, a: "depth-stencil" },
-  // "depth24unorm-stencil8" feature
-  "depth24unorm-stencil8": { components: 2, bpp: 4, a: "depth-stencil" },
+  stencil8: { components: 1, bytesPerPixel: 1, a: "stencil", dataType: "uint8" },
+  depth16unorm: { components: 1, bytesPerPixel: 2, a: "depth", dataType: "uint16" },
+  depth24plus: { components: 1, bytesPerPixel: 3, a: "depth", dataType: "uint32" },
+  depth32float: { components: 1, bytesPerPixel: 4, a: "depth", dataType: "float32" },
+  "depth24plus-stencil8": { components: 2, bytesPerPixel: 4, a: "depth-stencil", packed: true },
   // "depth32float-stencil8" feature
-  "depth32float-stencil8": { components: 2, bpp: 4, a: "depth-stencil" }
+  "depth32float-stencil8": { components: 2, bytesPerPixel: 4, a: "depth-stencil", packed: true }
 };
 function decodeNonStandardFormat(format) {
   var _a;
+  if (isTextureFormatCompressed(format)) {
+    const info2 = {
+      channels: "rgb",
+      components: 3,
+      bytesPerPixel: 1,
+      srgb: false,
+      compressed: true
+    };
+    const blockSize = getCompressedTextureBlockSize(format);
+    if (blockSize) {
+      info2.blockWidth = blockSize.blockWidth;
+      info2.blockHeight = blockSize.blockHeight;
+    }
+    return info2;
+  }
   const data = EXCEPTIONS[format];
   if (!data) {
     throw new Error(`Unknown format ${format}`);
   }
-  return {
-    format: data.format || "",
-    components: data.components || ((_a = data.format) == null ? void 0 : _a.length) || 1,
-    byteLength: data.bpp || 1,
-    srgb: false,
-    unsized: false
+  const info = {
+    ...data,
+    channels: data.channels || "",
+    components: data.components || ((_a = data.channels) == null ? void 0 : _a.length) || 1,
+    bytesPerPixel: data.bytesPerPixel || 1,
+    srgb: false
   };
+  if (data.packed) {
+    info.packed = data.packed;
+  }
+  return info;
+}
+function getCompressedTextureBlockSize(format) {
+  const REGEX2 = /.*-(\d+)x(\d+)-.*/;
+  const matches = REGEX2.exec(format);
+  if (matches) {
+    const [, blockWidth, blockHeight] = matches;
+    return { blockWidth: Number(blockWidth), blockHeight: Number(blockHeight) };
+  }
+  return null;
 }
 
 // dist/adapter/device.js
@@ -503,7 +464,8 @@ var DeviceFeatures = class {
     yield* this.features;
   }
   has(feature) {
-    return !this.disabledFeatures[feature] && this.features.has(feature);
+    var _a;
+    return !((_a = this.disabledFeatures) == null ? void 0 : _a[feature]) && this.features.has(feature);
   }
 };
 var _Device = class {
@@ -536,6 +498,10 @@ var _Device = class {
   loseDevice() {
     return false;
   }
+  /** Report error (normally for unhandled device errors) */
+  error(error) {
+    this.props.onError(error);
+  }
   /** Returns the default / primary canvas context. Throws an error if no canvas context is available (a WebGPU compute device) */
   getCanvasContext() {
     if (!this.canvasContext) {
@@ -543,10 +509,8 @@ var _Device = class {
     }
     return this.canvasContext;
   }
+  // createTexture(data: Promise<TextureData>): Texture;
   createTexture(props) {
-    if (props instanceof Promise || typeof props === "string") {
-      props = { data: props };
-    }
     return this._createTexture(props);
   }
   createCommandEncoder(props = {}) {
@@ -620,16 +584,9 @@ __publicField(Device, "defaultProps", {
   // width are height are only used by headless gl
   height: 600,
   requestMaxLimits: true,
-  debug: Boolean(log.get("debug")),
-  // Instrument context (at the expense of performance)
-  spector: Boolean(log.get("spector") || log.get("spectorjs")),
-  // Initialize the SpectorJS WebGL debugger
-  break: [],
-  // TODO - Change these after confirming things work as expected
-  initalizeFeatures: true,
-  disabledFeatures: {
-    "compilation-status-async-webgl": true
-  },
+  // Callbacks
+  onError: (error) => log.error(error.message),
+  gl: null,
   // alpha: undefined,
   // depth: undefined,
   // stencil: undefined,
@@ -637,134 +594,165 @@ __publicField(Device, "defaultProps", {
   // premultipliedAlpha: undefined,
   // preserveDrawingBuffer: undefined,
   // failIfMajorPerformanceCaveat: undefined
-  gl: null,
-  // Callbacks
-  onError: (error) => log.error(error.message)
+  debug: Boolean(log.get("debug")),
+  // Instrument context (at the expense of performance)
+  break: log.get("break") || [],
+  // WebGL specific debugging
+  debugWithSpectorJS: void 0,
+  spectorUrl: void 0,
+  // TODO - Change these after confirming things work as expected
+  initalizeFeatures: true,
+  disabledFeatures: {
+    "compilation-status-async-webgl": true
+  },
+  _factoryDestroyPolicy: "unused"
 });
-__publicField(Device, "VERSION", VERSION);
 
-// dist/utils/assert.js
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || "luma.gl: assertion failed.");
+// dist/adapter/luma.js
+var STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering";
+var ERROR_MESSAGE = "No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.";
+var _Luma = class {
+  /** Global stats for all devices */
+  stats = lumaStats;
+  /**
+   * Global log
+   *
+   * Assign luma.log.level in console to control logging: \
+   * 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs
+   * luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;
+   */
+  log = log;
+  /** Version of luma.gl */
+  VERSION = (
+    // Version detection using build plugin
+    // @ts-expect-error no-undef
+    true ? "9.1.0-alpha.10" : "running from source"
+  );
+  spector;
+  preregisteredAdapters = /* @__PURE__ */ new Map();
+  constructor() {
+    if (globalThis.luma) {
+      if (globalThis.luma.VERSION !== this.VERSION) {
+        log.error(`Found luma.gl ${globalThis.luma.VERSION} while initialzing ${this.VERSION}`)();
+        log.error(`'yarn why @luma.gl/core' can help identify the source of the conflict`)();
+        throw new Error(`luma.gl - multiple versions detected: see console log`);
+      }
+      log.error("This version of luma.gl has already been initialized")();
+    }
+    log.log(1, `${this.VERSION} - ${STARTUP_MESSAGE}`)();
+    globalThis.luma = this;
   }
-}
-
-// dist/lib/luma.js
-var deviceMap = /* @__PURE__ */ new Map();
-var _luma = class {
-  static registerDevices(deviceClasses) {
-    for (const deviceClass of deviceClasses) {
-      assert(deviceClass.type && deviceClass.isSupported && deviceClass.create);
-      deviceMap.set(deviceClass.type, deviceClass);
+  registerAdapters(adapters) {
+    for (const deviceClass of adapters) {
+      this.preregisteredAdapters.set(deviceClass.type, deviceClass);
     }
   }
-  static getAvailableDevices() {
-    return Array.from(deviceMap).map((Device2) => Device2.type);
+  /** Get type strings for supported Devices */
+  getSupportedAdapters(adapters = []) {
+    const adapterMap = this.getAdapterMap(adapters);
+    return Array.from(adapterMap).map(([, adapter]) => adapter).filter((adapter) => {
+      var _a;
+      return (_a = adapter.isSupported) == null ? void 0 : _a.call(adapter);
+    }).map((adapter) => adapter.type);
   }
-  static getSupportedDevices() {
-    return Array.from(deviceMap).filter((Device2) => Device2.isSupported()).map((Device2) => Device2.type);
+  /** Get type strings for best available Device */
+  getBestAvailableAdapter(adapters = []) {
+    var _a, _b, _c, _d;
+    const adapterMap = this.getAdapterMap(adapters);
+    if ((_b = (_a = adapterMap.get("webgpu")) == null ? void 0 : _a.isSupported) == null ? void 0 : _b.call(_a)) {
+      return "webgpu";
+    }
+    if ((_d = (_c = adapterMap.get("webgl")) == null ? void 0 : _c.isSupported) == null ? void 0 : _d.call(_c)) {
+      return "webgl";
+    }
+    return null;
   }
-  static setDefaultDeviceProps(props) {
-    Object.assign(Device.defaultProps, props);
+  setDefaultDeviceProps(props) {
+    Object.assign(_Luma.defaultProps, props);
+  }
+  /** Creates a device. Asynchronously. */
+  async createDevice(props = {}) {
+    var _a;
+    props = { ..._Luma.defaultProps, ...props };
+    const adapterMap = this.getAdapterMap(props.adapters);
+    let type = props.type || "";
+    if (type === "best-available") {
+      type = this.getBestAvailableAdapter(props.adapters) || type;
+    }
+    const adapters = this.getAdapterMap(props.adapters) || adapterMap;
+    const adapter = adapters.get(type);
+    const device = await ((_a = adapter == null ? void 0 : adapter.create) == null ? void 0 : _a.call(adapter, props));
+    if (device) {
+      return device;
+    }
+    throw new Error(ERROR_MESSAGE);
   }
   /** Attach to an existing GPU API handle (WebGL2RenderingContext or GPUDevice). */
-  static async attachDevice(props) {
-    const devices = getDeviceMap(props.devices) || deviceMap;
+  async attachDevice(props) {
+    var _a;
+    const adapters = this.getAdapterMap(props.adapters);
+    let type = "";
     if (props.handle instanceof WebGL2RenderingContext) {
-      const WebGLDevice = devices.get("webgl");
-      if (WebGLDevice) {
-        return await WebGLDevice.attach(props.handle);
-      }
+      type = "webgl";
     }
     if (props.handle === null) {
-      const UnknownDevice = devices.get("unknown");
-      if (UnknownDevice) {
-        return await UnknownDevice.attach(null);
-      }
+      type = "unknown";
     }
-    throw new Error("Failed to attach device. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.");
+    const adapter = adapters.get(type);
+    const device = await ((_a = adapter == null ? void 0 : adapter.attach) == null ? void 0 : _a.call(adapter, null));
+    if (device) {
+      return device;
+    }
+    throw new Error(ERROR_MESSAGE);
   }
-  /** Creates a device. Asynchronously. */
-  static async createDevice(props = {}) {
-    var _a, _b;
-    props = { ..._luma.defaultProps, ...props };
-    if (props.gl) {
-      props.type = "webgl";
-    }
-    const devices = getDeviceMap(props.devices) || deviceMap;
-    switch (props.type) {
-      case "webgpu":
-        let WebGPUDevice = devices.get("webgpu");
-        if (WebGPUDevice) {
-          return await WebGPUDevice.create(props);
-        }
-        break;
-      case "webgl":
-        let WebGLDevice = devices.get("webgl");
-        if (WebGLDevice) {
-          return await WebGLDevice.create(props);
-        }
-        break;
-      case "unknown":
-        const UnknownDevice = devices.get("unknown");
-        if (UnknownDevice) {
-          return await UnknownDevice.create(props);
-        }
-        break;
-      case "best-available":
-        WebGPUDevice = devices.get("webgpu");
-        if ((_a = WebGPUDevice == null ? void 0 : WebGPUDevice.isSupported) == null ? void 0 : _a.call(WebGPUDevice)) {
-          return await WebGPUDevice.create(props);
-        }
-        WebGLDevice = devices.get("webgl");
-        if ((_b = WebGLDevice == null ? void 0 : WebGLDevice.isSupported) == null ? void 0 : _b.call(WebGLDevice)) {
-          return await WebGLDevice.create(props);
-        }
-        break;
+  /**
+   * Override `HTMLCanvasContext.getCanvas()` to always create WebGL2 contexts with additional WebGL1 compatibility.
+   * Useful when attaching luma to a context from an external library does not support creating WebGL2 contexts.
+   */
+  enforceWebGL2(enforce = true, adapters = []) {
+    var _a;
+    const adapterMap = this.getAdapterMap(adapters);
+    const webgl2Adapter = adapterMap.get("webgl");
+    if (!webgl2Adapter) {
+      log.warn("enforceWebGL2: webgl adapter not found")();
     }
-    throw new Error("No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.");
+    (_a = webgl2Adapter == null ? void 0 : webgl2Adapter.enforceWebGL2) == null ? void 0 : _a.call(webgl2Adapter, enforce);
   }
-  static enforceWebGL2(enforce = true) {
-    const prototype = HTMLCanvasElement.prototype;
-    if (!enforce && prototype.originalGetContext) {
-      prototype.getContext = prototype.originalGetContext;
-      prototype.originalGetContext = void 0;
-      return;
+  /** Convert a list of adapters to a map */
+  getAdapterMap(adapters = []) {
+    const map = new Map(this.preregisteredAdapters);
+    for (const adapter of adapters) {
+      map.set(adapter.type, adapter);
     }
-    prototype.originalGetContext = prototype.getContext;
-    prototype.getContext = function(contextId, options) {
-      if (contextId === "webgl" || contextId === "experimental-webgl") {
-        return this.originalGetContext("webgl2", options);
+    return map;
+  }
+  // DEPRECATED
+  /** @deprecated Use registerAdapters */
+  registerDevices(deviceClasses) {
+    log.warn("luma.registerDevices() is deprecated, use luma.registerAdapters() instead");
+    for (const deviceClass of deviceClasses) {
+      const adapter = deviceClass.adapter;
+      if (adapter) {
+        this.preregisteredAdapters.set(adapter.type, adapter);
       }
-      return this.originalGetContext(contextId, options);
-    };
+    }
   }
 };
-var luma = _luma;
-__publicField(luma, "defaultProps", {
+var Luma = _Luma;
+__publicField(Luma, "defaultProps", {
   ...Device.defaultProps,
   type: "best-available",
-  devices: void 0
+  adapters: void 0
 });
-/** Global stats for all devices */
-__publicField(luma, "stats", lumaStats);
-/** Global log */
-__publicField(luma, "log", log);
-function getDeviceMap(deviceClasses) {
-  if (!deviceClasses || (deviceClasses == null ? void 0 : deviceClasses.length) === 0) {
-    return null;
-  }
-  const map = /* @__PURE__ */ new Map();
-  for (const deviceClass of deviceClasses) {
-    map.set(deviceClass.type, deviceClass);
-  }
-  return map;
-}
+var luma = new Luma();
+
+// dist/adapter/adapter.js
+var Adapter = class {
+};
 
 // dist/adapter/canvas-context.js
-var import_env2 = require("@probe.gl/env");
-var isPage = (0, import_env2.isBrowser)() && typeof document !== "undefined";
+var import_env = require("@probe.gl/env");
+var isPage = (0, import_env.isBrowser)() && typeof document !== "undefined";
 var isPageLoaded = () => isPage && document.readyState === "complete";
 var DEFAULT_CANVAS_CONTEXT_PROPS = {
   canvas: null,
@@ -797,7 +785,7 @@ var CanvasContext = class {
   constructor(props) {
     this.props = { ...DEFAULT_CANVAS_CONTEXT_PROPS, ...props };
     props = this.props;
-    if (!(0, import_env2.isBrowser)()) {
+    if (!(0, import_env.isBrowser)()) {
       this.id = "node-canvas-context";
       this.type = "node";
       this.width = this.props.width;
@@ -1051,20 +1039,106 @@ var _Texture = class extends Resource {
   height;
   /** depth of this texture */
   depth;
+  /** mip levels in this texture */
+  mipLevels;
   /** "Time" of last update. Monotonically increasing timestamp */
   updateTimestamp;
+  /** Check if data is an external image */
+  static isExternalImage(data) {
+    return typeof ImageData !== "undefined" && data instanceof ImageData || typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap || typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement || typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement || typeof VideoFrame !== "undefined" && data instanceof VideoFrame || typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && data instanceof OffscreenCanvas;
+  }
+  /** Determine size (width and height) of provided image data */
+  static getExternalImageSize(data) {
+    if (typeof ImageData !== "undefined" && data instanceof ImageData || typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap || typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && data instanceof OffscreenCanvas) {
+      return { width: data.width, height: data.height };
+    }
+    if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) {
+      return { width: data.naturalWidth, height: data.naturalHeight };
+    }
+    if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) {
+      return { width: data.videoWidth, height: data.videoHeight };
+    }
+    if (typeof VideoFrame !== "undefined" && data instanceof VideoFrame) {
+      return { width: data.displayWidth, height: data.displayHeight };
+    }
+    throw new Error("Unknown image type");
+  }
+  /** Check if texture data is a typed array */
+  static isTextureLevelData(data) {
+    const typedArray = data == null ? void 0 : data.data;
+    return ArrayBuffer.isView(typedArray);
+  }
+  /** Get the size of the texture described by the provided TextureData */
+  static getTextureDataSize(data) {
+    if (!data) {
+      return null;
+    }
+    if (ArrayBuffer.isView(data)) {
+      return null;
+    }
+    if (Array.isArray(data)) {
+      return _Texture.getTextureDataSize(data[0]);
+    }
+    if (_Texture.isExternalImage(data)) {
+      return _Texture.getExternalImageSize(data);
+    }
+    if (data && typeof data === "object" && data.constructor === Object) {
+      const textureDataArray = Object.values(data);
+      const untypedData = textureDataArray[0];
+      return { width: untypedData.width, height: untypedData.height };
+    }
+    throw new Error("texture size deduction failed");
+  }
+  /** Calculate the number of mip levels for a texture of width and height */
+  static getMipLevelCount(width, height) {
+    return Math.floor(Math.log2(Math.max(width, height))) + 1;
+  }
+  /** Convert luma.gl cubemap face constants to depth index */
+  static getCubeFaceDepth(face) {
+    switch (face) {
+      case "+X":
+        return 0;
+      case "-X":
+        return 1;
+      case "+Y":
+        return 2;
+      case "-Y":
+        return 3;
+      case "+Z":
+        return 4;
+      case "-Z":
+        return 5;
+      default:
+        throw new Error(face);
+    }
+  }
   /** Do not use directly. Create with device.createTexture() */
-  constructor(device, props, defaultProps = _Texture.defaultProps) {
-    super(device, props, defaultProps);
+  constructor(device, props) {
+    super(device, props, _Texture.defaultProps);
     this.dimension = this.props.dimension;
     this.format = this.props.format;
     this.width = this.props.width;
     this.height = this.props.height;
     this.depth = this.props.depth;
+    if (this.props.width === void 0 || this.props.height === void 0) {
+      const size = _Texture.getTextureDataSize(this.props.data);
+      this.width = (size == null ? void 0 : size.width) || 1;
+      this.height = (size == null ? void 0 : size.height) || 1;
+    }
+    if (this.props.mipmaps && this.props.mipLevels === void 0) {
+      this.props.mipLevels = "pyramid";
+    }
+    this.mipLevels = this.props.mipLevels === "pyramid" ? _Texture.getMipLevelCount(this.width, this.height) : this.props.mipLevels || 1;
     this.updateTimestamp = device.incrementTimestamp();
   }
 };
 var Texture = _Texture;
+__publicField(Texture, "COPY_SRC", 1);
+__publicField(Texture, "COPY_DST", 2);
+__publicField(Texture, "TEXTURE", 4);
+__publicField(Texture, "STORAGE", 8);
+__publicField(Texture, "RENDER_ATTACHMENT", 16);
+__publicField(Texture, "CubeFaces", ["+X", "-X", "+Y", "-Y", "+Z", "-Z"]);
 __publicField(Texture, "defaultProps", {
   ...Resource.defaultProps,
   data: null,
@@ -1073,23 +1147,30 @@ __publicField(Texture, "defaultProps", {
   width: void 0,
   height: void 0,
   depth: 1,
-  mipmaps: true,
-  // type: undefined,
+  mipmaps: false,
   compressed: false,
-  // mipLevels: 1,
   usage: 0,
-  // usage: GPUTextureUsage.COPY_DST
   mipLevels: void 0,
   samples: void 0,
-  type: void 0,
   sampler: {},
   view: void 0
 });
-__publicField(Texture, "COPY_SRC", 1);
-__publicField(Texture, "COPY_DST", 2);
-__publicField(Texture, "TEXTURE_BINDING", 4);
-__publicField(Texture, "STORAGE_BINDING", 8);
-__publicField(Texture, "RENDER_ATTACHMENT", 16);
+/** Default options */
+__publicField(Texture, "defaultCopyExternalImageOptions", {
+  image: void 0,
+  sourceX: 0,
+  sourceY: 0,
+  width: void 0,
+  height: void 0,
+  depth: 1,
+  mipLevel: 0,
+  x: 0,
+  y: 0,
+  z: 0,
+  aspect: "all",
+  colorSpace: "srgb",
+  premultipliedAlpha: false
+});
 
 // dist/adapter/resources/texture-view.js
 var _TextureView = class extends Resource {
@@ -1125,11 +1206,11 @@ var _ExternalTexture = class extends Resource {
 var ExternalTexture = _ExternalTexture;
 __publicField(ExternalTexture, "defaultProps", {
   ...Resource.defaultProps,
-  source: null,
+  source: void 0,
   colorSpace: "srgb"
 });
 
-// dist/lib/compiler-log/format-compiler-log.js
+// dist/adapter-utils/format-compiler-log.js
 function formatCompilerLog(shaderLog, source, options) {
   let formattedLog = "";
   const lines = source.split(/\r?\n/);
@@ -1195,31 +1276,6 @@ function escapeHTML(unsafe) {
   return unsafe.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#039;");
 }
 
-// dist/lib/compiler-log/get-shader-info.js
-function getShaderInfo(source, defaultName) {
-  return {
-    name: getShaderName(source, defaultName),
-    language: "glsl",
-    version: getShaderVersion(source)
-  };
-}
-function getShaderName(shader, defaultName = "unnamed") {
-  const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
-  const match = SHADER_NAME_REGEXP.exec(shader);
-  return match ? match[1] : defaultName;
-}
-function getShaderVersion(source) {
-  let version = 100;
-  const words = source.match(/[^\s]+/g);
-  if (words && words.length >= 2 && words[0] === "#version") {
-    const v = parseInt(words[1], 10);
-    if (Number.isFinite(v)) {
-      version = v;
-    }
-  }
-  return version;
-}
-
 // dist/adapter/resources/shader.js
 var _Shader = class extends Resource {
   get [Symbol.toStringTag]() {
@@ -1267,13 +1323,16 @@ var _Shader = class extends Resource {
     this._displayShaderLog(messages);
   }
   // PRIVATE
-  /** In-browser UI logging of errors */
+  /**
+   * In-browser UI logging of errors
+   * TODO - this HTML formatting code should not be in Device, should be pluggable
+   */
   _displayShaderLog(messages) {
     var _a;
     if (typeof document === "undefined" || !(document == null ? void 0 : document.createElement)) {
       return;
     }
-    const shaderName = getShaderInfo(this.source).name;
+    const shaderName = getShaderName(this.source);
     const shaderTitle = `${this.stage} ${shaderName}`;
     let htmlLog = formatCompilerLog(messages, this.source, { showSourceCode: "all", html: true });
     const translatedSource = this.getTranslatedSource();
@@ -1294,9 +1353,7 @@ ${htmlLog}
     button.style.textAlign = "left";
     document.body.appendChild(button);
     const errors = document.getElementsByClassName("luma-compiler-log-error");
-    if ((_a = errors[0]) == null ? void 0 : _a.scrollIntoView) {
-      errors[0].scrollIntoView();
-    }
+    (_a = errors[0]) == null ? void 0 : _a.scrollIntoView();
     button.onclick = () => {
       const dataURI = `data:text/plain,${encodeURIComponent(this.source)}`;
       navigator.clipboard.writeText(dataURI);
@@ -1314,7 +1371,12 @@ __publicField(Shader, "defaultProps", {
   debug: "errors"
 });
 function getShaderIdFromProps(props) {
-  return getShaderInfo(props.source).name || props.id || uid(`unnamed ${props.stage}-shader`);
+  return getShaderName(props.source) || props.id || uid(`unnamed ${props.stage}-shader`);
+}
+function getShaderName(shader, defaultName = "unnamed") {
+  const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
+  const match = SHADER_NAME_REGEXP.exec(shader);
+  return match ? match[1] : defaultName;
 }
 
 // dist/adapter/resources/sampler.js
@@ -1352,10 +1414,6 @@ var _Framebuffer = class extends Resource {
   width;
   /** Height of all attachments in this framebuffer */
   height;
-  /** Color attachments */
-  colorAttachments = [];
-  /** Depth-stencil attachment, if provided */
-  depthStencilAttachment = null;
   constructor(device, props = {}) {
     super(device, props, _Framebuffer.defaultProps);
     this.width = this.props.width;
@@ -1432,7 +1490,7 @@ var _Framebuffer = class extends Resource {
     for (let i = 0; i < this.colorAttachments.length; ++i) {
       if (this.colorAttachments[i]) {
         const resizedTexture = this.device._createTexture({
-          ...this.colorAttachments[i].props,
+          ...this.colorAttachments[i].texture.props,
           width,
           height
         });
@@ -1443,7 +1501,7 @@ var _Framebuffer = class extends Resource {
     }
     if (this.depthStencilAttachment) {
       const resizedTexture = this.device._createTexture({
-        ...this.depthStencilAttachment.props,
+        ...this.depthStencilAttachment.texture.props,
         width,
         height
       });
@@ -1546,8 +1604,11 @@ var _ComputePipeline = class extends Resource {
     return "ComputePipeline";
   }
   hash = "";
+  /** The merged shader layout */
+  shaderLayout;
   constructor(device, props) {
     super(device, props, _ComputePipeline.defaultProps);
+    this.shaderLayout = props.shaderLayout;
   }
 };
 var ComputePipeline = _ComputePipeline;
@@ -1605,7 +1666,7 @@ __publicField(CommandBuffer, "defaultProps", {
   ...Resource.defaultProps
 });
 
-// dist/adapter/type-utils/decode-attribute-type.js
+// dist/gpu-type-utils/decode-attribute-type.js
 function decodeShaderAttributeType(attributeType) {
   const [dataType, components] = TYPE_INFO[attributeType];
   const integer = dataType === "i32" || dataType === "u32";
@@ -1667,7 +1728,7 @@ var TYPE_SIZES2 = {
   // 'bool-webgl': 4,
 };
 
-// dist/adapter/type-utils/decode-vertex-format.js
+// dist/gpu-type-utils/decode-vertex-format.js
 function decodeVertexFormat(format) {
   let webglOnly;
   if (format.endsWith("-webgl")) {
@@ -1692,11 +1753,14 @@ function decodeVertexFormat(format) {
   return result;
 }
 
-// dist/adapter/attribute-utils/get-attribute-from-layouts.js
+// dist/adapter-utils/get-attribute-from-layouts.js
 function getAttributeInfosFromLayouts(shaderLayout, bufferLayout) {
   const attributeInfos = {};
   for (const attribute of shaderLayout.attributes) {
-    attributeInfos[attribute.name] = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name);
+    const attributeInfo = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name);
+    if (attributeInfo) {
+      attributeInfos[attribute.name] = attributeInfo;
+    }
   }
   return attributeInfos;
 }
@@ -1731,7 +1795,7 @@ function getAttributeInfoFromLayouts(shaderLayout, bufferLayout, name2) {
     normalized: vertexFormatInfo.normalized,
     // integer is a property of the shader declaration
     integer: attributeTypeInfo.integer,
-    stepMode: (bufferMapping == null ? void 0 : bufferMapping.stepMode) || shaderDeclaration.stepMode,
+    stepMode: (bufferMapping == null ? void 0 : bufferMapping.stepMode) || shaderDeclaration.stepMode || "vertex",
     byteOffset: (bufferMapping == null ? void 0 : bufferMapping.byteOffset) || 0,
     byteStride: (bufferMapping == null ? void 0 : bufferMapping.byteStride) || 0
   };
@@ -1797,28 +1861,13 @@ function getAttributeFromAttributesList(bufferLayouts, name2) {
         stepMode: bufferLayout.stepMode,
         vertexFormat: attributeMapping.format,
         byteOffset: attributeMapping.byteOffset,
+        // @ts-ignore
         byteStride
       };
     }
   }
   return null;
 }
-function mergeShaderLayout(baseLayout, overrideLayout) {
-  const mergedLayout = {
-    ...baseLayout,
-    attributes: baseLayout.attributes.map((attribute) => ({ ...attribute }))
-  };
-  for (const attribute of (overrideLayout == null ? void 0 : overrideLayout.attributes) || []) {
-    const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
-    if (!baseAttribute) {
-      log.warn(`shader layout attribute ${attribute.name} not present in shader`);
-    } else {
-      baseAttribute.type = attribute.type || baseAttribute.type;
-      baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
-    }
-  }
-  return mergedLayout;
-}
 
 // dist/adapter/resources/vertex-array.js
 var _VertexArray = class extends Resource {
@@ -1837,7 +1886,11 @@ var _VertexArray = class extends Resource {
     super(device, props, _VertexArray.defaultProps);
     this.maxVertexAttributes = device.limits.maxVertexAttributes;
     this.attributes = new Array(this.maxVertexAttributes).fill(null);
-    this.attributeInfos = getAttributeInfosByLocation(props.renderPipeline.shaderLayout, props.renderPipeline.bufferLayout, this.maxVertexAttributes);
+    const { shaderLayout, bufferLayout } = props.renderPipeline || {};
+    if (!shaderLayout || !bufferLayout) {
+      throw new Error("VertexArray");
+    }
+    this.attributeInfos = getAttributeInfosByLocation(shaderLayout, bufferLayout, this.maxVertexAttributes);
   }
   // DEPRECATED METHODS
   /** @deprecated Set constant attributes (WebGL only) */
@@ -1883,7 +1936,7 @@ __publicField(QuerySet, "defaultProps", {
   count: void 0
 });
 
-// dist/adapter/type-utils/decode-shader-types.js
+// dist/gpu-type-utils/decode-shader-types.js
 var UNIFORM_FORMATS = {
   f32: { type: "f32", components: 1 },
   i32: { type: "i32", components: 1 },
@@ -1910,7 +1963,6 @@ var UNIFORM_FORMATS = {
 };
 function decodeShaderUniformType(format) {
   const decoded = UNIFORM_FORMATS[format];
-  assert(format);
   return decoded;
 }
 function alignTo(size, count) {
@@ -1936,27 +1988,19 @@ function getScratchArray(Type, length) {
   const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
   return new Type(scratchArrayBuffer, 0, length);
 }
-function fillArray(options) {
-  const { target, source, start = 0, count = 1 } = options;
-  const length = source.length;
-  const total = count * length;
-  let copied = 0;
-  for (let i = start; copied < length; copied++) {
-    target[i++] = source[copied];
-  }
-  while (copied < total) {
-    if (copied < total - copied) {
-      target.copyWithin(start + copied, start, start + copied);
-      copied *= 2;
-    } else {
-      target.copyWithin(start + copied, start, start + total - copied);
-      copied = total;
-    }
+
+// dist/utils/is-array.js
+function isTypedArray(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function isNumberArray(value) {
+  if (Array.isArray(value)) {
+    return value.length === 0 || typeof value[0] === "number";
   }
-  return options.target;
+  return isTypedArray(value);
 }
 
-// dist/lib/uniforms/uniform-buffer-layout.js
+// dist/portable/uniform-buffer-layout.js
 var minBufferSize = 1024;
 var UniformBufferLayout = class {
   layout = {};
@@ -2003,12 +2047,11 @@ var UniformBufferLayout = class {
         }
         typedArray[offset] = Number(value);
       } else {
-        const numericArray = isNumberArray(value);
-        if (!numericArray) {
+        if (!isNumberArray(value)) {
           log.warn(`Supplied value for multi component / array uniform ${name2} is not a numeric array: ${value}`)();
           continue;
         }
-        typedArray.set(numericArray, offset);
+        typedArray.set(value, offset);
       }
     }
     return new Uint8Array(arrayBuffer2);
@@ -2029,12 +2072,12 @@ function arrayEqual(a, b, limit = 16) {
   if (a !== b) {
     return false;
   }
-  const arrayA = isNumberArray(a);
-  if (!arrayA) {
+  const arrayA = a;
+  const arrayB = b;
+  if (!isNumberArray(arrayA)) {
     return false;
   }
-  const arrayB = isNumberArray(b);
-  if (arrayB && arrayA.length === arrayB.length) {
+  if (isNumberArray(arrayB) && arrayA.length === arrayB.length) {
     for (let i = 0; i < arrayA.length; ++i) {
       if (arrayB[i] !== arrayA[i]) {
         return false;
@@ -2044,14 +2087,13 @@ function arrayEqual(a, b, limit = 16) {
   return true;
 }
 function arrayCopy(a) {
-  const numberArray = isNumberArray(a);
-  if (numberArray) {
-    return numberArray.slice();
+  if (isNumberArray(a)) {
+    return a.slice();
   }
   return a;
 }
 
-// dist/lib/uniforms/uniform-block.js
+// dist/portable/uniform-block.js
 var UniformBlock = class {
   name;
   uniforms = {};
@@ -2061,7 +2103,7 @@ var UniformBlock = class {
   needsRedraw = "initialized";
   constructor(props) {
     var _a;
-    this.name = props == null ? void 0 : props.name;
+    this.name = (props == null ? void 0 : props.name) || "unnamed";
     if ((props == null ? void 0 : props.name) && (props == null ? void 0 : props.shaderLayout)) {
       const binding = (_a = props == null ? void 0 : props.shaderLayout.bindings) == null ? void 0 : _a.find((binding2) => binding2.type === "uniform" && binding2.name === (props == null ? void 0 : props.name));
       if (!binding) {
@@ -2102,7 +2144,7 @@ var UniformBlock = class {
   }
 };
 
-// dist/lib/uniforms/uniform-store.js
+// dist/portable/uniform-store.js
 var UniformStore = class {
   /** Stores the uniform values for each uniform block */
   uniformBlocks = /* @__PURE__ */ new Map();
@@ -2135,19 +2177,22 @@ var UniformStore = class {
    * Makes all properties partial
    */
   setUniforms(uniforms) {
+    var _a;
     for (const [blockName, uniformValues] of Object.entries(uniforms)) {
-      this.uniformBlocks.get(blockName).setUniforms(uniformValues);
+      (_a = this.uniformBlocks.get(blockName)) == null ? void 0 : _a.setUniforms(uniformValues);
     }
     this.updateUniformBuffers();
   }
   /** Get the required minimum length of the uniform buffer */
   getUniformBufferByteLength(uniformBufferName) {
-    return this.uniformBufferLayouts.get(uniformBufferName).byteLength;
+    var _a;
+    return ((_a = this.uniformBufferLayouts.get(uniformBufferName)) == null ? void 0 : _a.byteLength) || 0;
   }
   /** Get formatted binary memory that can be uploaded to a buffer */
   getUniformBufferData(uniformBufferName) {
-    const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms();
-    return this.uniformBufferLayouts.get(uniformBufferName).getData(uniformValues);
+    var _a, _b;
+    const uniformValues = ((_a = this.uniformBlocks.get(uniformBufferName)) == null ? void 0 : _a.getAllUniforms()) || {};
+    return (_b = this.uniformBufferLayouts.get(uniformBufferName)) == null ? void 0 : _b.getData(uniformValues);
   }
   /**
    * Creates an unmanaged uniform buffer (umnanaged means that application is responsible for destroying it)
@@ -2192,22 +2237,23 @@ var UniformStore = class {
   }
   /** Update one uniform buffer. Only updates if values have changed */
   updateUniformBuffer(uniformBufferName) {
+    var _a;
     const uniformBlock = this.uniformBlocks.get(uniformBufferName);
     const uniformBuffer = this.uniformBuffers.get(uniformBufferName);
     let reason = false;
-    if (uniformBuffer && uniformBlock.needsRedraw) {
+    if (uniformBuffer && (uniformBlock == null ? void 0 : uniformBlock.needsRedraw)) {
       reason ||= uniformBlock.needsRedraw;
       const uniformBufferData = this.getUniformBufferData(uniformBufferName);
       const uniformBuffer2 = this.uniformBuffers.get(uniformBufferName);
-      uniformBuffer2.write(uniformBufferData);
-      const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms();
+      uniformBuffer2 == null ? void 0 : uniformBuffer2.write(uniformBufferData);
+      const uniformValues = (_a = this.uniformBlocks.get(uniformBufferName)) == null ? void 0 : _a.getAllUniforms();
       log.log(4, `Writing to uniform buffer ${String(uniformBufferName)}`, uniformBufferData, uniformValues)();
     }
     return reason;
   }
 };
 
-// dist/adapter/type-utils/vertex-format-from-attribute.js
+// dist/gpu-type-utils/vertex-format-from-attribute.js
 function getDataTypeFromTypedArray(arrayOrType) {
   const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
   switch (type) {
@@ -2283,221 +2329,4 @@ function getVertexFormatFromAttribute(typedArray, size, normalized) {
   }
   return `${dataType}x${components}`;
 }
-
-// dist/utils/cast.js
-function cast(value) {
-  return value;
-}
-
-// dist/lib/uniforms/uniform.js
-function isUniformValue(value) {
-  return isNumberArray(value) !== null || typeof value === "number" || typeof value === "boolean";
-}
-function splitUniformsAndBindings(uniforms) {
-  const result = { bindings: {}, uniforms: {} };
-  Object.keys(uniforms).forEach((name2) => {
-    const uniform = uniforms[name2];
-    if (isUniformValue(uniform)) {
-      result.uniforms[name2] = uniform;
-    } else {
-      result.bindings[name2] = uniform;
-    }
-  });
-  return result;
-}
-
-// dist/utils/format-value.js
-function formatArrayValue(v, opts = {}) {
-  const { maxElts = 16, size = 1 } = opts;
-  let string = "[";
-  for (let i = 0; i < v.length && i < maxElts; ++i) {
-    if (i > 0) {
-      string += `,${i % size === 0 ? " " : ""}`;
-    }
-    string += formatValue(v[i], opts);
-  }
-  const terminator = v.length > maxElts ? "..." : "]";
-  return `${string}${terminator}`;
-}
-function formatValue(v, opts = {}) {
-  const EPSILON = 1e-16;
-  const { isInteger = false } = opts;
-  if (Array.isArray(v) || ArrayBuffer.isView(v)) {
-    return formatArrayValue(v, opts);
-  }
-  if (typeof v !== "number") {
-    return String(v);
-  }
-  if (Math.abs(v) < EPSILON) {
-    return isInteger ? "0" : "0.";
-  }
-  if (isInteger) {
-    return v.toFixed(0);
-  }
-  if (Math.abs(v) > 100 && Math.abs(v) < 1e4) {
-    return v.toFixed(0);
-  }
-  const string = v.toPrecision(2);
-  const decimal = string.indexOf(".0");
-  return decimal === string.length - 2 ? string.slice(0, -1) : string;
-}
-
-// dist/utils/stub-methods.js
-function stubRemovedMethods(instance, className, version, methodNames) {
-  const upgradeMessage = `See luma.gl ${version} Upgrade Guide at https://luma.gl/docs/upgrade-guide`;
-  const prototype = Object.getPrototypeOf(instance);
-  methodNames.forEach((methodName) => {
-    if (prototype.methodName) {
-      return;
-    }
-    prototype[methodName] = () => {
-      log.removed(`Calling removed method ${className}.${methodName}: `, upgradeMessage)();
-      throw new Error(methodName);
-    };
-  });
-}
-
-// dist/utils/check-props.js
-function checkProps(className, props, propChecks) {
-  const { removedProps = {}, deprecatedProps = {}, replacedProps = {} } = propChecks;
-  for (const propName in removedProps) {
-    if (propName in props) {
-      const replacementProp = removedProps[propName];
-      const replacement = replacementProp ? `${className}.${removedProps[propName]}` : "N/A";
-      log.removed(`${className}.${propName}`, replacement)();
-    }
-  }
-  for (const propName in deprecatedProps) {
-    if (propName in props) {
-      const replacementProp = deprecatedProps[propName];
-      log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();
-    }
-  }
-  let newProps = null;
-  for (const [propName, replacementProp] of Object.entries(replacedProps)) {
-    if (propName in props) {
-      log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();
-      newProps = newProps || Object.assign({}, props);
-      newProps[replacementProp] = props[propName];
-      delete newProps[propName];
-    }
-  }
-  return newProps || props;
-}
-
-// dist/utils/load-file.js
-var pathPrefix = "";
-function setPathPrefix(prefix) {
-  pathPrefix = prefix;
-}
-async function loadFile(url, options) {
-  url = url.startsWith("http") ? url : pathPrefix + url;
-  const dataType = (options == null ? void 0 : options.dataType) || "text";
-  const response = await fetch(url, options);
-  return await response[dataType]();
-}
-async function loadImageBitmap(url, opts) {
-  const image = new Image();
-  image.crossOrigin = (opts == null ? void 0 : opts.crossOrigin) || "anonymous";
-  image.src = url.startsWith("http") ? url : pathPrefix + url;
-  await image.decode();
-  return await createImageBitmap(image);
-}
-async function loadImage(url, opts) {
-  return await new Promise((resolve, reject) => {
-    try {
-      const image = new Image();
-      image.onload = () => resolve(image);
-      image.onerror = () => reject(new Error(`Could not load image ${url}.`));
-      image.crossOrigin = (opts == null ? void 0 : opts.crossOrigin) || "anonymous";
-      image.src = url.startsWith("http") ? url : pathPrefix + url;
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-async function loadScript(scriptUrl, scriptId) {
-  const head = document.getElementsByTagName("head")[0];
-  if (!head) {
-    throw new Error("loadScript");
-  }
-  const script = document.createElement("script");
-  script.setAttribute("type", "text/javascript");
-  script.setAttribute("src", scriptUrl);
-  if (scriptId) {
-    script.id = scriptId;
-  }
-  return new Promise((resolve, reject) => {
-    script.onload = resolve;
-    script.onerror = (error) => reject(new Error(`Unable to load script '${scriptUrl}': ${error}`));
-    head.appendChild(script);
-  });
-}
-
-// dist/utils/random.js
-function makeRandomNumberGenerator() {
-  let s = 1;
-  let c = 1;
-  return () => {
-    s = Math.sin(c * 17.23);
-    c = Math.cos(s * 27.92);
-    return fract(Math.abs(s * c) * 1432.71);
-  };
-}
-function fract(n) {
-  return n - Math.floor(n);
-}
-var random = makeRandomNumberGenerator();
-
-// dist/utils/deep-equal.js
-function deepEqual(a, b, depth) {
-  if (a === b) {
-    return true;
-  }
-  if (!depth || !a || !b) {
-    return false;
-  }
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b) || a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i], depth - 1)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (Array.isArray(b)) {
-    return false;
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) {
-      return false;
-    }
-    for (const key of aKeys) {
-      if (!b.hasOwnProperty(key)) {
-        return false;
-      }
-      if (!deepEqual(a[key], b[key], depth - 1)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-
-// dist/utils/request-animation-frame.js
-function requestAnimationFrame(callback) {
-  return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1e3 / 60);
-}
-function cancelAnimationFrame(timerId) {
-  return typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame(timerId) : clearTimeout(timerId);
-}
-
-// dist/index.js
-var glsl = (x) => `${x}`;
 //# sourceMappingURL=index.cjs.map