@mapbox/mapbox-gl-style-spec 14.13.0-beta.1 → 14.14.0-alpha.a4a566d51

package/dist/index.cjs

@@ -1945,6 +1945,79 @@
   		},
   		"property-type": "constant"
   	},
+  	"building-facade": {
+  		type: "boolean",
+  		"default": false,
+  		doc: "Whether to render facade details on the buildings.",
+  		experimental: true,
+  		"private": true,
+  		"sdk-support": {
+  			"basic functionality": {
+  			},
+  			"data-driven styling": {
+  			}
+  		},
+  		expression: {
+  			interpolated: false,
+  			parameters: [
+  				"feature"
+  			]
+  		},
+  		"property-type": "data-driven"
+  	},
+  	"building-facade-floors": {
+  		type: "number",
+  		minimum: 1,
+  		maximum: 200,
+  		"default": 3,
+  		doc: "Number of floors created when building-facade is enabled.",
+  		experimental: true,
+  		"property-type": "data-driven",
+  		"sdk-support": {
+  			"basic functionality": {
+  			},
+  			"data-driven styling": {
+  			}
+  		},
+  		expression: {
+  			interpolated: false,
+  			parameters: [
+  				"feature"
+  			]
+  		},
+  		requires: [
+  			"building-facade"
+  		]
+  	},
+  	"building-facade-window": {
+  		type: "array",
+  		length: 2,
+  		value: "number",
+  		minimum: 0.1,
+  		maximum: 1,
+  		"default": [
+  			0.9,
+  			0.9
+  		],
+  		doc: "Given as fractions, specifies the percentage of floor area covered by windows when building-facade is enabled",
+  		experimental: true,
+  		"property-type": "data-driven",
+  		"sdk-support": {
+  			"basic functionality": {
+  			},
+  			"data-driven styling": {
+  			}
+  		},
+  		expression: {
+  			interpolated: false,
+  			parameters: [
+  				"feature"
+  			]
+  		},
+  		requires: [
+  			"building-facade"
+  		]
+  	},
   	"building-roof-shape": {
   		type: "enum",
   		values: {
@@ -4192,6 +4265,17 @@
   				}
   			}
   		},
+  		split: {
+  			doc: "Returns an array of substrings from a string, split by a delimiter parameter.",
+  			group: "Lookup",
+  			"sdk-support": {
+  				"basic functionality": {
+  					js: "3.14.0",
+  					android: "11.14.0",
+  					ios: "11.14.0"
+  				}
+  			}
+  		},
   		"case": {
   			doc: "Selects the first output whose corresponding test condition evaluates to true, or the fallback value otherwise.",
   			group: "Decision",
@@ -6680,7 +6764,7 @@
   		},
   		"property-type": "data-constant"
   	},
