geojs 1.8.10 → 1.9.2

package/geo.lean.js

@@ -138,6 +138,12 @@ var editHandleFeatureLevel = 3;
  * @property {boolean|string[]} [showLabel=true] `true` to show the annotation
  *    label on annotations in done or edit states.  Alternately, a list of
  *    states in which to show the label.  Falsy to not show the label.
+ * @property {boolean} [allowBooleanOperations] This defaults to `true` for
+ *    annotations that have area and `false` for those without area (e.g.,
+ *    false for lines and points).  If it is truthy, then, when the annotation
+ *    is being created, it checks the metakeys on the first click that defines
+ *    a coordinate to determine what boolean polygon operation should be
+ *    performaned on the completion of the annotation.
  */
 
 /**
@@ -160,9 +166,7 @@ var annotation = function annotation(type, args) {
   }
 
   var m_this = this,
-      m_options = $.extend({}, {
-    showLabel: true
-  }, args || {}),
+      m_options = $.extend(true, {}, this.constructor.defaults, args || {}),
       m_id = m_options.annotationId;
   delete m_options.annotationId;
 
@@ -968,11 +972,16 @@ var annotation = function annotation(type, args) {
       value = util.ensureFunction(objStyle[key])();
 
       if (value !== undefined) {
+        var defvalue = ((m_this.constructor.defaults || {}).style || {})[key];
+
         if (key.toLowerCase().match(/color$/)) {
           value = util.convertColorToHex(value, 'needed');
+          defvalue = defvalue !== undefined ? util.convertColorToHex(defvalue, 'needed') : defvalue;
         }
 
-        obj.properties[key] = value;
+        if (value !== defvalue) {
+          obj.properties[key] = value;
+        }
       }
     }
 
@@ -1699,7 +1708,14 @@ function constrainAspectRatio(ratio) {
 
   return constraintFunction;
 }
+/**
+ * This object contains the default options to initialize the class.
+ */
 
+
+annotation.defaults = {
+  showLabel: true
+};
 module.exports = {
   state: annotationState,
   actionOwner: annotationActionOwner,
@@ -1744,18 +1760,22 @@ var ellipseAnnotation = __webpack_require__(7505);
 var circleAnnotation = function circleAnnotation(args, annotationName) {
   'use strict';
 
-  args = $.extend({}, args, {
-    constraint: 1
-  });
-
   if (!(this instanceof circleAnnotation)) {
     return new circleAnnotation(args, annotationName);
   }
 
+  args = $.extend(true, {}, this.constructor.defaults, args, {
+    constraint: 1
+  });
   ellipseAnnotation.call(this, args, annotationName || 'circle');
 };
 
 inherit(circleAnnotation, ellipseAnnotation);
+/**
+ * This object contains the default options to initialize the class.
+ */
+
+circleAnnotation.defaults = $.extend({}, ellipseAnnotation.defaults, {});
 var circleRequiredFeatures = {};
 circleRequiredFeatures[markerFeature.capabilities.feature] = true;
 registerAnnotation('circle', circleAnnotation, circleRequiredFeatures);
@@ -1798,6 +1818,7 @@ var ellipseAnnotation = function ellipseAnnotation(args, annotationName) {
     return new ellipseAnnotation(args, annotationName);
   }
 
+  args = $.extend(true, {}, this.constructor.defaults, args);
   rectangleAnnotation.call(this, args, annotationName || 'ellipse');
   var m_this = this;
   /**
@@ -1844,9 +1865,68 @@ var ellipseAnnotation = function ellipseAnnotation(args, annotationName) {
 
     return features;
   };
+  /**
+   * Return this annotation as a polygon list.
+   *
+   * @param {geo.util.polyop.spec} [opts] The ``tolerance`` and
+   *   ``pixelTolerance`` parameters are used if set.  Otherwise, a polygon is
+   *   approximated to 1/10th of a pixel at the map's current maximum zoom
+   *   level.
+   * @returns {geo.polygonList} A list of polygons.
+   */
+
+
+  this.toPolygonList = function (opts) {
+    var coord = m_this._coordinates();
+
+    if (coord.length < 3) {
+      return [];
+    }
+
+    var tolerance = opts && opts.tolerance || 0;
+
+    if (!tolerance) {
+      var map = m_this.layer().map();
+
+      if (opts && opts.pixelTolerance) {
+        tolerance = map.unitsPerPixel(map.zoom()) * opts.pixelTolerance;
+      } else {
+        tolerance = map.unitsPerPixel(map.zoomRange().max) * 0.1;
+      }
+    }
+
+    var w = Math.pow(Math.pow(coord[0].x - coord[1].x, 2) + Math.pow(coord[0].y - coord[1].y, 2), 0.5);
+    var h = Math.pow(Math.pow(coord[0].x - coord[3].x, 2) + Math.pow(coord[0].y - coord[3].y, 2), 0.5);
+    var cx = (coord[0].x + coord[2].x) / 2;
+    var cy = (coord[0].y + coord[2].y) / 2;
+    var radius = Math.max(w, h) / 2;
+    var rotation = -Math.atan2(coord[1].y - coord[0].y, coord[1].x - coord[0].x);
+    var sides = Math.max(12, Math.ceil(Math.PI / Math.acos((radius - tolerance) / (radius + tolerance))));
+    var a = w / 2 * (1 + (1 - Math.cos(Math.PI / sides)) / 2);
+    var b = h / 2 * (1 + (1 - Math.cos(Math.PI / sides)) / 2);
+    var poly = [];
+    var cosr = Math.cos(rotation),
+        sinr = Math.sin(rotation);
+
+    for (var s = 0; s < sides; s += 1) {
+      var sa = Math.PI * 2 * s / sides;
+      var cosa = Math.cos(sa),
+          sina = Math.sin(sa);
+      var x = cx + a * cosr * cosa - b * sinr * sina;
+      var y = cy + a * sinr * cosa + b * cosr * sina;
+      poly.push([x, y]);
+    }
+
+    return [[poly]];
+  };
 };
 
 inherit(ellipseAnnotation, rectangleAnnotation);
+/**
+ * This object contains the default options to initialize the class.
+ */
+
+ellipseAnnotation.defaults = $.extend({}, rectangleAnnotation.defaults, {});
 var ellipseRequiredFeatures = {};
 ellipseRequiredFeatures[markerFeature.capabilities.feature] = true;
 registerAnnotation('ellipse', ellipseAnnotation, ellipseRequiredFeatures);
@@ -1933,7 +2013,7 @@ var lineAnnotation = function lineAnnotation(args) {
     return new lineAnnotation(args);
   }
 
-  args = $.extend(true, {}, {
+  args = $.extend(true, {}, this.constructor.defaults, {
     style: {
       line: function line(d) {
         /* Return an array that has the same number of items as we have
@@ -1944,20 +2024,7 @@ var lineAnnotation = function lineAnnotation(args) {
       },
       position: function position(d, i) {
         return m_this.options('vertices')[i];
-      },
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 0
-      },
-      strokeOpacity: 1,
-      strokeWidth: 3,
-      closed: false,
-      lineCap: 'butt',
-      lineJoin: 'miter'
-    },
-    highlightStyle: {
-      strokeWidth: 5
+      }
     },
     createStyle: {
       line: function line(d) {
@@ -1969,19 +2036,9 @@ var lineAnnotation = function lineAnnotation(args) {
       },
       position: function position(d, i) {
         return m_this.options('vertices')[i];
-      },
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 1
-      },
-      strokeOpacity: 1,
-      strokeWidth: 3,
-      closed: false,
-      lineCap: 'butt',
-      lineJoin: 'miter'
+      }
     }
-  }, args || {});
+  }, args);
   args.vertices = args.vertices || args.coordinates || [];
   delete args.coordinates;
   annotation.call(this, 'line', args);
@@ -2277,6 +2334,39 @@ var lineAnnotation = function lineAnnotation(args) {
 };
 
 inherit(lineAnnotation, annotation);
+/**
+ * This object contains the default options to initialize the class.
+ */
+
+lineAnnotation.defaults = $.extend({}, annotation.defaults, {
+  style: {
+    strokeColor: {
+      r: 0,
+      g: 0,
+      b: 0
+    },
+    strokeOpacity: 1,
+    strokeWidth: 3,
+    closed: false,
+    lineCap: 'butt',
+    lineJoin: 'miter'
+  },
+  highlightStyle: {
+    strokeWidth: 5
+  },
+  createStyle: {
+    strokeColor: {
+      r: 0,
+      g: 0,
+      b: 1
+    },
+    strokeOpacity: 1,
+    strokeWidth: 3,
+    closed: false,
+    lineCap: 'butt',
+    lineJoin: 'miter'
+  }
+});
 var lineRequiredFeatures = {};
 lineRequiredFeatures[lineFeature.capabilities.basic] = [annotationState.create];
 registerAnnotation('line', lineAnnotation, lineRequiredFeatures);
@@ -2336,49 +2426,7 @@ var pointAnnotation = function pointAnnotation(args) {
     return new pointAnnotation(args);
   }
 
-  args = $.extend(true, {}, {
-    style: {
-      fill: true,
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 0
-      },
-      fillOpacity: 0.25,
-      radius: 10,
-      scaled: false,
-      stroke: true,
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 0
-      },
-      strokeOpacity: 1,
-      strokeWidth: 3
-    },
-    createStyle: {
-      fillColor: {
-        r: 0.3,
-        g: 0.3,
-        b: 0.3
-      },
-      fillOpacity: 0.25,
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 1
-      }
-    },
-    highlightStyle: {
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 1
-      },
-      fillOpacity: 0.5,
-      strokeWidth: 5
-    }
-  }, args || {});
+  args = $.extend(true, {}, this.constructor.defaults, args);
   args.position = args.position || (args.coordinates ? args.coordinates[0] : undefined);
   delete args.coordinates;
   annotation.call(this, 'point', args);
@@ -2539,6 +2587,53 @@ var pointAnnotation = function pointAnnotation(args) {
 };
 
 inherit(pointAnnotation, annotation);
+/**
+ * This object contains the default options to initialize the class.
+ */
+
+pointAnnotation.defaults = $.extend({}, annotation.defaults, {
+  style: {
+    fill: true,
+    fillColor: {
+      r: 0,
+      g: 1,
+      b: 0
+    },
+    fillOpacity: 0.25,
+    radius: 10,
+    scaled: false,
+    stroke: true,
+    strokeColor: {
+      r: 0,
+      g: 0,
+      b: 0
+    },
+    strokeOpacity: 1,
+    strokeWidth: 3
+  },
+  createStyle: {
+    fillColor: {
+      r: 0.3,
+      g: 0.3,
+      b: 0.3
+    },
+    fillOpacity: 0.25,
+    strokeColor: {
+      r: 0,
+      g: 0,
+      b: 1
+    }
+  },
+  highlightStyle: {
+    fillColor: {
+      r: 0,
+      g: 1,
+      b: 1
+    },
+    fillOpacity: 0.5,
+    strokeWidth: 5
+  }
+});
 var pointRequiredFeatures = {};
 pointRequiredFeatures[pointFeature.capabilities.feature] = true;
 registerAnnotation('point', pointAnnotation, pointRequiredFeatures);
@@ -2603,45 +2698,13 @@ var polygonAnnotation = function polygonAnnotation(args) {
     return new polygonAnnotation(args);
   }
 
-  args = $.extend(true, {}, {
+  args = $.extend(true, {}, this.constructor.defaults, {
     style: {
-      fill: true,
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 0
-      },
-      fillOpacity: 0.25,
       polygon: function polygon(d) {
         return d.polygon;
-      },
-      stroke: true,
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 0
-      },
-      strokeOpacity: 1,
-      strokeWidth: 3,
-      uniformPolygon: true
-    },
-    highlightStyle: {
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 1
-      },
-      fillOpacity: 0.5,
-      strokeWidth: 5
+      }
     },
     createStyle: {
-      closed: false,
-      fillColor: {
-        r: 0.3,
-        g: 0.3,
-        b: 0.3
-      },
-      fillOpacity: 0.25,
       line: function line(d) {
         var coord = m_this._coordinates();
         /* Return an array that has the same number of items as we have
@@ -2658,15 +2721,9 @@ var polygonAnnotation = function polygonAnnotation(args) {
         }
 
         return m_this.options('vertices')[i];
-      },
-      stroke: false,
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 1
       }
     }
-  }, args || {});
+  }, args);
   args.vertices = args.vertices || args.coordinates || [];
   delete args.coordinates;
   annotation.call(this, 'polygon', args);
@@ -2727,6 +2784,37 @@ var polygonAnnotation = function polygonAnnotation(args) {
 
     return features;
   };
+  /**
+   * Return this annotation as a polygon list.
+   *
+   * @param {geo.util.polyop.spec} [opts] Ignored.
+   * @returns {geo.polygonList} A list of polygons.
+   */
+
+
+  this.toPolygonList = function (opts) {
+    var coord = m_this._coordinates();
+
+    if (coord.outer) {
+      var result = [[coord.outer.map(function (pt) {
+        return [pt.x, pt.y];
+      })]];
+      (coord.inner || []).forEach(function (h) {
+        return result[0].push(h.map(function (pt) {
+          return [pt.x, pt.y];
+        }));
+      });
+      return result;
+    }
+
+    if (coord.length < 3) {
+      return [];
+    }
+
+    return [[coord.map(function (pt) {
+      return [pt.x, pt.y];
+    })]];
+  };
   /**
    * Get and optionally set coordinates associated with this annotation in the
    * map gcs coordinate system.
@@ -2926,6 +3014,55 @@ var polygonAnnotation = function polygonAnnotation(args) {
 };
 
 inherit(polygonAnnotation, annotation);
+/**
+ * This object contains the default options to initialize the class.
+ */
+
+polygonAnnotation.defaults = $.extend({}, annotation.defaults, {
+  style: {
+    fill: true,
+    fillColor: {
+      r: 0,
+      g: 1,
+      b: 0
+    },
+    fillOpacity: 0.25,
+    stroke: true,
+    strokeColor: {
+      r: 0,
+      g: 0,
+      b: 0
+    },
+    strokeOpacity: 1,
+    strokeWidth: 3,
+    uniformPolygon: true
+  },
+  highlightStyle: {
+    fillColor: {
+      r: 0,
+      g: 1,
+      b: 1
+    },
+    fillOpacity: 0.5,
+    strokeWidth: 5
+  },
+  createStyle: {
+    closed: false,
+    fillColor: {
+      r: 0.3,
+      g: 0.3,
+      b: 0.3
+    },
+    fillOpacity: 0.25,
+    stroke: false,
+    strokeColor: {
+      r: 0,
+      g: 0,
+      b: 1
+    }
+  },
+  allowBooleanOperations: true
+});
 var polygonRequiredFeatures = {};
 polygonRequiredFeatures[polygonFeature.capabilities.feature] = true;
 polygonRequiredFeatures[lineFeature.capabilities.basic] = [annotationState.create];
@@ -2996,51 +3133,7 @@ var rectangleAnnotation = function rectangleAnnotation(args, annotationName) {
     return new rectangleAnnotation(args, annotationName);
   }
 
-  args = $.extend(true, {}, {
-    style: {
-      fill: true,
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 0
-      },
-      fillOpacity: 0.25,
-      polygon: function polygon(d) {
-        return d.polygon;
-      },
-      stroke: true,
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 0
-      },
-      strokeOpacity: 1,
-      strokeWidth: 3,
-      uniformPolygon: true
-    },
-    highlightStyle: {
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 1
-      },
-      fillOpacity: 0.5,
-      strokeWidth: 5
-    },
-    createStyle: {
-      fillColor: {
-        r: 0.3,
-        g: 0.3,
-        b: 0.3
-      },
-      fillOpacity: 0.25,
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 1
-      }
-    }
-  }, args || {});
+  args = $.extend(true, {}, this.constructor.defaults, args);
   args.corners = args.corners || args.coordinates || [];
   delete args.coordinates;
   annotation.call(this, annotationName || 'rectangle', args);
@@ -3156,6 +3249,23 @@ var rectangleAnnotation = function rectangleAnnotation(args, annotationName) {
 
     return features;
   };
+  /**
+   * Return this annotation as a polygon list.
+   *
+   * @param {geo.util.polyop.spec} [opts] Ignored.
+   * @returns {geo.polygonList} A list of polygons.
+   */
+
+
+  this.toPolygonList = function (opts) {
+    if (m_this._coordinates().length < 3) {
+      return [];
+    }
+
+    return [[m_this._coordinates().map(function (pt) {
+      return [pt.x, pt.y];
+    })]];
+  };
   /**
    * Get and optionally set coordinates associated with this annotation in the
    * map gcs coordinate system.
@@ -3431,6 +3541,56 @@ var rectangleAnnotation = function rectangleAnnotation(args, annotationName) {
 };
 
 inherit(rectangleAnnotation, annotation);
+/**
+ * This object contains the default options to initialize the class.
+ */
+
+rectangleAnnotation.defaults = $.extend({}, annotation.defaults, {
+  style: {
+    fill: true,
+    fillColor: {
+      r: 0,
+      g: 1,
+      b: 0
+    },
+    fillOpacity: 0.25,
+    polygon: function polygon(d) {
+      return d.polygon;
+    },
+    stroke: true,
+    strokeColor: {
+      r: 0,
+      g: 0,
+      b: 0
+    },
+    strokeOpacity: 1,
+    strokeWidth: 3,
+    uniformPolygon: true
+  },
+  highlightStyle: {
+    fillColor: {
+      r: 0,
+      g: 1,
+      b: 1
+    },
+    fillOpacity: 0.5,
+    strokeWidth: 5
+  },
+  createStyle: {
+    fillColor: {
+      r: 0.3,
+      g: 0.3,
+      b: 0.3
+    },
+    fillOpacity: 0.25,
+    strokeColor: {
+      r: 0,
+      g: 0,
+      b: 1
+    }
+  },
+  allowBooleanOperations: true
+});
 var rectangleRequiredFeatures = {};
 rectangleRequiredFeatures[polygonFeature.capabilities.feature] = true;
 registerAnnotation('rectangle', rectangleAnnotation, rectangleRequiredFeatures);
@@ -3467,18 +3627,22 @@ var rectangleAnnotation = __webpack_require__(3442);
 var squareAnnotation = function squareAnnotation(args, annotationName) {
   'use strict';
 
-  args = $.extend({}, args, {
-    constraint: 1
-  });
-
   if (!(this instanceof squareAnnotation)) {
     return new squareAnnotation(args, annotationName);
   }
 
+  args = $.extend(true, {}, this.constructor.defaults, args, {
+    constraint: 1
+  });
   rectangleAnnotation.call(this, args, annotationName || 'square');
 };
 
 inherit(squareAnnotation, rectangleAnnotation);
+/**
+ * This object contains the default options to initialize the class.
+ */
+
+squareAnnotation.defaults = $.extend({}, rectangleAnnotation.defaults, {});
 var squareRequiredFeatures = {};
 squareRequiredFeatures[polygonFeature.capabilities.feature] = true;
 registerAnnotation('square', squareAnnotation, squareRequiredFeatures);
@@ -3489,6 +3653,20 @@ module.exports = squareAnnotation;
 /***/ 836:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 var inherit = __webpack_require__(5699);
 
 var featureLayer = __webpack_require__(3715);
@@ -3722,6 +3900,56 @@ var annotationLayer = function annotationLayer(arg) {
 
     m_this._updateFromEvent(update);
   };
