@luma.gl/webgpu 9.0.0-alpha.5 → 9.0.0-alpha.50

package/dist/dist.dev.js

@@ -0,0 +1,2988 @@
+(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 name2 in all)
+      __defProp(target, name2, { get: all[name2], 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, {
+    WebGPUBuffer: () => WebGPUBuffer,
+    WebGPUDevice: () => WebGPUDevice,
+    WebGPUSampler: () => WebGPUSampler,
+    WebGPUShader: () => WebGPUShader,
+    WebGPUTexture: () => WebGPUTexture
+  });
+
+  // ../../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/@probe.gl/env/dist/lib/get-browser.js
+  var window2 = globalThis;
+  function getBrowser(mockUserAgent) {
+    if (!mockUserAgent && !isBrowser()) {
+      return "Node";
+    }
+    if (isElectron(mockUserAgent)) {
+      return "Electron";
+    }
+    const userAgent = mockUserAgent || navigator_.userAgent || "";
+    if (userAgent.indexOf("Edge") > -1) {
+      return "Edge";
+    }
+    const isMSIE = userAgent.indexOf("MSIE ") !== -1;
+    const isTrident = userAgent.indexOf("Trident/") !== -1;
+    if (isMSIE || isTrident) {
+      return "IE";
+    }
+    if (window2.chrome) {
+      return "Chrome";
+    }
+    if (window2.safari) {
+      return "Safari";
+    }
+    if (window2.mozInnerScreenX) {
+      return "Firefox";
+    }
+    return "Unknown";
+  }
+
+  // ../../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";
+      this.storage = void 0;
+      this.id = void 0;
+      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((name2) => key === name2)) {
+          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: ""
+      };
+      this.id = void 0;
+      this.VERSION = VERSION;
+      this._startTs = getHiResTimestamp();
+      this._deltaTs = getHiResTimestamp();
+      this._storage = void 0;
+      this.userData = {};
+      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;
+    }
+  };
+  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"
+  });
+
+  // ../core/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(name2, type) {
+      this.name = void 0;
+      this.type = void 0;
+      this.sampleSize = 1;
+      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;
+      this.name = name2;
+      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) {
+      this.id = void 0;
+      this.stats = {};
+      this.id = options.id;
+      this.stats = {};
+      this._initializeStats(options.stats);
+      Object.seal(this);
+    }
+    get(name2) {
+      let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
+      return this._getOrCreate({
+        name: name2,
+        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: name2,
+        type
+      } = stat;
+      let result = this.stats[name2];
+      if (!result) {
+        if (stat instanceof Stat) {
+          result = stat;
+        } else {
+          result = new Stat(name2, type);
+        }
+        this.stats[name2] = result;
+      }
+      return result;
+    }
+  };
+
+  // ../core/src/lib/utils/stats-manager.ts
+  var StatsManager = class {
+    stats = /* @__PURE__ */ new Map();
+    getStats(name2) {
+      return this.get(name2);
+    }
+    get(name2) {
+      if (!this.stats.has(name2)) {
+        this.stats.set(name2, new Stats({
+          id: name2
+        }));
+      }
+      return this.stats.get(name2);
+    }
+  };
+  var lumaStats = new StatsManager();
+
+  // ../core/src/init.ts
+  function initializeLuma() {
+    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,
+        stats: lumaStats
+      };
+    }
+    return VERSION3;
+  }
+  var VERSION2 = initializeLuma();
+
+  // ../core/src/lib/utils/utils.ts
+  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;
+  }
+
+  // ../core/src/adapter/resources/resource.ts
+  var Resource = class {
+    userData = {};
+    destroyed = false;
+    allocatedBytes = 0;
+    _attachedResources = /* @__PURE__ */ new Set();
+    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() {
+      this.destroyResource();
+    }
+    delete() {
+      this.destroy();
+      return this;
+    }
+    toString() {
+      return `${this[Symbol.toStringTag] || this.constructor.name}(${this.id})`;
+    }
+    getProps() {
+      return this.props;
+    }
+    attachResource(resource) {
+      this._attachedResources.add(resource);
+    }
+    detachResource(resource) {
+      this._attachedResources.delete(resource);
+    }
+    destroyAttachedResource(resource) {
+      if (this._attachedResources.delete(resource)) {
+        resource.destroy();
+      }
+    }
+    destroyAttachedResources() {
+      for (const resource of Object.values(this._attachedResources)) {
+        resource.destroy();
+      }
+      this._attachedResources = /* @__PURE__ */ new Set();
+    }
+    destroyResource() {
+      this.destroyAttachedResources();
+      this.removeStats();
+      this.destroyed = true;
+    }
+    removeStats() {
+      const stats = this._device.statsManager.getStats("Resource Counts");
+      const name2 = this[Symbol.toStringTag];
+      stats.get(`${name2}s Active`).decrementCount();
+    }
+    trackAllocatedMemory(bytes, name2 = this[Symbol.toStringTag]) {
+      const stats = this._device.statsManager.getStats("Resource Counts");
+      stats.get("GPU Memory").addCount(bytes);
+      stats.get(`${name2} Memory`).addCount(bytes);
+      this.allocatedBytes = bytes;
+    }
+    trackDeallocatedMemory(name2 = this[Symbol.toStringTag]) {
+      const stats = this._device.statsManager.getStats("Resource Counts");
+      stats.get("GPU Memory").subtractCount(this.allocatedBytes);
+      stats.get(`${name2} Memory`).subtractCount(this.allocatedBytes);
+      this.allocatedBytes = 0;
+    }
+    addStats() {
+      const stats = this._device.statsManager.getStats("Resource Counts");
+      const name2 = this[Symbol.toStringTag];
+      stats.get("Resources Created").incrementCount();
+      stats.get(`${name2}s Created`).incrementCount();
+      stats.get(`${name2}s Active`).incrementCount();
+    }
+  };
+  __publicField(Resource, "defaultProps", {
+    id: "undefined",
+    handle: void 0,
+    userData: void 0
+  });
+  function selectivelyMerge(props, defaultProps) {
+    const mergedProps = {
+      ...defaultProps
+    };
+    for (const key in props) {
+      if (props[key] !== void 0) {
+        mergedProps[key] = props[key];
+      }
+    }
+    return mergedProps;
+  }
+
+  // ../core/src/adapter/resources/buffer.ts
+  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, _Buffer.defaultProps);
+      this.usage = props.usage || 0;
+      this.indexType = deducedProps.indexType;
+    }
+    write(data, byteOffset) {
+      throw new Error("not implemented");
+    }
+    readAsync(byteOffset, byteLength) {
+      throw new Error("not implemented");
+    }
+    getData() {
+      throw new Error("not implemented");
+    }
+  };
+  var Buffer2 = _Buffer;
+  __publicField(Buffer2, "defaultProps", {
+    ...Resource.defaultProps,
+    usage: 0,
+    byteLength: 0,
+    byteOffset: 0,
+    data: null,
+    indexType: "uint16",
+    mappedAtCreation: false
+  });
+  __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);
+
+  // ../core/src/adapter/device.ts
+  var _Device = class {
+    get [Symbol.toStringTag]() {
+      return "Device";
+    }
+    constructor(props) {
+      this.props = {
+        ..._Device.defaultProps,
+        ...props
+      };
+      this.id = this.props.id || uid(this[Symbol.toStringTag].toLowerCase());
+    }
+    statsManager = lumaStats;
+    userData = {};
+    _lumaData = {};
+    loseDevice() {
+      return false;
+    }
+    getCanvasContext() {
+      if (!this.canvasContext) {
+        throw new Error("Device has no CanvasContext");
+      }
+      return this.canvasContext;
+    }
+    createTexture(props) {
+      if (props instanceof Promise || typeof props === "string") {
+        props = {
+          data: props
+        };
+      }
+      return this._createTexture(props);
+    }
+    createCommandEncoder(props = {}) {
+      throw new Error("not implemented");
+    }
+    _getBufferProps(props) {
+      if (props instanceof ArrayBuffer || ArrayBuffer.isView(props)) {
+        props = {
+          data: props
+        };
+      }
+      const newProps = {
+        ...props
+      };
+      if ((props.usage || 0) & Buffer2.INDEX && !props.indexType) {
+        if (props.data instanceof Uint32Array) {
+          newProps.indexType = "uint32";
+        } else if (props.data instanceof Uint16Array) {
+          newProps.indexType = "uint16";
+        } else {
+          log.warn("indices buffer content must be of integer type")();
+        }
+      }
+      return newProps;
+    }
+  };
+  var Device = _Device;
+  __publicField(Device, "defaultProps", {
+    id: null,
+    type: "best-available",
+    canvas: null,
+    container: null,
+    webgl2: true,
+    webgl1: true,
+    manageState: true,
+    width: 800,
+    height: 600,
+    debug: Boolean(log.get("debug")),
+    break: [],
+    gl: null
+  });
+  __publicField(Device, "VERSION", VERSION2);
+
+  // ../core/src/adapter/canvas-context.ts
+  var isPage = isBrowser() && typeof document !== "undefined";
+  var isPageLoaded = () => isPage && document.readyState === "complete";
+  var DEFAULT_CANVAS_CONTEXT_PROPS = {
+    canvas: null,
+    width: 800,
+    height: 600,
+    useDevicePixels: true,
+    autoResize: true,
+    container: null,
+    visible: true,
+    colorSpace: "srgb",
+    alphaMode: "opaque"
+  };
+  var CanvasContext = class {
+    width = 1;
+    height = 1;
+    _canvasSizeInfo = {
+      clientWidth: 0,
+      clientHeight: 0,
+      devicePixelRatio: 1
+    };
+    static get isPageLoaded() {
+      return isPageLoaded();
+    }
+    constructor(props) {
+      this.props = {
+        ...DEFAULT_CANVAS_CONTEXT_PROPS,
+        ...props
+      };
+      props = this.props;
+      if (!isBrowser()) {
+        this.id = "node-canvas-context";
+        this.type = "node";
+        this.width = this.props.width;
+        this.height = this.props.height;
+        this.canvas = null;
+        return;
+      }
+      if (!props.canvas) {
+        const canvas = createCanvas(props);
+        const container = getContainer(props?.container || null);
+        container.insertBefore(canvas, container.firstChild);
+        this.canvas = canvas;
+        if (!props?.visible) {
+          this.canvas.style.visibility = "hidden";
+        }
+      } else if (typeof props.canvas === "string") {
+        this.canvas = getCanvasFromDOM(props.canvas);
+      } else {
+        this.canvas = props.canvas;
+      }
+      if (this.canvas instanceof HTMLCanvasElement) {
+        this.id = this.canvas.id;
+        this.type = "html-canvas";
+        this.htmlCanvas = this.canvas;
+      } else {
+        this.id = "offscreen-canvas";
+        this.type = "offscreen-canvas";
+        this.offscreenCanvas = this.canvas;
+      }
+      if (this.canvas instanceof HTMLCanvasElement && props.autoResize) {
+        this.resizeObserver = new ResizeObserver((entries) => {
+          for (const entry of entries) {
+            if (entry.target === this.canvas) {
+              this.update();
+            }
+          }
+        });
+        this.resizeObserver.observe(this.canvas);
+      }
+    }
+    getDevicePixelRatio(useDevicePixels) {
+      if (typeof OffscreenCanvas !== "undefined" && this.canvas instanceof OffscreenCanvas) {
+        return 1;
+      }
+      useDevicePixels = useDevicePixels === void 0 ? this.props.useDevicePixels : useDevicePixels;
+      if (!useDevicePixels || useDevicePixels <= 0) {
+        return 1;
+      }
+      if (useDevicePixels === true) {
+        const dpr = typeof window !== "undefined" && window.devicePixelRatio;
+        return dpr || 1;
+      }
+      return useDevicePixels;
+    }
+    getPixelSize() {
+      switch (this.type) {
+        case "node":
+          return [this.width, this.height];
+        case "offscreen-canvas":
+          return [this.canvas.width, this.canvas.height];
+        case "html-canvas":
+          const dpr = this.getDevicePixelRatio();
+          const canvas = this.canvas;
+          return canvas.parentElement ? [canvas.clientWidth * dpr, canvas.clientHeight * dpr] : [this.canvas.width, this.canvas.height];
+        default:
+          throw new Error(this.type);
+      }
+    }
+    getAspect() {
+      const [width, height] = this.getPixelSize();
+      return width / height;
+    }
+    cssToDeviceRatio() {
+      try {
+        const [drawingBufferWidth] = this.getDrawingBufferSize();
+        const {
+          clientWidth
+        } = this._canvasSizeInfo;
+        return clientWidth ? drawingBufferWidth / clientWidth : 1;
+      } catch {
+        return 1;
+      }
+    }
+    cssToDevicePixels(cssPixel, yInvert = true) {
+      const ratio = this.cssToDeviceRatio();
+      const [width, height] = this.getDrawingBufferSize();
+      return scalePixels(cssPixel, ratio, width, height, yInvert);
+    }
+    setDevicePixelRatio(devicePixelRatio, options = {}) {
+      if (!this.htmlCanvas) {
+        return;
+      }
+      let clientWidth = "width" in options ? options.width : this.htmlCanvas.clientWidth;
+      let clientHeight = "height" in options ? options.height : this.htmlCanvas.clientHeight;
+      if (!clientWidth || !clientHeight) {
+        log.log(1, "Canvas clientWidth/clientHeight is 0")();
+        devicePixelRatio = 1;
+        clientWidth = this.htmlCanvas.width || 1;
+        clientHeight = this.htmlCanvas.height || 1;
+      }
+      const cachedSize = this._canvasSizeInfo;
+      if (cachedSize.clientWidth !== clientWidth || cachedSize.clientHeight !== clientHeight || cachedSize.devicePixelRatio !== devicePixelRatio) {
+        let clampedPixelRatio = devicePixelRatio;
+        const canvasWidth = Math.floor(clientWidth * clampedPixelRatio);
+        const canvasHeight = Math.floor(clientHeight * clampedPixelRatio);
+        this.htmlCanvas.width = canvasWidth;
+        this.htmlCanvas.height = canvasHeight;
+        const [drawingBufferWidth, drawingBufferHeight] = this.getDrawingBufferSize();
+        if (drawingBufferWidth !== canvasWidth || drawingBufferHeight !== canvasHeight) {
+          clampedPixelRatio = Math.min(drawingBufferWidth / clientWidth, drawingBufferHeight / clientHeight);
+          this.htmlCanvas.width = Math.floor(clientWidth * clampedPixelRatio);
+          this.htmlCanvas.height = Math.floor(clientHeight * clampedPixelRatio);
+          log.warn("Device pixel ratio clamped")();
+        }
+        this._canvasSizeInfo.clientWidth = clientWidth;
+        this._canvasSizeInfo.clientHeight = clientHeight;
+        this._canvasSizeInfo.devicePixelRatio = devicePixelRatio;
+      }
+    }
+    getDrawingBufferSize() {
+      const gl = this.device.gl;
+      if (!gl) {
+        throw new Error("canvas size");
+      }
+      return [gl.drawingBufferWidth, gl.drawingBufferHeight];
+    }
+    _setAutoCreatedCanvasId(id) {
+      if (this.htmlCanvas?.id === "lumagl-auto-created-canvas") {
+        this.htmlCanvas.id = id;
+      }
+    }
+  };
+  __publicField(CanvasContext, "pageLoaded", getPageLoadPromise());
+  function getPageLoadPromise() {
+    if (isPageLoaded() || typeof window === "undefined") {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      window.addEventListener("load", () => resolve());
+    });
+  }
+  function getContainer(container) {
+    if (typeof container === "string") {
+      const element = document.getElementById(container);
+      if (!element && !isPageLoaded()) {
+        throw new Error(`Accessing '${container}' before page was loaded`);
+      }
+      if (!element) {
+        throw new Error(`${container} is not an HTML element`);
+      }
+      return element;
+    } else if (container) {
+      return container;
+    }
+    return document.body;
+  }
+  function getCanvasFromDOM(canvasId) {
+    const canvas = document.getElementById(canvasId);
+    if (!canvas && !isPageLoaded()) {
+      throw new Error(`Accessing '${canvasId}' before page was loaded`);
+    }
+    if (!(canvas instanceof HTMLCanvasElement)) {
+      throw new Error("Object is not a canvas element");
+    }
+    return canvas;
+  }
+  function createCanvas(props) {
+    const {
+      width,
+      height
+    } = props;
+    const targetCanvas = document.createElement("canvas");
+    targetCanvas.id = "lumagl-auto-created-canvas";
+    targetCanvas.width = width || 1;
+    targetCanvas.height = height || 1;
+    targetCanvas.style.width = Number.isFinite(width) ? `${width}px` : "100%";
+    targetCanvas.style.height = Number.isFinite(height) ? `${height}px` : "100%";
+    return targetCanvas;
+  }
+  function scalePixels(pixel, ratio, width, height, yInvert) {
+    const point = pixel;
+    const x = scaleX(point[0], ratio, width);
+    let y = scaleY(point[1], ratio, height, yInvert);
+    let t = scaleX(point[0] + 1, ratio, width);
+    const xHigh = t === width - 1 ? t : t - 1;
+    t = scaleY(point[1] + 1, ratio, height, yInvert);
+    let yHigh;
+    if (yInvert) {
+      t = t === 0 ? t : t + 1;
+      yHigh = y;
+      y = t;
+    } else {
+      yHigh = t === height - 1 ? t : t - 1;
+    }
+    return {
+      x,
+      y,
+      width: Math.max(xHigh - x + 1, 1),
+      height: Math.max(yHigh - y + 1, 1)
+    };
+  }
+  function scaleX(x, ratio, width) {
+    const r = Math.min(Math.round(x * ratio), width - 1);
+    return r;
+  }
+  function scaleY(y, ratio, height, yInvert) {
+    return yInvert ? Math.max(0, height - 1 - Math.round(y * ratio)) : Math.min(Math.round(y * ratio), height - 1);
+  }
+
+  // ../core/src/adapter/resources/texture.ts
+  var _Texture = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "Texture";
+    }
+    constructor(device, props, defaultProps = _Texture.defaultProps) {
+      super(device, props, 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;
+    }
+  };
+  var Texture = _Texture;
+  __publicField(Texture, "defaultProps", {
+    ...Resource.defaultProps,
+    data: null,
+    dimension: "2d",
+    format: "rgba8unorm",
+    width: void 0,
+    height: void 0,
+    depth: 1,
+    mipmaps: true,
+    sampler: {},
+    compressed: false,
+    usage: 0,
+    mipLevels: void 0,
+    samples: void 0,
+    type: 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);
+
+  // ../core/src/adapter/resources/external-texture.ts
+  var _ExternalTexture = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "ExternalTexture";
+    }
+    constructor(device, props) {
+      super(device, props, _ExternalTexture.defaultProps);
+    }
+  };
+  var ExternalTexture = _ExternalTexture;
+  __publicField(ExternalTexture, "defaultProps", {
+    ...Resource.defaultProps,
+    source: null,
+    colorSpace: "srgb"
+  });
+
+  // ../core/src/adapter/resources/shader.ts
+  var _Shader = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "Shader";
+    }
+    constructor(device, props) {
+      super(device, props, _Shader.defaultProps);
+      this.stage = this.props.stage;
+      this.source = this.props.source;
+    }
+  };
+  var Shader = _Shader;
+  __publicField(Shader, "defaultProps", {
+    ...Resource.defaultProps,
+    stage: "vertex",
+    source: "",
+    sourceMap: null,
+    language: "auto",
+    shaderType: 0
+  });
+
+  // ../core/src/adapter/resources/sampler.ts
+  var _Sampler = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "Sampler";
+    }
+    constructor(device, props) {
+      super(device, props, _Sampler.defaultProps);
+    }
+  };
+  var Sampler = _Sampler;
+  __publicField(Sampler, "defaultProps", {
+    ...Resource.defaultProps,
+    type: "color-sampler",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+    magFilter: "nearest",
+    minFilter: "nearest",
+    mipmapFilter: "nearest",
+    lodMinClamp: 0,
+    lodMaxClamp: 32,
+    compare: "less-equal",
+    maxAnisotropy: 1
+  });
+
+  // ../core/src/adapter/resources/framebuffer.ts
+  var _Framebuffer = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "Framebuffer";
+    }
+    colorAttachments = [];
+    depthStencilAttachment = null;
+    constructor(device, props = {}) {
+      super(device, props, _Framebuffer.defaultProps);
+      this.width = this.props.width;
+      this.height = this.props.height;
+    }
+    resize(size) {
+      let updateSize = !size;
+      if (size) {
+        const [width, height] = Array.isArray(size) ? size : [size.width, size.height];
+        updateSize = updateSize || height !== this.height || width !== this.width;
+        this.width = width;
+        this.height = height;
+      }
+      if (updateSize) {
+        log.log(2, `Resizing framebuffer ${this.id} to ${this.width}x${this.height}`)();
+        this.resizeAttachments(this.width, this.height);
+      }
+    }
+    autoCreateAttachmentTextures() {
+      this.colorAttachments = this.props.colorAttachments.map((attachment) => {
+        if (typeof attachment === "string") {
+          const texture = this.createColorTexture(attachment);
+          this.attachResource(texture);
+          return texture;
+        }
+        return attachment;
+      });
+      if (this.props.depthStencilAttachment) {
+        if (typeof this.props.depthStencilAttachment === "string") {
+          const texture = this.createDepthStencilTexture(this.props.depthStencilAttachment);
+          this.attachResource(texture);
+          this.depthStencilAttachment = texture;
+        } else {
+          this.depthStencilAttachment = this.props.depthStencilAttachment;
+        }
+      }
+    }
+    createColorTexture(format) {
+      return this.device.createTexture({
+        id: "color-attachment",
+        usage: Texture.RENDER_ATTACHMENT,
+        format,
+        width: this.width,
+        height: this.height
+      });
+    }
+    createDepthStencilTexture(format) {
+      return this.device.createTexture({
+        id: "depth-stencil-attachment",
+        usage: Texture.RENDER_ATTACHMENT,
+        format,
+        width: this.width,
+        height: this.height
+      });
+    }
+    resizeAttachments(width, height) {
+      for (let i = 0; i < this.colorAttachments.length; ++i) {
+        if (this.colorAttachments[i]) {
+          const resizedTexture = this.device._createTexture({
+            ...this.colorAttachments[i].props,
+            width,
+            height
+          });
+          this.destroyAttachedResource(this.colorAttachments[i]);
+          this.colorAttachments[i] = resizedTexture;
+          this.attachResource(resizedTexture);
+        }
+      }
+      if (this.depthStencilAttachment) {
+        const resizedTexture = this.device._createTexture({
+          ...this.depthStencilAttachment.props,
+          width,
+          height
+        });
+        this.destroyAttachedResource(this.depthStencilAttachment);
+        this.depthStencilAttachment = resizedTexture;
+        this.attachResource(resizedTexture);
+      }
+    }
+  };
+  var Framebuffer = _Framebuffer;
+  __publicField(Framebuffer, "defaultProps", {
+    ...Resource.defaultProps,
+    width: 1,
+    height: 1,
+    colorAttachments: [],
+    depthStencilAttachment: null
+  });
+
+  // ../core/src/adapter/resources/render-pipeline.ts
+  var _RenderPipeline = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "RenderPipeline";
+    }
+    hash = "";
+    constructor(device, props) {
+      super(device, props, _RenderPipeline.defaultProps);
+      this.shaderLayout = this.props.shaderLayout;
+      this.bufferLayout = this.props.bufferLayout || [];
+    }
+  };
+  var RenderPipeline = _RenderPipeline;
+  __publicField(RenderPipeline, "defaultProps", {
+    ...Resource.defaultProps,
+    vs: null,
+    vsEntryPoint: "",
+    vsConstants: {},
+    fs: null,
+    fsEntryPoint: "",
+    fsConstants: {},
+    shaderLayout: null,
+    bufferLayout: [],
+    topology: "triangle-list",
+    parameters: {},
+    vertexCount: 0,
+    instanceCount: 0,
+    bindings: {},
+    uniforms: {}
+  });
+
+  // ../core/src/adapter/resources/compute-pipeline.ts
+  var _ComputePipeline = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "ComputePipeline";
+    }
+    hash = "";
+    constructor(device, props) {
+      super(device, props, _ComputePipeline.defaultProps);
+    }
+  };
+  var ComputePipeline = _ComputePipeline;
+  __publicField(ComputePipeline, "defaultProps", {
+    ...Resource.defaultProps,
+    cs: void 0,
+    csEntryPoint: void 0,
+    csConstants: {},
+    shaderLayout: []
+  });
+
+  // ../core/src/adapter/resources/render-pass.ts
+  var _RenderPass = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "RenderPass";
+    }
+    constructor(device, props) {
+      super(device, props, _RenderPass.defaultProps);
+    }
+  };
+  var RenderPass = _RenderPass;
+  __publicField(RenderPass, "defaultProps", {
+    ...Resource.defaultProps,
+    framebuffer: null,
+    parameters: void 0,
+    clearColor: [0, 0, 0, 0],
+    clearDepth: 1,
+    clearStencil: 0,
+    depthReadOnly: false,
+    stencilReadOnly: false,
+    discard: false
+  });
+
+  // ../core/src/adapter/resources/compute-pass.ts
+  var ComputePass = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "ComputePass";
+    }
+    constructor(device, props) {
+      super(device, props, Resource.defaultProps);
+    }
+  };
+  __publicField(ComputePass, "defaultProps", {
+    ...Resource.defaultProps
+  });
+
+  // ../core/src/adapter/type-utils/decode-attribute-type.ts
+  function decodeShaderAttributeType(attributeType) {
+    const [dataType, components] = TYPE_INFO[attributeType];
+    const integer = dataType === "i32" || dataType === "u32";
+    const signed = dataType !== "u32";
+    const byteLength = TYPE_SIZES[dataType] * components;
+    const defaultVertexFormat = getCompatibleVertexFormat(dataType, components);
+    return {
+      dataType,
+      components,
+      defaultVertexFormat,
+      byteLength,
+      integer,
+      signed
+    };
+  }
+  function getCompatibleVertexFormat(dataType, components) {
+    let vertexType;
+    switch (dataType) {
+      case "f32":
+        vertexType = "float32";
+        break;
+      case "i32":
+        vertexType = "sint32";
+        break;
+      case "u32":
+        vertexType = "uint32";
+        break;
+      case "f16":
+        return components <= 2 ? "float16x2" : "float16x4";
+    }
+    if (components === 1) {
+      return vertexType;
+    }
+    return `${vertexType}x${components}`;
+  }
+  var TYPE_INFO = {
+    f32: ["f32", 1],
+    "vec2<f32>": ["f32", 2],
+    "vec3<f32>": ["f32", 3],
+    "vec4<f32>": ["f32", 4],
+    f16: ["f16", 1],
+    "vec2<f16>": ["f16", 2],
+    "vec3<f16>": ["f16", 3],
+    "vec4<f16>": ["f16", 4],
+    i32: ["i32", 1],
+    "vec2<i32>": ["i32", 2],
+    "vec3<i32>": ["i32", 3],
+    "vec4<i32>": ["i32", 4],
+    u32: ["u32", 1],
+    "vec2<u32>": ["u32", 2],
+    "vec3<u32>": ["u32", 3],
+    "vec4<u32>": ["u32", 4]
+  };
+  var TYPE_SIZES = {
+    f32: 4,
+    f16: 2,
+    i32: 4,
+    u32: 4
+  };
+
+  // ../core/src/adapter/type-utils/decode-data-type.ts
+  function decodeVertexType(type) {
+    const dataType = TYPE_MAP[type];
+    const bytes = getDataTypeBytes(dataType);
+    const normalized = type.includes("norm");
+    const integer = !normalized && !type.startsWith("float");
+    const signed = type.startsWith("s");
+    return {
+      dataType: TYPE_MAP[type],
+      byteLength: bytes,
+      integer,
+      signed,
+      normalized
+    };
+  }
+  function getDataTypeBytes(type) {
+    const bytes = TYPE_SIZES2[type];
+    return bytes;
+  }
+  var TYPE_MAP = {
+    uint8: "uint8",
+    sint8: "sint8",
+    unorm8: "uint8",
+    snorm8: "sint8",
+    uint16: "uint16",
+    sint16: "sint16",
+    unorm16: "uint16",
+    snorm16: "sint16",
+    float16: "float16",
+    float32: "float32",
+    uint32: "uint32",
+    sint32: "sint32"
+  };
+  var TYPE_SIZES2 = {
+    uint8: 1,
+    sint8: 1,
+    uint16: 2,
+    sint16: 2,
+    float16: 2,
+    float32: 4,
+    uint32: 4,
+    sint32: 4
+  };
+
+  // ../core/src/adapter/type-utils/decode-vertex-format.ts
+  function decodeVertexFormat(format) {
+    let webglOnly;
+    if (format.endsWith("-webgl")) {
+      format.replace("-webgl", "");
+      webglOnly = true;
+    }
+    const [type_, count] = format.split("x");
+    const type = type_;
+    const components = count ? parseInt(count) : 1;
+    const decodedType = decodeVertexType(type);
+    const result = {
+      type,
+      components,
+      byteLength: decodedType.byteLength * components,
+      integer: decodedType.integer,
+      signed: decodedType.signed,
+      normalized: decodedType.normalized
+    };
+    if (webglOnly) {
+      result.webglOnly = true;
+    }
+    return result;
+  }
+
+  // ../core/src/adapter/attribute-utils/get-attribute-from-layouts.ts
+  function getAttributeInfosFromLayouts(shaderLayout, bufferLayout) {
+    const attributeInfos = {};
+    for (const attribute of shaderLayout.attributes) {
+      attributeInfos[attribute.name] = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name);
+    }
+    return attributeInfos;
+  }
+  function getAttributeInfosByLocation(shaderLayout, bufferLayout, maxVertexAttributes = 16) {
+    const attributeInfos = getAttributeInfosFromLayouts(shaderLayout, bufferLayout);
+    const locationInfos = new Array(maxVertexAttributes).fill(null);
+    for (const attributeInfo of Object.values(attributeInfos)) {
+      locationInfos[attributeInfo.location] = attributeInfo;
+    }
+    return locationInfos;
+  }
+  function getAttributeInfoFromLayouts(shaderLayout, bufferLayout, name2) {
+    const shaderDeclaration = getAttributeFromShaderLayout(shaderLayout, name2);
+    const bufferMapping = getAttributeFromBufferLayout(bufferLayout, name2);
+    if (!shaderDeclaration) {
+      return null;
+    }
+    const attributeTypeInfo = decodeShaderAttributeType(shaderDeclaration.type);
+    const vertexFormat = bufferMapping?.vertexFormat || attributeTypeInfo.defaultVertexFormat;
+    const vertexFormatInfo = decodeVertexFormat(vertexFormat);
+    return {
+      attributeName: bufferMapping?.attributeName || shaderDeclaration.name,
+      bufferName: bufferMapping?.bufferName || shaderDeclaration.name,
+      location: shaderDeclaration.location,
+      shaderType: shaderDeclaration.type,
+      shaderDataType: attributeTypeInfo.dataType,
+      shaderComponents: attributeTypeInfo.components,
+      vertexFormat,
+      bufferDataType: vertexFormatInfo.type,
+      bufferComponents: vertexFormatInfo.components,
+      normalized: vertexFormatInfo.normalized,
+      integer: attributeTypeInfo.integer,
+      stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode,
+      byteOffset: bufferMapping?.byteOffset || 0,
+      byteStride: bufferMapping?.byteStride || 0
+    };
+  }
+  function getAttributeFromShaderLayout(shaderLayout, name2) {
+    const attribute = shaderLayout.attributes.find((attr) => attr.name === name2);
+    if (!attribute) {
+      log.warn(`shader layout attribute "${name2}" not present in shader`);
+    }
+    return attribute || null;
+  }
+  function getAttributeFromBufferLayout(bufferLayouts, name2) {
+    checkBufferLayouts(bufferLayouts);
+    let bufferLayoutInfo = getAttributeFromShortHand(bufferLayouts, name2);
+    if (bufferLayoutInfo) {
+      return bufferLayoutInfo;
+    }
+    bufferLayoutInfo = getAttributeFromAttributesList(bufferLayouts, name2);
+    if (bufferLayoutInfo) {
+      return bufferLayoutInfo;
+    }
+    log.warn(`layout for attribute "${name2}" not present in buffer layout`);
+    return null;
+  }
+  function checkBufferLayouts(bufferLayouts) {
+    for (const bufferLayout of bufferLayouts) {
+      if (bufferLayout.attributes && bufferLayout.format || !bufferLayout.attributes && !bufferLayout.format) {
+        log.warn(`BufferLayout ${name} must have either 'attributes' or 'format' field`);
+      }
+    }
+  }
+  function getAttributeFromShortHand(bufferLayouts, name2) {
+    for (const bufferLayout of bufferLayouts) {
+      if (bufferLayout.format && bufferLayout.name === name2) {
+        return {
+          attributeName: bufferLayout.name,
+          bufferName: name2,
+          stepMode: bufferLayout.stepMode,
+          vertexFormat: bufferLayout.format,
+          byteOffset: 0,
+          byteStride: bufferLayout.byteStride || 0
+        };
+      }
+    }
+    return null;
+  }
+  function getAttributeFromAttributesList(bufferLayouts, name2) {
+    for (const bufferLayout of bufferLayouts) {
+      let byteStride = bufferLayout.byteStride;
+      if (typeof bufferLayout.byteStride !== "number") {
+        for (const attributeMapping2 of bufferLayout.attributes || []) {
+          const info = decodeVertexFormat(attributeMapping2.format);
+          byteStride += info.byteLength;
+        }
+      }
+      const attributeMapping = bufferLayout.attributes?.find((mapping) => mapping.attribute === name2);
+      if (attributeMapping) {
+        return {
+          attributeName: attributeMapping.attribute,
+          bufferName: bufferLayout.name,
+          stepMode: bufferLayout.stepMode,
+          vertexFormat: attributeMapping.format,
+          byteOffset: attributeMapping.byteOffset,
+          byteStride
+        };
+      }
+    }
+    return null;
+  }
+
+  // ../core/src/adapter/resources/vertex-array.ts
+  var _VertexArray = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "VertexArray";
+    }
+    indexBuffer = null;
+    constructor(device, props) {
+      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);
+    }
+  };
+  var VertexArray = _VertexArray;
+  __publicField(VertexArray, "defaultProps", {
+    ...Resource.defaultProps,
+    renderPipeline: null
+  });
+
+  // ../core/src/lib/utils/cast.ts
+  function cast(value) {
+    return value;
+  }
+
+  // src/adapter/resources/webgpu-buffer.ts
+  function getByteLength(props) {
+    return props.byteLength || props.data?.byteLength || 0;
+  }
+  var WebGPUBuffer = class extends Buffer2 {
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      this.byteLength = getByteLength(props);
+      const mapBuffer = Boolean(props.data);
+      const size = Math.ceil(this.byteLength / 4) * 4;
+      this.handle = this.props.handle || this.device.handle.createBuffer({
+        size,
+        usage: this.props.usage || GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        mappedAtCreation: this.props.mappedAtCreation || mapBuffer,
+        label: this.props.id
+      });
+      if (props.data) {
+        this._writeMapped(props.data);
+      }
+      if (mapBuffer && !props.mappedAtCreation) {
+        this.handle.unmap();
+      }
+    }
+    destroy() {
+      this.handle.destroy();
+    }
+    write(data, byteOffset = 0) {
+      this.device.handle.queue.writeBuffer(this.handle, byteOffset, data.buffer, data.byteOffset, data.byteLength);
+    }
+    async readAsync(byteOffset = 0, byteLength = this.byteLength) {
+      const tempBuffer = new WebGPUBuffer(this.device, {
+        usage: Buffer2.MAP_READ | Buffer2.COPY_DST,
+        byteLength
+      });
+      const commandEncoder = this.device.handle.createCommandEncoder();
+      commandEncoder.copyBufferToBuffer(this.handle, byteOffset, tempBuffer.handle, 0, byteLength);
+      this.device.handle.queue.submit([commandEncoder.finish()]);
+      await tempBuffer.handle.mapAsync(GPUMapMode.READ, byteOffset, byteLength);
+      const arrayBuffer = tempBuffer.handle.getMappedRange().slice(0);
+      tempBuffer.handle.unmap();
+      tempBuffer.destroy();
+      return new Uint8Array(arrayBuffer);
+    }
+    _writeMapped(typedArray) {
+      const arrayBuffer = this.handle.getMappedRange();
+      new typedArray.constructor(arrayBuffer).set(typedArray);
+    }
+    mapAsync(mode, offset = 0, size) {
+      return this.handle.mapAsync(mode, offset, size);
+    }
+    getMappedRange(offset = 0, size) {
+      return this.handle.getMappedRange(offset, size);
+    }
+    unmap() {
+      this.handle.unmap();
+    }
+  };
+
+  // src/adapter/helpers/convert-texture-format.ts
+  function getWebGPUTextureFormat(format) {
+    if (format.includes("webgl")) {
+      throw new Error("webgl-only format");
+    }
+    return format;
+  }
+
+  // src/adapter/resources/webgpu-sampler.ts
+  var WebGPUSampler = class extends Sampler {
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      const samplerProps = {
+        ...this.props
+      };
+      if (samplerProps.type !== "comparison-sampler") {
+        delete samplerProps.compare;
+      }
+      this.handle = this.handle || this.device.handle.createSampler(samplerProps);
+      this.handle.label = this.props.id;
+    }
+    destroy() {
+    }
+  };
+
+  // src/adapter/resources/webgpu-texture.ts
+  var BASE_DIMENSIONS = {
+    "1d": "1d",
+    "2d": "2d",
+    "2d-array": "2d",
+    "cube": "2d",
+    "cube-array": "2d",
+    "3d": "3d"
+  };
+  var WebGPUTexture = class extends Texture {
+    height = 1;
+    width = 1;
+    constructor(device, props) {
+      super(device, props);
+      if (typeof this.props.format === "number") {
+        throw new Error("number format");
+      }
+      this.device = device;
+      this.handle = this.props.handle || this.createHandle();
+      if (this.props.data) {
+        this.setData({
+          data: this.props.data
+        });
+      }
+      this.width = this.handle.width;
+      this.height = this.handle.height;
+      this.sampler = props.sampler instanceof WebGPUSampler ? props.sampler : new WebGPUSampler(this.device, props.sampler);
+      this.view = this.handle.createView({});
+    }
+    createHandle() {
+      if (typeof this.props.format === "number") {
+        throw new Error("number format");
+      }
+      const width = this.props.width || this.props.data?.width || 1;
+      const height = this.props.height || this.props.data?.height || 1;
+      return this.device.handle.createTexture({
+        size: {
+          width,
+          height,
+          depthOrArrayLayers: this.props.depth
+        },
+        dimension: BASE_DIMENSIONS[this.props.dimension],
+        format: getWebGPUTextureFormat(this.props.format),
+        usage: this.props.usage,
+        mipLevelCount: this.props.mipLevels,
+        sampleCount: this.props.samples
+      });
+    }
+    destroy() {
+      this.handle.destroy();
+    }
+    setSampler(sampler) {
+      this.sampler = sampler instanceof WebGPUSampler ? sampler : new WebGPUSampler(this.device, sampler);
+      return this;
+    }
+    setData(options) {
+      return this.setImage({
+        source: options.data
+      });
+    }
+    setImage(options) {
+      const {
+        source,
+        width = options.source.width,
+        height = options.source.height,
+        depth = 1,
+        sourceX = 0,
+        sourceY = 0,
+        mipLevel = 0,
+        x = 0,
+        y = 0,
+        z = 0,
+        aspect = "all",
+        colorSpace = "srgb",
+        premultipliedAlpha = false
+      } = options;
+      this.device.handle.queue.copyExternalImageToTexture({
+        source,
+        origin: [sourceX, sourceY]
+      }, {
+        texture: this.handle,
+        origin: [x, y, z],
+        mipLevel,
+        aspect,
+        colorSpace,
+        premultipliedAlpha
+      }, [width, height, depth]);
+      return {
+        width,
+        height
+      };
+    }
+  };
+
+  // src/adapter/resources/webgpu-external-texture.ts
+  var WebGPUExternalTexture = class extends ExternalTexture {
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      this.handle = this.props.handle || this.device.handle.importExternalTexture({
+        source: props.source,
+        colorSpace: props.colorSpace
+      });
+      this.sampler = null;
+    }
+    destroy() {
+    }
+    setSampler(sampler) {
+      this.sampler = sampler instanceof WebGPUSampler ? sampler : new WebGPUSampler(this.device, sampler);
+      return this;
+    }
+  };
+
+  // src/adapter/resources/webgpu-shader.ts
+  var WebGPUShader = class extends Shader {
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      this.device.handle.pushErrorScope("validation");
+      this.handle = this.props.handle || this.createHandle();
+      this.handle.label = this.props.id;
+      this._checkCompilationError(this.device.handle.popErrorScope());
+    }
+    async _checkCompilationError(errorScope) {
+      const error = await errorScope;
+      if (error) {
+        const shaderLog = await this.compilationInfo();
+        log.error(`Shader compilation error: ${error.message}`, shaderLog)();
+        throw new Error(`Shader compilation error: ${error.message}`);
+      }
+    }
+    destroy() {
+    }
+    createHandle() {
+      const {
+        source,
+        stage
+      } = this.props;
+      let language = this.props.language;
+      if (language === "auto") {
+        language = source.includes("->") ? "wgsl" : "glsl";
+      }
+      switch (language) {
+        case "wgsl":
+          return this.device.handle.createShaderModule({
+            code: source
+          });
+        case "glsl":
+          return this.device.handle.createShaderModule({
+            code: source,
+            transform: (glsl) => this.device.glslang.compileGLSL(glsl, stage)
+          });
+        default:
+          throw new Error(language);
+      }
+    }
+    async compilationInfo() {
+      const compilationInfo = await this.handle.getCompilationInfo();
+      return compilationInfo.messages;
+    }
+  };
+
+  // src/adapter/helpers/webgpu-parameters.ts
+  function addDepthStencil(descriptor) {
+    descriptor.depthStencil = descriptor.depthStencil || {
+      format: "depth24plus",
+      stencilFront: {},
+      stencilBack: {},
+      depthWriteEnabled: false,
+      depthCompare: "less-equal"
+    };
+    return descriptor.depthStencil;
+  }
+  var PARAMETER_TABLE = {
+    cullMode: (parameter, value, descriptor) => {
+      descriptor.primitive = descriptor.primitive || {};
+      descriptor.primitive.cullMode = value;
+    },
+    frontFace: (parameter, value, descriptor) => {
+      descriptor.primitive = descriptor.primitive || {};
+      descriptor.primitive.frontFace = value;
+    },
+    depthWriteEnabled: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.depthWriteEnabled = value;
+    },
+    depthCompare: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.depthCompare = value;
+    },
+    depthFormat: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.format = value;
+    },
+    depthBias: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.depthBias = value;
+    },
+    depthBiasSlopeScale: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.depthBiasSlopeScale = value;
+    },
+    depthBiasClamp: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.depthBiasClamp = value;
+    },
+    stencilReadMask: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.stencilReadMask = value;
+    },
+    stencilWriteMask: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.stencilWriteMask = value;
+    },
+    stencilCompare: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.stencilFront.compare = value;
+      depthStencil.stencilBack.compare = value;
+    },
+    stencilPassOperation: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.stencilFront.passOp = value;
+      depthStencil.stencilBack.passOp = value;
+    },
+    stencilFailOperation: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.stencilFront.failOp = value;
+      depthStencil.stencilBack.failOp = value;
+    },
+    stencilDepthFailOperation: (parameter, value, descriptor) => {
+      const depthStencil = addDepthStencil(descriptor);
+      depthStencil.stencilFront.depthFailOp = value;
+      depthStencil.stencilBack.depthFailOp = value;
+    },
+    sampleCount: (parameter, value, descriptor) => {
+      descriptor.multisample = descriptor.multisample || {};
+      descriptor.multisample.count = value;
+    },
+    sampleMask: (parameter, value, descriptor) => {
+      descriptor.multisample = descriptor.multisample || {};
+      descriptor.multisample.mask = value;
+    },
+    sampleAlphaToCoverageEnabled: (parameter, value, descriptor) => {
+      descriptor.multisample = descriptor.multisample || {};
+      descriptor.multisample.alphaToCoverageEnabled = value;
+    },
+    colorMask: (parameter, value, descriptor) => {
+      const targets = addColorState(descriptor);
+      targets[0].writeMask = value;
+    },
+    blendColorOperation: (parameter, value, descriptor) => {
+      addColorState(descriptor);
+    }
+  };
+  var DEFAULT_PIPELINE_DESCRIPTOR = {
+    primitive: {
+      cullMode: "back",
+      topology: "triangle-list"
+    },
+    vertex: {
+      module: void 0,
+      entryPoint: "main"
+    },
+    fragment: {
+      module: void 0,
+      entryPoint: "main",
+      targets: []
+    },
+    layout: "auto"
+  };
+  function applyParametersToRenderPipelineDescriptor(pipelineDescriptor, parameters = {}) {
+    Object.assign(pipelineDescriptor, {
+      ...DEFAULT_PIPELINE_DESCRIPTOR,
+      ...pipelineDescriptor
+    });
+    setParameters(pipelineDescriptor, parameters);
+  }
+  function setParameters(pipelineDescriptor, parameters) {
+    for (const [key, value] of Object.entries(parameters)) {
+      const setterFunction = PARAMETER_TABLE[key];
+      if (!setterFunction) {
+        throw new Error(`Illegal parameter ${key}`);
+      }
+      setterFunction(key, value, pipelineDescriptor);
+    }
+  }
+  function addColorState(descriptor) {
+    descriptor.fragment.targets = descriptor.fragment?.targets || [];
+    if (!Array.isArray(descriptor.fragment?.targets)) {
+      throw new Error("colorstate");
+    }
+    if (descriptor.fragment?.targets?.length === 0) {
+      descriptor.fragment.targets?.push({});
+    }
+    return descriptor.fragment?.targets;
+  }
+
+  // src/adapter/helpers/get-bind-group.ts
+  function getBindGroup(device, bindGroupLayout, shaderLayout, bindings) {
+    const entries = getBindGroupEntries(bindings, shaderLayout);
+    return device.createBindGroup({
+      layout: bindGroupLayout,
+      entries
+    });
+  }
+  function getShaderLayoutBinding(shaderLayout, bindingName) {
+    const bindingLayout = shaderLayout.bindings.find((binding) => binding.name === bindingName);
+    if (!bindingLayout) {
+      log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();
+    }
+    return bindingLayout;
+  }
+  function getBindGroupEntries(bindings, shaderLayout) {
+    const entries = [];
+    for (const [bindingName, value] of Object.entries(bindings)) {
+      const bindingLayout = getShaderLayoutBinding(shaderLayout, bindingName);
+      if (bindingLayout) {
+        entries.push(getBindGroupEntry(value, bindingLayout.location));
+      }
+    }
+    return entries;
+  }
+  function getBindGroupEntry(binding, index) {
+    if (binding instanceof Buffer2) {
+      return {
+        binding: index,
+        resource: {
+          buffer: cast(binding).handle
+        }
+      };
+    }
+    if (binding instanceof Sampler) {
+      return {
+        binding: index,
+        resource: cast(binding).handle
+      };
+    } else if (binding instanceof Texture) {
+      return {
+        binding: index,
+        resource: cast(binding).handle.createView()
+      };
+    }
+    throw new Error("invalid binding");
+  }
+
+  // src/adapter/helpers/get-vertex-buffer-layout.ts
+  function getWebGPUVertexFormat(format) {
+    if (format.endsWith("-webgl")) {
+      throw new Error(`WebGPU does not support vertex format ${format}`);
+    }
+    return format;
+  }
+  function getVertexBufferLayout(shaderLayout, bufferLayout) {
+    const vertexBufferLayouts = [];
+    const usedAttributes = /* @__PURE__ */ new Set();
+    for (const mapping of bufferLayout) {
+      const vertexAttributes = [];
+      let stepMode = "vertex";
+      let byteStride = 0;
+      if (mapping.attributes) {
+        for (const attributeMapping of mapping.attributes) {
+          const attributeName = attributeMapping.attribute;
+          const attributeLayout = findAttributeLayout(shaderLayout, attributeName, usedAttributes);
+          stepMode = attributeLayout.stepMode || "vertex";
+          vertexAttributes.push({
+            format: getWebGPUVertexFormat(attributeMapping.format || mapping.format),
+            offset: attributeMapping.byteOffset,
+            shaderLocation: attributeLayout.location
+          });
+          byteStride += decodeVertexFormat(mapping.format).byteLength;
+        }
+      } else {
+        const attributeLayout = findAttributeLayout(shaderLayout, mapping.name, usedAttributes);
+        byteStride = decodeVertexFormat(mapping.format).byteLength;
+        stepMode = attributeLayout.stepMode || "vertex";
+        vertexAttributes.push({
+          format: getWebGPUVertexFormat(mapping.format),
+          offset: 0,
+          shaderLocation: attributeLayout.location
+        });
+      }
+      vertexBufferLayouts.push({
+        arrayStride: mapping.byteStride || byteStride,
+        stepMode: stepMode || "vertex",
+        attributes: vertexAttributes
+      });
+    }
+    for (const attribute of shaderLayout.attributes) {
+      if (!usedAttributes.has(attribute.name)) {
+        vertexBufferLayouts.push({
+          arrayStride: decodeVertexFormat("float32x3").byteLength,
+          stepMode: attribute.stepMode || "vertex",
+          attributes: [{
+            format: getWebGPUVertexFormat("float32x3"),
+            offset: 0,
+            shaderLocation: attribute.location
+          }]
+        });
+      }
+    }
+    return vertexBufferLayouts;
+  }
+  function getBufferSlots(shaderLayout, bufferLayout) {
+    const usedAttributes = /* @__PURE__ */ new Set();
+    let bufferSlot = 0;
+    const bufferSlots = {};
+    for (const mapping of bufferLayout) {
+      if ("attributes" in mapping) {
+        for (const interleaved of mapping.attributes) {
+          usedAttributes.add(interleaved.attribute);
+        }
+      } else {
+        usedAttributes.add(mapping.name);
+      }
+      bufferSlots[mapping.name] = bufferSlot++;
+    }
+    for (const attribute of shaderLayout.attributes) {
+      if (!usedAttributes.has(attribute.name)) {
+        bufferSlots[attribute.name] = bufferSlot++;
+      }
+    }
+    return bufferSlots;
+  }
+  function findAttributeLayout(shaderLayout, name2, attributeNames) {
+    const attribute = shaderLayout.attributes.find((attribute2) => attribute2.name === name2);
+    if (!attribute) {
+      throw new Error(`Unknown attribute ${name2}`);
+    }
+    if (attributeNames.has(name2)) {
+      throw new Error(`Duplicate attribute ${name2}`);
+    }
+    attributeNames.add(name2);
+    return attribute;
+  }
+
+  // src/adapter/resources/webgpu-render-pipeline.ts
+  var WebGPURenderPipeline = class extends RenderPipeline {
+    fs = null;
+    _indexBuffer = null;
+    _bindGroupLayout = null;
+    _bindGroup = null;
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      this.handle = this.props.handle;
+      if (!this.handle) {
+        const descriptor = this._getRenderPipelineDescriptor();
+        log.groupCollapsed(1, `new WebGPURenderPipeline(${this.id})`)();
+        log.probe(1, JSON.stringify(descriptor, null, 2))();
+        log.groupEnd(1)();
+        this.handle = this.device.handle.createRenderPipeline(descriptor);
+      }
+      this.handle.label = this.props.id;
+      this.vs = cast(props.vs);
+      this.fs = cast(props.fs);
+      this._bufferSlots = getBufferSlots(this.props.shaderLayout, this.props.bufferLayout);
+      this._buffers = new Array(Object.keys(this._bufferSlots).length).fill(null);
+    }
+    destroy() {
+    }
+    setIndexBuffer(indexBuffer) {
+      this._indexBuffer = cast(indexBuffer);
+    }
+    setAttributes(attributes) {
+      for (const [name2, buffer] of Object.entries(attributes)) {
+        const bufferIndex = this._bufferSlots[name2];
+        if (bufferIndex >= 0) {
+          this._buffers[bufferIndex] = buffer;
+        } else {
+          throw new Error(`Setting attribute '${name2}' not listed in shader layout for program ${this.id}`);
+        }
+      }
+    }
+    setConstantAttributes(attributes) {
+      throw new Error("not implemented");
+    }
+    setBindings(bindings) {
+      if (!isObjectEmpty(this.props.bindings)) {
+        Object.assign(this.props.bindings, bindings);
+        this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
+        this._bindGroup = getBindGroup(this.device.handle, this._bindGroupLayout, this.props.shaderLayout, this.props.bindings);
+      }
+    }
+    setUniforms(uniforms) {
+      if (!isObjectEmpty(uniforms)) {
+        throw new Error("WebGPU does not support uniforms");
+      }
+    }
+    _getBuffers() {
+      return this._buffers;
+    }
+    _getBindGroup() {
+      return this._bindGroup;
+    }
+    _getRenderPipelineDescriptor() {
+      const vertex = {
+        module: cast(this.props.vs).handle,
+        entryPoint: this.props.vsEntryPoint || "main",
+        buffers: getVertexBufferLayout(this.props.shaderLayout, this.props.bufferLayout)
+      };
+      let fragment;
+      if (this.props.fs) {
+        fragment = {
+          module: cast(this.props.fs).handle,
+          entryPoint: this.props.fsEntryPoint || "main",
+          targets: [{
+            format: getWebGPUTextureFormat(this.device?.canvasContext?.format)
+          }]
+        };
+      }
+      switch (this.props.topology) {
+        case "triangle-fan-webgl":
+        case "line-loop-webgl":
+          throw new Error(`WebGPU does not support primitive topology ${this.props.topology}`);
+        default:
+      }
+      const descriptor = {
+        vertex,
+        fragment,
+        primitive: {
+          topology: this.props.topology
+        },
+        layout: "auto"
+      };
+      applyParametersToRenderPipelineDescriptor(descriptor, this.props.parameters);
+      return descriptor;
+    }
+    draw(options) {
+      const webgpuRenderPass = cast(options.renderPass) || this.device.getDefaultRenderPass();
+      webgpuRenderPass.handle.setPipeline(this.handle);
+      const bindGroup = this._getBindGroup();
+      if (bindGroup) {
+        webgpuRenderPass.handle.setBindGroup(0, bindGroup);
+      }
+      this._setAttributeBuffers(webgpuRenderPass);
+      if (options.indexCount) {
+        webgpuRenderPass.handle.drawIndexed(options.indexCount, options.instanceCount, options.firstIndex, options.baseVertex, options.firstInstance);
+      } else {
+        webgpuRenderPass.handle.draw(options.vertexCount || 0, options.instanceCount || 1, options.firstInstance);
+      }
+    }
+    _setAttributeBuffers(webgpuRenderPass) {
+      if (this._indexBuffer) {
+        webgpuRenderPass.handle.setIndexBuffer(this._indexBuffer.handle, this._indexBuffer.props.indexType);
+      }
+      const buffers = this._getBuffers();
+      for (let i = 0; i < buffers.length; ++i) {
+        const buffer = cast(buffers[i]);
+        if (!buffer) {
+          const attribute = this.props.shaderLayout.attributes.find((attribute2) => attribute2.location === i);
+          throw new Error(`No buffer provided for attribute '${attribute?.name || ""}' in Model '${this.props.id}'`);
+        }
+        webgpuRenderPass.handle.setVertexBuffer(i, buffer.handle);
+      }
+    }
+  };
+
+  // src/adapter/resources/webgpu-compute-pipeline.ts
+  var WebGPUComputePipeline = class extends ComputePipeline {
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      const module = cast(this.props.cs).handle;
+      this.handle = this.props.handle || this.device.handle.createComputePipeline({
+        label: this.props.id,
+        compute: {
+          module,
+          entryPoint: this.props.csEntryPoint
+        },
+        layout: "auto"
+      });
+    }
+    _getBindGroupLayout() {
+      return this.handle.getBindGroupLayout(0);
+    }
+  };
+
+  // src/adapter/resources/webgpu-render-pass.ts
+  var WebGPURenderPass = class extends RenderPass {
+    pipeline = null;
+    constructor(device, props = {}) {
+      super(device, props);
+      this.device = device;
+      const framebuffer = props.framebuffer || device.canvasContext.getCurrentFramebuffer();
+      const renderPassDescriptor = this.getRenderPassDescriptor(framebuffer);
+      log.groupCollapsed(1, `new WebGPURenderPass(${this.id})`)();
+      log.probe(1, JSON.stringify(renderPassDescriptor, null, 2))();
+      log.groupEnd(1)();
+      this.handle = this.props.handle || device.commandEncoder.beginRenderPass(renderPassDescriptor);
+      this.handle.label = this.props.id;
+    }
+    destroy() {
+    }
+    end() {
+      this.handle.end();
+    }
+    setPipeline(pipeline) {
+      this.pipeline = cast(pipeline);
+      this.handle.setPipeline(this.pipeline.handle);
+    }
+    setBindings(bindings) {
+      this.pipeline?.setBindings(bindings);
+      const bindGroup = this.pipeline?._getBindGroup();
+      if (bindGroup) {
+        this.handle.setBindGroup(0, bindGroup);
+      }
+    }
+    setIndexBuffer(buffer, indexFormat, offset = 0, size) {
+      this.handle.setIndexBuffer(cast(buffer).handle, indexFormat, offset, size);
+    }
+    setVertexBuffer(slot, buffer, offset = 0) {
+      this.handle.setVertexBuffer(slot, cast(buffer).handle, offset);
+    }
+    draw(options) {
+      if (options.indexCount) {
+        this.handle.drawIndexed(options.indexCount, options.instanceCount, options.firstIndex, options.baseVertex, options.firstInstance);
+      } else {
+        this.handle.draw(options.vertexCount || 0, options.instanceCount || 1, options.firstIndex, options.firstInstance);
+      }
+    }
+    drawIndirect() {
+    }
+    setParameters(parameters) {
+      const {
+        blendConstant,
+        stencilReference,
+        scissorRect,
+        viewport
+      } = parameters;
+      if (blendConstant) {
+        this.handle.setBlendConstant(blendConstant);
+      }
+      if (stencilReference) {
+        this.handle.setStencilReference(stencilReference);
+      }
+      if (scissorRect) {
+        this.handle.setScissorRect(scissorRect[0], scissorRect[1], scissorRect[2], scissorRect[3]);
+      }
+      if (viewport) {
+        this.handle.setViewport(viewport[0], viewport[1], viewport[2], viewport[3], viewport[4], viewport[5]);
+      }
+    }
+    pushDebugGroup(groupLabel) {
+      this.handle.pushDebugGroup(groupLabel);
+    }
+    popDebugGroup() {
+      this.handle.popDebugGroup();
+    }
+    insertDebugMarker(markerLabel) {
+      this.handle.insertDebugMarker(markerLabel);
+    }
+    getRenderPassDescriptor(framebuffer) {
+      const renderPassDescriptor = {
+        colorAttachments: []
+      };
+      renderPassDescriptor.colorAttachments = framebuffer.colorAttachments.map((colorAttachment) => ({
+        loadOp: this.props.clearColor !== false ? "clear" : "load",
+        colorClearValue: this.props.clearColor || [0, 0, 0, 0],
+        storeOp: this.props.discard ? "discard" : "store",
+        view: colorAttachment.handle.createView()
+      }));
+      if (framebuffer.depthStencilAttachment) {
+        renderPassDescriptor.depthStencilAttachment = {
+          view: framebuffer.depthStencilAttachment.handle.createView()
+        };
+        const {
+          depthStencilAttachment
+        } = renderPassDescriptor;
+        if (this.props.depthReadOnly) {
+          depthStencilAttachment.depthReadOnly = true;
+        }
+        depthStencilAttachment.depthClearValue = this.props.clearDepth || 0;
+        const hasDepthAspect = true;
+        if (hasDepthAspect) {
+          depthStencilAttachment.depthLoadOp = this.props.clearDepth !== false ? "clear" : "load";
+          depthStencilAttachment.depthStoreOp = "store";
+        }
+        const hasStencilAspect = false;
+        if (hasStencilAspect) {
+          depthStencilAttachment.stencilLoadOp = this.props.clearStencil !== false ? "clear" : "load";
+          depthStencilAttachment.stencilStoreOp = "store";
+        }
+      }
+      return renderPassDescriptor;
+    }
+  };
+
+  // src/adapter/resources/webgpu-compute-pass.ts
+  var WebGPUComputePass = class extends ComputePass {
+    _bindGroupLayout = null;
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      this.handle = this.props.handle || device.commandEncoder?.beginComputePass({
+        label: this.props.id
+      });
+    }
+    destroy() {
+    }
+    end() {
+      this.handle.end();
+    }
+    setPipeline(pipeline) {
+      const wgpuPipeline = cast(pipeline);
+      this.handle.setPipeline(wgpuPipeline.handle);
+      this._bindGroupLayout = wgpuPipeline._getBindGroupLayout();
+    }
+    setBindings(bindings) {
+      throw new Error("fix me");
+    }
+    dispatch(x, y, z) {
+      this.handle.dispatchWorkgroups(x, y, z);
+    }
+    dispatchIndirect(indirectBuffer, indirectOffset = 0) {
+      this.handle.dispatchWorkgroupsIndirect(cast(indirectBuffer).handle, indirectOffset);
+    }
+    pushDebugGroup(groupLabel) {
+      this.handle.pushDebugGroup(groupLabel);
+    }
+    popDebugGroup() {
+      this.handle.popDebugGroup();
+    }
+    insertDebugMarker(markerLabel) {
+      this.handle.insertDebugMarker(markerLabel);
+    }
+  };
+
+  // src/adapter/resources/webgpu-vertex-array.ts
+  var WebGPUVertexArray = class extends VertexArray {
+    get [Symbol.toStringTag]() {
+      return "WebGPUVertexArray";
+    }
+    static isConstantAttributeZeroSupported(device) {
+      return device.info.type === "webgl2" || getBrowser() === "Chrome";
+    }
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+    }
+    destroy() {
+    }
+    setIndexBuffer(buffer) {
+      this.indexBuffer = buffer;
+    }
+    setBuffer(location, buffer) {
+      this.attributes[location] = buffer;
+    }
+    setConstant(location, value) {
+      log.warn(`${this.id} constant attributes not supported on WebGPU`);
+    }
+    bindBeforeRender(renderPass, firstIndex, indexCount) {
+      const webgpuRenderPass = renderPass;
+      const webgpuIndexBuffer = this.indexBuffer;
+      webgpuRenderPass.handle.setIndexBuffer(webgpuIndexBuffer?.handle, webgpuIndexBuffer?.indexType);
+      for (let location = 0; location < this.maxVertexAttributes; location++) {
+        const webgpuBuffer = this.attributes[location];
+        webgpuRenderPass.handle.setVertexBuffer(location, webgpuBuffer.handle);
+      }
+    }
+    unbindAfterRender(renderPass) {
+    }
+  };
+
+  // src/adapter/resources/webgpu-framebuffer.ts
+  var WebGPUFramebuffer = class extends Framebuffer {
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      this.autoCreateAttachmentTextures();
+    }
+  };
+
+  // src/adapter/webgpu-canvas-context.ts
+  var WebGPUCanvasContext = class extends CanvasContext {
+    format = navigator.gpu.getPreferredCanvasFormat();
+    depthStencilFormat = "depth24plus";
+    depthStencilAttachment = null;
+    constructor(device, adapter, props) {
+      super(props);
+      this.device = device;
+      this.width = -1;
+      this.height = -1;
+      this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
+      this.gpuCanvasContext = this.canvas.getContext("webgpu");
+      this.format = "bgra8unorm";
+    }
+    destroy() {
+      this.gpuCanvasContext.unconfigure();
+    }
+    getCurrentTexture() {
+      return this.device._createTexture({
+        id: "default-render-target",
+        handle: this.gpuCanvasContext.getCurrentTexture()
+      });
+    }
+    getCurrentFramebuffer() {
+      this.update();
+      const currentColorAttachment = this.getCurrentTexture();
+      this.width = currentColorAttachment.width;
+      this.height = currentColorAttachment.height;
+      this._createDepthStencilAttachment();
+      return new WebGPUFramebuffer(this.device, {
+        colorAttachments: [currentColorAttachment],
+        depthStencilAttachment: this.depthStencilAttachment
+      });
+    }
+    update() {
+      const [width, height] = this.getPixelSize();
+      const sizeChanged = width !== this.width || height !== this.height;
+      if (sizeChanged) {
+        this.width = width;
+        this.height = height;
+        if (this.depthStencilAttachment) {
+          this.depthStencilAttachment.destroy();
+          this.depthStencilAttachment = null;
+        }
+        this.gpuCanvasContext.configure({
+          device: this.device.handle,
+          format: getWebGPUTextureFormat(this.format),
+          colorSpace: this.props.colorSpace,
+          alphaMode: this.props.alphaMode
+        });
+        log.log(1, `Resized to ${this.width}x${this.height}px`)();
+      }
+    }
+    resize(options) {
+      this.update();
+    }
+    _createDepthStencilAttachment() {
+      if (!this.depthStencilAttachment) {
+        this.depthStencilAttachment = this.device.createTexture({
+          id: "depth-stencil-target",
+          format: this.depthStencilFormat,
+          width: this.width,
+          height: this.height,
+          usage: GPUTextureUsage.RENDER_ATTACHMENT
+        });
+      }
+      return this.depthStencilAttachment;
+    }
+  };
+
+  // src/adapter/webgpu-device.ts
+  var _WebGPUDevice = class extends Device {
+    canvasContext = null;
+    commandEncoder = null;
+    renderPass = null;
+    _isLost = false;
+    static isSupported() {
+      return Boolean(typeof navigator !== "undefined" && navigator.gpu);
+    }
+    static async create(props) {
+      if (!navigator.gpu) {
+        throw new Error("WebGPU not available. Open in Chrome Canary and turn on chrome://flags/#enable-unsafe-webgpu");
+      }
+      log.groupCollapsed(1, "WebGPUDevice created")();
+      const adapter = await navigator.gpu.requestAdapter({
+        powerPreference: "high-performance"
+      });
+      if (!adapter) {
+        throw new Error("Failed to request WebGPU adapter");
+      }
+      const adapterInfo = await adapter.requestAdapterInfo();
+      log.probe(1, "Adapter available", adapterInfo)();
+      const gpuDevice = await adapter.requestDevice({
+        requiredFeatures: adapter.features
+      });
+      log.probe(1, "GPUDevice available")();
+      if (typeof props.canvas === "string") {
+        await CanvasContext.pageLoaded;
+        log.probe(1, "DOM is loaded")();
+      }
+      const device = new _WebGPUDevice(gpuDevice, adapter, props);
+      log.probe(1, "Device created", device.info)();
+      log.table(1, device.info)();
+      log.groupEnd(1)();
+      return device;
+    }
+    constructor(device, adapter, props) {
+      super({
+        ...props,
+        id: props.id || uid("webgpu-device")
+      });
+      this.handle = device;
+      this.adapter = adapter;
+      this._info = {
+        type: "webgpu",
+        vendor: this.adapter.__brand,
+        renderer: "",
+        version: "",
+        gpu: "unknown",
+        shadingLanguage: "wgsl",
+        shadingLanguageVersion: 100,
+        vendorMasked: "",
+        rendererMasked: ""
+      };
+      this.lost = new Promise(async (resolve) => {
+        const lostInfo = await this.handle.lost;
+        this._isLost = true;
+        resolve({
+          reason: "destroyed",
+          message: lostInfo.message
+        });
+      });
+      this.canvasContext = new WebGPUCanvasContext(this, this.adapter, {
+        canvas: props.canvas,
+        height: props.height,
+        width: props.width,
+        container: props.container
+      });
+      this.features = this._getFeatures();
+    }
+    destroy() {
+      this.handle.destroy();
+    }
+    get info() {
+      return this._info;
+    }
+    get limits() {
+      return this.handle.limits;
+    }
+    isTextureFormatSupported(format) {
+      return !format.includes("webgl");
+    }
+    isTextureFormatFilterable(format) {
+      return this.isTextureFormatSupported(format);
+    }
+    isTextureFormatRenderable(format) {
+      return this.isTextureFormatSupported(format);
+    }
+    get isLost() {
+      return this._isLost;
+    }
+    createBuffer(props) {
+      const newProps = this._getBufferProps(props);
+      return new WebGPUBuffer(this, newProps);
+    }
+    _createTexture(props) {
+      return new WebGPUTexture(this, props);
+    }
+    createExternalTexture(props) {
+      return new WebGPUExternalTexture(this, props);
+    }
+    createShader(props) {
+      return new WebGPUShader(this, props);
+    }
+    createSampler(props) {
+      return new WebGPUSampler(this, props);
+    }
+    createRenderPipeline(props) {
+      return new WebGPURenderPipeline(this, props);
+    }
+    createFramebuffer(props) {
+      throw new Error("Not implemented");
+    }
+    createComputePipeline(props) {
+      return new WebGPUComputePipeline(this, props);
+    }
+    createVertexArray(props) {
+      return new WebGPUVertexArray(this, props);
+    }
+    beginRenderPass(props) {
+      this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();
+      return new WebGPURenderPass(this, props);
+    }
+    beginComputePass(props) {
+      this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();
+      return new WebGPUComputePass(this, props);
+    }
+    createTransformFeedback(props) {
+      throw new Error("Transform feedback not supported in WebGPU");
+    }
+    createCanvasContext(props) {
+      return new WebGPUCanvasContext(this, this.adapter, props);
+    }
+    getDefaultRenderPass() {
+      throw new Error("a");
+    }
+    submit() {
+      const commandBuffer = this.commandEncoder?.finish();
+      if (commandBuffer) {
+        this.handle.queue.submit([commandBuffer]);
+      }
+      this.commandEncoder = null;
+    }
+    _getFeatures() {
+      const features = new Set(this.handle.features);
+      if (features.has("depth-clamping")) {
+        features.delete("depth-clamping");
+        features.add("depth-clip-control");
+      }
+      if (features.has("texture-compression-bc")) {
+        features.add("texture-compression-bc5-webgl");
+      }
+      features.add("webgpu");
+      features.add("timer-query-webgl");
+      features.add("vertex-array-object-webgl1");
+      features.add("instanced-rendering-webgl1");
+      features.add("multiple-render-targets-webgl1");
+      features.add("index-uint32-webgl1");
+      features.add("blend-minmax-webgl1");
+      features.add("texture-blend-float-webgl1");
+      features.add("texture-formats-srgb-webgl1");
+      features.add("texture-formats-depth-webgl1");
+      features.add("texture-formats-float32-webgl1");
+      features.add("texture-formats-float16-webgl1");
+      features.add("texture-filter-linear-float32-webgl");
+      features.add("texture-filter-linear-float16-webgl");
+      features.add("texture-filter-anisotropic-webgl");
+      features.add("texture-renderable-rgba32float-webgl");
+      features.add("texture-renderable-float32-webgl");
+      features.add("texture-renderable-float16-webgl");
+      features.add("glsl-frag-data");
+      features.add("glsl-frag-depth");
+      features.add("glsl-derivatives");
+      features.add("glsl-texture-lod");
+      return features;
+    }
+    copyExternalImageToTexture(options) {
+      const {
+        source,
+        sourceX = 0,
+        sourceY = 0,
+        texture,
+        mipLevel = 0,
+        aspect = "all",
+        colorSpace = "display-p3",
+        premultipliedAlpha = false,
+        width = texture.width,
+        height = texture.height,
+        depth = 1
+      } = options;
+      const webGpuTexture = texture;
+      this.handle?.queue.copyExternalImageToTexture({
+        source,
+        origin: [sourceX, sourceY]
+      }, {
+        texture: webGpuTexture.handle,
+        origin: [0, 0, 0],
+        mipLevel,
+        aspect,
+        colorSpace,
+        premultipliedAlpha
+      }, [width, height, depth]);
+    }
+  };
+  var WebGPUDevice = _WebGPUDevice;
+  __publicField(WebGPUDevice, "type", "webgpu");
+  return __toCommonJS(src_exports);
+})();
+      return __exports__;
+      });