brighterscript 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.util = exports.standardizePath = exports.Util = void 0;
+exports.MAX_PARAM_COUNT = exports.util = exports.standardizePath = exports.Util = void 0;
 const fs = require("fs");
 const fsExtra = require("fs-extra");
 const jsonc_parser_1 = require("jsonc-parser");
@@ -13,7 +13,7 @@ const BooleanType_1 = require("./types/BooleanType");
 const DoubleType_1 = require("./types/DoubleType");
 const DynamicType_1 = require("./types/DynamicType");
 const FloatType_1 = require("./types/FloatType");
-const FunctionType_1 = require("./types/FunctionType");
+const TypedFunctionType_1 = require("./types/TypedFunctionType");
 const IntegerType_1 = require("./types/IntegerType");
 const InvalidType_1 = require("./types/InvalidType");
 const LongIntegerType_1 = require("./types/LongIntegerType");
@@ -22,10 +22,13 @@ const StringType_1 = require("./types/StringType");
 const VoidType_1 = require("./types/VoidType");
 const Parser_1 = require("./parser/Parser");
 const Logger_1 = require("./Logger");
-const lexer_1 = require("./lexer");
-const astUtils_1 = require("./astUtils");
-const CustomType_1 = require("./types/CustomType");
+const TokenKind_1 = require("./lexer/TokenKind");
+const reflection_1 = require("./astUtils/reflection");
+const visitors_1 = require("./astUtils/visitors");
 const source_map_1 = require("source-map");
+const SGTypes_1 = require("./parser/SGTypes");
+const LazyType_1 = require("./types/LazyType");
+const FunctionType_1 = require("./types/FunctionType");
 class Util {
     clearConsole() {
         // process.stdout.write('\x1Bc');
@@ -125,7 +128,7 @@ class Util {
                 colIndex++;
             }
         }
-        return exports.util.createRange(lineIndex, colIndex, lineIndex, colIndex + length);
+        return this.createRange(lineIndex, colIndex, lineIndex, colIndex + length);
     }
     /**
      * Load the contents of a config file.
@@ -154,16 +157,19 @@ class Util {
             //load the project file
             let projectFileContents = fsExtra.readFileSync(configFilePath).toString();
             let parseErrors = [];
-            let projectConfig = jsonc_parser_1.parse(projectFileContents, parseErrors);
+            let projectConfig = (0, jsonc_parser_1.parse)(projectFileContents, parseErrors);
             if (parseErrors.length > 0) {
                 let err = parseErrors[0];
-                let diagnostic = Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.bsConfigJsonHasSyntaxErrors(jsonc_parser_1.printParseErrorCode(parseErrors[0].error))), { file: {
+                let diagnostic = Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.bsConfigJsonHasSyntaxErrors((0, jsonc_parser_1.printParseErrorCode)(parseErrors[0].error))), { file: {
                         srcPath: configFilePath
                     }, range: this.getRangeFromOffsetLength(projectFileContents, err.offset, err.length) });
                 throw diagnostic; //eslint-disable-line @typescript-eslint/no-throw-literal
             }
-            this.resolvePluginPaths(projectConfig, configFilePath);
             let projectFileCwd = path.dirname(configFilePath);
+            //`plugins` paths should be relative to the current bsconfig
+            this.resolvePathsRelativeTo(projectConfig, 'plugins', projectFileCwd);
+            //`require` paths should be relative to cwd
+            exports.util.resolvePathsRelativeTo(projectConfig, 'require', projectFileCwd);
             let result;
             //if the project has a base file, load it
             if (projectConfig && typeof projectConfig.extends === 'string') {
@@ -191,26 +197,22 @@ class Util {
         }
     }
     /**
-     * Relative paths to scripts in plugins should be resolved relatively to the bsconfig file
-     * and de-duplicated
-     * @param config Parsed configuration
-     * @param configFilePath Path of the configuration file
+     * Convert relative paths to absolute paths, relative to the given directory. Also de-dupes the paths. Modifies the array in-place
+     * @param paths the list of paths to be resolved and deduped
+     * @param relativeDir the path to the folder where the paths should be resolved relative to. This should be an absolute path
      */
