@kepler.gl/components 3.3.0-alpha.3 → 3.3.0-alpha.5

package/dist/map/annotations/annotation-control.js

@@ -11,8 +11,7 @@ var _utils = require("@kepler.gl/utils");
 var _icons = require("../../common/icons");
 var _styledComponents = require("../../common/styled-components");
 var _mapControlTooltip = _interopRequireDefault(require("../map-control-tooltip"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 // SPDX-License-Identifier: MIT
 // Copyright contributors to the kepler.gl project
 
@@ -53,4 +52,4 @@ function AnnotationControlFactory(MapControlTooltip) {
   AnnotationControl.displayName = 'AnnotationControl';
   return /*#__PURE__*/_react["default"].memo(AnnotationControl);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/map/attribution.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import { AttributionWithStyle, DatasetAttribution } from '@kepler.gl/types';
+import { BaseMapLibraryConfig } from '@kepler.gl/utils';
+import type { GlobeAttribution } from '@kepler.gl/deckgl-layers';
+type MapLibLogoProps = {
+    baseMapLibraryConfig: BaseMapLibraryConfig;
+};
+export declare const MapLibLogo: ({ baseMapLibraryConfig }: MapLibLogoProps) => React.JSX.Element;
+export declare const DatasetAttributions: ({ datasetAttributions, isPalm }: {
+    datasetAttributions: DatasetAttribution[];
+    isPalm: boolean;
+}) => React.JSX.Element;
+type AttributionProps = {
+    showBaseMapLibLogo: boolean;
+    basemapAttributions?: string[];
+    datasetAttributions: DatasetAttribution[];
+    baseMapLibraryConfig: BaseMapLibraryConfig;
+    globeAttributions?: GlobeAttribution[];
+};
+/**
+ * Parse a basemap attribution HTML string into safe React nodes. Only anchor
+ * tags with http(s)/mailto hrefs become links; everything else is rendered as
+ * plain text. This avoids dangerouslySetInnerHTML while preserving the links
+ * custom basemap styles (e.g. OpenFreeMap) declare in their attribution.
+ *
+ * Uses the browser's DOMParser (inert: scripts don't run and no resources are
+ * fetched) so nested tags, `>` inside attributes, unusual quoting, and HTML
+ * entities are all handled correctly. Falls back to plain text where no DOM is
+ * available (e.g. SSR).
+ */
+export declare function renderBasemapAttribution(html: string, keyPrefix: string): React.ReactNode[];
+/**
+ * Drop attributions whose providers are already fully represented by a single
+ * earlier (kept) attribution. Order is preserved, and the longer/more complete
+ * strings tend to come first from the sources so they survive. This collapses
+ * near-duplicates such as a standalone "© OpenStreetMap" when a CARTO string
+ * that already links OpenStreetMap is present.
+ *
+ * Subsumption is checked against each kept attribution *individually* (never a
+ * merged union), so an entry is only dropped when some single earlier entry
+ * fully covers it. This avoids false positives where two unrelated providers'
+ * tokens together happen to cover a distinct third provider.
+ */
+export declare function dedupeBasemapAttributions(attributions: string[]): string[];
+export declare const Attribution: React.FC<AttributionProps>;
+type AttributionLogosProps = {
+    logos: AttributionWithStyle[];
+    activeSidePanel?: boolean;
+    sidePanelWidth?: number;
+};
+export declare const AttributionLogos: React.FC<AttributionLogosProps>;
+export {};

package/dist/map/attribution.js

@@ -0,0 +1,391 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MapLibLogo = exports.DatasetAttributions = exports.AttributionLogos = exports.Attribution = void 0;
+exports.dedupeBasemapAttributions = dedupeBasemapAttributions;
+exports.renderBasemapAttribution = renderBasemapAttribution;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _styledComponents = _interopRequireWildcard(require("styled-components"));
+var _utils = require("@kepler.gl/utils");
+var _styles = require("@kepler.gl/styles");
+var _styledComponents2 = require("../common/styled-components");
+var _templateObject, _templateObject2, _templateObject3; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+var MapLibLogo = exports.MapLibLogo = function MapLibLogo(_ref) {
+  var baseMapLibraryConfig = _ref.baseMapLibraryConfig;
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: "attrition-logo"
+  }, "Basemap by:", /*#__PURE__*/_react["default"].createElement("a", {
+    style: {
+      marginLeft: '5px'
+    },
+    className: "".concat(baseMapLibraryConfig.mapLibCssClass, "-ctrl-logo"),
+    target: "_blank",
+    rel: "noopener noreferrer",
+    href: baseMapLibraryConfig.mapLibUrl,
+    "aria-label": "".concat(baseMapLibraryConfig.mapLibName, " logo")
+  }));
+};
+var StyledDatasetAttributionsContainer = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  max-width: ", ";\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n  color: ", ";\n  margin-right: 2px;\n  margin-bottom: 1px;\n  line-height: ", ";\n\n  &:hover {\n    white-space: inherit;\n  }\n"])), function (props) {
+  return props.isPalm ? '200px' : '300px';
+}, function (props) {
+  return props.theme.labelColor;
+}, function (props) {
+  return props.isPalm ? '1em' : '1.4em';
+});
+var DatasetAttributions = exports.DatasetAttributions = function DatasetAttributions(_ref2) {
+  var datasetAttributions = _ref2.datasetAttributions,
+    isPalm = _ref2.isPalm;
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/_react["default"].createElement(StyledDatasetAttributionsContainer, {
+    isPalm: isPalm
+  }, datasetAttributions.map(function (ds, idx) {
+    return /*#__PURE__*/_react["default"].createElement("a", (0, _extends2["default"])({}, ds.url ? {
+      href: ds.url
+    } : null, {
+      target: "_blank",
+      rel: "noopener noreferrer",
+      key: "".concat(ds.title, "_").concat(idx)
+    }), ds.title, idx !== datasetAttributions.length - 1 ? ', ' : null);
+  })) : null);
+};
+var ATTRIBUTION_SAFE_HREF_REGEX = /^(https?:|mailto:)/i;
+
+/**
+ * Decode the handful of HTML entities that commonly appear in basemap
+ * attribution strings, so they render as text rather than raw entities. Only
+ * needed on the SSR / no-DOM fallback path; in the browser DOMParser decodes
+ * entities for us.
+ */
+function decodeAttributionEntities(text) {
+  return text.replace(/&copy;/gi, '©').replace(/&nbsp;/gi, ' ').replace(/&lt;/gi, '<').replace(/&gt;/gi, '>').replace(/&quot;/gi, '"').replace(/&#0*39;/gi, "'").replace(/&amp;/gi, '&');
+}
+
+/**
+ * Strip all markup from a string as a fallback for environments without a DOM
+ * (e.g. SSR), then decode common HTML entities. Uses a non-greedy tag matcher;
+ * only used when DOMParser is unavailable, so it never has to be perfectly
+ * correct.
+ */
+function stripTags(html) {
+  return decodeAttributionEntities(html.replace(/<[^>]*>/g, '')).trim();
+}
+
+/**
+ * Recursively convert parsed DOM nodes into safe React nodes. Only anchor
+ * elements with http(s)/mailto hrefs become links; every other element is
+ * flattened to its text content. Text nodes are emitted with internal
+ * whitespace collapsed to single spaces (matching HTML rendering), so the
+ * meaningful single space between adjacent links is preserved while we avoid
+ * emitting large whitespace blobs.
+ *
+ * Anchors are collapsed to their `textContent`, so any markup nested inside an
+ * anchor (including an invalid nested `<a>`) becomes plain text — a link can
+ * never contain another link.
+ */
+function domNodesToReact(nodes, keyPrefix, counter) {
+  var result = [];
+  nodes.forEach(function (node) {
+    if (node.nodeType === 3 /* TEXT_NODE */) {
+      // collapse whitespace runs to a single space (HTML-like), keeping a
+      // meaningful separating space between adjacent inline links
+      var text = (node.textContent || '').replace(/\s+/g, ' ');
+      if (text) {
+        result.push(/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+          key: "".concat(keyPrefix, "-t").concat(counter.i++)
+        }, text));
+      }
+      return;
+    }
+    if (node.nodeType !== 1 /* ELEMENT_NODE */) {
+      return;
+    }
+    var el = node;
+    var tag = el.tagName.toLowerCase();
+    // never surface the source of script/style/template elements as text
+    if (tag === 'script' || tag === 'style' || tag === 'template' || tag === 'noscript') {
+      return;
+    }
+    if (tag === 'a') {
+      var href = el.getAttribute('href') || '';
+      // textContent flattens any nested markup (incl. a nested <a>) to text, so
+      // the rendered link can never contain another link
+      var _text = el.textContent || '';
+      if (!_text.trim()) return;
+      if (ATTRIBUTION_SAFE_HREF_REGEX.test(href)) {
+        result.push(/*#__PURE__*/_react["default"].createElement("a", {
+          key: "".concat(keyPrefix, "-a").concat(counter.i++),
+          href: href,
+          target: "_blank",
+          rel: "noopener noreferrer"
+        }, _text));
+      } else {
+        // drop unsafe hrefs (e.g. javascript:) but keep the link text
+        result.push(/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+          key: "".concat(keyPrefix, "-a").concat(counter.i++)
+        }, _text));
+      }
+      return;
+    }
+    // any other element: keep its (recursively resolved) children
+    result.push.apply(result, (0, _toConsumableArray2["default"])(domNodesToReact(el.childNodes, keyPrefix, counter)));
+  });
+  return result;
+}
+function resolveDOMParser() {
+  return typeof window !== 'undefined' && window.DOMParser || typeof globalThis !== 'undefined' && globalThis.DOMParser || null;
+}
+
+/**
+ * Parse a basemap attribution HTML string into safe React nodes. Only anchor
+ * tags with http(s)/mailto hrefs become links; everything else is rendered as
+ * plain text. This avoids dangerouslySetInnerHTML while preserving the links
+ * custom basemap styles (e.g. OpenFreeMap) declare in their attribution.
+ *
+ * Uses the browser's DOMParser (inert: scripts don't run and no resources are
+ * fetched) so nested tags, `>` inside attributes, unusual quoting, and HTML
+ * entities are all handled correctly. Falls back to plain text where no DOM is
+ * available (e.g. SSR).
+ */
+function renderBasemapAttribution(html, keyPrefix) {
+  var DOMParserCtor = resolveDOMParser();
+  if (!DOMParserCtor) {
+    var text = stripTags(html);
+    return text ? [/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+      key: "".concat(keyPrefix, "-t0")
+    }, text)] : [];
+  }
+  try {
+    var doc = new DOMParserCtor().parseFromString(html, 'text/html');
+    return domNodesToReact(doc.body.childNodes, keyPrefix, {
+      i: 0
+    }).filter(Boolean);
+  } catch (_unused) {
+    var _text2 = stripTags(html);
+    return _text2 ? [/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+      key: "".concat(keyPrefix, "-t0")
+    }, _text2)] : [];
+  }
+}
+
+/**
+ * Build a set of "signature" tokens for an attribution string: the hostname of
+ * each safe link plus the normalized plain text (lowercased, punctuation and
+ * the boilerplate word "contributors" removed). Two attributions that point at
+ * the same providers therefore produce overlapping signatures even when their
+ * wording differs (e.g. "© OpenStreetMap" vs "© OpenStreetMap contributors").
+ */
+function attributionSignature(html) {
+  var tokens = new Set();
+  var DOMParserCtor = resolveDOMParser();
+  var text = html;
+  if (DOMParserCtor) {
+    try {
+      var doc = new DOMParserCtor().parseFromString(html, 'text/html');
+      doc.body.querySelectorAll('a').forEach(function (a) {
+        var href = a.getAttribute('href') || '';
+        if (ATTRIBUTION_SAFE_HREF_REGEX.test(href)) {
+          try {
+            tokens.add("href:".concat(new URL(href).hostname.replace(/^www\./, '').toLowerCase()));
+          } catch (_unused2) {
+            tokens.add("href:".concat(href.toLowerCase()));
+          }
+        }
+      });
+      text = doc.body.textContent || '';
+    } catch (_unused3) {
+      text = stripTags(html);
+    }
+  } else {
+    text = stripTags(html);
+  }
+  var normalized = text.toLowerCase().replace(/©|&copy;/g, '').replace(/\bcontributors?\b/g, '').replace(/[^a-z0-9]+/g, ' ').trim();
+  if (normalized) {
+    // emit per-word tokens so a shorter attribution's words can be subsumed by
+    // a longer one that mentions the same providers (e.g. "openstreetmap" is
+    // covered by a CARTO string mentioning both "carto" and "openstreetmap")
+    normalized.split(' ').forEach(function (word) {
+      if (word) tokens.add("text:".concat(word));
+    });
+  }
+  return tokens;
+}
+
+/**
+ * Drop attributions whose providers are already fully represented by a single
+ * earlier (kept) attribution. Order is preserved, and the longer/more complete
+ * strings tend to come first from the sources so they survive. This collapses
+ * near-duplicates such as a standalone "© OpenStreetMap" when a CARTO string
+ * that already links OpenStreetMap is present.
+ *
+ * Subsumption is checked against each kept attribution *individually* (never a
+ * merged union), so an entry is only dropped when some single earlier entry
+ * fully covers it. This avoids false positives where two unrelated providers'
+ * tokens together happen to cover a distinct third provider.
+ */
+function dedupeBasemapAttributions(attributions) {
+  var kept = [];
+  var keptTokens = [];
+  attributions.forEach(function (attribution) {
+    var sig = attributionSignature(attribution);
+    if (sig.size === 0) {
+      // nothing to compare on; keep as-is (exact dedup already done upstream)
+      if (!kept.includes(attribution)) {
+        kept.push(attribution);
+        keptTokens.push(sig);
+      }
+      return;
+    }
+    // subsumed only if some single kept attribution's tokens are a superset
+    var isSubsumed = keptTokens.some(function (tokens) {
+      return tokens.size > 0 && (0, _toConsumableArray2["default"])(sig).every(function (t) {
+        return tokens.has(t);
+      });
+    });
+    if (!isSubsumed) {
+      kept.push(attribution);
+      keptTokens.push(sig);
+    }
+  });
+  return kept;
+}
+
+/**
+ * Render a list of items as `| item | item ...` fragments, each preceded by a
+ * pipe separator. Keys are index-based (safe even when item content collides,
+ * e.g. two globe attributions sharing a label). Returns null when empty so
+ * callers can `{group}` inline.
+ */
+function renderSeparatedLinks(items, keyPrefix, renderItem) {
+  if (!items.length) return null;
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, items.map(function (item, idx) {
+    return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, {
+      key: "".concat(keyPrefix, "-").concat(idx)
+    }, /*#__PURE__*/_react["default"].createElement("span", {
+      className: "pipe-separator"
+    }, "|"), renderItem(item, idx));
+  }));
+}
+var Attribution = exports.Attribution = function Attribution(_ref3) {
+  var _ref3$showBaseMapLibL = _ref3.showBaseMapLibLogo,
+    showBaseMapLibLogo = _ref3$showBaseMapLibL === void 0 ? true : _ref3$showBaseMapLibL,
+    _ref3$basemapAttribut = _ref3.basemapAttributions,
+    basemapAttributions = _ref3$basemapAttribut === void 0 ? [] : _ref3$basemapAttribut,
+    datasetAttributions = _ref3.datasetAttributions,
+    baseMapLibraryConfig = _ref3.baseMapLibraryConfig,
+    _ref3$globeAttributio = _ref3.globeAttributions,
+    globeAttributions = _ref3$globeAttributio === void 0 ? [] : _ref3$globeAttributio;
+  var isPalm = (0, _utils.hasMobileWidth)(_styles.breakPointValues);
+  var memoizedComponents = (0, _react.useMemo)(function () {
+    // collapse near-duplicate attributions (e.g. a standalone OSM link when a
+    // CARTO string already links OSM) before rendering
+    var dedupedBasemapAttributions = dedupeBasemapAttributions(basemapAttributions);
+    // attributions declared by custom basemap styles, rendered as safe links
+    var basemapAttributionNodes = renderSeparatedLinks(dedupedBasemapAttributions, 'basemap-attr', function (attribution, idx) {
+      return /*#__PURE__*/_react["default"].createElement("span", {
+        className: "basemap-attribution"
+      }, renderBasemapAttribution(attribution, "basemap-attr-".concat(idx)));
+    });
+    var globeAttributionNodes = renderSeparatedLinks(globeAttributions, 'globe-attr', function (attr) {
+      return /*#__PURE__*/_react["default"].createElement("a", {
+        href: attr.href,
+        target: "_blank",
+        rel: "noopener noreferrer"
+      }, attr.label);
+    });
+    if (!showBaseMapLibLogo) {
+      return /*#__PURE__*/_react["default"].createElement(_styledComponents2.StyledAttribution, {
+        mapLibCssClass: baseMapLibraryConfig.mapLibCssClass,
+        mapLibAttributionCssClass: baseMapLibraryConfig.mapLibAttributionCssClass,
+        showLogo: globeAttributions.length > 0
+      }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.EndHorizontalFlexbox, null, /*#__PURE__*/_react["default"].createElement(DatasetAttributions, {
+        datasetAttributions: datasetAttributions,
+        isPalm: isPalm
+      }), /*#__PURE__*/_react["default"].createElement("div", {
+        className: "attrition-link"
+      }, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/_react["default"].createElement("span", {
+        className: "pipe-separator"
+      }, "|") : null, globeAttributions.length && isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, {
+        baseMapLibraryConfig: baseMapLibraryConfig
+      }) : null, /*#__PURE__*/_react["default"].createElement("a", {
+        href: "https://kepler.gl/policy/",
+        target: "_blank",
+        rel: "noopener noreferrer"
+      }, "\xA9 kepler.gl"), basemapAttributionNodes, globeAttributionNodes, globeAttributions.length ? /*#__PURE__*/_react["default"].createElement("span", {
+        className: "pipe-separator"
+      }, "|") : null, globeAttributions.length && !isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, {
+        baseMapLibraryConfig: baseMapLibraryConfig
+      }) : null)));
+    }
+    return /*#__PURE__*/_react["default"].createElement(_styledComponents2.StyledAttribution, {
+      mapLibCssClass: baseMapLibraryConfig.mapLibCssClass,
+      mapLibAttributionCssClass: baseMapLibraryConfig.mapLibAttributionCssClass,
+      showLogo: true
+    }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.EndHorizontalFlexbox, null, /*#__PURE__*/_react["default"].createElement(DatasetAttributions, {
+      datasetAttributions: datasetAttributions,
+      isPalm: isPalm
+    }), /*#__PURE__*/_react["default"].createElement("div", {
+      className: "attrition-link"
+    }, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/_react["default"].createElement("span", {
+      className: "pipe-separator"
+    }, "|") : null, isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, {
+      baseMapLibraryConfig: baseMapLibraryConfig
+    }) : null, /*#__PURE__*/_react["default"].createElement("a", {
+      href: "https://kepler.gl/policy/",
+      target: "_blank",
+      rel: "noopener noreferrer"
+    }, "\xA9 kepler.gl"), basemapAttributionNodes, globeAttributionNodes, /*#__PURE__*/_react["default"].createElement("span", {
+      className: "pipe-separator"
+    }, "|"), !isPalm ? /*#__PURE__*/_react["default"].createElement(MapLibLogo, {
+      baseMapLibraryConfig: baseMapLibraryConfig
+    }) : null)));
+  }, [showBaseMapLibLogo, basemapAttributions, datasetAttributions, isPalm, baseMapLibraryConfig, globeAttributions]);
+  return memoizedComponents;
+};
+var StyledAttributionLogoContainer = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  position: absolute;\n  bottom: ", "px;\n  left: ", "px;\n  z-index: 1;\n  display: flex;\n  align-items: flex-end;\n  gap: 4px;\n  pointer-events: auto;\n  transition: left 250ms ease-in-out;\n"])), function (props) {
+  return props.theme.sidePanel.margin.left;
+}, function (props) {
+  return props.$left;
+});
+var StyledLogoLink = _styledComponents["default"].a(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  cursor: ", ";\n  display: flex;\n  align-items: flex-end;\n"])), function (props) {
+  return props.$enabled ? 'pointer' : 'default';
+});
+var LOGO_LEFT_ADJUSTMENT = 3;
+var AttributionLogos = exports.AttributionLogos = function AttributionLogos(_ref4) {
+  var logos = _ref4.logos,
+    activeSidePanel = _ref4.activeSidePanel,
+    sidePanelWidth = _ref4.sidePanelWidth;
+  var theme = (0, _styledComponents.useTheme)();
+  var left = (activeSidePanel ? (sidePanelWidth || 0) + LOGO_LEFT_ADJUSTMENT : 0) + theme.sidePanel.margin.left;
+  if (!(logos !== null && logos !== void 0 && logos.length)) return null;
+  return /*#__PURE__*/_react["default"].createElement(StyledAttributionLogoContainer, {
+    $left: left
+  }, logos.map(function (logo, idx) {
+    return /*#__PURE__*/_react["default"].createElement(StyledLogoLink, (0, _extends2["default"])({
+      key: logo.logoUrl || idx,
+      href: logo.url || undefined
+    }, logo.url ? {
+      target: '_blank',
+      rel: 'noopener noreferrer'
+    } : {}, {
+      $enabled: Boolean(logo.url),
+      style: logo.bottom ? {
+        marginBottom: logo.bottom
+      } : undefined
+    }), /*#__PURE__*/_react["default"].createElement("img", {
+      src: logo.logoUrl,
+      style: {
+        height: logo.height || 12
+      },
+      alt: logo.title
+    }));
+  }));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_styledComponents","_utils","_styles","_styledComponents2","_templateObject","_templateObject2","_templateObject3","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","_typeof","has","get","set","_t","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","MapLibLogo","exports","_ref","baseMapLibraryConfig","createElement","className","style","marginLeft","concat","mapLibCssClass","target","rel","href","mapLibUrl","mapLibName","StyledDatasetAttributionsContainer","styled","div","_taggedTemplateLiteral2","props","isPalm","theme","labelColor","DatasetAttributions","_ref2","datasetAttributions","Fragment","length","map","ds","idx","_extends2","url","key","title","ATTRIBUTION_SAFE_HREF_REGEX","decodeAttributionEntities","text","replace","stripTags","html","trim","domNodesToReact","nodes","keyPrefix","counter","result","forEach","node","nodeType","textContent","push","el","tag","tagName","toLowerCase","getAttribute","test","apply","_toConsumableArray2","childNodes","resolveDOMParser","window","DOMParser","globalThis","renderBasemapAttribution","DOMParserCtor","doc","parseFromString","body","filter","Boolean","_unused","attributionSignature","tokens","Set","querySelectorAll","a","add","URL","hostname","_unused2","_unused3","normalized","split","word","dedupeBasemapAttributions","attributions","kept","keptTokens","attribution","sig","size","includes","isSubsumed","some","every","renderSeparatedLinks","items","renderItem","item","Attribution","_ref3","_ref3$showBaseMapLibL","showBaseMapLibLogo","_ref3$basemapAttribut","basemapAttributions","_ref3$globeAttributio","globeAttributions","hasMobileWidth","breakPointValues","memoizedComponents","useMemo","dedupedBasemapAttributions","basemapAttributionNodes","globeAttributionNodes","attr","label","StyledAttribution","mapLibAttributionCssClass","showLogo","EndHorizontalFlexbox","StyledAttributionLogoContainer","sidePanel","margin","left","$left","StyledLogoLink","$enabled","LOGO_LEFT_ADJUSTMENT","AttributionLogos","_ref4","logos","activeSidePanel","sidePanelWidth","useTheme","logo","logoUrl","undefined","bottom","marginBottom","src","height","alt"],"sources":["../../src/map/attribution.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useMemo} from 'react';\nimport styled, {useTheme} from 'styled-components';\n\nimport {AttributionWithStyle, DatasetAttribution} from '@kepler.gl/types';\nimport {BaseMapLibraryConfig, hasMobileWidth} from '@kepler.gl/utils';\nimport {breakPointValues} from '@kepler.gl/styles';\nimport type {GlobeAttribution} from '@kepler.gl/deckgl-layers';\n\nimport {StyledAttribution, EndHorizontalFlexbox} from '../common/styled-components';\n\ntype MapLibLogoProps = {\n  baseMapLibraryConfig: BaseMapLibraryConfig;\n};\n\nexport const MapLibLogo = ({baseMapLibraryConfig}: MapLibLogoProps) => (\n  <div className=\"attrition-logo\">\n    Basemap by:\n    <a\n      style={{marginLeft: '5px'}}\n      className={`${baseMapLibraryConfig.mapLibCssClass}-ctrl-logo`}\n      target=\"_blank\"\n      rel=\"noopener noreferrer\"\n      href={baseMapLibraryConfig.mapLibUrl}\n      aria-label={`${baseMapLibraryConfig.mapLibName} logo`}\n    />\n  </div>\n);\n\ninterface StyledDatasetAttributionsContainerProps {\n  isPalm: boolean;\n}\n\nconst StyledDatasetAttributionsContainer = styled.div<StyledDatasetAttributionsContainerProps>`\n  max-width: ${props => (props.isPalm ? '200px' : '300px')};\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n  color: ${props => props.theme.labelColor};\n  margin-right: 2px;\n  margin-bottom: 1px;\n  line-height: ${props => (props.isPalm ? '1em' : '1.4em')};\n\n  &:hover {\n    white-space: inherit;\n  }\n`;\n\nexport const DatasetAttributions = ({\n  datasetAttributions,\n  isPalm\n}: {\n  datasetAttributions: DatasetAttribution[];\n  isPalm: boolean;\n}) => (\n  <>\n    {datasetAttributions?.length ? (\n      <StyledDatasetAttributionsContainer isPalm={isPalm}>\n        {datasetAttributions.map((ds, idx) => (\n          <a\n            {...(ds.url ? {href: ds.url} : null)}\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n            key={`${ds.title}_${idx}`}\n          >\n            {ds.title}\n            {idx !== datasetAttributions.length - 1 ? ', ' : null}\n          </a>\n        ))}\n      </StyledDatasetAttributionsContainer>\n    ) : null}\n  </>\n);\n\ntype AttributionProps = {\n  showBaseMapLibLogo: boolean;\n  basemapAttributions?: string[];\n  datasetAttributions: DatasetAttribution[];\n  baseMapLibraryConfig: BaseMapLibraryConfig;\n  globeAttributions?: GlobeAttribution[];\n};\n\nconst ATTRIBUTION_SAFE_HREF_REGEX = /^(https?:|mailto:)/i;\n\n/**\n * Decode the handful of HTML entities that commonly appear in basemap\n * attribution strings, so they render as text rather than raw entities. Only\n * needed on the SSR / no-DOM fallback path; in the browser DOMParser decodes\n * entities for us.\n */\nfunction decodeAttributionEntities(text: string): string {\n  return text\n    .replace(/&copy;/gi, '©')\n    .replace(/&nbsp;/gi, ' ')\n    .replace(/&lt;/gi, '<')\n    .replace(/&gt;/gi, '>')\n    .replace(/&quot;/gi, '\"')\n    .replace(/&#0*39;/gi, \"'\")\n    .replace(/&amp;/gi, '&');\n}\n\n/**\n * Strip all markup from a string as a fallback for environments without a DOM\n * (e.g. SSR), then decode common HTML entities. Uses a non-greedy tag matcher;\n * only used when DOMParser is unavailable, so it never has to be perfectly\n * correct.\n */\nfunction stripTags(html: string): string {\n  return decodeAttributionEntities(html.replace(/<[^>]*>/g, '')).trim();\n}\n\n/**\n * Recursively convert parsed DOM nodes into safe React nodes. Only anchor\n * elements with http(s)/mailto hrefs become links; every other element is\n * flattened to its text content. Text nodes are emitted with internal\n * whitespace collapsed to single spaces (matching HTML rendering), so the\n * meaningful single space between adjacent links is preserved while we avoid\n * emitting large whitespace blobs.\n *\n * Anchors are collapsed to their `textContent`, so any markup nested inside an\n * anchor (including an invalid nested `<a>`) becomes plain text — a link can\n * never contain another link.\n */\nfunction domNodesToReact(\n  nodes: NodeListOf<ChildNode> | ChildNode[],\n  keyPrefix: string,\n  counter: {i: number}\n): React.ReactNode[] {\n  const result: React.ReactNode[] = [];\n  nodes.forEach(node => {\n    if (node.nodeType === 3 /* TEXT_NODE */) {\n      // collapse whitespace runs to a single space (HTML-like), keeping a\n      // meaningful separating space between adjacent inline links\n      const text = (node.textContent || '').replace(/\\s+/g, ' ');\n      if (text) {\n        result.push(<React.Fragment key={`${keyPrefix}-t${counter.i++}`}>{text}</React.Fragment>);\n      }\n      return;\n    }\n    if (node.nodeType !== 1 /* ELEMENT_NODE */) {\n      return;\n    }\n    const el = node as Element;\n    const tag = el.tagName.toLowerCase();\n    // never surface the source of script/style/template elements as text\n    if (tag === 'script' || tag === 'style' || tag === 'template' || tag === 'noscript') {\n      return;\n    }\n    if (tag === 'a') {\n      const href = el.getAttribute('href') || '';\n      // textContent flattens any nested markup (incl. a nested <a>) to text, so\n      // the rendered link can never contain another link\n      const text = el.textContent || '';\n      if (!text.trim()) return;\n      if (ATTRIBUTION_SAFE_HREF_REGEX.test(href)) {\n        result.push(\n          <a\n            key={`${keyPrefix}-a${counter.i++}`}\n            href={href}\n            target=\"_blank\"\n            rel=\"noopener noreferrer\"\n          >\n            {text}\n          </a>\n        );\n      } else {\n        // drop unsafe hrefs (e.g. javascript:) but keep the link text\n        result.push(<React.Fragment key={`${keyPrefix}-a${counter.i++}`}>{text}</React.Fragment>);\n      }\n      return;\n    }\n    // any other element: keep its (recursively resolved) children\n    result.push(...domNodesToReact(el.childNodes, keyPrefix, counter));\n  });\n  return result;\n}\n\nfunction resolveDOMParser(): {new (): DOMParser} | null {\n  return (\n    (typeof window !== 'undefined' && (window as any).DOMParser) ||\n    (typeof globalThis !== 'undefined' && (globalThis as any).DOMParser) ||\n    null\n  );\n}\n\n/**\n * Parse a basemap attribution HTML string into safe React nodes. Only anchor\n * tags with http(s)/mailto hrefs become links; everything else is rendered as\n * plain text. This avoids dangerouslySetInnerHTML while preserving the links\n * custom basemap styles (e.g. OpenFreeMap) declare in their attribution.\n *\n * Uses the browser's DOMParser (inert: scripts don't run and no resources are\n * fetched) so nested tags, `>` inside attributes, unusual quoting, and HTML\n * entities are all handled correctly. Falls back to plain text where no DOM is\n * available (e.g. SSR).\n */\nexport function renderBasemapAttribution(html: string, keyPrefix: string): React.ReactNode[] {\n  const DOMParserCtor = resolveDOMParser();\n  if (!DOMParserCtor) {\n    const text = stripTags(html);\n    return text ? [<React.Fragment key={`${keyPrefix}-t0`}>{text}</React.Fragment>] : [];\n  }\n  try {\n    const doc = new DOMParserCtor().parseFromString(html, 'text/html');\n    return domNodesToReact(doc.body.childNodes, keyPrefix, {i: 0}).filter(Boolean);\n  } catch {\n    const text = stripTags(html);\n    return text ? [<React.Fragment key={`${keyPrefix}-t0`}>{text}</React.Fragment>] : [];\n  }\n}\n\n/**\n * Build a set of \"signature\" tokens for an attribution string: the hostname of\n * each safe link plus the normalized plain text (lowercased, punctuation and\n * the boilerplate word \"contributors\" removed). Two attributions that point at\n * the same providers therefore produce overlapping signatures even when their\n * wording differs (e.g. \"© OpenStreetMap\" vs \"© OpenStreetMap contributors\").\n */\nfunction attributionSignature(html: string): Set<string> {\n  const tokens = new Set<string>();\n  const DOMParserCtor = resolveDOMParser();\n  let text = html;\n  if (DOMParserCtor) {\n    try {\n      const doc = new DOMParserCtor().parseFromString(html, 'text/html');\n      doc.body.querySelectorAll('a').forEach(a => {\n        const href = a.getAttribute('href') || '';\n        if (ATTRIBUTION_SAFE_HREF_REGEX.test(href)) {\n          try {\n            tokens.add(`href:${new URL(href).hostname.replace(/^www\\./, '').toLowerCase()}`);\n          } catch {\n            tokens.add(`href:${href.toLowerCase()}`);\n          }\n        }\n      });\n      text = doc.body.textContent || '';\n    } catch {\n      text = stripTags(html);\n    }\n  } else {\n    text = stripTags(html);\n  }\n  const normalized = text\n    .toLowerCase()\n    .replace(/©|&copy;/g, '')\n    .replace(/\\bcontributors?\\b/g, '')\n    .replace(/[^a-z0-9]+/g, ' ')\n    .trim();\n  if (normalized) {\n    // emit per-word tokens so a shorter attribution's words can be subsumed by\n    // a longer one that mentions the same providers (e.g. \"openstreetmap\" is\n    // covered by a CARTO string mentioning both \"carto\" and \"openstreetmap\")\n    normalized.split(' ').forEach(word => {\n      if (word) tokens.add(`text:${word}`);\n    });\n  }\n  return tokens;\n}\n\n/**\n * Drop attributions whose providers are already fully represented by a single\n * earlier (kept) attribution. Order is preserved, and the longer/more complete\n * strings tend to come first from the sources so they survive. This collapses\n * near-duplicates such as a standalone \"© OpenStreetMap\" when a CARTO string\n * that already links OpenStreetMap is present.\n *\n * Subsumption is checked against each kept attribution *individually* (never a\n * merged union), so an entry is only dropped when some single earlier entry\n * fully covers it. This avoids false positives where two unrelated providers'\n * tokens together happen to cover a distinct third provider.\n */\nexport function dedupeBasemapAttributions(attributions: string[]): string[] {\n  const kept: string[] = [];\n  const keptTokens: Set<string>[] = [];\n  attributions.forEach(attribution => {\n    const sig = attributionSignature(attribution);\n    if (sig.size === 0) {\n      // nothing to compare on; keep as-is (exact dedup already done upstream)\n      if (!kept.includes(attribution)) {\n        kept.push(attribution);\n        keptTokens.push(sig);\n      }\n      return;\n    }\n    // subsumed only if some single kept attribution's tokens are a superset\n    const isSubsumed = keptTokens.some(\n      tokens => tokens.size > 0 && [...sig].every(t => tokens.has(t))\n    );\n    if (!isSubsumed) {\n      kept.push(attribution);\n      keptTokens.push(sig);\n    }\n  });\n  return kept;\n}\n\n/**\n * Render a list of items as `| item | item ...` fragments, each preceded by a\n * pipe separator. Keys are index-based (safe even when item content collides,\n * e.g. two globe attributions sharing a label). Returns null when empty so\n * callers can `{group}` inline.\n */\nfunction renderSeparatedLinks<T>(\n  items: T[],\n  keyPrefix: string,\n  renderItem: (item: T, index: number) => React.ReactNode\n): React.ReactNode {\n  if (!items.length) return null;\n  return (\n    <>\n      {items.map((item, idx) => (\n        <React.Fragment key={`${keyPrefix}-${idx}`}>\n          <span className=\"pipe-separator\">|</span>\n          {renderItem(item, idx)}\n        </React.Fragment>\n      ))}\n    </>\n  );\n}\n\nexport const Attribution: React.FC<AttributionProps> = ({\n  showBaseMapLibLogo = true,\n  basemapAttributions = [],\n  datasetAttributions,\n  baseMapLibraryConfig,\n  globeAttributions = []\n}: AttributionProps) => {\n  const isPalm = hasMobileWidth(breakPointValues);\n\n  const memoizedComponents = useMemo(() => {\n    // collapse near-duplicate attributions (e.g. a standalone OSM link when a\n    // CARTO string already links OSM) before rendering\n    const dedupedBasemapAttributions = dedupeBasemapAttributions(basemapAttributions);\n    // attributions declared by custom basemap styles, rendered as safe links\n    const basemapAttributionNodes = renderSeparatedLinks(\n      dedupedBasemapAttributions,\n      'basemap-attr',\n      (attribution, idx) => (\n        <span className=\"basemap-attribution\">\n          {renderBasemapAttribution(attribution, `basemap-attr-${idx}`)}\n        </span>\n      )\n    );\n\n    const globeAttributionNodes = renderSeparatedLinks(globeAttributions, 'globe-attr', attr => (\n      <a href={attr.href} target=\"_blank\" rel=\"noopener noreferrer\">\n        {attr.label}\n      </a>\n    ));\n\n    if (!showBaseMapLibLogo) {\n      return (\n        <StyledAttribution\n          mapLibCssClass={baseMapLibraryConfig.mapLibCssClass}\n          mapLibAttributionCssClass={baseMapLibraryConfig.mapLibAttributionCssClass}\n          showLogo={globeAttributions.length > 0}\n        >\n          <EndHorizontalFlexbox>\n            <DatasetAttributions datasetAttributions={datasetAttributions} isPalm={isPalm} />\n            <div className=\"attrition-link\">\n              {datasetAttributions?.length ? <span className=\"pipe-separator\">|</span> : null}\n              {globeAttributions.length && isPalm ? (\n                <MapLibLogo baseMapLibraryConfig={baseMapLibraryConfig} />\n              ) : null}\n              <a href=\"https://kepler.gl/policy/\" target=\"_blank\" rel=\"noopener noreferrer\">\n                © kepler.gl\n              </a>\n              {basemapAttributionNodes}\n              {globeAttributionNodes}\n              {globeAttributions.length ? <span className=\"pipe-separator\">|</span> : null}\n              {globeAttributions.length && !isPalm ? (\n                <MapLibLogo baseMapLibraryConfig={baseMapLibraryConfig} />\n              ) : null}\n            </div>\n          </EndHorizontalFlexbox>\n        </StyledAttribution>\n      );\n    }\n\n    return (\n      <StyledAttribution\n        mapLibCssClass={baseMapLibraryConfig.mapLibCssClass}\n        mapLibAttributionCssClass={baseMapLibraryConfig.mapLibAttributionCssClass}\n        showLogo={true}\n      >\n        <EndHorizontalFlexbox>\n          <DatasetAttributions datasetAttributions={datasetAttributions} isPalm={isPalm} />\n          <div className=\"attrition-link\">\n            {datasetAttributions?.length ? <span className=\"pipe-separator\">|</span> : null}\n            {isPalm ? <MapLibLogo baseMapLibraryConfig={baseMapLibraryConfig} /> : null}\n            <a href=\"https://kepler.gl/policy/\" target=\"_blank\" rel=\"noopener noreferrer\">\n              © kepler.gl\n            </a>\n            {basemapAttributionNodes}\n            {globeAttributionNodes}\n            <span className=\"pipe-separator\">|</span>\n            {!isPalm ? <MapLibLogo baseMapLibraryConfig={baseMapLibraryConfig} /> : null}\n          </div>\n        </EndHorizontalFlexbox>\n      </StyledAttribution>\n    );\n  }, [\n    showBaseMapLibLogo,\n    basemapAttributions,\n    datasetAttributions,\n    isPalm,\n    baseMapLibraryConfig,\n    globeAttributions\n  ]);\n\n  return memoizedComponents;\n};\n\nconst StyledAttributionLogoContainer = styled.div<{$left: number}>`\n  position: absolute;\n  bottom: ${props => props.theme.sidePanel.margin.left}px;\n  left: ${props => props.$left}px;\n  z-index: 1;\n  display: flex;\n  align-items: flex-end;\n  gap: 4px;\n  pointer-events: auto;\n  transition: left 250ms ease-in-out;\n`;\n\nconst StyledLogoLink = styled.a<{$enabled: boolean}>`\n  cursor: ${props => (props.$enabled ? 'pointer' : 'default')};\n  display: flex;\n  align-items: flex-end;\n`;\n\ntype AttributionLogosProps = {\n  logos: AttributionWithStyle[];\n  activeSidePanel?: boolean;\n  sidePanelWidth?: number;\n};\n\nconst LOGO_LEFT_ADJUSTMENT = 3;\n\nexport const AttributionLogos: React.FC<AttributionLogosProps> = ({\n  logos,\n  activeSidePanel,\n  sidePanelWidth\n}) => {\n  const theme = useTheme() as any;\n  const left =\n    (activeSidePanel ? (sidePanelWidth || 0) + LOGO_LEFT_ADJUSTMENT : 0) +\n    theme.sidePanel.margin.left;\n\n  if (!logos?.length) return null;\n  return (\n    <StyledAttributionLogoContainer $left={left}>\n      {logos.map((logo, idx) => (\n        <StyledLogoLink\n          key={logo.logoUrl || idx}\n          href={logo.url || undefined}\n          {...(logo.url ? {target: '_blank', rel: 'noopener noreferrer'} : {})}\n          $enabled={Boolean(logo.url)}\n          style={logo.bottom ? {marginBottom: logo.bottom} : undefined}\n        >\n          <img src={logo.logoUrl} style={{height: logo.height || 12}} alt={logo.title} />\n        </StyledLogoLink>\n      ))}\n    </StyledAttributionLogoContainer>\n  );\n};\n"],"mappings":"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","ignoreList":[]}

package/dist/map/effects/effect-control.js

@@ -10,8 +10,7 @@ var _react = _interopRequireWildcard(require("react"));
 var _icons = require("../../common/icons");
 var _styledComponents = require("../../common/styled-components");
 var _mapControlTooltip = _interopRequireDefault(require("../map-control-tooltip"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 // SPDX-License-Identifier: MIT
 // Copyright contributors to the kepler.gl project
 
@@ -49,4 +48,4 @@ function EffectControlFactory(MapControlTooltip) {
   EffectControl.displayName = 'EffectControl';
   return /*#__PURE__*/_react["default"].memo(EffectControl);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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