+  /**
+   * Check if there is a current boolean operation.
+   *
+   * @returns {string?} Either undefined for no current boolean operation or
+   *   the name of the operation.
+   */
+
+
+  this.currentBooleanOperation = function () {
+    var op;
+
+    if (m_this._currentBooleanClass) {
+      op = m_this._currentBooleanClass.split('-')[1];
+    }
+
+    return op;
+  };
+  /**
+   * Check if the map is currently in a mode where we are adding an annotation
+   * with a boolean operation.  If so, remove the current annotation from the
+   * layer, then apply it via the boolean operation.
+   */
+
+
+  this._handleBooleanOperation = function () {
+    var op = m_this.currentBooleanOperation();
+
+    if (!op || !m_this.currentAnnotation || !m_this.currentAnnotation.toPolygonList) {
+      return;
+    }
+
+    var newAnnot = m_this.currentAnnotation;
+    m_this.removeAnnotation(m_this.currentAnnotation, false);
+
+    if (m_this.annotations().length || op !== 'difference' && op !== 'intersect') {
+      var evt = {
+        annotation: newAnnot,
+        operation: op
+      };
+      m_this.geoTrigger(geo_event.annotation.boolean, evt);
+
+      if (evt.cancel !== false) {
+        util.polyops[op](m_this, newAnnot.toPolygonList(), {
+          correspond: {},
+          keepAnnotations: 'exact',
+          style: m_this
+        });
+      }
+    }
+  };
   /**
    * Handle updating the current annotation based on an update state.
    *
@@ -3740,6 +3968,8 @@ var annotationLayer = function annotationLayer(arg) {
         break;
 
       case 'done':
+        m_this._handleBooleanOperation();
+
         m_this.mode(null);
         break;
     }
@@ -3749,6 +3979,30 @@ var annotationLayer = function annotationLayer(arg) {
       m_this.draw();
     }
   };
+  /**
+   * Check the state of the modifier keys and apply them if appropriate.
+   *
+   * @param {geo.event} evt The mouse move or click event.
+   */
+
+
+  this._handleMouseMoveModifiers = function (evt) {
+    if (m_this.mode() !== m_this.modes.edit && m_this.currentAnnotation.options('allowBooleanOperations') && m_this.currentAnnotation._coordinates().length < 2) {
+      if (evt.modifiers) {
+        var mod = (evt.modifiers.shift ? 's' : '') + (evt.modifiers.ctrl ? 'c' : '') + (evt.modifiers.meta || evt.modifiers.alt ? 'a' : '');
+
+        if (m_this._currentBooleanClass === m_this._booleanClasses[mod]) {
+          return;
+        }
+
+        m_this._currentBooleanClass = m_this._booleanClasses[mod];
+        var mapNode = m_this.map().node();
+        Object.values(m_this._booleanClasses).forEach(function (c) {
+          mapNode.toggleClass(c, m_this._booleanClasses[mod] === c);
+        });
+      }
+    }
+  };
   /**
    * Handle mouse movement.  If there is a current annotation, the movement
    * event is sent to it.
@@ -3759,6 +4013,8 @@ var annotationLayer = function annotationLayer(arg) {
 
   this._handleMouseMove = function (evt) {
     if (m_this.mode() && m_this.currentAnnotation) {
+      m_this._handleMouseMoveModifiers(evt);
+
       var update = m_this.currentAnnotation.mouseMove(evt);
 
       if (update) {
@@ -3881,6 +4137,8 @@ var annotationLayer = function annotationLayer(arg) {
       });
       retrigger = true;
     } else if (m_this.mode() && m_this.currentAnnotation) {
+      m_this._handleMouseMoveModifiers(evt);
+
       update = m_this.currentAnnotation.mouseClick(evt);
 
       m_this._updateFromEvent(update);
@@ -4118,6 +4376,15 @@ var annotationLayer = function annotationLayer(arg) {
   this.modes = {
     edit: 'edit'
   };
+  /* Keys are short-hand for preferred event modifiers.  Values are classes to
+   * apply to the map node. */
+
+  this._booleanClasses = {
+    s: 'annotation-union',
+    sc: 'annotation-intersect',
+    c: 'annotation-difference',
+    sa: 'annotation-xor'
+  };
   /**
    * Get or set the current mode.
    *
@@ -4139,7 +4406,7 @@ var annotationLayer = function annotationLayer(arg) {
       return m_mode;
     }
 
-    if (arg !== m_mode || arg === m_this.modes.edit && editAnnotation !== m_this.editAnnotation) {
+    if (arg !== m_mode || arg === m_this.modes.edit && editAnnotation !== m_this.editAnnotation || arg !== m_this.modes.edit && arg && !m_this.currentAnnotation) {
       var createAnnotation,
           actions,
           mapNode = m_this.map().node(),
@@ -4147,6 +4414,13 @@ var annotationLayer = function annotationLayer(arg) {
       m_mode = arg;
       mapNode.toggleClass('annotation-input', !!(m_mode && m_mode !== m_this.modes.edit));
 
+      if (!m_mode || m_mode === m_this.modes.edit) {
+        Object.values(m_this._booleanClasses).forEach(function (c) {
+          return mapNode.toggleClass(c, false);
+        });
+        m_this._currentBooleanClass = undefined;
+      }
+
       if (!m_keyHandler) {
         m_keyHandler = Mousetrap(mapNode[0]);
       }
@@ -4238,7 +4512,10 @@ var annotationLayer = function annotationLayer(arg) {
   this.geojson = function (geojson, clear, gcs, includeCrs) {
     if (geojson !== undefined) {
       var reader = registry.createFileReader('geojsonReader', {
-        layer: m_this
+        layer: m_this,
+        lineStyle: (__webpack_require__(3984).defaults.style),
+        pointStyle: (__webpack_require__(8296).defaults.style),
+        polygonStyle: (__webpack_require__(56).defaults.style)
       });
 
       if (!reader.canRead(geojson)) {
@@ -4887,6 +5164,150 @@ var annotationLayer = function annotationLayer(arg) {
     s_draw.call(m_this);
     return m_this;
   };
+  /**
+   * Return any annotation that has area as a polygon list: an array of
+   * polygons, each of which is an array of polylines, each of which is an
+   * array of points, each of which is a 2-tuple of numbers.
+   *
+   * @param {geo.util.polyop.spec} [opts] Ignored.
+   * @returns {geo.polygonList} A list of polygons.
+   */
+
+
+  this.toPolygonList = function (opts) {
+    var poly = [];
+    opts = opts || {};
+    opts.annotationIndices = [];
+    m_annotations.forEach(function (annotation, idx) {
+      if (annotation.toPolygonList) {
+        annotation.toPolygonList(opts).forEach(function (p) {
+          return poly.push(p);
+        });
+        opts.annotationIndices.push(idx);
+      }
+    });
+    return poly;
+  };
+  /**
+   * Replace appropriate annotations with a list of polygons.
+   *
+   * @param {geo.polygonList} poly A list of polygons.
+   * @param {geo.util.polyop.spec} [opts] This contains annotationIndices and
+   *   correspondence used to track annotations.
+   * @returns {this}
+   */
+
+
+  this.fromPolygonList = function (poly, opts) {
+    if (!poly || !poly.length) {
+      return m_this;
+    }
+    /* One of 'all', 'exact', 'none'; default is 'exact' */
+
+
+    var keep = opts.keepAnnotations;
+    var keepIds = {};
+    var reusedIds = {};
+    var correspond, exact, annot;
+
+    if (opts.annotationIndices && opts.correspond && opts.correspond.poly1 && opts.annotationIndices.length === opts.correspond.poly1.length) {
+      correspond = opts.correspond.poly1;
+      exact = opts.correspond.exact1;
+      annot = m_this.annotations();
+    }
+
+    if (keep !== 'all' && keep !== 'none') {
+      annot.forEach(function (oldAnnot, idx) {
+        if (opts.annotationIndices.indexOf(idx) < 0) {
+          keepIds[oldAnnot.id()] = true;
+        }
+      });
+    }
+
+    var polyAnnot = [];
+    poly.forEach(function (p, idx) {
+      p = p.map(function (h) {
+        return h.map(function (pt) {
+          return {
+            x: pt[0],
+            y: pt[1]
+          };
+        });
+      });
+      var result = {
+        vertices: p.length === 1 ? p[0] : {
+          outer: p[0],
+          inner: p.slice(1)
+        }
+      };
+
+      if (correspond) {
+        for (var i = 0; i < correspond.length; i += 1) {
+          if (correspond[i] && correspond[i].indexOf(idx) >= 0) {
+            var _ret = function () {
+              var orig = annot[opts.annotationIndices[i]];
+
+              if (keep !== 'all' && keep !== 'none' && exact && exact[i] && exact[i].indexOf(idx) >= 0) {
+                keepIds[orig.id()] = true;
+                return {
+                  v: void 0
+                };
+              }
+
+              if (keep !== 'all' && reusedIds[orig.id()] === undefined) {
+                result.annotationId = orig.id();
+                reusedIds[orig.id()] = true;
+              }
+
+              ['name', 'description', 'label'].forEach(function (k) {
+                if (orig[k](undefined, true)) {
+                  result[k] = orig[k](undefined, true);
+                }
+              });
+              Object.entries(orig.options()).forEach(function (_ref) {
+                var _ref2 = _slicedToArray(_ref, 2),
+                    key = _ref2[0],
+                    value = _ref2[1];
+
+                if (['showLabel', 'style'].indexOf(key) >= 0 || key.endsWith('Style')) {
+                  result[key] = value;
+                }
+              });
+              return "break";
+            }();
+
+            if (_ret === "break") break;
+            if (_typeof(_ret) === "object") return _ret.v;
+          }
+        }
+      }
+
+      polyAnnot.push(result);
+    });
+    var update = false; // delete extant annotations
+
+    if (keep !== 'all' && annot) {
+      annot.filter(function (oldAnnot) {
+        return keepIds[oldAnnot.id()] === undefined;
+      }).forEach(function (oldAnnot) {
+        m_this.removeAnnotation(oldAnnot, false);
+        update = true;
+      });
+    } // add new annotations
+
+
+    polyAnnot.forEach(function (p) {
+      m_this.addAnnotation(registry.createAnnotation('polygon', p), m_this.gcs(), false);
+      update = true;
+    });
+
+    if (update) {
+      m_this.modified();
+      m_this.draw();
+    }
+
+    return m_this;
+  };
   /**
    * Initialize.
    *
@@ -9418,6 +9839,20 @@ geo_event.annotation.state = 'geo_annotation_state';
  */
 
 geo_event.annotation.mode = 'geo_annotation_mode';
+/**
+ * Triggered when an annotation can be combined via a boolean operation (union,
+ * intersect, difference, xor).
+ *
+ * @event geo.event.annotation.boolean
+ * @type {geo.event.base}
+ * @property {geo.annotation} annotation The annotation that is being operated
+ *      on.
+ * @property {string} operation The operation being performed.
+ * @property {boolean} [cancel] If the handle sets this to false, don't apply
+ *      the operation to the annotation layer.
+ */
+
+geo_event.annotation.boolean = 'geo_annotation_boolean';
 module.exports = geo_event;
 
 /***/ }),
@@ -15293,7 +15728,10 @@ var lineFeature = function lineFeature(arg) {
         var p = posFunc(current, j, d, index);
 
         if (onlyInvertedY) {
-          p.y = -p.y;
+          p = {
+            x: p.x,
+            y: -p.y
+          };
         } else if (gcs !== mapgcs) {
           p = transform.transformCoordinates(gcs, mapgcs, p);
         }
@@ -25090,6 +25528,72 @@ var polygonFeature = function polygonFeature(arg) {
       evt.over.found[idx] = data[di];
     });
   };
+  /**
+   * Return the polygons as a polygon list: an array of polygons, each of which
+   * is an array of polylines, each of which is an array of points, each of
+   * which is a 2-tuple of numbers.
+   *
+   * @param {geo.util.polyop.spec} [opts] Ignored.
+   * @returns {geo.polygonList} A list of polygons.
+   */
+
+
+  this.toPolygonList = function (opts) {
+    var polyFunc = m_this.style.get('polygon');
+    var posFunc = m_this.style.get('position');
+    return m_this.data().map(function (d, i) {
+      var polygon = polyFunc(d, i);
+      var outer = polygon.outer || (Array.isArray(polygon) ? polygon : []);
+
+      if (outer.length < 3) {
+        return [];
+      }
+
+      var resp = [outer.map(function (p, j) {
+        var pos = posFunc(p, j, d, i);
+        return [pos.x, pos.y];
+      })];
+
+      if (polygon.inner) {
+        polygon.inner.forEach(function (h) {
+          resp.push(h.map(function (p, j) {
+            var pos = posFunc(p, j, d, i);
+            return [pos.x, pos.y];
+          }));
+        });
+      }
+
+      return resp;
+    });
+  };
+  /**
+   * Set the data, position accessor, and polygon accessor to use a list of
+   * polygons.
+   *
+   * @param {geo.polygonList} poly A list of polygons.
+   * @param {geo.util.polyop.spec} [opts] Ignored.
+   * @returns {this}
+   */
+
+
+  this.fromPolygonList = function (poly, opts) {
+    m_this.style({
+      position: function position(p) {
+        return {
+          x: p[0],
+          y: p[1]
+        };
+      },
+      polygon: function polygon(p) {
+        return {
+          outer: p[0],
+          inner: p.slice(1)
+        };
+      }
+    });
+    m_this.data(poly);
+    return m_this;
+  };
   /**
    * Destroy.
    */
@@ -27059,7 +27563,7 @@ module.exports = sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "e13f6d922451bb86544884283bfb31843f58bd60";
+module.exports = "c77ab7869ca682dfc42f6a12a7ad2121687e94b8";
 
 /***/ }),
 
@@ -34006,6 +34510,17 @@ module.exports = transform;
  * @property {number} [z=0] Altitude coordinate.
  */
 
+/**
+ * General represention of a point on the earth.  The coordinates are most
+ * commonly in longitude and latitude, but the coordinate system is changed
+ * by the interface gcs.  This is a list of numbers consisting of either [x, y]
+ * or [x, y, z], where therse are the horizontal, vertical, and altitude
+ * coordinates.
+ *
+ * @typedef geo.geoPositionFlat
+ * @type {number[]}
+ */
+
 /**
  * General represention of a two-dimensional point in any coordinate system.
  *
@@ -38828,7 +39343,8 @@ __webpack_require__(7566), __webpack_require__(9215), __webpack_require__(895),
 {
   DistanceGrid: __webpack_require__(5844),
   ClusterGroup: __webpack_require__(9808),
-  mesh: __webpack_require__(9244)
+  mesh: __webpack_require__(9244),
+  polyops: __webpack_require__(6771)
 });
 
 /***/ }),
@@ -39205,6 +39721,592 @@ module.exports.restoreWebglRenderer = function () {
 
 /***/ }),
 
