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

package/dist/esm/modals/swipe-export-video-preview.js

@@ -0,0 +1,384 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _templateObject, _templateObject2, _templateObject3;
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { Component, forwardRef } from 'react';
+import DeckGL from '@deck.gl/react';
+import ReactMapGL, { useControl } from 'react-map-gl/maplibre';
+// @ts-ignore module resolution mismatch with moduleResolution:"node"
+import { MapboxOverlay } from '@deck.gl/mapbox';
+import isEqual from 'lodash.isequal';
+import styled from 'styled-components';
+import { createKeplerLayers } from '@hubble.gl/react';
+import { compositeSwipeFrame, getSwipePercentageAtTime } from './swipe-composite-utils';
+import { EXPORT_DECK_DEVICE_PROPS, EXPORT_OVERLAY_DEVICE_PROPS, getGlobeExportLayers } from './hubble-utils';
+function setRef(ref, value) {
+  if (typeof ref === 'function') {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+}
+var DeckGLOverlay = /*#__PURE__*/forwardRef(function (props, ref) {
+  var overlay = useControl(function () {
+    return new MapboxOverlay(_objectSpread(_objectSpread({}, props), {}, {
+      interleaved: true
+    }));
+  });
+  overlay.setProps(props);
+  setRef(ref, overlay._deck);
+  return null;
+});
+DeckGLOverlay.displayName = 'DeckGLOverlay';
+var PreviewContainer = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  width: ", "px;\n  height: ", "px;\n  position: relative;\n"])), function (props) {
+  return props.$width;
+}, function (props) {
+  return props.$height;
+});
+var VisibleCanvas = styled.canvas(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  width: ", "px;\n  height: ", "px;\n  display: block;\n  position: relative;\n  z-index: 1;\n"])), function (props) {
+  return props.$width;
+}, function (props) {
+  return props.$height;
+});
+var MapLayer = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  width: ", "px;\n  height: ", "px;\n  position: absolute;\n  top: 0;\n  left: 0;\n  opacity: 0;\n  pointer-events: none;\n  z-index: 0;\n"])), function (props) {
+  return props.$width;
+}, function (props) {
+  return props.$height;
+});
+/**
+ * A dual-canvas video export preview that renders left/right split map layers
+ * and composites them with an animated swipe divider.
+ */
+export var SwipeExportVideoPreview = /*#__PURE__*/function (_Component) {
+  function SwipeExportVideoPreview(props) {
+    var _this;
+    _classCallCheck(this, SwipeExportVideoPreview);
+    _this = _callSuper(this, SwipeExportVideoPreview, [props]);
+    _defineProperty(_this, "leftMapRef", /*#__PURE__*/React.createRef());
+    _defineProperty(_this, "rightMapRef", /*#__PURE__*/React.createRef());
+    _defineProperty(_this, "leftDeckRef", /*#__PURE__*/React.createRef());
+    _defineProperty(_this, "rightDeckRef", /*#__PURE__*/React.createRef());
+    _defineProperty(_this, "compositeCanvasRef", /*#__PURE__*/React.createRef());
+    /**
+     * Called by the parent container's adapter after each render.
+     * We need both maps to be loaded before compositing and capturing.
+     */
+    _defineProperty(_this, "onAfterRender", function (proceedToNextFrame) {
+      var leftLoaded = _this._areLayersLoaded('left');
+      var rightLoaded = _this._areLayersLoaded('right');
+      var leftTilesReady = _this.props.disableBaseMap || !_this.leftMapRef.current || _this.leftMapRef.current.getMap().areTilesLoaded();
+      var rightTilesReady = _this.props.disableBaseMap || !_this.rightMapRef.current || _this.rightMapRef.current.getMap().areTilesLoaded();
+      if (leftLoaded && rightLoaded && leftTilesReady && rightTilesReady) {
+        _this._compositeFrame();
+        proceedToNextFrame();
+      }
+    });
+    _defineProperty(_this, "_onLeftMapLoad", function () {
+      var _this$leftMapRef$curr;
+      var map = (_this$leftMapRef$curr = _this.leftMapRef.current) === null || _this$leftMapRef$curr === void 0 ? void 0 : _this$leftMapRef$curr.getMap();
+      if (map) {
+        map.on('render', function () {
+          if (!_this.state.leftReady) {
+            _this.setState({
+              leftReady: true
+            });
+          }
+          _this._tryComposite();
+        });
+      }
+    });
+    _defineProperty(_this, "_onRightMapLoad", function () {
+      var _this$rightMapRef$cur;
+      var map = (_this$rightMapRef$cur = _this.rightMapRef.current) === null || _this$rightMapRef$cur === void 0 ? void 0 : _this$rightMapRef$cur.getMap();
+      if (map) {
+        map.on('render', function () {
+          if (!_this.state.rightReady) {
+            _this.setState({
+              rightReady: true
+            });
+          }
+          _this._tryComposite();
+        });
+      }
+    });
+    // Globe (disableBaseMap) mode has no ReactMapGL and therefore no map 'render'
+    // event to drive compositing. Instead each bare <DeckGL> reports when it has
+    // drawn via onAfterRender; once both sides have rendered we composite. Without
+    // this the composite output canvas is never painted until the user presses
+    // play, so the preview shows a blank (white) frame on mount.
+    _defineProperty(_this, "_onDeckRender", function (side) {
+      var readyKey = side === 'left' ? 'leftReady' : 'rightReady';
+      if (!_this.state[readyKey]) {
+        _this.setState(_defineProperty({}, readyKey, true));
+      }
+      // Composite as soon as both decks exist and have drawn. We check the deck
+      // refs directly (not React state, which can be stale right after setState)
+      // and intentionally don't gate on layers being fully loaded here (that gate
+      // lives in the capture loop): for a live preview we want to show the globe
+      // as it streams in rather than a blank frame while tiles load.
+      if (_this.leftDeckRef.current && _this.rightDeckRef.current) {
+        _this._compositeFrame();
+      }
+    });
+    _this.state = {
+      leftReady: false,
+      rightReady: false
+    };
+    _this._resizeVideo();
+    return _this;
+  }
+  _inherits(SwipeExportVideoPreview, _Component);
+  return _createClass(SwipeExportVideoPreview, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (!isEqual(prevProps.resolution, this.props.resolution)) {
+        this._resizeVideo();
+      }
+      if (prevProps.currentTimeMs !== this.props.currentTimeMs || prevProps.swipeStartPct !== this.props.swipeStartPct || prevProps.swipeEndPct !== this.props.swipeEndPct || prevProps.swipeEasing !== this.props.swipeEasing) {
+        this._compositeFrame();
+      }
+    }
+  }, {
+    key: "_resizeVideo",
+    value: function _resizeVideo() {
+      var _this$props = this.props,
+        exportVideoWidth = _this$props.exportVideoWidth,
+        resolution = _this$props.resolution;
+      this._setDevicePixelRatio(resolution[0] / exportVideoWidth);
+    }
+  }, {
+    key: "_setDevicePixelRatio",
+    value: function _setDevicePixelRatio(devicePixelRatio) {
+      // @ts-ignore
+      window.devicePixelRatio = devicePixelRatio;
+    }
+  }, {
+    key: "_getContainer",
+    value: function _getContainer() {
+      var _this$props2 = this.props,
+        exportVideoWidth = _this$props2.exportVideoWidth,
+        resolution = _this$props2.resolution;
+      var aspectRatio = resolution[0] / resolution[1];
+      return {
+        height: exportVideoWidth / aspectRatio,
+        width: exportVideoWidth
+      };
+    }
+  }, {
+    key: "_getCurrentSwipePercentage",
+    value: function _getCurrentSwipePercentage() {
+      var _this$props3 = this.props,
+        currentTimeMs = _this$props3.currentTimeMs,
+        durationMs = _this$props3.durationMs,
+        swipeStartPct = _this$props3.swipeStartPct,
+        swipeEndPct = _this$props3.swipeEndPct,
+        swipeEasing = _this$props3.swipeEasing;
+      return getSwipePercentageAtTime(currentTimeMs, durationMs, swipeStartPct, swipeEndPct, swipeEasing);
+    }
+  }, {
+    key: "_getLeftCanvas",
+    value: function _getLeftCanvas() {
+      if (this.leftMapRef.current) {
+        return this.leftMapRef.current.getMap().getCanvas();
+      }
+      // Fallback: DeckGL canvas (no basemap mode)
+      if (this.leftDeckRef.current) {
+        var _getCanvas, _ref;
+        return ((_getCanvas = (_ref = this.leftDeckRef.current).getCanvas) === null || _getCanvas === void 0 ? void 0 : _getCanvas.call(_ref)) || null;
+      }
+      return null;
+    }
+  }, {
+    key: "_getRightCanvas",
+    value: function _getRightCanvas() {
+      if (this.rightMapRef.current) {
+        return this.rightMapRef.current.getMap().getCanvas();
+      }
+      if (this.rightDeckRef.current) {
+        var _getCanvas2, _ref2;
+        return ((_getCanvas2 = (_ref2 = this.rightDeckRef.current).getCanvas) === null || _getCanvas2 === void 0 ? void 0 : _getCanvas2.call(_ref2)) || null;
+      }
+      return null;
+    }
+  }, {
+    key: "_compositeFrame",
+    value: function _compositeFrame() {
+      var leftCanvas = this._getLeftCanvas();
+      var rightCanvas = this._getRightCanvas();
+      var outputCanvas = this.compositeCanvasRef.current;
+      if (!leftCanvas || !rightCanvas || !outputCanvas) return;
+      var percentage = this._getCurrentSwipePercentage();
+      compositeSwipeFrame(leftCanvas, rightCanvas, outputCanvas, percentage, true, this.props.backgroundColor);
+    }
+  }, {
+    key: "_areLayersLoaded",
+    value: function _areLayersLoaded(side) {
+      var deckRef = side === 'left' ? this.leftDeckRef : this.rightDeckRef;
+      if (!deckRef.current) return false;
+      var layers = deckRef.current.props.layers || [];
+      return layers.every(function (layer) {
+        return layer.isLoaded;
+      });
+    }
+
+    /**
+     * Get the composited canvas element for video capture.
+     */
+  }, {
+    key: "getCompositeCanvas",
+    value: function getCompositeCanvas() {
+      return this.compositeCanvasRef.current;
+    }
+  }, {
+    key: "_createLayers",
+    value: function _createLayers(mapIndex, beforeId) {
+      var _mapData$mapState;
+      var _this$props4 = this.props,
+        deckProps = _this$props4.deckProps,
+        mapData = _this$props4.mapData,
+        viewState = _this$props4.viewState,
+        disableBaseMap = _this$props4.disableBaseMap,
+        mapProps = _this$props4.mapProps;
+
+      // Globe swipe: build a fresh set of globe layers per side. Each side is a
+      // separate Deck, so it needs its OWN Layer instances (deck.gl Layer objects
+      // are stateful and bound to one Deck — sharing them makes the second Deck
+      // assert while initializing them). Building per `mapIndex` also respects the
+      // split-map layer visibility on each half of the swipe.
+      if (disableBaseMap && mapData !== null && mapData !== void 0 && (_mapData$mapState = mapData.mapState) !== null && _mapData$mapState !== void 0 && (_mapData$mapState = _mapData$mapState.globe) !== null && _mapData$mapState !== void 0 && _mapData$mapState.enabled) {
+        return getGlobeExportLayers(mapData, {
+          mapIndex: mapIndex,
+          mapboxApiAccessToken: mapProps === null || mapProps === void 0 ? void 0 : mapProps.mapboxApiAccessToken,
+          mapboxApiUrl: mapProps === null || mapProps === void 0 ? void 0 : mapProps.mapboxApiUrl
+        });
+      }
+      if (deckProps && deckProps.layers) {
+        // Non-globe path with explicit layers: clone per side with a unique id so
+        // the two Deck instances don't share the same stateful Layer objects.
+        return deckProps.layers.map(function (layer) {
+          return layer && typeof layer.clone === 'function' ? layer.clone({
+            id: "".concat(layer.id, "-swipe-").concat(mapIndex)
+          }) : layer;
+        });
+      }
+      return createKeplerLayers(mapData, viewState, mapIndex, beforeId);
+    }
+  }, {
+    key: "_tryComposite",
+    value: function _tryComposite() {
+      if (this.state.leftReady && this.state.rightReady) {
+        this._compositeFrame();
+      }
+    }
+  }, {
+    key: "_renderMapCanvas",
+    value: function _renderMapCanvas(side, mapIndex) {
+      var _this2 = this;
+      var _this$props5 = this.props,
+        viewState = _this$props5.viewState,
+        adapter = _this$props5.adapter,
+        deckProps = _this$props5.deckProps,
+        mapProps = _this$props5.mapProps,
+        disableBaseMap = _this$props5.disableBaseMap,
+        mapboxLayerBeforeId = _this$props5.mapboxLayerBeforeId;
+      var _this$_getContainer = this._getContainer(),
+        width = _this$_getContainer.width,
+        height = _this$_getContainer.height;
+      var keplerLayers = this._createLayers(mapIndex, mapboxLayerBeforeId);
+      var mapRef = side === 'left' ? this.leftMapRef : this.rightMapRef;
+      var deckRef = side === 'left' ? this.leftDeckRef : this.rightDeckRef;
+      var onMapLoad = side === 'left' ? this._onLeftMapLoad : this._onRightMapLoad;
+      var deck = deckRef.current;
+      if (disableBaseMap) {
+        var adapterProps = adapter.getProps({
+          deck: deck,
+          extraProps: _objectSpread(_objectSpread({}, deckProps), {}, {
+            layers: keplerLayers
+          })
+        });
+        var adapterOnAfterRender = adapterProps.onAfterRender;
+        return /*#__PURE__*/React.createElement(MapLayer, {
+          $width: width,
+          $height: height
+        }, /*#__PURE__*/React.createElement(DeckGL, _extends({
+          ref: function ref(_ref4) {
+            return setRef(deckRef, _ref4 === null || _ref4 === void 0 ? void 0 : _ref4.deck);
+          },
+          deviceProps: EXPORT_DECK_DEVICE_PROPS
+        }, adapterProps, {
+          viewState: viewState,
+          onViewStateChange: function onViewStateChange(_ref3) {
+            var vs = _ref3.viewState;
+            return _this2.props.setViewState(vs);
+          },
+          onAfterRender: function onAfterRender(params) {
+            if (typeof adapterOnAfterRender === 'function') {
+              adapterOnAfterRender(params);
+            }
+            _this2._onDeckRender(side);
+          }
+        }, this._getContainer())));
+      }
+      var _ref5 = mapProps || {},
+        mapStyleFromProps = _ref5.mapStyle,
+        mapLib = _ref5.mapLib,
+        transformRequest = _ref5.transformRequest;
+      return /*#__PURE__*/React.createElement(MapLayer, {
+        $width: width,
+        $height: height
+      }, /*#__PURE__*/React.createElement(ReactMapGL, _extends({
+        ref: mapRef,
+        style: {
+          width: width,
+          height: height
+        },
+        antialias: true,
+        mapLib: mapLib,
+        transformRequest: transformRequest,
+        preserveDrawingBuffer: true
+      }, viewState, {
+        mapStyle: mapStyleFromProps,
+        onLoad: onMapLoad
+      }), /*#__PURE__*/React.createElement(DeckGLOverlay, _extends({
+        ref: deckRef,
+        deviceProps: EXPORT_OVERLAY_DEVICE_PROPS
+      }, adapter.getProps({
+        deck: deck,
+        extraProps: _objectSpread(_objectSpread({}, deckProps), {}, {
+          layers: keplerLayers
+        })
+      })))));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var resolution = this.props.resolution;
+      var _this$_getContainer2 = this._getContainer(),
+        width = _this$_getContainer2.width,
+        height = _this$_getContainer2.height;
+      return /*#__PURE__*/React.createElement(PreviewContainer, {
+        $width: width,
+        $height: height
+      }, this._renderMapCanvas('left', 0), this._renderMapCanvas('right', 1), /*#__PURE__*/React.createElement(VisibleCanvas, {
+        ref: this.compositeCanvasRef,
+        width: resolution[0],
+        height: resolution[1],
+        $width: width,
+        $height: height
+      }));
+    }
+  }]);
+}(Component);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","forwardRef","DeckGL","ReactMapGL","useControl","MapboxOverlay","isEqual","styled","createKeplerLayers","compositeSwipeFrame","getSwipePercentageAtTime","EXPORT_DECK_DEVICE_PROPS","EXPORT_OVERLAY_DEVICE_PROPS","getGlobeExportLayers","setRef","ref","value","current","DeckGLOverlay","props","overlay","_objectSpread","interleaved","setProps","_deck","displayName","PreviewContainer","div","_templateObject","_taggedTemplateLiteral","$width","$height","VisibleCanvas","canvas","_templateObject2","MapLayer","_templateObject3","SwipeExportVideoPreview","_Component","_this","_classCallCheck","_callSuper","_defineProperty","createRef","proceedToNextFrame","leftLoaded","_areLayersLoaded","rightLoaded","leftTilesReady","disableBaseMap","leftMapRef","getMap","areTilesLoaded","rightTilesReady","rightMapRef","_compositeFrame","_this$leftMapRef$curr","map","on","state","leftReady","setState","_tryComposite","_this$rightMapRef$cur","rightReady","side","readyKey","leftDeckRef","rightDeckRef","_resizeVideo","_inherits","_createClass","key","componentDidUpdate","prevProps","resolution","currentTimeMs","swipeStartPct","swipeEndPct","swipeEasing","_this$props","exportVideoWidth","_setDevicePixelRatio","devicePixelRatio","window","_getContainer","_this$props2","aspectRatio","height","width","_getCurrentSwipePercentage","_this$props3","durationMs","_getLeftCanvas","getCanvas","_getCanvas","_ref","call","_getRightCanvas","_getCanvas2","_ref2","leftCanvas","rightCanvas","outputCanvas","compositeCanvasRef","percentage","backgroundColor","deckRef","layers","every","layer","isLoaded","getCompositeCanvas","_createLayers","mapIndex","beforeId","_mapData$mapState","_this$props4","deckProps","mapData","viewState","mapProps","mapState","globe","enabled","mapboxApiAccessToken","mapboxApiUrl","clone","id","concat","_renderMapCanvas","_this2","_this$props5","adapter","mapboxLayerBeforeId","_this$_getContainer","keplerLayers","mapRef","onMapLoad","_onLeftMapLoad","_onRightMapLoad","deck","adapterProps","getProps","extraProps","adapterOnAfterRender","onAfterRender","createElement","_extends","deviceProps","onViewStateChange","_ref3","vs","setViewState","params","_onDeckRender","_ref5","mapStyleFromProps","mapStyle","mapLib","transformRequest","style","antialias","preserveDrawingBuffer","onLoad","render","_this$_getContainer2"],"sources":["../../../src/modals/swipe-export-video-preview.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, RefObject, forwardRef, ForwardedRef} from 'react';\nimport DeckGL from '@deck.gl/react';\nimport ReactMapGL, {type MapRef, useControl} from 'react-map-gl/maplibre';\n// @ts-ignore module resolution mismatch with moduleResolution:\"node\"\nimport {MapboxOverlay} from '@deck.gl/mapbox';\nimport type {Deck, DeckProps, MapViewState} from '@deck.gl/core';\nimport isEqual from 'lodash.isequal';\nimport styled from 'styled-components';\n\nimport {DeckAdapter} from '@hubble.gl/core';\nimport {createKeplerLayers} from '@hubble.gl/react';\nimport {compositeSwipeFrame, getSwipePercentageAtTime, SwipeEasing} from './swipe-composite-utils';\nimport {\n  EXPORT_DECK_DEVICE_PROPS,\n  EXPORT_OVERLAY_DEVICE_PROPS,\n  getGlobeExportLayers\n} from './hubble-utils';\n\nfunction setRef<T>(ref: React.Ref<T> | React.MutableRefObject<T>, value: T) {\n  if (typeof ref === 'function') {\n    ref(value);\n  } else if (ref) {\n    (ref as React.MutableRefObject<T>).current = value;\n  }\n}\n\nconst DeckGLOverlay = forwardRef<Deck, any>(\n  (props: any, ref: ForwardedRef<Deck>) => {\n    const overlay = useControl<MapboxOverlay>(() => new MapboxOverlay({...props, interleaved: true}));\n    overlay.setProps(props);\n    setRef(ref, (overlay as any)._deck);\n    return null;\n  }\n);\nDeckGLOverlay.displayName = 'DeckGLOverlay';\n\nconst PreviewContainer = styled.div<{$width: number; $height: number}>`\n  width: ${props => props.$width}px;\n  height: ${props => props.$height}px;\n  position: relative;\n`;\n\nconst VisibleCanvas = styled.canvas<{$width: number; $height: number}>`\n  width: ${props => props.$width}px;\n  height: ${props => props.$height}px;\n  display: block;\n  position: relative;\n  z-index: 1;\n`;\n\nconst MapLayer = styled.div<{$width: number; $height: number}>`\n  width: ${props => props.$width}px;\n  height: ${props => props.$height}px;\n  position: absolute;\n  top: 0;\n  left: 0;\n  opacity: 0;\n  pointer-events: none;\n  z-index: 0;\n`;\n\nexport type SwipeExportVideoPreviewProps = {\n  mapData: any;\n  resolution: [number, number];\n  exportVideoWidth: number;\n  disableBaseMap: boolean;\n  deckProps?: DeckProps;\n  viewState: MapViewState;\n  adapter: DeckAdapter;\n  mapboxLayerBeforeId?: string;\n  rendering: boolean;\n  saving: boolean;\n  setViewState: (viewState: MapViewState) => void;\n  durationMs: number;\n  mapProps?: Record<string, any>;\n  swipeStartPct: number;\n  swipeEndPct: number;\n  swipeEasing: SwipeEasing;\n  currentTimeMs: number;\n  backgroundColor?: string;\n};\n\ntype SwipeExportVideoPreviewState = {\n  leftReady: boolean;\n  rightReady: boolean;\n};\n\n/**\n * A dual-canvas video export preview that renders left/right split map layers\n * and composites them with an animated swipe divider.\n */\nexport class SwipeExportVideoPreview extends Component<\n  SwipeExportVideoPreviewProps,\n  SwipeExportVideoPreviewState\n> {\n  leftMapRef: RefObject<MapRef | null> = React.createRef<MapRef | null>();\n  rightMapRef: RefObject<MapRef | null> = React.createRef<MapRef | null>();\n  leftDeckRef: RefObject<Deck | null> = React.createRef<Deck | null>();\n  rightDeckRef: RefObject<Deck | null> = React.createRef<Deck | null>();\n  compositeCanvasRef: RefObject<HTMLCanvasElement | null> = React.createRef<HTMLCanvasElement | null>();\n\n  constructor(props: SwipeExportVideoPreviewProps) {\n    super(props);\n\n    this.state = {\n      leftReady: false,\n      rightReady: false\n    };\n\n    this._resizeVideo();\n  }\n\n  componentDidUpdate(prevProps: SwipeExportVideoPreviewProps) {\n    if (!isEqual(prevProps.resolution, this.props.resolution)) {\n      this._resizeVideo();\n    }\n\n    if (\n      prevProps.currentTimeMs !== this.props.currentTimeMs ||\n      prevProps.swipeStartPct !== this.props.swipeStartPct ||\n      prevProps.swipeEndPct !== this.props.swipeEndPct ||\n      prevProps.swipeEasing !== this.props.swipeEasing\n    ) {\n      this._compositeFrame();\n    }\n  }\n\n  _resizeVideo() {\n    const {exportVideoWidth, resolution} = this.props;\n    this._setDevicePixelRatio(resolution[0] / exportVideoWidth);\n  }\n\n  _setDevicePixelRatio(devicePixelRatio: number) {\n    // @ts-ignore\n    window.devicePixelRatio = devicePixelRatio;\n  }\n\n  _getContainer() {\n    const {exportVideoWidth, resolution} = this.props;\n    const aspectRatio = resolution[0] / resolution[1];\n    return {height: exportVideoWidth / aspectRatio, width: exportVideoWidth};\n  }\n\n  _getCurrentSwipePercentage(): number {\n    const {currentTimeMs, durationMs, swipeStartPct, swipeEndPct, swipeEasing} = this.props;\n    return getSwipePercentageAtTime(currentTimeMs, durationMs, swipeStartPct, swipeEndPct, swipeEasing);\n  }\n\n  _getLeftCanvas(): HTMLCanvasElement | null {\n    if (this.leftMapRef.current) {\n      return this.leftMapRef.current.getMap().getCanvas();\n    }\n    // Fallback: DeckGL canvas (no basemap mode)\n    if (this.leftDeckRef.current) {\n      return (this.leftDeckRef.current as any).getCanvas?.() || null;\n    }\n    return null;\n  }\n\n  _getRightCanvas(): HTMLCanvasElement | null {\n    if (this.rightMapRef.current) {\n      return this.rightMapRef.current.getMap().getCanvas();\n    }\n    if (this.rightDeckRef.current) {\n      return (this.rightDeckRef.current as any).getCanvas?.() || null;\n    }\n    return null;\n  }\n\n  _compositeFrame() {\n    const leftCanvas = this._getLeftCanvas();\n    const rightCanvas = this._getRightCanvas();\n    const outputCanvas = this.compositeCanvasRef.current;\n\n    if (!leftCanvas || !rightCanvas || !outputCanvas) return;\n\n    const percentage = this._getCurrentSwipePercentage();\n    compositeSwipeFrame(\n      leftCanvas,\n      rightCanvas,\n      outputCanvas,\n      percentage,\n      true,\n      this.props.backgroundColor\n    );\n  }\n\n  /**\n   * Called by the parent container's adapter after each render.\n   * We need both maps to be loaded before compositing and capturing.\n   */\n  onAfterRender = (proceedToNextFrame: () => void) => {\n    const leftLoaded = this._areLayersLoaded('left');\n    const rightLoaded = this._areLayersLoaded('right');\n    const leftTilesReady =\n      this.props.disableBaseMap || !this.leftMapRef.current || this.leftMapRef.current.getMap().areTilesLoaded();\n    const rightTilesReady =\n      this.props.disableBaseMap || !this.rightMapRef.current || this.rightMapRef.current.getMap().areTilesLoaded();\n\n    if (leftLoaded && rightLoaded && leftTilesReady && rightTilesReady) {\n      this._compositeFrame();\n      proceedToNextFrame();\n    }\n  };\n\n  _areLayersLoaded(side: 'left' | 'right'): boolean {\n    const deckRef = side === 'left' ? this.leftDeckRef : this.rightDeckRef;\n    if (!deckRef.current) return false;\n    const layers = deckRef.current.props.layers || [];\n    return layers.every((layer: any) => layer.isLoaded);\n  }\n\n  /**\n   * Get the composited canvas element for video capture.\n   */\n  getCompositeCanvas(): HTMLCanvasElement | null {\n    return this.compositeCanvasRef.current;\n  }\n\n  _createLayers(mapIndex: number, beforeId?: string) {\n    const {deckProps, mapData, viewState, disableBaseMap, mapProps} = this.props;\n\n    // Globe swipe: build a fresh set of globe layers per side. Each side is a\n    // separate Deck, so it needs its OWN Layer instances (deck.gl Layer objects\n    // are stateful and bound to one Deck — sharing them makes the second Deck\n    // assert while initializing them). Building per `mapIndex` also respects the\n    // split-map layer visibility on each half of the swipe.\n    if (disableBaseMap && mapData?.mapState?.globe?.enabled) {\n      return getGlobeExportLayers(mapData, {\n        mapIndex,\n        mapboxApiAccessToken: mapProps?.mapboxApiAccessToken,\n        mapboxApiUrl: mapProps?.mapboxApiUrl\n      });\n    }\n\n    if (deckProps && deckProps.layers) {\n      // Non-globe path with explicit layers: clone per side with a unique id so\n      // the two Deck instances don't share the same stateful Layer objects.\n      return deckProps.layers.map((layer: any) =>\n        layer && typeof layer.clone === 'function'\n          ? layer.clone({id: `${layer.id}-swipe-${mapIndex}`})\n          : layer\n      );\n    }\n    return createKeplerLayers(mapData, viewState, mapIndex, beforeId);\n  }\n\n  _onLeftMapLoad = () => {\n    const map = this.leftMapRef.current?.getMap();\n    if (map) {\n      map.on('render', () => {\n        if (!this.state.leftReady) {\n          this.setState({leftReady: true});\n        }\n        this._tryComposite();\n      });\n    }\n  };\n\n  _onRightMapLoad = () => {\n    const map = this.rightMapRef.current?.getMap();\n    if (map) {\n      map.on('render', () => {\n        if (!this.state.rightReady) {\n          this.setState({rightReady: true});\n        }\n        this._tryComposite();\n      });\n    }\n  };\n\n  _tryComposite() {\n    if (this.state.leftReady && this.state.rightReady) {\n      this._compositeFrame();\n    }\n  }\n\n  // Globe (disableBaseMap) mode has no ReactMapGL and therefore no map 'render'\n  // event to drive compositing. Instead each bare <DeckGL> reports when it has\n  // drawn via onAfterRender; once both sides have rendered we composite. Without\n  // this the composite output canvas is never painted until the user presses\n  // play, so the preview shows a blank (white) frame on mount.\n  _onDeckRender = (side: 'left' | 'right') => {\n    const readyKey = side === 'left' ? 'leftReady' : 'rightReady';\n    if (!this.state[readyKey]) {\n      this.setState({[readyKey]: true} as any);\n    }\n    // Composite as soon as both decks exist and have drawn. We check the deck\n    // refs directly (not React state, which can be stale right after setState)\n    // and intentionally don't gate on layers being fully loaded here (that gate\n    // lives in the capture loop): for a live preview we want to show the globe\n    // as it streams in rather than a blank frame while tiles load.\n    if (this.leftDeckRef.current && this.rightDeckRef.current) {\n      this._compositeFrame();\n    }\n  };\n\n  _renderMapCanvas(\n    side: 'left' | 'right',\n    mapIndex: number\n  ) {\n    const {viewState, adapter, deckProps, mapProps, disableBaseMap, mapboxLayerBeforeId} = this.props;\n    const {width, height} = this._getContainer();\n    const keplerLayers = this._createLayers(mapIndex, mapboxLayerBeforeId);\n    const mapRef = side === 'left' ? this.leftMapRef : this.rightMapRef;\n    const deckRef = side === 'left' ? this.leftDeckRef : this.rightDeckRef;\n    const onMapLoad = side === 'left' ? this._onLeftMapLoad : this._onRightMapLoad;\n    const deck = deckRef.current;\n\n    if (disableBaseMap) {\n      const adapterProps = adapter.getProps({\n        deck: deck as any,\n        extraProps: {...deckProps, layers: keplerLayers}\n      }) as any;\n      const adapterOnAfterRender = adapterProps.onAfterRender;\n      return (\n        <MapLayer $width={width} $height={height}>\n          <DeckGL\n            ref={ref => setRef(deckRef, ref?.deck as any)}\n            deviceProps={EXPORT_DECK_DEVICE_PROPS}\n            {...adapterProps}\n            viewState={viewState}\n            onViewStateChange={({viewState: vs}: any) => this.props.setViewState(vs)}\n            onAfterRender={(params: any) => {\n              if (typeof adapterOnAfterRender === 'function') {\n                adapterOnAfterRender(params);\n              }\n              this._onDeckRender(side);\n            }}\n            {...this._getContainer()}\n          />\n        </MapLayer>\n      );\n    }\n\n    const {\n      mapStyle: mapStyleFromProps,\n      mapLib,\n      transformRequest\n    } = (mapProps || {}) as any;\n\n    return (\n      <MapLayer $width={width} $height={height}>\n        <ReactMapGL\n          ref={mapRef}\n          style={{width, height}}\n          antialias\n          mapLib={mapLib}\n          transformRequest={transformRequest}\n          preserveDrawingBuffer\n          {...viewState}\n          mapStyle={mapStyleFromProps}\n          onLoad={onMapLoad}\n        >\n          <DeckGLOverlay\n            ref={deckRef}\n            deviceProps={EXPORT_OVERLAY_DEVICE_PROPS}\n            {...adapter.getProps({deck: deck as any, extraProps: {...deckProps, layers: keplerLayers}})}\n          />\n        </ReactMapGL>\n      </MapLayer>\n    );\n  }\n\n  render() {\n    const {resolution} = this.props;\n    const {width, height} = this._getContainer();\n\n    return (\n      <PreviewContainer $width={width} $height={height}>\n        {/* Hidden map canvases for left (mapIndex=0) and right (mapIndex=1) */}\n        {this._renderMapCanvas('left', 0)}\n        {this._renderMapCanvas('right', 1)}\n\n        {/* Visible composited output */}\n        <VisibleCanvas\n          ref={this.compositeCanvasRef}\n          width={resolution[0]}\n          height={resolution[1]}\n          $width={width}\n          $height={height}\n        />\n      </PreviewContainer>\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAAA;AACA;;AAEA,OAAOA,KAAK,IAAGC,SAAS,EAAaC,UAAU,QAAqB,OAAO;AAC3E,OAAOC,MAAM,MAAM,gBAAgB;AACnC,OAAOC,UAAU,IAAgBC,UAAU,QAAO,uBAAuB;AACzE;AACA,SAAQC,aAAa,QAAO,iBAAiB;AAE7C,OAAOC,OAAO,MAAM,gBAAgB;AACpC,OAAOC,MAAM,MAAM,mBAAmB;AAGtC,SAAQC,kBAAkB,QAAO,kBAAkB;AACnD,SAAQC,mBAAmB,EAAEC,wBAAwB,QAAoB,yBAAyB;AAClG,SACEC,wBAAwB,EACxBC,2BAA2B,EAC3BC,oBAAoB,QACf,gBAAgB;AAEvB,SAASC,MAAMA,CAAIC,GAA6C,EAAEC,KAAQ,EAAE;EAC1E,IAAI,OAAOD,GAAG,KAAK,UAAU,EAAE;IAC7BA,GAAG,CAACC,KAAK,CAAC;EACZ,CAAC,MAAM,IAAID,GAAG,EAAE;IACbA,GAAG,CAA+BE,OAAO,GAAGD,KAAK;EACpD;AACF;AAEA,IAAME,aAAa,gBAAGjB,UAAU,CAC9B,UAACkB,KAAU,EAAEJ,GAAuB,EAAK;EACvC,IAAMK,OAAO,GAAGhB,UAAU,CAAgB;IAAA,OAAM,IAAIC,aAAa,CAAAgB,aAAA,CAAAA,aAAA,KAAKF,KAAK;MAAEG,WAAW,EAAE;IAAI,EAAC,CAAC;EAAA,EAAC;EACjGF,OAAO,CAACG,QAAQ,CAACJ,KAAK,CAAC;EACvBL,MAAM,CAACC,GAAG,EAAGK,OAAO,CAASI,KAAK,CAAC;EACnC,OAAO,IAAI;AACb,CACF,CAAC;AACDN,aAAa,CAACO,WAAW,GAAG,eAAe;AAE3C,IAAMC,gBAAgB,GAAGnB,MAAM,CAACoB,GAAG,CAAAC,eAAA,KAAAA,eAAA,GAAAC,sBAAA,uEACxB,UAAAV,KAAK;EAAA,OAAIA,KAAK,CAACW,MAAM;AAAA,GACpB,UAAAX,KAAK;EAAA,OAAIA,KAAK,CAACY,OAAO;AAAA,EAEjC;AAED,IAAMC,aAAa,GAAGzB,MAAM,CAAC0B,MAAM,CAAAC,gBAAA,KAAAA,gBAAA,GAAAL,sBAAA,yGACxB,UAAAV,KAAK;EAAA,OAAIA,KAAK,CAACW,MAAM;AAAA,GACpB,UAAAX,KAAK;EAAA,OAAIA,KAAK,CAACY,OAAO;AAAA,EAIjC;AAED,IAAMI,QAAQ,GAAG5B,MAAM,CAACoB,GAAG,CAAAS,gBAAA,KAAAA,gBAAA,GAAAP,sBAAA,qJAChB,UAAAV,KAAK;EAAA,OAAIA,KAAK,CAACW,MAAM;AAAA,GACpB,UAAAX,KAAK;EAAA,OAAIA,KAAK,CAACY,OAAO;AAAA,EAOjC;AA4BD;AACA;AACA;AACA;AACA,WAAaM,uBAAuB,0BAAAC,UAAA;EAUlC,SAAAD,wBAAYlB,KAAmC,EAAE;IAAA,IAAAoB,KAAA;IAAAC,eAAA,OAAAH,uBAAA;IAC/CE,KAAA,GAAAE,UAAA,OAAAJ,uBAAA,GAAMlB,KAAK;IAAEuB,eAAA,CAAAH,KAAA,6BAPwBxC,KAAK,CAAC4C,SAAS,CAAgB,CAAC;IAAAD,eAAA,CAAAH,KAAA,8BAC/BxC,KAAK,CAAC4C,SAAS,CAAgB,CAAC;IAAAD,eAAA,CAAAH,KAAA,8BAClCxC,KAAK,CAAC4C,SAAS,CAAc,CAAC;IAAAD,eAAA,CAAAH,KAAA,+BAC7BxC,KAAK,CAAC4C,SAAS,CAAc,CAAC;IAAAD,eAAA,CAAAH,KAAA,qCACXxC,KAAK,CAAC4C,SAAS,CAA2B,CAAC;IAwFrG;AACF;AACA;AACA;IAHED,eAAA,CAAAH,KAAA,mBAIgB,UAACK,kBAA8B,EAAK;MAClD,IAAMC,UAAU,GAAGN,KAAA,CAAKO,gBAAgB,CAAC,MAAM,CAAC;MAChD,IAAMC,WAAW,GAAGR,KAAA,CAAKO,gBAAgB,CAAC,OAAO,CAAC;MAClD,IAAME,cAAc,GAClBT,KAAA,CAAKpB,KAAK,CAAC8B,cAAc,IAAI,CAACV,KAAA,CAAKW,UAAU,CAACjC,OAAO,IAAIsB,KAAA,CAAKW,UAAU,CAACjC,OAAO,CAACkC,MAAM,CAAC,CAAC,CAACC,cAAc,CAAC,CAAC;MAC5G,IAAMC,eAAe,GACnBd,KAAA,CAAKpB,KAAK,CAAC8B,cAAc,IAAI,CAACV,KAAA,CAAKe,WAAW,CAACrC,OAAO,IAAIsB,KAAA,CAAKe,WAAW,CAACrC,OAAO,CAACkC,MAAM,CAAC,CAAC,CAACC,cAAc,CAAC,CAAC;MAE9G,IAAIP,UAAU,IAAIE,WAAW,IAAIC,cAAc,IAAIK,eAAe,EAAE;QAClEd,KAAA,CAAKgB,eAAe,CAAC,CAAC;QACtBX,kBAAkB,CAAC,CAAC;MACtB;IACF,CAAC;IAAAF,eAAA,CAAAH,KAAA,oBA4CgB,YAAM;MAAA,IAAAiB,qBAAA;MACrB,IAAMC,GAAG,IAAAD,qBAAA,GAAGjB,KAAA,CAAKW,UAAU,CAACjC,OAAO,cAAAuC,qBAAA,uBAAvBA,qBAAA,CAAyBL,MAAM,CAAC,CAAC;MAC7C,IAAIM,GAAG,EAAE;QACPA,GAAG,CAACC,EAAE,CAAC,QAAQ,EAAE,YAAM;UACrB,IAAI,CAACnB,KAAA,CAAKoB,KAAK,CAACC,SAAS,EAAE;YACzBrB,KAAA,CAAKsB,QAAQ,CAAC;cAACD,SAAS,EAAE;YAAI,CAAC,CAAC;UAClC;UACArB,KAAA,CAAKuB,aAAa,CAAC,CAAC;QACtB,CAAC,CAAC;MACJ;IACF,CAAC;IAAApB,eAAA,CAAAH,KAAA,qBAEiB,YAAM;MAAA,IAAAwB,qBAAA;MACtB,IAAMN,GAAG,IAAAM,qBAAA,GAAGxB,KAAA,CAAKe,WAAW,CAACrC,OAAO,cAAA8C,qBAAA,uBAAxBA,qBAAA,CAA0BZ,MAAM,CAAC,CAAC;MAC9C,IAAIM,GAAG,EAAE;QACPA,GAAG,CAACC,EAAE,CAAC,QAAQ,EAAE,YAAM;UACrB,IAAI,CAACnB,KAAA,CAAKoB,KAAK,CAACK,UAAU,EAAE;YAC1BzB,KAAA,CAAKsB,QAAQ,CAAC;cAACG,UAAU,EAAE;YAAI,CAAC,CAAC;UACnC;UACAzB,KAAA,CAAKuB,aAAa,CAAC,CAAC;QACtB,CAAC,CAAC;MACJ;IACF,CAAC;IAQD;IACA;IACA;IACA;IACA;IAAApB,eAAA,CAAAH,KAAA,mBACgB,UAAC0B,IAAsB,EAAK;MAC1C,IAAMC,QAAQ,GAAGD,IAAI,KAAK,MAAM,GAAG,WAAW,GAAG,YAAY;MAC7D,IAAI,CAAC1B,KAAA,CAAKoB,KAAK,CAACO,QAAQ,CAAC,EAAE;QACzB3B,KAAA,CAAKsB,QAAQ,CAAAnB,eAAA,KAAGwB,QAAQ,EAAG,IAAI,CAAQ,CAAC;MAC1C;MACA;MACA;MACA;MACA;MACA;MACA,IAAI3B,KAAA,CAAK4B,WAAW,CAAClD,OAAO,IAAIsB,KAAA,CAAK6B,YAAY,CAACnD,OAAO,EAAE;QACzDsB,KAAA,CAAKgB,eAAe,CAAC,CAAC;MACxB;IACF,CAAC;IA/LChB,KAAA,CAAKoB,KAAK,GAAG;MACXC,SAAS,EAAE,KAAK;MAChBI,UAAU,EAAE;IACd,CAAC;IAEDzB,KAAA,CAAK8B,YAAY,CAAC,CAAC;IAAC,OAAA9B,KAAA;EACtB;EAAC+B,SAAA,CAAAjC,uBAAA,EAAAC,UAAA;EAAA,OAAAiC,YAAA,CAAAlC,uBAAA;IAAAmC,GAAA;IAAAxD,KAAA,EAED,SAAAyD,kBAAkBA,CAACC,SAAuC,EAAE;MAC1D,IAAI,CAACpE,OAAO,CAACoE,SAAS,CAACC,UAAU,EAAE,IAAI,CAACxD,KAAK,CAACwD,UAAU,CAAC,EAAE;QACzD,IAAI,CAACN,YAAY,CAAC,CAAC;MACrB;MAEA,IACEK,SAAS,CAACE,aAAa,KAAK,IAAI,CAACzD,KAAK,CAACyD,aAAa,IACpDF,SAAS,CAACG,aAAa,KAAK,IAAI,CAAC1D,KAAK,CAAC0D,aAAa,IACpDH,SAAS,CAACI,WAAW,KAAK,IAAI,CAAC3D,KAAK,CAAC2D,WAAW,IAChDJ,SAAS,CAACK,WAAW,KAAK,IAAI,CAAC5D,KAAK,CAAC4D,WAAW,EAChD;QACA,IAAI,CAACxB,eAAe,CAAC,CAAC;MACxB;IACF;EAAC;IAAAiB,GAAA;IAAAxD,KAAA,EAED,SAAAqD,YAAYA,CAAA,EAAG;MACb,IAAAW,WAAA,GAAuC,IAAI,CAAC7D,KAAK;QAA1C8D,gBAAgB,GAAAD,WAAA,CAAhBC,gBAAgB;QAAEN,UAAU,GAAAK,WAAA,CAAVL,UAAU;MACnC,IAAI,CAACO,oBAAoB,CAACP,UAAU,CAAC,CAAC,CAAC,GAAGM,gBAAgB,CAAC;IAC7D;EAAC;IAAAT,GAAA;IAAAxD,KAAA,EAED,SAAAkE,oBAAoBA,CAACC,gBAAwB,EAAE;MAC7C;MACAC,MAAM,CAACD,gBAAgB,GAAGA,gBAAgB;IAC5C;EAAC;IAAAX,GAAA;IAAAxD,KAAA,EAED,SAAAqE,aAAaA,CAAA,EAAG;MACd,IAAAC,YAAA,GAAuC,IAAI,CAACnE,KAAK;QAA1C8D,gBAAgB,GAAAK,YAAA,CAAhBL,gBAAgB;QAAEN,UAAU,GAAAW,YAAA,CAAVX,UAAU;MACnC,IAAMY,WAAW,GAAGZ,UAAU,CAAC,CAAC,CAAC,GAAGA,UAAU,CAAC,CAAC,CAAC;MACjD,OAAO;QAACa,MAAM,EAAEP,gBAAgB,GAAGM,WAAW;QAAEE,KAAK,EAAER;MAAgB,CAAC;IAC1E;EAAC;IAAAT,GAAA;IAAAxD,KAAA,EAED,SAAA0E,0BAA0BA,CAAA,EAAW;MACnC,IAAAC,YAAA,GAA6E,IAAI,CAACxE,KAAK;QAAhFyD,aAAa,GAAAe,YAAA,CAAbf,aAAa;QAAEgB,UAAU,GAAAD,YAAA,CAAVC,UAAU;QAAEf,aAAa,GAAAc,YAAA,CAAbd,aAAa;QAAEC,WAAW,GAAAa,YAAA,CAAXb,WAAW;QAAEC,WAAW,GAAAY,YAAA,CAAXZ,WAAW;MACzE,OAAOrE,wBAAwB,CAACkE,aAAa,EAAEgB,UAAU,EAAEf,aAAa,EAAEC,WAAW,EAAEC,WAAW,CAAC;IACrG;EAAC;IAAAP,GAAA;IAAAxD,KAAA,EAED,SAAA6E,cAAcA,CAAA,EAA6B;MACzC,IAAI,IAAI,CAAC3C,UAAU,CAACjC,OAAO,EAAE;QAC3B,OAAO,IAAI,CAACiC,UAAU,CAACjC,OAAO,CAACkC,MAAM,CAAC,CAAC,CAAC2C,SAAS,CAAC,CAAC;MACrD;MACA;MACA,IAAI,IAAI,CAAC3B,WAAW,CAAClD,OAAO,EAAE;QAAA,IAAA8E,UAAA,EAAAC,IAAA;QAC5B,OAAO,EAAAD,UAAA,IAAAC,IAAA,GAAC,IAAI,CAAC7B,WAAW,CAAClD,OAAO,EAAS6E,SAAS,cAAAC,UAAA,uBAA3CA,UAAA,CAAAE,IAAA,CAAAD,IAA8C,CAAC,KAAI,IAAI;MAChE;MACA,OAAO,IAAI;IACb;EAAC;IAAAxB,GAAA;IAAAxD,KAAA,EAED,SAAAkF,eAAeA,CAAA,EAA6B;MAC1C,IAAI,IAAI,CAAC5C,WAAW,CAACrC,OAAO,EAAE;QAC5B,OAAO,IAAI,CAACqC,WAAW,CAACrC,OAAO,CAACkC,MAAM,CAAC,CAAC,CAAC2C,SAAS,CAAC,CAAC;MACtD;MACA,IAAI,IAAI,CAAC1B,YAAY,CAACnD,OAAO,EAAE;QAAA,IAAAkF,WAAA,EAAAC,KAAA;QAC7B,OAAO,EAAAD,WAAA,IAAAC,KAAA,GAAC,IAAI,CAAChC,YAAY,CAACnD,OAAO,EAAS6E,SAAS,cAAAK,WAAA,uBAA5CA,WAAA,CAAAF,IAAA,CAAAG,KAA+C,CAAC,KAAI,IAAI;MACjE;MACA,OAAO,IAAI;IACb;EAAC;IAAA5B,GAAA;IAAAxD,KAAA,EAED,SAAAuC,eAAeA,CAAA,EAAG;MAChB,IAAM8C,UAAU,GAAG,IAAI,CAACR,cAAc,CAAC,CAAC;MACxC,IAAMS,WAAW,GAAG,IAAI,CAACJ,eAAe,CAAC,CAAC;MAC1C,IAAMK,YAAY,GAAG,IAAI,CAACC,kBAAkB,CAACvF,OAAO;MAEpD,IAAI,CAACoF,UAAU,IAAI,CAACC,WAAW,IAAI,CAACC,YAAY,EAAE;MAElD,IAAME,UAAU,GAAG,IAAI,CAACf,0BAA0B,CAAC,CAAC;MACpDjF,mBAAmB,CACjB4F,UAAU,EACVC,WAAW,EACXC,YAAY,EACZE,UAAU,EACV,IAAI,EACJ,IAAI,CAACtF,KAAK,CAACuF,eACb,CAAC;IACH;EAAC;IAAAlC,GAAA;IAAAxD,KAAA,EAoBD,SAAA8B,gBAAgBA,CAACmB,IAAsB,EAAW;MAChD,IAAM0C,OAAO,GAAG1C,IAAI,KAAK,MAAM,GAAG,IAAI,CAACE,WAAW,GAAG,IAAI,CAACC,YAAY;MACtE,IAAI,CAACuC,OAAO,CAAC1F,OAAO,EAAE,OAAO,KAAK;MAClC,IAAM2F,MAAM,GAAGD,OAAO,CAAC1F,OAAO,CAACE,KAAK,CAACyF,MAAM,IAAI,EAAE;MACjD,OAAOA,MAAM,CAACC,KAAK,CAAC,UAACC,KAAU;QAAA,OAAKA,KAAK,CAACC,QAAQ;MAAA,EAAC;IACrD;;IAEA;AACF;AACA;EAFE;IAAAvC,GAAA;IAAAxD,KAAA,EAGA,SAAAgG,kBAAkBA,CAAA,EAA6B;MAC7C,OAAO,IAAI,CAACR,kBAAkB,CAACvF,OAAO;IACxC;EAAC;IAAAuD,GAAA;IAAAxD,KAAA,EAED,SAAAiG,aAAaA,CAACC,QAAgB,EAAEC,QAAiB,EAAE;MAAA,IAAAC,iBAAA;MACjD,IAAAC,YAAA,GAAkE,IAAI,CAAClG,KAAK;QAArEmG,SAAS,GAAAD,YAAA,CAATC,SAAS;QAAEC,OAAO,GAAAF,YAAA,CAAPE,OAAO;QAAEC,SAAS,GAAAH,YAAA,CAATG,SAAS;QAAEvE,cAAc,GAAAoE,YAAA,CAAdpE,cAAc;QAAEwE,QAAQ,GAAAJ,YAAA,CAARI,QAAQ;;MAE9D;MACA;MACA;MACA;MACA;MACA,IAAIxE,cAAc,IAAIsE,OAAO,aAAPA,OAAO,gBAAAH,iBAAA,GAAPG,OAAO,CAAEG,QAAQ,cAAAN,iBAAA,gBAAAA,iBAAA,GAAjBA,iBAAA,CAAmBO,KAAK,cAAAP,iBAAA,eAAxBA,iBAAA,CAA0BQ,OAAO,EAAE;QACvD,OAAO/G,oBAAoB,CAAC0G,OAAO,EAAE;UACnCL,QAAQ,EAARA,QAAQ;UACRW,oBAAoB,EAAEJ,QAAQ,aAARA,QAAQ,uBAARA,QAAQ,CAAEI,oBAAoB;UACpDC,YAAY,EAAEL,QAAQ,aAARA,QAAQ,uBAARA,QAAQ,CAAEK;QAC1B,CAAC,CAAC;MACJ;MAEA,IAAIR,SAAS,IAAIA,SAAS,CAACV,MAAM,EAAE;QACjC;QACA;QACA,OAAOU,SAAS,CAACV,MAAM,CAACnD,GAAG,CAAC,UAACqD,KAAU;UAAA,OACrCA,KAAK,IAAI,OAAOA,KAAK,CAACiB,KAAK,KAAK,UAAU,GACtCjB,KAAK,CAACiB,KAAK,CAAC;YAACC,EAAE,KAAAC,MAAA,CAAKnB,KAAK,CAACkB,EAAE,aAAAC,MAAA,CAAUf,QAAQ;UAAE,CAAC,CAAC,GAClDJ,KAAK;QAAA,CACX,CAAC;MACH;MACA,OAAOtG,kBAAkB,CAAC+G,OAAO,EAAEC,SAAS,EAAEN,QAAQ,EAAEC,QAAQ,CAAC;IACnE;EAAC;IAAA3C,GAAA;IAAAxD,KAAA,EA0BD,SAAA8C,aAAaA,CAAA,EAAG;MACd,IAAI,IAAI,CAACH,KAAK,CAACC,SAAS,IAAI,IAAI,CAACD,KAAK,CAACK,UAAU,EAAE;QACjD,IAAI,CAACT,eAAe,CAAC,CAAC;MACxB;IACF;EAAC;IAAAiB,GAAA;IAAAxD,KAAA,EAsBD,SAAAkH,gBAAgBA,CACdjE,IAAsB,EACtBiD,QAAgB,EAChB;MAAA,IAAAiB,MAAA;MACA,IAAAC,YAAA,GAAuF,IAAI,CAACjH,KAAK;QAA1FqG,SAAS,GAAAY,YAAA,CAATZ,SAAS;QAAEa,OAAO,GAAAD,YAAA,CAAPC,OAAO;QAAEf,SAAS,GAAAc,YAAA,CAATd,SAAS;QAAEG,QAAQ,GAAAW,YAAA,CAARX,QAAQ;QAAExE,cAAc,GAAAmF,YAAA,CAAdnF,cAAc;QAAEqF,mBAAmB,GAAAF,YAAA,CAAnBE,mBAAmB;MACnF,IAAAC,mBAAA,GAAwB,IAAI,CAAClD,aAAa,CAAC,CAAC;QAArCI,KAAK,GAAA8C,mBAAA,CAAL9C,KAAK;QAAED,MAAM,GAAA+C,mBAAA,CAAN/C,MAAM;MACpB,IAAMgD,YAAY,GAAG,IAAI,CAACvB,aAAa,CAACC,QAAQ,EAAEoB,mBAAmB,CAAC;MACtE,IAAMG,MAAM,GAAGxE,IAAI,KAAK,MAAM,GAAG,IAAI,CAACf,UAAU,GAAG,IAAI,CAACI,WAAW;MACnE,IAAMqD,OAAO,GAAG1C,IAAI,KAAK,MAAM,GAAG,IAAI,CAACE,WAAW,GAAG,IAAI,CAACC,YAAY;MACtE,IAAMsE,SAAS,GAAGzE,IAAI,KAAK,MAAM,GAAG,IAAI,CAAC0E,cAAc,GAAG,IAAI,CAACC,eAAe;MAC9E,IAAMC,IAAI,GAAGlC,OAAO,CAAC1F,OAAO;MAE5B,IAAIgC,cAAc,EAAE;QAClB,IAAM6F,YAAY,GAAGT,OAAO,CAACU,QAAQ,CAAC;UACpCF,IAAI,EAAEA,IAAW;UACjBG,UAAU,EAAA3H,aAAA,CAAAA,aAAA,KAAMiG,SAAS;YAAEV,MAAM,EAAE4B;UAAY;QACjD,CAAC,CAAQ;QACT,IAAMS,oBAAoB,GAAGH,YAAY,CAACI,aAAa;QACvD,oBACEnJ,KAAA,CAAAoJ,aAAA,CAAChH,QAAQ;UAACL,MAAM,EAAE2D,KAAM;UAAC1D,OAAO,EAAEyD;QAAO,gBACvCzF,KAAA,CAAAoJ,aAAA,CAACjJ,MAAM,EAAAkJ,QAAA;UACLrI,GAAG,EAAE,SAALA,GAAGA,CAAEA,KAAG;YAAA,OAAID,MAAM,CAAC6F,OAAO,EAAE5F,KAAG,aAAHA,KAAG,uBAAHA,KAAG,CAAE8H,IAAW,CAAC;UAAA,CAAC;UAC9CQ,WAAW,EAAE1I;QAAyB,GAClCmI,YAAY;UAChBtB,SAAS,EAAEA,SAAU;UACrB8B,iBAAiB,EAAE,SAAnBA,iBAAiBA,CAAAC,KAAA;YAAA,IAAeC,EAAE,GAAAD,KAAA,CAAb/B,SAAS;YAAA,OAAeW,MAAI,CAAChH,KAAK,CAACsI,YAAY,CAACD,EAAE,CAAC;UAAA,CAAC;UACzEN,aAAa,EAAE,SAAfA,aAAaA,CAAGQ,MAAW,EAAK;YAC9B,IAAI,OAAOT,oBAAoB,KAAK,UAAU,EAAE;cAC9CA,oBAAoB,CAACS,MAAM,CAAC;YAC9B;YACAvB,MAAI,CAACwB,aAAa,CAAC1F,IAAI,CAAC;UAC1B;QAAE,GACE,IAAI,CAACoB,aAAa,CAAC,CAAC,CACzB,CACO,CAAC;MAEf;MAEA,IAAAuE,KAAA,GAIKnC,QAAQ,IAAI,CAAC,CAAC;QAHPoC,iBAAiB,GAAAD,KAAA,CAA3BE,QAAQ;QACRC,MAAM,GAAAH,KAAA,CAANG,MAAM;QACNC,gBAAgB,GAAAJ,KAAA,CAAhBI,gBAAgB;MAGlB,oBACEjK,KAAA,CAAAoJ,aAAA,CAAChH,QAAQ;QAACL,MAAM,EAAE2D,KAAM;QAAC1D,OAAO,EAAEyD;MAAO,gBACvCzF,KAAA,CAAAoJ,aAAA,CAAChJ,UAAU,EAAAiJ,QAAA;QACTrI,GAAG,EAAE0H,MAAO;QACZwB,KAAK,EAAE;UAACxE,KAAK,EAALA,KAAK;UAAED,MAAM,EAANA;QAAM,CAAE;QACvB0E,SAAS;QACTH,MAAM,EAAEA,MAAO;QACfC,gBAAgB,EAAEA,gBAAiB;QACnCG,qBAAqB;MAAA,GACjB3C,SAAS;QACbsC,QAAQ,EAAED,iBAAkB;QAC5BO,MAAM,EAAE1B;MAAU,iBAElB3I,KAAA,CAAAoJ,aAAA,CAACjI,aAAa,EAAAkI,QAAA;QACZrI,GAAG,EAAE4F,OAAQ;QACb0C,WAAW,EAAEzI;MAA4B,GACrCyH,OAAO,CAACU,QAAQ,CAAC;QAACF,IAAI,EAAEA,IAAW;QAAEG,UAAU,EAAA3H,aAAA,CAAAA,aAAA,KAAMiG,SAAS;UAAEV,MAAM,EAAE4B;QAAY;MAAC,CAAC,CAAC,CAC5F,CACS,CACJ,CAAC;IAEf;EAAC;IAAAhE,GAAA;IAAAxD,KAAA,EAED,SAAAqJ,MAAMA,CAAA,EAAG;MACP,IAAO1F,UAAU,GAAI,IAAI,CAACxD,KAAK,CAAxBwD,UAAU;MACjB,IAAA2F,oBAAA,GAAwB,IAAI,CAACjF,aAAa,CAAC,CAAC;QAArCI,KAAK,GAAA6E,oBAAA,CAAL7E,KAAK;QAAED,MAAM,GAAA8E,oBAAA,CAAN9E,MAAM;MAEpB,oBACEzF,KAAA,CAAAoJ,aAAA,CAACzH,gBAAgB;QAACI,MAAM,EAAE2D,KAAM;QAAC1D,OAAO,EAAEyD;MAAO,GAE9C,IAAI,CAAC0C,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,EAChC,IAAI,CAACA,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC,eAGlCnI,KAAA,CAAAoJ,aAAA,CAACnH,aAAa;QACZjB,GAAG,EAAE,IAAI,CAACyF,kBAAmB;QAC7Bf,KAAK,EAAEd,UAAU,CAAC,CAAC,CAAE;QACrBa,MAAM,EAAEb,UAAU,CAAC,CAAC,CAAE;QACtB7C,MAAM,EAAE2D,KAAM;QACd1D,OAAO,EAAEyD;MAAO,CACjB,CACe,CAAC;IAEvB;EAAC;AAAA,EArS0CxF,SAAS","ignoreList":[]}

