planning

node_modules/@mapbox/mapbox-gl-style-spec/expression/compound_expression.js

@@ -0,0 +1,162 @@
+// @flow
+
+import {toString} from './types.js';
+
+import ParsingContext from './parsing_context.js';
+import EvaluationContext from './evaluation_context.js';
+import assert from 'assert';
+
+import type {Expression, ExpressionRegistry} from './expression.js';
+import type {Type} from './types.js';
+import type {Value} from './values.js';
+
+export type Varargs = {| type: Type |};
+type Signature = Array<Type> | Varargs;
+type Evaluate = (EvaluationContext, Array<Expression>) => Value;
+type Definition = [Type, Signature, Evaluate] |
+    {|type: Type, overloads: Array<[Signature, Evaluate]>|};
+
+class CompoundExpression implements Expression {
+    name: string;
+    type: Type;
+    _evaluate: Evaluate;
+    args: Array<Expression>;
+
+    static definitions: {[_: string]: Definition };
+
+    constructor(name: string, type: Type, evaluate: Evaluate, args: Array<Expression>) {
+        this.name = name;
+        this.type = type;
+        this._evaluate = evaluate;
+        this.args = args;
+    }
+
+    evaluate(ctx: EvaluationContext): Value {
+        return this._evaluate(ctx, this.args);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        this.args.forEach(fn);
+    }
+
+    outputDefined(): boolean {
+        return false;
+    }
+
+    serialize(): Array<mixed> {
+        return [this.name].concat(this.args.map(arg => arg.serialize()));
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+        const op: string = (args[0]: any);
+        const definition = CompoundExpression.definitions[op];
+        if (!definition) {
+            return context.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
+        }
+
+        // Now check argument types against each signature
+        const type = Array.isArray(definition) ?
+            definition[0] : definition.type;
+
+        const availableOverloads = Array.isArray(definition) ?
+            [[definition[1], definition[2]]] :
+            definition.overloads;
+
+        const overloads = availableOverloads.filter(([signature]) => (
+            !Array.isArray(signature) || // varags
+            signature.length === args.length - 1 // correct param count
+        ));
+
+        let signatureContext: ParsingContext = (null: any);
+
+        for (const [params, evaluate] of overloads) {
+            // Use a fresh context for each attempted signature so that, if
+            // we eventually succeed, we haven't polluted `context.errors`.
+            signatureContext = new ParsingContext(context.registry, context.path, null, context.scope);
+
+            // First parse all the args, potentially coercing to the
+            // types expected by this overload.
+            const parsedArgs: Array<Expression> = [];
+            let argParseFailed = false;
+            for (let i = 1; i < args.length; i++) {
+                const arg = args[i];
+                const expectedType = Array.isArray(params) ?
+                    params[i - 1] :
+                    params.type;
+
+                const parsed = signatureContext.parse(arg, 1 + parsedArgs.length, expectedType);
+                if (!parsed) {
+                    argParseFailed = true;
+                    break;
+                }
+                parsedArgs.push(parsed);
+            }
+            if (argParseFailed) {
+                // Couldn't coerce args of this overload to expected type, move
+                // on to next one.
+                continue;
+            }
+
+            if (Array.isArray(params)) {
+                if (params.length !== parsedArgs.length) {
+                    signatureContext.error(`Expected ${params.length} arguments, but found ${parsedArgs.length} instead.`);
+                    continue;
+                }
+            }
+
+            for (let i = 0; i < parsedArgs.length; i++) {
+                const expected = Array.isArray(params) ? params[i] : params.type;
+                const arg = parsedArgs[i];
+                signatureContext.concat(i + 1).checkSubtype(expected, arg.type);
+            }
+
+            if (signatureContext.errors.length === 0) {
+                return new CompoundExpression(op, type, evaluate, parsedArgs);
+            }
+        }
+
+        assert(!signatureContext || signatureContext.errors.length > 0);
+
+        if (overloads.length === 1) {
+            context.errors.push(...signatureContext.errors);
+        } else {
+            const expected = overloads.length ? overloads : availableOverloads;
+            const signatures = expected
+                .map(([params]) => stringifySignature(params))
+                .join(' | ');
+
+            const actualTypes = [];
+            // For error message, re-parse arguments without trying to
+            // apply any coercions
+            for (let i = 1; i < args.length; i++) {
+                const parsed = context.parse(args[i], 1 + actualTypes.length);
+                if (!parsed) return null;
+                actualTypes.push(toString(parsed.type));
+            }
+            context.error(`Expected arguments of type ${signatures}, but found (${actualTypes.join(', ')}) instead.`);
+        }
+
+        return null;
+    }
+
+    static register(
+        registry: ExpressionRegistry,
+        definitions: {[_: string]: Definition }
+    ) {
+        assert(!CompoundExpression.definitions);
+        CompoundExpression.definitions = definitions;
+        for (const name in definitions) {
+            registry[name] = CompoundExpression;
+        }
+    }
+}
+
+function stringifySignature(signature: Signature): string {
+    if (Array.isArray(signature)) {
+        return `(${signature.map(toString).join(', ')})`;
+    } else {
+        return `(${toString(signature.type)}...)`;
+    }
+}
+
+export default CompoundExpression;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/assertion.js

@@ -0,0 +1,130 @@
+// @flow
+
+import assert from 'assert';
+
+import {
+    ObjectType,
+    ValueType,
+    StringType,
+    NumberType,
+    BooleanType,
+    checkSubtype,
+    toString,
+    array
+} from '../types.js';
+import RuntimeError from '../runtime_error.js';
+import {typeOf} from '../values.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+const types = {
+    string: StringType,
+    number: NumberType,
+    boolean: BooleanType,
+    object: ObjectType
+};
+
+class Assertion implements Expression {
+    type: Type;
+    args: Array<Expression>;
+
+    constructor(type: Type, args: Array<Expression>) {
+        this.type = type;
+        this.args = args;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+        if (args.length < 2)
+            return context.error(`Expected at least one argument.`);
+
+        let i = 1;
+        let type;
+
+        const name: string = (args[0]: any);
+        if (name === 'array') {
+            let itemType;
+            if (args.length > 2) {
+                const type = args[1];
+                if (typeof type !== 'string' || !(type in types) || type === 'object')
+                    return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
+                itemType = types[type];
+                i++;
+            } else {
+                itemType = ValueType;
+            }
+
+            let N;
+            if (args.length > 3) {
+                if (args[2] !== null &&
+                    (typeof args[2] !== 'number' ||
+                        args[2] < 0 ||
+                        args[2] !== Math.floor(args[2]))
+                ) {
+                    return context.error('The length argument to "array" must be a positive integer literal', 2);
+                }
+                N = args[2];
+                i++;
+            }
+
+            type = array(itemType, N);
+        } else {
+            assert(types[name], name);
+            type = types[name];
+        }
+
+        const parsed = [];
+        for (; i < args.length; i++) {
+            const input = context.parse(args[i], i, ValueType);
+            if (!input) return null;
+            parsed.push(input);
+        }
+
+        return new Assertion(type, parsed);
+    }
+
+    evaluate(ctx: EvaluationContext): any | null {
+        for (let i = 0; i < this.args.length; i++) {
+            const value = this.args[i].evaluate(ctx);
+            const error = checkSubtype(this.type, typeOf(value));
+            if (!error) {
+                return value;
+            } else if (i === this.args.length - 1) {
+                throw new RuntimeError(`Expected value to be of type ${toString(this.type)}, but found ${toString(typeOf(value))} instead.`);
+            }
+        }
+
+        assert(false);
+        return null;
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        this.args.forEach(fn);
+    }
+
+    outputDefined(): boolean {
+        return this.args.every(arg => arg.outputDefined());
+    }
+
+    serialize(): SerializedExpression {
+        const type = this.type;
+        const serialized = [type.kind];
+        if (type.kind === 'array') {
+            const itemType = type.itemType;
+            if (itemType.kind === 'string' ||
+                itemType.kind === 'number' ||
+                itemType.kind === 'boolean') {
+                serialized.push(itemType.kind);
+                const N = type.N;
+                if (typeof N === 'number' || this.args.length > 1) {
+                    serialized.push(N);
+                }
+            }
+        }
+        return serialized.concat(this.args.map(arg => arg.serialize()));
+    }
+}
+
+export default Assertion;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/at.js

@@ -0,0 +1,70 @@
+// @flow
+
+import {array, ValueType, NumberType} from '../types.js';
+
+import RuntimeError from '../runtime_error.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type, ArrayType} from '../types.js';
+import type {Value} from '../values.js';
+
+class At implements Expression {
+    type: Type;
+    index: Expression;
+    input: Expression;
+
+    constructor(type: Type, index: Expression, input: Expression) {
+        this.type = type;
+        this.index = index;
+        this.input = input;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?At {
+        if (args.length !== 3)
+            return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
+
+        const index = context.parse(args[1], 1, NumberType);
+        const input = context.parse(args[2], 2, array(context.expectedType || ValueType));
+
+        if (!index || !input) return null;
+
+        const t: ArrayType = (input.type: any);
+        return new At(t.itemType, index, input);
+    }
+
+    evaluate(ctx: EvaluationContext): Value {
+        const index = ((this.index.evaluate(ctx): any): number);
+        const array = ((this.input.evaluate(ctx): any): Array<Value>);
+
+        if (index < 0) {
+            throw new RuntimeError(`Array index out of bounds: ${index} < 0.`);
+        }
+
+        if (index >= array.length) {
+            throw new RuntimeError(`Array index out of bounds: ${index} > ${array.length - 1}.`);
+        }
+
+        if (index !== Math.floor(index)) {
+            throw new RuntimeError(`Array index must be an integer, but found ${index} instead.`);
+        }
+
+        return array[index];
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.index);
+        fn(this.input);
+    }
+
+    outputDefined(): boolean {
+        return false;
+    }
+
+    serialize(): SerializedExpression {
+        return ["at", this.index.serialize(), this.input.serialize()];
+    }
+}
+
+export default At;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/case.js

@@ -0,0 +1,85 @@
+// @flow
+
+import assert from 'assert';
+
+import {BooleanType} from '../types.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+type Branches = Array<[Expression, Expression]>;
+
+class Case implements Expression {
+    type: Type;
+
+    branches: Branches;
+    otherwise: Expression;
+
+    constructor(type: Type, branches: Branches, otherwise: Expression) {
+        this.type = type;
+        this.branches = branches;
+        this.otherwise = otherwise;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Case {
+        if (args.length < 4)
+            return context.error(`Expected at least 3 arguments, but found only ${args.length - 1}.`);
+        if (args.length % 2 !== 0)
+            return context.error(`Expected an odd number of arguments.`);
+
+        let outputType: ?Type;
+        if (context.expectedType && context.expectedType.kind !== 'value') {
+            outputType = context.expectedType;
+        }
+
+        const branches = [];
+        for (let i = 1; i < args.length - 1; i += 2) {
+            const test = context.parse(args[i], i, BooleanType);
+            if (!test) return null;
+
+            const result = context.parse(args[i + 1], i + 1, outputType);
+            if (!result) return null;
+
+            branches.push([test, result]);
+
+            outputType = outputType || result.type;
+        }
+
+        const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
+        if (!otherwise) return null;
+
+        assert(outputType);
+        return new Case((outputType: any), branches, otherwise);
+    }
+
+    evaluate(ctx: EvaluationContext): any {
+        for (const [test, expression] of this.branches) {
+            if (test.evaluate(ctx)) {
+                return expression.evaluate(ctx);
+            }
+        }
+        return this.otherwise.evaluate(ctx);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        for (const [test, expression] of this.branches) {
+            fn(test);
+            fn(expression);
+        }
+        fn(this.otherwise);
+    }
+
+    outputDefined(): boolean {
+        return this.branches.every(([_, out]) => out.outputDefined()) && this.otherwise.outputDefined();
+    }
+
+    serialize(): SerializedExpression {
+        const serialized = ["case"];
+        this.eachChild(child => { serialized.push(child.serialize()); });
+        return serialized;
+    }
+}
+
+export default Case;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/coalesce.js

@@ -0,0 +1,95 @@
+// @flow
+
+import assert from 'assert';
+
+import {checkSubtype, ValueType} from '../types.js';
+import ResolvedImage from '../types/resolved_image.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+class Coalesce implements Expression {
+    type: Type;
+    args: Array<Expression>;
+
+    constructor(type: Type, args: Array<Expression>) {
+        this.type = type;
+        this.args = args;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Coalesce {
+        if (args.length < 2) {
+            return context.error("Expectected at least one argument.");
+        }
+        let outputType: Type = (null: any);
+        const expectedType = context.expectedType;
+        if (expectedType && expectedType.kind !== 'value') {
+            outputType = expectedType;
+        }
+        const parsedArgs = [];
+
+        for (const arg of args.slice(1)) {
+            const parsed = context.parse(arg, 1 + parsedArgs.length, outputType, undefined, {typeAnnotation: 'omit'});
+            if (!parsed) return null;
+            outputType = outputType || parsed.type;
+            parsedArgs.push(parsed);
+        }
+        assert(outputType);
+
+        // Above, we parse arguments without inferred type annotation so that
+        // they don't produce a runtime error for `null` input, which would
+        // preempt the desired null-coalescing behavior.
+        // Thus, if any of our arguments would have needed an annotation, we
+        // need to wrap the enclosing coalesce expression with it instead.
+        const needsAnnotation = expectedType &&
+            parsedArgs.some(arg => checkSubtype(expectedType, arg.type));
+
+        return needsAnnotation ?
+            new Coalesce(ValueType, parsedArgs) :
+            new Coalesce((outputType: any), parsedArgs);
+    }
+
+    evaluate(ctx: EvaluationContext): any | null {
+        let result = null;
+        let argCount = 0;
+        let firstImage;
+        for (const arg of this.args) {
+            argCount++;
+            result = arg.evaluate(ctx);
+            // we need to keep track of the first requested image in a coalesce statement
+            // if coalesce can't find a valid image, we return the first image so styleimagemissing can fire
+            if (result && result instanceof ResolvedImage && !result.available) {
+                // set to first image
+                if (!firstImage) {
+                    firstImage = result;
+                }
+                result = null;
+                // if we reach the end, return the first image
+                if (argCount === this.args.length) {
+                    return firstImage;
+                }
+            }
+
+            if (result !== null) break;
+        }
+        return result;
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        this.args.forEach(fn);
+    }
+
+    outputDefined(): boolean {
+        return this.args.every(arg => arg.outputDefined());
+    }
+
+    serialize(): SerializedExpression {
+        const serialized = ["coalesce"];
+        this.eachChild(child => { serialized.push(child.serialize()); });
+        return serialized;
+    }
+}
+
+export default Coalesce;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/coercion.js

@@ -0,0 +1,133 @@
+// @flow
+
+import assert from 'assert';
+
+import {BooleanType, ColorType, NumberType, StringType, ValueType} from '../types.js';
+import {Color, toString as valueToString, validateRGBA} from '../values.js';
+import RuntimeError from '../runtime_error.js';
+import Formatted from '../types/formatted.js';
+import FormatExpression from '../definitions/format.js';
+import ImageExpression from '../definitions/image.js';
+import ResolvedImage from '../types/resolved_image.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+const types = {
+    'to-boolean': BooleanType,
+    'to-color': ColorType,
+    'to-number': NumberType,
+    'to-string': StringType
+};
+
+/**
+ * Special form for error-coalescing coercion expressions "to-number",
+ * "to-color".  Since these coercions can fail at runtime, they accept multiple
+ * arguments, only evaluating one at a time until one succeeds.
+ *
+ * @private
+ */
+class Coercion implements Expression {
+    type: Type;
+    args: Array<Expression>;
+
+    constructor(type: Type, args: Array<Expression>) {
+        this.type = type;
+        this.args = args;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+        if (args.length < 2)
+            return context.error(`Expected at least one argument.`);
+
+        const name: string = (args[0]: any);
+        assert(types[name], name);
+
+        if ((name === 'to-boolean' || name === 'to-string') && args.length !== 2)
+            return context.error(`Expected one argument.`);
+
+        const type = types[name];
+
+        const parsed = [];
+        for (let i = 1; i < args.length; i++) {
+            const input = context.parse(args[i], i, ValueType);
+            if (!input) return null;
+            parsed.push(input);
+        }
+
+        return new Coercion(type, parsed);
+    }
+
+    evaluate(ctx: EvaluationContext): null | boolean | number | string | Color | Formatted | ResolvedImage {
+        if (this.type.kind === 'boolean') {
+            return Boolean(this.args[0].evaluate(ctx));
+        } else if (this.type.kind === 'color') {
+            let input;
+            let error;
+            for (const arg of this.args) {
+                input = arg.evaluate(ctx);
+                error = null;
+                if (input instanceof Color) {
+                    return input;
+                } else if (typeof input === 'string') {
+                    const c = ctx.parseColor(input);
+                    if (c) return c;
+                } else if (Array.isArray(input)) {
+                    if (input.length < 3 || input.length > 4) {
+                        error = `Invalid rbga value ${JSON.stringify(input)}: expected an array containing either three or four numeric values.`;
+                    } else {
+                        error = validateRGBA(input[0], input[1], input[2], input[3]);
+                    }
+                    if (!error) {
+                        return new Color((input[0]: any) / 255, (input[1]: any) / 255, (input[2]: any) / 255, (input[3]: any));
+                    }
+                }
+            }
+            throw new RuntimeError(error || `Could not parse color from value '${typeof input === 'string' ? input : String(JSON.stringify(input))}'`);
+        } else if (this.type.kind === 'number') {
+            let value = null;
+            for (const arg of this.args) {
+                value = arg.evaluate(ctx);
+                if (value === null) return 0;
+                const num = Number(value);
+                if (isNaN(num)) continue;
+                return num;
+            }
+            throw new RuntimeError(`Could not convert ${JSON.stringify(value)} to number.`);
+        } else if (this.type.kind === 'formatted') {
+            // There is no explicit 'to-formatted' but this coercion can be implicitly
+            // created by properties that expect the 'formatted' type.
+            return Formatted.fromString(valueToString(this.args[0].evaluate(ctx)));
+        } else if (this.type.kind === 'resolvedImage') {
+            return ResolvedImage.fromString(valueToString(this.args[0].evaluate(ctx)));
+        } else {
+            return valueToString(this.args[0].evaluate(ctx));
+        }
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        this.args.forEach(fn);
+    }
+
+    outputDefined(): boolean {
+        return this.args.every(arg => arg.outputDefined());
+    }
+
+    serialize(): SerializedExpression {
+        if (this.type.kind === 'formatted') {
+            return new FormatExpression([{content: this.args[0], scale: null, font: null, textColor: null}]).serialize();
+        }
+
+        if (this.type.kind === 'resolvedImage') {
+            return new ImageExpression(this.args[0]).serialize();
+        }
+
+        const serialized = [`to-${this.type.kind}`];
+        this.eachChild(child => { serialized.push(child.serialize()); });
+        return serialized;
+    }
+}
+
+export default Coercion;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/collator.js