+/***/ 6771:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var PolyBool = __webpack_require__(3291);
+
+var geo_map = __webpack_require__(2804);
+/**
+ * A list of flat polygon lists.
+ *
+ * @typedef {Array.<Array.<Array.<geo.geoPositionFlat>>>} geo.polygonList
+ */
+
+/**
+ * A polygon in any of a variety of formats.
+ *
+ * This can be any object with a ``toPolygonList`` and ``fromPolygonList``
+ * method.
+ *
+ * @typedef {geo.polygonFlat|Array.<geo.polygonFlat>|Array.<Array.<geo.polygonFlat>>|geo.polygonObject|Array.<geo.polygonObject>|Array.<geo.geoPositionFlat>|Array.<Array.<geo.geoPositionFlat>>|geo.polygonList|object} geo.polygonAny
+ */
+
+/**
+ * Object specification for polygon operation options.
+ *
+ * @typedef {object} geo.util.polyop.spec
+ * @property {geo.polygonAny} [poly1] The first polygon set to operate on.
+ * @property {geo.polygonAny} [poly2] The second polygon set to operate on.
+ * @property {number} [epsilon1] A precision value to use when computing the
+ *   operation.  If not specified, this is computed from the range of values in
+ *   ``poly1``.  It is used for processing ``poly1`` and the general operation.
+ * @property {number} [epsilon1] A precision value to use when processing
+ *   ``poly2``.  If not specified, this is computed from the range of values in
+ *   ``poly2``.
+ * @property {string|object} [style] If specified, the preferred output style.
+ *   This can be (flat|object)[-list[list[-outer[-list]]]].  If an object,
+ *   the object must have a method ``fromPolygonList``.
+ * @property {string|geo.transform} [ingcs] The default coordinate
+ *   system of the source polygon coordinates.  If not specified , this is
+ *   taken from the feature first or the map second if either is available.
+ * @property {string|geo.transform} [gcs] The default coordinate system to use
+ *   for the actual operations.  This is where the epsilon and rdp values are
+ *   applied.  If not specified , this is taken from the map second if
+ *   available.
+ * @property {geo.map} [map] Used for ``ingcs`` and ``gcs`` if needed.
+ * @property {string} [innerOperation="union"] one of union, intersect, xor.
+ *   Used to combine individual polygons in each of ``poly1`` and ``poly2``
+ *   before the main operation is carried out.
+ * @property {object} [correspond] If present, information about the
+ *   correspondence of the input and output polygons is added to this object.
+ *   This is of the form {poly1: [idx...], poly2: [idx...], exact1: [idx...],
+ *   exact2: [idx...]}, where the [idx...] array is the length of the input
+ *  polygon array and each entry is either undefined or contains a list of
+ *   indices of corresponding output polygons.  Exact means that all of the
+ *   points in the input polygon are in the output polygon.  Multiple inputs
+ *   can refer to the same output.
+ * @property {number} [tolerance] A tolerance value to pass to features,
+ *   annotations, or other object-based polygon generators to specify how
+ *   closely non-polygons are converted to polygons.  This is in the feature's
+ *   gcs coordinate system.
+ * @property {number} [pixelTolerance] A tolerance value to pass to features,
+ *   annotations, or other object-based polygon generators to specify how
+ *   closely non-polygons are converted to polygons.  This is interpreted in
+ *   the feature's map's display coordinates.
+ */
+
+
+var AlternateOpNames = {
+  '+': 'union',
+  '|': 'union',
+  add: 'union',
+  '-': 'difference',
+  sub: 'difference',
+  subtract: 'difference',
+  minus: 'difference',
+  '*': 'intersect',
+  '&': 'intersect',
+  mul: 'intersect',
+  multiply: 'intersect',
+  x: 'xor',
+  '^': 'xor'
+};
+/**
+ * Convert a segment list to a polygon list.
+ *
+ * @param {object[]} seglist A PolyBool segment list.
+ * @returns {geo.polygonList} A polygon list.
+ */
+
+function seglistToPolygonList(seglist) {
+  // This single line doesn't arrange holes correctly
+  // return seglist.map((s) => PolyBool.polygon(s).regions);
+  var polys = [];
+  seglist.forEach(function (s) {
+    var geojson = PolyBool.polygonToGeoJSON(PolyBool.polygon(s));
+
+    if (geojson.type === 'MultiPolygon') {
+      geojson.coordinates.forEach(function (p) {
+        polys.push(p.map(function (h) {
+          return h.slice(0, h.length - 1);
+        }));
+      });
+    } else if (geojson.type === 'Polygon') {
+      polys.push(geojson.coordinates.map(function (h) {
+        return h.slice(0, h.length - 1);
+      }));
+    }
+  });
+  return polys;
+}
+/**
+ * Perform an boolean operation on a seglist from polygons.
+ *
+ * @param {string} op One of 'union', 'intersect', or other value PolyBool
+ *      supports.
+ * @param {number} epsilon Precision for calculations.  In degrees, 1e-9 is
+ *      around 0.11 mm in ground distance.
+ * @param {object} seglist A seglist array as used by the polybool library.
+ * @returns {object} A seglist array.
+ */
+
+
+function polygonOperationSeglist(op, epsilon, seglist) {
+  op = 'select' + op.charAt(0).toUpperCase() + op.slice(1);
+  PolyBool.epsilon(epsilon);
+
+  while (seglist.length > 1) {
+    var newlist = [];
+    var half = Math.ceil(seglist.length / 2);
+
+    for (var i = 0; i < half; i += 1) {
+      var segments = seglist[i];
+
+      if (i + half < seglist.length) {
+        var nextseg = seglist[i + half];
+
+        try {
+          segments = PolyBool.combine(segments, nextseg);
+        } catch (err) {
+          segments = PolyBool.segments(PolyBool.polygon(segments));
+          nextseg = PolyBool.segments(PolyBool.polygon(nextseg));
+
+          for (var j = 20; j >= 6; j -= 1) {
+            PolyBool.epsilon(Math.pow(0.1, j));
+
+            try {
+              segments = PolyBool.combine(segments, nextseg);
+              break;
+            } catch (err) {}
+          }
+
+          PolyBool.epsilon(epsilon);
+        }
+
+        if (segments.combined) {
+          segments.combined = segments.combined.filter(function (s) {
+            return Math.abs(s.start[0] - s.end[0]) > epsilon || Math.abs(s.start[1] - s.end[1]) > epsilon;
+          });
+          segments = PolyBool[op](segments);
+        } else {
+          console.warn('Failed in polygon functions.');
+        }
+
+        segments.segments = segments.segments.filter(function (s) {
+          return Math.abs(s.start[0] - s.end[0]) > epsilon || Math.abs(s.start[1] - s.end[1]) > epsilon;
+        });
+      }
+
+      newlist.push(segments);
+    }
+
+    seglist = newlist;
+  }
+
+  return seglist;
+}
+/**
+ * Convert a polygon in any of several formats to a polygon list.  Each polygon
+ * in the list is a list of polylines.  Each polyline is a list of points.
+ * Each point is a list of two coordinates.  The input can be a variety of
+ * formats:
+ *   - object, flat: a list of {x, y} or [x, y]
+ *   - object-list, flat-list: a list of lists of {x, y} or [x, y]
+ *   - object-listlist, flat-listlist: a list if lists of lists of {x, y} or
+ *     [x, y]
+ *   - object-listlist-outer, flat-listlist-outer: {outer: {x, y}, inner:
+ *     [{x, y}]} or {outer: [x, y], inner: [[x, y]]}
+ *   - object-listlist-outer-list, flat-listlist-outer-list: a list of objects
+ *     in outer/inner object or outer/inner list form
+ * The actual format is stored in the mode object.
+ *
+ * @param {geo.polygonAny} poly A polygon in one of the above formats to
+ *   convert.
+ * @param {object} mode An object that is modified with information about
+ *   the conversion.  This includes style: the input polygon format; min: a
+ *   2-item list with minimum values in x, y; max: a 2-item list with
+ *   maximum values in x, y; epsilon: a recommended value for epsilon in other
+ *   functions.
+ * @param {geo.util.polyop.spec} [opts] Options for the operation.  Only used
+ *    if poly is an object with a toPolygonList method.
+ * @returns {geo.polygonList} A list of polygons.
+ */
+
+
+function toPolygonList(poly, mode, opts) {
+  mode = mode || {};
+
+  if (poly.toPolygonList) {
+    mode.style = poly;
+    poly = poly.toPolygonList(opts);
+
+    if (!poly.length) {
+      mode.min = mode.max = [0, 0];
+      mode.epsilon = 1e-10;
+      return poly;
+    }
+  } else {
+    mode.style = '';
+
+    if (poly.outer) {
+      mode.style = '-outer';
+      poly = [[poly.outer].concat(_toConsumableArray(poly.inner || []))];
+    } else if (poly.length && poly[0].outer) {
+      mode.style = '-outer-list';
+      poly = poly.map(function (p) {
+        return [p.outer].concat(_toConsumableArray(p.inner || []));
+      });
+    }
+
+    if (!poly.length) {
+      mode.style = 'flat-listlist' + mode.style;
+      mode.min = mode.max = [0, 0];
+      mode.epsilon = 1e-10;
+      return poly;
+    }
+
+    if (poly[0].x !== undefined) {
+      mode.style = 'object';
+      poly = [[poly.map(function (pt) {
+        return [pt.x, pt.y];
+      })]];
+    } else if (poly[0][0].x !== undefined) {
+      mode.style = 'object-list' + mode.style;
+      poly = [poly.map(function (p) {
+        return p.map(function (pt) {
+          return [pt.x, pt.y];
+        });
+      })];
+    } else if (poly[0][0][0] === undefined) {
+      mode.style = 'flat';
+      poly = [[poly]];
+    } else if (poly[0][0][0].x !== undefined) {
+      mode.style = 'object-listlist' + mode.style;
+      poly = poly.map(function (p) {
+        return p.map(function (l) {
+          return l.map(function (pt) {
+            return [pt.x, pt.y];
+          });
+        });
+      });
+    } else if (poly[0][0][0][0] === undefined) {
+      mode.style = 'flat-list';
+      poly = [poly];
+    } else {
+      mode.style = 'flat-listlist' + mode.style;
+    }
+  }
+
+  mode.min = [poly[0][0][0][0], poly[0][0][0][1]];
+  mode.max = [poly[0][0][0][0], poly[0][0][0][1]];
+  poly.forEach(function (p) {
+    return p.forEach(function (l) {
+      return l.forEach(function (pt) {
+        if (pt[0] < mode.min[0]) {
+          mode.min[0] = pt[0];
+        }
+
+        if (pt[0] > mode.max[0]) {
+          mode.max[0] = pt[0];
+        }
+
+        if (pt[1] < mode.min[1]) {
+          mode.min[1] = pt[1];
+        }
+
+        if (pt[1] > mode.max[1]) {
+          mode.max[1] = pt[1];
+        }
+      });
+    });
+  });
+  mode.epsilon = Math.max(Math.max(mode.max[0], mode.max[1]), Math.max(Math.abs(mode.min[0]), Math.abs(mode.min[1]))) * 1e-10;
+  return poly;
+}
+/**
+ * Convert a polygon list to another format.
+ *
+ * @param {geo.polygonList} poly A list of polygons.
+ * @param {object} mode An object that is modified with information about the
+ *   conversion.  This includes style: the input polygon format; min: a 2-item
+ *   list with minimum values in x, y; max: a 2-item list with maximum values
+ *   in x, y; epsilon: a recommended value for epsilon in other functions.
+ * @param {geo.util.polyop.spec} [opts] Options for the operation.  Only used
+ *    if ``mode.style`` is an object with a fromPolygonList method.
+ * @returns {geo.polygonAny} A polygon in one of several formats.
+ */
+
+
+function fromPolygonList(poly, mode, opts) {
+  if (mode.style.fromPolygonList) {
+    return mode.style.fromPolygonList(poly, opts);
+  }
+
+  if (mode.style.includes('object')) {
+    poly = poly.map(function (p) {
+      return p.map(function (h) {
+        return h.map(function (pt) {
+          return {
+            x: pt[0],
+            y: pt[1]
+          };
+        });
+      });
+    });
+  }
+
+  if (mode.style.includes('outer')) {
+    poly = [poly.map(function (p) {
+      return {
+        outer: p[0],
+        inner: p.slice(1)
+      };
+    })];
+  }
+
+  if (!mode.style.endsWith('listlist')) {
+    if (mode.style.endsWith('list')) {
+      poly = poly[0];
+    } else {
+      poly = poly[0][0];
+    }
+  }
+
+  return poly;
+}
+/**
+ * Use a minimum style for output to include all of the results.
+ *
+ * @param {geo.polygonList} polylist A list of polygons.
+ * @param {string} style the proposed style.
+ * @returns {string} The preferred style.
+ */
+
+
+function minimumPolygonStyle(polylist, style) {
+  if (style.fromPolygonList) {
+    return style;
+  }
+
+  if (polylist.length > 1) {
+    if (style.includes('outer')) {
+      return style + (style.endsWith('list') ? '' : '-list');
+    }
+
+    if (style.endsWith('listlist')) {
+      return style;
+    }
+
+    return style + (style.endsWith('list') ? 'list' : '-listlist');
+  }
+
+  if (polylist.length === 1 && polylist[0].length > 1) {
+    if (style.includes('outer') || style.endsWith('list')) {
+      return style;
+    }
+
+    return style + '-list';
+  }
+
+  return style;
+}
+/**
+ * Generate the correspondence between the source polygons and the output
+ * polygons.  A polygon corresponds if it has at least two points in common.
+ *
+ * @param {geo.polygonList} poly1 First set of source polygons.
+ * @param {geo.polygonList} poly2 Second set of source polygons.
+ * @param {geo.polygonList} newpoly Output polygons.
+ * @param {object} results An object to add results to.
+ */
+
+
+function generateCorrespondence(poly1, poly2, newpoly, results) {
+  var pts = {};
+  var counts = [];
+  newpoly.forEach(function (p, idx) {
+    return p.forEach(function (h) {
+      return h.forEach(function (pt) {
+        var key = '_' + pt[0] + '_' + pt[1];
+
+        if (pts[key]) {
+          if (pts[key].indexOf(idx) === -1) {
+            pts[key].push(idx);
+          }
+        } else {
+          pts[key] = [idx];
+        }
+
+        if (counts.length <= idx) {
+          counts.push(0);
+        }
+
+        counts[idx] += 1;
+      });
+    });
+  });
+  ['poly1', 'poly2'].forEach(function (pkey) {
+    var poly = pkey === 'poly1' ? poly1 : poly2;
+    var ekey = pkey === 'poly1' ? 'exact1' : 'exact2';
+    results[pkey] = Array(poly.length);
+    results[ekey] = Array(poly.length);
+    poly.forEach(function (p, idx) {
+      var found = {};
+      p.forEach(function (h) {
+        return h.forEach(function (pt) {
+          var key = '_' + pt[0] + '_' + pt[1];
+
+          if (pts[key]) {
+            pts[key].forEach(function (val) {
+              found[val] = (found[val] || 0) + 1;
+            });
+          }
+        });
+      });
+      Object.keys(found).forEach(function (nidx) {
+        if (found[nidx] === counts[+nidx]) {
+          if (!results[ekey][idx]) {
+            results[ekey][idx] = [];
+          }
+
+          results[ekey][idx].push(+nidx);
+        }
+
+        if (found[nidx] >= 2) {
+          if (!results[pkey][idx]) {
+            results[pkey][idx] = [];
+          }
+
+          results[pkey][idx].push(+nidx);
+        }
+      });
+    });
+  });
+}
+/**
+ * Perform a general operation of a set of polygons.
+ *
+ * @param {string} op The operation to handle.  One of union, intersect,
+ *    difference, or xor.
+ * @param {geo.polygonAny|geo.util.polyop.spec} poly1 Either the first polygon
+ *    set or an object containing all parameters for the function.
+ * @param {geo.polygonAny} [poly2] If the poly1 parameter is not a complete
+ *    options object, the second polygon set for the operation.
+ * @param {geo.util.polyop.spec} [opts] If the poly1 parameter is not a
+ *    complete options object, the options for the operation.
+ * @returns {geo.polygonAny} A polygon set in the same style as poly1.
+ */
+
+
+function generalOperationProcess(op, poly1, poly2, opts) {
+  var transform = __webpack_require__(6853);
+
+  op = AlternateOpNames[op] || op;
+
+  if (poly1.poly1) {
+    opts = poly1;
+    poly1 = opts.poly1;
+    poly2 = opts.poly2;
+  }
+
+  opts = opts || {};
+  var ingcs1 = opts.ingcs || (opts.map ? opts.map.ingcs() : poly1.gcs ? poly1.gcs() : poly1.layer && poly1.layer().gcs ? poly1.layer().gcs() : poly1.layer ? poly1.layer().map().ingcs() : poly1.map instanceof geo_map ? poly1.map().ingcs() : undefined);
+  var ingcs2 = opts.ingcs || (opts.map ? opts.map.ingcs() : poly2.gcs ? poly2.gcs() : poly2.layer && poly2.layer().gcs ? poly2.layer().gcs() : poly2.layer ? poly2.layer().map().ingcs() : poly2.map instanceof geo_map ? poly2.map().ingcs() : ingcs1);
+  var gcs = opts.gcs || (opts.map ? opts.map.gcs() : poly1.layer ? poly1.layer().map().gcs() : poly1.map instanceof geo_map ? poly1.map().gcs() : undefined);
+  var mode1 = {};
+  var mode2 = {};
+  poly1 = toPolygonList(poly1, mode1, opts);
+  poly2 = toPolygonList(poly2, mode2, opts);
+  mode1.epsilon = opts.epsilon1 || mode1.epsilon;
+  mode2.epsilon = opts.epsilon2 || mode1.epsilon;
+
+  if (ingcs1 && gcs && ingcs1 !== gcs) {
+    poly1 = poly1.map(function (p) {
+      return p.map(function (h) {
+        return transform.transformCoordinates(ingcs1, gcs, h);
+      });
+    });
+  }
+
+  if (ingcs2 && gcs && ingcs2 !== gcs) {
+    poly2 = poly2.map(function (p) {
+      return p.map(function (h) {
+        return transform.transformCoordinates(ingcs2, gcs, h);
+      });
+    });
+  }
+
+  var seglist1 = poly1.map(function (p) {
+    return PolyBool.segments({
+      regions: p
+    });
+  });
+  var seglist2 = poly2.map(function (p) {
+    return PolyBool.segments({
+      regions: p
+    });
+  });
+  seglist1 = polygonOperationSeglist(opts.innerOperation || 'union', mode1.epsilon, seglist1);
+  seglist2 = polygonOperationSeglist(opts.innerOperation || 'union', mode2.epsilon, seglist2);
+  var seglist = seglist1;
+
+  if (seglist1[0] && seglist2[0]) {
+    /* We need to do the main operation with the same inversion flags */
+    seglist1[0].inverted = false;
+    seglist2[0].inverted = false;
+    seglist = polygonOperationSeglist(op, Math.max(mode1.epsilon, mode2.epsilon), [seglist1[0], seglist2[0]]);
+  } else if (seglist2[0]) {
+    seglist = seglist2;
+  }
+
+  var newpoly = seglistToPolygonList(seglist);
+
+  if (opts.correspond) {
+    generateCorrespondence(poly1, poly2, newpoly, opts.correspond);
+  }
+
+  if (ingcs1 && gcs && ingcs1 !== gcs) {
+    newpoly = newpoly.map(function (p) {
+      return p.map(function (h) {
+        return transform.transformCoordinates(gcs, ingcs1, h);
+      });
+    });
+  }
+
+  var mode = {
+    style: opts.style || minimumPolygonStyle(newpoly, mode1.style)
+  };
+  return fromPolygonList(newpoly, mode, opts);
+}
+/**
+ * Generate a polygon function for a specific operation.
+ *
+ * @param {string} op The operation to handle.  One of union, intersect,
+ *    difference, or xor.
+ * @returns {function} a function for the polygons.
+ */
+
+
+function generalOperation(op) {
+  return function (poly1, poly2, opts) {
+    return generalOperationProcess(op, poly1, poly2, opts);
+  };
+}
+
+module.exports = {
+  union: generalOperation('union'),
+  intersect: generalOperation('intersect'),
+  difference: generalOperation('difference'),
+  xor: generalOperation('xor'),
+  toPolygonList: toPolygonList,
+  fromPolygonList: fromPolygonList
+};
+
+/***/ }),
+
 /***/ 9215:
 /***/ (function(module) {
 
@@ -39581,7 +40683,7 @@ module.exports = vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.8.10";
+module.exports = "1.9.2";
 
 /***/ }),
 
@@ -45314,12 +46416,23 @@ module.exports = {
 /* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3476);
 /* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _node_modules_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1678);
+/* harmony import */ var _node_modules_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2__);
 // Imports
 
 
+
+var ___CSS_LOADER_URL_IMPORT_0___ = new URL(/* asset import */ __webpack_require__(3554), __webpack_require__.b);
+var ___CSS_LOADER_URL_IMPORT_1___ = new URL(/* asset import */ __webpack_require__(4144), __webpack_require__.b);
+var ___CSS_LOADER_URL_IMPORT_2___ = new URL(/* asset import */ __webpack_require__(237), __webpack_require__.b);
+var ___CSS_LOADER_URL_IMPORT_3___ = new URL(/* asset import */ __webpack_require__(9490), __webpack_require__.b);
 var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
+var ___CSS_LOADER_URL_REPLACEMENT_0___ = _node_modules_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_0___);
+var ___CSS_LOADER_URL_REPLACEMENT_1___ = _node_modules_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_1___);
+var ___CSS_LOADER_URL_REPLACEMENT_2___ = _node_modules_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_2___);
+var ___CSS_LOADER_URL_REPLACEMENT_3___ = _node_modules_css_loader_dist_runtime_getUrl_js__WEBPACK_IMPORTED_MODULE_2___default()(___CSS_LOADER_URL_IMPORT_3___);
 // Module
