@rightcapital/phpdoc-parser 0.3.3-feature-add-basic-ci.7.0 → 0.3.3-feature-add-basic-ci.8.0

package/dist/phpdoc-parser/ast/type/object-shape-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectShapeNode = void 0;
+const type_node_1 = require("./type-node");
+class ObjectShapeNode extends type_node_1.TypeNode {
+    constructor(items) {
+        super();
+        this.items = items;
+    }
+    toString() {
+        return `object{${this.items.join(', ')}`;
+    }
+    getNodeType() {
+        return 'ObjectShapeNode';
+    }
+}
+exports.ObjectShapeNode = ObjectShapeNode;

package/dist/phpdoc-parser/ast/type/offset-access-type-node.d.ts

@@ -0,0 +1,8 @@
+import { TypeNode } from './type-node';
+export declare class OffsetAccessTypeNode extends TypeNode {
+    type: TypeNode;
+    offset: TypeNode;
+    constructor(type: TypeNode, offset: TypeNode);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/offset-access-type-node.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffsetAccessTypeNode = void 0;
+const callable_type_node_1 = require("./callable-type-node");
+const const_type_node_1 = require("./const-type-node");
+const nullable_type_node_1 = require("./nullable-type-node");
+const type_node_1 = require("./type-node");
+class OffsetAccessTypeNode extends type_node_1.TypeNode {
+    constructor(type, offset) {
+        super();
+        this.type = type;
+        this.offset = offset;
+    }
+    toString() {
+        if (this.type instanceof callable_type_node_1.CallableTypeNode ||
+            this.type instanceof const_type_node_1.ConstTypeNode ||
+            this.type instanceof nullable_type_node_1.NullableTypeNode) {
+            return `(${this.type.toString()})[${this.offset.toString()}]`;
+        }
+        return `${this.type.toString()}[${this.offset.toString()}]`;
+    }
+    getNodeType() {
+        return 'OffsetAccessTypeNode';
+    }
+}
+exports.OffsetAccessTypeNode = OffsetAccessTypeNode;

package/dist/phpdoc-parser/ast/type/this-type-node.d.ts

@@ -0,0 +1,5 @@
+import { TypeNode } from './type-node';
+export declare class ThisTypeNode extends TypeNode {
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/this-type-node.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThisTypeNode = void 0;
+const type_node_1 = require("./type-node");
+class ThisTypeNode extends type_node_1.TypeNode {
+    toString() {
+        return '$this';
+    }
+    getNodeType() {
+        return 'ThisTypeNode';
+    }
+}
+exports.ThisTypeNode = ThisTypeNode;

package/dist/phpdoc-parser/ast/type/type-node.d.ts

@@ -0,0 +1,40 @@
+import type { ArrayShapeItemNode } from './array-shape-item-node';
+import type { ArrayShapeNode } from './array-shape-node';
+import type { ArrayTypeNode } from './array-type-node';
+import type { CallableTypeNode } from './callable-type-node';
+import type { CallableTypeParameterNode } from './callable-type-parameter-node';
+import type { ConditionalTypeForParameterNode } from './conditional-type-for-parameter-node';
+import type { ConditionalTypeNode } from './conditional-type-node';
+import type { ConstTypeNode } from './const-type-node';
+import type { GenericTypeNode } from './generic-type-node';
+import type { IdentifierTypeNode } from './identifier-type-node';
+import type { IntersectionTypeNode } from './intersection-type-node';
+import type { InvalidTypeNode } from './invalid-type-node';
+import type { NullableTypeNode } from './nullable-type-node';
+import type { ObjectShapeItemNode } from './object-shape-item-node';
+import type { ObjectShapeNode } from './object-shape-node';
+import type { OffsetAccessTypeNode } from './offset-access-type-node';
+import type { ThisTypeNode } from './this-type-node';
+import type { UnionTypeNode } from './union-type-node';
+import { BaseNode } from '../base-node';
+export declare class TypeNode extends BaseNode {
+    getNodeType(): string;
+    isArrayShapeItemNode(): this is ArrayShapeItemNode;
+    isArrayShapeNode(): this is ArrayShapeNode;
+    isArrayTypeNode(): this is ArrayTypeNode;
+    isCallableTypeNode(): this is CallableTypeNode;
+    isCallableTypeParameterNode(): this is CallableTypeParameterNode;
+    isConditionalTypeForParameterNode(): this is ConditionalTypeForParameterNode;
+    isConditionalTypeNode(): this is ConditionalTypeNode;
+    isConstTypeNode(): this is ConstTypeNode;
+    isGenericTypeNode(): this is GenericTypeNode;
+    isIdentifierTypeNode(): this is IdentifierTypeNode;
+    isIntersectionTypeNode(): this is IntersectionTypeNode;
+    isInvalidTypeNode(): this is InvalidTypeNode;
+    isNullableTypeNode(): this is NullableTypeNode;
+    isObjectShapeItemNode(): this is ObjectShapeItemNode;
+    isObjectShapeNode(): this is ObjectShapeNode;
+    isOffsetAccessTypeNode(): this is OffsetAccessTypeNode;
+    isThisTypeNode(): this is ThisTypeNode;
+    isUnionTypeNode(): this is UnionTypeNode;
+}

package/dist/phpdoc-parser/ast/type/type-node.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeNode = void 0;
+const base_node_1 = require("../base-node");
+class TypeNode extends base_node_1.BaseNode {
+    getNodeType() {
+        return 'TypeNode';
+    }
+    isArrayShapeItemNode() {
+        return this.getNodeType() === 'ArrayShapeItemNode';
+    }
+    isArrayShapeNode() {
+        return this.getNodeType() === 'ArrayShapeNode';
+    }
+    isArrayTypeNode() {
+        return this.getNodeType() === 'ArrayTypeNode';
+    }
+    isCallableTypeNode() {
+        return this.getNodeType() === 'CallableTypeNode';
+    }
+    isCallableTypeParameterNode() {
+        return this.getNodeType() === 'CallableTypeParameterNode';
+    }
+    isConditionalTypeForParameterNode() {
+        return this.getNodeType() === 'ConditionalTypeForParameterNode';
+    }
+    isConditionalTypeNode() {
+        return this.getNodeType() === 'ConditionalTypeNode';
+    }
+    isConstTypeNode() {
+        return this.getNodeType() === 'ConstTypeNode';
+    }
+    isGenericTypeNode() {
+        return this.getNodeType() === 'GenericTypeNode';
+    }
+    isIdentifierTypeNode() {
+        return this.getNodeType() === 'IdentifierTypeNode';
+    }
+    isIntersectionTypeNode() {
+        return this.getNodeType() === 'IntersectionTypeNode';
+    }
+    isInvalidTypeNode() {
+        return this.getNodeType() === 'InvalidTypeNode';
+    }
+    isNullableTypeNode() {
+        return this.getNodeType() === 'NullableTypeNode';
+    }
+    isObjectShapeItemNode() {
+        return this.getNodeType() === 'ObjectShapeItemNode';
+    }
+    isObjectShapeNode() {
+        return this.getNodeType() === 'ObjectShapeNode';
+    }
+    isOffsetAccessTypeNode() {
+        return this.getNodeType() === 'OffsetAccessTypeNode';
+    }
+    isThisTypeNode() {
+        return this.getNodeType() === 'ThisTypeNode';
+    }
+    isUnionTypeNode() {
+        return this.getNodeType() === 'UnionTypeNode';
+    }
+}
+exports.TypeNode = TypeNode;

package/dist/phpdoc-parser/ast/type/union-type-node.d.ts

@@ -0,0 +1,7 @@
+import { TypeNode } from './type-node';
+export declare class UnionTypeNode extends TypeNode {
+    types: TypeNode[];
+    constructor(types: TypeNode[]);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/type/union-type-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionTypeNode = void 0;
+const nullable_type_node_1 = require("./nullable-type-node");
+const type_node_1 = require("./type-node");
+class UnionTypeNode extends type_node_1.TypeNode {
+    constructor(types) {
+        super();
+        this.types = types;
+    }
+    toString() {
+        return `(${this.types
+            .map((type) => {
+            if (type instanceof nullable_type_node_1.NullableTypeNode) {
+                return `(${type.toString()})`;
+            }
+            return type.toString();
+        })
+            .join(' | ')})`;
+    }
+    getNodeType() {
+        return 'UnionTypeNode';
+    }
+}
+exports.UnionTypeNode = UnionTypeNode;

package/dist/phpdoc-parser/ast/types.d.ts

@@ -0,0 +1,13 @@
+export declare const enum NodeTraverserState {
+    DONT_TRAVERSE_CHILDREN = 1,
+    STOP_TRAVERSAL = 2,
+    REMOVE_NODE = 3,
+    DONT_TRAVERSE_CURRENT_AND_CHILDREN = 4
+}
+export declare enum Attribute {
+    START_LINE = "startLine",
+    END_LINE = "endLine",
+    START_INDEX = "startIndex",
+    END_INDEX = "endIndex",
+    ORIGINAL_NODE = "originalNode"
+}

package/dist/phpdoc-parser/ast/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attribute = exports.NodeTraverserState = void 0;
+var NodeTraverserState;
+(function (NodeTraverserState) {
+    NodeTraverserState[NodeTraverserState["DONT_TRAVERSE_CHILDREN"] = 1] = "DONT_TRAVERSE_CHILDREN";
+    NodeTraverserState[NodeTraverserState["STOP_TRAVERSAL"] = 2] = "STOP_TRAVERSAL";
+    NodeTraverserState[NodeTraverserState["REMOVE_NODE"] = 3] = "REMOVE_NODE";
+    NodeTraverserState[NodeTraverserState["DONT_TRAVERSE_CURRENT_AND_CHILDREN"] = 4] = "DONT_TRAVERSE_CURRENT_AND_CHILDREN";
+})(NodeTraverserState || (exports.NodeTraverserState = NodeTraverserState = {}));
+var Attribute;
+(function (Attribute) {
+    Attribute["START_LINE"] = "startLine";
+    Attribute["END_LINE"] = "endLine";
+    Attribute["START_INDEX"] = "startIndex";
+    Attribute["END_INDEX"] = "endIndex";
+    Attribute["ORIGINAL_NODE"] = "originalNode";
+})(Attribute || (exports.Attribute = Attribute = {}));

package/dist/phpdoc-parser/lexer/lexer.d.ts

@@ -0,0 +1,46 @@
+export declare class Lexer {
+    static TOKEN_REFERENCE: string;
+    static TOKEN_UNION: string;
+    static TOKEN_INTERSECTION: string;
+    static TOKEN_NULLABLE: string;
+    static TOKEN_OPEN_PARENTHESES: string;
+    static TOKEN_CLOSE_PARENTHESES: string;
+    static TOKEN_OPEN_ANGLE_BRACKET: string;
+    static TOKEN_CLOSE_ANGLE_BRACKET: string;
+    static TOKEN_OPEN_SQUARE_BRACKET: string;
+    static TOKEN_CLOSE_SQUARE_BRACKET: string;
+    static TOKEN_COMMA: string;
+    static TOKEN_VARIADIC: string;
+    static TOKEN_DOUBLE_COLON: string;
+    static TOKEN_DOUBLE_ARROW: string;
+    static TOKEN_EQUAL: string;
+    static TOKEN_OPEN_PHPDOC: string;
+    static TOKEN_CLOSE_PHPDOC: string;
+    static TOKEN_PHPDOC_TAG: string;
+    static TOKEN_FLOAT: string;
+    static TOKEN_INTEGER: string;
+    static TOKEN_SINGLE_QUOTED_STRING: string;
+    static TOKEN_DOUBLE_QUOTED_STRING: string;
+    static TOKEN_IDENTIFIER: string;
+    static TOKEN_THIS_VARIABLE: string;
+    static TOKEN_VARIABLE: string;
+    static TOKEN_HORIZONTAL_WS: string;
+    static TOKEN_PHPDOC_EOL: string;
+    static TOKEN_OTHER: string;
+    static TOKEN_END: string;
+    static TOKEN_COLON: string;
+    static TOKEN_WILDCARD: string;
+    static TOKEN_OPEN_CURLY_BRACKET: string;
+    static TOKEN_CLOSE_CURLY_BRACKET: string;
+    static TOKEN_NEGATED: string;
+    static TOKEN_ARROW: string;
+    static TOKEN_LABELS: {
+        [x: string]: string;
+    };
+    static VALUE_OFFSET: 0;
+    static TYPE_OFFSET: 1;
+    static LINE_OFFSET: 2;
+    private regexp;
+    tokenize(source: string): Array<[string, string, number]>;
+    private generateRegexp;
+}

package/dist/phpdoc-parser/lexer/lexer.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lexer = void 0;
+class Lexer {
+    constructor() {
+        this.regexp = this.generateRegexp();
+    }
+    tokenize(source) {
+        const matchArray = source.matchAll(this.regexp);
+        const tokens = [];
+        let line = 1;
+        for (const match of matchArray) {
+            const type = Object.entries(match.groups).filter(([_, value]) => typeof value !== 'undefined')[0][0];
+            tokens.push([match[0], type, line]);
+            if (type !== Lexer.TOKEN_PHPDOC_EOL) {
+                continue;
+            }
+            line++;
+        }
+        tokens.push(['', Lexer.TOKEN_END, line]);
+        return tokens;
+    }
+    generateRegexp() {
+        const patterns = {
+            [Lexer.TOKEN_HORIZONTAL_WS]: '[\\x09\\x20]+',
+            [Lexer.TOKEN_IDENTIFIER]: '(?:[\\\\]?[a-z_\\x80-\\xFF][0-9a-z_\\x80-\\xFF-]*)+',
+            [Lexer.TOKEN_THIS_VARIABLE]: '\\$this(?![0-9a-z_\\x80-\\xFF])',
+            [Lexer.TOKEN_VARIABLE]: '\\$[a-z_\\x80-\\xFF][0-9a-z_\\x80-\\xFF]*',
+            [Lexer.TOKEN_REFERENCE]: '&(?=\\s*(?:[.,=)]|(?:\\$(?!this(?![0-9a-z_\\x80-\\xFF])))))',
+            [Lexer.TOKEN_UNION]: '\\|',
+            [Lexer.TOKEN_INTERSECTION]: '&',
+            [Lexer.TOKEN_NULLABLE]: '\\?',
+            [Lexer.TOKEN_NEGATED]: '!',
+            [Lexer.TOKEN_OPEN_PARENTHESES]: '\\(',
+            [Lexer.TOKEN_CLOSE_PARENTHESES]: '\\)',
+            [Lexer.TOKEN_OPEN_ANGLE_BRACKET]: '<',
+            [Lexer.TOKEN_CLOSE_ANGLE_BRACKET]: '>',
+            [Lexer.TOKEN_OPEN_SQUARE_BRACKET]: '\\[',
+            [Lexer.TOKEN_CLOSE_SQUARE_BRACKET]: '\\]',
+            [Lexer.TOKEN_OPEN_CURLY_BRACKET]: '\\{',
+            [Lexer.TOKEN_CLOSE_CURLY_BRACKET]: '\\}',
+            [Lexer.TOKEN_COMMA]: ',',
+            [Lexer.TOKEN_VARIADIC]: '\\.\\.\\.',
+            [Lexer.TOKEN_DOUBLE_COLON]: '::',
+            [Lexer.TOKEN_DOUBLE_ARROW]: '=>',
+            [Lexer.TOKEN_ARROW]: '->',
+            [Lexer.TOKEN_EQUAL]: '=',
+            [Lexer.TOKEN_COLON]: ':',
+            [Lexer.TOKEN_OPEN_PHPDOC]: '\\/\\*\\*(?=\\s)\\x20?',
+            [Lexer.TOKEN_CLOSE_PHPDOC]: '\\*\\/',
+            [Lexer.TOKEN_PHPDOC_TAG]: '@(?:[a-z][a-z0-9-\\\\]+:)?[a-z][a-z0-9-\\\\]*',
+            [Lexer.TOKEN_PHPDOC_EOL]: '\\r?\\n[\\x09\\x20]*(?:\\*(?!\\/)\\x20?)?',
+            [Lexer.TOKEN_FLOAT]: '[+-]?(?:(?:[0-9]+(_[0-9]+)*\\.[0-9]*(_[0-9]+)*(?:e[+-]?[0-9]+(_[0-9]+)*)?)|(?:[0-9]*(_[0-9]+)*\\.[0-9]+(_[0-9]+)*(?:e[+-]?[0-9]+(_[0-9]+)*)?)|(?:[0-9]+(_[0-9]+)*e[+-]?[0-9]+(_[0-9]+)*))',
+            [Lexer.TOKEN_INTEGER]: '[+-]?(?:(?:0b[0-1]+(_[0-1]+)*)|(?:0o[0-7]+(_[0-7]+)*)|(?:0x[0-9a-f]+(_[0-9a-f]+)*)|(?:[0-9]+(_[0-9]+)*))',
+            [Lexer.TOKEN_SINGLE_QUOTED_STRING]: "'(?:\\\\[^\\r\\n]|[^'\\r\\n\\\\])*'",
+            [Lexer.TOKEN_DOUBLE_QUOTED_STRING]: '"(?:\\\\[^\\r\\n]|[^"\\r\\n\\\\])*"',
+            [Lexer.TOKEN_WILDCARD]: '\\*',
+        };
+        patterns[Lexer.TOKEN_OTHER] = '(?:(?!\\*\\/)[^\\s])+';
+        const combinedRegExp = Object.entries(patterns)
+            .map(([key, pattern]) => {
+            return `(?<${key}>${pattern})`;
+        })
+            .join('|');
+        return new RegExp(combinedRegExp, 'sig');
+    }
+}
+exports.Lexer = Lexer;
+Lexer.TOKEN_REFERENCE = 'TOKEN_REFERENCE';
+Lexer.TOKEN_UNION = 'TOKEN_UNION';
+Lexer.TOKEN_INTERSECTION = 'TOKEN_INTERSECTION';
+Lexer.TOKEN_NULLABLE = 'TOKEN_NULLABLE';
+Lexer.TOKEN_OPEN_PARENTHESES = 'TOKEN_OPEN_PARENTHESES';
+Lexer.TOKEN_CLOSE_PARENTHESES = 'TOKEN_CLOSE_PARENTHESES';
+Lexer.TOKEN_OPEN_ANGLE_BRACKET = 'TOKEN_OPEN_ANGLE_BRACKET';
+Lexer.TOKEN_CLOSE_ANGLE_BRACKET = 'TOKEN_CLOSE_ANGLE_BRACKET';
+Lexer.TOKEN_OPEN_SQUARE_BRACKET = 'TOKEN_OPEN_SQUARE_BRACKET';
+Lexer.TOKEN_CLOSE_SQUARE_BRACKET = 'TOKEN_CLOSE_SQUARE_BRACKET';
+Lexer.TOKEN_COMMA = 'TOKEN_COMMA';
+Lexer.TOKEN_VARIADIC = 'TOKEN_VARIADIC';
+Lexer.TOKEN_DOUBLE_COLON = 'TOKEN_DOUBLE_COLON';
+Lexer.TOKEN_DOUBLE_ARROW = 'TOKEN_DOUBLE_ARROW';
+Lexer.TOKEN_EQUAL = 'TOKEN_EQUAL';
+Lexer.TOKEN_OPEN_PHPDOC = 'TOKEN_OPEN_PHPDOC';
+Lexer.TOKEN_CLOSE_PHPDOC = 'TOKEN_CLOSE_PHPDOC';
+Lexer.TOKEN_PHPDOC_TAG = 'TOKEN_PHPDOC_TAG';
+Lexer.TOKEN_FLOAT = 'TOKEN_FLOAT';
+Lexer.TOKEN_INTEGER = 'TOKEN_INTEGER';
+Lexer.TOKEN_SINGLE_QUOTED_STRING = 'TOKEN_SINGLE_QUOTED_STRING';
+Lexer.TOKEN_DOUBLE_QUOTED_STRING = 'TOKEN_DOUBLE_QUOTED_STRING';
+Lexer.TOKEN_IDENTIFIER = 'TOKEN_IDENTIFIER';
+Lexer.TOKEN_THIS_VARIABLE = 'TOKEN_THIS_VARIABLE';
+Lexer.TOKEN_VARIABLE = 'TOKEN_VARIABLE';
+Lexer.TOKEN_HORIZONTAL_WS = 'TOKEN_HORIZONTAL_WS';
+Lexer.TOKEN_PHPDOC_EOL = 'TOKEN_PHPDOC_EOL';
+Lexer.TOKEN_OTHER = 'TOKEN_OTHER';
+Lexer.TOKEN_END = 'TOKEN_END';
+Lexer.TOKEN_COLON = 'TOKEN_COLON';
+Lexer.TOKEN_WILDCARD = 'TOKEN_WILDCARD';
+Lexer.TOKEN_OPEN_CURLY_BRACKET = 'TOKEN_OPEN_CURLY_BRACKET';
+Lexer.TOKEN_CLOSE_CURLY_BRACKET = 'TOKEN_CLOSE_CURLY_BRACKET';
+Lexer.TOKEN_NEGATED = 'TOKEN_NEGATED';
+Lexer.TOKEN_ARROW = 'TOKEN_ARROW';
+Lexer.TOKEN_LABELS = {
+    [Lexer.TOKEN_REFERENCE]: '&',
+    [Lexer.TOKEN_UNION]: '|',
+    [Lexer.TOKEN_INTERSECTION]: '&',
+    [Lexer.TOKEN_NULLABLE]: '?',
+    [Lexer.TOKEN_NEGATED]: '!',
+    [Lexer.TOKEN_OPEN_PARENTHESES]: '(',
+    [Lexer.TOKEN_CLOSE_PARENTHESES]: ')',
+    [Lexer.TOKEN_OPEN_ANGLE_BRACKET]: '<',
+    [Lexer.TOKEN_CLOSE_ANGLE_BRACKET]: '>',
+    [Lexer.TOKEN_OPEN_SQUARE_BRACKET]: '[',
+    [Lexer.TOKEN_CLOSE_SQUARE_BRACKET]: ']',
+    [Lexer.TOKEN_OPEN_CURLY_BRACKET]: '{',
+    [Lexer.TOKEN_CLOSE_CURLY_BRACKET]: '}',
+    [Lexer.TOKEN_COMMA]: ',',
+    [Lexer.TOKEN_COLON]: ':',
+    [Lexer.TOKEN_VARIADIC]: '...',
+    [Lexer.TOKEN_DOUBLE_COLON]: '::',
+    [Lexer.TOKEN_DOUBLE_ARROW]: '=>',
+    [Lexer.TOKEN_ARROW]: '->',
+    [Lexer.TOKEN_EQUAL]: '=',
+    [Lexer.TOKEN_OPEN_PHPDOC]: '/**',
+    [Lexer.TOKEN_CLOSE_PHPDOC]: '*/',
+    [Lexer.TOKEN_PHPDOC_TAG]: 'TOKEN_PHPDOC_TAG',
+    [Lexer.TOKEN_PHPDOC_EOL]: 'TOKEN_PHPDOC_EOL',
+    [Lexer.TOKEN_FLOAT]: 'TOKEN_FLOAT',
+    [Lexer.TOKEN_INTEGER]: 'TOKEN_INTEGER',
+    [Lexer.TOKEN_SINGLE_QUOTED_STRING]: 'TOKEN_SINGLE_QUOTED_STRING',
+    [Lexer.TOKEN_DOUBLE_QUOTED_STRING]: 'TOKEN_DOUBLE_QUOTED_STRING',
+    [Lexer.TOKEN_IDENTIFIER]: 'type',
+    [Lexer.TOKEN_THIS_VARIABLE]: '$this',
+    [Lexer.TOKEN_VARIABLE]: 'variable',
+    [Lexer.TOKEN_HORIZONTAL_WS]: 'TOKEN_HORIZONTAL_WS',
+    [Lexer.TOKEN_OTHER]: 'TOKEN_OTHER',
+    [Lexer.TOKEN_END]: 'TOKEN_END',
+    [Lexer.TOKEN_WILDCARD]: '*',
+};
+Lexer.VALUE_OFFSET = 0;
+Lexer.TYPE_OFFSET = 1;
+Lexer.LINE_OFFSET = 2;

package/dist/phpdoc-parser/parser/const-expr-parser.d.ts

@@ -0,0 +1,16 @@
+import { TokenIterator } from './token-iterator';
+import { ConstExprNode } from '../ast/const-expr/const-expr-node';
+export declare class ConstExprParser {
+    private unescapeStrings;
+    private quoteAwareConstExprString;
+    private useLinesAttributes;
+    private useIndexAttributes;
+    constructor(unescapeStrings?: boolean, quoteAwareConstExprString?: boolean, usedAttributes?: {
+        lines?: boolean;
+        indexes?: boolean;
+    });
+    parse(tokens: TokenIterator, trimStrings?: boolean): ConstExprNode;
+    private parseArray;
+    private parseArrayItem;
+    private enrichWithAttributes;
+}

package/dist/phpdoc-parser/parser/const-expr-parser.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprParser = void 0;
+const parser_exception_1 = require("./parser-exception");
+const string_unescaper_1 = require("./string-unescaper");
+const const_expr_array_item_node_1 = require("../ast/const-expr/const-expr-array-item-node");
+const const_expr_array_node_1 = require("../ast/const-expr/const-expr-array-node");
+const const_expr_false_node_1 = require("../ast/const-expr/const-expr-false-node");
+const const_expr_float_node_1 = require("../ast/const-expr/const-expr-float-node");
+const const_expr_integer_node_1 = require("../ast/const-expr/const-expr-integer-node");
+const const_expr_null_node_1 = require("../ast/const-expr/const-expr-null-node");
+const const_expr_string_node_1 = require("../ast/const-expr/const-expr-string-node");
+const const_expr_true_node_1 = require("../ast/const-expr/const-expr-true-node");
+const const_fetch_node_1 = require("../ast/const-expr/const-fetch-node");
+const quote_aware_const_expr_string_node_1 = require("../ast/const-expr/quote-aware-const-expr-string-node");
+const types_1 = require("../ast/types");
+const lexer_1 = require("../lexer/lexer");
+class ConstExprParser {
+    constructor(unescapeStrings = false, quoteAwareConstExprString = false, usedAttributes = {}) {
+        var _a, _b;
+        this.unescapeStrings = unescapeStrings;
+        this.quoteAwareConstExprString = quoteAwareConstExprString;
+        this.useLinesAttributes = (_a = usedAttributes.lines) !== null && _a !== void 0 ? _a : false;
+        this.useIndexAttributes = (_b = usedAttributes.indexes) !== null && _b !== void 0 ? _b : false;
+    }
+    parse(tokens, trimStrings = false) {
+        const startLine = tokens.currentTokenLine();
+        const startIndex = tokens.currentTokenIndex();
+        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_FLOAT)) {
+            const value = tokens.currentTokenValue();
+            tokens.next();
+            return this.enrichWithAttributes(tokens, new const_expr_float_node_1.ConstExprFloatNode(value.replaceAll('_', '')), startLine, startIndex);
+        }
+        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_INTEGER)) {
+            const value = tokens.currentTokenValue();
+            tokens.next();
+            return this.enrichWithAttributes(tokens, new const_expr_integer_node_1.ConstExprIntegerNode(value.replaceAll('_', '')), startLine, startIndex);
+        }
+        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_SINGLE_QUOTED_STRING, lexer_1.Lexer.TOKEN_DOUBLE_QUOTED_STRING)) {
+            let value = tokens.currentTokenValue();
+            const type = tokens.currentTokenType();
+            if (trimStrings) {
+                if (this.unescapeStrings) {
+                    value = string_unescaper_1.StringUnescaper.unescapeString(value);
+                }
+                else {
+                    value = value.substring(1, value.length - 1);
+                }
+            }
+            tokens.next();
+            if (this.quoteAwareConstExprString) {
+                return this.enrichWithAttributes(tokens, new quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode(value, type === lexer_1.Lexer.TOKEN_SINGLE_QUOTED_STRING
+                    ? quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode.SINGLE_QUOTED
+                    : quote_aware_const_expr_string_node_1.QuoteAwareConstExprStringNode.DOUBLE_QUOTED), startLine, startIndex);
+            }
+            return this.enrichWithAttributes(tokens, new const_expr_string_node_1.ConstExprStringNode(value), startLine, startIndex);
+        }
+        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER)) {
+            const identifier = tokens.currentTokenValue();
+            tokens.next();
+            switch (identifier.toLowerCase()) {
+                case 'true':
+                    return this.enrichWithAttributes(tokens, new const_expr_true_node_1.ConstExprTrueNode(), startLine, startIndex);
+                case 'false':
+                    return this.enrichWithAttributes(tokens, new const_expr_false_node_1.ConstExprFalseNode(), startLine, startIndex);
+                case 'null':
+                    return this.enrichWithAttributes(tokens, new const_expr_null_node_1.ConstExprNullNode(), startLine, startIndex);
+                case 'array':
+                    tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_PARENTHESES);
+                    return this.parseArray(tokens, lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES, startIndex);
+            }
+            if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_DOUBLE_COLON)) {
+                let classConstantName = '';
+                let lastType = null;
+                while (true) {
+                    if (lastType !== lexer_1.Lexer.TOKEN_IDENTIFIER &&
+                        tokens.currentTokenType() === lexer_1.Lexer.TOKEN_IDENTIFIER) {
+                        classConstantName += tokens.currentTokenValue();
+                        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
+                        lastType = lexer_1.Lexer.TOKEN_IDENTIFIER;
+                        continue;
+                    }
+                    if (lastType !== lexer_1.Lexer.TOKEN_WILDCARD &&
+                        tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_WILDCARD)) {
+                        classConstantName += '*';
+                        lastType = lexer_1.Lexer.TOKEN_WILDCARD;
+                        if (tokens.getSkippedHorizontalWhiteSpaceIfAny() !== '') {
+                            break;
+                        }
+                        continue;
+                    }
+                    if (lastType === null) {
+                        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_WILDCARD);
+                    }
+                    break;
+                }
+                return this.enrichWithAttributes(tokens, new const_fetch_node_1.ConstFetchNode(identifier, classConstantName), startLine, startIndex);
+            }
+            return this.enrichWithAttributes(tokens, new const_fetch_node_1.ConstFetchNode('', identifier), startLine, startIndex);
+        }
+        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
+            return this.parseArray(tokens, lexer_1.Lexer.TOKEN_CLOSE_SQUARE_BRACKET, startIndex);
+        }
+        throw new parser_exception_1.ParserException(tokens.currentTokenValue(), tokens.currentTokenType(), tokens.currentTokenOffset(), lexer_1.Lexer.TOKEN_IDENTIFIER, null, tokens.currentTokenLine());
+    }
+    parseArray(tokens, endToken, startIndex) {
+        const items = [];
+        const startLine = tokens.currentTokenLine();
+        if (!tokens.tryConsumeTokenType(endToken)) {
+            do {
+                items.push(this.parseArrayItem(tokens));
+            } while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA) &&
+                !tokens.isCurrentTokenType(endToken));
+            tokens.consumeTokenType(endToken);
+        }
+        return this.enrichWithAttributes(tokens, new const_expr_array_node_1.ConstExprArrayNode(items), startLine, startIndex);
+    }
+    parseArrayItem(tokens) {
+        const startLine = tokens.currentTokenLine();
+        const startIndex = tokens.currentTokenIndex();
+        const expr = this.parse(tokens);
+        let key;
+        let value;
+        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_DOUBLE_ARROW)) {
+            key = expr;
+            value = this.parse(tokens);
+        }
+        else {
+            key = null;
+            value = expr;
+        }
+        return this.enrichWithAttributes(tokens, new const_expr_array_item_node_1.ConstExprArrayItemNode(key, value), startLine, startIndex);
+    }
+    enrichWithAttributes(tokens, node, startLine, startIndex) {
+        if (this.useLinesAttributes) {
+            node.setAttribute(types_1.Attribute.START_LINE, startLine);
+            node.setAttribute(types_1.Attribute.END_LINE, tokens.currentTokenLine());
+        }
+        if (this.useIndexAttributes) {
+            node.setAttribute(types_1.Attribute.START_INDEX, startIndex);
+            node.setAttribute(types_1.Attribute.END_INDEX, tokens.endIndexOfLastRelevantToken());
+        }
+        return node;
+    }
+}
+exports.ConstExprParser = ConstExprParser;

