@carto/api-client 0.2.2-alpha.0 → 0.2.2

package/build/api-client.cjs

@@ -34,6 +34,8 @@ function setClient(c) {
   client = c;
 }
 
+/** Current version of @carto/api-client. */
+const API_CLIENT_VERSION = "0.2.2";
 /**
  * Defines a comparator used when matching a column's values against given filter values.
  *
@@ -101,7 +103,7 @@ function normalizeObjectKeys(el) {
   }, {});
 }
 /** @internalRemarks Source: @carto/react-core */
-function assert(condition, message) {
+function assert$2(condition, message) {
   if (!condition) {
     throw new Error(message);
   }
@@ -120,7 +122,7 @@ class InvalidColumnError extends Error {
   }
 }
 InvalidColumnError.NAME = 'InvalidColumnError';
-function isEmptyObject(object) {
+function isEmptyObject$1(object) {
   for (const _ in object) {
     return false;
   }
@@ -170,7 +172,7 @@ function removeFilter(filters, _ref2) {
       }
     }
   }
-  if (!owner || isEmptyObject(filter)) {
+  if (!owner || isEmptyObject$1(filter)) {
     delete filters[column];
   }
   return filters;
@@ -480,10 +482,10 @@ const REQUEST_GET_MAX_URL_LENGTH = 2048;
  * @internalRemarks Source: @carto/react-api
  */
 function executeModel(props) {
-  assert(props.source, 'executeModel: missing source');
-  assert(props.model, 'executeModel: missing model');
-  assert(props.params, 'executeModel: missing params');
-  assert(AVAILABLE_MODELS.includes(props.model), `executeModel: model provided isn't valid. Available models: ${AVAILABLE_MODELS.join(', ')}`);
+  assert$2(props.source, 'executeModel: missing source');
+  assert$2(props.model, 'executeModel: missing model');
+  assert$2(props.params, 'executeModel: missing params');
+  assert$2(AVAILABLE_MODELS.includes(props.model), `executeModel: model provided isn't valid. Available models: ${AVAILABLE_MODELS.join(', ')}`);
   const {
     model,
     source,
@@ -498,10 +500,10 @@ function executeModel(props) {
     connectionName,
     clientId
   } = source;
-  assert(apiBaseUrl, 'executeModel: missing apiBaseUrl');
-  assert(accessToken, 'executeModel: missing accessToken');
-  assert(apiVersion === V3, 'executeModel: SQL Model API requires CARTO 3+');
-  assert(type !== MapType.TILESET, 'executeModel: Tilesets not supported');
+  assert$2(apiBaseUrl, 'executeModel: missing apiBaseUrl');
+  assert$2(accessToken, 'executeModel: missing accessToken');
+  assert$2(apiVersion === V3, 'executeModel: SQL Model API requires CARTO 3+');
+  assert$2(type !== MapType.TILESET, 'executeModel: Tilesets not supported');
   let url = `${apiBaseUrl}/v3/sql/${connectionName}/model/${model}`;
   const {
     filters,
@@ -977,6 +979,1373 @@ class WidgetTableSource extends WidgetBaseSource {
   }
 }
 
+/**
+ * Throws an `Error` with the optional `message` if `condition` is falsy
+ * @note Replacement for the external assert method to reduce bundle size
+ */
+function assert$1(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'loader assertion failed.');
+  }
+}
+
+// Purpose: include this in your module to avoid
+/** true if running in a browser */
+const isBrowser$1 =
+// @ts-ignore process does not exist on browser
+Boolean(typeof process !== 'object' || String(process) !== '[object process]' || process.browser);
+// Extract node major version
+typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
+
+// Do not name these variables the same as the global objects - will break bundling
+const window_ = globalThis;
+const process_ = globalThis.process || {};
+
+// based on https://github.com/cheton/is-electron
+// https://github.com/electron/electron/issues/2288
+/* eslint-disable complexity */
+function isElectron(mockUserAgent) {
+  // Renderer process
+  // @ts-expect-error
+  if (typeof window !== 'undefined' && window.process?.type === 'renderer') {
+    return true;
+  }
+  // Main process
+  // eslint-disable-next-line
+  if (typeof process !== 'undefined' && Boolean(process.versions?.['electron'])) {
+    return true;
+  }
+  // Detect the user agent when the `nodeIntegration` option is set to true
+  const realUserAgent = typeof navigator !== 'undefined' && navigator.userAgent;
+  const userAgent = mockUserAgent || realUserAgent;
+  return Boolean(userAgent && userAgent.indexOf('Electron') >= 0);
+}
+
+// This function is needed in initialization stages,
+/** Check if in browser by duck-typing Node context */
+function isBrowser() {
+  const isNode =
+  // @ts-expect-error
+  typeof process === 'object' && String(process) === '[object process]' && !process?.browser;
+  return !isNode || isElectron();
+}
+
+// Extract injected version from package.json (injected by babel plugin)
+// @ts-expect-error
+const VERSION$2 = "4.0.7" ;
+// TODO - wish we could just export a constant
+// export const isBrowser = checkIfBrowser();
+
+// probe.gl, MIT license
+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;
+  }
+}
+// Store keys in local storage via simple interface
+class LocalStorage {
+  constructor(id, defaultConfig, type = 'sessionStorage') {
+    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);
+    }
+  }
+  // Get config from persistent store, if available
+  _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;
+  }
+}
+
+// probe.gl, MIT license
+/**
+ * Format time
+ */
+function formatTime(ms) {
+  let formatted;
+  if (ms < 10) {
+    formatted = `${ms.toFixed(2)}ms`;
+  } else if (ms < 100) {
+    formatted = `${ms.toFixed(1)}ms`;
+  } else if (ms < 1000) {
+    formatted = `${ms.toFixed(0)}ms`;
+  } else {
+    formatted = `${(ms / 1000).toFixed(2)}s`;
+  }
+  return formatted;
+}
+function leftPad(string, length = 8) {
+  const padLength = Math.max(length - string.length, 0);
+  return `${' '.repeat(padLength)}${string}`;
+}
+
+var COLOR;
+(function (COLOR) {
+  COLOR[COLOR["BLACK"] = 30] = "BLACK";
+  COLOR[COLOR["RED"] = 31] = "RED";
+  COLOR[COLOR["GREEN"] = 32] = "GREEN";
+  COLOR[COLOR["YELLOW"] = 33] = "YELLOW";
+  COLOR[COLOR["BLUE"] = 34] = "BLUE";
+  COLOR[COLOR["MAGENTA"] = 35] = "MAGENTA";
+  COLOR[COLOR["CYAN"] = 36] = "CYAN";
+  COLOR[COLOR["WHITE"] = 37] = "WHITE";
+  COLOR[COLOR["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+  COLOR[COLOR["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+  COLOR[COLOR["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+  COLOR[COLOR["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+  COLOR[COLOR["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+  COLOR[COLOR["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+  COLOR[COLOR["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+  COLOR[COLOR["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+})(COLOR || (COLOR = {}));
+const 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 = `\u001b[${colorCode}m${string}\u001b[39m`;
+    }
+    if (background) {
+      // background colors values are +10
+      const colorCode = getColor(background);
+      string = `\u001b[${colorCode + BACKGROUND_INCREMENT}m${string}\u001b[49m`;
+    }
+  }
+  return string;
+}
+
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/**
+ * Binds the "this" argument of all functions on a class instance to the instance
+ * @param obj - class instance (typically a react component)
+ */
+function autobind(obj, predefined = ['constructor']) {
+  const proto = Object.getPrototypeOf(obj);
+  const propNames = Object.getOwnPropertyNames(proto);
+  const object = obj;
+  for (const key of propNames) {
+    const value = object[key];
+    if (typeof value === 'function') {
+      if (!predefined.find(name => key === name)) {
+        object[key] = value.bind(obj);
+      }
+    }
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'Assertion failed');
+  }
+}
+
+// probe.gl, MIT license
+/** Get best timer available. */
+function getHiResTimestamp() {
+  let timestamp;
+  if (isBrowser() && window_.performance) {
+    timestamp = window_?.performance?.now?.();
+  } else if ('hrtime' in process_) {
+    // @ts-ignore
+    const timeParts = process_?.hrtime?.();
+    timestamp = timeParts[0] * 1000 + timeParts[1] / 1e6;
+  } else {
+    timestamp = Date.now();
+  }
+  return timestamp;
+}
+
+// probe.gl, MIT license
+// Instrumentation in other packages may override console methods, so preserve them here
+const originalConsole = {
+  debug: isBrowser() ? console.debug || console.log : console.log,
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error
+};
+const DEFAULT_LOG_CONFIGURATION = {
+  enabled: true,
+  level: 0
+};
+function noop() {} // eslint-disable-line @typescript-eslint/no-empty-function
+const cache = {};
+const ONCE = {
+  once: true
+};
+/** A console wrapper */
+class Log {
+  constructor({
+    id
+  } = {
+    id: ''
+  }) {
+    this.VERSION = VERSION$2;
+    this._startTs = getHiResTimestamp();
+    this._deltaTs = getHiResTimestamp();
+    this.userData = {};
+    // TODO - fix support from throttling groups
+    this.LOG_THROTTLE_TIMEOUT = 0; // Time before throttled messages are logged again
+    this.id = id;
+    this.userData = {};
+    this._storage = new LocalStorage(`__probe-${this.id}__`, DEFAULT_LOG_CONFIGURATION);
+    this.timeStamp(`${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;
+  }
+  /** @return milliseconds, with fractions */
+  getTotal() {
+    return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
+  }
+  /** @return milliseconds, with fractions */
+  getDelta() {
+    return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
+  }
+  /** @deprecated use logLevel */
+  set priority(newPriority) {
+    this.level = newPriority;
+  }
+  /** @deprecated use logLevel */
+  get priority() {
+    return this.level;
+  }
+  /** @deprecated use logLevel */
+  getPriority() {
+    return this.level;
+  }
+  // Configure
+  enable(enabled = true) {
+    this._storage.setConfiguration({
+      enabled
+    });
+    return this;
+  }
+  setLevel(level) {
+    this._storage.setConfiguration({
+      level
+    });
+    return this;
+  }
+  /** return the current status of the setting */
+  get(setting) {
+    return this._storage.config[setting];
+  }
+  // update the status of the setting
+  set(setting, value) {
+    this._storage.setConfiguration({
+      [setting]: value
+    });
+  }
+  /** Logs the current settings as a table */
+  settings() {
+    if (console.table) {
+      console.table(this._storage.config);
+    } else {
+      console.log(this._storage.config);
+    }
+  }
+  // Unconditional logging
+  assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || 'Assertion failed');
+    }
+  }
+  warn(message) {
+    return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);
+  }
+  error(message) {
+    return this._getLogFunction(0, message, originalConsole.error, arguments);
+  }
+  /** Print a deprecation warning */
+  deprecated(oldUsage, newUsage) {
+    return this.warn(`\`${oldUsage}\` is deprecated and will be removed \
+in a later version. Use \`${newUsage}\` instead`);
+  }
+  /** Print a removal warning */
+  removed(oldUsage, newUsage) {
+    return this.error(`\`${oldUsage}\` has been removed. Use \`${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);
+  }
+  /** Logs an object as a table */
+  table(logLevel, table, columns) {
+    if (table) {
+      return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
+        tag: getTableHeader(table)
+      });
+    }
+    return noop;
+  }
+  time(logLevel, message) {
+    return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+  }
+  timeEnd(logLevel, message) {
+    return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+  }
+  timeStamp(logLevel, message) {
+    return this._getLogFunction(logLevel, message, console.timeStamp || noop);
+  }
+  group(logLevel, message, opts = {
+    collapsed: false
+  }) {
+    const options = normalizeArguments({
+      logLevel,
+      message,
+      opts
+    });
+    const {
+      collapsed
+    } = opts;
+    // @ts-expect-error
+    options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+    return this._getLogFunction(options);
+  }
+  groupCollapsed(logLevel, message, opts = {}) {
+    return this.group(logLevel, message, Object.assign({}, opts, {
+      collapsed: true
+    }));
+  }
+  groupEnd(logLevel) {
+    return this._getLogFunction(logLevel, '', console.groupEnd || noop);
+  }
+  // EXPERIMENTAL
+  withGroup(logLevel, message, func) {
+    this.group(logLevel, message)();
+    try {
+      func();
+    } finally {
+      this.groupEnd(logLevel)();
+    }
+  }
+  trace() {
+    if (console.trace) {
+      console.trace();
+    }
+  }
+  // PRIVATE METHODS
+  /** Deduces log level from a variety of arguments */
+  _shouldLog(logLevel) {
+    return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
+  }
+  _getLogFunction(logLevel, message, method, args, opts) {
+    if (this._shouldLog(logLevel)) {
+      // normalized opts + timings
+      opts = normalizeArguments({
+        logLevel,
+        message,
+        args,
+        opts
+      });
+      method = method || opts.method;
+      assert(method);
+      opts.total = this.getTotal();
+      opts.delta = this.getDelta();
+      // reset delta timer
+      this._deltaTs = getHiResTimestamp();
+      const tag = opts.tag || opts.message;
+      if (opts.once && tag) {
+        if (!cache[tag]) {
+          cache[tag] = getHiResTimestamp();
+        } else {
+          return noop;
+        }
+      }
+      // TODO - Make throttling work with groups
+      // if (opts.nothrottle || !throttle(tag, this.LOG_THROTTLE_TIMEOUT)) {
+      //   return noop;
+      // }
+      message = decorateMessage(this.id, opts.message, opts);
+      // Bind console function so that it can be called after being returned
+      return method.bind(console, message, ...opts.args);
+    }
+    return noop;
+  }
+}
+Log.VERSION = VERSION$2;
+/**
+ * Get logLevel from first argument:
+ * - log(logLevel, message, args) => logLevel
+ * - log(message, args) => 0
+ * - log({logLevel, ...}, message, args) => logLevel
+ * - log({logLevel, message, args}) => logLevel
+ */
+function normalizeLogLevel(logLevel) {
+  if (!logLevel) {
+    return 0;
+  }
+  let resolvedLevel;
+  switch (typeof logLevel) {
+    case 'number':
+      resolvedLevel = logLevel;
+      break;
+    case 'object':
+      // Backward compatibility
+      // TODO - deprecate `priority`
+      // @ts-expect-error
+      resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+      break;
+    default:
+      return 0;
+  }
+  // 'log level must be a number'
+  assert(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+  return resolvedLevel;
+}
+/**
+ * "Normalizes" the various argument patterns into an object with known types
+ * - log(logLevel, message, args) => {logLevel, message, args}
+ * - log(message, args) => {logLevel: 0, message, args}
+ * - log({logLevel, ...}, message, args) => {logLevel, message, args}
+ * - log({logLevel, message, args}) => {logLevel, message, args}
+ */
+function normalizeArguments(opts) {
+  const {
+    logLevel,
+    message
+  } = opts;
+  opts.logLevel = normalizeLogLevel(logLevel);
+  // We use `arguments` instead of rest parameters (...args) because IE
+  // does not support the syntax. Rest parameters is transpiled to code with
+  // perf impact. Doing it here instead avoids constructing args when logging is
+  // disabled.
+  // TODO - remove when/if IE support is dropped
+  const args = opts.args ? Array.from(opts.args) : [];
+  // args should only contain arguments that appear after `message`
+  // eslint-disable-next-line no-empty
+  while (args.length && args.shift() !== message) {}
+  switch (typeof logLevel) {
+    case 'string':
+    case 'function':
+      if (message !== undefined) {
+        args.unshift(message);
+      }
+      opts.message = logLevel;
+      break;
+    case 'object':
+      Object.assign(opts, logLevel);
+      break;
+  }
+  // Resolve functions into strings by calling them
+  if (typeof opts.message === 'function') {
+    opts.message = opts.message();
+  }
+  const messageType = typeof opts.message;
+  // 'log message must be a string' or object
+  assert(messageType === 'string' || messageType === 'object');
+  // original opts + normalized opts + opts arg + fixed up message
+  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 ? `${id}: ${time}  ${message}` : `${id}: ${message}`;
+    message = addColor(message, opts.color, opts.background);
+  }
+  return message;
+}
+function getTableHeader(table) {
+  for (const key in table) {
+    for (const title in table[key]) {
+      return title || 'untitled';
+    }
+  }
+  return 'empty';
+}
+
+// loaders.gl
+/**
+ * Helper for safely accessing global loaders.gl variables
+ * Wraps initialization of global variable in function to defeat overly aggressive tree-shakers
+ */
+function getGlobalLoaderState() {
+  // @ts-ignore
+  globalThis.loaders = globalThis.loaders || {};
+  // @ts-ignore
+  const {
+    loaders
+  } = globalThis;
+  // Add _state object to keep separate from modules added to globalThis.loaders
+  if (!loaders._state) {
+    loaders._state = {};
+  }
+  return loaders._state;
+}
+
+// loaders.gl
+function isLoaderObject(loader) {
+  if (!loader) {
+    return false;
+  }
+  if (Array.isArray(loader)) {
+    loader = loader[0];
+  }
+  const hasExtensions = Array.isArray(loader?.extensions);
+  /* Now handled by types and worker loaders do not have these
+  let hasParser =
+    loader.parseTextSync ||
+    loader.parseSync ||
+    loader.parse ||
+    loader.parseStream || // TODO Remove, Replace with parseInBatches
+    loader.parseInBatches;
+  */
+  return hasExtensions;
+}
+function normalizeLoader(loader) {
+  // This error is fairly easy to trigger by mixing up import statements etc
+  // So we make an exception and add a developer error message for this case
+  // To help new users from getting stuck here
+  assert$1(loader, 'null loader');
+  assert$1(isLoaderObject(loader), 'invalid loader');
+  // NORMALIZE [LOADER, OPTIONS] => LOADER
+  // If [loader, options], create a new loaders object with options merged in
+  let options;
+  if (Array.isArray(loader)) {
+    options = loader[1];
+    loader = loader[0];
+    loader = {
+      ...loader,
+      options: {
+        ...loader.options,
+        ...options
+      }
+    };
+  }
+  // NORMALIZE text and binary flags
+  // Ensure at least one of text/binary flags are properly set
+  // @ts-expect-error
+  if (loader?.parseTextSync || loader?.parseText) {
+    loader.text = true;
+  }
+  if (!loader.text) {
+    loader.binary = true;
+  }
+  return loader;
+}
+
+// loaders.gl
+/**
+ * Store global registered loaders on the global object to increase chances of cross loaders-version interoperability
+ * This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks
+ */
+const getGlobalLoaderRegistry = () => {
+  const state = getGlobalLoaderState();
+  state.loaderRegistry = state.loaderRegistry || [];
+  return state.loaderRegistry;
+};
+/** Register a list of global loaders */
+function registerLoaders(loaders) {
+  const loaderRegistry = getGlobalLoaderRegistry();
+  loaders = Array.isArray(loaders) ? loaders : [loaders];
+  for (const loader of loaders) {
+    const normalizedLoader = normalizeLoader(loader);
+    if (!loaderRegistry.find(registeredLoader => normalizedLoader === registeredLoader)) {
+      // add to the beginning of the loaderRegistry, so the last registeredLoader get picked
+      loaderRegistry.unshift(normalizedLoader);
+    }
+  }
+}
+
+// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION$1 = "4.2.3" ;
+
+// @ts-ignore TS2339: Property does not exist on type
+const parseImageNode = globalThis.loaders?.parseImageNode;
+const IMAGE_SUPPORTED = typeof Image !== 'undefined'; // NOTE: "false" positives if jsdom is installed
+const IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== 'undefined';
+const NODE_IMAGE_SUPPORTED = Boolean(parseImageNode);
+const DATA_SUPPORTED = isBrowser$1 ? true : NODE_IMAGE_SUPPORTED;
+/**
+ * Checks if a loaders.gl image type is supported
+ * @param type image type string
+ */
+function isImageTypeSupported(type) {
+  switch (type) {
+    case 'auto':
+      // Should only ever be false in Node.js, if polyfills have not been installed...
+      return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+    case 'imagebitmap':
+      return IMAGE_BITMAP_SUPPORTED;
+    case 'image':
+      return IMAGE_SUPPORTED;
+    case 'data':
+      return DATA_SUPPORTED;
+    default:
+      throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
+  }
+}
+/**
+ * Returns the "most performant" supported image type on this platform
+ * @returns image type string
+ */
+function getDefaultImageType() {
+  if (IMAGE_BITMAP_SUPPORTED) {
+    return 'imagebitmap';
+  }
+  if (IMAGE_SUPPORTED) {
+    return 'image';
+  }
+  if (DATA_SUPPORTED) {
+    return 'data';
+  }
+  // This should only happen in Node.js
+  throw new Error('Install \'@loaders.gl/polyfills\' to parse images under Node.js');
+}
+
+function getImageType(image) {
+  const format = getImageTypeOrNull(image);
+  if (!format) {
+    throw new Error('Not an image');
+  }
+  return format;
+}
+function getImageData(image) {
+  switch (getImageType(image)) {
+    case 'data':
+      return image;
+    case 'image':
+    case 'imagebitmap':
+      // Extract the image data from the image via a canvas
+      const canvas = document.createElement('canvas');
+      // TODO - reuse the canvas?
+      const context = canvas.getContext('2d');
+      if (!context) {
+        throw new Error('getImageData');
+      }
+      // @ts-ignore
+      canvas.width = image.width;
+      // @ts-ignore
+      canvas.height = image.height;
+      // @ts-ignore
+      context.drawImage(image, 0, 0);
+      // @ts-ignore
+      return context.getImageData(0, 0, image.width, image.height);
+    default:
+      throw new Error('getImageData');
+  }
+}
+// PRIVATE
+// eslint-disable-next-line complexity
+function getImageTypeOrNull(image) {
+  if (typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
+    return 'imagebitmap';
+  }
+  if (typeof Image !== 'undefined' && image instanceof Image) {
+    return 'image';
+  }
+  if (image && typeof image === 'object' && image.data && image.width && image.height) {
+    return 'data';
+  }
+  return null;
+}
+
+// SVG parsing has limitations, e.g:
+// https://bugs.chromium.org/p/chromium/issues/detail?id=606319
+const SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+const SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+function isSVG(url) {
+  return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+}
+function getBlobOrSVGDataUrl(arrayBuffer, url) {
+  if (isSVG(url)) {
+    // Prepare a properly tagged data URL, and load using normal mechanism
+    const textDecoder = new TextDecoder();
+    let xmlText = textDecoder.decode(arrayBuffer);
+    // TODO Escape in browser to support e.g. Chinese characters
+    try {
+      if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {
+        xmlText = unescape(encodeURIComponent(xmlText));
+      }
+    } catch (error) {
+      throw new Error(error.message);
+    }
+    // base64 encoding is safer. utf-8 fails in some browsers
+    const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+    return src;
+  }
+  return getBlob(arrayBuffer, url);
+}
+function getBlob(arrayBuffer, url) {
+  if (isSVG(url)) {
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=606319
+    // return new Blob([new Uint8Array(arrayBuffer)], {type: 'image/svg+xml'});
+    throw new Error('SVG cannot be parsed directly to imagebitmap');
+  }
+  // TODO - how to determine mime type? Param? Sniff here?
+  return new Blob([new Uint8Array(arrayBuffer)]); // MIME type not needed?
+}
+
+// Parses html image from array buffer
+async function parseToImage(arrayBuffer, options, url) {
+  // Note: image parsing requires conversion to Blob (for createObjectURL).
+  // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...
+  // But presumably not worth adding 'blob' flag to loader objects?
+  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
+  const URL = self.URL || self.webkitURL;
+  const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);
+  try {
+    return await loadToImage(objectUrl || blobOrDataUrl, options);
+  } finally {
+    if (objectUrl) {
+      URL.revokeObjectURL(objectUrl);
+    }
+  }
+}
+async function loadToImage(url, options) {
+  const image = new Image();
+  image.src = url;
+  // The `image.onload()` callback does not guarantee that the image has been decoded
+  // so a main thread "freeze" can be incurred when using the image for the first time.
+  // `Image.decode()` returns a promise that completes when image is decoded.
+  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode
+  // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`
+  // Note: `HTMLImageElement.decode()` is not available in Edge and IE11
+  if (options.image && options.image.decode && image.decode) {
+    await image.decode();
+    return image;
+  }
+  // Create a promise that tracks onload/onerror callbacks
+  return await new Promise((resolve, reject) => {
+    try {
+      image.onload = () => resolve(image);
+      image.onerror = error => {
+        const message = error instanceof Error ? error.message : 'error';
+        reject(new Error(message));
+      };
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+const EMPTY_OBJECT = {};
+let imagebitmapOptionsSupported = true;
+/**
+ * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data
+ * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari
+ * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility
+ *
+ * TODO - createImageBitmap supports source rect (5 param overload), pass through?
+ */
+async function parseToImageBitmap(arrayBuffer, options, url) {
+  let blob;
+  // Cannot parse SVG directly to ImageBitmap, parse to Image first
+  if (isSVG(url)) {
+    // Note: this only works on main thread
+    const image = await parseToImage(arrayBuffer, options, url);
+    blob = image;
+  } else {
+    // Create blob from the array buffer
+    blob = getBlob(arrayBuffer, url);
+  }
+  const imagebitmapOptions = options && options.imagebitmap;
+  return await safeCreateImageBitmap(blob, imagebitmapOptions);
+}
+/**
+ * Safely creates an imageBitmap with options
+ * *
+ * Firefox crashes if imagebitmapOptions is supplied
+ * Avoid supplying if not provided or supported, remember if not supported
+ */
+async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+    imagebitmapOptions = null;
+  }
+  if (imagebitmapOptions) {
+    try {
+      // @ts-ignore Options
+      return await createImageBitmap(blob, imagebitmapOptions);
+    } catch (error) {
+      console.warn(error); // eslint-disable-line
+      imagebitmapOptionsSupported = false;
+    }
+  }
+  return await createImageBitmap(blob);
+}
+function isEmptyObject(object) {
+  // @ts-ignore
+  for (const key in object || EMPTY_OBJECT) {
+    return false;
+  }
+  return true;
+}
+
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// code adapted from https://github.com/sindresorhus/file-type under MIT license
+/**
+ * Tests if a buffer is in ISO base media file format (ISOBMFF) @see https://en.wikipedia.org/wiki/ISO_base_media_file_format
+ * (ISOBMFF is a media container standard based on the Apple QuickTime container format)
+ */
+function getISOBMFFMediaType(buffer) {
+  // Almost all ISO base media files start with `ftyp` box. (It's not required to be first, but it's recommended to be.)
+  if (!checkString(buffer, 'ftyp', 4)) {
+    return null;
+  }
+  // Extra check: test for 8859-1 printable characters (for simplicity, it's a mask which also catches one non-printable character).
+  if ((buffer[8] & 0x60) === 0x00) {
+    return null;
+  }
+  // `ftyp` box must contain a brand major identifier, which must consist of ISO 8859-1 printable characters.
+  return decodeMajorBrand(buffer);
+}
+/**
+ * brands explained @see https://github.com/strukturag/libheif/issues/83
+ * code adapted from @see https://github.com/sindresorhus/file-type/blob/main/core.js#L489-L492
+ */
+function decodeMajorBrand(buffer) {
+  const brandMajor = getUTF8String(buffer, 8, 12).replace('\0', ' ').trim();
+  switch (brandMajor) {
+    case 'avif':
+    case 'avis':
+      return {
+        extension: 'avif',
+        mimeType: 'image/avif'
+      };
+    default:
+      return null;
+  }
+  // We don't need these now, but they are easy to add
+  // case 'mif1':
+  //   return {extension: 'heic', mimeType: 'image/heif'};
+  // case 'msf1':
+  //   return {extension: 'heic', mimeType: 'image/heif-sequence'};
+  // case 'heic':
+  // case 'heix':
+  //   return {extension: 'heic', mimeType: 'image/heic'};
+  // case 'hevc':
+  // case 'hevx':
+  //   return {extension: 'heic', mimeType: 'image/heic-sequence'};
+  // case 'qt':
+  //   return {ext: 'mov', mime: 'video/quicktime'};
+  // case 'M4V':
+  // case 'M4VH':
+  // case 'M4VP':
+  //   return {ext: 'm4v', mime: 'video/x-m4v'};
+  // case 'M4P':
+  //   return {ext: 'm4p', mime: 'video/mp4'};
+  // case 'M4B':
+  //   return {ext: 'm4b', mime: 'audio/mp4'};
+  // case 'M4A':
+  //   return {ext: 'm4a', mime: 'audio/x-m4a'};
+  // case 'F4V':
+  //   return {ext: 'f4v', mime: 'video/mp4'};
+  // case 'F4P':
+  //   return {ext: 'f4p', mime: 'video/mp4'};
+  // case 'F4A':
+  //   return {ext: 'f4a', mime: 'audio/mp4'};
+  // case 'F4B':
+  //   return {ext: 'f4b', mime: 'audio/mp4'};
+  // case 'crx':
+  //   return {ext: 'cr3', mime: 'image/x-canon-cr3'};
+  // default:
+  // if (brandMajor.startsWith('3g')) {
+  //   if (brandMajor.startsWith('3g2')) {
+  //     return {ext: '3g2', mime: 'video/3gpp2'};
+  //   }
+  //   return {ext: '3gp', mime: 'video/3gpp'};
+  // }
+  // return {ext: 'mp4', mime: 'video/mp4'};
+}
+/** Interpret a chunk of bytes as a UTF8 string */
+function getUTF8String(array, start, end) {
+  return String.fromCharCode(...array.slice(start, end));
+}
+function stringToBytes(string) {
+  return [...string].map(character => character.charCodeAt(0));
+}
+function checkString(buffer, header, offset = 0) {
+  const headerBytes = stringToBytes(header);
+  for (let i = 0; i < headerBytes.length; ++i) {
+    if (headerBytes[i] !== buffer[i + offset]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// Attributions
+const BIG_ENDIAN = false;
+const LITTLE_ENDIAN = true;
+/**
+ * Extracts `{mimeType, width and height}` from a memory buffer containing a known image format
+ * Currently supports `image/png`, `image/jpeg`, `image/bmp` and `image/gif`.
+ * @param binaryData: DataView | ArrayBuffer image file memory to parse
+ * @returns metadata or null if memory is not a valid image file format layout.
+ */
+function getBinaryImageMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+}
+// ISOBMFF
+function getISOBMFFMetadata(binaryData) {
+  const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+  const mediaType = getISOBMFFMediaType(buffer);
+  if (!mediaType) {
+    return null;
+  }
+  return {
+    mimeType: mediaType.mimeType,
+    // TODO - decode width and height
+    width: 0,
+    height: 0
+  };
+}
+// PNG
+function getPngMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  // Check file contains the first 4 bytes of the PNG signature.
+  const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 0x89504e47;
+  if (!isPng) {
+    return null;
+  }
+  // Extract size from a binary PNG file
+  return {
+    mimeType: 'image/png',
+    width: dataView.getUint32(16, BIG_ENDIAN),
+    height: dataView.getUint32(20, BIG_ENDIAN)
+  };
+}
+// GIF
+// Extract size from a binary GIF file
+// TODO: GIF is not this simple
+function getGifMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  // Check first 4 bytes of the GIF signature ("GIF8").
+  const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 0x47494638;
+  if (!isGif) {
+    return null;
+  }
+  // GIF is little endian.
+  return {
+    mimeType: 'image/gif',
+    width: dataView.getUint16(6, LITTLE_ENDIAN),
+    height: dataView.getUint16(8, LITTLE_ENDIAN)
+  };
+}
+// BMP
+// TODO: BMP is not this simple
+function getBmpMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  // Check magic number is valid (first 2 characters should be "BM").
+  // The mandatory bitmap file header is 14 bytes long.
+  const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 0x424d && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
+  if (!isBmp) {
+    return null;
+  }
+  // BMP is little endian.
+  return {
+    mimeType: 'image/bmp',
+    width: dataView.getUint32(18, LITTLE_ENDIAN),
+    height: dataView.getUint32(22, LITTLE_ENDIAN)
+  };
+}
+// JPEG
+// Extract width and height from a binary JPEG file
+function getJpegMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  // Check file contains the JPEG "start of image" (SOI) marker
+  // followed by another marker.
+  const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 0xffd8 && dataView.getUint8(2) === 0xff;
+  if (!isJpeg) {
+    return null;
+  }
+  const {
+    tableMarkers,
+    sofMarkers
+  } = getJpegMarkers();
+  // Exclude the two byte SOI marker.
+  let i = 2;
+  while (i + 9 < dataView.byteLength) {
+    const marker = dataView.getUint16(i, BIG_ENDIAN);
+    // The frame that contains the width and height of the JPEG image.
+    if (sofMarkers.has(marker)) {
+      return {
+        mimeType: 'image/jpeg',
+        height: dataView.getUint16(i + 5, BIG_ENDIAN),
+        // Number of lines
+        width: dataView.getUint16(i + 7, BIG_ENDIAN) // Number of pixels per line
+      };
+    }
+    // Miscellaneous tables/data preceding the frame header.
+    if (!tableMarkers.has(marker)) {
+      return null;
+    }
+    // Length includes size of length parameter but not the two byte header.
+    i += 2;
+    i += dataView.getUint16(i, BIG_ENDIAN);
+  }
+  return null;
+}
+function getJpegMarkers() {
+  // Tables/misc header markers.
+  // DQT, DHT, DAC, DRI, COM, APP_n
+  const tableMarkers = new Set([0xffdb, 0xffc4, 0xffcc, 0xffdd, 0xfffe]);
+  for (let i = 0xffe0; i < 0xfff0; ++i) {
+    tableMarkers.add(i);
+  }
+  // SOF markers and DHP marker.
+  // These markers are after tables/misc data.
+  const sofMarkers = new Set([0xffc0, 0xffc1, 0xffc2, 0xffc3, 0xffc5, 0xffc6, 0xffc7, 0xffc9, 0xffca, 0xffcb, 0xffcd, 0xffce, 0xffcf, 0xffde]);
+  return {
+    tableMarkers,
+    sofMarkers
+  };
+}
+// TODO - move into image module?
+function toDataView(data) {
+  if (data instanceof DataView) {
+    return data;
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new DataView(data.buffer);
+  }
+  // TODO: make these functions work for Node.js buffers?
+  // if (bufferToArrayBuffer) {
+  //   data = bufferToArrayBuffer(data);
+  // }
+  // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)
+  if (data instanceof ArrayBuffer) {
+    return new DataView(data);
+  }
+  throw new Error('toDataView');
+}
+
+// Use polyfills if installed to parsed image using get-pixels
+async function parseToNodeImage(arrayBuffer, options) {
+  const {
+    mimeType
+  } = getBinaryImageMetadata(arrayBuffer) || {};
+  // @ts-ignore
+  const parseImageNode = globalThis.loaders?.parseImageNode;
+  assert$1(parseImageNode); // '@loaders.gl/polyfills not installed'
+  // @ts-expect-error TODO should we throw error in this case?
+  return await parseImageNode(arrayBuffer, mimeType);
+}
+
+// Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)
+// eslint-disable-next-line complexity
+async function parseImage(arrayBuffer, options, context) {
+  options = options || {};
+  const imageOptions = options.image || {};
+  // The user can request a specific output format via `options.image.type`
+  const imageType = imageOptions.type || 'auto';
+  const {
+    url
+  } = context || {};
+  // Note: For options.image.type === `data`, we may still need to load as `image` or `imagebitmap`
+  const loadType = getLoadableImageType(imageType);
+  let image;
+  switch (loadType) {
+    case 'imagebitmap':
+      image = await parseToImageBitmap(arrayBuffer, options, url);
+      break;
+    case 'image':
+      image = await parseToImage(arrayBuffer, options, url);
+      break;
+    case 'data':
+      // Node.js loads imagedata directly
+      image = await parseToNodeImage(arrayBuffer);
+      break;
+    default:
+      assert$1(false);
+  }
+  // Browser: if options.image.type === 'data', we can now extract data from the loaded image
+  if (imageType === 'data') {
+    image = getImageData(image);
+  }
+  return image;
+}
+// Get a loadable image type from image type
+function getLoadableImageType(type) {
+  switch (type) {
+    case 'auto':
+    case 'data':
+      // Browser: For image data we need still need to load using an image format
+      // Node: the default image type is `data`.
+      return getDefaultImageType();
+    default:
+      // Throw an error if not supported
+      isImageTypeSupported(type);
+      return type;
+  }
+}
+
+// import type { ImageType } from '@loaders.gl/schema';
+const EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'ico', 'svg', 'avif'];
+const MIME_TYPES = ['image/png', 'image/jpeg', 'image/gif', 'image/webp', 'image/avif', 'image/bmp', 'image/vnd.microsoft.icon', 'image/svg+xml'];
+const DEFAULT_IMAGE_LOADER_OPTIONS = {
+  image: {
+    type: 'auto',
+    decode: true // if format is HTML
+  }
+  // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
+};
+/**
+ * Loads a platform-specific image type
+ * Note: This type can be used as input data to WebGL texture creation
+ */
+const ImageLoader = {
+  dataType: null,
+  batchType: null,
+  id: 'image',
+  module: 'images',
+  name: 'Images',
+  version: VERSION$1,
+  mimeTypes: MIME_TYPES,
+  extensions: EXTENSIONS,
+  parse: parseImage,
+  // TODO: byteOffset, byteLength;
+  tests: [arrayBuffer => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
+  options: DEFAULT_IMAGE_LOADER_OPTIONS
+};
+
+const defaultLogger = new Log({
+  id: 'deck'
+});
+var log = defaultLogger;
+
+const logState = {
+  attributeUpdateStart: -1,
+  attributeManagerUpdateStart: -1,
+  attributeUpdateMessages: []
+};
+const LOG_LEVEL_MAJOR_UPDATE = 1; // Events with direct perf impact
+const LOG_LEVEL_MINOR_UPDATE = 2; // Events that may affect perf
+const LOG_LEVEL_UPDATE_DETAIL = 3;
+const LOG_LEVEL_INFO = 4;
+const LOG_LEVEL_DRAW = 2;
+const getLoggers = log => ({
+  /* Layer events */
+  'layer.changeFlag': (layer, key, flags) => {
+    log.log(LOG_LEVEL_UPDATE_DETAIL, `${layer.id} ${key}: `, flags[key])();
+  },
+  'layer.initialize': layer => {
+    log.log(LOG_LEVEL_MAJOR_UPDATE, `Initializing ${layer}`)();
+  },
+  'layer.update': (layer, needsUpdate) => {
+    if (needsUpdate) {
+      const flags = layer.getChangeFlags();
+      log.log(LOG_LEVEL_MINOR_UPDATE, `Updating ${layer} because: ${Object.keys(flags).filter(key => flags[key]).join(', ')}`)();
+    } else {
+      log.log(LOG_LEVEL_INFO, `${layer} does not need update`)();
+    }
+  },
+  'layer.matched': (layer, changed) => {
+    if (changed) {
+      log.log(LOG_LEVEL_INFO, `Matched ${layer}, state transfered`)();
+    }
+  },
+  'layer.finalize': layer => {
+    log.log(LOG_LEVEL_MAJOR_UPDATE, `Finalizing ${layer}`)();
+  },
+  /* CompositeLayer events */
+  'compositeLayer.renderLayers': (layer, updated, subLayers) => {
+    if (updated) {
+      log.log(LOG_LEVEL_MINOR_UPDATE, `Composite layer rendered new subLayers ${layer}`, subLayers)();
+    } else {
+      log.log(LOG_LEVEL_INFO, `Composite layer reused subLayers ${layer}`, subLayers)();
+    }
+  },
+  /* LayerManager events */
+  'layerManager.setLayers': (layerManager, updated, layers) => {
+    if (updated) {
+      log.log(LOG_LEVEL_MINOR_UPDATE, `Updating ${layers.length} deck layers`)();
+    }
+  },
+  'layerManager.activateViewport': (layerManager, viewport) => {
+    log.log(LOG_LEVEL_UPDATE_DETAIL, 'Viewport changed', viewport)();
+  },
+  /* AttributeManager events */
+  'attributeManager.invalidate': (attributeManager, trigger, attributeNames) => {
+    log.log(LOG_LEVEL_MAJOR_UPDATE, attributeNames ? `invalidated attributes ${attributeNames} (${trigger}) for ${attributeManager.id}` : `invalidated all attributes for ${attributeManager.id}`)();
+  },
+  'attributeManager.updateStart': attributeManager => {
+    logState.attributeUpdateMessages.length = 0;
+    logState.attributeManagerUpdateStart = Date.now();
+  },
+  'attributeManager.updateEnd': (attributeManager, numInstances) => {
+    const timeMs = Math.round(Date.now() - logState.attributeManagerUpdateStart);
+    log.groupCollapsed(LOG_LEVEL_MINOR_UPDATE, `Updated attributes for ${numInstances} instances in ${attributeManager.id} in ${timeMs}ms`)();
+    for (const updateMessage of logState.attributeUpdateMessages) {
+      log.log(LOG_LEVEL_UPDATE_DETAIL, updateMessage)();
+    }
+    log.groupEnd(LOG_LEVEL_MINOR_UPDATE)();
+  },
+  /* Attribute events */
+  'attribute.updateStart': attribute => {
+    logState.attributeUpdateStart = Date.now();
+  },
+  'attribute.allocate': (attribute, numInstances) => {
+    const message = `${attribute.id} allocated ${numInstances}`;
+    logState.attributeUpdateMessages.push(message);
+  },
+  'attribute.updateEnd': (attribute, numInstances) => {
+    const timeMs = Math.round(Date.now() - logState.attributeUpdateStart);
+    const message = `${attribute.id} updated ${numInstances} in ${timeMs}ms`;
+    logState.attributeUpdateMessages.push(message);
+  },
+  /* Render events */
+  'deckRenderer.renderLayers': (deckRenderer, renderStats, opts) => {
+    const {
+      pass,
+      redrawReason,
+      stats
+    } = opts;
+    for (const status of renderStats) {
+      const {
+        totalCount,
+        visibleCount,
+        compositeCount,
+        pickableCount
+      } = status;
+      const primitiveCount = totalCount - compositeCount;
+      const hiddenCount = primitiveCount - visibleCount;
+      log.log(LOG_LEVEL_DRAW, `RENDER #${deckRenderer.renderCount} \
+  ${visibleCount} (of ${totalCount} layers) to ${pass} because ${redrawReason} \
+  (${hiddenCount} hidden, ${compositeCount} composite ${pickableCount} pickable)`)();
+      if (stats) {
+        stats.get('Redraw Layers').add(visibleCount);
+      }
+    }
+  }
+});
+
+// Conditionally load default loggers in development mode
+// eslint-disable-next-line
+if (process.env.NODE_ENV !== 'production') {
+  getLoggers(log);
+}
+function register(handlers) {
+}
+
+function isJSON(text) {
+  const firstChar = text[0];
+  const lastChar = text[text.length - 1];
+  return firstChar === '{' && lastChar === '}' || firstChar === '[' && lastChar === ']';
+}
+// A light weight version instead of @loaders.gl/json (stream processing etc.)
+var jsonLoader = {
+  dataType: null,
+  batchType: null,
+  id: 'JSON',
+  name: 'JSON',
+  module: '',
+  version: '',
+  options: {},
+  extensions: ['json', 'geojson'],
+  mimeTypes: ['application/json', 'application/geo+json'],
+  testText: isJSON,
+  parseTextSync: JSON.parse
+};
+
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+function checkVersion() {
+  // Version detection using typescript plugin.
+  // Fallback for tests and SSR since global variable is defined by esbuild.
+  const version = "9.0.30" ;
+  // Note: a `deck` object not created by deck.gl may exist in the global scope
+  const existingVersion = globalThis.deck && globalThis.deck.VERSION;
+  if (existingVersion && existingVersion !== version) {
+    throw new Error(`deck.gl - multiple versions detected: ${existingVersion} vs ${version}`);
+  }
+  if (!existingVersion) {
+    log.log(1, `deck.gl ${version}`)();
+    globalThis.deck = {
+      ...globalThis.deck,
+      VERSION: version,
+      version,
+      log,
+      // experimental
+      _registerLoggers: register
+    };
+    registerLoaders([jsonLoader,
+    // @ts-expect-error non-standard Loader format
+    [ImageLoader, {
+      imagebitmap: {
+        premultiplyAlpha: 'none'
+      }
+    }]]);
+  }
+  return version;
+}
+const VERSION = checkVersion();
+
 const DEFAULT_TILE_RESOLUTION = 0.5;
 const DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
 const DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
@@ -1056,7 +2425,7 @@ function buildSourceUrl({
  */
 const DEFAULT_PARAMETERS = {
   v: V3_MINOR_VERSION,
-  deckglVersion: "0.2.2-alpha.0"
+  deckglVersion: VERSION
 };
 const DEFAULT_HEADERS = {
   Accept: 'application/json',
@@ -1579,6 +2948,7 @@ function assignDefaultProps(props) {
   }
 }
 
+exports.API_CLIENT_VERSION = API_CLIENT_VERSION;
 exports.WidgetBaseSource = WidgetBaseSource;
 exports.WidgetQuerySource = WidgetQuerySource;
 exports.WidgetTableSource = WidgetTableSource;