-___CSS_LOADER_EXPORT___.push([module.id, ".geojs-map{position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;overflow:hidden}.geojs-map .geo-attribution{position:absolute;right:0;bottom:0;padding-right:5px;cursor:auto;font:11px/1.5 \"Helvetica Neue\",Arial,Helvetica,sans-serif;z-index:1001;background:rgba(255,255,255,0.7);clear:both;display:block;pointer-events:auto}.geojs-map .geo-attribution .geo-attribution-layer{padding-left:5px}.geojs-map .canvas-canvas{display:block;-webkit-transform-origin:0 0;-moz-transform-origin:0 0;-o-transform-origin:0 0;-ms-transform-origin:0 0;transform-origin:0 0}.geojs-map .webgl-canvas{display:block}.geojs-map .geojs-layer{position:absolute;width:100%;height:100%;left:0;top:0;pointer-events:none}.geojs-map .geojs-layer.active:not(.hidden) > *{pointer-events:auto}.geojs-map .geojs-layer.hidden{display:none}.geojs-map .geojs-layer.hidden[renderer=\"webgl\"]{display:inherit}.geojs-map .geo-tile-layer{-webkit-transform-origin:0 0;-moz-transform-origin:0 0;-o-transform-origin:0 0;-ms-transform-origin:0 0;transform-origin:0 0;line-height:0;font-size:0}.geojs-map.annotation-input{cursor:crosshair}.geojs-map.highlight-focus:after{content:\"\";display:block;position:absolute;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;left:0;top:0;right:0;bottom:0;border:3px solid Highlight;opacity:1;-ms-filter:none;filter:none;-webkit-transition:opacity 0s;-moz-transition:opacity 0s;-o-transition:opacity 0s;-ms-transition:opacity 0s;transition:opacity 0s;visibility:hidden}.geojs-map.highlight-focus:focus:after{visibility:visible;-webkit-transition:opacity 2.5s ease-in;-moz-transition:opacity 2.5s ease-in;-o-transition:opacity 2.5s ease-in;-ms-transition:opacity 2.5s ease-in;transition:opacity 2.5s ease-in;opacity:0;-ms-filter:\"progid:DXImageTransform.Microsoft.Alpha(Opacity=0)\";filter:alpha(opacity=0)}.geo-tile-container{position:absolute}.geo-tile-container.crop{overflow:hidden}", "",{"version":3,"sources":["webpack://./main.styl","webpack://./../node_modules/nib/lib/nib/vendor.styl","webpack://./../node_modules/nib/lib/nib/overflow.styl","webpack://./../node_modules/nib/lib/nib/flex.styl","webpack://./../node_modules/nib/lib/nib/border.styl"],"names":[],"mappings":"AAEA,WACE,iBAAS,CCwCO,wBAAG,CAAH,qBAAG,CAAH,oBAAG,CARN,gBAAG,CChBd,eAAU,CFZZ,4BACE,iBAAS,CACT,OAAM,CACN,QAAO,CACP,iBAAc,CCmfd,WAAO,CDjfP,yDAA8B,CAC9B,YAAQ,CCoeR,gCAAW,CDleX,UAAM,CGMN,aAAS,CHJT,mBAAe,CAEf,mDACE,gBAAa,CAEjB,0BGDE,aAAS,CFqBK,4BAAG,CAAH,yBAAG,CAAH,uBAAG,CAAH,wBAAG,CARN,oBAAG,CDThB,yBGJE,aAAS,CHOX,wBACE,iBAAS,CACT,UAAM,CACN,WAAO,CACP,MAAK,CACL,KAAI,CACJ,mBAAe,CAEb,gDACE,mBAAe,CACnB,+BGjBA,YAAS,CHmBT,iDGnBA,eAAS,CHsBX,2BCDgB,4BAAG,CAAH,yBAAG,CAAH,uBAAG,CAAH,wBAAG,CARN,oBAAG,CDWd,aAAY,CACZ,WAAU,CAEZ,4BC6cE,gBAAO,CDzcP,iCACE,UAAQ,CGhCV,aAAS,CHkCP,iBAAS,CCbG,6BAAG,CAAH,0BAAG,CARN,qBAAG,CDuBZ,MAAK,CACL,KAAI,CACJ,OAAM,CACN,QAAO,CIpDT,0BAAQ,CHmQV,SAAS,CAQH,eAAY,CACZ,WAAQ,CA5OE,6BAAG,CAAH,0BAAG,CAAH,wBAAG,CAAH,yBAAG,CARN,qBAAG,CDkCZ,iBAAW,CACb,uCACE,kBAAW,CC5BC,uCAAG,CAAH,oCAAG,CAAH,kCAAG,CAAH,mCAAG,CARN,+BAAG,CA2OhB,SAAS,CAWH,+DAAyE,CACzE,uBAAiC,CD/MzC,oBACE,iBAAS,CACT,yBExDE,eAAU","sourcesContent":["@import '~nib/index.styl'\n\n.geojs-map\n  position relative\n  user-select none\n  overflow hidden\n\n  .geo-attribution\n    position absolute\n    right 0\n    bottom 0\n    padding-right 5px\n    cursor auto\n    font 11px/1.5 \"Helvetica Neue\", Arial, Helvetica, sans-serif\n    z-index 1001\n    background rgba(255,255,255,0.7)\n    clear both\n    display block\n    pointer-events auto\n\n    .geo-attribution-layer\n      padding-left 5px\n\n  .canvas-canvas\n    display block\n    transform-origin 0px 0px\n  .webgl-canvas\n    display block\n\n  .geojs-layer\n    position absolute\n    width 100%\n    height 100%\n    left 0\n    top 0\n    pointer-events none\n    &.active:not(.hidden)\n      > *\n        pointer-events auto\n    &.hidden\n      display none\n    &.hidden[renderer=\"webgl\"]\n      display inherit\n\n  .geo-tile-layer\n    transform-origin 0px 0px\n    line-height 0\n    font-size 0\n\n  &.annotation-input\n    cursor crosshair\n\n  &.highlight-focus\n    &:after\n      content \"\"\n      display block\n      position absolute\n      box-sizing border-box\n      left 0px\n      top 0px\n      right 0px\n      bottom 0px\n      // Highlight is technically a css2 color.  We may need to specify it\n      // explicitly.  #3B66A6 seems close\n      border 3px solid Highlight\n      opacity 1\n      transition opacity 0s\n      visibility hidden\n    &:focus:after\n      visibility visible\n      transition opacity 2.5s ease-in\n      opacity 0\n\n.geo-tile-container\n  position absolute\n  &.crop\n    overflow hidden\n","use('../nodes/vendor-helpers.js')\n@import 'config'\n\n/*\n * Alias \"nowrap\" as \"no-wrap\".\n */\n\nno-wrap = unquote('nowrap')\n\n/*\n * Helper to find out if a given value is a width\n */\n\nis-width(val)\n  if auto == val\n    return true\n  else if val && 'unit' == type(val)\n    // Stylus does not short circuit so we need to perform this as a distinct\n    // operation to prevent errors\n    return '' != unit(val)\n  return false\n\n/*\n * Vendor support for the given prop / arguments, optionally specifying the\n * only prefixes to utilize, or those which should be ignored.\n */\n\nvendor(prop, args, only = null, ignore = null, vendor-property = true)\n  need_normalize = !vendor-property or prop in ('transition' 'transition-property' 'border-image' 'border-image-slice')\n  for prefix in vendor-prefixes\n    unless (only and !(prefix in only)) or (ignore and prefix in ignore)\n      if official == prefix\n        if need_normalize\n          {prop}: normalize(prop,('%s' % args))\n        else\n          {prop}: args\n      else\n        newprop = prop\n        newprop = '-' + prefix + '-' + prop if vendor-property\n\n        if need_normalize\n          {newprop}: normalize(prop,('%s' % args),prefix)\n        else\n          {newprop}: args\n/*\n * Vendorize the given value.\n */\n\nvendor-value(arg, only = null, ignore = null)\n  prop = current-property[0]\n  for prefix in vendor-prefixes\n    unless (only and !(prefix in only)) or (ignore and prefix in ignore) or official == prefix\n      add-property(prop, '-%s-%s' % (prefix arg))\n  arg\n\n/*\n * Vendor \"box-shadow\" support.\n */\n\nbox-shadow()\n  vendor('box-shadow', arguments, only: webkit official)\n\n/*\n * Vendor \"user-select\" support.\n */\n\nuser-select()\n  vendor('user-select', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"column-count\" support.\n */\n\ncolumn-count()\n  vendor('column-count', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-gap\" support.\n */\n\ncolumn-gap()\n  vendor('column-gap', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-rule\" support.\n */\n\ncolumn-rule()\n  vendor('column-rule', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-rule-color\" support.\n */\n\ncolumn-rule-color()\n  vendor('column-rule-color', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-rule-width\" support.\n */\n\ncolumn-rule-width()\n  vendor('column-rule-width', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-rule-style\" support.\n */\n\ncolumn-rule-style()\n  vendor('column-rule-style', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-width\" support.\n */\n\ncolumn-width()\n  vendor('column-width', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-span\" support.\n */\n\ncolumn-span()\n  vendor('column-span', arguments, only: webkit official)\n\n/*\n * Vendor \"column-fill\" support.\n */\n\ncolumn-fill()\n  vendor('column-fill', arguments, only: moz)\n\n/*\n * Legacy syntax support for background-clip and background-origin\n */\n\nlegacy-bg-values(property, args)\n  legacy_args = ()\n  importance = unquote('')\n  for subargs in args\n    for arg in subargs\n      if arg in (border-box padding-box content-box)\n        arg = unquote('border')  if arg == border-box\n        arg = unquote('padding') if arg == padding-box\n        arg = unquote('content') if arg == content-box\n      if arg != '!important'\n        push(legacy_args,arg)\n      else\n        importance = !important\n  vendor(property, unquote(join(', ',legacy_args)) importance, only: moz webkit)\n\n/*\n * Vendor \"background-clip\" support.\n */\n\nbackground-clip()\n  if arguments[0] == text\n    vendor('background-clip', arguments, only: webkit)\n  else\n    legacy-bg-values('background-clip', arguments)\n    background-clip: arguments\n\n/*\n * Vendor \"background-origin\" support.\n */\n\nbackground-origin()\n  legacy-bg-values('background-origin', arguments)\n  background-origin: arguments\n\n/*\n * Vendor \"background-size\" support.\n */\n\nbackground-size()\n  vendor('background-size', arguments, only: webkit moz official)\n\n/*\n * Vendor \"transform\" support.\n */\n\ntransform()\n  vendor('transform', arguments)\n\n/*\n * Vendor \"transform-origin\" support.\n */\ntransform-origin()\n    vendor('transform-origin', arguments)\n\n/*\n * Vendor \"transform-style\" support.\n */\n\ntransform-style()\n  vendor('transform-style', arguments)\n\n/*\n * Vendor \"border-image\" support.\n */\n\nborder-image()\n  vendor('border-image', arguments, only: webkit moz o official)\n\n/*\n * Vendor \"transition\" support.\n */\n\ntransition()\n  vendor('transition', arguments)\n\n/*\n * Vendor \"transition-property\" support.\n */\n\ntransition-property()\n  vendor('transition-property', arguments)\n\n/*\n * Vendor \"transition-duration\" support.\n */\n\ntransition-duration()\n  vendor('transition-duration', arguments)\n\n/*\n * Vendor \"transition-timing-function\" support.\n */\n\ntransition-timing-function()\n  vendor('transition-timing-function', arguments)\n\n/*\n * Vendor \"transition-delay\" support.\n */\n\ntransition-delay()\n  vendor('transition-delay', arguments)\n\n/*\n * Vendor \"backface-visibility\" support.\n */\n\nbackface-visibility()\n  vendor('backface-visibility', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"perspective\" support.\n */\n\nperspective()\n  if mixin\n    vendor('perspective', arguments, only: webkit moz ms official)\n  else\n    'perspective(%s)' % arguments\n\n/*\n * Vendor \"perspective-origin\" support.\n */\n\nperspective-origin()\n  vendor('perspective-origin', arguments, only: webkit moz ms official)\n\n/*\n * Opacity with conditional IE support.\n */\n\nopacity(n, args...)\n  opacity: n args\n  if support-for-ie\n    if n == inherit or n == initial\n      -ms-filter: n args\n      filter: n args\n    else\n      val = round(n * 100)\n      if val == 100\n        -ms-filter: none args\n        filter: none args\n      else\n        -ms-filter: '\"progid:DXImageTransform.Microsoft.Alpha(Opacity=%s)\"' % val args\n        filter: 'alpha(opacity=%s)' % val args\n\n/*\n * Vendor \"text-size-adjust\"\n */\n\ntext-size-adjust()\n  vendor('text-size-adjust', arguments)\n\n/*\n * Alias the \"white-space\" property.\n */\n\nwhitespace()\n  white-space: arguments\n\n/*\n * Vendor \"box-sizing\" support.\n */\n\nbox-sizing()\n  vendor('box-sizing', arguments, only: webkit moz official)\n\n/*\n * Vendor \"box-orient\" support.\n */\n\nbox-orient()\n  vendor('box-orient', arguments, only: webkit moz official)\n\n/*\n * Vendor \"box-flex-group\" support.\n */\n\nbox-flex-group()\n  vendor('box-flex-group', arguments, only: webkit moz official)\n\n/*\n * Vendor \"box-ordinal-group\" support.\n */\n\nbox-ordinal-group()\n  vendor('box-ordinal-group', arguments, only: webkit moz ms official)\n\n\n/*\n * Vendor \"box-align\" support.\n */\n\nbox-align()\n  vendor('box-align', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"box-pack\" support.\n */\n\nbox-pack()\n  vendor('box-pack', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"box-direction\" support.\n */\n\nbox-direction()\n  vendor('box-direction', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"animation\" support.\n */\n\nanimation()\n  vendor('animation', arguments)\n\n\n/*\n * Vendor \"animation-name\" support.\n */\n\nanimation-name()\n  vendor('animation-name', arguments)\n\n/*\n * Vendor \"animation-duration\" support.\n */\n\nanimation-duration()\n  vendor('animation-duration', arguments)\n\n/*\n * Vendor \"animation-delay\" support.\n */\n\nanimation-delay()\n  vendor('animation-delay', arguments)\n\n/*\n * Vendor \"animation-direction\" support.\n */\n\nanimation-direction()\n  vendor('animation-direction', arguments)\n\n/*\n * Vendor \"animation-iteration-count\" support.\n */\n\nanimation-iteration-count()\n  vendor('animation-iteration-count', arguments)\n\n/*\n * Vendor \"animation-timing-function\" support.\n */\n\nanimation-timing-function()\n  vendor('animation-timing-function', arguments)\n\n/*\n * Vendor \"animation-play-state\" support.\n */\n\nanimation-play-state()\n  vendor('animation-play-state', arguments)\n\n/*\n * Vendor \"animation-fill-mode\" support.\n */\n\nanimation-fill-mode()\n  vendor('animation-fill-mode', arguments)\n\n/*\n * Vendor \"hyphens\" support.\n */\n\nhyphens()\n  vendor('hyphens', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"appearance\" support.\n */\n\nappearance()\n  vendor('appearance', arguments, only: webkit moz official)\n\n/*\n * Vendor \"tab-size\" support.\n */\n\ntab-size()\n  vendor('tab-size', arguments, only: moz o official)\n\n/*\n * Vendor \"overflow-scrolling\" support.\n */\n\noverflow-scrolling()\n  vendor('overflow-scrolling', arguments, only: webkit official)\n\n/*\n * Vendor \"text-overflow\" support, , -o- for opera 9.* - 10.*\n */\n\ntext-overflow()\n  vendor('text-overflow', arguments, only: official o)\n\n/*\n * Vendor \"text-size-adjust\" support.\n */\ntext-size-adjust()\n  vendor('text-size-adjust', arguments, only: official webkit ms)\n\n/*\n * Vendor \"font-smoothing\" support, webkit only.\n */\nfont-smoothing()\n  vendor('font-smoothing', arguments, only: webkit)\n\n\n/**\n * Vendor input-placeholder/placeholder support.\n *\n * Examples:\n *    // Default syntax\n *    body\n *      placeholder(color #333, font-weight normal)\n *\n *    // The comma is important\n *    .placeholder-red\n *      placeholder(color red,)\n *\n *    // We can pass a function\n *    green-placeholder()\n *      color green\n *    .placeholder-green\n *      placeholder(green-placeholder)\n *\n *    // We can pass a hash\n *    textarea\n *      placeholder((font-style italic) (font-weight bold) (padding '4px 10px'))\n */\nplaceholder()\n  for v in ':-webkit-input' '-moz' ':-moz' '-ms-input'\n    &:{v}-placeholder\n      for pair in arguments\n        if typeof(pair) == 'function'\n          pair()\n        else if pair is not null && pair[0] is not null\n          {pair[0]}: type(pair[1]) == 'string' ? s(pair[1]) : pair[1]\ninput-placeholder = placeholder\n\n/*\n * Vendor background support (gradients).\n */\n\nbackground()\n  if match('-gradient\\(', ''+arguments)\n    vendor('background', arguments, vendor-property: false)\n  else\n    background arguments\n\nbackground-image()\n  if match('-gradient\\(', ''+arguments)\n    vendor('background-image', arguments, vendor-property: false)\n  else\n    background-image arguments\n\ncursor()\n  if match('-gradient\\(', ''+arguments)\n    vendor('cursor', arguments, vendor-property: false)\n  else\n    cursor arguments\n\nlist-style()\n  if match('-gradient\\(', ''+arguments)\n    vendor('list-style', arguments, vendor-property: false)\n  else\n    list-style arguments\n\nlist-style-image()\n  if match('-gradient\\(', ''+arguments)\n    vendor('list-style-image', arguments, vendor-property: false)\n  else\n    list-style-image arguments\n","/*\n * Overflow utility. Maps to regular overflow, and adds an ellipsis value.\n *\n * Synopsis:\n *\n *   overflow: <type>\n *\n * Examples:\n *\n *     overflow: auto\n *     overflow: hidden\n *     overflow: ellipsis\n *\n */\n\noverflow()\n  if arguments[0] == ellipsis\n    ellipsis()\n  else\n    overflow: arguments\n","/*\n * Vendor \"display: flex\" support with fallback to obsolete versions.\n */\n\nflex-version ?= box flex\n\n//\n// 1. Display values\n//    - http://www.w3.org/TR/css3-flexbox/#flex-containers\n//\ndisplay(type, args...)\n  if flex == type || inline-flex == type\n    if box in flex-version\n      if flex == type\n        display: -ms-flexbox args\n        display: vendor-value(box args, only: moz webkit)\n      else\n        display: -ms-inline-flexbox args\n        display: vendor-value(inline-box args, only: moz webkit)\n    if flex in flex-version\n      display: vendor-value(arguments, only: webkit official) // overwrites old webkit\n  else\n    display: arguments\n\n/*\n * New syntax for browsers like Google Chrome.\n * Plus a translation to the old syntax, if possible.\n */\n\n\n//\n// 5. Ordering and Orientation\n//    - http://www.w3.org/TR/css3-flexbox/#ordering-and-orientation\n//\n-flex-obsolete-direction(direction)\n  if box in flex-version\n    if row-reverse == direction || column-reverse == direction\n      vendor('box-direction', reverse, ignore: ms official)\n\n    if row == direction || row-reverse == direction\n      vendor('box-orient', horizontal, ignore: ms official)\n    else if column == direction || column-reverse == direction\n      vendor('box-orient', vertical, ignore: ms official)\n\n-flex-obsolete-wrap(value)\n  if box in flex-version\n    // WARN: wrap-reverse does not have a box equivalent. This will render in different manners\n    //    on box vs. flex values.\n    if 'wrap' == value || wrap-reverse == value\n      vendor('box-lines', multiple, ignore: ms official)\n    else if nowrap == value\n      vendor('box-lines', single, ignore: ms official)\n\nflex-direction(direction)\n  // obsolete\n  -flex-obsolete-direction(direction)\n\n  // new\n  if flex in flex-version\n    vendor('flex-direction', arguments, only: webkit ms official)\n\nflex-wrap(value)\n  // obsolete\n  -flex-obsolete-wrap(value)\n\n  if flex in flex-version\n    vendor('flex-wrap', arguments, only: webkit ms official)\n\nflex-flow()\n  // obsolete\n  -flex-obsolete-direction(arguments[0])\n  -flex-obsolete-direction(arguments[1])\n  -flex-obsolete-wrap(arguments[0])\n  -flex-obsolete-wrap(arguments[1])\n\n  // new\n  if flex in flex-version\n    vendor('flex-flow', arguments, only: webkit ms official)\n\n\norder()\n  // obsolete\n  if box in flex-version\n    vendor('box-ordinal-group', arguments, ignore: ms official)\n\n  // new\n  if flex in flex-version\n    vendor('flex-order', arguments, only: ms)\n    vendor('order', arguments, only: webkit official)\n\n\n//\n// 7. Flexibility\n//    - http://www.w3.org/TR/css3-flexbox/#flexibility\n//\nflex-grow(growth)\n  // obsolete\n  if box in flex-version\n    vendor('box-flex', growth)\n\n  // new\n  if flex in flex-version\n    vendor('flex-grow', arguments, only: webkit official)\n\nflex-basis()\n  if flex in flex-version\n    vendor('flex-basis', arguments, only: webkit official)\n\nflex-shrink()\n  if flex in flex-version\n    vendor('flex-shrink', arguments, only: webkit official)\n\nflex(growth)\n\n  // obsolete\n  if box in flex-version\n    shrink = 1\n\n    if none == growth || initial == growth\n      // Well known values\n      shrink = 0 if none == growth\n      growth = 0\n    else if is-width(growth) == true\n      // Basis is defined as the first parameter\n      growth = arguments[1] || 0\n      shrink = arguments[2] if 3 <= length(arguments)\n    else if arguments[1] && is-width(arguments[1]) == false\n      // Growth is first and shrink is second\n      shrink = arguments[1]\n\n    // Since we can't make the distinction between growing and shrinking in the box model, take\n    // the one that provides the most flexibility.\n    vendor('box-flex', max(growth, shrink), ignore: ms)\n\n  // new\n  if flex in flex-version\n    vendor('flex', arguments, only: webkit ms official)\n\n\n// converts the justification alignment\n-convert-justify(align)\n  if flex-start == align\n    return start\n  else if flex-end == align\n    return end\n  else if space-around == align\n    return distribute\n  else if space-between == align\n    return justify\n  else\n    return align\n\n//\n// 8. Alignment\n//    - http://www.w3.org/TR/css3-flexbox/#alignment\n//\njustify-content(align)\n  // obsolete\n  if box in flex-version\n    vendor('box-pack', -convert-justify(align), ignore: ms official)\n\n  // new\n  if flex in flex-version\n    vendor('flex-pack', -convert-justify(align), only: ms)\n    vendor('justify-content', align, only: webkit official)\n\nalign-content(align)\n  // WARN: Obsolete spec does not allow for adjustment here\n  if flex in flex-version\n    vendor('flex-line-pack', -convert-justify(align), only: ms)\n    vendor('align-content', align, only: webkit official)\n\n// converts alignment from 'flex' to normal value\n-convert-alignment(align)\n  if flex-start == align\n    return start\n  else if flex-end == align\n    return end\n  else\n    return align\n\nalign-items(align)\n  // obsolete\n  if box in flex-version\n    vendor('box-align', -convert-alignment(align), ignore: ms official)\n\n  // new\n  if flex in flex-version\n    vendor('flex-align', -convert-alignment(align), only: ms)\n    vendor('align-items', arguments, only: webkit official)\n\nalign-self(align)\n  // WARN: Obsolete spec does not allow for overriding alignment on individual items.\n  if flex in flex-version\n    vendor('align-self', align, only: webkit official)\n    vendor('flex-item-align', -convert-alignment(align), only: ms)\n","/*\n * border: <color>\n * border: ...\n */\n\nborder(color, args...)\n  if color is a 'color'\n    border: 1px solid color args\n  else\n    border: arguments\n"],"sourceRoot":""}]);
+___CSS_LOADER_EXPORT___.push([module.id, ".geojs-map{position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;overflow:hidden}.geojs-map .geo-attribution{position:absolute;right:0;bottom:0;padding-right:5px;cursor:auto;font:11px/1.5 \"Helvetica Neue\",Arial,Helvetica,sans-serif;z-index:1001;background:rgba(255,255,255,0.7);clear:both;display:block;pointer-events:auto}.geojs-map .geo-attribution .geo-attribution-layer{padding-left:5px}.geojs-map .canvas-canvas{display:block;-webkit-transform-origin:0 0;-moz-transform-origin:0 0;-o-transform-origin:0 0;-ms-transform-origin:0 0;transform-origin:0 0}.geojs-map .webgl-canvas{display:block}.geojs-map .geojs-layer{position:absolute;width:100%;height:100%;left:0;top:0;pointer-events:none}.geojs-map .geojs-layer.active:not(.hidden) > *{pointer-events:auto}.geojs-map .geojs-layer.hidden{display:none}.geojs-map .geojs-layer.hidden[renderer=\"webgl\"]{display:inherit}.geojs-map .geo-tile-layer{-webkit-transform-origin:0 0;-moz-transform-origin:0 0;-o-transform-origin:0 0;-ms-transform-origin:0 0;transform-origin:0 0;line-height:0;font-size:0}.geojs-map.annotation-input{cursor:crosshair}.geojs-map.annotation-input.annotation-intersect{cursor:url(" + ___CSS_LOADER_URL_REPLACEMENT_0___ + ") 12 12,crosshair}.geojs-map.annotation-input.annotation-difference{cursor:url(" + ___CSS_LOADER_URL_REPLACEMENT_1___ + ") 12 12,crosshair}.geojs-map.annotation-input.annotation-union{cursor:url(" + ___CSS_LOADER_URL_REPLACEMENT_2___ + ") 12 12,crosshair}.geojs-map.annotation-input.annotation-xor{cursor:url(" + ___CSS_LOADER_URL_REPLACEMENT_3___ + ") 12 12,crosshair}.geojs-map.highlight-focus:after{content:\"\";display:block;position:absolute;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;left:0;top:0;right:0;bottom:0;border:3px solid Highlight;opacity:1;-ms-filter:none;filter:none;-webkit-transition:opacity 0s;-moz-transition:opacity 0s;-o-transition:opacity 0s;-ms-transition:opacity 0s;transition:opacity 0s;visibility:hidden}.geojs-map.highlight-focus:focus:after{visibility:visible;-webkit-transition:opacity 2.5s ease-in;-moz-transition:opacity 2.5s ease-in;-o-transition:opacity 2.5s ease-in;-ms-transition:opacity 2.5s ease-in;transition:opacity 2.5s ease-in;opacity:0;-ms-filter:\"progid:DXImageTransform.Microsoft.Alpha(Opacity=0)\";filter:alpha(opacity=0)}.geo-tile-container{position:absolute}.geo-tile-container.crop{overflow:hidden}", "",{"version":3,"sources":["webpack://./main.styl","webpack://./../node_modules/nib/lib/nib/vendor.styl","webpack://./../node_modules/nib/lib/nib/overflow.styl","webpack://./../node_modules/nib/lib/nib/flex.styl","webpack://./../node_modules/nib/lib/nib/border.styl"],"names":[],"mappings":"AAEA,WACE,iBAAS,CCwCO,wBAAG,CAAH,qBAAG,CAAH,oBAAG,CARN,gBAAG,CChBd,eAAU,CFZZ,4BACE,iBAAS,CACT,OAAM,CACN,QAAO,CACP,iBAAc,CC4ed,WAAO,CD1eP,yDAA8B,CAC9B,YAAQ,CC6dR,gCAAW,CD3dX,UAAM,CGMN,aAAS,CHJT,mBAAe,CAEf,mDACE,gBAAa,CAEjB,0BGDE,aAAS,CFqBK,4BAAG,CAAH,yBAAG,CAAH,uBAAG,CAAH,wBAAG,CARN,oBAAG,CDThB,yBGJE,aAAS,CHOX,wBACE,iBAAS,CACT,UAAM,CACN,WAAO,CACP,MAAK,CACL,KAAI,CACJ,mBAAe,CAEb,gDACE,mBAAe,CACnB,+BGjBA,YAAS,CHmBT,iDGnBA,eAAS,CHsBX,2BCDgB,4BAAG,CAAH,yBAAG,CAAH,uBAAG,CAAH,wBAAG,CARN,oBAAG,CDWd,aAAY,CACZ,WAAU,CAEZ,4BCscE,gBAAO,CDpcP,iDCocA,8DAAO,CDlcP,kDCkcA,8DAAO,CDhcP,6CCgcA,8DAAO,CD9bP,2CC8bA,8DAAO,CD1bP,iCACE,UAAQ,CGxCV,aAAS,CH0CP,iBAAS,CCrBG,6BAAG,CAAH,0BAAG,CARN,qBAAG,CD+BZ,MAAK,CACL,KAAI,CACJ,OAAM,CACN,QAAO,CI5DT,0BAAQ,CH4PV,SAAS,CAQH,eAAY,CACZ,WAAQ,CArOE,6BAAG,CAAH,0BAAG,CAAH,wBAAG,CAAH,yBAAG,CARN,qBAAG,CD0CZ,iBAAW,CACb,uCACE,kBAAW,CCpCC,uCAAG,CAAH,oCAAG,CAAH,kCAAG,CAAH,mCAAG,CARN,+BAAG,CAoOhB,SAAS,CAWH,+DAAyE,CACzE,uBAAiC,CDhMzC,oBACE,iBAAS,CACT,yBEhEE,eAAU","sourcesContent":["@import '~nib/index.styl'\n\n.geojs-map\n  position relative\n  user-select none\n  overflow hidden\n\n  .geo-attribution\n    position absolute\n    right 0\n    bottom 0\n    padding-right 5px\n    cursor auto\n    font 11px/1.5 \"Helvetica Neue\", Arial, Helvetica, sans-serif\n    z-index 1001\n    background rgba(255,255,255,0.7)\n    clear both\n    display block\n    pointer-events auto\n\n    .geo-attribution-layer\n      padding-left 5px\n\n  .canvas-canvas\n    display block\n    transform-origin 0px 0px\n  .webgl-canvas\n    display block\n\n  .geojs-layer\n    position absolute\n    width 100%\n    height 100%\n    left 0\n    top 0\n    pointer-events none\n    &.active:not(.hidden)\n      > *\n        pointer-events auto\n    &.hidden\n      display none\n    &.hidden[renderer=\"webgl\"]\n      display inherit\n\n  .geo-tile-layer\n    transform-origin 0px 0px\n    line-height 0\n    font-size 0\n\n  &.annotation-input\n    cursor crosshair\n    &.annotation-intersect\n      cursor embedurl(\"./css/cursor-crosshair-intersect.svg\") 12 12,crosshair\n    &.annotation-difference\n      cursor embedurl(\"./css/cursor-crosshair-difference.svg\") 12 12,crosshair\n    &.annotation-union\n      cursor embedurl(\"./css/cursor-crosshair-union.svg\") 12 12,crosshair\n    &.annotation-xor\n      cursor embedurl(\"./css/cursor-crosshair-xor.svg\") 12 12,crosshair\n\n  &.highlight-focus\n    &:after\n      content \"\"\n      display block\n      position absolute\n      box-sizing border-box\n      left 0px\n      top 0px\n      right 0px\n      bottom 0px\n      // Highlight is technically a css2 color.  We may need to specify it\n      // explicitly.  #3B66A6 seems close\n      border 3px solid Highlight\n      opacity 1\n      transition opacity 0s\n      visibility hidden\n    &:focus:after\n      visibility visible\n      transition opacity 2.5s ease-in\n      opacity 0\n\n.geo-tile-container\n  position absolute\n  &.crop\n    overflow hidden\n","use('../nodes/vendor-helpers.js')\n@import 'config'\n\n/*\n * Alias \"nowrap\" as \"no-wrap\".\n */\n\nno-wrap = unquote('nowrap')\n\n/*\n * Helper to find out if a given value is a width\n */\n\nis-width(val)\n  if auto == val\n    return true\n  else if val && 'unit' == type(val)\n    // Stylus does not short circuit so we need to perform this as a distinct\n    // operation to prevent errors\n    return '' != unit(val)\n  return false\n\n/*\n * Vendor support for the given prop / arguments, optionally specifying the\n * only prefixes to utilize, or those which should be ignored.\n */\n\nvendor(prop, args, only = null, ignore = null, vendor-property = true)\n  need_normalize = !vendor-property or prop in ('transition' 'transition-property' 'border-image' 'border-image-slice')\n  for prefix in vendor-prefixes\n    unless (only and !(prefix in only)) or (ignore and prefix in ignore)\n      if official == prefix\n        if need_normalize\n          {prop}: normalize(prop,('%s' % args))\n        else\n          {prop}: args\n      else\n        newprop = prop\n        newprop = '-' + prefix + '-' + prop if vendor-property\n\n        if need_normalize\n          {newprop}: normalize(prop,('%s' % args),prefix)\n        else\n          {newprop}: args\n/*\n * Vendorize the given value.\n */\n\nvendor-value(arg, only = null, ignore = null)\n  prop = current-property[0]\n  for prefix in vendor-prefixes\n    unless (only and !(prefix in only)) or (ignore and prefix in ignore) or official == prefix\n      add-property(prop, '-%s-%s' % (prefix arg))\n  arg\n\n/*\n * Vendor \"box-shadow\" support.\n */\n\nbox-shadow()\n  vendor('box-shadow', arguments, only: webkit official)\n\n/*\n * Vendor \"user-select\" support.\n */\n\nuser-select()\n  vendor('user-select', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"column-count\" support.\n */\n\ncolumn-count()\n  vendor('column-count', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-gap\" support.\n */\n\ncolumn-gap()\n  vendor('column-gap', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-rule\" support.\n */\n\ncolumn-rule()\n  vendor('column-rule', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-rule-color\" support.\n */\n\ncolumn-rule-color()\n  vendor('column-rule-color', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-rule-width\" support.\n */\n\ncolumn-rule-width()\n  vendor('column-rule-width', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-rule-style\" support.\n */\n\ncolumn-rule-style()\n  vendor('column-rule-style', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-width\" support.\n */\n\ncolumn-width()\n  vendor('column-width', arguments, only: webkit moz official)\n\n/*\n * Vendor \"column-span\" support.\n */\n\ncolumn-span()\n  vendor('column-span', arguments, only: webkit official)\n\n/*\n * Vendor \"column-fill\" support.\n */\n\ncolumn-fill()\n  vendor('column-fill', arguments, only: moz official)\n\n/*\n * Legacy syntax support for background-clip and background-origin\n */\n\nlegacy-bg-values(property, args)\n  legacy_args = ()\n  importance = unquote('')\n  for subargs in args\n    for arg in subargs\n      if arg in (border-box padding-box content-box)\n        arg = unquote('border')  if arg == border-box\n        arg = unquote('padding') if arg == padding-box\n        arg = unquote('content') if arg == content-box\n      if arg != '!important'\n        push(legacy_args,arg)\n      else\n        importance = !important\n  vendor(property, unquote(join(', ',legacy_args)) importance, only: moz webkit)\n\n/*\n * Vendor \"background-clip\" support.\n */\n\nbackground-clip()\n  if arguments[0] == text\n    vendor('background-clip', arguments, only: webkit)\n  else\n    legacy-bg-values('background-clip', arguments)\n    background-clip: arguments\n\n/*\n * Vendor \"background-origin\" support.\n */\n\nbackground-origin()\n  legacy-bg-values('background-origin', arguments)\n  background-origin: arguments\n\n/*\n * Vendor \"transform\" support.\n */\n\ntransform()\n  vendor('transform', arguments)\n\n/*\n * Vendor \"transform-origin\" support.\n */\ntransform-origin()\n    vendor('transform-origin', arguments)\n\n/*\n * Vendor \"transform-style\" support.\n */\n\ntransform-style()\n  vendor('transform-style', arguments)\n\n/*\n * Vendor \"border-image\" support.\n */\n\nborder-image()\n  vendor('border-image', arguments, only: webkit moz o official)\n\n/*\n * Vendor \"transition\" support.\n */\n\ntransition()\n  vendor('transition', arguments)\n\n/*\n * Vendor \"transition-property\" support.\n */\n\ntransition-property()\n  vendor('transition-property', arguments)\n\n/*\n * Vendor \"transition-duration\" support.\n */\n\ntransition-duration()\n  vendor('transition-duration', arguments)\n\n/*\n * Vendor \"transition-timing-function\" support.\n */\n\ntransition-timing-function()\n  vendor('transition-timing-function', arguments)\n\n/*\n * Vendor \"transition-delay\" support.\n */\n\ntransition-delay()\n  vendor('transition-delay', arguments)\n\n/*\n * Vendor \"backface-visibility\" support.\n */\n\nbackface-visibility()\n  vendor('backface-visibility', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"perspective\" support.\n */\n\nperspective()\n  if mixin\n    vendor('perspective', arguments, only: webkit moz ms official)\n  else\n    'perspective(%s)' % arguments\n\n/*\n * Vendor \"perspective-origin\" support.\n */\n\nperspective-origin()\n  vendor('perspective-origin', arguments, only: webkit moz ms official)\n\n/*\n * Opacity with conditional IE support.\n */\n\nopacity(n, args...)\n  opacity: n args\n  if support-for-ie\n    if n == inherit or n == initial\n      -ms-filter: n args\n      filter: n args\n    else\n      val = round(n * 100)\n      if val == 100\n        -ms-filter: none args\n        filter: none args\n      else\n        -ms-filter: '\"progid:DXImageTransform.Microsoft.Alpha(Opacity=%s)\"' % val args\n        filter: 'alpha(opacity=%s)' % val args\n\n/*\n * Vendor \"text-size-adjust\"\n */\n\ntext-size-adjust()\n  vendor('text-size-adjust', arguments)\n\n/*\n * Alias the \"white-space\" property.\n */\n\nwhitespace()\n  white-space: arguments\n\n/*\n * Vendor \"box-sizing\" support.\n */\n\nbox-sizing()\n  vendor('box-sizing', arguments, only: webkit moz official)\n\n/*\n * Vendor \"box-orient\" support.\n */\n\nbox-orient()\n  vendor('box-orient', arguments, only: webkit moz official)\n\n/*\n * Vendor \"box-flex-group\" support.\n */\n\nbox-flex-group()\n  vendor('box-flex-group', arguments, only: webkit moz official)\n\n/*\n * Vendor \"box-ordinal-group\" support.\n */\n\nbox-ordinal-group()\n  vendor('box-ordinal-group', arguments, only: webkit moz ms official)\n\n\n/*\n * Vendor \"box-align\" support.\n */\n\nbox-align()\n  vendor('box-align', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"box-pack\" support.\n */\n\nbox-pack()\n  vendor('box-pack', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"box-direction\" support.\n */\n\nbox-direction()\n  vendor('box-direction', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"animation\" support.\n */\n\nanimation()\n  vendor('animation', arguments)\n\n\n/*\n * Vendor \"animation-name\" support.\n */\n\nanimation-name()\n  vendor('animation-name', arguments)\n\n/*\n * Vendor \"animation-duration\" support.\n */\n\nanimation-duration()\n  vendor('animation-duration', arguments)\n\n/*\n * Vendor \"animation-delay\" support.\n */\n\nanimation-delay()\n  vendor('animation-delay', arguments)\n\n/*\n * Vendor \"animation-direction\" support.\n */\n\nanimation-direction()\n  vendor('animation-direction', arguments)\n\n/*\n * Vendor \"animation-iteration-count\" support.\n */\n\nanimation-iteration-count()\n  vendor('animation-iteration-count', arguments)\n\n/*\n * Vendor \"animation-timing-function\" support.\n */\n\nanimation-timing-function()\n  vendor('animation-timing-function', arguments)\n\n/*\n * Vendor \"animation-play-state\" support.\n */\n\nanimation-play-state()\n  vendor('animation-play-state', arguments)\n\n/*\n * Vendor \"animation-fill-mode\" support.\n */\n\nanimation-fill-mode()\n  vendor('animation-fill-mode', arguments)\n\n/*\n * Vendor \"hyphens\" support.\n */\n\nhyphens()\n  vendor('hyphens', arguments, only: webkit moz ms official)\n\n/*\n * Vendor \"appearance\" support.\n */\n\nappearance()\n  vendor('appearance', arguments, only: webkit moz official)\n\n/*\n * Vendor \"tab-size\" support.\n */\n\ntab-size()\n  vendor('tab-size', arguments, only: moz o official)\n\n/*\n * Vendor \"overflow-scrolling\" support.\n */\n\noverflow-scrolling()\n  vendor('overflow-scrolling', arguments, only: webkit official)\n\n/*\n * Vendor \"text-overflow\" support, , -o- for opera 9.* - 10.*\n */\n\ntext-overflow()\n  vendor('text-overflow', arguments, only: official o)\n\n/*\n * Vendor \"text-size-adjust\" support.\n */\ntext-size-adjust()\n  vendor('text-size-adjust', arguments, only: official webkit ms)\n\n/*\n * Vendor \"font-smoothing\" support, webkit only.\n */\nfont-smoothing()\n  vendor('font-smoothing', arguments, only: webkit)\n\n\n/**\n * Vendor input-placeholder/placeholder support.\n *\n * Examples:\n *    // Default syntax\n *    body\n *      placeholder(color #333, font-weight normal)\n *\n *    // The comma is important\n *    .placeholder-red\n *      placeholder(color red,)\n *\n *    // We can pass a function\n *    green-placeholder()\n *      color green\n *    .placeholder-green\n *      placeholder(green-placeholder)\n *\n *    // We can pass a hash\n *    textarea\n *      placeholder((font-style italic) (font-weight bold) (padding '4px 10px'))\n */\nplaceholder()\n  for v in ':-webkit-input' '-moz' ':-moz' '-ms-input'\n    &:{v}-placeholder\n      for pair in arguments\n        if typeof(pair) == 'function'\n          pair()\n        else if pair is not null && pair[0] is not null\n          {pair[0]}: type(pair[1]) == 'string' ? s(pair[1]) : pair[1]\ninput-placeholder = placeholder\n\n/*\n * Vendor background support (gradients).\n */\n\nbackground()\n  if match('-gradient\\(', ''+arguments)\n    vendor('background', arguments, vendor-property: false)\n  else\n    background arguments\n\nbackground-image()\n  if match('-gradient\\(', ''+arguments)\n    vendor('background-image', arguments, vendor-property: false)\n  else\n    background-image arguments\n\ncursor()\n  if match('-gradient\\(', ''+arguments)\n    vendor('cursor', arguments, vendor-property: false)\n  else\n    cursor arguments\n\nlist-style()\n  if match('-gradient\\(', ''+arguments)\n    vendor('list-style', arguments, vendor-property: false)\n  else\n    list-style arguments\n\nlist-style-image()\n  if match('-gradient\\(', ''+arguments)\n    vendor('list-style-image', arguments, vendor-property: false)\n  else\n    list-style-image arguments\n","/*\n * Overflow utility. Maps to regular overflow, and adds an ellipsis value.\n *\n * Synopsis:\n *\n *   overflow: <type>\n *\n * Examples:\n *\n *     overflow: auto\n *     overflow: hidden\n *     overflow: ellipsis\n *\n */\n\noverflow()\n  if arguments[0] == ellipsis\n    ellipsis()\n  else\n    overflow: arguments\n","/*\n * Vendor \"display: flex\" support with fallback to obsolete versions.\n */\n\nflex-version ?= box flex\n\n//\n// 1. Display values\n//    - http://www.w3.org/TR/css3-flexbox/#flex-containers\n//\ndisplay(type, args...)\n  if flex == type || inline-flex == type\n    if box in flex-version\n      if flex == type\n        display: -ms-flexbox args\n        display: vendor-value(box args, only: moz webkit)\n      else\n        display: -ms-inline-flexbox args\n        display: vendor-value(inline-box args, only: moz webkit)\n    if flex in flex-version\n      display: vendor-value(arguments, only: webkit official) // overwrites old webkit\n  else\n    display: arguments\n\n/*\n * New syntax for browsers like Google Chrome.\n * Plus a translation to the old syntax, if possible.\n */\n\n\n//\n// 5. Ordering and Orientation\n//    - http://www.w3.org/TR/css3-flexbox/#ordering-and-orientation\n//\n-flex-obsolete-direction(direction)\n  if box in flex-version\n    if row-reverse == direction || column-reverse == direction\n      vendor('box-direction', reverse, ignore: ms official)\n\n    if row == direction || row-reverse == direction\n      vendor('box-orient', horizontal, ignore: ms official)\n    else if column == direction || column-reverse == direction\n      vendor('box-orient', vertical, ignore: ms official)\n\n-flex-obsolete-wrap(value)\n  if box in flex-version\n    // WARN: wrap-reverse does not have a box equivalent. This will render in different manners\n    //    on box vs. flex values.\n    if 'wrap' == value || wrap-reverse == value\n      vendor('box-lines', multiple, ignore: ms official)\n    else if nowrap == value\n      vendor('box-lines', single, ignore: ms official)\n\nflex-direction(direction)\n  // obsolete\n  -flex-obsolete-direction(direction)\n\n  // new\n  if flex in flex-version\n    vendor('flex-direction', arguments, only: webkit ms official)\n\nflex-wrap(value)\n  // obsolete\n  -flex-obsolete-wrap(value)\n\n  if flex in flex-version\n    vendor('flex-wrap', arguments, only: webkit ms official)\n\nflex-flow()\n  // obsolete\n  -flex-obsolete-direction(arguments[0])\n  -flex-obsolete-direction(arguments[1])\n  -flex-obsolete-wrap(arguments[0])\n  -flex-obsolete-wrap(arguments[1])\n\n  // new\n  if flex in flex-version\n    vendor('flex-flow', arguments, only: webkit ms official)\n\n\norder()\n  // obsolete\n  if box in flex-version\n    vendor('box-ordinal-group', arguments, ignore: ms official)\n\n  // new\n  if flex in flex-version\n    vendor('flex-order', arguments, only: ms)\n    vendor('order', arguments, only: webkit official)\n\n\n//\n// 7. Flexibility\n//    - http://www.w3.org/TR/css3-flexbox/#flexibility\n//\nflex-grow(growth)\n  // obsolete\n  if box in flex-version\n    vendor('box-flex', growth)\n\n  // new\n  if flex in flex-version\n    vendor('flex-grow', arguments, only: webkit official)\n\nflex-basis()\n  if flex in flex-version\n    vendor('flex-basis', arguments, only: webkit official)\n\nflex-shrink()\n  if flex in flex-version\n    vendor('flex-shrink', arguments, only: webkit official)\n\nflex(growth)\n\n  // obsolete\n  if box in flex-version\n    shrink = 1\n\n    if none == growth || initial == growth\n      // Well known values\n      shrink = 0 if none == growth\n      growth = 0\n    else if is-width(growth) == true\n      // Basis is defined as the first parameter\n      growth = arguments[1] || 0\n      shrink = arguments[2] if 3 <= length(arguments)\n    else if arguments[1] && is-width(arguments[1]) == false\n      // Growth is first and shrink is second\n      shrink = arguments[1]\n\n    // Since we can't make the distinction between growing and shrinking in the box model, take\n    // the one that provides the most flexibility.\n    vendor('box-flex', max(growth, shrink), ignore: ms)\n\n  // new\n  if flex in flex-version\n    vendor('flex', arguments, only: webkit ms official)\n\n\n// converts the justification alignment\n-convert-justify(align)\n  if flex-start == align\n    return start\n  else if flex-end == align\n    return end\n  else if space-around == align\n    return distribute\n  else if space-between == align\n    return justify\n  else\n    return align\n\n//\n// 8. Alignment\n//    - http://www.w3.org/TR/css3-flexbox/#alignment\n//\njustify-content(align)\n  // obsolete\n  if box in flex-version\n    vendor('box-pack', -convert-justify(align), ignore: ms official)\n\n  // new\n  if flex in flex-version\n    vendor('flex-pack', -convert-justify(align), only: ms)\n    vendor('justify-content', align, only: webkit official)\n\nalign-content(align)\n  // WARN: Obsolete spec does not allow for adjustment here\n  if flex in flex-version\n    vendor('flex-line-pack', -convert-justify(align), only: ms)\n    vendor('align-content', align, only: webkit official)\n\n// converts alignment from 'flex' to normal value\n-convert-alignment(align)\n  if flex-start == align\n    return start\n  else if flex-end == align\n    return end\n  else\n    return align\n\nalign-items(align)\n  // obsolete\n  if box in flex-version\n    vendor('box-align', -convert-alignment(align), ignore: ms official)\n\n  // new\n  if flex in flex-version\n    vendor('flex-align', -convert-alignment(align), only: ms)\n    vendor('align-items', arguments, only: webkit official)\n\nalign-self(align)\n  // WARN: Obsolete spec does not allow for overriding alignment on individual items.\n  if flex in flex-version\n    vendor('align-self', align, only: webkit official)\n    vendor('flex-item-align', -convert-alignment(align), only: ms)\n","/*\n * border: <color>\n * border: ...\n */\n\nborder(color, args...)\n  if color is a 'color'\n    border: 1px solid color args\n  else\n    border: arguments\n"],"sourceRoot":""}]);
 // Exports
 /* harmony default export */ __webpack_exports__["Z"] = (___CSS_LOADER_EXPORT___);
 