@@ -0,0 +1,78 @@
+// @flow
+
+import {StringType, BooleanType, CollatorType} from '../types.js';
+import Collator from '../types/collator.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type ParsingContext from '../parsing_context.js';
+import type {Type} from '../types.js';
+
+export default class CollatorExpression implements Expression {
+    type: Type;
+    caseSensitive: Expression;
+    diacriticSensitive: Expression;
+    locale: Expression | null;
+
+    constructor(caseSensitive: Expression, diacriticSensitive: Expression, locale: Expression | null) {
+        this.type = CollatorType;
+        this.locale = locale;
+        this.caseSensitive = caseSensitive;
+        this.diacriticSensitive = diacriticSensitive;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+        if (args.length !== 2)
+            return context.error(`Expected one argument.`);
+
+        const options = (args[1]: any);
+        if (typeof options !== "object" || Array.isArray(options))
+            return context.error(`Collator options argument must be an object.`);
+
+        const caseSensitive = context.parse(
+            options['case-sensitive'] === undefined ? false : options['case-sensitive'], 1, BooleanType);
+        if (!caseSensitive) return null;
+
+        const diacriticSensitive = context.parse(
+            options['diacritic-sensitive'] === undefined ? false : options['diacritic-sensitive'], 1, BooleanType);
+        if (!diacriticSensitive) return null;
+
+        let locale = null;
+        if (options['locale']) {
+            locale = context.parse(options['locale'], 1, StringType);
+            if (!locale) return null;
+        }
+
+        return new CollatorExpression(caseSensitive, diacriticSensitive, locale);
+    }
+
+    evaluate(ctx: EvaluationContext): Collator {
+        return new Collator(this.caseSensitive.evaluate(ctx), this.diacriticSensitive.evaluate(ctx), this.locale ? this.locale.evaluate(ctx) : null);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.caseSensitive);
+        fn(this.diacriticSensitive);
+        if (this.locale) {
+            fn(this.locale);
+        }
+    }
+
+    outputDefined(): boolean {
+        // Technically the set of possible outputs is the combinatoric set of Collators produced
+        // by all possible outputs of locale/caseSensitive/diacriticSensitive
+        // But for the primary use of Collators in comparison operators, we ignore the Collator's
+        // possible outputs anyway, so we can get away with leaving this false for now.
+        return false;
+    }
+
+    serialize(): SerializedExpression {
+        const options = {};
+        options['case-sensitive'] = this.caseSensitive.serialize();
+        options['diacritic-sensitive'] = this.diacriticSensitive.serialize();
+        if (this.locale) {
+            options['locale'] = this.locale.serialize();
+        }
+        return ["collator", options];
+    }
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/comparison.js

@@ -0,0 +1,184 @@
+// @flow
+
+import {toString, ValueType, BooleanType, CollatorType} from '../types.js';
+import Assertion from './assertion.js';
+import {typeOf} from '../values.js';
+import RuntimeError from '../runtime_error.js';
+
+import type {Expression, SerializedExpression, ExpressionRegistration} from '../expression.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type ParsingContext from '../parsing_context.js';
+import type {Type} from '../types.js';
+
+type ComparisonOperator = '==' | '!=' | '<' | '>' | '<=' | '>=' ;
+
+function isComparableType(op: ComparisonOperator, type: Type) {
+    if (op === '==' || op === '!=') {
+        // equality operator
+        return type.kind === 'boolean' ||
+            type.kind === 'string' ||
+            type.kind === 'number' ||
+            type.kind === 'null' ||
+            type.kind === 'value';
+    } else {
+        // ordering operator
+        return type.kind === 'string' ||
+            type.kind === 'number' ||
+            type.kind === 'value';
+    }
+}
+
+function eq(ctx: EvaluationContext, a: any, b: any): boolean { return a === b; }
+function neq(ctx: EvaluationContext, a: any, b: any): boolean { return a !== b; }
+function lt(ctx: EvaluationContext, a: any, b: any): boolean { return a < b; }
+function gt(ctx: EvaluationContext, a: any, b: any): boolean { return a > b; }
+function lteq(ctx: EvaluationContext, a: any, b: any): boolean { return a <= b; }
+function gteq(ctx: EvaluationContext, a: any, b: any): boolean { return a >= b; }
+
+function eqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) === 0; }
+function neqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return !eqCollate(ctx, a, b, c); }
+function ltCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) < 0; }
+function gtCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) > 0; }
+function lteqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) <= 0; }
+function gteqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) >= 0; }
+
+/**
+ * Special form for comparison operators, implementing the signatures:
+ * - (T, T, ?Collator) => boolean
+ * - (T, value, ?Collator) => boolean
+ * - (value, T, ?Collator) => boolean
+ *
+ * For inequalities, T must be either value, string, or number. For ==/!=, it
+ * can also be boolean or null.
+ *
+ * Equality semantics are equivalent to Javascript's strict equality (===/!==)
+ * -- i.e., when the arguments' types don't match, == evaluates to false, != to
+ * true.
+ *
+ * When types don't match in an ordering comparison, a runtime error is thrown.
+ *
+ * @private
+ */
+function makeComparison(op: ComparisonOperator, compareBasic: (EvaluationContext, any, any) => boolean, compareWithCollator: (EvaluationContext, any, any, any) => boolean): ExpressionRegistration {
+    const isOrderComparison = op !== '==' && op !== '!=';
+
+    return class Comparison implements Expression {
+        type: Type;
+        lhs: Expression;
+        rhs: Expression;
+        collator: ?Expression;
+        hasUntypedArgument: boolean;
+
+        constructor(lhs: Expression, rhs: Expression, collator: ?Expression) {
+            this.type = BooleanType;
+            this.lhs = lhs;
+            this.rhs = rhs;
+            this.collator = collator;
+            this.hasUntypedArgument = lhs.type.kind === 'value' || rhs.type.kind === 'value';
+        }
+
+        static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+            if (args.length !== 3 && args.length !== 4)
+                return context.error(`Expected two or three arguments.`);
+
+            const op: ComparisonOperator = (args[0]: any);
+
+            let lhs = context.parse(args[1], 1, ValueType);
+            if (!lhs) return null;
+            if (!isComparableType(op, lhs.type)) {
+                return context.concat(1).error(`"${op}" comparisons are not supported for type '${toString(lhs.type)}'.`);
+            }
+            let rhs = context.parse(args[2], 2, ValueType);
+            if (!rhs) return null;
+            if (!isComparableType(op, rhs.type)) {
+                return context.concat(2).error(`"${op}" comparisons are not supported for type '${toString(rhs.type)}'.`);
+            }
+
+            if (
+                lhs.type.kind !== rhs.type.kind &&
+                lhs.type.kind !== 'value' &&
+                rhs.type.kind !== 'value'
+            ) {
+                return context.error(`Cannot compare types '${toString(lhs.type)}' and '${toString(rhs.type)}'.`);
+            }
+
+            if (isOrderComparison) {
+                // typing rules specific to less/greater than operators
+                if (lhs.type.kind === 'value' && rhs.type.kind !== 'value') {
+                    // (value, T)
+                    lhs = new Assertion(rhs.type, [lhs]);
+                } else if (lhs.type.kind !== 'value' && rhs.type.kind === 'value') {
+                    // (T, value)
+                    rhs = new Assertion(lhs.type, [rhs]);
+                }
+            }
+
+            let collator = null;
+            if (args.length === 4) {
+                if (
+                    lhs.type.kind !== 'string' &&
+                    rhs.type.kind !== 'string' &&
+                    lhs.type.kind !== 'value' &&
+                    rhs.type.kind !== 'value'
+                ) {
+                    return context.error(`Cannot use collator to compare non-string types.`);
+                }
+                collator = context.parse(args[3], 3, CollatorType);
+                if (!collator) return null;
+            }
+
+            return new Comparison(lhs, rhs, collator);
+        }
+
+        evaluate(ctx: EvaluationContext): boolean {
+            const lhs = this.lhs.evaluate(ctx);
+            const rhs = this.rhs.evaluate(ctx);
+
+            if (isOrderComparison && this.hasUntypedArgument) {
+                const lt = typeOf(lhs);
+                const rt = typeOf(rhs);
+                // check that type is string or number, and equal
+                if (lt.kind !== rt.kind || !(lt.kind === 'string' || lt.kind === 'number')) {
+                    throw new RuntimeError(`Expected arguments for "${op}" to be (string, string) or (number, number), but found (${lt.kind}, ${rt.kind}) instead.`);
+                }
+            }
+
+            if (this.collator && !isOrderComparison && this.hasUntypedArgument) {
+                const lt = typeOf(lhs);
+                const rt = typeOf(rhs);
+                if (lt.kind !== 'string' || rt.kind !== 'string') {
+                    return compareBasic(ctx, lhs, rhs);
+                }
+            }
+
+            return this.collator ?
+                compareWithCollator(ctx, lhs, rhs, this.collator.evaluate(ctx)) :
+                compareBasic(ctx, lhs, rhs);
+        }
+
+        eachChild(fn: (_: Expression) => void) {
+            fn(this.lhs);
+            fn(this.rhs);
+            if (this.collator) {
+                fn(this.collator);
+            }
+        }
+
+        outputDefined(): boolean {
+            return true;
+        }
+
+        serialize(): SerializedExpression {
+            const serialized = [op];
+            this.eachChild(child => { serialized.push(child.serialize()); });
+            return serialized;
+        }
+    };
+}
+
+export const Equals: $Call<typeof makeComparison, '==', typeof eq, typeof eqCollate> = makeComparison('==', eq, eqCollate);
+export const NotEquals: $Call<typeof makeComparison, '!=', typeof neq, typeof neqCollate> = makeComparison('!=', neq, neqCollate);
+export const LessThan: $Call<typeof makeComparison, '<', typeof lt, typeof ltCollate> = makeComparison('<', lt, ltCollate);
+export const GreaterThan: $Call<typeof makeComparison, '>', typeof gt, typeof gtCollate> = makeComparison('>', gt, gtCollate);
+export const LessThanOrEqual: $Call<typeof makeComparison, '<=', typeof lteq, typeof lteqCollate> = makeComparison('<=', lteq, lteqCollate);
+export const GreaterThanOrEqual: $Call<typeof makeComparison, '>=', typeof gteq, typeof gteqCollate> = makeComparison('>=', gteq, gteqCollate);

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/format.js

@@ -0,0 +1,144 @@
+// @flow
+
+import {NumberType, ValueType, FormattedType, array, StringType, ColorType, ResolvedImageType} from '../types.js';
+import Formatted, {FormattedSection} from '../types/formatted.js';
+import {toString, typeOf} from '../values.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type ParsingContext from '../parsing_context.js';
+import type {Type} from '../types.js';
+
+type FormattedSectionExpression = {
+    // Content of a section may be Image expression or other
+    // type of expression that is coercable to 'string'.
+    content: Expression,
+    scale: Expression | null;
+    font: Expression | null;
+    textColor: Expression | null;
+}
+
+export default class FormatExpression implements Expression {
+    type: Type;
+    sections: Array<FormattedSectionExpression>;
+
+    constructor(sections: Array<FormattedSectionExpression>) {
+        this.type = FormattedType;
+        this.sections = sections;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+        if (args.length < 2) {
+            return context.error(`Expected at least one argument.`);
+        }
+
+        const firstArg = args[1];
+        if (!Array.isArray(firstArg) && typeof firstArg === 'object')  {
+            return context.error(`First argument must be an image or text section.`);
+        }
+
+        const sections: Array<FormattedSectionExpression> = [];
+        let nextTokenMayBeObject = false;
+        for (let i = 1; i <= args.length - 1; ++i) {
+            const arg = (args[i]: any);
+
+            if (nextTokenMayBeObject && typeof arg === "object" && !Array.isArray(arg)) {
+                nextTokenMayBeObject = false;
+
+                let scale = null;
+                if (arg['font-scale']) {
+                    scale = context.parse(arg['font-scale'], 1, NumberType);
+                    if (!scale) return null;
+                }
+
+                let font = null;
+                if (arg['text-font']) {
+                    font = context.parse(arg['text-font'], 1, array(StringType));
+                    if (!font) return null;
+                }
+
+                let textColor = null;
+                if (arg['text-color']) {
+                    textColor = context.parse(arg['text-color'], 1, ColorType);
+                    if (!textColor) return null;
+                }
+
+                const lastExpression = sections[sections.length - 1];
+                lastExpression.scale = scale;
+                lastExpression.font = font;
+                lastExpression.textColor = textColor;
+            } else {
+                const content = context.parse(args[i], 1, ValueType);
+                if (!content) return null;
+
+                const kind = content.type.kind;
+                if (kind !== 'string' && kind !== 'value' && kind !== 'null' && kind !== 'resolvedImage')
+                    return context.error(`Formatted text type must be 'string', 'value', 'image' or 'null'.`);
+
+                nextTokenMayBeObject = true;
+                sections.push({content, scale: null, font: null, textColor: null});
+            }
+        }
+
+        return new FormatExpression(sections);
+    }
+
+    evaluate(ctx: EvaluationContext): Formatted {
+        const evaluateSection = section => {
+            const evaluatedContent = section.content.evaluate(ctx);
+            if (typeOf(evaluatedContent) === ResolvedImageType) {
+                return new FormattedSection('', evaluatedContent, null, null, null);
+            }
+
+            return new FormattedSection(
+                    toString(evaluatedContent),
+                    null,
+                    section.scale ? section.scale.evaluate(ctx) : null,
+                    section.font ? section.font.evaluate(ctx).join(',') : null,
+                    section.textColor ? section.textColor.evaluate(ctx) : null
+            );
+        };
+
+        return new Formatted(this.sections.map(evaluateSection));
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        for (const section of this.sections) {
+            fn(section.content);
+            if (section.scale) {
+                fn(section.scale);
+            }
+            if (section.font) {
+                fn(section.font);
+            }
+            if (section.textColor) {
+                fn(section.textColor);
+            }
+        }
+    }
+
+    outputDefined(): boolean {
+        // Technically the combinatoric set of all children
+        // Usually, this.text will be undefined anyway
+        return false;
+    }
+
+    serialize(): SerializedExpression {
+        const serialized = ["format"];
+        for (const section of this.sections) {
+            serialized.push(section.content.serialize());
+            const options = {};
+            if (section.scale) {
+                options['font-scale'] = section.scale.serialize();
+            }
+            if (section.font) {
+                options['text-font'] = section.font.serialize();
+            }
+            if (section.textColor) {
+                options['text-color'] = section.textColor.serialize();
+            }
+            serialized.push(options);
+        }
+        return serialized;
+    }
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/image.js

@@ -0,0 +1,52 @@
+// @flow
+
+import {ResolvedImageType, StringType} from '../types.js';
+import ResolvedImage from '../types/resolved_image.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type ParsingContext from '../parsing_context.js';
+import type {Type} from '../types.js';
+
+export default class ImageExpression implements Expression {
+    type: Type;
+    input: Expression;
+
+    constructor(input: Expression) {
+        this.type = ResolvedImageType;
+        this.input = input;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+        if (args.length !== 2) {
+            return context.error(`Expected two arguments.`);
+        }
+
+        const name = context.parse(args[1], 1, StringType);
+        if (!name) return context.error(`No image name provided.`);
+
+        return new ImageExpression(name);
+    }
+
+    evaluate(ctx: EvaluationContext): null | ResolvedImage {
+        const evaluatedImageName = this.input.evaluate(ctx);
+
+        const value = ResolvedImage.fromString(evaluatedImageName);
+        if (value && ctx.availableImages) value.available = ctx.availableImages.indexOf(evaluatedImageName) > -1;
+
+        return value;
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.input);
+    }
+
+    outputDefined(): boolean {
+        // The output of image is determined by the list of available images in the evaluation context
+        return false;
+    }
+
+    serialize(): SerializedExpression {
+        return ["image", this.input.serialize()];
+    }
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/in.js

@@ -0,0 +1,72 @@
+// @flow
+
+import {BooleanType, StringType, ValueType, NullType, toString, NumberType, isValidType, isValidNativeType} from '../types.js';
+import RuntimeError from '../runtime_error.js';
+import {typeOf} from '../values.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+class In implements Expression {
+    type: Type;
+    needle: Expression;
+    haystack: Expression;
+
+    constructor(needle: Expression, haystack: Expression) {
+        this.type = BooleanType;
+        this.needle = needle;
+        this.haystack = haystack;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?In {
+        if (args.length !== 3) {
+            return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
+        }
+
+        const needle = context.parse(args[1], 1, ValueType);
+
+        const haystack = context.parse(args[2], 2, ValueType);
+
+        if (!needle || !haystack) return null;
+
+        if (!isValidType(needle.type, [BooleanType, StringType, NumberType, NullType, ValueType])) {
+            return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${toString(needle.type)} instead`);
+        }
+
+        return new In(needle, haystack);
+    }
+
+    evaluate(ctx: EvaluationContext): boolean {
+        const needle = (this.needle.evaluate(ctx): any);
+        const haystack = (this.haystack.evaluate(ctx): any);
+
+        if (haystack == null) return false;
+
+        if (!isValidNativeType(needle, ['boolean', 'string', 'number', 'null'])) {
+            throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${toString(typeOf(needle))} instead.`);
+        }
+
+        if (!isValidNativeType(haystack, ['string', 'array'])) {
+            throw new RuntimeError(`Expected second argument to be of type array or string, but found ${toString(typeOf(haystack))} instead.`);
+        }
+
+        return haystack.indexOf(needle) >= 0;
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.needle);
+        fn(this.haystack);
+    }
+
+    outputDefined(): boolean {
+        return true;
+    }
+
+    serialize(): SerializedExpression {
+        return ["in", this.needle.serialize(), this.haystack.serialize()];
+    }
+}
+
+export default In;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/index.js