-  	"building-ambient-occlusion-wall-intensity": {
+  	"building-ambient-occlusion-intensity": {
   		"property-type": "data-constant",
   		type: "number",
   		"default": 0,
@@ -6689,13 +6773,12 @@
   		experimental: true,
   		"private": true,
   		expression: {
-  			interpolated: true,
+  			interpolated: false,
   			parameters: [
-  				"zoom"
   			]
   		},
   		transition: true,
-  		doc: "Controls the intensity of shading concave angles between walls and building elements, such as facades and rooftop.",
+  		doc: "Controls the intensity of ambinet occlusion when shading concave angles between walls and roof crevices.",
   		"sdk-support": {
   			"basic functionality": {
   			}
@@ -6814,7 +6897,8 @@
   			interpolated: true,
   			parameters: [
   				"feature",
-  				"feature-state"
+  				"feature-state",
+  				"measure-light"
   			]
   		},
   		"property-type": "data-driven"
@@ -6823,7 +6907,9 @@
   		type: "number",
   		"default": 0,
   		minimum: 0,
-  		doc: "Controls the intensity of light emitted on the source features.",
+  		maximum: 5,
+  		units: "intensity",
+  		doc: "Controls the intensity of light emitted on the source features. There is no emission for value 0. For value 1.0, only emissive component (no shading) is displayed and values above 1.0 produce light contribution to surrounding area, for some of the parts (e.g. doors).",
   		experimental: true,
   		"private": true,
   		"sdk-support": {
@@ -6841,6 +6927,60 @@
   			]
   		},
   		"property-type": "data-driven"
+  	},
+  	"building-facade-emissive-chance": {
+  		type: "number",
+  		"default": 0.35,
+  		minimum: 0,
+  		maximum: 1,
+  		doc: "Given as a fraction specifies the likelihood for the facades to be emissive when building-facade is enabled. A value of 0.0 means the window will never be emissive, while a value of 1.0 means the window will always be emissive. This can be used to create variations on a building where some windows are lit and some are not.",
+  		experimental: true,
+  		"property-type": "data-constant",
+  		"sdk-support": {
+  			"basic functionality": {
+  			}
+  		},
+  		expression: {
+  			interpolated: true,
+  			parameters: [
+  				"measure-light",
+  				"zoom"
+  			]
+  		}
+  	},
+  	"building-ambient-occlusion-window-intensity": {
+  		type: "number",
+  		"default": 0,
+  		minimum: 0,
+  		maximum: 1,
+  		doc: "Controls the intensity of ambient occlusion applied to the windows of the buildings. A value of 0.0 means no ambient occlusion is applied, while a value of 1.0 means full ambient occlusion is applied.",
+  		experimental: true,
+  		"property-type": "data-constant",
+  		"sdk-support": {
+  			"basic functionality": {
+  			}
+  		},
+  		expression: {
+  			interpolated: false,
+  			parameters: [
+  			]
+  		}
+  	},
+  	"building-cutoff-fade-range": {
+  		type: "number",
+  		"default": 0,
+  		minimum: 0,
+  		maximum: 1,
+  		doc: "This parameter defines the range for the fade-out effect before an automatic content cutoff on pitched map views. Fade out is implemented by scaling down and removing buildings in the fade range in a staggered fashion. Opacity is not changed. The fade range is expressed in relation to the height of the map view. A value of 1.0 indicates that the content is faded to the same extent as the map's height in pixels, while a value close to zero represents a sharp cutoff. When the value is set to 0.0, the cutoff is completely disabled. Note: The property has no effect on the map if terrain is enabled.",
+  		transition: false,
+  		expression: {
+  			interpolated: false
+  		},
+  		"sdk-support": {
+  			"basic functionality": {
+  			}
+  		},
+  		"property-type": "data-constant"
   	}
   };
   var paint_line = {
@@ -14111,305 +14251,309 @@
       }
   }
 