package/dist/esm/modals/tilesets-modals/common.js

@@ -0,0 +1,3 @@
+export {};
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21vZGFscy90aWxlc2V0cy1tb2RhbHMvY29tbW9uLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQgdHlwZSB7V01TQ2FwYWJpbGl0aWVzfSBmcm9tICdAbG9hZGVycy5nbC93bXMnO1xuXG5pbXBvcnQgdHlwZSB7VmVjdG9yVGlsZU1ldGFkYXRhfSBmcm9tICdAa2VwbGVyLmdsL3RhYmxlJztcbmltcG9ydCB0eXBlIHtTdGFjVHlwZXN9IGZyb20gJ0BrZXBsZXIuZ2wvdHlwZXMnO1xuXG5leHBvcnQgdHlwZSBEYXRhc2V0Q3JlYXRpb25BdHRyaWJ1dGVzID0ge1xuICBuYW1lOiBzdHJpbmc7XG4gIHR5cGU6IHN0cmluZztcbiAgbWV0YWRhdGE6IFJlY29yZDxzdHJpbmcsIGFueT47XG59O1xuXG5leHBvcnQgdHlwZSBNZXRhUmVzcG9uc2UgPSB7XG4gIG1ldGFkYXRhPzpcbiAgICB8IFZlY3RvclRpbGVNZXRhZGF0YVxuICAgIHwgU3RhY1R5cGVzLkNvbXBsZXRlU1RBQ09iamVjdFxuICAgIHwgV01TQ2FwYWJpbGl0aWVzXG4gICAgfCBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPlxuICAgIHwgbnVsbDtcbiAgZGF0YXNldD86IERhdGFzZXRDcmVhdGlvbkF0dHJpYnV0ZXMgfCBudWxsO1xuICBsb2FkaW5nPzogYm9vbGVhbjtcbiAgZXJyb3I/OiBFcnJvciB8IG51bGw7XG59O1xuIl0sIm1hcHBpbmdzIjoiIiwiaWdub3JlTGlzdCI6W119