@@ -0,0 +1,580 @@
+// @flow
+
+import {
+    type Type,
+    NumberType,
+    StringType,
+    BooleanType,
+    ColorType,
+    ObjectType,
+    ValueType,
+    ErrorType,
+    CollatorType,
+    array,
+    toString as typeToString
+} from '../types.js';
+
+import {typeOf, Color, validateRGBA, toString as valueToString} from '../values.js';
+import CompoundExpression from '../compound_expression.js';
+import RuntimeError from '../runtime_error.js';
+import Let from './let.js';
+import Var from './var.js';
+import Literal from './literal.js';
+import Assertion from './assertion.js';
+import Coercion from './coercion.js';
+import At from './at.js';
+import In from './in.js';
+import IndexOf from './index_of.js';
+import Match from './match.js';
+import Case from './case.js';
+import Slice from './slice.js';
+import Step from './step.js';
+import Interpolate from './interpolate.js';
+import Coalesce from './coalesce.js';
+import {
+    Equals,
+    NotEquals,
+    LessThan,
+    GreaterThan,
+    LessThanOrEqual,
+    GreaterThanOrEqual
+} from './comparison.js';
+import CollatorExpression from './collator.js';
+import NumberFormat from './number_format.js';
+import FormatExpression from './format.js';
+import ImageExpression from './image.js';
+import Length from './length.js';
+import Within from './within.js';
+
+import type {Varargs} from '../compound_expression.js';
+import type {ExpressionRegistry} from '../expression.js';
+
+const expressions: ExpressionRegistry = {
+    // special forms
+    '==': Equals,
+    '!=': NotEquals,
+    '>': GreaterThan,
+    '<': LessThan,
+    '>=': GreaterThanOrEqual,
+    '<=': LessThanOrEqual,
+    'array': Assertion,
+    'at': At,
+    'boolean': Assertion,
+    'case': Case,
+    'coalesce': Coalesce,
+    'collator': CollatorExpression,
+    'format': FormatExpression,
+    'image': ImageExpression,
+    'in': In,
+    'index-of': IndexOf,
+    'interpolate': Interpolate,
+    'interpolate-hcl': Interpolate,
+    'interpolate-lab': Interpolate,
+    'length': Length,
+    'let': Let,
+    'literal': Literal,
+    'match': Match,
+    'number': Assertion,
+    'number-format': NumberFormat,
+    'object': Assertion,
+    'slice': Slice,
+    'step': Step,
+    'string': Assertion,
+    'to-boolean': Coercion,
+    'to-color': Coercion,
+    'to-number': Coercion,
+    'to-string': Coercion,
+    'var': Var,
+    'within': Within
+};
+
+function rgba(ctx, [r, g, b, a]) {
+    r = r.evaluate(ctx);
+    g = g.evaluate(ctx);
+    b = b.evaluate(ctx);
+    const alpha = a ? a.evaluate(ctx) : 1;
+    const error = validateRGBA(r, g, b, alpha);
+    if (error) throw new RuntimeError(error);
+    return new Color(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
+}
+
+function has(key, obj) {
+    return key in obj;
+}
+
+function get(key, obj) {
+    const v = obj[key];
+    return typeof v === 'undefined' ? null : v;
+}
+
+function binarySearch(v, a, i, j) {
+    while (i <= j) {
+        const m = (i + j) >> 1;
+        if (a[m] === v)
+            return true;
+        if (a[m] > v)
+            j = m - 1;
+        else
+            i = m + 1;
+    }
+    return false;
+}
+
+function varargs(type: Type): Varargs {
+    return {type};
+}
+
+CompoundExpression.register(expressions, {
+    'error': [
+        ErrorType,
+        [StringType],
+        (ctx, [v]) => { throw new RuntimeError(v.evaluate(ctx)); }
+    ],
+    'typeof': [
+        StringType,
+        [ValueType],
+        (ctx, [v]) => typeToString(typeOf(v.evaluate(ctx)))
+    ],
+    'to-rgba': [
+        array(NumberType, 4),
+        [ColorType],
+        (ctx, [v]) => {
+            return v.evaluate(ctx).toArray();
+        }
+    ],
+    'rgb': [
+        ColorType,
+        [NumberType, NumberType, NumberType],
+        rgba
+    ],
+    'rgba': [
+        ColorType,
+        [NumberType, NumberType, NumberType, NumberType],
+        rgba
+    ],
+    'has': {
+        type: BooleanType,
+        overloads: [
+            [
+                [StringType],
+                (ctx, [key]) => has(key.evaluate(ctx), ctx.properties())
+            ], [
+                [StringType, ObjectType],
+                (ctx, [key, obj]) => has(key.evaluate(ctx), obj.evaluate(ctx))
+            ]
+        ]
+    },
+    'get': {
+        type: ValueType,
+        overloads: [
+            [
+                [StringType],
+                (ctx, [key]) => get(key.evaluate(ctx), ctx.properties())
+            ], [
+                [StringType, ObjectType],
+                (ctx, [key, obj]) => get(key.evaluate(ctx), obj.evaluate(ctx))
+            ]
+        ]
+    },
+    'feature-state': [
+        ValueType,
+        [StringType],
+        (ctx, [key]) => get(key.evaluate(ctx), ctx.featureState || {})
+    ],
+    'properties': [
+        ObjectType,
+        [],
+        (ctx) => ctx.properties()
+    ],
+    'geometry-type': [
+        StringType,
+        [],
+        (ctx) => ctx.geometryType()
+    ],
+    'id': [
+        ValueType,
+        [],
+        (ctx) => ctx.id()
+    ],
+    'zoom': [
+        NumberType,
+        [],
+        (ctx) => ctx.globals.zoom
+    ],
+    'pitch': [
+        NumberType,
+        [],
+        (ctx) => ctx.globals.pitch || 0
+    ],
+    'distance-from-center': [
+        NumberType,
+        [],
+        (ctx) => ctx.distanceFromCenter()
+    ],
+    'heatmap-density': [
+        NumberType,
+        [],
+        (ctx) => ctx.globals.heatmapDensity || 0
+    ],
+    'line-progress': [
+        NumberType,
+        [],
+        (ctx) => ctx.globals.lineProgress || 0
+    ],
+    'sky-radial-progress': [
+        NumberType,
+        [],
+        (ctx) => ctx.globals.skyRadialProgress || 0
+    ],
+    'accumulated': [
+        ValueType,
+        [],
+        (ctx) => ctx.globals.accumulated === undefined ? null : ctx.globals.accumulated
+    ],
+    '+': [
+        NumberType,
+        varargs(NumberType),
+        (ctx, args) => {
+            let result = 0;
+            for (const arg of args) {
+                result += arg.evaluate(ctx);
+            }
+            return result;
+        }
+    ],
+    '*': [
+        NumberType,
+        varargs(NumberType),
+        (ctx, args) => {
+            let result = 1;
+            for (const arg of args) {
+                result *= arg.evaluate(ctx);
+            }
+            return result;
+        }
+    ],
+    '-': {
+        type: NumberType,
+        overloads: [
+            [
+                [NumberType, NumberType],
+                (ctx, [a, b]) => a.evaluate(ctx) - b.evaluate(ctx)
+            ], [
+                [NumberType],
+                (ctx, [a]) => -a.evaluate(ctx)
+            ]
+        ]
+    },
+    '/': [
+        NumberType,
+        [NumberType, NumberType],
+        (ctx, [a, b]) => a.evaluate(ctx) / b.evaluate(ctx)
+    ],
+    '%': [
+        NumberType,
+        [NumberType, NumberType],
+        (ctx, [a, b]) => a.evaluate(ctx) % b.evaluate(ctx)
+    ],
+    'ln2': [
+        NumberType,
+        [],
+        () => Math.LN2
+    ],
+    'pi': [
+        NumberType,
+        [],
+        () => Math.PI
+    ],
+    'e': [
+        NumberType,
+        [],
+        () => Math.E
+    ],
+    '^': [
+        NumberType,
+        [NumberType, NumberType],
+        (ctx, [b, e]) => Math.pow(b.evaluate(ctx), e.evaluate(ctx))
+    ],
+    'sqrt': [
+        NumberType,
+        [NumberType],
+        (ctx, [x]) => Math.sqrt(x.evaluate(ctx))
+    ],
+    'log10': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.log(n.evaluate(ctx)) / Math.LN10
+    ],
+    'ln': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.log(n.evaluate(ctx))
+    ],
+    'log2': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.log(n.evaluate(ctx)) / Math.LN2
+    ],
+    'sin': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.sin(n.evaluate(ctx))
+    ],
+    'cos': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.cos(n.evaluate(ctx))
+    ],
+    'tan': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.tan(n.evaluate(ctx))
+    ],
+    'asin': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.asin(n.evaluate(ctx))
+    ],
+    'acos': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.acos(n.evaluate(ctx))
+    ],
+    'atan': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.atan(n.evaluate(ctx))
+    ],
+    'min': [
+        NumberType,
+        varargs(NumberType),
+        (ctx, args) => Math.min(...args.map(arg => arg.evaluate(ctx)))
+    ],
+    'max': [
+        NumberType,
+        varargs(NumberType),
+        (ctx, args) => Math.max(...args.map(arg => arg.evaluate(ctx)))
+    ],
+    'abs': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.abs(n.evaluate(ctx))
+    ],
+    'round': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => {
+            const v = n.evaluate(ctx);
+            // Javascript's Math.round() rounds towards +Infinity for halfway
+            // values, even when they're negative. It's more common to round
+            // away from 0 (e.g., this is what python and C++ do)
+            return v < 0 ? -Math.round(-v) : Math.round(v);
+        }
+    ],
+    'floor': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.floor(n.evaluate(ctx))
+    ],
+    'ceil': [
+        NumberType,
+        [NumberType],
+        (ctx, [n]) => Math.ceil(n.evaluate(ctx))
+    ],
+    'filter-==': [
+        BooleanType,
+        [StringType, ValueType],
+        (ctx, [k, v]) => ctx.properties()[(k: any).value] === (v: any).value
+    ],
+    'filter-id-==': [
+        BooleanType,
+        [ValueType],
+        (ctx, [v]) => ctx.id() === (v: any).value
+    ],
+    'filter-type-==': [
+        BooleanType,
+        [StringType],
+        (ctx, [v]) => ctx.geometryType() === (v: any).value
+    ],
+    'filter-<': [
+        BooleanType,
+        [StringType, ValueType],
+        (ctx, [k, v]) => {
+            const a = ctx.properties()[(k: any).value];
+            const b = (v: any).value;
+            return typeof a === typeof b && a < b;
+        }
+    ],
+    'filter-id-<': [
+        BooleanType,
+        [ValueType],
+        (ctx, [v]) => {
+            const a = ctx.id();
+            const b = (v: any).value;
+            return typeof a === typeof b && a < b;
+        }
+    ],
+    'filter->': [
+        BooleanType,
+        [StringType, ValueType],
+        (ctx, [k, v]) => {
+            const a = ctx.properties()[(k: any).value];
+            const b = (v: any).value;
+            return typeof a === typeof b && a > b;
+        }
+    ],
+    'filter-id->': [
+        BooleanType,
+        [ValueType],
+        (ctx, [v]) => {
+            const a = ctx.id();
+            const b = (v: any).value;
+            return typeof a === typeof b && a > b;
+        }
+    ],
+    'filter-<=': [
+        BooleanType,
+        [StringType, ValueType],
+        (ctx, [k, v]) => {
+            const a = ctx.properties()[(k: any).value];
+            const b = (v: any).value;
+            return typeof a === typeof b && a <= b;
+        }
+    ],
+    'filter-id-<=': [
+        BooleanType,
+        [ValueType],
+        (ctx, [v]) => {
+            const a = ctx.id();
+            const b = (v: any).value;
+            return typeof a === typeof b && a <= b;
+        }
+    ],
+    'filter->=': [
+        BooleanType,
+        [StringType, ValueType],
+        (ctx, [k, v]) => {
+            const a = ctx.properties()[(k: any).value];
+            const b = (v: any).value;
+            return typeof a === typeof b && a >= b;
+        }
+    ],
+    'filter-id->=': [
+        BooleanType,
+        [ValueType],
+        (ctx, [v]) => {
+            const a = ctx.id();
+            const b = (v: any).value;
+            return typeof a === typeof b && a >= b;
+        }
+    ],
+    'filter-has': [
+        BooleanType,
+        [ValueType],
+        (ctx, [k]) => (k: any).value in ctx.properties()
+    ],
+    'filter-has-id': [
+        BooleanType,
+        [],
+        (ctx) => (ctx.id() !== null && ctx.id() !== undefined)
+    ],
+    'filter-type-in': [
+        BooleanType,
+        [array(StringType)],
+        (ctx, [v]) => (v: any).value.indexOf(ctx.geometryType()) >= 0
+    ],
+    'filter-id-in': [
+        BooleanType,
+        [array(ValueType)],
+        (ctx, [v]) => (v: any).value.indexOf(ctx.id()) >= 0
+    ],
+    'filter-in-small': [
+        BooleanType,
+        [StringType, array(ValueType)],
+        // assumes v is an array literal
+        (ctx, [k, v]) => (v: any).value.indexOf(ctx.properties()[(k: any).value]) >= 0
+    ],
+    'filter-in-large': [
+        BooleanType,
+        [StringType, array(ValueType)],
+        // assumes v is a array literal with values sorted in ascending order and of a single type
+        (ctx, [k, v]) => binarySearch(ctx.properties()[(k: any).value], (v: any).value, 0, (v: any).value.length - 1)
+    ],
+    'all': {
+        type: BooleanType,
+        overloads: [
+            [
+                [BooleanType, BooleanType],
+                (ctx, [a, b]) => a.evaluate(ctx) && b.evaluate(ctx)
+            ],
+            [
+                varargs(BooleanType),
+                (ctx, args) => {
+                    for (const arg of args) {
+                        if (!arg.evaluate(ctx))
+                            return false;
+                    }
+                    return true;
+                }
+            ]
+        ]
+    },
+    'any': {
+        type: BooleanType,
+        overloads: [
+            [
+                [BooleanType, BooleanType],
+                (ctx, [a, b]) => a.evaluate(ctx) || b.evaluate(ctx)
+            ],
+            [
+                varargs(BooleanType),
+                (ctx, args) => {
+                    for (const arg of args) {
+                        if (arg.evaluate(ctx))
+                            return true;
+                    }
+                    return false;
+                }
+            ]
+        ]
+    },
+    '!': [
+        BooleanType,
+        [BooleanType],
+        (ctx, [b]) => !b.evaluate(ctx)
+    ],
+    'is-supported-script': [
+        BooleanType,
+        [StringType],
+        // At parse time this will always return true, so we need to exclude this expression with isGlobalPropertyConstant
+        (ctx, [s]) => {
+            const isSupportedScript = ctx.globals && ctx.globals.isSupportedScript;
+            if (isSupportedScript) {
+                return isSupportedScript(s.evaluate(ctx));
+            }
+            return true;
+        }
+    ],
+    'upcase': [
+        StringType,
+        [StringType],
+        (ctx, [s]) => s.evaluate(ctx).toUpperCase()
+    ],
+    'downcase': [
+        StringType,
+        [StringType],
+        (ctx, [s]) => s.evaluate(ctx).toLowerCase()
+    ],
+    'concat': [
+        StringType,
+        varargs(ValueType),
+        (ctx, args) => args.map(arg => valueToString(arg.evaluate(ctx))).join('')
+    ],
+    'resolved-locale': [
+        StringType,
+        [CollatorType],
+        (ctx, [collator]) => collator.evaluate(ctx).resolvedLocale()
+    ]
+});
+
+export default expressions;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/index_of.js

