{"version":3,"file":"index.esm.mjs","sources":["../node_modules/.pnpm/@humanwhocodes+momoa@2.0.4/node_modules/@humanwhocodes/momoa/api.js","../lib/errors.ts","../lib/types.ts","../lib/get_type.ts","../lib/get_member_value.ts","../lib/get_array.ts","../lib/get_object.ts","../lib/array_is_numbers.ts","../lib/enforce_position.ts","../lib/enforce_position_array.ts","../lib/enforce_same_position.ts","../lib/enforce_bbox.ts","../lib/forbid_confusing_properties.ts","../lib/index.ts","../lib/check_duplicate_keys.ts"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n/**\n * @fileoverview JSON syntax helpers\n * @author Nicholas C. Zakas\n */\n\n//-----------------------------------------------------------------------------\n// Predefined Tokens\n//-----------------------------------------------------------------------------\n\nconst LBRACKET = \"[\";\nconst RBRACKET = \"]\";\nconst LBRACE = \"{\";\nconst RBRACE = \"}\";\nconst COLON = \":\";\nconst COMMA = \",\";\n\nconst TRUE = \"true\";\nconst FALSE = \"false\";\nconst NULL = \"null\";\n\nconst QUOTE = \"\\\"\";\n\nconst expectedKeywords = new Map([\n    [\"t\", TRUE],\n    [\"f\", FALSE],\n    [\"n\", NULL]\n]);\n\nconst escapeToChar = new Map([\n    [QUOTE, QUOTE],\n    [\"\\\\\", \"\\\\\"],\n    [\"/\", \"/\"],\n    [\"b\", \"\\b\"],\n    [\"n\", \"\\n\"],\n    [\"f\", \"\\f\"],\n    [\"r\", \"\\r\"],\n    [\"t\", \"\\t\"]\n]);\n\nconst knownTokenTypes = new Map([\n    [LBRACKET, \"Punctuator\"],\n    [RBRACKET, \"Punctuator\"],\n    [LBRACE, \"Punctuator\"],\n    [RBRACE, \"Punctuator\"],\n    [COLON, \"Punctuator\"],\n    [COMMA, \"Punctuator\"],\n    [TRUE, \"Boolean\"],\n    [FALSE, \"Boolean\"],\n    [NULL, \"Null\"]\n]);\n\n/**\n * @fileoverview JSON tokenization/parsing errors\n * @author Nicholas C. Zakas\n */\n\n\n/**\n * Base class that attaches location to an error.\n */\nclass ErrorWithLocation extends Error {\n\n    /**\n     * \n     * @param {string} message The error message to report. \n     * @param {int} loc.line The line on which the error occurred.\n     * @param {int} loc.column The column in the line where the error occurrred.\n     * @param {int} loc.index The index in the string where the error occurred.\n     */\n    constructor(message, { line, column, index }) {\n        super(`${ message } (${ line }:${ column})`);\n\n        /**\n         * The line on which the error occurred.\n         * @type int\n         * @property line\n         */\n        this.line = line;\n\n        /**\n         * The column on which the error occurred.\n         * @type int\n         * @property column\n         */\n        this.column = column;\n        \n        /**\n         * The index into the string where the error occurred.\n         * @type int\n         * @property index\n         */\n        this.index = index;\n    }\n\n}\n\n/**\n * Error thrown when an unexpected character is found during tokenizing.\n */\nclass UnexpectedChar extends ErrorWithLocation {\n\n    /**\n     * Creates a new instance.\n     * @param {string} unexpected The character that was found.\n     * @param {Object} loc The location information for the found character.\n     */\n    constructor(unexpected, loc) {\n        super(`Unexpected character ${ unexpected } found.`, loc);\n    }\n}\n\n/**\n * Error thrown when an unexpected token is found during parsing.\n */\nclass UnexpectedToken extends ErrorWithLocation {\n\n    /**\n     * Creates a new instance.\n     * @param {string} expected The character that was expected. \n     * @param {string} unexpected The character that was found.\n     * @param {Object} loc The location information for the found character.\n     */\n    constructor(token) {\n        super(`Unexpected token ${ token.type }(${ token.value }) found.`, token.loc.start);\n    }\n}\n\n/**\n * Error thrown when the end of input is found where it isn't expected.\n */\nclass UnexpectedEOF extends ErrorWithLocation {\n\n    /**\n     * Creates a new instance.\n     * @param {Object} loc The location information for the found character.\n     */\n    constructor(loc) {\n        super(\"Unexpected end of input found.\", loc);\n    }\n}\n\n/**\n * @fileoverview JSON tokenizer\n * @author Nicholas C. Zakas\n */\n\n//-----------------------------------------------------------------------------\n// Helpers\n//-----------------------------------------------------------------------------\n\nconst QUOTE$1 = \"\\\"\";\nconst SLASH = \"/\";\nconst STAR = \"*\";\n\nconst DEFAULT_OPTIONS = {\n    comments: false,\n    ranges: false\n};\n\nfunction isWhitespace(c) {\n    return /[\\s\\n]/.test(c);\n}\n\nfunction isDigit(c) {\n    return c >= \"0\" && c <= \"9\";\n}\n\nfunction isHexDigit(c) {\n    return isDigit(c) || /[a-f]/i.test(c);\n}\n\nfunction isPositiveDigit(c) {\n    return c >= \"1\" && c <= \"9\";\n}\n\nfunction isKeywordStart(c) {\n    return /[tfn]/.test(c);\n}\n\nfunction isNumberStart(c) {\n    return isDigit(c) || c === \".\" || c === \"-\";\n}\n\n//-----------------------------------------------------------------------------\n// Main\n//-----------------------------------------------------------------------------\n\n/**\n * Creates an iterator over the tokens representing the source text.\n * @param {string} text The source text to tokenize.\n * @returns {Iterator} An iterator over the tokens. \n */\nfunction tokenize(text, options) {\n\n    options = Object.freeze({\n        ...DEFAULT_OPTIONS,\n        ...options\n    });\n\n    let offset = -1;\n    let line = 1;\n    let column = 0;\n    let newLine = false;\n\n    const tokens = [];\n\n\n    function createToken(tokenType, value, startLoc, endLoc) {\n        \n        const endOffset = startLoc.offset + value.length;\n        let range = options.ranges ? {\n            range: [startLoc.offset, endOffset]\n        } : undefined;\n        \n        return {\n            type: tokenType,\n            value,\n            loc: {\n                start: startLoc,\n                end: endLoc || {\n                    line: startLoc.line,\n                    column: startLoc.column + value.length,\n                    offset: endOffset\n                }\n            },\n            ...range\n        };\n    }\n\n    function next() {\n        let c = text.charAt(++offset);\n    \n        if (newLine) {\n            line++;\n            column = 1;\n            newLine = false;\n        } else {\n            column++;\n        }\n\n        if (c === \"\\r\") {\n            newLine = true;\n\n            // if we already see a \\r, just ignore upcoming \\n\n            if (text.charAt(offset + 1) === \"\\n\") {\n                offset++;\n            }\n        } else if (c === \"\\n\") {\n            newLine = true;\n        }\n\n        return c;\n    }\n\n    function locate() {\n        return {\n            line,\n            column,\n            offset\n        };\n    }\n\n    function readKeyword(c) {\n\n        // get the expected keyword\n        let value = expectedKeywords.get(c);\n\n        // check to see if it actually exists\n        if (text.slice(offset, offset + value.length) === value) {\n            offset += value.length - 1;\n            column += value.length - 1;\n            return { value, c: next() };\n        }\n\n        // find the first unexpected character\n        for (let j = 1; j < value.length; j++) {\n            if (value[j] !== text.charAt(offset + j)) {\n                unexpected(next());\n            }\n        }\n\n    }\n\n    function readString(c) {\n        let value = c;\n        c = next();\n\n        while (c && c !== QUOTE$1) {\n\n            // escapes\n            if (c === \"\\\\\") {\n                value += c;\n                c = next();\n\n                if (escapeToChar.has(c)) {\n                    value += c;\n                } else if (c === \"u\") {\n                    value += c;\n                    for (let i = 0; i < 4; i++) {\n                        c = next();\n                        if (isHexDigit(c)) {\n                            value += c;\n                        } else {\n                            unexpected(c);\n                        }\n                    }\n                } else {\n                    unexpected(c);\n                }\n            } else {\n                value += c;\n            }\n\n            c = next();\n        }\n\n        if (!c) {\n            unexpectedEOF();\n        }\n        \n        value += c;\n\n        return { value, c: next() };\n    }\n\n\n    function readNumber(c) {\n\n        let value = \"\";\n\n        // Number may start with a minus but not a plus\n        if (c === \"-\") {\n\n            value += c;\n\n            c = next();\n\n            // Next digit cannot be zero\n            if (!isDigit(c)) {\n                unexpected(c);\n            }\n\n        }\n\n        // Zero must be followed by a decimal point or nothing\n        if (c === \"0\") {\n\n            value += c;\n\n            c = next();\n            if (isDigit(c)) {\n                unexpected(c);\n            }\n\n        } else {\n            if (!isPositiveDigit(c)) {\n                unexpected(c);\n            }\n\n            do {\n                value += c;\n                c = next();\n            } while (isDigit(c));\n        }\n\n        // Decimal point may be followed by any number of digits\n        if (c === \".\") {\n\n            do {\n                value += c;\n                c = next();\n            } while (isDigit(c));\n        }\n\n        // Exponent is always last\n        if (c === \"e\" || c === \"E\") {\n\n            value += c;\n            c = next();\n\n            if (c === \"+\" || c === \"-\") {\n                value += c;\n                c = next();\n            }\n\n            /*\n             * Must always have a digit in this position to avoid:\n             * 5e\n             * 12E+\n             * 42e-\n             */\n            if (!isDigit(c)) {\n                unexpected(c);\n            }\n\n            while (isDigit(c)) {\n                value += c;\n                c = next();\n            }\n        }\n\n\n        return { value, c };\n    }\n\n    /**\n     * Reads in either a single-line or multi-line comment.\n     * @param {string} c The first character of the comment.\n     * @returns {string} The comment string.\n     * @throws {UnexpectedChar} when the comment cannot be read.\n     * @throws {UnexpectedEOF} when EOF is reached before the comment is\n     *      finalized.\n     */\n    function readComment(c) {\n\n        let value = c;\n\n        // next character determines single- or multi-line\n        c = next();\n\n        // single-line comments\n        if (c === \"/\") {\n            \n            do {\n                value += c;\n                c = next();\n            } while (c && c !== \"\\r\" && c !== \"\\n\");\n\n            return { value, c };\n        }\n\n        // multi-line comments\n        if (c === STAR) {\n\n            while (c) {\n                value += c;\n                c = next();\n\n                // check for end of comment\n                if (c === STAR) {\n                    value += c;\n                    c = next();\n                    \n                    //end of comment\n                    if (c === SLASH) {\n                        value += c;\n\n                        /*\n                         * The single-line comment functionality cues up the\n                         * next character, so we do the same here to avoid\n                         * splitting logic later.\n                         */\n                        c = next();\n                        return { value, c };\n                    }\n                }\n            }\n\n            unexpectedEOF();\n            \n        }\n\n        // if we've made it here, there's an invalid character\n        unexpected(c);        \n    }\n\n\n    /**\n     * Convenience function for throwing unexpected character errors.\n     * @param {string} c The unexpected character.\n     * @returns {void}\n     * @throws {UnexpectedChar} always.\n     */\n    function unexpected(c) {\n        throw new UnexpectedChar(c, locate());\n    }\n\n    /**\n     * Convenience function for throwing unexpected EOF errors.\n     * @returns {void}\n     * @throws {UnexpectedEOF} always.\n     */\n    function unexpectedEOF() {\n        throw new UnexpectedEOF(locate());\n    }\n\n    let c = next();\n\n    while (offset < text.length) {\n\n        while (isWhitespace(c)) {\n            c = next();\n        }\n\n        if (!c) {\n            break;\n        }\n\n        const start = locate();\n\n        // check for easy case\n        if (knownTokenTypes.has(c)) {\n            tokens.push(createToken(knownTokenTypes.get(c), c, start));\n            c = next();\n        } else if (isKeywordStart(c)) {\n            const result = readKeyword(c);\n            let value = result.value;\n            c = result.c;\n            tokens.push(createToken(knownTokenTypes.get(value), value, start));\n        } else if (isNumberStart(c)) {\n            const result = readNumber(c);\n            let value = result.value;\n            c = result.c;\n            tokens.push(createToken(\"Number\", value, start));\n        } else if (c === QUOTE$1) {\n            const result = readString(c);\n            let value = result.value;\n            c = result.c;\n            tokens.push(createToken(\"String\", value, start));\n        } else if (c === SLASH && options.comments) {\n            const result = readComment(c);\n            let value = result.value;\n            c = result.c;\n            tokens.push(createToken(value.startsWith(\"//\") ? \"LineComment\" : \"BlockComment\", value, start, locate()));\n        } else {\n            unexpected(c);\n        }\n    }\n\n    return tokens;\n\n}\n\n/**\n * @fileoverview Momoa JSON AST types\n * @author Nicholas C. Zakas\n */\n\nconst types = {\n    document(body, parts = {}) {\n        return {\n            type: \"Document\",\n            body,\n            ...parts\n        };\n    },\n    string(value, parts = {}) {\n        return {\n            type: \"String\",\n            value,\n            ...parts\n        };\n    },\n    number(value, parts = {}) {\n        return {\n            type: \"Number\",\n            value,\n            ...parts\n        };\n    },\n    boolean(value, parts = {}) {\n        return {\n            type: \"Boolean\",\n            value,\n            ...parts\n        };\n    },\n    null(parts = {}) {\n        return {\n            type: \"Null\",\n            value: \"null\",\n            ...parts\n        };\n    },\n    array(elements, parts = {}) {\n        return {\n            type: \"Array\",\n            elements,\n            ...parts\n        };\n    },\n    object(members, parts = {}) {\n        return {\n            type: \"Object\",\n            members,\n            ...parts\n        };\n    },\n    member(name, value, parts = {}) {\n        return {\n            type: \"Member\",\n            name,\n            value,\n            ...parts\n        };\n    },\n\n};\n\n/**\n * @fileoverview JSON parser\n * @author Nicholas C. Zakas\n */\n\n//-----------------------------------------------------------------------------\n// Helpers\n//-----------------------------------------------------------------------------\n\nconst DEFAULT_OPTIONS$1 = {\n    tokens: false,\n    comments: false,\n    ranges: false\n};\n\n/**\n * Converts a JSON-encoded string into a JavaScript string, interpreting each\n * escape sequence.\n * @param {Token} token The string token to convert into a JavaScript string.\n * @returns {string} A JavaScript string.\n */\nfunction getStringValue(token) {\n    \n    // slice off the quotation marks\n    let value = token.value.slice(1, -1);\n    let result = \"\";\n    let escapeIndex = value.indexOf(\"\\\\\");\n    let lastIndex = 0;\n\n    // While there are escapes, interpret them to build up the result\n    while (escapeIndex >= 0) {\n\n        // append the text that happened before the escape\n        result += value.slice(lastIndex, escapeIndex);\n\n        // get the character immediately after the \\\n        const escapeChar = value.charAt(escapeIndex + 1);\n        \n        // check for the non-Unicode escape sequences first\n        if (escapeToChar.has(escapeChar)) {\n            result += escapeToChar.get(escapeChar);\n            lastIndex = escapeIndex + 2;\n        } else if (escapeChar === \"u\") {\n            const hexCode = value.slice(escapeIndex + 2, escapeIndex + 6);\n            if (hexCode.length < 4 || /[^0-9a-f]/i.test(hexCode)) {\n                throw new ErrorWithLocation(\n                    `Invalid unicode escape \\\\u${ hexCode}.`,\n                    {\n                        line: token.loc.start.line,\n                        column: token.loc.start.column + escapeIndex,\n                        offset: token.loc.start.offset + escapeIndex\n                    }\n                );\n            }\n            \n            result += String.fromCharCode(parseInt(hexCode, 16));\n            lastIndex = escapeIndex + 6;\n        } else {\n            throw new ErrorWithLocation(\n                `Invalid escape \\\\${ escapeChar }.`,\n                {\n                    line: token.loc.start.line,\n                    column: token.loc.start.column + escapeIndex,\n                    offset: token.loc.start.offset + escapeIndex\n                }\n            );\n        }\n\n        // find the next escape sequence\n        escapeIndex = value.indexOf(\"\\\\\", lastIndex);\n    }\n\n    // get the last segment of the string value\n    result += value.slice(lastIndex);\n\n    return result;\n}\n\n/**\n * Gets the JavaScript value represented by a JSON token.\n * @param {Token} token The JSON token to get a value for.\n * @returns {*} A number, string, boolean, or `null`. \n */\nfunction getLiteralValue(token) {\n    switch (token.type) {\n    case \"Boolean\":\n        return token.value === \"true\";\n        \n    case \"Number\":\n        return Number(token.value);\n\n    case \"Null\":\n        return null;\n\n    case \"String\":\n        return getStringValue(token);\n    }\n}\n\n//-----------------------------------------------------------------------------\n// Main Function\n//-----------------------------------------------------------------------------\n\n/**\n * \n * @param {string} text The text to parse.\n * @param {boolean} [options.tokens=false] Determines if tokens are returned in\n *      the AST. \n * @param {boolean} [options.comments=false] Determines if comments are allowed\n *      in the JSON.\n * @param {boolean} [options.ranges=false] Determines if ranges will be returned\n *      in addition to `loc` properties.\n * @returns {Object} The AST representing the parsed JSON.\n * @throws {Error} When there is a parsing error. \n */\nfunction parse(text, options) {\n\n    options = Object.freeze({\n        ...DEFAULT_OPTIONS$1,\n        ...options\n    });\n\n    const tokens = tokenize(text, {\n        comments: !!options.comments,\n        ranges: !!options.ranges\n    });\n    let tokenIndex = 0;\n\n    function nextNoComments() {\n        return tokens[tokenIndex++];\n    }\n    \n    function nextSkipComments() {\n        const nextToken = tokens[tokenIndex++];\n        if (nextToken && nextToken.type.endsWith(\"Comment\")) {\n            return nextSkipComments();\n        }\n\n        return nextToken;\n\n    }\n\n    // determine correct way to evaluate tokens based on presence of comments\n    const next = options.comments ? nextSkipComments : nextNoComments;\n\n    function assertTokenValue(token, value) {\n        if (!token || token.value !== value) {\n            throw new UnexpectedToken(token);\n        }\n    }\n\n    function assertTokenType(token, type) {\n        if (!token || token.type !== type) {\n            throw new UnexpectedToken(token);\n        }\n    }\n\n    function createRange(start, end) {\n        return options.ranges ? {\n            range: [start.offset, end.offset]\n        } : undefined;\n    }\n\n    function createLiteralNode(token) {\n        const range = createRange(token.loc.start, token.loc.end);\n\n        return {\n            type: token.type,\n            value: getLiteralValue(token),\n            loc: {\n                start: {\n                    ...token.loc.start\n                },\n                end: {\n                    ...token.loc.end\n                }\n            },\n            ...range\n        };\n    }\n\n\n    function parseProperty(token) {\n        assertTokenType(token, \"String\");\n        const name = createLiteralNode(token);\n\n        token = next();\n        assertTokenValue(token, \":\");\n        const value = parseValue();\n        const range = createRange(name.loc.start, value.loc.end);\n\n        return types.member(name, value, {\n            loc: {\n                start: {\n                    ...name.loc.start\n                },\n                end: {\n                    ...value.loc.end\n                }\n            },\n            ...range\n        });\n    }\n\n    function parseObject(firstToken) {\n\n        // The first token must be a { or else it's an error\n        assertTokenValue(firstToken, \"{\");\n\n        const members = [];\n        let token = next();\n\n        if (token && token.value !== \"}\") {\n            do {\n    \n                // add the value into the array\n                members.push(parseProperty(token));\n    \n                token = next();\n    \n                if (token.value === \",\") {\n                    token = next();\n                } else {\n                    break;\n                }\n            } while (token);\n        }\n\n        assertTokenValue(token, \"}\");\n        const range = createRange(firstToken.loc.start, token.loc.end);\n\n        return types.object(members, {\n            loc: {\n                start: {\n                    ...firstToken.loc.start\n                },\n                end: {\n                    ...token.loc.end\n                }\n            },\n            ...range\n        });\n\n    }\n\n    function parseArray(firstToken) {\n\n        // The first token must be a [ or else it's an error\n        assertTokenValue(firstToken, \"[\");\n\n        const elements = [];\n        let token = next();\n        \n        if (token && token.value !== \"]\") {\n\n            do {\n\n              // add the value into the array\n              elements.push(parseValue(token));\n\n              token = next();\n              \n              if (token.value === \",\") {\n                  token = next();\n              } else {\n                  break;\n              }\n            } while (token);\n        }\n\n        assertTokenValue(token, \"]\");\n        const range = createRange(firstToken.loc.start, token.loc.end);\n\n        return types.array(elements, {\n            type: \"Array\",\n            elements,\n            loc: {\n                start: {\n                    ...firstToken.loc.start\n                },\n                end: {\n                    ...token.loc.end\n                }\n            },\n            ...range\n        });\n\n    }\n\n\n\n    function parseValue(token) {\n\n        token = token || next();\n        \n        switch (token.type) {\n        case \"String\":\n        case \"Boolean\":\n        case \"Number\":\n        case \"Null\":\n            return createLiteralNode(token);\n\n        case \"Punctuator\":\n            if (token.value === \"{\") {\n                return parseObject(token);\n            } else if (token.value === \"[\") {\n                return parseArray(token);\n            }\n            /*falls through*/\n\n        default:\n            throw new UnexpectedToken(token);\n        }\n\n    }\n\n    \n    const docBody = parseValue();\n    \n    const unexpectedToken = next();\n    if (unexpectedToken) {\n        throw new UnexpectedToken(unexpectedToken);\n    }\n    \n    \n    const docParts = {\n        loc: {\n            start: {\n                line: 1,\n                column: 1,\n                offset: 0\n            },\n            end: {\n                ...docBody.loc.end\n            }\n        }\n    };\n    \n\n    if (options.tokens) {\n        docParts.tokens = tokens;\n    }\n\n    if (options.ranges) {\n        docParts.range = createRange(docParts.loc.start, docParts.loc.end);\n    }\n\n    return types.document(docBody, docParts);\n\n}\n\n/**\n * @fileoverview Traversal approaches for Momoa JSON AST.\n * @author Nicholas C. Zakas\n */\n\n//-----------------------------------------------------------------------------\n// Data\n//-----------------------------------------------------------------------------\n\nconst childKeys = new Map([\n    [\"Document\", [\"body\"]],\n    [\"Object\", [\"members\"]],\n    [\"Member\", [\"name\", \"value\"]],\n    [\"Array\", [\"elements\"]],\n    [\"String\", []],\n    [\"Number\", []],\n    [\"Boolean\", []],\n    [\"Null\", []]\n]);\n\n//-----------------------------------------------------------------------------\n// Helpers\n//-----------------------------------------------------------------------------\n\n/**\n * Determines if a given value is an object.\n * @param {*} value The value to check.\n * @returns {boolean} True if the value is an object, false if not. \n */\nfunction isObject(value) {\n    return value && (typeof value === \"object\");\n}\n\n/**\n * Determines if a given value is an AST node.\n * @param {*} value The value to check.\n * @returns {boolean} True if the value is a node, false if not. \n */\nfunction isNode(value) {\n    return isObject(value) && (typeof value.type === \"string\");\n}\n\n//-----------------------------------------------------------------------------\n// Exports\n//-----------------------------------------------------------------------------\n\n/**\n * Traverses an AST from the given node.\n * @param {Node} root The node to traverse from \n * @param {Object} visitor An object with an `enter` and `exit` method. \n */\nfunction traverse(root, visitor) {\n\n    /**\n     * Recursively visits a node.\n     * @param {Node} node The node to visit.\n     * @param {Node} parent The parent of the node to visit.\n     * @returns {void}\n     */\n    function visitNode(node, parent) {\n\n        if (typeof visitor.enter === \"function\") {\n            visitor.enter(node, parent);\n        }\n\n        for (const key of childKeys.get(node.type)) {\n            const value = node[key];\n\n            if (isObject(value)) {\n                if (Array.isArray(value)) {\n                    value.forEach(child => visitNode(child, node));\n                } else if (isNode(value)) {\n                    visitNode(value, node);\n                }\n            }\n        }\n\n        if (typeof visitor.exit === \"function\") {\n            visitor.exit(node, parent);\n        }\n    }\n\n    visitNode(root);\n}\n\n/**\n * Creates an iterator over the given AST.\n * @param {Node} root The root AST node to traverse. \n * @param {Function} [filter] A filter function to determine which steps to\n *      return;\n * @returns {Iterator} An iterator over the AST.  \n */\nfunction iterator(root, filter = () => true) {\n\n    const traversal = [];\n\n    traverse(root, {\n        enter(node, parent) {\n            traversal.push({ node, parent, phase: \"enter\" });\n        },\n        exit(node, parent) {\n            traversal.push({ node, parent, phase: \"exit\" });\n        }\n    });\n\n    return traversal.filter(filter).values();\n}\n\n/**\n * @fileoverview Evaluator for Momoa AST.\n * @author Nicholas C. Zakas\n */\n\n//-----------------------------------------------------------------------------\n// Exports\n//-----------------------------------------------------------------------------\n\n/**\n * Evaluates a Momoa AST node into a JavaScript value.\n * @param {Node} node The node to interpet.\n * @returns {*} The JavaScript value for the node. \n */\nfunction evaluate(node) {\n    switch (node.type) {\n    case \"String\":\n    case \"Number\":\n    case \"Boolean\":\n        return node.value;\n\n    case \"Null\":\n        return null;\n\n    case \"Array\":\n        return node.elements.map(evaluate);\n\n    case \"Object\": {\n\n        const object = {};\n\n        node.members.forEach(member => {\n            object[evaluate(member.name)] = evaluate(member.value);\n        });    \n\n        return object;\n    }    \n\n    case \"Document\":\n        return evaluate(node.body);\n\n    case \"Property\":\n        throw new Error(\"Cannot evaluate object property outside of an object.\");\n\n    default:\n        throw new Error(`Unknown node type ${ node.type }.`);\n    }\n}\n\n/**\n * @fileoverview Printer for Momoa AST.\n * @author Nicholas C. Zakas\n */\n\n//-----------------------------------------------------------------------------\n// Exports\n//-----------------------------------------------------------------------------\n\n/**\n * Converts a Momoa AST back into a JSON string.\n * @param {Node} node The node to print.\n * @param {int} [options.indent=0] The number of spaces to indent each line. If\n *      greater than 0, then newlines and indents will be added to output. \n * @returns {string} The JSON representation of the AST.\n */\nfunction print(node, { indent = 0 } = {}) {\n    const value = evaluate(node);\n    return JSON.stringify(value, null, indent);\n}\n\n/**\n * @fileoverview File defining the interface of the package.\n * @author Nicholas C. Zakas\n */\n\nexports.evaluate = evaluate;\nexports.iterator = iterator;\nexports.parse = parse;\nexports.print = print;\nexports.tokenize = tokenize;\nexports.traverse = traverse;\nexports.types = types;\n","import { Node } from '@humanwhocodes/momoa';\nimport { HintIssue } from './types';\n\nexport function makeIssue(message: string, node: Node): HintIssue {\n  return {\n    message,\n    severity: 'error',\n    // node,\n    from: node.loc.start.offset,\n    to: node.loc.end.offset,\n  };\n}\n\nexport class HintError extends Error {\n  issues: HintIssue[] = [];\n\n  constructor(issues: HintIssue[]) {\n    super();\n    // restore prototype chain\n    const actualProto = new.target.prototype;\n    Object.setPrototypeOf(this, actualProto);\n    this.issues = issues;\n  }\n\n  get message() {\n    return JSON.stringify(this.issues, null, 2);\n  }\n}\n","import { GeoJSON } from 'geojson';\n\nexport type GeoJSONTypeSet = Set<GeoJSON['type']>;\n\nexport interface HintIssue {\n  from: number;\n  to: number;\n  node?: Node;\n  severity: 'error';\n  message: string;\n}\n\nexport interface Ctx {\n  issues: HintIssue[];\n  valid: Array<undefined | HintIssue[]>;\n}\n\nexport const GEOJSON_FEATURE_TYPE = new Set<GeoJSON['type']>(['Feature']);\n\nexport const GEOJSON_GEOMETRY_TYPES = new Set<GeoJSON['type']>([\n  'Point',\n  'MultiPoint',\n  'Polygon',\n  'MultiPolygon',\n  'LineString',\n  'MultiLineString',\n  'GeometryCollection',\n]);\n\nexport const GEOJSON_GEOMETRY_TYPES_EX_GEOMETRY_COLLECTION = new Set<\n  GeoJSON['type']\n>([\n  'Point',\n  'MultiPoint',\n  'Polygon',\n  'MultiPolygon',\n  'LineString',\n  'MultiLineString',\n]);\n\nexport const GEOJSON_TYPES = new Set<GeoJSON['type']>(\n  Array.from(GEOJSON_GEOMETRY_TYPES).concat([\n  'Feature',\n  'FeatureCollection',\n]));\n","import { Ctx, GeoJSONTypeSet } from './types';\nimport { GeoJSON } from 'geojson';\nimport { HintError, makeIssue } from './errors';\nimport { Node } from '@humanwhocodes/momoa';\n\nexport function getType(ctx: Ctx, node: Node, allowedTypes: GeoJSONTypeSet) {\n  if (node.type !== 'Object') {\n    throw new HintError([\n      makeIssue('Expected an object, but found an incorrect type.', node),\n    ]);\n  }\n\n  const typeMember = node.members.find((member) => {\n    return member.name.value === 'type';\n  });\n\n  if (!typeMember) {\n    ctx.issues.push(\n      makeIssue('This GeoJSON object is missing its type member.', node)\n    );\n    return {};\n  }\n\n  const value = typeMember.value;\n\n  if (value.type !== 'String') {\n    ctx.issues.push(\n      makeIssue('The type member should have been a string.', node)\n    );\n\n    return {};\n  }\n\n  if (!allowedTypes.has(value.value as any)) {\n    ctx.issues.push(\n      makeIssue('This type of GeoJSON object is not allowed here.', node)\n    );\n\n    return {};\n  }\n\n  return {\n    type: value.value as GeoJSON['type'],\n    objectNode: node,\n  };\n}\n","import { makeIssue } from './errors';\nimport { ObjectNode } from '@humanwhocodes/momoa';\nimport { Ctx } from './types';\n\nexport function getMemberValue(ctx: Ctx, node: ObjectNode, name: string) {\n  const member = node.members.find((member) => {\n    return member.name.value === name;\n  });\n\n  if (!member) {\n    ctx.issues.push(\n      makeIssue(\n        `This GeoJSON object requires a ${name} member but it is missing.`,\n        node\n      )\n    );\n\n    return null;\n  }\n\n  return member.value;\n}\n","import { makeIssue } from './errors';\nimport { Node, ArrayNode } from '@humanwhocodes/momoa';\nimport { Ctx } from './types';\n\nexport function getArray(ctx: Ctx, node: Node | null): ArrayNode | null {\n  if (node?.type === 'Array') return node;\n  if (node) {\n    ctx.issues.push(makeIssue('This must be an array.', node));\n  }\n  return null;\n}\n","import { makeIssue } from './errors';\nimport { Node, ObjectNode } from '@humanwhocodes/momoa';\nimport { Ctx } from './types';\n\nexport function getObject(ctx: Ctx, node: Node | null): ObjectNode | null {\n  if (node?.type === 'Object') return node;\n  if (node) {\n    ctx.issues.push(makeIssue('This must be an object.', node));\n  }\n  return null;\n}\n","import { Node } from '@humanwhocodes/momoa';\nimport { makeIssue } from './errors';\nimport { Ctx } from './types';\n\nexport function arrayIsNumbers(ctx: Ctx, elements: Node[], name: string) {\n  for (const element of elements) {\n    if (element.type !== 'Number') {\n      ctx.issues.push(\n        makeIssue(`Each element in a ${name} must be a number.`, element)\n      );\n      return;\n    }\n  }\n}\n","import { makeIssue } from './errors';\nimport { ArrayNode } from '@humanwhocodes/momoa';\nimport { arrayIsNumbers } from './array_is_numbers';\nimport { Ctx } from './types';\n\nexport function enforcePosition(ctx: Ctx, node: ArrayNode | null) {\n  // This error has already been caught. Allow a no-op for simplicity.\n  if (node === null) return;\n\n  if (node.elements.length < 2 || node.elements.length > 3) {\n    ctx.issues.push(\n      makeIssue(\n        `A position should have 2 or 3 elements - found ${node.elements.length}.`,\n        node\n      )\n    );\n  }\n\n  arrayIsNumbers(ctx, node.elements, 'position');\n}\n","import { makeIssue } from './errors';\nimport { enforcePosition } from './enforce_position';\nimport { enforceSamePosition } from './enforce_same_position';\nimport { Node, ArrayNode } from '@humanwhocodes/momoa';\nimport { Ctx } from './types';\n\nfunction getArray(ctx: Ctx, node: Node): ArrayNode | null {\n  if (node.type !== 'Array') {\n    ctx.issues.push(\n      makeIssue('Expected to find an array of positions here.', node)\n    );\n    return null;\n  }\n  return node;\n}\n\ntype PositionKind = 'Polygon' | 'LineString';\n\nexport function enforcePositionArray(\n  ctx: Ctx,\n  node: Node | null,\n  kind?: PositionKind\n) {\n  // This error has already been caught. Allow a no-op for simplicity.\n  if (node === null) return;\n\n  node = getArray(ctx, node);\n  if (!node) return;\n\n  for (const element of node.elements) {\n    if (element.type !== 'Array') {\n      ctx.issues.push(\n        makeIssue(\n          'Expected to find a position here, found another type.',\n          element\n        )\n      );\n      return;\n    } else {\n      enforcePosition(ctx, element);\n    }\n  }\n\n  switch (kind) {\n    case 'LineString': {\n      if (node.elements.length < 2) {\n        ctx.issues.push(\n          makeIssue('Expected to find two or more positions here.', node)\n        );\n      }\n      break;\n    }\n    case 'Polygon':\n      if (node.elements.length < 4) {\n        ctx.issues.push(\n          makeIssue('Expected to find four or more positions here.', node)\n        );\n      }\n      enforceSamePosition(ctx, node);\n      break;\n  }\n}\n\nexport function enforcePositionArray2(\n  ctx: Ctx,\n  node: Node | null,\n  kind?: PositionKind\n) {\n  // This error has already been caught. Allow a no-op for simplicity.\n  if (node === null) return;\n\n  node = getArray(ctx, node);\n  if (!node) return;\n\n  for (const element of node.elements) {\n    enforcePositionArray(ctx, element, kind);\n  }\n}\n\nexport function enforcePositionArray3(\n  ctx: Ctx,\n  node: ArrayNode | null,\n  kind?: PositionKind\n) {\n  // This error has already been caught. Allow a no-op for simplicity.\n  if (node === null) return;\n\n  node = getArray(ctx, node);\n  if (!node) return;\n\n  for (const element of node.elements) {\n    enforcePositionArray2(ctx, element, kind);\n  }\n}\n","import { makeIssue } from './errors';\nimport { ArrayNode, NumberNode } from '@humanwhocodes/momoa';\nimport { Ctx } from './types';\n\nexport function enforceSamePosition(ctx: Ctx, node: ArrayNode) {\n  const first = node.elements[0] as ArrayNode;\n  const last = node.elements[node.elements.length - 1] as ArrayNode;\n  const len = Math.max(first.elements.length, last.elements.length);\n\n  for (let j = 0; j < len; j++) {\n    const firstValue = (first.elements[j] as NumberNode | undefined)?.value;\n    const secondValue = (last.elements[j] as NumberNode | undefined)?.value;\n    if (firstValue !== secondValue) {\n      ctx.issues.push(\n        makeIssue(\n          'First and last positions of a Polygon or MultiPolygon’s ring should be the same.',\n          first\n        ),\n        makeIssue(\n          'First and last positions of a Polygon or MultiPolygon’s ring should be the same.',\n          last\n        )\n      );\n      return;\n    }\n  }\n}\n","import { makeIssue } from './errors';\nimport { ObjectNode } from '@humanwhocodes/momoa';\nimport { getArray } from './get_array';\nimport { arrayIsNumbers } from './array_is_numbers';\nimport { Ctx } from './types';\n\nexport function enforceBbox(ctx: Ctx, node: ObjectNode) {\n  const member = node.members.find((member) => {\n    return member.name.value === 'bbox';\n  });\n\n  // bboxes are optional\n  if (member === undefined) return;\n\n  const array = getArray(ctx, member.value);\n\n  if (!array) return;\n\n  if (!(array.elements.length === 4 || array.elements.length === 6)) {\n    ctx.issues.push(makeIssue('A bbox must have 4 or 6 positions', array));\n  }\n\n  arrayIsNumbers(ctx, array.elements, 'bbox');\n}\n","import { makeIssue } from './errors';\nimport { ObjectNode, MemberNode } from '@humanwhocodes/momoa';\nimport { Ctx } from './types';\n\ntype PropertiesFrom = 'Feature' | 'FeatureCollection' | 'Geometry';\n\nfunction forbidProperty(\n  ctx: Ctx,\n  member: MemberNode,\n  propertiesFrom: PropertiesFrom,\n  name: string\n) {\n  if (member.name.value === name) {\n    ctx.issues.push(\n      makeIssue(\n        `${propertiesFrom} objects cannot contain a member named ${member.name.value}`,\n        member.name\n      )\n    );\n  }\n}\n\nconst FORBIDDEN_PROPERTIES = {\n  Geometry: ['properties', 'geometry', 'features'],\n  Feature: ['features'],\n  FeatureCollection: ['properties', 'coordinates'],\n} as const;\n\nexport function forbidConfusingProperties(\n  ctx: Ctx,\n  node: ObjectNode,\n  propertiesFrom: PropertiesFrom\n) {\n  for (const member of node.members) {\n    for (const property of FORBIDDEN_PROPERTIES[propertiesFrom]) {\n      forbidProperty(ctx, member, propertiesFrom, property);\n    }\n  }\n}\n","import {\n  parse,\n  evaluate,\n  DocumentNode,\n  Node,\n  ObjectNode,\n} from '@humanwhocodes/momoa';\nimport { GeoJSON } from 'geojson';\nimport { HintError, makeIssue } from './errors';\nimport {\n  GeoJSONTypeSet,\n  GEOJSON_TYPES,\n  GEOJSON_GEOMETRY_TYPES,\n  GEOJSON_GEOMETRY_TYPES_EX_GEOMETRY_COLLECTION,\n  GEOJSON_FEATURE_TYPE,\n  HintIssue,\n  Ctx,\n} from './types';\nimport { getType } from './get_type';\nimport { getMemberValue } from './get_member_value';\nimport { getArray } from './get_array';\nimport { getObject } from './get_object';\nimport { enforcePosition } from './enforce_position';\nimport { checkDuplicateKeys } from './check_duplicate_keys';\nimport {\n  enforcePositionArray,\n  enforcePositionArray2,\n  enforcePositionArray3,\n} from './enforce_position_array';\nimport { enforceBbox } from './enforce_bbox';\nimport { forbidConfusingProperties } from './forbid_confusing_properties';\n\ntype Checker = (ctx: Ctx, node: ObjectNode) => void;\n\nfunction getCoordinates(ctx: Ctx, node: ObjectNode) {\n  const coordinatesMember = getMemberValue(ctx, node, 'coordinates');\n  if (!coordinatesMember) return null;\n  return getArray(ctx, coordinatesMember);\n}\n\nconst checkGeometryShared: Checker = (ctx, node) => {\n  enforceBbox(ctx, node);\n  forbidConfusingProperties(ctx, node, 'Geometry');\n};\n\nconst checkLineString: Checker = (ctx, node) => {\n  enforcePositionArray(ctx, getCoordinates(ctx, node), 'LineString');\n  checkGeometryShared(ctx, node);\n};\n\nconst checkMultiLineString: Checker = (ctx, node) => {\n  enforcePositionArray2(ctx, getCoordinates(ctx, node), 'LineString');\n  checkGeometryShared(ctx, node);\n};\n\nconst checkPolygon: Checker = (ctx, node) => {\n  enforcePositionArray2(ctx, getCoordinates(ctx, node), 'Polygon');\n  checkGeometryShared(ctx, node);\n};\n\nconst checkMultiPolygon: Checker = (ctx, node) => {\n  enforcePositionArray3(ctx, getCoordinates(ctx, node), 'Polygon');\n  checkGeometryShared(ctx, node);\n};\n\nconst checkPoint: Checker = (ctx, node) => {\n  enforcePosition(ctx, getCoordinates(ctx, node));\n  checkGeometryShared(ctx, node);\n};\n\nconst checkMultiPoint: Checker = (ctx, node) => {\n  enforcePositionArray(ctx, getCoordinates(ctx, node));\n  checkGeometryShared(ctx, node);\n};\n\nconst checkGeometryCollection: Checker = (ctx, node) => {\n  checkGeometryShared(ctx, node);\n  const geometriesMember = getArray(\n    ctx,\n    getMemberValue(ctx, node, 'geometries')\n  );\n  if (!geometriesMember) return;\n  for (const element of geometriesMember.elements) {\n    checkObject(ctx, element, GEOJSON_GEOMETRY_TYPES_EX_GEOMETRY_COLLECTION);\n  }\n};\n\nconst checkFeature: Checker = (ctx, node) => {\n  forbidConfusingProperties(ctx, node, 'Feature');\n  const geometryMember = getMemberValue(ctx, node, 'geometry');\n  enforceBbox(ctx, node);\n  if (geometryMember?.type !== 'Null') {\n    const geometry = getObject(ctx, geometryMember);\n    if (geometry) checkObject(ctx, geometry, GEOJSON_GEOMETRY_TYPES);\n  }\n\n  const idMember = node.members.find((member) => {\n    return member.name.value === 'id';\n  });\n  if (\n    idMember &&\n    !(idMember.value.type === 'String' || idMember.value.type === 'Number')\n  ) {\n    ctx.issues.push(\n      makeIssue(`The Feature id must be a string or number.`, node)\n    );\n  }\n\n  const properties = getMemberValue(ctx, node, 'properties');\n  if (!properties) {\n    ctx.issues.push(makeIssue(`The properties member is missing.`, node));\n    return;\n  }\n\n  const { type } = properties;\n\n  if (!(type === 'Object' || type === 'Null')) {\n    ctx.issues.push(\n      makeIssue(`The Feature properties member can be an object or null.`, node)\n    );\n  }\n};\n\nconst checkFeatureCollection: Checker = (ctx, node) => {\n  forbidConfusingProperties(ctx, node, 'FeatureCollection');\n  const featuresMember = getArray(ctx, getMemberValue(ctx, node, 'features'));\n  if (!featuresMember) return;\n  for (const feature of featuresMember.elements) {\n    const beforeCount = ctx.issues.length;\n    const obj = getObject(ctx, feature);\n    if (obj) {\n      getType(ctx, obj, GEOJSON_FEATURE_TYPE);\n      checkFeature(ctx, obj);\n    }\n    ctx.valid.push(\n      ctx.issues.length === beforeCount\n        ? undefined\n        : ctx.issues.slice(beforeCount)\n    );\n  }\n};\n\nconst CHECKERS: Record<GeoJSON['type'], Checker> = {\n  LineString: checkLineString,\n  MultiLineString: checkMultiLineString,\n\n  Polygon: checkPolygon,\n  MultiPolygon: checkMultiPolygon,\n\n  Point: checkPoint,\n  MultiPoint: checkMultiPoint,\n\n  GeometryCollection: checkGeometryCollection,\n\n  Feature: checkFeature,\n  FeatureCollection: checkFeatureCollection,\n};\n\nfunction checkObject(\n  ctx: Ctx,\n  node: Node,\n  typeSet: GeoJSONTypeSet = GEOJSON_TYPES\n) {\n  const { type, objectNode } = getType(ctx, node, typeSet);\n  if (!(type && objectNode)) return;\n  checkDuplicateKeys(ctx, objectNode);\n  CHECKERS[type](ctx, objectNode);\n}\n\nfunction checkInternal(jsonStr: string): {\n  ast: DocumentNode | undefined;\n  ctx: Ctx;\n} {\n  if (typeof jsonStr !== 'string') {\n    throw new TypeError('Input must be a string. (Use JSON.stringify first.)');\n  }\n  const ctx: Ctx = {\n    issues: [],\n    valid: [],\n  };\n  let ast;\n  try {\n    ast = parse(jsonStr, {\n      ranges: true,\n    });\n    checkObject(ctx, ast.body);\n  } catch (e: unknown) {\n    ctx.issues.push({\n      message: `Invalid JSON: ${(e as Error).message}`,\n      from: 0,\n      to: 0,\n      severity: 'error',\n    });\n  }\n\n  return { ast, ctx };\n}\n\n/**\n * Given a string of possibly valid GeoJSON data,\n * return an array of issues. This will handle invalid JSON\n * data, invalid GeoJSON structure, and anything else that will\n * prevent this string of data from being parsed and\n * displayed on a map.\n *\n * check-geojson looks for invalid structure and invalid syntax.\n * It does not check for complex geometry issues like\n * self-intersections, which are hard to detect and don't cause\n * failures in most display & manipulation software.\n */\nexport const getIssues = (jsonStr: string): HintIssue[] => {\n  return checkInternal(jsonStr).ctx.issues;\n};\n\n/**\n * This catches the same issues as `getIssues`, but instead\n * of returning a list of issues, it will throw a HintError\n * if any errors are detected, and return the parsed\n * GeoJSON as an object if no errors are.\n */\nexport const check = (jsonStr: string): GeoJSON => {\n  const { ctx, ast } = checkInternal(jsonStr);\n  if (ctx.issues.length || !ast) throw new HintError(ctx.issues);\n  return evaluate(ast);\n};\n\n/**\n * This method will allow you to parse a possibly-valid\n * bit of GeoJSON data. If nothing can be parsed, it will\n * throw a HintError. However, if the GeoJSON can be parsed,\n * it will return an object with valid features\n * and rejected features along with the reasons why those\n * features were rejected.\n */\nexport const scavenge = (\n  jsonStr: string\n): {\n  result: GeoJSON;\n  rejected: Array<{ feature: any; reasons: HintIssue[] }>;\n} => {\n  const {\n    ctx: { issues, valid },\n    ast,\n  } = checkInternal(jsonStr);\n  // If GeoJSON can't be parsed, throw.\n  if (!ast) throw new HintError(issues);\n  const result = evaluate(ast) as GeoJSON;\n  // If everything was fine, return.\n  if (!issues.length) return { result, rejected: [] };\n  // If there were errors but it's a featurecollection, sift\n  if (result.type === 'FeatureCollection') {\n    return {\n      result: {\n        ...result,\n        features: result.features.filter((_, i) => {\n          return valid[i] === undefined;\n        }),\n      },\n      rejected: result.features.flatMap((feature, i) => {\n        const reasons = valid[i];\n        if (reasons) {\n          return [\n            {\n              feature,\n              reasons,\n            },\n          ];\n        }\n        return [];\n      }),\n    };\n  }\n  // Otherwise, throw\n  throw new HintError(issues);\n};\n\nexport { HintError, HintIssue };\n","import { makeIssue } from './errors';\nimport { ObjectNode } from '@humanwhocodes/momoa';\nimport { Ctx } from './types';\n\nexport function checkDuplicateKeys(ctx: Ctx, parent: ObjectNode): ObjectNode {\n  const keys = new Set<string>();\n  for (const node of parent.members) {\n    const {\n      name: { value },\n    } = node;\n    if (keys.has(value)) {\n      ctx.issues.push(\n        makeIssue('Duplicate properties are ambiguous in GeoJSON', node)\n      );\n    }\n    keys.add(value);\n  }\n  return parent;\n}\n"],"names":["TRUE","FALSE","NULL","expectedKeywords","Map","escapeToChar","knownTokenTypes","ErrorWithLocation","Error","constructor","message","line","column","index","super","this","UnexpectedChar","unexpected","loc","UnexpectedToken","token","type","value","start","UnexpectedEOF","DEFAULT_OPTIONS","comments","ranges","isWhitespace","c","test","isDigit","isHexDigit","isKeywordStart","isNumberStart","DEFAULT_OPTIONS$1","tokens","getLiteralValue","Number","slice","result","escapeIndex","indexOf","lastIndex","escapeChar","charAt","has","get","offset","hexCode","length","String","fromCharCode","parseInt","getStringValue","evaluate_1","evaluate","node","elements","map","object","members","forEach","member","name","body","makeIssue","severity","from","to","end","HintError","_Error","issues","_this","call","actualProto","prototype","Object","setPrototypeOf","key","JSON","stringify","_wrapNativeSuper","GEOJSON_FEATURE_TYPE","Set","GEOJSON_GEOMETRY_TYPES","GEOJSON_GEOMETRY_TYPES_EX_GEOMETRY_COLLECTION","GEOJSON_TYPES","Array","concat","getType","ctx","allowedTypes","typeMember","find","push","objectNode","getMemberValue","getArray","getObject","arrayIsNumbers","_iterator","_step","_createForOfIteratorHelperLoose","done","element","enforcePosition","enforcePositionArray","kind","first","last","len","Math","max","j","_first$elements$j","_last$elements$j","enforceSamePosition","enforcePositionArray2","_step2","_iterator2","enforceBbox","undefined","array","forbidProperty","propertiesFrom","FORBIDDEN_PROPERTIES","Geometry","Feature","FeatureCollection","forbidConfusingProperties","getCoordinates","coordinatesMember","checkGeometryShared","checkFeature","geometryMember","geometry","checkObject","idMember","properties","CHECKERS","LineString","MultiLineString","Polygon","MultiPolygon","_iterator3","_step3","enforcePositionArray3","Point","MultiPoint","GeometryCollection","geometriesMember","featuresMember","beforeCount","obj","valid","typeSet","_getType","parent","keys","add","checkDuplicateKeys","checkInternal","jsonStr","TypeError","ast","text","options","freeze","newLine","createToken","tokenType","startLoc","endLoc","endOffset","range","next","locate","readKeyword","readString","i","unexpectedEOF","readNumber","isPositiveDigit","readComment","startsWith","tokenize","tokenIndex","nextSkipComments","nextToken","endsWith","assertTokenValue","createRange","createLiteralNode","parseProperty","assertTokenType","parseValue","parts","types","firstToken","parseObject","parseArray","docBody","unexpectedToken","docParts","parse","e","getIssues","check","_checkInternal","scavenge","_checkInternal2","_checkInternal2$ctx","rejected","_extends","features","filter","_","flatMap","feature","reasons"],"mappings":"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"}