@@ -45475,6 +46588,42 @@ module.exports = function (cssWithMappingToString) {
 
 /***/ }),
 
+/***/ 1678:
+/***/ (function(module) {
+
+"use strict";
+
+
+module.exports = function (url, options) {
+  if (!options) {
+    options = {};
+  }
+
+  if (!url) {
+    return url;
+  }
+
+  url = String(url.__esModule ? url.default : url); // If url is already wrapped in quotes, remove them
+
+  if (/^['"].*['"]$/.test(url)) {
+    url = url.slice(1, -1);
+  }
+
+  if (options.hash) {
+    url += options.hash;
+  } // Should url be wrapped?
+  // See https://drafts.csswg.org/css-values-3/#urls
+
+
+  if (/["'() \t\n]|(%20)/.test(url) || options.needQuotes) {
+    return "\"".concat(url.replace(/"/g, '\\"').replace(/\n/g, "\\n"), "\"");
+  }
+
+  return url;
+};
+
+/***/ }),
+
 /***/ 559:
 /***/ (function(module) {
 
@@ -74518,6 +75667,1671 @@ var __WEBPACK_AMD_DEFINE_RESULT__;/*global define:false */
 }) (typeof window !== 'undefined' ? window : null, typeof  window !== 'undefined' ? document : null);
 
 
+/***/ }),
+
+/***/ 3291:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+/*
+ * @copyright 2016 Sean Connelly (@voidqk), http://syntheti.cc
+ * @license MIT
+ * @preserve Project Home: https://github.com/voidqk/polybooljs
+ */
+
+var BuildLog = __webpack_require__(1009);
+var Epsilon = __webpack_require__(1835);
+var Intersecter = __webpack_require__(7671);
+var SegmentChainer = __webpack_require__(9048);
+var SegmentSelector = __webpack_require__(571);
+var GeoJSON = __webpack_require__(3928);
+
+var buildLog = false;
+var epsilon = Epsilon();
+
+var PolyBool;
+PolyBool = {
+	// getter/setter for buildLog
+	buildLog: function(bl){
+		if (bl === true)
+			buildLog = BuildLog();
+		else if (bl === false)
+			buildLog = false;
+		return buildLog === false ? false : buildLog.list;
+	},
+	// getter/setter for epsilon
+	epsilon: function(v){
+		return epsilon.epsilon(v);
+	},
+
+	// core API
+	segments: function(poly){
+		var i = Intersecter(true, epsilon, buildLog);
+		poly.regions.forEach(i.addRegion);
+		return {
+			segments: i.calculate(poly.inverted),
+			inverted: poly.inverted
+		};
+	},
+	combine: function(segments1, segments2){
+		var i3 = Intersecter(false, epsilon, buildLog);
+		return {
+			combined: i3.calculate(
+				segments1.segments, segments1.inverted,
+				segments2.segments, segments2.inverted
+			),
+			inverted1: segments1.inverted,
+			inverted2: segments2.inverted
+		};
+	},
+	selectUnion: function(combined){
+		return {
+			segments: SegmentSelector.union(combined.combined, buildLog),
+			inverted: combined.inverted1 || combined.inverted2
+		}
+	},
+	selectIntersect: function(combined){
+		return {
+			segments: SegmentSelector.intersect(combined.combined, buildLog),
+			inverted: combined.inverted1 && combined.inverted2
+		}
+	},
+	selectDifference: function(combined){
+		return {
+			segments: SegmentSelector.difference(combined.combined, buildLog),
+			inverted: combined.inverted1 && !combined.inverted2
+		}
+	},
+	selectDifferenceRev: function(combined){
+		return {
+			segments: SegmentSelector.differenceRev(combined.combined, buildLog),
+			inverted: !combined.inverted1 && combined.inverted2
+		}
+	},
+	selectXor: function(combined){
+		return {
+			segments: SegmentSelector.xor(combined.combined, buildLog),
+			inverted: combined.inverted1 !== combined.inverted2
+		}
+	},
+	polygon: function(segments){
+		return {
+			regions: SegmentChainer(segments.segments, epsilon, buildLog),
+			inverted: segments.inverted
+		};
+	},
+
+	// GeoJSON converters
+	polygonFromGeoJSON: function(geojson){
+		return GeoJSON.toPolygon(PolyBool, geojson);
+	},
+	polygonToGeoJSON: function(poly){
+		return GeoJSON.fromPolygon(PolyBool, epsilon, poly);
+	},
+
+	// helper functions for common operations
+	union: function(poly1, poly2){
+		return operate(poly1, poly2, PolyBool.selectUnion);
+	},
+	intersect: function(poly1, poly2){
+		return operate(poly1, poly2, PolyBool.selectIntersect);
+	},
+	difference: function(poly1, poly2){
+		return operate(poly1, poly2, PolyBool.selectDifference);
+	},
+	differenceRev: function(poly1, poly2){
+		return operate(poly1, poly2, PolyBool.selectDifferenceRev);
+	},
+	xor: function(poly1, poly2){
+		return operate(poly1, poly2, PolyBool.selectXor);
+	}
+};
+
+function operate(poly1, poly2, selector){
+	var seg1 = PolyBool.segments(poly1);
+	var seg2 = PolyBool.segments(poly2);
+	var comb = PolyBool.combine(seg1, seg2);
+	var seg3 = selector(comb);
+	return PolyBool.polygon(seg3);
+}
+
+if (typeof window === 'object')
+	window.PolyBool = PolyBool;
+
+module.exports = PolyBool;
+
+
+/***/ }),
+
+/***/ 1009:
+/***/ (function(module) {
+
+// (c) Copyright 2016, Sean Connelly (@voidqk), http://syntheti.cc
+// MIT License
+// Project Home: https://github.com/voidqk/polybooljs
+
+//
+// used strictly for logging the processing of the algorithm... only useful if you intend on
+// looking under the covers (for pretty UI's or debugging)
+//
+
+function BuildLog(){
+	var my;
+	var nextSegmentId = 0;
+	var curVert = false;
+
+	function push(type, data){
+		my.list.push({
+			type: type,
+			data: data ? JSON.parse(JSON.stringify(data)) : void 0
+		});
+		return my;
+	}
+
+	my = {
+		list: [],
+		segmentId: function(){
+			return nextSegmentId++;
+		},
+		checkIntersection: function(seg1, seg2){
+			return push('check', { seg1: seg1, seg2: seg2 });
+		},
+		segmentChop: function(seg, end){
+			push('div_seg', { seg: seg, pt: end });
+			return push('chop', { seg: seg, pt: end });
+		},
+		statusRemove: function(seg){
+			return push('pop_seg', { seg: seg });
+		},
+		segmentUpdate: function(seg){
+			return push('seg_update', { seg: seg });
+		},
+		segmentNew: function(seg, primary){
+			return push('new_seg', { seg: seg, primary: primary });
+		},
+		segmentRemove: function(seg){
+			return push('rem_seg', { seg: seg });
+		},
+		tempStatus: function(seg, above, below){
+			return push('temp_status', { seg: seg, above: above, below: below });
+		},
+		rewind: function(seg){
+			return push('rewind', { seg: seg });
+		},
+		status: function(seg, above, below){
+			return push('status', { seg: seg, above: above, below: below });
+		},
+		vert: function(x){
+			if (x === curVert)
+				return my;
+			curVert = x;
+			return push('vert', { x: x });
+		},
+		log: function(data){
+			if (typeof data !== 'string')
+				data = JSON.stringify(data, false, '  ');
+			return push('log', { txt: data });
+		},
+		reset: function(){
+			return push('reset');
+		},
+		selected: function(segs){
+			return push('selected', { segs: segs });
+		},
+		chainStart: function(seg){
+			return push('chain_start', { seg: seg });
+		},
+		chainRemoveHead: function(index, pt){
+			return push('chain_rem_head', { index: index, pt: pt });
+		},
+		chainRemoveTail: function(index, pt){
+			return push('chain_rem_tail', { index: index, pt: pt });
+		},
+		chainNew: function(pt1, pt2){
+			return push('chain_new', { pt1: pt1, pt2: pt2 });
+		},
+		chainMatch: function(index){
+			return push('chain_match', { index: index });
+		},
+		chainClose: function(index){
+			return push('chain_close', { index: index });
+		},
+		chainAddHead: function(index, pt){
+			return push('chain_add_head', { index: index, pt: pt });
+		},
+		chainAddTail: function(index, pt){
+			return push('chain_add_tail', { index: index, pt: pt, });
+		},
+		chainConnect: function(index1, index2){
+			return push('chain_con', { index1: index1, index2: index2 });
+		},
+		chainReverse: function(index){
+			return push('chain_rev', { index: index });
+		},
+		chainJoin: function(index1, index2){
+			return push('chain_join', { index1: index1, index2: index2 });
+		},
+		done: function(){
+			return push('done');
+		}
+	};
+	return my;
+}
+
+module.exports = BuildLog;
+
+
+/***/ }),
+
+/***/ 1835:
+/***/ (function(module) {
+
+// (c) Copyright 2016, Sean Connelly (@voidqk), http://syntheti.cc
+// MIT License
+// Project Home: https://github.com/voidqk/polybooljs
+
+//
+// provides the raw computation functions that takes epsilon into account
+//
+// zero is defined to be between (-epsilon, epsilon) exclusive
+//
+
+function Epsilon(eps){
+	if (typeof eps !== 'number')
+		eps = 0.0000000001; // sane default? sure why not
+	var my = {
+		epsilon: function(v){
+			if (typeof v === 'number')
+				eps = v;
+			return eps;
+		},
+		pointAboveOrOnLine: function(pt, left, right){
+			var Ax = left[0];
+			var Ay = left[1];
+			var Bx = right[0];
+			var By = right[1];
+			var Cx = pt[0];
+			var Cy = pt[1];
+			var ABx = Bx - Ax;
+			var ABy = By - Ay;
+			var AB = Math.sqrt(ABx * ABx + ABy * ABy);
+			// algebraic distance of 'pt' to ('left', 'right') line is:
+			// [ABx * (Cy - Ay) - ABy * (Cx - Ax)] / AB
+			return ABx * (Cy - Ay) - ABy * (Cx - Ax) >= -eps * AB;
+		},
+		pointBetween: function(p, left, right){
+			// p must be collinear with left->right
+			// returns false if p == left, p == right, or left == right
+			if (my.pointsSame(p, left) || my.pointsSame(p, right)) return false;
+			var d_py_ly = p[1] - left[1];
+			var d_rx_lx = right[0] - left[0];
+			var d_px_lx = p[0] - left[0];
+			var d_ry_ly = right[1] - left[1];
+
+			var dot = d_px_lx * d_rx_lx + d_py_ly * d_ry_ly;
+			// dot < 0 is p is to the left of 'left'
+			if (dot < 0) return false;
+			var sqlen = d_rx_lx * d_rx_lx + d_ry_ly * d_ry_ly;
+			// dot <= sqlen is p is to the left of 'right'
+			return dot <= sqlen;
+		},
+		pointsSameX: function(p1, p2){
+			return Math.abs(p1[0] - p2[0]) < eps;
+		},
+		pointsSameY: function(p1, p2){
+			return Math.abs(p1[1] - p2[1]) < eps;
+		},
+		pointsSame: function(p1, p2){
+			return my.pointsSameX(p1, p2) && my.pointsSameY(p1, p2);
+		},
+		pointsCompare: function(p1, p2){
+			// returns -1 if p1 is smaller, 1 if p2 is smaller, 0 if equal
+			if (my.pointsSameX(p1, p2))
+				return my.pointsSameY(p1, p2) ? 0 : (p1[1] < p2[1] ? -1 : 1);
+			return p1[0] < p2[0] ? -1 : 1;
+		},
+		pointsCollinear: function(pt1, pt2, pt3){
+			// does pt1->pt2->pt3 make a straight line?
+			// essentially this is just checking to see if the slope(pt1->pt2) === slope(pt2->pt3)
+			// if slopes are equal, then they must be collinear, because they share pt2
+			var dx1 = pt1[0] - pt2[0];
+			var dy1 = pt1[1] - pt2[1];
+			var dx2 = pt2[0] - pt3[0];
+			var dy2 = pt2[1] - pt3[1];
+			var n1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+			var n2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+			// Assuming det(u, v) = 0, we have:
+			// |det(u + u_err, v + v_err)| = |det(u + u_err, v + v_err) - det(u,v)|
+			// =|det(u, v_err) + det(u_err. v) + det(u_err, v_err)|
+			// <= |det(u, v_err)| + |det(u_err, v)| + |det(u_err, v_err)|
+			// <= N(u)N(v_err) + N(u_err)N(v) + N(u_err)N(v_err)
+			// <= eps * (N(u) + N(v) + eps)
+			// We have N(u) ~ N(u + u_err) and N(v) ~ N(v + v_err).
+			// Assuming eps << N(u) and eps << N(v), we end with:
+			// |det(u + u_err, v + v_err)| <= eps * (N(u + u_err) + N(v + v_err))
+			return Math.abs(dx1 * dy2 - dx2 * dy1) <= eps * (n1 + n2);
+		},
+		linesIntersect: function(a0, a1, b0, b1){
+			// returns false if the lines are coincident (e.g., parallel or on top of each other)
+			//
+			// returns an object if the lines intersect:
+			//   {
+			//     pt: [x, y],    where the intersection point is at
+			//     alongA: where intersection point is along A,
+			//     alongB: where intersection point is along B
+			//   }
+			//
+			//  alongA and alongB will each be one of: -2, -1, 0, 1, 2
+			//
+			//  with the following meaning:
+			//
+			//    -2   intersection point is before segment's first point
+			//    -1   intersection point is directly on segment's first point
+			//     0   intersection point is between segment's first and second points (exclusive)
+			//     1   intersection point is directly on segment's second point
+			//     2   intersection point is after segment's second point
+			var adx = a1[0] - a0[0];
+			var ady = a1[1] - a0[1];
+			var bdx = b1[0] - b0[0];
+			var bdy = b1[1] - b0[1];
+
+			var axb = adx * bdy - ady * bdx;
+			var n1 = Math.sqrt(adx * adx + ady * ady);
+			var n2 = Math.sqrt(bdx * bdx + bdy * bdy);
+			if (Math.abs(axb) <= eps * (n1 + n2))
+				return false; // lines are coincident
+
+			var dx = a0[0] - b0[0];
+			var dy = a0[1] - b0[1];
+
+			var A = (bdx * dy - bdy * dx) / axb;
+			var B = (adx * dy - ady * dx) / axb;
+			var pt = [
+				a0[0] + A * adx,
+				a0[1] + A * ady
+			];
+
+			var ret = {
+				alongA: 0,
+				alongB: 0,
+				pt: pt
+			};
+
+			// categorize where intersection point is along A and B
+			if (my.pointsSame(pt, a0))
+				ret.alongA = -1;
+			else if (my.pointsSame(pt, a1))
+				ret.alongA = 1;
+			else if (A < 0)
+				ret.alongA = -2;
+			else if (A > 1)
+				ret.alongA = 2;
+
+			if (my.pointsSame(pt, b0))
+				ret.alongB = -1;
+			else if (my.pointsSame(pt, b1))
+				ret.alongB = 1;
+			else if (B < 0)
+				ret.alongB = -2;
+			else if (B > 1)
+				ret.alongB = 2;
+
+			return ret;
+		},
+		pointInsideRegion: function(pt, region){
+			var x = pt[0];
+			var y = pt[1];
+			var last_x = region[region.length - 1][0];
+			var last_y = region[region.length - 1][1];
+			var inside = false;
+			for (var i = 0; i < region.length; i++){
+				var curr_x = region[i][0];
+				var curr_y = region[i][1];
+
+				// if y is between curr_y and last_y, and
+				// x is to the right of the boundary created by the line
+				if ((curr_y - y > eps) != (last_y - y > eps) &&
+					(last_x - curr_x) * (y - curr_y) / (last_y - curr_y) + curr_x - x > eps)
+					inside = !inside
+
+				last_x = curr_x;
+				last_y = curr_y;
+			}
+			return inside;
+		}
+	};
+	return my;
+}
+
+module.exports = Epsilon;
+
+
+/***/ }),
+
+/***/ 3928:
+/***/ (function(module) {
+
+// (c) Copyright 2017, Sean Connelly (@voidqk), http://syntheti.cc
+// MIT License
+// Project Home: https://github.com/voidqk/polybooljs
+
+//
+// convert between PolyBool polygon format and GeoJSON formats (Polygon and MultiPolygon)
+//
+
+var GeoJSON = {
+	// convert a GeoJSON object to a PolyBool polygon
+	toPolygon: function(PolyBool, geojson){
+
+		// converts list of LineString's to segments
+		function GeoPoly(coords){
+			// check for empty coords
+			if (coords.length <= 0)
+				return PolyBool.segments({ inverted: false, regions: [] });
+
+			// convert LineString to segments
+			function LineString(ls){
+				// remove tail which should be the same as head
+				var reg = ls.slice(0, ls.length - 1);
+				return PolyBool.segments({ inverted: false, regions: [reg] });
+			}
+
+			// the first LineString is considered the outside
+			var out = LineString(coords[0]);
+
+			// the rest of the LineStrings are considered interior holes, so subtract them from the
+			// current result
+			for (var i = 1; i < coords.length; i++)
+				out = PolyBool.selectDifference(PolyBool.combine(out, LineString(coords[i])));
+
+			return out;
+		}
+
+		if (geojson.type === 'Polygon'){
+			// single polygon, so just convert it and we're done
+			return PolyBool.polygon(GeoPoly(geojson.coordinates));
+		}
+		else if (geojson.type === 'MultiPolygon'){
+			// multiple polygons, so union all the polygons together
+			var out = PolyBool.segments({ inverted: false, regions: [] });
+			for (var i = 0; i < geojson.coordinates.length; i++)
+				out = PolyBool.selectUnion(PolyBool.combine(out, GeoPoly(geojson.coordinates[i])));
+			return PolyBool.polygon(out);
+		}
+		throw new Error('PolyBool: Cannot convert GeoJSON object to PolyBool polygon');
+	},
+
+	// convert a PolyBool polygon to a GeoJSON object
+	fromPolygon: function(PolyBool, eps, poly){
+		// make sure out polygon is clean
+		poly = PolyBool.polygon(PolyBool.segments(poly));
+
+		// test if r1 is inside r2
+		function regionInsideRegion(r1, r2){
+			// we're guaranteed no lines intersect (because the polygon is clean), but a vertex
+			// could be on the edge -- so we just average pt[0] and pt[1] to produce a point on the
+			// edge of the first line, which cannot be on an edge
+			return eps.pointInsideRegion([
+				(r1[0][0] + r1[1][0]) * 0.5,
+				(r1[0][1] + r1[1][1]) * 0.5
+			], r2);
+		}
+
+		// calculate inside heirarchy
+		//
+		//  _____________________   _______    roots -> A       -> F
+		// |          A          | |   F   |            |          |
+		// |  _______   _______  | |  ___  |            +-- B      +-- G
+		// | |   B   | |   C   | | | |   | |            |   |
+		// | |  ___  | |  ___  | | | |   | |            |   +-- D
+		// | | | D | | | | E | | | | | G | |            |
+		// | | |___| | | |___| | | | |   | |            +-- C
+		// | |_______| |_______| | | |___| |                |
+		// |_____________________| |_______|                +-- E
+
+		function newNode(region){
+			return {
+				region: region,
+				children: []
+			};
+		}
+
+		var roots = newNode(null);
+
+		function addChild(root, region){
+			// first check if we're inside any children
+			for (var i = 0; i < root.children.length; i++){
+				var child = root.children[i];
+				if (regionInsideRegion(region, child.region)){
+					// we are, so insert inside them instead
+					addChild(child, region);
+					return;
+				}
+			}
+
+			// not inside any children, so check to see if any children are inside us
+			var node = newNode(region);
+			for (var i = 0; i < root.children.length; i++){
+				var child = root.children[i];
+				if (regionInsideRegion(child.region, region)){
+					// oops... move the child beneath us, and remove them from root
+					node.children.push(child);
+					root.children.splice(i, 1);
+					i--;
+				}
+			}
+
+			// now we can add ourselves
+			root.children.push(node);
+		}
+
+		// add all regions to the root
+		for (var i = 0; i < poly.regions.length; i++){
+			var region = poly.regions[i];
+			if (region.length < 3) // regions must have at least 3 points (sanity check)
+				continue;
+			addChild(roots, region);
+		}
+
+		// with our heirarchy, we can distinguish between exterior borders, and interior holes
+		// the root nodes are exterior, children are interior, children's children are exterior,
+		// children's children's children are interior, etc
+
+		// while we're at it, exteriors are counter-clockwise, and interiors are clockwise
+
+		function forceWinding(region, clockwise){
+			// first, see if we're clockwise or counter-clockwise
+			// https://en.wikipedia.org/wiki/Shoelace_formula
+			var winding = 0;
+			var last_x = region[region.length - 1][0];
+			var last_y = region[region.length - 1][1];
+			var copy = [];
+			for (var i = 0; i < region.length; i++){
+				var curr_x = region[i][0];
+				var curr_y = region[i][1];
+				copy.push([curr_x, curr_y]); // create a copy while we're at it
+				winding += curr_y * last_x - curr_x * last_y;
+				last_x = curr_x;
+				last_y = curr_y;
+			}
+			// this assumes Cartesian coordinates (Y is positive going up)
+			var isclockwise = winding < 0;
+			if (isclockwise !== clockwise)
+				copy.reverse();
+			// while we're here, the last point must be the first point...
+			copy.push([copy[0][0], copy[0][1]]);
+			return copy;
+		}
+
+		var geopolys = [];
+
+		function addExterior(node){
+			var poly = [forceWinding(node.region, false)];
+			geopolys.push(poly);
+			// children of exteriors are interior
+			for (var i = 0; i < node.children.length; i++)
+				poly.push(getInterior(node.children[i]));
+		}
+
+		function getInterior(node){
+			// children of interiors are exterior
+			for (var i = 0; i < node.children.length; i++)
+				addExterior(node.children[i]);
+			// return the clockwise interior
+			return forceWinding(node.region, true);
+		}
+
+		// root nodes are exterior
+		for (var i = 0; i < roots.children.length; i++)
+			addExterior(roots.children[i]);
+
+		// lastly, construct the approrpriate GeoJSON object
+
+		if (geopolys.length <= 0) // empty GeoJSON Polygon
+			return { type: 'Polygon', coordinates: [] };
+		if (geopolys.length == 1) // use a GeoJSON Polygon
+			return { type: 'Polygon', coordinates: geopolys[0] };
+		return { // otherwise, use a GeoJSON MultiPolygon
+			type: 'MultiPolygon',
+			coordinates: geopolys
+		};
+	}
+};
+
+module.exports = GeoJSON;
+
+
+/***/ }),
+
+/***/ 7671:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+// (c) Copyright 2016, Sean Connelly (@voidqk), http://syntheti.cc
+// MIT License
+// Project Home: https://github.com/voidqk/polybooljs
+
+//
+// this is the core work-horse
+//
+
+var LinkedList = __webpack_require__(9186);
+
+function Intersecter(selfIntersection, eps, buildLog){
+	// selfIntersection is true/false depending on the phase of the overall algorithm
+
+	//
+	// segment creation
+	//
+
+	function segmentNew(start, end){
+		return {
+			id: buildLog ? buildLog.segmentId() : -1,
+			start: start,
+			end: end,
+			myFill: {
+				above: null, // is there fill above us?
+				below: null  // is there fill below us?
+			},
+			otherFill: null
+		};
+	}
+
+	function segmentCopy(start, end, seg){
+		return {
+			id: buildLog ? buildLog.segmentId() : -1,
+			start: start,
+			end: end,
+			myFill: {
+				above: seg.myFill.above,
+				below: seg.myFill.below
+			},
+			otherFill: null
+		};
+	}
+
+	//
+	// event logic
+	//
+
+	var event_root = LinkedList.create();
+
+	function eventCompare(p1_isStart, p1_1, p1_2, p2_isStart, p2_1, p2_2){
+		// compare the selected points first
+		var comp = eps.pointsCompare(p1_1, p2_1);
+		if (comp !== 0)
+			return comp;
+		// the selected points are the same
+
+		if (eps.pointsSame(p1_2, p2_2)) // if the non-selected points are the same too...
+			return 0; // then the segments are equal
+
+		if (p1_isStart !== p2_isStart) // if one is a start and the other isn't...
+			return p1_isStart ? 1 : -1; // favor the one that isn't the start
+
+		// otherwise, we'll have to calculate which one is below the other manually
+		return eps.pointAboveOrOnLine(p1_2,
+			p2_isStart ? p2_1 : p2_2, // order matters
+			p2_isStart ? p2_2 : p2_1
+		) ? 1 : -1;
+	}
+
+	function eventAdd(ev, other_pt){
+		event_root.insertBefore(ev, function(here){
+			// should ev be inserted before here?
+			var comp = eventCompare(
+				ev  .isStart, ev  .pt,      other_pt,
+				here.isStart, here.pt, here.other.pt
+			);
+			return comp < 0;
+		});
+	}
+
+	function eventAddSegmentStart(seg, primary){
+		var ev_start = LinkedList.node({
+			isStart: true,
+			pt: seg.start,
+			seg: seg,
+			primary: primary,
+			other: null,
+			status: null
+		});
+		eventAdd(ev_start, seg.end);
+		return ev_start;
+	}
+
+	function eventAddSegmentEnd(ev_start, seg, primary){
+		var ev_end = LinkedList.node({
+			isStart: false,
+			pt: seg.end,
+			seg: seg,
+			primary: primary,
+			other: ev_start,
+			status: null
+		});
+		ev_start.other = ev_end;
+		eventAdd(ev_end, ev_start.pt);
+	}
+
+	function eventAddSegment(seg, primary){
+		var ev_start = eventAddSegmentStart(seg, primary);
+		eventAddSegmentEnd(ev_start, seg, primary);
+		return ev_start;
+	}
+
+	function eventUpdateEnd(ev, end){
+		// slides an end backwards
+		//   (start)------------(end)    to:
+		//   (start)---(end)
+
+		if (buildLog)
+			buildLog.segmentChop(ev.seg, end);
+
+		ev.other.remove();
+		ev.seg.end = end;
+		ev.other.pt = end;
+		eventAdd(ev.other, ev.pt);
+	}
+
+	function eventDivide(ev, pt){
+		var ns = segmentCopy(pt, ev.seg.end, ev.seg);
+		eventUpdateEnd(ev, pt);
+		return eventAddSegment(ns, ev.primary);
+	}
+
+	function calculate(primaryPolyInverted, secondaryPolyInverted){
+		// if selfIntersection is true then there is no secondary polygon, so that isn't used
+
+		//
+		// status logic
+		//
+
+		var status_root = LinkedList.create();
+
+		function statusCompare(ev1, ev2){
+			var a1 = ev1.seg.start;
+			var a2 = ev1.seg.end;
+			var b1 = ev2.seg.start;
+			var b2 = ev2.seg.end;
+
+			if (eps.pointsCollinear(a1, b1, b2)){
+				if (eps.pointsCollinear(a2, b1, b2))
+					return 1;//eventCompare(true, a1, a2, true, b1, b2);
+				return eps.pointAboveOrOnLine(a2, b1, b2) ? 1 : -1;
+			}
+			return eps.pointAboveOrOnLine(a1, b1, b2) ? 1 : -1;
+		}
+
+		function statusFindSurrounding(ev){
+			return status_root.findTransition(function(here){
+				var comp = statusCompare(ev, here.ev);
+				return comp > 0;
+			});
+		}
+
+		function checkIntersection(ev1, ev2){
+			// returns the segment equal to ev1, or false if nothing equal
+
+			var seg1 = ev1.seg;
+			var seg2 = ev2.seg;
+			var a1 = seg1.start;
+			var a2 = seg1.end;
+			var b1 = seg2.start;
+			var b2 = seg2.end;
+
+			if (buildLog)
+				buildLog.checkIntersection(seg1, seg2);
+
+			var i = eps.linesIntersect(a1, a2, b1, b2);
+
+			if (i === false){
+				// segments are parallel or coincident
+
+				// if points aren't collinear, then the segments are parallel, so no intersections
+				if (!eps.pointsCollinear(a1, a2, b1))
+					return false;
+				// otherwise, segments are on top of each other somehow (aka coincident)
+
+				if (eps.pointsSame(a1, b2) || eps.pointsSame(a2, b1))
+					return false; // segments touch at endpoints... no intersection
+
+				var a1_equ_b1 = eps.pointsSame(a1, b1);
+				var a2_equ_b2 = eps.pointsSame(a2, b2);
+
+				if (a1_equ_b1 && a2_equ_b2)
+					return ev2; // segments are exactly equal
+
+				var a1_between = !a1_equ_b1 && eps.pointBetween(a1, b1, b2);
+				var a2_between = !a2_equ_b2 && eps.pointBetween(a2, b1, b2);
+
+				// handy for debugging:
+				// buildLog.log({
+				//	a1_equ_b1: a1_equ_b1,
+				//	a2_equ_b2: a2_equ_b2,
+				//	a1_between: a1_between,
+				//	a2_between: a2_between
+				// });
+
+				if (a1_equ_b1){
+					if (a2_between){
+						//  (a1)---(a2)
+						//  (b1)----------(b2)
+						eventDivide(ev2, a2);
+					}
+					else{
+						//  (a1)----------(a2)
+						//  (b1)---(b2)
+						eventDivide(ev1, b2);
+					}
+					return ev2;
+				}
+				else if (a1_between){
+					if (!a2_equ_b2){
+						// make a2 equal to b2
+						if (a2_between){
+							//         (a1)---(a2)
+							//  (b1)-----------------(b2)
+							eventDivide(ev2, a2);
+						}
+						else{
+							//         (a1)----------(a2)
+							//  (b1)----------(b2)
+							eventDivide(ev1, b2);
+						}
+					}
+
+					//         (a1)---(a2)
+					//  (b1)----------(b2)
+					eventDivide(ev2, a1);
+				}
+			}
+			else{
+				// otherwise, lines intersect at i.pt, which may or may not be between the endpoints
+
+				// is A divided between its endpoints? (exclusive)
+				if (i.alongA === 0){
+					if (i.alongB === -1) // yes, at exactly b1
+						eventDivide(ev1, b1);
+					else if (i.alongB === 0) // yes, somewhere between B's endpoints
+						eventDivide(ev1, i.pt);
+					else if (i.alongB === 1) // yes, at exactly b2
+						eventDivide(ev1, b2);
+				}
+
+				// is B divided between its endpoints? (exclusive)
+				if (i.alongB === 0){
+					if (i.alongA === -1) // yes, at exactly a1
+						eventDivide(ev2, a1);
+					else if (i.alongA === 0) // yes, somewhere between A's endpoints (exclusive)
+						eventDivide(ev2, i.pt);
+					else if (i.alongA === 1) // yes, at exactly a2
+						eventDivide(ev2, a2);
+				}
+			}
+			return false;
+		}
+
+		//
+		// main event loop
+		//
+		var segments = [];
+		while (!event_root.isEmpty()){
+			var ev = event_root.getHead();
+
+			if (buildLog)
+				buildLog.vert(ev.pt[0]);
+
+			if (ev.isStart){
+
+				if (buildLog)
+					buildLog.segmentNew(ev.seg, ev.primary);
+
+				var surrounding = statusFindSurrounding(ev);
+				var above = surrounding.before ? surrounding.before.ev : null;
+				var below = surrounding.after ? surrounding.after.ev : null;
+
+				if (buildLog){
+					buildLog.tempStatus(
+						ev.seg,
+						above ? above.seg : false,
+						below ? below.seg : false
+					);
+				}
+
+				function checkBothIntersections(){
+					if (above){
+						var eve = checkIntersection(ev, above);
+						if (eve)
+							return eve;
+					}
+					if (below)
+						return checkIntersection(ev, below);
+					return false;
+				}
+
+				var eve = checkBothIntersections();
+				if (eve){
+					// ev and eve are equal
+					// we'll keep eve and throw away ev
+
+					// merge ev.seg's fill information into eve.seg
+
+					if (selfIntersection){
+						var toggle; // are we a toggling edge?
+						if (ev.seg.myFill.below === null)
+							toggle = true;
+						else
+							toggle = ev.seg.myFill.above !== ev.seg.myFill.below;
+
+						// merge two segments that belong to the same polygon
+						// think of this as sandwiching two segments together, where `eve.seg` is
+						// the bottom -- this will cause the above fill flag to toggle
+						if (toggle)
+							eve.seg.myFill.above = !eve.seg.myFill.above;
+					}
+					else{
+						// merge two segments that belong to different polygons
+						// each segment has distinct knowledge, so no special logic is needed
+						// note that this can only happen once per segment in this phase, because we
+						// are guaranteed that all self-intersections are gone
+						eve.seg.otherFill = ev.seg.myFill;
+					}
+
+					if (buildLog)
+						buildLog.segmentUpdate(eve.seg);
+
+					ev.other.remove();
+					ev.remove();
+				}
+
+				if (event_root.getHead() !== ev){
+					// something was inserted before us in the event queue, so loop back around and
+					// process it before continuing
+					if (buildLog)
+						buildLog.rewind(ev.seg);
+					continue;
+				}
+
+				//
+				// calculate fill flags
+				//
+				if (selfIntersection){
+					var toggle; // are we a toggling edge?
+					if (ev.seg.myFill.below === null) // if we are a new segment...
+						toggle = true; // then we toggle
+					else // we are a segment that has previous knowledge from a division
+						toggle = ev.seg.myFill.above !== ev.seg.myFill.below; // calculate toggle
+
+					// next, calculate whether we are filled below us
+					if (!below){ // if nothing is below us...
+						// we are filled below us if the polygon is inverted
+						ev.seg.myFill.below = primaryPolyInverted;
+					}
+					else{
+						// otherwise, we know the answer -- it's the same if whatever is below
+						// us is filled above it
+						ev.seg.myFill.below = below.seg.myFill.above;
+					}
+
+					// since now we know if we're filled below us, we can calculate whether
+					// we're filled above us by applying toggle to whatever is below us
+					if (toggle)
+						ev.seg.myFill.above = !ev.seg.myFill.below;
+					else
+						ev.seg.myFill.above = ev.seg.myFill.below;
+				}
+				else{
+					// now we fill in any missing transition information, since we are all-knowing
+					// at this point
+
+					if (ev.seg.otherFill === null){
+						// if we don't have other information, then we need to figure out if we're
+						// inside the other polygon
+						var inside;
+						if (!below){
+							// if nothing is below us, then we're inside if the other polygon is
+							// inverted
+							inside =
+								ev.primary ? secondaryPolyInverted : primaryPolyInverted;
+						}
+						else{ // otherwise, something is below us
+							// so copy the below segment's other polygon's above
+							if (ev.primary === below.primary)
+								inside = below.seg.otherFill.above;
+							else
+								inside = below.seg.myFill.above;
+						}
+						ev.seg.otherFill = {
+							above: inside,
+							below: inside
+						};
+					}
+				}
+
+				if (buildLog){
+					buildLog.status(
+						ev.seg,
+						above ? above.seg : false,
+						below ? below.seg : false
+					);
+				}
+
+				// insert the status and remember it for later removal
+				ev.other.status = surrounding.insert(LinkedList.node({ ev: ev }));
+			}
+			else{
+				var st = ev.status;
+
+				if (st === null){
+					throw new Error('PolyBool: Zero-length segment detected; your epsilon is ' +
+						'probably too small or too large');
+				}
+
+				// removing the status will create two new adjacent edges, so we'll need to check
+				// for those
+				if (status_root.exists(st.prev) && status_root.exists(st.next))
+					checkIntersection(st.prev.ev, st.next.ev);
+
+				if (buildLog)
+					buildLog.statusRemove(st.ev.seg);
+
+				// remove the status
+				st.remove();
+
+				// if we've reached this point, we've calculated everything there is to know, so
+				// save the segment for reporting
+				if (!ev.primary){
+					// make sure `seg.myFill` actually points to the primary polygon though
+					var s = ev.seg.myFill;
+					ev.seg.myFill = ev.seg.otherFill;
+					ev.seg.otherFill = s;
+				}
+				segments.push(ev.seg);
+			}
+
+			// remove the event and continue
+			event_root.getHead().remove();
+		}
+
+		if (buildLog)
+			buildLog.done();
+
+		return segments;
+	}
+
+	// return the appropriate API depending on what we're doing
+	if (!selfIntersection){
+		// performing combination of polygons, so only deal with already-processed segments
+		return {
+			calculate: function(segments1, inverted1, segments2, inverted2){
+				// segmentsX come from the self-intersection API, or this API
+				// invertedX is whether we treat that list of segments as an inverted polygon or not
+				// returns segments that can be used for further operations
+				segments1.forEach(function(seg){
+					eventAddSegment(segmentCopy(seg.start, seg.end, seg), true);
+				});
+				segments2.forEach(function(seg){
+					eventAddSegment(segmentCopy(seg.start, seg.end, seg), false);
+				});
+				return calculate(inverted1, inverted2);
+			}
+		};
+	}
+
+	// otherwise, performing self-intersection, so deal with regions
+	return {
+		addRegion: function(region){
+			// regions are a list of points:
+			//  [ [0, 0], [100, 0], [50, 100] ]
+			// you can add multiple regions before running calculate
+			var pt1;
+			var pt2 = region[region.length - 1];
+			for (var i = 0; i < region.length; i++){
+				pt1 = pt2;
+				pt2 = region[i];
+
+				var forward = eps.pointsCompare(pt1, pt2);
+				if (forward === 0) // points are equal, so we have a zero-length segment
+					continue; // just skip it
+
+				eventAddSegment(
+					segmentNew(
+						forward < 0 ? pt1 : pt2,
+						forward < 0 ? pt2 : pt1
+					),
+					true
+				);
+			}
+		},
+		calculate: function(inverted){
+			// is the polygon inverted?
+			// returns segments
+			return calculate(inverted, false);
+		}
+	};
+}
+
+module.exports = Intersecter;
+
+
+/***/ }),
+
+/***/ 9186:
+/***/ (function(module) {
+
+// (c) Copyright 2016, Sean Connelly (@voidqk), http://syntheti.cc
+// MIT License
+// Project Home: https://github.com/voidqk/polybooljs
+
+//
+// simple linked list implementation that allows you to traverse down nodes and save positions
+//
+
+var LinkedList = {
+	create: function(){
+		var my = {
+			root: { root: true, next: null },
+			exists: function(node){
+				if (node === null || node === my.root)
+					return false;
+				return true;
+			},
+			isEmpty: function(){
+				return my.root.next === null;
+			},
+			getHead: function(){
+				return my.root.next;
+			},
+			insertBefore: function(node, check){
+				var last = my.root;
+				var here = my.root.next;
+				while (here !== null){
+					if (check(here)){
+						node.prev = here.prev;
+						node.next = here;
+						here.prev.next = node;
+						here.prev = node;
+						return;
+					}
+					last = here;
+					here = here.next;
+				}
+				last.next = node;
+				node.prev = last;
+				node.next = null;
+			},
+			findTransition: function(check){
+				var prev = my.root;
+				var here = my.root.next;
+				while (here !== null){
+					if (check(here))
+						break;
+					prev = here;
+					here = here.next;
+				}
+				return {
+					before: prev === my.root ? null : prev,
+					after: here,
+					insert: function(node){
+						node.prev = prev;
+						node.next = here;
+						prev.next = node;
+						if (here !== null)
+							here.prev = node;
+						return node;
+					}
+				};
+			}
+		};
+		return my;
+	},
+	node: function(data){
+		data.prev = null;
+		data.next = null;
+		data.remove = function(){
+			data.prev.next = data.next;
+			if (data.next)
+				data.next.prev = data.prev;
+			data.prev = null;
+			data.next = null;
+		};
+		return data;
+	}
+};
+
+module.exports = LinkedList;
+
+
+/***/ }),
+
+/***/ 9048:
+/***/ (function(module) {
+
+// (c) Copyright 2016, Sean Connelly (@voidqk), http://syntheti.cc
+// MIT License
+// Project Home: https://github.com/voidqk/polybooljs
+
+//
+// converts a list of segments into a list of regions, while also removing unnecessary verticies
+//
+
+function SegmentChainer(segments, eps, buildLog){
+	var chains = [];
+	var regions = [];
+
+	segments.forEach(function(seg){
+		var pt1 = seg.start;
+		var pt2 = seg.end;
+		if (eps.pointsSame(pt1, pt2)){
+			console.warn('PolyBool: Warning: Zero-length segment detected; your epsilon is ' +
+				'probably too small or too large');
+			return;
+		}
+
+		if (buildLog)
+			buildLog.chainStart(seg);
+
+		// search for two chains that this segment matches
+		var first_match = {
+			index: 0,
+			matches_head: false,
+			matches_pt1: false
+		};
+		var second_match = {
+			index: 0,
+			matches_head: false,
+			matches_pt1: false
+		};
+		var next_match = first_match;
+		function setMatch(index, matches_head, matches_pt1){
+			// return true if we've matched twice
+			next_match.index = index;
+			next_match.matches_head = matches_head;
+			next_match.matches_pt1 = matches_pt1;
+			if (next_match === first_match){
+				next_match = second_match;
+				return false;
+			}
+			next_match = null;
+			return true; // we've matched twice, we're done here
+		}
+		for (var i = 0; i < chains.length; i++){
+			var chain = chains[i];
+			var head  = chain[0];
+			var head2 = chain[1];
+			var tail  = chain[chain.length - 1];
+			var tail2 = chain[chain.length - 2];
+			if (eps.pointsSame(head, pt1)){
+				if (setMatch(i, true, true))
+					break;
+			}
+			else if (eps.pointsSame(head, pt2)){
+				if (setMatch(i, true, false))
+					break;
+			}
+			else if (eps.pointsSame(tail, pt1)){
+				if (setMatch(i, false, true))
+					break;
+			}
+			else if (eps.pointsSame(tail, pt2)){
+				if (setMatch(i, false, false))
+					break;
+			}
+		}
+
+		if (next_match === first_match){
+			// we didn't match anything, so create a new chain
+			chains.push([ pt1, pt2 ]);
+			if (buildLog)
+				buildLog.chainNew(pt1, pt2);
+			return;
+		}
+
+		if (next_match === second_match){
+			// we matched a single chain
+
+			if (buildLog)
+				buildLog.chainMatch(first_match.index);
+
+			// add the other point to the apporpriate end, and check to see if we've closed the
+			// chain into a loop
+
+			var index = first_match.index;
+			var pt = first_match.matches_pt1 ? pt2 : pt1; // if we matched pt1, then we add pt2, etc
+			var addToHead = first_match.matches_head; // if we matched at head, then add to the head
+
+			var chain = chains[index];
+			var grow  = addToHead ? chain[0] : chain[chain.length - 1];
+			var grow2 = addToHead ? chain[1] : chain[chain.length - 2];
+			var oppo  = addToHead ? chain[chain.length - 1] : chain[0];
+			var oppo2 = addToHead ? chain[chain.length - 2] : chain[1];
+
+			if (eps.pointsCollinear(grow2, grow, pt)){
+				// grow isn't needed because it's directly between grow2 and pt:
+				// grow2 ---grow---> pt
+				if (addToHead){
+					if (buildLog)
+						buildLog.chainRemoveHead(first_match.index, pt);
+					chain.shift();
+				}
+				else{
+					if (buildLog)
+						buildLog.chainRemoveTail(first_match.index, pt);
+					chain.pop();
+				}
+				grow = grow2; // old grow is gone... new grow is what grow2 was
+			}
+
+			if (eps.pointsSame(oppo, pt)){
+				// we're closing the loop, so remove chain from chains
+				chains.splice(index, 1);
+
+				if (eps.pointsCollinear(oppo2, oppo, grow)){
+					// oppo isn't needed because it's directly between oppo2 and grow:
+					// oppo2 ---oppo--->grow
+					if (addToHead){
+						if (buildLog)
+							buildLog.chainRemoveTail(first_match.index, grow);
+						chain.pop();
+					}
+					else{
+						if (buildLog)
+							buildLog.chainRemoveHead(first_match.index, grow);
+						chain.shift();
+					}
+				}
+
+				if (buildLog)
+					buildLog.chainClose(first_match.index);
+
+				// we have a closed chain!
+				regions.push(chain);
+				return;
+			}
+
+			// not closing a loop, so just add it to the apporpriate side
+			if (addToHead){
+				if (buildLog)
+					buildLog.chainAddHead(first_match.index, pt);
+				chain.unshift(pt);
+			}
+			else{
+				if (buildLog)
+					buildLog.chainAddTail(first_match.index, pt);
+				chain.push(pt);
+			}
+			return;
+		}
+
+		// otherwise, we matched two chains, so we need to combine those chains together
+
+		function reverseChain(index){
+			if (buildLog)
+				buildLog.chainReverse(index);
+			chains[index].reverse(); // gee, that's easy
+		}
+
+		function appendChain(index1, index2){
+			// index1 gets index2 appended to it, and index2 is removed
+			var chain1 = chains[index1];
+			var chain2 = chains[index2];
+			var tail  = chain1[chain1.length - 1];
+			var tail2 = chain1[chain1.length - 2];
+			var head  = chain2[0];
+			var head2 = chain2[1];
+
+			if (eps.pointsCollinear(tail2, tail, head)){
+				// tail isn't needed because it's directly between tail2 and head
+				// tail2 ---tail---> head
+				if (buildLog)
+					buildLog.chainRemoveTail(index1, tail);
+				chain1.pop();
+				tail = tail2; // old tail is gone... new tail is what tail2 was
+			}
+
+			if (eps.pointsCollinear(tail, head, head2)){
+				// head isn't needed because it's directly between tail and head2
+				// tail ---head---> head2
+				if (buildLog)
+					buildLog.chainRemoveHead(index2, head);
+				chain2.shift();
+			}
+
+			if (buildLog)
+				buildLog.chainJoin(index1, index2);
+			chains[index1] = chain1.concat(chain2);
+			chains.splice(index2, 1);
+		}
+
+		var F = first_match.index;
+		var S = second_match.index;
+
+		if (buildLog)
+			buildLog.chainConnect(F, S);
+
+		var reverseF = chains[F].length < chains[S].length; // reverse the shorter chain, if needed
+		if (first_match.matches_head){
+			if (second_match.matches_head){
+				if (reverseF){
+					// <<<< F <<<< --- >>>> S >>>>
+					reverseChain(F);
+					// >>>> F >>>> --- >>>> S >>>>
+					appendChain(F, S);
+				}
+				else{
+					// <<<< F <<<< --- >>>> S >>>>
+					reverseChain(S);
+					// <<<< F <<<< --- <<<< S <<<<   logically same as:
+					// >>>> S >>>> --- >>>> F >>>>
+					appendChain(S, F);
+				}
+			}
+			else{
+				// <<<< F <<<< --- <<<< S <<<<   logically same as:
+				// >>>> S >>>> --- >>>> F >>>>
+				appendChain(S, F);
+			}
+		}
+		else{
+			if (second_match.matches_head){
+				// >>>> F >>>> --- >>>> S >>>>
+				appendChain(F, S);
+			}
+			else{
+				if (reverseF){
+					// >>>> F >>>> --- <<<< S <<<<
+					reverseChain(F);
+					// <<<< F <<<< --- <<<< S <<<<   logically same as:
+					// >>>> S >>>> --- >>>> F >>>>
+					appendChain(S, F);
+				}
+				else{
+					// >>>> F >>>> --- <<<< S <<<<
+					reverseChain(S);
+					// >>>> F >>>> --- >>>> S >>>>
+					appendChain(F, S);
+				}
+			}
+		}
+	});
+
+	return regions;
+}
+
+module.exports = SegmentChainer;
+
+
+/***/ }),
+
+/***/ 571:
+/***/ (function(module) {
+
+// (c) Copyright 2016, Sean Connelly (@voidqk), http://syntheti.cc
+// MIT License
+// Project Home: https://github.com/voidqk/polybooljs
+
+//
+// filter a list of segments based on boolean operations
+//
+
+function select(segments, selection, buildLog){
+	var result = [];
+	segments.forEach(function(seg){
+		var index =
+			(seg.myFill.above ? 8 : 0) +
+			(seg.myFill.below ? 4 : 0) +
+			((seg.otherFill && seg.otherFill.above) ? 2 : 0) +
+			((seg.otherFill && seg.otherFill.below) ? 1 : 0);
+		if (selection[index] !== 0){
+			// copy the segment to the results, while also calculating the fill status
+			result.push({
+				id: buildLog ? buildLog.segmentId() : -1,
+				start: seg.start,
+				end: seg.end,
+				myFill: {
+					above: selection[index] === 1, // 1 if filled above
+					below: selection[index] === 2  // 2 if filled below
+				},
+				otherFill: null
+			});
+		}
+	});
+
+	if (buildLog)
+		buildLog.selected(result);
+
+	return result;
+}
+
+var SegmentSelector = {
+	union: function(segments, buildLog){ // primary | secondary
+		// above1 below1 above2 below2    Keep?               Value
+		//    0      0      0      0   =>   no                  0
+		//    0      0      0      1   =>   yes filled below    2
+		//    0      0      1      0   =>   yes filled above    1
+		//    0      0      1      1   =>   no                  0
+		//    0      1      0      0   =>   yes filled below    2
+		//    0      1      0      1   =>   yes filled below    2
+		//    0      1      1      0   =>   no                  0
+		//    0      1      1      1   =>   no                  0
+		//    1      0      0      0   =>   yes filled above    1
+		//    1      0      0      1   =>   no                  0
+		//    1      0      1      0   =>   yes filled above    1
+		//    1      0      1      1   =>   no                  0
+		//    1      1      0      0   =>   no                  0
+		//    1      1      0      1   =>   no                  0
+		//    1      1      1      0   =>   no                  0
+		//    1      1      1      1   =>   no                  0
+		return select(segments, [
+			0, 2, 1, 0,
+			2, 2, 0, 0,
+			1, 0, 1, 0,
+			0, 0, 0, 0
+		], buildLog);
+	},
+	intersect: function(segments, buildLog){ // primary & secondary
+		// above1 below1 above2 below2    Keep?               Value
+		//    0      0      0      0   =>   no                  0
+		//    0      0      0      1   =>   no                  0
+		//    0      0      1      0   =>   no                  0
+		//    0      0      1      1   =>   no                  0
+		//    0      1      0      0   =>   no                  0
+		//    0      1      0      1   =>   yes filled below    2
+		//    0      1      1      0   =>   no                  0
+		//    0      1      1      1   =>   yes filled below    2
+		//    1      0      0      0   =>   no                  0
+		//    1      0      0      1   =>   no                  0
+		//    1      0      1      0   =>   yes filled above    1
+		//    1      0      1      1   =>   yes filled above    1
+		//    1      1      0      0   =>   no                  0
+		//    1      1      0      1   =>   yes filled below    2
+		//    1      1      1      0   =>   yes filled above    1
+		//    1      1      1      1   =>   no                  0
+		return select(segments, [
+			0, 0, 0, 0,
+			0, 2, 0, 2,
+			0, 0, 1, 1,
+			0, 2, 1, 0
+		], buildLog);
+	},
+	difference: function(segments, buildLog){ // primary - secondary
+		// above1 below1 above2 below2    Keep?               Value
+		//    0      0      0      0   =>   no                  0
+		//    0      0      0      1   =>   no                  0
+		//    0      0      1      0   =>   no                  0
+		//    0      0      1      1   =>   no                  0
+		//    0      1      0      0   =>   yes filled below    2
+		//    0      1      0      1   =>   no                  0
+		//    0      1      1      0   =>   yes filled below    2
+		//    0      1      1      1   =>   no                  0
+		//    1      0      0      0   =>   yes filled above    1
+		//    1      0      0      1   =>   yes filled above    1
+		//    1      0      1      0   =>   no                  0
+		//    1      0      1      1   =>   no                  0
+		//    1      1      0      0   =>   no                  0
+		//    1      1      0      1   =>   yes filled above    1
+		//    1      1      1      0   =>   yes filled below    2
+		//    1      1      1      1   =>   no                  0
+		return select(segments, [
+			0, 0, 0, 0,
+			2, 0, 2, 0,
+			1, 1, 0, 0,
+			0, 1, 2, 0
+		], buildLog);
+	},
+	differenceRev: function(segments, buildLog){ // secondary - primary
+		// above1 below1 above2 below2    Keep?               Value
+		//    0      0      0      0   =>   no                  0
+		//    0      0      0      1   =>   yes filled below    2
+		//    0      0      1      0   =>   yes filled above    1
+		//    0      0      1      1   =>   no                  0
+		//    0      1      0      0   =>   no                  0
+		//    0      1      0      1   =>   no                  0
+		//    0      1      1      0   =>   yes filled above    1
+		//    0      1      1      1   =>   yes filled above    1
+		//    1      0      0      0   =>   no                  0
+		//    1      0      0      1   =>   yes filled below    2
+		//    1      0      1      0   =>   no                  0
+		//    1      0      1      1   =>   yes filled below    2
+		//    1      1      0      0   =>   no                  0
+		//    1      1      0      1   =>   no                  0
+		//    1      1      1      0   =>   no                  0
+		//    1      1      1      1   =>   no                  0
+		return select(segments, [
+			0, 2, 1, 0,
+			0, 0, 1, 1,
+			0, 2, 0, 2,
+			0, 0, 0, 0
+		], buildLog);
+	},
+	xor: function(segments, buildLog){ // primary ^ secondary
+		// above1 below1 above2 below2    Keep?               Value
+		//    0      0      0      0   =>   no                  0
+		//    0      0      0      1   =>   yes filled below    2
+		//    0      0      1      0   =>   yes filled above    1
+		//    0      0      1      1   =>   no                  0
+		//    0      1      0      0   =>   yes filled below    2
+		//    0      1      0      1   =>   no                  0
+		//    0      1      1      0   =>   no                  0
+		//    0      1      1      1   =>   yes filled above    1
+		//    1      0      0      0   =>   yes filled above    1
+		//    1      0      0      1   =>   no                  0
+		//    1      0      1      0   =>   no                  0
+		//    1      0      1      1   =>   yes filled below    2
+		//    1      1      0      0   =>   no                  0
+		//    1      1      0      1   =>   yes filled above    1
+		//    1      1      1      0   =>   yes filled below    2
+		//    1      1      1      1   =>   no                  0
+		return select(segments, [
+			0, 2, 1, 0,
+			2, 0, 0, 1,
+			1, 0, 0, 2,
+			0, 1, 2, 0
+		], buildLog);
+	}
+};
+
+module.exports = SegmentSelector;
+
+
 /***/ }),
 
 /***/ 6886:
@@ -83957,6 +86771,38 @@ module.exports = styleTagTransform;
 
 /***/ }),
 
+/***/ 4144:
+/***/ (function(module) {
+
+"use strict";
+module.exports = "data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIj4KPHBhdGggZD0iTTAsMTFsMTEsMGwwLC0xMWwyLDBsMCwxMWwxMSwwbDAsMmwtMTEsMGwwLDExbC0yLDBsMCwtMTFsLTExLDB6IiBmaWxsPSJibGFjayIgc3Ryb2tlLXdpZHRoPSIwIi8+CjxwYXRoIGQ9Ik0yNCwyN2w4LDBsMCwybC04LDB6IiBmaWxsPSJibGFjayIgc3Ryb2tlLXdpZHRoPSIwIi8+Cjwvc3ZnPgo=";
+
+/***/ }),
+
+/***/ 237:
+/***/ (function(module) {
+
+"use strict";
+module.exports = "data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIj4KPHBhdGggZD0iTTAsMTFsMTEsMGwwLC0xMWwyLDBsMCwxMWwxMSwwbDAsMmwtMTEsMGwwLDExbC0yLDBsMCwtMTFsLTExLDB6IiBmaWxsPSJibGFjayIgc3Ryb2tlLXdpZHRoPSIwIi8+CjxwYXRoIGQ9Ik0yNCwyN2wzLDBsMCwtM2wyLDBsMCwzbDMsMGwwLDJsLTMsMGwwLDNsLTIsMGwwLC0zbC0zLDB6IiBmaWxsPSJibGFjayIgc3Ryb2tlLXdpZHRoPSIwIi8+Cjwvc3ZnPgo=";
+
+/***/ }),
+
+/***/ 3554:
+/***/ (function(module) {
+
+"use strict";
+module.exports = "data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIj4KPHBhdGggZD0iTTAsMTFsMTEsMGwwLC0xMWwyLDBsMCwxMWwxMSwwbDAsMmwtMTEsMGwwLDExbC0yLDBsMCwtMTFsLTExLDB6IiBmaWxsPSJibGFjayIgc3Ryb2tlLXdpZHRoPSIwIi8+CjxwYXRoIGQ9Ik0yNCwzMmwwLC00YTQsNCwwLDAsMSw4LDBsMCw0bC0yLDBsMCwtNGEyLDIsMCwwLDAsLTQsMGwwLDR6IiBmaWxsPSJibGFjayIgc3Ryb2tlLXdpZHRoPSIwIi8+Cjwvc3ZnPgo=";
+
+/***/ }),
+
+/***/ 9490:
+/***/ (function(module) {
+
+"use strict";
+module.exports = "data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIj4KPHBhdGggZD0iTTAsMTFsMTEsMGwwLC0xMWwyLDBsMCwxMWwxMSwwbDAsMmwtMTEsMGwwLDExbC0yLDBsMCwtMTFsLTExLDB6IiBmaWxsPSJibGFjayIgc3Ryb2tlLXdpZHRoPSIwIi8+CjxwYXRoIGQ9Ik0zMiwzMC41OWwtMS40MSwxLjQxbC0yLjEyLC0yLjEybC0yLjEyLDIuMTJsLTEuNDEsLTEuNDFsMi4xMiwtMi4xMmwtMi4xMiwtMi4xMmwxLjQxLC0xLjQxbDIuMTIsMi4xMmwyLjEyLC0yLjEybDEuNDEsMS40MWwtMi4xMiwyLjEyeiIgZmlsbD0iYmxhY2siIHN0cm9rZS13aWR0aD0iMCIvPgo8L3N2Zz4K";
+
+/***/ }),
+
 /***/ 9990:
 /***/ (function(module) {
 
@@ -84013,6 +86859,9 @@ module.exports = __WEBPACK_EXTERNAL_MODULE__3877__;
 /******/ 		return module.exports;
 /******/ 	}
 /******/ 	
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = __webpack_modules__;
+/******/ 	
 /************************************************************************/
 /******/ 	/* webpack/runtime/compat get default export */
 /******/ 	!function() {
@@ -84066,6 +86915,38 @@ module.exports = __WEBPACK_EXTERNAL_MODULE__3877__;
 /******/ 		};
 /******/ 	}();
 /******/ 	
+/******/ 	/* webpack/runtime/jsonp chunk loading */
+/******/ 	!function() {
+/******/ 		__webpack_require__.b = document.baseURI || self.location.href;
+/******/ 		
+/******/ 		// object to store loaded and loading chunks
+/******/ 		// undefined = chunk not loaded, null = chunk preloaded/prefetched
+/******/ 		// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
+/******/ 		var installedChunks = {
+/******/ 			387: 0,
+/******/ 			93: 0
+/******/ 		};
+/******/ 		
+/******/ 		// no chunk on demand loading
+/******/ 		
+/******/ 		// no prefetching
+/******/ 		
+/******/ 		// no preloaded
+/******/ 		
+/******/ 		// no HMR
+/******/ 		
+/******/ 		// no HMR manifest
+/******/ 		
+/******/ 		// no on chunks loaded
+/******/ 		
+/******/ 		// no jsonp function
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/nonce */
+/******/ 	!function() {
+/******/ 		__webpack_require__.nc = undefined;
+/******/ 	}();
+/******/ 	
 /************************************************************************/
 /******/ 	
 /******/ 	// startup