@@ -0,0 +1,89 @@
+// @flow
+
+import {BooleanType, StringType, ValueType, NullType, toString, NumberType, isValidType, isValidNativeType} from '../types.js';
+import RuntimeError from '../runtime_error.js';
+import {typeOf} from '../values.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+class IndexOf implements Expression {
+    type: Type;
+    needle: Expression;
+    haystack: Expression;
+    fromIndex: ?Expression;
+
+    constructor(needle: Expression, haystack: Expression, fromIndex?: Expression) {
+        this.type = NumberType;
+        this.needle = needle;
+        this.haystack = haystack;
+        this.fromIndex = fromIndex;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?IndexOf {
+        if (args.length <= 2 ||  args.length >= 5) {
+            return context.error(`Expected 3 or 4 arguments, but found ${args.length - 1} instead.`);
+        }
+
+        const needle = context.parse(args[1], 1, ValueType);
+
+        const haystack = context.parse(args[2], 2, ValueType);
+
+        if (!needle || !haystack) return null;
+        if (!isValidType(needle.type, [BooleanType, StringType, NumberType, NullType, ValueType])) {
+            return context.error(`Expected first argument to be of type boolean, string, number or null, but found ${toString(needle.type)} instead`);
+        }
+
+        if (args.length === 4) {
+            const fromIndex = context.parse(args[3], 3, NumberType);
+            if (!fromIndex) return null;
+            return new IndexOf(needle, haystack, fromIndex);
+        } else {
+            return new IndexOf(needle, haystack);
+        }
+    }
+
+    evaluate(ctx: EvaluationContext): any {
+        const needle = (this.needle.evaluate(ctx): any);
+        const haystack = (this.haystack.evaluate(ctx): any);
+
+        if (!isValidNativeType(needle, ['boolean', 'string', 'number', 'null'])) {
+            throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${toString(typeOf(needle))} instead.`);
+        }
+
+        if (!isValidNativeType(haystack, ['string', 'array'])) {
+            throw new RuntimeError(`Expected second argument to be of type array or string, but found ${toString(typeOf(haystack))} instead.`);
+        }
+
+        if (this.fromIndex) {
+            const fromIndex = (this.fromIndex.evaluate(ctx): number);
+            return haystack.indexOf(needle, fromIndex);
+        }
+
+        return haystack.indexOf(needle);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.needle);
+        fn(this.haystack);
+        if (this.fromIndex) {
+            fn(this.fromIndex);
+        }
+    }
+
+    outputDefined(): boolean {
+        return false;
+    }
+
+    serialize(): SerializedExpression {
+        if (this.fromIndex != null && this.fromIndex !== undefined) {
+            const fromIndex = this.fromIndex.serialize();
+            return ["index-of", this.needle.serialize(), this.haystack.serialize(), fromIndex];
+        }
+        return ["index-of", this.needle.serialize(), this.haystack.serialize()];
+    }
+}
+
+export default IndexOf;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/interpolate.js

@@ -0,0 +1,268 @@
+// @flow
+
+import UnitBezier from '@mapbox/unitbezier';
+
+import * as interpolate from '../../util/interpolate.js';
+import {toString, NumberType, ColorType} from '../types.js';
+import {findStopLessThanOrEqualTo} from '../stops.js';
+import {hcl, lab} from '../../util/color_spaces.js';
+import Color from '../../util/color.js';
+
+import type {Stops} from '../stops.js';
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+export type InterpolationType =
+    { name: 'linear' } |
+    { name: 'exponential', base: number } |
+    { name: 'cubic-bezier', controlPoints: [number, number, number, number] };
+
+class Interpolate implements Expression {
+    type: Type;
+
+    operator: 'interpolate' | 'interpolate-hcl' | 'interpolate-lab';
+    interpolation: InterpolationType;
+    input: Expression;
+    labels: Array<number>;
+    outputs: Array<Expression>;
+
+    constructor(type: Type, operator: 'interpolate' | 'interpolate-hcl' | 'interpolate-lab', interpolation: InterpolationType, input: Expression, stops: Stops) {
+        this.type = type;
+        this.operator = operator;
+        this.interpolation = interpolation;
+        this.input = input;
+
+        this.labels = [];
+        this.outputs = [];
+        for (const [label, expression] of stops) {
+            this.labels.push(label);
+            this.outputs.push(expression);
+        }
+    }
+
+    static interpolationFactor(interpolation: InterpolationType, input: number, lower: number, upper: number): number {
+        let t = 0;
+        if (interpolation.name === 'exponential') {
+            t = exponentialInterpolation(input, interpolation.base, lower, upper);
+        } else if (interpolation.name === 'linear') {
+            t = exponentialInterpolation(input, 1, lower, upper);
+        } else if (interpolation.name === 'cubic-bezier') {
+            const c = interpolation.controlPoints;
+            const ub = new UnitBezier(c[0], c[1], c[2], c[3]);
+            t = ub.solve(exponentialInterpolation(input, 1, lower, upper));
+        }
+        return t;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Interpolate {
+        let [operator, interpolation, input, ...rest] = args;
+
+        if (!Array.isArray(interpolation) || interpolation.length === 0) {
+            return context.error(`Expected an interpolation type expression.`, 1);
+        }
+
+        if (interpolation[0] === 'linear') {
+            interpolation = {name: 'linear'};
+        } else if (interpolation[0] === 'exponential') {
+            const base = interpolation[1];
+            if (typeof base !== 'number')
+                return context.error(`Exponential interpolation requires a numeric base.`, 1, 1);
+            interpolation = {
+                name: 'exponential',
+                base
+            };
+        } else if (interpolation[0] === 'cubic-bezier') {
+            const controlPoints = interpolation.slice(1);
+            if (
+                controlPoints.length !== 4 ||
+                controlPoints.some(t => typeof t !== 'number' || t < 0 || t > 1)
+            ) {
+                return context.error('Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.', 1);
+            }
+
+            interpolation = {
+                name: 'cubic-bezier',
+                controlPoints: (controlPoints: any)
+            };
+        } else {
+            return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
+        }
+
+        if (args.length - 1 < 4) {
+            return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
+        }
+
+        if ((args.length - 1) % 2 !== 0) {
+            return context.error(`Expected an even number of arguments.`);
+        }
+
+        input = context.parse(input, 2, NumberType);
+        if (!input) return null;
+
+        const stops: Stops = [];
+
+        let outputType: Type = (null: any);
+        if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
+            outputType = ColorType;
+        } else if (context.expectedType && context.expectedType.kind !== 'value') {
+            outputType = context.expectedType;
+        }
+
+        for (let i = 0; i < rest.length; i += 2) {
+            const label = rest[i];
+            const value = rest[i + 1];
+
+            const labelKey = i + 3;
+            const valueKey = i + 4;
+
+            if (typeof label !== 'number') {
+                return context.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
+            }
+
+            if (stops.length && stops[stops.length - 1][0] >= label) {
+                return context.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', labelKey);
+            }
+
+            const parsed = context.parse(value, valueKey, outputType);
+            if (!parsed) return null;
+            outputType = outputType || parsed.type;
+            stops.push([label, parsed]);
+        }
+
+        if (outputType.kind !== 'number' &&
+            outputType.kind !== 'color' &&
+            !(
+                outputType.kind === 'array' &&
+                outputType.itemType.kind === 'number' &&
+                typeof outputType.N === 'number'
+            )
+        ) {
+            return context.error(`Type ${toString(outputType)} is not interpolatable.`);
+        }
+
+        return new Interpolate(outputType, (operator: any), interpolation, input, stops);
+    }
+
+    evaluate(ctx: EvaluationContext): Color {
+        const labels = this.labels;
+        const outputs = this.outputs;
+
+        if (labels.length === 1) {
+            return outputs[0].evaluate(ctx);
+        }
+
+        const value = ((this.input.evaluate(ctx): any): number);
+        if (value <= labels[0]) {
+            return outputs[0].evaluate(ctx);
+        }
+
+        const stopCount = labels.length;
+        if (value >= labels[stopCount - 1]) {
+            return outputs[stopCount - 1].evaluate(ctx);
+        }
+
+        const index = findStopLessThanOrEqualTo(labels, value);
+        const lower = labels[index];
+        const upper = labels[index + 1];
+        const t = Interpolate.interpolationFactor(this.interpolation, value, lower, upper);
+
+        const outputLower = outputs[index].evaluate(ctx);
+        const outputUpper = outputs[index + 1].evaluate(ctx);
+
+        if (this.operator === 'interpolate') {
+            return (interpolate[this.type.kind.toLowerCase()]: any)(outputLower, outputUpper, t); // eslint-disable-line import/namespace
+        } else if (this.operator === 'interpolate-hcl') {
+            return hcl.reverse(hcl.interpolate(hcl.forward(outputLower), hcl.forward(outputUpper), t));
+        } else {
+            return lab.reverse(lab.interpolate(lab.forward(outputLower), lab.forward(outputUpper), t));
+        }
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.input);
+        for (const expression of this.outputs) {
+            fn(expression);
+        }
+    }
+
+    outputDefined(): boolean {
+        return this.outputs.every(out => out.outputDefined());
+    }
+
+    serialize(): SerializedExpression {
+        let interpolation;
+        if (this.interpolation.name === 'linear') {
+            interpolation = ["linear"];
+        } else if (this.interpolation.name === 'exponential') {
+            if  (this.interpolation.base === 1) {
+                interpolation = ["linear"];
+            } else {
+                interpolation = ["exponential", this.interpolation.base];
+            }
+        } else {
+            interpolation = ["cubic-bezier" ].concat(this.interpolation.controlPoints);
+        }
+
+        const serialized = [this.operator, interpolation, this.input.serialize()];
+
+        for (let i = 0; i < this.labels.length; i++) {
+            serialized.push(
+                this.labels[i],
+                this.outputs[i].serialize()
+            );
+        }
+        return serialized;
+    }
+}
+
+/**
+ * Returns a ratio that can be used to interpolate between exponential function
+ * stops.
+ * How it works: Two consecutive stop values define a (scaled and shifted) exponential function `f(x) = a * base^x + b`, where `base` is the user-specified base,
+ * and `a` and `b` are constants affording sufficient degrees of freedom to fit
+ * the function to the given stops.
+ *
+ * Here's a bit of algebra that lets us compute `f(x)` directly from the stop
+ * values without explicitly solving for `a` and `b`:
+ *
+ * First stop value: `f(x0) = y0 = a * base^x0 + b`
+ * Second stop value: `f(x1) = y1 = a * base^x1 + b`
+ * => `y1 - y0 = a(base^x1 - base^x0)`
+ * => `a = (y1 - y0)/(base^x1 - base^x0)`
+ *
+ * Desired value: `f(x) = y = a * base^x + b`
+ * => `f(x) = y0 + a * (base^x - base^x0)`
+ *
+ * From the above, we can replace the `a` in `a * (base^x - base^x0)` and do a
+ * little algebra:
+ * ```
+ * a * (base^x - base^x0) = (y1 - y0)/(base^x1 - base^x0) * (base^x - base^x0)
+ *                     = (y1 - y0) * (base^x - base^x0) / (base^x1 - base^x0)
+ * ```
+ *
+ * If we let `(base^x - base^x0) / (base^x1 base^x0)`, then we have
+ * `f(x) = y0 + (y1 - y0) * ratio`.  In other words, `ratio` may be treated as
+ * an interpolation factor between the two stops' output values.
+ *
+ * (Note: a slightly different form for `ratio`,
+ * `(base^(x-x0) - 1) / (base^(x1-x0) - 1) `, is equivalent, but requires fewer
+ * expensive `Math.pow()` operations.)
+ *
+ * @private
+*/
+function exponentialInterpolation(input, base, lowerValue, upperValue) {
+    const difference = upperValue - lowerValue;
+    const progress = input - lowerValue;
+
+    if (difference === 0) {
+        return 0;
+    } else if (base === 1) {
+        return progress / difference;
+    } else {
+        return (Math.pow(base, progress) - 1) / (Math.pow(base, difference) - 1);
+    }
+}
+
+export default Interpolate;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/length.js

@@ -0,0 +1,61 @@
+// @flow
+
+import {NumberType, toString} from '../types.js';
+
+import {typeOf} from '../values.js';
+import RuntimeError from '../runtime_error.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+class Length implements Expression {
+    type: Type;
+    input: Expression;
+
+    constructor(input: Expression) {
+        this.type = NumberType;
+        this.input = input;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Length {
+        if (args.length !== 2)
+            return context.error(`Expected 1 argument, but found ${args.length - 1} instead.`);
+
+        const input = context.parse(args[1], 1);
+        if (!input) return null;
+
+        if (input.type.kind !== 'array' && input.type.kind !== 'string' && input.type.kind !== 'value')
+            return context.error(`Expected argument of type string or array, but found ${toString(input.type)} instead.`);
+
+        return new Length(input);
+    }
+
+    evaluate(ctx: EvaluationContext): any | number {
+        const input = this.input.evaluate(ctx);
+        if (typeof input === 'string') {
+            return input.length;
+        } else if (Array.isArray(input)) {
+            return input.length;
+        } else {
+            throw new RuntimeError(`Expected value to be of type string or array, but found ${toString(typeOf(input))} instead.`);
+        }
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.input);
+    }
+
+    outputDefined(): boolean {
+        return false;
+    }
+
+    serialize(): SerializedExpression {
+        const serialized = ["length"];
+        this.eachChild(child => { serialized.push(child.serialize()); });
+        return serialized;
+    }
+}
+
+export default Length;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/let.js

@@ -0,0 +1,72 @@
+// @flow
+
+import type {Type} from '../types.js';
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext  from '../evaluation_context.js';
+
+class Let implements Expression {
+    type: Type;
+    bindings: Array<[string, Expression]>;
+    result: Expression;
+
+    constructor(bindings: Array<[string, Expression]>, result: Expression) {
+        this.type = result.type;
+        this.bindings = [].concat(bindings);
+        this.result = result;
+    }
+
+    evaluate(ctx: EvaluationContext): any {
+        return this.result.evaluate(ctx);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        for (const binding of this.bindings) {
+            fn(binding[1]);
+        }
+        fn(this.result);
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Let {
+        if (args.length < 4)
+            return context.error(`Expected at least 3 arguments, but found ${args.length - 1} instead.`);
+
+        const bindings: Array<[string, Expression]> = [];
+        for (let i = 1; i < args.length - 1; i += 2) {
+            const name = args[i];
+
+            if (typeof name !== 'string') {
+                return context.error(`Expected string, but found ${typeof name} instead.`, i);
+            }
+
+            if (/[^a-zA-Z0-9_]/.test(name)) {
+                return context.error(`Variable names must contain only alphanumeric characters or '_'.`, i);
+            }
+
+            const value = context.parse(args[i + 1], i + 1);
+            if (!value) return null;
+
+            bindings.push([name, value]);
+        }
+
+        const result = context.parse(args[args.length - 1], args.length - 1, context.expectedType, bindings);
+        if (!result) return null;
+
+        return new Let(bindings, result);
+    }
+
+    outputDefined(): boolean {
+        return this.result.outputDefined();
+    }
+
+    serialize(): SerializedExpression {
+        const serialized = ["let"];
+        for (const [name, expr] of this.bindings) {
+            serialized.push(name, expr.serialize());
+        }
+        serialized.push(this.result.serialize());
+        return serialized;
+    }
+}
+
+export default Let;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/literal.js

@@ -0,0 +1,77 @@
+// @flow
+
+import assert from 'assert';
+import {isValue, typeOf, Color} from '../values.js';
+import Formatted from '../types/formatted.js';
+
+import type {Type} from '../types.js';
+import type {Value}  from '../values.js';
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+
+class Literal implements Expression {
+    type: Type;
+    value: Value;
+
+    constructor(type: Type, value: Value) {
+        this.type = type;
+        this.value = value;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): void | Literal {
+        if (args.length !== 2)
+            return context.error(`'literal' expression requires exactly one argument, but found ${args.length - 1} instead.`);
+
+        if (!isValue(args[1]))
+            return context.error(`invalid value`);
+
+        const value = (args[1]: any);
+        let type = typeOf(value);
+
+        // special case: infer the item type if possible for zero-length arrays
+        const expected = context.expectedType;
+        if (
+            type.kind === 'array' &&
+            type.N === 0 &&
+            expected &&
+            expected.kind === 'array' &&
+            (typeof expected.N !== 'number' || expected.N === 0)
+        ) {
+            type = expected;
+        }
+
+        return new Literal(type, value);
+    }
+
+    evaluate(): Value {
+        return this.value;
+    }
+
+    eachChild() {}
+
+    outputDefined(): boolean {
+        return true;
+    }
+
+    serialize(): SerializedExpression {
+        if (this.type.kind === 'array' || this.type.kind === 'object') {
+            return ["literal", this.value];
+        } else if (this.value instanceof Color) {
+            // Constant-folding can generate Literal expressions that you
+            // couldn't actually generate with a "literal" expression,
+            // so we have to implement an equivalent serialization here
+            return ["rgba"].concat(this.value.toArray());
+        } else if (this.value instanceof Formatted) {
+            // Same as Color
+            return this.value.serialize();
+        } else {
+            assert(this.value === null ||
+                typeof this.value === 'string' ||
+                typeof this.value === 'number' ||
+                typeof this.value === 'boolean');
+            return (this.value: any);
+        }
+    }
+}
+
+export default Literal;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/match.js

@@ -0,0 +1,158 @@
+// @flow
+
+import assert from 'assert';
+
+import {typeOf} from '../values.js';
+import {ValueType, type Type} from '../types.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+
+// Map input label values to output expression index
+type Cases = {[number | string]: number};
+
+class Match implements Expression {
+    type: Type;
+    inputType: Type;
+
+    input: Expression;
+    cases: Cases;
+    outputs: Array<Expression>;
+    otherwise: Expression;
+
+    constructor(inputType: Type, outputType: Type, input: Expression, cases: Cases, outputs: Array<Expression>, otherwise: Expression) {
+        this.inputType = inputType;
+        this.type = outputType;
+        this.input = input;
+        this.cases = cases;
+        this.outputs = outputs;
+        this.otherwise = otherwise;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Match {
+        if (args.length < 5)
+            return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
+        if (args.length % 2 !== 1)
+            return context.error(`Expected an even number of arguments.`);
+
+        let inputType;
+        let outputType;
+        if (context.expectedType && context.expectedType.kind !== 'value') {
+            outputType = context.expectedType;
+        }
+        const cases = {};
+        const outputs = [];
+        for (let i = 2; i < args.length - 1; i += 2) {
+            let labels = args[i];
+            const value = args[i + 1];
+
+            if (!Array.isArray(labels)) {
+                labels = [labels];
+            }
+
+            const labelContext = context.concat(i);
+            if (labels.length === 0) {
+                return labelContext.error('Expected at least one branch label.');
+            }
+
+            for (const label of labels) {
+                if (typeof label !== 'number' && typeof label !== 'string') {
+                    return labelContext.error(`Branch labels must be numbers or strings.`);
+                } else if (typeof label === 'number' && Math.abs(label) > Number.MAX_SAFE_INTEGER) {
+                    return labelContext.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);
+
+                } else if (typeof label === 'number' && Math.floor(label) !== label) {
+                    return labelContext.error(`Numeric branch labels must be integer values.`);
+
+                } else if (!inputType) {
+                    inputType = typeOf(label);
+                } else if (labelContext.checkSubtype(inputType, typeOf(label))) {
+                    return null;
+                }
+
+                if (typeof cases[String(label)] !== 'undefined') {
+                    return labelContext.error('Branch labels must be unique.');
+                }
+
+                cases[String(label)] = outputs.length;
+            }
+
+            const result = context.parse(value, i, outputType);
+            if (!result) return null;
+            outputType = outputType || result.type;
+            outputs.push(result);
+        }
+
+        const input = context.parse(args[1], 1, ValueType);
+        if (!input) return null;
+
+        const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
+        if (!otherwise) return null;
+
+        assert(inputType && outputType);
+
+        if (input.type.kind !== 'value' && context.concat(1).checkSubtype((inputType: any), input.type)) {
+            return null;
+        }
+
+        return new Match((inputType: any), (outputType: any), input, cases, outputs, otherwise);
+    }
+
+    evaluate(ctx: EvaluationContext): any {
+        const input = (this.input.evaluate(ctx): any);
+        const output = (typeOf(input) === this.inputType && this.outputs[this.cases[input]]) || this.otherwise;
+        return output.evaluate(ctx);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.input);
+        this.outputs.forEach(fn);
+        fn(this.otherwise);
+    }
+
+    outputDefined(): boolean {
+        return this.outputs.every(out => out.outputDefined()) && this.otherwise.outputDefined();
+    }
+
+    serialize(): SerializedExpression {
+        const serialized = ["match", this.input.serialize()];
+
+        // Sort so serialization has an arbitrary defined order, even though
+        // branch order doesn't affect evaluation
+        const sortedLabels = Object.keys(this.cases).sort();
+
+        // Group branches by unique match expression to support condensed
+        // serializations of the form [case1, case2, ...] -> matchExpression
+        const groupedByOutput: Array<[number, Array<number | string>]> = [];
+        const outputLookup: {[index: number]: number} = {}; // lookup index into groupedByOutput for a given output expression
+        for (const label of sortedLabels) {
+            const outputIndex = outputLookup[this.cases[label]];
+            if (outputIndex === undefined) {
+                // First time seeing this output, add it to the end of the grouped list
+                outputLookup[this.cases[label]] = groupedByOutput.length;
+                groupedByOutput.push([this.cases[label], [label]]);
+            } else {
+                // We've seen this expression before, add the label to that output's group
+                groupedByOutput[outputIndex][1].push(label);
+            }
+        }
+
+        const coerceLabel = (label) => this.inputType.kind === 'number' ? Number(label) : label;
+
+        for (const [outputIndex, labels] of groupedByOutput) {
+            if (labels.length === 1) {
+                // Only a single label matches this output expression
+                serialized.push(coerceLabel(labels[0]));
+            } else {
+                // Array of literal labels pointing to this output expression
+                serialized.push(labels.map(coerceLabel));
+            }
+            serialized.push(this.outputs[outputIndex].serialize());
+        }
+        serialized.push(this.otherwise.serialize());
+        return serialized;
+    }
+}
+
+export default Match;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/number_format.js

@@ -0,0 +1,162 @@
+// @flow
+
+import {StringType, NumberType} from '../types.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type ParsingContext from '../parsing_context.js';
+import type {Type} from '../types.js';
+
+declare var Intl: {
+    NumberFormat: Class<Intl$NumberFormat>
+};
+
+declare class Intl$NumberFormat {
+    constructor (
+        locales?: string | string[],
+        options?: NumberFormatOptions
+    ): Intl$NumberFormat;
+
+    static (
+        locales?: string | string[],
+        options?: NumberFormatOptions
+    ): Intl$NumberFormat;
+
+    format(a: number): string;
+
+    resolvedOptions(): any;
+}
+
+type NumberFormatOptions = {
+    style?: 'decimal' | 'currency' | 'percent' | 'unit';
+    currency?: null | string;
+    unit?: null | string;
+    minimumFractionDigits?: null | string;
+    maximumFractionDigits?: null | string;
+};
+
+export default class NumberFormat implements Expression {
+    type: Type;
+    number: Expression;
+    locale: Expression | null;   // BCP 47 language tag
+    currency: Expression | null; // ISO 4217 currency code, required if style=currency
+    unit: Expression | null;     // Simple units sanctioned for use in ECMAScript, required if style=unit. https://tc39.es/proposal-unified-intl-numberformat/section6/locales-currencies-tz_proposed_out.html#sec-issanctionedsimpleunitidentifier
+    minFractionDigits: Expression | null; // Default 0
+    maxFractionDigits: Expression | null; // Default 3
+
+    constructor(number: Expression,
+                locale: Expression | null,
+                currency: Expression | null,
+                unit: Expression | null,
+                minFractionDigits: Expression | null,
+                maxFractionDigits: Expression | null) {
+        this.type = StringType;
+        this.number = number;
+        this.locale = locale;
+        this.currency = currency;
+        this.unit = unit;
+        this.minFractionDigits = minFractionDigits;
+        this.maxFractionDigits = maxFractionDigits;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Expression {
+        if (args.length !== 3)
+            return context.error(`Expected two arguments.`);
+
+        const number = context.parse(args[1], 1, NumberType);
+        if (!number) return null;
+
+        const options = (args[2]: any);
+        if (typeof options !== "object" || Array.isArray(options))
+            return context.error(`NumberFormat options argument must be an object.`);
+
+        let locale = null;
+        if (options['locale']) {
+            locale = context.parse(options['locale'], 1, StringType);
+            if (!locale) return null;
+        }
+
+        let currency = null;
+        if (options['currency']) {
+            currency = context.parse(options['currency'], 1, StringType);
+            if (!currency) return null;
+        }
+
+        let unit = null;
+        if (options['unit']) {
+            unit = context.parse(options['unit'], 1, StringType);
+            if (!unit) return null;
+        }
+
+        let minFractionDigits = null;
+        if (options['min-fraction-digits']) {
+            minFractionDigits = context.parse(options['min-fraction-digits'], 1, NumberType);
+            if (!minFractionDigits) return null;
+        }
+
+        let maxFractionDigits = null;
+        if (options['max-fraction-digits']) {
+            maxFractionDigits = context.parse(options['max-fraction-digits'], 1, NumberType);
+            if (!maxFractionDigits) return null;
+        }
+
+        return new NumberFormat(number, locale, currency, unit, minFractionDigits, maxFractionDigits);
+    }
+
+    evaluate(ctx: EvaluationContext): string {
+        return new Intl.NumberFormat(this.locale ? this.locale.evaluate(ctx) : [],
+            {
+                style:
+                    (this.currency && "currency") ||
+                    (this.unit && "unit") ||
+                    "decimal",
+                currency: this.currency ? this.currency.evaluate(ctx) : undefined,
+                unit: this.unit ? this.unit.evaluate(ctx) : undefined,
+                minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(ctx) : undefined,
+                maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(ctx) : undefined,
+            }).format(this.number.evaluate(ctx));
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.number);
+        if (this.locale) {
+            fn(this.locale);
+        }
+        if (this.currency) {
+            fn(this.currency);
+        }
+        if (this.unit) {
+            fn(this.unit);
+        }
+        if (this.minFractionDigits) {
+            fn(this.minFractionDigits);
+        }
+        if (this.maxFractionDigits) {
+            fn(this.maxFractionDigits);
+        }
+    }
+
+    outputDefined(): boolean {
+        return false;
+    }
+
+    serialize(): SerializedExpression {
+        const options = {};
+        if (this.locale) {
+            options['locale'] = this.locale.serialize();
+        }
+        if (this.currency) {
+            options['currency'] = this.currency.serialize();
+        }
+        if (this.unit) {
+            options['unit'] = this.unit.serialize();
+        }
+        if (this.minFractionDigits) {
+            options['min-fraction-digits'] = this.minFractionDigits.serialize();
+        }
+        if (this.maxFractionDigits) {
+            options['max-fraction-digits'] = this.maxFractionDigits.serialize();
+        }
+        return ["number-format", this.number.serialize(), options];
+    }
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/slice.js

@@ -0,0 +1,86 @@
+// @flow
+
+import {ValueType, NumberType, StringType, array, toString, isValidType, isValidNativeType} from '../types.js';
+import RuntimeError from '../runtime_error.js';
+import {typeOf} from '../values.js';
+
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+class Slice implements Expression {
+    type: Type;
+    input: Expression;
+    beginIndex: Expression;
+    endIndex: ?Expression;
+
+    constructor(type: Type, input: Expression, beginIndex: Expression, endIndex?: Expression) {
+        this.type = type;
+        this.input = input;
+        this.beginIndex = beginIndex;
+        this.endIndex = endIndex;
+
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Slice {
+        if (args.length <= 2 ||  args.length >= 5) {
+            return context.error(`Expected 3 or 4 arguments, but found ${args.length - 1} instead.`);
+        }
+
+        const input = context.parse(args[1], 1, ValueType);
+        const beginIndex = context.parse(args[2], 2, NumberType);
+
+        if (!input || !beginIndex) return null;
+
+        if (!isValidType(input.type, [array(ValueType), StringType, ValueType])) {
+            return context.error(`Expected first argument to be of type array or string, but found ${toString(input.type)} instead`);
+        }
+
+        if (args.length === 4) {
+            const endIndex = context.parse(args[3], 3, NumberType);
+            if (!endIndex) return null;
+            return new Slice(input.type, input, beginIndex, endIndex);
+        } else {
+            return new Slice(input.type, input, beginIndex);
+        }
+    }
+
+    evaluate(ctx: EvaluationContext): any {
+        const input = (this.input.evaluate(ctx): any);
+        const beginIndex = (this.beginIndex.evaluate(ctx): number);
+
+        if (!isValidNativeType(input, ['string', 'array'])) {
+            throw new RuntimeError(`Expected first argument to be of type array or string, but found ${toString(typeOf(input))} instead.`);
+        }
+
+        if (this.endIndex) {
+            const endIndex = (this.endIndex.evaluate(ctx): number);
+            return input.slice(beginIndex, endIndex);
+        }
+
+        return input.slice(beginIndex);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.input);
+        fn(this.beginIndex);
+        if (this.endIndex) {
+            fn(this.endIndex);
+        }
+    }
+
+    outputDefined(): boolean {
+        return false;
+    }
+
+    serialize(): SerializedExpression {
+        if (this.endIndex != null && this.endIndex !== undefined) {
+            const endIndex = this.endIndex.serialize();
+            return ["slice", this.input.serialize(), this.beginIndex.serialize(), endIndex];
+        }
+        return ["slice", this.input.serialize(), this.beginIndex.serialize()];
+    }
+}
+
+export default Slice;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/step.js

@@ -0,0 +1,120 @@
+// @flow
+
+import {NumberType} from '../types.js';
+
+import {findStopLessThanOrEqualTo} from '../stops.js';
+
+import type {Stops} from '../stops.js';
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {Type} from '../types.js';
+
+class Step implements Expression {
+    type: Type;
+
+    input: Expression;
+    labels: Array<number>;
+    outputs: Array<Expression>;
+
+    constructor(type: Type, input: Expression, stops: Stops) {
+        this.type = type;
+        this.input = input;
+
+        this.labels = [];
+        this.outputs = [];
+        for (const [label, expression] of stops) {
+            this.labels.push(label);
+            this.outputs.push(expression);
+        }
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Step {
+        if (args.length - 1 < 4) {
+            return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
+        }
+
+        if ((args.length - 1) % 2 !== 0) {
+            return context.error(`Expected an even number of arguments.`);
+        }
+
+        const input = context.parse(args[1], 1, NumberType);
+        if (!input) return null;
+
+        const stops: Stops = [];
+
+        let outputType: Type = (null: any);
+        if (context.expectedType && context.expectedType.kind !== 'value') {
+            outputType = context.expectedType;
+        }
+
+        for (let i = 1; i < args.length; i += 2) {
+            const label = i === 1 ? -Infinity : args[i];
+            const value = args[i + 1];
+
+            const labelKey = i;
+            const valueKey = i + 1;
+
+            if (typeof label !== 'number') {
+                return context.error('Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
+            }
+
+            if (stops.length && stops[stops.length - 1][0] >= label) {
+                return context.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', labelKey);
+            }
+
+            const parsed = context.parse(value, valueKey, outputType);
+            if (!parsed) return null;
+            outputType = outputType || parsed.type;
+            stops.push([label, parsed]);
+        }
+
+        return new Step(outputType, input, stops);
+    }
+
+    evaluate(ctx: EvaluationContext): any {
+        const labels = this.labels;
+        const outputs = this.outputs;
+
+        if (labels.length === 1) {
+            return outputs[0].evaluate(ctx);
+        }
+
+        const value = ((this.input.evaluate(ctx): any): number);
+        if (value <= labels[0]) {
+            return outputs[0].evaluate(ctx);
+        }
+
+        const stopCount = labels.length;
+        if (value >= labels[stopCount - 1]) {
+            return outputs[stopCount - 1].evaluate(ctx);
+        }
+
+        const index = findStopLessThanOrEqualTo(labels, value);
+        return outputs[index].evaluate(ctx);
+    }
+
+    eachChild(fn: (_: Expression) => void) {
+        fn(this.input);
+        for (const expression of this.outputs) {
+            fn(expression);
+        }
+    }
+
+    outputDefined(): boolean {
+        return this.outputs.every(out => out.outputDefined());
+    }
+
+    serialize(): SerializedExpression {
+        const serialized = ["step", this.input.serialize()];
+        for (let i = 0; i < this.labels.length; i++) {
+            if (i > 0) {
+                serialized.push(this.labels[i]);
+            }
+            serialized.push(this.outputs[i].serialize());
+        }
+        return serialized;
+    }
+}
+
+export default Step;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/var.js

@@ -0,0 +1,46 @@
+// @flow
+
+import type {Type} from '../types.js';
+import type {Expression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext  from '../evaluation_context.js';
+
+class Var implements Expression {
+    type: Type;
+    name: string;
+    boundExpression: Expression;
+
+    constructor(name: string, boundExpression: Expression) {
+        this.type = boundExpression.type;
+        this.name = name;
+        this.boundExpression = boundExpression;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): void | Var {
+        if (args.length !== 2 || typeof args[1] !== 'string')
+            return context.error(`'var' expression requires exactly one string literal argument.`);
+
+        const 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));
+    }
+
+    evaluate(ctx: EvaluationContext): any {
+        return this.boundExpression.evaluate(ctx);
+    }
+
+    eachChild() {}
+
+    outputDefined(): boolean {
+        return false;
+    }
+
+    serialize(): Array<string> {
+        return ["var", this.name];
+    }
+}
+
+export default Var;

node_modules/@mapbox/mapbox-gl-style-spec/expression/definitions/within.js

@@ -0,0 +1,349 @@
+// @flow
+
+import {isValue} from '../values.js';
+import type {Type} from '../types.js';
+import {BooleanType} from '../types.js';
+import type {Expression, SerializedExpression} from '../expression.js';
+import type ParsingContext from '../parsing_context.js';
+import type EvaluationContext from '../evaluation_context.js';
+import type {GeoJSON, GeoJSONPolygon, GeoJSONMultiPolygon} from '@mapbox/geojson-types';
+import type {CanonicalTileID} from '../../../source/tile_id.js';
+
+type GeoJSONPolygons =| GeoJSONPolygon | GeoJSONMultiPolygon;
+
+// minX, minY, maxX, maxY
+type BBox = [number, number, number, number];
+const EXTENT = 8192;
+
+function updateBBox(bbox: BBox, coord: [number, number]) {
+    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 mercatorXfromLng(lng: number) {
+    return (180 + lng) / 360;
+}
+
+function mercatorYfromLat(lat: number) {
+    return (180 - (180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360)))) / 360;
+}
+
+function boxWithinBox(bbox1: BBox, bbox2: BBox) {
+    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: CanonicalTileID) {
+    const x = mercatorXfromLng(p[0]);
+    const y = mercatorYfromLat(p[1]);
+    const tilesAtZoom = Math.pow(2, canonical.z);
+    return [Math.round(x * tilesAtZoom * EXTENT), Math.round(y * tilesAtZoom * EXTENT)];
+}
+
+function onBoundary(p, p1, p2) {
+    const x1 = p[0] - p1[0];
+    const y1 = p[1] - p1[1];
+    const x2 = p[0] - p2[0];
+    const 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]);
+}
+
+// ray casting algorithm for detecting if point is in polygon
+function pointWithinPolygon(point, rings) {
+    let inside = false;
+    for (let i = 0, len = rings.length; i < len; i++) {
+        const ring = rings[i];
+        for (let 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 (let 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]);
+}
+
+// check if p1 and p2 are in different sides of line segment q1->q2
+function  twoSided(p1, p2, q1, q2) {
+    // q1->p1 (x1, y1), q1->p2 (x2, y2), q1->q2 (x3, y3)
+    const x1 = p1[0] - q1[0];
+    const y1 = p1[1] - q1[1];
+    const x2 = p2[0] - q1[0];
+    const y2 = p2[1] - q1[1];
+    const x3 = q2[0] - q1[0];
+    const y3 = q2[1] - q1[1];
+    const det1 = (x1 * y3 - x3 * y1);
+    const det2 =  (x2 * y3 - x3 * y2);
+    if ((det1 > 0 && det2 < 0) || (det1 < 0 && det2 > 0)) return true;
+    return false;
+}
+// a, b are end points for line segment1, c and d are end points for line segment2
+function lineIntersectLine(a, b, c, d) {
+    // check if two segments are parallel or not
+    // precondition is end point a, b is inside polygon, if line a->b is
+    // parallel to polygon edge c->d, then a->b won't intersect with c->d
+    const vectorP = [b[0] - a[0], b[1] - a[1]];
+    const vectorQ = [d[0] - c[0], d[1] - c[1]];
+    if (perp(vectorQ, vectorP) === 0) return false;
+
+    // If lines are intersecting with each other, the relative location should be:
+    // a and b lie in different sides of segment c->d
+    // c and d lie in different sides of segment a->b
+    if (twoSided(a, b, c, d) && twoSided(c, d, a, b)) return true;
+    return false;
+}
+
+function lineIntersectPolygon(p1, p2, polygon) {
+    for (const ring of polygon) {
+        // loop through every edge of the ring
+        for (let j = 0; j < ring.length - 1; ++j) {
+            if (lineIntersectLine(p1, p2, ring[j], ring[j + 1])) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+function lineStringWithinPolygon(line, polygon) {
+    // First, check if geometry points of line segments are all inside polygon
+    for (let i = 0; i < line.length; ++i) {
+        if (!pointWithinPolygon(line[i], polygon)) {
+            return false;
+        }
+    }
+
+    // Second, check if there is line segment intersecting polygon edge
+    for (let i = 0; i < line.length - 1; ++i) {
+        if (lineIntersectPolygon(line[i], line[i + 1], polygon)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function lineStringWithinPolygons(line, polygons) {
+    for (let i = 0; i < polygons.length; i++) {
+        if (lineStringWithinPolygon(line, polygons[i])) return true;
+    }
+    return false;
+}
+
+function getTilePolygon(coordinates, bbox: BBox, canonical: CanonicalTileID) {
+    const polygon = [];
+    for (let i = 0; i < coordinates.length; i++) {
+        const ring = [];
+        for (let j = 0; j < coordinates[i].length; j++) {
+            const coord = getTileCoordinates(coordinates[i][j], canonical);
+            updateBBox(bbox, coord);
+            ring.push(coord);
+        }
+        polygon.push(ring);
+    }
+    return polygon;
+}
+
+function getTilePolygons(coordinates, bbox, canonical: CanonicalTileID) {
+    const polygons = [];
+    for (let i = 0; i < coordinates.length; i++) {
+        const polygon = getTilePolygon(coordinates[i], bbox, canonical);
+        polygons.push(polygon);
+    }
+    return polygons;
+}
+
+function updatePoint(p, bbox, polyBBox, worldSize) {
+    if (p[0] < polyBBox[0] || p[0] > polyBBox[2]) {
+        const halfWorldSize = worldSize * 0.5;
+        let shift = (p[0] - polyBBox[0] > halfWorldSize) ? -worldSize : (polyBBox[0] - p[0] > halfWorldSize) ? worldSize : 0;
+        if (shift === 0) {
+            shift = (p[0] - polyBBox[2] > halfWorldSize) ? -worldSize : (polyBBox[2] - p[0] > halfWorldSize) ? worldSize : 0;
+        }
+        p[0] += shift;
+    }
+    updateBBox(bbox, p);
+}
+
+function resetBBox(bbox) {
+    bbox[0] = bbox[1] = Infinity;
+    bbox[2] = bbox[3] = -Infinity;
+}
+
+function getTilePoints(geometry, pointBBox, polyBBox, canonical: CanonicalTileID) {
+    const worldSize = Math.pow(2, canonical.z) * EXTENT;
+    const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
+    const tilePoints = [];
+    if (!geometry) return tilePoints;
+    for (const points of geometry) {
+        for (const point of points) {
+            const p = [point.x + shifts[0], point.y + shifts[1]];
+            updatePoint(p, pointBBox, polyBBox, worldSize);
+            tilePoints.push(p);
+        }
+    }
+    return tilePoints;
+}
+
+function getTileLines(geometry, lineBBox, polyBBox, canonical: CanonicalTileID) {
+    const worldSize = Math.pow(2, canonical.z) * EXTENT;
+    const shifts = [canonical.x * EXTENT, canonical.y * EXTENT];
+    const tileLines = [];
+    if (!geometry) return tileLines;
+    for (const line of geometry) {
+        const tileLine = [];
+        for (const point of line) {
+            const p = [point.x + shifts[0], point.y + shifts[1]];
+            updateBBox(lineBBox, p);
+            tileLine.push(p);
+        }
+        tileLines.push(tileLine);
+    }
+    if (lineBBox[2] - lineBBox[0] <= worldSize / 2) {
+        resetBBox(lineBBox);
+        for (const line of tileLines) {
+            for (const p of line) {
+                updatePoint(p, lineBBox, polyBBox, worldSize);
+            }
+        }
+    }
+    return tileLines;
+}
+
+function pointsWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPolygons) {
+    const pointBBox = [Infinity, Infinity, -Infinity, -Infinity];
+    const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
+
+    const canonical = ctx.canonicalID();
+    if (!canonical) {
+        return false;
+    }
+
+    if (polygonGeometry.type === 'Polygon') {
+        const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
+        const tilePoints = getTilePoints(ctx.geometry(), pointBBox, polyBBox, canonical);
+        if (!boxWithinBox(pointBBox, polyBBox)) return false;
+
+        for (const point of tilePoints) {
+            if (!pointWithinPolygon(point, tilePolygon)) return false;
+        }
+    }
+    if (polygonGeometry.type === 'MultiPolygon') {
+        const tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
+        const tilePoints = getTilePoints(ctx.geometry(), pointBBox, polyBBox, canonical);
+        if (!boxWithinBox(pointBBox, polyBBox)) return false;
+
+        for (const point of tilePoints) {
+            if (!pointWithinPolygons(point, tilePolygons)) return false;
+        }
+    }
+
+    return true;
+}
+
+function linesWithinPolygons(ctx: EvaluationContext, polygonGeometry: GeoJSONPolygons) {
+    const lineBBox = [Infinity, Infinity, -Infinity, -Infinity];
+    const polyBBox = [Infinity, Infinity, -Infinity, -Infinity];
+
+    const canonical = ctx.canonicalID();
+    if (!canonical) {
+        return false;
+    }
+
+    if (polygonGeometry.type === 'Polygon') {
+        const tilePolygon = getTilePolygon(polygonGeometry.coordinates, polyBBox, canonical);
+        const tileLines = getTileLines(ctx.geometry(), lineBBox, polyBBox, canonical);
+        if (!boxWithinBox(lineBBox, polyBBox)) return false;
+
+        for (const line of tileLines) {
+            if (!lineStringWithinPolygon(line, tilePolygon)) return false;
+        }
+    }
+    if (polygonGeometry.type === 'MultiPolygon') {
+        const tilePolygons = getTilePolygons(polygonGeometry.coordinates, polyBBox, canonical);
+        const tileLines = getTileLines(ctx.geometry(), lineBBox, polyBBox, canonical);
+        if (!boxWithinBox(lineBBox, polyBBox)) return false;
+
+        for (const line of tileLines) {
+            if (!lineStringWithinPolygons(line, tilePolygons)) return false;
+        }
+    }
+    return true;
+}
+
+class Within implements Expression {
+    type: Type;
+    geojson: GeoJSON
+    geometries: GeoJSONPolygons;
+
+    constructor(geojson: GeoJSON, geometries: GeoJSONPolygons) {
+        this.type = BooleanType;
+        this.geojson = geojson;
+        this.geometries = geometries;
+    }
+
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Within {
+        if (args.length !== 2)
+            return context.error(`'within' expression requires exactly one argument, but found ${args.length - 1} instead.`);
+        if (isValue(args[1])) {
+            const geojson = (args[1]: Object);
+            if (geojson.type === 'FeatureCollection') {
+                for (let i = 0; i < geojson.features.length; ++i) {
+                    const type = geojson.features[i].geometry.type;
+                    if (type === 'Polygon' || type === 'MultiPolygon') {
+                        return new Within(geojson, geojson.features[i].geometry);
+                    }
+                }
+            } else if (geojson.type === 'Feature') {
+                const type = geojson.geometry.type;
+                if (type === 'Polygon' || type === '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.`);
+    }
+
+    evaluate(ctx: EvaluationContext): boolean {
+        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;
+    }
+
+    eachChild() {}
+
+    outputDefined(): boolean {
+        return true;
+    }
+
+    serialize(): SerializedExpression {
+        return ["within", this.geojson];
+    }
+
+}
+
+export default Within;

