@mapbox/mapbox-gl-style-spec 13.12.0 → 13.13.0

package/dist/index.js

@@ -1006,7 +1006,7 @@
   	},
   	"symbol-sort-key": {
   		type: "number",
-  		doc: "Sorts features in ascending order based on this value. Features with a higher sort key will appear above features with a lower sort key when they overlap. Features with a lower sort key will have priority over other features when doing placement.",
+  		doc: "Sorts features in ascending order based on this value. Features with lower sort keys are drawn and placed first.  When `icon-allow-overlap` or `text-allow-overlap` is `false`, features with a lower sort key will have priority during placement. When `icon-allow-overlap` or `text-allow-overlap` is set to `true`, features with a higher sort key will overlap over features with a lower sort key.",
   		"sdk-support": {
   			"basic functionality": {
   				js: "0.53.0",
@@ -3373,6 +3373,15 @@
   				}
   			}
   		},
+  		within: {
+  			doc: "Returns `true` if the feature being evaluated is inside the pre-defined geometry boundary, `false` otherwise. The expression has one argument which must be a valid GeoJSON Polygon/Multi-Polygon object. The expression only evaluates on `Point` or `LineString` feature. For `Point` feature, The expression will return false if any point of the feature is on the boundary or outside the boundary. For `LineString` feature, the expression will return false if the line is fully outside the boundary, or the line is partially intersecting the boundary, which means either part of the line is outside of the boundary, or end point of the line lies on the boundary.",
+  			group: "Decision",
+  			"sdk-support": {
+  				"basic functionality": {
+  					js: "1.9.0"
+  				}
+  			}
+  		},
   		"is-supported-script": {
   			doc: "Returns `true` if the input string is expected to render legibly. Returns `false` if the input string contains sections that cannot be rendered without potential loss of meaning (e.g. Indic scripts that require complex text shaping, or right-to-left scripts if the the `mapbox-gl-rtl-text` plugin is not in use in Mapbox GL JS).",
   			group: "String",
@@ -8020,6 +8029,9 @@
       return this.name;
   };
   ResolvedImage.fromString = function fromString(name) {
+      if (!name) {
+          return null;
+      }
       return new ResolvedImage({
           name: name,
           available: false
@@ -8166,8 +8178,8 @@
   };
   Literal.prototype.eachChild = function eachChild() {
   };
-  Literal.prototype.possibleOutputs = function possibleOutputs() {
-      return [this.value];
+  Literal.prototype.outputDefined = function outputDefined() {
+      return true;
   };
   Literal.prototype.serialize = function serialize() {
       if (this.type.kind === 'array' || this.type.kind === 'object') {
@@ -8258,11 +8270,10 @@
   Assertion.prototype.eachChild = function eachChild(fn) {
       this.args.forEach(fn);
   };
-  Assertion.prototype.possibleOutputs = function possibleOutputs() {
-      var ref;
-      return (ref = []).concat.apply(ref, this.args.map(function (arg) {
-          return arg.possibleOutputs();
-      }));
+  Assertion.prototype.outputDefined = function outputDefined() {
+      return this.args.every(function (arg) {
+          return arg.outputDefined();
+      });
   };
   Assertion.prototype.serialize = function serialize() {
       var type = this.type;
@@ -8370,8 +8381,8 @@
           }
       }
   };
-  FormatExpression.prototype.possibleOutputs = function possibleOutputs() {
-      return [undefined];
+  FormatExpression.prototype.outputDefined = function outputDefined() {
+      return false;
   };
   FormatExpression.prototype.serialize = function serialize() {
       var serialized = ['format'];
@@ -8409,20 +8420,17 @@
   };
   ImageExpression.prototype.evaluate = function evaluate(ctx) {
       var evaluatedImageName = this.input.evaluate(ctx);
-      var available = false;
-      if (ctx.availableImages && ctx.availableImages.indexOf(evaluatedImageName) > -1) {
-          available = true;
+      var value = ResolvedImage.fromString(evaluatedImageName);
+      if (value && ctx.availableImages) {
+          value.available = ctx.availableImages.indexOf(evaluatedImageName) > -1;
       }
-      return new ResolvedImage({
-          name: evaluatedImageName,
-          available: available
-      });
+      return value;
   };
   ImageExpression.prototype.eachChild = function eachChild(fn) {
       fn(this.input);
   };
-  ImageExpression.prototype.possibleOutputs = function possibleOutputs() {
-      return [undefined];
+  ImageExpression.prototype.outputDefined = function outputDefined() {
+      return false;
   };
   ImageExpression.prototype.serialize = function serialize() {
       return [
@@ -8515,11 +8523,10 @@
   Coercion.prototype.eachChild = function eachChild(fn) {
       this.args.forEach(fn);
   };
-  Coercion.prototype.possibleOutputs = function possibleOutputs() {
-      var ref;
-      return (ref = []).concat.apply(ref, this.args.map(function (arg) {
-          return arg.possibleOutputs();
-      }));
+  Coercion.prototype.outputDefined = function outputDefined() {
+      return this.args.every(function (arg) {
+          return arg.outputDefined();
+      });
   };
   Coercion.prototype.serialize = function serialize() {
       if (this.type.kind === 'formatted') {
@@ -8553,6 +8560,7 @@
       this.formattedSection = null;
       this._parseColorCache = {};
       this.availableImages = null;
+      this.canonical = null;
   };
   EvaluationContext.prototype.id = function id() {
       return this.feature && 'id' in this.feature ? this.feature.id : null;
@@ -8560,6 +8568,12 @@
   EvaluationContext.prototype.geometryType = function geometryType() {
       return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
   };
+  EvaluationContext.prototype.geometry = function geometry() {
+      return this.feature && 'geometry' in this.feature ? this.feature.geometry : null;
+  };
+  EvaluationContext.prototype.canonicalID = function canonicalID() {
+      return this.canonical;
+  };
   EvaluationContext.prototype.properties = function properties() {
       return this.feature && this.feature.properties || {};
   };
@@ -8583,8 +8597,8 @@
   CompoundExpression.prototype.eachChild = function eachChild(fn) {
       this.args.forEach(fn);
   };
-  CompoundExpression.prototype.possibleOutputs = function possibleOutputs() {
-      return [undefined];
+  CompoundExpression.prototype.outputDefined = function outputDefined() {
+      return false;
   };
   CompoundExpression.prototype.serialize = function serialize() {
       return [this.name].concat(this.args.map(function (arg) {
@@ -8718,8 +8732,8 @@
           fn(this.locale);
       }
   };
-  CollatorExpression.prototype.possibleOutputs = function possibleOutputs() {
-      return [undefined];
+  CollatorExpression.prototype.outputDefined = function outputDefined() {
+      return false;
   };
   CollatorExpression.prototype.serialize = function serialize() {
       var options = {};
@@ -8734,94 +8748,1119 @@
       ];
   };
 
-  function isFeatureConstant(e) {
-      if (e instanceof CompoundExpression) {
-          if (e.name === 'get' && e.args.length === 1) {
-              return false;
-          } else if (e.name === 'feature-state') {
-              return false;
-          } else if (e.name === 'has' && e.args.length === 1) {
-              return false;
-          } else if (e.name === 'properties' || e.name === 'geometry-type' || e.name === 'id') {
-              return false;
-          } else if (/^filter-/.test(e.name)) {
+  /*
+   * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions
+   * are met:
+   * 1. Redistributions of source code must retain the above copyright
+   *    notice, this list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright
+   *    notice, this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   *
+   * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+   * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+   * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *
+   * Ported from Webkit
+   * http://svn.webkit.org/repository/webkit/trunk/Source/WebCore/platform/graphics/UnitBezier.h
+   */
+
+  var unitbezier = UnitBezier;
+
+  function UnitBezier(p1x, p1y, p2x, p2y) {
+      // Calculate the polynomial coefficients, implicit first and last control points are (0,0) and (1,1).
+      this.cx = 3.0 * p1x;
+      this.bx = 3.0 * (p2x - p1x) - this.cx;
+      this.ax = 1.0 - this.cx - this.bx;
+
+      this.cy = 3.0 * p1y;
+      this.by = 3.0 * (p2y - p1y) - this.cy;
+      this.ay = 1.0 - this.cy - this.by;
+
+      this.p1x = p1x;
+      this.p1y = p2y;
+      this.p2x = p2x;
+      this.p2y = p2y;
+  }
+
+  UnitBezier.prototype.sampleCurveX = function(t) {
+      // `ax t^3 + bx t^2 + cx t' expanded using Horner's rule.
+      return ((this.ax * t + this.bx) * t + this.cx) * t;
+  };
+
+  UnitBezier.prototype.sampleCurveY = function(t) {
+      return ((this.ay * t + this.by) * t + this.cy) * t;
+  };
+
+  UnitBezier.prototype.sampleCurveDerivativeX = function(t) {
+      return (3.0 * this.ax * t + 2.0 * this.bx) * t + this.cx;
+  };
+
+  UnitBezier.prototype.solveCurveX = function(x, epsilon) {
+      if (typeof epsilon === 'undefined') { epsilon = 1e-6; }
+
+      var t0, t1, t2, x2, i;
+
+      // First try a few iterations of Newton's method -- normally very fast.
+      for (t2 = x, i = 0; i < 8; i++) {
+
+          x2 = this.sampleCurveX(t2) - x;
+          if (Math.abs(x2) < epsilon) { return t2; }
+
+          var d2 = this.sampleCurveDerivativeX(t2);
+          if (Math.abs(d2) < 1e-6) { break; }
+
+          t2 = t2 - x2 / d2;
+      }
+
+      // Fall back to the bisection method for reliability.
+      t0 = 0.0;
+      t1 = 1.0;
+      t2 = x;
+
+      if (t2 < t0) { return t0; }
+      if (t2 > t1) { return t1; }
+
+      while (t0 < t1) {
+
+          x2 = this.sampleCurveX(t2);
+          if (Math.abs(x2 - x) < epsilon) { return t2; }
+
+          if (x > x2) {
+              t0 = t2;
+          } else {
+              t1 = t2;
+          }
+
+          t2 = (t1 - t0) * 0.5 + t0;
+      }
+
+      // Failure.
+      return t2;
+  };
+
+  UnitBezier.prototype.solve = function(x, epsilon) {
+      return this.sampleCurveY(this.solveCurveX(x, epsilon));
+  };
+
+  function deepEqual(a, b) {
+      if (Array.isArray(a)) {
+          if (!Array.isArray(b) || a.length !== b.length) {
               return false;
           }
+          for (var i = 0; i < a.length; i++) {
+              if (!deepEqual(a[i], b[i])) {
+                  return false;
+              }
+          }
+          return true;
       }
-      var result = true;
-      e.eachChild(function (arg) {
-          if (result && !isFeatureConstant(arg)) {
-              result = false;
+      if (typeof a === 'object' && a !== null && b !== null) {
+          if (!(typeof b === 'object')) {
+              return false;
           }
-      });
-      return result;
-  }
-  function isStateConstant(e) {
-      if (e instanceof CompoundExpression) {
-          if (e.name === 'feature-state') {
+          var keys = Object.keys(a);
+          if (keys.length !== Object.keys(b).length) {
               return false;
           }
-      }
-      var result = true;
-      e.eachChild(function (arg) {
-          if (result && !isStateConstant(arg)) {
-              result = false;
+          for (var key in a) {
+              if (!deepEqual(a[key], b[key])) {
+                  return false;
+              }
           }
-      });
-      return result;
-  }
-  function isGlobalPropertyConstant(e, properties) {
-      if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) {
-          return false;
+          return true;
       }
-      var result = true;
-      e.eachChild(function (arg) {
-          if (result && !isGlobalPropertyConstant(arg, properties)) {
-              result = false;
-          }
-      });
-      return result;
+      return a === b;
   }
 
-  var Var = function Var(name, boundExpression) {
-      this.type = boundExpression.type;
-      this.name = name;
-      this.boundExpression = boundExpression;
-  };
-  Var.parse = function parse(args, context) {
-      if (args.length !== 2 || typeof args[1] !== 'string') {
-          return context.error('\'var\' expression requires exactly one string literal argument.');
-      }
-      var name = args[1];
-      if (!context.scope.has(name)) {
-          return context.error('Unknown variable "' + name + '". Make sure "' + name + '" has been bound in an enclosing "let" expression before using it.', 1);
+  //      
+
+  /**
+   * constrain n to the given range, excluding the minimum, via modular arithmetic
+   *
+   * @param n value
+   * @param min the minimum value to be returned, exclusive
+   * @param max the maximum value to be returned, inclusive
+   * @returns constrained number
+   * @private
+   */
+  function wrap(n        , min        , max        )         {
+      var d = max - min;
+      var w = ((n - min) % d + d) % d + min;
+      return (w === min) ? max : w;
+  }
+
+  //      
+
+                                            
+
+  /**
+   * A `LngLatBounds` object represents a geographical bounding box,
+   * defined by its southwest and northeast points in longitude and latitude.
+   *
+   * If no arguments are provided to the constructor, a `null` bounding box is created.
+   *
+   * Note that any Mapbox GL method that accepts a `LngLatBounds` object as an argument or option
+   * can also accept an `Array` of two {@link LngLatLike} constructs and will perform an implicit conversion.
+   * This flexible type is documented as {@link LngLatBoundsLike}.
+   *
+   * @param {LngLatLike} [sw] The southwest corner of the bounding box.
+   * @param {LngLatLike} [ne] The northeast corner of the bounding box.
+   * @example
+   * var sw = new mapboxgl.LngLat(-73.9876, 40.7661);
+   * var ne = new mapboxgl.LngLat(-73.9397, 40.8002);
+   * var llb = new mapboxgl.LngLatBounds(sw, ne);
+   */
+  var LngLatBounds = function LngLatBounds(sw , ne ) {
+      if (!sw) ; else if (ne) {
+          this.setSouthWest(sw).setNorthEast(ne);
+      } else if (sw.length === 4) {
+          this.setSouthWest([sw[0], sw[1]]).setNorthEast([sw[2], sw[3]]);
+      } else {
+          this.setSouthWest(sw[0]).setNorthEast(sw[1]);
       }
-      return new Var(name, context.scope.get(name));
   };
-  Var.prototype.evaluate = function evaluate(ctx) {
-      return this.boundExpression.evaluate(ctx);
+
+  /**
+   * Set the northeast corner of the bounding box
+   *
+   * @param {LngLatLike} ne a {@link LngLatLike} object describing the northeast corner of the bounding box.
+   * @returns {LngLatBounds} `this`
+   */
+  LngLatBounds.prototype.setNorthEast = function setNorthEast (ne        ) {
+      this._ne = ne instanceof LngLat ? new LngLat(ne.lng, ne.lat) : LngLat.convert(ne);
+      return this;
   };
-  Var.prototype.eachChild = function eachChild() {
+
+  /**
+   * Set the southwest corner of the bounding box
+   *
+   * @param {LngLatLike} sw a {@link LngLatLike} object describing the southwest corner of the bounding box.
+   * @returns {LngLatBounds} `this`
+   */
+  LngLatBounds.prototype.setSouthWest = function setSouthWest (sw        ) {
+      this._sw = sw instanceof LngLat ? new LngLat(sw.lng, sw.lat) : LngLat.convert(sw);
+      return this;
   };
-  Var.prototype.possibleOutputs = function possibleOutputs() {
-      return [undefined];
+
+  /**
+   * Extend the bounds to include a given LngLatLike or LngLatBoundsLike.
+   *
+   * @param {LngLatLike|LngLatBoundsLike} obj object to extend to
+   * @returns {LngLatBounds} `this`
+   */
+  LngLatBounds.prototype.extend = function extend (obj                           ) {
+      var sw = this._sw,
+          ne = this._ne;
+      var sw2, ne2;
+
+      if (obj instanceof LngLat) {
+          sw2 = obj;
+          ne2 = obj;
+
+      } else if (obj instanceof LngLatBounds) {
+          sw2 = obj._sw;
+          ne2 = obj._ne;
+
+          if (!sw2 || !ne2) { return this; }
+
+      } else {
+          if (Array.isArray(obj)) {
+              if (obj.length === 4 || obj.every(Array.isArray)) {
+                  var lngLatBoundsObj = ((obj )              );
+                  return this.extend(LngLatBounds.convert(lngLatBoundsObj));
+              } else {
+                  var lngLatObj = ((obj )        );
+                  return this.extend(LngLat.convert(lngLatObj));
+              }
+          }
+          return this;
+      }
+
+      if (!sw && !ne) {
+          this._sw = new LngLat(sw2.lng, sw2.lat);
+          this._ne = new LngLat(ne2.lng, ne2.lat);
+
+      } else {
+          sw.lng = Math.min(sw2.lng, sw.lng);
+          sw.lat = Math.min(sw2.lat, sw.lat);
+          ne.lng = Math.max(ne2.lng, ne.lng);
+          ne.lat = Math.max(ne2.lat, ne.lat);
+      }
+
+      return this;
   };
-  Var.prototype.serialize = function serialize() {
-      return [
-          'var',
-          this.name
-      ];
+
+  /**
+   * Returns the geographical coordinate equidistant from the bounding box's corners.
+   *
+   * @returns {LngLat} The bounding box's center.
+   * @example
+   * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+   * llb.getCenter(); // = LngLat {lng: -73.96365, lat: 40.78315}
+   */
+  LngLatBounds.prototype.getCenter = function getCenter ()     {
+      return new LngLat((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
   };
 
-  var ParsingContext = function ParsingContext(registry, path, expectedType, scope, errors) {
-      if (path === void 0)
-          path = [];
-      if (scope === void 0)
-          scope = new Scope();
-      if (errors === void 0)
-          errors = [];
-      this.registry = registry;
-      this.path = path;
+  /**
+   * Returns the southwest corner of the bounding box.
+   *
+   * @returns {LngLat} The southwest corner of the bounding box.
+   */
+  LngLatBounds.prototype.getSouthWest = function getSouthWest ()     { return this._sw; };
+
+  /**
+  * Returns the northeast corner of the bounding box.
+  *
+  * @returns {LngLat} The northeast corner of the bounding box.
+   */
+  LngLatBounds.prototype.getNorthEast = function getNorthEast ()     { return this._ne; };
+
+  /**
+  * Returns the northwest corner of the bounding box.
+  *
+  * @returns {LngLat} The northwest corner of the bounding box.
+   */
+  LngLatBounds.prototype.getNorthWest = function getNorthWest ()     { return new LngLat(this.getWest(), this.getNorth()); };
+
+  /**
+  * Returns the southeast corner of the bounding box.
+  *
+  * @returns {LngLat} The southeast corner of the bounding box.
+   */
+  LngLatBounds.prototype.getSouthEast = function getSouthEast ()     { return new LngLat(this.getEast(), this.getSouth()); };
+
+  /**
+  * Returns the west edge of the bounding box.
+  *
+  * @returns {number} The west edge of the bounding box.
+   */
+  LngLatBounds.prototype.getWest = function getWest ()     { return this._sw.lng; };
+
+  /**
+  * Returns the south edge of the bounding box.
+  *
+  * @returns {number} The south edge of the bounding box.
+   */
+  LngLatBounds.prototype.getSouth = function getSouth ()     { return this._sw.lat; };
+
+  /**
+  * Returns the east edge of the bounding box.
+  *
+  * @returns {number} The east edge of the bounding box.
+   */
+  LngLatBounds.prototype.getEast = function getEast ()     { return this._ne.lng; };
+
+  /**
+  * Returns the north edge of the bounding box.
+  *
+  * @returns {number} The north edge of the bounding box.
+   */
+  LngLatBounds.prototype.getNorth = function getNorth ()     { return this._ne.lat; };
+
+  /**
+   * Returns the bounding box represented as an array.
+   *
+   * @returns {Array<Array<number>>} The bounding box represented as an array, consisting of the
+   *   southwest and northeast coordinates of the bounding represented as arrays of numbers.
+   * @example
+   * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+   * llb.toArray(); // = [[-73.9876, 40.7661], [-73.9397, 40.8002]]
+   */
+  LngLatBounds.prototype.toArray = function toArray () {
+      return [this._sw.toArray(), this._ne.toArray()];
+  };
+
+  /**
+   * Return the bounding box represented as a string.
+   *
+   * @returns {string} The bounding box represents as a string of the format
+   *   `'LngLatBounds(LngLat(lng, lat), LngLat(lng, lat))'`.
+   * @example
+   * var llb = new mapboxgl.LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+   * llb.toString(); // = "LngLatBounds(LngLat(-73.9876, 40.7661), LngLat(-73.9397, 40.8002))"
+   */
+  LngLatBounds.prototype.toString = function toString () {
+      return ("LngLatBounds(" + (this._sw.toString()) + ", " + (this._ne.toString()) + ")");
+  };
+
+  /**
+   * Check if the bounding box is an empty/`null`-type box.
+   *
+   * @returns {boolean} True if bounds have been defined, otherwise false.
+   */
+  LngLatBounds.prototype.isEmpty = function isEmpty () {
+      return !(this._sw && this._ne);
+  };
+
+  /**
+  * Check if the point is within the bounding box.
+  *
+  * @param {LngLatLike} lnglat geographic point to check against.
+  * @returns {boolean} True if the point is within the bounding box.
+  */
+  LngLatBounds.prototype.contains = function contains (lnglat        ) {
+      var ref = LngLat.convert(lnglat);
+          var lng = ref.lng;
+          var lat = ref.lat;
+
+      var containsLatitude = this._sw.lat <= lat && lat <= this._ne.lat;
+      var containsLongitude = this._sw.lng <= lng && lng <= this._ne.lng;
+      if (this._sw.lng > this._ne.lng) { // wrapped coordinates
+          containsLongitude = this._sw.lng >= lng && lng >= this._ne.lng;
+      }
+
+      return containsLatitude && containsLongitude;
+  };
+
+  /**
+   * Converts an array to a `LngLatBounds` object.
+   *
+   * If a `LngLatBounds` object is passed in, the function returns it unchanged.
+   *
+   * Internally, the function calls `LngLat#convert` to convert arrays to `LngLat` values.
+   *
+   * @param {LngLatBoundsLike} input An array of two coordinates to convert, or a `LngLatBounds` object to return.
+   * @returns {LngLatBounds} A new `LngLatBounds` object, if a conversion occurred, or the original `LngLatBounds` object.
+   * @example
+   * var arr = [[-73.9876, 40.7661], [-73.9397, 40.8002]];
+   * var llb = mapboxgl.LngLatBounds.convert(arr);
+   * llb;   // = LngLatBounds {_sw: LngLat {lng: -73.9876, lat: 40.7661}, _ne: LngLat {lng: -73.9397, lat: 40.8002}}
+   */
+  LngLatBounds.convert = function convert (input              )           {
+      if (!input || input instanceof LngLatBounds) { return input; }
+      return new LngLatBounds(input);
+  };
+
+  //      
+
+  /*
+  * Approximate radius of the earth in meters.
+  * Uses the WGS-84 approximation. The radius at the equator is ~6378137 and at the poles is ~6356752. https://en.wikipedia.org/wiki/World_Geodetic_System#WGS84
+  * 6371008.8 is one published "average radius" see https://en.wikipedia.org/wiki/Earth_radius#Mean_radius, or ftp://athena.fsv.cvut.cz/ZFG/grs80-Moritz.pdf p.4
+  */
+  var earthRadius = 6371008.8;
+
+  /**
+   * A `LngLat` object represents a given longitude and latitude coordinate, measured in degrees.
+   *
+   * Mapbox GL uses longitude, latitude coordinate order (as opposed to latitude, longitude) to match GeoJSON.
+   *
+   * Note that any Mapbox GL method that accepts a `LngLat` object as an argument or option
+   * can also accept an `Array` of two numbers and will perform an implicit conversion.
+   * This flexible type is documented as {@link LngLatLike}.
+   *
+   * @param {number} lng Longitude, measured in degrees.
+   * @param {number} lat Latitude, measured in degrees.
+   * @example
+   * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);
+   * @see [Get coordinates of the mouse pointer](https://www.mapbox.com/mapbox-gl-js/example/mouse-position/)
+   * @see [Display a popup](https://www.mapbox.com/mapbox-gl-js/example/popup/)
+   * @see [Highlight features within a bounding box](https://www.mapbox.com/mapbox-gl-js/example/using-box-queryrenderedfeatures/)
+   * @see [Create a timeline animation](https://www.mapbox.com/mapbox-gl-js/example/timeline-animation/)
+   */
+  var LngLat = function LngLat(lng    , lat    ) {
+      if (isNaN(lng) || isNaN(lat)) {
+          throw new Error(("Invalid LngLat object: (" + lng + ", " + lat + ")"));
+      }
+      this.lng = +lng;
+      this.lat = +lat;
+      if (this.lat > 90 || this.lat < -90) {
+          throw new Error('Invalid LngLat latitude value: must be between -90 and 90');
+      }
+  };
+
+  /**
+   * Returns a new `LngLat` object whose longitude is wrapped to the range (-180, 180).
+   *
+   * @returns {LngLat} The wrapped `LngLat` object.
+   * @example
+   * var ll = new mapboxgl.LngLat(286.0251, 40.7736);
+   * var wrapped = ll.wrap();
+   * wrapped.lng; // = -73.9749
+   */
+  LngLat.prototype.wrap = function wrap$1 () {
+      return new LngLat(wrap(this.lng, -180, 180), this.lat);
+  };
+
+  /**
+   * Returns the coordinates represented as an array of two numbers.
+   *
+   * @returns {Array<number>} The coordinates represeted as an array of longitude and latitude.
+   * @example
+   * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);
+   * ll.toArray(); // = [-73.9749, 40.7736]
+   */
+  LngLat.prototype.toArray = function toArray () {
+      return [this.lng, this.lat];
+  };
+
+  /**
+   * Returns the coordinates represent as a string.
+   *
+   * @returns {string} The coordinates represented as a string of the format `'LngLat(lng, lat)'`.
+   * @example
+   * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);
+   * ll.toString(); // = "LngLat(-73.9749, 40.7736)"
+   */
+  LngLat.prototype.toString = function toString () {
+      return ("LngLat(" + (this.lng) + ", " + (this.lat) + ")");
+  };
+
+  /**
+   * Returns the approximate distance between a pair of coordinates in meters
+   * Uses the Haversine Formula (from R.W. Sinnott, "Virtues of the Haversine", Sky and Telescope, vol. 68, no. 2, 1984, p. 159)
+   *
+   * @param {LngLat} lngLat coordinates to compute the distance to
+   * @returns {number} Distance in meters between the two coordinates.
+   * @example
+   * var new_york = new mapboxgl.LngLat(-74.0060, 40.7128);
+   * var los_angeles = new mapboxgl.LngLat(-118.2437, 34.0522);
+   * new_york.distanceTo(los_angeles); // = 3935751.690893987, "true distance" using a non-spherical approximation is ~3966km
+   */
+  LngLat.prototype.distanceTo = function distanceTo (lngLat    ) {
+      var rad = Math.PI / 180;
+      var lat1 = this.lat * rad;
+      var lat2 = lngLat.lat * rad;
+      var a = Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos((lngLat.lng - this.lng) * rad);
+
+      var maxMeters = earthRadius * Math.acos(Math.min(a, 1));
+      return maxMeters;
+  };
+
+  /**
+   * Returns a `LngLatBounds` from the coordinates extended by a given `radius`. The returned `LngLatBounds` completely contains the `radius`.
+   *
+   * @param {number} [radius=0] Distance in meters from the coordinates to extend the bounds.
+   * @returns {LngLatBounds} A new `LngLatBounds` object representing the coordinates extended by the `radius`.
+   * @example
+   * var ll = new mapboxgl.LngLat(-73.9749, 40.7736);
+   * ll.toBounds(100).toArray(); // = [[-73.97501862141328, 40.77351016847229], [-73.97478137858673, 40.77368983152771]]
+   */
+  LngLat.prototype.toBounds = function toBounds (radius) {
+          if ( radius === void 0 ) radius      = 0;
+
+      var earthCircumferenceInMetersAtEquator = 40075017;
+      var latAccuracy = 360 * radius / earthCircumferenceInMetersAtEquator,
+          lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
+
+      return new LngLatBounds(new LngLat(this.lng - lngAccuracy, this.lat - latAccuracy),
+          new LngLat(this.lng + lngAccuracy, this.lat + latAccuracy));
+  };
+
+  /**
+   * Converts an array of two numbers or an object with `lng` and `lat` or `lon` and `lat` properties
+   * to a `LngLat` object.
+   *
+   * If a `LngLat` object is passed in, the function returns it unchanged.
+   *
+   * @param {LngLatLike} input An array of two numbers or object to convert, or a `LngLat` object to return.
+   * @returns {LngLat} A new `LngLat` object, if a conversion occurred, or the original `LngLat` object.
+   * @example
+   * var arr = [-73.9749, 40.7736];
+   * var ll = mapboxgl.LngLat.convert(arr);
+   * ll;   // = LngLat {lng: -73.9749, lat: 40.7736}
+   */
+  LngLat.convert = function convert (input        )     {
+      if (input instanceof LngLat) {
+          return input;
+      }
+      if (Array.isArray(input) && (input.length === 2 || input.length === 3)) {
+          return new LngLat(Number(input[0]), Number(input[1]));
+      }
+      if (!Array.isArray(input) && typeof input === 'object' && input !== null) {
+          return new LngLat(
+              // flow can't refine this to have one of lng or lat, so we have to cast to any
+              Number('lng' in input ? (input ).lng : (input ).lon),
+              Number(input.lat)
+          );
+      }
+      throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]");
+  };
+
+  //      
+                                                 
+
+  /*
+   * The average circumference of the world in meters.
+   */
+  var earthCircumfrence = 2 * Math.PI * earthRadius; // meters
+
+  /*
+   * The circumference at a line of latitude in meters.
+   */
+  function circumferenceAtLatitude(latitude        ) {
+      return earthCircumfrence * Math.cos(latitude * Math.PI / 180);
+  }
+
+  function mercatorXfromLng(lng        ) {
+      return (180 + lng) / 360;
+  }
+
+  function mercatorYfromLat(lat        ) {
+      return (180 - (180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360)))) / 360;
+  }
+
+  function mercatorZfromAltitude(altitude        , lat        ) {
+      return altitude / circumferenceAtLatitude(lat);
+  }
+
+  function lngFromMercatorX(x        ) {
+      return x * 360 - 180;
+  }
+
+  function latFromMercatorY(y        ) {
+      var y2 = 180 - y * 360;
+      return 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+  }
+
+  function altitudeFromMercatorZ(z        , y        ) {
+      return z * circumferenceAtLatitude(latFromMercatorY(y));
+  }
+
+  /**
+   * Determine the Mercator scale factor for a given latitude, see
+   * https://en.wikipedia.org/wiki/Mercator_projection#Scale_factor
+   *
+   * At the equator the scale factor will be 1, which increases at higher latitudes.
+   *
+   * @param {number} lat Latitude
+   * @returns {number} scale factor
+   * @private
+   */
+  function mercatorScale(lat        ) {
+      return 1 / Math.cos(lat * Math.PI / 180);
+  }
+
+  /**
+   * A `MercatorCoordinate` object represents a projected three dimensional position.
+   *
+   * `MercatorCoordinate` uses the web mercator projection ([EPSG:3857](https://epsg.io/3857)) with slightly different units:
+   * - the size of 1 unit is the width of the projected world instead of the "mercator meter"
+   * - the origin of the coordinate space is at the north-west corner instead of the middle
+   *
+   * For example, `MercatorCoordinate(0, 0, 0)` is the north-west corner of the mercator world and
+   * `MercatorCoordinate(1, 1, 0)` is the south-east corner. If you are familiar with
+   * [vector tiles](https://github.com/mapbox/vector-tile-spec) it may be helpful to think
+   * of the coordinate space as the `0/0/0` tile with an extent of `1`.
+   *
+   * The `z` dimension of `MercatorCoordinate` is conformal. A cube in the mercator coordinate space would be rendered as a cube.
+   *
+   * @param {number} x The x component of the position.
+   * @param {number} y The y component of the position.
+   * @param {number} z The z component of the position.
+   * @example
+   * var nullIsland = new mapboxgl.MercatorCoordinate(0.5, 0.5, 0);
+   *
+   * @see [Add a custom style layer](https://www.mapbox.com/mapbox-gl-js/example/custom-style-layer/)
+   */
+  var MercatorCoordinate = function MercatorCoordinate(x    , y    , z) {
+      if ( z === void 0 ) z     = 0;
+
+      this.x = +x;
+      this.y = +y;
+      this.z = +z;
+  };
+
+  /**
+   * Project a `LngLat` to a `MercatorCoordinate`.
+   *
+   * @param {LngLatLike} lngLatLike The location to project.
+   * @param {number} altitude The altitude in meters of the position.
+   * @returns {MercatorCoordinate} The projected mercator coordinate.
+   * @example
+   * var coord = mapboxgl.MercatorCoordinate.fromLngLat({ lng: 0, lat: 0}, 0);
+   * coord; // MercatorCoordinate(0.5, 0.5, 0)
+   */
+  MercatorCoordinate.fromLngLat = function fromLngLat (lngLatLike        , altitude) {
+          if ( altitude === void 0 ) altitude     = 0;
+
+      var lngLat = LngLat.convert(lngLatLike);
+
+      return new MercatorCoordinate(
+              mercatorXfromLng(lngLat.lng),
+              mercatorYfromLat(lngLat.lat),
+              mercatorZfromAltitude(altitude, lngLat.lat));
+  };
+
+  /**
+   * Returns the `LngLat` for the coordinate.
+   *
+   * @returns {LngLat} The `LngLat` object.
+   * @example
+   * var coord = new mapboxgl.MercatorCoordinate(0.5, 0.5, 0);
+   * var latLng = coord.toLngLat(); // LngLat(0, 0)
+   */
+  MercatorCoordinate.prototype.toLngLat = function toLngLat () {
+      return new LngLat(
+              lngFromMercatorX(this.x),
+              latFromMercatorY(this.y));
+  };
+
+  /**
+   * Returns the altitude in meters of the coordinate.
+   *
+   * @returns {number} The altitude in meters.
+   * @example
+   * var coord = new mapboxgl.MercatorCoordinate(0, 0, 0.02);
+   * coord.toAltitude(); // 6914.281956295339
+   */
+  MercatorCoordinate.prototype.toAltitude = function toAltitude () {
+      return altitudeFromMercatorZ(this.z, this.y);
+  };
+
+  /**
+   * Returns the distance of 1 meter in `MercatorCoordinate` units at this latitude.
+   *
+   * For coordinates in real world units using meters, this naturally provides the scale
+   * to transform into `MercatorCoordinate`s.
+   *
+   * @returns {number} Distance of 1 meter in `MercatorCoordinate` units.
+   */
+  MercatorCoordinate.prototype.meterInMercatorCoordinateUnits = function meterInMercatorCoordinateUnits () {
+      // 1 meter / circumference at equator in meters * Mercator projection scale factor at this latitude
+      return 1 / earthCircumfrence * mercatorScale(latFromMercatorY(this.y));
+  };
+
+  //      
+
+  /**
+   * The maximum value of a coordinate in the internal tile coordinate system. Coordinates of
+   * all source features normalized to this extent upon load.
+   *
+   * The value is a consequence of the following:
+   *
+   * * Vertex buffer store positions as signed 16 bit integers.
+   * * One bit is lost for signedness to support tile buffers.
+   * * One bit is lost because the line vertex buffer used to pack 1 bit of other data into the int.
+   * * One bit is lost to support features extending past the extent on the right edge of the tile.
+   * * This leaves us with 2^13 = 8192
+   *
+   * @private
+   * @readonly
+   */
+  var EXTENT = 8192;
+
+  function updateBBox(bbox, coord) {
+      bbox[0] = Math.min(bbox[0], coord[0]);
+      bbox[1] = Math.min(bbox[1], coord[1]);
+      bbox[2] = Math.max(bbox[2], coord[0]);
+      bbox[3] = Math.max(bbox[3], coord[1]);
+  }
+  function boxWithinBox(bbox1, bbox2) {
+      if (bbox1[0] <= bbox2[0]) {
+          return false;
+      }
+      if (bbox1[2] >= bbox2[2]) {
+          return false;
+      }
+      if (bbox1[1] <= bbox2[1]) {
+          return false;
+      }
+      if (bbox1[3] >= bbox2[3]) {
+          return false;
+      }
+      return true;
+  }
+  function getTileCoordinates(p, canonical) {
+      var coord = MercatorCoordinate.fromLngLat({
+          lng: p[0],
+          lat: p[1]
+      }, 0);
+      var tilesAtZoom = Math.pow(2, canonical.z);
+      return [
+          Math.round(coord.x * tilesAtZoom * EXTENT),
+          Math.round(coord.y * tilesAtZoom * EXTENT)
+      ];
+  }
+  function onBoundary(p, p1, p2) {
+      var x1 = p[0] - p1[0];
+      var y1 = p[1] - p1[1];
+      var x2 = p[0] - p2[0];
+      var y2 = p[1] - p2[1];
+      return x1 * y2 - x2 * y1 === 0 && x1 * x2 <= 0 && y1 * y2 <= 0;
+  }
+  function rayIntersect(p, p1, p2) {
+      return p1[1] > p[1] !== p2[1] > p[1] && p[0] < (p2[0] - p1[0]) * (p[1] - p1[1]) / (p2[1] - p1[1]) + p1[0];
+  }
+  function pointWithinPolygon(point, rings) {
+      var inside = false;
+      for (var i = 0, len = rings.length; i < len; i++) {
+          var ring = rings[i];
+          for (var j = 0, len2 = ring.length; j < len2 - 1; j++) {
+              if (onBoundary(point, ring[j], ring[j + 1])) {
+                  return false;
+              }
+              if (rayIntersect(point, ring[j], ring[j + 1])) {
+                  inside = !inside;
+              }
+          }
+      }
+      return inside;
+  }
+  function pointWithinPolygons(point, polygons) {
+      for (var i = 0; i < polygons.length; i++) {
+          if (pointWithinPolygon(point, polygons[i])) {
+              return true;
+          }
+      }
+      return false;
+  }
+  function perp(v1, v2) {
+      return v1[0] * v2[1] - v1[1] * v2[0];
+  }
+  function twoSided(p1, p2, q1, q2) {
+      var x1 = p1[0] - q1[0];
+      var y1 = p1[1] - q1[1];
+      var x2 = p2[0] - q1[0];
+      var y2 = p2[1] - q1[1];
+      var x3 = q2[0] - q1[0];
+      var y3 = q2[1] - q1[1];
+      if ((x1 * y3 - x3 * y1) * (x2 * y3 - x3 * y2) < 0) {
+          return true;
+      }
+      return false;
+  }
+  function lineIntersectLine(a, b, c, d) {
+      var vectorP = [
+          b[0] - a[0],
+          b[1] - a[1]
+      ];
+      var vectorQ = [
+          d[0] - c[0],
+          d[1] - c[1]
+      ];
+      if (perp(vectorQ, vectorP) === 0) {
+          return false;
+      }
+      if (twoSided(a, b, c, d) && twoSided(c, d, a, b)) {
+          return true;
+      }
+      return false;
+  }
+  function lineIntersectPolygon(p1, p2, polygon) {
+      for (var i = 0, list = polygon; i < list.length; i += 1) {
+          var ring = list[i];
+          for (var j = 0; j < ring.length - 1; ++j) {
+              if (lineIntersectLine(p1, p2, ring[j], ring[j + 1])) {
+                  return true;
+              }
+          }
+      }
+      return false;
+  }
+  function lineStringWithinPolygon(line, polygon) {
+      for (var i = 0; i < line.length; ++i) {
+          if (!pointWithinPolygon(line[i], polygon)) {
+              return false;
+          }
+      }
+      for (var i$1 = 0; i$1 < line.length - 1; ++i$1) {
+          if (lineIntersectPolygon(line[i$1], line[i$1 + 1], polygon)) {
+              return false;
+          }
+      }
+      return true;
+  }
+  function lineStringWithinPolygons(line, polygons) {
+      for (var i = 0; i < polygons.length; i++) {
+          if (lineStringWithinPolygon(line, polygons[i])) {
+              return true;
+          }
+      }
+      return false;
+  }
+  function getTilePolygon(coordinates, bbox, canonical) {
+      var polygon = [];
+      for (var i = 0; i < coordinates.length; i++) {
+          var ring = [];
+          for (var j = 0; j < coordinates[i].length; j++) {
+              var coord = getTileCoordinates(coordinates[i][j], canonical);
+              updateBBox(bbox, coord);
+              ring.push(coord);
+          }
+          polygon.push(ring);
+      }
+      return polygon;
+  }
+  function getTilePolygons(coordinates, bbox, canonical) {
+      var polygons = [];
+      for (var i = 0; i < coordinates.length; i++) {
+          var polygon = getTilePolygon(coordinates[i], bbox, canonical);
+          polygons.push(polygon);
+      }
+      return polygons;
+  }
+  function pointsWithinPolygons(ctx, polygonGeometry) {
+      var pointBBox = [
+          Infinity,
+          Infinity,
+          -Infinity,
+          -Infinity
+      ];
+      var polyBBox = [
+          Infinity,
+          Infinity,
+          -Infinity,
+          -Infinity
+      ];
+      var canonical = ctx.canonicalID();
+      var shifts = [
+          canonical.x * EXTENT,
+          canonical.y * EXTENT
+      ];
+      var tilePoints = [];
+      for (var i$1 = 0, list$1 = ctx.geometry(); i$1 < list$1.length; i$1 += 1) {
+          var points = list$1[i$1];
+          for (var i = 0, list = points; i < list.length; i += 1) {
+              var point = list[i];
+              var p = [
+                  point.x + shifts[0],
+                  point.y + shifts[1]
+              ];
+              updateBBox(pointBBox, p);
+              tilePoints.push(p);
+          }
+      }
+      if (polygonGeometry.type === 'Polygon') {
+          var tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
+          if (!boxWithinBox(pointBBox, polyBBox)) {
+              return false;
+          }
+          for (var i$2 = 0, list$2 = tilePoints; i$2 < list$2.length; i$2 += 1) {
+              var point$1 = list$2[i$2];
+              if (!pointWithinPolygon(point$1, tilePolygon)) {
+                  return false;
+              }
+          }
+      }
+      if (polygonGeometry.type === 'MultiPolygon') {
+          var tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
+          if (!boxWithinBox(pointBBox, polyBBox)) {
+              return false;
+          }
+          for (var i$3 = 0, list$3 = tilePoints; i$3 < list$3.length; i$3 += 1) {
+              var point$2 = list$3[i$3];
+              if (!pointWithinPolygons(point$2, tilePolygons)) {
+                  return false;
+              }
+          }
+      }
+      return true;
+  }
+  function linesWithinPolygons(ctx, polygonGeometry) {
+      var lineBBox = [
+          Infinity,
+          Infinity,
+          -Infinity,
+          -Infinity
+      ];
+      var polyBBox = [
+          Infinity,
+          Infinity,
+          -Infinity,
+          -Infinity
+      ];
+      var canonical = ctx.canonicalID();
+      var shifts = [
+          canonical.x * EXTENT,
+          canonical.y * EXTENT
+      ];
+      var tileLines = [];
+      for (var i$1 = 0, list$1 = ctx.geometry(); i$1 < list$1.length; i$1 += 1) {
+          var line = list$1[i$1];
+          var tileLine = [];
+          for (var i = 0, list = line; i < list.length; i += 1) {
+              var point = list[i];
+              var p = [
+                  point.x + shifts[0],
+                  point.y + shifts[1]
+              ];
+              updateBBox(lineBBox, p);
+              tileLine.push(p);
+          }
+          tileLines.push(tileLine);
+      }
+      if (polygonGeometry.type === 'Polygon') {
+          var tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
+          if (!boxWithinBox(lineBBox, polyBBox)) {
+              return false;
+          }
+          for (var i$2 = 0, list$2 = tileLines; i$2 < list$2.length; i$2 += 1) {
+              var line$1 = list$2[i$2];
+              if (!lineStringWithinPolygon(line$1, tilePolygon)) {
+                  return false;
+              }
+          }
+      }
+      if (polygonGeometry.type === 'MultiPolygon') {
+          var tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
+          if (!boxWithinBox(lineBBox, polyBBox)) {
+              return false;
+          }
+          for (var i$3 = 0, list$3 = tileLines; i$3 < list$3.length; i$3 += 1) {
+              var line$2 = list$3[i$3];
+              if (!lineStringWithinPolygons(line$2, tilePolygons)) {
+                  return false;
+              }
+          }
+      }
+      return true;
+  }
+  var Within = function Within(geojson, geometries) {
+      this.type = BooleanType;
+      this.geojson = geojson;
+      this.geometries = geometries;
+  };
+  Within.parse = function parse(args, context) {
+      if (args.length !== 2) {
+          return context.error('\'within\' expression requires exactly one argument, but found ' + (args.length - 1) + ' instead.');
+      }
+      if (isValue(args[1])) {
+          var geojson = args[1];
+          if (geojson.type === 'FeatureCollection') {
+              for (var i = 0; i < geojson.features.length; ++i) {
+                  var type = geojson.features[i].geometry.type;
+                  if (type === 'Polygon' || type === 'MultiPolygon') {
+                      return new Within(geojson, geojson.features[i].geometry);
+                  }
+              }
+          } else if (geojson.type === 'Feature') {
+              var type$1 = geojson.geometry.type;
+              if (type$1 === 'Polygon' || type$1 === 'MultiPolygon') {
+                  return new Within(geojson, geojson.geometry);
+              }
+          } else if (geojson.type === 'Polygon' || geojson.type === 'MultiPolygon') {
+              return new Within(geojson, geojson);
+          }
+      }
+      return context.error('\'within\' expression requires valid geojson object that contains polygon geometry type.');
+  };
+  Within.prototype.evaluate = function evaluate(ctx) {
+      if (ctx.geometry() != null && ctx.canonicalID() != null) {
+          if (ctx.geometryType() === 'Point') {
+              return pointsWithinPolygons(ctx, this.geometries);
+          } else if (ctx.geometryType() === 'LineString') {
+              return linesWithinPolygons(ctx, this.geometries);
+          }
+      }
+      return false;
+  };
+  Within.prototype.eachChild = function eachChild() {
+  };
+  Within.prototype.outputDefined = function outputDefined() {
+      return true;
+  };
+  Within.prototype.serialize = function serialize() {
+      return [
+          'within',
+          this.geojson
+      ];
+  };
+
+  function isFeatureConstant(e) {
+      if (e instanceof CompoundExpression) {
+          if (e.name === 'get' && e.args.length === 1) {
+              return false;
+          } else if (e.name === 'feature-state') {
+              return false;
+          } else if (e.name === 'has' && e.args.length === 1) {
+              return false;
+          } else if (e.name === 'properties' || e.name === 'geometry-type' || e.name === 'id') {
+              return false;
+          } else if (/^filter-/.test(e.name)) {
+              return false;
+          }
+      }
+      if (e instanceof Within) {
+          return false;
+      }
+      var result = true;
+      e.eachChild(function (arg) {
+          if (result && !isFeatureConstant(arg)) {
+              result = false;
+          }
+      });
+      return result;
+  }
+  function isStateConstant(e) {
+      if (e instanceof CompoundExpression) {
+          if (e.name === 'feature-state') {
+              return false;
+          }
+      }
+      var result = true;
+      e.eachChild(function (arg) {
+          if (result && !isStateConstant(arg)) {
+              result = false;
+          }
+      });
+      return result;
+  }
+  function isGlobalPropertyConstant(e, properties) {
+      if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) {
+          return false;
+      }
+      var result = true;
+      e.eachChild(function (arg) {
+          if (result && !isGlobalPropertyConstant(arg, properties)) {
+              result = false;
+          }
+      });
+      return result;
+  }
+
+  var Var = function Var(name, boundExpression) {
+      this.type = boundExpression.type;
+      this.name = name;
+      this.boundExpression = boundExpression;
+  };
+  Var.parse = function parse(args, context) {
+      if (args.length !== 2 || typeof args[1] !== 'string') {
+          return context.error('\'var\' expression requires exactly one string literal argument.');
+      }
+      var name = args[1];
+      if (!context.scope.has(name)) {
+          return context.error('Unknown variable "' + name + '". Make sure "' + name + '" has been bound in an enclosing "let" expression before using it.', 1);
+      }
+      return new Var(name, context.scope.get(name));
+  };
+  Var.prototype.evaluate = function evaluate(ctx) {
+      return this.boundExpression.evaluate(ctx);
+  };
+  Var.prototype.eachChild = function eachChild() {
+  };
+  Var.prototype.outputDefined = function outputDefined() {
+      return false;
+  };
+  Var.prototype.serialize = function serialize() {
+      return [
+          'var',
+          this.name
+      ];
+  };
+
+  var ParsingContext = function ParsingContext(registry, path, expectedType, scope, errors) {
+      if (path === void 0)
+          path = [];
+      if (scope === void 0)
+          scope = new Scope();
+      if (errors === void 0)
+          errors = [];
+      this.registry = registry;
+      this.path = path;
       this.key = path.map(function (part) {
           return '[' + part + ']';
       }).join('');
@@ -8927,6 +9966,8 @@
           return false;
       } else if (expression instanceof CollatorExpression) {
           return false;
+      } else if (expression instanceof Within) {
+          return false;
       }
       var isTypeAnnotation = expression instanceof Coercion || expression instanceof Assertion;
       var childrenConstant = true;
@@ -9049,11 +10090,10 @@
           fn(expression);
       }
   };
-  Step.prototype.possibleOutputs = function possibleOutputs() {
-      var ref;
-      return (ref = []).concat.apply(ref, this.outputs.map(function (output) {
-          return output.possibleOutputs();
-      }));
+  Step.prototype.outputDefined = function outputDefined() {
+      return this.outputs.every(function (out) {
+          return out.outputDefined();
+      });
   };
   Step.prototype.serialize = function serialize() {
       var serialized = [
@@ -9069,112 +10109,6 @@
       return serialized;
   };
 
-  /*
-   * Copyright (C) 2008 Apple Inc. All Rights Reserved.
-   *
-   * Redistribution and use in source and binary forms, with or without
-   * modification, are permitted provided that the following conditions
-   * are met:
-   * 1. Redistributions of source code must retain the above copyright
-   *    notice, this list of conditions and the following disclaimer.
-   * 2. Redistributions in binary form must reproduce the above copyright
-   *    notice, this list of conditions and the following disclaimer in the
-   *    documentation and/or other materials provided with the distribution.
-   *
-   * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
-   * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
-   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
-   * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-   *
-   * Ported from Webkit
-   * http://svn.webkit.org/repository/webkit/trunk/Source/WebCore/platform/graphics/UnitBezier.h
-   */
-
-  var unitbezier = UnitBezier;
-
-  function UnitBezier(p1x, p1y, p2x, p2y) {
-      // Calculate the polynomial coefficients, implicit first and last control points are (0,0) and (1,1).
-      this.cx = 3.0 * p1x;
-      this.bx = 3.0 * (p2x - p1x) - this.cx;
-      this.ax = 1.0 - this.cx - this.bx;
-
-      this.cy = 3.0 * p1y;
-      this.by = 3.0 * (p2y - p1y) - this.cy;
-      this.ay = 1.0 - this.cy - this.by;
-
-      this.p1x = p1x;
-      this.p1y = p2y;
-      this.p2x = p2x;
-      this.p2y = p2y;
-  }
-
-  UnitBezier.prototype.sampleCurveX = function(t) {
-      // `ax t^3 + bx t^2 + cx t' expanded using Horner's rule.
-      return ((this.ax * t + this.bx) * t + this.cx) * t;
-  };
-
-  UnitBezier.prototype.sampleCurveY = function(t) {
-      return ((this.ay * t + this.by) * t + this.cy) * t;
-  };
-
-  UnitBezier.prototype.sampleCurveDerivativeX = function(t) {
-      return (3.0 * this.ax * t + 2.0 * this.bx) * t + this.cx;
-  };
-
-  UnitBezier.prototype.solveCurveX = function(x, epsilon) {
-      if (typeof epsilon === 'undefined') { epsilon = 1e-6; }
-
-      var t0, t1, t2, x2, i;
-
-      // First try a few iterations of Newton's method -- normally very fast.
-      for (t2 = x, i = 0; i < 8; i++) {
-
-          x2 = this.sampleCurveX(t2) - x;
-          if (Math.abs(x2) < epsilon) { return t2; }
-
-          var d2 = this.sampleCurveDerivativeX(t2);
-          if (Math.abs(d2) < 1e-6) { break; }
-
-          t2 = t2 - x2 / d2;
-      }
-
-      // Fall back to the bisection method for reliability.
-      t0 = 0.0;
-      t1 = 1.0;
-      t2 = x;
-
-      if (t2 < t0) { return t0; }
-      if (t2 > t1) { return t1; }
-
-      while (t0 < t1) {
-
-          x2 = this.sampleCurveX(t2);
-          if (Math.abs(x2 - x) < epsilon) { return t2; }
-
-          if (x > x2) {
-              t0 = t2;
-          } else {
-              t1 = t2;
-          }
-
-          t2 = (t1 - t0) * 0.5 + t0;
-      }
-
-      // Failure.
-      return t2;
-  };
-
-  UnitBezier.prototype.solve = function(x, epsilon) {
-      return this.sampleCurveY(this.solveCurveX(x, epsilon));
-  };
-
   function number(a, b, t) {
       return a * (1 - t) + b * t;
   }
@@ -9422,11 +10356,10 @@
           fn(expression);
       }
   };
-  Interpolate.prototype.possibleOutputs = function possibleOutputs() {
-      var ref;
-      return (ref = []).concat.apply(ref, this.outputs.map(function (output) {
-          return output.possibleOutputs();
-      }));
+  Interpolate.prototype.outputDefined = function outputDefined() {
+      return this.outputs.every(function (out) {
+          return out.outputDefined();
+      });
   };
   Interpolate.prototype.serialize = function serialize() {
       var interpolation;
@@ -9520,11 +10453,10 @@
   Coalesce.prototype.eachChild = function eachChild(fn) {
       this.args.forEach(fn);
   };
-  Coalesce.prototype.possibleOutputs = function possibleOutputs() {
-      var ref;
-      return (ref = []).concat.apply(ref, this.args.map(function (arg) {
-          return arg.possibleOutputs();
-      }));
+  Coalesce.prototype.outputDefined = function outputDefined() {
+      return this.args.every(function (arg) {
+          return arg.outputDefined();
+      });
   };
   Coalesce.prototype.serialize = function serialize() {
       var serialized = ['coalesce'];
@@ -9577,8 +10509,8 @@
       }
       return new Let(bindings, result);
   };
-  Let.prototype.possibleOutputs = function possibleOutputs() {
-      return this.result.possibleOutputs();
+  Let.prototype.outputDefined = function outputDefined() {
+      return this.result.outputDefined();
   };
   Let.prototype.serialize = function serialize() {
       var serialized = ['let'];
@@ -9627,8 +10559,8 @@
       fn(this.index);
       fn(this.input);
   };
-  At.prototype.possibleOutputs = function possibleOutputs() {
-      return [undefined];
+  At.prototype.outputDefined = function outputDefined() {
+      return false;
   };
   At.prototype.serialize = function serialize() {
       return [
@@ -9669,7 +10601,7 @@
   In.prototype.evaluate = function evaluate(ctx) {
       var needle = this.needle.evaluate(ctx);
       var haystack = this.haystack.evaluate(ctx);
-      if (!needle || !haystack) {
+      if (needle == null || !haystack) {
           return false;
       }
       if (!isComparableRuntimeValue(needle)) {
@@ -9684,11 +10616,8 @@
       fn(this.needle);
       fn(this.haystack);
   };
-  In.prototype.possibleOutputs = function possibleOutputs() {
-      return [
-          true,
-          false
-      ];
+  In.prototype.outputDefined = function outputDefined() {
+      return true;
   };
   In.prototype.serialize = function serialize() {
       return [
@@ -9778,11 +10707,10 @@
       this.outputs.forEach(fn);
       fn(this.otherwise);
   };
-  Match.prototype.possibleOutputs = function possibleOutputs() {
-      var ref;
-      return (ref = []).concat.apply(ref, this.outputs.map(function (out) {
-          return out.possibleOutputs();
-      })).concat(this.otherwise.possibleOutputs());
+  Match.prototype.outputDefined = function outputDefined() {
+      return this.outputs.every(function (out) {
+          return out.outputDefined();
+      }) && this.otherwise.outputDefined();
   };
   Match.prototype.serialize = function serialize() {
       var this$1 = this;
@@ -9883,13 +10811,12 @@
       }
       fn(this.otherwise);
   };
-  Case.prototype.possibleOutputs = function possibleOutputs() {
-      var ref;
-      return (ref = []).concat.apply(ref, this.branches.map(function (ref) {
+  Case.prototype.outputDefined = function outputDefined() {
+      return this.branches.every(function (ref) {
           var _ = ref[0];
           var out = ref[1];
-          return out.possibleOutputs();
-      })).concat(this.otherwise.possibleOutputs());
+          return out.outputDefined();
+      }) && this.otherwise.outputDefined();
   };
   Case.prototype.serialize = function serialize() {
       var serialized = ['case'];
@@ -10019,11 +10946,8 @@
                   fn(this.collator);
               }
           };
-          Comparison.prototype.possibleOutputs = function possibleOutputs() {
-              return [
-                  true,
-                  false
-              ];
+          Comparison.prototype.outputDefined = function outputDefined() {
+              return true;
           };
           Comparison.prototype.serialize = function serialize() {
               var serialized = [op];
@@ -10115,8 +11039,8 @@
           fn(this.maxFractionDigits);
       }
   };
-  NumberFormat.prototype.possibleOutputs = function possibleOutputs() {
-      return [undefined];
+  NumberFormat.prototype.outputDefined = function outputDefined() {
+      return false;
   };
   NumberFormat.prototype.serialize = function serialize() {
       var options = {};
@@ -10169,8 +11093,8 @@
   Length.prototype.eachChild = function eachChild(fn) {
       fn(this.input);
   };
-  Length.prototype.possibleOutputs = function possibleOutputs() {
-      return [undefined];
+  Length.prototype.outputDefined = function outputDefined() {
+      return false;
   };
   Length.prototype.serialize = function serialize() {
       var serialized = ['length'];
@@ -10212,7 +11136,8 @@
       'to-color': Coercion,
       'to-number': Coercion,
       'to-string': Coercion,
-      'var': Var
+      'var': Var,
+      'within': Within
   };
   function rgba(ctx, ref) {
       var r = ref[0];
@@ -10771,7 +11696,7 @@
           BooleanType,
           [],
           function (ctx) {
-              return ctx.id() !== null;
+              return ctx.id() !== null && ctx.id() !== undefined;
           }
       ],
       'filter-type-in': [
@@ -11200,18 +12125,20 @@
       this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
       this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
   };
-  StyleExpression.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, availableImages, formattedSection) {
+  StyleExpression.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection) {
       this._evaluator.globals = globals;
       this._evaluator.feature = feature;
       this._evaluator.featureState = featureState;
+      this._evaluator.canonical = canonical;
       this._evaluator.availableImages = availableImages || null;
       this._evaluator.formattedSection = formattedSection;
       return this.expression.evaluate(this._evaluator);
   };
-  StyleExpression.prototype.evaluate = function evaluate(globals, feature, featureState, availableImages, formattedSection) {
+  StyleExpression.prototype.evaluate = function evaluate(globals, feature, featureState, canonical, availableImages, formattedSection) {
       this._evaluator.globals = globals;
       this._evaluator.feature = feature || null;
       this._evaluator.featureState = featureState || null;
+      this._evaluator.canonical = canonical;
       this._evaluator.availableImages = availableImages || null;
       this._evaluator.formattedSection = formattedSection || null;
       try {
@@ -11251,11 +12178,11 @@
       this._styleExpression = expression;
       this.isStateDependent = kind !== 'constant' && !isStateConstant(expression.expression);
   };
-  ZoomConstantExpression.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, availableImages, formattedSection) {
-      return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, availableImages, formattedSection);
+  ZoomConstantExpression.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection) {
+      return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
   };
-  ZoomConstantExpression.prototype.evaluate = function evaluate(globals, feature, featureState, availableImages, formattedSection) {
-      return this._styleExpression.evaluate(globals, feature, featureState, availableImages, formattedSection);
+  ZoomConstantExpression.prototype.evaluate = function evaluate(globals, feature, featureState, canonical, availableImages, formattedSection) {
+      return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
   };
   var ZoomDependentExpression = function ZoomDependentExpression(kind, expression, zoomStops, interpolationType) {
       this.kind = kind;
@@ -11264,11 +12191,11 @@
       this.isStateDependent = kind !== 'camera' && !isStateConstant(expression.expression);
       this.interpolationType = interpolationType;
   };
-  ZoomDependentExpression.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, availableImages, formattedSection) {
-      return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, availableImages, formattedSection);
+  ZoomDependentExpression.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection) {
+      return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
   };
-  ZoomDependentExpression.prototype.evaluate = function evaluate(globals, feature, featureState, availableImages, formattedSection) {
-      return this._styleExpression.evaluate(globals, feature, featureState, availableImages, formattedSection);
+  ZoomDependentExpression.prototype.evaluate = function evaluate(globals, feature, featureState, canonical, availableImages, formattedSection) {
+      return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
   };
   ZoomDependentExpression.prototype.interpolationFactor = function interpolationFactor(input, lower, upper) {
       if (this.interpolationType) {
@@ -11714,7 +12641,7 @@
       case 'has':
           return filter.length >= 2 && filter[1] !== '$id' && filter[1] !== '$type';
       case 'in':
-          return filter.length >= 3 && Array.isArray(filter[2]);
+          return filter.length >= 3 && (typeof filter[1] !== 'string' || Array.isArray(filter[2]));
       case '!in':
       case '!has':
       case 'none':
@@ -11754,8 +12681,11 @@
   };
   function createFilter(filter) {
       if (filter === null || filter === undefined) {
-          return function () {
-              return true;
+          return {
+              filter: function () {
+                  return true;
+              },
+              needGeometry: false
           };
       }
       if (!isExpressionFilter(filter)) {
@@ -11767,8 +12697,12 @@
               return err.key + ': ' + err.message;
           }).join(', '));
       } else {
-          return function (globalProperties, feature) {
-              return compiled.value.evaluate(globalProperties, feature);
+          var needGeometry = Array.isArray(filter) && filter.length !== 0 && filter[0] === 'within';
+          return {
+              filter: function (globalProperties, feature, canonical) {
+                  return compiled.value.evaluate(globalProperties, feature, {}, canonical);
+              },
+              needGeometry: needGeometry
           };
       }
   }
@@ -12201,36 +13135,6 @@
       return layers;
   }
 
-  function deepEqual(a, b) {
-      if (Array.isArray(a)) {
-          if (!Array.isArray(b) || a.length !== b.length) {
-              return false;
-          }
-          for (var i = 0; i < a.length; i++) {
-              if (!deepEqual(a[i], b[i])) {
-                  return false;
-              }
-          }
-          return true;
-      }
-      if (typeof a === 'object' && a !== null && b !== null) {
-          if (!(typeof b === 'object')) {
-              return false;
-          }
-          var keys = Object.keys(a);
-          if (keys.length !== Object.keys(b).length) {
-              return false;
-          }
-          for (var key in a) {
-              if (!deepEqual(a[key], b[key])) {
-                  return false;
-              }
-          }
-          return true;
-      }
-      return a === b;
-  }
-
   var operations = {
       setStyle: 'setStyle',
       addLayer: 'addLayer',
@@ -12921,7 +13825,7 @@
           });
       }
       var expressionObj = expression.value.expression || expression.value._styleExpression.expression;
-      if (options.expressionContext === 'property' && options.propertyKey === 'text-font' && expressionObj.possibleOutputs().indexOf(undefined) !== -1) {
+      if (options.expressionContext === 'property' && options.propertyKey === 'text-font' && !expressionObj.outputDefined()) {
           return [new ValidationError(options.key, options.value, 'Invalid data expression for "' + options.propertyKey + '". Output values must be contained as literals within the expression.')];
       }
       if (options.expressionContext === 'property' && options.propertyType === 'layout' && !isStateConstant(expressionObj)) {