@mapbox/mapbox-gl-style-spec 14.21.0 → 14.22.0

package/dist/index.cjs

@@ -20762,12 +20762,15 @@ ${ JSON.stringify(filterExp, null, 2) }
       layers = layers.slice();
       const map = /* @__PURE__ */
       Object.create(null);
-      for (let i = 0; i < layers.length; i++) {
-          map[layers[i].id] = layers[i];
+      for (const layer of layers) {
+          map[layer.id] = layer;
       }
       for (let i = 0; i < layers.length; i++) {
-          if ('ref' in layers[i]) {
-              layers[i] = deref(layers[i], map[layers[i].ref]);
+          const layer = layers[i];
+          if (layer && 'ref' in layer) {
+              const parent = map[layer.ref];
+              if (parent)
+                  layers[i] = deref(layer, parent);
           }
       }
       return layers;
@@ -22962,1086 +22965,137 @@ Use an identity property function instead: ${ example }.`)];
       return errors.slice().sort((a, b) => a.line && b.line ? a.line - b.line : 0);
   }
 
-  function commonjsRequire(path) {
-  	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-  }
-
-  var jsonlint$1 = {};
-
-  /* parser generated by jison 0.4.15 */
-
-  var hasRequiredJsonlint;
-
-  function requireJsonlint () {
-  	if (hasRequiredJsonlint) return jsonlint$1;
-  	hasRequiredJsonlint = 1;
-  	(function (exports$1) {
-  		/*
-  		  Returns a Parser object of the following structure:
-
-  		  Parser: {
-  		    yy: {}
-  		  }
-
-  		  Parser.prototype: {
-  		    yy: {},
-  		    trace: function(),
-  		    symbols_: {associative list: name ==> number},
-  		    terminals_: {associative list: number ==> name},
-  		    productions_: [...],
-  		    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
-  		    table: [...],
-  		    defaultActions: {...},
-  		    parseError: function(str, hash),
-  		    parse: function(input),
-
-  		    lexer: {
-  		        EOF: 1,
-  		        parseError: function(str, hash),
-  		        setInput: function(input),
-  		        input: function(),
-  		        unput: function(str),
-  		        more: function(),
-  		        less: function(n),
-  		        pastInput: function(),
-  		        upcomingInput: function(),
-  		        showPosition: function(),
-  		        test_match: function(regex_match_array, rule_index),
-  		        next: function(),
-  		        lex: function(),
-  		        begin: function(condition),
-  		        popState: function(),
-  		        _currentRules: function(),
-  		        topState: function(),
-  		        pushState: function(condition),
-
-  		        options: {
-  		            ranges: boolean           (optional: true ==> token location info will include a .range[] member)
-  		            flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
-  		            backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
-  		        },
-
-  		        performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
-  		        rules: [...],
-  		        conditions: {associative list: name ==> set},
-  		    }
-  		  }
-
-
-  		  token location info (@$, _$, etc.): {
-  		    first_line: n,
-  		    last_line: n,
-  		    first_column: n,
-  		    last_column: n,
-  		    range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
-  		  }
-
-
-  		  the parseError function receives a 'hash' object with these members for lexer and parser errors: {
-  		    text:        (matched text)
-  		    token:       (the produced terminal token, if any)
-  		    line:        (yylineno)
-  		  }
-  		  while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
-  		    loc:         (yylloc)
-  		    expected:    (string describing the set of expected tokens)
-  		    recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
-  		  }
-  		*/
-  		var parser = (function () {
-  		    var o = function (k, v, o, l) {
-  		            for (o = o || {}, l = k.length; l--; o[k[l]] = v);
-  		            return o;
-  		        }, $V0 = [
-  		            1,
-  		            12
-  		        ], $V1 = [
-  		            1,
-  		            13
-  		        ], $V2 = [
-  		            1,
-  		            9
-  		        ], $V3 = [
-  		            1,
-  		            10
-  		        ], $V4 = [
-  		            1,
-  		            11
-  		        ], $V5 = [
-  		            1,
-  		            14
-  		        ], $V6 = [
-  		            1,
-  		            15
-  		        ], $V7 = [
-  		            14,
-  		            18,
-  		            22,
-  		            24
-  		        ], $V8 = [
-  		            18,
-  		            22
-  		        ], $V9 = [
-  		            22,
-  		            24
-  		        ];
-  		    var parser = {
-  		        trace: function trace() {
-  		        },
-  		        yy: {},
-  		        symbols_: {
-  		            'error': 2,
-  		            'JSONString': 3,
-  		            'STRING': 4,
-  		            'JSONNumber': 5,
-  		            'NUMBER': 6,
-  		            'JSONNullLiteral': 7,
-  		            'NULL': 8,
-  		            'JSONBooleanLiteral': 9,
-  		            'TRUE': 10,
-  		            'FALSE': 11,
-  		            'JSONText': 12,
-  		            'JSONValue': 13,
-  		            'EOF': 14,
-  		            'JSONObject': 15,
-  		            'JSONArray': 16,
-  		            '{': 17,
-  		            '}': 18,
-  		            'JSONMemberList': 19,
-  		            'JSONMember': 20,
-  		            ':': 21,
-  		            ',': 22,
-  		            '[': 23,
-  		            ']': 24,
-  		            'JSONElementList': 25,
-  		            '$accept': 0,
-  		            '$end': 1
-  		        },
-  		        terminals_: {
-  		            2: 'error',
-  		            4: 'STRING',
-  		            6: 'NUMBER',
-  		            8: 'NULL',
-  		            10: 'TRUE',
-  		            11: 'FALSE',
-  		            14: 'EOF',
-  		            17: '{',
-  		            18: '}',
-  		            21: ':',
-  		            22: ',',
-  		            23: '[',
-  		            24: ']'
-  		        },
-  		        productions_: [
-  		            0,
-  		            [
-  		                3,
-  		                1
-  		            ],
-  		            [
-  		                5,
-  		                1
-  		            ],
-  		            [
-  		                7,
-  		                1
-  		            ],
-  		            [
-  		                9,
-  		                1
-  		            ],
-  		            [
-  		                9,
-  		                1
-  		            ],
-  		            [
-  		                12,
-  		                2
-  		            ],
-  		            [
-  		                13,
-  		                1
-  		            ],
-  		            [
-  		                13,
-  		                1
-  		            ],
-  		            [
-  		                13,
-  		                1
-  		            ],
-  		            [
-  		                13,
-  		                1
-  		            ],
-  		            [
-  		                13,
-  		                1
-  		            ],
-  		            [
-  		                13,
-  		                1
-  		            ],
-  		            [
-  		                15,
-  		                2
-  		            ],
-  		            [
-  		                15,
-  		                3
-  		            ],
-  		            [
-  		                20,
-  		                3
-  		            ],
-  		            [
-  		                19,
-  		                1
-  		            ],
-  		            [
-  		                19,
-  		                3
-  		            ],
-  		            [
-  		                16,
-  		                2
-  		            ],
-  		            [
-  		                16,
-  		                3
-  		            ],
-  		            [
-  		                25,
-  		                1
-  		            ],
-  		            [
-  		                25,
-  		                3
-  		            ]
-  		        ],
-  		        performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
-  		            /* this == yyval */
-  		            var $0 = $$.length - 1;
-  		            switch (yystate) {
-  		            case 1:
-  		                // replace escaped characters with actual character
-  		                this.$ = new String(yytext.replace(/\\(\\|")/g, '$' + '1').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t').replace(/\\v/g, '\x0B').replace(/\\f/g, '\f').replace(/\\b/g, '\b'));
-  		                this.$.__line__ = this._$.first_line;
-  		                break;
-  		            case 2:
-  		                this.$ = new Number(yytext);
-  		                this.$.__line__ = this._$.first_line;
-  		                break;
-  		            case 3:
-  		                this.$ = null;
-  		                break;
-  		            case 4:
-  		                this.$ = new Boolean(true);
-  		                this.$.__line__ = this._$.first_line;
-  		                break;
-  		            case 5:
-  		                this.$ = new Boolean(false);
-  		                this.$.__line__ = this._$.first_line;
-  		                break;
-  		            case 6:
-  		                return this.$ = $$[$0 - 1];
-  		            case 13:
-  		                this.$ = {};
-  		                Object.defineProperty(this.$, '__line__', {
-  		                    value: this._$.first_line,
-  		                    enumerable: false
-  		                });
-  		                break;
-  		            case 14:
-  		            case 19:
-  		                this.$ = $$[$0 - 1];
-  		                Object.defineProperty(this.$, '__line__', {
-  		                    value: this._$.first_line,
-  		                    enumerable: false
-  		                });
-  		                break;
-  		            case 15:
-  		                this.$ = [
-  		                    $$[$0 - 2],
-  		                    $$[$0]
-  		                ];
-  		                break;
-  		            case 16:
-  		                this.$ = {};
-  		                this.$[$$[$0][0]] = $$[$0][1];
-  		                break;
-  		            case 17:
-  		                this.$ = $$[$0 - 2];
-  		                $$[$0 - 2][$$[$0][0]] = $$[$0][1];
-  		                break;
-  		            case 18:
-  		                this.$ = [];
-  		                Object.defineProperty(this.$, '__line__', {
-  		                    value: this._$.first_line,
-  		                    enumerable: false
-  		                });
-  		                break;
-  		            case 20:
-  		                this.$ = [$$[$0]];
-  		                break;
-  		            case 21:
-  		                this.$ = $$[$0 - 2];
-  		                $$[$0 - 2].push($$[$0]);
-  		                break;
-  		            }
-  		        },
-  		        table: [
-  		            {
-  		                3: 5,
-  		                4: $V0,
-  		                5: 6,
-  		                6: $V1,
-  		                7: 3,
-  		                8: $V2,
-  		                9: 4,
-  		                10: $V3,
-  		                11: $V4,
-  		                12: 1,
-  		                13: 2,
-  		                15: 7,
-  		                16: 8,
-  		                17: $V5,
-  		                23: $V6
-  		            },
-  		            { 1: [3] },
-  		            {
-  		                14: [
-  		                    1,
-  		                    16
-  		                ]
-  		            },
-  		            o($V7, [
-  		                2,
-  		                7
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                8
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                9
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                10
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                11
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                12
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                3
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                4
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                5
-  		            ]),
-  		            o([
-  		                14,
-  		                18,
-  		                21,
-  		                22,
-  		                24
-  		            ], [
-  		                2,
-  		                1
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                2
-  		            ]),
-  		            {
-  		                3: 20,
-  		                4: $V0,
-  		                18: [
-  		                    1,
-  		                    17
-  		                ],
-  		                19: 18,
-  		                20: 19
-  		            },
-  		            {
-  		                3: 5,
-  		                4: $V0,
-  		                5: 6,
-  		                6: $V1,
-  		                7: 3,
-  		                8: $V2,
-  		                9: 4,
-  		                10: $V3,
-  		                11: $V4,
-  		                13: 23,
-  		                15: 7,
-  		                16: 8,
-  		                17: $V5,
-  		                23: $V6,
-  		                24: [
-  		                    1,
-  		                    21
-  		                ],
-  		                25: 22
-  		            },
-  		            {
-  		                1: [
-  		                    2,
-  		                    6
-  		                ]
-  		            },
-  		            o($V7, [
-  		                2,
-  		                13
-  		            ]),
-  		            {
-  		                18: [
-  		                    1,
-  		                    24
-  		                ],
-  		                22: [
-  		                    1,
-  		                    25
-  		                ]
-  		            },
-  		            o($V8, [
-  		                2,
-  		                16
-  		            ]),
-  		            {
-  		                21: [
-  		                    1,
-  		                    26
-  		                ]
-  		            },
-  		            o($V7, [
-  		                2,
-  		                18
-  		            ]),
-  		            {
-  		                22: [
-  		                    1,
-  		                    28
-  		                ],
-  		                24: [
-  		                    1,
-  		                    27
-  		                ]
-  		            },
-  		            o($V9, [
-  		                2,
-  		                20
-  		            ]),
-  		            o($V7, [
-  		                2,
-  		                14
-  		            ]),
-  		            {
-  		                3: 20,
-  		                4: $V0,
-  		                20: 29
-  		            },
-  		            {
-  		                3: 5,
-  		                4: $V0,
-  		                5: 6,
-  		                6: $V1,
-  		                7: 3,
-  		                8: $V2,
-  		                9: 4,
-  		                10: $V3,
-  		                11: $V4,
-  		                13: 30,
-  		                15: 7,
-  		                16: 8,
-  		                17: $V5,
-  		                23: $V6
-  		            },
-  		            o($V7, [
-  		                2,
-  		                19
-  		            ]),
-  		            {
-  		                3: 5,
-  		                4: $V0,
-  		                5: 6,
-  		                6: $V1,
-  		                7: 3,
-  		                8: $V2,
-  		                9: 4,
-  		                10: $V3,
-  		                11: $V4,
-  		                13: 31,
-  		                15: 7,
-  		                16: 8,
-  		                17: $V5,
-  		                23: $V6
-  		            },
-  		            o($V8, [
-  		                2,
-  		                17
-  		            ]),
-  		            o($V8, [
-  		                2,
-  		                15
-  		            ]),
-  		            o($V9, [
-  		                2,
-  		                21
-  		            ])
-  		        ],
-  		        defaultActions: {
-  		            16: [
-  		                2,
-  		                6
-  		            ]
-  		        },
-  		        parseError: function parseError(str, hash) {
-  		            if (hash.recoverable) {
-  		                this.trace(str);
-  		            } else {
-  		                throw new Error(str);
-  		            }
-  		        },
-  		        parse: function parse(input) {
-  		            var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, TERROR = 2, EOF = 1;
-  		            var args = lstack.slice.call(arguments, 1);
-  		            var lexer = Object.create(this.lexer);
-  		            var sharedState = { yy: {} };
-  		            for (var k in this.yy) {
-  		                if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
-  		                    sharedState.yy[k] = this.yy[k];
-  		                }
-  		            }
-  		            lexer.setInput(input, sharedState.yy);
-  		            sharedState.yy.lexer = lexer;
-  		            sharedState.yy.parser = this;
-  		            if (typeof lexer.yylloc == 'undefined') {
-  		                lexer.yylloc = {};
-  		            }
-  		            var yyloc = lexer.yylloc;
-  		            lstack.push(yyloc);
-  		            var ranges = lexer.options && lexer.options.ranges;
-  		            if (typeof sharedState.yy.parseError === 'function') {
-  		                this.parseError = sharedState.yy.parseError;
-  		            } else {
-  		                this.parseError = Object.getPrototypeOf(this).parseError;
-  		            }
-  		            function lex() {
-  		                var token;
-  		                token = lexer.lex() || EOF;
-  		                if (typeof token !== 'number') {
-  		                    token = self.symbols_[token] || token;
-  		                }
-  		                return token;
-  		            }
-  		            var symbol, state, action, r, yyval = {}, p, len, newState, expected;
-  		            while (true) {
-  		                state = stack[stack.length - 1];
-  		                if (this.defaultActions[state]) {
-  		                    action = this.defaultActions[state];
-  		                } else {
-  		                    if (symbol === null || typeof symbol == 'undefined') {
-  		                        symbol = lex();
-  		                    }
-  		                    action = table[state] && table[state][symbol];
-  		                }
-  		                if (typeof action === 'undefined' || !action.length || !action[0]) {
-  		                    var errStr = '';
-  		                    expected = [];
-  		                    for (p in table[state]) {
-  		                        if (this.terminals_[p] && p > TERROR) {
-  		                            expected.push('\'' + this.terminals_[p] + '\'');
-  		                        }
-  		                    }
-  		                    if (lexer.showPosition) {
-  		                        errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
-  		                    } else {
-  		                        errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
-  		                    }
-  		                    this.parseError(errStr, {
-  		                        text: lexer.match,
-  		                        token: this.terminals_[symbol] || symbol,
-  		                        line: lexer.yylineno,
-  		                        loc: yyloc,
-  		                        expected: expected
-  		                    });
-  		                }
-  		                if (action[0] instanceof Array && action.length > 1) {
-  		                    throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
-  		                }
-  		                switch (action[0]) {
-  		                case 1:
-  		                    stack.push(symbol);
-  		                    vstack.push(lexer.yytext);
-  		                    lstack.push(lexer.yylloc);
-  		                    stack.push(action[1]);
-  		                    symbol = null;
-  		                    {
-  		                        yyleng = lexer.yyleng;
-  		                        yytext = lexer.yytext;
-  		                        yylineno = lexer.yylineno;
-  		                        yyloc = lexer.yylloc;
-  		                    }
-  		                    break;
-  		                case 2:
-  		                    len = this.productions_[action[1]][1];
-  		                    yyval.$ = vstack[vstack.length - len];
-  		                    yyval._$ = {
-  		                        first_line: lstack[lstack.length - (len || 1)].first_line,
-  		                        last_line: lstack[lstack.length - 1].last_line,
-  		                        first_column: lstack[lstack.length - (len || 1)].first_column,
-  		                        last_column: lstack[lstack.length - 1].last_column
-  		                    };
-  		                    if (ranges) {
-  		                        yyval._$.range = [
-  		                            lstack[lstack.length - (len || 1)].range[0],
-  		                            lstack[lstack.length - 1].range[1]
-  		                        ];
-  		                    }
-  		                    r = this.performAction.apply(yyval, [
-  		                        yytext,
-  		                        yyleng,
-  		                        yylineno,
-  		                        sharedState.yy,
-  		                        action[1],
-  		                        vstack,
-  		                        lstack
-  		                    ].concat(args));
-  		                    if (typeof r !== 'undefined') {
-  		                        return r;
-  		                    }
-  		                    if (len) {
-  		                        stack = stack.slice(0, -1 * len * 2);
-  		                        vstack = vstack.slice(0, -1 * len);
-  		                        lstack = lstack.slice(0, -1 * len);
-  		                    }
-  		                    stack.push(this.productions_[action[1]][0]);
-  		                    vstack.push(yyval.$);
-  		                    lstack.push(yyval._$);
-  		                    newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
-  		                    stack.push(newState);
-  		                    break;
-  		                case 3:
-  		                    return true;
-  		                }
-  		            }
-  		            return true;
-  		        }
-  		    };
-  		    /* generated by jison-lex 0.3.4 */
-  		    var lexer = (function () {
-  		        var lexer = {
-  		            EOF: 1,
-  		            parseError: function parseError(str, hash) {
-  		                if (this.yy.parser) {
-  		                    this.yy.parser.parseError(str, hash);
-  		                } else {
-  		                    throw new Error(str);
-  		                }
-  		            },
-  		            // resets the lexer, sets new input
-  		            setInput: function (input, yy) {
-  		                this.yy = yy || this.yy || {};
-  		                this._input = input;
-  		                this._more = this._backtrack = this.done = false;
-  		                this.yylineno = this.yyleng = 0;
-  		                this.yytext = this.matched = this.match = '';
-  		                this.conditionStack = ['INITIAL'];
-  		                this.yylloc = {
-  		                    first_line: 1,
-  		                    first_column: 0,
-  		                    last_line: 1,
-  		                    last_column: 0
-  		                };
-  		                if (this.options.ranges) {
-  		                    this.yylloc.range = [
-  		                        0,
-  		                        0
-  		                    ];
-  		                }
-  		                this.offset = 0;
-  		                return this;
-  		            },
-  		            // consumes and returns one char from the input
-  		            input: function () {
-  		                var ch = this._input[0];
-  		                this.yytext += ch;
-  		                this.yyleng++;
-  		                this.offset++;
-  		                this.match += ch;
-  		                this.matched += ch;
-  		                var lines = ch.match(/(?:\r\n?|\n).*/g);
-  		                if (lines) {
-  		                    this.yylineno++;
-  		                    this.yylloc.last_line++;
-  		                } else {
-  		                    this.yylloc.last_column++;
-  		                }
-  		                if (this.options.ranges) {
-  		                    this.yylloc.range[1]++;
-  		                }
-  		                this._input = this._input.slice(1);
-  		                return ch;
-  		            },
-  		            // unshifts one char (or a string) into the input
-  		            unput: function (ch) {
-  		                var len = ch.length;
-  		                var lines = ch.split(/(?:\r\n?|\n)/g);
-  		                this._input = ch + this._input;
-  		                this.yytext = this.yytext.substr(0, this.yytext.length - len);
-  		                //this.yyleng -= len;
-  		                this.offset -= len;
-  		                var oldLines = this.match.split(/(?:\r\n?|\n)/g);
-  		                this.match = this.match.substr(0, this.match.length - 1);
-  		                this.matched = this.matched.substr(0, this.matched.length - 1);
-  		                if (lines.length - 1) {
-  		                    this.yylineno -= lines.length - 1;
-  		                }
-  		                var r = this.yylloc.range;
-  		                this.yylloc = {
-  		                    first_line: this.yylloc.first_line,
-  		                    last_line: this.yylineno + 1,
-  		                    first_column: this.yylloc.first_column,
-  		                    last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
-  		                };
-  		                if (this.options.ranges) {
-  		                    this.yylloc.range = [
-  		                        r[0],
-  		                        r[0] + this.yyleng - len
-  		                    ];
-  		                }
-  		                this.yyleng = this.yytext.length;
-  		                return this;
-  		            },
-  		            // When called from action, caches matched text and appends it on next action
-  		            more: function () {
-  		                this._more = true;
-  		                return this;
-  		            },
-  		            // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
-  		            reject: function () {
-  		                if (this.options.backtrack_lexer) {
-  		                    this._backtrack = true;
-  		                } else {
-  		                    return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
-  		                        text: '',
-  		                        token: null,
-  		                        line: this.yylineno
-  		                    });
-  		                }
-  		                return this;
-  		            },
-  		            // retain first n characters of the match
-  		            less: function (n) {
-  		                this.unput(this.match.slice(n));
-  		            },
-  		            // displays already matched input, i.e. for error messages
-  		            pastInput: function () {
-  		                var past = this.matched.substr(0, this.matched.length - this.match.length);
-  		                return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, '');
-  		            },
-  		            // displays upcoming input, i.e. for error messages
-  		            upcomingInput: function () {
-  		                var next = this.match;
-  		                if (next.length < 20) {
-  		                    next += this._input.substr(0, 20 - next.length);
-  		                }
-  		                return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, '');
-  		            },
-  		            // displays the character position where the lexing error occurred, i.e. for error messages
-  		            showPosition: function () {
-  		                var pre = this.pastInput();
-  		                var c = new Array(pre.length + 1).join('-');
-  		                return pre + this.upcomingInput() + '\n' + c + '^';
-  		            },
-  		            // test the lexed token: return FALSE when not a match, otherwise return token
-  		            test_match: function (match, indexed_rule) {
-  		                var token, lines, backup;
-  		                if (this.options.backtrack_lexer) {
-  		                    // save context
-  		                    backup = {
-  		                        yylineno: this.yylineno,
-  		                        yylloc: {
-  		                            first_line: this.yylloc.first_line,
-  		                            last_line: this.last_line,
-  		                            first_column: this.yylloc.first_column,
-  		                            last_column: this.yylloc.last_column
-  		                        },
-  		                        yytext: this.yytext,
-  		                        match: this.match,
-  		                        matches: this.matches,
-  		                        matched: this.matched,
-  		                        yyleng: this.yyleng,
-  		                        offset: this.offset,
-  		                        _more: this._more,
-  		                        _input: this._input,
-  		                        yy: this.yy,
-  		                        conditionStack: this.conditionStack.slice(0),
-  		                        done: this.done
-  		                    };
-  		                    if (this.options.ranges) {
-  		                        backup.yylloc.range = this.yylloc.range.slice(0);
-  		                    }
-  		                }
-  		                lines = match[0].match(/(?:\r\n?|\n).*/g);
-  		                if (lines) {
-  		                    this.yylineno += lines.length;
-  		                }
-  		                this.yylloc = {
-  		                    first_line: this.yylloc.last_line,
-  		                    last_line: this.yylineno + 1,
-  		                    first_column: this.yylloc.last_column,
-  		                    last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
-  		                };
-  		                this.yytext += match[0];
-  		                this.match += match[0];
-  		                this.matches = match;
-  		                this.yyleng = this.yytext.length;
-  		                if (this.options.ranges) {
-  		                    this.yylloc.range = [
-  		                        this.offset,
-  		                        this.offset += this.yyleng
-  		                    ];
-  		                }
-  		                this._more = false;
-  		                this._backtrack = false;
-  		                this._input = this._input.slice(match[0].length);
-  		                this.matched += match[0];
-  		                token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
-  		                if (this.done && this._input) {
-  		                    this.done = false;
-  		                }
-  		                if (token) {
-  		                    return token;
-  		                } else if (this._backtrack) {
-  		                    // recover context
-  		                    for (var k in backup) {
-  		                        this[k] = backup[k];
-  		                    }
-  		                    return false;    // rule action called reject() implying the next rule should be tested instead.
-  		                }
-  		                return false;
-  		            },
-  		            // return next match in input
-  		            next: function () {
-  		                if (this.done) {
-  		                    return this.EOF;
-  		                }
-  		                if (!this._input) {
-  		                    this.done = true;
-  		                }
-  		                var token, match, tempMatch, index;
-  		                if (!this._more) {
-  		                    this.yytext = '';
-  		                    this.match = '';
-  		                }
-  		                var rules = this._currentRules();
-  		                for (var i = 0; i < rules.length; i++) {
-  		                    tempMatch = this._input.match(this.rules[rules[i]]);
-  		                    if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
-  		                        match = tempMatch;
-  		                        index = i;
-  		                        if (this.options.backtrack_lexer) {
-  		                            token = this.test_match(tempMatch, rules[i]);
-  		                            if (token !== false) {
-  		                                return token;
-  		                            } else if (this._backtrack) {
-  		                                match = false;
-  		                                continue;    // rule action called reject() implying a rule MISmatch.
-  		                            } else {
-  		                                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
-  		                                return false;
-  		                            }
-  		                        } else if (!this.options.flex) {
-  		                            break;
-  		                        }
-  		                    }
-  		                }
-  		                if (match) {
-  		                    token = this.test_match(match, rules[index]);
-  		                    if (token !== false) {
-  		                        return token;
-  		                    }
-  		                    // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
-  		                    return false;
-  		                }
-  		                if (this._input === '') {
-  		                    return this.EOF;
-  		                } else {
-  		                    return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
-  		                        text: '',
-  		                        token: null,
-  		                        line: this.yylineno
-  		                    });
-  		                }
-  		            },
-  		            // return next match that has a token
-  		            lex: function lex() {
-  		                var r = this.next();
-  		                if (r) {
-  		                    return r;
-  		                } else {
-  		                    return this.lex();
-  		                }
-  		            },
-  		            // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
-  		            begin: function begin(condition) {
-  		                this.conditionStack.push(condition);
-  		            },
-  		            // pop the previously active lexer condition state off the condition stack
-  		            popState: function popState() {
-  		                var n = this.conditionStack.length - 1;
-  		                if (n > 0) {
-  		                    return this.conditionStack.pop();
-  		                } else {
-  		                    return this.conditionStack[0];
-  		                }
-  		            },
-  		            // produce the lexer rule set which is active for the currently active lexer condition state
-  		            _currentRules: function _currentRules() {
-  		                if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
-  		                    return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
-  		                } else {
-  		                    return this.conditions['INITIAL'].rules;
-  		                }
-  		            },
-  		            // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
-  		            topState: function topState(n) {
-  		                n = this.conditionStack.length - 1 - Math.abs(n || 0);
-  		                if (n >= 0) {
-  		                    return this.conditionStack[n];
-  		                } else {
-  		                    return 'INITIAL';
-  		                }
-  		            },
-  		            // alias for begin(condition)
-  		            pushState: function pushState(condition) {
-  		                this.begin(condition);
-  		            },
-  		            // return the number of states currently on the stack
-  		            stateStackSize: function stateStackSize() {
-  		                return this.conditionStack.length;
-  		            },
-  		            options: {},
-  		            performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
-  		                switch ($avoiding_name_collisions) {
-  		                case 0:
-  		                    /* skip whitespace */
-  		                    break;
-  		                case 1:
-  		                    return 6;
-  		                case 2:
-  		                    yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2);
-  		                    return 4;
-  		                case 3:
-  		                    return 17;
-  		                case 4:
-  		                    return 18;
-  		                case 5:
-  		                    return 23;
-  		                case 6:
-  		                    return 24;
-  		                case 7:
-  		                    return 22;
-  		                case 8:
-  		                    return 21;
-  		                case 9:
-  		                    return 10;
-  		                case 10:
-  		                    return 11;
-  		                case 11:
-  		                    return 8;
-  		                case 12:
-  		                    return 14;
-  		                case 13:
-  		                    return 'INVALID';
-  		                }
-  		            },
-  		            rules: [
-  		                /^(?:\s+)/,
-  		                /^(?:(-?([0-9]|[1-9][0-9]+))(\.[0-9]+)?([eE][-+]?[0-9]+)?\b)/,
-  		                /^(?:"(?:\\[\\"bfnrt/]|\\u[a-fA-F0-9]{4}|[^\\\0-\x09\x0a-\x1f"])*")/,
-  		                /^(?:\{)/,
-  		                /^(?:\})/,
-  		                /^(?:\[)/,
-  		                /^(?:\])/,
-  		                /^(?:,)/,
-  		                /^(?::)/,
-  		                /^(?:true\b)/,
-  		                /^(?:false\b)/,
-  		                /^(?:null\b)/,
-  		                /^(?:$)/,
-  		                /^(?:.)/
-  		            ],
-  		            conditions: {
-  		                'INITIAL': {
-  		                    'rules': [
-  		                        0,
-  		                        1,
-  		                        2,
-  		                        3,
-  		                        4,
-  		                        5,
-  		                        6,
-  		                        7,
-  		                        8,
-  		                        9,
-  		                        10,
-  		                        11,
-  		                        12,
-  		                        13
-  		                    ],
-  		                    'inclusive': true
-  		                }
-  		            }
-  		        };
-  		        return lexer;
-  		    }());
-  		    parser.lexer = lexer;
-  		    function Parser() {
-  		        this.yy = {};
-  		    }
-  		    Parser.prototype = parser;
-  		    parser.Parser = Parser;
-  		    return new Parser();
-  		}());
-  		if (typeof commonjsRequire !== 'undefined' && 'object' !== 'undefined') {
-  		    exports$1.parser = parser;
-  		    exports$1.Parser = parser.Parser;
-  		    exports$1.parse = function () {
-  		        return parser.parse.apply(parser, arguments);
-  		    };
-  		} 
-  	} (jsonlint$1));
-  	return jsonlint$1;
-  }
-
-  var jsonlintExports = requireJsonlint();
-  var jsonlint = /*@__PURE__*/getDefaultExportFromCjs(jsonlintExports);
-
   function readStyle(style) {
       if (style instanceof String || typeof style === 'string' || ArrayBuffer.isView(style)) {
           try {
-              return jsonlint.parse(style.toString());
+              const str = style.toString();
+              JSON.parse(str);
+              return parse(str);
           } catch (e) {
               throw new ParsingError(e);
           }
       }
       return style;
   }
+  const LBRACE = 0;
+  const RBRACE = 1;
+  const LBRACKET = 2;
+  const RBRACKET = 3;
+  const STRING = 4;
+  const NUMBER = 5;
+  const TRUE = 6;
+  const FALSE = 7;
+  const NULL = 8;
+  function tokenize(s) {
+      const tokens = [];
+      let pos = 0;
+      const len = s.length;
+      while (pos < len) {
+          const c = s.charCodeAt(pos);
+          if (c === 32 || c === 9 || c === 10 || c === 13 || c === 58 || c === 44) {
+              pos++;
+              continue;
+          }
+          const start = pos;
+          if (c === 123)
+              tokens.push(LBRACE, start, ++pos);
+          else if (c === 125)
+              tokens.push(RBRACE, start, ++pos);
+          else if (c === 91)
+              tokens.push(LBRACKET, start, ++pos);
+          else if (c === 93)
+              tokens.push(RBRACKET, start, ++pos);
+          else if (c === 34) {
+              pos++;
+              while (pos < len) {
+                  const ch = s.charCodeAt(pos);
+                  if (ch === 92)
+                      pos += s.charCodeAt(pos + 1) === 117 ? 6 : 2;
+                  else if (ch === 34)
+                      break;
+                  else
+                      pos++;
+              }
+              tokens.push(STRING, start, ++pos);
+          } else if (c === 116)
+              tokens.push(TRUE, start, pos += 4);
+          else if (c === 102)
+              tokens.push(FALSE, start, pos += 5);
+          else if (c === 110)
+              tokens.push(NULL, start, pos += 4);
+          else {
+              while (pos < len) {
+                  const ch = s.charCodeAt(pos);
+                  if (ch >= 48 && ch <= 57 || ch === 45 || ch === 43 || ch === 46 || ch === 101 || ch === 69)
+                      pos++;
+                  else
+                      break;
+              }
+              tokens.push(NUMBER, start, pos);
+          }
+      }
+      return tokens;
+  }
+  function parseTokens(s, tokens) {
+      let i = 0;
+      const lineOffsets = [0];
+      for (let j = 0; j < s.length; j++) {
+          if (s.charCodeAt(j) === 10)
+              lineOffsets.push(j + 1);
+      }
+      function lineNum(pos) {
+          let lo = 0, hi = lineOffsets.length - 1;
+          while (lo < hi) {
+              const mid = lo + hi + 1 >> 1;
+              if (lineOffsets[mid] <= pos)
+                  lo = mid;
+              else
+                  hi = mid - 1;
+          }
+          return lo + 1;
+      }
+      function setLine(obj, line) {
+          Object.defineProperty(obj, '__line__', { value: line });
+          return obj;
+      }
+      function parseValue() {
+          const type = tokens[i];
+          const start = tokens[i + 1];
+          const end = tokens[i + 2];
+          i += 3;
+          const line = lineNum(start);
+          if (type === LBRACE) {
+              const obj = setLine({}, line);
+              while (tokens[i] !== RBRACE) {
+                  const key = JSON.parse(s.slice(tokens[i + 1], tokens[i + 2]));
+                  i += 3;
+                  obj[key] = parseValue();
+              }
+              i += 3;
+              return obj;
+          }
+          if (type === LBRACKET) {
+              const arr = setLine([], line);
+              while (tokens[i] !== RBRACKET)
+                  arr.push(parseValue());
+              i += 3;
+              return arr;
+          }
+          if (type === STRING)
+              return setLine(new String(JSON.parse(s.slice(start, end))), line);
+          if (type === NUMBER)
+              return setLine(new Number(+s.slice(start, end)), line);
+          if (type === TRUE)
+              return setLine(new Boolean(true), line);
+          if (type === FALSE)
+              return setLine(new Boolean(false), line);
+          return null;
+      }
+      return parseValue();
+  }
+  function parse(s) {
+      return parseTokens(s, tokenize(s));
+  }
 
   function validateStyle(style, styleSpec = v8) {
       let s = style;