-  var pointGeometry;
-  var hasRequiredPointGeometry;
-
-  function requirePointGeometry () {
-  	if (hasRequiredPointGeometry) return pointGeometry;
-  	hasRequiredPointGeometry = 1;
-  	pointGeometry = Point;
-  	/**
-  	 * A standalone point geometry with useful accessor, comparison, and
-  	 * modification methods.
-  	 *
-  	 * @class Point
-  	 * @param {Number} x the x-coordinate. this could be longitude or screen
-  	 * pixels, or any other sort of unit.
-  	 * @param {Number} y the y-coordinate. this could be latitude or screen
-  	 * pixels, or any other sort of unit.
-  	 * @example
-  	 * var point = new Point(-77, 38);
-  	 */
-  	function Point(x, y) {
-  	    this.x = x;
-  	    this.y = y;
-  	}
-  	Point.prototype = {
-  	    /**
-  	     * Clone this point, returning a new point that can be modified
-  	     * without affecting the old one.
-  	     * @return {Point} the clone
-  	     */
-  	    clone: function () {
-  	        return new Point(this.x, this.y);
-  	    },
-  	    /**
-  	     * Add this point's x & y coordinates to another point,
-  	     * yielding a new point.
-  	     * @param {Point} p the other point
-  	     * @return {Point} output point
-  	     */
-  	    add: function (p) {
-  	        return this.clone()._add(p);
-  	    },
-  	    /**
-  	     * Subtract this point's x & y coordinates to from point,
-  	     * yielding a new point.
-  	     * @param {Point} p the other point
-  	     * @return {Point} output point
-  	     */
-  	    sub: function (p) {
-  	        return this.clone()._sub(p);
-  	    },
-  	    /**
-  	     * Multiply this point's x & y coordinates by point,
-  	     * yielding a new point.
-  	     * @param {Point} p the other point
-  	     * @return {Point} output point
-  	     */
-  	    multByPoint: function (p) {
-  	        return this.clone()._multByPoint(p);
-  	    },
-  	    /**
-  	     * Divide this point's x & y coordinates by point,
-  	     * yielding a new point.
-  	     * @param {Point} p the other point
-  	     * @return {Point} output point
-  	     */
-  	    divByPoint: function (p) {
-  	        return this.clone()._divByPoint(p);
-  	    },
-  	    /**
-  	     * Multiply this point's x & y coordinates by a factor,
-  	     * yielding a new point.
-  	     * @param {Point} k factor
-  	     * @return {Point} output point
-  	     */
-  	    mult: function (k) {
-  	        return this.clone()._mult(k);
-  	    },
-  	    /**
-  	     * Divide this point's x & y coordinates by a factor,
-  	     * yielding a new point.
-  	     * @param {Point} k factor
-  	     * @return {Point} output point
-  	     */
-  	    div: function (k) {
-  	        return this.clone()._div(k);
-  	    },
-  	    /**
-  	     * Rotate this point around the 0, 0 origin by an angle a,
-  	     * given in radians
-  	     * @param {Number} a angle to rotate around, in radians
-  	     * @return {Point} output point
-  	     */
-  	    rotate: function (a) {
-  	        return this.clone()._rotate(a);
-  	    },
-  	    /**
-  	     * Rotate this point around p point by an angle a,
-  	     * given in radians
-  	     * @param {Number} a angle to rotate around, in radians
-  	     * @param {Point} p Point to rotate around
-  	     * @return {Point} output point
-  	     */
-  	    rotateAround: function (a, p) {
-  	        return this.clone()._rotateAround(a, p);
-  	    },
-  	    /**
-  	     * Multiply this point by a 4x1 transformation matrix
-  	     * @param {Array<Number>} m transformation matrix
-  	     * @return {Point} output point
-  	     */
-  	    matMult: function (m) {
-  	        return this.clone()._matMult(m);
-  	    },
-  	    /**
-  	     * Calculate this point but as a unit vector from 0, 0, meaning
-  	     * that the distance from the resulting point to the 0, 0
-  	     * coordinate will be equal to 1 and the angle from the resulting
-  	     * point to the 0, 0 coordinate will be the same as before.
-  	     * @return {Point} unit vector point
-  	     */
-  	    unit: function () {
-  	        return this.clone()._unit();
-  	    },
-  	    /**
-  	     * Compute a perpendicular point, where the new y coordinate
-  	     * is the old x coordinate and the new x coordinate is the old y
-  	     * coordinate multiplied by -1
-  	     * @return {Point} perpendicular point
-  	     */
-  	    perp: function () {
-  	        return this.clone()._perp();
-  	    },
-  	    /**
-  	     * Return a version of this point with the x & y coordinates
-  	     * rounded to integers.
-  	     * @return {Point} rounded point
-  	     */
-  	    round: function () {
-  	        return this.clone()._round();
-  	    },
-  	    /**
-  	     * Return the magitude of this point: this is the Euclidean
-  	     * distance from the 0, 0 coordinate to this point's x and y
-  	     * coordinates.
-  	     * @return {Number} magnitude
-  	     */
-  	    mag: function () {
-  	        return Math.sqrt(this.x * this.x + this.y * this.y);
-  	    },
-  	    /**
-  	     * Judge whether this point is equal to another point, returning
-  	     * true or false.
-  	     * @param {Point} other the other point
-  	     * @return {boolean} whether the points are equal
-  	     */
-  	    equals: function (other) {
-  	        return this.x === other.x && this.y === other.y;
-  	    },
-  	    /**
-  	     * Calculate the distance from this point to another point
-  	     * @param {Point} p the other point
-  	     * @return {Number} distance
-  	     */
-  	    dist: function (p) {
-  	        return Math.sqrt(this.distSqr(p));
-  	    },
-  	    /**
-  	     * Calculate the distance from this point to another point,
-  	     * without the square root step. Useful if you're comparing
-  	     * relative distances.
-  	     * @param {Point} p the other point
-  	     * @return {Number} distance
-  	     */
-  	    distSqr: function (p) {
-  	        var dx = p.x - this.x, dy = p.y - this.y;
-  	        return dx * dx + dy * dy;
-  	    },
-  	    /**
-  	     * Get the angle from the 0, 0 coordinate to this point, in radians
-  	     * coordinates.
-  	     * @return {Number} angle
-  	     */
-  	    angle: function () {
-  	        return Math.atan2(this.y, this.x);
-  	    },
-  	    /**
-  	     * Get the angle from this point to another point, in radians
-  	     * @param {Point} b the other point
-  	     * @return {Number} angle
-  	     */
-  	    angleTo: function (b) {
-  	        return Math.atan2(this.y - b.y, this.x - b.x);
-  	    },
-  	    /**
-  	     * Get the angle between this point and another point, in radians
-  	     * @param {Point} b the other point
-  	     * @return {Number} angle
-  	     */
-  	    angleWith: function (b) {
-  	        return this.angleWithSep(b.x, b.y);
-  	    },
-  	    /*
-  	     * Find the angle of the two vectors, solving the formula for
-  	     * the cross product a x b = |a||b|sin(θ) for θ.
-  	     * @param {Number} x the x-coordinate
-  	     * @param {Number} y the y-coordinate
-  	     * @return {Number} the angle in radians
-  	     */
-  	    angleWithSep: function (x, y) {
-  	        return Math.atan2(this.x * y - this.y * x, this.x * x + this.y * y);
-  	    },
-  	    _matMult: function (m) {
-  	        var x = m[0] * this.x + m[1] * this.y, y = m[2] * this.x + m[3] * this.y;
-  	        this.x = x;
-  	        this.y = y;
-  	        return this;
-  	    },
-  	    _add: function (p) {
-  	        this.x += p.x;
-  	        this.y += p.y;
-  	        return this;
-  	    },
-  	    _sub: function (p) {
-  	        this.x -= p.x;
-  	        this.y -= p.y;
-  	        return this;
-  	    },
-  	    _mult: function (k) {
-  	        this.x *= k;
-  	        this.y *= k;
-  	        return this;
-  	    },
-  	    _div: function (k) {
-  	        this.x /= k;
-  	        this.y /= k;
-  	        return this;
-  	    },
-  	    _multByPoint: function (p) {
-  	        this.x *= p.x;
-  	        this.y *= p.y;
-  	        return this;
-  	    },
-  	    _divByPoint: function (p) {
-  	        this.x /= p.x;
-  	        this.y /= p.y;
-  	        return this;
-  	    },
-  	    _unit: function () {
-  	        this._div(this.mag());
-  	        return this;
-  	    },
-  	    _perp: function () {
-  	        var y = this.y;
-  	        this.y = this.x;
-  	        this.x = -y;
-  	        return this;
-  	    },
-  	    _rotate: function (angle) {
-  	        var cos = Math.cos(angle), sin = Math.sin(angle), x = cos * this.x - sin * this.y, y = sin * this.x + cos * this.y;
-  	        this.x = x;
-  	        this.y = y;
-  	        return this;
-  	    },
-  	    _rotateAround: function (angle, p) {
-  	        var cos = Math.cos(angle), sin = Math.sin(angle), x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y), y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);
-  	        this.x = x;
-  	        this.y = y;
-  	        return this;
-  	    },
-  	    _round: function () {
-  	        this.x = Math.round(this.x);
-  	        this.y = Math.round(this.y);
-  	        return this;
-  	    }
-  	};
-  	/**
-  	 * Construct a point from an array if necessary, otherwise if the input
-  	 * is already a Point, or an unknown type, return it unchanged
-  	 * @param {Array<Number>|Point|*} a any kind of input value
-  	 * @return {Point} constructed point, or passed-through value.
-  	 * @example
-  	 * // this
-  	 * var point = Point.convert([0, 1]);
-  	 * // is equivalent to
-  	 * var point = new Point(0, 1);
-  	 */
-  	Point.convert = function (a) {
-  	    if (a instanceof Point) {
-  	        return a;
-  	    }
-  	    if (Array.isArray(a)) {
-  	        return new Point(a[0], a[1]);
-  	    }
-  	    return a;
-  	};
-  	return pointGeometry;
+  /**
+   * A standalone point geometry with useful accessor, comparison, and
+   * modification methods.
+   *
+   * @class
+   * @param {number} x the x-coordinate. This could be longitude or screen pixels, or any other sort of unit.
+   * @param {number} y the y-coordinate. This could be latitude or screen pixels, or any other sort of unit.
+   *
+   * @example
+   * const point = new Point(-77, 38);
+   */
+  function Point(x, y) {
+      this.x = x;
+      this.y = y;
   }
