@deck.gl/carto 8.9.4 → 8.9.6

package/dist/dist.dev.js

@@ -106,8 +106,8 @@ var __exports__ = (() => {
           return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
         }
         function map2(arr, fn) {
-          var res = [], i;
-          for (i = 0; i < arr.length; ++i) {
+          var res = [], i, arrLen = arr.length;
+          for (i = 0; i < arrLen; ++i) {
             res.push(fn(arr[i], i));
           }
           return res;
@@ -196,7 +196,7 @@ var __exports__ = (() => {
         }
         var momentProperties = hooks.momentProperties = [], updateInProgress = false;
         function copyConfig(to2, from2) {
-          var i, prop, val;
+          var i, prop, val, momentPropertiesLen = momentProperties.length;
           if (!isUndefined(from2._isAMomentObject)) {
             to2._isAMomentObject = from2._isAMomentObject;
           }
@@ -227,8 +227,8 @@ var __exports__ = (() => {
           if (!isUndefined(from2._locale)) {
             to2._locale = from2._locale;
           }
-          if (momentProperties.length > 0) {
-            for (i = 0; i < momentProperties.length; i++) {
+          if (momentPropertiesLen > 0) {
+            for (i = 0; i < momentPropertiesLen; i++) {
               prop = momentProperties[i];
               val = from2[prop];
               if (!isUndefined(val)) {
@@ -265,8 +265,8 @@ var __exports__ = (() => {
               hooks.deprecationHandler(null, msg);
             }
             if (firstTime) {
-              var args = [], arg, i, key;
-              for (i = 0; i < arguments.length; i++) {
+              var args = [], arg, i, key, argLen = arguments.length;
+              for (i = 0; i < argLen; i++) {
                 arg = "";
                 if (typeof arguments[i] === "object") {
                   arg += "\n[" + i + "] ";
@@ -596,8 +596,8 @@ var __exports__ = (() => {
         function stringSet(units, value) {
           if (typeof units === "object") {
             units = normalizeObjectUnits(units);
-            var prioritized = getPrioritizedUnits(units), i;
-            for (i = 0; i < prioritized.length; i++) {
+            var prioritized = getPrioritizedUnits(units), i, prioritizedLen = prioritized.length;
+            for (i = 0; i < prioritizedLen; i++) {
               this[prioritized[i].unit](units[prioritized[i].unit]);
             }
           } else {
@@ -623,9 +623,12 @@ var __exports__ = (() => {
         }
         function unescapeFormat(s) {
           return regexEscape(
-            s.replace("\\", "").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function(matched, p1, p2, p3, p4) {
-              return p1 || p2 || p3 || p4;
-            })
+            s.replace("\\", "").replace(
+              /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
+              function(matched, p1, p2, p3, p4) {
+                return p1 || p2 || p3 || p4;
+              }
+            )
           );
         }
         function regexEscape(s) {
@@ -633,7 +636,7 @@ var __exports__ = (() => {
         }
         var tokens = {};
         function addParseToken(token2, callback) {
-          var i, func = callback;
+          var i, func = callback, tokenLen;
           if (typeof token2 === "string") {
             token2 = [token2];
           }
@@ -642,7 +645,8 @@ var __exports__ = (() => {
               array[callback] = toInt(input);
             };
           }
-          for (i = 0; i < token2.length; i++) {
+          tokenLen = token2.length;
+          for (i = 0; i < tokenLen; i++) {
             tokens[token2[i]] = func;
           }
         }
@@ -715,9 +719,7 @@ var __exports__ = (() => {
         });
         var defaultLocaleMonths = "January_February_March_April_May_June_July_August_September_October_November_December".split(
           "_"
-        ), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split(
-          "_"
-        ), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord;
+        ), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord;
         function localeMonths(m, format3) {
           if (!m) {
             return isArray(this._months) ? this._months : this._months["standalone"];
@@ -1019,9 +1021,12 @@ var __exports__ = (() => {
         addRegexToken("ww", match1to2, match2);
         addRegexToken("W", match1to2);
         addRegexToken("WW", match1to2, match2);
-        addWeekParseToken(["w", "ww", "W", "WW"], function(input, week, config, token2) {
-          week[token2.substr(0, 1)] = toInt(input);
-        });
+        addWeekParseToken(
+          ["w", "ww", "W", "WW"],
+          function(input, week, config, token2) {
+            week[token2.substr(0, 1)] = toInt(input);
+          }
+        );
         function localeWeek(mom) {
           return weekOfYear(mom, this._week.dow, this._week.doy).week;
         }
@@ -1106,9 +1111,7 @@ var __exports__ = (() => {
         function shiftWeekdays(ws, n) {
           return ws.slice(n, 7).concat(ws.slice(0, n));
         }
-        var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split(
-          "_"
-        ), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord;
+        var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord;
         function localeWeekdays(m, format3) {
           var weekdays = isArray(this._weekdays) ? this._weekdays : this._weekdays[m && m !== true && this._weekdays.isFormat.test(format3) ? "format" : "standalone"];
           return m === true ? shiftWeekdays(weekdays, this._week.dow) : m ? weekdays[m.day()] : weekdays;
@@ -1492,9 +1495,12 @@ var __exports__ = (() => {
           }
           return globalLocale;
         }
+        function isLocaleNameSane(name) {
+          return name.match("^[^/\\\\]*$") != null;
+        }
         function loadLocale(name) {
           var oldLocale = null, aliasedRequire;
-          if (locales[name] === void 0 && typeof module !== "undefined" && module && module.exports) {
+          if (locales[name] === void 0 && typeof module !== "undefined" && module && module.exports && isLocaleNameSane(name)) {
             try {
               oldLocale = globalLocale._abbr;
               aliasedRequire = __require;
@@ -1675,10 +1681,10 @@ var __exports__ = (() => {
           PST: -8 * 60
         };
         function configFromISO(config) {
-          var i, l, string = config._i, match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), allowTime, dateFormat, timeFormat, tzFormat;
+          var i, l, string = config._i, match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), allowTime, dateFormat, timeFormat, tzFormat, isoDatesLen = isoDates.length, isoTimesLen = isoTimes.length;
           if (match) {
             getParsingFlags(config).iso = true;
-            for (i = 0, l = isoDates.length; i < l; i++) {
+            for (i = 0, l = isoDatesLen; i < l; i++) {
               if (isoDates[i][1].exec(match[1])) {
                 dateFormat = isoDates[i][0];
                 allowTime = isoDates[i][2] !== false;
@@ -1690,7 +1696,7 @@ var __exports__ = (() => {
               return;
             }
             if (match[3]) {
-              for (i = 0, l = isoTimes.length; i < l; i++) {
+              for (i = 0, l = isoTimesLen; i < l; i++) {
                 if (isoTimes[i][1].exec(match[3])) {
                   timeFormat = (match[2] || " ") + isoTimes[i][0];
                   break;
@@ -1742,7 +1748,7 @@ var __exports__ = (() => {
           return year;
         }
         function preprocessRFC2822(s) {
-          return s.replace(/\([^)]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").replace(/^\s\s*/, "").replace(/\s\s*$/, "");
+          return s.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").replace(/^\s\s*/, "").replace(/\s\s*$/, "");
         }
         function checkWeekday(weekdayStr, parsedInput, config) {
           if (weekdayStr) {
@@ -1946,9 +1952,10 @@ var __exports__ = (() => {
           }
           config._a = [];
           getParsingFlags(config).empty = true;
-          var string = "" + config._i, i, parsedInput, tokens2, token2, skipped, stringLength = string.length, totalParsedInputLength = 0, era;
+          var string = "" + config._i, i, parsedInput, tokens2, token2, skipped, stringLength = string.length, totalParsedInputLength = 0, era, tokenLen;
           tokens2 = expandFormat(config._f, config._locale).match(formattingTokens) || [];
-          for (i = 0; i < tokens2.length; i++) {
+          tokenLen = tokens2.length;
+          for (i = 0; i < tokenLen; i++) {
             token2 = tokens2[i];
             parsedInput = (string.match(getParseRegexForToken(token2, config)) || [])[0];
             if (parsedInput) {
@@ -2014,13 +2021,13 @@ var __exports__ = (() => {
           }
         }
         function configFromStringAndArray(config) {
-          var tempConfig, bestMoment, scoreToBeat, i, currentScore, validFormatFound, bestFormatIsValid = false;
-          if (config._f.length === 0) {
+          var tempConfig, bestMoment, scoreToBeat, i, currentScore, validFormatFound, bestFormatIsValid = false, configfLen = config._f.length;
+          if (configfLen === 0) {
             getParsingFlags(config).invalidFormat = true;
             config._d = new Date(NaN);
             return;
           }
-          for (i = 0; i < config._f.length; i++) {
+          for (i = 0; i < configfLen; i++) {
             currentScore = 0;
             validFormatFound = false;
             tempConfig = copyConfig({}, config);
@@ -2203,13 +2210,13 @@ var __exports__ = (() => {
           "millisecond"
         ];
         function isDurationValid(m) {
-          var key, unitHasDecimal = false, i;
+          var key, unitHasDecimal = false, i, orderLen = ordering.length;
           for (key in m) {
             if (hasOwnProp(m, key) && !(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
               return false;
             }
           }
-          for (i = 0; i < ordering.length; ++i) {
+          for (i = 0; i < orderLen; ++i) {
             if (m[ordering[i]]) {
               if (unitHasDecimal) {
                 return false;
@@ -2570,8 +2577,8 @@ var __exports__ = (() => {
             "milliseconds",
             "millisecond",
             "ms"
-          ], i, property;
-          for (i = 0; i < properties.length; i += 1) {
+          ], i, property, propertyLen = properties.length;
+          for (i = 0; i < propertyLen; i += 1) {
             property = properties[i];
             propertyTest = propertyTest || hasOwnProp(input, property);
           }
@@ -3031,14 +3038,17 @@ var __exports__ = (() => {
         addRegexToken("NNN", matchEraAbbr);
         addRegexToken("NNNN", matchEraName);
         addRegexToken("NNNNN", matchEraNarrow);
-        addParseToken(["N", "NN", "NNN", "NNNN", "NNNNN"], function(input, array, config, token2) {
-          var era = config._locale.erasParse(input, token2, config._strict);
-          if (era) {
-            getParsingFlags(config).era = era;
-          } else {
-            getParsingFlags(config).invalidEra = input;
+        addParseToken(
+          ["N", "NN", "NNN", "NNNN", "NNNNN"],
+          function(input, array, config, token2) {
+            var era = config._locale.erasParse(input, token2, config._strict);
+            if (era) {
+              getParsingFlags(config).era = era;
+            } else {
+              getParsingFlags(config).invalidEra = input;
+            }
           }
-        });
+        );
         addRegexToken("y", matchUnsigned);
         addRegexToken("yy", matchUnsigned);
         addRegexToken("yyy", matchUnsigned);
@@ -3240,9 +3250,12 @@ var __exports__ = (() => {
         addRegexToken("gggg", match1to4, match4);
         addRegexToken("GGGGG", match1to6, match6);
         addRegexToken("ggggg", match1to6, match6);
-        addWeekParseToken(["gggg", "ggggg", "GGGG", "GGGGG"], function(input, week, config, token2) {
-          week[token2.substr(0, 2)] = toInt(input);
-        });
+        addWeekParseToken(
+          ["gggg", "ggggg", "GGGG", "GGGGG"],
+          function(input, week, config, token2) {
+            week[token2.substr(0, 2)] = toInt(input);
+          }
+        );
         addWeekParseToken(["gg", "GG"], function(input, week, config, token2) {
           week[token2] = hooks.parseTwoDigitYear(input);
         });
@@ -3910,7 +3923,7 @@ var __exports__ = (() => {
         addParseToken("x", function(input, array, config) {
           config._d = new Date(toInt(input));
         });
-        hooks.version = "2.29.1";
+        hooks.version = "2.29.4";
         setHookCallback(createLocal);
         hooks.fn = proto;
         hooks.min = min2;
@@ -5441,8 +5454,8 @@ var __exports__ = (() => {
       Pbf.Fixed64 = 1;
       Pbf.Bytes = 2;
       Pbf.Fixed32 = 5;
-      var SHIFT_LEFT_322 = (1 << 16) * (1 << 16);
-      var SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_322;
+      var SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
+      var SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
       var TEXT_DECODER_MIN_LENGTH = 12;
       var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf8");
       Pbf.prototype = {
@@ -5474,12 +5487,12 @@ var __exports__ = (() => {
           return val;
         },
         readFixed64: function() {
-          var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_322;
+          var val = readUInt32(this.buf, this.pos) + readUInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
           this.pos += 8;
           return val;
         },
         readSFixed64: function() {
-          var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_322;
+          var val = readUInt32(this.buf, this.pos) + readInt32(this.buf, this.pos + 4) * SHIFT_LEFT_32;
           this.pos += 8;
           return val;
         },
@@ -5542,7 +5555,7 @@ var __exports__ = (() => {
         readPackedVarint: function(arr, isSigned) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readVarint(isSigned));
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readVarint(isSigned));
@@ -5551,7 +5564,7 @@ var __exports__ = (() => {
         readPackedSVarint: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readSVarint());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readSVarint());
@@ -5560,7 +5573,7 @@ var __exports__ = (() => {
         readPackedBoolean: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readBoolean());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readBoolean());
@@ -5569,7 +5582,7 @@ var __exports__ = (() => {
         readPackedFloat: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readFloat());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readFloat());
@@ -5578,7 +5591,7 @@ var __exports__ = (() => {
         readPackedDouble: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readDouble());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readDouble());
@@ -5587,7 +5600,7 @@ var __exports__ = (() => {
         readPackedFixed32: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readFixed32());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readFixed32());
@@ -5596,7 +5609,7 @@ var __exports__ = (() => {
         readPackedSFixed32: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readSFixed32());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readSFixed32());
@@ -5605,7 +5618,7 @@ var __exports__ = (() => {
         readPackedFixed64: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readFixed64());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readFixed64());
@@ -5614,7 +5627,7 @@ var __exports__ = (() => {
         readPackedSFixed64: function(arr) {
           if (this.type !== Pbf.Bytes)
             return arr.push(this.readSFixed64());
-          var end = readPackedEnd2(this);
+          var end = readPackedEnd(this);
           arr = arr || [];
           while (this.pos < end)
             arr.push(this.readSFixed64());
@@ -5852,7 +5865,7 @@ var __exports__ = (() => {
           return toNum(l, h, s);
         throw new Error("Expected varint not more than 10 bytes");
       }
-      function readPackedEnd2(pbf) {
+      function readPackedEnd(pbf) {
         return pbf.type === Pbf.Bytes ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
       }
       function toNum(low, high, isSigned) {
@@ -8317,6 +8330,7 @@ var __exports__ = (() => {
     TILE_FORMATS: () => TILE_FORMATS,
     _CartoTileLayer: () => CartoTileLayer,
     _H3TileLayer: () => H3TileLayer,
+    _PointLabelLayer: () => PointLabelLayer,
     _QuadbinTileLayer: () => QuadbinTileLayer,
     _getDataV2: () => getDataV2,
     _mapInstantiation: () => mapInstantiation,
@@ -8436,7 +8450,7 @@ var __exports__ = (() => {
   }
 
   // src/layers/carto-layer.ts
-  var import_core8 = __toESM(require_core());
+  var import_core9 = __toESM(require_core());
   var import_geo_layers8 = __toESM(require_geo_layers());
 
   // src/api/carto-api-error.ts
@@ -11127,6 +11141,20 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/layers/carto-tile-layer.ts
   var import_core = __toESM(require_core2());
 
+  // src/layers/schema/fast-pbf.ts
+  function readPackedDouble(pbf, obj) {
+    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+    obj.value = new Float64Array(pbf.buf.buffer.slice(pbf.pos, end));
+    pbf.pos = end;
+    return obj.value;
+  }
+  function readPackedFixed64(pbf, obj) {
+    const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+    obj.value = new BigUint64Array(pbf.buf.buffer.slice(pbf.pos, end));
+    pbf.pos = end;
+    return obj.value;
+  }
+
   // src/layers/schema/carto-tile.ts
   var KeyValueObjectReader = class {
     static read(pbf, end) {
@@ -11144,13 +11172,16 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   };
   var PropertiesReader = class {
     static read(pbf, end) {
-      return pbf.readFields(PropertiesReader._readField, {
-        data: []
-      }, end);
+      return pbf.readFields(PropertiesReader._readField, {}, end);
     }
     static _readField(tag, obj, pbf) {
-      if (tag === 1)
-        obj.data.push(KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos));
+      if (tag === 1) {
+        const {
+          key,
+          value
+        } = KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos);
+        obj[key] = value;
+      }
     }
   };
   var DoublesReader = class {
@@ -11169,7 +11200,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        pbf.readPackedDouble(obj.value);
+        readPackedDouble(pbf, obj);
       else if (tag === 2)
         obj.size = pbf.readVarint(true);
     }
@@ -11214,7 +11245,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        pbf.readPackedDouble(obj.value);
+        readPackedDouble(pbf, obj);
     }
   };
   var NumericPropKeyValueReader = class {
@@ -11349,21 +11380,6 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     const tile = TileReader3.read(pbf);
     return tile;
   }
-  function unpackProperties(properties) {
-    if (!properties || !properties.length) {
-      return [];
-    }
-    return properties.map((item) => {
-      const currentRecord = {};
-      item.data.forEach(({
-        key,
-        value
-      }) => {
-        currentRecord[key] = value;
-      });
-      return currentRecord;
-    });
-  }
 
   // src/layers/schema/carto-vector-tile-loader.ts
   var CartoVectorTileLoader = {
@@ -11383,26 +11399,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     if (!arrayBuffer)
       return null;
     const tile = parsePbf(arrayBuffer, TileReader);
-    const {
-      points,
-      lines,
-      polygons
-    } = tile;
-    const data = {
-      points: {
-        ...points,
-        properties: unpackProperties(points.properties)
-      },
-      lines: {
-        ...lines,
-        properties: unpackProperties(lines.properties)
-      },
-      polygons: {
-        ...polygons,
-        properties: unpackProperties(polygons.properties)
-      }
-    };
-    return data;
+    return tile;
   }
   var carto_vector_tile_loader_default = CartoVectorTileLoader;
 
@@ -11815,18 +11812,13 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   // src/layers/schema/carto-spatial-tile.ts
   var IndicesReader = class {
     static read(pbf, end) {
-      const {
-        value
-      } = pbf.readFields(IndicesReader._readField, {
+      return pbf.readFields(IndicesReader._readField, {
         value: []
       }, end);
-      return {
-        value: new BigUint64Array(value)
-      };
     }
     static _readField(tag, obj, pbf) {
       if (tag === 1)
-        readPackedFixed64(pbf, obj.value);
+        readPackedFixed64(pbf, obj);
     }
   };
   var CellsReader = class {
@@ -11862,24 +11854,6 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         obj.cells = CellsReader.read(pbf, pbf.readVarint() + pbf.pos);
     }
   };
-  var SHIFT_LEFT_32 = BigInt((1 << 16) * (1 << 16));
-  function readPackedEnd(pbf) {
-    return pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
-  }
-  function readFixed64(pbf) {
-    const a = BigInt(pbf.readFixed32());
-    const b = BigInt(pbf.readFixed32());
-    return a + b * SHIFT_LEFT_32;
-  }
-  function readPackedFixed64(pbf, arr) {
-    if (pbf.type !== 2)
-      return arr.push(readFixed64(pbf));
-    const end = readPackedEnd(pbf);
-    arr = arr || [];
-    while (pbf.pos < end)
-      arr.push(readFixed64(pbf));
-    return arr;
-  }
 
   // ../../node_modules/quadbin/dist/esm/index.js
   var B = [
@@ -11993,10 +11967,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     } = tile;
     const scheme = options?.cartoSpatialTile?.scheme;
     const data = {
-      cells: {
-        ...cells,
-        properties: unpackProperties(cells.properties)
-      },
+      cells,
       scheme
     };
     return binaryToSpatialjson(data);
@@ -12092,11 +12063,28 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       } = this.state;
       const data = tile.content;
       const isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId);
-      if (!isFeatureIdPresent || !Array.isArray(data)) {
+      if (!isFeatureIdPresent || !Array.isArray(data) || !this._featureInTile(tile, hoveredFeatureId)) {
         return -1;
       }
       return data.findIndex((feature) => feature.id === hoveredFeatureId);
     }
+    _featureInTile(tile, featureId) {
+      const {
+        getTileZoom,
+        getParentIndex
+      } = this.state.tileset;
+      const tileZoom = getTileZoom(tile.index);
+      const KEY = tile.index.q ? "q" : "i";
+      let featureIndex = {
+        [KEY]: featureId
+      };
+      let featureZoom = getTileZoom(featureIndex);
+      while (!(featureZoom <= tileZoom)) {
+        featureIndex = getParentIndex(featureIndex);
+        featureZoom = getTileZoom(featureIndex);
+      }
+      return featureIndex[KEY] === tile.index[KEY];
+    }
   };
   __publicField(SpatialIndexTileLayer, "layerName", "SpatialIndexTileLayer");
   __publicField(SpatialIndexTileLayer, "defaultProps", defaultProps2);
@@ -12448,7 +12436,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function getLayer(type, config, dataset) {
     let basePropMap = sharedPropMap;
-    if (config.visConfig?.customMarkers && !config.textLabel) {
+    if (config.visConfig?.customMarkers) {
       basePropMap = mergePropMaps(sharedPropMap, customMarkersPropsMap);
     }
     if (type === "mvt" || type === "tileset" || type === "h3" || type === "quadbin") {
@@ -12624,10 +12612,30 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
   function normalizeAccessor(accessor, data) {
     if (data.features || data.tilestats) {
-      return ({
-        properties
-      }) => {
-        return accessor(properties);
+      return (object, info) => {
+        if (object) {
+          return accessor(object.properties || object.__source.object.properties);
+        }
+        const {
+          data: data2,
+          index
+        } = info;
+        const {
+          properties,
+          numericProps
+        } = data2;
+        const proxy = new Proxy(properties[index] || {}, {
+          get(target, property, receiver) {
+            if (property in numericProps) {
+              return numericProps[property].value[index];
+            }
+            return target[property];
+          },
+          has(target, property) {
+            return property in numericProps || property in target;
+          }
+        });
+        return accessor(proxy);
       };
     }
     return accessor;
@@ -12788,23 +12796,195 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     };
     return normalizeAccessor(accessor, data);
   }
-  function getTextPixelOffsetAccessor({
-    alignment,
-    anchor,
-    size
-  }, radius) {
-    const padding = 20;
-    const signX = anchor === "middle" ? 0 : anchor === "start" ? 1 : -1;
-    const signY = alignment === "center" ? 0 : alignment === "bottom" ? 1 : -1;
-    const sizeOffset = alignment === "center" ? 0 : size;
-    const calculateOffset = (r) => [signX * (r + padding), signY * (r + padding + sizeOffset)];
-    return typeof radius === "function" ? (d) => {
-      return calculateOffset(radius(d));
-    } : calculateOffset(radius);
-  }
 
-  // src/api/parseMap.ts
+  // src/layers/point-label-layer.ts
   var import_core6 = __toESM(require_core());
+  var import_layers3 = __toESM(require_layers());
+  var [LEFT, TOP, RIGHT, BOTTOM] = [0, 1, 2, 3];
+  var EnhancedTextBackgroundLayer = class extends import_layers3._TextBackgroundLayer {
+    getShaders() {
+      const shaders = super.getShaders();
+      let vs = shaders.vs;
+      vs = vs.replaceAll("padding.", "_padding.");
+      vs = vs.replace("void main(void) {", "void main(void) {\n  vec4 _padding = padding + instancePixelOffsets.xyxy * vec4(1.0, 1.0, -1.0, -1.0);");
+      return {
+        ...shaders,
+        vs
+      };
+    }
+  };
+  __publicField(EnhancedTextBackgroundLayer, "layerName", "EnhancedTextBackgroundLayer");
+  var EnhancedTextLayer = class extends import_layers3.TextLayer {
+    filterSubLayer({
+      layer,
+      renderPass
+    }) {
+      const background = layer.id.includes("primary-background");
+      if (renderPass === "collision") {
+        return background;
+      }
+      return !background;
+    }
+  };
+  __publicField(EnhancedTextLayer, "layerName", "EnhancedTextLayer");
+  var defaultProps7 = {
+    ...import_layers3.TextLayer.defaultProps,
+    getRadius: {
+      type: "accessor",
+      value: 1
+    },
+    radiusScale: {
+      type: "number",
+      min: 0,
+      value: 1
+    }
+  };
+  var PointLabelLayer = class extends import_core6.CompositeLayer {
+    calculatePixelOffset(secondary) {
+      const {
+        getTextAnchor: anchor,
+        getAlignmentBaseline: alignment,
+        getRadius,
+        getSecondaryText,
+        radiusScale,
+        secondarySizeScale,
+        sizeScale
+      } = this.props;
+      const xMult = anchor === "middle" ? 0 : anchor === "start" ? 1 : -1;
+      const yMult = alignment === "center" ? 0 : alignment === "bottom" ? 1 : -1;
+      const xPadding = sizeScale / 4;
+      const yPadding = sizeScale * (1 + 1 / 4);
+      const secondaryOffset = 0.6 * (1 - yMult) * sizeScale;
+      let yOffset = secondary ? secondaryOffset : 0;
+      if (anchor === "middle" && alignment === "top" && getSecondaryText) {
+        yOffset -= secondaryOffset;
+        yOffset -= secondarySizeScale;
+        yOffset += sizeScale;
+      }
+      const radiusPadding = 1 + 1 / 4;
+      return typeof getRadius === "function" ? (d, info) => {
+        const r = (info ? getRadius(d, info) : 1) * radiusScale * radiusPadding;
+        return [xMult * (r + xPadding), yMult * (r + yPadding) + yOffset];
+      } : [xMult * (getRadius * radiusScale * radiusPadding + xPadding), yMult * (getRadius * radiusScale * radiusPadding + yPadding) + yOffset];
+    }
+    calculateBackgroundPadding() {
+      const {
+        getTextAnchor: anchor,
+        getAlignmentBaseline: alignment,
+        sizeScale
+      } = this.props;
+      const paddingX = 12 * sizeScale;
+      const paddingY = 3 * sizeScale;
+      const backgroundPadding = [0, 0, 0, 0];
+      if (alignment === "top") {
+        backgroundPadding[TOP] = paddingY;
+      } else if (alignment === "bottom") {
+        backgroundPadding[BOTTOM] = paddingY;
+      } else {
+        backgroundPadding[TOP] = 0.5 * paddingY;
+        backgroundPadding[BOTTOM] = 0.5 * paddingY;
+      }
+      if (anchor === "start") {
+        backgroundPadding[LEFT] = paddingX;
+      } else if (anchor === "end") {
+        backgroundPadding[RIGHT] = paddingX;
+      } else {
+        backgroundPadding[LEFT] = 0.5 * paddingX;
+        backgroundPadding[RIGHT] = 0.5 * paddingX;
+      }
+      return backgroundPadding;
+    }
+    renderTextLayer(id, {
+      updateTriggers: updateTriggersOverride = {},
+      ...props
+    }) {
+      const {
+        data,
+        characterSet,
+        fontFamily,
+        fontSettings,
+        fontWeight,
+        outlineColor,
+        outlineWidth,
+        sizeScale,
+        radiusScale,
+        getAlignmentBaseline,
+        getColor,
+        getPosition,
+        getTextAnchor,
+        updateTriggers
+      } = this.props;
+      return new EnhancedTextLayer(this.getSubLayerProps({
+        id,
+        data,
+        characterSet,
+        fontFamily,
+        fontSettings,
+        fontWeight,
+        outlineColor,
+        outlineWidth,
+        sizeScale,
+        getAlignmentBaseline,
+        getColor,
+        getPosition,
+        getTextAnchor,
+        updateTriggers: {
+          ...updateTriggers,
+          ...updateTriggersOverride,
+          getPixelOffset: [updateTriggers.getRadius, updateTriggers.getTextAnchor, updateTriggers.getAlignmentBaseline, radiusScale, sizeScale]
+        }
+      }), {
+        getSize: 1,
+        _subLayerProps: {
+          background: {
+            type: EnhancedTextBackgroundLayer
+          }
+        }
+      }, props);
+    }
+    renderLayers() {
+      const {
+        getText,
+        getSecondaryColor,
+        getSecondaryText,
+        secondaryOutlineColor,
+        secondarySizeScale,
+        updateTriggers
+      } = this.props;
+      const getPixelOffset = this.calculatePixelOffset(false);
+      const backgroundPadding = this.calculateBackgroundPadding();
+      const out = [
+        this.renderTextLayer(`${updateTriggers.getText}-primary`, {
+          backgroundPadding,
+          getText,
+          getPixelOffset,
+          background: true
+        }),
+        Boolean(getSecondaryText) && this.renderTextLayer(`${updateTriggers.getSecondaryText}-secondary`, {
+          getText: getSecondaryText,
+          getPixelOffset: this.calculatePixelOffset(true),
+          getAlignmentBaseline: "top",
+          ...getSecondaryColor && {
+            getColor: getSecondaryColor
+          },
+          ...secondarySizeScale && {
+            sizeScale: secondarySizeScale
+          },
+          ...secondaryOutlineColor && {
+            outlineColor: secondaryOutlineColor
+          }
+        })
+      ];
+      return out;
+    }
+  };
+  __publicField(PointLabelLayer, "layerName", "PointLabelLayer");
+  __publicField(PointLabelLayer, "defaultProps", defaultProps7);
+
+  // src/api/parseMap.ts
+  var import_core7 = __toESM(require_core());
+  var import_extensions2 = __toESM(require_extensions());
+  var collisionFilterExtension = new import_extensions2.CollisionFilterExtension();
   function parseMap(json) {
     const {
       keplerMapConfig,
@@ -12830,7 +13010,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       initialViewState: mapState,
       mapStyle,
       token,
-      layers: extractTextLayers(layers.reverse()).map(({
+      layers: layers.reverse().map(({
         id,
         type,
         config,
@@ -12849,60 +13029,26 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
           const {
             Layer,
             propMap,
-            defaultProps: defaultProps8
+            defaultProps: defaultProps9
           } = getLayer(type, config, dataset);
           const styleProps = createStyleProps(config, propMap);
           return new Layer({
             id,
             data,
-            ...defaultProps8,
-            ...!config.textLabel && createInteractionProps(interactionConfig),
+            ...defaultProps9,
+            ...createInteractionProps(interactionConfig),
             ...styleProps,
-            ...createChannelProps(visualChannels, type, config, data),
+            ...createChannelProps(id, type, config, visualChannels, data),
             ...createParametersProp(layerBlending, styleProps.parameters || {}),
             ...createLoadOptions(token)
           });
         } catch (e) {
-          import_core6.log.error(e.message)();
+          import_core7.log.error(e.message)();
           return void 0;
         }
       })
     };
   }
-  function extractTextLayers(layers) {
-    return (0, import_core6._flatten)(layers.map(({
-      id,
-      config,
-      ...rest
-    }) => {
-      const {
-        textLabel,
-        ...configRest
-      } = config;
-      return [
-        {
-          id,
-          config: configRest,
-          ...rest
-        },
-        ...textLabel.filter((t) => t.field).map((t) => {
-          return {
-            id: `${id}-label-${t.field.name}`,
-            config: {
-              textLabel: t,
-              ...configRest,
-              label: `${config.label}-label-${t.field.name}`,
-              visConfig: {
-                ...configRest.visConfig,
-                opacity: 1
-              }
-            },
-            ...rest
-          };
-        })
-      ];
-    }));
-  }
   function createParametersProp(layerBlending, parameters) {
     if (layerBlending === "additive") {
       parameters.blendFunc = [esm_default.SRC_ALPHA, esm_default.DST_ALPHA];
@@ -12957,7 +13103,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
     return result;
   }
-  function createChannelProps(visualChannels, type, config, data) {
+  function createChannelProps(id, type, config, visualChannels, data) {
     const {
       colorField,
       colorScale,
@@ -12981,7 +13127,6 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       visConfig
     } = config;
     const result = {};
-    const textLabelField = textLabel && textLabel.field;
     if (type === "grid" || type === "hexagon") {
       result.colorScaleType = colorScale;
       if (colorField) {
@@ -13066,12 +13211,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
         data
       );
     }
-    if (textLabelField) {
-      result.getText = getTextAccessor(textLabelField, data);
-      result.pointType = "text";
-      const radius = result.getPointRadius || visConfig.radius;
-      result.getTextPixelOffset = getTextPixelOffsetAccessor(textLabel, radius);
-    } else if (visConfig.customMarkers) {
+    if (visConfig.customMarkers) {
       const maxIconSize = getMaxMarkerSize(visConfig, visualChannels);
       const {
         getPointRadius,
@@ -13111,6 +13251,55 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       if (visualChannels.rotationField) {
         result.getIconAngle = negateAccessor(getSizeAccessor(visualChannels.rotationField, void 0, null, void 0, data));
       }
+    } else if (type === "point" || type === "tileset") {
+      result.pointType = "circle";
+    }
+    if (textLabel && textLabel.length && textLabel[0].field) {
+      const [mainLabel, secondaryLabel] = textLabel;
+      const collisionGroup = id;
+      ({
+        alignment: result.getTextAlignmentBaseline,
+        anchor: result.getTextAnchor,
+        color: result.getTextColor,
+        outlineColor: result.textOutlineColor,
+        size: result.textSizeScale
+      } = mainLabel);
+      const {
+        color: getSecondaryColor,
+        field: secondaryField,
+        outlineColor: secondaryOutlineColor,
+        size: secondarySizeScale
+      } = secondaryLabel || {};
+      result.getText = mainLabel.field && getTextAccessor(mainLabel.field, data);
+      const getSecondaryText = secondaryField && getTextAccessor(secondaryField, data);
+      result.pointType = `${result.pointType}+text`;
+      result.textCharacterSet = "auto";
+      result.textFontFamily = "Inter, sans";
+      result.textFontSettings = {
+        sdf: true
+      };
+      result.textFontWeight = 600;
+      result.textOutlineWidth = 3;
+      result._subLayerProps = {
+        ...result._subLayerProps,
+        "points-text": {
+          type: PointLabelLayer,
+          extensions: [collisionFilterExtension],
+          collisionEnabled: true,
+          collisionGroup,
+          ...result.getPointRadius ? {
+            getRadius: result.getPointRadius
+          } : {
+            radiusScale: visConfig.radius
+          },
+          ...secondaryField && {
+            getSecondaryText,
+            getSecondaryColor,
+            secondarySizeScale,
+            secondaryOutlineColor
+          }
+        }
+      };
     }
     return result;
   }
@@ -13127,7 +13316,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
   }
 
   // src/api/maps-v3-client.ts
-  var import_core7 = __toESM(require_core());
+  var import_core8 = __toESM(require_core());
   var MAX_GET_LENGTH = 8192;
   var DEFAULT_CLIENT = "deck-gl-carto";
   var V3_MINOR_VERSION = "3.1";
@@ -13454,7 +13643,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       assert2(url && mapFormat, "Unsupported data formats received from backend.");
     }
     if (format2 === FORMATS.TILEJSON && formatTiles) {
-      import_core7.log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
+      import_core8.log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
       url += `&${encodeParameter("formatTiles", formatTiles)}`;
     }
     const {
@@ -13666,16 +13855,25 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     });
     await fillInMapDatasets(map2, clientId, localCreds, headers);
     await fillInTileStats(map2, localCreds);
-    return {
+    const out = {
       ...parseMap(map2),
       ...{
         stopAutoRefresh
       }
     };
+    const textLayers = out.layers.filter((layer) => {
+      const pointType = layer.props.pointType || "";
+      return pointType.includes("text");
+    });
+    if (textLayers.length && window.FontFace && !document.fonts.check("12px Inter")) {
+      const font = new FontFace("Inter", "url(https://fonts.gstatic.com/s/inter/v12/UcC73FwrK3iLTeHuS_fvQtMwCp50KnMa1ZL7W0Q5nw.woff2)");
+      await font.load().then((f) => document.fonts.add(f));
+    }
+    return out;
   }
 
   // src/layers/carto-layer.ts
-  var defaultProps7 = {
+  var defaultProps8 = {
     data: null,
     type: null,
     onDataLoad: {
@@ -13708,7 +13906,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     aggregationResLevel: null,
     queryParameters: null
   };
-  var CartoLayer = class extends import_core8.CompositeLayer {
+  var CartoLayer = class extends import_core9.CompositeLayer {
     initializeState() {
       this.state = {
         data: null,
@@ -13733,23 +13931,23 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       const {
         apiVersion
       } = localCreds;
-      import_core8.log.assert(Object.values(API_VERSIONS).includes(apiVersion), `Invalid apiVersion ${apiVersion}. Use API_VERSIONS enum.`);
+      import_core9.log.assert(Object.values(API_VERSIONS).includes(apiVersion), `Invalid apiVersion ${apiVersion}. Use API_VERSIONS enum.`);
       if (apiVersion === API_VERSIONS.V1 || apiVersion === API_VERSIONS.V2) {
-        import_core8.log.assert(type === MAP_TYPES.QUERY || type === MAP_TYPES.TILESET, `Invalid type ${type}. Use type MAP_TYPES.QUERY or MAP_TYPES.TILESET for apiVersion ${apiVersion}`);
-        import_core8.log.assert(!connection, `Connection prop is not supported for apiVersion ${apiVersion}`);
-        import_core8.log.assert(!geoColumn, `geoColumn prop is not supported for apiVersion ${apiVersion}`);
-        import_core8.log.assert(!columns, `columns prop is not supported for apiVersion ${apiVersion}`);
+        import_core9.log.assert(type === MAP_TYPES.QUERY || type === MAP_TYPES.TILESET, `Invalid type ${type}. Use type MAP_TYPES.QUERY or MAP_TYPES.TILESET for apiVersion ${apiVersion}`);
+        import_core9.log.assert(!connection, `Connection prop is not supported for apiVersion ${apiVersion}`);
+        import_core9.log.assert(!geoColumn, `geoColumn prop is not supported for apiVersion ${apiVersion}`);
+        import_core9.log.assert(!columns, `columns prop is not supported for apiVersion ${apiVersion}`);
       } else if (apiVersion === API_VERSIONS.V3) {
-        import_core8.log.assert(connection, "Missing mandatory connection parameter");
-        import_core8.log.assert(Object.values(MAP_TYPES).includes(type), `Invalid type ${type}. Use MAP_TYPES enum.`);
+        import_core9.log.assert(connection, "Missing mandatory connection parameter");
+        import_core9.log.assert(Object.values(MAP_TYPES).includes(type), `Invalid type ${type}. Use MAP_TYPES enum.`);
         if (!COLUMNS_SUPPORT.includes(type)) {
-          import_core8.log.assert(!columns, `columns prop is only supported for types: ${COLUMNS_SUPPORT.join()}`);
+          import_core9.log.assert(!columns, `columns prop is only supported for types: ${COLUMNS_SUPPORT.join()}`);
         }
         if (!GEO_COLUMN_SUPPORT.includes(type)) {
-          import_core8.log.assert(!geoColumn, `geoColumn prop is only supported for types: ${GEO_COLUMN_SUPPORT.join()}`);
+          import_core9.log.assert(!geoColumn, `geoColumn prop is only supported for types: ${GEO_COLUMN_SUPPORT.join()}`);
         }
         if (columns) {
-          import_core8.log.assert(Array.isArray(columns), "columns prop must be an Array");
+          import_core9.log.assert(Array.isArray(columns), "columns prop must be an Array");
         }
       }
     }
@@ -13827,7 +14025,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
       } = this.state;
       const {
         uniqueIdProperty
-      } = defaultProps7;
+      } = defaultProps8;
       const {
         data: _notUsed,
         ...propsNoData
@@ -13880,7 +14078,7 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
     }
   };
   __publicField(CartoLayer, "layerName", "CartoLayer");
-  __publicField(CartoLayer, "defaultProps", defaultProps7);
+  __publicField(CartoLayer, "defaultProps", defaultProps8);
 
   // src/basemap.ts
   var baseUrl = "https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json";
@@ -14006,9 +14204,9 @@ ${formatErrorKey(key)}: ${errorContext[key]}`;
 
   // ../layers/bundle/peer-dependency.ts
   var peer_dependency_exports = {};
-  var import_layers3 = __toESM(require_layers());
+  var import_layers4 = __toESM(require_layers());
   __reExport(peer_dependency_exports, __toESM(require_layers()));
-  if (!import_layers3.GeoJsonLayer) {
+  if (!import_layers4.GeoJsonLayer) {
     throw new Error("@deck.gl/layers is not found");
   }