node_modules/@mapbox/mapbox-gl-style-spec/expression/evaluation_context.js

@@ -0,0 +1,89 @@
+// @flow
+
+import {Color} from './values.js';
+
+import type Point from '@mapbox/point-geometry';
+import type {FormattedSection} from './types/formatted.js';
+import type {GlobalProperties, Feature, FeatureState} from './index.js';
+import type {CanonicalTileID} from '../../source/tile_id.js';
+import type {FeatureDistanceData} from '../feature_filter/index.js';
+
+const geometryTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];
+
+class EvaluationContext {
+    globals: GlobalProperties;
+    feature: ?Feature;
+    featureState: ?FeatureState;
+    formattedSection: ?FormattedSection;
+    availableImages: ?Array<string>;
+    canonical: null | CanonicalTileID;
+    featureTileCoord: ?Point;
+    featureDistanceData: ?FeatureDistanceData;
+
+    _parseColorCache: {[_: string]: ?Color};
+
+    constructor() {
+        this.globals = (null: any);
+        this.feature = null;
+        this.featureState = null;
+        this.formattedSection = null;
+        this._parseColorCache = {};
+        this.availableImages = null;
+        this.canonical = null;
+        this.featureTileCoord = null;
+        this.featureDistanceData = null;
+    }
+
+    id(): number | null {
+        return this.feature && this.feature.id !== undefined ? this.feature.id : null;
+    }
+
+    geometryType(): null | string {
+        return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
+    }
+
+    geometry(): ?Array<Array<Point>> {
+        return this.feature && 'geometry' in this.feature ? this.feature.geometry : null;
+    }
+
+    canonicalID(): null | CanonicalTileID {
+        return this.canonical;
+    }
+
+    properties(): {[string]: any} {
+        return (this.feature && this.feature.properties) || {};
+    }
+
+    distanceFromCenter(): number {
+        if (this.featureTileCoord && this.featureDistanceData) {
+
+            const c = this.featureDistanceData.center;
+            const scale = this.featureDistanceData.scale;
+            const {x, y} = this.featureTileCoord;
+
+            // Calculate the distance vector `d` (left handed)
+            const dX = x * scale - c[0];
+            const dY = y * scale - c[1];
+
+            // The bearing vector `b` (left handed)
+            const bX = this.featureDistanceData.bearing[0];
+            const bY = this.featureDistanceData.bearing[1];
+
+            // Distance is calculated as `dot(d, v)`
+            const dist = (bX * dX + bY * dY);
+            return dist;
+        }
+
+        return 0;
+    }
+
+    parseColor(input: string): ?Color {
+        let cached = this._parseColorCache[input];
+        if (!cached) {
+            cached = this._parseColorCache[input] = Color.parse(input);
+        }
+        return cached;
+    }
+}
+
+export default EvaluationContext;

