@kepler.gl/components 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/esm/map/attribution.js

@@ -0,0 +1,382 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import styled, { useTheme } from 'styled-components';
+import { hasMobileWidth } from '@kepler.gl/utils';
+import { breakPointValues } from '@kepler.gl/styles';
+import { StyledAttribution, EndHorizontalFlexbox } from '../common/styled-components';
+export var MapLibLogo = function MapLibLogo(_ref) {
+  var baseMapLibraryConfig = _ref.baseMapLibraryConfig;
+  return /*#__PURE__*/React.createElement("div", {
+    className: "attrition-logo"
+  }, "Basemap by:", /*#__PURE__*/React.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 = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\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';
+});
+export var DatasetAttributions = function DatasetAttributions(_ref2) {
+  var datasetAttributions = _ref2.datasetAttributions,
+    isPalm = _ref2.isPalm;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/React.createElement(StyledDatasetAttributionsContainer, {
+    isPalm: isPalm
+  }, datasetAttributions.map(function (ds, idx) {
+    return /*#__PURE__*/React.createElement("a", _extends({}, 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.createElement(React.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.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.createElement(React.Fragment, {
+          key: "".concat(keyPrefix, "-a").concat(counter.i++)
+        }, _text));
+      }
+      return;
+    }
+    // any other element: keep its (recursively resolved) children
+    result.push.apply(result, _toConsumableArray(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).
+ */
+export function renderBasemapAttribution(html, keyPrefix) {
+  var DOMParserCtor = resolveDOMParser();
+  if (!DOMParserCtor) {
+    var text = stripTags(html);
+    return text ? [/*#__PURE__*/React.createElement(React.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.createElement(React.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.
+ */
+export 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 && _toConsumableArray(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.createElement(React.Fragment, null, items.map(function (item, idx) {
+    return /*#__PURE__*/React.createElement(React.Fragment, {
+      key: "".concat(keyPrefix, "-").concat(idx)
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "pipe-separator"
+    }, "|"), renderItem(item, idx));
+  }));
+}
+export var 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 = hasMobileWidth(breakPointValues);
+  var memoizedComponents = 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.createElement("span", {
+        className: "basemap-attribution"
+      }, renderBasemapAttribution(attribution, "basemap-attr-".concat(idx)));
+    });
+    var globeAttributionNodes = renderSeparatedLinks(globeAttributions, 'globe-attr', function (attr) {
+      return /*#__PURE__*/React.createElement("a", {
+        href: attr.href,
+        target: "_blank",
+        rel: "noopener noreferrer"
+      }, attr.label);
+    });
+    if (!showBaseMapLibLogo) {
+      return /*#__PURE__*/React.createElement(StyledAttribution, {
+        mapLibCssClass: baseMapLibraryConfig.mapLibCssClass,
+        mapLibAttributionCssClass: baseMapLibraryConfig.mapLibAttributionCssClass,
+        showLogo: globeAttributions.length > 0
+      }, /*#__PURE__*/React.createElement(EndHorizontalFlexbox, null, /*#__PURE__*/React.createElement(DatasetAttributions, {
+        datasetAttributions: datasetAttributions,
+        isPalm: isPalm
+      }), /*#__PURE__*/React.createElement("div", {
+        className: "attrition-link"
+      }, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/React.createElement("span", {
+        className: "pipe-separator"
+      }, "|") : null, globeAttributions.length && isPalm ? /*#__PURE__*/React.createElement(MapLibLogo, {
+        baseMapLibraryConfig: baseMapLibraryConfig
+      }) : null, /*#__PURE__*/React.createElement("a", {
+        href: "https://kepler.gl/policy/",
+        target: "_blank",
+        rel: "noopener noreferrer"
+      }, "\xA9 kepler.gl"), basemapAttributionNodes, globeAttributionNodes, globeAttributions.length ? /*#__PURE__*/React.createElement("span", {
+        className: "pipe-separator"
+      }, "|") : null, globeAttributions.length && !isPalm ? /*#__PURE__*/React.createElement(MapLibLogo, {
+        baseMapLibraryConfig: baseMapLibraryConfig
+      }) : null)));
+    }
+    return /*#__PURE__*/React.createElement(StyledAttribution, {
+      mapLibCssClass: baseMapLibraryConfig.mapLibCssClass,
+      mapLibAttributionCssClass: baseMapLibraryConfig.mapLibAttributionCssClass,
+      showLogo: true
+    }, /*#__PURE__*/React.createElement(EndHorizontalFlexbox, null, /*#__PURE__*/React.createElement(DatasetAttributions, {
+      datasetAttributions: datasetAttributions,
+      isPalm: isPalm
+    }), /*#__PURE__*/React.createElement("div", {
+      className: "attrition-link"
+    }, datasetAttributions !== null && datasetAttributions !== void 0 && datasetAttributions.length ? /*#__PURE__*/React.createElement("span", {
+      className: "pipe-separator"
+    }, "|") : null, isPalm ? /*#__PURE__*/React.createElement(MapLibLogo, {
+      baseMapLibraryConfig: baseMapLibraryConfig
+    }) : null, /*#__PURE__*/React.createElement("a", {
+      href: "https://kepler.gl/policy/",
+      target: "_blank",
+      rel: "noopener noreferrer"
+    }, "\xA9 kepler.gl"), basemapAttributionNodes, globeAttributionNodes, /*#__PURE__*/React.createElement("span", {
+      className: "pipe-separator"
+    }, "|"), !isPalm ? /*#__PURE__*/React.createElement(MapLibLogo, {
+      baseMapLibraryConfig: baseMapLibraryConfig
+    }) : null)));
+  }, [showBaseMapLibLogo, basemapAttributions, datasetAttributions, isPalm, baseMapLibraryConfig, globeAttributions]);
+  return memoizedComponents;
+};
+var StyledAttributionLogoContainer = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\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 = styled.a(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  cursor: ", ";\n  display: flex;\n  align-items: flex-end;\n"])), function (props) {
+  return props.$enabled ? 'pointer' : 'default';
+});
+var LOGO_LEFT_ADJUSTMENT = 3;
+export var AttributionLogos = function AttributionLogos(_ref4) {
+  var logos = _ref4.logos,
+    activeSidePanel = _ref4.activeSidePanel,
+    sidePanelWidth = _ref4.sidePanelWidth;
+  var theme = 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.createElement(StyledAttributionLogoContainer, {
+    $left: left
+  }, logos.map(function (logo, idx) {
+    return /*#__PURE__*/React.createElement(StyledLogoLink, _extends({
+      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.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","useMemo","styled","useTheme","hasMobileWidth","breakPointValues","StyledAttribution","EndHorizontalFlexbox","MapLibLogo","_ref","baseMapLibraryConfig","createElement","className","style","marginLeft","concat","mapLibCssClass","target","rel","href","mapLibUrl","mapLibName","StyledDatasetAttributionsContainer","div","_templateObject","_taggedTemplateLiteral","props","isPalm","theme","labelColor","DatasetAttributions","_ref2","datasetAttributions","Fragment","length","map","ds","idx","_extends","url","key","title","ATTRIBUTION_SAFE_HREF_REGEX","decodeAttributionEntities","text","replace","stripTags","html","trim","domNodesToReact","nodes","keyPrefix","counter","result","forEach","node","nodeType","textContent","push","i","el","tag","tagName","toLowerCase","getAttribute","test","apply","_toConsumableArray","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","t","has","renderSeparatedLinks","items","renderItem","item","Attribution","_ref3","_ref3$showBaseMapLibL","showBaseMapLibLogo","_ref3$basemapAttribut","basemapAttributions","_ref3$globeAttributio","globeAttributions","memoizedComponents","dedupedBasemapAttributions","basemapAttributionNodes","globeAttributionNodes","attr","label","mapLibAttributionCssClass","showLogo","StyledAttributionLogoContainer","_templateObject2","sidePanel","margin","left","$left","StyledLogoLink","_templateObject3","$enabled","LOGO_LEFT_ADJUSTMENT","AttributionLogos","_ref4","logos","activeSidePanel","sidePanelWidth","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/esm/map/coordinate-info.js

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import { preciseRound } from '@kepler.gl/utils';
+import { CursorClick } from '../common/icons';
+import { StyledLayerName } from './layer-hover-info';
+
+// 6th decimal is worth up to 0.11 m
+// https://gis.stackexchange.com/questions/8650/measuring-accuracy-of-latitude-and-longitude
+var DECIMAL = 6;
+var DECIMAL_Z = 1;
+var CoordinateInfoFactory = function CoordinateInfoFactory() {
+  var CoordinateInfo = function CoordinateInfo(_ref) {
+    var coordinate = _ref.coordinate,
+      zoom = _ref.zoom;
+    return /*#__PURE__*/React.createElement("div", {
+      className: "coordingate-hover-info"
+    }, /*#__PURE__*/React.createElement(StyledLayerName, {
+      className: "map-popover__layer-name"
+    }, /*#__PURE__*/React.createElement(CursorClick, {
+      height: "12px"
+    }), "Coordinate"), /*#__PURE__*/React.createElement("table", null, /*#__PURE__*/React.createElement("tbody", null, /*#__PURE__*/React.createElement("tr", {
+      className: "row"
+    }, /*#__PURE__*/React.createElement("td", {
+      className: "row__value"
+    }, preciseRound(coordinate[1], DECIMAL), ","), /*#__PURE__*/React.createElement("td", {
+      className: "row__value"
+    }, preciseRound(coordinate[0], DECIMAL), ","), /*#__PURE__*/React.createElement("td", {
+      className: "row__value"
+    }, preciseRound(zoom, DECIMAL_Z), "z")))));
+  };
+  return CoordinateInfo;
+};
+export default CoordinateInfoFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback } from 'react';
+import { MagicWand } from '../../common/icons';
+import { MapControlButton } from '../../common/styled-components';
+import MapControlTooltipFactory from '../map-control-tooltip';
+EffectControlFactory.deps = [MapControlTooltipFactory];
+export default function EffectControlFactory(MapControlTooltip) {
+  var defaultActionIcons = {
+    effectsIcon: MagicWand
+  };
+  var EffectControl = function EffectControl(_ref) {
+    var _mapControls$effect, _mapControls$effect2;
+    var mapControls = _ref.mapControls,
+      onToggleMapControl = _ref.onToggleMapControl,
+      _ref$actionIcons = _ref.actionIcons,
+      actionIcons = _ref$actionIcons === void 0 ? defaultActionIcons : _ref$actionIcons;
+    var onClick = useCallback(function (event) {
+      event.preventDefault();
+      onToggleMapControl('effect');
+    }, [onToggleMapControl]);
+    var showControl = mapControls === null || mapControls === void 0 || (_mapControls$effect = mapControls.effect) === null || _mapControls$effect === void 0 ? void 0 : _mapControls$effect.show;
+    if (!showControl) {
+      return null;
+    }
+    var active = mapControls === null || mapControls === void 0 || (_mapControls$effect2 = mapControls.effect) === null || _mapControls$effect2 === void 0 ? void 0 : _mapControls$effect2.active;
+    return /*#__PURE__*/React.createElement(MapControlTooltip, {
+      id: "show-effect",
+      message: active ? 'tooltip.hideEffectPanel' : 'tooltip.showEffectPanel'
+    }, /*#__PURE__*/React.createElement(MapControlButton, {
+      className: "map-control-button toggle-effect",
+      onClick: onClick,
+      active: active
+    }, /*#__PURE__*/React.createElement(actionIcons.effectsIcon, {
+      height: "22px"
+    })));
+  };
+  EffectControl.displayName = 'EffectControl';
+  return /*#__PURE__*/React.memo(EffectControl);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsInVzZUNhbGxiYWNrIiwiTWFnaWNXYW5kIiwiTWFwQ29udHJvbEJ1dHRvbiIsIk1hcENvbnRyb2xUb29sdGlwRmFjdG9yeSIsIkVmZmVjdENvbnRyb2xGYWN0b3J5IiwiZGVwcyIsIk1hcENvbnRyb2xUb29sdGlwIiwiZGVmYXVsdEFjdGlvbkljb25zIiwiZWZmZWN0c0ljb24iLCJFZmZlY3RDb250cm9sIiwiX3JlZiIsIl9tYXBDb250cm9scyRlZmZlY3QiLCJfbWFwQ29udHJvbHMkZWZmZWN0MiIsIm1hcENvbnRyb2xzIiwib25Ub2dnbGVNYXBDb250cm9sIiwiX3JlZiRhY3Rpb25JY29ucyIsImFjdGlvbkljb25zIiwib25DbGljayIsImV2ZW50IiwicHJldmVudERlZmF1bHQiLCJzaG93Q29udHJvbCIsImVmZmVjdCIsInNob3ciLCJhY3RpdmUiLCJjcmVhdGVFbGVtZW50IiwiaWQiLCJtZXNzYWdlIiwiY2xhc3NOYW1lIiwiaGVpZ2h0IiwiZGlzcGxheU5hbWUiLCJtZW1vIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21hcC9lZmZlY3RzL2VmZmVjdC1jb250cm9sLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQgUmVhY3QsIHt1c2VDYWxsYmFjaywgQ29tcG9uZW50VHlwZX0gZnJvbSAncmVhY3QnO1xuXG5pbXBvcnQge01hcENvbnRyb2xzfSBmcm9tICdAa2VwbGVyLmdsL3R5cGVzJztcblxuaW1wb3J0IHtNYWdpY1dhbmR9IGZyb20gJy4uLy4uL2NvbW1vbi9pY29ucyc7XG5pbXBvcnQge01hcENvbnRyb2xCdXR0b259IGZyb20gJy4uLy4uL2NvbW1vbi9zdHlsZWQtY29tcG9uZW50cyc7XG5pbXBvcnQgTWFwQ29udHJvbFRvb2x0aXBGYWN0b3J5IGZyb20gJy4uL21hcC1jb250cm9sLXRvb2x0aXAnO1xuXG5pbnRlcmZhY2UgRWZmZWN0Q29udHJvbEljb25zIHtcbiAgZWZmZWN0c0ljb246IENvbXBvbmVudFR5cGU8YW55Pjtcbn1cblxuZXhwb3J0IHR5cGUgRWZmZWN0Q29udHJvbFByb3BzID0ge1xuICBtYXBDb250cm9sczogTWFwQ29udHJvbHM7XG4gIG9uVG9nZ2xlTWFwQ29udHJvbDogKGNvbnRyb2w6IHN0cmluZykgPT4gdm9pZDtcbiAgYWN0aW9uSWNvbnM6IEVmZmVjdENvbnRyb2xJY29ucztcbn07XG5cbkVmZmVjdENvbnRyb2xGYWN0b3J5LmRlcHMgPSBbTWFwQ29udHJvbFRvb2x0aXBGYWN0b3J5XTtcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gRWZmZWN0Q29udHJvbEZhY3RvcnkoXG4gIE1hcENvbnRyb2xUb29sdGlwOiBSZXR1cm5UeXBlPHR5cGVvZiBNYXBDb250cm9sVG9vbHRpcEZhY3Rvcnk+XG4pOiBSZWFjdC5GQzxFZmZlY3RDb250cm9sUHJvcHM+IHtcbiAgY29uc3QgZGVmYXVsdEFjdGlvbkljb25zID0ge1xuICAgIGVmZmVjdHNJY29uOiBNYWdpY1dhbmRcbiAgfTtcblxuICBjb25zdCBFZmZlY3RDb250cm9sID0gKHtcbiAgICBtYXBDb250cm9scyxcbiAgICBvblRvZ2dsZU1hcENvbnRyb2wsXG4gICAgYWN0aW9uSWNvbnMgPSBkZWZhdWx0QWN0aW9uSWNvbnNcbiAgfTogRWZmZWN0Q29udHJvbFByb3BzKSA9PiB7XG4gICAgY29uc3Qgb25DbGljayA9IHVzZUNhbGxiYWNrKFxuICAgICAgZXZlbnQgPT4ge1xuICAgICAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpO1xuICAgICAgICBvblRvZ2dsZU1hcENvbnRyb2woJ2VmZmVjdCcpO1xuICAgICAgfSxcbiAgICAgIFtvblRvZ2dsZU1hcENvbnRyb2xdXG4gICAgKTtcblxuICAgIGNvbnN0IHNob3dDb250cm9sID0gbWFwQ29udHJvbHM/LmVmZmVjdD8uc2hvdztcbiAgICBpZiAoIXNob3dDb250cm9sKSB7XG4gICAgICByZXR1cm4gbnVsbDtcbiAgICB9XG5cbiAgICBjb25zdCBhY3RpdmUgPSBtYXBDb250cm9scz8uZWZmZWN0Py5hY3RpdmU7XG4gICAgcmV0dXJuIChcbiAgICAgIDxNYXBDb250cm9sVG9vbHRpcFxuICAgICAgICBpZD1cInNob3ctZWZmZWN0XCJcbiAgICAgICAgbWVzc2FnZT17YWN0aXZlID8gJ3Rvb2x0aXAuaGlkZUVmZmVjdFBhbmVsJyA6ICd0b29sdGlwLnNob3dFZmZlY3RQYW5lbCd9XG4gICAgICA+XG4gICAgICAgIDxNYXBDb250cm9sQnV0dG9uXG4gICAgICAgICAgY2xhc3NOYW1lPVwibWFwLWNvbnRyb2wtYnV0dG9uIHRvZ2dsZS1lZmZlY3RcIlxuICAgICAgICAgIG9uQ2xpY2s9e29uQ2xpY2t9XG4gICAgICAgICAgYWN0aXZlPXthY3RpdmV9XG4gICAgICAgID5cbiAgICAgICAgICA8YWN0aW9uSWNvbnMuZWZmZWN0c0ljb24gaGVpZ2h0PVwiMjJweFwiIC8+XG4gICAgICAgIDwvTWFwQ29udHJvbEJ1dHRvbj5cbiAgICAgIDwvTWFwQ29udHJvbFRvb2x0aXA+XG4gICAgKTtcbiAgfTtcblxuICBFZmZlY3RDb250cm9sLmRpc3BsYXlOYW1lID0gJ0VmZmVjdENvbnRyb2wnO1xuICByZXR1cm4gUmVhY3QubWVtbyhFZmZlY3RDb250cm9sKTtcbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUE7QUFDQTs7QUFFQSxPQUFPQSxLQUFLLElBQUdDLFdBQVcsUUFBc0IsT0FBTztBQUl2RCxTQUFRQyxTQUFTLFFBQU8sb0JBQW9CO0FBQzVDLFNBQVFDLGdCQUFnQixRQUFPLGdDQUFnQztBQUMvRCxPQUFPQyx3QkFBd0IsTUFBTSx3QkFBd0I7QUFZN0RDLG9CQUFvQixDQUFDQyxJQUFJLEdBQUcsQ0FBQ0Ysd0JBQXdCLENBQUM7QUFFdEQsZUFBZSxTQUFTQyxvQkFBb0JBLENBQzFDRSxpQkFBOEQsRUFDaEM7RUFDOUIsSUFBTUMsa0JBQWtCLEdBQUc7SUFDekJDLFdBQVcsRUFBRVA7RUFDZixDQUFDO0VBRUQsSUFBTVEsYUFBYSxHQUFHLFNBQWhCQSxhQUFhQSxDQUFBQyxJQUFBLEVBSU87SUFBQSxJQUFBQyxtQkFBQSxFQUFBQyxvQkFBQTtJQUFBLElBSHhCQyxXQUFXLEdBQUFILElBQUEsQ0FBWEcsV0FBVztNQUNYQyxrQkFBa0IsR0FBQUosSUFBQSxDQUFsQkksa0JBQWtCO01BQUFDLGdCQUFBLEdBQUFMLElBQUEsQ0FDbEJNLFdBQVc7TUFBWEEsV0FBVyxHQUFBRCxnQkFBQSxjQUFHUixrQkFBa0IsR0FBQVEsZ0JBQUE7SUFFaEMsSUFBTUUsT0FBTyxHQUFHakIsV0FBVyxDQUN6QixVQUFBa0IsS0FBSyxFQUFJO01BQ1BBLEtBQUssQ0FBQ0MsY0FBYyxDQUFDLENBQUM7TUFDdEJMLGtCQUFrQixDQUFDLFFBQVEsQ0FBQztJQUM5QixDQUFDLEVBQ0QsQ0FBQ0Esa0JBQWtCLENBQ3JCLENBQUM7SUFFRCxJQUFNTSxXQUFXLEdBQUdQLFdBQVcsYUFBWEEsV0FBVyxnQkFBQUYsbUJBQUEsR0FBWEUsV0FBVyxDQUFFUSxNQUFNLGNBQUFWLG1CQUFBLHVCQUFuQkEsbUJBQUEsQ0FBcUJXLElBQUk7SUFDN0MsSUFBSSxDQUFDRixXQUFXLEVBQUU7TUFDaEIsT0FBTyxJQUFJO0lBQ2I7SUFFQSxJQUFNRyxNQUFNLEdBQUdWLFdBQVcsYUFBWEEsV0FBVyxnQkFBQUQsb0JBQUEsR0FBWEMsV0FBVyxDQUFFUSxNQUFNLGNBQUFULG9CQUFBLHVCQUFuQkEsb0JBQUEsQ0FBcUJXLE1BQU07SUFDMUMsb0JBQ0V4QixLQUFBLENBQUF5QixhQUFBLENBQUNsQixpQkFBaUI7TUFDaEJtQixFQUFFLEVBQUMsYUFBYTtNQUNoQkMsT0FBTyxFQUFFSCxNQUFNLEdBQUcseUJBQXlCLEdBQUc7SUFBMEIsZ0JBRXhFeEIsS0FBQSxDQUFBeUIsYUFBQSxDQUFDdEIsZ0JBQWdCO01BQ2Z5QixTQUFTLEVBQUMsa0NBQWtDO01BQzVDVixPQUFPLEVBQUVBLE9BQVE7TUFDakJNLE1BQU0sRUFBRUE7SUFBTyxnQkFFZnhCLEtBQUEsQ0FBQXlCLGFBQUEsQ0FBQ1IsV0FBVyxDQUFDUixXQUFXO01BQUNvQixNQUFNLEVBQUM7SUFBTSxDQUFFLENBQ3hCLENBQ0QsQ0FBQztFQUV4QixDQUFDO0VBRURuQixhQUFhLENBQUNvQixXQUFXLEdBQUcsZUFBZTtFQUMzQyxvQkFBTzlCLEtBQUssQ0FBQytCLElBQUksQ0FBQ3JCLGFBQWEsQ0FBQztBQUNsQyIsImlnbm9yZUxpc3QiOltdfQ==