package/dist/esm/modals/tilesets-modals/load-data-footer.js

@@ -0,0 +1,48 @@
+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 from 'react';
+import { injectIntl } from 'react-intl';
+import styled, { withTheme } from 'styled-components';
+import { Button } from '../../common';
+import LoadingSpinner from '../../common/loading-spinner';
+var AddDataButton = styled(Button)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  position: relative;\n  display: inline-flex;\n  align-items: center;\n  opacity: ", ";\n  height: 40px;\n  padding: 9px 32px;\n  width: ", ";\n\n  svg {\n    margin-right: ", ";\n  }\n"])), function (props) {
+  return props.disabled ? 0.6 : 1;
+}, function (props) {
+  return props.width;
+}, function (props) {
+  return props.isLoading ? '0' : '6px';
+});
+var LoadDataFooterContainer = styled.div.attrs({
+  className: 'load-data-footer'
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  /* position: absolute; */\n  width: 100%;\n  bottom: 0;\n\n  display: flex;\n  justify-content: space-between;\n  padding: 21px 21px 0px 72px;\n  margin: 0 -72px 0;\n  align-items: center;\n"])));
+var ErrorContainer = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  color: red;\n  padding-left: 15px;\n  display: inline-block;\n"])));
+var LoadDataFooter = function LoadDataFooter(_ref) {
+  var disabled = _ref.disabled,
+    intl = _ref.intl,
+    isLoading = _ref.isLoading,
+    onConfirm = _ref.onConfirm,
+    confirmText = _ref.confirmText,
+    _ref$prependText = _ref.prependText,
+    prependText = _ref$prependText === void 0 ? '' : _ref$prependText,
+    _ref$errorText = _ref.errorText,
+    errorText = _ref$errorText === void 0 ? '' : _ref$errorText,
+    theme = _ref.theme;
+  return /*#__PURE__*/React.createElement(LoadDataFooterContainer, null, /*#__PURE__*/React.createElement("div", null, prependText, /*#__PURE__*/React.createElement(AddDataButton, {
+    disabled: disabled,
+    isLoading: isLoading,
+    onClick: onConfirm,
+    width: "130px",
+    cta: true
+  }, isLoading && /*#__PURE__*/React.createElement(LoadingSpinner, {
+    color: theme.borderColorLT,
+    borderColor: "transparent",
+    size: 24
+  }), isLoading ? null : intl.formatMessage({
+    id: confirmText
+  })), errorText && /*#__PURE__*/React.createElement(ErrorContainer, null, errorText)));
+};
+export default withTheme(injectIntl(LoadDataFooter));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsImluamVjdEludGwiLCJzdHlsZWQiLCJ3aXRoVGhlbWUiLCJCdXR0b24iLCJMb2FkaW5nU3Bpbm5lciIsIkFkZERhdGFCdXR0b24iLCJfdGVtcGxhdGVPYmplY3QiLCJfdGFnZ2VkVGVtcGxhdGVMaXRlcmFsIiwicHJvcHMiLCJkaXNhYmxlZCIsIndpZHRoIiwiaXNMb2FkaW5nIiwiTG9hZERhdGFGb290ZXJDb250YWluZXIiLCJkaXYiLCJhdHRycyIsImNsYXNzTmFtZSIsIl90ZW1wbGF0ZU9iamVjdDIiLCJFcnJvckNvbnRhaW5lciIsIl90ZW1wbGF0ZU9iamVjdDMiLCJMb2FkRGF0YUZvb3RlciIsIl9yZWYiLCJpbnRsIiwib25Db25maXJtIiwiY29uZmlybVRleHQiLCJfcmVmJHByZXBlbmRUZXh0IiwicHJlcGVuZFRleHQiLCJfcmVmJGVycm9yVGV4dCIsImVycm9yVGV4dCIsInRoZW1lIiwiY3JlYXRlRWxlbWVudCIsIm9uQ2xpY2siLCJjdGEiLCJjb2xvciIsImJvcmRlckNvbG9yTFQiLCJib3JkZXJDb2xvciIsInNpemUiLCJmb3JtYXRNZXNzYWdlIiwiaWQiXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbW9kYWxzL3RpbGVzZXRzLW1vZGFscy9sb2FkLWRhdGEtZm9vdGVyLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnO1xuaW1wb3J0IHtpbmplY3RJbnRsLCBXcmFwcGVkQ29tcG9uZW50UHJvcHN9IGZyb20gJ3JlYWN0LWludGwnO1xuaW1wb3J0IHN0eWxlZCwge3dpdGhUaGVtZX0gZnJvbSAnc3R5bGVkLWNvbXBvbmVudHMnO1xuXG5pbXBvcnQge0J1dHRvbn0gZnJvbSAnLi4vLi4vY29tbW9uJztcbmltcG9ydCBMb2FkaW5nU3Bpbm5lciBmcm9tICcuLi8uLi9jb21tb24vbG9hZGluZy1zcGlubmVyJztcblxuY29uc3QgQWRkRGF0YUJ1dHRvbiA9IHN0eWxlZChCdXR0b24pPHtpc0xvYWRpbmc/OiBib29sZWFufT5gXG4gIHBvc2l0aW9uOiByZWxhdGl2ZTtcbiAgZGlzcGxheTogaW5saW5lLWZsZXg7XG4gIGFsaWduLWl0ZW1zOiBjZW50ZXI7XG4gIG9wYWNpdHk6ICR7cHJvcHMgPT4gKHByb3BzLmRpc2FibGVkID8gMC42IDogMSl9O1xuICBoZWlnaHQ6IDQwcHg7XG4gIHBhZGRpbmc6IDlweCAzMnB4O1xuICB3aWR0aDogJHtwcm9wcyA9PiBwcm9wcy53aWR0aH07XG5cbiAgc3ZnIHtcbiAgICBtYXJnaW4tcmlnaHQ6ICR7cHJvcHMgPT4gKHByb3BzLmlzTG9hZGluZyA/ICcwJyA6ICc2cHgnKX07XG4gIH1cbmA7XG5cbmNvbnN0IExvYWREYXRhRm9vdGVyQ29udGFpbmVyID0gc3R5bGVkLmRpdi5hdHRycyh7XG4gIGNsYXNzTmFtZTogJ2xvYWQtZGF0YS1mb290ZXInXG59KWBcbiAgLyogcG9zaXRpb246IGFic29sdXRlOyAqL1xuICB3aWR0aDogMTAwJTtcbiAgYm90dG9tOiAwO1xuXG4gIGRpc3BsYXk6IGZsZXg7XG4gIGp1c3RpZnktY29udGVudDogc3BhY2UtYmV0d2VlbjtcbiAgcGFkZGluZzogMjFweCAyMXB4IDBweCA3MnB4O1xuICBtYXJnaW46IDAgLTcycHggMDtcbiAgYWxpZ24taXRlbXM6IGNlbnRlcjtcbmA7XG5cbmNvbnN0IEVycm9yQ29udGFpbmVyID0gc3R5bGVkLmRpdmBcbiAgY29sb3I6IHJlZDtcbiAgcGFkZGluZy1sZWZ0OiAxNXB4O1xuICBkaXNwbGF5OiBpbmxpbmUtYmxvY2s7XG5gO1xuXG50eXBlIExvYWREYXRhRm9vdGVyUHJvcHMgPSB7XG4gIGRpc2FibGVkPzogYm9vbGVhbjtcbiAgaXNMb2FkaW5nPzogYm9vbGVhbjtcbiAgb25Db25maXJtOiAoKSA9PiB2b2lkO1xuICBjb25maXJtVGV4dDogc3RyaW5nO1xuICBwcmVwZW5kVGV4dD86IHN0cmluZztcbiAgZXJyb3JUZXh0Pzogc3RyaW5nIHwgbnVsbDtcbn07XG5cbnR5cGUgVGhlbWVQcm9wcyA9IHtcbiAgdGhlbWU6IGFueTtcbn07XG5cbmNvbnN0IExvYWREYXRhRm9vdGVyID0gKHtcbiAgZGlzYWJsZWQsXG4gIGludGwsXG4gIGlzTG9hZGluZyxcbiAgb25Db25maXJtLFxuICBjb25maXJtVGV4dCxcbiAgcHJlcGVuZFRleHQgPSAnJyxcbiAgZXJyb3JUZXh0ID0gJycsXG4gIHRoZW1lXG59OiBMb2FkRGF0YUZvb3RlclByb3BzICYgV3JhcHBlZENvbXBvbmVudFByb3BzICYgVGhlbWVQcm9wcykgPT4ge1xuICByZXR1cm4gKFxuICAgIDxMb2FkRGF0YUZvb3RlckNvbnRhaW5lcj5cbiAgICAgIDxkaXY+XG4gICAgICAgIHtwcmVwZW5kVGV4dH1cbiAgICAgICAgPEFkZERhdGFCdXR0b25cbiAgICAgICAgICBkaXNhYmxlZD17ZGlzYWJsZWR9XG4gICAgICAgICAgaXNMb2FkaW5nPXtpc0xvYWRpbmd9XG4gICAgICAgICAgb25DbGljaz17b25Db25maXJtfVxuICAgICAgICAgIHdpZHRoPVwiMTMwcHhcIlxuICAgICAgICAgIGN0YVxuICAgICAgICA+XG4gICAgICAgICAge2lzTG9hZGluZyAmJiAoXG4gICAgICAgICAgICA8TG9hZGluZ1NwaW5uZXIgY29sb3I9e3RoZW1lLmJvcmRlckNvbG9yTFR9IGJvcmRlckNvbG9yPVwidHJhbnNwYXJlbnRcIiBzaXplPXsyNH0gLz5cbiAgICAgICAgICApfVxuICAgICAgICAgIHtpc0xvYWRpbmdcbiAgICAgICAgICAgID8gbnVsbFxuICAgICAgICAgICAgOiBpbnRsLmZvcm1hdE1lc3NhZ2Uoe1xuICAgICAgICAgICAgICAgIGlkOiBjb25maXJtVGV4dFxuICAgICAgICAgICAgICB9KX1cbiAgICAgICAgPC9BZGREYXRhQnV0dG9uPlxuICAgICAgICB7ZXJyb3JUZXh0ICYmIDxFcnJvckNvbnRhaW5lcj57ZXJyb3JUZXh0fTwvRXJyb3JDb250YWluZXI+fVxuICAgICAgPC9kaXY+XG4gICAgPC9Mb2FkRGF0YUZvb3RlckNvbnRhaW5lcj5cbiAgKTtcbn07XG5cbmV4cG9ydCBkZWZhdWx0IHdpdGhUaGVtZShpbmplY3RJbnRsKExvYWREYXRhRm9vdGVyKSkgYXMgUmVhY3QuRkM8XG4gIE9taXQ8TG9hZERhdGFGb290ZXJQcm9wcywgJ3RoZW1lJz5cbj47XG4iXSwibWFwcGluZ3MiOiI7O0FBQUE7QUFDQTs7QUFFQSxPQUFPQSxLQUFLLE1BQU0sT0FBTztBQUN6QixTQUFRQyxVQUFVLFFBQThCLFlBQVk7QUFDNUQsT0FBT0MsTUFBTSxJQUFHQyxTQUFTLFFBQU8sbUJBQW1CO0FBRW5ELFNBQVFDLE1BQU0sUUFBTyxjQUFjO0FBQ25DLE9BQU9DLGNBQWMsTUFBTSw4QkFBOEI7QUFFekQsSUFBTUMsYUFBYSxHQUFHSixNQUFNLENBQUNFLE1BQU0sQ0FBQyxDQUFBRyxlQUFBLEtBQUFBLGVBQUEsR0FBQUMsc0JBQUEscU1BSXZCLFVBQUFDLEtBQUs7RUFBQSxPQUFLQSxLQUFLLENBQUNDLFFBQVEsR0FBRyxHQUFHLEdBQUcsQ0FBQztBQUFBLENBQUMsRUFHckMsVUFBQUQsS0FBSztFQUFBLE9BQUlBLEtBQUssQ0FBQ0UsS0FBSztBQUFBLEdBR1gsVUFBQUYsS0FBSztFQUFBLE9BQUtBLEtBQUssQ0FBQ0csU0FBUyxHQUFHLEdBQUcsR0FBRyxLQUFLO0FBQUEsQ0FBQyxDQUUzRDtBQUVELElBQU1DLHVCQUF1QixHQUFHWCxNQUFNLENBQUNZLEdBQUcsQ0FBQ0MsS0FBSyxDQUFDO0VBQy9DQyxTQUFTLEVBQUU7QUFDYixDQUFDLENBQUMsQ0FBQUMsZ0JBQUEsS0FBQUEsZ0JBQUEsR0FBQVQsc0JBQUEsME1BVUQ7QUFFRCxJQUFNVSxjQUFjLEdBQUdoQixNQUFNLENBQUNZLEdBQUcsQ0FBQUssZ0JBQUEsS0FBQUEsZ0JBQUEsR0FBQVgsc0JBQUEsMEVBSWhDO0FBZUQsSUFBTVksY0FBYyxHQUFHLFNBQWpCQSxjQUFjQSxDQUFBQyxJQUFBLEVBUzRDO0VBQUEsSUFSOURYLFFBQVEsR0FBQVcsSUFBQSxDQUFSWCxRQUFRO0lBQ1JZLElBQUksR0FBQUQsSUFBQSxDQUFKQyxJQUFJO0lBQ0pWLFNBQVMsR0FBQVMsSUFBQSxDQUFUVCxTQUFTO0lBQ1RXLFNBQVMsR0FBQUYsSUFBQSxDQUFURSxTQUFTO0lBQ1RDLFdBQVcsR0FBQUgsSUFBQSxDQUFYRyxXQUFXO0lBQUFDLGdCQUFBLEdBQUFKLElBQUEsQ0FDWEssV0FBVztJQUFYQSxXQUFXLEdBQUFELGdCQUFBLGNBQUcsRUFBRSxHQUFBQSxnQkFBQTtJQUFBRSxjQUFBLEdBQUFOLElBQUEsQ0FDaEJPLFNBQVM7SUFBVEEsU0FBUyxHQUFBRCxjQUFBLGNBQUcsRUFBRSxHQUFBQSxjQUFBO0lBQ2RFLEtBQUssR0FBQVIsSUFBQSxDQUFMUSxLQUFLO0VBRUwsb0JBQ0U3QixLQUFBLENBQUE4QixhQUFBLENBQUNqQix1QkFBdUIscUJBQ3RCYixLQUFBLENBQUE4QixhQUFBLGNBQ0dKLFdBQVcsZUFDWjFCLEtBQUEsQ0FBQThCLGFBQUEsQ0FBQ3hCLGFBQWE7SUFDWkksUUFBUSxFQUFFQSxRQUFTO0lBQ25CRSxTQUFTLEVBQUVBLFNBQVU7SUFDckJtQixPQUFPLEVBQUVSLFNBQVU7SUFDbkJaLEtBQUssRUFBQyxPQUFPO0lBQ2JxQixHQUFHO0VBQUEsR0FFRnBCLFNBQVMsaUJBQ1JaLEtBQUEsQ0FBQThCLGFBQUEsQ0FBQ3pCLGNBQWM7SUFBQzRCLEtBQUssRUFBRUosS0FBSyxDQUFDSyxhQUFjO0lBQUNDLFdBQVcsRUFBQyxhQUFhO0lBQUNDLElBQUksRUFBRTtFQUFHLENBQUUsQ0FDbEYsRUFDQXhCLFNBQVMsR0FDTixJQUFJLEdBQ0pVLElBQUksQ0FBQ2UsYUFBYSxDQUFDO0lBQ2pCQyxFQUFFLEVBQUVkO0VBQ04sQ0FBQyxDQUNRLENBQUMsRUFDZkksU0FBUyxpQkFBSTVCLEtBQUEsQ0FBQThCLGFBQUEsQ0FBQ1osY0FBYyxRQUFFVSxTQUEwQixDQUN0RCxDQUNrQixDQUFDO0FBRTlCLENBQUM7QUFFRCxlQUFlekIsU0FBUyxDQUFDRixVQUFVLENBQUNtQixjQUFjLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==