@arcgis/arcade-languageservice 5.2.0-next.90 → 5.2.0-next.93

package/dist/index.d.ts

@@ -34,9 +34,7 @@ export declare const ArcadeReservedKeywords: string[];
  * Example: [1, 2, 3]
  */
 declare interface ArrayExpression extends NodeBase<typeof NodeTypes.ArrayExpression> {
-    /**
-     * The elements of the array expression.
-     */
+    /** The elements of the array expression. */
     elements: Expression[];
 }
 
@@ -48,7 +46,6 @@ declare interface AssignmentExpression extends NodeBase<typeof NodeTypes.Assignm
     /**
      * The operator of the assignment expression.
      * Example: a = 1;
-     *
      */
     operator: AssignmentOperators;
     /**
@@ -65,14 +62,17 @@ declare interface AssignmentExpression extends NodeBase<typeof NodeTypes.Assignm
     right: Expression;
 }
 
-/**
- * Arcade assignment operators.
- */
-declare const AssignmentOperators: readonly ["=", "/=", "*=", "%=", "+=", "-="];
-
-/**
- * Arcade assignment operators.
- */
+/** Arcade assignment operators. */
+declare const AssignmentOperators: readonly [
+"=",
+"/=",
+"*=",
+"%=",
+"+=",
+"-="
+];
+
+/** Arcade assignment operators. */
 declare type AssignmentOperators = (typeof AssignmentOperators)[number];
 
 /**
@@ -100,24 +100,34 @@ declare interface BinaryExpression extends NodeBase<typeof NodeTypes.BinaryExpre
     right: Expression;
 }
 
-/**
- * Arcade binary operators.
- */
-declare const BinaryOperators: readonly ["|", "&", ">>", "<<", ">>>", "^", "==", "!=", "<", "<=", ">", ">=", "+", "-", "*", "/", "%"];
-
-/**
- * Arcade binary operators.
- */
+/** Arcade binary operators. */
+declare const BinaryOperators: readonly [
+"|",
+"&",
+">>",
+"<<",
+">>>",
+"^",
+"==",
+"!=",
+"<",
+"<=",
+">",
+">=",
+"+",
+"-",
+"*",
+"/",
+"%"
+];
+
+/** Arcade binary operators. */
 declare type BinaryOperators = (typeof BinaryOperators)[number];
 
-/**
- * Define a block comment.
- */
+/** Define a block comment. */
 declare interface BlockComment extends ItemLocation {
     readonly type: typeof NodeTypes.BlockComment;
-    /**
-     * The value of the comment.
-     */
+    /** The value of the comment. */
     value: string;
 }
 
@@ -126,13 +136,9 @@ declare interface BlockComment extends ItemLocation {
  * Example: { return 1; }
  */
 declare interface BlockStatement extends NodeBase<typeof NodeTypes.BlockStatement> {
-    /**
-     * The collection of statements in the block.
-     */
+    /** The collection of statements in the block. */
     body: Statement[];
-    /**
-     * The collection of comments inside the block.
-     */
+    /** The collection of comments inside the block. */
     innerComments?: Comment_2[];
 }
 
@@ -161,9 +167,7 @@ declare interface CallExpression extends NodeBase<typeof NodeTypes.CallExpressio
     arguments: Expression[];
 }
 
