style-dictionary 3.7.2 → 3.8.0

package/examples/advanced/custom-file-header/node_modules/jsonc-parser/lib/umd/impl/parser.js

@@ -1,655 +0,0 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./scanner"], factory);
-    }
-})(function (require, exports) {
-    /*---------------------------------------------------------------------------------------------
-     *  Copyright (c) Microsoft Corporation. All rights reserved.
-     *  Licensed under the MIT License. See License.txt in the project root for license information.
-     *--------------------------------------------------------------------------------------------*/
-    'use strict';
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.getNodeType = exports.stripComments = exports.visit = exports.findNodeAtOffset = exports.contains = exports.getNodeValue = exports.getNodePath = exports.findNodeAtLocation = exports.parseTree = exports.parse = exports.getLocation = void 0;
-    const scanner_1 = require("./scanner");
-    var ParseOptions;
-    (function (ParseOptions) {
-        ParseOptions.DEFAULT = {
-            allowTrailingComma: false
-        };
-    })(ParseOptions || (ParseOptions = {}));
-    /**
-     * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
-     */
-    function getLocation(text, position) {
-        const segments = []; // strings or numbers
-        const earlyReturnException = new Object();
-        let previousNode = undefined;
-        const previousNodeInst = {
-            value: {},
-            offset: 0,
-            length: 0,
-            type: 'object',
-            parent: undefined
-        };
-        let isAtPropertyKey = false;
-        function setPreviousNode(value, offset, length, type) {
-            previousNodeInst.value = value;
-            previousNodeInst.offset = offset;
-            previousNodeInst.length = length;
-            previousNodeInst.type = type;
-            previousNodeInst.colonOffset = undefined;
-            previousNode = previousNodeInst;
-        }
-        try {
-            visit(text, {
-                onObjectBegin: (offset, length) => {
-                    if (position <= offset) {
-                        throw earlyReturnException;
-                    }
-                    previousNode = undefined;
-                    isAtPropertyKey = position > offset;
-                    segments.push(''); // push a placeholder (will be replaced)
-                },
-                onObjectProperty: (name, offset, length) => {
-                    if (position < offset) {
-                        throw earlyReturnException;
-                    }
-                    setPreviousNode(name, offset, length, 'property');
-                    segments[segments.length - 1] = name;
-                    if (position <= offset + length) {
-                        throw earlyReturnException;
-                    }
-                },
-                onObjectEnd: (offset, length) => {
-                    if (position <= offset) {
-                        throw earlyReturnException;
-                    }
-                    previousNode = undefined;
-                    segments.pop();
-                },
-                onArrayBegin: (offset, length) => {
-                    if (position <= offset) {
-                        throw earlyReturnException;
-                    }
-                    previousNode = undefined;
-                    segments.push(0);
-                },
-                onArrayEnd: (offset, length) => {
-                    if (position <= offset) {
-                        throw earlyReturnException;
-                    }
-                    previousNode = undefined;
-                    segments.pop();
-                },
-                onLiteralValue: (value, offset, length) => {
-                    if (position < offset) {
-                        throw earlyReturnException;
-                    }
-                    setPreviousNode(value, offset, length, getNodeType(value));
-                    if (position <= offset + length) {
-                        throw earlyReturnException;
-                    }
-                },
-                onSeparator: (sep, offset, length) => {
-                    if (position <= offset) {
-                        throw earlyReturnException;
-                    }
-                    if (sep === ':' && previousNode && previousNode.type === 'property') {
-                        previousNode.colonOffset = offset;
-                        isAtPropertyKey = false;
-                        previousNode = undefined;
-                    }
-                    else if (sep === ',') {
-                        const last = segments[segments.length - 1];
-                        if (typeof last === 'number') {
-                            segments[segments.length - 1] = last + 1;
-                        }
-                        else {
-                            isAtPropertyKey = true;
-                            segments[segments.length - 1] = '';
-                        }
-                        previousNode = undefined;
-                    }
-                }
-            });
-        }
-        catch (e) {
-            if (e !== earlyReturnException) {
-                throw e;
-            }
-        }
-        return {
-            path: segments,
-            previousNode,
-            isAtPropertyKey,
-            matches: (pattern) => {
-                let k = 0;
-                for (let i = 0; k < pattern.length && i < segments.length; i++) {
-                    if (pattern[k] === segments[i] || pattern[k] === '*') {
-                        k++;
-                    }
-                    else if (pattern[k] !== '**') {
-                        return false;
-                    }
-                }
-                return k === pattern.length;
-            }
-        };
-    }
-    exports.getLocation = getLocation;
-    /**
-     * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
-     * Therefore always check the errors list to find out if the input was valid.
-     */
-    function parse(text, errors = [], options = ParseOptions.DEFAULT) {
-        let currentProperty = null;
-        let currentParent = [];
-        const previousParents = [];
-        function onValue(value) {
-            if (Array.isArray(currentParent)) {
-                currentParent.push(value);
-            }
-            else if (currentProperty !== null) {
-                currentParent[currentProperty] = value;
-            }
-        }
-        const visitor = {
-            onObjectBegin: () => {
-                const object = {};
-                onValue(object);
-                previousParents.push(currentParent);
-                currentParent = object;
-                currentProperty = null;
-            },
-            onObjectProperty: (name) => {
-                currentProperty = name;
-            },
-            onObjectEnd: () => {
-                currentParent = previousParents.pop();
-            },
-            onArrayBegin: () => {
-                const array = [];
-                onValue(array);
-                previousParents.push(currentParent);
-                currentParent = array;
-                currentProperty = null;
-            },
-            onArrayEnd: () => {
-                currentParent = previousParents.pop();
-            },
-            onLiteralValue: onValue,
-            onError: (error, offset, length) => {
-                errors.push({ error, offset, length });
-            }
-        };
-        visit(text, visitor, options);
-        return currentParent[0];
-    }
-    exports.parse = parse;
-    /**
-     * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
-     */
-    function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
-        let currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
-        function ensurePropertyComplete(endOffset) {
-            if (currentParent.type === 'property') {
-                currentParent.length = endOffset - currentParent.offset;
-                currentParent = currentParent.parent;
-            }
-        }
-        function onValue(valueNode) {
-            currentParent.children.push(valueNode);
-            return valueNode;
-        }
-        const visitor = {
-            onObjectBegin: (offset) => {
-                currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });
-            },
-            onObjectProperty: (name, offset, length) => {
-                currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });
-                currentParent.children.push({ type: 'string', value: name, offset, length, parent: currentParent });
-            },
-            onObjectEnd: (offset, length) => {
-                ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete
-                currentParent.length = offset + length - currentParent.offset;
-                currentParent = currentParent.parent;
-                ensurePropertyComplete(offset + length);
-            },
-            onArrayBegin: (offset, length) => {
-                currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });
-            },
-            onArrayEnd: (offset, length) => {
-                currentParent.length = offset + length - currentParent.offset;
-                currentParent = currentParent.parent;
-                ensurePropertyComplete(offset + length);
-            },
-            onLiteralValue: (value, offset, length) => {
-                onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
-                ensurePropertyComplete(offset + length);
-            },
-            onSeparator: (sep, offset, length) => {
-                if (currentParent.type === 'property') {
-                    if (sep === ':') {
-                        currentParent.colonOffset = offset;
-                    }
-                    else if (sep === ',') {
-                        ensurePropertyComplete(offset);
-                    }
-                }
-            },
-            onError: (error, offset, length) => {
-                errors.push({ error, offset, length });
-            }
-        };
-        visit(text, visitor, options);
-        const result = currentParent.children[0];
-        if (result) {
-            delete result.parent;
-        }
-        return result;
-    }
-    exports.parseTree = parseTree;
-    /**
-     * Finds the node at the given path in a JSON DOM.
-     */
-    function findNodeAtLocation(root, path) {
-        if (!root) {
-            return undefined;
-        }
-        let node = root;
-        for (let segment of path) {
-            if (typeof segment === 'string') {
-                if (node.type !== 'object' || !Array.isArray(node.children)) {
-                    return undefined;
-                }
-                let found = false;
-                for (const propertyNode of node.children) {
-                    if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
-                        node = propertyNode.children[1];
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    return undefined;
-                }
-            }
-            else {
-                const index = segment;
-                if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
-                    return undefined;
-                }
-                node = node.children[index];
-            }
-        }
-        return node;
-    }
-    exports.findNodeAtLocation = findNodeAtLocation;
-    /**
-     * Gets the JSON path of the given JSON DOM node
-     */
-    function getNodePath(node) {
-        if (!node.parent || !node.parent.children) {
-            return [];
-        }
-        const path = getNodePath(node.parent);
-        if (node.parent.type === 'property') {
-            const key = node.parent.children[0].value;
-            path.push(key);
-        }
-        else if (node.parent.type === 'array') {
-            const index = node.parent.children.indexOf(node);
-            if (index !== -1) {
-                path.push(index);
-            }
-        }
-        return path;
-    }
-    exports.getNodePath = getNodePath;
-    /**
-     * Evaluates the JavaScript object of the given JSON DOM node
-     */
-    function getNodeValue(node) {
-        switch (node.type) {
-            case 'array':
-                return node.children.map(getNodeValue);
-            case 'object':
-                const obj = Object.create(null);
-                for (let prop of node.children) {
-                    const valueNode = prop.children[1];
-                    if (valueNode) {
-                        obj[prop.children[0].value] = getNodeValue(valueNode);
-                    }
-                }
-                return obj;
-            case 'null':
-            case 'string':
-            case 'number':
-            case 'boolean':
-                return node.value;
-            default:
-                return undefined;
-        }
-    }
-    exports.getNodeValue = getNodeValue;
-    function contains(node, offset, includeRightBound = false) {
-        return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
-    }
-    exports.contains = contains;
-    /**
-     * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
-     */
-    function findNodeAtOffset(node, offset, includeRightBound = false) {
-        if (contains(node, offset, includeRightBound)) {
-            const children = node.children;
-            if (Array.isArray(children)) {
-                for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
-                    const item = findNodeAtOffset(children[i], offset, includeRightBound);
-                    if (item) {
-                        return item;
-                    }
-                }
-            }
-            return node;
-        }
-        return undefined;
-    }
-    exports.findNodeAtOffset = findNodeAtOffset;
-    /**
-     * Parses the given text and invokes the visitor functions for each object, array and literal reached.
-     */
-    function visit(text, visitor, options = ParseOptions.DEFAULT) {
-        const _scanner = (0, scanner_1.createScanner)(text, false);
-        // Important: Only pass copies of this to visitor functions to prevent accidental modification, and
-        // to not affect visitor functions which stored a reference to a previous JSONPath
-        const _jsonPath = [];
-        function toNoArgVisit(visitFunction) {
-            return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
-        }
-        function toNoArgVisitWithPath(visitFunction) {
-            return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
-        }
-        function toOneArgVisit(visitFunction) {
-            return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
-        }
-        function toOneArgVisitWithPath(visitFunction) {
-            return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
-        }
-        const onObjectBegin = toNoArgVisitWithPath(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisitWithPath(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
-        const disallowComments = options && options.disallowComments;
-        const allowTrailingComma = options && options.allowTrailingComma;
-        function scanNext() {
-            while (true) {
-                const token = _scanner.scan();
-                switch (_scanner.getTokenError()) {
-                    case 4 /* ScanError.InvalidUnicode */:
-                        handleError(14 /* ParseErrorCode.InvalidUnicode */);
-                        break;
-                    case 5 /* ScanError.InvalidEscapeCharacter */:
-                        handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);
-                        break;
-                    case 3 /* ScanError.UnexpectedEndOfNumber */:
-                        handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);
-                        break;
-                    case 1 /* ScanError.UnexpectedEndOfComment */:
-                        if (!disallowComments) {
-                            handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);
-                        }
-                        break;
-                    case 2 /* ScanError.UnexpectedEndOfString */:
-                        handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);
-                        break;
-                    case 6 /* ScanError.InvalidCharacter */:
-                        handleError(16 /* ParseErrorCode.InvalidCharacter */);
-                        break;
-                }
-                switch (token) {
-                    case 12 /* SyntaxKind.LineCommentTrivia */:
-                    case 13 /* SyntaxKind.BlockCommentTrivia */:
-                        if (disallowComments) {
-                            handleError(10 /* ParseErrorCode.InvalidCommentToken */);
-                        }
-                        else {
-                            onComment();
-                        }
-                        break;
-                    case 16 /* SyntaxKind.Unknown */:
-                        handleError(1 /* ParseErrorCode.InvalidSymbol */);
-                        break;
-                    case 15 /* SyntaxKind.Trivia */:
-                    case 14 /* SyntaxKind.LineBreakTrivia */:
-                        break;
-                    default:
-                        return token;
-                }
-            }
-        }
-        function handleError(error, skipUntilAfter = [], skipUntil = []) {
-            onError(error);
-            if (skipUntilAfter.length + skipUntil.length > 0) {
-                let token = _scanner.getToken();
-                while (token !== 17 /* SyntaxKind.EOF */) {
-                    if (skipUntilAfter.indexOf(token) !== -1) {
-                        scanNext();
-                        break;
-                    }
-                    else if (skipUntil.indexOf(token) !== -1) {
-                        break;
-                    }
-                    token = scanNext();
-                }
-            }
-        }
-        function parseString(isValue) {
-            const value = _scanner.getTokenValue();
-            if (isValue) {
-                onLiteralValue(value);
-            }
-            else {
-                onObjectProperty(value);
-                // add property name afterwards
-                _jsonPath.push(value);
-            }
-            scanNext();
-            return true;
-        }
-        function parseLiteral() {
-            switch (_scanner.getToken()) {
-                case 11 /* SyntaxKind.NumericLiteral */:
-                    const tokenValue = _scanner.getTokenValue();
-                    let value = Number(tokenValue);
-                    if (isNaN(value)) {
-                        handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
-                        value = 0;
-                    }
-                    onLiteralValue(value);
-                    break;
-                case 7 /* SyntaxKind.NullKeyword */:
-                    onLiteralValue(null);
-                    break;
-                case 8 /* SyntaxKind.TrueKeyword */:
-                    onLiteralValue(true);
-                    break;
-                case 9 /* SyntaxKind.FalseKeyword */:
-                    onLiteralValue(false);
-                    break;
-                default:
-                    return false;
-            }
-            scanNext();
-            return true;
-        }
-        function parseProperty() {
-            if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {
-                handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
-                return false;
-            }
-            parseString(false);
-            if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {
-                onSeparator(':');
-                scanNext(); // consume colon
-                if (!parseValue()) {
-                    handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
-                }
-            }
-            else {
-                handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
-            }
-            _jsonPath.pop(); // remove processed property name
-            return true;
-        }
-        function parseObject() {
-            onObjectBegin();
-            scanNext(); // consume open brace
-            let needsComma = false;
-            while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
-                if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
-                    if (!needsComma) {
-                        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
-                    }
-                    onSeparator(',');
-                    scanNext(); // consume comma
-                    if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {
-                        break;
-                    }
-                }
-                else if (needsComma) {
-                    handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
-                }
-                if (!parseProperty()) {
-                    handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
-                }
-                needsComma = true;
-            }
-            onObjectEnd();
-            if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {
-                handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);
-            }
-            else {
-                scanNext(); // consume close brace
-            }
-            return true;
-        }
-        function parseArray() {
-            onArrayBegin();
-            scanNext(); // consume open bracket
-            let isFirstElement = true;
-            let needsComma = false;
-            while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
-                if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
-                    if (!needsComma) {
-                        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
-                    }
-                    onSeparator(',');
-                    scanNext(); // consume comma
-                    if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {
-                        break;
-                    }
-                }
-                else if (needsComma) {
-                    handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
-                }
-                if (isFirstElement) {
-                    _jsonPath.push(0);
-                    isFirstElement = false;
-                }
-                else {
-                    _jsonPath[_jsonPath.length - 1]++;
-                }
-                if (!parseValue()) {
-                    handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);
-                }
-                needsComma = true;
-            }
-            onArrayEnd();
-            if (!isFirstElement) {
-                _jsonPath.pop(); // remove array index
-            }
-            if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {
-                handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);
-            }
-            else {
-                scanNext(); // consume close bracket
-            }
-            return true;
-        }
-        function parseValue() {
-            switch (_scanner.getToken()) {
-                case 3 /* SyntaxKind.OpenBracketToken */:
-                    return parseArray();
-                case 1 /* SyntaxKind.OpenBraceToken */:
-                    return parseObject();
-                case 10 /* SyntaxKind.StringLiteral */:
-                    return parseString(true);
-                default:
-                    return parseLiteral();
-            }
-        }
-        scanNext();
-        if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {
-            if (options.allowEmptyContent) {
-                return true;
-            }
-            handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
-            return false;
-        }
-        if (!parseValue()) {
-            handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
-            return false;
-        }
-        if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
-            handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);
-        }
-        return true;
-    }
-    exports.visit = visit;
-    /**
-     * Takes JSON with JavaScript-style comments and remove
-     * them. Optionally replaces every none-newline character
-     * of comments with a replaceCharacter
-     */
-    function stripComments(text, replaceCh) {
-        let _scanner = (0, scanner_1.createScanner)(text), parts = [], kind, offset = 0, pos;
-        do {
-            pos = _scanner.getPosition();
-            kind = _scanner.scan();
-            switch (kind) {
-                case 12 /* SyntaxKind.LineCommentTrivia */:
-                case 13 /* SyntaxKind.BlockCommentTrivia */:
-                case 17 /* SyntaxKind.EOF */:
-                    if (offset !== pos) {
-                        parts.push(text.substring(offset, pos));
-                    }
-                    if (replaceCh !== undefined) {
-                        parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
-                    }
-                    offset = _scanner.getPosition();
-                    break;
-            }
-        } while (kind !== 17 /* SyntaxKind.EOF */);
-        return parts.join('');
-    }
-    exports.stripComments = stripComments;
-    function getNodeType(value) {
-        switch (typeof value) {
-            case 'boolean': return 'boolean';
-            case 'number': return 'number';
-            case 'string': return 'string';
-            case 'object': {
-                if (!value) {
-                    return 'null';
-                }
-                else if (Array.isArray(value)) {
-                    return 'array';
-                }
-                return 'object';
-            }
-            default: return 'null';
-        }
-    }
-    exports.getNodeType = getNodeType;
-});