-    resolvePluginPaths(config, configFilePath) {
+    resolvePathsRelativeTo(collection, key, relativeDir) {
         var _a;
-        if (((_a = config.plugins) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-            const relPath = path.dirname(configFilePath);
-            const exists = {};
-            config.plugins = config.plugins.map(p => {
-                return (p === null || p === void 0 ? void 0 : p.startsWith('.')) ? path.resolve(relPath, p) : p;
-            }).filter(p => {
-                if (!p || exists[p]) {
-                    return false;
-                }
-                exists[p] = true;
-                return true;
-            });
+        if (!collection[key]) {
+            return;
         }
+        const result = new Set();
+        for (const p of (_a = collection[key]) !== null && _a !== void 0 ? _a : []) {
+            if (p) {
+                result.add((p === null || p === void 0 ? void 0 : p.startsWith('.')) ? path.resolve(relativeDir, p) : p);
+            }
+        }
+        collection[key] = [...result];
     }
     /**
      * Do work within the scope of a changed current working directory
@@ -424,10 +426,10 @@ class Util {
     findBeginningVariableExpression(dottedGet) {
         let left = dottedGet;
         while (left) {
-            if (astUtils_1.isVariableExpression(left)) {
+            if ((0, reflection_1.isVariableExpression)(left)) {
                 return left;
             }
-            else if (astUtils_1.isDottedGetExpression(left)) {
+            else if ((0, reflection_1.isDottedGetExpression)(left)) {
                 left = left.obj;
             }
             else {
@@ -598,11 +600,12 @@ class Util {
      */
     diagnosticIsSuppressed(diagnostic) {
         var _a, _b;
+        const diagnosticCode = typeof diagnostic.code === 'string' ? diagnostic.code.toLowerCase() : diagnostic.code;
         for (let flag of (_b = (_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.commentFlags) !== null && _b !== void 0 ? _b : []) {
             //this diagnostic is affected by this flag
             if (this.rangeContains(flag.affectedRange, diagnostic.range.start)) {
                 //if the flag acts upon this diagnostic's code
-                if (flag.codes === null || flag.codes.includes(diagnostic.code)) {
+                if (flag.codes === null || flag.codes.includes(diagnosticCode)) {
                     return true;
                 }
             }
@@ -807,6 +810,40 @@ class Util {
             }
         };
     }
+    /**
+     * Given a list of ranges, create a range that starts with the first non-null lefthand range, and ends with the first non-null
+     * righthand range. Returns undefined if none of the items have a range.
+     */
+    createBoundingRange(...locatables) {
+        let leftmostRange;
+        let rightmostRange;
+        for (let i = 0; i < locatables.length; i++) {
+            //set the leftmost non-null-range item
+            const left = locatables[i];
+            //the range might be a getter, so access it exactly once
+            const leftRange = left === null || left === void 0 ? void 0 : left.range;
+            if (!leftmostRange && leftRange) {
+                leftmostRange = leftRange;
+            }
+            //set the rightmost non-null-range item
+            const right = locatables[locatables.length - 1 - i];
+            //the range might be a getter, so access it exactly once
+            const rightRange = right === null || right === void 0 ? void 0 : right.range;
+            if (!rightmostRange && rightRange) {
+                rightmostRange = rightRange;
+            }
+            //if we have both sides, quit
+            if (leftmostRange && rightmostRange) {
+                break;
+            }
+        }
+        if (leftmostRange) {
+            return this.createRangeFromPositions(leftmostRange.start, rightmostRange.end);
+        }
+        else {
+            return undefined;
+        }
+    }
     /**
      * Create a `Position` object. Prefer this over `Position.create` for performance reasons
      */
@@ -831,71 +868,95 @@ class Util {
     /**
      * Convert a token into a BscType
      */
-    tokenToBscType(token, allowCustomType = true) {
+    tokenToBscType(token, allowBrighterscriptTypes = true, currentNamespaceName) {
         if (!token) {
             return new DynamicType_1.DynamicType();
         }
         // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
         switch (token.kind) {
-            case lexer_1.TokenKind.Boolean:
-            case lexer_1.TokenKind.True:
-            case lexer_1.TokenKind.False:
+            case TokenKind_1.TokenKind.Boolean:
+                return new BooleanType_1.BooleanType(token.text);
+            case TokenKind_1.TokenKind.True:
+            case TokenKind_1.TokenKind.False:
                 return new BooleanType_1.BooleanType();
-            case lexer_1.TokenKind.Double:
-            case lexer_1.TokenKind.DoubleLiteral:
+            case TokenKind_1.TokenKind.Double:
+                return new DoubleType_1.DoubleType(token.text);
+            case TokenKind_1.TokenKind.DoubleLiteral:
                 return new DoubleType_1.DoubleType();
-            case lexer_1.TokenKind.Dynamic:
-                return new DynamicType_1.DynamicType();
-            case lexer_1.TokenKind.Float:
-            case lexer_1.TokenKind.FloatLiteral:
+            case TokenKind_1.TokenKind.Dynamic:
+                return new DynamicType_1.DynamicType(token.text);
+            case TokenKind_1.TokenKind.Float:
+                return new FloatType_1.FloatType(token.text);
+            case TokenKind_1.TokenKind.FloatLiteral:
                 return new FloatType_1.FloatType();
-            case lexer_1.TokenKind.Function:
-                //TODO should there be a more generic function type without a signature that's assignable to all other function types?
-                return new FunctionType_1.FunctionType(new DynamicType_1.DynamicType());
-            case lexer_1.TokenKind.Integer:
-            case lexer_1.TokenKind.IntegerLiteral:
+            case TokenKind_1.TokenKind.Function:
+                return new FunctionType_1.FunctionType();
+            case TokenKind_1.TokenKind.Integer:
+                return new IntegerType_1.IntegerType(token.text);
+            case TokenKind_1.TokenKind.IntegerLiteral:
                 return new IntegerType_1.IntegerType();
-            case lexer_1.TokenKind.Invalid:
-                return new InvalidType_1.InvalidType();
-            case lexer_1.TokenKind.LongInteger:
-            case lexer_1.TokenKind.LongIntegerLiteral:
+            case TokenKind_1.TokenKind.Invalid:
+                return new InvalidType_1.InvalidType(token.text);
+            case TokenKind_1.TokenKind.LongInteger:
+                return new LongIntegerType_1.LongIntegerType(token.text);
+            case TokenKind_1.TokenKind.LongIntegerLiteral:
                 return new LongIntegerType_1.LongIntegerType();
-            case lexer_1.TokenKind.Object:
-                return new ObjectType_1.ObjectType();
-            case lexer_1.TokenKind.String:
-            case lexer_1.TokenKind.StringLiteral:
-            case lexer_1.TokenKind.TemplateStringExpressionBegin:
-            case lexer_1.TokenKind.TemplateStringExpressionEnd:
-            case lexer_1.TokenKind.TemplateStringQuasi:
+            case TokenKind_1.TokenKind.Object:
+                return new ObjectType_1.ObjectType(token.text);
+            case TokenKind_1.TokenKind.String:
+                return new StringType_1.StringType(token.text);
+            case TokenKind_1.TokenKind.StringLiteral:
+            case TokenKind_1.TokenKind.TemplateStringExpressionBegin:
+            case TokenKind_1.TokenKind.TemplateStringExpressionEnd:
+            case TokenKind_1.TokenKind.TemplateStringQuasi:
                 return new StringType_1.StringType();
-            case lexer_1.TokenKind.Void:
-                return new VoidType_1.VoidType();
-            case lexer_1.TokenKind.Identifier:
-                switch (token.text.toLowerCase()) {
+            case TokenKind_1.TokenKind.Void:
+                return new VoidType_1.VoidType(token.text);
+            case TokenKind_1.TokenKind.Identifier:
+                let typeText = token.text.trim().toLowerCase();
+                let typeClass;
+                switch (typeText) {
                     case 'boolean':
-                        return new BooleanType_1.BooleanType();
+                        typeClass = new BooleanType_1.BooleanType(token.text);
+                        break;
                     case 'double':
-                        return new DoubleType_1.DoubleType();
+                        typeClass = new DoubleType_1.DoubleType(token.text);
+                        break;
                     case 'float':
-                        return new FloatType_1.FloatType();
+                        typeClass = new FloatType_1.FloatType(token.text);
+                        break;
                     case 'function':
-                        return new FunctionType_1.FunctionType(new DynamicType_1.DynamicType());
+                        typeClass = new TypedFunctionType_1.TypedFunctionType(new DynamicType_1.DynamicType(token.text));
+                        break;
                     case 'integer':
-                        return new IntegerType_1.IntegerType();
+                        typeClass = new IntegerType_1.IntegerType(token.text);
+                        break;
                     case 'invalid':
-                        return new InvalidType_1.InvalidType();
+                        typeClass = new InvalidType_1.InvalidType(token.text);
+                        break;
                     case 'longinteger':
-                        return new LongIntegerType_1.LongIntegerType();
+                        typeClass = new LongIntegerType_1.LongIntegerType(token.text);
+                        break;
                     case 'object':
-                        return new ObjectType_1.ObjectType();
+                        typeClass = new ObjectType_1.ObjectType(token.text);
+                        break;
                     case 'string':
-                        return new StringType_1.StringType();
+                        typeClass = new StringType_1.StringType(token.text);
+                        break;
                     case 'void':
-                        return new VoidType_1.VoidType();
+                        typeClass = new VoidType_1.VoidType(token.text);
+                        break;
+                    case 'dynamic':
+                        typeClass = new DynamicType_1.DynamicType(token.text);
+                        break;
                 }
-                if (allowCustomType) {
-                    return new CustomType_1.CustomType(token.text);
+                if (!typeClass && allowBrighterscriptTypes) {
+                    typeClass = new LazyType_1.LazyType((context) => {
+                        var _a, _b;
+                        return (_b = (_a = context === null || context === void 0 ? void 0 : context.scope) === null || _a === void 0 ? void 0 : _a.getNamedTypeStatement(typeText, currentNamespaceName === null || currentNamespaceName === void 0 ? void 0 : currentNamespaceName.getName())) === null || _b === void 0 ? void 0 : _b.getThisBscType();
+                    });
                 }
+                return typeClass;
         }
     }
     /**
@@ -976,19 +1037,22 @@ class Util {
         const expressions = [expression];
         const variableExpressions = [];
         const uniqueVarNames = new Set();
-        // Collect all expressions. Most of these expressions are fairly small so this should be quick!
-        // This should only be called during transpile time and only when we actually need it.
-        expression === null || expression === void 0 ? void 0 : expression.walk((expression) => {
-            if (astUtils_1.isExpression(expression)) {
+        function expressionWalker(expression) {
+            if ((0, reflection_1.isExpression)(expression)) {
                 expressions.push(expression);
             }
-            if (astUtils_1.isVariableExpression(expression)) {
+            if ((0, reflection_1.isVariableExpression)(expression)) {
                 variableExpressions.push(expression);
                 uniqueVarNames.add(expression.name.text);
             }
-        }, {
-            walkMode: astUtils_1.WalkMode.visitExpressions
+        }
+        // Collect all expressions. Most of these expressions are fairly small so this should be quick!
+        // This should only be called during transpile time and only when we actually need it.
+        expression === null || expression === void 0 ? void 0 : expression.walk(expressionWalker, {
+            walkMode: visitors_1.WalkMode.visitExpressions
         });
+        //handle the expression itself (for situations when expression is a VariableExpression)
+        expressionWalker(expression);
         return { expressions: expressions, varExpressions: variableExpressions, uniqueVarNames: [...uniqueVarNames] };
     }
     /**
@@ -1006,20 +1070,25 @@ class Util {
         return new source_map_1.SourceNode(null, null, source, chunks);
     }
     /**
-     * Creates a new SGAttribute object, but keeps the existing Range references (since those shouldn't ever get changed directly)
+     * Creates a new SGAttribute object, but keeps the existing Range references (since those should be immutable)
      */
     cloneSGAttribute(attr, value) {
-        return {
-            key: {
-                text: attr.key.text,
-                range: attr.range
-            },
-            value: {
-                text: value,
-                range: attr.value.range
-            },
-            range: attr.range
-        };
+        return new SGTypes_1.SGAttribute({ text: attr.tokens.key.text, range: attr.range }, { text: '=' }, { text: '"' }, { text: value, range: attr.tokens.value.range }, { text: '"' });
+    }
+    /**
+     * Shorthand for creating a new source node
+     */
+    sourceNode(source, locatable, code) {
+        if (code !== undefined) {
+            const node = new source_map_1.SourceNode(null, null, source, code);
+            if (locatable.range) {
+                //convert 0-based Range line to 1-based SourceNode line
+                node.line = locatable.range.start.line + 1;
+                //SourceNode columns are 0-based so no conversion necessary
+                node.column = locatable.range.start.character;
+            }
+            return node;
+        }
     }
     /**
      * Remove leading simple protocols from a path (if present)
@@ -1033,10 +1102,13 @@ class Util {
             return pkgPath;
         }
     }
+    /**
+     * Converts a path into a standardized format (drive letter to lower, remove extra slashes, use single slash type, resolve relative parts, etc...)
+     */
     standardizePath(thePath) {
         return exports.util.driveLetterToLower(rokuDeploy.standardizePath(thePath));
     }
-    /*
+    /**
      * Copy the version of bslib from local node_modules to the staging folder
      */
     async copyBslibToStaging(stagingDir) {
@@ -1077,13 +1149,60 @@ class Util {
         };
     }
     /**
-     * Finds the array of callables from a container map, taking into account the function from which it was called
+     * Gets the minimum and maximum number of allowed params
+     * @param params The list of callable parameters to check
+     * @returns the minimum and maximum number of allowed params
+     */
+    getMinMaxParamCount(params) {
+        //get min/max parameter count for callable
+        let minParams = 0;
+        let maxParams = 0;
+        let continueCheckingForRequired = true;
+        for (let param of params) {
+            maxParams++;
+            //optional parameters must come last, so we can assume that minParams won't increase once we hit
+            //the first isOptional
+            if (continueCheckingForRequired && !param.isOptional) {
+                minParams++;
+            }
+            else {
+                continueCheckingForRequired = false;
+            }
+        }
+        return { min: minParams, max: maxParams };
+    }
+    /**
+     * Gets the minimum and maximum number of allowed params for ALL functions with the name of the function call
+     * @param callablesByLowerName The map of callable containers
+     * @param expCall function call expression to use for the name
+     * @returns the minimum and maximum number of allowed params
+     */
+    getMinMaxParamCountByFunctionCall(callablesByLowerName, expCall) {
+        const callablesWithThisName = this.getCallableContainersByName(callablesByLowerName, expCall);
+        if ((callablesWithThisName === null || callablesWithThisName === void 0 ? void 0 : callablesWithThisName.length) > 0) {
+            const paramCount = { min: exports.MAX_PARAM_COUNT, max: 0 };
+            for (const callableContainer of callablesWithThisName) {
+                let specificParamCount = exports.util.getMinMaxParamCount(callableContainer.callable.params);
+                if (specificParamCount.max > paramCount.max) {
+                    paramCount.max = specificParamCount.max;
+                }
+                if (specificParamCount.min < paramCount.min) {
+                    paramCount.min = specificParamCount.min;
+                }
+            }
+            return paramCount;
+        }
+    }
+    /**
+     * Finds the array of callables from a container map, based on the name of the function call
      * If the callable was called in a function in a namespace, functions in that namespace are preferred
+     * @param callablesByLowerName The map of callable containers
+     * @param expCall function call expression to use for the name
      * @return an array with callable containers - could be empty if nothing was found
      */
-    getCallableContainersFromContainerMapByFunctionCall(callablesByLowerName, expCall) {
+    getCallableContainersByName(callablesByLowerName, expCall) {
         let callablesWithThisName = [];
-        const lowerName = expCall.name.toLowerCase();
+        const lowerName = expCall.name.text.toLowerCase();
         if (expCall.functionExpression.namespaceName) {
             // prefer namespaced function
             const potentialNamespacedCallable = expCall.functionExpression.namespaceName.getName(Parser_1.ParseMode.BrightScript).toLowerCase() + '_' + lowerName;
@@ -1095,6 +1214,131 @@ class Util {
         }
         return callablesWithThisName;
     }
+    /**
+     * Sort an array of objects that have a Range
+     */
+    sortByRange(locatables) {
+        //sort the tokens by range
+        return locatables.sort((a, b) => {
+            //start line
+            if (a.range.start.line < b.range.start.line) {
+                return -1;
+            }
+            if (a.range.start.line > b.range.start.line) {
+                return 1;
+            }
+            //start char
+            if (a.range.start.character < b.range.start.character) {
+                return -1;
+            }
+            if (a.range.start.character > b.range.start.character) {
+                return 1;
+            }
+            //end line
+            if (a.range.end.line < b.range.end.line) {
+                return -1;
+            }
+            if (a.range.end.line > b.range.end.line) {
+                return 1;
+            }
+            //end char
+            if (a.range.end.character < b.range.end.character) {
+                return -1;
+            }
+            else if (a.range.end.character > b.range.end.character) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+    /**
+     * Split the given text and return ranges for each chunk.
+     * Only works for single-line strings
+     */
+    splitGetRange(separator, text, range) {
+        const chunks = text.split(separator);
+        const result = [];
+        let offset = 0;
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            //only keep nonzero chunks
+            if (chunk.length > 0) {
+                result.push({
+                    text: chunk,
+                    range: this.createRange(range.start.line, range.start.character + offset, range.end.line, range.start.character + offset + chunk.length)
+                });
+            }
+            offset += chunk.length + separator.length;
+        }
+        return result;
+    }
+    /*
+     * Wrap the given code in a markdown code fence (with the language)
+     */
+    mdFence(code, language = '') {
+        return '```' + language + '\n' + code + '\n```';
+    }
+    /**
+     * Finds a callable from a container map based on the name AND number of arguments
+     * If the callable was called in a function in a namespace, functions in that namespace are preferred
+     * The first callable that matches the name AND will accept the number of arguments given is returned
+     * @return a callable containers that matches the call
+     */
+    getCallableContainerByFunctionCall(callablesByLowerName, expCall) {
+        const callablesWithThisName = this.getCallableContainersByName(callablesByLowerName, expCall);
+        if ((callablesWithThisName === null || callablesWithThisName === void 0 ? void 0 : callablesWithThisName.length) > 0) {
+            for (const callableContainer of callablesWithThisName) {
+                const paramCount = exports.util.getMinMaxParamCount(callableContainer.callable.params);
+                if (paramCount.min <= expCall.args.length && paramCount.max >= expCall.args.length) {
+                    return callableContainer;
+                }
+            }
+        }
+    }
+    /**
+     * Gets each part of the dotted get.
+     * @param expression
+     * @returns an array of the parts of the dotted get. If not fully a dotted get, then returns undefined
+     */
+    getAllDottedGetParts(expression) {
+        var _a, _b;
+        const parts = [];
+        let nextPart = expression;
+        while (nextPart) {
+            if ((0, reflection_1.isDottedGetExpression)(nextPart)) {
+                parts.push((_a = nextPart === null || nextPart === void 0 ? void 0 : nextPart.name) === null || _a === void 0 ? void 0 : _a.text);
+                nextPart = nextPart.obj;
+            }
+            else if ((0, reflection_1.isVariableExpression)(nextPart)) {
+                parts.push((_b = nextPart === null || nextPart === void 0 ? void 0 : nextPart.name) === null || _b === void 0 ? void 0 : _b.text);
+                break;
+            }
+            else {
+                //we found a non-DottedGet expression, so return because this whole operation is invalid.
+                return undefined;
+            }
+        }
+        return parts.reverse();
+    }
+    /**
+     * Returns an integer if valid, or undefined. Eliminates checking for NaN
+     */
+    parseInt(value) {
+        const result = parseInt(value);
+        if (!isNaN(result)) {
+            return result;
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Converts a range to a string in the format 1:2-3:4
+     */
+    rangeToString(range) {
+        var _a, _b, _c, _d;
+        return `${(_a = range === null || range === void 0 ? void 0 : range.start) === null || _a === void 0 ? void 0 : _a.line}:${(_b = range === null || range === void 0 ? void 0 : range.start) === null || _b === void 0 ? void 0 : _b.character}-${(_c = range === null || range === void 0 ? void 0 : range.end) === null || _c === void 0 ? void 0 : _c.line}:${(_d = range === null || range === void 0 ? void 0 : range.end) === null || _d === void 0 ? void 0 : _d.character}`;
+    }
 }
 exports.Util = Util;
 /**
@@ -1111,4 +1355,5 @@ function standardizePath(stringParts, ...expressions) {
 exports.standardizePath = standardizePath;
 exports.util = new Util();
 exports.default = exports.util;
+exports.MAX_PARAM_COUNT = 32;
 //# sourceMappingURL=util.js.map