node_modules/@mapbox/mapbox-gl-style-spec/expression/expression.js

@@ -0,0 +1,27 @@
+// @flow
+
+import type {Type} from './types.js';
+import type ParsingContext from './parsing_context.js';
+import type EvaluationContext from './evaluation_context.js';
+
+export type SerializedExpression = Array<mixed> | Array<string> | string | number | boolean | null;
+
+export interface Expression {
+    +type: Type;
+
+    evaluate(ctx: EvaluationContext): any;
+
+    eachChild(fn: Expression => void): void;
+
+    /**
+     * Statically analyze the expression, attempting to enumerate possible outputs. Returns
+     * false if the complete set of outputs is statically undecidable, otherwise true.
+     */
+    outputDefined(): boolean;
+
+    serialize(): SerializedExpression;
+}
+
+export type ExpressionParser = (args: $ReadOnlyArray<mixed>, context: ParsingContext) => ?Expression;
+export type ExpressionRegistration = Class<Expression> & { +parse: ExpressionParser };
+export type ExpressionRegistry = {[_: string]: ExpressionRegistration};

node_modules/@mapbox/mapbox-gl-style-spec/expression/index.js

@@ -0,0 +1,399 @@
+// @flow
+
+import assert from 'assert';
+
+import extend from '../util/extend.js';
+import ParsingError from './parsing_error.js';
+import ParsingContext from './parsing_context.js';
+import EvaluationContext from './evaluation_context.js';
+import CompoundExpression from './compound_expression.js';
+import Step from './definitions/step.js';
+import Interpolate from './definitions/interpolate.js';
+import Coalesce from './definitions/coalesce.js';
+import Let from './definitions/let.js';
+import definitions from './definitions/index.js';
+import * as isConstant from './is_constant.js';
+import RuntimeError from './runtime_error.js';
+import {success, error} from '../util/result.js';
+import {supportsPropertyExpression, supportsZoomExpression, supportsInterpolation} from '../util/properties.js';
+
+import type {Type, EvaluationKind} from './types.js';
+import type {Value} from './values.js';
+import type {Expression} from './expression.js';
+import type {StylePropertySpecification} from '../style-spec.js';
+import type {Result} from '../util/result.js';
+import type {InterpolationType} from './definitions/interpolate.js';
+import type {PropertyValueSpecification} from '../types.js';
+import type {FormattedSection} from './types/formatted.js';
+import type Point from '@mapbox/point-geometry';
+import type {CanonicalTileID} from '../../source/tile_id.js';
+import type {FeatureDistanceData} from '../feature_filter/index.js';
+
+export type Feature = {
+    +type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon',
+    +id?: number | null,
+    +properties: {[_: string]: any},
+    +patterns?: {[_: string]: string},
+    +geometry?: Array<Array<Point>>
+};
+
+export type FeatureState = {[_: string]: any};
+
+export type GlobalProperties = $ReadOnly<{
+    zoom: number,
+    pitch?: number,
+    heatmapDensity?: number,
+    lineProgress?: number,
+    skyRadialProgress?: number,
+    isSupportedScript?: (_: string) => boolean,
+    accumulated?: Value
+}>;
+
+export class StyleExpression {
+    expression: Expression;
+
+    _evaluator: EvaluationContext;
+    _defaultValue: Value;
+    _warningHistory: {[key: string]: boolean};
+    _enumValues: ?{[_: string]: any};
+
+    constructor(expression: Expression, propertySpec: ?StylePropertySpecification) {
+        this.expression = expression;
+        this._warningHistory = {};
+        this._evaluator = new EvaluationContext();
+        this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
+        this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
+    }
+
+    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData): any {
+        this._evaluator.globals = globals;
+        this._evaluator.feature = feature;
+        this._evaluator.featureState = featureState;
+        this._evaluator.canonical = canonical || null;
+        this._evaluator.availableImages = availableImages || null;
+        this._evaluator.formattedSection = formattedSection;
+        this._evaluator.featureTileCoord = featureTileCoord || null;
+        this._evaluator.featureDistanceData = featureDistanceData || null;
+
+        return this.expression.evaluate(this._evaluator);
+    }
+
+    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData): any {
+        this._evaluator.globals = globals;
+        this._evaluator.feature = feature || null;
+        this._evaluator.featureState = featureState || null;
+        this._evaluator.canonical = canonical || null;
+        this._evaluator.availableImages = availableImages || null;
+        this._evaluator.formattedSection = formattedSection || null;
+        this._evaluator.featureTileCoord = featureTileCoord || null;
+        this._evaluator.featureDistanceData = featureDistanceData || null;
+
+        try {
+            const val = this.expression.evaluate(this._evaluator);
+            // eslint-disable-next-line no-self-compare
+            if (val === null || val === undefined || (typeof val === 'number' && val !== val)) {
+                return this._defaultValue;
+            }
+            if (this._enumValues && !(val in this._enumValues)) {
+                throw new RuntimeError(`Expected value to be one of ${Object.keys(this._enumValues).map(v => JSON.stringify(v)).join(', ')}, but found ${JSON.stringify(val)} instead.`);
+            }
+            return val;
+        } catch (e) {
+            if (!this._warningHistory[e.message]) {
+                this._warningHistory[e.message] = true;
+                if (typeof console !== 'undefined') {
+                    console.warn(e.message);
+                }
+            }
+            return this._defaultValue;
+        }
+    }
+}
+
+export function isExpression(expression: mixed): boolean {
+    return Array.isArray(expression) && expression.length > 0 &&
+        typeof expression[0] === 'string' && expression[0] in definitions;
+}
+
+/**
+ * Parse and typecheck the given style spec JSON expression.  If
+ * options.defaultValue is provided, then the resulting StyleExpression's
+ * `evaluate()` method will handle errors by logging a warning (once per
+ * message) and returning the default value.  Otherwise, it will throw
+ * evaluation errors.
+ *
+ * @private
+ */
+export function createExpression(expression: mixed, propertySpec: ?StylePropertySpecification): Result<StyleExpression, Array<ParsingError>> {
+    const parser = new ParsingContext(definitions, [], propertySpec ? getExpectedType(propertySpec) : undefined);
+
+    // For string-valued properties, coerce to string at the top level rather than asserting.
+    const parsed = parser.parse(expression, undefined, undefined, undefined,
+        propertySpec && propertySpec.type === 'string' ? {typeAnnotation: 'coerce'} : undefined);
+
+    if (!parsed) {
+        assert(parser.errors.length > 0);
+        return error(parser.errors);
+    }
+
+    return success(new StyleExpression(parsed, propertySpec));
+}
+
+export class ZoomConstantExpression<Kind: EvaluationKind> {
+    kind: Kind;
+    isStateDependent: boolean;
+    _styleExpression: StyleExpression;
+
+    constructor(kind: Kind, expression: StyleExpression) {
+        this.kind = kind;
+        this._styleExpression = expression;
+        this.isStateDependent = kind !== ('constant': EvaluationKind) && !isConstant.isStateConstant(expression.expression);
+    }
+
+    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+        return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
+    }
+
+    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+        return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
+    }
+}
+
+export class ZoomDependentExpression<Kind: EvaluationKind> {
+    kind: Kind;
+    zoomStops: Array<number>;
+    isStateDependent: boolean;
+
+    _styleExpression: StyleExpression;
+    interpolationType: ?InterpolationType;
+
+    constructor(kind: Kind, expression: StyleExpression, zoomStops: Array<number>, interpolationType?: InterpolationType) {
+        this.kind = kind;
+        this.zoomStops = zoomStops;
+        this._styleExpression = expression;
+        this.isStateDependent = kind !== ('camera': EvaluationKind) && !isConstant.isStateConstant(expression.expression);
+        this.interpolationType = interpolationType;
+    }
+
+    evaluateWithoutErrorHandling(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+        return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
+    }
+
+    evaluate(globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection): any {
+        return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
+    }
+
+    interpolationFactor(input: number, lower: number, upper: number): number {
+        if (this.interpolationType) {
+            return Interpolate.interpolationFactor(this.interpolationType, input, lower, upper);
+        } else {
+            return 0;
+        }
+    }
+}
+
+export type ConstantExpression = {
+    kind: 'constant',
+    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any,
+}
+
+export type SourceExpression = {
+    kind: 'source',
+    isStateDependent: boolean,
+    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any,
+};
+
+export type CameraExpression = {
+    kind: 'camera',
+    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>) => any,
+    +interpolationFactor: (input: number, lower: number, upper: number) => number,
+    zoomStops: Array<number>,
+    interpolationType: ?InterpolationType
+};
+
+export type CompositeExpression = {
+    kind: 'composite',
+    isStateDependent: boolean,
+    +evaluate: (globals: GlobalProperties, feature?: Feature, featureState?: FeatureState, canonical?: CanonicalTileID, availableImages?: Array<string>, formattedSection?: FormattedSection) => any,
+    +interpolationFactor: (input: number, lower: number, upper: number) => number,
+    zoomStops: Array<number>,
+    interpolationType: ?InterpolationType
+};
+
+export type StylePropertyExpression =
+    | ConstantExpression
+    | SourceExpression
+    | CameraExpression
+    | CompositeExpression;
+
+export function createPropertyExpression(expression: mixed, propertySpec: StylePropertySpecification): Result<StylePropertyExpression, Array<ParsingError>> {
+    expression = createExpression(expression, propertySpec);
+    if (expression.result === 'error') {
+        return expression;
+    }
+
+    const parsed = expression.value.expression;
+
+    const isFeatureConstant = isConstant.isFeatureConstant(parsed);
+    if (!isFeatureConstant && !supportsPropertyExpression(propertySpec)) {
+        return error([new ParsingError('', 'data expressions not supported')]);
+    }
+
+    const isZoomConstant = isConstant.isGlobalPropertyConstant(parsed, ['zoom', 'pitch', 'distance-from-center']);
+    if (!isZoomConstant && !supportsZoomExpression(propertySpec)) {
+        return error([new ParsingError('', 'zoom expressions not supported')]);
+    }
+
+    const zoomCurve = findZoomCurve(parsed);
+    if (!zoomCurve && !isZoomConstant) {
+        return error([new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
+    } else if (zoomCurve instanceof ParsingError) {
+        return error([zoomCurve]);
+    } else if (zoomCurve instanceof Interpolate && !supportsInterpolation(propertySpec)) {
+        return error([new ParsingError('', '"interpolate" expressions cannot be used with this property')]);
+    }
+
+    if (!zoomCurve) {
+        return success(isFeatureConstant ?
+            (new ZoomConstantExpression('constant', expression.value): ConstantExpression) :
+            (new ZoomConstantExpression('source', expression.value): SourceExpression));
+    }
+
+    const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
+
+    return success(isFeatureConstant ?
+        (new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType): CameraExpression) :
+        (new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType): CompositeExpression));
+}
+
+import {isFunction, createFunction} from '../function/index.js';
+import {Color} from './values.js';
+
+// serialization wrapper for old-style stop functions normalized to the
+// expression interface
+export class StylePropertyFunction<T> {
+    _parameters: PropertyValueSpecification<T>;
+    _specification: StylePropertySpecification;
+
+    kind: EvaluationKind;
+    evaluate: (globals: GlobalProperties, feature?: Feature) => any;
+    interpolationFactor: ?(input: number, lower: number, upper: number) => number;
+    zoomStops: ?Array<number>;
+
+    constructor(parameters: PropertyValueSpecification<T>, specification: StylePropertySpecification) {
+        this._parameters = parameters;
+        this._specification = specification;
+        extend(this, createFunction(this._parameters, this._specification));
+    }
+
+    static deserialize(serialized: {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification}): StylePropertyFunction<T> {
+        return new StylePropertyFunction(serialized._parameters, serialized._specification);
+    }
+
+    static serialize(input: StylePropertyFunction<T>): {_parameters: PropertyValueSpecification<T>, _specification: StylePropertySpecification} {
+        return {
+            _parameters: input._parameters,
+            _specification: input._specification
+        };
+    }
+}
+
+export function normalizePropertyExpression<T>(value: PropertyValueSpecification<T>, specification: StylePropertySpecification): StylePropertyExpression {
+    if (isFunction(value)) {
+        return (new StylePropertyFunction(value, specification): any);
+
+    } else if (isExpression(value)) {
+        const expression = createPropertyExpression(value, specification);
+        if (expression.result === 'error') {
+            // this should have been caught in validation
+            throw new Error(expression.value.map(err => `${err.key}: ${err.message}`).join(', '));
+        }
+        return expression.value;
+
+    } else {
+        let constant: any = value;
+        if (typeof value === 'string' && specification.type === 'color') {
+            constant = Color.parse(value);
+        }
+        return {
+            kind: 'constant',
+            evaluate: () => constant
+        };
+    }
+}
+
+// Zoom-dependent expressions may only use ["zoom"] as the input to a top-level "step" or "interpolate"
+// expression (collectively referred to as a "curve"). The curve may be wrapped in one or more "let" or
+// "coalesce" expressions.
+function findZoomCurve(expression: Expression): Step | Interpolate | ParsingError | null {
+    let result = null;
+    if (expression instanceof Let) {
+        result = findZoomCurve(expression.result);
+
+    } else if (expression instanceof Coalesce) {
+        for (const arg of expression.args) {
+            result = findZoomCurve(arg);
+            if (result) {
+                break;
+            }
+        }
+
+    } else if ((expression instanceof Step || expression instanceof Interpolate) &&
+        expression.input instanceof CompoundExpression &&
+        expression.input.name === 'zoom') {
+
+        result = expression;
+    }
+
+    if (result instanceof ParsingError) {
+        return result;
+    }
+
+    expression.eachChild((child) => {
+        const childResult = findZoomCurve(child);
+        if (childResult instanceof ParsingError) {
+            result = childResult;
+        } else if (!result && childResult) {
+            result = new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.');
+        } else if (result && childResult && result !== childResult) {
+            result = new ParsingError('', 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.');
+        }
+    });
+
+    return result;
+}
+
+import {ColorType, StringType, NumberType, BooleanType, ValueType, FormattedType, ResolvedImageType, array} from './types.js';
+
+function getExpectedType(spec: StylePropertySpecification): Type {
+    const types = {
+        color: ColorType,
+        string: StringType,
+        number: NumberType,
+        enum: StringType,
+        boolean: BooleanType,
+        formatted: FormattedType,
+        resolvedImage: ResolvedImageType
+    };
+
+    if (spec.type === 'array') {
+        return array(types[spec.value] || ValueType, spec.length);
+    }
+
+    return types[spec.type];
+}
+
+function getDefaultValue(spec: StylePropertySpecification): Value {
+    if (spec.type === 'color' && (isFunction(spec.default) || Array.isArray(spec.default))) {
+        // Special case for heatmap-color: it uses the 'default:' to define a
+        // default color ramp, but createExpression expects a simple value to fall
+        // back to in case of runtime errors
+        return new Color(0, 0, 0, 0);
+    } else if (spec.type === 'color') {
+        return Color.parse(spec.default) || null;
+    } else if (spec.default === undefined) {
+        return null;
+    } else {
+        return spec.default;
+    }
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/is_constant.js

@@ -0,0 +1,59 @@
+// @flow
+
+import CompoundExpression from './compound_expression.js';
+import Within from './definitions/within.js';
+import type {Expression} from './expression.js';
+
+function isFeatureConstant(e: Expression): boolean {
+    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;
+    }
+
+    let result = true;
+    e.eachChild(arg => {
+        if (result && !isFeatureConstant(arg)) { result = false; }
+    });
+    return result;
+}
+
+function isStateConstant(e: Expression): boolean {
+    if (e instanceof CompoundExpression) {
+        if (e.name === 'feature-state') {
+            return false;
+        }
+    }
+    let result = true;
+    e.eachChild(arg => {
+        if (result && !isStateConstant(arg)) { result = false; }
+    });
+    return result;
+}
+
+function isGlobalPropertyConstant(e: Expression, properties: Array<string>): boolean {
+    if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) { return false; }
+    let result = true;
+    e.eachChild((arg) => {
+        if (result && !isGlobalPropertyConstant(arg, properties)) { result = false; }
+    });
+    return result;
+}
+
+export {isFeatureConstant, isGlobalPropertyConstant, isStateConstant};