-/**
- * Define a comment of type block or line.
- */
+/** Define a comment of type block or line. */
 declare type Comment_2 = BlockComment | LineComment;
 
 /**
@@ -186,9 +190,7 @@ declare interface ComputedMemberExpression extends NodeBase<typeof NodeTypes.Mem
     property: Expression;
 }
 
-/**
- * Arcade contextual keywords.
- */
+/** Arcade contextual keywords. */
 declare const ContextualKeywords: {
     From: string;
     Of: string;
@@ -200,15 +202,16 @@ declare const ContextualKeywords: {
  */
 declare type ContinueStatement = NodeBase<typeof NodeTypes.ContinueStatement>;
 
+/** @param program */
 declare function convertProgramToJSON(program: Program): Record<string, unknown>;
 
-/**
- * Define the types of Arcade Declaration.
- */
+/** Define the types of Arcade Declaration. */
 declare type Declaration = ExportNamedDeclaration | FunctionDeclaration | ImportDeclaration | VariableDeclaration;
 
 /**
  * Define the delegate for the parser.
+ *
+ * @param node
  */
 declare type Delegate = (node: Node_2) => void;
 
@@ -240,41 +243,30 @@ export declare interface Diagnostic {
     data?: DiagnosticData | null;
 }
 
-/**
- * The Arcade diagnostic class.
- */
-declare class Diagnostic_2 extends Error implements DiagnosticApi {
-    readonly declaredRootClass: string;
+/** The Arcade diagnostic class. */
+declare class Diagnostic_2 extends Error {
+    constructor(diagnosticApi: DiagnosticApi);
     code: DiagnosticCodes_2;
-    index: number;
-    line: number;
     column: number;
+    data?: DiagnosticData_2 | null;
+    /** @default "esri.arcade.lib.diagnostic" */
+    readonly declaredRootClass: string;
+    description?: string;
+    index: number;
     len: number;
+    line: number;
     range: SourceLocation;
-    description?: string;
-    data?: DiagnosticData_2 | null;
-    constructor({ code, index, line, column, len, description, data }: DiagnosticApi);
 }
 
-/**
- * Define the properties of a diagnostic.
- */
+/** Define the properties of a diagnostic. */
 declare interface DiagnosticApi extends Marker {
-    /**
-     * The diagnostic code.
-     */
+    /** The diagnostic code. */
     code: DiagnosticCodes_2;
-    /**
-     * The diagnostic description.
-     */
+    /** The diagnostic description. */
     description?: string;
-    /**
-     * The length of the token.
-     */
+    /** The length of the token. */
     len?: number;
-    /**
-     * The associated diagnostic data.
-     */
+    /** The associated diagnostic data. */
     data?: DiagnosticData_2 | null;
 }
 
@@ -283,9 +275,7 @@ declare interface DiagnosticApi extends Marker {
  */
 export declare type DiagnosticCodes = Parser.DiagnosticCodes | ValidationDiagnosticCodes;
 
-/**
- * Arcade diagnostic error codes.
- */
+/** Arcade diagnostic error codes. */
 declare const DiagnosticCodes_2: {
     readonly InvalidModuleUri: "InvalidModuleUri";
     readonly ForInOfLoopInitializer: "ForInOfLoopInitializer";
@@ -317,9 +307,7 @@ declare const DiagnosticCodes_2: {
     readonly UnexpectedToken: "UnexpectedToken";
 };
 
-/**
- * Arcade diagnostic error codes.
- */
+/** Arcade diagnostic error codes. */
 declare type DiagnosticCodes_2 = (typeof DiagnosticCodes_2)[keyof typeof DiagnosticCodes_2];
 
 /**
@@ -329,9 +317,7 @@ declare type DiagnosticCodes_2 = (typeof DiagnosticCodes_2)[keyof typeof Diagnos
  */
 export declare type DiagnosticData = Record<string, number | string>;
 
-/**
- * Arcade diagnostic data.
- */
+/** Arcade diagnostic data. */
 declare type DiagnosticData_2 = Record<string, number | string>;
 
 export declare const DiagnosticMessages: {
@@ -386,16 +372,12 @@ export declare const DiagnosticMessages: {
     readonly UnknownPropertyIdentifier: "Unknown property identifier '${identifier}'.";
 };
 
-/**
- * Arcade diagnostic messages.
- */
+/** Arcade diagnostic messages. */
 declare const DiagnosticMessages_2: Record<DiagnosticCodes_2, string>;
 
 export { DiagnosticSeverity }
 
-/**
- * Define an Arcade empty statement.
- */
+/** Define an Arcade empty statement. */
 declare type EmptyStatement = NodeBase<typeof NodeTypes.EmptyStatement>;
 
 /**
@@ -445,9 +427,7 @@ declare interface ExportSpecifier extends NodeBase<typeof NodeTypes.ExportSpecif
     local: Identifier;
 }
 
-/**
- * Define the types of Arcade Expression.
- */
+/** Define the types of Arcade Expression. */
 declare type Expression = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression | Identifier | Literal | LogicalExpression | MemberAccessChainExpression | MemberExpression | ObjectExpression | SafeMemberExpression | TemplateLiteral | UnaryExpression | UpdateExpression;
 
 /**
@@ -455,9 +435,7 @@ declare type Expression = ArrayExpression | AssignmentExpression | BinaryExpress
  * Example: a = 1;
  */
 declare interface ExpressionStatement extends NodeBase<typeof NodeTypes.ExpressionStatement> {
-    /**
-     * The expression of the statement.
-     */
+    /** The expression of the statement. */
     expression: Expression;
 }
 
@@ -472,17 +450,11 @@ declare interface ExpressionStatement extends NodeBase<typeof NodeTypes.Expressi
  * ```
  */
 declare interface ForInStatement extends NodeBase<typeof NodeTypes.ForInStatement> {
-    /**
-     * The left: `var i`.
-     */
+    /** The left: `var i`. */
     left: Identifier | VariableDeclaration;
-    /**
-     * The right: `arr`.
-     */
+    /** The right: `arr`. */
     right: Expression;
-    /**
-     * The body: `Console(arr[i])`.
-     */
+    /** The body: `Console(arr[i])`. */
     body: Statement;
 }
 
@@ -530,17 +502,11 @@ declare interface FormattingOptions {
  * ```
  */
 declare interface ForOfStatement extends NodeBase<typeof NodeTypes.ForOfStatement> {
-    /**
-     * The left side: `var v`.
-     */
+    /** The left side: `var v`. */
     left: Identifier | VariableDeclaration;
-    /**
-     * The right side: `arr`.
-     */
+    /** The right side: `arr`. */
     right: Expression;
-    /**
-     * The body: `Console(v)`.
-     */
+    /** The body: `Console(v)`. */
     body: Statement;
 }
 
@@ -567,15 +533,11 @@ declare interface ForStatement extends NodeBase<typeof NodeTypes.ForStatement> {
      * The update is i++.
      */
     update: Expression | null;
-    /**
-     * The body of the for statement.
-     */
+    /** The body of the for statement. */
     body: Statement;
 }
 
-/**
- * Define an Arcade function declaration.
- */
+/** Define an Arcade function declaration. */
 declare interface FunctionDeclaration extends NodeBase<typeof NodeTypes.FunctionDeclaration> {
     /**
      * The identifier of the function.
@@ -672,166 +634,232 @@ declare interface ImportDefaultSpecifier extends NodeBase<typeof NodeTypes.Impor
 
 /**
  * Test if the item is an Arcade ArrayExpression.
+ *
+ * @param item
  */
 declare function isArrayExpression(item: unknown): item is ArrayExpression;
 
 /**
  * Test if the item is an Arcade AssignmentExpression.
+ *
+ * @param item
  */
 declare function isAssignmentExpression(item: unknown): item is AssignmentExpression;
 
 /**
  * Test if the item is an Arcade BinaryExpression.
+ *
+ * @param item
  */
 declare function isBinaryExpression(item: unknown): item is BinaryExpression;
 
 /**
  * Test if the item is an Arcade BlockComment.
+ *
+ * @param item
  */
 declare function isBlockComment(item: unknown): item is BlockComment;
 
 /**
  * Test if the item is an Arcade BlockStatement.
+ *
+ * @param item
  */
 declare function isBlockStatement(item: unknown): item is BlockStatement;
 
 /**
  * Test if the item is an Arcade BreakStatement.
+ *
+ * @param item
  */
 declare function isBreakStatement(item: unknown): item is BreakStatement;
 
 /**
  * Test if the item is an Arcade CallExpression.
+ *
+ * @param item
  */
 declare function isCallExpression(item: unknown): item is CallExpression;
 
 /**
  * Test if the item is an Arcade ContinueStatement.
+ *
+ * @param item
  */
 declare function isContinueStatement(item: unknown): item is ContinueStatement;
 
 /**
  * Test if the item is an Arcade EmptyStatement.
+ *
+ * @param item
  */
 declare function isEmptyStatement(item: unknown): item is EmptyStatement;
 
 /**
  * Test if the item is an Arcade Expression.
+ *
+ * @param item
  */
 declare function isExpression(item: unknown): item is Expression;
 
 /**
  * Test if the item is an Arcade ExpressionStatement.
+ *
+ * @param item
  */
 declare function isExpressionStatement(item: unknown): item is ExpressionStatement;
 
 /**
  * Test if the item is an Arcade ForInStatement.
+ *
+ * @param item
  */
 declare function isForInStatement(item: unknown): item is ForInStatement;
 
 /**
  * Test if the item is an Arcade ForOfStatement.
+ *
+ * @param item
  */
 declare function isForOfStatement(item: unknown): item is ForOfStatement;
 
 /**
  * Test if the item is an Arcade ForStatement.
+ *
+ * @param item
  */
 declare function isForStatement(item: unknown): item is ForStatement;
 
 /**
  * Test if the item is an Arcade FunctionDeclaration.
+ *
+ * @param item
  */
 declare function isFunctionDeclaration(item: unknown): item is FunctionDeclaration;
 
 /**
  * Test if the item is an Arcade Identifier.
+ *
+ * @param item
  */
 declare function isIdentifier(item: unknown): item is Identifier;
 
 /**
  * Test if the item is an Arcade IfStatement.
+ *
+ * @param item
  */
 declare function isIfStatement(item: unknown): item is IfStatement;
 
 /**
  * Test if the item is an Arcade Literal.
+ *
+ * @param item
  */
 declare function isLiteral(item: unknown): item is Literal;
 
 /**
  * Test if the item is an Arcade LogicalExpression.
+ *
+ * @param item
  */
 declare function isLogicalExpression(item: unknown): item is LogicalExpression;
 
 /**
  * Test if the item is an Arcade MemberAccessChainExpression.
+ *
+ * @param item
  */
 declare function isMemberAccessChainExpression(item: unknown): item is MemberAccessChainExpression;
 
 /**
  * Test if the item is an Arcade MemberExpression.
+ *
+ * @param item
  */
 declare function isMemberExpression(item: unknown): item is MemberExpression;
 
 /**
  * Test if the item is an Arcade ObjectExpression.
+ *
+ * @param item
  */
 declare function isObjectExpression(item: unknown): item is ObjectExpression;
 
 /**
  * Test if the item is an Arcade Program.
+ *
+ * @param item
  */
 declare function isProgram(item: unknown): item is Program;
 
 /**
  * Test if the item is an Arcade Property.
+ *
+ * @param item
  */
 declare function isProperty(item: unknown): item is Property;
 
 /**
  * Test if the item is an Arcade ReturnStatement.
+ *
+ * @param item
  */
 declare function isReturnStatement(item: unknown): item is ReturnStatement;
 
 /**
  * Test if the item is an Arcade SafeMemberExpression.
+ *
+ * @param item
  */
 declare function isSafeMemberExpression(item: unknown): item is SafeMemberExpression;
 
 /**
  * Test if the item is an Arcade Statement.
+ *
+ * @param item
  */
 declare function isStatement(item: unknown): item is Statement;
 
 /**
  * Test if the item is an Arcade TemplateElement.
+ *
+ * @param item
  */
 declare function isTemplateElement(item: unknown): item is TemplateElement;
 
 /**
  * Test if the item is an Arcade TemplateLiteral.
+ *
+ * @param item
  */
 declare function isTemplateLiteral(item: unknown): item is TemplateLiteral;
 
 /**
  * Test if the item is an Arcade UnaryExpression.
+ *
+ * @param item
  */
 declare function isUnaryExpression(item: unknown): item is UnaryExpression;
 
 /**
  * Test if the item is an Arcade UpdateExpression.
+ *
+ * @param item
  */
 declare function isUpdateExpression(item: unknown): item is UpdateExpression;
 
 /**
  * Test if the item is an Arcade VariableDeclaration.
+ *
+ * @param item
  */
 declare function isVariableDeclaration(item: unknown): item is VariableDeclaration;
 
 /**
  * Test if the item is an Arcade VariableDeclarator.
+ *
+ * @param item
  */
 declare function isVariableDeclarator(item: unknown): item is VariableDeclarator;
 
@@ -841,9 +869,7 @@ declare function isVariableDeclarator(item: unknown): item is VariableDeclarator
  * The location is 1-based line number and 0-based column number.
  */
 declare interface ItemLocation {
-    /**
-     * The location of the item in the source code as start and end positions.
-     */
+    /** The location of the item in the source code as start and end positions. */
     loc: SourceLocation;
     /**
      * The range of the item in the source code as start and end indexes.
@@ -852,9 +878,7 @@ declare interface ItemLocation {
     range: [number, number];
 }
 
-/**
- * Arcade keywords.
- */
+/** Arcade keywords. */
 declare const Keywords: {
     readonly Break: "break";
     readonly Continue: "continue";
@@ -870,19 +894,13 @@ declare const Keywords: {
     readonly While: "while";
 };
 
-/**
- * Arcade keywords.
- */
+/** Arcade keywords. */
 declare type Keywords = (typeof Keywords)[keyof typeof Keywords];
 
-/**
- * Define a line comment.
- */
+/** Define a line comment. */
 declare interface LineComment extends ItemLocation {
     readonly type: typeof NodeTypes.LineComment;
-    /**
-     * The value of the comment.
-     */
+    /** The value of the comment. */
     value: string;
 }
 
@@ -892,9 +910,7 @@ declare interface LineComment extends ItemLocation {
  * The value is 1 or "foo".
  */
 declare interface Literal extends NodeBase<typeof NodeTypes.Literal> {
-    /**
-     * Indicate if the literal is a string.
-     */
+    /** Indicate if the literal is a string. */
     isString: boolean;
     /**
      * The value of the literal.
@@ -910,18 +926,14 @@ declare interface Literal extends NodeBase<typeof NodeTypes.Literal> {
     raw: string;
 }
 
-/**
- * Arcade literals.
- */
+/** Arcade literals. */
 declare const Literals: {
     readonly False: "false";
     readonly Null: "null";
     readonly True: "true";
 };
 
-/**
- * Arcade literals.
- */
+/** Arcade literals. */
 declare type Literals = (typeof Literals)[keyof typeof Literals];
 
 /**
@@ -951,23 +963,18 @@ declare interface LogicalExpression extends NodeBase<typeof NodeTypes.LogicalExp
     right: Expression;
 }
 
-/**
- * Arcade logical operators.
- */
-declare const LogicalOperators: readonly ["||", "&&"];
+/** Arcade logical operators. */
+declare const LogicalOperators: readonly [
+"||",
+"&&"
+];
 
-/**
- * Arcade logical operators.
- */
+/** Arcade logical operators. */
 declare type LogicalOperators = (typeof LogicalOperators)[number];
 
-/**
- * Describe the location of a character in the source code.
- */
+/** Describe the location of a character in the source code. */
 declare interface Marker extends Position {
-    /**
-     * The zero based index of the character where the marker begins in the source code.
-     */
+    /** The zero based index of the character where the marker begins in the source code. */
     index: number;
 }
 
@@ -986,29 +993,20 @@ declare interface MemberAccessChainExpression extends NodeBase<typeof NodeTypes.
  */
 declare type MemberExpression = ComputedMemberExpression | NonComputedMemberExpression;
 
-/**
- * Define the types of Arcade AST Node (excluding comments).
- */
+/** Define the types of Arcade AST Node (excluding comments). */
 declare type Node_2 = Expression | ImportDefaultSpecifier | Program | Property | Statement | TemplateElement | VariableDeclarator;
 
-/**
- * Define the base properties of any Arcade AST Node.
- */
+/** Define the base properties of any Arcade AST Node. */
 declare interface NodeBase<T extends NodeTypes> extends ItemLocation {
-    /**
-     * The type of the node.
-     */
+    /** The type of the node. */
     type: T;
-    /**
-     * The leading comments of the node.
-     */
+    /** The leading comments of the node. */
     leadingComments?: Comment_2[];
-    /**
-     * The trailing comments of the node.
-     */
+    /** The trailing comments of the node. */
     trailingComments?: Comment_2[];
 }
 
+/** Arcade AST Node Types. */
 declare const NodeTypes: {
     readonly AssignmentExpression: "AssignmentExpression";
     readonly ArrayExpression: "ArrayExpression";
@@ -1049,9 +1047,7 @@ declare const NodeTypes: {
     readonly WhileStatement: "WhileStatement";
 };
 
-/**
- * Arcade AST Node Types.
- */
+/** Arcade AST Node Types. */
 declare type NodeTypes = (typeof NodeTypes)[keyof typeof NodeTypes];
 
 /**
@@ -1079,15 +1075,11 @@ declare interface NonComputedMemberExpression extends NodeBase<typeof NodeTypes.
  * Example: { foo: 1, bar: 2 }
  */
 declare interface ObjectExpression extends NodeBase<typeof NodeTypes.ObjectExpression> {
-    /**
-     * The collection of properties of the object expression.
-     */
+    /** The collection of properties of the object expression. */
     properties: Property[];
 }
 
-/**
- * Arcade operators precedence.
- */
+/** Arcade operators precedence. */
 declare const OperatorPrecedence: {
     readonly "||": 1;
     readonly "&&": 2;
@@ -1110,11 +1102,14 @@ declare const OperatorPrecedence: {
     readonly "%": 10;
 };
 
-declare function parse(code: string, options?: ParseOptions, delegate?: Delegate): Program;
-
 /**
- * Define the options for the parser.
+ * @param code
+ * @param options
+ * @param delegate
  */
+declare function parse(code: string, options?: ParseOptions, delegate?: Delegate): Program;
+
+/** Define the options for the parser. */
 declare interface ParseOptions {
     tolerant?: boolean;
     tokens?: boolean;
@@ -1219,6 +1214,9 @@ declare namespace Parser {
         Literal,
         LogicalExpression,
         ComputedMemberExpression,
+        SafeComputedMemberExpression,
+        NonComputedMemberExpression,
+        SafeNonComputedMemberExpression,
         MemberExpression,
         SafeMemberExpression,
         MemberAccessChainExpression,
@@ -1226,51 +1224,34 @@ declare namespace Parser {
         Property,
         TemplateLiteral,
         TemplateElement,
+        TemplateElementValue,
         UnaryExpression,
         UpdateExpression,
         convertProgramToJSON
     }
 }
 
-/**
- * Describe a position in the source code as 1-based line number and 0-based column number.
- */
+/** Describe a position in the source code as 1-based line number and 0-based column number. */
 declare interface Position {
-    /**
-     * The 1-based line number.
-     */
+    /** The 1-based line number. */
     line: number;
-    /**
-     * The 0-based column number.
-     */
+    /** The 0-based column number. */
     column: number;
 }
 
-/**
- * Define an Arcade program.
- */
+/** Define an Arcade program. */
 declare interface Program extends NodeBase<typeof NodeTypes.Program> {
-    /**
-     * The collection of statements in the program.
-     */
+    /** The collection of statements in the program. */
     body: Statement[];
-    /**
-     * The collection of comments inside the program.
-     */
+    /** The collection of comments inside the program. */
     comments?: Comment_2[];
-    /**
-     * The collection of tokens inside the program.
-     */
+    /** The collection of tokens inside the program. */
     tokens?: Token[];
-    /**
-     * The collection of errors inside the program.
-     */
+    /** The collection of errors inside the program. */
     errors?: Error[];
 }
 
-/**
- * Define an Arcade object property.
- */
+/** Define an Arcade object property. */
 declare interface Property extends NodeBase<typeof NodeTypes.Property> {
     kind: "init";
     /**
@@ -1298,13 +1279,11 @@ declare interface Property extends NodeBase<typeof NodeTypes.Property> {
  * Example: return 1;
  */
 declare interface ReturnStatement extends NodeBase<typeof NodeTypes.ReturnStatement> {
-    /**
-     * The argument of the return statement.
-     */
+    /** The argument of the return statement. */
     argument: Expression | null;
 }
 
-declare const SafeAccessOperator = "?.";
+declare const SafeAccessOperator: "?.";
 
 declare type SafeAccessOperator = typeof SafeAccessOperator;
 
@@ -1360,24 +1339,16 @@ declare interface SafeNonComputedMemberExpression extends NodeBase<typeof NodeTy
  * Positions are 1-based line number and 0-based column number.
  */
 declare interface SourceLocation {
-    /**
-     * The position of the first character of the parsed source region (inclusive).
-     */
+    /** The position of the first character of the parsed source region (inclusive). */
     start: Position;
-    /**
-     * The position of the first character after the parsed source region (exclusive).
-     */
+    /** The position of the first character after the parsed source region (exclusive). */
     end: Position;
 }
 
-/**
- * Define the types of Arcade Statement.
- */
+/** Define the types of Arcade Statement. */
 declare type Statement = BlockStatement | BreakStatement | ContinueStatement | Declaration | EmptyStatement | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | ReturnStatement | WhileStatement;
 
-/**
- * Define an Arcade template element.
- */
+/** Define an Arcade template element. */
 declare interface TemplateElement extends NodeBase<typeof NodeTypes.TemplateElement> {
     /**
      * The value of the template element.
@@ -1394,17 +1365,11 @@ declare interface TemplateElement extends NodeBase<typeof NodeTypes.TemplateElem
     tail?: boolean;
 }
 
-/**
- * Define an Arcade template element value.
- */
+/** Define an Arcade template element value. */
 declare interface TemplateElementValue {
-    /**
-     * The cooked value of the template element.
-     */
+    /** The cooked value of the template element. */
     cooked?: string;
-    /**
-     * The raw value of the template element.
-     */
+    /** The raw value of the template element. */
     raw: string;
 }
 
@@ -1427,28 +1392,25 @@ declare interface TemplateLiteral extends NodeBase<typeof NodeTypes.TemplateLite
     expressions: Expression[];
 }
 
-/**
- * Define a token returned by the scanner.
- */
+/** Define a token returned by the scanner. */
 declare interface Token extends ItemLocation {
-    /**
-     * The type of the token found.
-     */
+    /** The type of the token found. */
     type: TokenNames | typeof NodeTypes.BlockComment | typeof NodeTypes.LineComment;
-    /**
-     * The value of the token.
-     */
+    /** The value of the token. */
     value: string;
 }
 
+/**
+ * @param code
+ * @param options
+ * @param delegate
+ */
 declare function tokenize(code: string, options?: TokenizeOptions, delegate?: (entry: Token) => Token): {
     tokens: Token[];
     errors?: Error[];
 };
 
-/**
- * Define the options for the scanner.
- */
+/** Define the options for the scanner. */
 declare interface TokenizeOptions {
     tolerant?: boolean;
     range?: boolean;
@@ -1456,19 +1418,25 @@ declare interface TokenizeOptions {
     comment?: boolean;
 }
 
-/**
- * Arcade scanner token names.
- */
-declare const TokenNames: readonly ["Unknown", "Boolean", "<end>", "Identifier", "Keyword", "Null", "Numeric", "Punctuator", "String", "RegularExpression", "Template"];
-
-/**
- * Arcade scanner token names.
- */
+/** Arcade scanner token names. */
+declare const TokenNames: readonly [
+"Unknown",
+"Boolean",
+"<end>",
+"Identifier",
+"Keyword",
+"Null",
+"Numeric",
+"Punctuator",
+"String",
+"RegularExpression",
+"Template"
+];
+
+/** Arcade scanner token names. */
 declare type TokenNames = (typeof TokenNames)[number];
 
-/**
- * Arcade scanner token types.
- */
+/** Arcade scanner token types. */
 declare const TokenTypes: {
     readonly Unknown: 0;
     readonly BooleanLiteral: 1;
@@ -1482,9 +1450,7 @@ declare const TokenTypes: {
     readonly Template: 10;
 };
 
-/**
- * Arcade scanner token types.
- */
+/** Arcade scanner token types. */
 declare type TokenTypes = (typeof TokenTypes)[keyof typeof TokenTypes];
 
 /**
@@ -1507,14 +1473,15 @@ declare interface UnaryExpression extends NodeBase<typeof NodeTypes.UnaryExpress
     argument: Expression;
 }
 
-/**
- * Arcade unary operators.
- */
-declare const UnaryOperators: readonly ["-", "+", "!", "~"];
+/** Arcade unary operators. */
+declare const UnaryOperators: readonly [
+"-",
+"+",
+"!",
+"~"
+];
 
-/**
- * Arcade unary operators.
- */
+/** Arcade unary operators. */
 declare type UnaryOperators = (typeof UnaryOperators)[number];
 
 /**
@@ -1542,14 +1509,13 @@ declare interface UpdateExpression extends NodeBase<typeof NodeTypes.UpdateExpre
     prefix: boolean;
 }
 
-/**
- * Arcade update operators.
- */
-declare const UpdateOperators: readonly ["++", "--"];
+/** Arcade update operators. */
+declare const UpdateOperators: readonly [
+"++",
+"--"
+];
 
-/**
- * Arcade update operators.
- */
+/** Arcade update operators. */
 declare type UpdateOperators = (typeof UpdateOperators)[number];
 
 export declare const ValidationDiagnosticCodes: {
@@ -1590,9 +1556,7 @@ declare interface VariableDeclaration extends NodeBase<typeof NodeTypes.Variable
      * The declarators are foo = 1 and bar = 2.
      */
     declarations: VariableDeclarator[];
-    /**
-     * The kind is always "var" for Arcade.
-     */
+    /** The kind is always "var" for Arcade. */
     kind: "var";
 }
 
@@ -1603,13 +1567,9 @@ declare interface VariableDeclaration extends NodeBase<typeof NodeTypes.Variable
  * The init is 1.
  */
 declare interface VariableDeclarator extends NodeBase<typeof NodeTypes.VariableDeclarator> {
-    /**
-     * The identifier of the variable declarator.
-     */
+    /** The identifier of the variable declarator. */
     id: Identifier;
-    /**
-     * The init of the variable declarator.
-     */
+    /** The init of the variable declarator. */
     init: Expression | null;
 }
 
@@ -1624,9 +1584,7 @@ declare interface WhileStatement extends NodeBase<typeof NodeTypes.WhileStatemen
      * The test is a < 10.
      */
     test: Exclude<Expression, AssignmentExpression | UpdateExpression>;
-    /**
-     * The body of the while statement.
-     */
+    /** The body of the while statement. */
     body: Statement;
 }
 

package/dist/index.js

@@ -178,6 +178,10 @@ const V = {
   [h.UnexpectedToken]: "Unexpected token '${value}'."
 };
 class z extends Error {
+  /**
+   * @public
+   * @param diagnosticApi
+   */
   constructor({ code: e, index: t, line: i, column: r, len: s = 0, description: a, data: o }) {
     super(a ?? e), this.declaredRootClass = "esri.arcade.lib.diagnostic", this.name = "ParsingError", this.code = e, this.index = t, this.line = i, this.column = r, this.len = s, this.data = o, this.description = a, this.range = {
       start: { line: i, column: r - 1 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/arcade-languageservice",
-  "version": "5.2.0-next.90",
+  "version": "5.2.0-next.93",
   "description": "Arcade Language Service",
   "homepage": "https://developers.arcgis.com/javascript/latest/",
   "type": "module",
@@ -12,7 +12,7 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/languages-api-utils": "5.2.0-next.90",
+    "@arcgis/languages-api-utils": "5.2.0-next.93",
     "tslib": "^2.8.1",
     "vscode-languageserver-textdocument": "^1.0.11",
     "vscode-languageserver-types": "^3.17.5"