-
-  requirePointGeometry();
+  Point.prototype = {
+      /**
+       * Clone this point, returning a new point that can be modified
+       * without affecting the old one.
+       * @return {Point} the clone
+       */
+      clone() {
+          return new Point(this.x, this.y);
+      },
+      /**
+       * Add this point's x & y coordinates to another point,
+       * yielding a new point.
+       * @param {Point} p the other point
+       * @return {Point} output point
+       */
+      add(p) {
+          return this.clone()._add(p);
+      },
+      /**
+       * Subtract this point's x & y coordinates to from point,
+       * yielding a new point.
+       * @param {Point} p the other point
+       * @return {Point} output point
+       */
+      sub(p) {
+          return this.clone()._sub(p);
+      },
+      /**
+       * Multiply this point's x & y coordinates by point,
+       * yielding a new point.
+       * @param {Point} p the other point
+       * @return {Point} output point
+       */
+      multByPoint(p) {
+          return this.clone()._multByPoint(p);
+      },
+      /**
+       * Divide this point's x & y coordinates by point,
+       * yielding a new point.
+       * @param {Point} p the other point
+       * @return {Point} output point
+       */
+      divByPoint(p) {
+          return this.clone()._divByPoint(p);
+      },
+      /**
+       * Multiply this point's x & y coordinates by a factor,
+       * yielding a new point.
+       * @param {number} k factor
+       * @return {Point} output point
+       */
+      mult(k) {
+          return this.clone()._mult(k);
+      },
+      /**
+       * Divide this point's x & y coordinates by a factor,
+       * yielding a new point.
+       * @param {number} k factor
+       * @return {Point} output point
+       */
+      div(k) {
+          return this.clone()._div(k);
+      },
+      /**
+       * Rotate this point around the 0, 0 origin by an angle a,
+       * given in radians
+       * @param {number} a angle to rotate around, in radians
+       * @return {Point} output point
+       */
+      rotate(a) {
+          return this.clone()._rotate(a);
+      },
+      /**
+       * Rotate this point around p point by an angle a,
+       * given in radians
+       * @param {number} a angle to rotate around, in radians
+       * @param {Point} p Point to rotate around
+       * @return {Point} output point
+       */
+      rotateAround(a, p) {
+          return this.clone()._rotateAround(a, p);
+      },
+      /**
+       * Multiply this point by a 4x1 transformation matrix
+       * @param {[number, number, number, number]} m transformation matrix
+       * @return {Point} output point
+       */
+      matMult(m) {
+          return this.clone()._matMult(m);
+      },
+      /**
+       * Calculate this point but as a unit vector from 0, 0, meaning
+       * that the distance from the resulting point to the 0, 0
+       * coordinate will be equal to 1 and the angle from the resulting
+       * point to the 0, 0 coordinate will be the same as before.
+       * @return {Point} unit vector point
+       */
+      unit() {
+          return this.clone()._unit();
+      },
+      /**
+       * Compute a perpendicular point, where the new y coordinate
+       * is the old x coordinate and the new x coordinate is the old y
+       * coordinate multiplied by -1
+       * @return {Point} perpendicular point
+       */
+      perp() {
+          return this.clone()._perp();
+      },
+      /**
+       * Return a version of this point with the x & y coordinates
+       * rounded to integers.
+       * @return {Point} rounded point
+       */
+      round() {
+          return this.clone()._round();
+      },
+      /**
+       * Return the magnitude of this point: this is the Euclidean
+       * distance from the 0, 0 coordinate to this point's x and y
+       * coordinates.
+       * @return {number} magnitude
+       */
+      mag() {
+          return Math.sqrt(this.x * this.x + this.y * this.y);
+      },
+      /**
+       * Judge whether this point is equal to another point, returning
+       * true or false.
+       * @param {Point} other the other point
+       * @return {boolean} whether the points are equal
+       */
+      equals(other) {
+          return this.x === other.x && this.y === other.y;
+      },
+      /**
+       * Calculate the distance from this point to another point
+       * @param {Point} p the other point
+       * @return {number} distance
+       */
+      dist(p) {
+          return Math.sqrt(this.distSqr(p));
+      },
+      /**
+       * Calculate the distance from this point to another point,
+       * without the square root step. Useful if you're comparing
+       * relative distances.
+       * @param {Point} p the other point
+       * @return {number} distance
+       */
+      distSqr(p) {
+          const dx = p.x - this.x, dy = p.y - this.y;
+          return dx * dx + dy * dy;
+      },
+      /**
+       * Get the angle from the 0, 0 coordinate to this point, in radians
+       * coordinates.
+       * @return {number} angle
+       */
+      angle() {
+          return Math.atan2(this.y, this.x);
+      },
+      /**
+       * Get the angle from this point to another point, in radians
+       * @param {Point} b the other point
+       * @return {number} angle
+       */
+      angleTo(b) {
+          return Math.atan2(this.y - b.y, this.x - b.x);
+      },
+      /**
+       * Get the angle between this point and another point, in radians
+       * @param {Point} b the other point
+       * @return {number} angle
+       */
+      angleWith(b) {
+          return this.angleWithSep(b.x, b.y);
+      },
+      /**
+       * Find the angle of the two vectors, solving the formula for
+       * the cross product a x b = |a||b|sin(θ) for θ.
+       * @param {number} x the x-coordinate
+       * @param {number} y the y-coordinate
+       * @return {number} the angle in radians
+       */
+      angleWithSep(x, y) {
+          return Math.atan2(this.x * y - this.y * x, this.x * x + this.y * y);
+      },
+      /** @param {[number, number, number, number]} m */
+      _matMult(m) {
+          const x = m[0] * this.x + m[1] * this.y, y = m[2] * this.x + m[3] * this.y;
+          this.x = x;
+          this.y = y;
+          return this;
+      },
+      /** @param {Point} p */
+      _add(p) {
+          this.x += p.x;
+          this.y += p.y;
+          return this;
+      },
+      /** @param {Point} p */
+      _sub(p) {
+          this.x -= p.x;
+          this.y -= p.y;
+          return this;
+      },
+      /** @param {number} k */
+      _mult(k) {
+          this.x *= k;
+          this.y *= k;
+          return this;
+      },
+      /** @param {number} k */
+      _div(k) {
+          this.x /= k;
+          this.y /= k;
+          return this;
+      },
+      /** @param {Point} p */
+      _multByPoint(p) {
+          this.x *= p.x;
+          this.y *= p.y;
+          return this;
+      },
+      /** @param {Point} p */
+      _divByPoint(p) {
+          this.x /= p.x;
+          this.y /= p.y;
+          return this;
+      },
+      _unit() {
+          this._div(this.mag());
+          return this;
+      },
+      _perp() {
+          const y = this.y;
+          this.y = this.x;
+          this.x = -y;
+          return this;
+      },
+      /** @param {number} angle */
+      _rotate(angle) {
+          const cos = Math.cos(angle), sin = Math.sin(angle), x = cos * this.x - sin * this.y, y = sin * this.x + cos * this.y;
+          this.x = x;
+          this.y = y;
+          return this;
+      },
+      /**
+       * @param {number} angle
+       * @param {Point} p
+       */
+      _rotateAround(angle, p) {
+          const cos = Math.cos(angle), sin = Math.sin(angle), x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y), y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);
+          this.x = x;
+          this.y = y;
+          return this;
+      },
+      _round() {
+          this.x = Math.round(this.x);
+          this.y = Math.round(this.y);
+          return this;
+      },
+      constructor: Point
+  };
+  /**
+   * Construct a point from an array if necessary, otherwise if the input
+   * is already a Point, return it unchanged.
+   * @param {Point | [number, number] | {x: number, y: number}} p input value
+   * @return {Point} constructed point.
+   * @example
+   * // this
+   * var point = Point.convert([0, 1]);
+   * // is equivalent to
+   * var point = new Point(0, 1);
+   */
+  Point.convert = function (p) {
+      if (p instanceof Point) {
+          return p;
+      }
+      if (Array.isArray(p)) {
+          return new Point(+p[0], +p[1]);
+      }
+      if (p.x !== undefined && p.y !== undefined) {
+          return new Point(+p.x, +p.y);
+      }
+      throw new Error('Expected [x, y] or {x, y} point format');
+  };
 
   function calculateSignedArea(ring) {
       let sum = 0;
@@ -17365,6 +17509,43 @@
       }
   }
 
