@carto/api-client 0.2.2 → 0.3.0

package/build/api-client.modern.js

@@ -3,6 +3,7 @@ import bboxPolygon from '@turf/bbox-polygon';
 import union from '@turf/union';
 import { getType } from '@turf/invariant';
 import { featureCollection, feature, polygon, multiPolygon } from '@turf/helpers';
+import { vectorTableSource as vectorTableSource$1, vectorQuerySource as vectorQuerySource$1, h3TableSource as h3TableSource$1, h3QuerySource as h3QuerySource$1, quadbinTableSource as quadbinTableSource$1, quadbinQuerySource as quadbinQuerySource$1 } from '@deck.gl/carto';
 
 /**
  * @internal
@@ -29,7 +30,7 @@ function setClient(c) {
 }
 
 /** Current version of @carto/api-client. */
-const API_CLIENT_VERSION = "0.2.2";
+const API_CLIENT_VERSION = "0.3.0";
 /**
  * Defines a comparator used when matching a column's values against given filter values.
  *
@@ -96,7 +97,7 @@ function normalizeObjectKeys(el) {
   }, {});
 }
 /** @internalRemarks Source: @carto/react-core */
-function assert$2(condition, message) {
+function assert(condition, message) {
   if (!condition) {
     throw new Error(message);
   }
@@ -116,7 +117,7 @@ class InvalidColumnError extends Error {
   }
 }
 InvalidColumnError.NAME = 'InvalidColumnError';
-function isEmptyObject$1(object) {
+function isEmptyObject(object) {
   for (const _ in object) {
     return false;
   }
@@ -165,7 +166,7 @@ function removeFilter(filters, {
       }
     }
   }
-  if (!owner || isEmptyObject$1(filter)) {
+  if (!owner || isEmptyObject(filter)) {
     delete filters[column];
   }
   return filters;
@@ -363,7 +364,7 @@ function _objectWithoutPropertiesLoose(r, e) {
  * @internalRemarks Source: @carto/constants
  * @internal
  */
-const DEFAULT_API_BASE_URL$1 = 'https://gcp-us-east1.api.carto.com';
+const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
 /**
  * @internalRemarks Source: @carto/react-api
  * @internal
@@ -466,10 +467,10 @@ const REQUEST_GET_MAX_URL_LENGTH = 2048;
  * @internalRemarks Source: @carto/react-api
  */
 function executeModel(props) {
-  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(', ')}`);
+  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(', ')}`);
   const {
     model,
     source,
@@ -484,10 +485,10 @@ function executeModel(props) {
     connectionName,
     clientId
   } = source;
-  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');
+  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');
   let url = `${apiBaseUrl}/v3/sql/${connectionName}/model/${model}`;
   const {
     filters,
@@ -847,7 +848,7 @@ class WidgetBaseSource {
 }
 WidgetBaseSource.defaultProps = {
   apiVersion: ApiVersion.V3,
-  apiBaseUrl: DEFAULT_API_BASE_URL$1,
+  apiBaseUrl: DEFAULT_API_BASE_URL,
   clientId: getClient(),
   filters: {},
   filtersLogicalOperator: 'and',
@@ -917,1881 +918,6 @@ 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;
-
-const isObject = x => x !== null && typeof x === 'object';
-const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
-
-/**
- *
- * Custom error for reported errors in CARTO Maps API.
- * Provides useful debugging information in console and context for applications.
- *
- */
-class CartoAPIError extends Error {
-  constructor(error, errorContext, response, responseJson) {
-    let responseString = 'Failed to connect';
-    if (response) {
-      responseString = 'Server returned: ';
-      if (response.status === 400) {
-        responseString += 'Bad request';
-      } else if (response.status === 401 || response.status === 403) {
-        responseString += 'Unauthorized access';
-      } else if (response.status === 404) {
-        responseString += 'Not found';
-      } else {
-        responseString += 'Error';
-      }
-      responseString += ` (${response.status}):`;
-    }
-    responseString += ` ${error.message || error}`;
-    let message = `${errorContext.requestType} API request failed`;
-    message += `\n${responseString}`;
-    for (const key of Object.keys(errorContext)) {
-      if (key === 'requestType') continue; // eslint-disable-line no-continue
-      message += `\n${formatErrorKey(key)}: ${errorContext[key]}`;
-    }
-    message += '\n';
-    super(message);
-    this.name = 'CartoAPIError';
-    this.response = response;
-    this.responseJson = responseJson;
-    this.error = error;
-    this.errorContext = errorContext;
-  }
-}
-/**
- * Converts camelCase to Camel Case
- */
-function formatErrorKey(key) {
-  return key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase());
-}
-
-const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
-const DEFAULT_CLIENT = 'deck-gl-carto';
-const V3_MINOR_VERSION = '3.4';
-// Fastly default limit is 8192; leave some padding.
-const DEFAULT_MAX_LENGTH_URL = 7000;
-
-function joinPath(...args) {
-  return args.map(part => part.endsWith('/') ? part.slice(0, -1) : part).join('/');
-}
-function buildV3Path(apiBaseUrl, version, endpoint, ...rest) {
-  return joinPath(apiBaseUrl, version, endpoint, ...rest);
-}
-function buildSourceUrl({
-  apiBaseUrl,
-  connectionName,
-  endpoint
-}) {
-  return buildV3Path(apiBaseUrl, 'v3', 'maps', connectionName, endpoint);
-}
-
-/**
- * Parameters added to all requests issued with `requestWithParameters()`.
- * These parameters override parameters already in the base URL, but not
- * user-provided parameters.
- */
-const DEFAULT_PARAMETERS = {
-  v: V3_MINOR_VERSION,
-  deckglVersion: VERSION
-};
-const DEFAULT_HEADERS = {
-  Accept: 'application/json',
-  'Content-Type': 'application/json'
-};
-const REQUEST_CACHE = new Map();
-async function requestWithParameters({
-  baseUrl,
-  parameters = {},
-  headers: customHeaders = {},
-  errorContext,
-  maxLengthURL = DEFAULT_MAX_LENGTH_URL
-}) {
-  parameters = {
-    ...DEFAULT_PARAMETERS,
-    ...parameters
-  };
-  baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
-  const key = createCacheKey(baseUrl, parameters, customHeaders);
-  if (REQUEST_CACHE.has(key)) {
-    return REQUEST_CACHE.get(key);
-  }
-  const url = createURLWithParameters(baseUrl, parameters);
-  const headers = {
-    ...DEFAULT_HEADERS,
-    ...customHeaders
-  };
-  /* global fetch */
-  const fetchPromise = url.length > maxLengthURL ? fetch(baseUrl, {
-    method: 'POST',
-    body: JSON.stringify(parameters),
-    headers
-  }) : fetch(url, {
-    headers
-  });
-  let response;
-  let responseJson;
-  const jsonPromise = fetchPromise.then(_response => {
-    response = _response;
-    return response.json();
-  }).then(json => {
-    responseJson = json;
-    if (!response || !response.ok) {
-      throw new Error(json.error);
-    }
-    return json;
-  }).catch(error => {
-    REQUEST_CACHE.delete(key);
-    throw new CartoAPIError(error, errorContext, response, responseJson);
-  });
-  REQUEST_CACHE.set(key, jsonPromise);
-  return jsonPromise;
-}
-function createCacheKey(baseUrl, parameters, headers) {
-  const parameterEntries = Object.entries(parameters).sort(([a], [b]) => a > b ? 1 : -1);
-  const headerEntries = Object.entries(headers).sort(([a], [b]) => a > b ? 1 : -1);
-  return JSON.stringify({
-    baseUrl,
-    parameters: parameterEntries,
-    headers: headerEntries
-  });
-}
-/**
- * Appends query string parameters to a URL. Existing URL parameters are kept,
- * unless there is a conflict, in which case the new parameters override
- * those already in the URL.
- */
-function createURLWithParameters(baseUrlString, parameters) {
-  const baseUrl = new URL(baseUrlString);
-  for (const [key, value] of Object.entries(parameters)) {
-    if (isPureObject(value) || Array.isArray(value)) {
-      baseUrl.searchParams.set(key, JSON.stringify(value));
-    } else {
-      baseUrl.searchParams.set(key, value.toString());
-    }
-  }
-  return baseUrl.toString();
-}
-/**
- * Deletes query string parameters from a URL.
- */
-function excludeURLParameters(baseUrlString, parameters) {
-  const baseUrl = new URL(baseUrlString);
-  for (const param of parameters) {
-    if (baseUrl.searchParams.has(param)) {
-      baseUrl.searchParams.delete(param);
-    }
-  }
-  return baseUrl.toString();
-}
-
-/* eslint-disable camelcase */
-const SOURCE_DEFAULTS = {
-  apiBaseUrl: DEFAULT_API_BASE_URL,
-  clientId: DEFAULT_CLIENT,
-  format: 'tilejson',
-  headers: {},
-  maxLengthURL: DEFAULT_MAX_LENGTH_URL
-};
-async function baseSource(endpoint, options, urlParameters) {
-  const {
-    accessToken,
-    connectionName,
-    cache,
-    ...optionalOptions
-  } = options;
-  const mergedOptions = {
-    ...SOURCE_DEFAULTS,
-    accessToken,
-    connectionName,
-    endpoint
-  };
-  for (const key in optionalOptions) {
-    if (optionalOptions[key]) {
-      mergedOptions[key] = optionalOptions[key];
-    }
-  }
-  const baseUrl = buildSourceUrl(mergedOptions);
-  const {
-    clientId,
-    maxLengthURL,
-    format
-  } = mergedOptions;
-  const headers = {
-    Authorization: `Bearer ${options.accessToken}`,
-    ...options.headers
-  };
-  const parameters = {
-    client: clientId,
-    ...urlParameters
-  };
-  const errorContext = {
-    requestType: 'Map instantiation',
-    connection: options.connectionName,
-    type: endpoint,
-    source: JSON.stringify(parameters, undefined, 2)
-  };
-  const mapInstantiation = await requestWithParameters({
-    baseUrl,
-    parameters,
-    headers,
-    errorContext,
-    maxLengthURL
-  });
-  const dataUrl = mapInstantiation[format].url[0];
-  if (cache) {
-    cache.value = parseInt(new URL(dataUrl).searchParams.get('cache') || '', 10);
-  }
-  errorContext.requestType = 'Map data';
-  if (format === 'tilejson') {
-    const json = await requestWithParameters({
-      baseUrl: dataUrl,
-      headers,
-      errorContext,
-      maxLengthURL
-    });
-    if (accessToken) {
-      json.accessToken = accessToken;
-    }
-    return json;
-  }
-  return await requestWithParameters({
-    baseUrl: dataUrl,
-    headers,
-    errorContext,
-    maxLengthURL
-  });
-}
-
-const boundaryQuerySource = async function (options) {
-  const {
-    columns,
-    filters,
-    tilesetTableName,
-    propertiesSqlQuery,
-    queryParameters
-  } = options;
-  const urlParameters = {
-    tilesetTableName,
-    propertiesSqlQuery
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(',');
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  return baseSource('boundary', options, urlParameters);
-};
-
-const boundaryTableSource = async function (options) {
-  const {
-    filters,
-    tilesetTableName,
-    columns,
-    propertiesTableName
-  } = options;
-  const urlParameters = {
-    tilesetTableName,
-    propertiesTableName
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(',');
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource('boundary', options, urlParameters);
-};
-
-/* eslint-disable camelcase */
-const h3QuerySource$1 = async function (options) {
-  const {
-    aggregationExp,
-    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
-    sqlQuery,
-    spatialDataColumn = 'h3',
-    queryParameters,
-    filters
-  } = options;
-  const urlParameters = {
-    aggregationExp,
-    spatialDataColumn,
-    spatialDataType: 'h3',
-    q: sqlQuery
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource('query', options, urlParameters);
-};
-
-/* eslint-disable camelcase */
-const h3TableSource$1 = async function (options) {
-  const {
-    aggregationExp,
-    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
-    spatialDataColumn = 'h3',
-    tableName,
-    filters
-  } = options;
-  const urlParameters = {
-    aggregationExp,
-    name: tableName,
-    spatialDataColumn,
-    spatialDataType: 'h3'
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource('table', options, urlParameters);
-};
-
-const h3TilesetSource = async function (options) {
-  const {
-    tableName
-  } = options;
-  const urlParameters = {
-    name: tableName
-  };
-  return baseSource('tileset', options, urlParameters);
-};
-
-const rasterSource = async function (options) {
-  const {
-    tableName,
-    filters
-  } = options;
-  const urlParameters = {
-    name: tableName
-  };
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource('raster', options, urlParameters);
-};
-
-/* eslint-disable camelcase */
-const quadbinQuerySource$1 = async function (options) {
-  const {
-    aggregationExp,
-    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
-    sqlQuery,
-    spatialDataColumn = 'quadbin',
-    queryParameters,
-    filters
-  } = options;
-  const urlParameters = {
-    aggregationExp,
-    q: sqlQuery,
-    spatialDataColumn,
-    spatialDataType: 'quadbin'
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource('query', options, urlParameters);
-};
-
-/* eslint-disable camelcase */
-const quadbinTableSource$1 = async function (options) {
-  const {
-    aggregationExp,
-    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
-    spatialDataColumn = 'quadbin',
-    tableName,
-    filters
-  } = options;
-  const urlParameters = {
-    aggregationExp,
-    name: tableName,
-    spatialDataColumn,
-    spatialDataType: 'quadbin'
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource('table', options, urlParameters);
-};
-
-const quadbinTilesetSource = async function (options) {
-  const {
-    tableName
-  } = options;
-  const urlParameters = {
-    name: tableName
-  };
-  return baseSource('tileset', options, urlParameters);
-};
-
-/* eslint-disable camelcase */
-const vectorQuerySource$1 = async function (options) {
-  const {
-    columns,
-    filters,
-    spatialDataColumn = 'geom',
-    sqlQuery,
-    tileResolution = DEFAULT_TILE_RESOLUTION,
-    queryParameters
-  } = options;
-  const urlParameters = {
-    spatialDataColumn,
-    spatialDataType: 'geo',
-    tileResolution: tileResolution.toString(),
-    q: sqlQuery
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(',');
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  return baseSource('query', options, urlParameters);
-};
-
-/* eslint-disable camelcase */
-const vectorTableSource$1 = async function (options) {
-  const {
-    columns,
-    filters,
-    spatialDataColumn = 'geom',
-    tableName,
-    tileResolution = DEFAULT_TILE_RESOLUTION
-  } = options;
-  const urlParameters = {
-    name: tableName,
-    spatialDataColumn,
-    spatialDataType: 'geo',
-    tileResolution: tileResolution.toString()
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(',');
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource('table', options, urlParameters);
-};
-
-const vectorTilesetSource = async function (options) {
-  const {
-    tableName
-  } = options;
-  const urlParameters = {
-    name: tableName
-  };
-  return baseSource('tileset', options, urlParameters);
-};
-
-({
-  boundaryQuerySource,
-  boundaryTableSource,
-  h3QuerySource: h3QuerySource$1,
-  h3TableSource: h3TableSource$1,
-  h3TilesetSource,
-  rasterSource,
-  quadbinQuerySource: quadbinQuerySource$1,
-  quadbinTableSource: quadbinTableSource$1,
-  quadbinTilesetSource,
-  vectorQuerySource: vectorQuerySource$1,
-  vectorTableSource: vectorTableSource$1,
-  vectorTilesetSource
-});
-
 /** Wrapper adding Widget API support to [vectorTableSource](https://deck.gl/docs/api-reference/carto/data-sources). */
 async function vectorTableSource(props) {
   assignDefaultProps(props);