node_modules/@mapbox/mapbox-gl-style-spec/expression/parsing_context.js

@@ -0,0 +1,233 @@
+// @flow
+
+import Scope from './scope.js';
+import {checkSubtype} from './types.js';
+import ParsingError from './parsing_error.js';
+import Literal from './definitions/literal.js';
+import Assertion from './definitions/assertion.js';
+import Coercion from './definitions/coercion.js';
+import EvaluationContext from './evaluation_context.js';
+import CompoundExpression from './compound_expression.js';
+import CollatorExpression from './definitions/collator.js';
+import Within from './definitions/within.js';
+import {isGlobalPropertyConstant, isFeatureConstant} from './is_constant.js';
+import Var from './definitions/var.js';
+
+import type {Expression, ExpressionRegistry} from './expression.js';
+import type {Type} from './types.js';
+
+/**
+ * State associated parsing at a given point in an expression tree.
+ * @private
+ */
+class ParsingContext {
+    registry: ExpressionRegistry;
+    path: Array<number>;
+    key: string;
+    scope: Scope;
+    errors: Array<ParsingError>;
+
+    // The expected type of this expression. Provided only to allow Expression
+    // implementations to infer argument types: Expression#parse() need not
+    // check that the output type of the parsed expression matches
+    // `expectedType`.
+    expectedType: ?Type;
+
+    constructor(
+        registry: ExpressionRegistry,
+        path: Array<number> = [],
+        expectedType: ?Type,
+        scope: Scope = new Scope(),
+        errors: Array<ParsingError> = []
+    ) {
+        this.registry = registry;
+        this.path = path;
+        this.key = path.map(part => `[${part}]`).join('');
+        this.scope = scope;
+        this.errors = errors;
+        this.expectedType = expectedType;
+    }
+
+    /**
+     * @param expr the JSON expression to parse
+     * @param index the optional argument index if this expression is an argument of a parent expression that's being parsed
+     * @param options
+     * @param options.omitTypeAnnotations set true to omit inferred type annotations.  Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
+     * @private
+     */
+    parse(
+        expr: mixed,
+        index?: number,
+        expectedType?: ?Type,
+        bindings?: Array<[string, Expression]>,
+        options: {typeAnnotation?: 'assert' | 'coerce' | 'omit'} = {}
+    ): ?Expression {
+        if (index) {
+            return this.concat(index, expectedType, bindings)._parse(expr, options);
+        }
+        return this._parse(expr, options);
+    }
+
+    _parse(expr: mixed, options: {typeAnnotation?: 'assert' | 'coerce' | 'omit'}): ?Expression {
+        if (expr === null || typeof expr === 'string' || typeof expr === 'boolean' || typeof expr === 'number') {
+            expr = ['literal', expr];
+        }
+
+        function annotate(parsed, type, typeAnnotation: 'assert' | 'coerce' | 'omit') {
+            if (typeAnnotation === 'assert') {
+                return new Assertion(type, [parsed]);
+            } else if (typeAnnotation === 'coerce') {
+                return new Coercion(type, [parsed]);
+            } else {
+                return parsed;
+            }
+        }
+
+        if (Array.isArray(expr)) {
+            if (expr.length === 0) {
+                return this.error(`Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`);
+            }
+
+            const op = expr[0];
+            if (typeof op !== 'string') {
+                this.error(`Expression name must be a string, but found ${typeof op} instead. If you wanted a literal array, use ["literal", [...]].`, 0);
+                return null;
+            }
+
+            const Expr = this.registry[op];
+            if (Expr) {
+                let parsed = Expr.parse(expr, this);
+                if (!parsed) return null;
+
+                if (this.expectedType) {
+                    const expected = this.expectedType;
+                    const actual = parsed.type;
+
+                    // When we expect a number, string, boolean, or array but have a value, wrap it in an assertion.
+                    // When we expect a color or formatted string, but have a string or value, wrap it in a coercion.
+                    // Otherwise, we do static type-checking.
+                    //
+                    // These behaviors are overridable for:
+                    //   * The "coalesce" operator, which needs to omit type annotations.
+                    //   * String-valued properties (e.g. `text-field`), where coercion is more convenient than assertion.
+                    //
+                    if ((expected.kind === 'string' || expected.kind === 'number' || expected.kind === 'boolean' || expected.kind === 'object' || expected.kind === 'array') && actual.kind === 'value') {
+                        parsed = annotate(parsed, expected, options.typeAnnotation || 'assert');
+                    } else if ((expected.kind === 'color' || expected.kind === 'formatted' || expected.kind === 'resolvedImage') && (actual.kind === 'value' || actual.kind === 'string')) {
+                        parsed = annotate(parsed, expected, options.typeAnnotation || 'coerce');
+                    } else if (this.checkSubtype(expected, actual)) {
+                        return null;
+                    }
+                }
+
+                // If an expression's arguments are all literals, we can evaluate
+                // it immediately and replace it with a literal value in the
+                // parsed/compiled result. Expressions that expect an image should
+                // not be resolved here so we can later get the available images.
+                if (!(parsed instanceof Literal) && (parsed.type.kind !== 'resolvedImage') && isConstant(parsed)) {
+                    const ec = new EvaluationContext();
+                    try {
+                        parsed = new Literal(parsed.type, parsed.evaluate(ec));
+                    } catch (e) {
+                        this.error(e.message);
+                        return null;
+                    }
+                }
+
+                return parsed;
+            }
+
+            return this.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
+        } else if (typeof expr === 'undefined') {
+            return this.error(`'undefined' value invalid. Use null instead.`);
+        } else if (typeof expr === 'object') {
+            return this.error(`Bare objects invalid. Use ["literal", {...}] instead.`);
+        } else {
+            return this.error(`Expected an array, but found ${typeof expr} instead.`);
+        }
+    }
+
+    /**
+     * Returns a copy of this context suitable for parsing the subexpression at
+     * index `index`, optionally appending to 'let' binding map.
+     *
+     * Note that `errors` property, intended for collecting errors while
+     * parsing, is copied by reference rather than cloned.
+     * @private
+     */
+    concat(index: number, expectedType?: ?Type, bindings?: Array<[string, Expression]>): ParsingContext {
+        const path = typeof index === 'number' ? this.path.concat(index) : this.path;
+        const scope = bindings ? this.scope.concat(bindings) : this.scope;
+        return new ParsingContext(
+            this.registry,
+            path,
+            expectedType || null,
+            scope,
+            this.errors
+        );
+    }
+
+    /**
+     * Push a parsing (or type checking) error into the `this.errors`
+     * @param error The message
+     * @param keys Optionally specify the source of the error at a child
+     * of the current expression at `this.key`.
+     * @private
+     */
+    error(error: string, ...keys: Array<number>) {
+        const key = `${this.key}${keys.map(k => `[${k}]`).join('')}`;
+        this.errors.push(new ParsingError(key, error));
+    }
+
+    /**
+     * Returns null if `t` is a subtype of `expected`; otherwise returns an
+     * error message and also pushes it to `this.errors`.
+     */
+    checkSubtype(expected: Type, t: Type): ?string {
+        const error = checkSubtype(expected, t);
+        if (error) this.error(error);
+        return error;
+    }
+}
+
+export default ParsingContext;
+
+function isConstant(expression: Expression) {
+    if (expression instanceof Var) {
+        return isConstant(expression.boundExpression);
+    } else if (expression instanceof CompoundExpression && expression.name === 'error') {
+        return false;
+    } else if (expression instanceof CollatorExpression) {
+        // Although the results of a Collator expression with fixed arguments
+        // generally shouldn't change between executions, we can't serialize them
+        // as constant expressions because results change based on environment.
+        return false;
+    } else if (expression instanceof Within) {
+        return false;
+    }
+
+    const isTypeAnnotation = expression instanceof Coercion ||
+        expression instanceof Assertion;
+
+    let childrenConstant = true;
+    expression.eachChild(child => {
+        // We can _almost_ assume that if `expressions` children are constant,
+        // they would already have been evaluated to Literal values when they
+        // were parsed.  Type annotations are the exception, because they might
+        // have been inferred and added after a child was parsed.
+
+        // So we recurse into isConstant() for the children of type annotations,
+        // but otherwise simply check whether they are Literals.
+        if (isTypeAnnotation) {
+            childrenConstant = childrenConstant && isConstant(child);
+        } else {
+            childrenConstant = childrenConstant && child instanceof Literal;
+        }
+    });
+    if (!childrenConstant) {
+        return false;
+    }
+
+    return isFeatureConstant(expression) &&
+        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'line-progress', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center']);
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/parsing_error.js

@@ -0,0 +1,13 @@
+// @flow
+
+class ParsingError extends Error {
+    key: string;
+    message: string;
+    constructor(key: string, message: string) {
+        super(message);
+        this.message = message;
+        this.key = key;
+    }
+}
+
+export default ParsingError;

node_modules/@mapbox/mapbox-gl-style-spec/expression/runtime_error.js

@@ -0,0 +1,17 @@
+// @flow
+
+class RuntimeError {
+    name: string;
+    message: string;
+
+    constructor(message: string) {
+        this.name = 'ExpressionEvaluationError';
+        this.message = message;
+    }
+
+    toJSON(): string {
+        return this.message;
+    }
+}
+
+export default RuntimeError;

node_modules/@mapbox/mapbox-gl-style-spec/expression/scope.js

@@ -0,0 +1,36 @@
+// @flow
+
+import type {Expression} from './expression.js';
+
+/**
+ * Tracks `let` bindings during expression parsing.
+ * @private
+ */
+class Scope {
+    parent: ?Scope;
+    bindings: {[_: string]: Expression};
+    constructor(parent?: Scope, bindings: Array<[string, Expression]> = []) {
+        this.parent = parent;
+        this.bindings = {};
+        for (const [name, expression] of bindings) {
+            this.bindings[name] = expression;
+        }
+    }
+
+    concat(bindings: Array<[string, Expression]>): Scope {
+        return new Scope(this, bindings);
+    }
+
+    get(name: string): Expression {
+        if (this.bindings[name]) { return this.bindings[name]; }
+        if (this.parent) { return this.parent.get(name); }
+        throw new Error(`${name} not found in scope.`);
+    }
+
+    has(name: string): boolean {
+        if (this.bindings[name]) return true;
+        return this.parent ? this.parent.has(name) : false;
+    }
+}
+
+export default Scope;

node_modules/@mapbox/mapbox-gl-style-spec/expression/stops.js

@@ -0,0 +1,39 @@
+// @flow
+
+import RuntimeError from './runtime_error.js';
+
+import type {Expression} from './expression.js';
+
+export type Stops = Array<[number, Expression]>;
+
+/**
+ * Returns the index of the last stop <= input, or 0 if it doesn't exist.
+ * @private
+ */
+export function findStopLessThanOrEqualTo(stops: Array<number>, input: number): number {
+    const lastIndex = stops.length - 1;
+    let lowerIndex = 0;
+    let upperIndex = lastIndex;
+    let currentIndex = 0;
+    let currentValue, nextValue;
+
+    while (lowerIndex <= upperIndex) {
+        currentIndex = Math.floor((lowerIndex + upperIndex) / 2);
+        currentValue = stops[currentIndex];
+        nextValue = stops[currentIndex + 1];
+
+        if (currentValue <= input) {
+            if (currentIndex === lastIndex || input < nextValue) { // Search complete
+                return currentIndex;
+            }
+
+            lowerIndex = currentIndex + 1;
+        } else if (currentValue > input) {
+            upperIndex = currentIndex - 1;
+        } else {
+            throw new RuntimeError('Input is not a number.');
+        }
+    }
+
+    return 0;
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/types.js

@@ -0,0 +1,126 @@
+// @flow
+
+export type NullTypeT = { kind: 'null' };
+export type NumberTypeT = { kind: 'number' };
+export type StringTypeT = { kind: 'string' };
+export type BooleanTypeT = { kind: 'boolean' };
+export type ColorTypeT = { kind: 'color' };
+export type ObjectTypeT = { kind: 'object' };
+export type ValueTypeT = { kind: 'value' };
+export type ErrorTypeT = { kind: 'error' };
+export type CollatorTypeT = { kind: 'collator' };
+export type FormattedTypeT = { kind: 'formatted' };
+export type ResolvedImageTypeT = { kind: 'resolvedImage' };
+
+export type EvaluationKind = 'constant' | 'source' | 'camera' | 'composite';
+
+export type Type =
+    NullTypeT |
+    NumberTypeT |
+    StringTypeT |
+    BooleanTypeT |
+    ColorTypeT |
+    ObjectTypeT |
+    ValueTypeT |
+    ArrayType | // eslint-disable-line no-use-before-define
+    ErrorTypeT |
+    CollatorTypeT |
+    FormattedTypeT |
+    ResolvedImageTypeT
+
+export type ArrayType = {
+    kind: 'array',
+    itemType: Type,
+    N: ?number
+}
+
+export type NativeType = 'number' | 'string' | 'boolean' | 'null' | 'array' | 'object'
+
+export const NullType = {kind: 'null'};
+export const NumberType = {kind: 'number'};
+export const StringType = {kind: 'string'};
+export const BooleanType = {kind: 'boolean'};
+export const ColorType = {kind: 'color'};
+export const ObjectType = {kind: 'object'};
+export const ValueType = {kind: 'value'};
+export const ErrorType = {kind: 'error'};
+export const CollatorType = {kind: 'collator'};
+export const FormattedType = {kind: 'formatted'};
+export const ResolvedImageType = {kind: 'resolvedImage'};
+
+export function array(itemType: Type, N: ?number): ArrayType {
+    return {
+        kind: 'array',
+        itemType,
+        N
+    };
+}
+
+export function toString(type: Type): string {
+    if (type.kind === 'array') {
+        const itemType = toString(type.itemType);
+        return typeof type.N === 'number' ?
+            `array<${itemType}, ${type.N}>` :
+            type.itemType.kind === 'value' ? 'array' : `array<${itemType}>`;
+    } else {
+        return type.kind;
+    }
+}
+
+const valueMemberTypes = [
+    NullType,
+    NumberType,
+    StringType,
+    BooleanType,
+    ColorType,
+    FormattedType,
+    ObjectType,
+    array(ValueType),
+    ResolvedImageType
+];
+
+/**
+ * Returns null if `t` is a subtype of `expected`; otherwise returns an
+ * error message.
+ * @private
+ */
+export function checkSubtype(expected: Type, t: Type): ?string {
+    if (t.kind === 'error') {
+        // Error is a subtype of every type
+        return null;
+    } else if (expected.kind === 'array') {
+        if (t.kind === 'array' &&
+            ((t.N === 0 && t.itemType.kind === 'value') || !checkSubtype(expected.itemType, t.itemType)) &&
+            (typeof expected.N !== 'number' || expected.N === t.N)) {
+            return null;
+        }
+    } else if (expected.kind === t.kind) {
+        return null;
+    } else if (expected.kind === 'value') {
+        for (const memberType of valueMemberTypes) {
+            if (!checkSubtype(memberType, t)) {
+                return null;
+            }
+        }
+    }
+
+    return `Expected ${toString(expected)} but found ${toString(t)} instead.`;
+}
+
+export function isValidType(provided: Type, allowedTypes: Array<Type>): boolean {
+    return allowedTypes.some(t => t.kind === provided.kind);
+}
+
+export function isValidNativeType(provided: any, allowedTypes: Array<NativeType>): boolean {
+    return allowedTypes.some(t => {
+        if (t === 'null') {
+            return provided === null;
+        } else if (t === 'array') {
+            return Array.isArray(provided);
+        } else if (t === 'object') {
+            return provided && !Array.isArray(provided) && typeof provided === 'object';
+        } else {
+            return t === typeof provided;
+        }
+    });
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/types/collator.js

@@ -0,0 +1,61 @@
+// @flow
+
+// Flow type declarations for Intl cribbed from
+// https://github.com/facebook/flow/issues/1270
+
+declare var Intl: {
+    Collator: Class<Intl$Collator>
+};
+
+declare class Intl$Collator {
+    constructor (
+        locales?: string | string[],
+        options?: CollatorOptions
+    ): Intl$Collator;
+
+    static (
+        locales?: string | string[],
+        options?: CollatorOptions
+    ): Intl$Collator;
+
+    compare (a: string, b: string): number;
+
+    resolvedOptions(): any;
+}
+
+type CollatorOptions = {
+    localeMatcher?: 'lookup' | 'best fit',
+    usage?: 'sort' | 'search',
+    sensitivity?: 'base' | 'accent' | 'case' | 'variant',
+    ignorePunctuation?: boolean,
+    numeric?: boolean,
+    caseFirst?: 'upper' | 'lower' | 'false'
+}
+
+export default class Collator {
+    locale: string | null;
+    sensitivity: 'base' | 'accent' | 'case' | 'variant';
+    collator: Intl$Collator;
+
+    constructor(caseSensitive: boolean, diacriticSensitive: boolean, locale: string | null) {
+        if (caseSensitive)
+            this.sensitivity = diacriticSensitive ? 'variant' : 'case';
+        else
+            this.sensitivity = diacriticSensitive ? 'accent' : 'base';
+
+        this.locale = locale;
+        this.collator = new Intl.Collator(this.locale ? this.locale : [],
+            {sensitivity: this.sensitivity, usage: 'search'});
+    }
+
+    compare(lhs: string, rhs: string): number {
+        return this.collator.compare(lhs, rhs);
+    }
+
+    resolvedLocale(): string {
+        // We create a Collator without "usage: search" because we don't want
+        // the search options encoded in our result (e.g. "en-u-co-search")
+        return new Intl.Collator(this.locale ? this.locale : [])
+            .resolvedOptions().locale;
+    }
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/types/formatted.js

@@ -0,0 +1,74 @@
+// @flow
+import type Color from '../../util/color.js';
+import type ResolvedImage from '../types/resolved_image.js';
+
+export class FormattedSection {
+    text: string;
+    image: ResolvedImage | null;
+    scale: number | null;
+    fontStack: string | null;
+    textColor: Color | null;
+
+    constructor(text: string, image: ResolvedImage | null, scale: number | null, fontStack: string | null, textColor: Color | null) {
+        // combine characters so that diacritic marks are not separate code points
+        this.text = text.normalize ? text.normalize() : text;
+        this.image = image;
+        this.scale = scale;
+        this.fontStack = fontStack;
+        this.textColor = textColor;
+    }
+}
+
+export default class Formatted {
+    sections: Array<FormattedSection>;
+
+    constructor(sections: Array<FormattedSection>) {
+        this.sections = sections;
+    }
+
+    static fromString(unformatted: string): Formatted {
+        return new Formatted([new FormattedSection(unformatted, null, null, null, null)]);
+    }
+
+    isEmpty(): boolean {
+        if (this.sections.length === 0) return true;
+        return !this.sections.some(section => section.text.length !== 0 ||
+                                             (section.image && section.image.name.length !== 0));
+    }
+
+    static factory(text: Formatted | string): Formatted {
+        if (text instanceof Formatted) {
+            return text;
+        } else {
+            return Formatted.fromString(text);
+        }
+    }
+
+    toString(): string {
+        if (this.sections.length === 0) return '';
+        return this.sections.map(section => section.text).join('');
+    }
+
+    serialize(): Array<mixed> {
+        const serialized: Array<mixed> = ["format"];
+        for (const section of this.sections) {
+            if (section.image) {
+                serialized.push(["image", section.image.name]);
+                continue;
+            }
+            serialized.push(section.text);
+            const options: { [key: string]: mixed } = {};
+            if (section.fontStack) {
+                options["text-font"] = ["literal", section.fontStack.split(',')];
+            }
+            if (section.scale) {
+                options["font-scale"] = section.scale;
+            }
+            if (section.textColor) {
+                options["text-color"] = (["rgba"]: Array<mixed>).concat(section.textColor.toArray());
+            }
+            serialized.push(options);
+        }
+        return serialized;
+    }
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/types/resolved_image.js

@@ -0,0 +1,29 @@
+// @flow
+
+export type ResolvedImageOptions = {
+    name: string,
+    available: boolean
+};
+
+export default class ResolvedImage {
+    name: string;
+    available: boolean;
+
+    constructor(options: ResolvedImageOptions) {
+        this.name = options.name;
+        this.available = options.available;
+    }
+
+    toString(): string {
+        return this.name;
+    }
+
+    static fromString(name: string): ResolvedImage | null {
+        if (!name) return null; // treat empty values as no image
+        return new ResolvedImage({name, available: false});
+    }
+
+    serialize(): Array<string> {
+        return ["image", this.name];
+    }
+}

node_modules/@mapbox/mapbox-gl-style-spec/expression/values.js

@@ -0,0 +1,123 @@
+// @flow
+
+import assert from 'assert';
+
+import Color from '../util/color.js';
+import Collator from './types/collator.js';
+import Formatted from './types/formatted.js';
+import ResolvedImage from './types/resolved_image.js';
+import {NullType, NumberType, StringType, BooleanType, ColorType, ObjectType, ValueType, CollatorType, FormattedType, ResolvedImageType, array} from './types.js';
+
+import type {Type} from './types.js';
+
+export function validateRGBA(r: mixed, g: mixed, b: mixed, a?: mixed): string | null {
+    if (!(
+        typeof r === 'number' && r >= 0 && r <= 255 &&
+        typeof g === 'number' && g >= 0 && g <= 255 &&
+        typeof b === 'number' && b >= 0 && b <= 255
+    )) {
+        const value = typeof a === 'number' ? [r, g, b, a] : [r, g, b];
+        return `Invalid rgba value [${value.join(', ')}]: 'r', 'g', and 'b' must be between 0 and 255.`;
+    }
+
+    if (!(
+        typeof a === 'undefined' || (typeof a === 'number' && a >= 0 && a <= 1)
+    )) {
+        return `Invalid rgba value [${[r, g, b, a].join(', ')}]: 'a' must be between 0 and 1.`;
+    }
+
+    return null;
+}
+
+export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | $ReadOnlyArray<Value> | { +[string]: Value }
+
+export function isValue(mixed: mixed): boolean {
+    if (mixed === null) {
+        return true;
+    } else if (typeof mixed === 'string') {
+        return true;
+    } else if (typeof mixed === 'boolean') {
+        return true;
+    } else if (typeof mixed === 'number') {
+        return true;
+    } else if (mixed instanceof Color) {
+        return true;
+    } else if (mixed instanceof Collator) {
+        return true;
+    } else if (mixed instanceof Formatted) {
+        return true;
+    } else if (mixed instanceof ResolvedImage) {
+        return true;
+    } else if (Array.isArray(mixed)) {
+        for (const item of mixed) {
+            if (!isValue(item)) {
+                return false;
+            }
+        }
+        return true;
+    } else if (typeof mixed === 'object') {
+        for (const key in mixed) {
+            if (!isValue(mixed[key])) {
+                return false;
+            }
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+export function typeOf(value: Value): Type {
+    if (value === null) {
+        return NullType;
+    } else if (typeof value === 'string') {
+        return StringType;
+    } else if (typeof value === 'boolean') {
+        return BooleanType;
+    } else if (typeof value === 'number') {
+        return NumberType;
+    } else if (value instanceof Color) {
+        return ColorType;
+    } else if (value instanceof Collator) {
+        return CollatorType;
+    } else if (value instanceof Formatted) {
+        return FormattedType;
+    } else if (value instanceof ResolvedImage) {
+        return ResolvedImageType;
+    } else if (Array.isArray(value)) {
+        const length = value.length;
+        let itemType: Type | typeof undefined;
+
+        for (const item of value) {
+            const t = typeOf(item);
+            if (!itemType) {
+                itemType = t;
+            } else if (itemType === t) {
+                continue;
+            } else {
+                itemType = ValueType;
+                break;
+            }
+        }
+
+        return array(itemType || ValueType, length);
+    } else {
+        assert(typeof value === 'object');
+        return ObjectType;
+    }
+}
+
+export function toString(value: Value): string {
+    const type = typeof value;
+    if (value === null) {
+        return '';
+    } else if (type === 'string' || type === 'number' || type === 'boolean') {
+        return String(value);
+    } else if (value instanceof Color || value instanceof Formatted || value instanceof ResolvedImage) {
+        return value.toString();
+    } else {
+        return JSON.stringify(value);
+    }
+}
+
+export {Color, Collator};