ShuoHuang/public/SuperMap/Cesium/Workers/MVTWorkTile.js

/**
 * Cesium - https://github.com/AnalyticalGraphicsInc/cesium
 *
 * Copyright 2011-2017 Cesium Contributors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Columbus View (Pat. Pend.)
 *
 * Portions licensed separately.
 * See https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md for full licensing details.
 */
define(['./when-8d13db60', './createTaskProcessorWorker', './earcut-2.2.1-b404d9e6', './defined-21f7e510', './pbf-9fe59c76'], function (when, createTaskProcessorWorker, earcut2_2_1, defined, pbf) { 'use strict';

    function DictionaryCoder(strings) {
        this._stringToNumber = {};
        this._numberToString = [];
        for (var i = 0; i < strings.length; i++) {
            var string = strings[i];
            this._stringToNumber[string] = i;
            this._numberToString[i] = string;
        }
    }

    DictionaryCoder.prototype.encode = function(string) {
        return this._stringToNumber[string];
    };

    DictionaryCoder.prototype.decode = function(n) {
        return this._numberToString[n];
    };

    var viewTypes = {
        'Int8': Int8Array,
        'Uint8': Uint8Array,
        'Int16': Int16Array,
        'Uint16': Uint16Array,
        'Int32': Int32Array,
        'Uint32': Uint32Array,
        'Float32': Float32Array
    };

    /**
     * Given a list of member fields, create a full StructArrayLayout, in
     * particular calculating the correct byte offset for each field.  This data
     * is used at build time to generate StructArrayLayout_*#emplaceBack() and
     * other accessors, and at runtime for binding vertex buffer attributes.
     *
     * @private
     */
    function createLayout(members, alignment) {
        if (alignment === void 0) alignment = 1;


        var offset = 0;
        var maxSize = 0;
        var layoutMembers = members.map(function (member) {
            //assert_1(member.name.length);
            var typeSize = sizeOf(member.type);
            var memberOffset = offset = align(offset, Math.max(alignment, typeSize));
            var components = member.components || 1;

            maxSize = Math.max(maxSize, typeSize);
            offset += typeSize * components;

            return {
                name: member.name,
                type: member.type,
                components: components,
                offset: memberOffset,
            };
        });

        var size = align(offset, Math.max(maxSize, alignment));

        return {
            members: layoutMembers,
            size: size,
            alignment: alignment
        };
    }

    function sizeOf(type) {
        return viewTypes[type].BYTES_PER_ELEMENT;
    }

    function align(offset, size) {
        return Math.ceil(offset / size) * size;
    }

    var IMAGE_PADDING = 1;

    var ImagePosition = function ImagePosition(paddedRect, ref) {
        var pixelRatio = ref.pixelRatio;
        var version = ref.version;
        var stretchX = ref.stretchX;
        var stretchY = ref.stretchY;
        var content = ref.content;

        this.paddedRect = paddedRect;
        this.pixelRatio = pixelRatio;
        this.stretchX = stretchX;
        this.stretchY = stretchY;
        this.content = content;
        this.version = version;
    };

    var prototypeAccessors = { tl: { configurable: true }, br: { configurable: true }, tlbr: { configurable: true }, displaySize: { configurable: true } };

    prototypeAccessors.tl.get = function () {
        return [
            this.paddedRect.x + IMAGE_PADDING,
            this.paddedRect.y + IMAGE_PADDING
        ];
    };

    prototypeAccessors.br.get = function () {
        return [
            this.paddedRect.x + this.paddedRect.w - IMAGE_PADDING,
            this.paddedRect.y + this.paddedRect.h - IMAGE_PADDING
        ];
    };

    prototypeAccessors.tlbr.get = function () {
        return this.tl.concat(this.br);
    };

    prototypeAccessors.displaySize.get = function () {
        return [
            (this.paddedRect.w - IMAGE_PADDING * 2) / this.pixelRatio,
            (this.paddedRect.h - IMAGE_PADDING * 2) / this.pixelRatio
        ];
    };

    Object.defineProperties(ImagePosition.prototype, prototypeAccessors);

    // Not premultiplied, because ImageData is not premultiplied.
    // UNPACK_PREMULTIPLY_ALPHA_WEBGL must be used when uploading to a texture.
    var RGBAImage = function RGBAImage(size, data) {
        createImage(this, size, 4, data);
    };

    RGBAImage.prototype.resize = function resize(size) {
        resizeImage(this, size, 4);
    };

    RGBAImage.prototype.replace = function replace(data, copy) {
        if (copy) {
            this.data.set(data);
        } else if (data instanceof Uint8ClampedArray) {
            this.data = new Uint8Array(data.buffer);
        } else {
            this.data = data;
        }
    };

    RGBAImage.prototype.clone = function clone() {
        return new RGBAImage({width: this.width, height: this.height}, new Uint8Array(this.data));
    };

    RGBAImage.copy = function copy(srcImg, dstImg, srcPt, dstPt, size) {
        copyImage(srcImg, dstImg, srcPt, dstPt, size, 4);
    };

    function createImage(image, ref, channels, data) {
        var width = ref.width;
        var height = ref.height;

        if (!data) {
            data = new Uint8Array(width * height * channels);
        } else if (data instanceof Uint8ClampedArray) {
            data = new Uint8Array(data.buffer);
        } else if (data.length !== width * height * channels) {
            throw new RangeError('mismatched image size');
        }
        image.width = width;
        image.height = height;
        image.data = data;
        return image;
    }

    function resizeImage(image, ref, channels) {
        var width = ref.width;
        var height = ref.height;

        if (width === image.width && height === image.height) {
            return;
        }

        var newImage = createImage({}, {width: width, height: height}, channels);

        copyImage(image, newImage, {x: 0, y: 0}, {x: 0, y: 0}, {
            width: Math.min(image.width, width),
            height: Math.min(image.height, height)
        }, channels);

        image.width = width;
        image.height = height;
        image.data = newImage.data;
    }

    function copyImage(srcImg, dstImg, srcPt, dstPt, size, channels) {
        if (size.width === 0 || size.height === 0) {
            return dstImg;
        }

        if (size.width > srcImg.width ||
            size.height > srcImg.height ||
            srcPt.x > srcImg.width - size.width ||
            srcPt.y > srcImg.height - size.height) {
            throw new RangeError('out of range source coordinates for image copy');
        }

        if (size.width > dstImg.width ||
            size.height > dstImg.height ||
            dstPt.x > dstImg.width - size.width ||
            dstPt.y > dstImg.height - size.height) {
            throw new RangeError('out of range destination coordinates for image copy');
        }

        var srcData = srcImg.data;
        var dstData = dstImg.data;

        //assert_1(srcData !== dstData);

        for (var y = 0; y < size.height; y++) {
            var srcOffset = ((srcPt.y + y) * srcImg.width + srcPt.x) * channels;
            var dstOffset = ((dstPt.y + y) * dstImg.width + dstPt.x) * channels;
            for (var i = 0; i < size.width * channels; i++) {
                dstData[dstOffset + i] = srcData[srcOffset + i];
            }
        }
        return dstImg;
    }

    function potpack(boxes) {

        // calculate total box area and maximum box width
        var area = 0;
        var maxWidth = 0;

        for (var i$1 = 0, list = boxes; i$1 < list.length; i$1 += 1) {
            var box = list[i$1];

            area += box.w * box.h;
            maxWidth = Math.max(maxWidth, box.w);
        }

        // sort the boxes for insertion by height, descending
        boxes.sort(function (a, b) { return b.h - a.h; });

        // aim for a squarish resulting container,
        // slightly adjusted for sub-100% space utilization
        var startWidth = Math.max(Math.ceil(Math.sqrt(area / 0.95)), maxWidth);

        // start with a single empty space, unbounded at the bottom
        var spaces = [{x: 0, y: 0, w: startWidth, h: Infinity}];

        var width = 0;
        var height = 0;

        for (var i$2 = 0, list$1 = boxes; i$2 < list$1.length; i$2 += 1) {
            // look through spaces backwards so that we check smaller spaces first
            var box$1 = list$1[i$2];

            for (var i = spaces.length - 1; i >= 0; i--) {
                var space = spaces[i];

                // look for empty spaces that can accommodate the current box
                if (box$1.w > space.w || box$1.h > space.h) { continue; }

                // found the space; add the box to its top-left corner
                // |-------|-------|
                // |  box  |       |
                // |_______|       |
                // |         space |
                // |_______________|
                box$1.x = space.x;
                box$1.y = space.y;

                height = Math.max(height, box$1.y + box$1.h);
                width = Math.max(width, box$1.x + box$1.w);

                if (box$1.w === space.w && box$1.h === space.h) {
                    // space matches the box exactly; remove it
                    var last = spaces.pop();
                    if (i < spaces.length) { spaces[i] = last; }

                } else if (box$1.h === space.h) {
                    // space matches the box height; update it accordingly
                    // |-------|---------------|
                    // |  box  | updated space |
                    // |_______|_______________|
                    space.x += box$1.w;
                    space.w -= box$1.w;

                } else if (box$1.w === space.w) {
                    // space matches the box width; update it accordingly
                    // |---------------|
                    // |      box      |
                    // |_______________|
                    // | updated space |
                    // |_______________|
                    space.y += box$1.h;
                    space.h -= box$1.h;

                } else {
                    // otherwise the box splits the space into two spaces
                    // |-------|-----------|
                    // |  box  | new space |
                    // |_______|___________|
                    // | updated space     |
                    // |___________________|
                    spaces.push({
                        x: space.x + box$1.w,
                        y: space.y,
                        w: space.w - box$1.w,
                        h: box$1.h
                    });
                    space.y += box$1.h;
                    space.h -= box$1.h;
                }
                break;
            }
        }

        return {
            w: width, // container width
            h: height, // container height
            fill: (area / (width * height)) || 0 // space utilization
        };
    }

    var IMAGE_PADDING$1 = 1;

    var ImageAtlas = function ImageAtlas(icons, patterns) {
        var iconPositions = {}, patternPositions = {};
        this.haveRenderCallbacks = [];

        var bins = [];

        this.addImages(icons, iconPositions, bins);
        this.addImages(patterns, patternPositions, bins);

        var ref = potpack(bins);
        var w = ref.w;
        var h = ref.h;
        var image = new RGBAImage({width: w || 1, height: h || 1});

        for (var id in icons) {
            var src = icons[id];
            var bin = iconPositions[id].paddedRect;
            RGBAImage.copy(src.data, image, {x: 0, y: 0}, {x: bin.x + IMAGE_PADDING$1, y: bin.y + IMAGE_PADDING$1}, src.data);
        }

        for (var id$1 in patterns) {
            var src$1 = patterns[id$1];
            var bin$1 = patternPositions[id$1].paddedRect;
            var x = bin$1.x + IMAGE_PADDING$1,
                y = bin$1.y + IMAGE_PADDING$1,
                w$1 = src$1.data.width,
                h$1 = src$1.data.height;

            RGBAImage.copy(src$1.data, image, {x: 0, y: 0}, {x: x, y: y}, src$1.data);
            // Add 1 pixel wrapped padding on each side of the image.
            RGBAImage.copy(src$1.data, image, {x: 0, y: h$1 - 1}, {x: x, y: y - 1}, {width: w$1, height: 1}); // T
            RGBAImage.copy(src$1.data, image, {x: 0, y: 0}, {x: x, y: y + h$1}, {width: w$1, height: 1}); // B
            RGBAImage.copy(src$1.data, image, {x: w$1 - 1, y: 0}, {x: x - 1, y: y}, {width: 1, height: h$1}); // L
            RGBAImage.copy(src$1.data, image, {x: 0, y: 0}, {x: x + w$1, y: y}, {width: 1, height: h$1}); // R
        }

        this.image = image;
        this.iconPositions = iconPositions;
        this.patternPositions = patternPositions;
    };

    ImageAtlas.prototype.addImages = function addImages(images, positions, bins) {
        for (var id in images) {
            var src = images[id];
            var bin = {
                x: 0,
                y: 0,
                w: src.data.width + 2 * IMAGE_PADDING$1,
                h: src.data.height + 2 * IMAGE_PADDING$1,
            };
            bins.push(bin);
            positions[id] = new ImagePosition(bin, src);

            if (src.hasRenderCallback) {
                this.haveRenderCallbacks.push(id);
            }
        }
    };

    ImageAtlas.prototype.patchUpdatedImages = function patchUpdatedImages(imageManager, texture) {
        imageManager.dispatchRenderCallbacks(this.haveRenderCallbacks);
        for (var name in imageManager.updatedImages) {
            this.patchUpdatedImage(this.iconPositions[name], imageManager.getImage(name), texture);
            this.patchUpdatedImage(this.patternPositions[name], imageManager.getImage(name), texture);
        }
    };

    ImageAtlas.prototype.patchUpdatedImage = function patchUpdatedImage(position, image, texture) {
        if (!position || !image) {
            return;
        }

        if (position.version === image.version) {
            return;
        }

        position.version = image.version;
        var ref = position.tl;
        var x = ref[0];
        var y = ref[1];
        texture.update(image.data, undefined, {x: x, y: y});
    };

    // http://www.w3.org/TR/css3-color/
    var kCSSColorTable = {
        "transparent": [0,0,0,0], "aliceblue": [240,248,255,1],
        "antiquewhite": [250,235,215,1], "aqua": [0,255,255,1],
        "aquamarine": [127,255,212,1], "azure": [240,255,255,1],
        "beige": [245,245,220,1], "bisque": [255,228,196,1],
        "black": [0,0,0,1], "blanchedalmond": [255,235,205,1],
        "blue": [0,0,255,1], "blueviolet": [138,43,226,1],
        "brown": [165,42,42,1], "burlywood": [222,184,135,1],
        "cadetblue": [95,158,160,1], "chartreuse": [127,255,0,1],
        "chocolate": [210,105,30,1], "coral": [255,127,80,1],
        "cornflowerblue": [100,149,237,1], "cornsilk": [255,248,220,1],
        "crimson": [220,20,60,1], "cyan": [0,255,255,1],
        "darkblue": [0,0,139,1], "darkcyan": [0,139,139,1],
        "darkgoldenrod": [184,134,11,1], "darkgray": [169,169,169,1],
        "darkgreen": [0,100,0,1], "darkgrey": [169,169,169,1],
        "darkkhaki": [189,183,107,1], "darkmagenta": [139,0,139,1],
        "darkolivegreen": [85,107,47,1], "darkorange": [255,140,0,1],
        "darkorchid": [153,50,204,1], "darkred": [139,0,0,1],
        "darksalmon": [233,150,122,1], "darkseagreen": [143,188,143,1],
        "darkslateblue": [72,61,139,1], "darkslategray": [47,79,79,1],
        "darkslategrey": [47,79,79,1], "darkturquoise": [0,206,209,1],
        "darkviolet": [148,0,211,1], "deeppink": [255,20,147,1],
        "deepskyblue": [0,191,255,1], "dimgray": [105,105,105,1],
        "dimgrey": [105,105,105,1], "dodgerblue": [30,144,255,1],
        "firebrick": [178,34,34,1], "floralwhite": [255,250,240,1],
        "forestgreen": [34,139,34,1], "fuchsia": [255,0,255,1],
        "gainsboro": [220,220,220,1], "ghostwhite": [248,248,255,1],
        "gold": [255,215,0,1], "goldenrod": [218,165,32,1],
        "gray": [128,128,128,1], "green": [0,128,0,1],
        "greenyellow": [173,255,47,1], "grey": [128,128,128,1],
        "honeydew": [240,255,240,1], "hotpink": [255,105,180,1],
        "indianred": [205,92,92,1], "indigo": [75,0,130,1],
        "ivory": [255,255,240,1], "khaki": [240,230,140,1],
        "lavender": [230,230,250,1], "lavenderblush": [255,240,245,1],
        "lawngreen": [124,252,0,1], "lemonchiffon": [255,250,205,1],
        "lightblue": [173,216,230,1], "lightcoral": [240,128,128,1],
        "lightcyan": [224,255,255,1], "lightgoldenrodyellow": [250,250,210,1],
        "lightgray": [211,211,211,1], "lightgreen": [144,238,144,1],
        "lightgrey": [211,211,211,1], "lightpink": [255,182,193,1],
        "lightsalmon": [255,160,122,1], "lightseagreen": [32,178,170,1],
        "lightskyblue": [135,206,250,1], "lightslategray": [119,136,153,1],
        "lightslategrey": [119,136,153,1], "lightsteelblue": [176,196,222,1],
        "lightyellow": [255,255,224,1], "lime": [0,255,0,1],
        "limegreen": [50,205,50,1], "linen": [250,240,230,1],
        "magenta": [255,0,255,1], "maroon": [128,0,0,1],
        "mediumaquamarine": [102,205,170,1], "mediumblue": [0,0,205,1],
        "mediumorchid": [186,85,211,1], "mediumpurple": [147,112,219,1],
        "mediumseagreen": [60,179,113,1], "mediumslateblue": [123,104,238,1],
        "mediumspringgreen": [0,250,154,1], "mediumturquoise": [72,209,204,1],
        "mediumvioletred": [199,21,133,1], "midnightblue": [25,25,112,1],
        "mintcream": [245,255,250,1], "mistyrose": [255,228,225,1],
        "moccasin": [255,228,181,1], "navajowhite": [255,222,173,1],
        "navy": [0,0,128,1], "oldlace": [253,245,230,1],
        "olive": [128,128,0,1], "olivedrab": [107,142,35,1],
        "orange": [255,165,0,1], "orangered": [255,69,0,1],
        "orchid": [218,112,214,1], "palegoldenrod": [238,232,170,1],
        "palegreen": [152,251,152,1], "paleturquoise": [175,238,238,1],
        "palevioletred": [219,112,147,1], "papayawhip": [255,239,213,1],
        "peachpuff": [255,218,185,1], "peru": [205,133,63,1],
        "pink": [255,192,203,1], "plum": [221,160,221,1],
        "powderblue": [176,224,230,1], "purple": [128,0,128,1],
        "rebeccapurple": [102,51,153,1],
        "red": [255,0,0,1], "rosybrown": [188,143,143,1],
        "royalblue": [65,105,225,1], "saddlebrown": [139,69,19,1],
        "salmon": [250,128,114,1], "sandybrown": [244,164,96,1],
        "seagreen": [46,139,87,1], "seashell": [255,245,238,1],
        "sienna": [160,82,45,1], "silver": [192,192,192,1],
        "skyblue": [135,206,235,1], "slateblue": [106,90,205,1],
        "slategray": [112,128,144,1], "slategrey": [112,128,144,1],
        "snow": [255,250,250,1], "springgreen": [0,255,127,1],
        "steelblue": [70,130,180,1], "tan": [210,180,140,1],
        "teal": [0,128,128,1], "thistle": [216,191,216,1],
        "tomato": [255,99,71,1], "turquoise": [64,224,208,1],
        "violet": [238,130,238,1], "wheat": [245,222,179,1],
        "white": [255,255,255,1], "whitesmoke": [245,245,245,1],
        "yellow": [255,255,0,1], "yellowgreen": [154,205,50,1]};

    function clamp_css_byte(i) {  // Clamp to integer 0 .. 255.
        i = Math.round(i);  // Seems to be what Chrome does (vs truncation).
        return i < 0 ? 0 : i > 255 ? 255 : i;
    }

    function clamp_css_float(f) {  // Clamp to float 0.0 .. 1.0.
        return f < 0 ? 0 : f > 1 ? 1 : f;
    }

    function parse_css_int(str) {  // int or percentage.
        if (str[str.length - 1] === '%')
            return clamp_css_byte(parseFloat(str) / 100 * 255);
        return clamp_css_byte(parseInt(str));
    }

    function parse_css_float(str) {  // float or percentage.
        if (str[str.length - 1] === '%')
            return clamp_css_float(parseFloat(str) / 100);
        return clamp_css_float(parseFloat(str));
    }

    function css_hue_to_rgb(m1, m2, h) {
        if (h < 0) h += 1;
        else if (h > 1) h -= 1;

        if (h * 6 < 1) return m1 + (m2 - m1) * h * 6;
        if (h * 2 < 1) return m2;
        if (h * 3 < 2) return m1 + (m2 - m1) * (2/3 - h) * 6;
        return m1;
    }

    function parseCSSColor(css_str) {
        // Remove all whitespace, not compliant, but should just be more accepting.
        var str = css_str.replace(/ /g, '').toLowerCase();

        // Color keywords (and transparent) lookup.
        if (str in kCSSColorTable) return kCSSColorTable[str].slice();  // dup.

        // #abc and #abc123 syntax.
        if (str[0] === '#') {
            if (str.length === 4) {
                var iv = parseInt(str.substr(1), 16);  // TODO(deanm): Stricter parsing.
                if (!(iv >= 0 && iv <= 0xfff)) return null;  // Covers NaN.
                return [((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8),
                    (iv & 0xf0) | ((iv & 0xf0) >> 4),
                    (iv & 0xf) | ((iv & 0xf) << 4),
                    1];
            } else if (str.length === 7) {
                var iv = parseInt(str.substr(1), 16);  // TODO(deanm): Stricter parsing.
                if (!(iv >= 0 && iv <= 0xffffff)) return null;  // Covers NaN.
                return [(iv & 0xff0000) >> 16,
                    (iv & 0xff00) >> 8,
                    iv & 0xff,
                    1];
            }

            return null;
        }

        var op = str.indexOf('('), ep = str.indexOf(')');
        if (op !== -1 && ep + 1 === str.length) {
            var fname = str.substr(0, op);
            var params = str.substr(op+1, ep-(op+1)).split(',');
            var alpha = 1;  // To allow case fallthrough.
            switch (fname) {
                case 'rgba':
                    if (params.length !== 4) return null;
                    alpha = parse_css_float(params.pop());
                // Fall through.
                case 'rgb':
                    if (params.length !== 3) return null;
                    return [parse_css_int(params[0]),
                        parse_css_int(params[1]),
                        parse_css_int(params[2]),
                        alpha];
                case 'hsla':
                    if (params.length !== 4) return null;
                    alpha = parse_css_float(params.pop());
                // Fall through.
                case 'hsl':
                    if (params.length !== 3) return null;
                    var h = (((parseFloat(params[0]) % 360) + 360) % 360) / 360;  // 0 .. 1
                    // NOTE(deanm): According to the CSS spec s/l should only be
                    // percentages, but we don't bother and let float or percentage.
                    var s = parse_css_float(params[1]);
                    var l = parse_css_float(params[2]);
                    var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
                    var m1 = l * 2 - m2;
                    return [clamp_css_byte(css_hue_to_rgb(m1, m2, h+1/3) * 255),
                        clamp_css_byte(css_hue_to_rgb(m1, m2, h) * 255),
                        clamp_css_byte(css_hue_to_rgb(m1, m2, h-1/3) * 255),
                        alpha];
                default:
                    return null;
            }
        }

        return null;
    }

    /**
     * An RGBA color value. Create instances from color strings using the static
     * method `Color.parse`. The constructor accepts RGB channel values in the range
     * `[0, 1]`, premultiplied by A.
     *
     * @param {number} r The red channel.
     * @param {number} g The green channel.
     * @param {number} b The blue channel.
     * @param {number} a The alpha channel.
     * @private
     */
    var Color$1 = function Color(r, g, b, a) {
        if (a === void 0) a = 1;

        this.r = r;
        this.g = g;
        this.b = b;
        this.a = a;
    };

    /**
     * Parses valid CSS color strings and returns a `Color` instance.
     * @returns A `Color` instance, or `undefined` if the input is not a valid color string.
     */
    Color$1.parse = function parse(input) {
        if (!input) {
            return undefined;
        }

        if (input instanceof Color$1) {
            return input;
        }

        if (typeof input !== 'string') {
            return undefined;
        }

        var rgba = parseCSSColor(input);
        if (!rgba) {
            return undefined;
        }

        return new Color$1(
            rgba[0] / 255 * rgba[3],
            rgba[1] / 255 * rgba[3],
            rgba[2] / 255 * rgba[3],
            rgba[3]
        );
    };

    /**
     * Returns an RGBA string representing the color value.
     *
     * @returns An RGBA string.
     * @example
     * var purple = new Color.parse('purple');
     * purple.toString; // = "rgba(128,0,128,1)"
     * var translucentGreen = new Color.parse('rgba(26, 207, 26, .73)');
     * translucentGreen.toString(); // = "rgba(26,207,26,0.73)"
     */
    Color$1.prototype.toString = function toString() {
        var ref = this.toArray();
        var r = ref[0];
        var g = ref[1];
        var b = ref[2];
        var a = ref[3];
        return ("rgba(" + (Math.round(r)) + "," + (Math.round(g)) + "," + (Math.round(b)) + "," + a + ")");
    };

    Color$1.prototype.toArray = function toArray() {
        var ref = this;
        var r = ref.r;
        var g = ref.g;
        var b = ref.b;
        var a = ref.a;
        return a === 0 ? [0, 0, 0, 0] : [
            r * 255 / a,
            g * 255 / a,
            b * 255 / a,
            a
        ];
    };

    Color$1.black = new Color$1(0, 0, 0, 1);
    Color$1.white = new Color$1(1, 1, 1, 1);
    Color$1.transparent = new Color$1(0, 0, 0, 0);
    Color$1.red = new Color$1(1, 0, 0, 1);

    var NullType = {kind: 'null'};
    var NumberType$1 = {kind: 'number'};
    var StringType = {kind: 'string'};
    var BooleanType = {kind: 'boolean'};
    var ColorType$1 = {kind: 'color'};
    var ObjectType = {kind: 'object'};
    var ValueType = {kind: 'value'};
    var FormattedType = {kind: 'formatted'};
    var ResolvedImageType = {kind: 'resolvedImage'};

    function array(itemType, N) {
        return {
            kind: 'array',
            itemType: itemType,
            N: N
        };
    }

    function toString$2(type) {
        if (type.kind === 'array') {
            var itemType = toString$2(type.itemType);
            return typeof type.N === 'number' ?
                ("array<" + itemType + ", " + (type.N) + ">") :
                type.itemType.kind === 'value' ? 'array' : ("array<" + itemType + ">");
        } else {
            return type.kind;
        }
    }

    var valueMemberTypes = [
        NullType,
        NumberType$1,
        StringType,
        BooleanType,
        ColorType$1,
        FormattedType,
        ObjectType,
        array(ValueType),
        ResolvedImageType
    ];

    /**
     * Returns null if `t` is a subtype of `expected`; otherwise returns an
     * error message.
     * @private
     */
    function checkSubtype(expected, t) {
        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 (var i = 0, list = valueMemberTypes; i < list.length; i += 1) {
                var memberType = list[i];

                if (!checkSubtype(memberType, t)) {
                    return null;
                }
            }
        }

        return ("Expected " + (toString$2(expected)) + " but found " + (toString$2(t)) + " instead.");
    }

    var Collator = function Collator(caseSensitive       , diacriticSensitive       , locale             ) {
        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'});
    };

    Collator.prototype.compare = function compare (lhs      , rhs      )       {
        return this.collator.compare(lhs, rhs);
    };

    Collator.prototype.resolvedLocale = function resolvedLocale ()       {
        // 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;
    };

    var FormattedSection = function FormattedSection(text, image, scale, fontStack, textColor) {
        this.text = text;
        this.image = image;
        this.scale = scale;
        this.fontStack = fontStack;
        this.textColor = textColor;
    };

    var Formatted$1 = function Formatted(sections) {
        this.sections = sections;
    };

    Formatted$1.fromString = function fromString(unformatted) {
        return new Formatted$1([new FormattedSection(unformatted, null, null, null, null)]);
    };

    Formatted$1.prototype.isEmpty = function isEmpty() {
        if (this.sections.length === 0) {
            return true;
        }
        return !this.sections.some(function (section) {
            return section.text.length !== 0 ||
                (section.image && section.image.name.length !== 0);
        });
    };

    Formatted$1.factory = function factory(text) {
        if (text instanceof Formatted$1) {
            return text;
        } else {
            return Formatted$1.fromString(text);
        }
    };

    Formatted$1.prototype.toString = function toString() {
        if (this.sections.length === 0) {
            return '';
        }
        return this.sections.map(function (section) {
            return section.text;
        }).join('');
    };

    Formatted$1.prototype.serialize = function serialize() {
        var serialized = ["format"];
        for (var i = 0, list = this.sections; i < list.length; i += 1) {
            var section = list[i];

            if (section.image) {
                serialized.push(["image", section.image.name]);
                continue;
            }
            serialized.push(section.text);
            var options = {};
            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"]          ).concat(section.textColor.toArray());
            }
            serialized.push(options);
        }
        return serialized;
    };

    var ResolvedImage$1 = function ResolvedImage(options) {
        this.name = options.name;
        this.available = options.available;
    };

    ResolvedImage$1.prototype.toString = function toString() {
        return this.name;
    };

    ResolvedImage$1.fromString = function fromString(name) {
        return new ResolvedImage$1({name: name, available: false});
    };

    ResolvedImage$1.prototype.serialize = function serialize() {
        return ["image", this.name];
    };

    var NullType$1 = {kind: 'null'};
    var NumberType$2 = {kind: 'number'};
    var StringType$1 = {kind: 'string'};
    var BooleanType$1 = {kind: 'boolean'};
    var ColorType$2 = {kind: 'color'};
    var ObjectType$1 = {kind: 'object'};
    var ValueType$1 = {kind: 'value'};
    var CollatorType = {kind: 'collator'};
    var FormattedType$1 = {kind: 'formatted'};
    var ResolvedImageType$1 = {kind: 'resolvedImage'};

    function array$1(itemType, N) {
        return {
            kind: 'array',
            itemType: itemType,
            N: N
        };
    }

    function Values$1() {
    }

    Values$1.validateRGBA = function(r, g, b, a){
        if (!(
            typeof r === 'number' && r >= 0 && r <= 255 &&
                typeof g === 'number' && g >= 0 && g <= 255 &&
                typeof b === 'number' && b >= 0 && b <= 255
            )) {
            var 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;
    };

    Values$1.isValue = function(mixed){
        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$1) {
            return true;
        } else if (mixed instanceof Collator) {
            return true;
        } else if (mixed instanceof Formatted$1) {
            return true;
        } else if (mixed instanceof ResolvedImage$1) {
            return true;
        } else if (Array.isArray(mixed)) {
            for (var i = 0, list = mixed; i < list.length; i += 1) {
                var item = list[i];

                if (!Values$1.isValue(item)) {
                    return false;
                }
            }
            return true;
        } else if (typeof mixed === 'object') {
            for (var key in mixed) {
                if (!Values$1.isValue(mixed[key])) {
                    return false;
                }
            }
            return true;
        } else {
            return false;
        }
    };

    Values$1.typeOf = function(value){
        if (value === null) {
            return NullType$1;
        } else if (typeof value === 'string') {
            return StringType$1;
        } else if (typeof value === 'boolean') {
            return BooleanType$1;
        } else if (typeof value === 'number') {
            return NumberType$2;
        } else if (value instanceof Color$1) {
            return ColorType$2;
        } else if (value instanceof Collator) {
            return CollatorType;
        } else if (value instanceof Formatted$1) {
            return FormattedType$1;
        } else if (value instanceof ResolvedImage$1) {
            return ResolvedImageType$1;
        } else if (Array.isArray(value)) {
            var length = value.length;
            var itemType;

            for (var i = 0, list = value; i < list.length; i += 1) {
                var item = list[i];

                var t = Values$1.typeOf(item);
                if (!itemType) {
                    itemType = t;
                } else if (itemType === t) {
                    continue;
                } else {
                    itemType = ValueType$1;
                    break;
                }
            }

            return array$1(itemType || ValueType$1, length);
        } else {
            assert_1(typeof value === 'object');
            return ObjectType$1;
        }
    };

    Values$1.toString$1 = function(value){
        var type = typeof value;
        if (value === null) {
            return '';
        } else if (type === 'string' || type === 'number' || type === 'boolean') {
            return String(value);
        } else if (value instanceof Color$1 || value instanceof Formatted$1 || value instanceof ResolvedImage$1) {
            return value.toString();
        } else {
            return JSON.stringify(value);
        }
    };

    var NumberType$3 = {kind: 'number'};
    var StringType$2 = {kind: 'string'};
    var BooleanType$2 = {kind: 'boolean'};
    var ObjectType$2 = {kind: 'object'};
    var ValueType$2 = {kind: 'value'};

    function array$2(itemType, N) {
        return {
            kind: 'array',
            itemType: itemType,
            N: N
        };
    }

    var types = {
        string: StringType$2,
        number: NumberType$3,
        boolean: BooleanType$2,
        object: ObjectType$2
    };

    var Assertion = function Assertion(type, args) {
        this.type = type;
        this.args = args;
    };

    Assertion.parse = function parse(args, context) {
        if (args.length < 2) {
            return context.error("Expected at least one argument.");
        }

        var i = 1;
        var type;

        var name = (args[0] );
        if (name === 'array') {
            var itemType;
            if (args.length > 2) {
                var type$1 = args[1];
                if (typeof type$1 !== 'string' || !(type$1 in types) || type$1 === 'object') {
                    return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
                }
                itemType = types[type$1];
                i++;
            } else {
                itemType = ValueType$2;
            }

            var 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$2(itemType, N);
        } else {
            assert_1(types[name], name);
            type = types[name];
        }

        var parsed = [];
        for (; i < args.length; i++) {
            var input = context.parse(args[i], i, ValueType$2);
            if (!input) {
                return null;
            }
            parsed.push(input);
        }

        return new Assertion(type, parsed);
    };

    Assertion.prototype.evaluate = function evaluate(ctx) {
        for (var i = 0; i < this.args.length; i++) {
            var value = this.args[i].evaluate(ctx);
            var error = checkSubtype(this.type, Values$1.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(Values$1.typeOf(value))) + " instead."));
            }
        }

        assert_1(false);
        return null;
    };

    Assertion.prototype.eachChild = function eachChild(fn) {
        this.args.forEach(fn);
    };

    Assertion.prototype.possibleOutputs = function possibleOutputs() {
        var ref;

        return (ref = []).concat.apply(ref, this.args.map(function (arg) {
            return arg.possibleOutputs();
        }));
    };

    Assertion.prototype.serialize = function serialize() {
        var type = this.type;
        var serialized = [type.kind];
        if (type.kind === 'array') {
            var itemType = type.itemType;
            if (itemType.kind === 'string' ||
                itemType.kind === 'number' ||
                itemType.kind === 'boolean') {
                serialized.push(itemType.kind);
                var N = type.N;
                if (typeof N === 'number' || this.args.length > 1) {
                    serialized.push(N);
                }
            }
        }
        return serialized.concat(this.args.map(function (arg) {
            return arg.serialize();
        }));
    };

    var NumberType$4 = {kind: 'number'};
    var ValueType$3 = {kind: 'value'};

    function array$3(itemType, N) {
        return {
            kind: 'array',
            itemType: itemType,
            N: N
        };
    }

    var At = function At(type, index, input) {
        this.type = type;
        this.index = index;
        this.input = input;
    };

    At.parse = function parse(args, context) {
        if (args.length !== 3) {
            return context.error(("Expected 2 arguments, but found " + (args.length - 1) + " instead."));
        }

        var index = context.parse(args[1], 1, NumberType$4);
        var input = context.parse(args[2], 2, array$3(context.expectedType || ValueType$3));

        if (!index || !input) {
            return null;
        }

        var t = (input.type );
        return new At(t.itemType, index, input);
    };

    At.prototype.evaluate = function evaluate(ctx) {
        var index = ((this.index.evaluate(ctx) )    );
        var array = ((this.input.evaluate(ctx) )          );

        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];
    };

    At.prototype.eachChild = function eachChild(fn) {
        fn(this.index);
        fn(this.input);
    };

    At.prototype.possibleOutputs = function possibleOutputs() {
        return [undefined];
    };

    At.prototype.serialize = function serialize() {
        return ["at", this.index.serialize(), this.input.serialize()];
    };

    var BooleanType$3 = {kind: 'boolean'};

    var Case = function Case(type, branches, otherwise) {
        this.type = type;
        this.branches = branches;
        this.otherwise = otherwise;
    };

    Case.parse = function parse(args, context) {
        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.");
        }

        var outputType;
        if (context.expectedType && context.expectedType.kind !== 'value') {
            outputType = context.expectedType;
        }

        var branches = [];
        for (var i = 1; i < args.length - 1; i += 2) {
            var test = context.parse(args[i], i, BooleanType$3);
            if (!test) {
                return null;
            }

            var result = context.parse(args[i + 1], i + 1, outputType);
            if (!result) {
                return null;
            }

            branches.push([test, result]);

            outputType = outputType || result.type;
        }

        var otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
        if (!otherwise) {
            return null;
        }

        assert_1(outputType);
        return new Case((outputType ), branches, otherwise);
    };

    Case.prototype.evaluate = function evaluate(ctx) {
        for (var i = 0, list = this.branches; i < list.length; i += 1) {
            var ref = list[i];
            var test = ref[0];
            var expression = ref[1];

            if (test.evaluate(ctx)) {
                return expression.evaluate(ctx);
            }
        }
        return this.otherwise.evaluate(ctx);
    };

    Case.prototype.eachChild = function eachChild(fn) {
        for (var i = 0, list = this.branches; i < list.length; i += 1) {
            var ref = list[i];
            var test = ref[0];
            var expression = ref[1];

            fn(test);
            fn(expression);
        }
        fn(this.otherwise);
    };

    Case.prototype.possibleOutputs = function possibleOutputs() {
        var ref;

        return (ref = [])
            .concat.apply(ref, this.branches.map(function (ref) {
                var _ = ref[0];
                var out = ref[1];

                return out.possibleOutputs();
            }))
            .concat(this.otherwise.possibleOutputs());
    };

    Case.prototype.serialize = function serialize() {
        var serialized = ["case"];
        this.eachChild(function (child) {
            serialized.push(child.serialize());
        });
        return serialized;
    };

    var ValueType$4 = {kind: 'value'};

    var Coalesce = function Coalesce(type, args) {
        this.type = type;
        this.args = args;
    };

    Coalesce.parse = function parse(args, context) {
        if (args.length < 2) {
            return context.error("Expectected at least one argument.");
        }
        var outputType = (null );
        var expectedType = context.expectedType;
        if (expectedType && expectedType.kind !== 'value') {
            outputType = expectedType;
        }
        var parsedArgs = [];

        for (var i = 0, list = args.slice(1); i < list.length; i += 1) {
            var arg = list[i];

            var parsed = context.parse(arg, 1 + parsedArgs.length, outputType, undefined, {typeAnnotation: 'omit'});
            if (!parsed) {
                return null;
            }
            outputType = outputType || parsed.type;
            parsedArgs.push(parsed);
        }
        assert_1(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.
        var needsAnnotation = expectedType &&
            parsedArgs.some(function (arg) {
                return checkSubtype(expectedType, arg.type);
            });

        return needsAnnotation ?
            new Coalesce(ValueType$4, parsedArgs) :
            new Coalesce((outputType ), parsedArgs);
    };

    Coalesce.prototype.evaluate = function evaluate(ctx) {
        var result = null;
        var argCount = 0;
        var requestedImageName;
        for (var i = 0, list = this.args; i < list.length; i += 1) {
            var arg = list[i];

            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 name so styleimagemissing can fire
            if (result && result instanceof ResolvedImage$1 && !result.available) {
                if (!requestedImageName) {
                    requestedImageName = result.name;
                }
                result = null;
                if (argCount === this.args.length) {
                    result = requestedImageName;
                }
            }

            if (result !== null) {
                break;
            }
        }
        return result;
    };

    Coalesce.prototype.eachChild = function eachChild(fn) {
        this.args.forEach(fn);
    };

    Coalesce.prototype.possibleOutputs = function possibleOutputs() {
        var ref;

        return (ref = []).concat.apply(ref, this.args.map(function (arg) {
            return arg.possibleOutputs();
        }));
    };

    Coalesce.prototype.serialize = function serialize() {
        var serialized = ["coalesce"];
        this.eachChild(function (child) {
            serialized.push(child.serialize());
        });
        return serialized;
    };

    var NumberType$5 = {kind: 'number'};
    var StringType$3 = {kind: 'string'};
    var BooleanType$4 = {kind: 'boolean'};
    var ColorType$3 = {kind: 'color'};
    var ValueType$5 = {kind: 'value'};

    var types$1 = {
        'to-boolean': BooleanType$4,
        'to-color': ColorType$3,
        'to-number': NumberType$5,
        'to-string': StringType$3
    };

    /**
     * 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
     */
    var Coercion = function Coercion(type, args) {
        this.type = type;
        this.args = args;
    };

    Coercion.parse = function parse(args, context) {
        if (args.length < 2) {
            return context.error("Expected at least one argument.");
        }

        var name = (args[0] );
        assert_1(types$1[name], name);

        if ((name === 'to-boolean' || name === 'to-string') && args.length !== 2) {
            return context.error("Expected one argument.");
        }

        var type = types$1[name];

        var parsed = [];
        for (var i = 1; i < args.length; i++) {
            var input = context.parse(args[i], i, ValueType$5);
            if (!input) {
                return null;
            }
            parsed.push(input);
        }

        return new Coercion(type, parsed);
    };

    Coercion.prototype.evaluate = function evaluate(ctx) {
        if (this.type.kind === 'boolean') {
            return Boolean(this.args[0].evaluate(ctx));
        } else if (this.type.kind === 'color') {
            var input;
            var error;
            for (var i = 0, list = this.args; i < list.length; i += 1) {
                var arg = list[i];

                input = arg.evaluate(ctx);
                error = null;
                if (input instanceof Color) {
                    return input;
                } else if (typeof input === 'string') {
                    var 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] ) / 255, (input[1] ) / 255, (input[2] ) / 255, (input[3] ));
                    }
                }
            }
            throw new RuntimeError(error || ("Could not parse color from value '" + (typeof input === 'string' ? input : String(JSON.stringify(input))) + "'"));
        } else if (this.type.kind === 'number') {
            var value = null;
            for (var i$1 = 0, list$1 = this.args; i$1 < list$1.length; i$1 += 1) {
                var arg$1 = list$1[i$1];

                value = arg$1.evaluate(ctx);
                if (value === null) {
                    return 0;
                }
                var 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(toString$1(this.args[0].evaluate(ctx)));
        } else if (this.type.kind === 'resolvedImage') {
            return ResolvedImage.fromString(toString$1(this.args[0].evaluate(ctx)));
        } else {
            return toString$1(this.args[0].evaluate(ctx));
        }
    };

    Coercion.prototype.eachChild = function eachChild(fn) {
        this.args.forEach(fn);
    };

    Coercion.prototype.possibleOutputs = function possibleOutputs() {
        var ref;

        return (ref = []).concat.apply(ref, this.args.map(function (arg) {
            return arg.possibleOutputs();
        }));
    };

    Coercion.prototype.serialize = function serialize() {
        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();
        }

        var serialized = [("to-" + (this.type.kind))];
        this.eachChild(function (child) {
            serialized.push(child.serialize());
        });
        return serialized;
    };

    var StringType$4 = {kind: 'string'};
    var BooleanType$5 = {kind: 'boolean'};
    var CollatorType$1 = {kind: 'collator'};

    var CollatorExpression = function CollatorExpression(caseSensitive, diacriticSensitive, locale) {
        this.type = CollatorType$1;
        this.locale = locale;
        this.caseSensitive = caseSensitive;
        this.diacriticSensitive = diacriticSensitive;
    };

    CollatorExpression.parse = function parse(args, context) {
        if (args.length !== 2) {
            return context.error("Expected one argument.");
        }

        var options = (args[1] );
        if (typeof options !== "object" || Array.isArray(options)) {
            return context.error("Collator options argument must be an object.");
        }

        var caseSensitive = context.parse(
            options['case-sensitive'] === undefined ? false : options['case-sensitive'], 1, BooleanType$5);
        if (!caseSensitive) {
            return null;
        }

        var diacriticSensitive = context.parse(
            options['diacritic-sensitive'] === undefined ? false : options['diacritic-sensitive'], 1, BooleanType$5);
        if (!diacriticSensitive) {
            return null;
        }

        var locale = null;
        if (options['locale']) {
            locale = context.parse(options['locale'], 1, StringType$4);
            if (!locale) {
                return null;
            }
        }

        return new CollatorExpression(caseSensitive, diacriticSensitive, locale);
    };

    CollatorExpression.prototype.evaluate = function evaluate(ctx) {
        return new Collator(this.caseSensitive.evaluate(ctx), this.diacriticSensitive.evaluate(ctx), this.locale ? this.locale.evaluate(ctx) : null);
    };

    CollatorExpression.prototype.eachChild = function eachChild(fn) {
        fn(this.caseSensitive);
        fn(this.diacriticSensitive);
        if (this.locale) {
            fn(this.locale);
        }
    };

    CollatorExpression.prototype.possibleOutputs = function possibleOutputs() {
        // Technically the set of possible outputs is the combinatoric set of Collators produced
        // by all possibleOutputs of locale/caseSensitive/diacriticSensitive
        // But for the primary use of Collators in comparison operators, we ignore the Collator's
        // possibleOutputs anyway, so we can get away with leaving this undefined for now.
        return [undefined];
    };

    CollatorExpression.prototype.serialize = function serialize() {
        var options = {};
        options['case-sensitive'] = this.caseSensitive.serialize();
        options['diacritic-sensitive'] = this.diacriticSensitive.serialize();
        if (this.locale) {
            options['locale'] = this.locale.serialize();
        }
        return ["collator", options];
    };

    var BooleanType$6 = {kind: 'boolean'};
    var ValueType$6 = {kind: 'value'};
    var CollatorType$2 = {kind: 'collator'};

    function isComparableType$1(op, 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, a, b) {
        return a === b;
    }
    function neq(ctx, a, b) {
        return a !== b;
    }
    function lt(ctx, a, b) {
        return a < b;
    }
    function gt(ctx, a, b) {
        return a > b;
    }
    function lteq(ctx, a, b) {
        return a <= b;
    }
    function gteq(ctx, a, b) {
        return a >= b;
    }

    function eqCollate(ctx, a, b, c) {
        return c.compare(a, b) === 0;
    }
    function neqCollate(ctx, a, b, c) {
        return !eqCollate(ctx, a, b, c);
    }
    function ltCollate(ctx, a, b, c) {
        return c.compare(a, b) < 0;
    }
    function gtCollate(ctx, a, b, c) {
        return c.compare(a, b) > 0;
    }
    function lteqCollate(ctx, a, b, c) {
        return c.compare(a, b) <= 0;
    }
    function gteqCollate(ctx, a, b, c) {
        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, compareBasic, compareWithCollator) {
        var isOrderComparison = op !== '==' && op !== '!=';

        return /*@__PURE__*/(function () {
            function Comparison(lhs, rhs, collator) {
                this.type = BooleanType$6;
                this.lhs = lhs;
                this.rhs = rhs;
                this.collator = collator;
                this.hasUntypedArgument = lhs.type.kind === 'value' || rhs.type.kind === 'value';
            }

            Comparison.parse = function parse(args, context) {
                if (args.length !== 3 && args.length !== 4) {
                    return context.error("Expected two or three arguments.");
                }

                var op = (args[0]     );

                var lhs = context.parse(args[1], 1, ValueType$6);
                if (!lhs) {
                    return null;
                }
                if (!isComparableType$1(op, lhs.type)) {
                    return context.concat(1).error(("\"" + op + "\" comparisons are not supported for type '" + (toString(lhs.type)) + "'."));
                }
                var rhs = context.parse(args[2], 2, ValueType$6);
                if (!rhs) {
                    return null;
                }
                if (!isComparableType$1(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]);
                    }
                }

                var 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$2);
                    if (!collator) {
                        return null;
                    }
                }

                return new Comparison(lhs, rhs, collator);
            };

            Comparison.prototype.evaluate = function evaluate(ctx) {
                var lhs = this.lhs.evaluate(ctx);
                var rhs = this.rhs.evaluate(ctx);

                if (isOrderComparison && this.hasUntypedArgument) {
                    var lt = Values$1.typeOf(lhs);
                    var rt = Values$1.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) {
                    var lt$1 = Values$1.typeOf(lhs);
                    var rt$1 = Values$1.typeOf(rhs);
                    if (lt$1.kind !== 'string' || rt$1.kind !== 'string') {
                        return compareBasic(ctx, lhs, rhs);
                    }
                }

                return this.collator ?
                    compareWithCollator(ctx, lhs, rhs, this.collator.evaluate(ctx)) :
                    compareBasic(ctx, lhs, rhs);
            };

            Comparison.prototype.eachChild = function eachChild(fn) {
                fn(this.lhs);
                fn(this.rhs);
                if (this.collator) {
                    fn(this.collator);
                }
            };

            Comparison.prototype.possibleOutputs = function possibleOutputs() {
                return [true, false];
            };

            Comparison.prototype.serialize = function serialize() {
                var serialized = [op];
                this.eachChild(function (child) {
                    serialized.push(child.serialize());
                });
                return serialized;
            };

            return Comparison;
        }());
    }

    var ComparisonEnum = {
    };
    ComparisonEnum.Equals = makeComparison('==', eq, eqCollate);
    ComparisonEnum.NotEquals = makeComparison('!=', neq, neqCollate);
    ComparisonEnum.LessThan = makeComparison('<', lt, ltCollate);
    ComparisonEnum.GreaterThan = makeComparison('>', gt, gtCollate);
    ComparisonEnum.LessThanOrEqual = makeComparison('<=', lteq, lteqCollate);
    ComparisonEnum.GreaterThanOrEqual = makeComparison('>=', gteq, gteqCollate);

    var NumberType$6 = {kind: 'number'};
    var StringType$5 = {kind: 'string'};
    var ColorType$4 = {kind: 'color'};
    var ValueType$7 = {kind: 'value'};
    var FormattedType$2 = {kind: 'formatted'};
    var ResolvedImageType$2 = {kind: 'resolvedImage'};

    function array$4(itemType, N) {
        return {
            kind: 'array',
            itemType: itemType,
            N: N
        };
    }

    var FormatExpression$1 = function FormatExpression(sections) {
        this.type = FormattedType$2;
        this.sections = sections;
    };

    FormatExpression$1.parse = function parse(args, context) {
        if (args.length < 2) {
            return context.error("Expected at least one argument.");
        }

        var firstArg = args[1];
        if (!Array.isArray(firstArg) && typeof firstArg === 'object') {
            return context.error("First argument must be an image or text section.");
        }

        var sections = [];
        var nextTokenMayBeObject = false;
        for (var i = 1; i <= args.length - 1; ++i) {
            var arg = (args[i] );

            if (nextTokenMayBeObject && typeof arg === "object" && !Array.isArray(arg)) {
                nextTokenMayBeObject = false;

                var scale = null;
                if (arg['font-scale']) {
                    scale = context.parse(arg['font-scale'], 1, NumberType$6);
                    if (!scale) {
                        return null;
                    }
                }

                var font = null;
                if (arg['text-font']) {
                    font = context.parse(arg['text-font'], 1, array$4(StringType$5));
                    if (!font) {
                        return null;
                    }
                }

                var textColor = null;
                if (arg['text-color']) {
                    textColor = context.parse(arg['text-color'], 1, ColorType$4);
                    if (!textColor) {
                        return null;
                    }
                }

                var lastExpression = sections[sections.length - 1];
                lastExpression.scale = scale;
                lastExpression.font = font;
                lastExpression.textColor = textColor;
            } else {
                var content = context.parse(args[i], 1, ValueType$7);
                if (!content) {
                    return null;
                }

                var 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: content, scale: null, font: null, textColor: null});
            }
        }

        return new FormatExpression$1(sections);
    };

    FormatExpression$1.prototype.evaluate = function evaluate(ctx) {
        var evaluateSection = function (section) {
            var evaluatedContent = section.content.evaluate(ctx);
            if (Values$1.typeOf(evaluatedContent) === ResolvedImageType$2) {
                return new FormattedSection('', evaluatedContent, null, null, null);
            }

            return new FormattedSection(
                Values$1.toString$1(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$1(this.sections.map(evaluateSection));
    };

    FormatExpression$1.prototype.eachChild = function eachChild(fn) {
        for (var i = 0, list = this.sections; i < list.length; i += 1) {
            var section = list[i];

            fn(section.content);
            if (section.scale) {
                fn(section.scale);
            }
            if (section.font) {
                fn(section.font);
            }
            if (section.textColor) {
                fn(section.textColor);
            }
        }
    };

    FormatExpression$1.prototype.possibleOutputs = function possibleOutputs() {
        // Technically the combinatoric set of all children
        // Usually, this.text will be undefined anyway
        return [undefined];
    };

    FormatExpression$1.prototype.serialize = function serialize() {
        var serialized = ["format"];
        for (var i = 0, list = this.sections; i < list.length; i += 1) {
            var section = list[i];

            serialized.push(section.content.serialize());
            var 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;
    };

    var StringType$6 = {kind: 'string'};
    var ResolvedImageType$3 = {kind: 'resolvedImage'};

    var ImageExpression$1 = function ImageExpression(input) {
        this.type = ResolvedImageType$3;
        this.input = input;
    };

    ImageExpression$1.parse = function parse(args, context) {
        if (args.length !== 2) {
            return context.error("Expected two arguments.");
        }

        var name = context.parse(args[1], 1, StringType$6);
        if (!name) {
            return context.error("No image name provided.");
        }

        return new ImageExpression$1(name);
    };

    ImageExpression$1.prototype.evaluate = function evaluate(ctx) {
        var evaluatedImageName = this.input.evaluate(ctx);
        var available = false;

        if (ctx.availableImages && ctx.availableImages.indexOf(evaluatedImageName) > -1) {
            available = true;
        }

        return new ResolvedImage$1({name: evaluatedImageName, available: available});
    };

    ImageExpression$1.prototype.eachChild = function eachChild(fn) {
        fn(this.input);
    };

    ImageExpression$1.prototype.possibleOutputs = function possibleOutputs() {
        // The output of image is determined by the list of available images in the evaluation context
        return [undefined];
    };

    ImageExpression$1.prototype.serialize = function serialize() {
        return ["image", this.input.serialize()];
    };

    var Interpolate$1 = function Interpolate(type, operator, interpolation, input, stops) {
        this.type = type;
        this.operator = operator;
        this.interpolation = interpolation;
        this.input = input;

        this.labels = [];
        this.outputs = [];
        for (var i = 0, list = stops; i < list.length; i += 1) {
            var ref = list[i];
            var label = ref[0];
            var expression = ref[1];

            this.labels.push(label);
            this.outputs.push(expression);
        }
    };

    Interpolate$1.interpolationFactor = function interpolationFactor(interpolation, input, lower, upper) {
        var 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') {
            var c = interpolation.controlPoints;
            var ub = new unitbezier(c[0], c[1], c[2], c[3]);
            t = ub.solve(exponentialInterpolation(input, 1, lower, upper));
        }
        return t;
    };

    Interpolate$1.parse = function parse(args, context) {
        var operator = args[0];
        var interpolation = args[1];
        var input = args[2];
        var rest = args.slice(3);

        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') {
            var base = interpolation[1];
            if (typeof base !== 'number') {
                return context.error("Exponential interpolation requires a numeric base.", 1, 1);
            }
            interpolation = {
                name: 'exponential',
                base: base
            };
        } else if (interpolation[0] === 'cubic-bezier') {
            var controlPoints = interpolation.slice(1);
            if (
                controlPoints.length !== 4 ||
                    controlPoints.some(function (t) {
                        return 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 )
            };
        } 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;
        }

        var stops = [];

        var outputType = (null );
        if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
            outputType = ColorType;
        } else if (context.expectedType && context.expectedType.kind !== 'value') {
            outputType = context.expectedType;
        }

        for (var i = 0; i < rest.length; i += 2) {
            var label = rest[i];
            var value = rest[i + 1];

            var labelKey = i + 3;
            var 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);
            }

            var 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$1(outputType, (operator ), interpolation, input, stops);
    };

    Interpolate$1.prototype.evaluate = function evaluate(ctx) {
        var labels = this.labels;
        var outputs = this.outputs;

        if (labels.length === 1) {
            return outputs[0].evaluate(ctx);
        }

        var value = ((this.input.evaluate(ctx) )    );
        if (value <= labels[0]) {
            return outputs[0].evaluate(ctx);
        }

        var stopCount = labels.length;
        if (value >= labels[stopCount - 1]) {
            return outputs[stopCount - 1].evaluate(ctx);
        }

        var index = findStopLessThanOrEqualTo(labels, value);
        var lower = labels[index];
        var upper = labels[index + 1];
        var t = Interpolate$1.interpolationFactor(this.interpolation, value, lower, upper);

        var outputLower = outputs[index].evaluate(ctx);
        var outputUpper = outputs[index + 1].evaluate(ctx);

        if (this.operator === 'interpolate') {
            return (interpolate[this.type.kind.toLowerCase()] )(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));
        }
    };

    Interpolate$1.prototype.eachChild = function eachChild(fn) {
        fn(this.input);
        for (var i = 0, list = this.outputs; i < list.length; i += 1) {
            var expression = list[i];

            fn(expression);
        }
    };

    Interpolate$1.prototype.possibleOutputs = function possibleOutputs() {
        var ref;

        return (ref = []).concat.apply(ref, this.outputs.map(function (output) {
            return output.possibleOutputs();
        }));
    };

    Interpolate$1.prototype.serialize = function serialize() {
        var 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);
        }

        var serialized = [this.operator, interpolation, this.input.serialize()];

        for (var 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) {
        var difference = upperValue - lowerValue;
        var 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);
        }
    }

    var BooleanType$7 = {kind: 'boolean'};
    var ValueType$8 = {kind: 'value'};

    function isComparableType(type) {
        return type.kind === 'boolean' ||
            type.kind === 'string' ||
            type.kind === 'number' ||
            type.kind === 'null' ||
            type.kind === 'value';
    }

    function isComparableRuntimeValue(needle) {
        return typeof needle === 'boolean' ||
            typeof needle === 'string' ||
            typeof needle === 'number';
    }

    function isSearchableRuntimeValue(haystack) {
        return Array.isArray(haystack) ||
            typeof haystack === 'string';
    }

    var In = function In(needle, haystack) {
        this.type = BooleanType$7;
        this.needle = needle;
        this.haystack = haystack;
    };

    In.parse = function parse(args, context) {
        if (args.length !== 3) {
            return context.error(("Expected 2 arguments, but found " + (args.length - 1) + " instead."));
        }

        var needle = context.parse(args[1], 1, ValueType$8);

        var haystack = context.parse(args[2], 2, ValueType$8);

        if (!needle || !haystack) {
            return null;
        }

        if (!isComparableType(needle.type)) {
            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);
    };

    In.prototype.evaluate = function evaluate(ctx) {
        var needle = (this.needle.evaluate(ctx) );
        var haystack = (this.haystack.evaluate(ctx) );

        if (!needle || !haystack) {
            return false;
        }

        if (!isComparableRuntimeValue(needle)) {
            throw new RuntimeError(("Expected first argument to be of type boolean, string or number, but found " + (toString(typeOf(needle))) + " instead."));
        }

        if (!isSearchableRuntimeValue(haystack)) {
            throw new RuntimeError(("Expected second argument to be of type array or string, but found " + (toString(typeOf(haystack))) + " instead."));
        }

        return haystack.indexOf(needle) >= 0;
    };

    In.prototype.eachChild = function eachChild(fn) {
        fn(this.needle);
        fn(this.haystack);
    };

    In.prototype.possibleOutputs = function possibleOutputs() {
        return [true, false];
    };

    In.prototype.serialize = function serialize() {
        return ["in", this.needle.serialize(), this.haystack.serialize()];
    };

    var Let = function Let(bindings, result) {
        this.type = result.type;
        this.bindings = [].concat(bindings);
        this.result = result;
    };

    Let.prototype.evaluate = function evaluate(ctx) {
        return this.result.evaluate(ctx);
    };

    Let.prototype.eachChild = function eachChild(fn) {
        for (var i = 0, list = this.bindings; i < list.length; i += 1) {
            var binding = list[i];

            fn(binding[1]);
        }
        fn(this.result);
    };

    Let.parse = function parse(args, context) {
        if (args.length < 4) {
            return context.error(("Expected at least 3 arguments, but found " + (args.length - 1) + " instead."));
        }

        var bindings = [];
        for (var i = 1; i < args.length - 1; i += 2) {
            var 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);
            }

            var value = context.parse(args[i + 1], i + 1);
            if (!value) {
                return null;
            }

            bindings.push([name, value]);
        }

        var result = context.parse(args[args.length - 1], args.length - 1, context.expectedType, bindings);
        if (!result) {
            return null;
        }

        return new Let(bindings, result);
    };

    Let.prototype.possibleOutputs = function possibleOutputs() {
        return this.result.possibleOutputs();
    };

    Let.prototype.serialize = function serialize() {
        var serialized = ["let"];
        for (var i = 0, list = this.bindings; i < list.length; i += 1) {
            var ref = list[i];
            var name = ref[0];
            var expr = ref[1];

            serialized.push(name, expr.serialize());
        }
        serialized.push(this.result.serialize());
        return serialized;
    };

    var NumberType$7 = {kind: 'number'};

    var Length = function Length(input) {
        this.type = NumberType$7;
        this.input = input;
    };

    Length.parse = function parse(args, context) {
        if (args.length !== 2) {
            return context.error(("Expected 1 argument, but found " + (args.length - 1) + " instead."));
        }

        var 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);
    };

    Length.prototype.evaluate = function evaluate(ctx) {
        var 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."));
        }
    };

    Length.prototype.eachChild = function eachChild(fn) {
        fn(this.input);
    };

    Length.prototype.possibleOutputs = function possibleOutputs() {
        return [undefined];
    };

    Length.prototype.serialize = function serialize() {
        var serialized = ["length"];
        this.eachChild(function (child) {
            serialized.push(child.serialize());
        });
        return serialized;
    };

    var Literal = function Literal(type, value) {
        this.type = type;
        this.value = value;
    };

    Literal.parse = function parse(args, context) {
        if (args.length !== 2) {
            return context.error(("'literal' expression requires exactly one argument, but found " + (args.length - 1) + " instead."));
        }

        if (!Values$1.isValue(args[1])) {
            return context.error("invalid value");
        }

        var value = (args[1] );
        var type = Values$1.typeOf(value);

        // special case: infer the item type if possible for zero-length arrays
        var 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);
    };

    Literal.prototype.evaluate = function evaluate() {
        return this.value;
    };

    Literal.prototype.eachChild = function eachChild() {
    };

    Literal.prototype.possibleOutputs = function possibleOutputs() {
        return [this.value];
    };

    Literal.prototype.serialize = function serialize() {
        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$1) {
            // Same as Color
            return this.value.serialize();
        } else {
            assert_1(this.value === null ||
                typeof this.value === 'string' ||
                typeof this.value === 'number' ||
                typeof this.value === 'boolean');
            return (this.value );
        }
    };

    var ValueType$9 = {kind: 'value'};

    // Map input label values to output expression index
    var Match = function Match(inputType, outputType, input, cases, outputs, otherwise) {
        this.inputType = inputType;
        this.type = outputType;
        this.input = input;
        this.cases = cases;
        this.outputs = outputs;
        this.otherwise = otherwise;
    };

    Match.parse = function parse(args, context) {
        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.");
        }

        var inputType;
        var outputType;
        if (context.expectedType && context.expectedType.kind !== 'value') {
            outputType = context.expectedType;
        }
        var cases = {};
        var outputs = [];
        for (var i = 2; i < args.length - 1; i += 2) {
            var labels = args[i];
            var value = args[i + 1];

            if (!Array.isArray(labels)) {
                labels = [labels];
            }

            var labelContext = context.concat(i);
            if (labels.length === 0) {
                return labelContext.error('Expected at least one branch label.');
            }

            for (var i$1 = 0, list = labels; i$1 < list.length; i$1 += 1) {
                var label = list[i$1];

                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 = Values$1.typeOf(label);
                } else if (labelContext.checkSubtype(inputType, Values$1.typeOf(label))) {
                    return null;
                }

                if (typeof cases[String(label)] !== 'undefined') {
                    return labelContext.error('Branch labels must be unique.');
                }

                cases[String(label)] = outputs.length;
            }

            var result = context.parse(value, i, outputType);
            if (!result) {
                return null;
            }
            outputType = outputType || result.type;
            outputs.push(result);
        }

        var input = context.parse(args[1], 1, ValueType$9);
        if (!input) {
            return null;
        }

        var otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
        if (!otherwise) {
            return null;
        }

        assert_1(inputType && outputType);

        if (input.type.kind !== 'value' && context.concat(1).checkSubtype((inputType ), input.type)) {
            return null;
        }

        return new Match((inputType ), (outputType ), input, cases, outputs, otherwise);
    };

    Match.prototype.evaluate = function evaluate(ctx) {
        var input = (this.input.evaluate(ctx) );
        var output = (Values$1.typeOf(input) === this.inputType && this.outputs[this.cases[input]]) || this.otherwise;
        return output.evaluate(ctx);
    };

    Match.prototype.eachChild = function eachChild(fn) {
        fn(this.input);
        this.outputs.forEach(fn);
        fn(this.otherwise);
    };

    Match.prototype.possibleOutputs = function possibleOutputs() {
        var ref;

        return (ref = [])
            .concat.apply(ref, this.outputs.map(function (out) {
                return out.possibleOutputs();
            }))
            .concat(this.otherwise.possibleOutputs());
    };

    Match.prototype.serialize = function serialize() {
        var this$1 = this;

        var serialized = ["match", this.input.serialize()];

        // Sort so serialization has an arbitrary defined order, even though
        // branch order doesn't affect evaluation
        var sortedLabels = Object.keys(this.cases).sort();

        // Group branches by unique match expression to support condensed
        // serializations of the form [case1, case2, ...] -> matchExpression
        var groupedByOutput = [];
        var outputLookup = {}; // lookup index into groupedByOutput for a given output expression
        for (var i = 0, list = sortedLabels; i < list.length; i += 1) {
            var label = list[i];

            var 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);
            }
        }

        var coerceLabel = function (label) {
            return this$1.inputType.kind === 'number' ? Number(label) : label;
        };

        for (var i$1 = 0, list$1 = groupedByOutput; i$1 < list$1.length; i$1 += 1) {
            var ref = list$1[i$1];
            var outputIndex = ref[0];
            var labels = ref[1];

            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$1].serialize());
        }
        serialized.push(this.otherwise.serialize());
        return serialized;
    };

    var NumberType$8 = {kind: 'number'};
    var StringType$7 = {kind: 'string'};

    var NumberFormat = function NumberFormat(number, locale, currency, minFractionDigits, maxFractionDigits) {
        this.type = StringType$7;
        this.number = number;
        this.locale = locale;
        this.currency = currency;
        this.minFractionDigits = minFractionDigits;
        this.maxFractionDigits = maxFractionDigits;
    };

    NumberFormat.parse = function parse(args, context) {
        if (args.length !== 3) {
            return context.error("Expected two arguments.");
        }

        var number = context.parse(args[1], 1, NumberType$8);
        if (!number) {
            return null;
        }

        var options = (args[2]   );
        if (typeof options !== "object" || Array.isArray(options)) {
            return context.error("NumberFormat options argument must be an object.");
        }

        var locale = null;
        if (options['locale']) {
            locale = context.parse(options['locale'], 1, StringType$7);
            if (!locale) {
                return null;
            }
        }

        var currency = null;
        if (options['currency']) {
            currency = context.parse(options['currency'], 1, StringType$7);
            if (!currency) {
                return null;
            }
        }

        var minFractionDigits = null;
        if (options['min-fraction-digits']) {
            minFractionDigits = context.parse(options['min-fraction-digits'], 1, NumberType$8);
            if (!minFractionDigits) {
                return null;
            }
        }

        var maxFractionDigits = null;
        if (options['max-fraction-digits']) {
            maxFractionDigits = context.parse(options['max-fraction-digits'], 1, NumberType$8);
            if (!maxFractionDigits) {
                return null;
            }
        }

        return new NumberFormat(number, locale, currency, minFractionDigits, maxFractionDigits);
    };

    NumberFormat.prototype.evaluate = function evaluate(ctx) {
        return new Intl.NumberFormat(this.locale ? this.locale.evaluate(ctx) : [],
            {
                style: this.currency ? "currency" : "decimal",
                currency: this.currency ? this.currency.evaluate(ctx) : undefined,
                minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(ctx) : undefined,
                maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(ctx) : undefined,
            }).format(this.number.evaluate(ctx));
    };

    NumberFormat.prototype.eachChild = function eachChild(fn) {
        fn(this.number);
        if (this.locale) {
            fn(this.locale);
        }
        if (this.currency) {
            fn(this.currency);
        }
        if (this.minFractionDigits) {
            fn(this.minFractionDigits);
        }
        if (this.maxFractionDigits) {
            fn(this.maxFractionDigits);
        }
    };

    NumberFormat.prototype.possibleOutputs = function possibleOutputs() {
        return [undefined];
    };

    NumberFormat.prototype.serialize = function serialize() {
        var options = {};
        if (this.locale) {
            options['locale'] = this.locale.serialize();
        }
        if (this.currency) {
            options['currency'] = this.currency.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];
    };

    /**
     * Returns the index of the last stop <= input, or 0 if it doesn't exist.
     * @private
     */
    function findStopLessThanOrEqualTo$1(stops, input) {
        var lastIndex = stops.length - 1;
        var lowerIndex = 0;
        var upperIndex = lastIndex;
        var currentIndex = 0;
        var 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;
    }

    var NumberType$9 = {kind: 'number'};

    var Step = function Step(type, input, stops) {
        this.type = type;
        this.input = input;

        this.labels = [];
        this.outputs = [];
        for (var i = 0, list = stops; i < list.length; i += 1) {
            var ref = list[i];
            var label = ref[0];
            var expression = ref[1];

            this.labels.push(label);
            this.outputs.push(expression);
        }
    };

    Step.parse = function parse(args, context) {
        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.");
        }

        var input = context.parse(args[1], 1, NumberType$9);
        if (!input) {
            return null;
        }

        var stops = [];

        var outputType = (null );
        if (context.expectedType && context.expectedType.kind !== 'value') {
            outputType = context.expectedType;
        }

        for (var i = 1; i < args.length; i += 2) {
            var label = i === 1 ? -Infinity : args[i];
            var value = args[i + 1];

            var labelKey = i;
            var 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);
            }

            var parsed = context.parse(value, valueKey, outputType);
            if (!parsed) {
                return null;
            }
            outputType = outputType || parsed.type;
            stops.push([label, parsed]);
        }

        return new Step(outputType, input, stops);
    };

    Step.prototype.evaluate = function evaluate(ctx) {
        var labels = this.labels;
        var outputs = this.outputs;

        if (labels.length === 1) {
            return outputs[0].evaluate(ctx);
        }

        var value = ((this.input.evaluate(ctx) )    );
        if (value <= labels[0]) {
            return outputs[0].evaluate(ctx);
        }

        var stopCount = labels.length;
        if (value >= labels[stopCount - 1]) {
            return outputs[stopCount - 1].evaluate(ctx);
        }

        var index = findStopLessThanOrEqualTo$1(labels, value);
        return outputs[index].evaluate(ctx);
    };

    Step.prototype.eachChild = function eachChild(fn) {
        fn(this.input);
        for (var i = 0, list = this.outputs; i < list.length; i += 1) {
            var expression = list[i];

            fn(expression);
        }
    };

    Step.prototype.possibleOutputs = function possibleOutputs() {
        var ref;

        return (ref = []).concat.apply(ref, this.outputs.map(function (output) {
            return output.possibleOutputs();
        }));
    };

    Step.prototype.serialize = function serialize() {
        var serialized = ["step", this.input.serialize()];
        for (var i = 0; i < this.labels.length; i++) {
            if (i > 0) {
                serialized.push(this.labels[i]);
            }
            serialized.push(this.outputs[i].serialize());
        }
        return serialized;
    };

    var Var = function Var(name, boundExpression) {
        this.type = boundExpression.type;
        this.name = name;
        this.boundExpression = boundExpression;
    };

    Var.parse = function parse(args, context) {
        if (args.length !== 2 || typeof args[1] !== 'string') {
            return context.error("'var' expression requires exactly one string literal argument.");
        }

        var name = args[1];
        if (!context.scope.has(name)) {
            return context.error(("Unknown variable \"" + name + "\". Make sure \"" + name + "\" has been bound in an enclosing \"let\" expression before using it."), 1);
        }

        return new Var(name, context.scope.get(name));
    };

    Var.prototype.evaluate = function evaluate(ctx) {
        return this.boundExpression.evaluate(ctx);
    };

    Var.prototype.eachChild = function eachChild() {
    };

    Var.prototype.possibleOutputs = function possibleOutputs() {
        return [undefined];
    };

    Var.prototype.serialize = function serialize() {
        return ["var", this.name];
    };

    var expressions = {
        // special forms
        '==': ComparisonEnum.Equals,
        '!=': ComparisonEnum.NotEquals,
        '>': ComparisonEnum.GreaterThan,
        '<': ComparisonEnum.LessThan,
        '>=': ComparisonEnum.GreaterThanOrEqual,
        '<=': ComparisonEnum.LessThanOrEqual,
        'array': Assertion,
        'at': At,
        'boolean': Assertion,
        'case': Case,
        'coalesce': Coalesce,
        'collator': CollatorExpression,
        'format': FormatExpression$1,
        'image': ImageExpression$1,
        'in': In,
        'interpolate': Interpolate$1,
        'interpolate-hcl': Interpolate$1,
        'interpolate-lab': Interpolate$1,
        'length': Length,
        'let': Let,
        'literal': Literal,
        'match': Match,
        'number': Assertion,
        'number-format': NumberFormat,
        'object': Assertion,
        'step': Step,
        'string': Assertion,
        'to-boolean': Coercion,
        'to-color': Coercion,
        'to-number': Coercion,
        'to-string': Coercion,
        'var': Var
    };

    function WebWorkerTransfer() {

    }

    var registry = {};

    /**
     * Register the given class as serializable.
     *
     * @param options
     * @param options.omit List of properties to omit from serialization (e.g., cached/computed properties)
     * @param options.shallow List of properties that should be serialized by a simple shallow copy, rather than by a recursive call to serialize().
     *
     * @private
     */
    WebWorkerTransfer.register = function (name, klass, options) {
        if (options === void 0) options = {};

        //assert(!registry[name], (name + " is already registered."));
        (Object.defineProperty     )(klass, '_classRegistryKey', {
            value: name,
            writeable: false
        });
        registry[name] = {
            klass: klass,
            omit: options.omit || [],
            shallow: options.shallow || []
        };
    };

    WebWorkerTransfer.register('Object', Object);


    //    gridIndex.serialize = function serialize(grid, transferables) {
    //        var buffer = grid.toArrayBuffer();
    //        if (transferables) {
    //            transferables.push(buffer);
    //        }
    //        return {buffer: buffer};
    //    };
    //
    //    gridIndex.deserialize = function deserialize(serialized) {
    //        return new gridIndex(serialized.buffer);
    //    };
    //    register('Grid', gridIndex);

    WebWorkerTransfer.register('Color', Color$1);
    //WebWorkerTransfer.register('Error', Error);
    WebWorkerTransfer.register('ResolvedImage', ResolvedImage$1);
    WebWorkerTransfer.register('ImageAtlas', ImageAtlas);
    WebWorkerTransfer.register('ImagePosition', ImagePosition);
    WebWorkerTransfer.register('RGBAImage', RGBAImage);
    WebWorkerTransfer.register('Formatted', Formatted$1);
    WebWorkerTransfer.register('FormattedSection', FormattedSection);

    //    WebWorkerTransfer.register('StylePropertyFunction', StylePropertyFunction);
    //    WebWorkerTransfer.register('StyleExpression', StyleExpression, {omit: ['_evaluator']});
    //
    //    WebWorkerTransfer.register('ZoomDependentExpression', ZoomDependentExpression);
    //    WebWorkerTransfer.register('ZoomConstantExpression', ZoomConstantExpression);
    //    WebWorkerTransfer.register('CompoundExpression', CompoundExpression, {omit: ['_evaluate']});

    for (var name$1 in expressions) {
        if ((expressions[name$1]     )._classRegistryKey) {
            continue;
        }
        WebWorkerTransfer.register(("Expression_" + name$1), expressions[name$1]);
    }

    function isArrayBuffer(val) {
        return val && typeof ArrayBuffer !== 'undefined' &&
            (val instanceof ArrayBuffer || (val.constructor && val.constructor.name === 'ArrayBuffer'));
    }

    /**
     * Serialize the given object for transfer to or from a web worker.
     *
     * For non-builtin types, recursively serialize each property (possibly
     * omitting certain properties - see register()), and package the result along
     * with the constructor's `name` so that the appropriate constructor can be
     * looked up in `deserialize()`.
     *
     * If a `transferables` array is provided, add any transferable objects (i.e.,
     * any ArrayBuffers or ArrayBuffer views) to the list. (If a copy is needed,
     * this should happen in the client code, before using serialize().)
     *
     * @private
     */
    WebWorkerTransfer.serialize = function (input, transferables) {
        if (input === null ||
            input === undefined ||
            typeof input === 'boolean' ||
            typeof input === 'number' ||
            typeof input === 'string' ||
            input instanceof Boolean ||
            input instanceof Number ||
            input instanceof String ||
            input instanceof Date ||
            input instanceof RegExp) {
            return input;
        }

        if (isArrayBuffer(input)) {
            if (transferables) {
                transferables.push(((input     )             ));
            }
            return input;
        }

        if (ArrayBuffer.isView(input)) {
            var view = (input     );
            if (transferables) {
                transferables.push(view.buffer);
            }
            return view;
        }

        if (input instanceof ImageData) {
            if (transferables) {
                transferables.push(input.data.buffer);
            }
            return input;
        }

        if (Array.isArray(input)) {
            var serialized = [];
            for (var i = 0, list = input; i < list.length; i += 1) {
                var item = list[i];

                serialized.push(WebWorkerTransfer.serialize(item, transferables));
            }
            return serialized;
        }

        if (typeof input === 'object') {
            var klass = (input.constructor     );
            var name = klass._classRegistryKey;
            if (!name) {
                throw new Error("can't serialize object of unregistered class");
            }
            //assert(registry[name]);

            var properties = klass.serialize ?
                // (Temporary workaround) allow a class to provide static
                // `serialize()` and `deserialize()` methods to bypass the generic
                // approach.
                // This temporary workaround lets us use the generic serialization
                // approach for objects whose members include instances of dynamic
                // StructArray types. Once we refactor StructArray to be static,
                // we can remove this complexity.
                (klass.serialize(input, transferables)                  ) : {};

            if (!klass.serialize) {
                for (var key in input) {
                    // any cast due to https://github.com/facebook/flow/issues/5393
                    if (!(input     ).hasOwnProperty(key)) {
                        continue;
                    }
                    if (registry[name].omit.indexOf(key) >= 0) {
                        continue;
                    }
                    var property = (input     )[key];
                    properties[key] = registry[name].shallow.indexOf(key) >= 0 ?
                        property :
                        WebWorkerTransfer.serialize(property, transferables);
                }
                if (input instanceof Error) {
                    properties.message = input.message;
                }
            }

            if (properties.$name) {
                throw new Error('$name property is reserved for worker serialization logic.');
            }
            if (name !== 'Object') {
                properties.$name = name;
            }

            return properties;
        }

        throw new Error(("can't serialize object of type " + (typeof input)));
    };

    WebWorkerTransfer.deserialize = function (input) {
        if (input === null ||
            input === undefined ||
            typeof input === 'boolean' ||
            typeof input === 'number' ||
            typeof input === 'string' ||
            input instanceof Boolean ||
            input instanceof Number ||
            input instanceof String ||
            input instanceof Date ||
            input instanceof RegExp ||
            isArrayBuffer(input) ||
            ArrayBuffer.isView(input) ||
            input instanceof ImageData) {
            return input;
        }

        if (Array.isArray(input)) {
            return input.map(WebWorkerTransfer.deserialize);
        }

        if (typeof input === 'object') {
            var name = (input     ).$name || 'Object';

            var ref = registry[name];
            var klass = ref.klass;
            if (!klass) {
                throw new Error(("can't deserialize unregistered class " + name));
            }

            if (klass.deserialize) {
                return (klass.deserialize                    )(input);
            }

            var result = Object.create(klass.prototype);

            for (var i = 0, list = Object.keys(input); i < list.length; i += 1) {
                var key = list[i];

                if (key === '$name') {
                    continue;
                }
                var value = (input                  )[key];
                result[key] = registry[name].shallow.indexOf(key) >= 0 ? value : WebWorkerTransfer.deserialize(value);
            }
            return result;
        }
        throw new Error(("can't deserialize object of type " + (typeof input)));
    };

    var ZoomHistory = function ZoomHistory() {
        this.first = true;
    };

    ZoomHistory.prototype.update = function update (z    , now    ) {
        var floorZ = Math.floor(z);

        if (this.first) {
            this.first = false;
            this.lastIntegerZoom = floorZ;
            this.lastIntegerZoomTime = 0;
            this.lastZoom = z;
            this.lastFloorZoom = floorZ;
            return true;
        }

        if (this.lastFloorZoom > floorZ) {
            this.lastIntegerZoom = floorZ + 1;
            this.lastIntegerZoomTime = now;
        } else if (this.lastFloorZoom < floorZ) {
            this.lastIntegerZoom = floorZ;
            this.lastIntegerZoomTime = now;
        }

        if (z !== this.lastZoom) {
            this.lastZoom = z;
            this.lastFloorZoom = floorZ;
            return true;
        }

        return false;
    };

    var EvaluationParameters$1 = function EvaluationParameters(zoom, options) {
        this.zoom = zoom;

        if (options) {
            this.now = options.now;
            this.fadeDuration = options.fadeDuration;
            this.zoomHistory = options.zoomHistory;
            this.transition = options.transition;
        } else {
            this.now = 0;
            this.fadeDuration = 0;
            this.zoomHistory = new ZoomHistory();
            this.transition = {};
        }
    };

    EvaluationParameters$1.prototype.isSupportedScript = function isSupportedScript(str) {
        return false;
        //return isStringInSupportedScript(str, plugin.isLoaded());
    };

    EvaluationParameters$1.prototype.crossFadingFactor = function crossFadingFactor() {
        if (this.fadeDuration === 0) {
            return 1;
        } else {
            return Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);
        }
    };

    EvaluationParameters$1.prototype.getCrossfadeParameters = function getCrossfadeParameters() {
        var z = this.zoom;
        var fraction = z - Math.floor(z);
        var t = this.crossFadingFactor();

        return z > this.zoomHistory.lastIntegerZoom ?
        {fromScale: 2, toScale: 1, t: fraction + (1 - fraction) * t} :
        {fromScale: 0.5, toScale: 1, t: 1 - (1 - t) * fraction};
    };

    var EXTENT = 8192;

    function clamp(n, min, max) {
        return Math.min(max, Math.max(min, n));
    }

    // These bounds define the minimum and maximum supported coordinate values.
    // While visible coordinates are within [0, EXTENT], tiles may theoretically
    // contain cordinates within [-Infinity, Infinity]. Our range is limited by the
    // number of bits used to represent the coordinate.
    function createBounds(bits) {
        return {
            min: -1 * Math.pow(2, bits - 1),
            max: Math.pow(2, bits - 1) - 1
        };
    }

    var bounds = createBounds(15);

    /**
     * Loads a geometry from a VectorTileFeature and scales it to the common extent
     * used internally.
     * @param {VectorTileFeature} feature
     * @private
     */
    function loadGeometry(feature) {
        var scale = EXTENT / feature.extent;
        var geometry = feature.loadGeometry();
        for (var r = 0; r < geometry.length; r++) {
            var ring = geometry[r];
            for (var p = 0; p < ring.length; p++) {
                var point = ring[p];
                // round here because mapbox-gl-native uses integers to represent
                // points and we need to do the same to avoid renering differences.
                point.x = Math.round(point.x * scale);
                // 因为绘制到纹理上颠倒了，所以在这里取反
                point.y = EXTENT - Math.round(point.y * scale);

                if (point.x < bounds.min || point.x > bounds.max || point.y < bounds.min || point.y > bounds.max) {
                    //warnOnce('Geometry exceeds allowed extent, reduce your vector tile buffer size');
                    point.x = clamp(point.x, bounds.min, bounds.max);
                    point.y = clamp(point.y, bounds.min, bounds.max);
                }
            }
        }
        return geometry;
    }

    var SegmentVector = function SegmentVector(segments) {
        if (segments === void 0) segments = [];

        this.segments = segments;
    };

    SegmentVector.prototype.prepareSegment = function prepareSegment(numVertices, layoutVertexArray, indexArray, sortKey) {
        var segment = this.segments[this.segments.length - 1];
        if (!segment || segment.vertexLength + numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH || segment.sortKey !== sortKey) {
            segment = ({
                vertexOffset: layoutVertexArray.length,
                primitiveOffset: indexArray.length,
                vertexLength: 0,
                primitiveLength: 0
            } );
            if (sortKey !== undefined) {
                segment.sortKey = sortKey;
            }
            this.segments.push(segment);
        }
        return segment;
    };

    SegmentVector.prototype.get = function get() {
        return this.segments;
    };

    SegmentVector.prototype.destroy = function destroy() {
        for (var i = 0, list = this.segments; i < list.length; i += 1) {
            var segment = list[i];

            for (var k in segment.vaos) {
                segment.vaos[k].destroy();
            }
        }
    };

    SegmentVector.simpleSegment = function simpleSegment(vertexOffset, primitiveOffset, vertexLength, primitiveLength) {
        return new SegmentVector([
            {
                vertexOffset: vertexOffset,
                primitiveOffset: primitiveOffset,
                vertexLength: vertexLength,
                primitiveLength: primitiveLength,
                vaos: {},
                sortKey: 0
            }
        ]);
    };

    /*
     * The maximum size of a vertex array. This limit is imposed by WebGL's 16 bit
     * addressing of vertex buffers.
     * @private
     * @readonly
     */
    SegmentVector.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1;
    WebWorkerTransfer.register('SegmentVector', SegmentVector);

    /**
     * @private
     */

    var DEFAULT_CAPACITY = 128;
    var RESIZE_MULTIPLIER = 5;

    /**
     * `StructArray` provides an abstraction over `ArrayBuffer` and `TypedArray`
     * making it behave like an array of typed structs.
     *
     * Conceptually, a StructArray is comprised of elements, i.e., instances of its
     * associated struct type. Each particular struct type, together with an
     * alignment size, determines the memory layout of a StructArray whose elements
     * are of that type.  Thus, for each such layout that we need, we have
     * a corrseponding StructArrayLayout class, inheriting from StructArray and
     * implementing `emplaceBack()` and `_refreshViews()`.
     *
     * In some cases, where we need to access particular elements of a StructArray,
     * we implement a more specific subclass that inherits from one of the
     * StructArrayLayouts and adds a `get(i): T` accessor that returns a structured
     * object whose properties are proxies into the underlying memory space for the
     * i-th element.  This affords the convience of working with (seemingly) plain
     * Javascript objects without the overhead of serializing/deserializing them
     * into ArrayBuffers for efficient web worker transfer.
     *
     * @private
     */
    var StructArray = function StructArray() {
        this.isTransferred = false;
        this.capacity = -1;
        this.resize(0);
    };

    /**
     * Serialize a StructArray instance.Serializes both the raw data and the
     * metadata needed to reconstruct the StructArray base class during
     * deserialization.
     */
    StructArray.serialize = function serialize(array, transferables) {
        //assert_1(!array.isTransferred);
        if(array.isTransferred){
            console.log("StructArray array.isTransferred.");
        }

        array._trim();

        if (transferables) {
            array.isTransferred = true;
            transferables.push(array.arrayBuffer);
        }

        return {
            length: array.length,
            arrayBuffer: array.arrayBuffer,
        };
    };

    StructArray.deserialize = function deserialize(input) {
        var structArray = Object.create(this.prototype);
        structArray.arrayBuffer = input.arrayBuffer;
        structArray.length = input.length;
        structArray.capacity = input.arrayBuffer.byteLength / structArray.bytesPerElement;
        structArray._refreshViews();
        return structArray;
    };

    /**
     * Resize the array to discard unused capacity.
     */
    StructArray.prototype._trim = function _trim() {
        if (this.length !== this.capacity) {
            this.capacity = this.length;
            this.arrayBuffer = this.arrayBuffer.slice(0, this.length * this.bytesPerElement);
            this._refreshViews();
        }
    };

    /**
     * Resets the the length of the array to 0 without de-allocating capcacity.
     */
    StructArray.prototype.clear = function clear() {
        this.length = 0;
    };

    /**
     * Resize the array.
     * If `n` is greater than the current length then additional elements with undefined values are added.
     * If `n` is less than the current length then the array will be reduced to the first `n` elements.
     * @param {number} n The new size of the array.
     */
    StructArray.prototype.resize = function resize(n) {
        //assert_1(!this.isTransferred);
        this.reserve(n);
        this.length = n;
    };

    /**
     * Indicate a planned increase in size, so that any necessary allocation may
     * be done once, ahead of time.
     * @param {number} n The expected size of the array.
     */
    StructArray.prototype.reserve = function reserve(n) {
        if (n > this.capacity) {
            this.capacity = Math.max(n, Math.floor(this.capacity * RESIZE_MULTIPLIER), DEFAULT_CAPACITY);
            this.arrayBuffer = new ArrayBuffer(this.capacity * this.bytesPerElement);

            var oldUint8Array = this.uint8;
            this._refreshViews();
            if (oldUint8Array) {
                this.uint8.set(oldUint8Array);
            }
        }
    };

    /**
     * Create TypedArray views for the current ArrayBuffer.
     */
    StructArray.prototype._refreshViews = function _refreshViews() {
        throw new Error('_refreshViews() must be implemented by each concrete StructArray layout');
    };

    /**
     * Implementation of the StructArray layout:
     * [0]: Int16[2]
     * [4]: Uint8[4]
     *
     * @private
     */
    var StructArrayLayout2i4ub8 = /*@__PURE__*/(function (StructArray) {
        function StructArrayLayout2i4ub8() {
            StructArray.apply(this, arguments);
        }

        if (StructArray) StructArrayLayout2i4ub8.__proto__ = StructArray;
        StructArrayLayout2i4ub8.prototype = Object.create(StructArray && StructArray.prototype);
        StructArrayLayout2i4ub8.prototype.constructor = StructArrayLayout2i4ub8;

        StructArrayLayout2i4ub8.prototype._refreshViews = function _refreshViews() {
            this.uint8 = new Uint8Array(this.arrayBuffer);
            this.int16 = new Int16Array(this.arrayBuffer);
        };

        StructArrayLayout2i4ub8.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5) {
            var i = this.length;
            this.resize(i + 1);
            return this.emplace(i, v0, v1, v2, v3, v4, v5);
        };

        StructArrayLayout2i4ub8.prototype.emplace = function emplace(i, v0, v1, v2, v3, v4, v5) {
            var o2 = i * 4;
            var o1 = i * 8;
            this.int16[o2 + 0] = v0;
            this.int16[o2 + 1] = v1;
            this.uint8[o1 + 4] = v2;
            this.uint8[o1 + 5] = v3;
            this.uint8[o1 + 6] = v4;
            this.uint8[o1 + 7] = v5;
            return i;
        };

        return StructArrayLayout2i4ub8;
    }(StructArray));

    StructArrayLayout2i4ub8.prototype.bytesPerElement = 8;
    WebWorkerTransfer.register('StructArrayLayout2i4ub8', StructArrayLayout2i4ub8);

    /**
     * Implementation of the StructArray layout:
     * [0]: Uint16[3]
     *
     * @private
     */
    var StructArrayLayout3ui6 = /*@__PURE__*/(function (StructArray) {
        function StructArrayLayout3ui6() {
            StructArray.apply(this, arguments);
        }

        if (StructArray) StructArrayLayout3ui6.__proto__ = StructArray;
        StructArrayLayout3ui6.prototype = Object.create(StructArray && StructArray.prototype);
        StructArrayLayout3ui6.prototype.constructor = StructArrayLayout3ui6;

        StructArrayLayout3ui6.prototype._refreshViews = function _refreshViews() {
            this.uint8 = new Uint8Array(this.arrayBuffer);
            this.uint16 = new Uint16Array(this.arrayBuffer);
        };

        StructArrayLayout3ui6.prototype.emplaceBack = function emplaceBack(v0, v1, v2) {
            var i = this.length;
            this.resize(i + 1);
            return this.emplace(i, v0, v1, v2);
        };

        StructArrayLayout3ui6.prototype.emplace = function emplace(i, v0, v1, v2) {
            var o2 = i * 3;
            this.uint16[o2 + 0] = v0;
            this.uint16[o2 + 1] = v1;
            this.uint16[o2 + 2] = v2;
            return i;
        };

        return StructArrayLayout3ui6;
    }(StructArray));

    StructArrayLayout3ui6.prototype.bytesPerElement = 6;
    WebWorkerTransfer.register('StructArrayLayout3ui6', StructArrayLayout3ui6);

    // A transferable data structure that maps feature ids to their indices and buffer offsets
    var FeaturePositionMap = function FeaturePositionMap() {
        this.ids = [];
        this.positions = [];
        this.indexed = false;
    };

    FeaturePositionMap.prototype.add = function add(id, index, start, end) {
        this.ids.push(id);
        this.positions.push(index, start, end);
    };

    FeaturePositionMap.prototype.getPositions = function getPositions(id) {
        //assert_1(this.indexed);

        // binary search for the first occurrence of id in this.ids;
        // relies on ids/positions being sorted by id, which happens in serialization
        var i = 0;
        var j = this.ids.length - 1;
        while (i < j) {
            var m = (i + j) >> 1;
            if (this.ids[m] >= id) {
                j = m;
            } else {
                i = m + 1;
            }
        }
        var positions = [];
        while (this.ids[i] === id) {
            var index = this.positions[3 * i];
            var start = this.positions[3 * i + 1];
            var end = this.positions[3 * i + 2];
            positions.push({index: index, start: start, end: end});
            i++;
        }
        return positions;
    };

    FeaturePositionMap.serialize = function serialize(map, transferables) {
        var ids = new Float64Array(map.ids);
        var positions = new Uint32Array(map.positions);

        sort(ids, positions, 0, ids.length - 1);

        if (transferables) {
            transferables.push(ids.buffer, positions.buffer);
        }

        return {ids: ids, positions: positions};
    };

    FeaturePositionMap.deserialize = function deserialize(obj) {
        var map = new FeaturePositionMap();
        // after transferring, we only use these arrays statically (no pushes),
        // so TypedArray vs Array distinction that flow points out doesn't matter
        map.ids = (obj.ids   );
        map.positions = (obj.positions   );
        map.indexed = true;
        return map;
    };

    // custom quicksort that sorts ids, indices and offsets together (by ids)
    function sort(ids, positions, left, right) {
        if (left >= right) {
            return;
        }

        var pivot = ids[(left + right) >> 1];
        var i = left - 1;
        var j = right + 1;

        while (true) {
            do {
                i++;
            } while (ids[i] < pivot);
            do {
                j--;
            } while (ids[j] > pivot);
            if (i >= j) {
                break;
            }
            swap(ids, i, j);
            swap(positions, 3 * i, 3 * j);
            swap(positions, 3 * i + 1, 3 * j + 1);
            swap(positions, 3 * i + 2, 3 * j + 2);
        }

        sort(ids, positions, left, j);
        sort(ids, positions, j + 1, right);
    }

    function swap(arr, i, j) {
        var tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    WebWorkerTransfer.register('FeaturePositionMap', FeaturePositionMap);

    /**
     * `PossiblyEvaluatedPropertyValue` is used for data-driven paint and layout property values. It holds a
     * `PossiblyEvaluatedValue` and the `GlobalProperties` that were used to generate it. You're not allowed to supply
     * a different set of `GlobalProperties` when performing the final evaluation because they would be ignored in the
     * case where the input value was a constant or camera function.
     *
     * @private
     */
    var PossiblyEvaluatedPropertyValue$1 = function PossiblyEvaluatedPropertyValue(property, value, parameters) {
        this.property = property;
        this.value = value;
        this.parameters = parameters;
    };

    PossiblyEvaluatedPropertyValue$1.prototype.isConstant = function isConstant() {
        return this.value.kind === 'constant';
    };

    PossiblyEvaluatedPropertyValue$1.prototype.constantOr = function constantOr(value) {
        if (this.value.kind === 'constant') {
            return this.value.value;
        } else {
            return value;
        }
    };

    PossiblyEvaluatedPropertyValue$1.prototype.evaluate = function evaluate(feature, featureState, availableImages) {
        return this.property.evaluate(this.value, this.parameters, feature, featureState, availableImages);
    };

    function Supports() {
    }

    Supports.supportsPropertyExpression = function (spec) {
        return spec['property-type'] === 'data-driven' || spec['property-type'] === 'cross-faded-data-driven';
    };

    Supports.supportsZoomExpression = function (spec) {
        return !!spec.expression && spec.expression.parameters.indexOf('zoom') > -1;
    };

    Supports.supportsInterpolation = function (spec) {
        return !!spec.expression && spec.expression.interpolated;
    };

    var UniformType = {};

    var Uniform = function Uniform(context, location) {
        this.gl = context.gl;
        this.location = location;
    };

    UniformType.Uniform1i = /*@__PURE__*/(function (Uniform) {
        function Uniform1i(context, location) {
            Uniform.call(this, context, location);
            this.current = 0;
        }

        if (Uniform) Uniform1i.__proto__ = Uniform;
        Uniform1i.prototype = Object.create(Uniform && Uniform.prototype);
        Uniform1i.prototype.constructor = Uniform1i;

        Uniform1i.prototype.set = function set(v) {
            if (this.current !== v) {
                this.current = v;
                this.gl.uniform1i(this.location, v);
            }
        };

        return Uniform1i;
    }(Uniform));

    UniformType.Uniform1f = /*@__PURE__*/(function (Uniform) {
        function Uniform1f(context, location) {
            Uniform.call(this, context, location);
            this.current = 0;
        }

        if (Uniform) Uniform1f.__proto__ = Uniform;
        Uniform1f.prototype = Object.create(Uniform && Uniform.prototype);
        Uniform1f.prototype.constructor = Uniform1f;

        Uniform1f.prototype.set = function set(v) {
            if (this.current !== v) {
                this.current = v;
                this.gl.uniform1f(this.location, v);
            }
        };

        return Uniform1f;
    }(Uniform));

    UniformType.Uniform2f = /*@__PURE__*/(function (Uniform) {
        function Uniform2f(context, location) {
            Uniform.call(this, context, location);
            this.current = [0, 0];
        }

        if (Uniform) Uniform2f.__proto__ = Uniform;
        Uniform2f.prototype = Object.create(Uniform && Uniform.prototype);
        Uniform2f.prototype.constructor = Uniform2f;

        Uniform2f.prototype.set = function set(v) {
            if (v[0] !== this.current[0] || v[1] !== this.current[1]) {
                this.current = v;
                this.gl.uniform2f(this.location, v[0], v[1]);
            }
        };

        return Uniform2f;
    }(Uniform));

    UniformType.Uniform3f = /*@__PURE__*/(function (Uniform) {
        function Uniform3f(context, location) {
            Uniform.call(this, context, location);
            this.current = [0, 0, 0];
        }

        if (Uniform) Uniform3f.__proto__ = Uniform;
        Uniform3f.prototype = Object.create(Uniform && Uniform.prototype);
        Uniform3f.prototype.constructor = Uniform3f;

        Uniform3f.prototype.set = function set(v) {
            if (v[0] !== this.current[0] || v[1] !== this.current[1] || v[2] !== this.current[2]) {
                this.current = v;
                this.gl.uniform3f(this.location, v[0], v[1], v[2]);
            }
        };

        return Uniform3f;
    }(Uniform));

    UniformType.Uniform4f = /*@__PURE__*/(function (Uniform) {
        function Uniform4f(context, location) {
            Uniform.call(this, context, location);
            this.current = [0, 0, 0, 0];
        }

        if (Uniform) Uniform4f.__proto__ = Uniform;
        Uniform4f.prototype = Object.create(Uniform && Uniform.prototype);
        Uniform4f.prototype.constructor = Uniform4f;

        Uniform4f.prototype.set = function set(v) {
            if (v[0] !== this.current[0] || v[1] !== this.current[1] ||
                v[2] !== this.current[2] || v[3] !== this.current[3]) {
                this.current = v;
                this.gl.uniform4f(this.location, v[0], v[1], v[2], v[3]);
            }
        };

        return Uniform4f;
    }(Uniform));

    UniformType.UniformColor = /*@__PURE__*/(function (Uniform) {
        function UniformColor(context, location) {
            Uniform.call(this, context, location);
            this.current = Color$1.transparent;
        }

        if (Uniform) UniformColor.__proto__ = Uniform;
        UniformColor.prototype = Object.create(Uniform && Uniform.prototype);
        UniformColor.prototype.constructor = UniformColor;

        UniformColor.prototype.set = function set(v) {
            if (v.r !== this.current.r || v.g !== this.current.g ||
                v.b !== this.current.b || v.a !== this.current.a) {
                this.current = v;
                this.gl.uniform4f(this.location, v.r, v.g, v.b, v.a);
            }
        };

        return UniformColor;
    }(Uniform));

    var emptyMat4 = new Float32Array(16);
    UniformType.UniformMatrix4f = /*@__PURE__*/(function (Uniform) {
        function UniformMatrix4f(context, location) {
            Uniform.call(this, context, location);
            this.current = emptyMat4;
        }

        if (Uniform) UniformMatrix4f.__proto__ = Uniform;
        UniformMatrix4f.prototype = Object.create(Uniform && Uniform.prototype);
        UniformMatrix4f.prototype.constructor = UniformMatrix4f;

        UniformMatrix4f.prototype.set = function set(v) {
            this.gl.uniformMatrix4fv(this.location, false, v);
            // The vast majority of matrix comparisons that will trip this set
            // happen at i=12 or i=0, so we check those first to avoid lots of
            // unnecessary iteration:
    //            if (v[12] !== this.current[12] || v[0] !== this.current[0]) {
    //                this.current = v;
    //                this.gl.uniformMatrix4fv(this.location, false, v);
    //                return;
    //            }
    //            for (var i = 1; i < 16; i++) {
    //                if (v[i] !== this.current[i]) {
    //                    this.current = v;
    //                    this.gl.uniformMatrix4fv(this.location, false, v);
    //                    break;
    //                }
    //            }
        };

        return UniformMatrix4f;
    }(Uniform));

    /**
     * Implementation of the StructArray layout:
     * [0]: Uint16[8]
     *
     * @private
     */
    var StructArrayLayout8ui16 = /*@__PURE__*/(function (StructArray) {
        function StructArrayLayout8ui16() {
            StructArray.apply(this, arguments);
        }

        if (StructArray) StructArrayLayout8ui16.__proto__ = StructArray;
        StructArrayLayout8ui16.prototype = Object.create(StructArray && StructArray.prototype);
        StructArrayLayout8ui16.prototype.constructor = StructArrayLayout8ui16;

        StructArrayLayout8ui16.prototype._refreshViews = function _refreshViews() {
            this.uint8 = new Uint8Array(this.arrayBuffer);
            this.uint16 = new Uint16Array(this.arrayBuffer);
        };

        StructArrayLayout8ui16.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3, v4, v5, v6, v7) {
            var i = this.length;
            this.resize(i + 1);
            return this.emplace(i, v0, v1, v2, v3, v4, v5, v6, v7);
        };

        StructArrayLayout8ui16.prototype.emplace = function emplace(i, v0, v1, v2, v3, v4, v5, v6, v7) {
            var o2 = i * 8;
            this.uint16[o2 + 0] = v0;
            this.uint16[o2 + 1] = v1;
            this.uint16[o2 + 2] = v2;
            this.uint16[o2 + 3] = v3;
            this.uint16[o2 + 4] = v4;
            this.uint16[o2 + 5] = v5;
            this.uint16[o2 + 6] = v6;
            this.uint16[o2 + 7] = v7;
            return i;
        };

        return StructArrayLayout8ui16;
    }(StructArray));

    StructArrayLayout8ui16.prototype.bytesPerElement = 16;
    WebWorkerTransfer.register('StructArrayLayout8ui16', StructArrayLayout8ui16);

    /**
     * Implementation of the StructArray layout:
     * [0]: Float32[2]
     *
     * @private
     */
    var StructArrayLayout2f8 = /*@__PURE__*/(function (StructArray) {
        function StructArrayLayout2f8() {
            StructArray.apply(this, arguments);
        }

        if (StructArray) StructArrayLayout2f8.__proto__ = StructArray;
        StructArrayLayout2f8.prototype = Object.create(StructArray && StructArray.prototype);
        StructArrayLayout2f8.prototype.constructor = StructArrayLayout2f8;

        StructArrayLayout2f8.prototype._refreshViews = function _refreshViews() {
            this.uint8 = new Uint8Array(this.arrayBuffer);
            this.float32 = new Float32Array(this.arrayBuffer);
        };

        StructArrayLayout2f8.prototype.emplaceBack = function emplaceBack(v0, v1) {
            var i = this.length;
            this.resize(i + 1);
            return this.emplace(i, v0, v1);
        };

        StructArrayLayout2f8.prototype.emplace = function emplace(i, v0, v1) {
            var o4 = i * 2;
            this.float32[o4 + 0] = v0;
            this.float32[o4 + 1] = v1;
            return i;
        };

        return StructArrayLayout2f8;
    }(StructArray));

    StructArrayLayout2f8.prototype.bytesPerElement = 8;
    WebWorkerTransfer.register('StructArrayLayout2f8', StructArrayLayout2f8);

    /**
     * Implementation of the StructArray layout:
     * [0]: Float32[4]
     *
     * @private
     */
    var StructArrayLayout4f16 = /*@__PURE__*/(function (StructArray) {
        function StructArrayLayout4f16() {
            StructArray.apply(this, arguments);
        }

        if (StructArray) StructArrayLayout4f16.__proto__ = StructArray;
        StructArrayLayout4f16.prototype = Object.create(StructArray && StructArray.prototype);
        StructArrayLayout4f16.prototype.constructor = StructArrayLayout4f16;

        StructArrayLayout4f16.prototype._refreshViews = function _refreshViews() {
            this.uint8 = new Uint8Array(this.arrayBuffer);
            this.float32 = new Float32Array(this.arrayBuffer);
        };

        StructArrayLayout4f16.prototype.emplaceBack = function emplaceBack(v0, v1, v2, v3) {
            var i = this.length;
            this.resize(i + 1);
            return this.emplace(i, v0, v1, v2, v3);
        };

        StructArrayLayout4f16.prototype.emplace = function emplace(i, v0, v1, v2, v3) {
            var o4 = i * 4;
            this.float32[o4 + 0] = v0;
            this.float32[o4 + 1] = v1;
            this.float32[o4 + 2] = v2;
            this.float32[o4 + 3] = v3;
            return i;
        };

        return StructArrayLayout4f16;
    }(StructArray));

    StructArrayLayout4f16.prototype.bytesPerElement = 16;
    WebWorkerTransfer.register('StructArrayLayout4f16', StructArrayLayout4f16);

    /**
     * Implementation of the StructArray layout:
     * [0]: Float32[1]
     *
     * @private
     */
    var StructArrayLayout1f4 = /*@__PURE__*/(function (StructArray) {
        function StructArrayLayout1f4() {
            StructArray.apply(this, arguments);
        }

        if (StructArray) StructArrayLayout1f4.__proto__ = StructArray;
        StructArrayLayout1f4.prototype = Object.create(StructArray && StructArray.prototype);
        StructArrayLayout1f4.prototype.constructor = StructArrayLayout1f4;

        StructArrayLayout1f4.prototype._refreshViews = function _refreshViews() {
            this.uint8 = new Uint8Array(this.arrayBuffer);
            this.float32 = new Float32Array(this.arrayBuffer);
        };

        StructArrayLayout1f4.prototype.emplaceBack = function emplaceBack(v0) {
            var i = this.length;
            this.resize(i + 1);
            return this.emplace(i, v0);
        };

        StructArrayLayout1f4.prototype.emplace = function emplace(i, v0) {
            var o4 = i * 1;
            this.float32[o4 + 0] = v0;
            return i;
        };

        return StructArrayLayout1f4;
    }(StructArray));

    StructArrayLayout1f4.prototype.bytesPerElement = 4;
    WebWorkerTransfer.register('StructArrayLayout1f4', StructArrayLayout1f4);

    function clamp$1(n, min, max) {
        return Math.min(max, Math.max(min, n));
    }

    function packUint8ToFloat(a, b) {
        // coerce a and b to 8-bit ints
        a = clamp$1(Math.floor(a), 0, 255);
        b = clamp$1(Math.floor(b), 0, 255);
        return 256 * a + b;
    }

    function packColor(color) {
        return [
            packUint8ToFloat(255 * color.r, 255 * color.g),
            packUint8ToFloat(255 * color.b, 255 * color.a)
        ];
    }

    var ConstantBinder = function ConstantBinder(value, names, type) {
        this.value = value;
        this.names = names;
        this.uniformNames = this.names.map(function (name) {
            return ("u_" + name);
        });
        this.type = type;
        this.maxValue = -Infinity;
    };

    ConstantBinder.prototype.defines = function defines() {
        return this.names.map(function (name) {
            return ("#define HAS_UNIFORM_u_" + name);
        });
    };
    ConstantBinder.prototype.setConstantPatternPositions = function setConstantPatternPositions() {
    };
    ConstantBinder.prototype.populatePaintArray = function populatePaintArray() {
    };
    ConstantBinder.prototype.updatePaintArray = function updatePaintArray() {
    };
    ConstantBinder.prototype.upload = function upload() {
    };
    ConstantBinder.prototype.destroy = function destroy() {
    };

    ConstantBinder.prototype.setUniforms = function setUniforms(context, uniform, globals, currentValue) {
        uniform.set(currentValue.constantOr(this.value));
    };

    ConstantBinder.prototype.getBinding = function getBinding(context, location) {
        return (this.type === 'color') ?
            new UniformType.UniformColor(context, location) :
            new UniformType.Uniform1f(context, location);
    };

    ConstantBinder.serialize = function serialize$1(binder) {
        var value = binder.value;
        var names = binder.names;
        var type = binder.type;
        return {value: WebWorkerTransfer.serialize(value), names: names, type: type};
    };

    ConstantBinder.deserialize = function deserialize$1(serialized) {
        var value = serialized.value;
        var names = serialized.names;
        var type = serialized.type;
        return new ConstantBinder(WebWorkerTransfer.deserialize(value), names, type);
    };

    var CrossFadedConstantBinder = function CrossFadedConstantBinder(value, names, type) {
        this.value = value;
        this.names = names;
        this.uniformNames = this.names.map(function (name) {
            return ("u_" + name);
        });
        this.type = type;
        this.maxValue = -Infinity;
        this.patternPositions = {patternTo: null, patternFrom: null};
    };

    CrossFadedConstantBinder.prototype.defines = function defines() {
        return this.names.map(function (name) {
            return ("#define HAS_UNIFORM_u_" + name);
        });
    };

    CrossFadedConstantBinder.prototype.populatePaintArray = function populatePaintArray() {
    };
    CrossFadedConstantBinder.prototype.updatePaintArray = function updatePaintArray() {
    };
    CrossFadedConstantBinder.prototype.upload = function upload() {
    };
    CrossFadedConstantBinder.prototype.destroy = function destroy() {
    };

    CrossFadedConstantBinder.prototype.setConstantPatternPositions = function setConstantPatternPositions(posTo, posFrom) {
        this.patternPositions.patternTo = posTo.tlbr;
        this.patternPositions.patternFrom = posFrom.tlbr;
    };

    CrossFadedConstantBinder.prototype.setUniforms = function setUniforms(context, uniform, globals, currentValue, uniformName) {
        var pos = this.patternPositions;
        if (uniformName === "u_pattern_to" && pos.patternTo) {
            uniform.set(pos.patternTo);
        }
        if (uniformName === "u_pattern_from" && pos.patternFrom) {
            uniform.set(pos.patternFrom);
        }
    };

    CrossFadedConstantBinder.prototype.getBinding = function getBinding(context, location) {
        return new UniformType.Uniform4f(context, location);
    };

    var SourceExpressionBinder = function SourceExpressionBinder(expression, names, type, PaintVertexArray) {
        this.expression = expression;
        this.names = names;
        this.type = type;
        this.uniformNames = this.names.map(function (name) {
            return ("a_" + name);
        });
        this.maxValue = -Infinity;
        this.paintVertexAttributes = names.map(function (name) {
                return ({
                    name: ("a_" + name),
                    type: 'Float32',
                    components: type === 'color' ? 2 : 1,
                    offset: 0
                });
            }
        );
        this.paintVertexArray = new PaintVertexArray();
    };

    SourceExpressionBinder.prototype.defines = function defines() {
        return [];
    };

    SourceExpressionBinder.prototype.setConstantPatternPositions = function setConstantPatternPositions() {
    };

    SourceExpressionBinder.prototype.populatePaintArray = function populatePaintArray(newLength, feature, imagePositions, formattedSection) {
        var paintArray = this.paintVertexArray;

        var start = paintArray.length;
        paintArray.reserve(newLength);

        var value = this.expression.evaluate(new EvaluationParameters(0), feature, {}, [], formattedSection);

        if (this.type === 'color') {
            var color = packColor(value);
            for (var i = start; i < newLength; i++) {
                paintArray.emplaceBack(color[0], color[1]);
            }
        } else {
            for (var i$1 = start; i$1 < newLength; i$1++) {
                paintArray.emplaceBack(value);
            }

            this.maxValue = Math.max(this.maxValue, value);
        }
    };

    SourceExpressionBinder.prototype.updatePaintArray = function updatePaintArray(start, end, feature, featureState) {
        var paintArray = this.paintVertexArray;
        var value = this.expression.evaluate({zoom: 0}, feature, featureState);

        if (this.type === 'color') {
            var color = packColor(value);
            for (var i = start; i < end; i++) {
                paintArray.emplace(i, color[0], color[1]);
            }
        } else {
            for (var i$1 = start; i$1 < end; i$1++) {
                paintArray.emplace(i$1, value);
            }

            this.maxValue = Math.max(this.maxValue, value);
        }
    };

    SourceExpressionBinder.prototype.upload = function upload(context) {
        if (this.paintVertexArray && this.paintVertexArray.arrayBuffer) {
            if (this.paintVertexBuffer && this.paintVertexBuffer.buffer) {
                this.paintVertexBuffer.updateData(this.paintVertexArray);
            } else {
                this.paintVertexBuffer = context.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent);
            }
        }
    };

    SourceExpressionBinder.prototype.destroy = function destroy() {
        if (this.paintVertexBuffer) {
            this.paintVertexBuffer.destroy();
        }
    };

    SourceExpressionBinder.prototype.setUniforms = function setUniforms(context, uniform) {
        uniform.set(0);
    };

    SourceExpressionBinder.prototype.getBinding = function getBinding(context, location) {
        return new UniformType.Uniform1f(context, location);
    };

    var CompositeExpressionBinder = function CompositeExpressionBinder(expression, names, type, useIntegerZoom, zoom, layout) {
        this.expression = expression;
        this.names = names;
        this.uniformNames = this.names.map(function (name) {
            return ("u_" + name + "_t");
        });
        this.type = type;
        this.useIntegerZoom = useIntegerZoom;
        this.zoom = zoom;
        this.maxValue = -Infinity;
        var PaintVertexArray = layout;
        this.paintVertexAttributes = names.map(function (name) {
            return {
                name: ("a_" + name),
                type: 'Float32',
                components: type === 'color' ? 4 : 2,
                offset: 0
            };
        });
        this.paintVertexArray = new PaintVertexArray();
    };

    CompositeExpressionBinder.prototype.defines = function defines() {
        return [];
    };

    CompositeExpressionBinder.prototype.setConstantPatternPositions = function setConstantPatternPositions() {
    };

    CompositeExpressionBinder.prototype.populatePaintArray = function populatePaintArray(newLength, feature, imagePositions, formattedSection) {
        var paintArray = this.paintVertexArray;

        var start = paintArray.length;
        paintArray.reserve(newLength);

        var min = this.expression.evaluate(new EvaluationParameters(this.zoom), feature, {}, [], formattedSection);
        var max = this.expression.evaluate(new EvaluationParameters(this.zoom + 1), feature, {}, [], formattedSection);

        if (this.type === 'color') {
            var minColor = packColor(min);
            var maxColor = packColor(max);
            for (var i = start; i < newLength; i++) {
                paintArray.emplaceBack(minColor[0], minColor[1], maxColor[0], maxColor[1]);
            }
        } else {
            for (var i$1 = start; i$1 < newLength; i$1++) {
                paintArray.emplaceBack(min, max);
            }
            this.maxValue = Math.max(this.maxValue, min, max);
        }
    };

    CompositeExpressionBinder.prototype.updatePaintArray = function updatePaintArray(start, end, feature, featureState) {
        var paintArray = this.paintVertexArray;

        var min = this.expression.evaluate({zoom: this.zoom}, feature, featureState);
        var max = this.expression.evaluate({zoom: this.zoom + 1}, feature, featureState);

        if (this.type === 'color') {
            var minColor = packColor(min);
            var maxColor = packColor(max);
            for (var i = start; i < end; i++) {
                paintArray.emplace(i, minColor[0], minColor[1], maxColor[0], maxColor[1]);
            }
        } else {
            for (var i$1 = start; i$1 < end; i$1++) {
                paintArray.emplace(i$1, min, max);
            }
            this.maxValue = Math.max(this.maxValue, min, max);
        }
    };

    CompositeExpressionBinder.prototype.upload = function upload(context) {
        if (this.paintVertexArray && this.paintVertexArray.arrayBuffer) {
            if (this.paintVertexBuffer && this.paintVertexBuffer.buffer) {
                this.paintVertexBuffer.updateData(this.paintVertexArray);
            } else {
                this.paintVertexBuffer = context.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent);
            }
        }
    };

    CompositeExpressionBinder.prototype.destroy = function destroy() {
        if (this.paintVertexBuffer) {
            this.paintVertexBuffer.destroy();
        }
    };

    CompositeExpressionBinder.prototype.interpolationFactor = function interpolationFactor(currentZoom) {
        if (this.useIntegerZoom) {
            currentZoom = Math.floor(currentZoom);
        }
        return clamp$1(this.expression.interpolationFactor(currentZoom, this.zoom, this.zoom + 1), 0, 1);
    };

    CompositeExpressionBinder.prototype.setUniforms = function setUniforms(context, uniform, globals) {
        uniform.set(this.interpolationFactor(globals.zoom));
    };

    CompositeExpressionBinder.prototype.getBinding = function getBinding(context, location) {
        return new UniformType.Uniform1f(context, location);
    };

    var CrossFadedCompositeBinder = function CrossFadedCompositeBinder(expression, names, type, useIntegerZoom, zoom, PaintVertexArray, layerId) {

        this.expression = expression;
        this.names = names;
        this.type = type;
        this.uniformNames = this.names.map(function (name) {
            return ("u_" + name + "_t");
        });
        this.useIntegerZoom = useIntegerZoom;
        this.zoom = zoom;
        this.maxValue = -Infinity;
        this.layerId = layerId;

        this.paintVertexAttributes = names.map(function (name) {
                return ({
                    name: ("a_" + name),
                    type: 'Uint16',
                    components: 4,
                    offset: 0
                });
            }
        );

        this.zoomInPaintVertexArray = new PaintVertexArray();
        this.zoomOutPaintVertexArray = new PaintVertexArray();
    };

    CrossFadedCompositeBinder.prototype.defines = function defines() {
        return [];
    };

    CrossFadedCompositeBinder.prototype.setConstantPatternPositions = function setConstantPatternPositions() {
    };

    CrossFadedCompositeBinder.prototype.populatePaintArray = function populatePaintArray(length, feature, imagePositions) {
        // We populate two paint arrays because, for cross-faded properties, we don't know which direction
        // we're cross-fading to at layout time. In order to keep vertex attributes to a minimum and not pass
        // unnecessary vertex data to the shaders, we determine which to upload at draw time.

        var zoomInArray = this.zoomInPaintVertexArray;
        var zoomOutArray = this.zoomOutPaintVertexArray;
        var ref = this;
        var layerId = ref.layerId;
        var start = zoomInArray.length;

        zoomInArray.reserve(length);
        zoomOutArray.reserve(length);

        if (imagePositions && feature.patterns && feature.patterns[layerId]) {
            var ref$1 = feature.patterns[layerId];
            var min = ref$1.min;
            var mid = ref$1.mid;
            var max = ref$1.max;

            var imageMin = imagePositions[min];
            var imageMid = imagePositions[mid];
            var imageMax = imagePositions[max];

            if (!imageMin || !imageMid || !imageMax) {
                return;
            }

            for (var i = start; i < length; i++) {
                zoomInArray.emplaceBack(
                    imageMid.tl[0], imageMid.tl[1], imageMid.br[0], imageMid.br[1],
                    imageMin.tl[0], imageMin.tl[1], imageMin.br[0], imageMin.br[1]
                );

                zoomOutArray.emplaceBack(
                    imageMid.tl[0], imageMid.tl[1], imageMid.br[0], imageMid.br[1],
                    imageMax.tl[0], imageMax.tl[1], imageMax.br[0], imageMax.br[1]
                );
            }
        }
    };

    CrossFadedCompositeBinder.prototype.updatePaintArray = function updatePaintArray(start, end, feature, featureState, imagePositions) {
        // We populate two paint arrays because, for cross-faded properties, we don't know which direction
        // we're cross-fading to at layout time. In order to keep vertex attributes to a minimum and not pass
        // unnecessary vertex data to the shaders, we determine which to upload at draw time.

        var zoomInArray = this.zoomInPaintVertexArray;
        var zoomOutArray = this.zoomOutPaintVertexArray;
        var ref = this;
        var layerId = ref.layerId;

        if (imagePositions && feature.patterns && feature.patterns[layerId]) {
            var ref$1 = feature.patterns[layerId];
            var min = ref$1.min;
            var mid = ref$1.mid;
            var max = ref$1.max;
            var imageMin = imagePositions[min];
            var imageMid = imagePositions[mid];
            var imageMax = imagePositions[max];

            if (!imageMin || !imageMid || !imageMax) {
                return;
            }
            for (var i = start; i < end; i++) {
                zoomInArray.emplace(i,
                    imageMid.tl[0], imageMid.tl[1], imageMid.br[0], imageMid.br[1],
                    imageMin.tl[0], imageMin.tl[1], imageMin.br[0], imageMin.br[1]
                );

                zoomOutArray.emplace(i,
                    imageMid.tl[0], imageMid.tl[1], imageMid.br[0], imageMid.br[1],
                    imageMax.tl[0], imageMax.tl[1], imageMax.br[0], imageMax.br[1]
                );
            }
        }
    };

    CrossFadedCompositeBinder.prototype.upload = function upload(context) {
        if (this.zoomInPaintVertexArray && this.zoomInPaintVertexArray.arrayBuffer && this.zoomOutPaintVertexArray && this.zoomOutPaintVertexArray.arrayBuffer) {
            this.zoomInPaintVertexBuffer = context.createVertexBuffer(this.zoomInPaintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent);
            this.zoomOutPaintVertexBuffer = context.createVertexBuffer(this.zoomOutPaintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent);
        }
    };

    CrossFadedCompositeBinder.prototype.destroy = function destroy() {
        if (this.zoomOutPaintVertexBuffer) {
            this.zoomOutPaintVertexBuffer.destroy();
        }
        if (this.zoomInPaintVertexBuffer) {
            this.zoomInPaintVertexBuffer.destroy();
        }

    };

    CrossFadedCompositeBinder.prototype.setUniforms = function setUniforms(context, uniform) {
        uniform.set(0);
    };

    CrossFadedCompositeBinder.prototype.getBinding = function getBinding(context, location) {
        return new Uniform1f(context, location);
    };

    /**
     * ProgramConfiguration contains the logic for binding style layer properties and tile
     * layer feature data into GL program uniforms and vertex attributes.
     *
     * Non-data-driven property values are bound to shader uniforms. Data-driven property
     * values are bound to vertex attributes. In order to support a uniform GLSL syntax over
     * both, [Mapbox GL Shaders](https://github.com/mapbox/mapbox-gl-shaders) defines a `#pragma`
     * abstraction, which ProgramConfiguration is responsible for implementing. At runtime,
     * it examines the attributes of a particular layer, combines this with fixed knowledge
     * about how layers of the particular type are implemented, and determines which uniforms
     * and vertex attributes will be required. It can then substitute the appropriate text
     * into the shader source code, create and link a program, and bind the uniforms and
     * vertex attributes in preparation for drawing.
     *
     * When a vector tile is parsed, this same configuration information is used to
     * populate the attribute buffers needed for data-driven styling using the zoom
     * level and feature property data.
     *
     * @private
     */
    var ProgramConfiguration = function ProgramConfiguration() {
        this.binders = {};
        this.cacheKey = '';
        this._buffers = [];
    };

    ProgramConfiguration.createDynamic = function createDynamic(layer, zoom, filterProperties) {
        var self = new ProgramConfiguration();
        var keys = [];

        for (var property in layer.paint._values) {
            if (!filterProperties(property)) {
                continue;
            }
            var value = layer.paint.get(property);
            if (!(value instanceof PossiblyEvaluatedPropertyValue$1) || !Supports.supportsPropertyExpression(value.property.specification)) {
                continue;
            }
            var names = paintAttributeNames(property, layer.type);
            var type = value.property.specification.type;
            var useIntegerZoom = value.property.useIntegerZoom;
            var isCrossFaded = value.property.specification['property-type'] === 'cross-faded' ||
                value.property.specification['property-type'] === 'cross-faded-data-driven';

            if (isCrossFaded) {
                if (value.value.kind === 'constant') {
                    self.binders[property] = new CrossFadedConstantBinder(value.value.value, names, type);
                    keys.push(("/u_" + property));
                } else {
                    var StructArrayLayout = layoutType(property, type, 'source');
                    self.binders[property] = new CrossFadedCompositeBinder(value.value, names, type, useIntegerZoom, zoom, StructArrayLayout, layer.id);
                    keys.push(("/a_" + property));
                }
            } else if (value.value.kind === 'constant') {
                self.binders[property] = new ConstantBinder(value.value.value, names, type);
                keys.push(("/u_" + property));
            } else if (value.value.kind === 'source') {
                var StructArrayLayout$1 = layoutType(property, type, 'source');
                self.binders[property] = new SourceExpressionBinder(value.value, names, type, StructArrayLayout$1);
                keys.push(("/a_" + property));
            } else {
                var StructArrayLayout$2 = layoutType(property, type, 'composite');
                self.binders[property] = new CompositeExpressionBinder(value.value, names, type, useIntegerZoom, zoom, StructArrayLayout$2);
                keys.push(("/z_" + property));
            }
        }

        self.cacheKey = keys.sort().join('');

        return self;
    };

    ProgramConfiguration.prototype.populatePaintArrays = function populatePaintArrays(newLength, feature, index, imagePositions, formattedSection) {
        for (var property in this.binders) {
            var binder = this.binders[property];
            binder.populatePaintArray(newLength, feature, imagePositions, formattedSection);
        }
    };
    ProgramConfiguration.prototype.setConstantPatternPositions = function setConstantPatternPositions(posTo, posFrom) {
        for (var property in this.binders) {
            var binder = this.binders[property];
            binder.setConstantPatternPositions(posTo, posFrom);
        }
    };

    ProgramConfiguration.prototype.updatePaintArrays = function updatePaintArrays(featureStates, featureMap, vtLayer, layer, imagePositions) {
        var dirty = false;
        for (var id in featureStates) {
            var positions = featureMap.getPositions(+id);

            for (var i = 0, list = positions; i < list.length; i += 1) {
                var pos = list[i];

                var feature = vtLayer.feature(pos.index);

                for (var property in this.binders) {
                    var binder = this.binders[property];
                    if (binder instanceof ConstantBinder || binder instanceof CrossFadedConstantBinder) {
                        continue;
                    }
                    if ((binder   ).expression.isStateDependent === true) {
                        //AHM: Remove after https://github.com/mapbox/mapbox-gl-js/issues/6255
                        var value = layer.paint.get(property);
                        (binder   ).expression = value.value;
                        binder.updatePaintArray(pos.start, pos.end, feature, featureStates[id], imagePositions);
                        dirty = true;
                    }
                }
            }
        }
        return dirty;
    };

    ProgramConfiguration.prototype.defines = function defines() {
        var result = [];
        for (var property in this.binders) {
            result.push.apply(result, this.binders[property].defines());
        }
        return result;
    };

    ProgramConfiguration.prototype.getPaintVertexBuffers = function getPaintVertexBuffers() {
        return this._buffers;
    };

    ProgramConfiguration.prototype.getUniforms = function getUniforms(context, locations) {
        var uniforms = [];
        for (var property in this.binders) {
            var binder = this.binders[property];
            for (var i = 0, list = binder.uniformNames; i < list.length; i += 1) {
                var name = list[i];

                if (locations[name]) {
                    var binding = binder.getBinding(context, locations[name]);
                    uniforms.push({name: name, property: property, binding: binding});
                }
            }
        }
        return uniforms;
    };

    ProgramConfiguration.prototype.setUniforms = function setUniforms(context, binderUniforms, properties, globals) {
        // Uniform state bindings are owned by the Program, but we set them
        // from within the ProgramConfiguraton's binder members.
        for (var i = 0, list = binderUniforms; i < list.length; i += 1) {
            var ref = list[i];
            var name = ref.name;
            var property = ref.property;
            var binding = ref.binding;

            this.binders[property].setUniforms(context, binding, globals, properties.get(property), name);
        }
    };

    ProgramConfiguration.prototype.updatePatternPaintBuffers = function updatePatternPaintBuffers(crossfade) {
        var buffers = [];

        for (var property in this.binders) {
            var binder = this.binders[property];
            if (binder instanceof CrossFadedCompositeBinder) {
                var patternVertexBuffer = crossfade.fromScale === 2 ? binder.zoomInPaintVertexBuffer : binder.zoomOutPaintVertexBuffer;
                if (patternVertexBuffer) {
                    buffers.push(patternVertexBuffer);
                }
            } else if ((binder instanceof SourceExpressionBinder ||
                binder instanceof CompositeExpressionBinder) &&
                binder.paintVertexBuffer
                ) {
                buffers.push(binder.paintVertexBuffer);
            }
        }

        this._buffers = buffers;
    };

    ProgramConfiguration.prototype.upload = function upload(context) {
        for (var property in this.binders) {
            this.binders[property].upload(context);
        }

        var buffers = [];
        for (var property$1 in this.binders) {
            var binder = this.binders[property$1];
            if ((binder instanceof SourceExpressionBinder ||
                binder instanceof CompositeExpressionBinder) &&
                binder.paintVertexBuffer
                ) {
                buffers.push(binder.paintVertexBuffer);
            }
        }
        this._buffers = buffers;
    };

    ProgramConfiguration.prototype.destroy = function destroy() {
        for (var property in this.binders) {
            this.binders[property].destroy();
        }
    };

    function paintAttributeNames(property, type) {
        var attributeNameExceptions = {
            'text-opacity': ['opacity'],
            'icon-opacity': ['opacity'],
            'text-color': ['fill_color'],
            'icon-color': ['fill_color'],
            'text-halo-color': ['halo_color'],
            'icon-halo-color': ['halo_color'],
            'text-halo-blur': ['halo_blur'],
            'icon-halo-blur': ['halo_blur'],
            'text-halo-width': ['halo_width'],
            'icon-halo-width': ['halo_width'],
            'line-gap-width': ['gapwidth'],
            'line-pattern': ['pattern_to', 'pattern_from'],
            'fill-pattern': ['pattern_to', 'pattern_from'],
            'fill-extrusion-pattern': ['pattern_to', 'pattern_from'],
        };

        return attributeNameExceptions[property] ||
            [property.replace((type + "-"), '').replace(/-/g, '_')];
    }

    function getLayoutException(property) {
        var propertyExceptions = {
            'line-pattern': {
                'source': StructArrayLayout8ui16,
                'composite': StructArrayLayout8ui16
            },
            'fill-pattern': {
                'source': StructArrayLayout8ui16,
                'composite': StructArrayLayout8ui16
            },
            'fill-extrusion-pattern': {
                'source': StructArrayLayout8ui16,
                'composite': StructArrayLayout8ui16
            }
        };

        return propertyExceptions[property];
    }

    function layoutType(property, type, binderType) {
        var defaultLayouts = {
            'color': {
                'source': StructArrayLayout2f8,
                'composite': StructArrayLayout4f16
            },
            'number': {
                'source': StructArrayLayout1f4,
                'composite': StructArrayLayout2f8
            }
        };

        var layoutException = getLayoutException(property);
        return  layoutException && layoutException[binderType] ||
            defaultLayouts[type][binderType];
    }

    WebWorkerTransfer.register('ConstantBinder', ConstantBinder);
    WebWorkerTransfer.register('CrossFadedConstantBinder', CrossFadedConstantBinder);
    WebWorkerTransfer.register('SourceExpressionBinder', SourceExpressionBinder);
    WebWorkerTransfer.register('CrossFadedCompositeBinder', CrossFadedCompositeBinder);
    WebWorkerTransfer.register('CompositeExpressionBinder', CompositeExpressionBinder);
    WebWorkerTransfer.register('ProgramConfiguration', ProgramConfiguration, {omit: ['_buffers']});

    var ProgramConfigurationSet = function ProgramConfigurationSet(layoutAttributes, layers, zoom, filterProperties) {
        if (filterProperties === void 0) filterProperties = function () {
            return true;
        };

        this.programConfigurations = {};
        for (var i = 0, list = layers; i < list.length; i += 1) {
            var layer = list[i];

            this.programConfigurations[layer.id] = ProgramConfiguration.createDynamic(layer, zoom, filterProperties);
            this.programConfigurations[layer.id].layoutAttributes = layoutAttributes;
        }
        this.needsUpload = false;
        this._featureMap = new FeaturePositionMap();
        this._bufferOffset = 0;
    };

    ProgramConfigurationSet.prototype.populatePaintArrays = function populatePaintArrays(length, feature, index, imagePositions, formattedSection) {
        for (var key in this.programConfigurations) {
            this.programConfigurations[key].populatePaintArrays(length, feature, index, imagePositions, formattedSection);
        }

        if (feature.id !== undefined) {
            this._featureMap.add(+feature.id, index, this._bufferOffset, length);
        }
        this._bufferOffset = length;

        this.needsUpload = true;
    };

    ProgramConfigurationSet.prototype.updatePaintArrays = function updatePaintArrays(featureStates, vtLayer, layers, imagePositions) {
        for (var i = 0, list = layers; i < list.length; i += 1) {
            var layer = list[i];

            this.needsUpload = this.programConfigurations[layer.id].updatePaintArrays(featureStates, this._featureMap, vtLayer, layer, imagePositions) || this.needsUpload;
        }
    };

    ProgramConfigurationSet.prototype.get = function get(layerId) {
        return this.programConfigurations[layerId];
    };

    ProgramConfigurationSet.prototype.upload = function upload(context) {
        if (!this.needsUpload) {
            return;
        }
        for (var layerId in this.programConfigurations) {
            this.programConfigurations[layerId].upload(context);
        }
        this.needsUpload = false;
    };

    ProgramConfigurationSet.prototype.destroy = function destroy() {
        for (var layerId in this.programConfigurations) {
            this.programConfigurations[layerId].destroy();
        }
    };

    WebWorkerTransfer.register('ProgramConfigurationSet', ProgramConfigurationSet);

    function addPatternDependencies(type, layers, patternFeature, zoom, options) {
        var patterns = options.patternDependencies;
        for (var i = 0, list = layers; i < list.length; i += 1) {
            var layer = list[i];

            var patternProperty = layer.paint.get((type + "-pattern"));

            var patternPropertyValue = patternProperty.value;
            if (patternPropertyValue.kind !== "constant") {
                var min = patternPropertyValue.evaluate({zoom: zoom - 1}, patternFeature, {}, options.availableImages);
                var mid = patternPropertyValue.evaluate({zoom: zoom}, patternFeature, {}, options.availableImages);
                var max = patternPropertyValue.evaluate({zoom: zoom + 1}, patternFeature, {}, options.availableImages);
                min = min && min.name ? min.name : min;
                mid = mid && mid.name ? mid.name : mid;
                max = max && max.name ? max.name : max;
                // add to patternDependencies
                patterns[min] = true;
                patterns[mid] = true;
                patterns[max] = true;

                // save for layout
                patternFeature.patterns[layer.id] = {min: min, mid: mid, max: max};
            }
        }
        return patternFeature;
    }

    var VectorTileFeatureTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];

    var lineLayoutAttributes = createLayout([
        {name: 'a_pos_normal', components: 2, type: 'Int16'},
        {name: 'a_data', components: 4, type: 'Uint8'}
    ], 4);
    var members$3 = lineLayoutAttributes.members;

    // NOTE ON EXTRUDE SCALE:
    // scale the extrusion vector so that the normal length is this value.
    // contains the "texture" normals (-1..1). this is distinct from the extrude
    // normals for line joins, because the x-value remains 0 for the texture
    // normal array, while the extrude normal actually moves the vertex to create
    // the acute/bevelled line join.
    var EXTRUDE_SCALE = 63;

    /*
     * Sharp corners cause dashed lines to tilt because the distance along the line
     * is the same at both the inner and outer corners. To improve the appearance of
     * dashed lines we add extra points near sharp corners so that a smaller part
     * of the line is tilted.
     *
     * COS_HALF_SHARP_CORNER controls how sharp a corner has to be for us to add an
     * extra vertex. The default is 75 degrees.
     *
     * The newly created vertices are placed SHARP_CORNER_OFFSET pixels from the corner.
     */
    var COS_HALF_SHARP_CORNER = Math.cos(75 / 2 * (Math.PI / 180));
    var SHARP_CORNER_OFFSET = 15;

    // Angle per triangle for approximating round line joins.
    var DEG_PER_TRIANGLE = 20;

    // The number of bits that is used to store the line distance in the buffer.
    var LINE_DISTANCE_BUFFER_BITS = 15;

    // We don't have enough bits for the line distance as we'd like to have, so
    // use this value to scale the line distance (in tile units) down to a smaller
    // value. This lets us store longer distances while sacrificing precision.
    var LINE_DISTANCE_SCALE = 1 / 2;

    // The maximum line distance, in tile units, that fits in the buffer.
    var MAX_LINE_DISTANCE = Math.pow(2, LINE_DISTANCE_BUFFER_BITS - 1) / LINE_DISTANCE_SCALE;

    /**
     * @private
     */
    var LineBucket = function LineBucket(options) {
        this.zoom = options.zoom;
        this.overscaling = options.overscaling;
        this.layers = options.layers;
        this.layerIds = this.layers.map(function (layer) {
            return layer.id;
        });
        this.index = options.index;
        this.hasPattern = false;
        this.patternFeatures = [];

        this.layoutVertexArray = new StructArrayLayout2i4ub8();
        this.indexArray = new StructArrayLayout3ui6();
        this.programConfigurations = new ProgramConfigurationSet(members$3, options.layers, options.zoom);
        this.segments = new SegmentVector();

        this.stateDependentLayerIds = this.layers.filter(function (l) {
            return l.isStateDependent();
        }).map(function (l) {
            return l.id;
        });
    };

    LineBucket.prototype.populate = function populate(features, options) {
        //this.hasPattern = hasPattern('line', this.layers, options);
        this.hasPattern = false;
        var lineSortKey = this.layers[0].layout.get('line-sort-key');
        var bucketFeatures = [];

        for (var i = 0, list = features; i < list.length; i += 1) {
            var ref = list[i];
            var feature = ref.feature;
            var index = ref.index;
            var sourceLayerIndex = ref.sourceLayerIndex;

            if (!this.layers[0]._featureFilter(new EvaluationParameters$1(0), feature)) {
                continue;
            }

            var geometry = loadGeometry(feature);
            var sortKey = lineSortKey ?
                lineSortKey.evaluate(feature, {}) :
                undefined;

            var bucketFeature = {
                id: feature.id,
                properties: feature.properties,
                type: feature.type,
                sourceLayerIndex: sourceLayerIndex,
                index: index,
                geometry: geometry,
                patterns: {},
                sortKey: sortKey
            };

            bucketFeatures.push(bucketFeature);
        }

        if (lineSortKey) {
            bucketFeatures.sort(function (a, b) {
                // a.sortKey is always a number when in use
                return ((a.sortKey )    ) - ((b.sortKey )    );
            });
        }

        for (var i$1 = 0, list$1 = bucketFeatures; i$1 < list$1.length; i$1 += 1) {
            var bucketFeature$1 = list$1[i$1];

            var ref$1 = bucketFeature$1;
            var geometry$1 = ref$1.geometry;
            var index$1 = ref$1.index;
            var sourceLayerIndex$1 = ref$1.sourceLayerIndex;

            if (this.hasPattern) {
                var patternBucketFeature = addPatternDependencies('line', this.layers, bucketFeature$1, this.zoom, options);
                // pattern features are added only once the pattern is loaded into the image atlas
                // so are stored during populate until later updated with positions by tile worker in addFeatures
                this.patternFeatures.push(patternBucketFeature);
            } else {
                this.addFeature(bucketFeature$1, geometry$1, index$1, {});
            }

            var feature$1 = features[index$1].feature;
            options.featureIndex.insert(feature$1, geometry$1, index$1, sourceLayerIndex$1, this.index);
        }
    };

    LineBucket.prototype.update = function update(states, vtLayer, imagePositions) {
        if (!this.stateDependentLayers.length) {
            return;
        }
        this.programConfigurations.updatePaintArrays(states, vtLayer, this.stateDependentLayers, imagePositions);
    };

    LineBucket.prototype.addFeatures = function addFeatures(options, imagePositions) {
        for (var i = 0, list = this.patternFeatures; i < list.length; i += 1) {
            var feature = list[i];

            this.addFeature(feature, feature.geometry, feature.index, imagePositions);
        }
    };

    LineBucket.prototype.isEmpty = function isEmpty() {
        return this.layoutVertexArray.length === 0;
    };

    LineBucket.prototype.uploadPending = function uploadPending() {
        return !this.uploaded || this.programConfigurations.needsUpload;
    };

    LineBucket.prototype.upload = function upload(context) {
        if (!this.uploaded) {
            this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, members$3);
            this.indexBuffer = context.createIndexBuffer(this.indexArray);
        }
        this.programConfigurations.upload(context);
        this.uploaded = true;
    };

    LineBucket.prototype.destroy = function destroy() {
        if (!this.layoutVertexBuffer) {
            return;
        }
        this.layoutVertexBuffer.destroy();
        this.indexBuffer.destroy();
        this.programConfigurations.destroy();
        this.segments.destroy();
    };

    LineBucket.prototype.clear = function clear() {
        if (defined.defined(this.layoutVertexArray)) {
            this.layoutVertexArray = null;
        }
        if (defined.defined(this.indexArray)) {
            this.indexArray = null;
        }
    };

    LineBucket.prototype.addFeature = function addFeature(feature, geometry, index, imagePositions) {
        var layout = this.layers[0].layout;
        var join = layout.get('line-join').evaluate(feature, {});
        var cap = layout.get('line-cap');
        var miterLimit = layout.get('line-miter-limit');
        var roundLimit = layout.get('line-round-limit');

        for (var i = 0, list = geometry; i < list.length; i += 1) {
            var line = list[i];

            this.addLine(line, feature, join, cap, miterLimit, roundLimit, index, imagePositions);
        }
    };

    LineBucket.prototype.addLine = function addLine(vertices, feature, join, cap, miterLimit, roundLimit, index, imagePositions) {
        this.distance = 0;
        this.scaledDistance = 0;
        this.totalDistance = 0;

        if (!!feature.properties &&
            feature.properties.hasOwnProperty('mapbox_clip_start') &&
            feature.properties.hasOwnProperty('mapbox_clip_end')) {

            this.clipStart = +feature.properties['mapbox_clip_start'];
            this.clipEnd = +feature.properties['mapbox_clip_end'];

            // Calculate the total distance, in tile units, of this tiled line feature
            for (var i = 0; i < vertices.length - 1; i++) {
                this.totalDistance += vertices[i].dist(vertices[i + 1]);
            }
        }

        var isPolygon = VectorTileFeatureTypes[feature.type] === 'Polygon';

        // If the line has duplicate vertices at the ends, adjust start/length to remove them.
        var len = vertices.length;
        while (len >= 2 && vertices[len - 1].equals(vertices[len - 2])) {
            len--;
        }
        var first = 0;
        while (first < len - 1 && vertices[first].equals(vertices[first + 1])) {
            first++;
        }

        // Ignore invalid geometry.
        if (len < (isPolygon ? 3 : 2)) {
            return;
        }

        if (join === 'bevel') {
            miterLimit = 1.05;
        }

        var sharpCornerOffset = this.overscaling <= 16 ?
            SHARP_CORNER_OFFSET * EXTENT / (512 * this.overscaling) :
            0;

        // we could be more precise, but it would only save a negligible amount of space
        var segment = this.segments.prepareSegment(len * 10, this.layoutVertexArray, this.indexArray);

        var currentVertex;
        var prevVertex = ((undefined )   );
        var nextVertex = ((undefined )   );
        var prevNormal = ((undefined )   );
        var nextNormal = ((undefined )   );

        // the last two vertices added
        this.e1 = this.e2 = -1;

        if (isPolygon) {
            currentVertex = vertices[len - 2];
            nextNormal = vertices[first].sub(currentVertex)._unit()._perp();
        }

        for (var i$1 = first; i$1 < len; i$1++) {

            nextVertex = isPolygon && i$1 === len - 1 ?
                vertices[first + 1] : // if the line is closed, we treat the last vertex like the first
                vertices[i$1 + 1]; // just the next vertex

            // if two consecutive vertices exist, skip the current one
            if (nextVertex && vertices[i$1].equals(nextVertex)) {
                continue;
            }

            if (nextNormal) {
                prevNormal = nextNormal;
            }
            if (currentVertex) {
                prevVertex = currentVertex;
            }

            currentVertex = vertices[i$1];

            // Calculate the normal towards the next vertex in this line. In case
            // there is no next vertex, pretend that the line is continuing straight,
            // meaning that we are just using the previous normal.
            nextNormal = nextVertex ? nextVertex.sub(currentVertex)._unit()._perp() : prevNormal;

            // If we still don't have a previous normal, this is the beginning of a
            // non-closed line, so we're doing a straight "join".
            prevNormal = prevNormal || nextNormal;

            // Determine the normal of the join extrusion. It is the angle bisector
            // of the segments between the previous line and the next line.
            // In the case of 180° angles, the prev and next normals cancel each other out:
            // prevNormal + nextNormal = (0, 0), its magnitude is 0, so the unit vector would be
            // undefined. In that case, we're keeping the joinNormal at (0, 0), so that the cosHalfAngle
            // below will also become 0 and miterLength will become Infinity.
            var joinNormal = prevNormal.add(nextNormal);
            if (joinNormal.x !== 0 || joinNormal.y !== 0) {
                joinNormal._unit();
            }
            /*  joinNormal prevNormal
             *         ↖  ↑
             *            .________. prevVertex
             *            |
             * nextNormal  ←  |  currentVertex
             *            |
             * nextVertex !
             *
             */

            // calculate cosines of the angle (and its half) using dot product
            var cosAngle = prevNormal.x * nextNormal.x + prevNormal.y * nextNormal.y;
            var cosHalfAngle = joinNormal.x * nextNormal.x + joinNormal.y * nextNormal.y;

            // Calculate the length of the miter (the ratio of the miter to the width)
            // as the inverse of cosine of the angle between next and join normals
            var miterLength = cosHalfAngle !== 0 ? 1 / cosHalfAngle : Infinity;

            // approximate angle from cosine
            var approxAngle = 2 * Math.sqrt(2 - 2 * cosHalfAngle);

            var isSharpCorner = cosHalfAngle < COS_HALF_SHARP_CORNER && prevVertex && nextVertex;
            var lineTurnsLeft = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x > 0;

            if (isSharpCorner && i$1 > first) {
                var prevSegmentLength = currentVertex.dist(prevVertex);
                if (prevSegmentLength > 2 * sharpCornerOffset) {
                    var newPrevVertex = currentVertex.sub(currentVertex.sub(prevVertex)._mult(sharpCornerOffset / prevSegmentLength)._round());
                    this.updateDistance(prevVertex, newPrevVertex);
                    this.addCurrentVertex(newPrevVertex, prevNormal, 0, 0, segment);
                    prevVertex = newPrevVertex;
                }
            }

            // The join if a middle vertex, otherwise the cap.
            var middleVertex = prevVertex && nextVertex;
            var currentJoin = middleVertex ? join : isPolygon ? 'butt' : cap;

            if (middleVertex && currentJoin === 'round') {
                if (miterLength < roundLimit) {
                    currentJoin = 'miter';
                } else if (miterLength <= 2) {
                    currentJoin = 'fakeround';
                }
            }

            if (currentJoin === 'miter' && miterLength > miterLimit) {
                currentJoin = 'bevel';
            }

            if (currentJoin === 'bevel') {
                // The maximum extrude length is 128 / 63 = 2 times the width of the line
                // so if miterLength >= 2 we need to draw a different type of bevel here.
                if (miterLength > 2) {
                    currentJoin = 'flipbevel';
                }

                // If the miterLength is really small and the line bevel wouldn't be visible,
                // just draw a miter join to save a triangle.
                if (miterLength < miterLimit) {
                    currentJoin = 'miter';
                }
            }

            // Calculate how far along the line the currentVertex is
            if (prevVertex) {
                this.updateDistance(prevVertex, currentVertex);
            }

            if (currentJoin === 'miter') {

                joinNormal._mult(miterLength);
                this.addCurrentVertex(currentVertex, joinNormal, 0, 0, segment);

            } else if (currentJoin === 'flipbevel') {
                // miter is too big, flip the direction to make a beveled join

                if (miterLength > 100) {
                    // Almost parallel lines
                    joinNormal = nextNormal.mult(-1);

                } else {
                    var bevelLength = miterLength * prevNormal.add(nextNormal).mag() / prevNormal.sub(nextNormal).mag();
                    joinNormal._perp()._mult(bevelLength * (lineTurnsLeft ? -1 : 1));
                }
                this.addCurrentVertex(currentVertex, joinNormal, 0, 0, segment);
                this.addCurrentVertex(currentVertex, joinNormal.mult(-1), 0, 0, segment);

            } else if (currentJoin === 'bevel' || currentJoin === 'fakeround') {
                var offset = -Math.sqrt(miterLength * miterLength - 1);
                var offsetA = lineTurnsLeft ? offset : 0;
                var offsetB = lineTurnsLeft ? 0 : offset;

                // Close previous segment with a bevel
                if (prevVertex) {
                    this.addCurrentVertex(currentVertex, prevNormal, offsetA, offsetB, segment);
                }

                if (currentJoin === 'fakeround') {
                    // The join angle is sharp enough that a round join would be visible.
                    // Bevel joins fill the gap between segments with a single pie slice triangle.
                    // Create a round join by adding multiple pie slices. The join isn't actually round, but
                    // it looks like it is at the sizes we render lines at.

                    // pick the number of triangles for approximating round join by based on the angle between normals
                    var n = Math.round((approxAngle * 180 / Math.PI) / DEG_PER_TRIANGLE);

                    for (var m = 1; m < n; m++) {
                        var t = m / n;
                        if (t !== 0.5) {
                            // approximate spherical interpolation https://observablehq.com/@mourner/approximating-geometric-slerp
                            var t2 = t - 0.5;
                            var A = 1.0904 + cosAngle * (-3.2452 + cosAngle * (3.55645 - cosAngle * 1.43519));
                            var B = 0.848013 + cosAngle * (-1.06021 + cosAngle * 0.215638);
                            t = t + t * t2 * (t - 1) * (A * t2 * t2 + B);
                        }
                        var extrude = nextNormal.sub(prevNormal)._mult(t)._add(prevNormal)._unit()._mult(lineTurnsLeft ? -1 : 1);
                        this.addHalfVertex(currentVertex, extrude.x, extrude.y, false, lineTurnsLeft, 0, segment);
                    }
                }

                if (nextVertex) {
                    // Start next segment
                    this.addCurrentVertex(currentVertex, nextNormal, -offsetA, -offsetB, segment);
                }

            } else if (currentJoin === 'butt') {
                this.addCurrentVertex(currentVertex, joinNormal, 0, 0, segment); // butt cap

            } else if (currentJoin === 'square') {
                var offset$1 = prevVertex ? 1 : -1; // closing or starting square cap
                this.addCurrentVertex(currentVertex, joinNormal, offset$1, offset$1, segment);

            } else if (currentJoin === 'round') {

                if (prevVertex) {
                    // Close previous segment with butt
                    this.addCurrentVertex(currentVertex, prevNormal, 0, 0, segment);

                    // Add round cap or linejoin at end of segment
                    this.addCurrentVertex(currentVertex, prevNormal, 1, 1, segment, true);
                }
                if (nextVertex) {
                    // Add round cap before first segment
                    this.addCurrentVertex(currentVertex, nextNormal, -1, -1, segment, true);

                    // Start next segment with a butt
                    this.addCurrentVertex(currentVertex, nextNormal, 0, 0, segment);
                }
            }

            if (isSharpCorner && i$1 < len - 1) {
                var nextSegmentLength = currentVertex.dist(nextVertex);
                if (nextSegmentLength > 2 * sharpCornerOffset) {
                    var newCurrentVertex = currentVertex.add(nextVertex.sub(currentVertex)._mult(sharpCornerOffset / nextSegmentLength)._round());
                    this.updateDistance(currentVertex, newCurrentVertex);
                    this.addCurrentVertex(newCurrentVertex, nextNormal, 0, 0, segment);
                    currentVertex = newCurrentVertex;
                }
            }
        }

        this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, feature, index, imagePositions);
    };

    /**
     * Add two vertices to the buffers.
     *
     * @param p the line vertex to add buffer vertices for
     * @param normal vertex normal
     * @param endLeft extrude to shift the left vertex along the line
     * @param endRight extrude to shift the left vertex along the line
     * @param segment the segment object to add the vertex to
     * @param round whether this is a round cap
     * @private
     */
    LineBucket.prototype.addCurrentVertex = function addCurrentVertex(p, normal, endLeft, endRight, segment, round) {
        if (round === void 0) round = false;

        // left and right extrude vectors, perpendicularly shifted by endLeft/endRight
        var leftX = normal.x + normal.y * endLeft;
        var leftY = normal.y - normal.x * endLeft;
        var rightX = -normal.x + normal.y * endRight;
        var rightY = -normal.y - normal.x * endRight;

        this.addHalfVertex(p, leftX, leftY, round, false, endLeft, segment);
        this.addHalfVertex(p, rightX, rightY, round, true, -endRight, segment);

        // There is a maximum "distance along the line" that we can store in the buffers.
        // When we get close to the distance, reset it to zero and add the vertex again with
        // a distance of zero. The max distance is determined by the number of bits we allocate
        // to `linesofar`.
        if (this.distance > MAX_LINE_DISTANCE / 2 && this.totalDistance === 0) {
            this.distance = 0;
            this.addCurrentVertex(p, normal, endLeft, endRight, segment, round);
        }
    };

    LineBucket.prototype.addHalfVertex = function addHalfVertex(ref, extrudeX, extrudeY, round, up, dir, segment) {
        var x = ref.x;
        var y = ref.y;

        // scale down so that we can store longer distances while sacrificing precision.
        var linesofar = this.scaledDistance * LINE_DISTANCE_SCALE;

        this.layoutVertexArray.emplaceBack(
            // a_pos_normal
            // Encode round/up the least significant bits
            (x << 1) + (round ? 1 : 0),
            (y << 1) + (up ? 1 : 0),
            // a_data
            // add 128 to store a byte in an unsigned byte
            Math.round(EXTRUDE_SCALE * extrudeX) + 128,
            Math.round(EXTRUDE_SCALE * extrudeY) + 128,
            // Encode the -1/0/1 direction value into the first two bits of .z of a_data.
            // Combine it with the lower 6 bits of `linesofar` (shifted by 2 bites to make
            // room for the direction value). The upper 8 bits of `linesofar` are placed in
            // the `w` component.
            ((dir === 0 ? 0 : (dir < 0 ? -1 : 1)) + 1) | ((linesofar & 0x3F) << 2),
            linesofar >> 6);

        var e = segment.vertexLength++;
        if (this.e1 >= 0 && this.e2 >= 0) {
            this.indexArray.emplaceBack(this.e1, this.e2, e);
            segment.primitiveLength++;
        }
        if (up) {
            this.e2 = e;
        } else {
            this.e1 = e;
        }
    };

    LineBucket.prototype.updateDistance = function updateDistance(prev, next) {
        this.distance += prev.dist(next);

        // Knowing the ratio of the full linestring covered by this tiled feature, as well
        // as the total distance (in tile units) of this tiled feature, and the distance
        // (in tile units) of the current vertex, we can determine the relative distance
        // of this vertex along the full linestring feature and scale it to [0, 2^15)
        this.scaledDistance = this.totalDistance > 0 ?
            (this.clipStart + (this.clipEnd - this.clipStart) * this.distance / this.totalDistance) * (MAX_LINE_DISTANCE - 1) :
            this.distance;
    };

    WebWorkerTransfer.register('LineBucket', LineBucket, {omit: ['layers', 'patternFeatures']});

    function quickselect(arr, k, left, right, compare) {
        quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare);
    }
    function quickselectStep(arr, k, left, right, compare) {

        while (right > left) {
            if (right - left > 600) {
                var n = right - left + 1;
                var m = k - left + 1;
                var z = Math.log(n);
                var s = 0.5 * Math.exp(2 * z / 3);
                var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
                var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
                var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
                quickselectStep(arr, k, newLeft, newRight, compare);
            }

            var t = arr[k];
            var i = left;
            var j = right;

            swap$1(arr, left, k);
            if (compare(arr[right], t) > 0) swap$1(arr, left, right);

            while (i < j) {
                swap$1(arr, i, j);
                i++;
                j--;
                while (compare(arr[i], t) < 0) i++;
                while (compare(arr[j], t) > 0) j--;
            }

            if (compare(arr[left], t) === 0) swap$1(arr, left, j);
            else {
                j++;
                swap$1(arr, j, right);
            }

            if (j <= k) left = j + 1;
            if (k <= j) right = j - 1;
        }
    }

    function swap$1(arr, i, j) {
        var tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    function defaultCompare(a, b) {
        return a < b ? -1 : a > b ? 1 : 0;
    }

    /**
     * Returns the signed area for the polygon ring.  Postive areas are exterior rings and
     * have a clockwise winding.  Negative areas are interior rings and have a counter clockwise
     * ordering.
     *
     * @private
     * @param ring Exterior or interior ring
     */
    function calculateSignedArea(ring) {
        var sum = 0;
        for (var i = 0, len = ring.length, j = len - 1, p1 = (void 0), p2 = (void 0); i < len; j = i++) {
            p1 = ring[i];
            p2 = ring[j];
            sum += (p2.x - p1.x) * (p1.y + p2.y);
        }
        return sum;
    }

    // classifies an array of rings into polygons with outer rings and holes
    function classifyRings(rings, maxRings) {
        var len = rings.length;

        if (len <= 1) {
            return [rings];
        }

        var polygons = [];
        var polygon,
            ccw;

        for (var i = 0; i < len; i++) {
            var area = calculateSignedArea(rings[i]);
            if (area === 0) {
                continue;
            }

            (rings[i]     ).area = Math.abs(area);

            if (ccw === undefined) {
                ccw = area < 0;
            }

            if (ccw === area < 0) {
                if (polygon) {
                    polygons.push(polygon);
                }
                polygon = [rings[i]];

            } else {
                (polygon     ).push(rings[i]);
            }
        }
        if (polygon) {
            polygons.push(polygon);
        }

        // Earcut performance degrades with the # of rings in a polygon. For this
        // reason, we limit strip out all but the `maxRings` largest rings.
        if (maxRings > 1) {
            for (var j = 0; j < polygons.length; j++) {
                if (polygons[j].length <= maxRings) {
                    continue;
                }
                quickselect(polygons[j], maxRings, 1, polygons[j].length - 1, compareAreas);
                polygons[j] = polygons[j].slice(0, maxRings);
            }
        }

        return polygons;
    }

    function compareAreas(a, b) {
        return b.area - a.area;
    }

    var StructArrayLayout2i4 = /*@__PURE__*/(function (StructArray) {
        function StructArrayLayout2i4() {
            StructArray.apply(this, arguments);
        }

        if (StructArray) StructArrayLayout2i4.__proto__ = StructArray;
        StructArrayLayout2i4.prototype = Object.create(StructArray && StructArray.prototype);
        StructArrayLayout2i4.prototype.constructor = StructArrayLayout2i4;

        StructArrayLayout2i4.prototype._refreshViews = function _refreshViews() {
            this.uint8 = new Uint8Array(this.arrayBuffer);
            this.int16 = new Int16Array(this.arrayBuffer);
        };

        StructArrayLayout2i4.prototype.emplaceBack = function emplaceBack(v0, v1) {
            var i = this.length;
            this.resize(i + 1);
            return this.emplace(i, v0, v1);
        };

        StructArrayLayout2i4.prototype.emplace = function emplace(i, v0, v1) {
            var o2 = i * 2;
            this.int16[o2 + 0] = v0;
            this.int16[o2 + 1] = v1;
            return i;
        };

        return StructArrayLayout2i4;
    }(StructArray));

    StructArrayLayout2i4.prototype.bytesPerElement = 4;
    WebWorkerTransfer.register('StructArrayLayout2i4', StructArrayLayout2i4);

    var StructArrayLayout2ui4 = /*@__PURE__*/(function (StructArray) {
        function StructArrayLayout2ui4() {
            StructArray.apply(this, arguments);
        }

        if (StructArray) StructArrayLayout2ui4.__proto__ = StructArray;
        StructArrayLayout2ui4.prototype = Object.create(StructArray && StructArray.prototype);
        StructArrayLayout2ui4.prototype.constructor = StructArrayLayout2ui4;

        StructArrayLayout2ui4.prototype._refreshViews = function _refreshViews() {
            this.uint8 = new Uint8Array(this.arrayBuffer);
            this.uint16 = new Uint16Array(this.arrayBuffer);
        };

        StructArrayLayout2ui4.prototype.emplaceBack = function emplaceBack(v0, v1) {
            var i = this.length;
            this.resize(i + 1);
            return this.emplace(i, v0, v1);
        };

        StructArrayLayout2ui4.prototype.emplace = function emplace(i, v0, v1) {
            var o2 = i * 2;
            this.uint16[o2 + 0] = v0;
            this.uint16[o2 + 1] = v1;
            return i;
        };

        return StructArrayLayout2ui4;
    }(StructArray));

    StructArrayLayout2ui4.prototype.bytesPerElement = 4;
    WebWorkerTransfer.register('StructArrayLayout2ui4', StructArrayLayout2ui4);

    function hasPattern(type, layers, options) {
        var patterns = options.patternDependencies;
        var hasPattern = false;

        for (var i = 0, list = layers; i < list.length; i += 1) {
            var layer = list[i];

            var patternProperty = layer.paint.get((type + "-pattern"));
            if (!patternProperty.isConstant()) {
                hasPattern = true;
            }

            var constantPattern = patternProperty.constantOr(null);
            if (constantPattern) {
                hasPattern = true;
                patterns[constantPattern.to] = true;
                patterns[constantPattern.from] = true;
            }
        }

        return hasPattern;
    }

    // Copyright 2010 The Emscripten Authors.  All rights reserved.
    // Emscripten is available under two separate licenses, the MIT license and the
    // University of Illinois/NCSA Open Source License.  Both these licenses can be
    // found in the LICENSE file.

    // The Module object: Our interface to the outside world. We import
    // and export values on it. There are various ways Module can be used:
    // 1. Not defined. We create it here
    // 2. A function parameter, function(Module) { ..generated code.. }
    // 3. pre-run appended it, var Module = {}; ..generated code..
    // 4. External script tag defines var Module.
    // We need to check if Module already exists (e.g. case 3 above).
    // Substitution will be replaced with actual code on later stage of the build,
    // this way Closure Compiler will not mangle it (e.g. case 4. above).
    // Note that if you want to run closure, and also to use Module
    // after the generated code, you will need to define   var Module = {};
    // before the code. Then that object will be used in the code, and you
    // can continue to use Module afterwards as well.
    if (typeof WebAssembly !== 'undefined') {
    	var Module = typeof Module !== 'undefined' ? Module : {};

    	// --pre-jses are emitted after the Module integration code, so that they can
    	// refer to Module (if they choose; they can also define Module)
    	// {{PRE_JSES}}

    	// Sometimes an existing Module object exists with properties
    	// meant to overwrite the default module functionality. Here
    	// we collect those properties and reapply _after_ we configure
    	// the current environment's defaults to avoid having to be so
    	// defensive during initialization.
    	var moduleOverrides = {};
    	var key;
    	for (key in Module) {
    	  if (Module.hasOwnProperty(key)) {
    		moduleOverrides[key] = Module[key];
    	  }
    	}

    	Module['arguments'] = [];
    	Module['thisProgram'] = './this.program';
    	Module['quit'] = function(status, toThrow) {
    	  throw toThrow;
    	};
    	Module['preRun'] = [];
    	Module['postRun'] = [];

    	// Determine the runtime environment we are in. You can customize this by
    	// setting the ENVIRONMENT setting at compile time (see settings.js).

    	var ENVIRONMENT_IS_WEB = false;
    	var ENVIRONMENT_IS_WORKER = false;
    	var ENVIRONMENT_IS_NODE = false;
    	var ENVIRONMENT_HAS_NODE = false;
    	var ENVIRONMENT_IS_SHELL = false;
    	ENVIRONMENT_IS_WEB = typeof window === 'object';
    	ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
    	// A web environment like Electron.js can have Node enabled, so we must
    	// distinguish between Node-enabled environments and Node environments per se.
    	// This will allow the former to do things like mount NODEFS.
    	ENVIRONMENT_HAS_NODE = typeof process === 'object' && typeof require === 'function';
    	ENVIRONMENT_IS_NODE = ENVIRONMENT_HAS_NODE && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
    	ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;

    	if (Module['ENVIRONMENT']) {
    	  throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -s ENVIRONMENT=web or -s ENVIRONMENT=node)');
    	}


    	// Three configurations we can be running in:
    	// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false)
    	// 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false)
    	// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true)




    	// `/` should be present at the end if `scriptDirectory` is not empty
    	var scriptDirectory = '';
    	function locateFile(path) {
    	  if (Module['locateFile']) {
    		return Module['locateFile'](path, scriptDirectory);
    	  } else {
    		return scriptDirectory + path;
    	  }
    	}

    	if (ENVIRONMENT_IS_NODE) {
    	  scriptDirectory = __dirname + '/';

    	  // Expose functionality in the same simple way that the shells work
    	  // Note that we pollute the global namespace here, otherwise we break in node
    	  var nodeFS;
    	  var nodePath;

    	  Module['read'] = function shell_read(filename, binary) {
    		var ret;
    		  if (!nodeFS) nodeFS = require('fs');
    		  if (!nodePath) nodePath = require('path');
    		  filename = nodePath['normalize'](filename);
    		  ret = nodeFS['readFileSync'](filename);
    		return binary ? ret : ret.toString();
    	  };

    	  Module['readBinary'] = function readBinary(filename) {
    		var ret = Module['read'](filename, true);
    		if (!ret.buffer) {
    		  ret = new Uint8Array(ret);
    		}
    		assert(ret.buffer);
    		return ret;
    	  };

    	  if (process['argv'].length > 1) {
    		Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/');
    	  }

    	  Module['arguments'] = process['argv'].slice(2);

    	  if (typeof module !== 'undefined') {
    		module['exports'] = Module;
    	  }

    	  process['on']('uncaughtException', function(ex) {
    		// suppress ExitStatus exceptions from showing an error
    		if (!(ex instanceof ExitStatus)) {
    		  throw ex;
    		}
    	  });
    	  // Currently node will swallow unhandled rejections, but this behavior is
    	  // deprecated, and in the future it will exit with error status.
    	  process['on']('unhandledRejection', abort);

    	  Module['quit'] = function(status) {
    		process['exit'](status);
    	  };

    	  Module['inspect'] = function () { return '[Emscripten Module object]'; };
    	} else
    	if (ENVIRONMENT_IS_SHELL) {


    	  if (typeof read != 'undefined') {
    		Module['read'] = function shell_read(f) {
    		  return read(f);
    		};
    	  }

    	  Module['readBinary'] = function readBinary(f) {
    		var data;
    		if (typeof readbuffer === 'function') {
    		  return new Uint8Array(readbuffer(f));
    		}
    		data = read(f, 'binary');
    		assert(typeof data === 'object');
    		return data;
    	  };

    	  if (typeof scriptArgs != 'undefined') {
    		Module['arguments'] = scriptArgs;
    	  } else if (typeof arguments != 'undefined') {
    		Module['arguments'] = arguments;
    	  }

    	  if (typeof quit === 'function') {
    		Module['quit'] = function(status) {
    		  quit(status);
    		};
    	  }
    	} else
    	if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
    	  if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled
    		scriptDirectory = self.location.href;
    	  } else if (document.currentScript) { // web
    		scriptDirectory = document.currentScript.src;
    	  }
    	  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
    	  // otherwise, slice off the final part of the url to find the script directory.
    	  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
    	  // and scriptDirectory will correctly be replaced with an empty string.
    	  if (scriptDirectory.indexOf('blob:') !== 0) {
    		scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1);
    	  } else {
    		scriptDirectory = '';
    	  }


    	  Module['read'] = function shell_read(url) {
    		  var xhr = new XMLHttpRequest();
    		  xhr.open('GET', url, false);
    		  xhr.send(null);
    		  return xhr.responseText;
    	  };

    	  if (ENVIRONMENT_IS_WORKER) {
    		Module['readBinary'] = function readBinary(url) {
    			var xhr = new XMLHttpRequest();
    			xhr.open('GET', url, false);
    			xhr.responseType = 'arraybuffer';
    			xhr.send(null);
    			return new Uint8Array(xhr.response);
    		};
    	  }

    	  Module['readAsync'] = function readAsync(url, onload, onerror) {
    		var xhr = new XMLHttpRequest();
    		xhr.open('GET', url, true);
    		xhr.responseType = 'arraybuffer';
    		xhr.onload = function xhr_onload() {
    		  if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
    			onload(xhr.response);
    			return;
    		  }
    		  onerror();
    		};
    		xhr.onerror = onerror;
    		xhr.send(null);
    	  };

    	  Module['setWindowTitle'] = function(title) { document.title = title; };
    	} else
    	{
    	  throw new Error('environment detection error');
    	}

    	// Set up the out() and err() hooks, which are how we can print to stdout or
    	// stderr, respectively.
    	// If the user provided Module.print or printErr, use that. Otherwise,
    	// console.log is checked first, as 'print' on the web will open a print dialogue
    	// printErr is preferable to console.warn (works better in shells)
    	// bind(console) is necessary to fix IE/Edge closed dev tools panel behavior.
    	var out = Module['print'] || (typeof console !== 'undefined' ? console.log.bind(console) : (typeof print !== 'undefined' ? print : null));
    	var err = Module['printErr'] || (typeof printErr !== 'undefined' ? printErr : ((typeof console !== 'undefined' && console.warn.bind(console)) || out));

    	// Merge back in the overrides
    	for (key in moduleOverrides) {
    	  if (moduleOverrides.hasOwnProperty(key)) {
    		Module[key] = moduleOverrides[key];
    	  }
    	}
    	// Free the object hierarchy contained in the overrides, this lets the GC
    	// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
    	moduleOverrides = undefined;

    	// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
    	assert(typeof Module['memoryInitializerPrefixURL'] === 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');
    	assert(typeof Module['pthreadMainPrefixURL'] === 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');
    	assert(typeof Module['cdInitializerPrefixURL'] === 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');
    	assert(typeof Module['filePackagePrefixURL'] === 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');

    	// stack management, and other functionality that is provided by the compiled code,
    	// should not be used before it is ready
    	stackSave = stackRestore = stackAlloc = function() {
    	  abort('cannot use the stack before compiled code is ready to run, and has provided stack access');
    	};

    	function warnOnce(text) {
    	  if (!warnOnce.shown) warnOnce.shown = {};
    	  if (!warnOnce.shown[text]) {
    		warnOnce.shown[text] = 1;
    		//err(text);
    	  }
    	}

    	var asm2wasmImports = { // special asm2wasm imports
    		"f64-rem": function(x, y) {
    			return x % y;
    		},
    		"debugger": function() {
    			debugger;
    		}
    	};
    	var functionPointers = new Array(0);

    	var tempRet0 = 0;

    	var setTempRet0 = function(value) {
    	  tempRet0 = value;
    	};

    	var getTempRet0 = function() {
    	  return tempRet0;
    	};




    	// === Preamble library stuff ===

    	// Documentation for the public APIs defined in this file must be updated in:
    	//    site/source/docs/api_reference/preamble.js.rst
    	// A prebuilt local version of the documentation is available at:
    	//    site/build/text/docs/api_reference/preamble.js.txt
    	// You can also build docs locally as HTML or other formats in site/
    	// An online HTML version (which may be of a different version of Emscripten)
    	//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html



    	if (typeof WebAssembly !== 'object') {
    	  abort('No WebAssembly support found. Build with -s WASM=0 to target JavaScript instead.');
    	}

    	/** @type {function(number, string, boolean=)} */
    	function getValue(ptr, type, noSafe) {
    	  type = type || 'i8';
    	  if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
    		switch(type) {
    		  case 'i1': return HEAP8[((ptr)>>0)];
    		  case 'i8': return HEAP8[((ptr)>>0)];
    		  case 'i16': return HEAP16[((ptr)>>1)];
    		  case 'i32': return HEAP32[((ptr)>>2)];
    		  case 'i64': return HEAP32[((ptr)>>2)];
    		  case 'float': return HEAPF32[((ptr)>>2)];
    		  case 'double': return HEAPF64[((ptr)>>3)];
    		  default: abort('invalid type for getValue: ' + type);
    		}
    	  return null;
    	}





    	// Wasm globals

    	var wasmMemory;

    	// Potentially used for direct table calls.
    	var wasmTable;


    	//========================================
    	// Runtime essentials
    	//========================================

    	// whether we are quitting the application. no code should run after this.
    	// set in exit() and abort()
    	var ABORT = false;

    	/** @type {function(*, string=)} */
    	function assert(condition, text) {
    	  if (!condition) {
    		abort('Assertion failed: ' + text);
    	  }
    	}

    	// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
    	function getCFunc(ident) {
    	  var func = Module['_' + ident]; // closure exported function
    	  assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported');
    	  return func;
    	}

    	// C calling interface.
    	function ccall(ident, returnType, argTypes, args, opts) {
    	  // For fast lookup of conversion functions
    	  var toC = {
    		'string': function(str) {
    		  var ret = 0;
    		  if (str !== null && str !== undefined && str !== 0) { // null string
    			// at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
    			var len = (str.length << 2) + 1;
    			ret = stackAlloc(len);
    			stringToUTF8(str, ret, len);
    		  }
    		  return ret;
    		},
    		'array': function(arr) {
    		  var ret = stackAlloc(arr.length);
    		  writeArrayToMemory(arr, ret);
    		  return ret;
    		}
    	  };

    	  function convertReturnValue(ret) {
    		if (returnType === 'string') return UTF8ToString(ret);
    		if (returnType === 'boolean') return Boolean(ret);
    		return ret;
    	  }

    	  var func = getCFunc(ident);
    	  var cArgs = [];
    	  var stack = 0;
    	  assert(returnType !== 'array', 'Return type should not be "array".');
    	  if (args) {
    		for (var i = 0; i < args.length; i++) {
    		  var converter = toC[argTypes[i]];
    		  if (converter) {
    			if (stack === 0) stack = stackSave();
    			cArgs[i] = converter(args[i]);
    		  } else {
    			cArgs[i] = args[i];
    		  }
    		}
    	  }
    	  var ret = func.apply(null, cArgs);
    	  ret = convertReturnValue(ret);
    	  if (stack !== 0) stackRestore(stack);
    	  return ret;
    	}

    	function cwrap(ident, returnType, argTypes, opts) {
    	  return function() {
    		return ccall(ident, returnType, argTypes, arguments);
    	  }
    	}


    	// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
    	// a copy of that string as a Javascript String object.

    	var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined;

    	/**
    	 * @param {number} idx
    	 * @param {number=} maxBytesToRead
    	 * @return {string}
    	 */
    	function UTF8ArrayToString(u8Array, idx, maxBytesToRead) {
    	  var endIdx = idx + maxBytesToRead;
    	  var endPtr = idx;
    	  // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
    	  // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
    	  // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity)
    	  while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr;

    	  if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
    		return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
    	  } else {
    		var str = '';
    		// If building with TextDecoder, we have already computed the string length above, so test loop end condition against that
    		while (idx < endPtr) {
    		  // For UTF8 byte structure, see:
    		  // http://en.wikipedia.org/wiki/UTF-8#Description
    		  // https://www.ietf.org/rfc/rfc2279.txt
    		  // https://tools.ietf.org/html/rfc3629
    		  var u0 = u8Array[idx++];
    		  if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
    		  var u1 = u8Array[idx++] & 63;
    		  if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
    		  var u2 = u8Array[idx++] & 63;
    		  if ((u0 & 0xF0) == 0xE0) {
    			u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
    		  } else {
    			if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte 0x' + u0.toString(16) + ' encountered when deserializing a UTF-8 string on the asm.js/wasm heap to a JS string!');
    			u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (u8Array[idx++] & 63);
    		  }

    		  if (u0 < 0x10000) {
    			str += String.fromCharCode(u0);
    		  } else {
    			var ch = u0 - 0x10000;
    			str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
    		  }
    		}
    	  }
    	  return str;
    	}

    	// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a
    	// copy of that string as a Javascript String object.
    	// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit
    	//                 this parameter to scan the string until the first \0 byte. If maxBytesToRead is
    	//                 passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the
    	//                 middle, then the string will cut short at that byte index (i.e. maxBytesToRead will
    	//                 not produce a string of exact length [ptr, ptr+maxBytesToRead[)
    	//                 N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may
    	//                 throw JS JIT optimizations off, so it is worth to consider consistently using one
    	//                 style or the other.
    	/**
    	 * @param {number} ptr
    	 * @param {number=} maxBytesToRead
    	 * @return {string}
    	 */
    	function UTF8ToString(ptr, maxBytesToRead) {
    	  return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
    	}

    	// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',
    	// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.
    	// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
    	// Parameters:
    	//   str: the Javascript string to copy.
    	//   outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element.
    	//   outIdx: The starting offset in the array to begin the copying.
    	//   maxBytesToWrite: The maximum number of bytes this function can write to the array.
    	//                    This count should include the null terminator,
    	//                    i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.
    	//                    maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.
    	// Returns the number of bytes written, EXCLUDING the null terminator.

    	function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
    	  if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.
    		return 0;

    	  var startIdx = outIdx;
    	  var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
    	  for (var i = 0; i < str.length; ++i) {
    		// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
    		// See http://unicode.org/faq/utf_bom.html#utf16-3
    		// For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629
    		var u = str.charCodeAt(i); // possibly a lead surrogate
    		if (u >= 0xD800 && u <= 0xDFFF) {
    		  var u1 = str.charCodeAt(++i);
    		  u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
    		}
    		if (u <= 0x7F) {
    		  if (outIdx >= endIdx) break;
    		  outU8Array[outIdx++] = u;
    		} else if (u <= 0x7FF) {
    		  if (outIdx + 1 >= endIdx) break;
    		  outU8Array[outIdx++] = 0xC0 | (u >> 6);
    		  outU8Array[outIdx++] = 0x80 | (u & 63);
    		} else if (u <= 0xFFFF) {
    		  if (outIdx + 2 >= endIdx) break;
    		  outU8Array[outIdx++] = 0xE0 | (u >> 12);
    		  outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
    		  outU8Array[outIdx++] = 0x80 | (u & 63);
    		} else {
    		  if (outIdx + 3 >= endIdx) break;
    		  if (u >= 0x200000) warnOnce('Invalid Unicode code point 0x' + u.toString(16) + ' encountered when serializing a JS string to an UTF-8 string on the asm.js/wasm heap! (Valid unicode code points should be in range 0-0x1FFFFF).');
    		  outU8Array[outIdx++] = 0xF0 | (u >> 18);
    		  outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);
    		  outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
    		  outU8Array[outIdx++] = 0x80 | (u & 63);
    		}
    	  }
    	  // Null-terminate the pointer to the buffer.
    	  outU8Array[outIdx] = 0;
    	  return outIdx - startIdx;
    	}

    	// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
    	// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.
    	// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
    	// Returns the number of bytes written, EXCLUDING the null terminator.

    	function stringToUTF8(str, outPtr, maxBytesToWrite) {
    	  assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');
    	  return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);
    	}


    	// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
    	// a copy of that string as a Javascript String object.

    	var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined;

    	function writeArrayToMemory(array, buffer) {
    	  assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)');
    	  HEAP8.set(array, buffer);
    	}





    	function demangle(func) {
    	  return func;
    	}

    	function demangleAll(text) {
    	  var regex =
    		/__Z[\w\d_]+/g;
    	  return text.replace(regex,
    		function(x) {
    		  var y = demangle(x);
    		  return x === y ? x : (y + ' [' + x + ']');
    		});
    	}

    	function jsStackTrace() {
    	  var err = new Error();
    	  if (!err.stack) {
    		// IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,
    		// so try that as a special-case.
    		try {
    		  throw new Error(0);
    		} catch(e) {
    		  err = e;
    		}
    		if (!err.stack) {
    		  return '(no stack trace available)';
    		}
    	  }
    	  return err.stack.toString();
    	}

    	function stackTrace() {
    	  var js = jsStackTrace();
    	  if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace']();
    	  return demangleAll(js);
    	}
    	var WASM_PAGE_SIZE = 65536;

    	function alignUp(x, multiple) {
    	  if (x % multiple > 0) {
    		x += multiple - (x % multiple);
    	  }
    	  return x;
    	}

    	var /** @type {ArrayBuffer} */
    	  buffer,
    	/** @type {Int8Array} */
    	  HEAP8,
    	/** @type {Uint8Array} */
    	  HEAPU8,
    	/** @type {Int16Array} */
    	  HEAP16,
    	/** @type {Uint16Array} */
    	  HEAPU16,
    	/** @type {Int32Array} */
    	  HEAP32,
    	/** @type {Uint32Array} */
    	  HEAPU32,
    	/** @type {Float32Array} */
    	  HEAPF32,
    	/** @type {Float64Array} */
    	  HEAPF64;

    	function updateGlobalBufferViews() {
    	  Module['HEAP8'] = HEAP8 = new Int8Array(buffer);
    	  Module['HEAP16'] = HEAP16 = new Int16Array(buffer);
    	  Module['HEAP32'] = HEAP32 = new Int32Array(buffer);
    	  Module['HEAPU8'] = HEAPU8 = new Uint8Array(buffer);
    	  Module['HEAPU16'] = HEAPU16 = new Uint16Array(buffer);
    	  Module['HEAPU32'] = HEAPU32 = new Uint32Array(buffer);
    	  Module['HEAPF32'] = HEAPF32 = new Float32Array(buffer);
    	  Module['HEAPF64'] = HEAPF64 = new Float64Array(buffer);
    	}


    	var STACK_BASE = 5872,
    		STACK_MAX = 5248752,
    		DYNAMIC_BASE = 5248752,
    		DYNAMICTOP_PTR = 5840;

    	assert(STACK_BASE % 16 === 0, 'stack must start aligned');
    	assert(DYNAMIC_BASE % 16 === 0, 'heap must start aligned');



    	var TOTAL_STACK = 5242880;
    	if (Module['TOTAL_STACK']) assert(TOTAL_STACK === Module['TOTAL_STACK'], 'the stack size can no longer be determined at runtime');

    	var INITIAL_TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216;
    	if (INITIAL_TOTAL_MEMORY < TOTAL_STACK) err('TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + INITIAL_TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')');

    	// Initialize the runtime's memory
    	// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
    	assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray !== undefined && Int32Array.prototype.set !== undefined,
    		   'JS engine does not provide full typed array support');







    	// Use a provided buffer, if there is one, or else allocate a new one
    	if (Module['buffer']) {
    	  buffer = Module['buffer'];
    	  assert(buffer.byteLength === INITIAL_TOTAL_MEMORY, 'provided buffer should be ' + INITIAL_TOTAL_MEMORY + ' bytes, but it is ' + buffer.byteLength);
    	} else {
    	  // Use a WebAssembly memory where available
    	  if (typeof WebAssembly === 'object' && typeof WebAssembly.Memory === 'function') {
    		assert(INITIAL_TOTAL_MEMORY % WASM_PAGE_SIZE === 0);
    		wasmMemory = new WebAssembly.Memory({ 'initial': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE });
    		buffer = wasmMemory.buffer;
    	  } else
    	  {
    		buffer = new ArrayBuffer(INITIAL_TOTAL_MEMORY);
    	  }
    	  assert(buffer.byteLength === INITIAL_TOTAL_MEMORY);
    	}
    	updateGlobalBufferViews();


    	HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE;


    	// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
    	function writeStackCookie() {
    	  assert((STACK_MAX & 3) == 0);
    	  HEAPU32[(STACK_MAX >> 2)-1] = 0x02135467;
    	  HEAPU32[(STACK_MAX >> 2)-2] = 0x89BACDFE;
    	}

    	function checkStackCookie() {
    	  if (HEAPU32[(STACK_MAX >> 2)-1] != 0x02135467 || HEAPU32[(STACK_MAX >> 2)-2] != 0x89BACDFE) {
    		abort('Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x02135467, but received 0x' + HEAPU32[(STACK_MAX >> 2)-2].toString(16) + ' ' + HEAPU32[(STACK_MAX >> 2)-1].toString(16));
    	  }
    	  // Also test the global address 0 for integrity.
    	  if (HEAP32[0] !== 0x63736d65 /* 'emsc' */) abort('Runtime error: The application has corrupted its heap memory area (address zero)!');
    	}

    	function abortStackOverflow(allocSize) {
    	  abort('Stack overflow! Attempted to allocate ' + allocSize + ' bytes on the stack, but stack has only ' + (STACK_MAX - stackSave() + allocSize) + ' bytes available!');
    	}


    	  HEAP32[0] = 0x63736d65; /* 'emsc' */



    	// Endianness check (note: assumes compiler arch was little-endian)
    	HEAP16[1] = 0x6373;
    	if (HEAPU8[2] !== 0x73 || HEAPU8[3] !== 0x63) throw 'Runtime error: expected the system to be little-endian!';

    	function callRuntimeCallbacks(callbacks) {
    	  while(callbacks.length > 0) {
    		var callback = callbacks.shift();
    		if (typeof callback == 'function') {
    		  callback();
    		  continue;
    		}
    		var func = callback.func;
    		if (typeof func === 'number') {
    		  if (callback.arg === undefined) {
    			Module['dynCall_v'](func);
    		  } else {
    			Module['dynCall_vi'](func, callback.arg);
    		  }
    		} else {
    		  func(callback.arg === undefined ? null : callback.arg);
    		}
    	  }
    	}

    	var __ATPRERUN__  = []; // functions called before the runtime is initialized
    	var __ATINIT__    = []; // functions called during startup
    	var __ATMAIN__    = []; // functions called when main() is to be run
    	var __ATPOSTRUN__ = []; // functions called after the main() is called

    	var runtimeInitialized = false;
    	var runtimeExited = false;


    	function preRun() {
    	  // compatibility - merge in anything from Module['preRun'] at this time
    	  if (Module['preRun']) {
    		if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
    		while (Module['preRun'].length) {
    		  addOnPreRun(Module['preRun'].shift());
    		}
    	  }
    	  callRuntimeCallbacks(__ATPRERUN__);
    	}

    	function ensureInitRuntime() {
    	  checkStackCookie();
    	  if (runtimeInitialized) return;
    	  runtimeInitialized = true;
    	  
    	  callRuntimeCallbacks(__ATINIT__);
    	}

    	function preMain() {
    	  checkStackCookie();
    	  
    	  callRuntimeCallbacks(__ATMAIN__);
    	}

    	function postRun() {
    	  checkStackCookie();
    	  // compatibility - merge in anything from Module['postRun'] at this time
    	  if (Module['postRun']) {
    		if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
    		while (Module['postRun'].length) {
    		  addOnPostRun(Module['postRun'].shift());
    		}
    	  }
    	  callRuntimeCallbacks(__ATPOSTRUN__);
    	}

    	function addOnPreRun(cb) {
    	  __ATPRERUN__.unshift(cb);
    	}

    	function addOnPostRun(cb) {
    	  __ATPOSTRUN__.unshift(cb);
    	}


    	assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
    	assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
    	assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');
    	assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill');



    	// A counter of dependencies for calling run(). If we need to
    	// do asynchronous work before running, increment this and
    	// decrement it. Incrementing must happen in a place like
    	// Module.preRun (used by emcc to add file preloading).
    	// Note that you can add dependencies in preRun, even though
    	// it happens right before run - run will be postponed until
    	// the dependencies are met.
    	var runDependencies = 0;
    	var runDependencyWatcher = null;
    	var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
    	var runDependencyTracking = {};

    	function addRunDependency(id) {
    	  runDependencies++;
    	  if (Module['monitorRunDependencies']) {
    		Module['monitorRunDependencies'](runDependencies);
    	  }
    	  if (id) {
    		assert(!runDependencyTracking[id]);
    		runDependencyTracking[id] = 1;
    		if (runDependencyWatcher === null && typeof setInterval !== 'undefined') {
    		  // Check for missing dependencies every few seconds
    		  runDependencyWatcher = setInterval(function() {
    			if (ABORT) {
    			  clearInterval(runDependencyWatcher);
    			  runDependencyWatcher = null;
    			  return;
    			}
    		  }, 10000);
    		}
    	  }
    	}

    	function removeRunDependency(id) {
    	  runDependencies--;
    	  if (Module['monitorRunDependencies']) {
    		Module['monitorRunDependencies'](runDependencies);
    	  }
    	  if (id) {
    		assert(runDependencyTracking[id]);
    		delete runDependencyTracking[id];
    	  }
    	  if (runDependencies == 0) {
    		if (runDependencyWatcher !== null) {
    		  clearInterval(runDependencyWatcher);
    		  runDependencyWatcher = null;
    		}
    		if (dependenciesFulfilled) {
    		  var callback = dependenciesFulfilled;
    		  dependenciesFulfilled = null;
    		  callback(); // can add another dependenciesFulfilled
    		}
    	  }
    	}

    	Module["preloadedImages"] = {}; // maps url to image data
    	Module["preloadedAudios"] = {}; // maps url to audio data



    	// show errors on likely calls to FS when it was not included
    	var FS = {
    	  error: function() {
    		abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with  -s FORCE_FILESYSTEM=1');
    	  },
    	  init: function() { FS.error(); },
    	  createDataFile: function() { FS.error(); },
    	  createPreloadedFile: function() { FS.error(); },
    	  createLazyFile: function() { FS.error(); },
    	  open: function() { FS.error(); },
    	  mkdev: function() { FS.error(); },
    	  registerDevice: function() { FS.error(); },
    	  analyzePath: function() { FS.error(); },
    	  loadFilesFromDB: function() { FS.error(); },

    	  ErrnoError: function ErrnoError() { FS.error(); },
    	};
    	Module['FS_createDataFile'] = FS.createDataFile;
    	Module['FS_createPreloadedFile'] = FS.createPreloadedFile;



    	// Copyright 2017 The Emscripten Authors.  All rights reserved.
    	// Emscripten is available under two separate licenses, the MIT license and the
    	// University of Illinois/NCSA Open Source License.  Both these licenses can be
    	// found in the LICENSE file.

    	// Prefix of data URIs emitted by SINGLE_FILE and related options.
    	var dataURIPrefix = 'data:application/octet-stream;base64,';

    	// Indicates whether filename is a base64 data URI.
    	function isDataURI(filename) {
    	  return String.prototype.startsWith ?
    		  filename.startsWith(dataURIPrefix) :
    		  filename.indexOf(dataURIPrefix) === 0;
    	}




    	var wasmBinaryFile = 'ThirdParty/earcut.wasm';
    	if (!isDataURI(wasmBinaryFile)) {
    	  wasmBinaryFile = locateFile(wasmBinaryFile);
    	}

    	function getBinary() {
    	  try {
    		if (Module['wasmBinary']) {
    		  return new Uint8Array(Module['wasmBinary']);
    		}
    		if (Module['readBinary']) {
    		  return Module['readBinary'](wasmBinaryFile);
    		} else {
    		  throw "both async and sync fetching of the wasm failed";
    		}
    	  }
    	  catch (err) {
    		abort(err);
    	  }
    	}

    	function getBinaryPromise() {
    	  // if we don't have the binary yet, and have the Fetch api, use that
    	  // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web
    	  if (!Module['wasmBinary'] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') {
    		return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) {
    		  if (!response['ok']) {
    			throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
    		  }
    		  return response['arrayBuffer']();
    		}).catch(function () {
    		  return getBinary();
    		});
    	  }
    	  // Otherwise, getBinary should be able to get it synchronously
    	  return new Promise(function(resolve, reject) {
    		resolve(getBinary());
    	  });
    	}



    	// Create the wasm instance.
    	// Receives the wasm imports, returns the exports.
    	function createWasm(env) {

    	  // prepare imports
    	  var info = {
    		'env': env
    		,
    		'global': {
    		  'NaN': NaN,
    		  'Infinity': Infinity
    		},
    		'global.Math': Math,
    		'asm2wasm': asm2wasmImports
    	  };
    	  // Load the wasm module and create an instance of using native support in the JS engine.
    	  // handle a generated wasm instance, receiving its exports and
    	  // performing other necessary setup
    	  function receiveInstance(instance, module) {
    		var exports = instance.exports;
    		Module['asm'] = exports;
    		removeRunDependency('wasm-instantiate');
    	  }
    	  addRunDependency('wasm-instantiate');


    	  // Async compilation can be confusing when an error on the page overwrites Module
    	  // (for example, if the order of elements is wrong, and the one defining Module is
    	  // later), so we save Module and check it later.
    	  var trueModule = Module;
    	  function receiveInstantiatedSource(output) {
    		// 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance.
    		// receiveInstance() will swap in the exports (to Module.asm) so they can be called
    		assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?');
    		trueModule = null;
    		  // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
    		  // When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
    		receiveInstance(output['instance']);
    	  }


    	  function instantiateArrayBuffer(receiver) {
    		return getBinaryPromise().then(function(binary) {
    		  return WebAssembly.instantiate(binary, info);
    		}).then(receiver, function(reason) {
    		  //err('failed to asynchronously prepare wasm: ' + reason);
    		  //abort(reason);
    		});
    	  }

    	  // Prefer streaming instantiation if available.
    	  function instantiateAsync() {
    		if (!Module['wasmBinary'] &&
    			typeof WebAssembly.instantiateStreaming === 'function' &&
    			!isDataURI(wasmBinaryFile) &&
    			typeof fetch === 'function') {
    		  fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) {
    			return WebAssembly.instantiateStreaming(response, info)
    			  .then(receiveInstantiatedSource, function(reason) {
    				// We expect the most common failure cause to be a bad MIME type for the binary,
    				// in which case falling back to ArrayBuffer instantiation should work.
    				//err('wasm streaming compile failed: ' + reason);
    				//err('falling back to ArrayBuffer instantiation');
    				instantiateArrayBuffer(receiveInstantiatedSource);
    			  });
    		  });
    		} else {
    		  return instantiateArrayBuffer(receiveInstantiatedSource);
    		}
    	  }
    	  // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
    	  // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
    	  // to any other async startup actions they are performing.
    	  if (Module['instantiateWasm']) {
    		try {
    		  return Module['instantiateWasm'](info, receiveInstance);
    		} catch(e) {
    		  //err('Module.instantiateWasm callback failed with error: ' + e);
    		  return false;
    		}
    	  }

    	  instantiateAsync();
    	  return {}; // no exports yet; we'll fill them in later
    	}

    	// Provide an "asm.js function" for the application, called to "link" the asm.js module. We instantiate
    	// the wasm module at that time, and it receives imports and provides exports and so forth, the app
    	// doesn't need to care that it is wasm or asm.js.

    	Module['asm'] = function(global, env, providedBuffer) {
    	  // memory was already allocated (so js could use the buffer)
    	  env['memory'] = wasmMemory
    	  ;
    	  // import table
    	  env['table'] = wasmTable = new WebAssembly.Table({
    		'initial': 260,
    		'maximum': 260,
    		'element': 'anyfunc'
    	  });
    	  // With the wasm backend __memory_base and __table_base and only needed for
    	  // relocatable output.
    	  env['__memory_base'] = 1024; // tell the memory segments where to place themselves
    	  // table starts at 0 by default (even in dynamic linking, for the main module)
    	  env['__table_base'] = 0;

    	  var exports = createWasm(env);
    	  assert(exports, 'binaryen setup failed (no wasm support?)');
    	  return exports;
    	};





    	// STATICTOP = STATIC_BASE + 4848;
    	/* global initializers */ /*__ATINIT__.push();*/








    	/* no memory initializer */
    	var tempDoublePtr = 5856;
    	assert(tempDoublePtr % 8 == 0);

    	// {{PRE_LIBRARY}}


    	  function ___cxa_allocate_exception(size) {
    		  return _malloc(size);
    		}

    	  
    	  var ___exception_infos={};
    	  
    	  var ___exception_caught= [];
    	  
    	  function ___exception_addRef(ptr) {
    		  if (!ptr) return;
    		  var info = ___exception_infos[ptr];
    		  info.refcount++;
    		}
    	  
    	  function ___exception_deAdjust(adjusted) {
    		  if (!adjusted || ___exception_infos[adjusted]) return adjusted;
    		  for (var key in ___exception_infos) {
    			var ptr = +key; // the iteration key is a string, and if we throw this, it must be an integer as that is what we look for
    			var adj = ___exception_infos[ptr].adjusted;
    			var len = adj.length;
    			for (var i = 0; i < len; i++) {
    			  if (adj[i] === adjusted) {
    				return ptr;
    			  }
    			}
    		  }
    		  return adjusted;
    		}function ___cxa_begin_catch(ptr) {
    		  var info = ___exception_infos[ptr];
    		  if (info && !info.caught) {
    			info.caught = true;
    			__ZSt18uncaught_exceptionv.uncaught_exception--;
    		  }
    		  if (info) info.rethrown = false;
    		  ___exception_caught.push(ptr);
    		  ___exception_addRef(___exception_deAdjust(ptr));
    		  return ptr;
    		}
    function ___cxa_throw(ptr, type, destructor) {
    		  ___exception_infos[ptr] = {
    			ptr: ptr,
    			adjusted: [ptr],
    			type: type,
    			destructor: destructor,
    			refcount: 0,
    			caught: false,
    			rethrown: false
    		  };
    		  if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
    			__ZSt18uncaught_exceptionv.uncaught_exception = 1;
    		  } else {
    			__ZSt18uncaught_exceptionv.uncaught_exception++;
    		  }
    		  throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";
    		}

    	  function ___cxa_uncaught_exception() {
    		  return !!__ZSt18uncaught_exceptionv.uncaught_exception;
    		}

    	  function ___gxx_personality_v0() {
    		}

    	  function ___lock() {}
    var SYSCALLS={buffers:[null,[],[]],printChar:function (stream, curr) {
    			var buffer = SYSCALLS.buffers[stream];
    			assert(buffer);
    			if (curr === 0 || curr === 10) {
    			  (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
    			  buffer.length = 0;
    			} else {
    			  buffer.push(curr);
    			}
    		  },varargs:0,get:function (varargs) {
    			SYSCALLS.varargs += 4;
    			var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)];
    			return ret;
    		  },getStr:function () {
    			var ret = UTF8ToString(SYSCALLS.get());
    			return ret;
    		  },get64:function () {
    			var low = SYSCALLS.get(), high = SYSCALLS.get();
    			if (low >= 0) assert(high === 0);
    			else assert(high === -1);
    			return low;
    		  },getZero:function () {
    			assert(SYSCALLS.get() === 0);
    		  }};function ___syscall140(which, varargs) {SYSCALLS.varargs = varargs;
    	  try {
    	   // llseek
    		  var stream = SYSCALLS.getStreamFromFD(), offset_high = SYSCALLS.get(), offset_low = SYSCALLS.get(), result = SYSCALLS.get(), whence = SYSCALLS.get();
    		  abort('it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM');
    		  return 0;
    		} catch (e) {
    		if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
    		return -e.errno;
    	  }
    	  }

    	  
    	  function flush_NO_FILESYSTEM() {
    		  // flush anything remaining in the buffers during shutdown
    		  var fflush = Module["_fflush"];
    		  if (fflush) fflush(0);
    		  var buffers = SYSCALLS.buffers;
    		  if (buffers[1].length) SYSCALLS.printChar(1, 10);
    		  if (buffers[2].length) SYSCALLS.printChar(2, 10);
    		}function ___syscall146(which, varargs) {SYSCALLS.varargs = varargs;
    	  try {
    	   // writev
    		  // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
    		  var stream = SYSCALLS.get(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get();
    		  var ret = 0;
    		  for (var i = 0; i < iovcnt; i++) {
    			var ptr = HEAP32[(((iov)+(i*8))>>2)];
    			var len = HEAP32[(((iov)+(i*8 + 4))>>2)];
    			for (var j = 0; j < len; j++) {
    			  SYSCALLS.printChar(stream, HEAPU8[ptr+j]);
    			}
    			ret += len;
    		  }
    		  return ret;
    		} catch (e) {
    		if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
    		return -e.errno;
    	  }
    	  }

    	  function ___syscall54(which, varargs) {SYSCALLS.varargs = varargs;
    	  try {
    	   // ioctl
    		  return 0;
    		} catch (e) {
    		if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
    		return -e.errno;
    	  }
    	  }

    	  function ___syscall6(which, varargs) {SYSCALLS.varargs = varargs;
    	  try {
    	   // close
    		  var stream = SYSCALLS.getStreamFromFD();
    		  abort('it should not be possible to operate on streams when !SYSCALLS_REQUIRE_FILESYSTEM');
    		  return 0;
    		} catch (e) {
    		if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
    		return -e.errno;
    	  }
    	  }

    	  function ___unlock() {}

    	  function _abort() {
    		  Module['abort']();
    		}

    	  function _emscripten_get_heap_size() {
    		  return HEAP8.length;
    		}

    	   

    	   

    	  
    	  function _emscripten_memcpy_big(dest, src, num) {
    		  HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
    		}
    	  
    	   

    	   

    	  
    	  function ___setErrNo(value) {
    		  if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value;
    		  else //err('failed to set errno from JS');
    		  return value;
    		}
    	  
    	  
    	  function abortOnCannotGrowMemory(requestedSize) {
    		  abort('Cannot enlarge memory arrays to size ' + requestedSize + ' bytes (OOM). Either (1) compile with  -s TOTAL_MEMORY=X  with X higher than the current value ' + HEAP8.length + ', (2) compile with  -s ALLOW_MEMORY_GROWTH=1  which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with  -s ABORTING_MALLOC=0 ');
    		}
    	  
    	  function emscripten_realloc_buffer(size) {
    		  var PAGE_MULTIPLE = 65536;
    		  size = alignUp(size, PAGE_MULTIPLE); // round up to wasm page size
    		  var oldSize = buffer.byteLength;
    		  // native wasm support
    		  // note that this is *not* threadsafe. multiple threads can call .grow(), and each
    		  // presents a delta, so in theory we may over-allocate here (e.g. if two threads
    		  // ask to grow from 256MB to 512MB, we get 2 requests to add +256MB, and may end
    		  // up growing to 768MB (even though we may have been able to make do with 512MB).
    		  // TODO: consider decreasing the step sizes in emscripten_resize_heap
    		  try {
    			var result = wasmMemory.grow((size - oldSize) / 65536); // .grow() takes a delta compared to the previous size
    			if (result !== (-1 | 0)) {
    			  // success in native wasm memory growth, get the buffer from the memory
    			  buffer = wasmMemory.buffer;
    			  return true;
    			} else {
    			  return false;
    			}
    		  } catch(e) {
    			console.error('emscripten_realloc_buffer: Attempted to grow from ' + oldSize  + ' bytes to ' + size + ' bytes, but got error: ' + e);
    			return false;
    		  }
    		}function _emscripten_resize_heap(requestedSize) {
    		  var oldSize = _emscripten_get_heap_size();
    		  // With pthreads, races can happen (another thread might increase the size in between), so return a failure, and let the caller retry.
    		  assert(requestedSize > oldSize);
    	  
    	  
    		  var PAGE_MULTIPLE = 65536;
    		  var LIMIT = 2147483648 - PAGE_MULTIPLE; // We can do one page short of 2GB as theoretical maximum.
    	  
    		  if (requestedSize > LIMIT) {
    			//err('Cannot enlarge memory, asked to go up to ' + requestedSize + ' bytes, but the limit is ' + LIMIT + ' bytes!');
    			return false;
    		  }
    	  
    		  var MIN_TOTAL_MEMORY = 16777216;
    		  var newSize = Math.max(oldSize, MIN_TOTAL_MEMORY); // So the loop below will not be infinite, and minimum asm.js memory size is 16MB.
    	  
    		  // TODO: see realloc_buffer - for PTHREADS we may want to decrease these jumps
    		  while (newSize < requestedSize) { // Keep incrementing the heap size as long as it's less than what is requested.
    			if (newSize <= 536870912) {
    			  newSize = alignUp(2 * newSize, PAGE_MULTIPLE); // Simple heuristic: double until 1GB...
    			} else {
    			  // ..., but after that, add smaller increments towards 2GB, which we cannot reach
    			  newSize = Math.min(alignUp((3 * newSize + 2147483648) / 4, PAGE_MULTIPLE), LIMIT);
    			}
    	  
    			if (newSize === oldSize) {
    			  warnOnce('Cannot ask for more memory since we reached the practical limit in browsers (which is just below 2GB), so the request would have failed. Requesting only ' + HEAP8.length);
    			}
    		  }
    	  
    		  if (!emscripten_realloc_buffer(newSize)) {
    			//err('Failed to grow the heap from ' + oldSize + ' bytes to ' + newSize + ' bytes, not enough memory!');
    			return false;
    		  }
    	  
    		  updateGlobalBufferViews();
    	  
    	  
    	  
    		  return true;
    		} 


    	// ASM_LIBRARY EXTERN PRIMITIVES: Math_max,Math_min,Int8Array,Int32Array


    	function nullFunc_ii(x) { err("Invalid function pointer called with signature 'ii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	function nullFunc_iidiiii(x) { err("Invalid function pointer called with signature 'iidiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	function nullFunc_iiii(x) { err("Invalid function pointer called with signature 'iiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	function nullFunc_jiji(x) { err("Invalid function pointer called with signature 'jiji'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	function nullFunc_v(x) { err("Invalid function pointer called with signature 'v'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	function nullFunc_vi(x) { err("Invalid function pointer called with signature 'vi'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	function nullFunc_vii(x) { err("Invalid function pointer called with signature 'vii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	function nullFunc_viiii(x) { err("Invalid function pointer called with signature 'viiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	function nullFunc_viiiii(x) { err("Invalid function pointer called with signature 'viiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	function nullFunc_viiiiii(x) { err("Invalid function pointer called with signature 'viiiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)");  err("Build with ASSERTIONS=2 for more info.");abort(x); }

    	var asmGlobalArg = {};

    	var asmLibraryArg = {
    	  "abort": abort,
    	  "setTempRet0": setTempRet0,
    	  "getTempRet0": getTempRet0,
    	  "abortStackOverflow": abortStackOverflow,
    	  "nullFunc_ii": nullFunc_ii,
    	  "nullFunc_iidiiii": nullFunc_iidiiii,
    	  "nullFunc_iiii": nullFunc_iiii,
    	  "nullFunc_jiji": nullFunc_jiji,
    	  "nullFunc_v": nullFunc_v,
    	  "nullFunc_vi": nullFunc_vi,
    	  "nullFunc_vii": nullFunc_vii,
    	  "nullFunc_viiii": nullFunc_viiii,
    	  "nullFunc_viiiii": nullFunc_viiiii,
    	  "nullFunc_viiiiii": nullFunc_viiiiii,
    	  "___cxa_allocate_exception": ___cxa_allocate_exception,
    	  "___cxa_begin_catch": ___cxa_begin_catch,
    	  "___cxa_throw": ___cxa_throw,
    	  "___cxa_uncaught_exception": ___cxa_uncaught_exception,
    	  "___exception_addRef": ___exception_addRef,
    	  "___exception_deAdjust": ___exception_deAdjust,
    	  "___gxx_personality_v0": ___gxx_personality_v0,
    	  "___lock": ___lock,
    	  "___setErrNo": ___setErrNo,
    	  "___syscall140": ___syscall140,
    	  "___syscall146": ___syscall146,
    	  "___syscall54": ___syscall54,
    	  "___syscall6": ___syscall6,
    	  "___unlock": ___unlock,
    	  "_abort": _abort,
    	  "_emscripten_get_heap_size": _emscripten_get_heap_size,
    	  "_emscripten_memcpy_big": _emscripten_memcpy_big,
    	  "_emscripten_resize_heap": _emscripten_resize_heap,
    	  "abortOnCannotGrowMemory": abortOnCannotGrowMemory,
    	  "emscripten_realloc_buffer": emscripten_realloc_buffer,
    	  "flush_NO_FILESYSTEM": flush_NO_FILESYSTEM,
    	  "tempDoublePtr": tempDoublePtr,
    	  "DYNAMICTOP_PTR": DYNAMICTOP_PTR
    	};
    	// EMSCRIPTEN_START_ASM
    	var asm =Module["asm"]// EMSCRIPTEN_END_ASM
    	(asmGlobalArg, asmLibraryArg, buffer);

    	var real___ZSt18uncaught_exceptionv = asm["__ZSt18uncaught_exceptionv"];
    	asm["__ZSt18uncaught_exceptionv"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real___ZSt18uncaught_exceptionv.apply(null, arguments);
    	};

    	var real____cxa_can_catch = asm["___cxa_can_catch"];
    	asm["___cxa_can_catch"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real____cxa_can_catch.apply(null, arguments);
    	};

    	var real____cxa_is_pointer_type = asm["___cxa_is_pointer_type"];
    	asm["___cxa_is_pointer_type"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real____cxa_is_pointer_type.apply(null, arguments);
    	};

    	var real____errno_location = asm["___errno_location"];
    	asm["___errno_location"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real____errno_location.apply(null, arguments);
    	};

    	var real__earcut = asm["_earcut"];
    	asm["_earcut"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real__earcut.apply(null, arguments);
    	};

    	var real__fflush = asm["_fflush"];
    	asm["_fflush"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real__fflush.apply(null, arguments);
    	};

    	var real__free = asm["_free"];
    	asm["_free"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real__free.apply(null, arguments);
    	};

    	var real__llvm_maxnum_f64 = asm["_llvm_maxnum_f64"];
    	asm["_llvm_maxnum_f64"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real__llvm_maxnum_f64.apply(null, arguments);
    	};

    	var real__llvm_minnum_f64 = asm["_llvm_minnum_f64"];
    	asm["_llvm_minnum_f64"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real__llvm_minnum_f64.apply(null, arguments);
    	};

    	var real__malloc = asm["_malloc"];
    	asm["_malloc"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real__malloc.apply(null, arguments);
    	};

    	var real__sbrk = asm["_sbrk"];
    	asm["_sbrk"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real__sbrk.apply(null, arguments);
    	};

    	var real_establishStackSpace = asm["establishStackSpace"];
    	asm["establishStackSpace"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real_establishStackSpace.apply(null, arguments);
    	};

    	var real_stackAlloc = asm["stackAlloc"];
    	asm["stackAlloc"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real_stackAlloc.apply(null, arguments);
    	};

    	var real_stackRestore = asm["stackRestore"];
    	asm["stackRestore"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real_stackRestore.apply(null, arguments);
    	};

    	var real_stackSave = asm["stackSave"];
    	asm["stackSave"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return real_stackSave.apply(null, arguments);
    	};
    	Module["asm"] = asm;
    	var __ZSt18uncaught_exceptionv = Module["__ZSt18uncaught_exceptionv"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["__ZSt18uncaught_exceptionv"].apply(null, arguments)
    	};

    	var ___cxa_can_catch = Module["___cxa_can_catch"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["___cxa_can_catch"].apply(null, arguments)
    	};

    	var ___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["___cxa_is_pointer_type"].apply(null, arguments)
    	};

    	var ___errno_location = Module["___errno_location"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["___errno_location"].apply(null, arguments)
    	};

    	var _earcut = Module["_earcut"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_earcut"].apply(null, arguments)
    	};

    	var _emscripten_replace_memory = Module["_emscripten_replace_memory"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_emscripten_replace_memory"].apply(null, arguments)
    	};

    	var _fflush = Module["_fflush"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_fflush"].apply(null, arguments)
    	};

    	var _free = Module["_free"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_free"].apply(null, arguments)
    	};

    	var _llvm_maxnum_f64 = Module["_llvm_maxnum_f64"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_llvm_maxnum_f64"].apply(null, arguments)
    	};

    	var _llvm_minnum_f64 = Module["_llvm_minnum_f64"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_llvm_minnum_f64"].apply(null, arguments)
    	};

    	var _malloc = Module["_malloc"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_malloc"].apply(null, arguments)
    	};

    	var _memcpy = Module["_memcpy"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_memcpy"].apply(null, arguments)
    	};

    	var _memset = Module["_memset"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_memset"].apply(null, arguments)
    	};

    	var _sbrk = Module["_sbrk"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["_sbrk"].apply(null, arguments)
    	};

    	var establishStackSpace = Module["establishStackSpace"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["establishStackSpace"].apply(null, arguments)
    	};

    	var stackAlloc = Module["stackAlloc"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["stackAlloc"].apply(null, arguments)
    	};

    	var stackRestore = Module["stackRestore"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["stackRestore"].apply(null, arguments)
    	};

    	var stackSave = Module["stackSave"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["stackSave"].apply(null, arguments)
    	};

    	var dynCall_ii = Module["dynCall_ii"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_ii"].apply(null, arguments)
    	};

    	var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_iidiiii"].apply(null, arguments)
    	};

    	var dynCall_iiii = Module["dynCall_iiii"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_iiii"].apply(null, arguments)
    	};

    	var dynCall_jiji = Module["dynCall_jiji"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_jiji"].apply(null, arguments)
    	};

    	var dynCall_v = Module["dynCall_v"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_v"].apply(null, arguments)
    	};

    	var dynCall_vi = Module["dynCall_vi"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_vi"].apply(null, arguments)
    	};

    	var dynCall_vii = Module["dynCall_vii"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_vii"].apply(null, arguments)
    	};

    	var dynCall_viiii = Module["dynCall_viiii"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_viiii"].apply(null, arguments)
    	};

    	var dynCall_viiiii = Module["dynCall_viiiii"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_viiiii"].apply(null, arguments)
    	};

    	var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() {
    	  assert(runtimeInitialized, 'you need to wait for the runtime to be ready (e.g. wait for main() to be called)');
    	  assert(!runtimeExited, 'the runtime was exited (use NO_EXIT_RUNTIME to keep it alive after main() exits)');
    	  return Module["asm"]["dynCall_viiiiii"].apply(null, arguments)
    	};



    	// === Auto-generated postamble setup entry stuff ===

    	Module['asm'] = asm;

    	if (!Module["intArrayFromString"]) Module["intArrayFromString"] = function() { abort("'intArrayFromString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["intArrayToString"]) Module["intArrayToString"] = function() { abort("'intArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	Module["ccall"] = ccall;
    	Module["cwrap"] = cwrap;
    	if (!Module["setValue"]) Module["setValue"] = function() { abort("'setValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	Module["getValue"] = getValue;
    	if (!Module["allocate"]) Module["allocate"] = function() { abort("'allocate' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["getMemory"]) Module["getMemory"] = function() { abort("'getMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["AsciiToString"]) Module["AsciiToString"] = function() { abort("'AsciiToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["stringToAscii"]) Module["stringToAscii"] = function() { abort("'stringToAscii' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["UTF8ArrayToString"]) Module["UTF8ArrayToString"] = function() { abort("'UTF8ArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["UTF8ToString"]) Module["UTF8ToString"] = function() { abort("'UTF8ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["stringToUTF8Array"]) Module["stringToUTF8Array"] = function() { abort("'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["stringToUTF8"]) Module["stringToUTF8"] = function() { abort("'stringToUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["lengthBytesUTF8"]) Module["lengthBytesUTF8"] = function() { abort("'lengthBytesUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["UTF16ToString"]) Module["UTF16ToString"] = function() { abort("'UTF16ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["stringToUTF16"]) Module["stringToUTF16"] = function() { abort("'stringToUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["lengthBytesUTF16"]) Module["lengthBytesUTF16"] = function() { abort("'lengthBytesUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["UTF32ToString"]) Module["UTF32ToString"] = function() { abort("'UTF32ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["stringToUTF32"]) Module["stringToUTF32"] = function() { abort("'stringToUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["lengthBytesUTF32"]) Module["lengthBytesUTF32"] = function() { abort("'lengthBytesUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["allocateUTF8"]) Module["allocateUTF8"] = function() { abort("'allocateUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["stackTrace"]) Module["stackTrace"] = function() { abort("'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["addOnPreRun"]) Module["addOnPreRun"] = function() { abort("'addOnPreRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["addOnInit"]) Module["addOnInit"] = function() { abort("'addOnInit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["addOnPreMain"]) Module["addOnPreMain"] = function() { abort("'addOnPreMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["addOnExit"]) Module["addOnExit"] = function() { abort("'addOnExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["addOnPostRun"]) Module["addOnPostRun"] = function() { abort("'addOnPostRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["writeStringToMemory"]) Module["writeStringToMemory"] = function() { abort("'writeStringToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["writeArrayToMemory"]) Module["writeArrayToMemory"] = function() { abort("'writeArrayToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["writeAsciiToMemory"]) Module["writeAsciiToMemory"] = function() { abort("'writeAsciiToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["addRunDependency"]) Module["addRunDependency"] = function() { abort("'addRunDependency' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["removeRunDependency"]) Module["removeRunDependency"] = function() { abort("'removeRunDependency' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["ENV"]) Module["ENV"] = function() { abort("'ENV' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["FS"]) Module["FS"] = function() { abort("'FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["FS_createFolder"]) Module["FS_createFolder"] = function() { abort("'FS_createFolder' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["FS_createPath"]) Module["FS_createPath"] = function() { abort("'FS_createPath' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["FS_createDataFile"]) Module["FS_createDataFile"] = function() { abort("'FS_createDataFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["FS_createPreloadedFile"]) Module["FS_createPreloadedFile"] = function() { abort("'FS_createPreloadedFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["FS_createLazyFile"]) Module["FS_createLazyFile"] = function() { abort("'FS_createLazyFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["FS_createLink"]) Module["FS_createLink"] = function() { abort("'FS_createLink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["FS_createDevice"]) Module["FS_createDevice"] = function() { abort("'FS_createDevice' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["FS_unlink"]) Module["FS_unlink"] = function() { abort("'FS_unlink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you"); };
    	if (!Module["GL"]) Module["GL"] = function() { abort("'GL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["dynamicAlloc"]) Module["dynamicAlloc"] = function() { abort("'dynamicAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["warnOnce"]) Module["warnOnce"] = function() { abort("'warnOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["loadDynamicLibrary"]) Module["loadDynamicLibrary"] = function() { abort("'loadDynamicLibrary' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["loadWebAssemblyModule"]) Module["loadWebAssemblyModule"] = function() { abort("'loadWebAssemblyModule' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["getLEB"]) Module["getLEB"] = function() { abort("'getLEB' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["getFunctionTables"]) Module["getFunctionTables"] = function() { abort("'getFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["alignFunctionTables"]) Module["alignFunctionTables"] = function() { abort("'alignFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["registerFunctions"]) Module["registerFunctions"] = function() { abort("'registerFunctions' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["addFunction"]) Module["addFunction"] = function() { abort("'addFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["removeFunction"]) Module["removeFunction"] = function() { abort("'removeFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["getFuncWrapper"]) Module["getFuncWrapper"] = function() { abort("'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["prettyPrint"]) Module["prettyPrint"] = function() { abort("'prettyPrint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["makeBigInt"]) Module["makeBigInt"] = function() { abort("'makeBigInt' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["dynCall"]) Module["dynCall"] = function() { abort("'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["getCompilerSetting"]) Module["getCompilerSetting"] = function() { abort("'getCompilerSetting' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["stackSave"]) Module["stackSave"] = function() { abort("'stackSave' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["stackRestore"]) Module["stackRestore"] = function() { abort("'stackRestore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["stackAlloc"]) Module["stackAlloc"] = function() { abort("'stackAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["establishStackSpace"]) Module["establishStackSpace"] = function() { abort("'establishStackSpace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["print"]) Module["print"] = function() { abort("'print' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["printErr"]) Module["printErr"] = function() { abort("'printErr' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["getTempRet0"]) Module["getTempRet0"] = function() { abort("'getTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["setTempRet0"]) Module["setTempRet0"] = function() { abort("'setTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };
    	if (!Module["Pointer_stringify"]) Module["Pointer_stringify"] = function() { abort("'Pointer_stringify' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); };if (!Module["ALLOC_NORMAL"]) Object.defineProperty(Module, "ALLOC_NORMAL", { get: function() { abort("'ALLOC_NORMAL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); } });
    	if (!Module["ALLOC_STACK"]) Object.defineProperty(Module, "ALLOC_STACK", { get: function() { abort("'ALLOC_STACK' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); } });
    	if (!Module["ALLOC_DYNAMIC"]) Object.defineProperty(Module, "ALLOC_DYNAMIC", { get: function() { abort("'ALLOC_DYNAMIC' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); } });
    	if (!Module["ALLOC_NONE"]) Object.defineProperty(Module, "ALLOC_NONE", { get: function() { abort("'ALLOC_NONE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)"); } });




    	/**
    	 * @constructor
    	 * @extends {Error}
    	 * @this {ExitStatus}
    	 */
    	function ExitStatus(status) {
    	  this.name = "ExitStatus";
    	  this.message = "Program terminated with exit(" + status + ")";
    	  this.status = status;
    	}	ExitStatus.prototype = new Error();
    	ExitStatus.prototype.constructor = ExitStatus;

    	dependenciesFulfilled = function runCaller() {
    	  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
    	  if (!Module['calledRun']) run();
    	  if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
    	};





    	/** @type {function(Array=)} */
    	function run(args) {
    	  args = args || Module['arguments'];

    	  if (runDependencies > 0) {
    		return;
    	  }

    	  writeStackCookie();

    	  preRun();

    	  if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
    	  if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame

    	  function doRun() {
    		if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
    		Module['calledRun'] = true;

    		if (ABORT) return;

    		ensureInitRuntime();

    		preMain();

    		if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();

    		assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');

    		postRun();
    	  }

    	  if (Module['setStatus']) {
    		Module['setStatus']('Running...');
    		setTimeout(function() {
    		  setTimeout(function() {
    			Module['setStatus']('');
    		  }, 1);
    		  doRun();
    		}, 1);
    	  } else {
    		doRun();
    	  }
    	  checkStackCookie();
    	}
    	Module['run'] = run;

    	var abortDecorators = [];

    	function abort(what) {
    	  if (Module['onAbort']) {
    		Module['onAbort'](what);
    	  }

    	  if (what !== undefined) {
    		//out(what);
    		//err(what);
    		what = '"' + what + '"';
    	  } else {
    		what = '';
    	  }

    	  ABORT = true;

    	  var extra = '';
    	  var output = 'abort(' + what + ') at ' + stackTrace() + extra;
    	  if (abortDecorators) {
    		abortDecorators.forEach(function(decorator) {
    		  output = decorator(output, what);
    		});
    	  }
    	  throw output;
    	}
    	Module['abort'] = abort;

    	if (Module['preInit']) {
    	  if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
    	  while (Module['preInit'].length > 0) {
    		Module['preInit'].pop()();
    	  }
    	}


    	  Module["noExitRuntime"] = true;

    	run();
    } else {
        var Module = null;
    }

    var earcutWasm = Module;



    // {{MODULE_ADDITIONS}}

    var earcutWasmReady = false;
    if (defined.defined(earcutWasm)) {
        earcutWasm.onRuntimeInitialized = function () {
            earcutWasmReady = true;
        };
        var earcutwasm = earcutWasm.cwrap('earcut','number',['number','number','number','number','number','number']);
    }

    var layout$3 = createLayout([
        {name: 'a_pos', components: 2, type: 'Int16'}
    ], 4);
    var members$1 = layout$3.members;

    var EARCUT_MAX_RINGS = 500;

    var FillBucket = function FillBucket(options) {
        this.zoom = options.zoom;
        this.overscaling = options.overscaling;
        this.layers = options.layers;
        this.layerIds = this.layers.map(function (layer) {
            return layer.id;
        });
        this.index = options.index;
        this.hasPattern = false;
        this.patternFeatures = [];

        this.layoutVertexArray = new StructArrayLayout2i4();
        this.indexArray = new StructArrayLayout3ui6();
        this.indexArray2 = new StructArrayLayout2ui4();
        this.programConfigurations = new ProgramConfigurationSet(members$1, options.layers, options.zoom);
        this.segments = new SegmentVector();
        this.segments2 = new SegmentVector();
        this.stateDependentLayerIds = this.layers.filter(function (l) {
            return l.isStateDependent();
        }).map(function (l) {
            return l.id;
        });
    };

    FillBucket.prototype.populate = function populate(features, options) {
        this.hasPattern = hasPattern('fill', this.layers, options);
        var bucketFeatures = [];

        for (var i = 0, list = features; i < list.length; i += 1) {
            var ref = list[i];
            var feature = ref.feature;
            var index = ref.index;
            var sourceLayerIndex = ref.sourceLayerIndex;

            if (!this.layers[0]._featureFilter(new EvaluationParameters$1(0), feature)) {
                continue;
            }

            var geometry = loadGeometry(feature);
            var sortKey = 
                undefined;

            var bucketFeature = {
                id: feature.id,
                properties: feature.properties,
                type: feature.type,
                sourceLayerIndex: sourceLayerIndex,
                index: index,
                geometry: geometry,
                patterns: {},
                sortKey: sortKey
            };

            bucketFeatures.push(bucketFeature);
        }

        for (var i$1 = 0, list$1 = bucketFeatures; i$1 < list$1.length; i$1 += 1) {
            var bucketFeature$1 = list$1[i$1];

            var ref$1 = bucketFeature$1;
            var geometry$1 = ref$1.geometry;
            var index$1 = ref$1.index;
            var sourceLayerIndex$1 = ref$1.sourceLayerIndex;

            if (this.hasPattern) {
                var patternFeature = addPatternDependencies('fill', this.layers, bucketFeature$1, this.zoom, options);
                // pattern features are added only once the pattern is loaded into the image atlas
                // so are stored during populate until later updated with positions by tile worker in addFeatures
                this.patternFeatures.push(patternFeature);
            } else {
                this.addFeature(bucketFeature$1, geometry$1, index$1, {}, options.indexData);
            }

            var feature$1 = features[index$1].feature;
            options.featureIndex.insert(feature$1, geometry$1, index$1, sourceLayerIndex$1, this.index);
        }
    };

    FillBucket.prototype.update = function update(states, vtLayer, imagePositions) {
        if (!this.stateDependentLayers.length) {
            return;
        }
        this.programConfigurations.updatePaintArrays(states, vtLayer, this.stateDependentLayers, imagePositions);
    };

    FillBucket.prototype.addFeatures = function addFeatures(options, imagePositions) {
        for (var i = 0, list = this.patternFeatures; i < list.length; i += 1) {
            var feature = list[i];

            this.addFeature(feature, feature.geometry, feature.index, imagePositions);
        }
    };

    FillBucket.prototype.isEmpty = function isEmpty() {
        return this.layoutVertexArray.length === 0;
    };

    FillBucket.prototype.uploadPending = function uploadPending() {
        return !this.uploaded || this.programConfigurations.needsUpload;
    };
    FillBucket.prototype.upload = function upload(context) {
        if (!this.uploaded) {
            this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, members$1);
            this.indexBuffer = context.createIndexBuffer(this.indexArray);
            this.indexBuffer2 = context.createIndexBuffer(this.indexArray2);
        }
        this.programConfigurations.upload(context);
        this.uploaded = true;
    };

    FillBucket.prototype.destroy = function destroy() {
        if (!this.layoutVertexBuffer) {
            return;
        }
        this.layoutVertexBuffer.destroy();
        this.indexBuffer.destroy();
        this.indexBuffer2.destroy();
        this.programConfigurations.destroy();
        this.segments.destroy();
        this.segments2.destroy();
    };

    FillBucket.prototype.clear = function clear() {
        if (defined.defined(this.layoutVertexArray)) {
            this.layoutVertexArray = null;
        }
        if (defined.defined(this.indexArray)) {
            this.indexArray = null;
        }
        if (defined.defined(this.indexArray2)) {
            this.indexArray2 = null;
        }
    };

    FillBucket.prototype.addFeature = function addFeature(feature, geometry, index, imagePositions, indexData) {
        for (var i$4 = 0, list$2 = classifyRings(geometry, EARCUT_MAX_RINGS); i$4 < list$2.length; i$4 += 1) {
            var polygon = list$2[i$4];

            var numVertices = 0;
            for (var i$2 = 0, list = polygon; i$2 < list.length; i$2 += 1) {
                var ring = list[i$2];

                numVertices += ring.length;
            }

            var triangleSegment = this.segments.prepareSegment(numVertices, this.layoutVertexArray, this.indexArray);
            var triangleIndex = triangleSegment.vertexLength;

            var flattened = [];
            var holeIndices = [];

            for (var i$3 = 0, list$1 = polygon; i$3 < list$1.length; i$3 += 1) {
                var ring$1 = list$1[i$3];

                if (ring$1.length === 0) {
                    continue;
                }

                if (ring$1 !== polygon[0]) {
                    holeIndices.push(flattened.length / 2);
                }

                var lineSegment = this.segments2.prepareSegment(ring$1.length, this.layoutVertexArray, this.indexArray2);
                var lineIndex = lineSegment.vertexLength;

                this.layoutVertexArray.emplaceBack(ring$1[0].x, ring$1[0].y);
                this.indexArray2.emplaceBack(lineIndex + ring$1.length - 1, lineIndex);
                flattened.push(ring$1[0].x);
                flattened.push(ring$1[0].y);

                for (var i = 1; i < ring$1.length; i++) {
                    this.layoutVertexArray.emplaceBack(ring$1[i].x, ring$1[i].y);
                    this.indexArray2.emplaceBack(lineIndex + i - 1, lineIndex + i);
                    flattened.push(ring$1[i].x);
                    flattened.push(ring$1[i].y);
                }

                lineSegment.vertexLength += ring$1.length;
                lineSegment.primitiveLength += ring$1.length;
            }
            
            var indices;

            if (defined.defined(indexData) && defined.defined(indexData[feature.id])) {
                indices = indexData[feature.id];
            } else if (earcutWasmReady === true) {
                var data = new Int32Array(flattened);
                var dataLength = data.length;

                var offset = earcutWasm._malloc(Int32Array.BYTES_PER_ELEMENT * dataLength); //开辟内存
                earcutWasm.HEAP32.set(data, offset / Int32Array.BYTES_PER_ELEMENT); //设置值

                var hole = new Int32Array(holeIndices);
                var holeLength = hole.length;
                var offset1 = earcutWasm._malloc(Int32Array.BYTES_PER_ELEMENT * holeLength); //开辟内存
                earcutWasm.HEAP32.set(hole, offset1 / Int32Array.BYTES_PER_ELEMENT); //设置值

                var res = new Int32Array(dataLength * 10);
                var offset2 = earcutWasm._malloc(Int32Array.BYTES_PER_ELEMENT * dataLength * 10); //开辟内存
                earcutWasm.HEAP32.set(res, offset2 / Int32Array.BYTES_PER_ELEMENT);

                var len = earcutwasm(offset, dataLength, offset1, holeLength, 2, offset2);
                var result = new Int32Array(earcutWasm.HEAP32.buffer, offset2, len);
                indices = new Int32Array(result);
                earcutWasm._free(offset);
                earcutWasm._free(offset1);
                earcutWasm._free(offset2);
            }  else {
                indices = earcut2_2_1.earcut(flattened, holeIndices);
            }
            
            for (var i$1 = 0; i$1 < indices.length; i$1 += 3) {
                this.indexArray.emplaceBack(
                    triangleIndex + indices[i$1],
                    triangleIndex + indices[i$1 + 1],
                    triangleIndex + indices[i$1 + 2]);
            }

            triangleSegment.vertexLength += numVertices;
            triangleSegment.primitiveLength += indices.length / 3;
        }
        this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, feature, index, imagePositions);
    };

    WebWorkerTransfer.register('FillBucket', FillBucket, {omit: ['layers', 'patternFeatures']});

    var Struct = function Struct(structArray           , index      ) {
        (this   )._structArray = structArray;
        this._pos1 = index * this.size;
        this._pos2 = this._pos1 / 2;
        this._pos4 = this._pos1 / 4;
        this._pos8 = this._pos1 / 8;
    };

    var DEFAULT_CAPACITY$1 = 128;
    var RESIZE_MULTIPLIER$1 = 5;

    /**
     * `StructArray` provides an abstraction over `ArrayBuffer` and `TypedArray`
     * making it behave like an array of typed structs.
     *
     * Conceptually, a StructArray is comprised of elements, i.e., instances of its
     * associated struct type. Each particular struct type, together with an
     * alignment size, determines the memory layout of a StructArray whose elements
     * are of that type.  Thus, for each such layout that we need, we have
     * a corrseponding StructArrayLayout class, inheriting from StructArray and
     * implementing `emplaceBack()` and `_refreshViews()`.
     *
     * In some cases, where we need to access particular elements of a StructArray,
     * we implement a more specific subclass that inherits from one of the
     * StructArrayLayouts and adds a `get(i): T` accessor that returns a structured
     * object whose properties are proxies into the underlying memory space for the
     * i-th element.  This affords the convience of working with (seemingly) plain
     * Javascript objects without the overhead of serializing/deserializing them
     * into ArrayBuffers for efficient web worker transfer.
     *
     * @private
     */
    var StructArray$1 = function StructArray() {
        this.isTransferred = false;
        this.capacity = -1;
        this.resize(0);
    };

    /**
     * Serialize a StructArray instance.Serializes both the raw data and the
     * metadata needed to reconstruct the StructArray base class during
     * deserialization.
     */
    StructArray$1.serialize = function serialize (array, transferables) {
        //assert_1(!array.isTransferred);
        if(array.isTransferred){
            console.log("StructArray array.isTransferred.");
        }

        array._trim();

        if (transferables) {
            array.isTransferred = true;
            transferables.push(array.arrayBuffer);
        }

        return {
            length: array.length,
            arrayBuffer: array.arrayBuffer,
        };
    };

    StructArray$1.deserialize = function deserialize (input                     ) {
        var structArray = Object.create(this.prototype);
        structArray.arrayBuffer = input.arrayBuffer;
        structArray.length = input.length;
        structArray.capacity = input.arrayBuffer.byteLength / structArray.bytesPerElement;
        structArray._refreshViews();
        return structArray;
    };

    /**
     * Resize the array to discard unused capacity.
     */
    StructArray$1.prototype._trim = function _trim () {
        if (this.length !== this.capacity) {
            this.capacity = this.length;
            this.arrayBuffer = this.arrayBuffer.slice(0, this.length * this.bytesPerElement);
            this._refreshViews();
        }
    };

    /**
     * Resets the the length of the array to 0 without de-allocating capcacity.
     */
    StructArray$1.prototype.clear = function clear () {
        this.length = 0;
    };

    /**
     * Resize the array.
     * If `n` is greater than the current length then additional elements with undefined values are added.
     * If `n` is less than the current length then the array will be reduced to the first `n` elements.
     * @param {number} n The new size of the array.
     */
    StructArray$1.prototype.resize = function resize (n      ) {
        //assert_1(!this.isTransferred);
        this.reserve(n);
        this.length = n;
    };

    /**
     * Indicate a planned increase in size, so that any necessary allocation may
     * be done once, ahead of time.
     * @param {number} n The expected size of the array.
     */
    StructArray$1.prototype.reserve = function reserve (n      ) {
        if (n > this.capacity) {
            this.capacity = Math.max(n, Math.floor(this.capacity * RESIZE_MULTIPLIER$1), DEFAULT_CAPACITY$1);
            this.arrayBuffer = new ArrayBuffer(this.capacity * this.bytesPerElement);

            var oldUint8Array = this.uint8;
            this._refreshViews();
            if (oldUint8Array) { this.uint8.set(oldUint8Array); }
        }
    };

    /**
     * Create TypedArray views for the current ArrayBuffer.
     */
    StructArray$1.prototype._refreshViews = function _refreshViews () {
        throw new Error('_refreshViews() must be implemented by each concrete StructArray layout');
    };
    /**
     * Implementation of the StructArray layout:
     * [0]: Uint32[1]
     * [4]: Uint16[2]
     *
     * @private
     */
    var StructArrayLayout1ul2ui8 = /*@__PURE__*/(function (StructArray) {
        function StructArrayLayout1ul2ui8 () {
            StructArray.apply(this, arguments);
        }

        if ( StructArray ) StructArrayLayout1ul2ui8.__proto__ = StructArray;
        StructArrayLayout1ul2ui8.prototype = Object.create( StructArray && StructArray.prototype );
        StructArrayLayout1ul2ui8.prototype.constructor = StructArrayLayout1ul2ui8;

        StructArrayLayout1ul2ui8.prototype._refreshViews = function _refreshViews () {
            this.uint8 = new Uint8Array(this.arrayBuffer);
            this.uint32 = new Uint32Array(this.arrayBuffer);
            this.uint16 = new Uint16Array(this.arrayBuffer);
        };

        StructArrayLayout1ul2ui8.prototype.emplaceBack = function emplaceBack (v0        , v1        , v2        ) {
            var i = this.length;
            this.resize(i + 1);
            return this.emplace(i, v0, v1, v2);
        };

        StructArrayLayout1ul2ui8.prototype.emplace = function emplace (i        , v0        , v1        , v2        ) {
            var o4 = i * 2;
            var o2 = i * 4;
            this.uint32[o4 + 0] = v0;
            this.uint16[o2 + 2] = v1;
            this.uint16[o2 + 3] = v2;
            return i;
        };

        return StructArrayLayout1ul2ui8;
    }(StructArray$1));

    StructArrayLayout1ul2ui8.prototype.bytesPerElement = 8;

    var FeatureIndexStruct = /*@__PURE__*/(function (Struct) {
        function FeatureIndexStruct () {
            Struct.apply(this, arguments);
        }

        if ( Struct ) FeatureIndexStruct.__proto__ = Struct;
        FeatureIndexStruct.prototype = Object.create( Struct && Struct.prototype );
        FeatureIndexStruct.prototype.constructor = FeatureIndexStruct;

        var prototypeAccessors$5 = { featureIndex: { configurable: true },sourceLayerIndex: { configurable: true },bucketIndex: { configurable: true } };

        prototypeAccessors$5.featureIndex.get = function () { return this._structArray.uint32[this._pos4 + 0]; };
        prototypeAccessors$5.featureIndex.set = function (x        ) { this._structArray.uint32[this._pos4 + 0] = x; };
        prototypeAccessors$5.sourceLayerIndex.get = function () { return this._structArray.uint16[this._pos2 + 2]; };
        prototypeAccessors$5.sourceLayerIndex.set = function (x        ) { this._structArray.uint16[this._pos2 + 2] = x; };
        prototypeAccessors$5.bucketIndex.get = function () { return this._structArray.uint16[this._pos2 + 3]; };
        prototypeAccessors$5.bucketIndex.set = function (x        ) { this._structArray.uint16[this._pos2 + 3] = x; };

        Object.defineProperties( FeatureIndexStruct.prototype, prototypeAccessors$5 );

        return FeatureIndexStruct;
    }(Struct));

    FeatureIndexStruct.prototype.size = 8;

    /**
     * @private
     */
    var FeatureIndexArray = /*@__PURE__*/(function (StructArrayLayout1ul2ui8) {
        function FeatureIndexArray () {
            StructArrayLayout1ul2ui8.apply(this, arguments);
        }

        if ( StructArrayLayout1ul2ui8 ) FeatureIndexArray.__proto__ = StructArrayLayout1ul2ui8;
        FeatureIndexArray.prototype = Object.create( StructArrayLayout1ul2ui8 && StructArrayLayout1ul2ui8.prototype );
        FeatureIndexArray.prototype.constructor = FeatureIndexArray;

        FeatureIndexArray.prototype.get = function get (index        )                     {
            //assert_1(!this.isTransferred);
            return new FeatureIndexStruct(this, index);
        };

        return FeatureIndexArray;
    }(StructArrayLayout1ul2ui8));

    WebWorkerTransfer.register('FeatureIndexArray', FeatureIndexArray, {omit: ['layers', 'patternFeatures']});
    var arrayTypes = {
        FeatureIndexArray : FeatureIndexArray
    };

    /**
     * A standalone point geometry with useful accessor, comparison, and
     * modification methods.
     *
     * @class Point
     * @param {Number} x the x-coordinate. this could be longitude or screen
     * pixels, or any other sort of unit.
     * @param {Number} y the y-coordinate. this could be latitude or screen
     * pixels, or any other sort of unit.
     * @example
     * var point = new Point(-77, 38);
     */
    function Point(x, y) {
        this.x = x;
        this.y = y;
    }

    Point.prototype = {

        /**
         * Clone this point, returning a new point that can be modified
         * without affecting the old one.
         * @return {Point} the clone
         */
        clone: function() { return new Point(this.x, this.y); },

        /**
         * Add this point's x & y coordinates to another point,
         * yielding a new point.
         * @param {Point} p the other point
         * @return {Point} output point
         */
        add:     function(p) { return this.clone()._add(p); },

        /**
         * Subtract this point's x & y coordinates to from point,
         * yielding a new point.
         * @param {Point} p the other point
         * @return {Point} output point
         */
        sub:     function(p) { return this.clone()._sub(p); },

        /**
         * Multiply this point's x & y coordinates by point,
         * yielding a new point.
         * @param {Point} p the other point
         * @return {Point} output point
         */
        multByPoint:    function(p) { return this.clone()._multByPoint(p); },

        /**
         * Divide this point's x & y coordinates by point,
         * yielding a new point.
         * @param {Point} p the other point
         * @return {Point} output point
         */
        divByPoint:     function(p) { return this.clone()._divByPoint(p); },

        /**
         * Multiply this point's x & y coordinates by a factor,
         * yielding a new point.
         * @param {Point} k factor
         * @return {Point} output point
         */
        mult:    function(k) { return this.clone()._mult(k); },

        /**
         * Divide this point's x & y coordinates by a factor,
         * yielding a new point.
         * @param {Point} k factor
         * @return {Point} output point
         */
        div:     function(k) { return this.clone()._div(k); },

        /**
         * Rotate this point around the 0, 0 origin by an angle a,
         * given in radians
         * @param {Number} a angle to rotate around, in radians
         * @return {Point} output point
         */
        rotate:  function(a) { return this.clone()._rotate(a); },

        /**
         * Rotate this point around p point by an angle a,
         * given in radians
         * @param {Number} a angle to rotate around, in radians
         * @param {Point} p Point to rotate around
         * @return {Point} output point
         */
        rotateAround:  function(a,p) { return this.clone()._rotateAround(a,p); },

        /**
         * Multiply this point by a 4x1 transformation matrix
         * @param {Array<Number>} m transformation matrix
         * @return {Point} output point
         */
        matMult: function(m) { return this.clone()._matMult(m); },

        /**
         * Calculate this point but as a unit vector from 0, 0, meaning
         * that the distance from the resulting point to the 0, 0
         * coordinate will be equal to 1 and the angle from the resulting
         * point to the 0, 0 coordinate will be the same as before.
         * @return {Point} unit vector point
         */
        unit:    function() { return this.clone()._unit(); },

        /**
         * Compute a perpendicular point, where the new y coordinate
         * is the old x coordinate and the new x coordinate is the old y
         * coordinate multiplied by -1
         * @return {Point} perpendicular point
         */
        perp:    function() { return this.clone()._perp(); },

        /**
         * Return a version of this point with the x & y coordinates
         * rounded to integers.
         * @return {Point} rounded point
         */
        round:   function() { return this.clone()._round(); },

        /**
         * Return the magitude of this point: this is the Euclidean
         * distance from the 0, 0 coordinate to this point's x and y
         * coordinates.
         * @return {Number} magnitude
         */
        mag: function() {
            return Math.sqrt(this.x * this.x + this.y * this.y);
        },

        /**
         * Judge whether this point is equal to another point, returning
         * true or false.
         * @param {Point} other the other point
         * @return {boolean} whether the points are equal
         */
        equals: function(other) {
            return this.x === other.x &&
                this.y === other.y;
        },

        /**
         * Calculate the distance from this point to another point
         * @param {Point} p the other point
         * @return {Number} distance
         */
        dist: function(p) {
            return Math.sqrt(this.distSqr(p));
        },

        /**
         * Calculate the distance from this point to another point,
         * without the square root step. Useful if you're comparing
         * relative distances.
         * @param {Point} p the other point
         * @return {Number} distance
         */
        distSqr: function(p) {
            var dx = p.x - this.x,
                dy = p.y - this.y;
            return dx * dx + dy * dy;
        },

        /**
         * Get the angle from the 0, 0 coordinate to this point, in radians
         * coordinates.
         * @return {Number} angle
         */
        angle: function() {
            return Math.atan2(this.y, this.x);
        },

        /**
         * Get the angle from this point to another point, in radians
         * @param {Point} b the other point
         * @return {Number} angle
         */
        angleTo: function(b) {
            return Math.atan2(this.y - b.y, this.x - b.x);
        },

        /**
         * Get the angle between this point and another point, in radians
         * @param {Point} b the other point
         * @return {Number} angle
         */
        angleWith: function(b) {
            return this.angleWithSep(b.x, b.y);
        },

        /*
         * Find the angle of the two vectors, solving the formula for
         * the cross product a x b = |a||b|sin(θ) for θ.
         * @param {Number} x the x-coordinate
         * @param {Number} y the y-coordinate
         * @return {Number} the angle in radians
         */
        angleWithSep: function(x, y) {
            return Math.atan2(
                this.x * y - this.y * x,
                this.x * x + this.y * y);
        },

        _matMult: function(m) {
            var x = m[0] * this.x + m[1] * this.y,
                y = m[2] * this.x + m[3] * this.y;
            this.x = x;
            this.y = y;
            return this;
        },

        _add: function(p) {
            this.x += p.x;
            this.y += p.y;
            return this;
        },

        _sub: function(p) {
            this.x -= p.x;
            this.y -= p.y;
            return this;
        },

        _mult: function(k) {
            this.x *= k;
            this.y *= k;
            return this;
        },

        _div: function(k) {
            this.x /= k;
            this.y /= k;
            return this;
        },

        _multByPoint: function(p) {
            this.x *= p.x;
            this.y *= p.y;
            return this;
        },

        _divByPoint: function(p) {
            this.x /= p.x;
            this.y /= p.y;
            return this;
        },

        _unit: function() {
            this._div(this.mag());
            return this;
        },

        _perp: function() {
            var y = this.y;
            this.y = this.x;
            this.x = -y;
            return this;
        },

        _rotate: function(angle) {
            var cos = Math.cos(angle),
                sin = Math.sin(angle),
                x = cos * this.x - sin * this.y,
                y = sin * this.x + cos * this.y;
            this.x = x;
            this.y = y;
            return this;
        },

        _rotateAround: function(angle, p) {
            var cos = Math.cos(angle),
                sin = Math.sin(angle),
                x = p.x + cos * (this.x - p.x) - sin * (this.y - p.y),
                y = p.y + sin * (this.x - p.x) + cos * (this.y - p.y);
            this.x = x;
            this.y = y;
            return this;
        },

        _round: function() {
            this.x = Math.round(this.x);
            this.y = Math.round(this.y);
            return this;
        }
    };

    /**
     * Construct a point from an array if necessary, otherwise if the input
     * is already a Point, or an unknown type, return it unchanged
     * @param {Array<Number>|Point|*} a any kind of input value
     * @return {Point} constructed point, or passed-through value.
     * @example
     * // this
     * var point = Point.convert([0, 1]);
     * // is equivalent to
     * var point = new Point(0, 1);
     */
    Point.convert = function (a) {
        if (a instanceof Point) {
            return a;
        }
        if (Array.isArray(a)) {
            return new Point(a[0], a[1]);
        }
        return a;
    };

    function VectorTileFeature(pbf, end, extent, keys, values) {
        // Public
        this.properties = {};
        this.extent = extent;
        this.type = 0;

        // Private
        this._pbf = pbf;
        this._geometry = -1;
        this._keys = keys;
        this._values = values;

        pbf.readFields(readFeature, this, end);
    }

    function readFeature(tag, feature, pbf) {
        if (tag == 1) feature.id = pbf.readVarint();
        else if (tag == 2) readTag(pbf, feature);
        else if (tag == 3) feature.type = pbf.readVarint();
        else if (tag == 4) feature._geometry = pbf.pos;
    }

    function readTag(pbf, feature) {
        var end = pbf.readVarint() + pbf.pos;

        while (pbf.pos < end) {
            var key = feature._keys[pbf.readVarint()],
                value = feature._values[pbf.readVarint()];
            feature.properties[key] = value;
        }
    }

    VectorTileFeature.types = ['Unknown', 'Point', 'LineString', 'Polygon'];

    VectorTileFeature.prototype.loadGeometry = function() {
        var pbf = this._pbf;
        pbf.pos = this._geometry;

        var end = pbf.readVarint() + pbf.pos,
            cmd = 1,
            length = 0,
            x = 0,
            y = 0,
            lines = [],
            line;

        while (pbf.pos < end) {
            if (length <= 0) {
                var cmdLen = pbf.readVarint();
                cmd = cmdLen & 0x7;
                length = cmdLen >> 3;
            }

            length--;

            if (cmd === 1 || cmd === 2) {
                x += pbf.readSVarint();
                y += pbf.readSVarint();

                if (cmd === 1) { // moveTo
                    if (line) lines.push(line);
                    line = [];
                }

                line.push(new Point(x, y));

            } else if (cmd === 7) {

                // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
                if (line) {
                    line.push(line[0].clone()); // closePolygon
                }

            } else {
                throw new Error('unknown command ' + cmd);
            }
        }

        if (line) lines.push(line);

        return lines;
    };

    VectorTileFeature.prototype.bbox = function() {
        var pbf = this._pbf;
        pbf.pos = this._geometry;

        var end = pbf.readVarint() + pbf.pos,
            cmd = 1,
            length = 0,
            x = 0,
            y = 0,
            x1 = Infinity,
            x2 = -Infinity,
            y1 = Infinity,
            y2 = -Infinity;

        while (pbf.pos < end) {
            if (length <= 0) {
                var cmdLen = pbf.readVarint();
                cmd = cmdLen & 0x7;
                length = cmdLen >> 3;
            }

            length--;

            if (cmd === 1 || cmd === 2) {
                x += pbf.readSVarint();
                y += pbf.readSVarint();
                if (x < x1) x1 = x;
                if (x > x2) x2 = x;
                if (y < y1) y1 = y;
                if (y > y2) y2 = y;

            } else if (cmd !== 7) {
                throw new Error('unknown command ' + cmd);
            }
        }

        return [x1, y1, x2, y2];
    };

    VectorTileFeature.prototype.toGeoJSON = function(x, y, z) {
        var size = this.extent * Math.pow(2, z),
            x0 = this.extent * x,
            y0 = this.extent * y,
            coords = this.loadGeometry(),
            type = VectorTileFeature.types[this.type],
            i, j;

        function project(line) {
            for (var j = 0; j < line.length; j++) {
                var p = line[j], y2 = 180 - (p.y + y0) * 360 / size;
                line[j] = [
                    (p.x + x0) * 360 / size - 180,
                    360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90
                ];
            }
        }

        switch (this.type) {
            case 1:
                var points = [];
                for (i = 0; i < coords.length; i++) {
                    points[i] = coords[i][0];
                }
                coords = points;
                project(coords);
                break;

            case 2:
                for (i = 0; i < coords.length; i++) {
                    project(coords[i]);
                }
                break;

            case 3:
                coords = classifyRings$1(coords);
                for (i = 0; i < coords.length; i++) {
                    for (j = 0; j < coords[i].length; j++) {
                        project(coords[i][j]);
                    }
                }
                break;
        }

        if (coords.length === 1) {
            coords = coords[0];
        } else {
            type = 'Multi' + type;
        }

        var result = {
            type: "Feature",
            geometry: {
                type: type,
                coordinates: coords
            },
            properties: this.properties
        };

        if ('id' in this) {
            result.id = this.id;
        }

        return result;
    };

    // classifies an array of rings into polygons with outer rings and holes

    function classifyRings$1(rings) {
        var len = rings.length;

        if (len <= 1) return [rings];

        var polygons = [],
            polygon,
            ccw;

        for (var i = 0; i < len; i++) {
            var area = signedArea(rings[i]);
            if (area === 0) continue;

            if (ccw === undefined) ccw = area < 0;

            if (ccw === area < 0) {
                if (polygon) polygons.push(polygon);
                polygon = [rings[i]];

            } else {
                polygon.push(rings[i]);
            }
        }
        if (polygon) polygons.push(polygon);

        return polygons;
    }

    function signedArea(ring) {
        var sum = 0;
        for (var i = 0, len = ring.length, j = len - 1, p1, p2; i < len; j = i++) {
            p1 = ring[i];
            p2 = ring[j];
            sum += (p2.x - p1.x) * (p1.y + p2.y);
        }
        return sum;
    }

    function VectorTileLayer(pbf, end) {
        // Public
        this.version = 1;
        this.name = null;
        this.extent = 4096;
        this.length = 0;

        // Private
        this._pbf = pbf;
        this._keys = [];
        this._values = [];
        this._features = [];

        pbf.readFields(readLayer, this, end);

        this.length = this._features.length;
    }

    function readLayer(tag, layer, pbf) {
        if (tag === 15) layer.version = pbf.readVarint();
        else if (tag === 1) layer.name = pbf.readString();
        else if (tag === 5) layer.extent = pbf.readVarint();
        else if (tag === 2) layer._features.push(pbf.pos);
        else if (tag === 3) layer._keys.push(pbf.readString());
        else if (tag === 4) layer._values.push(readValueMessage(pbf));
    }

    function readValueMessage(pbf) {
        var value = null,
            end = pbf.readVarint() + pbf.pos;

        while (pbf.pos < end) {
            var tag = pbf.readVarint() >> 3;

            value = tag === 1 ? pbf.readString() :
                tag === 2 ? pbf.readFloat() :
                    tag === 3 ? pbf.readDouble() :
                        tag === 4 ? pbf.readVarint64() :
                            tag === 5 ? pbf.readVarint() :
                                tag === 6 ? pbf.readSVarint() :
                                    tag === 7 ? pbf.readBoolean() : null;
        }

        return value;
    }

    // return feature `i` from this layer as a `VectorTileFeature`
    VectorTileLayer.prototype.feature = function(i) {
        if (i < 0 || i >= this._features.length) throw new Error('feature index out of bounds');

        this._pbf.pos = this._features[i];

        var end = this._pbf.readVarint() + this._pbf.pos;
        return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
    };

    function VectorTile(pbf, end) {
        this.layers = pbf.readFields(readTile, {}, end);
    }

    function readTile(tag, layers, pbf) {
        if (tag === 3) {
            var layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
            if (layer.length) layers[layer.name] = layer;
        }
    }

    var NUM_PARAMS = 3;

    function GridIndex(extent, n, padding) {
        var cells = this.cells = [];

        if (extent instanceof ArrayBuffer) {
            this.arrayBuffer = extent;
            var array = new Int32Array(this.arrayBuffer);
            extent = array[0];
            n = array[1];
            padding = array[2];

            this.d = n + 2 * padding;
            for (var k = 0; k < this.d * this.d; k++) {
                var start = array[NUM_PARAMS + k];
                var end = array[NUM_PARAMS + k + 1];
                cells.push(start === end ?
                        null :
                        array.subarray(start, end));
            }
            var keysOffset = array[NUM_PARAMS + cells.length];
            var bboxesOffset = array[NUM_PARAMS + cells.length + 1];
            this.keys = array.subarray(keysOffset, bboxesOffset);
            this.bboxes = array.subarray(bboxesOffset);

            this.insert = this._insertReadonly;

        } else {
            this.d = n + 2 * padding;
            for (var i = 0; i < this.d * this.d; i++) {
                cells.push([]);
            }
            this.keys = [];
            this.bboxes = [];
        }

        this.n = n;
        this.extent = extent;
        this.padding = padding;
        this.scale = n / extent;
        this.uid = 0;

        var p = (padding / n) * extent;
        this.min = -p;
        this.max = extent + p;
    }


    GridIndex.prototype.insert = function(key, x1, y1, x2, y2) {
        this._forEachCell(x1, y1, x2, y2, this._insertCell, this.uid++);
        this.keys.push(key);
        this.bboxes.push(x1);
        this.bboxes.push(y1);
        this.bboxes.push(x2);
        this.bboxes.push(y2);
    };

    GridIndex.prototype._insertReadonly = function() {
        throw 'Cannot insert into a GridIndex created from an ArrayBuffer.';
    };

    GridIndex.prototype._insertCell = function(x1, y1, x2, y2, cellIndex, uid) {
        this.cells[cellIndex].push(uid);
    };

    GridIndex.prototype.query = function(x1, y1, x2, y2, intersectionTest) {
        var min = this.min;
        var max = this.max;
        if (x1 <= min && y1 <= min && max <= x2 && max <= y2 && !intersectionTest) {
            // We use `Array#slice` because `this.keys` may be a `Int32Array` and
            // some browsers (Safari and IE) do not support `TypedArray#slice`
            // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice#Browser_compatibility
            return Array.prototype.slice.call(this.keys);

        } else {
            var result = [];
            var seenUids = {};
            this._forEachCell(x1, y1, x2, y2, this._queryCell, result, seenUids, intersectionTest);
            return result;
        }
    };

    GridIndex.prototype._queryCell = function(x1, y1, x2, y2, cellIndex, result, seenUids, intersectionTest) {
        var cell = this.cells[cellIndex];
        if (cell !== null) {
            var keys = this.keys;
            var bboxes = this.bboxes;
            for (var u = 0; u < cell.length; u++) {
                var uid = cell[u];
                if (seenUids[uid] === undefined) {
                    var offset = uid * 4;
                    if (intersectionTest ?
                        intersectionTest(bboxes[offset + 0], bboxes[offset + 1], bboxes[offset + 2], bboxes[offset + 3]) :
                        ((x1 <= bboxes[offset + 2]) &&
                        (y1 <= bboxes[offset + 3]) &&
                        (x2 >= bboxes[offset + 0]) &&
                        (y2 >= bboxes[offset + 1]))) {
                        seenUids[uid] = true;
                        result.push(keys[uid]);
                    } else {
                        seenUids[uid] = false;
                    }
                }
            }
        }
    };

    GridIndex.prototype._forEachCell = function(x1, y1, x2, y2, fn, arg1, arg2, intersectionTest) {
        var cx1 = this._convertToCellCoord(x1);
        var cy1 = this._convertToCellCoord(y1);
        var cx2 = this._convertToCellCoord(x2);
        var cy2 = this._convertToCellCoord(y2);
        for (var x = cx1; x <= cx2; x++) {
            for (var y = cy1; y <= cy2; y++) {
                var cellIndex = this.d * y + x;
                if (intersectionTest && !intersectionTest(
                            this._convertFromCellCoord(x),
                            this._convertFromCellCoord(y),
                            this._convertFromCellCoord(x + 1),
                            this._convertFromCellCoord(y + 1))) { continue; }
                if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, intersectionTest)) { return; }
            }
        }
    };

    GridIndex.prototype._convertFromCellCoord = function(x) {
        return (x - this.padding) / this.scale;
    };

    GridIndex.prototype._convertToCellCoord = function(x) {
        return Math.max(0, Math.min(this.d - 1, Math.floor(x * this.scale) + this.padding));
    };

    GridIndex.prototype.toArrayBuffer = function() {
        if (this.arrayBuffer) { return this.arrayBuffer; }

        var cells = this.cells;

        var metadataLength = NUM_PARAMS + this.cells.length + 1 + 1;
        var totalCellLength = 0;
        for (var i = 0; i < this.cells.length; i++) {
            totalCellLength += this.cells[i].length;
        }

        var array = new Int32Array(metadataLength + totalCellLength + this.keys.length + this.bboxes.length);
        array[0] = this.extent;
        array[1] = this.n;
        array[2] = this.padding;

        var offset = metadataLength;
        for (var k = 0; k < cells.length; k++) {
            var cell = cells[k];
            array[NUM_PARAMS + k] = offset;
            array.set(cell, offset);
            offset += cell.length;
        }

        array[NUM_PARAMS + cells.length] = offset;
        array.set(this.keys, offset);
        offset += this.keys.length;

        array[NUM_PARAMS + cells.length + 1] = offset;
        array.set(this.bboxes, offset);
        offset += this.bboxes.length;

        return array.buffer;
    };

    WebWorkerTransfer.register('GridIndex', GridIndex, {omit: ['layers', 'patternFeatures']});

    /**
     * @module util
     * @private
     */
    function Util() {
    }

    /**
     * Given a value `t` that varies between 0 and 1, return
     * an interpolation function that eases between 0 and 1 in a pleasing
     * cubic in-out fashion.
     *
     * @private
     */
    Util.easeCubicInOut = function (t) {
        if (t <= 0) {
            return 0;
        }
        if (t >= 1) {
            return 1;
        }
        var t2 = t * t,
            t3 = t2 * t;
        return 4 * (t < 0.5 ? t3 : 3 * (t - t2) + t3 - 0.75);
    };

    /*
     * Call an asynchronous function on an array of arguments,
     * calling `callback` with the completed results of all calls.
     *
     * @param array input to each call of the async function.
     * @param fn an async function with signature (data, callback)
     * @param callback a callback run after all async work is done.
     * called with an array, containing the results of each async call.
     * @private
     */
    Util.asyncAll = function (array, fn, callback) {
        if (!array.length) {
            return callback(null, []);
        }
        var remaining = array.length;
        var results = new Array(array.length);
        var error = null;
        array.forEach(function (item, i) {
            fn(item, function (err, result) {
                if (err) {
                    error = err;
                }
                results[i] = ((result     )        ); // https://github.com/facebook/flow/issues/2123
                if (--remaining === 0) {
                    callback(error, results);
                }
            });
        });
    };

    /**
     * Given a destination object and optionally many source objects,
     * copy all properties from the source objects into the destination.
     * The last source object given overrides properties from previous
     * source objects.
     *
     * @param dest destination object
     * @param sources sources from which properties are pulled
     * @private
     */
    Util.extend = function (dest) {
        var sources = [], len = arguments.length - 1;
        while (len-- > 0) sources[ len ] = arguments[ len + 1 ];

        for (var i = 0, list = sources; i < list.length; i += 1) {
            var src = list[i];

            for (var k in src) {
                dest[k] = src[k];
            }
        }
        return dest;
    };

    var id = 1;

    /**
     * Return a unique numeric id, starting at 1 and incrementing with
     * each call.
     *
     * @returns unique numeric id.
     * @private
     */
    Util.uniqueId = function () {
        return id++;
    };

    /**
     * Return a random UUID (v4). Taken from: https://gist.github.com/jed/982883
     * @private
     */
    Util.uuid = function () {
        function b(a) {
            return a ? (a ^ Math.random() * 16 >> a / 4).toString(16) :
                //$FlowFixMe: Flow doesn't like the implied array literal conversion here
                ([1e7] + -[1e3] + -4e3 + -8e3 + -1e11).replace(/[018]/g, b);
        }

        return b();
    };

    /**
     * Validate a string to match UUID(v4) of the
     * form: xxxxxxxx-xxxx-4xxx-[89ab]xxx-xxxxxxxxxxxx
     * @param str string to validate.
     * @private
     */
    Util.validateUuid = function (str) {
        return str ? /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(str) : false;
    };

    /**
     * Given an array of member function names as strings, replace all of them
     * with bound versions that will always refer to `context` as `this`. This
     * is useful for classes where otherwise event bindings would reassign
     * `this` to the evented object or some other value: this lets you ensure
     * the `this` value always.
     *
     * @param fns list of member function names
     * @param context the context value
     * @example
     * function MyClass() {
    *   bindAll(['ontimer'], this);
    *   this.name = 'Tom';
    * }
     * MyClass.prototype.ontimer = function() {
    *   alert(this.name);
    * };
     * var myClass = new MyClass();
     * setTimeout(myClass.ontimer, 100);
     * @private
     */
    Util.bindAll = function (fns, context) {
        fns.forEach(function (fn) {
            if (!context[fn]) {
                return;
            }
            context[fn] = context[fn].bind(context);
        });
    };

    /**
     * Determine if a string ends with a particular substring
     *
     * @private
     */
    Util.endsWith = function (string, suffix) {
        return string.indexOf(suffix, string.length - suffix.length) !== -1;
    };

    /**
     * Create an object by mapping all the values of an existing object while
     * preserving their keys.
     *
     * @private
     */
    Util.mapObject = function (input, iterator, context) {
        var output = {};
        for (var key in input) {
            output[key] = iterator.call(context || this, input[key], key, input);
        }
        return output;
    };

    /**
     * Create an object by filtering out values of an existing object.
     *
     * @private
     */
    Util.filterObject = function (input, iterator, context) {
        var output = {};
        for (var key in input) {
            if (iterator.call(context || this, input[key], key, input)) {
                output[key] = input[key];
            }
        }
        return output;
    };

    /**
     * Deeply clones two objects.
     *
     * @private
     */
    Util.clone = function (input) {
        if (Array.isArray(input)) {
            return input.map(Util.clone);
        } else if (typeof input === 'object' && input) {
            return ((Util.mapObject(input, Util.clone)     )   );
        } else {
            return input;
        }
    };

    Util.deepEqual = function (a, b) {
        if (Array.isArray(a)) {
            if (!Array.isArray(b) || a.length !== b.length) {
                return false;
            }
            for (var i = 0; i < a.length; i++) {
                if (!Util.deepEqual(a[i], b[i])) {
                    return false;
                }
            }
            return true;
        }
        if (typeof a === 'object' && a !== null && b !== null) {
            if (!(typeof b === 'object')) {
                return false;
            }
            var keys = Object.keys(a);
            if (keys.length !== Object.keys(b).length) {
                return false;
            }
            for (var key in a) {
                if (!Util.deepEqual(a[key], b[key])) {
                    return false;
                }
            }
            return true;
        }
        return a === b;
    };

    /**
     * Check if two arrays have at least one common element.
     *
     * @private
     */
    Util.arraysIntersect = function (a, b) {
        for (var l = 0; l < a.length; l++) {
            if (b.indexOf(a[l]) >= 0) {
                return true;
            }
        }
        return false;
    };

    /**
     * Indicates if the provided Points are in a counter clockwise (true) or clockwise (false) order
     *
     * @private
     * @returns true for a counter clockwise set of points
     */
    // http://bryceboe.com/2006/10/23/line-segment-intersection-algorithm/
    Util.isCounterClockwise = function (a, b, c) {
        return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
    };

    /* global self, WorkerGlobalScope */
    /**
     *  Retuns true if the when run in the web-worker context.
     *
     * @private
     * @returns {boolean}
     */
    Util.isWorker = function () {
        return typeof WorkerGlobalScope !== 'undefined' && typeof self !== 'undefined' &&
            self instanceof WorkerGlobalScope;
    };

    var _isSafari = null;

    /**
     * Returns true when run in WebKit derived browsers.
     * This is used as a workaround for a memory leak in Safari caused by using Transferable objects to
     * transfer data between WebWorkers and the main thread.
     * https://github.com/mapbox/mapbox-gl-js/issues/8771
     *
     * This should be removed once the underlying Safari issue is fixed.
     *
     * @private
     * @param scope {WindowOrWorkerGlobalScope} Since this function is used both on the main thread and WebWorker context,
     *      let the calling scope pass in the global scope object.
     * @returns {boolean}
     */
    Util.isSafari = function (scope) {
        if (_isSafari == null) {
            var userAgent = scope.navigator ? scope.navigator.userAgent : null;
            _isSafari = !!scope.safari || !!(userAgent && (/\b(iPad|iPhone|iPod)\b/.test(userAgent) || (!!userAgent.match('Safari') && !userAgent.match('Chrome'))));
        }
        return _isSafari;
    };

    /**
     * Replace tokens in a string template with values in an object
     *
     * @param properties a key/value relationship between tokens and replacements
     * @param text the template string
     * @returns the template with tokens replaced
     * @private
     */
    Util.resolveTokens = function (properties, text) {
        return text.replace(/{([^{}]+)}/g, function (match, key) {
            return key in properties ? String(properties[key]) : '';
        });
    };

    /**
     * Tracks `let` bindings during expression parsing.
     * @private
     */
    var Scope = function Scope(parent, bindings) {
        if (bindings === void 0) bindings = [];

        this.parent = parent;
        this.bindings = {};
        for (var i = 0, list = bindings; i < list.length; i += 1) {
            var ref = list[i];
            var name = ref[0];
            var expression = ref[1];

            this.bindings[name] = expression;
        }
    };

    Scope.prototype.concat = function concat(bindings) {
        return new Scope(this, bindings);
    };

    Scope.prototype.get = function get(name) {
        if (this.bindings[name]) {
            return this.bindings[name];
        }
        if (this.parent) {
            return this.parent.get(name);
        }
        throw new Error((name + " not found in scope."));
    };

    Scope.prototype.has = function has(name) {
        if (this.bindings[name]) {
            return true;
        }
        return this.parent ? this.parent.has(name) : false;
    };

    var ParsingError = /*@__PURE__*/(function (Error) {
        function ParsingError(key        , message        ) {
            Error.call(this, message);
            this.message = message;
            this.key = key;
        }

        if ( Error ) ParsingError.__proto__ = Error;
        ParsingError.prototype = Object.create( Error && Error.prototype );
        ParsingError.prototype.constructor = ParsingError;

        return ParsingError;
    }(Error));

    var geometryTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];

    var EvaluationContext = function EvaluationContext() {
        this.globals = (null );
        this.feature = null;
        this.featureState = null;
        this.formattedSection = null;
        this._parseColorCache = {};
        this.availableImages = null;
    };

    EvaluationContext.prototype.id = function id () {
        return this.feature && 'id' in this.feature ? this.feature.id : null;
    };

    EvaluationContext.prototype.geometryType = function geometryType () {
        return this.feature ? typeof this.feature.type === 'number' ? geometryTypes[this.feature.type] : this.feature.type : null;
    };

    EvaluationContext.prototype.properties = function properties () {
        return this.feature && this.feature.properties || {};
    };

    EvaluationContext.prototype.parseColor = function parseColor (input    )     {
        var cached = this._parseColorCache[input];
        if (!cached) {
            cached = this._parseColorCache[input] = Color.parse(input);
        }
        return cached;
    };

    function isConstant() {
    }

    isConstant.isFeatureConstant = function(e){
        if (e instanceof CompoundExpression) {
            if (e.name === 'get' && e.args.length === 1) {
                return false;
            } else if (e.name === 'feature-state') {
                return false;
            } else if (e.name === 'has' && e.args.length === 1) {
                return false;
            } else if (
                e.name === 'properties' ||
                    e.name === 'geometry-type' ||
                    e.name === 'id'
                ) {
                return false;
            } else if (/^filter-/.test(e.name)) {
                return false;
            }
        }

        var result = true;
        e.eachChild(function (arg) {
            if (result && !isConstant.isFeatureConstant(arg)) {
                result = false;
            }
        });
        return result;
    };

    isConstant.isStateConstant = function(e){
        if (e instanceof CompoundExpression) {
            if (e.name === 'feature-state') {
                return false;
            }
        }
        var result = true;
        e.eachChild(function (arg) {
            if (result && !isConstant.isStateConstant(arg)) {
                result = false;
            }
        });
        return result;
    };

    isConstant.isGlobalPropertyConstant = function(e, properties){
        if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) {
            return false;
        }
        var result = true;
        e.eachChild(function (arg) {
            if (result && !isConstant.isGlobalPropertyConstant(arg, properties)) {
                result = false;
            }
        });
        return result;
    };

    /**
     * State associated parsing at a given point in an expression tree.
     * @private
     */
    var ParsingContext = function ParsingContext(registry, path, expectedType, scope, errors) {
        if (path === void 0) path = [];
        if (scope === void 0) scope = new Scope();
        if (errors === void 0) errors = [];

        this.registry = registry;
        this.path = path;
        this.key = path.map(function (part) {
            return ("[" + part + "]");
        }).join('');
        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
     */
    ParsingContext.prototype.parse = function parse(expr, index, expectedType, bindings, options) {
        if (options === void 0) options = {};

        if (index) {
            return this.concat(index, expectedType, bindings)._parse(expr, options);
        }
        return this._parse(expr, options);
    };

    ParsingContext.prototype._parse = function _parse(expr, options) {
        if (expr === null || typeof expr === 'string' || typeof expr === 'boolean' || typeof expr === 'number') {
            expr = ['literal', expr];
        }

        function annotate(parsed, type, typeAnnotation) {
            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\", []].");
            }

            var 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;
            }

            var Expr = this.registry[op];
            if (Expr) {
                var parsed = Expr.parse(expr, this);
                if (!parsed) {
                    return null;
                }

                if (this.expectedType) {
                    var expected = this.expectedType;
                    var 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()) {
                    var 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
     */
    ParsingContext.prototype.concat = function concat(index, expectedType, bindings) {
        var path = typeof index === 'number' ? this.path.concat(index) : this.path;
        var 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
     */
    ParsingContext.prototype.error = function error(error$1) {
        var keys = [], len = arguments.length - 1;
        while (len-- > 0) keys[ len ] = arguments[ len + 1 ];

        var key = "" + (this.key) + (keys.map(function (k) {
            return ("[" + k + "]");
        }).join(''));
        this.errors.push(new ParsingError(key, error$1));
    };

    /**
     * Returns null if `t` is a subtype of `expected`; otherwise returns an
     * error message and also pushes it to `this.errors`.
     */
    ParsingContext.prototype.checkSubtype = function checkSubtype$1(expected, t) {
        var error = checkSubtype(expected, t);
        if (error) {
            this.error(error);
        }
        return error;
    };

    function get(key, obj) {
        const v = obj[key];
        return typeof v === 'undefined' ? null : v;
    }

    var CompoundExpression$1 = function CompoundExpression(name, type, evaluate, args) {
        this.name = name;
        this.type = type;
        this._evaluate = evaluate;
        this.args = args;
    };

    CompoundExpression$1.prototype.evaluate = function evaluate(ctx) {
        return this._evaluate(ctx, this.args);
    };

    CompoundExpression$1.prototype.eachChild = function eachChild(fn) {
        this.args.forEach(fn);
    };

    CompoundExpression$1.prototype.possibleOutputs = function possibleOutputs() {
        return [undefined];
    };

    CompoundExpression$1.prototype.serialize = function serialize() {
        return [this.name].concat(this.args.map(function (arg) {
            return arg.serialize();
        }));
    };

    CompoundExpression$1.parse = function parse(args, context) {
        var ref$1;

        var op = (args[0] );
        var definition = CompoundExpression$1.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
        var type = Array.isArray(definition) ?
            definition[0] : definition.type;

        var availableOverloads = Array.isArray(definition) ?
            [
                [definition[1], definition[2]]
            ] :
            definition.overloads;

        var overloads = availableOverloads.filter(function (ref) {
            var signature = ref[0];

            return (
                !Array.isArray(signature) || // varags
                    signature.length === args.length - 1 // correct param count
                );
        });

        var signatureContext = (null );

        for (var i$3 = 0, list = overloads; i$3 < list.length; i$3 += 1) {
            // Use a fresh context for each attempted signature so that, if
            // we eventually succeed, we haven't polluted `context.errors`.
            var ref = list[i$3];
            var params = ref[0];
            var evaluate = ref[1];

            signatureContext = new ParsingContext(context.registry, context.path, null, context.scope);

            // First parse all the args, potentially coercing to the
            // types expected by this overload.
            var parsedArgs = [];
            var argParseFailed = false;
            for (var i = 1; i < args.length; i++) {
                var arg = args[i];
                var expectedType = Array.isArray(params) ?
                    params[i - 1] :
                    params.type;

                var 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 (var i$1 = 0; i$1 < parsedArgs.length; i$1++) {
                var expected = Array.isArray(params) ? params[i$1] : params.type;
                var arg$1 = parsedArgs[i$1];
                signatureContext.concat(i$1 + 1).checkSubtype(expected, arg$1.type);
            }

            if (signatureContext.errors.length === 0) {
                return new CompoundExpression$1(op, type, evaluate, parsedArgs);
            }
        }

        //assert_1(!signatureContext || signatureContext.errors.length > 0);

        if (overloads.length === 1) {
            (ref$1 = context.errors).push.apply(ref$1, signatureContext.errors);
        } else {
            var expected$1 = overloads.length ? overloads : availableOverloads;
            var signatures = expected$1
                .map(function (ref) {
                    var params = ref[0];

                    return stringifySignature(params);
                })
                .join(' | ');

            var actualTypes = [];
            // For error message, re-parse arguments without trying to
            // apply any coercions
            for (var i$2 = 1; i$2 < args.length; i$2++) {
                var parsed$1 = context.parse(args[i$2], 1 + actualTypes.length);
                if (!parsed$1) {
                    return null;
                }
                actualTypes.push(toString(parsed$1.type));
            }
            context.error(("Expected arguments of type " + signatures + ", but found (" + (actualTypes.join(', ')) + ") instead."));
        }

        return null;
    };

    CompoundExpression$1.register = function register(registry, definitions) {
        //assert_1(!CompoundExpression.definitions);
        CompoundExpression$1.definitions = definitions;
        for (var name in definitions) {
            registry[name] = CompoundExpression$1;
        }
    };

    function stringifySignature(signature) {
        if (Array.isArray(signature)) {
            return ("(" + (signature.map(toString).join(', ')) + ")");
        } else {
            return ("(" + (toString(signature.type)) + "...)");
        }
    }
    var NumberType$a = {kind: 'number'};
    var StringType$8 = {kind: 'string'};
    var BooleanType$8 = {kind: 'boolean'};
    var ColorType$5 = {kind: 'color'};
    var ObjectType$3 = {kind: 'object'};
    var ValueType$a = {kind: 'value'};
    var ErrorType = {kind: 'error'};
    var CollatorType$3 = {kind: 'collator'};

    function array$5(itemType, N) {
        return {
            kind: 'array',
            itemType: itemType,
            N: N
        };
    }

    function varargs(type) {
        return {type: type};
    }

    function rgba(ctx, ref) {
        var r = ref[0];
        var g = ref[1];
        var b = ref[2];
        var a = ref[3];

        r = r.evaluate(ctx);
        g = g.evaluate(ctx);
        b = b.evaluate(ctx);
        var alpha = a ? a.evaluate(ctx) : 1;
        var error = Values.validateRGBA(r, g, b, alpha);
        if (error) {
            throw new RuntimeError(error);
        }
        return new Color(r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha);
    }

    CompoundExpression$1.register(expressions, {
        'error': [
            ErrorType,
            [StringType$8],
            function (ctx, ref) {
                var v = ref[0];
                throw new RuntimeError(v.evaluate(ctx));
            }
        ],
        'typeof': [
            StringType$8,
            [ValueType$a],
            function (ctx, ref) {
                var v = ref[0];

                return toString(Values.typeOf(v.evaluate(ctx)));
            }
        ],
        'to-rgba': [
            array$5(NumberType$a, 4),
            [ColorType$5],
            function (ctx, ref) {
                var v = ref[0];

                return v.evaluate(ctx).toArray();
            }
        ],
        'rgb': [
            ColorType$5,
            [NumberType$a, NumberType$a, NumberType$a],
            rgba
        ],
        'rgba': [
            ColorType$5,
            [NumberType$a, NumberType$a, NumberType$a, NumberType$a],
            rgba
        ],
        'has': {
            type: BooleanType$8,
            overloads: [
                [
                    [StringType$8],
                    function (ctx, ref) {
                        var key = ref[0];

                        return has(key.evaluate(ctx), ctx.properties());
                    }
                ],
                [
                    [StringType$8, ObjectType$3],
                    function (ctx, ref) {
                        var key = ref[0];
                        var obj = ref[1];

                        return has(key.evaluate(ctx), obj.evaluate(ctx));
                    }
                ]
            ]
        },
        'get': {
            type: ValueType$a,
            overloads: [
                [
                    [StringType$8],
                    function (ctx, ref) {
                        var key = ref[0];

                        return get(key.evaluate(ctx), ctx.properties());
                    }
                ],
                [
                    [StringType$8, ObjectType$3],
                    function (ctx, ref) {
                        var key = ref[0];
                        var obj = ref[1];

                        return get(key.evaluate(ctx), obj.evaluate(ctx));
                    }
                ]
            ]
        },
        'feature-state': [
            ValueType$a,
            [StringType$8],
            function (ctx, ref) {
                var key = ref[0];

                return get(key.evaluate(ctx), ctx.featureState || {});
            }
        ],
        'properties': [
            ObjectType$3,
            [],
            function (ctx) {
                return ctx.properties();
            }
        ],
        'geometry-type': [
            StringType$8,
            [],
            function (ctx) {
                return ctx.geometryType();
            }
        ],
        'id': [
            ValueType$a,
            [],
            function (ctx) {
                return ctx.id();
            }
        ],
        'zoom': [
            NumberType$a,
            [],
            function (ctx) {
                return ctx.globals.zoom;
            }
        ],
        'heatmap-density': [
            NumberType$a,
            [],
            function (ctx) {
                return ctx.globals.heatmapDensity || 0;
            }
        ],
        'line-progress': [
            NumberType$a,
            [],
            function (ctx) {
                return ctx.globals.lineProgress || 0;
            }
        ],
        'accumulated': [
            ValueType$a,
            [],
            function (ctx) {
                return ctx.globals.accumulated === undefined ? null : ctx.globals.accumulated;
            }
        ],
        '+': [
            NumberType$a,
            varargs(NumberType$a),
            function (ctx, args) {
                var result = 0;
                for (var i = 0, list = args; i < list.length; i += 1) {
                    var arg = list[i];

                    result += arg.evaluate(ctx);
                }
                return result;
            }
        ],
        '*': [
            NumberType$a,
            varargs(NumberType$a),
            function (ctx, args) {
                var result = 1;
                for (var i = 0, list = args; i < list.length; i += 1) {
                    var arg = list[i];

                    result *= arg.evaluate(ctx);
                }
                return result;
            }
        ],
        '-': {
            type: NumberType$a,
            overloads: [
                [
                    [NumberType$a, NumberType$a],
                    function (ctx, ref) {
                        var a = ref[0];
                        var b = ref[1];

                        return a.evaluate(ctx) - b.evaluate(ctx);
                    }
                ],
                [
                    [NumberType$a],
                    function (ctx, ref) {
                        var a = ref[0];

                        return -a.evaluate(ctx);
                    }
                ]
            ]
        },
        '/': [
            NumberType$a,
            [NumberType$a, NumberType$a],
            function (ctx, ref) {
                var a = ref[0];
                var b = ref[1];

                return a.evaluate(ctx) / b.evaluate(ctx);
            }
        ],
        '%': [
            NumberType$a,
            [NumberType$a, NumberType$a],
            function (ctx, ref) {
                var a = ref[0];
                var b = ref[1];

                return a.evaluate(ctx) % b.evaluate(ctx);
            }
        ],
        'ln2': [
            NumberType$a,
            [],
            function () {
                return Math.LN2;
            }
        ],
        'pi': [
            NumberType$a,
            [],
            function () {
                return Math.PI;
            }
        ],
        'e': [
            NumberType$a,
            [],
            function () {
                return Math.E;
            }
        ],
        '^': [
            NumberType$a,
            [NumberType$a, NumberType$a],
            function (ctx, ref) {
                var b = ref[0];
                var e = ref[1];

                return Math.pow(b.evaluate(ctx), e.evaluate(ctx));
            }
        ],
        'sqrt': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var x = ref[0];

                return Math.sqrt(x.evaluate(ctx));
            }
        ],
        'log10': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.log(n.evaluate(ctx)) / Math.LN10;
            }
        ],
        'ln': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.log(n.evaluate(ctx));
            }
        ],
        'log2': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.log(n.evaluate(ctx)) / Math.LN2;
            }
        ],
        'sin': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.sin(n.evaluate(ctx));
            }
        ],
        'cos': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.cos(n.evaluate(ctx));
            }
        ],
        'tan': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.tan(n.evaluate(ctx));
            }
        ],
        'asin': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.asin(n.evaluate(ctx));
            }
        ],
        'acos': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.acos(n.evaluate(ctx));
            }
        ],
        'atan': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.atan(n.evaluate(ctx));
            }
        ],
        'min': [
            NumberType$a,
            varargs(NumberType$a),
            function (ctx, args) {
                return Math.min.apply(Math, args.map(function (arg) {
                    return arg.evaluate(ctx);
                }));
            }
        ],
        'max': [
            NumberType$a,
            varargs(NumberType$a),
            function (ctx, args) {
                return Math.max.apply(Math, args.map(function (arg) {
                    return arg.evaluate(ctx);
                }));
            }
        ],
        'abs': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.abs(n.evaluate(ctx));
            }
        ],
        'round': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                var 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$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.floor(n.evaluate(ctx));
            }
        ],
        'ceil': [
            NumberType$a,
            [NumberType$a],
            function (ctx, ref) {
                var n = ref[0];

                return Math.ceil(n.evaluate(ctx));
            }
        ],
        'filter-==': [
            BooleanType$8,
            [StringType$8, ValueType$a],
            function (ctx, ref) {
                var k = ref[0];
                var v = ref[1];

                return ctx.properties()[(k     ).value] === (v     ).value;
            }
        ],
        'filter-id-==': [
            BooleanType$8,
            [ValueType$a],
            function (ctx, ref) {
                var v = ref[0];

                return ctx.id() === (v     ).value;
            }
        ],
        'filter-like': [
            BooleanType$8,
            [StringType$8, StringType$8],
            function (ctx, ref) {
                var a = ref[0].value;
                var b = ref[1].value;
                var properties = ctx.properties();
                return (a in properties) && (properties[a].indexOf(b)) > -1;
            }
        ],
        'filter-type-==': [
            BooleanType$8,
            [StringType$8],
            function (ctx, ref) {
                var v = ref[0];

                return ctx.geometryType() === (v     ).value;
            }
        ],
        'filter-<': [
            BooleanType$8,
            [StringType$8, ValueType$a],
            function (ctx, ref) {
                var k = ref[0];
                var v = ref[1];

                var a = ctx.properties()[(k     ).value];
                var b = (v     ).value;
                return typeof a === typeof b && a < b;
            }
        ],
        'filter-id-<': [
            BooleanType$8,
            [ValueType$a],
            function (ctx, ref) {
                var v = ref[0];

                var a = ctx.id();
                var b = (v     ).value;
                return typeof a === typeof b && a < b;
            }
        ],
        'filter->': [
            BooleanType$8,
            [StringType$8, ValueType$a],
            function (ctx, ref) {
                var k = ref[0];
                var v = ref[1];

                var a = ctx.properties()[(k     ).value];
                var b = (v     ).value;
                return typeof a === typeof b && a > b;
            }
        ],
        'filter-id->': [
            BooleanType$8,
            [ValueType$a],
            function (ctx, ref) {
                var v = ref[0];

                var a = ctx.id();
                var b = (v     ).value;
                return typeof a === typeof b && a > b;
            }
        ],
        'filter-<=': [
            BooleanType$8,
            [StringType$8, ValueType$a],
            function (ctx, ref) {
                var k = ref[0];
                var v = ref[1];

                var a = ctx.properties()[(k     ).value];
                var b = (v     ).value;
                return typeof a === typeof b && a <= b;
            }
        ],
        'filter-id-<=': [
            BooleanType$8,
            [ValueType$a],
            function (ctx, ref) {
                var v = ref[0];

                var a = ctx.id();
                var b = (v     ).value;
                return typeof a === typeof b && a <= b;
            }
        ],
        'filter->=': [
            BooleanType$8,
            [StringType$8, ValueType$a],
            function (ctx, ref) {
                var k = ref[0];
                var v = ref[1];

                var a = ctx.properties()[(k     ).value];
                var b = (v     ).value;
                return typeof a === typeof b && a >= b;
            }
        ],
        'filter-id->=': [
            BooleanType$8,
            [ValueType$a],
            function (ctx, ref) {
                var v = ref[0];

                var a = ctx.id();
                var b = (v     ).value;
                return typeof a === typeof b && a >= b;
            }
        ],
        'filter-has': [
            BooleanType$8,
            [ValueType$a],
            function (ctx, ref) {
                var k = ref[0];

                return (k     ).value in ctx.properties();
            }
        ],
        'filter-has-id': [
            BooleanType$8,
            [],
            function (ctx) {
                return ctx.id() !== null;
            }
        ],
        'filter-type-in': [
            BooleanType$8,
            [array$5(StringType$8)],
            function (ctx, ref) {
                var v = ref[0];

                return (v     ).value.indexOf(ctx.geometryType()) >= 0;
            }
        ],
        'filter-id-in': [
            BooleanType$8,
            [array$5(ValueType$a)],
            function (ctx, ref) {
                var v = ref[0];

                return (v     ).value.indexOf(ctx.id()) >= 0;
            }
        ],
        'filter-in-small': [
            BooleanType$8,
            [StringType$8, array$5(ValueType$a)],
            // assumes v is an array literal
            function (ctx, ref) {
                var k = ref[0];
                var v = ref[1];

                return (v     ).value.indexOf(ctx.properties()[(k     ).value]) >= 0;
            }
        ],
        'filter-in-large': [
            BooleanType$8,
            [StringType$8, array$5(ValueType$a)],
            // assumes v is a array literal with values sorted in ascending order and of a single type
            function (ctx, ref) {
                var k = ref[0];
                var v = ref[1];

                return binarySearch(ctx.properties()[(k     ).value], (v     ).value, 0, (v     ).value.length - 1);
            }
        ],
        'all': {
            type: BooleanType$8,
            overloads: [
                [
                    [BooleanType$8, BooleanType$8],
                    function (ctx, ref) {
                        var a = ref[0];
                        var b = ref[1];

                        return a.evaluate(ctx) && b.evaluate(ctx);
                    }
                ],
                [
                    varargs(BooleanType$8),
                    function (ctx, args) {
                        for (var i = 0, list = args; i < list.length; i += 1) {
                            var arg = list[i];

                            if (!arg.evaluate(ctx)) {
                                return false;
                            }
                        }
                        return true;
                    }
                ]
            ]
        },
        'any': {
            type: BooleanType$8,
            overloads: [
                [
                    [BooleanType$8, BooleanType$8],
                    function (ctx, ref) {
                        var a = ref[0];
                        var b = ref[1];

                        return a.evaluate(ctx) || b.evaluate(ctx);
                    }
                ],
                [
                    varargs(BooleanType$8),
                    function (ctx, args) {
                        for (var i = 0, list = args; i < list.length; i += 1) {
                            var arg = list[i];

                            if (arg.evaluate(ctx)) {
                                return true;
                            }
                        }
                        return false;
                    }
                ]
            ]
        },
        '!': [
            BooleanType$8,
            [BooleanType$8],
            function (ctx, ref) {
                var b = ref[0];

                return !b.evaluate(ctx);
            }
        ],
        'is-supported-script': [
            BooleanType$8,
            [StringType$8],
            // At parse time this will always return true, so we need to exclude this expression with isGlobalPropertyConstant
            function (ctx, ref) {
                var s = ref[0];

                var isSupportedScript = ctx.globals && ctx.globals.isSupportedScript;
                if (isSupportedScript) {
                    return isSupportedScript(s.evaluate(ctx));
                }
                return true;
            }
        ],
        'upcase': [
            StringType$8,
            [StringType$8],
            function (ctx, ref) {
                var s = ref[0];

                return s.evaluate(ctx).toUpperCase();
            }
        ],
        'downcase': [
            StringType$8,
            [StringType$8],
            function (ctx, ref) {
                var s = ref[0];

                return s.evaluate(ctx).toLowerCase();
            }
        ],
        'concat': [
            StringType$8,
            varargs(ValueType$a),
            function (ctx, args) {
                return args.map(function (arg) {
                    return Values.toString$1(arg.evaluate(ctx));
                }).join('');
            }
        ],
        'resolved-locale': [
            StringType$8,
            [CollatorType$3],
            function (ctx, ref) {
                var collator = ref[0];

                return collator.evaluate(ctx).resolvedLocale();
            }
        ]
    });

    var StyleExpression$1 = function StyleExpression(expression, propertySpec) {
        this.expression = expression;
        this._warningHistory = {};
        this._evaluator = new EvaluationContext();
        this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
        this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
    };

    StyleExpression$1.prototype.evaluateWithoutErrorHandling = function evaluateWithoutErrorHandling(globals, feature, featureState, availableImages, formattedSection) {
        this._evaluator.globals = globals;
        this._evaluator.feature = feature;
        this._evaluator.featureState = featureState;
        this._evaluator.availableImages = availableImages || null;
        this._evaluator.formattedSection = formattedSection;

        return this.expression.evaluate(this._evaluator);
    };

    StyleExpression$1.prototype.evaluate = function evaluate(globals, feature, featureState, availableImages, formattedSection) {
        this._evaluator.globals = globals;
        this._evaluator.feature = feature || null;
        this._evaluator.featureState = featureState || null;
        this._evaluator.availableImages = availableImages || null;
        this._evaluator.formattedSection = formattedSection || null;

        try {
            var 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(function (v) {
                    return 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;
        }
    };

    function isFunction(value) {
        return typeof value === 'object' && value !== null && !Array.isArray(value);
    }

    function getDefaultValue(spec) {
        if (spec.type === 'color' && isFunction(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;
        }
    }

    function Expression() {
    }

    function success(value) {
        return {result: 'success', value: value};
    }

    function error(value) {
        return {result: 'error', value: value};
    }

    Expression.isExpression = function (testExpression) {
        return Array.isArray(testExpression) && testExpression.length > 0 &&
            typeof testExpression[0] === 'string' && testExpression[0] in expressions;
    };

    var NumberType$b = {kind: 'number'};
    var StringType$9 = {kind: 'string'};
    var BooleanType$9 = {kind: 'boolean'};
    var ColorType$6 = {kind: 'color'};
    var ValueType$b = {kind: 'value'};
    var FormattedType$3 = {kind: 'formatted'};
    var ResolvedImageType$4 = {kind: 'resolvedImage'};

    function array$6(itemType, N) {
        return {
            kind: 'array',
            itemType: itemType,
            N: N
        };
    }

    function getExpectedType(spec) {
        var types = {
            color: ColorType$6,
            string: StringType$9,
            number: NumberType$b,
            enum: StringType$9,
            boolean: BooleanType$9,
            formatted: FormattedType$3,
            resolvedImage: ResolvedImageType$4
        };

        if (spec.type === 'array') {
            return array$6(types[spec.value] || ValueType$b, spec.length);
        }

        return types[spec.type];
    }

    Expression.createExpression = function (expression, propertySpec) {
        var parser = new ParsingContext(expressions, [], propertySpec ? getExpectedType(propertySpec) : undefined);
        // For string-valued properties, coerce to string at the top level rather than asserting.
        var parsed = parser.parse(expression, undefined, undefined, undefined,
            propertySpec && propertySpec.type === 'string' ? {typeAnnotation: 'coerce'} : undefined);

        if (!parsed) {
            //assert_1(parser.errors.length > 0);
            return error(parser.errors);
        }

        return success(new StyleExpression$1(parsed, propertySpec));
    };


    function isFunction$1(value) {
        return typeof value === 'object' && value !== null && !Array.isArray(value);
    }

    function extend$1(output) {
        var inputs = [], len = arguments.length - 1;
        while (len-- > 0) inputs[ len ] = arguments[ len + 1 ];

        for (var i = 0, list = inputs; i < list.length; i += 1) {
            var input = list[i];

            for (var k in input) {
                output[k] = input[k];
            }
        }
        return output;
    }

    function evaluateIdentityFunction(parameters, propertySpec, input) {
        if (propertySpec.type === 'color') {
            input = Color$1.parse(input);
        } else if (propertySpec.type === 'formatted') {
            input = Formatted.fromString(input.toString());
        } else if (propertySpec.type === 'resolvedImage') {
            input = ResolvedImage.fromString(input.toString());
        } else if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values[input])) {
            input = undefined;
        }
        return coalesce(input, parameters.default, propertySpec.default);
    }

    function createFunction(parameters, propertySpec) {
        var isColor = propertySpec.type === 'color';
        var zoomAndFeatureDependent = parameters.stops && typeof parameters.stops[0][0] === 'object';
        var featureDependent = zoomAndFeatureDependent || parameters.property !== undefined;
        var zoomDependent = zoomAndFeatureDependent || !featureDependent;
        var type = parameters.type || (supportsInterpolation(propertySpec) ? 'exponential' : 'interval');

        if (isColor) {
            parameters = extend$1({}, parameters);

            if (parameters.stops) {
                parameters.stops = parameters.stops.map(function (stop) {
                    return [stop[0], Color$1.parse(stop[1])];
                });
            }

            if (parameters.default) {
                parameters.default = Color$1.parse(parameters.default);
            } else {
                parameters.default = Color$1.parse(propertySpec.default);
            }
        }

        if (parameters.colorSpace && parameters.colorSpace !== 'rgb' && !colorSpaces[parameters.colorSpace]) { // eslint-disable-line import/namespace
            throw new Error(("Unknown color space: " + (parameters.colorSpace)));
        }

        var innerFun;
        var hashedStops;
        var categoricalKeyType;
        if (type === 'exponential') {
            innerFun = evaluateExponentialFunction;
        } else if (type === 'interval') {
            innerFun = evaluateIntervalFunction;
        } else if (type === 'categorical') {
            innerFun = evaluateCategoricalFunction;

            // For categorical functions, generate an Object as a hashmap of the stops for fast searching
            hashedStops = Object.create(null);
            for (var i = 0, list = parameters.stops; i < list.length; i += 1) {
                var stop = list[i];

                hashedStops[stop[0]] = stop[1];
            }

            // Infer key type based on first stop key-- used to encforce strict type checking later
            categoricalKeyType = typeof parameters.stops[0][0];

        } else if (type === 'identity') {
            innerFun = evaluateIdentityFunction;
        } else {
            throw new Error(("Unknown function type \"" + type + "\""));
        }

        if (zoomAndFeatureDependent) {
            var featureFunctions = {};
            var zoomStops = [];
            for (var s = 0; s < parameters.stops.length; s++) {
                var stop$1 = parameters.stops[s];
                var zoom = stop$1[0].zoom;
                if (featureFunctions[zoom] === undefined) {
                    featureFunctions[zoom] = {
                        zoom: zoom,
                        type: parameters.type,
                        property: parameters.property,
                        default: parameters.default,
                        stops: []
                    };
                    zoomStops.push(zoom);
                }
                featureFunctions[zoom].stops.push([stop$1[0].value, stop$1[1]]);
            }

            var featureFunctionStops = [];
            for (var i$1 = 0, list$1 = zoomStops; i$1 < list$1.length; i$1 += 1) {
                var z = list$1[i$1];

                featureFunctionStops.push([featureFunctions[z].zoom, createFunction(featureFunctions[z], propertySpec)]);
            }

            var interpolationType = {name: 'linear'};
            return {
                kind: 'composite',
                interpolationType: interpolationType,
                interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType),
                zoomStops: featureFunctionStops.map(function (s) {
                    return s[0];
                }),
                evaluate: function evaluate(ref, properties) {
                    var zoom = ref.zoom;

                    return evaluateExponentialFunction({
                        stops: featureFunctionStops,
                        base: parameters.base
                    }, propertySpec, zoom).evaluate(zoom, properties);
                }
            };
        } else if (zoomDependent) {
            var interpolationType$1 = type === 'exponential' ?
            {name: 'exponential', base: parameters.base !== undefined ? parameters.base : 1} : null;
            return {
                kind: 'camera',
                interpolationType: interpolationType$1,
                interpolationFactor: Interpolate.interpolationFactor.bind(undefined, interpolationType$1),
                zoomStops: parameters.stops.map(function (s) {
                    return s[0];
                }),
                evaluate: function (ref) {
                    var zoom = ref.zoom;

                    return innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType);
                }
            };
        } else {
            return {
                kind: 'source',
                evaluate: function evaluate(_, feature) {
                    var value = feature && feature.properties ? feature.properties[parameters.property] : undefined;
                    if (value === undefined) {
                        return coalesce(parameters.default, propertySpec.default);
                    }
                    return innerFun(parameters, propertySpec, value, hashedStops, categoricalKeyType);
                }
            };
        }
    }

    function coalesce(a, b, c) {
        if (a !== undefined) return a;
        if (b !== undefined) return b;
        if (c !== undefined) return c;
    }

    // serialization wrapper for old-style stop functions normalized to the
    // expression interface
    var StylePropertyFunction = function StylePropertyFunction(parameters, specification) {
        this._parameters = parameters;
        this._specification = specification;
        extend$1(this, createFunction(this._parameters, this._specification));
    };

    StylePropertyFunction.deserialize = function deserialize(serialized) {
        return ((new StylePropertyFunction(serialized._parameters, serialized._specification))                        );
    };

    StylePropertyFunction.serialize = function serialize(input) {
        return {
            _parameters: input._parameters,
            _specification: input._specification
        };
    };

    Expression.normalizePropertyExpression = function (value, specification) {
        if (isFunction$1(value)) {
            return (new StylePropertyFunction(value, specification)     );

        } else if (Expression.isExpression(value)) {
            var expression = createPropertyExpression(value, specification);
            if (expression.result === 'error') {
                // this should have been caught in validation
                throw new Error(expression.value.map(function (err) {
                    return ((err.key) + ": " + (err.message));
                }).join(', '));
            }
            return expression.value;

        } else {
            var constant = value;
            if (typeof value === 'string' && specification.type === 'color') {
                constant = Color$1.parse(value);
            }
            return {
                kind: 'constant',
                evaluate: function () {
                    return constant;
                }
            };
        }
    };

    function featureFilter() {
    }

    featureFilter.isExpressionFilter = function (filter) {
        if (filter === true || filter === false) {
            return true;
        }

        if (!Array.isArray(filter) || filter.length === 0) {
            return false;
        }
        switch (filter[0]) {
            case 'has':
                return filter.length >= 2 && filter[1] !== '$id' && filter[1] !== '$type';

            case 'in':
                return filter.length >= 3 && Array.isArray(filter[2]);
            case '!in':
            case '!has':
            case 'none':
                return false;

            case '==':
            case '!=':
            case '>':
            case '>=':
            case '<':
            case '<=':
            case 'like':
                return filter.length !== 3 || (Array.isArray(filter[1]) || Array.isArray(filter[2]));

            case 'any':
            case 'all':
                for (var i = 0, list = filter.slice(1); i < list.length; i += 1) {
                    var f = list[i];

                    if (!featureFilter.isExpressionFilter(f) && typeof f !== 'boolean') {
                        return false;
                    }
                }
                return true;

            default:
                return true;
        }
    };

    var filterSpec = {
        'type': 'boolean',
        'default': false,
        'transition': false,
        'property-type': 'data-driven',
        'expression': {
            'interpolated': false,
            'parameters': ['zoom', 'feature']
        }
    };

    /**
     * Given a filter expressed as nested arrays, return a new function
     * that evaluates whether a given feature (with a .properties or .tags property)
     * passes its test.
     *
     * @private
     * @param {Array} filter mapbox gl filter
     * @returns {Function} filter-evaluating function
     */
    featureFilter.createFilter = function (filter) {
        if (filter === null || filter === undefined) {
            return function () {
                return true;
            };
        }

        if (!featureFilter.isExpressionFilter(filter)) {
            filter = convertFilter(filter);
        }

        var compiled = Expression.createExpression(filter, filterSpec);
        if (compiled.result === 'error') {
            throw new Error(compiled.value.map(function (err) {
                return ((err.key) + ": " + (err.message));
            }).join(', '));
        } else {
            return function (globalProperties, feature) {
                return compiled.value.evaluate(globalProperties, feature);
            };
        }
    };

    // Comparison function to sort numbers and strings
    function compare(a, b) {
        return a < b ? -1 : a > b ? 1 : 0;
    }

    function convertFilter(filter) {
        if (!filter) {
            return true;
        }
        var op = filter[0];
        if (filter.length <= 1) {
            return (op !== 'any');
        }
        var converted =
            op === '==' ? convertComparisonOp(filter[1], filter[2], '==') :
                op === '!=' ? convertNegation(convertComparisonOp(filter[1], filter[2], '==')) :
                    op === '<' ||
                        op === '>' ||
                        op === '<=' ||
                        op === '>=' ? convertComparisonOp(filter[1], filter[2], op) :
                        op === 'any' ? convertDisjunctionOp(filter.slice(1)) :
                            op === 'all' ? ['all'].concat(filter.slice(1).map(convertFilter)) :
                                op === 'none' ? ['all'].concat(filter.slice(1).map(convertFilter).map(convertNegation)) :
                                    op === 'in' ? convertInOp(filter[1], filter.slice(2)) :
                                        op === '!in' ? convertNegation(convertInOp(filter[1], filter.slice(2))) :
                                            op === 'has' ? convertHasOp(filter[1]) :
                                                op === '!has' ? convertNegation(convertHasOp(filter[1])) :
                                                    op === 'like' ? convertComparisonOp(filter[1], filter[2], 'like') :
                                                        true;
        return converted;
    }

    function convertComparisonOp(property, value, op) {
        switch (property) {
            case '$type':
                return [("filter-type-" + op), value];
            case '$id':
                return [("filter-id-" + op), value];
            default:
                return [("filter-" + op), property, value];
        }
    }

    function convertDisjunctionOp(filters) {
        return ['any'].concat(filters.map(convertFilter));
    }

    function convertInOp(property, values) {
        if (values.length === 0) {
            return false;
        }
        switch (property) {
            case '$type':
                return ["filter-type-in", ['literal', values]];
            case '$id':
                return ["filter-id-in", ['literal', values]];
            default:
                if (values.length > 200 && !values.some(function (v) {
                    return typeof v !== typeof values[0];
                })) {
                    return ['filter-in-large', property, ['literal', values.sort(compare)]];
                } else {
                    return ['filter-in-small', property, ['literal', values]];
                }
        }
    }

    function convertHasOp(property) {
        switch (property) {
            case '$type':
                return true;
            case '$id':
                return ["filter-has-id"];
            default:
                return ["filter-has", property];
        }
    }

    function convertNegation(filter) {
        return ['!', filter];
    }

    var FeatureIndexArray$1 = arrayTypes.FeatureIndexArray;
    var FeatureIndex = function FeatureIndex(tileID, grid, featureIndexArray) {
        //this.tileID = tileID;
        this.x = tileID.x;
        this.y = tileID.y;
        this.z = tileID.z;
        this.grid = grid || new GridIndex(EXTENT, 16, 0);
        this.featureIndexArray = featureIndexArray || new FeatureIndexArray$1();
    };

    FeatureIndex.prototype.insert = function insert(feature, geometry, featureIndex, sourceLayerIndex, bucketIndex, is3D) {
        var key = this.featureIndexArray.length;
        this.featureIndexArray.emplaceBack(featureIndex, sourceLayerIndex, bucketIndex);

        var grid = this.grid;

        for (var r = 0; r < geometry.length; r++) {
            var ring = geometry[r];

            var bbox = [Infinity, Infinity, -Infinity, -Infinity];
            for (var i = 0; i < ring.length; i++) {
                var p = ring[i];
                bbox[0] = Math.min(bbox[0], p.x);
                bbox[1] = Math.min(bbox[1], p.y);
                bbox[2] = Math.max(bbox[2], p.x);
                bbox[3] = Math.max(bbox[3], p.y);
            }

            if (bbox[0] < EXTENT &&
                bbox[1] < EXTENT &&
                bbox[2] >= 0 &&
                bbox[3] >= 0) {
                grid.insert(key, bbox[0], bbox[1], bbox[2], bbox[3]);
            }
        }
    };

    FeatureIndex.prototype.loadVTLayers = function loadVTLayers() {
        if (!this.vtLayers) {
            this.vtLayers = new VectorTile(new pbf.Protobuf(this.rawTileData)).layers;
            this.sourceLayerCoder = new DictionaryCoder(this.vtLayers ? Object.keys(this.vtLayers).sort() : ['_geojsonTileLayer']);
        }
        return this.vtLayers;
    };

    // Finds non-symbol features in this tile at a particular position.
    FeatureIndex.prototype.query = function query(args, styleLayers, sourceFeatureState) {
        var this$1 = this;

        this.loadVTLayers();

        var params = args.params || {},
            pixelsToTileUnits = EXTENT / args.tileSize,
            filter = featureFilter.createFilter(params.filter);

        var queryGeometry = args.queryGeometry;
        var queryPadding = 5;

        var bounds = getBounds(queryGeometry);
        var matching = this.grid.query(bounds.minX - queryPadding, bounds.minY - queryPadding, bounds.maxX + queryPadding, bounds.maxY + queryPadding);
        matching.sort(topDownFeatureComparator);

        var result = {};
        var previousIndex;
        var loop = function (k) {
            var index = matching[k];

            // don't check the same feature more than once
            if (index === previousIndex) {
                return;
            }
            previousIndex = index;

            var match = this$1.featureIndexArray.get(index);
            var featureGeometry = null;
            this$1.loadMatchingFeature(
                result,
                match.bucketIndex,
                match.sourceLayerIndex,
                match.featureIndex,
                filter,
                params.layers,
                styleLayers,
                function (feature, styleLayer) {
                    if (!featureGeometry) {
                        featureGeometry = loadGeometry(feature);
                    }
                    var featureState = {};
    //                    if (feature.id) {
    //                        // `feature-state` expression evaluation requires feature state to be available
    //                        featureState = sourceFeatureState.getState(styleLayer.sourceLayer || '_geojsonTileLayer', feature.id);
    //                    }
                    return styleLayer.queryIntersectsFeature(queryGeometry, feature, featureState, featureGeometry, this$1.z, args.transform, pixelsToTileUnits, args.pixelPosMatrix);
                }
            );
        };

        for (var k = 0; k < matching.length; k++) loop(k);

        return result;
    };

    FeatureIndex.prototype.loadMatchingFeature = function loadMatchingFeature(result, bucketIndex, sourceLayerIndex, featureIndex, filter, filterLayerIDs, styleLayers, intersectionTest) {
        if(!defined.defined(bucketIndex) || !defined.defined(sourceLayerIndex) || !defined.defined(featureIndex)){
            return;
        }

        var layerIDs = this.bucketLayerIDs[bucketIndex];
        if (filterLayerIDs && !Util.arraysIntersect(filterLayerIDs, layerIDs)) {
            return;
        }

        var sourceLayerName = this.sourceLayerCoder.decode(sourceLayerIndex);
        var sourceLayer = this.vtLayers[sourceLayerName];
        var feature = sourceLayer.feature(featureIndex);

        if (!filter(new EvaluationParameters$1(this.z), feature)) {
            return;
        }

        for (var l = 0; l < layerIDs.length; l++) {
            var layerID = layerIDs[l];

            if (filterLayerIDs && filterLayerIDs.indexOf(layerID) < 0) {
                continue;
            }

            var styleLayer = styleLayers[layerID];
            if (!styleLayer) {
                continue;
            }

            var intersectionZ = !intersectionTest || intersectionTest(feature, styleLayer);
            if (!intersectionZ) {
                // Only applied for non-symbol features
                continue;
            }

    //            var geojsonFeature = new Feature(feature, this.z, this.x, this.y);
    //            (geojsonFeature ).layer = styleLayer.serialize();
            feature.layer = styleLayer.serialize();
            var layerResult = result[layerID];
            if (layerResult === undefined) {
                layerResult = result[layerID] = [];
            }
            layerResult.push({featureIndex: featureIndex, feature: feature, intersectionZ: intersectionZ});
        }
    };

    // Given a set of symbol indexes that have already been looked up,
    // return a matching set of GeoJSONFeatures
    FeatureIndex.prototype.lookupSymbolFeatures = function lookupSymbolFeatures(symbolFeatureIndexes, bucketIndex, sourceLayerIndex, filterSpec, filterLayerIDs, styleLayers) {
        var result = {};
        this.loadVTLayers();

        var filter = createFilter(filterSpec);

        for (var i = 0, list = symbolFeatureIndexes; i < list.length; i += 1) {
            var symbolFeatureIndex = list[i];

            this.loadMatchingFeature(
                result,
                bucketIndex,
                sourceLayerIndex,
                symbolFeatureIndex,
                filter,
                filterLayerIDs,
                styleLayers
            );

        }
        return result;
    };

    FeatureIndex.prototype.hasLayer = function hasLayer(id) {
        for (var i$1 = 0, list$1 = this.bucketLayerIDs; i$1 < list$1.length; i$1 += 1) {
            var layerIDs = list$1[i$1];

            for (var i = 0, list = layerIDs; i < list.length; i += 1) {
                var layerID = list[i];

                if (id === layerID) {
                    return true;
                }
            }
        }

        return false;
    };

    // register(
    //     'FeatureIndex',
    //     FeatureIndex,
    //     {omit: ['rawTileData', 'sourceLayerCoder']}
    // );

    function getBounds(geometry) {
        var minX = Infinity;
        var minY = Infinity;
        var maxX = -Infinity;
        var maxY = -Infinity;
        for (var i = 0, list = geometry; i < list.length; i += 1) {
            var p = list[i];

            minX = Math.min(minX, p.x);
            minY = Math.min(minY, p.y);
            maxX = Math.max(maxX, p.x);
            maxY = Math.max(maxY, p.y);
        }
        return {minX: minX, minY: minY, maxX: maxX, maxY: maxY};
    }

    function topDownFeatureComparator(a, b) {
        return b - a;
    }

    WebWorkerTransfer.register('FeatureIndex', FeatureIndex, {omit: ['rawTileData', 'sourceLayerCoder', 'vtLayers']});

    const refProperties = ['type', 'source', 'source-layer', 'minzoom', 'maxzoom', 'filter', 'layout'];

    function stringify(obj) {
        var type = typeof obj;
        if (type === 'number' || type === 'boolean' || type === 'string' || obj === undefined || obj === null)
        { return JSON.stringify(obj); }

        if (Array.isArray(obj)) {
            var str$1 = '[';
            for (var i$1 = 0, list = obj; i$1 < list.length; i$1 += 1) {
                var val = list[i$1];

                str$1 += (stringify(val)) + ",";
            }
            return (str$1 + "]");
        }

        var keys = Object.keys(obj).sort();

        var str = '{';
        for (var i = 0; i < keys.length; i++) {
            str += (JSON.stringify(keys[i])) + ":" + (stringify(obj[keys[i]])) + ",";
        }
        return (str + "}");
    }

    function getKey(layer) {
        var key = '';
        for (var i = 0, list = refProperties; i < list.length; i += 1) {
            var k = list[i];

            key += "/" + (stringify(layer[k]));
        }
        return key;
    }

    /**
     * Given an array of layers, return an array of arrays of layers where all
     * layers in each group have identical layout-affecting properties. These
     * are the properties that were formerly used by explicit `ref` mechanism
     * for layers: 'type', 'source', 'source-layer', 'minzoom', 'maxzoom',
     * 'filter', and 'layout'.
     *
     * The input is not modified. The output layers are references to the
     * input layers.
     *
     * @private
     * @param {Array<Layer>} layers
     * @param {Object} [cachedKeys] - an object to keep already calculated keys.
     * @returns {Array<Array<Layer>>}
     */
    function groupByLayout(layers, cachedKeys) {
        var groups = {};

        for (var i = 0; i < layers.length; i++) {

            var k = (cachedKeys && cachedKeys[layers[i].id]) || getKey(layers[i]);
            // update the cache if there is one
            if (cachedKeys)
            { cachedKeys[layers[i].id] = k; }

            var group = groups[k];
            if (!group) {
                group = groups[k] = [];
            }
            group.push(layers[i]);
        }

        var result = [];

        for (var k$1 in groups) {
            result.push(groups[k$1]);
        }

        return result;
    }

    var layout$1 = createLayout([
        {name: 'a_pos', components: 2, type: 'Int16'}
    ], 4);
    var members = layout$1.members;

    function addCircleVertex(layoutVertexArray, x, y, extrudeX, extrudeY) {
        layoutVertexArray.emplaceBack(
            (x * 2) + ((extrudeX + 1) / 2),
            (y * 2) + ((extrudeY + 1) / 2));
    }

    /**
     * Circles are represented by two triangles.
     *
     * Each corner has a pos that is the center of the circle and an extrusion
     * vector that is where it points.
     * @private
     */
    var CircleBucket = function CircleBucket(options) {
        this.zoom = options.zoom;
        this.overscaling = options.overscaling;
        this.layers = options.layers;
        this.layerIds = this.layers.map(function (layer) {
            return layer.id;
        });
        this.index = options.index;
        this.hasPattern = false;

        this.layoutVertexArray = new StructArrayLayout2i4();
        this.indexArray = new StructArrayLayout3ui6();
        this.segments = new SegmentVector();
        this.programConfigurations = new ProgramConfigurationSet(members, options.layers, options.zoom);
        this.stateDependentLayerIds = this.layers.filter(function (l) {
            return l.isStateDependent();
        }).map(function (l) {
            return l.id;
        });
    };

    CircleBucket.prototype.populate = function populate(features, options) {
        var styleLayer = this.layers[0];
        var bucketFeatures = [];
        var circleSortKey = null;

        // Heatmap layers are handled in this bucket and have no evaluated properties, so we check our access
        if (styleLayer.type === 'circle') {
            circleSortKey = ((styleLayer )).layout.get('circle-sort-key');
        }

        for (var i = 0, list = features; i < list.length; i += 1) {
            var ref = list[i];
            var feature = ref.feature;
            var index = ref.index;
            var sourceLayerIndex = ref.sourceLayerIndex;

            if (this.layers[0]._featureFilter(new EvaluationParameters$1(0), feature)) {
                var geometry = loadGeometry(feature);
                var sortKey = circleSortKey ?
                    circleSortKey.evaluate(feature, {}) :
                    undefined;

                var bucketFeature = {
                    id: feature.id,
                    properties: feature.properties,
                    type: feature.type,
                    sourceLayerIndex: sourceLayerIndex,
                    index: index,
                    geometry: geometry,
                    patterns: {},
                    sortKey: sortKey
                };

                bucketFeatures.push(bucketFeature);
            }
        }

        if (circleSortKey) {
            bucketFeatures.sort(function (a, b) {
                // a.sortKey is always a number when in use
                return ((a.sortKey )    ) - ((b.sortKey )    );
            });
        }

        for (var i$1 = 0, list$1 = bucketFeatures; i$1 < list$1.length; i$1 += 1) {
            var bucketFeature$1 = list$1[i$1];

            var ref$1 = bucketFeature$1;
            var geometry$1 = ref$1.geometry;
            var index$1 = ref$1.index;
            var sourceLayerIndex$1 = ref$1.sourceLayerIndex;
            var feature$1 = features[index$1].feature;

            this.addFeature(bucketFeature$1, geometry$1, index$1);
            options.featureIndex.insert(feature$1, geometry$1, index$1, sourceLayerIndex$1, this.index);
        }
    };

    CircleBucket.prototype.update = function update(states, vtLayer, imagePositions) {
        if (!this.stateDependentLayers.length) {
            return;
        }
        this.programConfigurations.updatePaintArrays(states, vtLayer, this.stateDependentLayers, imagePositions);
    };

    CircleBucket.prototype.isEmpty = function isEmpty() {
        return this.layoutVertexArray.length === 0;
    };

    CircleBucket.prototype.uploadPending = function uploadPending() {
        return !this.uploaded || this.programConfigurations.needsUpload;
    };

    CircleBucket.prototype.upload = function upload(context) {
        if (!this.uploaded) {
            this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, members);
            this.indexBuffer = context.createIndexBuffer(this.indexArray);
        }
        this.programConfigurations.upload(context);
        this.uploaded = true;
    };

    CircleBucket.prototype.destroy = function destroy() {
        if (!this.layoutVertexBuffer) {
            return;
        }
        this.layoutVertexBuffer.destroy();
        this.indexBuffer.destroy();
        this.programConfigurations.destroy();
        this.segments.destroy();
    };

    CircleBucket.prototype.addFeature = function addFeature(feature, geometry, index) {
        for (var i$1 = 0, list$1 = geometry; i$1 < list$1.length; i$1 += 1) {
            var ring = list$1[i$1];

            for (var i = 0, list = ring; i < list.length; i += 1) {
                var point = list[i];

                var x = point.x;
                var y = point.y;

                // Do not include points that are outside the tile boundaries.
                if (x < 0 || x >= EXTENT || y < 0 || y >= EXTENT) {
                    continue;
                }

                // this geometry will be of the Point type, and we'll derive
                // two triangles from it.
                //
                // ┌─────────┐
                // │ 3 2 │
                // │     │
                // │ 0 1 │
                // └─────────┘

                var segment = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray, feature.sortKey);
                var index$1 = segment.vertexLength;

                addCircleVertex(this.layoutVertexArray, x, y, -1, -1);
                addCircleVertex(this.layoutVertexArray, x, y, 1, -1);
                addCircleVertex(this.layoutVertexArray, x, y, 1, 1);
                addCircleVertex(this.layoutVertexArray, x, y, -1, 1);

                this.indexArray.emplaceBack(index$1, index$1 + 1, index$1 + 2);
                this.indexArray.emplaceBack(index$1, index$1 + 3, index$1 + 2);

                segment.vertexLength += 4;
                segment.primitiveLength += 2;
            }
        }

        this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, feature, index, {});
    };

    WebWorkerTransfer.register('CircleBucket', CircleBucket, {omit: ['layers']});

    /**
     * An implementation of `Property` for properties that do not permit data-driven (source or composite) expressions.
     * This restriction allows us to declare statically that the result of possibly evaluating this kind of property
     * is in fact always the scalar type `T`, and can be used without further evaluating the value on a per-feature basis.
     *
     * @private
     */
    var DataConstantProperty = function DataConstantProperty(specification) {
        this.specification = specification;
    };

    DataConstantProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters) {
        //assert_1(!value.isDataDriven());
        return value.expression.evaluate(parameters);
    };

    DataConstantProperty.prototype.interpolate = function interpolate$1(a, b, t) {
        var interp = (interpolate   )[this.specification.type];
        if (interp) {
            return interp(a, b, t);
        } else {
            return a;
        }
    };

    WebWorkerTransfer.register('DataConstantProperty', DataConstantProperty);

    /**
     * An implementation of `Property` for properties that permit data-driven (source or composite) expressions.
     * The result of possibly evaluating this kind of property is `PossiblyEvaluatedPropertyValue<T>`; obtaining
     * a scalar value `T` requires further evaluation on a per-feature basis.
     *
     * @private
     */
    var DataDrivenProperty = function DataDrivenProperty(specification, overrides) {
        this.specification = specification;
        this.overrides = overrides;
    };

    DataDrivenProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters, availableImages) {
        if (value.expression.kind === 'constant' || value.expression.kind === 'camera') {
            return new PossiblyEvaluatedPropertyValue$1(this, {kind: 'constant', value: value.expression.evaluate(parameters, (null   ), {}, availableImages)}, parameters);
        } else {
            return new PossiblyEvaluatedPropertyValue$1(this, value.expression, parameters);
        }
    };

    DataDrivenProperty.prototype.interpolate = function interpolate$2(a, b, t) {
        // If either possibly-evaluated value is non-constant, give up: we aren't able to interpolate data-driven values.
        if (a.value.kind !== 'constant' || b.value.kind !== 'constant') {
            return a;
        }

        // Special case hack solely for fill-outline-color. The undefined value is subsequently handled in
        // FillStyleLayer#recalculate, which sets fill-outline-color to the fill-color value if the former
        // is a PossiblyEvaluatedPropertyValue containing a constant undefined value. In addition to the
        // return value here, the other source of a PossiblyEvaluatedPropertyValue containing a constant
        // undefined value is the "default value" for fill-outline-color held in
        // `Properties#defaultPossiblyEvaluatedValues`, which serves as the prototype of
        // `PossiblyEvaluated#_values`.
        if (a.value.value === undefined || b.value.value === undefined) {
            return new PossiblyEvaluatedPropertyValue$1(this, {kind: 'constant', value: (undefined   )}, a.parameters);
        }

        var interp = (interpolate   )[this.specification.type];
        if (interp) {
            return new PossiblyEvaluatedPropertyValue$1(this, {kind: 'constant', value: interp(a.value.value, b.value.value, t)}, a.parameters);
        } else {
            return a;
        }
    };

    DataDrivenProperty.prototype.evaluate = function evaluate(value, parameters, feature, featureState, availableImages) {
        if (value.kind === 'constant') {
            return value.value;
        } else {
            return value.evaluate(parameters, feature, featureState, availableImages);
        }
    };

    WebWorkerTransfer.register('DataDrivenProperty', DataDrivenProperty);

    var PropertyValue = function PropertyValue(property, value) {
        this.property = property;
        this.value = value;
        this.expression = Expression.normalizePropertyExpression(value === undefined ? property.specification.default : value, property.specification);
    };

    PropertyValue.prototype.isDataDriven = function isDataDriven() {
        return this.expression.kind === 'source' || this.expression.kind === 'composite';
    };

    PropertyValue.prototype.possiblyEvaluate = function possiblyEvaluate(parameters, availableImages) {
        return this.property.possiblyEvaluate(this, parameters, availableImages);
    };

    /**
     * Given a value `t` that varies between 0 and 1, return
     * an interpolation function that eases between 0 and 1 in a pleasing
     * cubic in-out fashion.
     *
     * @private
     */
    function easeCubicInOut(t        )         {
        if (t <= 0) { return 0; }
        if (t >= 1) { return 1; }
        var t2 = t * t,
            t3 = t2 * t;
        return 4 * (t < 0.5 ? t3 : 3 * (t - t2) + t3 - 0.75);
    }

    /**
     * `TransitioningPropertyValue` implements the first of two intermediate steps in the evaluation chain of a paint
     * property value. In this step, transitions between old and new values are handled: as long as the transition is in
     * progress, `TransitioningPropertyValue` maintains a reference to the prior value, and interpolates between it and
     * the new value based on the current time and the configured transition duration and delay. The product is the next
     * step in the evaluation chain: the "possibly evaluated" result type `R`. See below for more on this concept.
     *
     * @private
     */
    var TransitioningPropertyValue = function TransitioningPropertyValue(property, value, prior, transition, now) {
        this.property = property;
        this.value = value;
        this.begin = now + transition.delay || 0;
        this.end = this.begin + transition.duration || 0;
        if (property.specification.transition && (transition.delay || transition.duration)) {
            this.prior = prior;
        }
    };

    TransitioningPropertyValue.prototype.possiblyEvaluate = function possiblyEvaluate(parameters, availableImages) {
        var now = parameters.now || 0;
        var finalValue = this.value.possiblyEvaluate(parameters, availableImages);
        var prior = this.prior;
        if (!prior) {
            // No prior value.
            return finalValue;
        } else if (now > this.end) {
            // Transition from prior value is now complete.
            this.prior = null;
            return finalValue;
        } else if (this.value.isDataDriven()) {
            // Transitions to data-driven properties are not supported.
            // We snap immediately to the data-driven value so that, when we perform layout,
            // we see the data-driven function and can use it to populate vertex buffers.
            this.prior = null;
            return finalValue;
        } else if (now < this.begin) {
            // Transition hasn't started yet.
            return prior.possiblyEvaluate(parameters, availableImages);
        } else {
            // Interpolate between recursively-calculated prior value and final.
            var t = (now - this.begin) / (this.end - this.begin);
            return this.property.interpolate(prior.possiblyEvaluate(parameters, availableImages), finalValue, easeCubicInOut(t));
        }
    };

    /**
     * @module util
     * @private
     */
    function Util$1() {
    }

    /**
     * Given a value `t` that varies between 0 and 1, return
     * an interpolation function that eases between 0 and 1 in a pleasing
     * cubic in-out fashion.
     *
     * @private
     */
    Util$1.easeCubicInOut = function (t) {
        if (t <= 0) {
            return 0;
        }
        if (t >= 1) {
            return 1;
        }
        var t2 = t * t,
            t3 = t2 * t;
        return 4 * (t < 0.5 ? t3 : 3 * (t - t2) + t3 - 0.75);
    };

    /*
     * Call an asynchronous function on an array of arguments,
     * calling `callback` with the completed results of all calls.
     *
     * @param array input to each call of the async function.
     * @param fn an async function with signature (data, callback)
     * @param callback a callback run after all async work is done.
     * called with an array, containing the results of each async call.
     * @private
     */
    Util$1.asyncAll = function (array, fn, callback) {
        if (!array.length) {
            return callback(null, []);
        }
        var remaining = array.length;
        var results = new Array(array.length);
        var error = null;
        array.forEach(function (item, i) {
            fn(item, function (err, result) {
                if (err) {
                    error = err;
                }
                results[i] = ((result     )        ); // https://github.com/facebook/flow/issues/2123
                if (--remaining === 0) {
                    callback(error, results);
                }
            });
        });
    };

    /**
     * Given a destination object and optionally many source objects,
     * copy all properties from the source objects into the destination.
     * The last source object given overrides properties from previous
     * source objects.
     *
     * @param dest destination object
     * @param sources sources from which properties are pulled
     * @private
     */
    Util$1.extend = function (dest) {
        var sources = [], len = arguments.length - 1;
        while (len-- > 0) sources[ len ] = arguments[ len + 1 ];

        for (var i = 0, list = sources; i < list.length; i += 1) {
            var src = list[i];

            for (var k in src) {
                dest[k] = src[k];
            }
        }
        return dest;
    };

    var id$1 = 1;

    /**
     * Return a unique numeric id, starting at 1 and incrementing with
     * each call.
     *
     * @returns unique numeric id.
     * @private
     */
    Util$1.uniqueId = function () {
        return id$1++;
    };

    /**
     * Return a random UUID (v4). Taken from: https://gist.github.com/jed/982883
     * @private
     */
    Util$1.uuid = function () {
        function b(a) {
            return a ? (a ^ Math.random() * 16 >> a / 4).toString(16) :
                //$FlowFixMe: Flow doesn't like the implied array literal conversion here
                ([1e7] + -[1e3] + -4e3 + -8e3 + -1e11).replace(/[018]/g, b);
        }

        return b();
    };

    /**
     * Validate a string to match UUID(v4) of the
     * form: xxxxxxxx-xxxx-4xxx-[89ab]xxx-xxxxxxxxxxxx
     * @param str string to validate.
     * @private
     */
    Util$1.validateUuid = function (str) {
        return str ? /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(str) : false;
    };

    /**
     * Given an array of member function names as strings, replace all of them
     * with bound versions that will always refer to `context` as `this`. This
     * is useful for classes where otherwise event bindings would reassign
     * `this` to the evented object or some other value: this lets you ensure
     * the `this` value always.
     *
     * @param fns list of member function names
     * @param context the context value
     * @example
     * function MyClass() {
    *   bindAll(['ontimer'], this);
    *   this.name = 'Tom';
    * }
     * MyClass.prototype.ontimer = function() {
    *   alert(this.name);
    * };
     * var myClass = new MyClass();
     * setTimeout(myClass.ontimer, 100);
     * @private
     */
    Util$1.bindAll = function (fns, context) {
        fns.forEach(function (fn) {
            if (!context[fn]) {
                return;
            }
            context[fn] = context[fn].bind(context);
        });
    };

    /**
     * Determine if a string ends with a particular substring
     *
     * @private
     */
    Util$1.endsWith = function (string, suffix) {
        return string.indexOf(suffix, string.length - suffix.length) !== -1;
    };

    /**
     * Create an object by mapping all the values of an existing object while
     * preserving their keys.
     *
     * @private
     */
    Util$1.mapObject = function (input, iterator, context) {
        var output = {};
        for (var key in input) {
            output[key] = iterator.call(context || this, input[key], key, input);
        }
        return output;
    };

    /**
     * Create an object by filtering out values of an existing object.
     *
     * @private
     */
    Util$1.filterObject = function (input, iterator, context) {
        var output = {};
        for (var key in input) {
            if (iterator.call(context || this, input[key], key, input)) {
                output[key] = input[key];
            }
        }
        return output;
    };

    /**
     * Deeply clones two objects.
     *
     * @private
     */
    Util$1.clone = function (input) {
        if (Array.isArray(input)) {
            return input.map(Util$1.clone);
        } else if (typeof input === 'object' && input) {
            return ((Util$1.mapObject(input, Util$1.clone)     )   );
        } else {
            return input;
        }
    };

    Util$1.deepEqual = function (a, b) {
        if (Array.isArray(a)) {
            if (!Array.isArray(b) || a.length !== b.length) {
                return false;
            }
            for (var i = 0; i < a.length; i++) {
                if (!Util$1.deepEqual(a[i], b[i])) {
                    return false;
                }
            }
            return true;
        }
        if (typeof a === 'object' && a !== null && b !== null) {
            if (!(typeof b === 'object')) {
                return false;
            }
            var keys = Object.keys(a);
            if (keys.length !== Object.keys(b).length) {
                return false;
            }
            for (var key in a) {
                if (!Util$1.deepEqual(a[key], b[key])) {
                    return false;
                }
            }
            return true;
        }
        return a === b;
    };

    /**
     * Check if two arrays have at least one common element.
     *
     * @private
     */
    Util$1.arraysIntersect = function (a, b) {
        for (var l = 0; l < a.length; l++) {
            if (b.indexOf(a[l]) >= 0) {
                return true;
            }
        }
        return false;
    };

    /**
     * Indicates if the provided Points are in a counter clockwise (true) or clockwise (false) order
     *
     * @private
     * @returns true for a counter clockwise set of points
     */
    // http://bryceboe.com/2006/10/23/line-segment-intersection-algorithm/
    Util$1.isCounterClockwise = function (a, b, c) {
        return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
    };

    /* global self, WorkerGlobalScope */
    /**
     *  Retuns true if the when run in the web-worker context.
     *
     * @private
     * @returns {boolean}
     */
    Util$1.isWorker = function () {
        return typeof WorkerGlobalScope !== 'undefined' && typeof self !== 'undefined' &&
            self instanceof WorkerGlobalScope;
    };

    var _isSafari$1 = null;

    /**
     * Returns true when run in WebKit derived browsers.
     * This is used as a workaround for a memory leak in Safari caused by using Transferable objects to
     * transfer data between WebWorkers and the main thread.
     * https://github.com/mapbox/mapbox-gl-js/issues/8771
     *
     * This should be removed once the underlying Safari issue is fixed.
     *
     * @private
     * @param scope {WindowOrWorkerGlobalScope} Since this function is used both on the main thread and WebWorker context,
     *      let the calling scope pass in the global scope object.
     * @returns {boolean}
     */
    Util$1.isSafari = function (scope) {
        if (_isSafari$1 == null) {
            var userAgent = scope.navigator ? scope.navigator.userAgent : null;
            _isSafari$1 = !!scope.safari || !!(userAgent && (/\b(iPad|iPhone|iPod)\b/.test(userAgent) || (!!userAgent.match('Safari') && !userAgent.match('Chrome'))));
        }
        return _isSafari$1;
    };

    /**
     * Replace tokens in a string template with values in an object
     *
     * @param properties a key/value relationship between tokens and replacements
     * @param text the template string
     * @returns the template with tokens replaced
     * @private
     */
    Util$1.resolveTokens = function (properties, text) {
        return text.replace(/{([^{}]+)}/g, function (match, key) {
            return key in properties ? String(properties[key]) : '';
        });
    };

    /**
     * Paint properties are _transitionable_: they can change in a fluid manner, interpolating or cross-fading between
     * old and new value. The duration of the transition, and the delay before it begins, is configurable.
     *
     * `TransitionablePropertyValue` is a compositional class that stores both the property value and that transition
     * configuration.
     *
     * A `TransitionablePropertyValue` can calculate the next step in the evaluation chain for paint property values:
     * `TransitioningPropertyValue`.
     *
     * @private
     */
    var TransitionablePropertyValue = function TransitionablePropertyValue(property) {
        this.property = property;
        this.value = new PropertyValue(property, undefined);
    };

    TransitionablePropertyValue.prototype.transitioned = function transitioned(parameters, prior) {
        return new TransitioningPropertyValue(this.property, this.value, prior, // eslint-disable-line no-use-before-define
            Util$1.extend({}, parameters.transition, this.transition), parameters.now);
    };

    TransitionablePropertyValue.prototype.untransitioned = function untransitioned() {
        return new TransitioningPropertyValue(this.property, this.value, null, {}, 0); // eslint-disable-line no-use-before-define
    };

    /**
     * A helper type: given an object type `Properties` whose values are each of type `Property<T, R>`, it calculates
     * an object type with the same keys, and values of type `R`.
     *
     * For properties that don't allow data-driven values, `R` is a scalar type such as `number`, `string`, or `Color`.
     * For data-driven properties, it is `PossiblyEvaluatedPropertyValue`. Critically, the type definitions are set up
     * in a way that allows flow to know which of these two cases applies for any given property name, and if you attempt
     * to use a `PossiblyEvaluatedPropertyValue` as if it was a scalar, or vice versa, you will get a type error. (However,
     * there's at least one case in which flow fails to produce a type error that you should be aware of: in a context such
     * as `layer.paint.get('foo-opacity') === 0`, if `foo-opacity` is data-driven, than the left-hand side is of type
     * `PossiblyEvaluatedPropertyValue<number>`, but flow will not complain about comparing this to a number using `===`.
     * See https://github.com/facebook/flow/issues/2359.)
     *
     * There's also a third, special case possiblity for `R`: for cross-faded properties, it's `?CrossFaded<T>`.
     *
     * @private
     */

    /**
     * `Properties` holds objects containing default values for the layout or paint property set of a given
     * layer type. These objects are immutable, and they are used as the prototypes for the `_values` members of
     * `Transitionable`, `Transitioning`, `Layout`, and `PossiblyEvaluated`. This allows these classes to avoid
     * doing work in the common case where a property has no explicit value set and should be considered to take
     * on the default value: using `for (const property of Object.keys(this._values))`, they can iterate over
     * only the _own_ properties of `_values`, skipping repeated calculation of transitions and possible/final
     * evaluations for defaults, the result of which will always be the same.
     *
     * @private
     */
    var Properties = function Properties(properties) {
        this.properties = properties;
        this.defaultPropertyValues = ({}   );
        this.defaultTransitionablePropertyValues = ({}   );
        this.defaultTransitioningPropertyValues = ({}   );
        this.defaultPossiblyEvaluatedValues = ({}   );
        this.overridableProperties = ([]   );

        for (var property in properties) {
            var prop = properties[property];
            if (prop.specification.overridable) {
                this.overridableProperties.push(property);
            }
            var defaultPropertyValue = this.defaultPropertyValues[property] =
                new PropertyValue(prop, undefined);
            var defaultTransitionablePropertyValue = this.defaultTransitionablePropertyValues[property] =
                new TransitionablePropertyValue(prop);
            this.defaultTransitioningPropertyValues[property] =
                defaultTransitionablePropertyValue.untransitioned();
            this.defaultPossiblyEvaluatedValues[property] =
                defaultPropertyValue.possiblyEvaluate(({}   ));
        }
    };

    function QueryUtils() {
    }

    QueryUtils.getMaximumPaintValue = function (property, layer, bucket) {
        var value = ((layer.paint).get(property)).value;
        if (value.kind === 'constant') {
            return value.value;
        } else {
            var binders = bucket.programConfigurations.get(layer.id).binders;
            return binders[property].maxValue;
        }
    };

    QueryUtils.translateDistance = function (translate) {
        return Math.sqrt(translate[0] * translate[0] + translate[1] * translate[1]);
    };

    QueryUtils.translate = function (queryGeometry, translate, translateAnchor, bearing, pixelsToTileUnits) {
        if (!translate[0] && !translate[1]) {
            return queryGeometry;
        }
        var pt = Point.convert(translate)._mult(pixelsToTileUnits);

        if (translateAnchor === "viewport") {
            pt._rotate(-bearing);
        }

        var translated = [];
        for (var i = 0; i < queryGeometry.length; i++) {
            var point = queryGeometry[i];
            translated.push(point.sub(pt));
        }
        return translated;
    };

    /**
     * `PossiblyEvaluated` stores a map of all (property name, `R`) pairs for paint or layout properties of a
     * given layer type.
     * @private
     */
    var PossiblyEvaluated = function PossiblyEvaluated(properties) {
        this._properties = properties;
        this._values = (Object.create(properties.defaultPossiblyEvaluatedValues)   );
    };

    PossiblyEvaluated.prototype.get = function get(name) {
        return this._values[name];
    };

    /**
     * Because layout properties are not transitionable, they have a simpler representation and evaluation chain than
     * paint properties: `PropertyValue`s are possibly evaluated, producing possibly evaluated values, which are then
     * fully evaluated.
     *
     * `Layout` stores a map of all (property name, `PropertyValue`) pairs for layout properties of a
     * given layer type. It can calculate the possibly-evaluated values for all of them at once, producing a
     * `PossiblyEvaluated` instance for the same set of properties.
     *
     * @private
     */
    var Layout = function Layout(properties                 ) {
        this._properties = properties;
        this._values = (Object.create(properties.defaultPropertyValues)   );
    };

    Layout.prototype.getValue = function getValue (name ) {
        return Util.clone(this._values[name].value);
    };

    Layout.prototype.setValue = function setValue (name , value ) {
        this._values[name] = new PropertyValue(this._values[name].property, value === null ? undefined : Util.clone(value));
    };

    Layout.prototype.serialize = function serialize () {
        var result    = {};
        for (var i = 0, list = Object.keys(this._values); i < list.length; i += 1) {
            var property = list[i];

            var value = this.getValue(property);
            if (value !== undefined) {
                result[property] = value;
            }
        }
        return result;
    };

    Layout.prototype.possiblyEvaluate = function possiblyEvaluate (parameters                    , availableImages              )                         {
        var result = new PossiblyEvaluated(this._properties); // eslint-disable-line no-use-before-define
        for (var i = 0, list = Object.keys(this._values); i < list.length; i += 1) {
            var property = list[i];

            result._values[property] = this._values[property].possiblyEvaluate(parameters, availableImages);
        }
        return result;
    };

    // ------- Transitioning -------

    /**
     * A helper type: given an object type `Properties` whose values are each of type `Property<T, R>`, it calculates
     * an object type with the same keys and values of type `TransitioningPropertyValue<T, R>`.
     *
     * @private
     */


    /**
     * `Transitioning` stores a map of all (property name, `TransitioningPropertyValue`) pairs for paint properties of a
     * given layer type. It can calculate the possibly-evaluated values for all of them at once, producing a
     * `PossiblyEvaluated` instance for the same set of properties.
     *
     * @private
     */
    var Transitioning = function Transitioning(properties) {
        this._properties = properties;
        this._values = (Object.create(properties.defaultTransitioningPropertyValues)   );
    };

    Transitioning.prototype.possiblyEvaluate = function possiblyEvaluate(parameters, availableImages) {
        var result = new PossiblyEvaluated(this._properties); // eslint-disable-line no-use-before-define
        for (var i = 0, list = Object.keys(this._values); i < list.length; i += 1) {
            var property = list[i];

            result._values[property] = this._values[property].possiblyEvaluate(parameters, availableImages);
        }
        return result;
    };

    Transitioning.prototype.hasTransition = function hasTransition() {
        for (var i = 0, list = Object.keys(this._values); i < list.length; i += 1) {
            var property = list[i];

            if (this._values[property].prior) {
                return true;
            }
        }
        return false;
    };

    /**
     * A helper type: given an object type `Properties` whose values are each of type `Property<T, R>`, it calculates
     * an object type with the same keys and values of type `TransitionablePropertyValue<T, R>`.
     *
     * @private
     */


    /**
     * `Transitionable` stores a map of all (property name, `TransitionablePropertyValue`) pairs for paint properties of a
     * given layer type. It can calculate the `TransitioningPropertyValue`s for all of them at once, producing a
     * `Transitioning` instance for the same set of properties.
     *
     * @private
     */
    var Transitionable = function Transitionable(properties) {
        this._properties = properties;
        this._values = (Object.create(properties.defaultTransitionablePropertyValues)   );
    };

    Transitionable.prototype.getValue = function getValue(name) {
        return Util.clone(this._values[name].value.value);
    };

    Transitionable.prototype.setValue = function setValue(name, value) {
        if (!this._values.hasOwnProperty(name)) {
            this._values[name] = new TransitionablePropertyValue(this._values[name].property);
        }
        // Note that we do not _remove_ an own property in the case where a value is being reset
        // to the default: the transition might still be non-default.
        this._values[name].value = new PropertyValue(this._values[name].property, value === null ? undefined : Util.clone(value));
    };

    Transitionable.prototype.getTransition = function getTransition(name) {
        return Util.clone(this._values[name].transition);
    };

    Transitionable.prototype.setTransition = function setTransition(name, value) {
        if (!this._values.hasOwnProperty(name)) {
            this._values[name] = new TransitionablePropertyValue(this._values[name].property);
        }
        this._values[name].transition = Util.clone(value) || undefined;
    };

    Transitionable.prototype.serialize = function serialize() {
        var result = {};
        for (var i = 0, list = Object.keys(this._values); i < list.length; i += 1) {
            var property = list[i];

            var value = this.getValue(property);
            if (value !== undefined) {
                result[property] = value;
            }

            var transition = this.getTransition(property);
            if (transition !== undefined) {
                result[(property + "-transition")] = transition;
            }
        }
        return result;
    };

    Transitionable.prototype.transitioned = function transitioned(parameters, prior) {
        var result = new Transitioning(this._properties); // eslint-disable-line no-use-before-define
        for (var i = 0, list = Object.keys(this._values); i < list.length; i += 1) {
            var property = list[i];

            result._values[property] = this._values[property].transitioned(parameters, prior._values[property]);
        }
        return result;
    };

    Transitionable.prototype.untransitioned = function untransitioned() {
        var result = new Transitioning(this._properties); // eslint-disable-line no-use-before-define
        for (var i = 0, list = Object.keys(this._values); i < list.length; i += 1) {
            var property = list[i];

            result._values[property] = this._values[property].untransitioned();
        }
        return result;
    };

    var TRANSITION_SUFFIX = '-transition';

    function endsWith(string, suffix) {
        return string.indexOf(suffix, string.length - suffix.length) !== -1;
    }

    function StyleLayer(layer, properties) {
        //Evented.call(this);

        this.id = layer.id;
        this.type = layer.type;
    //        this._featureFilter = function () {
    //            return true;
    //        };

        if (layer.type === 'custom') {
            return;
        }

        layer = ((layer));

        this.metadata = layer.metadata;
        this.minzoom = layer.minzoom;
        this.maxzoom = layer.maxzoom;

        if (layer.type !== 'background') {
            this.source = layer.source;
            this.sourceLayer = layer['source-layer'];
            this.filter = layer.filter;
        }

        if (properties.layout) {
            this._unevaluatedLayout = new Layout(properties.layout);
        }

        if (properties.paint) {
            this._transitionablePaint = new Transitionable(properties.paint);

            for (var property in layer.paint) {
                this.setPaintProperty(property, layer.paint[property], {validate: false});
            }
            for (var property$1 in layer.layout) {
                this.setLayoutProperty(property$1, layer.layout[property$1], {validate: false});
            }

            this._transitioningPaint = this._transitionablePaint.untransitioned();
        }
    }

    //    if (Evented) StyleLayer.__proto__ = Evented;
    //    StyleLayer.prototype = Object.create(Evented && Evented.prototype);
    //    StyleLayer.prototype.constructor = StyleLayer;

    StyleLayer.prototype.getCrossfadeParameters = function getCrossfadeParameters() {
        return this._crossfadeParameters;
    };

    StyleLayer.prototype.getLayoutProperty = function getLayoutProperty(name) {
        if (name === 'visibility') {
            return this.visibility;
        }

        return this._unevaluatedLayout.getValue(name);
    };

    StyleLayer.prototype.setLayoutProperty = function setLayoutProperty(name, value, options) {

        if (value !== null && value !== undefined) {
            var key = "layers." + (this.id) + ".layout." + name;
    //            if (this._validate(validateLayoutProperty$1, key, name, value, options)) {
    //                return;
    //            }
        }

        if (name === 'visibility') {
            this.visibility = value;
            return;
        }

        this._unevaluatedLayout.setValue(name, value);
    };

    StyleLayer.prototype.getPaintProperty = function getPaintProperty(name) {
        if (endsWith(name, TRANSITION_SUFFIX)) {
            return this._transitionablePaint.getTransition(name.slice(0, -TRANSITION_SUFFIX.length));
        } else {
            return this._transitionablePaint.getValue(name);
        }
    };

    StyleLayer.prototype.setPaintProperty = function setPaintProperty(name, value, options) {

        if (value !== null && value !== undefined) {
            var key = "layers." + (this.id) + ".paint." + name;
    //            if (this._validate(validatePaintProperty$1, key, name, value, options)) {
    //                return false;
    //            }
        }

        if (endsWith(name, TRANSITION_SUFFIX)) {
            this._transitionablePaint.setTransition(name.slice(0, -TRANSITION_SUFFIX.length), (value     ) || undefined);
            return false;
        } else {
            var transitionable = this._transitionablePaint._values[name];
            var isCrossFadedProperty = transitionable.property.specification["property-type"] === 'cross-faded-data-driven';
            var wasDataDriven = transitionable.value.isDataDriven();
            var oldValue = transitionable.value;

            this._transitionablePaint.setValue(name, value);
            this._handleSpecialPaintPropertyUpdate(name);

            var newValue = this._transitionablePaint._values[name].value;
            var isDataDriven = newValue.isDataDriven();

            // if a cross-faded value is changed, we need to make sure the new icons get added to each tile's iconAtlas
            // so a call to _updateLayer is necessary, and we return true from this function so it gets called in
            // Style#setPaintProperty
            return isDataDriven || wasDataDriven || isCrossFadedProperty || this._handleOverridablePaintPropertyUpdate(name, oldValue, newValue);
        }
    };

    StyleLayer.prototype._handleSpecialPaintPropertyUpdate = function _handleSpecialPaintPropertyUpdate(_) {
        // No-op; can be overridden by derived classes.
    };

    // eslint-disable-next-line no-unused-vars
    StyleLayer.prototype._handleOverridablePaintPropertyUpdate = function _handleOverridablePaintPropertyUpdate(name, oldValue, newValue) {
        // No-op; can be overridden by derived classes.
        return false;
    };

    StyleLayer.prototype.isHidden = function isHidden(zoom) {
        if (this.minzoom && zoom < this.minzoom) {
            return true;
        }
        if (this.maxzoom && zoom >= this.maxzoom) {
            return true;
        }
        return this.visibility === 'none';
    };

    StyleLayer.prototype.updateTransitions = function updateTransitions(parameters) {
        this._transitioningPaint = this._transitionablePaint.transitioned(parameters, this._transitioningPaint);
    };

    StyleLayer.prototype.hasTransition = function hasTransition() {
        return this._transitioningPaint.hasTransition();
    };

    StyleLayer.prototype.recalculate = function recalculate(parameters, availableImages) {
        if (parameters.getCrossfadeParameters) {
            this._crossfadeParameters = parameters.getCrossfadeParameters();
        }

        if (this._unevaluatedLayout) {
            (this).layout = this._unevaluatedLayout.possiblyEvaluate(parameters, availableImages);
        }

        (this).paint = this._transitioningPaint.possiblyEvaluate(parameters, availableImages);
    };

    StyleLayer.prototype.serialize = function serialize() {
        var output = {
            'id': this.id,
            'type': this.type,
            'source': this.source,
            'source-layer': this.sourceLayer,
            'metadata': this.metadata,
            'minzoom': this.minzoom,
            'maxzoom': this.maxzoom,
            'filter': this.filter,
            'layout': this._unevaluatedLayout && this._unevaluatedLayout.serialize(),
            'paint': this._transitionablePaint && this._transitionablePaint.serialize()
        };

        if (this.visibility) {
            output.layout = output.layout || {};
            output.layout.visibility = this.visibility;
        }

        return Util.filterObject(output, function (value, key) {
            return value !== undefined && !(key === 'layout' && !Object.keys(value).length) && !(key === 'paint' && !Object.keys(value).length);
        });
    };

    StyleLayer.prototype._validate = function _validate(validate, key, name, value, options) {
        return true;
    //        if (options === void 0) options = {};
    //
    //        if (options && options.validate === false) {
    //            return false;
    //        }
    //        return emitValidationErrors(this, validate.call(validateStyle, {
    //            key: key,
    //            layerType: this.type,
    //            objectKey: name,
    //            value: value,
    //            styleSpec: spec,
    //            // Workaround for https://github.com/mapbox/mapbox-gl-js/issues/2407
    //            style: {glyphs: true, sprite: true}
    //        }));
    };

    StyleLayer.prototype.is3D = function is3D() {
        return false;
    };

    StyleLayer.prototype.isTileClipped = function isTileClipped() {
        return false;
    };

    StyleLayer.prototype.hasOffscreenPass = function hasOffscreenPass() {
        return false;
    };

    StyleLayer.prototype.resize = function resize() {
        // noop
    };

    StyleLayer.prototype.isStateDependent = function isStateDependent() {
        return true;
    //        for (var property in (this     ).paint._values) {
    //            var value = (this     ).paint.get(property);
    //            if (!(value instanceof PossiblyEvaluatedPropertyValue) || !supportsPropertyExpression(value.property.specification)) {
    //                continue;
    //            }
    //
    //            if ((value.value.kind === 'source' || value.value.kind === 'composite') &&
    //                value.value.isStateDependent) {
    //                return true;
    //            }
    //        }
    //        return false;
    };

    var $version = 8;
    var $root = {
        version: {
            required: true,
            type: "enum",
            values: [
                8
            ]
        },
        name: {
            type: "string"
        },
        metadata: {
            type: "*"
        },
        center: {
            type: "array",
            value: "number"
        },
        zoom: {
            type: "number"
        },
        bearing: {
            type: "number",
            "default": 0,
            period: 360,
            units: "degrees"
        },
        pitch: {
            type: "number",
            "default": 0,
            units: "degrees"
        },
        light: {
            type: "light"
        },
        sources: {
            required: true,
            type: "sources"
        },
        sprite: {
            type: "string"
        },
        glyphs: {
            type: "string"
        },
        transition: {
            type: "transition"
        },
        layers: {
            required: true,
            type: "array",
            value: "layer"
        }
    };
    var sources = {
        "*": {
            type: "source"
        }
    };
    var source = [
        "source_vector",
        "source_raster",
        "source_raster_dem",
        "source_geojson",
        "source_video",
        "source_image"
    ];
    var source_vector = {
        type: {
            required: true,
            type: "enum",
            values: {
                vector: {
                }
            }
        },
        url: {
            type: "string"
        },
        tiles: {
            type: "array",
            value: "string"
        },
        bounds: {
            type: "array",
            value: "number",
            length: 4,
            "default": [
                -180,
                -85.051129,
                180,
                85.051129
            ]
        },
        scheme: {
            type: "enum",
            values: {
                xyz: {
                },
                tms: {
                }
            },
            "default": "xyz"
        },
        minzoom: {
            type: "number",
            "default": 0
        },
        maxzoom: {
            type: "number",
            "default": 22
        },
        attribution: {
            type: "string"
        },
        "*": {
            type: "*"
        }
    };
    var source_raster = {
        type: {
            required: true,
            type: "enum",
            values: {
                raster: {
                }
            }
        },
        url: {
            type: "string"
        },
        tiles: {
            type: "array",
            value: "string"
        },
        bounds: {
            type: "array",
            value: "number",
            length: 4,
            "default": [
                -180,
                -85.051129,
                180,
                85.051129
            ]
        },
        minzoom: {
            type: "number",
            "default": 0
        },
        maxzoom: {
            type: "number",
            "default": 22
        },
        tileSize: {
            type: "number",
            "default": 512,
            units: "pixels"
        },
        scheme: {
            type: "enum",
            values: {
                xyz: {
                },
                tms: {
                }
            },
            "default": "xyz"
        },
        attribution: {
            type: "string"
        },
        "*": {
            type: "*"
        }
    };
    var source_raster_dem = {
        type: {
            required: true,
            type: "enum",
            values: {
                "raster-dem": {
                }
            }
        },
        url: {
            type: "string"
        },
        tiles: {
            type: "array",
            value: "string"
        },
        bounds: {
            type: "array",
            value: "number",
            length: 4,
            "default": [
                -180,
                -85.051129,
                180,
                85.051129
            ]
        },
        minzoom: {
            type: "number",
            "default": 0
        },
        maxzoom: {
            type: "number",
            "default": 22
        },
        tileSize: {
            type: "number",
            "default": 512,
            units: "pixels"
        },
        attribution: {
            type: "string"
        },
        encoding: {
            type: "enum",
            values: {
                terrarium: {
                },
                mapbox: {
                }
            },
            "default": "mapbox"
        },
        "*": {
            type: "*"
        }
    };
    var source_geojson = {
        type: {
            required: true,
            type: "enum",
            values: {
                geojson: {
                }
            }
        },
        data: {
            type: "*"
        },
        maxzoom: {
            type: "number",
            "default": 18
        },
        attribution: {
            type: "string"
        },
        buffer: {
            type: "number",
            "default": 128,
            maximum: 512,
            minimum: 0
        },
        tolerance: {
            type: "number",
            "default": 0.375
        },
        cluster: {
            type: "boolean",
            "default": false
        },
        clusterRadius: {
            type: "number",
            "default": 50,
            minimum: 0
        },
        clusterMaxZoom: {
            type: "number"
        },
        clusterProperties: {
            type: "*"
        },
        lineMetrics: {
            type: "boolean",
            "default": false
        },
        generateId: {
            type: "boolean",
            "default": false
        }
    };
    var source_video = {
        type: {
            required: true,
            type: "enum",
            values: {
                video: {
                }
            }
        },
        urls: {
            required: true,
            type: "array",
            value: "string"
        },
        coordinates: {
            required: true,
            type: "array",
            length: 4,
            value: {
                type: "array",
                length: 2,
                value: "number"
            }
        }
    };
    var source_image = {
        type: {
            required: true,
            type: "enum",
            values: {
                image: {
                }
            }
        },
        url: {
            required: true,
            type: "string"
        },
        coordinates: {
            required: true,
            type: "array",
            length: 4,
            value: {
                type: "array",
                length: 2,
                value: "number"
            }
        }
    };
    var layer = {
        id: {
            type: "string",
            required: true
        },
        type: {
            type: "enum",
            values: {
                fill: {
                },
                line: {
                },
                symbol: {
                },
                circle: {
                },
                heatmap: {
                },
                "fill-extrusion": {
                },
                raster: {
                },
                hillshade: {
                },
                background: {
                }
            },
            required: true
        },
        metadata: {
            type: "*"
        },
        source: {
            type: "string"
        },
        "source-layer": {
            type: "string"
        },
        minzoom: {
            type: "number",
            minimum: 0,
            maximum: 24
        },
        maxzoom: {
            type: "number",
            minimum: 0,
            maximum: 24
        },
        filter: {
            type: "filter"
        },
        layout: {
            type: "layout"
        },
        paint: {
            type: "paint"
        }
    };
    var layout = [
        "layout_fill",
        "layout_line",
        "layout_circle",
        "layout_heatmap",
        "layout_fill-extrusion",
        "layout_symbol",
        "layout_raster",
        "layout_hillshade",
        "layout_background"
    ];
    var layout_background = {
        visibility: {
            type: "enum",
            values: {
                visible: {
                },
                none: {
                }
            },
            "default": "visible",
            "property-type": "constant"
        }
    };
    var layout_fill = {
        "fill-sort-key": {
            type: "number",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        visibility: {
            type: "enum",
            values: {
                visible: {
                },
                none: {
                }
            },
            "default": "visible",
            "property-type": "constant"
        }
    };
    var layout_circle = {
        "circle-sort-key": {
            type: "number",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        visibility: {
            type: "enum",
            values: {
                visible: {
                },
                none: {
                }
            },
            "default": "visible",
            "property-type": "constant"
        }
    };
    var layout_heatmap = {
        visibility: {
            type: "enum",
            values: {
                visible: {
                },
                none: {
                }
            },
            "default": "visible",
            "property-type": "constant"
        }
    };
    var layout_line = {
        "line-cap": {
            type: "enum",
            values: {
                butt: {
                },
                round: {
                },
                square: {
                }
            },
            "default": "butt",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "line-join": {
            type: "enum",
            values: {
                bevel: {
                },
                round: {
                },
                miter: {
                }
            },
            "default": "miter",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "line-miter-limit": {
            type: "number",
            "default": 2,
            requires: [
                {
                    "line-join": "miter"
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "line-round-limit": {
            type: "number",
            "default": 1.05,
            requires: [
                {
                    "line-join": "round"
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "line-sort-key": {
            type: "number",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        visibility: {
            type: "enum",
            values: {
                visible: {
                },
                none: {
                }
            },
            "default": "visible",
            "property-type": "constant"
        }
    };
    var layout_symbol = {
        "symbol-placement": {
            type: "enum",
            values: {
                point: {
                },
                line: {
                },
                "line-center": {
                }
            },
            "default": "point",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "symbol-spacing": {
            type: "number",
            "default": 250,
            minimum: 1,
            units: "pixels",
            requires: [
                {
                    "symbol-placement": "line"
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "symbol-avoid-edges": {
            type: "boolean",
            "default": false,
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "symbol-sort-key": {
            type: "number",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "symbol-z-order": {
            type: "enum",
            values: {
                auto: {
                },
                "viewport-y": {
                },
                source: {
                }
            },
            "default": "auto",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-allow-overlap": {
            type: "boolean",
            "default": false,
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-ignore-placement": {
            type: "boolean",
            "default": false,
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-optional": {
            type: "boolean",
            "default": false,
            requires: [
                "icon-image",
                "text-field"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-rotation-alignment": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                },
                auto: {
                }
            },
            "default": "auto",
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-size": {
            type: "number",
            "default": 1,
            minimum: 0,
            units: "factor of the original icon size",
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-text-fit": {
            type: "enum",
            values: {
                none: {
                },
                width: {
                },
                height: {
                },
                both: {
                }
            },
            "default": "none",
            requires: [
                "icon-image",
                "text-field"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-text-fit-padding": {
            type: "array",
            value: "number",
            length: 4,
            "default": [
                0,
                0,
                0,
                0
            ],
            units: "pixels",
            requires: [
                "icon-image",
                "text-field",
                {
                    "icon-text-fit": [
                        "both",
                        "width",
                        "height"
                    ]
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-image": {
            type: "resolvedImage",
            tokens: true,
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-rotate": {
            type: "number",
            "default": 0,
            period: 360,
            units: "degrees",
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-padding": {
            type: "number",
            "default": 2,
            minimum: 0,
            units: "pixels",
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-keep-upright": {
            type: "boolean",
            "default": false,
            requires: [
                "icon-image",
                {
                    "icon-rotation-alignment": "map"
                },
                {
                    "symbol-placement": [
                        "line",
                        "line-center"
                    ]
                }
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-offset": {
            type: "array",
            value: "number",
            length: 2,
            "default": [
                0,
                0
            ],
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-anchor": {
            type: "enum",
            values: {
                center: {
                },
                left: {
                },
                right: {
                },
                top: {
                },
                bottom: {
                },
                "top-left": {
                },
                "top-right": {
                },
                "bottom-left": {
                },
                "bottom-right": {
                }
            },
            "default": "center",
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-pitch-alignment": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                },
                auto: {
                }
            },
            "default": "auto",
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-pitch-alignment": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                },
                auto: {
                }
            },
            "default": "auto",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-rotation-alignment": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                },
                auto: {
                }
            },
            "default": "auto",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-field": {
            type: "formatted",
            "default": "",
            tokens: true,
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-font": {
            type: "array",
            value: "string",
            "default": [
                "Open Sans Regular",
                "Arial Unicode MS Regular"
            ],
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-size": {
            type: "number",
            "default": 16,
            minimum: 0,
            units: "pixels",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-max-width": {
            type: "number",
            "default": 10,
            minimum: 0,
            units: "ems",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-line-height": {
            type: "number",
            "default": 1.2,
            units: "ems",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-letter-spacing": {
            type: "number",
            "default": 0,
            units: "ems",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-justify": {
            type: "enum",
            values: {
                auto: {
                },
                left: {
                },
                center: {
                },
                right: {
                }
            },
            "default": "center",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-radial-offset": {
            type: "number",
            units: "ems",
            "default": 0,
            requires: [
                "text-field"
            ],
            "property-type": "data-driven",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature"
                ]
            }
        },
        "text-variable-anchor": {
            type: "array",
            value: "enum",
            values: {
                center: {
                },
                left: {
                },
                right: {
                },
                top: {
                },
                bottom: {
                },
                "top-left": {
                },
                "top-right": {
                },
                "bottom-left": {
                },
                "bottom-right": {
                }
            },
            requires: [
                "text-field",
                {
                    "symbol-placement": [
                        "point"
                    ]
                }
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-anchor": {
            type: "enum",
            values: {
                center: {
                },
                left: {
                },
                right: {
                },
                top: {
                },
                bottom: {
                },
                "top-left": {
                },
                "top-right": {
                },
                "bottom-left": {
                },
                "bottom-right": {
                }
            },
            "default": "center",
            requires: [
                "text-field",
                {
                    "!": "text-variable-anchor"
                }
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-max-angle": {
            type: "number",
            "default": 45,
            units: "degrees",
            requires: [
                "text-field",
                {
                    "symbol-placement": [
                        "line",
                        "line-center"
                    ]
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-writing-mode": {
            type: "array",
            value: "enum",
            values: {
                horizontal: {
                },
                vertical: {
                }
            },
            requires: [
                "text-field",
                {
                    "symbol-placement": [
                        "point"
                    ]
                }
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-rotate": {
            type: "number",
            "default": 0,
            period: 360,
            units: "degrees",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-padding": {
            type: "number",
            "default": 2,
            minimum: 0,
            units: "pixels",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-keep-upright": {
            type: "boolean",
            "default": true,
            requires: [
                "text-field",
                {
                    "text-rotation-alignment": "map"
                },
                {
                    "symbol-placement": [
                        "line",
                        "line-center"
                    ]
                }
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-transform": {
            type: "enum",
            values: {
                none: {
                },
                uppercase: {
                },
                lowercase: {
                }
            },
            "default": "none",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-offset": {
            type: "array",
            value: "number",
            units: "ems",
            length: 2,
            "default": [
                0,
                0
            ],
            requires: [
                "text-field",
                {
                    "!": "text-radial-offset"
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "data-driven"
        },
        "text-allow-overlap": {
            type: "boolean",
            "default": false,
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-ignore-placement": {
            type: "boolean",
            "default": false,
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-optional": {
            type: "boolean",
            "default": false,
            requires: [
                "text-field",
                "icon-image"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        visibility: {
            type: "enum",
            values: {
                visible: {
                },
                none: {
                }
            },
            "default": "visible",
            "property-type": "constant"
        }
    };
    var layout_raster = {
        visibility: {
            type: "enum",
            values: {
                visible: {
                },
                none: {
                }
            },
            "default": "visible",
            "property-type": "constant"
        }
    };
    var layout_hillshade = {
        visibility: {
            type: "enum",
            values: {
                visible: {
                },
                none: {
                }
            },
            "default": "visible",
            "property-type": "constant"
        }
    };
    var filter = {
        type: "array",
        value: "*"
    };
    var filter_operator = {
        type: "enum",
        values: {
            "==": {
            },
            "!=": {
            },
            ">": {
            },
            ">=": {
            },
            "<": {
            },
            "<=": {
            },
            "in": {
            },
            "!in": {
            },
            all: {
            },
            any: {
            },
            none: {
            },
            has: {
            },
            "!has": {
            }
        }
    };
    var geometry_type = {
        type: "enum",
        values: {
            Point: {
            },
            LineString: {
            },
            Polygon: {
            }
        }
    };
    var function_stop = {
        type: "array",
        minimum: 0,
        maximum: 24,
        value: [
            "number",
            "color"
        ],
        length: 2
    };
    var expression = {
        type: "array",
        value: "*",
        minimum: 1
    };
    var expression_name = {
        type: "enum",
        values: {
            "let": {
                group: "Variable binding"
            },
            "var": {
                group: "Variable binding"
            },
            literal: {
                group: "Types"
            },
            array: {
                group: "Types"
            },
            at: {
                group: "Lookup"
            },
            "in": {
                group: "Lookup"
            },
            "case": {
                group: "Decision"
            },
            match: {
                group: "Decision"
            },
            coalesce: {
                group: "Decision"
            },
            step: {
                group: "Ramps, scales, curves"
            },
            interpolate: {
                group: "Ramps, scales, curves"
            },
            "interpolate-hcl": {
                group: "Ramps, scales, curves"
            },
            "interpolate-lab": {
                group: "Ramps, scales, curves"
            },
            ln2: {
                group: "Math"
            },
            pi: {
                group: "Math"
            },
            e: {
                group: "Math"
            },
            "typeof": {
                group: "Types"
            },
            string: {
                group: "Types"
            },
            number: {
                group: "Types"
            },
            boolean: {
                group: "Types"
            },
            object: {
                group: "Types"
            },
            collator: {
                group: "Types"
            },
            format: {
                group: "Types"
            },
            image: {
                group: "Types"
            },
            "number-format": {
                group: "Types"
            },
            "to-string": {
                group: "Types"
            },
            "to-number": {
                group: "Types"
            },
            "to-boolean": {
                group: "Types"
            },
            "to-rgba": {
                group: "Color"
            },
            "to-color": {
                group: "Types"
            },
            rgb: {
                group: "Color"
            },
            rgba: {
                group: "Color"
            },
            get: {
                group: "Lookup"
            },
            has: {
                group: "Lookup"
            },
            length: {
                group: "Lookup"
            },
            properties: {
                group: "Feature data"
            },
            "feature-state": {
                group: "Feature data"
            },
            "geometry-type": {
                group: "Feature data"
            },
            id: {
                group: "Feature data"
            },
            zoom: {
                group: "Zoom"
            },
            "heatmap-density": {
                group: "Heatmap"
            },
            "line-progress": {
                group: "Feature data"
            },
            accumulated: {
                group: "Feature data"
            },
            "+": {
                group: "Math"
            },
            "*": {
                group: "Math"
            },
            "-": {
                group: "Math"
            },
            "/": {
                group: "Math"
            },
            "%": {
                group: "Math"
            },
            "^": {
                group: "Math"
            },
            sqrt: {
                group: "Math"
            },
            log10: {
                group: "Math"
            },
            ln: {
                group: "Math"
            },
            log2: {
                group: "Math"
            },
            sin: {
                group: "Math"
            },
            cos: {
                group: "Math"
            },
            tan: {
                group: "Math"
            },
            asin: {
                group: "Math"
            },
            acos: {
                group: "Math"
            },
            atan: {
                group: "Math"
            },
            min: {
                group: "Math"
            },
            max: {
                group: "Math"
            },
            round: {
                group: "Math"
            },
            abs: {
                group: "Math"
            },
            ceil: {
                group: "Math"
            },
            floor: {
                group: "Math"
            },
            "==": {
                group: "Decision"
            },
            "!=": {
                group: "Decision"
            },
            ">": {
                group: "Decision"
            },
            "<": {
                group: "Decision"
            },
            ">=": {
                group: "Decision"
            },
            "<=": {
                group: "Decision"
            },
            all: {
                group: "Decision"
            },
            any: {
                group: "Decision"
            },
            "!": {
                group: "Decision"
            },
            "is-supported-script": {
                group: "String"
            },
            upcase: {
                group: "String"
            },
            downcase: {
                group: "String"
            },
            concat: {
                group: "String"
            },
            "resolved-locale": {
                group: "String"
            }
        }
    };
    var light = {
        anchor: {
            type: "enum",
            "default": "viewport",
            values: {
                map: {
                },
                viewport: {
                }
            },
            "property-type": "data-constant",
            transition: false,
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            }
        },
        position: {
            type: "array",
            "default": [
                1.15,
                210,
                30
            ],
            length: 3,
            value: "number",
            "property-type": "data-constant",
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            }
        },
        color: {
            type: "color",
            "property-type": "data-constant",
            "default": "#ffffff",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            transition: true
        },
        intensity: {
            type: "number",
            "property-type": "data-constant",
            "default": 0.5,
            minimum: 0,
            maximum: 1,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            transition: true
        }
    };
    var paint = [
        "paint_fill",
        "paint_line",
        "paint_circle",
        "paint_heatmap",
        "paint_fill-extrusion",
        "paint_symbol",
        "paint_raster",
        "paint_hillshade",
        "paint_background"
    ];
    var paint_fill = {
        "fill-antialias": {
            type: "boolean",
            "default": true,
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "fill-opacity": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "fill-color": {
            type: "color",
            "default": "#000000",
            transition: true,
            requires: [
                {
                    "!": "fill-pattern"
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "fill-outline-color": {
            type: "color",
            transition: true,
            requires: [
                {
                    "!": "fill-pattern"
                },
                {
                    "fill-antialias": true
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "fill-translate": {
            type: "array",
            value: "number",
            length: 2,
            "default": [
                0,
                0
            ],
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "fill-translate-anchor": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                }
            },
            "default": "map",
            requires: [
                "fill-translate"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "fill-pattern": {
            type: "resolvedImage",
            transition: true,
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "cross-faded-data-driven"
        }
    };
    var paint_line = {
        "line-opacity": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "line-color": {
            type: "color",
            "default": "#000000",
            transition: true,
            requires: [
                {
                    "!": "line-pattern"
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "line-translate": {
            type: "array",
            value: "number",
            length: 2,
            "default": [
                0,
                0
            ],
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "line-translate-anchor": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                }
            },
            "default": "map",
            requires: [
                "line-translate"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "line-width": {
            type: "number",
            "default": 1,
            minimum: 0,
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "line-gap-width": {
            type: "number",
            "default": 0,
            minimum: 0,
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "line-offset": {
            type: "number",
            "default": 0,
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "line-blur": {
            type: "number",
            "default": 0,
            minimum: 0,
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "line-dasharray": {
            type: "array",
            value: "number",
            minimum: 0,
            transition: true,
            units: "line widths",
            requires: [
                {
                    "!": "line-pattern"
                }
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "cross-faded"
        },
        "line-pattern": {
            type: "resolvedImage",
            transition: true,
            expression: {
                interpolated: false,
                parameters: [
                    "zoom",
                    "feature"
                ]
            },
            "property-type": "cross-faded-data-driven"
        },
        "line-gradient": {
            type: "color",
            transition: false,
            requires: [
                {
                    "!": "line-dasharray"
                },
                {
                    "!": "line-pattern"
                },
                {
                    source: "geojson",
                    has: {
                        lineMetrics: true
                    }
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "line-progress"
                ]
            },
            "property-type": "color-ramp"
        }
    };
    var paint_circle = {
        "circle-radius": {
            type: "number",
            "default": 5,
            minimum: 0,
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "circle-color": {
            type: "color",
            "default": "#000000",
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "circle-blur": {
            type: "number",
            "default": 0,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "circle-opacity": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "circle-translate": {
            type: "array",
            value: "number",
            length: 2,
            "default": [
                0,
                0
            ],
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "circle-translate-anchor": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                }
            },
            "default": "map",
            requires: [
                "circle-translate"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "circle-pitch-scale": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                }
            },
            "default": "map",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "circle-pitch-alignment": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                }
            },
            "default": "viewport",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "circle-stroke-width": {
            type: "number",
            "default": 0,
            minimum: 0,
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "circle-stroke-color": {
            type: "color",
            "default": "#000000",
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "circle-stroke-opacity": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        }
    };
    var paint_heatmap = {
        "heatmap-radius": {
            type: "number",
            "default": 30,
            minimum: 1,
            transition: true,
            units: "pixels",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "heatmap-weight": {
            type: "number",
            "default": 1,
            minimum: 0,
            transition: false,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "heatmap-intensity": {
            type: "number",
            "default": 1,
            minimum: 0,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "heatmap-color": {
            type: "color",
            "default": [
                "interpolate",
                [
                    "linear"
                ],
                [
                    "heatmap-density"
                ],
                0,
                "rgba(0, 0, 255, 0)",
                0.1,
                "royalblue",
                0.3,
                "cyan",
                0.5,
                "lime",
                0.7,
                "yellow",
                1,
                "red"
            ],
            transition: false,
            expression: {
                interpolated: true,
                parameters: [
                    "heatmap-density"
                ]
            },
            "property-type": "color-ramp"
        },
        "heatmap-opacity": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        }
    };
    var paint_symbol = {
        "icon-opacity": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-color": {
            type: "color",
            "default": "#000000",
            transition: true,
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-halo-color": {
            type: "color",
            "default": "rgba(0, 0, 0, 0)",
            transition: true,
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-halo-width": {
            type: "number",
            "default": 0,
            minimum: 0,
            transition: true,
            units: "pixels",
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-halo-blur": {
            type: "number",
            "default": 0,
            minimum: 0,
            transition: true,
            units: "pixels",
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "icon-translate": {
            type: "array",
            value: "number",
            length: 2,
            "default": [
                0,
                0
            ],
            transition: true,
            units: "pixels",
            requires: [
                "icon-image"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "icon-translate-anchor": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                }
            },
            "default": "map",
            requires: [
                "icon-image",
                "icon-translate"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-opacity": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "text-color": {
            type: "color",
            "default": "#000000",
            transition: true,
            overridable: true,
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "text-halo-color": {
            type: "color",
            "default": "rgba(0, 0, 0, 0)",
            transition: true,
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "text-halo-width": {
            type: "number",
            "default": 0,
            minimum: 0,
            transition: true,
            units: "pixels",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "text-halo-blur": {
            type: "number",
            "default": 0,
            minimum: 0,
            transition: true,
            units: "pixels",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom",
                    "feature",
                    "feature-state"
                ]
            },
            "property-type": "data-driven"
        },
        "text-translate": {
            type: "array",
            value: "number",
            length: 2,
            "default": [
                0,
                0
            ],
            transition: true,
            units: "pixels",
            requires: [
                "text-field"
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "text-translate-anchor": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                }
            },
            "default": "map",
            requires: [
                "text-field",
                "text-translate"
            ],
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        }
    };
    var paint_raster = {
        "raster-opacity": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "raster-hue-rotate": {
            type: "number",
            "default": 0,
            period: 360,
            transition: true,
            units: "degrees",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "raster-brightness-min": {
            type: "number",
            "default": 0,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "raster-brightness-max": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "raster-saturation": {
            type: "number",
            "default": 0,
            minimum: -1,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "raster-contrast": {
            type: "number",
            "default": 0,
            minimum: -1,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "raster-resampling": {
            type: "enum",
            values: {
                linear: {
                },
                nearest: {
                }
            },
            "default": "linear",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "raster-fade-duration": {
            type: "number",
            "default": 300,
            minimum: 0,
            transition: false,
            units: "milliseconds",
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        }
    };
    var paint_hillshade = {
        "hillshade-illumination-direction": {
            type: "number",
            "default": 335,
            minimum: 0,
            maximum: 359,
            transition: false,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "hillshade-illumination-anchor": {
            type: "enum",
            values: {
                map: {
                },
                viewport: {
                }
            },
            "default": "viewport",
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "hillshade-exaggeration": {
            type: "number",
            "default": 0.5,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "hillshade-shadow-color": {
            type: "color",
            "default": "#000000",
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "hillshade-highlight-color": {
            type: "color",
            "default": "#FFFFFF",
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "hillshade-accent-color": {
            type: "color",
            "default": "#000000",
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        }
    };
    var paint_background = {
        "background-color": {
            type: "color",
            "default": "#000000",
            transition: true,
            requires: [
                {
                    "!": "background-pattern"
                }
            ],
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        },
        "background-pattern": {
            type: "resolvedImage",
            transition: true,
            expression: {
                interpolated: false,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "cross-faded"
        },
        "background-opacity": {
            type: "number",
            "default": 1,
            minimum: 0,
            maximum: 1,
            transition: true,
            expression: {
                interpolated: true,
                parameters: [
                    "zoom"
                ]
            },
            "property-type": "data-constant"
        }
    };
    var transition = {
        duration: {
            type: "number",
            "default": 300,
            minimum: 0,
            units: "milliseconds"
        },
        delay: {
            type: "number",
            "default": 0,
            minimum: 0,
            units: "milliseconds"
        }
    };

    var StyleSpec = {
        $version: $version,
        $root: $root,
        sources: sources,
        source: source,
        source_vector: source_vector,
        source_raster: source_raster,
        source_raster_dem: source_raster_dem,
        source_geojson: source_geojson,
        source_video: source_video,
        source_image: source_image,
        layer: layer,
        layout: layout,
        layout_background: layout_background,
        layout_fill: layout_fill,
        layout_circle: layout_circle,
        layout_heatmap: layout_heatmap,
        "layout_fill-extrusion": {
            visibility: {
                type: "enum",
                values: {
                    visible: {
                    },
                    none: {
                    }
                },
                "default": "visible",
                "property-type": "constant"
            }
        },
        layout_line: layout_line,
        layout_symbol: layout_symbol,
        layout_raster: layout_raster,
        layout_hillshade: layout_hillshade,
        filter: filter,
        filter_operator: filter_operator,
        geometry_type: geometry_type,
        "function": {
            expression: {
                type: "expression"
            },
            stops: {
                type: "array",
                value: "function_stop"
            },
            base: {
                type: "number",
                "default": 1,
                minimum: 0
            },
            property: {
                type: "string",
                "default": "$zoom"
            },
            type: {
                type: "enum",
                values: {
                    identity: {
                    },
                    exponential: {
                    },
                    interval: {
                    },
                    categorical: {
                    }
                },
                "default": "exponential"
            },
            colorSpace: {
                type: "enum",
                values: {
                    rgb: {
                    },
                    lab: {
                    },
                    hcl: {
                    }
                },
                "default": "rgb"
            },
            "default": {
                type: "*",
                required: false
            }
        },
        function_stop: function_stop,
        expression: expression,
        expression_name: expression_name,
        light: light,
        paint: paint,
        paint_fill: paint_fill,
        "paint_fill-extrusion": {
            "fill-extrusion-opacity": {
                type: "number",
                "default": 1,
                minimum: 0,
                maximum: 1,
                transition: true,
                expression: {
                    interpolated: true,
                    parameters: [
                        "zoom"
                    ]
                },
                "property-type": "data-constant"
            },
            "fill-extrusion-color": {
                type: "color",
                "default": "#000000",
                transition: true,
                requires: [
                    {
                        "!": "fill-extrusion-pattern"
                    }
                ],
                expression: {
                    interpolated: true,
                    parameters: [
                        "zoom",
                        "feature",
                        "feature-state"
                    ]
                },
                "property-type": "data-driven"
            },
            "fill-extrusion-translate": {
                type: "array",
                value: "number",
                length: 2,
                "default": [
                    0,
                    0
                ],
                transition: true,
                units: "pixels",
                expression: {
                    interpolated: true,
                    parameters: [
                        "zoom"
                    ]
                },
                "property-type": "data-constant"
            },
            "fill-extrusion-translate-anchor": {
                type: "enum",
                values: {
                    map: {
                    },
                    viewport: {
                    }
                },
                "default": "map",
                requires: [
                    "fill-extrusion-translate"
                ],
                expression: {
                    interpolated: false,
                    parameters: [
                        "zoom"
                    ]
                },
                "property-type": "data-constant"
            },
            "fill-extrusion-pattern": {
                type: "resolvedImage",
                transition: true,
                expression: {
                    interpolated: false,
                    parameters: [
                        "zoom",
                        "feature"
                    ]
                },
                "property-type": "cross-faded-data-driven"
            },
            "fill-extrusion-height": {
                type: "number",
                "default": 0,
                minimum: 0,
                units: "meters",
                transition: true,
                expression: {
                    interpolated: true,
                    parameters: [
                        "zoom",
                        "feature",
                        "feature-state"
                    ]
                },
                "property-type": "data-driven"
            },
            "fill-extrusion-base": {
                type: "number",
                "default": 0,
                minimum: 0,
                units: "meters",
                transition: true,
                requires: [
                    "fill-extrusion-height"
                ],
                expression: {
                    interpolated: true,
                    parameters: [
                        "zoom",
                        "feature",
                        "feature-state"
                    ]
                },
                "property-type": "data-driven"
            },
            "fill-extrusion-vertical-gradient": {
                type: "boolean",
                "default": true,
                transition: false,
                expression: {
                    interpolated: false,
                    parameters: [
                        "zoom"
                    ]
                },
                "property-type": "data-constant"
            }
        },
        paint_line: paint_line,
        paint_circle: paint_circle,
        paint_heatmap: paint_heatmap,
        paint_symbol: paint_symbol,
        paint_raster: paint_raster,
        paint_hillshade: paint_hillshade,
        paint_background: paint_background,
        transition: transition,
        "property-type": {
            "data-driven": {
                type: "property-type"
            },
            "cross-faded": {
                type: "property-type"
            },
            "cross-faded-data-driven": {
                type: "property-type"
            },
            "color-ramp": {
                type: "property-type"
            },
            "data-constant": {
                type: "property-type"
            },
            constant: {
                type: "property-type"
            }
        }
    };

    function IntersectionTest() {
    }

    IntersectionTest.polygonIntersectsPolygon = function (polygonA, polygonB) {
        for (var i = 0; i < polygonA.length; i++) {
            if (polygonContainsPoint(polygonB, polygonA[i])) {
                return true;
            }
        }

        for (var i$1 = 0; i$1 < polygonB.length; i$1++) {
            if (polygonContainsPoint(polygonA, polygonB[i$1])) {
                return true;
            }
        }

        if (lineIntersectsLine(polygonA, polygonB)) {
            return true;
        }

        return false;
    };

    IntersectionTest.polygonIntersectsBufferedPoint = function (polygon, point, radius) {
        if (polygonContainsPoint(polygon, point)) {
            return true;
        }
        if (pointIntersectsBufferedLine(point, polygon, radius)) {
            return true;
        }
        return false;
    };

    IntersectionTest.polygonIntersectsMultiPolygon = function (polygon, multiPolygon) {
        if (polygon.length === 1) {
            return multiPolygonContainsPoint(multiPolygon, polygon[0]);
        }

        for (var m = 0; m < multiPolygon.length; m++) {
            var ring = multiPolygon[m];
            for (var n = 0; n < ring.length; n++) {
                if (polygonContainsPoint(polygon, ring[n])) {
                    return true;
                }
            }
        }

        for (var i = 0; i < polygon.length; i++) {
            if (multiPolygonContainsPoint(multiPolygon, polygon[i])) {
                return true;
            }
        }

        for (var k = 0; k < multiPolygon.length; k++) {
            if (lineIntersectsLine(polygon, multiPolygon[k])) {
                return true;
            }
        }

        return false;
    };

    IntersectionTest.polygonIntersectsBufferedMultiLine = function (polygon, multiLine, radius) {
        for (var i = 0; i < multiLine.length; i++) {
            var line = multiLine[i];

            if (polygon.length >= 3) {
                for (var k = 0; k < line.length; k++) {
                    if (polygonContainsPoint(polygon, line[k])) {
                        return true;
                    }
                }
            }

            if (lineIntersectsBufferedLine(polygon, line, radius)) {
                return true;
            }
        }
        return false;
    };

    function lineIntersectsBufferedLine(lineA, lineB, radius) {

        if (lineA.length > 1) {
            if (lineIntersectsLine(lineA, lineB)) {
                return true;
            }

            // Check whether any point in either line is within radius of the other line
            for (var j = 0; j < lineB.length; j++) {
                if (pointIntersectsBufferedLine(lineB[j], lineA, radius)) {
                    return true;
                }
            }
        }

        for (var k = 0; k < lineA.length; k++) {
            if (pointIntersectsBufferedLine(lineA[k], lineB, radius)) {
                return true;
            }
        }

        return false;
    }

    function lineIntersectsLine(lineA, lineB) {
        if (lineA.length === 0 || lineB.length === 0) {
            return false;
        }
        for (var i = 0; i < lineA.length - 1; i++) {
            var a0 = lineA[i];
            var a1 = lineA[i + 1];
            for (var j = 0; j < lineB.length - 1; j++) {
                var b0 = lineB[j];
                var b1 = lineB[j + 1];
                if (lineSegmentIntersectsLineSegment(a0, a1, b0, b1)) {
                    return true;
                }
            }
        }
        return false;
    }

    function lineSegmentIntersectsLineSegment(a0, a1, b0, b1) {
        return Util.isCounterClockwise(a0, b0, b1) !== Util.isCounterClockwise(a1, b0, b1) &&
            Util.isCounterClockwise(a0, a1, b0) !== Util.isCounterClockwise(a0, a1, b1);
    }

    function pointIntersectsBufferedLine(p, line, radius) {
        var radiusSquared = radius * radius;

        if (line.length === 1) {
            return p.distSqr(line[0]) < radiusSquared;
        }

        for (var i = 1; i < line.length; i++) {
            // Find line segments that have a distance <= radius^2 to p
            // In that case, we treat the line as "containing point p".
            var v = line[i - 1], w = line[i];
            if (IntersectionTest.distToSegmentSquared(p, v, w) < radiusSquared) {
                return true;
            }
        }
        return false;
    }

    // Code from http://stackoverflow.com/a/1501725/331379.
    IntersectionTest.distToSegmentSquared = function (p, v, w) {
        var l2 = v.distSqr(w);
        if (l2 === 0) {
            return p.distSqr(v);
        }
        var t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
        if (t < 0) {
            return p.distSqr(v);
        }
        if (t > 1) {
            return p.distSqr(w);
        }
        return p.distSqr(w.sub(v)._mult(t)._add(v));
    };

    // point in polygon ray casting algorithm
    function multiPolygonContainsPoint(rings, p) {
        var c = false,
            ring, p1, p2;

        for (var k = 0; k < rings.length; k++) {
            ring = rings[k];
            for (var i = 0, j = ring.length - 1; i < ring.length; j = i++) {
                p1 = ring[i];
                p2 = ring[j];
                if (((p1.y > p.y) !== (p2.y > p.y)) && (p.x < (p2.x - p1.x) * (p.y - p1.y) / (p2.y - p1.y) + p1.x)) {
                    c = !c;
                }
            }
        }
        return c;
    }

    function polygonContainsPoint(ring, p) {
        var c = false;
        for (var i = 0, j = ring.length - 1; i < ring.length; j = i++) {
            var p1 = ring[i];
            var p2 = ring[j];
            if (((p1.y > p.y) !== (p2.y > p.y)) && (p.x < (p2.x - p1.x) * (p.y - p1.y) / (p2.y - p1.y) + p1.x)) {
                c = !c;
            }
        }
        return c;
    }

    var layout$2 = new Properties({
        "circle-sort-key": new DataDrivenProperty(StyleSpec["layout_circle"]["circle-sort-key"])
    });

    var paint$1 = new Properties({
        "circle-radius": new DataDrivenProperty(StyleSpec["paint_circle"]["circle-radius"]),
        "circle-color": new DataDrivenProperty(StyleSpec["paint_circle"]["circle-color"]),
        "circle-blur": new DataDrivenProperty(StyleSpec["paint_circle"]["circle-blur"]),
        "circle-opacity": new DataDrivenProperty(StyleSpec["paint_circle"]["circle-opacity"]),
        "circle-translate": new DataConstantProperty(StyleSpec["paint_circle"]["circle-translate"]),
        "circle-translate-anchor": new DataConstantProperty(StyleSpec["paint_circle"]["circle-translate-anchor"]),
        "circle-pitch-scale": new DataConstantProperty(StyleSpec["paint_circle"]["circle-pitch-scale"]),
        "circle-pitch-alignment": new DataConstantProperty(StyleSpec["paint_circle"]["circle-pitch-alignment"]),
        "circle-stroke-width": new DataDrivenProperty(StyleSpec["paint_circle"]["circle-stroke-width"]),
        "circle-stroke-color": new DataDrivenProperty(StyleSpec["paint_circle"]["circle-stroke-color"]),
        "circle-stroke-opacity": new DataDrivenProperty(StyleSpec["paint_circle"]["circle-stroke-opacity"])
    });

    // Note: without adding the explicit type annotation, Flow infers weaker types
    // for these objects from their use in the constructor to StyleLayer, as
    // {layout?: Properties<...>, paint: Properties<...>}
    var properties = ({ paint: paint$1, layout: layout$2 });

    var CircleStyleLayer = /*@__PURE__*/(function (StyleLayer) {
        function CircleStyleLayer(layer) {
            StyleLayer.call(this, layer, properties);
        }

        if (StyleLayer) CircleStyleLayer.__proto__ = StyleLayer;
        CircleStyleLayer.prototype = Object.create(StyleLayer && StyleLayer.prototype);
        CircleStyleLayer.prototype.constructor = CircleStyleLayer;

        CircleStyleLayer.prototype.createBucket = function createBucket(parameters) {
            return new CircleBucket(parameters);
        };

        CircleStyleLayer.prototype.queryRadius = function queryRadius(bucket) {
            var circleBucket = (bucket     );
            return QueryUtils.getMaximumPaintValue('circle-radius', this, circleBucket) +
                QueryUtils.getMaximumPaintValue('circle-stroke-width', this, circleBucket) +
                QueryUtils.translateDistance(this.paint.get('circle-translate'));
        };

        CircleStyleLayer.prototype.queryIntersectsFeature = function queryIntersectsFeature(queryGeometry, feature, featureState, geometry, zoom, transform, pixelsToTileUnits, pixelPosMatrix) {
            pixelPosMatrix = createMat4();
            var translatedPolygon = QueryUtils.translate(queryGeometry,
                this.paint.get('circle-translate'),
                this.paint.get('circle-translate-anchor'),
                0, pixelsToTileUnits);
            var radius = this.paint.get('circle-radius').evaluate(feature, featureState);
            var stroke = this.paint.get('circle-stroke-width').evaluate(feature, featureState);
            var size = radius + stroke;

            // For pitch-alignment: map, compare feature geometry to query geometry in the plane of the tile
            // // Otherwise, compare geometry in the plane of the viewport
            // // A circle with fixed scaling relative to the viewport gets larger in tile space as it moves into the distance
            // // A circle with fixed scaling relative to the map gets smaller in viewport space as it moves into the distance
            var alignWithMap = this.paint.get('circle-pitch-alignment') === 'map';
            var transformedPolygon = alignWithMap ? translatedPolygon : projectQueryGeometry(translatedPolygon, pixelPosMatrix);
            var transformedSize = alignWithMap ? size * pixelsToTileUnits : size;

            for (var i$1 = 0, list$1 = geometry; i$1 < list$1.length; i$1 += 1) {
                var ring = list$1[i$1];

                for (var i = 0, list = ring; i < list.length; i += 1) {

                    var point = list[i];

                    var transformedPoint = alignWithMap ? point : projectPoint(point, pixelPosMatrix);

                    var adjustedSize = transformedSize;
                    var projectedCenter = transformMat4([], [point.x, point.y, 0, 1], pixelPosMatrix);
                    if (this.paint.get('circle-pitch-scale') === 'viewport' && this.paint.get('circle-pitch-alignment') === 'map') ; else if (this.paint.get('circle-pitch-scale') === 'map' && this.paint.get('circle-pitch-alignment') === 'viewport') ;
                    adjustedSize *= 10.0;

                    if (IntersectionTest.polygonIntersectsBufferedPoint(transformedPolygon, transformedPoint, adjustedSize)) {
                        return true;
                    }
                }
            }

            return false;
        };

        return CircleStyleLayer;
    }(StyleLayer));

    function projectPoint(p, pixelPosMatrix) {
        var point = transformMat4([], [p.x, p.y, 0, 1], pixelPosMatrix);
        //return new pointGeometry(point[0] / point[3], point[1] / point[3]);
        return new Point(point[0], point[1]);
    }

    function projectQueryGeometry(queryGeometry, pixelPosMatrix) {
        return queryGeometry.map(function (p) {
            return projectPoint(p, pixelPosMatrix);
        });
    }

    function createMat4() {
        var out = new Float32Array(16);
        out[0] = 1;
        out[5] = 1;
        out[10] = 1;
        out[15] = 1;
        return out;
    }

    /**
     * Transforms the vec3 with a mat4.
     * 4th vector component is implicitly '1'
     *
     * @param {vec3} out the receiving vector
     * @param {vec3} a the vector to transform
     * @param {mat4} m matrix to transform with
     * @returns {vec3} out
     */
    function transformMat4(out, a, m) {
        var x = a[0],
            y = a[1],
            z = a[2];
        var w = m[3] * x + m[7] * y + m[11] * z + m[15];
        w = w || 1.0;
        out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
        out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
        out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
        return out;
    }

    /**
     * An implementation of `Property` for  data driven `line-pattern` which are transitioned by cross-fading
     * rather than interpolation.
     *
     * @private
     */

    var CrossFadedDataDrivenProperty = /*@__PURE__*/(function (DataDrivenProperty) {
        function CrossFadedDataDrivenProperty() {
            DataDrivenProperty.apply(this, arguments);
        }

        if (DataDrivenProperty) CrossFadedDataDrivenProperty.__proto__ = DataDrivenProperty;
        CrossFadedDataDrivenProperty.prototype = Object.create(DataDrivenProperty && DataDrivenProperty.prototype);
        CrossFadedDataDrivenProperty.prototype.constructor = CrossFadedDataDrivenProperty;

        CrossFadedDataDrivenProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters, availableImages) {
            if (value.value === undefined) {
                return new PossiblyEvaluatedPropertyValue$1(this, {kind: 'constant', value: undefined}, parameters);
            } else if (value.expression.kind === 'constant') {
                var evaluatedValue = value.expression.evaluate(parameters, (null     ), {}, availableImages);
                var isImageExpression = value.property.specification.type === 'resolvedImage';
                var constantValue = isImageExpression && typeof evaluatedValue !== 'string' ? evaluatedValue.name : evaluatedValue;
                var constant = this._calculate(constantValue, constantValue, constantValue, parameters);
                return new PossiblyEvaluatedPropertyValue$1(this, {kind: 'constant', value: constant}, parameters);
            } else if (value.expression.kind === 'camera') {
                var cameraVal = this._calculate(
                    value.expression.evaluate({zoom: parameters.zoom - 1.0}),
                    value.expression.evaluate({zoom: parameters.zoom}),
                    value.expression.evaluate({zoom: parameters.zoom + 1.0}),
                    parameters);
                return new PossiblyEvaluatedPropertyValue$1(this, {kind: 'constant', value: cameraVal}, parameters);
            } else {
                // source or composite expression
                return new PossiblyEvaluatedPropertyValue$1(this, value.expression, parameters);
            }
        };

        CrossFadedDataDrivenProperty.prototype.evaluate = function evaluate(value, globals, feature, featureState, availableImages) {
            if (value.kind === 'source') {
                var constant = value.evaluate(globals, feature, featureState, availableImages);
                return this._calculate(constant, constant, constant, globals);
            } else if (value.kind === 'composite') {
                return this._calculate(
                    value.evaluate({zoom: Math.floor(globals.zoom) - 1.0}, feature, featureState),
                    value.evaluate({zoom: Math.floor(globals.zoom)}, feature, featureState),
                    value.evaluate({zoom: Math.floor(globals.zoom) + 1.0}, feature, featureState),
                    globals);
            } else {
                return value.value;
            }
        };

        CrossFadedDataDrivenProperty.prototype._calculate = function _calculate(min, mid, max, parameters) {
            var z = parameters.zoom;
            return z > parameters.zoomHistory.lastIntegerZoom ? {from: min, to: mid} : {from: max, to: mid};
        };

        CrossFadedDataDrivenProperty.prototype.interpolate = function interpolate(a) {
            return a;
        };

        return CrossFadedDataDrivenProperty;
    }(DataDrivenProperty));

    WebWorkerTransfer.register('DataDrivenProperty', DataDrivenProperty);

    var layout$4 = new Properties({
        "fill-sort-key": new DataDrivenProperty(StyleSpec["layout_fill"]["fill-sort-key"])
    });

    var paint$4 = new Properties({
        "fill-antialias": new DataConstantProperty(StyleSpec["paint_fill"]["fill-antialias"]),
        "fill-opacity": new DataDrivenProperty(StyleSpec["paint_fill"]["fill-opacity"]),
        "fill-color": new DataDrivenProperty(StyleSpec["paint_fill"]["fill-color"]),
        "fill-outline-color": new DataDrivenProperty(StyleSpec["paint_fill"]["fill-outline-color"]),
        "fill-translate": new DataConstantProperty(StyleSpec["paint_fill"]["fill-translate"]),
        "fill-translate-anchor": new DataConstantProperty(StyleSpec["paint_fill"]["fill-translate-anchor"]),
        "fill-pattern": new CrossFadedDataDrivenProperty(StyleSpec["paint_fill"]["fill-pattern"]),
    });

    // Note: without adding the explicit type annotation, Flow infers weaker types
    // for these objects from their use in the constructor to StyleLayer, as
    // {layout?: Properties<...>, paint: Properties<...>}
    var properties$3 = ({ paint: paint$4, layout: layout$4 }

        );

    var FillStyleLayer = /*@__PURE__*/(function (StyleLayer) {
        function FillStyleLayer(layer) {
            StyleLayer.call(this, layer, properties$3);
        }

        if (StyleLayer) FillStyleLayer.__proto__ = StyleLayer;
        FillStyleLayer.prototype = Object.create(StyleLayer && StyleLayer.prototype);
        FillStyleLayer.prototype.constructor = FillStyleLayer;

        FillStyleLayer.prototype.recalculate = function recalculate(parameters, availableImages) {
            StyleLayer.prototype.recalculate.call(this, parameters, availableImages);

            var outlineColor = this.paint._values['fill-outline-color'];
            if (outlineColor.value.kind === 'constant' && outlineColor.value.value === undefined) {
                this.paint._values['fill-outline-color'] = this.paint._values['fill-color'];
            }
        };

        FillStyleLayer.prototype.createBucket = function createBucket(parameters) {
            return new FillBucket(parameters);
        };

        FillStyleLayer.prototype.queryRadius = function queryRadius() {
            return QueryUtils.translateDistance(this.paint.get('fill-translate'));
        };

        FillStyleLayer.prototype.queryIntersectsFeature = function queryIntersectsFeature(queryGeometry, feature, featureState, geometry, zoom, transform, pixelsToTileUnits) {
            var translatedPolygon = QueryUtils.translate(queryGeometry,
                this.paint.get('fill-translate'),
                this.paint.get('fill-translate-anchor'),
                0, pixelsToTileUnits);
            return IntersectionTest.polygonIntersectsMultiPolygon(translatedPolygon, geometry);
        };

        FillStyleLayer.prototype.isTileClipped = function isTileClipped() {
            return true;
        };

        return FillStyleLayer;
    }(StyleLayer));

    /**
     * An implementation of `Property` for `*-pattern` and `line-dasharray`, which are transitioned by cross-fading
     * rather than interpolation.
     *
     * @private
     */
    var CrossFadedProperty = function CrossFadedProperty(specification) {
        this.specification = specification;
    };

    CrossFadedProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters, availableImages) {
        if (value.value === undefined) {
            return undefined;
        } else if (value.expression.kind === 'constant') {
            var constant = value.expression.evaluate(parameters, (null   ), {}, availableImages);
            return this._calculate(constant, constant, constant, parameters);
        } else {
            //assert_1(!value.isDataDriven());
            return this._calculate(
                value.expression.evaluate(new EvaluationParameters(Math.floor(parameters.zoom - 1.0), parameters)),
                value.expression.evaluate(new EvaluationParameters(Math.floor(parameters.zoom), parameters)),
                value.expression.evaluate(new EvaluationParameters(Math.floor(parameters.zoom + 1.0), parameters)),
                parameters);
        }
    };

    CrossFadedProperty.prototype._calculate = function _calculate(min, mid, max, parameters) {
        var z = parameters.zoom;
        return z > parameters.zoomHistory.lastIntegerZoom ? {from: min, to: mid} : {from: max, to: mid};
    };

    CrossFadedProperty.prototype.interpolate = function interpolate(a) {
        return a;
    };

    WebWorkerTransfer.register('CrossFadedProperty', CrossFadedProperty);

    /**
     * An implementation of `Property` for `heatmap-color` and `line-gradient`. Interpolation is a no-op, and
     * evaluation returns a boolean value in order to indicate its presence, but the real
     * evaluation happens in StyleLayer classes.
     *
     * @private
     */

    var ColorRampProperty = function ColorRampProperty(specification) {
        this.specification = specification;
    };

    ColorRampProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters, availableImages) {
        return !!value.expression.evaluate(parameters, (null   ), {}, availableImages);
    };

    ColorRampProperty.prototype.interpolate = function interpolate() {
        return false;
    };

    WebWorkerTransfer.register('ColorRampProperty', ColorRampProperty);

    var layout$6 = new Properties({
        "line-cap": new DataConstantProperty(StyleSpec["layout_line"]["line-cap"]),
        "line-join": new DataDrivenProperty(StyleSpec["layout_line"]["line-join"]),
        "line-miter-limit": new DataConstantProperty(StyleSpec["layout_line"]["line-miter-limit"]),
        "line-round-limit": new DataConstantProperty(StyleSpec["layout_line"]["line-round-limit"]),
        "line-sort-key": new DataDrivenProperty(StyleSpec["layout_line"]["line-sort-key"])
    });


    var paint$6 = new Properties({
        "line-opacity": new DataDrivenProperty(StyleSpec["paint_line"]["line-opacity"]),
        "line-color": new DataDrivenProperty(StyleSpec["paint_line"]["line-color"]),
        "line-translate": new DataConstantProperty(StyleSpec["paint_line"]["line-translate"]),
        "line-translate-anchor": new DataConstantProperty(StyleSpec["paint_line"]["line-translate-anchor"]),
        "line-width": new DataDrivenProperty(StyleSpec["paint_line"]["line-width"]),
        "line-gap-width": new DataDrivenProperty(StyleSpec["paint_line"]["line-gap-width"]),
        "line-offset": new DataDrivenProperty(StyleSpec["paint_line"]["line-offset"]),
        "line-blur": new DataDrivenProperty(StyleSpec["paint_line"]["line-blur"]),
        "line-dasharray": new CrossFadedProperty(StyleSpec["paint_line"]["line-dasharray"]),
        "line-pattern": new CrossFadedDataDrivenProperty(StyleSpec["paint_line"]["line-pattern"]),
        "line-gradient": new ColorRampProperty(StyleSpec["paint_line"]["line-gradient"])
    });

    // Note: without adding the explicit type annotation, Flow infers weaker types
    // for these objects from their use in the constructor to StyleLayer, as
    // {layout?: Properties<...>, paint: Properties<...>}
    var properties$5 = ({ paint: paint$6, layout: layout$6 }

        );

    var LineFloorwidthProperty = /*@__PURE__*/(function (DataDrivenProperty) {
        function LineFloorwidthProperty() {
            DataDrivenProperty.apply(this, arguments);
        }

        if (DataDrivenProperty) LineFloorwidthProperty.__proto__ = DataDrivenProperty;
        LineFloorwidthProperty.prototype = Object.create(DataDrivenProperty && DataDrivenProperty.prototype);
        LineFloorwidthProperty.prototype.constructor = LineFloorwidthProperty;

        LineFloorwidthProperty.prototype.possiblyEvaluate = function possiblyEvaluate(value, parameters) {
            parameters = new EvaluationParameters$1(Math.floor(parameters.zoom), {
                now: parameters.now,
                fadeDuration: parameters.fadeDuration,
                zoomHistory: parameters.zoomHistory,
                transition: parameters.transition
            });
            return DataDrivenProperty.prototype.possiblyEvaluate.call(this, value, parameters);
        };

        LineFloorwidthProperty.prototype.evaluate = function evaluate(value, globals, feature, featureState) {
            globals = extend({}, globals, {zoom: Math.floor(globals.zoom)});
            return DataDrivenProperty.prototype.evaluate.call(this, value, globals, feature, featureState);
        };

        return LineFloorwidthProperty;
    }(DataDrivenProperty));

    var lineFloorwidthProperty = new LineFloorwidthProperty(properties$5.paint.properties['line-width'].specification);
    lineFloorwidthProperty.useIntegerZoom = true;

    var LineStyleLayer = /*@__PURE__*/(function (StyleLayer) {
        function LineStyleLayer(layer) {
            StyleLayer.call(this, layer, properties$5);
        }

        if (StyleLayer) LineStyleLayer.__proto__ = StyleLayer;
        LineStyleLayer.prototype = Object.create(StyleLayer && StyleLayer.prototype);
        LineStyleLayer.prototype.constructor = LineStyleLayer;

        LineStyleLayer.prototype._handleSpecialPaintPropertyUpdate = function _handleSpecialPaintPropertyUpdate(name) {
            if (name === 'line-gradient') {
                this._updateGradient();
            }
        };

        LineStyleLayer.prototype._updateGradient = function _updateGradient() {
            var expression = this._transitionablePaint._values['line-gradient'].value.expression;
            this.gradient = renderColorRamp(expression, 'lineProgress');
            this.gradientTexture = null;
        };

        LineStyleLayer.prototype.recalculate = function recalculate(parameters, availableImages) {
            StyleLayer.prototype.recalculate.call(this, parameters, availableImages);

            (this.paint._values     )['line-floorwidth'] =
                lineFloorwidthProperty.possiblyEvaluate(this._transitioningPaint._values['line-width'].value, parameters);
        };

        LineStyleLayer.prototype.createBucket = function createBucket(parameters) {
            return new LineBucket(parameters);
        };

        LineStyleLayer.prototype.queryRadius = function queryRadius(bucket) {
            var lineBucket = (bucket     );
            var width = getLineWidth(
                QueryUtils.getMaximumPaintValue('line-width', this, lineBucket),
                QueryUtils.getMaximumPaintValue('line-gap-width', this, lineBucket));
            var offset = QueryUtils.getMaximumPaintValue('line-offset', this, lineBucket);
            return width / 2 + Math.abs(offset) + QueryUtils.translateDistance(this.paint.get('line-translate'));
        };

        LineStyleLayer.prototype.queryIntersectsFeature = function queryIntersectsFeature(queryGeometry, feature, featureState, geometry, zoom, transform, pixelsToTileUnits) {
            var translatedPolygon = QueryUtils.translate(queryGeometry,
                this.paint.get('line-translate'),
                this.paint.get('line-translate-anchor'),
                0, pixelsToTileUnits);
            var halfWidth = pixelsToTileUnits / 2 * getLineWidth(
                this.paint.get('line-width').evaluate(feature, featureState),
                this.paint.get('line-gap-width').evaluate(feature, featureState));
            var lineOffset = this.paint.get('line-offset').evaluate(feature, featureState);
            if (lineOffset) {
                geometry = offsetLine(geometry, lineOffset * pixelsToTileUnits);
            }

            return IntersectionTest.polygonIntersectsBufferedMultiLine(translatedPolygon, geometry, halfWidth);
        };

        LineStyleLayer.prototype.isTileClipped = function isTileClipped() {
            return true;
        };

        function getLineWidth(lineWidth, lineGapWidth) {
            if (lineGapWidth > 0) {
                return lineGapWidth + 2 * lineWidth;
            } else {
                return lineWidth;
            }
        }

        function offsetLine(rings, offset) {
            var newRings = [];
            var zero = new Point(0, 0);
            for (var k = 0; k < rings.length; k++) {
                var ring = rings[k];
                var newRing = [];
                for (var i = 0; i < ring.length; i++) {
                    var a = ring[i - 1];
                    var b = ring[i];
                    var c = ring[i + 1];
                    var aToB = i === 0 ? zero : b.sub(a)._unit()._perp();
                    var bToC = i === ring.length - 1 ? zero : c.sub(b)._unit()._perp();
                    var extrude = aToB._add(bToC)._unit();

                    var cosHalfAngle = extrude.x * bToC.x + extrude.y * bToC.y;
                    extrude._mult(1 / cosHalfAngle);

                    newRing.push(extrude._mult(offset)._add(b));
                }
                newRings.push(newRing);
            }
            return newRings;
        }

        return LineStyleLayer;
    }(StyleLayer));

    function SymbolAttributes() {
    }

    SymbolAttributes.symbolLayoutAttributes = createLayout([
        {name: 'a_pos_offset', components: 4, type: 'Int16'},
        {name: 'a_data', components: 4, type: 'Uint16'},
        {name: 'a_pixeloffset', components: 4, type: 'Int16'}
    ], 4);

    SymbolAttributes.dynamicLayoutAttributes = createLayout([
        {name: 'a_projected_pos', components: 3, type: 'Float32'}
    ], 4);

    SymbolAttributes.placementOpacityAttributes = createLayout([
        {name: 'a_fade_opacity', components: 1, type: 'Uint32'}
    ], 4);

    SymbolAttributes.collisionVertexAttributes = createLayout([
        {name: 'a_placed', components: 2, type: 'Uint8'},
        {name: 'a_shift', components: 2, type: 'Float32'}
    ]);

    SymbolAttributes.collisionBox = createLayout([
        // the box is centered around the anchor point
        {type: 'Int16', name: 'anchorPointX'},
        {type: 'Int16', name: 'anchorPointY'},

        // distances to the edges from the anchor
        {type: 'Int16', name: 'x1'},
        {type: 'Int16', name: 'y1'},
        {type: 'Int16', name: 'x2'},
        {type: 'Int16', name: 'y2'},

        // the index of the feature in the original vectortile
        {type: 'Uint32', name: 'featureIndex'},
        // the source layer the feature appears in
        {type: 'Uint16', name: 'sourceLayerIndex'},
        // the bucket the feature appears in
        {type: 'Uint16', name: 'bucketIndex'},

        // collision circles for lines store their distance to the anchor in tile units
        // so that they can be ignored if the projected label doesn't extend into
        // the box area
        {type: 'Int16', name: 'radius'},
        {type: 'Int16', name: 'signedDistanceFromAnchor'}
    ]);

    SymbolAttributes.collisionBoxLayout = createLayout([ // used to render collision boxes for debugging purposes
        {name: 'a_pos', components: 2, type: 'Int16'},
        {name: 'a_anchor_pos', components: 2, type: 'Int16'},
        {name: 'a_extrude', components: 2, type: 'Int16'}
    ], 4);

    SymbolAttributes.collisionCircleLayout = createLayout([ // used to render collision circles for debugging purposes
        {name: 'a_pos', components: 2, type: 'Int16'},
        {name: 'a_anchor_pos', components: 2, type: 'Int16'},
        {name: 'a_extrude', components: 2, type: 'Int16'}
    ], 4);

    SymbolAttributes.placement = createLayout([
        {type: 'Int16', name: 'anchorX'},
        {type: 'Int16', name: 'anchorY'},
        {type: 'Uint16', name: 'glyphStartIndex'},
        {type: 'Uint16', name: 'numGlyphs'},
        {type: 'Uint32', name: 'vertexStartIndex'},
        {type: 'Uint32', name: 'lineStartIndex'},
        {type: 'Uint32', name: 'lineLength'},
        {type: 'Uint16', name: 'segment'},
        {type: 'Uint16', name: 'lowerSize'},
        {type: 'Uint16', name: 'upperSize'},
        {type: 'Float32', name: 'lineOffsetX'},
        {type: 'Float32', name: 'lineOffsetY'},
        {type: 'Uint8', name: 'writingMode'},
        {type: 'Uint8', name: 'placedOrientation'},
        {type: 'Uint8', name: 'hidden'},
        {type: 'Uint32', name: 'crossTileID'},
        {type: 'Int16', name: 'associatedIconIndex'}
    ]);

    SymbolAttributes.symbolInstance = createLayout([
        {type: 'Int16', name: 'anchorX'},
        {type: 'Int16', name: 'anchorY'},
        {type: 'Int16', name: 'rightJustifiedTextSymbolIndex'},
        {type: 'Int16', name: 'centerJustifiedTextSymbolIndex'},
        {type: 'Int16', name: 'leftJustifiedTextSymbolIndex'},
        {type: 'Int16', name: 'verticalPlacedTextSymbolIndex'},
        {type: 'Int16', name: 'placedIconSymbolIndex'},
        {type: 'Int16', name: 'verticalPlacedIconSymbolIndex'},
        {type: 'Uint16', name: 'key'},
        {type: 'Uint16', name: 'textBoxStartIndex'},
        {type: 'Uint16', name: 'textBoxEndIndex'},
        {type: 'Uint16', name: 'verticalTextBoxStartIndex'},
        {type: 'Uint16', name: 'verticalTextBoxEndIndex'},
        {type: 'Uint16', name: 'iconBoxStartIndex'},
        {type: 'Uint16', name: 'iconBoxEndIndex'},
        {type: 'Uint16', name: 'verticalIconBoxStartIndex'},
        {type: 'Uint16', name: 'verticalIconBoxEndIndex'},
        {type: 'Uint16', name: 'featureIndex'},
        {type: 'Uint16', name: 'numHorizontalGlyphVertices'},
        {type: 'Uint16', name: 'numVerticalGlyphVertices'},
        {type: 'Uint16', name: 'numIconVertices'},
        {type: 'Uint16', name: 'numVerticalIconVertices'},
        {type: 'Uint32', name: 'crossTileID'},
        {type: 'Float32', name: 'textBoxScale'},
        {type: 'Float32', components: 2, name: 'textOffset'}
    ]);

    SymbolAttributes.glyphOffset = createLayout([
        {type: 'Float32', name: 'offsetX'}
    ]);

    SymbolAttributes.lineVertex = createLayout([
        {type: 'Int16', name: 'x'},
        {type: 'Int16', name: 'y'},
        {type: 'Int16', name: 'tileUnitDistanceFromAnchor'}
    ]);

    function mergeLines(features) {
        var leftIndex = {};
        var rightIndex = {};
        var mergedFeatures = [];
        var mergedIndex = 0;

        function add(k) {
            mergedFeatures.push(features[k]);
            mergedIndex++;
        }

        function mergeFromRight(leftKey, rightKey, geom) {
            var i = rightIndex[leftKey];
            delete rightIndex[leftKey];
            rightIndex[rightKey] = i;

            mergedFeatures[i].geometry[0].pop();
            mergedFeatures[i].geometry[0] = mergedFeatures[i].geometry[0].concat(geom[0]);
            return i;
        }

        function mergeFromLeft(leftKey, rightKey, geom) {
            var i = leftIndex[rightKey];
            delete leftIndex[rightKey];
            leftIndex[leftKey] = i;

            mergedFeatures[i].geometry[0].shift();
            mergedFeatures[i].geometry[0] = geom[0].concat(mergedFeatures[i].geometry[0]);
            return i;
        }

        function getKey(text, geom, onRight) {
            var point = onRight ? geom[0][geom[0].length - 1] : geom[0][0];
            return (text + ":" + (point.x) + ":" + (point.y));
        }

        for (var k = 0; k < features.length; k++) {
            var feature = features[k];
            var geom = feature.geometry;
            var text = feature.text ? feature.text.toString() : null;

            if (!text) {
                add(k);
                continue;
            }

            var leftKey = getKey(text, geom),
                rightKey = getKey(text, geom, true);

            if ((leftKey in rightIndex) && (rightKey in leftIndex) && (rightIndex[leftKey] !== leftIndex[rightKey])) {
                // found lines with the same text adjacent to both ends of the current line, merge all three
                var j = mergeFromLeft(leftKey, rightKey, geom);
                var i = mergeFromRight(leftKey, rightKey, mergedFeatures[j].geometry);

                delete leftIndex[leftKey];
                delete rightIndex[rightKey];

                rightIndex[getKey(text, mergedFeatures[i].geometry, true)] = i;
                mergedFeatures[j].geometry = (null     );

            } else if (leftKey in rightIndex) {
                // found mergeable line adjacent to the start of the current line, merge
                mergeFromRight(leftKey, rightKey, geom);

            } else if (rightKey in leftIndex) {
                // found mergeable line adjacent to the end of the current line, merge
                mergeFromLeft(leftKey, rightKey, geom);

            } else {
                // no adjacent lines, add as a new item
                add(k);
                leftIndex[leftKey] = mergedIndex - 1;
                rightIndex[rightKey] = mergedIndex - 1;
            }
        }

        return mergedFeatures.filter(function (f) {
            return f.geometry;
        });
    }

    var Shaping = function Shaping() {
    };

    Shaping.WritingMode = {
        horizontal: 1,
        vertical: 2,
        horizontalOnly: 3
    };

    // The position of a glyph relative to the text's anchor point.


    // A collection of positioned glyphs and some metadata


    function isEmpty(positionedLines) {
        for (var i = 0, list = positionedLines; i < list.length; i += 1) {
            var line = list[i];

            if (line.positionedGlyphs.length !== 0) {
                return false;
            }
        }
        return true;
    }


    // Max number of images in label is 6401 U+E000–U+F8FF that covers
    // Basic Multilingual Plane Unicode Private Use Area (PUA).
    var PUAbegin = 0xE000;
    var PUAend = 0xF8FF;

    var SectionOptions = function SectionOptions() {
        this.scale = 1.0;
        this.fontStack = "";
        this.imageName = null;
    };

    SectionOptions.forText = function forText(scale, fontStack) {
        var textOptions = new SectionOptions();
        textOptions.scale = scale || 1;
        textOptions.fontStack = fontStack;
        return textOptions;
    };

    SectionOptions.forImage = function forImage(imageName) {
        var imageOptions = new SectionOptions();
        imageOptions.imageName = imageName;
        return imageOptions;
    };

    var TaggedString = function TaggedString() {
        this.text = "";
        this.sectionIndex = [];
        this.sections = [];
        this.imageSectionID = null;
    };

    TaggedString.fromFeature = function fromFeature(text, defaultFontStack) {
        var result = new TaggedString();
        for (var i = 0; i < text.sections.length; i++) {
            var section = text.sections[i];
            if (!section.image) {
                result.addTextSection(section, defaultFontStack);
            } else {
                result.addImageSection(section);
            }
        }
        return result;
    };

    TaggedString.prototype.length = function length() {
        return this.text.length;
    };

    TaggedString.prototype.getSection = function getSection(index) {
        return this.sections[this.sectionIndex[index]];
    };

    TaggedString.prototype.getSectionIndex = function getSectionIndex(index) {
        return this.sectionIndex[index];
    };

    TaggedString.prototype.getCharCode = function getCharCode(index) {
        return this.text.charCodeAt(index);
    };

    TaggedString.prototype.verticalizePunctuation = function verticalizePunctuation$1() {
        //this.text = verticalizePunctuation(this.text);
    };

    TaggedString.prototype.trim = function trim() {
        var beginningWhitespace = 0;
        for (var i = 0;
             i < this.text.length && whitespace[this.text.charCodeAt(i)];
             i++) {
            beginningWhitespace++;
        }
        var trailingWhitespace = this.text.length;
        for (var i$1 = this.text.length - 1;
             i$1 >= 0 && i$1 >= beginningWhitespace && whitespace[this.text.charCodeAt(i$1)];
             i$1--) {
            trailingWhitespace--;
        }
        this.text = this.text.substring(beginningWhitespace, trailingWhitespace);
        this.sectionIndex = this.sectionIndex.slice(beginningWhitespace, trailingWhitespace);
    };

    TaggedString.prototype.substring = function substring(start, end) {
        var substring = new TaggedString();
        substring.text = this.text.substring(start, end);
        substring.sectionIndex = this.sectionIndex.slice(start, end);
        substring.sections = this.sections;
        return substring;
    };

    TaggedString.prototype.toString = function toString() {
        return this.text;
    };

    TaggedString.prototype.getMaxScale = function getMaxScale() {
        var this$1 = this;

        return this.sectionIndex.reduce(function (max, index) {
            return Math.max(max, this$1.sections[index].scale);
        }, 0);
    };

    TaggedString.prototype.addTextSection = function addTextSection(section, defaultFontStack) {
        this.text += section.text;
        this.sections.push(SectionOptions.forText(section.scale, section.fontStack || defaultFontStack));
        var index = this.sections.length - 1;
        for (var i = 0; i < section.text.length; ++i) {
            this.sectionIndex.push(index);
        }
    };

    TaggedString.prototype.addImageSection = function addImageSection(section) {
        var imageName = section.image ? section.image.name : '';
        if (imageName.length === 0) {
            //warnOnce("Can't add FormattedSection with an empty image.");
            return;
        }

        var nextImageSectionCharCode = this.getNextImageSectionCharCode();
        if (!nextImageSectionCharCode) {
            //warnOnce(("Reached maximum number of images " + (PUAend - PUAbegin + 2)));
            return;
        }

        this.text += String.fromCharCode(nextImageSectionCharCode);
        this.sections.push(SectionOptions.forImage(imageName));
        this.sectionIndex.push(this.sections.length - 1);
    };

    TaggedString.prototype.getNextImageSectionCharCode = function getNextImageSectionCharCode() {
        if (!this.imageSectionID) {
            this.imageSectionID = PUAbegin;
            return this.imageSectionID;
        }

        if (this.imageSectionID >= PUAend) {
            return null;
        }
        return ++this.imageSectionID;
    };

    function breakLines(input, lineBreakPoints) {
        var lines = [];
        var text = input.text;
        var start = 0;
        for (var i = 0, list = lineBreakPoints; i < list.length; i += 1) {
            var lineBreak = list[i];

            lines.push(input.substring(start, lineBreak));
            start = lineBreak;
        }

        if (start < text.length) {
            lines.push(input.substring(start, text.length));
        }
        return lines;
    }

    Shaping.shapeText = function(text, glyphMap, glyphPositions, imagePositions, defaultFontStack, maxWidth, lineHeight, textAnchor, textJustify, spacing, translate, writingMode, allowVerticalPlacement, symbolPlacement, layoutTextSize, layoutTextSizeThisZoom){
        var logicalInput = TaggedString.fromFeature(text, defaultFontStack);

        if (writingMode === Shaping.WritingMode.vertical) {
            logicalInput.verticalizePunctuation();
        }

        var lines;
        {
            lines = breakLines(logicalInput, determineLineBreaks());
        }

        var positionedLines = [];
        var shaping = {
            positionedLines: positionedLines,
            text: logicalInput.toString(),
            top: translate[1],
            bottom: translate[1],
            left: translate[0],
            right: translate[0],
            writingMode: writingMode,
            iconsInText: false,
            verticalizable: false
        };
        if (isEmpty(positionedLines)) {
            return false;
        }

        return shaping;
    };

    // using computed properties due to https://github.com/facebook/flow/issues/380
    /* eslint no-useless-computed-key: 0 */

    var whitespace = {};
    whitespace[0x09] = true;
    whitespace[0x0a] = true;
    whitespace[0x0b] = true;
    whitespace[0x0c] = true;
    whitespace[0x0d] = true;
    whitespace[0x20] = true;

    function determineLineBreaks(logicalInput, spacing, maxWidth, glyphMap, imagePositions, symbolPlacement, layoutTextSize) {
    //        if (symbolPlacement !== 'point') {
    //            return [];
    //        }
    //
    //        if (!logicalInput) {
    //            return [];
    //        }
    //
    //        var potentialLineBreaks = [];
    //        var targetWidth = determineAverageLineWidth(logicalInput, spacing, maxWidth, glyphMap, imagePositions, layoutTextSize);
    //
    //        var hasServerSuggestedBreakpoints = logicalInput.text.indexOf("\u200b") >= 0;
    //
    //        var currentX = 0;
    //
    //        for (var i = 0; i < logicalInput.length(); i++) {
    //            var section = logicalInput.getSection(i);
    //            var codePoint = logicalInput.getCharCode(i);
    //            if (!whitespace[codePoint]) {
    //                currentX += getGlyphAdvance(codePoint, section, glyphMap, imagePositions, spacing, layoutTextSize);
    //            }
    //
    //            // Ideographic characters, spaces, and word-breaking punctuation that often appear without
    //            // surrounding spaces.
    //            if ((i < logicalInput.length() - 1)) {
    //                var ideographicBreak = charAllowsIdeographicBreaking(codePoint);
    //                if (breakable[codePoint] || ideographicBreak || section.imageName) {
    //
    //                    potentialLineBreaks.push(
    //                        evaluateBreak(
    //                            i + 1,
    //                            currentX,
    //                            targetWidth,
    //                            potentialLineBreaks,
    //                            calculatePenalty(codePoint, logicalInput.getCharCode(i + 1), ideographicBreak && hasServerSuggestedBreakpoints),
    //                            false));
    //                }
    //            }
    //        }
    //
    //        return leastBadBreaks(
    //            evaluateBreak(
    //                logicalInput.length(),
    //                currentX,
    //                targetWidth,
    //                potentialLineBreaks,
    //                0,
    //                true));
    }

    function getAnchorAlignment(anchor) {
        var horizontalAlign = 0.5, verticalAlign = 0.5;

        switch (anchor) {
            case 'right':
            case 'top-right':
            case 'bottom-right':
                horizontalAlign = 1;
                break;
            case 'left':
            case 'top-left':
            case 'bottom-left':
                horizontalAlign = 0;
                break;
        }

        switch (anchor) {
            case 'bottom':
            case 'bottom-right':
            case 'bottom-left':
                verticalAlign = 1;
                break;
            case 'top':
            case 'top-right':
            case 'top-left':
                verticalAlign = 0;
                break;
        }

        return {horizontalAlign: horizontalAlign, verticalAlign: verticalAlign};
    }


    Shaping.shapeIcon = function(image, iconOffset, iconAnchor){
        var ref = getAnchorAlignment(iconAnchor);
        var horizontalAlign = ref.horizontalAlign;
        var verticalAlign = ref.verticalAlign;
        var dx = iconOffset[0];
        var dy = iconOffset[1];
        var x1 = dx - image.displaySize[0] * horizontalAlign;
        var x2 = x1 + image.displaySize[0];
        var y1 = dy - image.displaySize[1] * verticalAlign;
        var y2 = y1 + image.displaySize[1];
        return {image: image, top: y1, bottom: y2, left: x1, right: x2};
    };

    Shaping.fitIconToText = function(shapedIcon, shapedText, textFit, padding, iconOffset, fontScale){
    //        assert_1(textFit !== 'none');
    //        assert_1(Array.isArray(padding) && padding.length === 4);
    //        assert_1(Array.isArray(iconOffset) && iconOffset.length === 2);

        var image = shapedIcon.image;

        var collisionPadding;
        if (image.content) {
            var content = image.content;
            var pixelRatio = image.pixelRatio || 1;
            collisionPadding = [
                content[0] / pixelRatio,
                content[1] / pixelRatio,
                image.displaySize[0] - content[2] / pixelRatio,
                image.displaySize[1] - content[3] / pixelRatio
            ];
        }

        // We don't respect the icon-anchor, because icon-text-fit is set. Instead,
        // the icon will be centered on the text, then stretched in the given
        // dimensions.

        var textLeft = shapedText.left * fontScale;
        var textRight = shapedText.right * fontScale;

        var top, right, bottom, left;
        if (textFit === 'width' || textFit === 'both') {
            // Stretched horizontally to the text width
            left = iconOffset[0] + textLeft - padding[3];
            right = iconOffset[0] + textRight + padding[1];
        } else {
            // Centered on the text
            left = iconOffset[0] + (textLeft + textRight - image.displaySize[0]) / 2;
            right = left + image.displaySize[0];
        }

        var textTop = shapedText.top * fontScale;
        var textBottom = shapedText.bottom * fontScale;
        if (textFit === 'height' || textFit === 'both') {
            // Stretched vertically to the text height
            top = iconOffset[1] + textTop - padding[0];
            bottom = iconOffset[1] + textBottom + padding[2];
        } else {
            // Centered on the text
            top = iconOffset[1] + (textTop + textBottom - image.displaySize[1]) / 2;
            bottom = top + image.displaySize[1];
        }

        return {image: image, top: top, right: right, bottom: bottom, left: left, collisionPadding: collisionPadding};
    };

    var SIZE_PACK_FACTOR = 128;

    // For {text,icon}-size, get the bucket-level data that will be needed by
    // the painter to set symbol-size-related uniforms
    function getSizeData(tileZoom, value) {
        var expression = value.expression;

        if (expression.kind === 'constant') {
            var layoutSize = expression.evaluate(new EvaluationParameters$1(tileZoom + 1));
            return {kind: 'constant', layoutSize: layoutSize};

        } else if (expression.kind === 'source') {
            return {kind: 'source'};

        } else {
            var zoomStops = expression.zoomStops;
            var interpolationType = expression.interpolationType;

            // calculate covering zoom stops for zoom-dependent values
            var lower = 0;
            while (lower < zoomStops.length && zoomStops[lower] <= tileZoom) {
                lower++;
            }
            lower = Math.max(0, lower - 1);
            var upper = lower;
            while (upper < zoomStops.length && zoomStops[upper] < tileZoom + 1) {
                upper++;
            }
            upper = Math.min(zoomStops.length - 1, upper);

            var minZoom = zoomStops[lower];
            var maxZoom = zoomStops[upper];

            // We'd like to be able to use CameraExpression or CompositeExpression in these
            // return types rather than ExpressionSpecification, but the former are not
            // transferrable across Web Worker boundaries.
            if (expression.kind === 'composite') {
                return {kind: 'composite', minZoom: minZoom, maxZoom: maxZoom, interpolationType: interpolationType};
            }

            // for camera functions, also save off the function values
            // evaluated at the covering zoom levels
            var minSize = expression.evaluate(new EvaluationParameters$1(minZoom));
            var maxSize = expression.evaluate(new EvaluationParameters$1(maxZoom));

            return {kind: 'camera', minZoom: minZoom, maxZoom: maxZoom, minSize: minSize, maxSize: maxSize, interpolationType: interpolationType};
        }
    }

    function evaluateSizeForFeature(sizeData, ref, ref$1) {
        var uSize = ref.uSize;
        var uSizeT = ref.uSizeT;
        var lowerSize = ref$1.lowerSize;
        var upperSize = ref$1.upperSize;

        if (sizeData.kind === 'source') {
            return lowerSize / SIZE_PACK_FACTOR;
        } else if (sizeData.kind === 'composite') {
            return number(lowerSize / SIZE_PACK_FACTOR, upperSize / SIZE_PACK_FACTOR, uSizeT);
        }
        return uSize;
    }

    function evaluateSizeForZoom(sizeData, zoom) {
        var uSizeT = 0;
        var uSize = 0;

        if (sizeData.kind === 'constant') {
            uSize = sizeData.layoutSize;

        } else if (sizeData.kind !== 'source') {
            var interpolationType = sizeData.interpolationType;
            var minZoom = sizeData.minZoom;
            var maxZoom = sizeData.maxZoom;

            // Even though we could get the exact value of the camera function
            // at z = tr.zoom, we intentionally do not: instead, we interpolate
            // between the camera function values at a pair of zoom stops covering
            // [tileZoom, tileZoom + 1] in order to be consistent with this
            // restriction on composite functions
    //            var t = !interpolationType ? 0 : clamp(
    //                Interpolate.interpolationFactor(interpolationType, zoom, minZoom, maxZoom), 0, 1);
            var t = 0;

            if (sizeData.kind === 'camera') {
                uSize = number(sizeData.minSize, sizeData.maxSize, t);
            } else {
                uSizeT = t;
            }
        }

        return {uSizeT: uSizeT, uSize: uSize};
    }

    var symbolSize = /*#__PURE__*/Object.freeze({
        __proto__: null,
        getSizeData: getSizeData,
        evaluateSizeForFeature: evaluateSizeForFeature,
        evaluateSizeForZoom: evaluateSizeForZoom,
        SIZE_PACK_FACTOR: SIZE_PACK_FACTOR
    });

    function transformText(text, layer, feature) {
        var transform = layer.layout.get('text-transform').evaluate(feature, {});
        if (transform === 'uppercase') {
            text = text.toLocaleUpperCase();
        } else if (transform === 'lowercase') {
            text = text.toLocaleLowerCase();
        }

    //        if (plugin.applyArabicShaping) {
    //            text = plugin.applyArabicShaping(text);
    //        }

        return text;
    }

    function transformText$1(text, layer, feature) {
        text.sections.forEach(function (section) {
            section.text = transformText(section.text, layer, feature);
        });
        return text;
    }

    // The following table comes from <http://www.unicode.org/Public/12.0.0/ucd/Blocks.txt>.
    // Keep it synchronized with <http://www.unicode.org/Public/UCD/latest/ucd/Blocks.txt>.

    var unicodeBlockLookup = {
        // 'Basic Latin': (char) => char >= 0x0000 && char <= 0x007F,
        'Latin-1 Supplement': function (char) {
            return char >= 0x0080 && char <= 0x00FF;
        },
        // 'Latin Extended-A': (char) => char >= 0x0100 && char <= 0x017F,
        // 'Latin Extended-B': (char) => char >= 0x0180 && char <= 0x024F,
        // 'IPA Extensions': (char) => char >= 0x0250 && char <= 0x02AF,
        // 'Spacing Modifier Letters': (char) => char >= 0x02B0 && char <= 0x02FF,
        // 'Combining Diacritical Marks': (char) => char >= 0x0300 && char <= 0x036F,
        // 'Greek and Coptic': (char) => char >= 0x0370 && char <= 0x03FF,
        // 'Cyrillic': (char) => char >= 0x0400 && char <= 0x04FF,
        // 'Cyrillic Supplement': (char) => char >= 0x0500 && char <= 0x052F,
        // 'Armenian': (char) => char >= 0x0530 && char <= 0x058F,
        //'Hebrew': (char) => char >= 0x0590 && char <= 0x05FF,
        'Arabic': function (char) {
            return char >= 0x0600 && char <= 0x06FF;
        },
        //'Syriac': (char) => char >= 0x0700 && char <= 0x074F,
        'Arabic Supplement': function (char) {
            return char >= 0x0750 && char <= 0x077F;
        },
        // 'Thaana': (char) => char >= 0x0780 && char <= 0x07BF,
        // 'NKo': (char) => char >= 0x07C0 && char <= 0x07FF,
        // 'Samaritan': (char) => char >= 0x0800 && char <= 0x083F,
        // 'Mandaic': (char) => char >= 0x0840 && char <= 0x085F,
        // 'Syriac Supplement': (char) => char >= 0x0860 && char <= 0x086F,
        'Arabic Extended-A': function (char) {
            return char >= 0x08A0 && char <= 0x08FF;
        },
        // 'Devanagari': (char) => char >= 0x0900 && char <= 0x097F,
        // 'Bengali': (char) => char >= 0x0980 && char <= 0x09FF,
        // 'Gurmukhi': (char) => char >= 0x0A00 && char <= 0x0A7F,
        // 'Gujarati': (char) => char >= 0x0A80 && char <= 0x0AFF,
        // 'Oriya': (char) => char >= 0x0B00 && char <= 0x0B7F,
        // 'Tamil': (char) => char >= 0x0B80 && char <= 0x0BFF,
        // 'Telugu': (char) => char >= 0x0C00 && char <= 0x0C7F,
        // 'Kannada': (char) => char >= 0x0C80 && char <= 0x0CFF,
        // 'Malayalam': (char) => char >= 0x0D00 && char <= 0x0D7F,
        // 'Sinhala': (char) => char >= 0x0D80 && char <= 0x0DFF,
        // 'Thai': (char) => char >= 0x0E00 && char <= 0x0E7F,
        // 'Lao': (char) => char >= 0x0E80 && char <= 0x0EFF,
        // 'Tibetan': (char) => char >= 0x0F00 && char <= 0x0FFF,
        // 'Myanmar': (char) => char >= 0x1000 && char <= 0x109F,
        // 'Georgian': (char) => char >= 0x10A0 && char <= 0x10FF,
        'Hangul Jamo': function (char) {
            return char >= 0x1100 && char <= 0x11FF;
        },
        // 'Ethiopic': (char) => char >= 0x1200 && char <= 0x137F,
        // 'Ethiopic Supplement': (char) => char >= 0x1380 && char <= 0x139F,
        // 'Cherokee': (char) => char >= 0x13A0 && char <= 0x13FF,
        'Unified Canadian Aboriginal Syllabics': function (char) {
            return char >= 0x1400 && char <= 0x167F;
        },
        // 'Ogham': (char) => char >= 0x1680 && char <= 0x169F,
        // 'Runic': (char) => char >= 0x16A0 && char <= 0x16FF,
        // 'Tagalog': (char) => char >= 0x1700 && char <= 0x171F,
        // 'Hanunoo': (char) => char >= 0x1720 && char <= 0x173F,
        // 'Buhid': (char) => char >= 0x1740 && char <= 0x175F,
        // 'Tagbanwa': (char) => char >= 0x1760 && char <= 0x177F,
        'Khmer': function (char) {
            return char >= 0x1780 && char <= 0x17FF;
        },
        // 'Mongolian': (char) => char >= 0x1800 && char <= 0x18AF,
        'Unified Canadian Aboriginal Syllabics Extended': function (char) {
            return char >= 0x18B0 && char <= 0x18FF;
        },
        // 'Limbu': (char) => char >= 0x1900 && char <= 0x194F,
        // 'Tai Le': (char) => char >= 0x1950 && char <= 0x197F,
        // 'New Tai Lue': (char) => char >= 0x1980 && char <= 0x19DF,
        // 'Khmer Symbols': (char) => char >= 0x19E0 && char <= 0x19FF,
        // 'Buginese': (char) => char >= 0x1A00 && char <= 0x1A1F,
        // 'Tai Tham': (char) => char >= 0x1A20 && char <= 0x1AAF,
        // 'Combining Diacritical Marks Extended': (char) => char >= 0x1AB0 && char <= 0x1AFF,
        // 'Balinese': (char) => char >= 0x1B00 && char <= 0x1B7F,
        // 'Sundanese': (char) => char >= 0x1B80 && char <= 0x1BBF,
        // 'Batak': (char) => char >= 0x1BC0 && char <= 0x1BFF,
        // 'Lepcha': (char) => char >= 0x1C00 && char <= 0x1C4F,
        // 'Ol Chiki': (char) => char >= 0x1C50 && char <= 0x1C7F,
        // 'Cyrillic Extended-C': (char) => char >= 0x1C80 && char <= 0x1C8F,
        // 'Georgian Extended': (char) => char >= 0x1C90 && char <= 0x1CBF,
        // 'Sundanese Supplement': (char) => char >= 0x1CC0 && char <= 0x1CCF,
        // 'Vedic Extensions': (char) => char >= 0x1CD0 && char <= 0x1CFF,
        // 'Phonetic Extensions': (char) => char >= 0x1D00 && char <= 0x1D7F,
        // 'Phonetic Extensions Supplement': (char) => char >= 0x1D80 && char <= 0x1DBF,
        // 'Combining Diacritical Marks Supplement': (char) => char >= 0x1DC0 && char <= 0x1DFF,
        // 'Latin Extended Additional': (char) => char >= 0x1E00 && char <= 0x1EFF,
        // 'Greek Extended': (char) => char >= 0x1F00 && char <= 0x1FFF,
        'General Punctuation': function (char) {
            return char >= 0x2000 && char <= 0x206F;
        },
        // 'Superscripts and Subscripts': (char) => char >= 0x2070 && char <= 0x209F,
        // 'Currency Symbols': (char) => char >= 0x20A0 && char <= 0x20CF,
        // 'Combining Diacritical Marks for Symbols': (char) => char >= 0x20D0 && char <= 0x20FF,
        'Letterlike Symbols': function (char) {
            return char >= 0x2100 && char <= 0x214F;
        },
        'Number Forms': function (char) {
            return char >= 0x2150 && char <= 0x218F;
        },
        // 'Arrows': (char) => char >= 0x2190 && char <= 0x21FF,
        // 'Mathematical Operators': (char) => char >= 0x2200 && char <= 0x22FF,
        'Miscellaneous Technical': function (char) {
            return char >= 0x2300 && char <= 0x23FF;
        },
        'Control Pictures': function (char) {
            return char >= 0x2400 && char <= 0x243F;
        },
        'Optical Character Recognition': function (char) {
            return char >= 0x2440 && char <= 0x245F;
        },
        'Enclosed Alphanumerics': function (char) {
            return char >= 0x2460 && char <= 0x24FF;
        },
        // 'Box Drawing': (char) => char >= 0x2500 && char <= 0x257F,
        // 'Block Elements': (char) => char >= 0x2580 && char <= 0x259F,
        'Geometric Shapes': function (char) {
            return char >= 0x25A0 && char <= 0x25FF;
        },
        'Miscellaneous Symbols': function (char) {
            return char >= 0x2600 && char <= 0x26FF;
        },
        // 'Dingbats': (char) => char >= 0x2700 && char <= 0x27BF,
        // 'Miscellaneous Mathematical Symbols-A': (char) => char >= 0x27C0 && char <= 0x27EF,
        // 'Supplemental Arrows-A': (char) => char >= 0x27F0 && char <= 0x27FF,
        // 'Braille Patterns': (char) => char >= 0x2800 && char <= 0x28FF,
        // 'Supplemental Arrows-B': (char) => char >= 0x2900 && char <= 0x297F,
        // 'Miscellaneous Mathematical Symbols-B': (char) => char >= 0x2980 && char <= 0x29FF,
        // 'Supplemental Mathematical Operators': (char) => char >= 0x2A00 && char <= 0x2AFF,
        'Miscellaneous Symbols and Arrows': function (char) {
            return char >= 0x2B00 && char <= 0x2BFF;
        },
        // 'Glagolitic': (char) => char >= 0x2C00 && char <= 0x2C5F,
        // 'Latin Extended-C': (char) => char >= 0x2C60 && char <= 0x2C7F,
        // 'Coptic': (char) => char >= 0x2C80 && char <= 0x2CFF,
        // 'Georgian Supplement': (char) => char >= 0x2D00 && char <= 0x2D2F,
        // 'Tifinagh': (char) => char >= 0x2D30 && char <= 0x2D7F,
        // 'Ethiopic Extended': (char) => char >= 0x2D80 && char <= 0x2DDF,
        // 'Cyrillic Extended-A': (char) => char >= 0x2DE0 && char <= 0x2DFF,
        // 'Supplemental Punctuation': (char) => char >= 0x2E00 && char <= 0x2E7F,
        'CJK Radicals Supplement': function (char) {
            return char >= 0x2E80 && char <= 0x2EFF;
        },
        'Kangxi Radicals': function (char) {
            return char >= 0x2F00 && char <= 0x2FDF;
        },
        'Ideographic Description Characters': function (char) {
            return char >= 0x2FF0 && char <= 0x2FFF;
        },
        'CJK Symbols and Punctuation': function (char) {
            return char >= 0x3000 && char <= 0x303F;
        },
        'Hiragana': function (char) {
            return char >= 0x3040 && char <= 0x309F;
        },
        'Katakana': function (char) {
            return char >= 0x30A0 && char <= 0x30FF;
        },
        'Bopomofo': function (char) {
            return char >= 0x3100 && char <= 0x312F;
        },
        'Hangul Compatibility Jamo': function (char) {
            return char >= 0x3130 && char <= 0x318F;
        },
        'Kanbun': function (char) {
            return char >= 0x3190 && char <= 0x319F;
        },
        'Bopomofo Extended': function (char) {
            return char >= 0x31A0 && char <= 0x31BF;
        },
        'CJK Strokes': function (char) {
            return char >= 0x31C0 && char <= 0x31EF;
        },
        'Katakana Phonetic Extensions': function (char) {
            return char >= 0x31F0 && char <= 0x31FF;
        },
        'Enclosed CJK Letters and Months': function (char) {
            return char >= 0x3200 && char <= 0x32FF;
        },
        'CJK Compatibility': function (char) {
            return char >= 0x3300 && char <= 0x33FF;
        },
        'CJK Unified Ideographs Extension A': function (char) {
            return char >= 0x3400 && char <= 0x4DBF;
        },
        'Yijing Hexagram Symbols': function (char) {
            return char >= 0x4DC0 && char <= 0x4DFF;
        },
        'CJK Unified Ideographs': function (char) {
            return char >= 0x4E00 && char <= 0x9FFF;
        },
        'Yi Syllables': function (char) {
            return char >= 0xA000 && char <= 0xA48F;
        },
        'Yi Radicals': function (char) {
            return char >= 0xA490 && char <= 0xA4CF;
        },
        // 'Lisu': (char) => char >= 0xA4D0 && char <= 0xA4FF,
        // 'Vai': (char) => char >= 0xA500 && char <= 0xA63F,
        // 'Cyrillic Extended-B': (char) => char >= 0xA640 && char <= 0xA69F,
        // 'Bamum': (char) => char >= 0xA6A0 && char <= 0xA6FF,
        // 'Modifier Tone Letters': (char) => char >= 0xA700 && char <= 0xA71F,
        // 'Latin Extended-D': (char) => char >= 0xA720 && char <= 0xA7FF,
        // 'Syloti Nagri': (char) => char >= 0xA800 && char <= 0xA82F,
        // 'Common Indic Number Forms': (char) => char >= 0xA830 && char <= 0xA83F,
        // 'Phags-pa': (char) => char >= 0xA840 && char <= 0xA87F,
        // 'Saurashtra': (char) => char >= 0xA880 && char <= 0xA8DF,
        // 'Devanagari Extended': (char) => char >= 0xA8E0 && char <= 0xA8FF,
        // 'Kayah Li': (char) => char >= 0xA900 && char <= 0xA92F,
        // 'Rejang': (char) => char >= 0xA930 && char <= 0xA95F,
        'Hangul Jamo Extended-A': function (char) {
            return char >= 0xA960 && char <= 0xA97F;
        },
        // 'Javanese': (char) => char >= 0xA980 && char <= 0xA9DF,
        // 'Myanmar Extended-B': (char) => char >= 0xA9E0 && char <= 0xA9FF,
        // 'Cham': (char) => char >= 0xAA00 && char <= 0xAA5F,
        // 'Myanmar Extended-A': (char) => char >= 0xAA60 && char <= 0xAA7F,
        // 'Tai Viet': (char) => char >= 0xAA80 && char <= 0xAADF,
        // 'Meetei Mayek Extensions': (char) => char >= 0xAAE0 && char <= 0xAAFF,
        // 'Ethiopic Extended-A': (char) => char >= 0xAB00 && char <= 0xAB2F,
        // 'Latin Extended-E': (char) => char >= 0xAB30 && char <= 0xAB6F,
        // 'Cherokee Supplement': (char) => char >= 0xAB70 && char <= 0xABBF,
        // 'Meetei Mayek': (char) => char >= 0xABC0 && char <= 0xABFF,
        'Hangul Syllables': function (char) {
            return char >= 0xAC00 && char <= 0xD7AF;
        },
        'Hangul Jamo Extended-B': function (char) {
            return char >= 0xD7B0 && char <= 0xD7FF;
        },
        // 'High Surrogates': (char) => char >= 0xD800 && char <= 0xDB7F,
        // 'High Private Use Surrogates': (char) => char >= 0xDB80 && char <= 0xDBFF,
        // 'Low Surrogates': (char) => char >= 0xDC00 && char <= 0xDFFF,
        'Private Use Area': function (char) {
            return char >= 0xE000 && char <= 0xF8FF;
        },
        'CJK Compatibility Ideographs': function (char) {
            return char >= 0xF900 && char <= 0xFAFF;
        },
        // 'Alphabetic Presentation Forms': (char) => char >= 0xFB00 && char <= 0xFB4F,
        'Arabic Presentation Forms-A': function (char) {
            return char >= 0xFB50 && char <= 0xFDFF;
        },
        // 'Variation Selectors': (char) => char >= 0xFE00 && char <= 0xFE0F,
        'Vertical Forms': function (char) {
            return char >= 0xFE10 && char <= 0xFE1F;
        },
        // 'Combining Half Marks': (char) => char >= 0xFE20 && char <= 0xFE2F,
        'CJK Compatibility Forms': function (char) {
            return char >= 0xFE30 && char <= 0xFE4F;
        },
        'Small Form Variants': function (char) {
            return char >= 0xFE50 && char <= 0xFE6F;
        },
        'Arabic Presentation Forms-B': function (char) {
            return char >= 0xFE70 && char <= 0xFEFF;
        },
        'Halfwidth and Fullwidth Forms': function (char) {
            return char >= 0xFF00 && char <= 0xFFEF;
        }
        // 'Specials': (char) => char >= 0xFFF0 && char <= 0xFFFF,
        // 'Linear B Syllabary': (char) => char >= 0x10000 && char <= 0x1007F,
        // 'Linear B Ideograms': (char) => char >= 0x10080 && char <= 0x100FF,
        // 'Aegean Numbers': (char) => char >= 0x10100 && char <= 0x1013F,
        // 'Ancient Greek Numbers': (char) => char >= 0x10140 && char <= 0x1018F,
        // 'Ancient Symbols': (char) => char >= 0x10190 && char <= 0x101CF,
        // 'Phaistos Disc': (char) => char >= 0x101D0 && char <= 0x101FF,
        // 'Lycian': (char) => char >= 0x10280 && char <= 0x1029F,
        // 'Carian': (char) => char >= 0x102A0 && char <= 0x102DF,
        // 'Coptic Epact Numbers': (char) => char >= 0x102E0 && char <= 0x102FF,
        // 'Old Italic': (char) => char >= 0x10300 && char <= 0x1032F,
        // 'Gothic': (char) => char >= 0x10330 && char <= 0x1034F,
        // 'Old Permic': (char) => char >= 0x10350 && char <= 0x1037F,
        // 'Ugaritic': (char) => char >= 0x10380 && char <= 0x1039F,
        // 'Old Persian': (char) => char >= 0x103A0 && char <= 0x103DF,
        // 'Deseret': (char) => char >= 0x10400 && char <= 0x1044F,
        // 'Shavian': (char) => char >= 0x10450 && char <= 0x1047F,
        // 'Osmanya': (char) => char >= 0x10480 && char <= 0x104AF,
        // 'Osage': (char) => char >= 0x104B0 && char <= 0x104FF,
        // 'Elbasan': (char) => char >= 0x10500 && char <= 0x1052F,
        // 'Caucasian Albanian': (char) => char >= 0x10530 && char <= 0x1056F,
        // 'Linear A': (char) => char >= 0x10600 && char <= 0x1077F,
        // 'Cypriot Syllabary': (char) => char >= 0x10800 && char <= 0x1083F,
        // 'Imperial Aramaic': (char) => char >= 0x10840 && char <= 0x1085F,
        // 'Palmyrene': (char) => char >= 0x10860 && char <= 0x1087F,
        // 'Nabataean': (char) => char >= 0x10880 && char <= 0x108AF,
        // 'Hatran': (char) => char >= 0x108E0 && char <= 0x108FF,
        // 'Phoenician': (char) => char >= 0x10900 && char <= 0x1091F,
        // 'Lydian': (char) => char >= 0x10920 && char <= 0x1093F,
        // 'Meroitic Hieroglyphs': (char) => char >= 0x10980 && char <= 0x1099F,
        // 'Meroitic Cursive': (char) => char >= 0x109A0 && char <= 0x109FF,
        // 'Kharoshthi': (char) => char >= 0x10A00 && char <= 0x10A5F,
        // 'Old South Arabian': (char) => char >= 0x10A60 && char <= 0x10A7F,
        // 'Old North Arabian': (char) => char >= 0x10A80 && char <= 0x10A9F,
        // 'Manichaean': (char) => char >= 0x10AC0 && char <= 0x10AFF,
        // 'Avestan': (char) => char >= 0x10B00 && char <= 0x10B3F,
        // 'Inscriptional Parthian': (char) => char >= 0x10B40 && char <= 0x10B5F,
        // 'Inscriptional Pahlavi': (char) => char >= 0x10B60 && char <= 0x10B7F,
        // 'Psalter Pahlavi': (char) => char >= 0x10B80 && char <= 0x10BAF,
        // 'Old Turkic': (char) => char >= 0x10C00 && char <= 0x10C4F,
        // 'Old Hungarian': (char) => char >= 0x10C80 && char <= 0x10CFF,
        // 'Hanifi Rohingya': (char) => char >= 0x10D00 && char <= 0x10D3F,
        // 'Rumi Numeral Symbols': (char) => char >= 0x10E60 && char <= 0x10E7F,
        // 'Old Sogdian': (char) => char >= 0x10F00 && char <= 0x10F2F,
        // 'Sogdian': (char) => char >= 0x10F30 && char <= 0x10F6F,
        // 'Elymaic': (char) => char >= 0x10FE0 && char <= 0x10FFF,
        // 'Brahmi': (char) => char >= 0x11000 && char <= 0x1107F,
        // 'Kaithi': (char) => char >= 0x11080 && char <= 0x110CF,
        // 'Sora Sompeng': (char) => char >= 0x110D0 && char <= 0x110FF,
        // 'Chakma': (char) => char >= 0x11100 && char <= 0x1114F,
        // 'Mahajani': (char) => char >= 0x11150 && char <= 0x1117F,
        // 'Sharada': (char) => char >= 0x11180 && char <= 0x111DF,
        // 'Sinhala Archaic Numbers': (char) => char >= 0x111E0 && char <= 0x111FF,
        // 'Khojki': (char) => char >= 0x11200 && char <= 0x1124F,
        // 'Multani': (char) => char >= 0x11280 && char <= 0x112AF,
        // 'Khudawadi': (char) => char >= 0x112B0 && char <= 0x112FF,
        // 'Grantha': (char) => char >= 0x11300 && char <= 0x1137F,
        // 'Newa': (char) => char >= 0x11400 && char <= 0x1147F,
        // 'Tirhuta': (char) => char >= 0x11480 && char <= 0x114DF,
        // 'Siddham': (char) => char >= 0x11580 && char <= 0x115FF,
        // 'Modi': (char) => char >= 0x11600 && char <= 0x1165F,
        // 'Mongolian Supplement': (char) => char >= 0x11660 && char <= 0x1167F,
        // 'Takri': (char) => char >= 0x11680 && char <= 0x116CF,
        // 'Ahom': (char) => char >= 0x11700 && char <= 0x1173F,
        // 'Dogra': (char) => char >= 0x11800 && char <= 0x1184F,
        // 'Warang Citi': (char) => char >= 0x118A0 && char <= 0x118FF,
        // 'Nandinagari': (char) => char >= 0x119A0 && char <= 0x119FF,
        // 'Zanabazar Square': (char) => char >= 0x11A00 && char <= 0x11A4F,
        // 'Soyombo': (char) => char >= 0x11A50 && char <= 0x11AAF,
        // 'Pau Cin Hau': (char) => char >= 0x11AC0 && char <= 0x11AFF,
        // 'Bhaiksuki': (char) => char >= 0x11C00 && char <= 0x11C6F,
        // 'Marchen': (char) => char >= 0x11C70 && char <= 0x11CBF,
        // 'Masaram Gondi': (char) => char >= 0x11D00 && char <= 0x11D5F,
        // 'Gunjala Gondi': (char) => char >= 0x11D60 && char <= 0x11DAF,
        // 'Makasar': (char) => char >= 0x11EE0 && char <= 0x11EFF,
        // 'Tamil Supplement': (char) => char >= 0x11FC0 && char <= 0x11FFF,
        // 'Cuneiform': (char) => char >= 0x12000 && char <= 0x123FF,
        // 'Cuneiform Numbers and Punctuation': (char) => char >= 0x12400 && char <= 0x1247F,
        // 'Early Dynastic Cuneiform': (char) => char >= 0x12480 && char <= 0x1254F,
        // 'Egyptian Hieroglyphs': (char) => char >= 0x13000 && char <= 0x1342F,
        // 'Egyptian Hieroglyph Format Controls': (char) => char >= 0x13430 && char <= 0x1343F,
        // 'Anatolian Hieroglyphs': (char) => char >= 0x14400 && char <= 0x1467F,
        // 'Bamum Supplement': (char) => char >= 0x16800 && char <= 0x16A3F,
        // 'Mro': (char) => char >= 0x16A40 && char <= 0x16A6F,
        // 'Bassa Vah': (char) => char >= 0x16AD0 && char <= 0x16AFF,
        // 'Pahawh Hmong': (char) => char >= 0x16B00 && char <= 0x16B8F,
        // 'Medefaidrin': (char) => char >= 0x16E40 && char <= 0x16E9F,
        // 'Miao': (char) => char >= 0x16F00 && char <= 0x16F9F,
        // 'Ideographic Symbols and Punctuation': (char) => char >= 0x16FE0 && char <= 0x16FFF,
        // 'Tangut': (char) => char >= 0x17000 && char <= 0x187FF,
        // 'Tangut Components': (char) => char >= 0x18800 && char <= 0x18AFF,
        // 'Kana Supplement': (char) => char >= 0x1B000 && char <= 0x1B0FF,
        // 'Kana Extended-A': (char) => char >= 0x1B100 && char <= 0x1B12F,
        // 'Small Kana Extension': (char) => char >= 0x1B130 && char <= 0x1B16F,
        // 'Nushu': (char) => char >= 0x1B170 && char <= 0x1B2FF,
        // 'Duployan': (char) => char >= 0x1BC00 && char <= 0x1BC9F,
        // 'Shorthand Format Controls': (char) => char >= 0x1BCA0 && char <= 0x1BCAF,
        // 'Byzantine Musical Symbols': (char) => char >= 0x1D000 && char <= 0x1D0FF,
        // 'Musical Symbols': (char) => char >= 0x1D100 && char <= 0x1D1FF,
        // 'Ancient Greek Musical Notation': (char) => char >= 0x1D200 && char <= 0x1D24F,
        // 'Mayan Numerals': (char) => char >= 0x1D2E0 && char <= 0x1D2FF,
        // 'Tai Xuan Jing Symbols': (char) => char >= 0x1D300 && char <= 0x1D35F,
        // 'Counting Rod Numerals': (char) => char >= 0x1D360 && char <= 0x1D37F,
        // 'Mathematical Alphanumeric Symbols': (char) => char >= 0x1D400 && char <= 0x1D7FF,
        // 'Sutton SignWriting': (char) => char >= 0x1D800 && char <= 0x1DAAF,
        // 'Glagolitic Supplement': (char) => char >= 0x1E000 && char <= 0x1E02F,
        // 'Nyiakeng Puachue Hmong': (char) => char >= 0x1E100 && char <= 0x1E14F,
        // 'Wancho': (char) => char >= 0x1E2C0 && char <= 0x1E2FF,
        // 'Mende Kikakui': (char) => char >= 0x1E800 && char <= 0x1E8DF,
        // 'Adlam': (char) => char >= 0x1E900 && char <= 0x1E95F,
        // 'Indic Siyaq Numbers': (char) => char >= 0x1EC70 && char <= 0x1ECBF,
        // 'Ottoman Siyaq Numbers': (char) => char >= 0x1ED00 && char <= 0x1ED4F,
        // 'Arabic Mathematical Alphabetic Symbols': (char) => char >= 0x1EE00 && char <= 0x1EEFF,
        // 'Mahjong Tiles': (char) => char >= 0x1F000 && char <= 0x1F02F,
        // 'Domino Tiles': (char) => char >= 0x1F030 && char <= 0x1F09F,
        // 'Playing Cards': (char) => char >= 0x1F0A0 && char <= 0x1F0FF,
        // 'Enclosed Alphanumeric Supplement': (char) => char >= 0x1F100 && char <= 0x1F1FF,
        // 'Enclosed Ideographic Supplement': (char) => char >= 0x1F200 && char <= 0x1F2FF,
        // 'Miscellaneous Symbols and Pictographs': (char) => char >= 0x1F300 && char <= 0x1F5FF,
        // 'Emoticons': (char) => char >= 0x1F600 && char <= 0x1F64F,
        // 'Ornamental Dingbats': (char) => char >= 0x1F650 && char <= 0x1F67F,
        // 'Transport and Map Symbols': (char) => char >= 0x1F680 && char <= 0x1F6FF,
        // 'Alchemical Symbols': (char) => char >= 0x1F700 && char <= 0x1F77F,
        // 'Geometric Shapes Extended': (char) => char >= 0x1F780 && char <= 0x1F7FF,
        // 'Supplemental Arrows-C': (char) => char >= 0x1F800 && char <= 0x1F8FF,
        // 'Supplemental Symbols and Pictographs': (char) => char >= 0x1F900 && char <= 0x1F9FF,
        // 'Chess Symbols': (char) => char >= 0x1FA00 && char <= 0x1FA6F,
        // 'Symbols and Pictographs Extended-A': (char) => char >= 0x1FA70 && char <= 0x1FAFF,
        // 'CJK Unified Ideographs Extension B': (char) => char >= 0x20000 && char <= 0x2A6DF,
        // 'CJK Unified Ideographs Extension C': (char) => char >= 0x2A700 && char <= 0x2B73F,
        // 'CJK Unified Ideographs Extension D': (char) => char >= 0x2B740 && char <= 0x2B81F,
        // 'CJK Unified Ideographs Extension E': (char) => char >= 0x2B820 && char <= 0x2CEAF,
        // 'CJK Unified Ideographs Extension F': (char) => char >= 0x2CEB0 && char <= 0x2EBEF,
        // 'CJK Compatibility Ideographs Supplement': (char) => char >= 0x2F800 && char <= 0x2FA1F,
        // 'Tags': (char) => char >= 0xE0000 && char <= 0xE007F,
        // 'Variation Selectors Supplement': (char) => char >= 0xE0100 && char <= 0xE01EF,
        // 'Supplementary Private Use Area-A': (char) => char >= 0xF0000 && char <= 0xFFFFF,
        // 'Supplementary Private Use Area-B': (char) => char >= 0x100000 && char <= 0x10FFFF,
    };

    var ScriptDetection = function ScriptDetection() {
    };

    ScriptDetection.allowsVerticalWritingMode = function(chars){
        for (var i = 0, list = chars; i < list.length; i += 1) {
            var char = list[i];

            if (charHasUprightVerticalOrientation(char.charCodeAt(0))) {
                return true;
            }
        }
        return false;
    };

    ScriptDetection.allowsLetterSpacing = function(chars){
        for (var i = 0, list = chars; i < list.length; i += 1) {
            var char = list[i];

            if (!charAllowsLetterSpacing(char.charCodeAt(0))) {
                return false;
            }
        }
        return true;
    };

    function charAllowsLetterSpacing(char) {
        if (unicodeBlockLookup['Arabic'](char)) {
            return false;
        }
        if (unicodeBlockLookup['Arabic Supplement'](char)) {
            return false;
        }
        if (unicodeBlockLookup['Arabic Extended-A'](char)) {
            return false;
        }
        if (unicodeBlockLookup['Arabic Presentation Forms-A'](char)) {
            return false;
        }
        if (unicodeBlockLookup['Arabic Presentation Forms-B'](char)) {
            return false;
        }

        return true;
    }

    // The following logic comes from
    // <http://www.unicode.org/Public/12.0.0/ucd/VerticalOrientation.txt>.
    // Keep it synchronized with
    // <http://www.unicode.org/Public/UCD/latest/ucd/VerticalOrientation.txt>.
    // The data file denotes with “U” or “Tu” any codepoint that may be drawn
    // upright in vertical text but does not distinguish between upright and
    // “neutral” characters.

    // Blocks in the Unicode supplementary planes are excluded from this module due
    // to <https://github.com/mapbox/mapbox-gl/issues/29>.

    /**
     * Returns true if the given Unicode codepoint identifies a character with
     * upright orientation.
     *
     * A character has upright orientation if it is drawn upright (unrotated)
     * whether the line is oriented horizontally or vertically, even if both
     * adjacent characters can be rotated. For example, a Chinese character is
     * always drawn upright. An uprightly oriented character causes an adjacent
     * “neutral” character to be drawn upright as well.
     * @private
     */
    function charHasUprightVerticalOrientation(char) {
        if (char === 0x02EA /* modifier letter yin departing tone mark */ ||
            char === 0x02EB /* modifier letter yang departing tone mark */) {
            return true;
        }

        // Return early for characters outside all ranges whose characters remain
        // upright in vertical writing mode.
        if (char < 0x1100) {
            return false;
        }

        if (unicodeBlockLookup['Bopomofo Extended'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Bopomofo'](char)) {
            return true;
        }
        if (unicodeBlockLookup['CJK Compatibility Forms'](char)) {
            if (!((char >= 0xFE49 /* dashed overline */ && char <= 0xFE4F) /* wavy low line */)) {
                return true;
            }
        }
        if (unicodeBlockLookup['CJK Compatibility Ideographs'](char)) {
            return true;
        }
        if (unicodeBlockLookup['CJK Compatibility'](char)) {
            return true;
        }
        if (unicodeBlockLookup['CJK Radicals Supplement'](char)) {
            return true;
        }
        if (unicodeBlockLookup['CJK Strokes'](char)) {
            return true;
        }
        if (unicodeBlockLookup['CJK Symbols and Punctuation'](char)) {
            if (!((char >= 0x3008 /* left angle bracket */ && char <= 0x3011) /* right black lenticular bracket */) && !((char >= 0x3014 /* left tortoise shell bracket */ && char <= 0x301F) /* low double prime quotation mark */) &&
                char !== 0x3030 /* wavy dash */) {
                return true;
            }
        }
        if (unicodeBlockLookup['CJK Unified Ideographs Extension A'](char)) {
            return true;
        }
        if (unicodeBlockLookup['CJK Unified Ideographs'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Enclosed CJK Letters and Months'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Hangul Compatibility Jamo'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Hangul Jamo Extended-A'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Hangul Jamo Extended-B'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Hangul Jamo'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Hangul Syllables'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Hiragana'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Ideographic Description Characters'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Kanbun'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Kangxi Radicals'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Katakana Phonetic Extensions'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Katakana'](char)) {
            if (char !== 0x30FC /* katakana-hiragana prolonged sound mark */) {
                return true;
            }
        }
        if (unicodeBlockLookup['Halfwidth and Fullwidth Forms'](char)) {
            if (char !== 0xFF08 /* fullwidth left parenthesis */ &&
                char !== 0xFF09 /* fullwidth right parenthesis */ &&
                char !== 0xFF0D /* fullwidth hyphen-minus */ && !((char >= 0xFF1A /* fullwidth colon */ && char <= 0xFF1E) /* fullwidth greater-than sign */) &&
                char !== 0xFF3B /* fullwidth left square bracket */ &&
                char !== 0xFF3D /* fullwidth right square bracket */ &&
                char !== 0xFF3F /* fullwidth low line */ && !(char >= 0xFF5B /* fullwidth left curly bracket */ && char <= 0xFFDF) &&
                char !== 0xFFE3 /* fullwidth macron */ && !(char >= 0xFFE8 /* halfwidth forms light vertical */ && char <= 0xFFEF)) {
                return true;
            }
        }
        if (unicodeBlockLookup['Small Form Variants'](char)) {
            if (!((char >= 0xFE58 /* small em dash */ && char <= 0xFE5E) /* small right tortoise shell bracket */) && !((char >= 0xFE63 /* small hyphen-minus */ && char <= 0xFE66) /* small equals sign */)) {
                return true;
            }
        }
        if (unicodeBlockLookup['Unified Canadian Aboriginal Syllabics'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Unified Canadian Aboriginal Syllabics Extended'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Vertical Forms'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Yijing Hexagram Symbols'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Yi Syllables'](char)) {
            return true;
        }
        if (unicodeBlockLookup['Yi Radicals'](char)) {
            return true;
        }

        return false;
    }

    function charInRTLScript(char) {
        // Main blocks for Hebrew, Arabic, Thaana and other RTL scripts
        return (char >= 0x0590 && char <= 0x08FF) ||
            unicodeBlockLookup['Arabic Presentation Forms-A'](char) ||
            unicodeBlockLookup['Arabic Presentation Forms-B'](char);
    }

    ScriptDetection.stringContainsRTLText = function(chars){
        for (var i = 0, list = chars; i < list.length; i += 1) {
            var char = list[i];

            if (charInRTLScript(char.charCodeAt(0))) {
                return true;
            }
        }
        return false;
    };

    var vectorTileFeatureTypes$2 = ['Unknown', 'Point', 'LineString', 'Polygon'];

    // Opacity arrays are frequently updated but don't contain a lot of information, so we pack them
    // tight. Each Uint32 is actually four duplicate Uint8s for the four corners of a glyph
    // 7 bits are for the current opacity, and the lowest bit is the target opacity

    // actually defined in symbol_attributes.js
    // const placementOpacityAttributes = [
    //     { name: 'a_fade_opacity', components: 1, type: 'Uint32' }
    // ];
    var shaderOpacityAttributes = [
        {name: 'a_fade_opacity', components: 1, type: 'Uint8', offset: 0}
    ];

    function addVertex$1(array, anchorX, anchorY, ox, oy, tx, ty, sizeVertex, isSDF, pixelOffsetX, pixelOffsetY, minFontScaleX, minFontScaleY) {
        var aSizeX = sizeVertex ? Math.min(MAX_PACKED_SIZE, Math.round(sizeVertex[0])) : 0;
        var aSizeY = sizeVertex ? Math.min(MAX_PACKED_SIZE, Math.round(sizeVertex[1])) : 0;
        array.emplaceBack(
            // a_pos_offset
            anchorX,
            anchorY,
            Math.round(ox * 32),
            Math.round(oy * 32),

            // a_data
            tx, // x coordinate of symbol on glyph atlas texture
            ty, // y coordinate of symbol on glyph atlas texture
            (aSizeX << 1) + (isSDF ? 1 : 0),
            aSizeY,
            pixelOffsetX * 16,
            pixelOffsetY * 16,
            minFontScaleX * 256,
            minFontScaleY * 256
        );
    }

    function addDynamicAttributes(dynamicLayoutVertexArray, p, angle) {
        dynamicLayoutVertexArray.emplaceBack(p.x, p.y, angle);
        dynamicLayoutVertexArray.emplaceBack(p.x, p.y, angle);
        dynamicLayoutVertexArray.emplaceBack(p.x, p.y, angle);
        dynamicLayoutVertexArray.emplaceBack(p.x, p.y, angle);
    }

    function containsRTLText(formattedText) {
        for (var i = 0, list = formattedText.sections; i < list.length; i += 1) {
            var section = list[i];

            if (ScriptDetection.stringContainsRTLText(section.text)) {
                return true;
            }
        }
        return false;
    }

    var SymbolBuffers = function SymbolBuffers(programConfigurations) {
        this.layoutVertexArray = new StructArrayLayout4i4ui4i24();
        this.indexArray = new StructArrayLayout3ui6();
        this.programConfigurations = programConfigurations;
        this.segments = new SegmentVector();
        this.dynamicLayoutVertexArray = new StructArrayLayout3f12();
        this.opacityVertexArray = new StructArrayLayout1ul4();
        this.placedSymbolArray = new PlacedSymbolArray();
    };

    SymbolBuffers.prototype.upload = function upload(context, dynamicIndexBuffer, upload$1, update) {
        if (upload$1) {
            this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, SymbolAttributes.symbolLayoutAttributes.members);
            this.indexBuffer = context.createIndexBuffer(this.indexArray, dynamicIndexBuffer);
            this.dynamicLayoutVertexBuffer = context.createVertexBuffer(this.dynamicLayoutVertexArray, SymbolAttributes.dynamicLayoutAttributes.members, true);
            this.opacityVertexBuffer = context.createVertexBuffer(this.opacityVertexArray, shaderOpacityAttributes, true);
            // This is a performance hack so that we can write to opacityVertexArray with uint32s
            // even though the shaders read uint8s
            this.opacityVertexBuffer.itemSize = 1;
        }
        if (upload$1 || update) {
            this.programConfigurations.upload(context);
        }
    };

    SymbolBuffers.prototype.destroy = function destroy() {
        if (!this.layoutVertexBuffer) {
            return;
        }
        this.layoutVertexBuffer.destroy();
        this.indexBuffer.destroy();
        this.programConfigurations.destroy();
        this.segments.destroy();
        this.dynamicLayoutVertexBuffer.destroy();
        this.opacityVertexBuffer.destroy();
    };

    SymbolBuffers.prototype.clear = function clear() {

    };

    WebWorkerTransfer.register('SymbolBuffers', SymbolBuffers);

    var CollisionBuffers = function CollisionBuffers(LayoutArray, layoutAttributes, IndexArray) {
        this.layoutVertexArray = new LayoutArray();
        this.layoutAttributes = layoutAttributes;
        this.indexArray = new IndexArray();
        this.segments = new SegmentVector();
        this.collisionVertexArray = new StructArrayLayout2ub2f12();
    };

    CollisionBuffers.prototype.upload = function upload(context) {
        this.layoutVertexBuffer = context.createVertexBuffer(this.layoutVertexArray, this.layoutAttributes);
        this.indexBuffer = context.createIndexBuffer(this.indexArray);
        this.collisionVertexBuffer = context.createVertexBuffer(this.collisionVertexArray, collisionVertexAttributes.members, true);
    };

    CollisionBuffers.prototype.destroy = function destroy() {
        if (!this.layoutVertexBuffer) {
            return;
        }
        this.layoutVertexBuffer.destroy();
        this.indexBuffer.destroy();
        this.segments.destroy();
        this.collisionVertexBuffer.destroy();
    };

    WebWorkerTransfer.register('CollisionBuffers', CollisionBuffers);

    /**
     * Unlike other buckets, which simply implement #addFeature with type-specific
     * logic for (essentially) triangulating feature geometries, SymbolBucket
     * requires specialized behavior:
     *
     * 1. WorkerTile#parse(), the logical owner of the bucket creation process,
     *    calls SymbolBucket#populate(), which resolves text and icon tokens on
     *    each feature, adds each glyphs and symbols needed to the passed-in
     *    collections options.glyphDependencies and options.iconDependencies, and
     *    stores the feature data for use in subsequent step (this.features).
     *
     * 2. WorkerTile asynchronously requests from the main thread all of the glyphs
     *    and icons needed (by this bucket and any others). When glyphs and icons
     *    have been received, the WorkerTile creates a CollisionIndex and invokes:
     *
     * 3. performSymbolLayout(bucket, stacks, icons) perform texts shaping and
     *    layout on a Symbol Bucket. This step populates:
     *      `this.symbolInstances`: metadata on generated symbols
     *      `this.collisionBoxArray`: collision data for use by foreground
     *      `this.text`: SymbolBuffers for text symbols
     *      `this.icons`: SymbolBuffers for icons
     *      `this.iconCollisionBox`: Debug SymbolBuffers for icon collision boxes
     *      `this.textCollisionBox`: Debug SymbolBuffers for text collision boxes
     *      `this.iconCollisionCircle`: Debug SymbolBuffers for icon collision circles
     *      `this.textCollisionCircle`: Debug SymbolBuffers for text collision circles
     *    The results are sent to the foreground for rendering
     *
     * 4. performSymbolPlacement(bucket, collisionIndex) is run on the foreground,
     *    and uses the CollisionIndex along with current camera settings to determine
     *    which symbols can actually show on the map. Collided symbols are hidden
     *    using a dynamic "OpacityVertexArray".
     *
     * @private
     */
    var SymbolBucket = function SymbolBucket(options) {
        this.collisionBoxArray = options.collisionBoxArray;
        this.zoom = options.zoom;
        this.overscaling = options.overscaling;
        this.layers = options.layers;
        this.layerIds = this.layers.map(function (layer) {
            return layer.id;
        });
        this.index = options.index;
        this.pixelRatio = options.pixelRatio;
        this.sourceLayerIndex = options.sourceLayerIndex;
        this.hasPattern = false;
        this.hasPaintOverrides = false;
        this.hasRTLText = false;

        var layer = this.layers[0];
        var unevaluatedLayoutValues = layer._unevaluatedLayout._values;

        this.textSizeData = symbolSize.getSizeData(this.zoom, unevaluatedLayoutValues['text-size']);
        this.iconSizeData = symbolSize.getSizeData(this.zoom, unevaluatedLayoutValues['icon-size']);

        var layout = this.layers[0].layout;
        var sortKey = layout.get('symbol-sort-key');
        var zOrder = layout.get('symbol-z-order');
        this.sortFeaturesByKey = zOrder !== 'viewport-y' && sortKey.constantOr(1) !== undefined;
        var zOrderByViewportY = zOrder === 'viewport-y' || (zOrder === 'auto' && !this.sortFeaturesByKey);
        this.sortFeaturesByY = zOrderByViewportY && (layout.get('text-allow-overlap') || layout.get('icon-allow-overlap') ||
            layout.get('text-ignore-placement') || layout.get('icon-ignore-placement'));

        if (layout.get('symbol-placement') === 'point') {
            this.writingModes = layout.get('text-writing-mode').map(function (wm) {
                return Shaping.WritingMode[wm];
            });
        }

        this.stateDependentLayerIds = this.layers.filter(function (l) {
            return l.isStateDependent();
        }).map(function (l) {
                return l.id;
            });

        this.sourceID = options.sourceID;
    };

    SymbolBucket.prototype.createArrays = function createArrays() {
    //        var layout = this.layers[0].layout;
    //        //this.hasPaintOverrides = SymbolStyleLayer.hasPaintOverrides(layout);
    //        this.hasPaintOverrides = false;
    //
    //        this.text = new SymbolBuffers(new ProgramConfigurationSet(SymbolAttributes.symbolLayoutAttributes.members, this.layers, this.zoom, function (property) {
    //            return /^text/.test(property);
    //        }));
    //        this.icon = new SymbolBuffers(new ProgramConfigurationSet(SymbolAttributes.symbolLayoutAttributes.members, this.layers, this.zoom, function (property) {
    //            return /^icon/.test(property);
    //        }));
    //
    //        this.textCollisionBox = new CollisionBuffers(StructArrayLayout2i2i2i12, SymbolAttributes.collisionBoxLayout.members, StructArrayLayout2ui4);
    //        this.iconCollisionBox = new CollisionBuffers(StructArrayLayout2i2i2i12, SymbolAttributes.collisionBoxLayout.members, StructArrayLayout2ui4);
    //        this.textCollisionCircle = new CollisionBuffers(StructArrayLayout2i2i2i12, SymbolAttributes.collisionCircleLayout.members, StructArrayLayout3ui6);
    //        this.iconCollisionCircle = new CollisionBuffers(StructArrayLayout2i2i2i12, SymbolAttributes.collisionCircleLayout.members, StructArrayLayout3ui6);
    //
    //        this.glyphOffsetArray = new GlyphOffsetArray();
    //        this.lineVertexArray = new SymbolLineVertexArray();
    //        this.symbolInstances = new SymbolInstanceArray();
    };

    SymbolBucket.prototype.calculateGlyphDependencies = function calculateGlyphDependencies(text, stack, textAlongLine, allowVerticalPlacement, doesAllowVerticalWritingMode) {
        for (var i = 0; i < text.length; i++) {
            stack[text.charCodeAt(i)] = true;
        }
    };

    SymbolBucket.prototype.populate = function populate(features, options) {
        var layer = this.layers[0];
        var layout = layer.layout;

        var textFont = layout.get('text-font');
        var textField = layout.get('text-field');
        var iconImage = layout.get('icon-image');
        var hasText =
            (textField.value.kind !== 'constant' ||
                (textField.value.value instanceof Formatted$1 && !textField.value.value.isEmpty()) ||
                textField.value.value.toString().length > 0) &&
                (textFont.value.kind !== 'constant' || textFont.value.value.length > 0);
        // we should always resolve the icon-image value if the property was defined in the style
        // this allows us to fire the styleimagemissing event if image evaluation returns null
        // the only way to distinguish between null returned from a coalesce statement with no valid images
        // and null returned because icon-image wasn't defined is to check whether or not iconImage.parameters is an empty object
        var hasIcon = (iconImage.value.kind !== 'constant' || !!iconImage.value.value) && Object.keys(iconImage.parameters).length > 0;
        var symbolSortKey = layout.get('symbol-sort-key');

        this.features = [];

        if (!hasText && !hasIcon) {
            return;
        }

        var icons = options.iconDependencies;
        var stacks = options.glyphDependencies;
        var availableImages = options.availableImages;
        var globalProperties = new EvaluationParameters$1(this.zoom);

        for (var i$1 = 0, list$1 = features; i$1 < list$1.length; i$1 += 1) {
            var ref = list$1[i$1];
            var feature = ref.feature;
            var index = ref.index;
            var sourceLayerIndex = ref.sourceLayerIndex;

            if (!layer._featureFilter(globalProperties, feature)) {
                continue;
            }

            var text = (void 0);
            if (hasText) {
                // Expression evaluation will automatically coerce to Formatted
                // but plain string token evaluation skips that pathway so do the
                // conversion here.
                var resolvedTokens = layer.getValueAndResolveTokens('text-field', feature, availableImages);
                var formattedText = Formatted$1.factory(resolvedTokens);
                if (containsRTLText(formattedText)) {
                    this.hasRTLText = true;
                }
                if (
                    !this.hasRTLText || // non-rtl text so can proceed safely
                        getRTLTextPluginStatus() === 'unavailable' || // We don't intend to lazy-load the rtl text plugin, so proceed with incorrect shaping
                        this.hasRTLText && plugin.isParsed() // Use the rtlText plugin to shape text
                    ) {
                    text = transformText$1(formattedText, layer, feature);
                }
            }

            var icon = (void 0);
            if (hasIcon) {
                // Expression evaluation will automatically coerce to Image
                // but plain string token evaluation skips that pathway so do the
                // conversion here.
                var resolvedTokens$1 = layer.getValueAndResolveTokens('icon-image', feature, availableImages);
                if (resolvedTokens$1 instanceof ResolvedImage$1) {
                    icon = resolvedTokens$1;
                } else {
                    icon = ResolvedImage$1.fromString(resolvedTokens$1);
                }
            }

            if (!text && !icon) {
                continue;
            }

            var sortKey = this.sortFeaturesByKey ?
                symbolSortKey.evaluate(feature, {}) :
                undefined;

            var symbolFeature = {
                text: text,
                icon: icon,
                index: index,
                sourceLayerIndex: sourceLayerIndex,
                geometry: loadGeometry(feature),
                properties: feature.properties,
                type: vectorTileFeatureTypes$2[feature.type],
                sortKey: sortKey
            };
            if (typeof feature.id !== 'undefined') {
                symbolFeature.id = feature.id;
            }
            this.features.push(symbolFeature);

            if (icon) {
                icons[icon.name] = true;
            }

            if (text) {
                var fontStack = textFont.evaluate(feature, {}).join(',');
                var textAlongLine = layout.get('text-rotation-alignment') === 'map' && layout.get('symbol-placement') !== 'point';
                this.allowVerticalPlacement = this.writingModes && this.writingModes.indexOf(Shaping.WritingMode.vertical) >= 0;
                for (var i = 0, list = text.sections; i < list.length; i += 1) {
                    var section = list[i];

                    if (!section.image) {
                        var doesAllowVerticalWritingMode = ScriptDetection.allowsVerticalWritingMode(text.toString());
                        var sectionFont = section.fontStack || fontStack;
                        var sectionStack = stacks[sectionFont] = stacks[sectionFont] || {};
                        this.calculateGlyphDependencies(section.text, sectionStack, textAlongLine, this.allowVerticalPlacement, doesAllowVerticalWritingMode);
                    } else {
                        // Add section image to the list of dependencies.
                        icons[section.image.name] = true;
                    }
                }
            }
        }

        if (layout.get('symbol-placement') === 'line') {
            // Merge adjacent lines with the same text to improve labelling.
            // It's better to place labels on one long line than on many short segments.
            this.features = mergeLines(this.features);
        }

        if (this.sortFeaturesByKey) {
            this.features.sort(function (a, b) {
                // a.sortKey is always a number when sortFeaturesByKey is true
                return ((a.sortKey   )      ) - ((b.sortKey   )      );
            });
        }
    };

    SymbolBucket.prototype.update = function update(states, vtLayer, imagePositions) {
        if (!this.stateDependentLayers.length) {
            return;
        }
        this.text.programConfigurations.updatePaintArrays(states, vtLayer, this.layers, imagePositions);
        this.icon.programConfigurations.updatePaintArrays(states, vtLayer, this.layers, imagePositions);
    };

    SymbolBucket.prototype.isEmpty = function isEmpty() {
        // When the bucket encounters only rtl-text but the plugin isnt loaded, no symbol instances will be created.
        // In order for the bucket to be serialized, and not discarded as an empty bucket both checks are necessary.
        return this.symbolInstances.length === 0 && !this.hasRTLText;
    };

    SymbolBucket.prototype.uploadPending = function uploadPending() {
        return !this.uploaded || this.text.programConfigurations.needsUpload || this.icon.programConfigurations.needsUpload;
    };

    SymbolBucket.prototype.upload = function upload(context) {
    //        if (!this.uploaded) {
    //            this.textCollisionBox.upload(context);
    //            this.iconCollisionBox.upload(context);
    //            this.textCollisionCircle.upload(context);
    //            this.iconCollisionCircle.upload(context);
    //        }
    //        this.text.upload(context, this.sortFeaturesByY, !this.uploaded, this.text.programConfigurations.needsUpload);
    //        this.icon.upload(context, this.sortFeaturesByY, !this.uploaded, this.icon.programConfigurations.needsUpload);
    //        this.uploaded = true;
    };

    SymbolBucket.prototype.destroy = function destroy() {
    //        this.text.destroy();
    //        this.icon.destroy();
    //        this.textCollisionBox.destroy();
    //        this.iconCollisionBox.destroy();
    //        this.textCollisionCircle.destroy();
    //        this.iconCollisionCircle.destroy();
    };

    SymbolBucket.prototype.clear = function clear() {
    };

    SymbolBucket.prototype.addToLineVertexArray = function addToLineVertexArray(anchor, line) {
        var lineStartIndex = this.lineVertexArray.length;
        if (anchor.segment !== undefined) {
            var sumForwardLength = anchor.dist(line[anchor.segment + 1]);
            var sumBackwardLength = anchor.dist(line[anchor.segment]);
            var vertices = {};
            for (var i = anchor.segment + 1; i < line.length; i++) {
                vertices[i] = {x: line[i].x, y: line[i].y, tileUnitDistanceFromAnchor: sumForwardLength};
                if (i < line.length - 1) {
                    sumForwardLength += line[i + 1].dist(line[i]);
                }
            }
            for (var i$1 = anchor.segment || 0; i$1 >= 0; i$1--) {
                vertices[i$1] = {x: line[i$1].x, y: line[i$1].y, tileUnitDistanceFromAnchor: sumBackwardLength};
                if (i$1 > 0) {
                    sumBackwardLength += line[i$1 - 1].dist(line[i$1]);
                }
            }
            for (var i$2 = 0; i$2 < line.length; i$2++) {
                var vertex = vertices[i$2];
                this.lineVertexArray.emplaceBack(vertex.x, vertex.y, vertex.tileUnitDistanceFromAnchor);
            }
        }
        return {
            lineStartIndex: lineStartIndex,
            lineLength: this.lineVertexArray.length - lineStartIndex
        };
    };

    SymbolBucket.prototype.addSymbols = function addSymbols(arrays, quads, sizeVertex, lineOffset, alongLine, feature, writingMode, labelAnchor, lineStartIndex, lineLength, associatedIconIndex) {
        var this$1 = this;

        var indexArray = arrays.indexArray;
        var layoutVertexArray = arrays.layoutVertexArray;
        var dynamicLayoutVertexArray = arrays.dynamicLayoutVertexArray;

        var segment = arrays.segments.prepareSegment(4 * quads.length, arrays.layoutVertexArray, arrays.indexArray, feature.sortKey);
        var glyphOffsetArrayStart = this.glyphOffsetArray.length;
        var vertexStartIndex = segment.vertexLength;

        var angle = (this.allowVerticalPlacement && writingMode === Shaping.WritingMode.vertical) ? Math.PI / 2 : 0;

        var addSymbol = function (symbol) {
            var tl = symbol.tl,
                tr = symbol.tr,
                bl = symbol.bl,
                br = symbol.br,
                tex = symbol.tex,
                pixelOffsetTL = symbol.pixelOffsetTL,
                pixelOffsetBR = symbol.pixelOffsetBR,
                mfsx = symbol.minFontScaleX,
                mfsy = symbol.minFontScaleY;

            var index = segment.vertexLength;

            var y = symbol.glyphOffset[1];
            addVertex$1(layoutVertexArray, labelAnchor.x, labelAnchor.y, tl.x, y + tl.y, tex.x, tex.y, sizeVertex, symbol.isSDF, pixelOffsetTL.x, pixelOffsetTL.y, mfsx, mfsy);
            addVertex$1(layoutVertexArray, labelAnchor.x, labelAnchor.y, tr.x, y + tr.y, tex.x + tex.w, tex.y, sizeVertex, symbol.isSDF, pixelOffsetBR.x, pixelOffsetTL.y, mfsx, mfsy);
            addVertex$1(layoutVertexArray, labelAnchor.x, labelAnchor.y, bl.x, y + bl.y, tex.x, tex.y + tex.h, sizeVertex, symbol.isSDF, pixelOffsetTL.x, pixelOffsetBR.y, mfsx, mfsy);
            addVertex$1(layoutVertexArray, labelAnchor.x, labelAnchor.y, br.x, y + br.y, tex.x + tex.w, tex.y + tex.h, sizeVertex, symbol.isSDF, pixelOffsetBR.x, pixelOffsetBR.y, mfsx, mfsy);

            addDynamicAttributes(dynamicLayoutVertexArray, labelAnchor, angle);

            indexArray.emplaceBack(index, index + 1, index + 2);
            indexArray.emplaceBack(index + 1, index + 2, index + 3);

            segment.vertexLength += 4;
            segment.primitiveLength += 2;

            this$1.glyphOffsetArray.emplaceBack(symbol.glyphOffset[0]);
        };

        if (feature.text && feature.text.sections) {
            var sections = feature.text.sections;

            if (this.hasPaintOverrides) {
                var currentSectionIndex;
                var populatePaintArrayForSection = function (sectionIndex, lastSection) {
                    if (currentSectionIndex !== undefined && (currentSectionIndex !== sectionIndex || lastSection)) {
                        arrays.programConfigurations.populatePaintArrays(arrays.layoutVertexArray.length, feature, feature.index, {}, sections[currentSectionIndex]);
                    }
                    currentSectionIndex = sectionIndex;
                };

                for (var i = 0, list = quads; i < list.length; i += 1) {
                    var symbol = list[i];

                    populatePaintArrayForSection(symbol.sectionIndex, false);
                    addSymbol(symbol);
                }

                // Populate paint arrays for the last section.
                populatePaintArrayForSection(currentSectionIndex, true);
            } else {
                for (var i$1 = 0, list$1 = quads; i$1 < list$1.length; i$1 += 1) {
                    var symbol$1 = list$1[i$1];

                    addSymbol(symbol$1);
                }
                arrays.programConfigurations.populatePaintArrays(arrays.layoutVertexArray.length, feature, feature.index, {}, sections[0]);
            }

        } else {
            for (var i$2 = 0, list$2 = quads; i$2 < list$2.length; i$2 += 1) {
                var symbol$2 = list$2[i$2];

                addSymbol(symbol$2);
            }
            arrays.programConfigurations.populatePaintArrays(arrays.layoutVertexArray.length, feature, feature.index, {});
        }

        arrays.placedSymbolArray.emplaceBack(labelAnchor.x, labelAnchor.y,
            glyphOffsetArrayStart, this.glyphOffsetArray.length - glyphOffsetArrayStart, vertexStartIndex,
            lineStartIndex, lineLength, (labelAnchor.segment   ),
            sizeVertex ? sizeVertex[0] : 0, sizeVertex ? sizeVertex[1] : 0,
            lineOffset[0], lineOffset[1],
            writingMode,
            // placedOrientation is null initially; will be updated to horizontal(1)/vertical(2) if placed
            0,
            (false   ),
            // The crossTileID is only filled/used on the foreground for dynamic text anchors
            0,
            associatedIconIndex
        );
    };

    SymbolBucket.prototype._addCollisionDebugVertex = function _addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, point, anchorX, anchorY, extrude) {
        collisionVertexArray.emplaceBack(0, 0);
        return layoutVertexArray.emplaceBack(
            // pos
            point.x,
            point.y,
            // a_anchor_pos
            anchorX,
            anchorY,
            // extrude
            Math.round(extrude.x),
            Math.round(extrude.y));
    };

    SymbolBucket.prototype.addCollisionDebugVertices = function addCollisionDebugVertices(x1, y1, x2, y2, arrays, boxAnchorPoint, symbolInstance, isCircle) {
        var segment = arrays.segments.prepareSegment(4, arrays.layoutVertexArray, arrays.indexArray);
        var index = segment.vertexLength;

        var layoutVertexArray = arrays.layoutVertexArray;
        var collisionVertexArray = arrays.collisionVertexArray;

        var anchorX = symbolInstance.anchorX;
        var anchorY = symbolInstance.anchorY;

        this._addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, boxAnchorPoint, anchorX, anchorY, new pointGeometry(x1, y1));
        this._addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, boxAnchorPoint, anchorX, anchorY, new pointGeometry(x2, y1));
        this._addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, boxAnchorPoint, anchorX, anchorY, new pointGeometry(x2, y2));
        this._addCollisionDebugVertex(layoutVertexArray, collisionVertexArray, boxAnchorPoint, anchorX, anchorY, new pointGeometry(x1, y2));

        segment.vertexLength += 4;
        if (isCircle) {
            var indexArray = (arrays.indexArray   );
            indexArray.emplaceBack(index, index + 1, index + 2);
            indexArray.emplaceBack(index, index + 2, index + 3);

            segment.primitiveLength += 2;
        } else {
            var indexArray$1 = (arrays.indexArray   );
            indexArray$1.emplaceBack(index, index + 1);
            indexArray$1.emplaceBack(index + 1, index + 2);
            indexArray$1.emplaceBack(index + 2, index + 3);
            indexArray$1.emplaceBack(index + 3, index);

            segment.primitiveLength += 4;
        }
    };

    SymbolBucket.prototype.addDebugCollisionBoxes = function addDebugCollisionBoxes(startIndex, endIndex, symbolInstance, isText) {
        for (var b = startIndex; b < endIndex; b++) {
            var box = (this.collisionBoxArray.get(b)   );
            var x1 = box.x1;
            var y1 = box.y1;
            var x2 = box.x2;
            var y2 = box.y2;

            // If the radius > 0, this collision box is actually a circle
            // The data we add to the buffers is exactly the same, but we'll render with a different shader.
            var isCircle = box.radius > 0;
            this.addCollisionDebugVertices(x1, y1, x2, y2, isCircle ?
                (isText ? this.textCollisionCircle : this.iconCollisionCircle) : (isText ? this.textCollisionBox : this.iconCollisionBox),
                box.anchorPoint, symbolInstance, isCircle);
        }
    };

    SymbolBucket.prototype.generateCollisionDebugBuffers = function generateCollisionDebugBuffers() {
        for (var i = 0; i < this.symbolInstances.length; i++) {
            var symbolInstance = this.symbolInstances.get(i);
            this.addDebugCollisionBoxes(symbolInstance.textBoxStartIndex, symbolInstance.textBoxEndIndex, symbolInstance, true);
            this.addDebugCollisionBoxes(symbolInstance.verticalTextBoxStartIndex, symbolInstance.verticalTextBoxEndIndex, symbolInstance, true);
            this.addDebugCollisionBoxes(symbolInstance.iconBoxStartIndex, symbolInstance.iconBoxEndIndex, symbolInstance, false);
            this.addDebugCollisionBoxes(symbolInstance.verticalIconBoxStartIndex, symbolInstance.verticalIconBoxEndIndex, symbolInstance, false);
        }
    };

    // These flat arrays are meant to be quicker to iterate over than the source
    // CollisionBoxArray
    SymbolBucket.prototype._deserializeCollisionBoxesForSymbol = function _deserializeCollisionBoxesForSymbol(collisionBoxArray, textStartIndex, textEndIndex, verticalTextStartIndex, verticalTextEndIndex, iconStartIndex, iconEndIndex, verticalIconStartIndex, verticalIconEndIndex) {

        var collisionArrays = {};
        for (var k = textStartIndex; k < textEndIndex; k++) {
            var box = (collisionBoxArray.get(k)   );
            if (box.radius === 0) {
                collisionArrays.textBox = {x1: box.x1, y1: box.y1, x2: box.x2, y2: box.y2, anchorPointX: box.anchorPointX, anchorPointY: box.anchorPointY};
                collisionArrays.textFeatureIndex = box.featureIndex;
                break; // Only one box allowed per instance
            } else {
                if (!collisionArrays.textCircles) {
                    collisionArrays.textCircles = [];
                    collisionArrays.textFeatureIndex = box.featureIndex;
                }
                var used = 1; // May be updated at collision detection time
                collisionArrays.textCircles.push(box.anchorPointX, box.anchorPointY, box.radius, box.signedDistanceFromAnchor, used);
            }
        }
        for (var k$1 = verticalTextStartIndex; k$1 < verticalTextEndIndex; k$1++) {
            var box$1 = (collisionBoxArray.get(k$1)   );
            if (box$1.radius === 0) {
                collisionArrays.verticalTextBox = {x1: box$1.x1, y1: box$1.y1, x2: box$1.x2, y2: box$1.y2, anchorPointX: box$1.anchorPointX, anchorPointY: box$1.anchorPointY};
                collisionArrays.verticalTextFeatureIndex = box$1.featureIndex;
                break; // Only one box allowed per instance
            }
        }
        for (var k$2 = iconStartIndex; k$2 < iconEndIndex; k$2++) {
            // An icon can only have one box now, so this indexing is a bit vestigial...
            var box$2 = (collisionBoxArray.get(k$2)   );
            if (box$2.radius === 0) {
                collisionArrays.iconBox = {x1: box$2.x1, y1: box$2.y1, x2: box$2.x2, y2: box$2.y2, anchorPointX: box$2.anchorPointX, anchorPointY: box$2.anchorPointY};
                collisionArrays.iconFeatureIndex = box$2.featureIndex;
                break; // Only one box allowed per instance
            }
        }
        for (var k$3 = verticalIconStartIndex; k$3 < verticalIconEndIndex; k$3++) {
            // An icon can only have one box now, so this indexing is a bit vestigial...
            var box$3 = (collisionBoxArray.get(k$3)   );
            if (box$3.radius === 0) {
                collisionArrays.verticalIconBox = {x1: box$3.x1, y1: box$3.y1, x2: box$3.x2, y2: box$3.y2, anchorPointX: box$3.anchorPointX, anchorPointY: box$3.anchorPointY};
                collisionArrays.verticalIconFeatureIndex = box$3.featureIndex;
                break; // Only one box allowed per instance
            }
        }
        return collisionArrays;
    };

    SymbolBucket.prototype.deserializeCollisionBoxes = function deserializeCollisionBoxes(collisionBoxArray) {
        this.collisionArrays = [];
        for (var i = 0; i < this.symbolInstances.length; i++) {
            var symbolInstance = this.symbolInstances.get(i);
            this.collisionArrays.push(this._deserializeCollisionBoxesForSymbol(
                collisionBoxArray,
                symbolInstance.textBoxStartIndex,
                symbolInstance.textBoxEndIndex,
                symbolInstance.verticalTextBoxStartIndex,
                symbolInstance.verticalTextBoxEndIndex,
                symbolInstance.iconBoxStartIndex,
                symbolInstance.iconBoxEndIndex,
                symbolInstance.verticalIconBoxStartIndex,
                symbolInstance.verticalIconBoxEndIndex
            ));
        }
    };

    SymbolBucket.prototype.hasTextData = function hasTextData() {
        return this.text.segments.get().length > 0;
    };

    SymbolBucket.prototype.hasIconData = function hasIconData() {
        return this.icon.segments.get().length > 0;
    };

    SymbolBucket.prototype.hasTextCollisionBoxData = function hasTextCollisionBoxData() {
        return this.textCollisionBox.segments.get().length > 0;
    };

    SymbolBucket.prototype.hasIconCollisionBoxData = function hasIconCollisionBoxData() {
        return this.iconCollisionBox.segments.get().length > 0;
    };

    SymbolBucket.prototype.hasTextCollisionCircleData = function hasTextCollisionCircleData() {
        return this.textCollisionCircle.segments.get().length > 0;
    };

    SymbolBucket.prototype.hasIconCollisionCircleData = function hasIconCollisionCircleData() {
        return this.iconCollisionCircle.segments.get().length > 0;
    };

    SymbolBucket.prototype.addIndicesForPlacedSymbol = function addIndicesForPlacedSymbol(iconOrText, placedSymbolIndex) {
        var placedSymbol = iconOrText.placedSymbolArray.get(placedSymbolIndex);

        var endIndex = placedSymbol.vertexStartIndex + placedSymbol.numGlyphs * 4;
        for (var vertexIndex = placedSymbol.vertexStartIndex; vertexIndex < endIndex; vertexIndex += 4) {
            iconOrText.indexArray.emplaceBack(vertexIndex, vertexIndex + 1, vertexIndex + 2);
            iconOrText.indexArray.emplaceBack(vertexIndex + 1, vertexIndex + 2, vertexIndex + 3);
        }
    };

    SymbolBucket.prototype.getSortedSymbolIndexes = function getSortedSymbolIndexes(angle) {
        if (this.sortedAngle === angle && this.symbolInstanceIndexes !== undefined) {
            return this.symbolInstanceIndexes;
        }
        var sin = Math.sin(angle);
        var cos = Math.cos(angle);
        var rotatedYs = [];
        var featureIndexes = [];
        var result = [];

        for (var i = 0; i < this.symbolInstances.length; ++i) {
            result.push(i);
            var symbolInstance = this.symbolInstances.get(i);
            rotatedYs.push(Math.round(sin * symbolInstance.anchorX + cos * symbolInstance.anchorY) | 0);
            featureIndexes.push(symbolInstance.featureIndex);
        }

        result.sort(function (aIndex, bIndex) {
            return (rotatedYs[aIndex] - rotatedYs[bIndex]) ||
                (featureIndexes[bIndex] - featureIndexes[aIndex]);
        });

        return result;
    };

    SymbolBucket.prototype.sortFeatures = function sortFeatures(angle) {
        var this$1 = this;

        if (!this.sortFeaturesByY) {
            return;
        }
        if (this.sortedAngle === angle) {
            return;
        }

        // The current approach to sorting doesn't sort across segments so don't try.
        // Sorting within segments separately seemed not to be worth the complexity.
        if (this.text.segments.get().length > 1 || this.icon.segments.get().length > 1) {
            return;
        }

        // If the symbols are allowed to overlap sort them by their vertical screen position.
        // The index array buffer is rewritten to reference the (unchanged) vertices in the
        // sorted order.

        // To avoid sorting the actual symbolInstance array we sort an array of indexes.
        this.symbolInstanceIndexes = this.getSortedSymbolIndexes(angle);
        this.sortedAngle = angle;

        this.text.indexArray.clear();
        this.icon.indexArray.clear();

        this.featureSortOrder = [];

        for (var i$1 = 0, list = this.symbolInstanceIndexes; i$1 < list.length; i$1 += 1) {
            var i = list[i$1];

            var symbolInstance = this.symbolInstances.get(i);
            this.featureSortOrder.push(symbolInstance.featureIndex);

            [
                symbolInstance.rightJustifiedTextSymbolIndex,
                symbolInstance.centerJustifiedTextSymbolIndex,
                symbolInstance.leftJustifiedTextSymbolIndex
            ].forEach(function (index, i, array) {
                    // Only add a given index the first time it shows up,
                    // to avoid duplicate opacity entries when multiple justifications
                    // share the same glyphs.
                    if (index >= 0 && array.indexOf(index) === i) {
                        this$1.addIndicesForPlacedSymbol(this$1.text, index);
                    }
                });

            if (symbolInstance.verticalPlacedTextSymbolIndex >= 0) {
                this.addIndicesForPlacedSymbol(this.text, symbolInstance.verticalPlacedTextSymbolIndex);
            }

            if (symbolInstance.placedIconSymbolIndex >= 0) {
                this.addIndicesForPlacedSymbol(this.icon, symbolInstance.placedIconSymbolIndex);
            }

            if (symbolInstance.verticalPlacedIconSymbolIndex >= 0) {
                this.addIndicesForPlacedSymbol(this.icon, symbolInstance.verticalPlacedIconSymbolIndex);
            }
        }

        if (this.text.indexBuffer) {
            this.text.indexBuffer.updateData(this.text.indexArray);
        }
        if (this.icon.indexBuffer) {
            this.icon.indexBuffer.updateData(this.icon.indexArray);
        }
    };

    WebWorkerTransfer.register('SymbolBucket', SymbolBucket, {
        //omit: ['layers', 'collisionBoxArray', 'features', 'compareText']
        omit: ['layers', 'collisionBoxArray', 'compareText']
    });

    // this constant is based on the size of StructArray indexes used in a symbol
    // bucket--namely, glyphOffsetArrayStart
    // eg the max valid UInt16 is 65,535
    // See https://github.com/mapbox/mapbox-gl-js/issues/2907 for motivation
    // lineStartIndex and textBoxStartIndex could potentially be concerns
    // but we expect there to be many fewer boxes/lines than glyphs
    SymbolBucket.MAX_GLYPHS = 65535;

    SymbolBucket.addDynamicAttributes = addDynamicAttributes;

    var ColorType$7 = {kind: 'color'};
    var FormattedType$4 = {kind: 'formatted'};

    var layout$7 = new Properties({
        "symbol-placement": new DataConstantProperty(StyleSpec["layout_symbol"]["symbol-placement"]),
        "symbol-spacing": new DataConstantProperty(StyleSpec["layout_symbol"]["symbol-spacing"]),
        "symbol-avoid-edges": new DataConstantProperty(StyleSpec["layout_symbol"]["symbol-avoid-edges"]),
        "symbol-sort-key": new DataDrivenProperty(StyleSpec["layout_symbol"]["symbol-sort-key"]),
        "symbol-z-order": new DataConstantProperty(StyleSpec["layout_symbol"]["symbol-z-order"]),
        "icon-allow-overlap": new DataConstantProperty(StyleSpec["layout_symbol"]["icon-allow-overlap"]),
        "icon-ignore-placement": new DataConstantProperty(StyleSpec["layout_symbol"]["icon-ignore-placement"]),
        "icon-optional": new DataConstantProperty(StyleSpec["layout_symbol"]["icon-optional"]),
        "icon-rotation-alignment": new DataConstantProperty(StyleSpec["layout_symbol"]["icon-rotation-alignment"]),
        "icon-size": new DataDrivenProperty(StyleSpec["layout_symbol"]["icon-size"]),
        "icon-text-fit": new DataConstantProperty(StyleSpec["layout_symbol"]["icon-text-fit"]),
        "icon-text-fit-padding": new DataConstantProperty(StyleSpec["layout_symbol"]["icon-text-fit-padding"]),
        "icon-image": new DataDrivenProperty(StyleSpec["layout_symbol"]["icon-image"]),
        "icon-rotate": new DataDrivenProperty(StyleSpec["layout_symbol"]["icon-rotate"]),
        "icon-padding": new DataConstantProperty(StyleSpec["layout_symbol"]["icon-padding"]),
        "icon-keep-upright": new DataConstantProperty(StyleSpec["layout_symbol"]["icon-keep-upright"]),
        "icon-offset": new DataDrivenProperty(StyleSpec["layout_symbol"]["icon-offset"]),
        "icon-anchor": new DataDrivenProperty(StyleSpec["layout_symbol"]["icon-anchor"]),
        "icon-pitch-alignment": new DataConstantProperty(StyleSpec["layout_symbol"]["icon-pitch-alignment"]),
        "text-pitch-alignment": new DataConstantProperty(StyleSpec["layout_symbol"]["text-pitch-alignment"]),
        "text-rotation-alignment": new DataConstantProperty(StyleSpec["layout_symbol"]["text-rotation-alignment"]),
        "text-field": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-field"]),
        "text-font": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-font"]),
        "text-size": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-size"]),
        "text-max-width": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-max-width"]),
        "text-line-height": new DataConstantProperty(StyleSpec["layout_symbol"]["text-line-height"]),
        "text-letter-spacing": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-letter-spacing"]),
        "text-justify": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-justify"]),
        "text-radial-offset": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-radial-offset"]),
        "text-variable-anchor": new DataConstantProperty(StyleSpec["layout_symbol"]["text-variable-anchor"]),
        "text-anchor": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-anchor"]),
        "text-max-angle": new DataConstantProperty(StyleSpec["layout_symbol"]["text-max-angle"]),
        "text-writing-mode": new DataConstantProperty(StyleSpec["layout_symbol"]["text-writing-mode"]),
        "text-rotate": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-rotate"]),
        "text-padding": new DataConstantProperty(StyleSpec["layout_symbol"]["text-padding"]),
        "text-keep-upright": new DataConstantProperty(StyleSpec["layout_symbol"]["text-keep-upright"]),
        "text-transform": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-transform"]),
        "text-offset": new DataDrivenProperty(StyleSpec["layout_symbol"]["text-offset"]),
        "text-allow-overlap": new DataConstantProperty(StyleSpec["layout_symbol"]["text-allow-overlap"]),
        "text-ignore-placement": new DataConstantProperty(StyleSpec["layout_symbol"]["text-ignore-placement"]),
        "text-optional": new DataConstantProperty(StyleSpec["layout_symbol"]["text-optional"])
    });


    var paint$7 = new Properties({
        "icon-opacity": new DataDrivenProperty(StyleSpec["paint_symbol"]["icon-opacity"]),
        "icon-color": new DataDrivenProperty(StyleSpec["paint_symbol"]["icon-color"]),
        "icon-halo-color": new DataDrivenProperty(StyleSpec["paint_symbol"]["icon-halo-color"]),
        "icon-halo-width": new DataDrivenProperty(StyleSpec["paint_symbol"]["icon-halo-width"]),
        "icon-halo-blur": new DataDrivenProperty(StyleSpec["paint_symbol"]["icon-halo-blur"]),
        "icon-translate": new DataConstantProperty(StyleSpec["paint_symbol"]["icon-translate"]),
        "icon-translate-anchor": new DataConstantProperty(StyleSpec["paint_symbol"]["icon-translate-anchor"]),
        "text-opacity": new DataDrivenProperty(StyleSpec["paint_symbol"]["text-opacity"]),
        "text-color": new DataDrivenProperty(StyleSpec["paint_symbol"]["text-color"], { runtimeType: ColorType$7, getOverride: function (o) {
            return o.textColor;
        }, hasOverride: function (o) {
            return !!o.textColor;
        } }),
        "text-halo-color": new DataDrivenProperty(StyleSpec["paint_symbol"]["text-halo-color"]),
        "text-halo-width": new DataDrivenProperty(StyleSpec["paint_symbol"]["text-halo-width"]),
        "text-halo-blur": new DataDrivenProperty(StyleSpec["paint_symbol"]["text-halo-blur"]),
        "text-translate": new DataConstantProperty(StyleSpec["paint_symbol"]["text-translate"]),
        "text-translate-anchor": new DataConstantProperty(StyleSpec["paint_symbol"]["text-translate-anchor"])
    });

    // Note: without adding the explicit type annotation, Flow infers weaker types
    // for these objects from their use in the constructor to StyleLayer, as
    // {layout?: Properties<...>, paint: Properties<...>}
    var properties$6 = ({ paint: paint$7, layout: layout$7 }
        );

    var SymbolStyleLayer = /*@__PURE__*/(function (StyleLayer) {
        function SymbolStyleLayer(layer) {
            StyleLayer.call(this, layer, properties$6);
        }

        if (StyleLayer) SymbolStyleLayer.__proto__ = StyleLayer;
        SymbolStyleLayer.prototype = Object.create(StyleLayer && StyleLayer.prototype);
        SymbolStyleLayer.prototype.constructor = SymbolStyleLayer;

        SymbolStyleLayer.prototype.recalculate = function recalculate(parameters, availableImages) {
            StyleLayer.prototype.recalculate.call(this, parameters, availableImages);

            if (this.layout.get('icon-rotation-alignment') === 'auto') {
                if (this.layout.get('symbol-placement') !== 'point') {
                    this.layout._values['icon-rotation-alignment'] = 'map';
                } else {
                    this.layout._values['icon-rotation-alignment'] = 'viewport';
                }
            }

            if (this.layout.get('text-rotation-alignment') === 'auto') {
                if (this.layout.get('symbol-placement') !== 'point') {
                    this.layout._values['text-rotation-alignment'] = 'map';
                } else {
                    this.layout._values['text-rotation-alignment'] = 'viewport';
                }
            }

            // If unspecified, `*-pitch-alignment` inherits `*-rotation-alignment`
            if (this.layout.get('text-pitch-alignment') === 'auto') {
                this.layout._values['text-pitch-alignment'] = this.layout.get('text-rotation-alignment');
            }
            if (this.layout.get('icon-pitch-alignment') === 'auto') {
                this.layout._values['icon-pitch-alignment'] = this.layout.get('icon-rotation-alignment');
            }

            if (this.layout.get('symbol-placement') === 'point') {
                var writingModes = this.layout.get('text-writing-mode');
                if (writingModes) {
                    // remove duplicates, preserving order
                    var deduped = [];
                    for (var i = 0, list = writingModes; i < list.length; i += 1) {
                        var m = list[i];

                        if (deduped.indexOf(m) < 0) {
                            deduped.push(m);
                        }
                    }
                    this.layout._values['text-writing-mode'] = deduped;
                } else {
                    this.layout._values['text-writing-mode'] = ['horizontal'];
                }
            }

            this._setPaintOverrides();
        };

        SymbolStyleLayer.prototype.getValueAndResolveTokens = function getValueAndResolveTokens(name, feature, availableImages) {
            var value = this.layout.get(name).evaluate(feature, {}, availableImages);
            var unevaluated = this._unevaluatedLayout._values[name];
            if (!unevaluated.isDataDriven() && !Expression.isExpression(unevaluated.value) && value) {
                return Util.resolveTokens(feature.properties, value);
            }

            return value;
        };

        SymbolStyleLayer.prototype.createBucket = function createBucket(parameters) {
            return new SymbolBucket(parameters);
        };

        SymbolStyleLayer.prototype.queryRadius = function queryRadius() {
            return 0;
        };

        SymbolStyleLayer.prototype.queryIntersectsFeature = function queryIntersectsFeature() {
            assert_1(false); // Should take a different path in FeatureIndex
            return false;
        };

        SymbolStyleLayer.prototype._setPaintOverrides = function _setPaintOverrides() {
            for (var i = 0, list = properties$6.paint.overridableProperties; i < list.length; i += 1) {
                var overridable = list[i];

                if (!SymbolStyleLayer.hasPaintOverride(this.layout, overridable)) {
                    continue;
                }
                var overriden = this.paint.get(overridable);
                var override = new FormatSectionOverride(overriden);
                var styleExpression = new StyleExpression(override, overriden.property.specification);
                var expression = null;
                if (overriden.value.kind === 'constant' || overriden.value.kind === 'source') {
                    expression = (new ZoomConstantExpression('source', styleExpression)                  );
                } else {
                    expression = (new ZoomDependentExpression('composite',
                        styleExpression,
                        overriden.value.zoomStops,
                        overriden.value._interpolationType)                     );
                }
                this.paint._values[overridable] = new PossiblyEvaluatedPropertyValue(overriden.property,
                    expression,
                    overriden.parameters);
            }
        };

        SymbolStyleLayer.prototype._handleOverridablePaintPropertyUpdate = function _handleOverridablePaintPropertyUpdate(name, oldValue, newValue) {
            if (!this.layout || oldValue.isDataDriven() || newValue.isDataDriven()) {
                return false;
            }
            return SymbolStyleLayer.hasPaintOverride(this.layout, name);
        };

        SymbolStyleLayer.hasPaintOverride = function hasPaintOverride(layout, propertyName) {
            var textField = layout.get('text-field');
            var property = properties$6.paint.properties[propertyName];
            var hasOverrides = false;

            var checkSections = function (sections) {
                for (var i = 0, list = sections; i < list.length; i += 1) {
                    var section = list[i];

                    if (property.overrides && property.overrides.hasOverride(section)) {
                        hasOverrides = true;
                        return;
                    }
                }
            };

            if (textField.value.kind === 'constant' && textField.value.value instanceof Formatted$1) {
                checkSections(textField.value.value.sections);
            } else if (textField.value.kind === 'source') {

                var checkExpression = function (expression) {
                    if (hasOverrides) {
                        return;
                    }

                    if (expression instanceof Literal && Values$1.typeOf(expression.value) === FormattedType$4) {
                        var formatted = ((expression.value)     );
                        checkSections(formatted.sections);
                    } else if (expression instanceof FormatExpression$1) {
                        checkSections(expression.sections);
                    } else {
                        expression.eachChild(checkExpression);
                    }
                };

                var expr = ((textField.value)     );
                if (expr._styleExpression) {
                    checkExpression(expr._styleExpression.expression);
                }
            }

            return hasOverrides;
        };

        SymbolStyleLayer.hasPaintOverrides = function hasPaintOverrides(layout) {
            for (var i = 0, list = properties$6.paint.overridableProperties; i < list.length; i += 1) {
                var overridable = list[i];

                if (SymbolStyleLayer.hasPaintOverride(layout, overridable)) {
                    return true;
                }
            }
            return false;
        };

        return SymbolStyleLayer;
    }(StyleLayer));

    var subclasses = {
        circle: CircleStyleLayer,
        fill: FillStyleLayer,
        line: LineStyleLayer,
        symbol : SymbolStyleLayer
    };

    function createStyleLayer(layer) {
        if(subclasses[layer.type]){
            return new subclasses[layer.type](layer);
        }
        else{
            return null;
        }
    }

    var StyleLayerIndex = function StyleLayerIndex(layerConfigs) {
        this.keyCache = {};
        if (layerConfigs) {
            this.replace(layerConfigs);
        }
    };

    StyleLayerIndex.prototype.replace = function replace (layerConfigs) {
        this._layerConfigs = {};
        this._layers = {};
        this.update(layerConfigs, []);
    };

    function values(obj) {
        var result = [];
        for (var k in obj) {
            result.push(obj[k]);
        }
        return result;
    }

    StyleLayerIndex.prototype.update = function update (layerConfigs, removedIds) {
        var this$1 = this;

        for (var i = 0, list = layerConfigs; i < list.length; i += 1) {
            var layerConfig = list[i];

            this._layerConfigs[layerConfig.id] = layerConfig;

            var layer = createStyleLayer(layerConfig);
            if(layer == null){
                continue;
            }
            this._layers[layerConfig.id] = layer;
            layer._featureFilter = featureFilter.createFilter(layer.filter);
            if (this.keyCache[layerConfig.id])
            { delete this.keyCache[layerConfig.id]; }
        }
        for (var i$1 = 0, list$1 = removedIds; i$1 < list$1.length; i$1 += 1) {
            var id = list$1[i$1];

            delete this.keyCache[id];
            delete this._layerConfigs[id];
            delete this._layers[id];
        }

        this.familiesBySource = {};

        var groups = groupByLayout(values(this._layerConfigs), this.keyCache);

        for (var i$2 = 0, list$2 = groups; i$2 < list$2.length; i$2 += 1) {
            var layerConfigs$1 = list$2[i$2];

            var layers = layerConfigs$1.map(function (layerConfig) { return this$1._layers[layerConfig.id]; });

            var layer$1 = layers[0];
            if (layer$1 == undefined || layer$1.visibility === 'none') {
                continue;
            }

            var sourceId = layer$1.source || '';
            var sourceGroup = this.familiesBySource[sourceId];
            if (!sourceGroup) {
                sourceGroup = this.familiesBySource[sourceId] = {};
            }

            var sourceLayerId = layer$1.sourceLayer;
            var sourceLayerFamilies = sourceGroup[sourceLayerId];
            if (!sourceLayerFamilies) {
                sourceLayerFamilies = sourceGroup[sourceLayerId] = [];
            }

            sourceLayerFamilies.push(layers);
        }
    };

    WebWorkerTransfer.register('FeatureIndex', FeatureIndex, {omit: ['rawTileData', 'sourceLayerCoder']});

    function MVTWorkTile(parameters, transferableObjects) {
        var pbfData = parameters.pbfData;
        var layers = parameters.layers;
        var imageMap = parameters.imageMap;
        var serializeObj = WebWorkerTransfer.deserialize(parameters.serializeObj);
        var featureIndex = serializeObj.featureIndex;
        var zoom = parameters.tileID.z;
        if(!when.defined(featureIndex)){
            featureIndex = new FeatureIndex(parameters.tileID);
            featureIndex.bucketLayerIDs = [];
        }
        var result = {};
        try {
            var styleIndexLayer = new StyleLayerIndex(layers);
            var vectorTile = loadVectorTile(pbfData);
            result = parse(vectorTile, styleIndexLayer, imageMap, featureIndex, zoom, parameters.indexData);
            result = WebWorkerTransfer.serialize(result, transferableObjects);
        }
        catch (err) {
        }
        return result;
    }

    function loadVectorTile(rawData) {
        if (!when.defined(rawData)) {
            return;
        }
        return new VectorTile(new pbf.Protobuf(rawData));
    }

    function parse(vectorTile, layerIndex, imageMap, featureIndex, zoom, indexData) {
        var sourceLayerCoder = new DictionaryCoder(Object.keys(vectorTile.layers).sort());
        var buckets = {};
        var options = {
            featureIndex: featureIndex,
            iconDependencies: {},
            patternDependencies: {},
            glyphDependencies: {},
            //availableImages: availableImages
        };

        for (var source in layerIndex.familiesBySource) {
            //if (source == "") continue;
            var layerFamilies = layerIndex.familiesBySource[source];
            for (var sourceLayerId in layerFamilies) {
                var sourceLayer = vectorTile.layers[sourceLayerId];
                if (!sourceLayer) {
                    continue;
                }

                var sourceLayerIndex = sourceLayerCoder.encode(sourceLayerId);
                var features = [];
                for (var index = 0; index < sourceLayer.length; index++) {
                    var feature = sourceLayer.feature(index);
                    features.push({feature: feature, index: index, sourceLayerIndex: sourceLayerIndex});
                }

                for (var i = 0, list = layerFamilies[sourceLayerId]; i < list.length; i += 1) {
                    var family = list[i];
                    var layer = family[0];
    //                    if(defined(layer.minzoom) && zoom < Math.floor(layer.minzoom)){
    //                        continue;
    //                    }
    //                    if(defined(layer.maxzoom) && zoom >= layer.maxzoom){
    //                        continue;
    //                    }
                    if (layer.visibility === 'none') {
                        continue;
                    }

                    //recalculateLayers(family, this.zoom, availableImages);
                    recalculateLayers(family, 0, null);

                    var bucket = buckets[layer.id] = layer.createBucket({
                        index: featureIndex.bucketLayerIDs.length,
                        layers: family,
    //                    zoom: this.zoom,
    //                    pixelRatio: this.pixelRatio,
    //                    overscaling : this.overscaling,
    //                    collisionBoxArray: this.collisionBoxArray,
                        sourceLayerIndex: sourceLayerIndex,
                        //sourceID: this.source
                    });

                    if (when.defined(indexData) && when.defined(indexData[layer.id])) {
                        options.indexData = indexData[layer.id];
                    }
                    bucket.populate(features, options);
                    featureIndex.bucketLayerIDs.push(family.map(function (l) { return l.id; }));
                }
            }
        }

        var imageAtlas = null;

        for (var key in buckets) {
            var bucket = buckets[key];
            if (bucket.hasPattern &&
                (bucket instanceof LineBucket || bucket instanceof FillBucket)) {
                //recalculateLayers(bucket.layers, this.zoom, availableImages);
                if(imageAtlas == null){
                    imageAtlas = new ImageAtlas({}, imageMap);
                }
                bucket.addFeatures(options, imageAtlas.patternPositions);
            }
        }

        return {
            buckets : buckets,
            imageAtlas : imageAtlas,
            featureIndex : featureIndex
        };
    }

    function recalculateLayers(layers, zoom, availableImages) {
        // Layers are shared and may have been used by a WorkerTile with a different zoom.
        var parameters = new EvaluationParameters$1(zoom);
        for (var i = 0, list = layers; i < list.length; i += 1) {
            var layer = list[i];
            layer.recalculate(parameters, availableImages);
        }
    }

    var MVTWorkTile$1 = createTaskProcessorWorker(MVTWorkTile);

    return MVTWorkTile$1;

});