package/dist/phpdoc-parser/parser/node-collecting-visitor.d.ts

@@ -0,0 +1,7 @@
+import { AbstractNodeVisitor } from '../ast/abstract-node-visitor';
+import { Node } from '../ast/node';
+import { NodeTraverserEnterReturn } from '../ast/node-visitor';
+export declare class NodeCollectingVisitor extends AbstractNodeVisitor {
+    nodes: Array<Node>;
+    enterNode(node: Node): NodeTraverserEnterReturn;
+}

package/dist/phpdoc-parser/parser/node-collecting-visitor.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCollectingVisitor = void 0;
+const abstract_node_visitor_1 = require("../ast/abstract-node-visitor");
+class NodeCollectingVisitor extends abstract_node_visitor_1.AbstractNodeVisitor {
+    constructor() {
+        super(...arguments);
+        this.nodes = [];
+    }
+    enterNode(node) {
+        this.nodes.push(node);
+        return null;
+    }
+}
+exports.NodeCollectingVisitor = NodeCollectingVisitor;

package/dist/phpdoc-parser/parser/parser-exception.d.ts

@@ -0,0 +1,16 @@
+export declare class ParserException extends Error {
+    private currentTokenValue;
+    private currentTokenType;
+    private currentOffset;
+    private expectedTokenType;
+    private expectedTokenValue;
+    private currentTokenLine;
+    constructor(currentTokenValue: string, currentTokenType: string, currentOffset: number, expectedTokenType: string, expectedTokenValue?: string | null, currentTokenLine?: number | null);
+    getCurrentTokenValue(): string;
+    getCurrentTokenType(): string;
+    getCurrentOffset(): number;
+    getExpectedTokenType(): string;
+    getExpectedTokenValue(): string | null;
+    getCurrentTokenLine(): number | null;
+    private formatValue;
+}