+  class Split {
+      constructor(str, delimiter) {
+          this.type = array$1(StringType);
+          this.str = str;
+          this.delimiter = delimiter;
+      }
+      static parse(args, context) {
+          if (args.length !== 3) {
+              return context.error(`Expected 2 arguments, but found ${ args.length - 1 } instead.`);
+          }
+          const str = context.parse(args[1], 1, StringType);
+          const delimiter = context.parse(args[2], 2, StringType);
+          if (!str || !delimiter)
+              return;
+          return new Split(str, delimiter);
+      }
+      evaluate(ctx) {
+          const str = this.str.evaluate(ctx);
+          const delimiter = this.delimiter.evaluate(ctx);
+          return str.split(delimiter);
+      }
+      eachChild(fn) {
+          fn(this.str);
+          fn(this.delimiter);
+      }
+      outputDefined() {
+          return false;
+      }
+      serialize() {
+          return [
+              'split',
+              this.str.serialize(),
+              this.delimiter.serialize()
+          ];
+      }
+  }
+
   function isComparableType(op, type) {
       if (op === '==' || op === '!=') {
           return type.kind === 'boolean' || type.kind === 'string' || type.kind === 'number' || type.kind === 'null' || type.kind === 'value';
@@ -17696,7 +17877,8 @@
       'var': Var,
       'within': Within,
       'distance': Distance,
-      'config': Config
+      'config': Config,
+      'split': Split
   };
   function rgba(ctx, [r, g, b, a]) {
       r = r.evaluate(ctx);