@rightcapital/phpdoc-parser 0.5.3 → 0.6.0

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayShapeUnsealedTypeNode = void 0;
+const type_node_1 = require("./type-node");
+class ArrayShapeUnsealedTypeNode extends type_node_1.TypeNode {
+    constructor(valueType, keyType) {
+        super();
+        this.valueType = valueType;
+        this.keyType = keyType;
+    }
+    toString() {
+        if (this.keyType !== null) {
+            return `<${this.keyType.toString()}, ${this.valueType.toString()}>`;
+        }
+        return `<${this.valueType.toString()}>`;
+    }
+    getNodeType() {
+        return 'ArrayShapeUnsealedTypeNode';
+    }
+}
+exports.ArrayShapeUnsealedTypeNode = ArrayShapeUnsealedTypeNode;

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

@@ -1,3 +1,4 @@
+import type { TemplateTagValueNode } from '../php-doc/template-tag-value-node';
 import type { CallableTypeParameterNode } from './callable-type-parameter-node';
 import type { IdentifierTypeNode } from './identifier-type-node';
 import { TypeNode } from './type-node';
@@ -5,7 +6,8 @@ export declare class CallableTypeNode extends TypeNode {
     identifier: IdentifierTypeNode;
     parameters: CallableTypeParameterNode[];
     returnType: TypeNode;
-    constructor(identifier: IdentifierTypeNode, parameters: CallableTypeParameterNode[], returnType: TypeNode);
+    templateTypes: TemplateTagValueNode[];
+    constructor(identifier: IdentifierTypeNode, parameters: CallableTypeParameterNode[], returnType: TypeNode, templateTypes?: TemplateTagValueNode[]);
     toString(): string;
     getNodeType(): string;
 }

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

@@ -3,19 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CallableTypeNode = void 0;
 const type_node_1 = require("./type-node");
 class CallableTypeNode extends type_node_1.TypeNode {
-    constructor(identifier, parameters, returnType) {
+    constructor(identifier, parameters, returnType, templateTypes = []) {
         super();
         this.identifier = identifier;
         this.parameters = parameters;
         this.returnType = returnType;
+        this.templateTypes = templateTypes;
     }
     toString() {
         let { returnType } = this;
         if (returnType instanceof CallableTypeNode) {
             returnType = `(${returnType.toString()})`;
         }
+        const template = this.templateTypes.length > 0 ? `<${this.templateTypes.join(', ')}>` : '';
         const parameters = this.parameters.join(', ');
-        return `${this.identifier.toString()}(${parameters}): ${returnType.toString()}`;
+        return `${this.identifier.toString()}${template}(${parameters}): ${returnType.toString()}`;
     }
     getNodeType() {
         return 'CallableTypeNode';

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

@@ -9,5 +9,6 @@ export declare enum Attribute {
     END_LINE = "endLine",
     START_INDEX = "startIndex",
     END_INDEX = "endIndex",
-    ORIGINAL_NODE = "originalNode"
+    ORIGINAL_NODE = "originalNode",
+    COMMENTS = "comments"
 }

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

@@ -15,4 +15,5 @@ var Attribute;
     Attribute["START_INDEX"] = "startIndex";
     Attribute["END_INDEX"] = "endIndex";
     Attribute["ORIGINAL_NODE"] = "originalNode";
+    Attribute["COMMENTS"] = "comments";
 })(Attribute || (exports.Attribute = Attribute = {}));

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

@@ -34,6 +34,7 @@ export declare class Lexer {
     static TOKEN_CLOSE_CURLY_BRACKET: string;
     static TOKEN_NEGATED: string;
     static TOKEN_ARROW: string;
+    static TOKEN_COMMENT: string;
     static TOKEN_LABELS: {
         [Lexer.TOKEN_REFERENCE]: string;
         [Lexer.TOKEN_UNION]: string;
@@ -49,6 +50,7 @@ export declare class Lexer {
         [Lexer.TOKEN_OPEN_CURLY_BRACKET]: string;
         [Lexer.TOKEN_CLOSE_CURLY_BRACKET]: string;
         [Lexer.TOKEN_COMMA]: string;
+        [Lexer.TOKEN_COMMENT]: string;
         [Lexer.TOKEN_COLON]: string;
         [Lexer.TOKEN_VARIADIC]: string;
         [Lexer.TOKEN_DOUBLE_COLON]: string;

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

@@ -40,6 +40,7 @@ class Lexer {
             [Lexer.TOKEN_OPEN_CURLY_BRACKET]: '\\{',
             [Lexer.TOKEN_CLOSE_CURLY_BRACKET]: '\\}',
             [Lexer.TOKEN_COMMA]: ',',
+            [Lexer.TOKEN_COMMENT]: '\\/\\/[^\\r\\n]*(?=\\n|\\r|\\*\\/)',
             [Lexer.TOKEN_VARIADIC]: '\\.\\.\\.',
             [Lexer.TOKEN_DOUBLE_COLON]: '::',
             [Lexer.TOKEN_DOUBLE_ARROW]: '=>',
@@ -101,6 +102,7 @@ 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_COMMENT = 'TOKEN_COMMENT';
 Lexer.TOKEN_LABELS = {
     [Lexer.TOKEN_REFERENCE]: '&',
     [Lexer.TOKEN_UNION]: '|',
@@ -116,6 +118,7 @@ Lexer.TOKEN_LABELS = {
     [Lexer.TOKEN_OPEN_CURLY_BRACKET]: '{',
     [Lexer.TOKEN_CLOSE_CURLY_BRACKET]: '}',
     [Lexer.TOKEN_COMMA]: ',',
+    [Lexer.TOKEN_COMMENT]: '//',
     [Lexer.TOKEN_COLON]: ':',
     [Lexer.TOKEN_VARIADIC]: '...',
     [Lexer.TOKEN_DOUBLE_COLON]: '::',

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

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

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

@@ -10,20 +10,17 @@ 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");
 const parser_exception_1 = require("./parser-exception");
 const string_unescaper_1 = require("./string-unescaper");
 class ConstExprParser {
-    constructor(unescapeStrings = false, quoteAwareConstExprString = false, usedAttributes = {}) {
+    constructor(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) {
+    parse(tokens) {
         const startLine = tokens.currentTokenLine();
         const startIndex = tokens.currentTokenIndex();
         if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_FLOAT)) {
@@ -37,23 +34,12 @@ class ConstExprParser {
             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 value = string_unescaper_1.StringUnescaper.unescapeString(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);
+            return this.enrichWithAttributes(tokens, new const_expr_string_node_1.ConstExprStringNode(value, type === lexer_1.Lexer.TOKEN_SINGLE_QUOTED_STRING
+                ? const_expr_string_node_1.ConstExprStringNode.SINGLE_QUOTED
+                : const_expr_string_node_1.ConstExprStringNode.DOUBLE_QUOTED), startLine, startIndex);
         }
         if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER)) {
             const identifier = tokens.currentTokenValue();

package/dist/phpdoc-parser/parser/php-doc-parser.d.ts

@@ -7,17 +7,13 @@ import type { TypeParser } from './type-parser';
 export declare class PhpDocParser {
     typeParser: TypeParser;
     constantExprParser: ConstExprParser;
-    requireWhitespaceBeforeDescription: boolean;
-    preserveTypeAliasesWithInvalidTypes: boolean;
-    parseDoctrineAnnotations: boolean;
-    private textBetweenTagsBelongsToDescription;
     private useLinesAttributes;
     private useIndexAttributes;
     private static readonly DISALLOWED_DESCRIPTION_START_TOKENS;
-    constructor(typeParser: TypeParser, constantExprParser: ConstExprParser, requireWhitespaceBeforeDescription?: boolean, preserveTypeAliasesWithInvalidTypes?: boolean, usedAttributes?: {
-        lines: boolean;
-        indexes: boolean;
-    }, parseDoctrineAnnotations?: boolean, textBetweenTagsBelongsToDescription?: boolean);
+    constructor(typeParser: TypeParser, constantExprParser: ConstExprParser, usedAttributes?: {
+        lines?: boolean;
+        indexes?: boolean;
+    });
     parse(tokens: TokenIterator): PhpDocNode;
     private parseChild;
     private enrichWithAttributes;
@@ -30,10 +26,16 @@ export declare class PhpDocParser {
     private parseThrowsTagValue;
     private parseMixinTagValue;
     private parseDeprecatedTagValue;
+    private parseParamImmediatelyInvokedCallableTagValue;
+    private parseParamLaterInvokedCallableTagValue;
+    private parseParamClosureThisTagValue;
+    private parsePureUnlessCallableIsImpureTagValue;
+    private parseRequireExtendsTagValue;
+    private parseRequireImplementsTagValue;
+    private parseSealedTagValue;
     private parsePropertyTagValue;
     private parseMethodTagValue;
     private parseMethodTagValueParameter;
-    private parseTemplateTagValue;
     private parseExtendsTagValue;
     private parseTypeAliasTagValue;
     private parseTypeAliasImportTagValue;

package/dist/phpdoc-parser/parser/php-doc-parser.js

@@ -12,15 +12,21 @@ const invalid_tag_value_node_1 = require("../ast/php-doc/invalid-tag-value-node"
 const method_tag_value_node_1 = require("../ast/php-doc/method-tag-value-node");
 const method_tag_value_parameter_node_1 = require("../ast/php-doc/method-tag-value-parameter-node");
 const mixin_tag_value_node_1 = require("../ast/php-doc/mixin-tag-value-node");
+const param_closure_this_tag_value_node_1 = require("../ast/php-doc/param-closure-this-tag-value-node");
+const param_immediately_invoked_callable_tag_value_node_1 = require("../ast/php-doc/param-immediately-invoked-callable-tag-value-node");
+const param_later_invoked_callable_tag_value_node_1 = require("../ast/php-doc/param-later-invoked-callable-tag-value-node");
 const param_out_tag_value_node_1 = require("../ast/php-doc/param-out-tag-value-node");
 const param_tag_value_node_1 = require("../ast/php-doc/param-tag-value-node");
 const php_doc_node_1 = require("../ast/php-doc/php-doc-node");
 const php_doc_tag_node_1 = require("../ast/php-doc/php-doc-tag-node");
 const php_doc_text_node_1 = require("../ast/php-doc/php-doc-text-node");
 const property_tag_value_node_1 = require("../ast/php-doc/property-tag-value-node");
+const pure_unless_callable_is_impure_tag_value_node_1 = require("../ast/php-doc/pure-unless-callable-is-impure-tag-value-node");
+const require_extends_tag_value_node_1 = require("../ast/php-doc/require-extends-tag-value-node");
+const require_implements_tag_value_node_1 = require("../ast/php-doc/require-implements-tag-value-node");
 const return_tag_value_node_1 = require("../ast/php-doc/return-tag-value-node");
+const sealed_tag_value_node_1 = require("../ast/php-doc/sealed-tag-value-node");
 const self_out_tag_value_node_1 = require("../ast/php-doc/self-out-tag-value-node");
-const template_tag_value_node_1 = require("../ast/php-doc/template-tag-value-node");
 const throws_tag_value_node_1 = require("../ast/php-doc/throws-tag-value-node");
 const type_alias_import_tag_value_node_1 = require("../ast/php-doc/type-alias-import-tag-value-node");
 const type_alias_tag_value_node_1 = require("../ast/php-doc/type-alias-tag-value-node");
@@ -36,17 +42,10 @@ const DISALLOWED_DESCRIPTION_START_TOKENS = [
     lexer_1.Lexer.TOKEN_INTERSECTION,
 ];
 class PhpDocParser {
-    constructor(typeParser, constantExprParser, requireWhitespaceBeforeDescription = false, preserveTypeAliasesWithInvalidTypes = false, usedAttributes = {
-        lines: false,
-        indexes: false,
-    }, parseDoctrineAnnotations = false, textBetweenTagsBelongsToDescription = false) {
+    constructor(typeParser, constantExprParser, usedAttributes = {}) {
         var _a, _b;
         this.typeParser = typeParser;
         this.constantExprParser = constantExprParser;
-        this.requireWhitespaceBeforeDescription = requireWhitespaceBeforeDescription;
-        this.preserveTypeAliasesWithInvalidTypes = preserveTypeAliasesWithInvalidTypes;
-        this.parseDoctrineAnnotations = parseDoctrineAnnotations;
-        this.textBetweenTagsBelongsToDescription = textBetweenTagsBelongsToDescription;
         this.useLinesAttributes = (_a = usedAttributes.lines) !== null && _a !== void 0 ? _a : false;
         this.useIndexAttributes = (_b = usedAttributes.indexes) !== null && _b !== void 0 ? _b : false;
     }
@@ -109,32 +108,22 @@ class PhpDocParser {
     parseText(tokens) {
         var _a, _b;
         let text = '';
-        let endTokens = [
-            lexer_1.Lexer.TOKEN_PHPDOC_EOL,
-            lexer_1.Lexer.TOKEN_CLOSE_PHPDOC,
-            lexer_1.Lexer.TOKEN_END,
-        ];
-        if (this.textBetweenTagsBelongsToDescription) {
-            endTokens = [lexer_1.Lexer.TOKEN_CLOSE_PHPDOC, lexer_1.Lexer.TOKEN_END];
-        }
+        const endTokens = [lexer_1.Lexer.TOKEN_CLOSE_PHPDOC, lexer_1.Lexer.TOKEN_END];
         let savepoint = false;
-        while (this.textBetweenTagsBelongsToDescription ||
-            !tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL)) {
+        while (true) {
             const tmpText = tokens.getSkippedHorizontalWhiteSpaceIfAny() +
                 tokens.joinUntil(lexer_1.Lexer.TOKEN_PHPDOC_EOL, ...endTokens);
             text += tmpText;
             if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL)) {
                 break;
             }
-            if (this.textBetweenTagsBelongsToDescription) {
-                if (!savepoint) {
-                    tokens.pushSavePoint();
-                    savepoint = true;
-                }
-                else if (tmpText !== '') {
-                    tokens.dropSavePoint();
-                    tokens.pushSavePoint();
-                }
+            if (!savepoint) {
+                tokens.pushSavePoint();
+                savepoint = true;
+            }
+            else if (tmpText !== '') {
+                tokens.dropSavePoint();
+                tokens.pushSavePoint();
             }
             tokens.pushSavePoint();
             tokens.next();
@@ -167,16 +156,36 @@ class PhpDocParser {
                 case '@param':
                 case '@phpstan-param':
                 case '@psalm-param':
+                case '@phan-param':
                     tagValue = this.parseParamTagValue(tokens);
                     break;
+                case '@param-immediately-invoked-callable':
+                case '@phpstan-param-immediately-invoked-callable':
+                    tagValue = this.parseParamImmediatelyInvokedCallableTagValue(tokens);
+                    break;
+                case '@param-later-invoked-callable':
+                case '@phpstan-param-later-invoked-callable':
+                    tagValue = this.parseParamLaterInvokedCallableTagValue(tokens);
+                    break;
+                case '@param-closure-this':
+                case '@phpstan-param-closure-this':
+                    tagValue = this.parseParamClosureThisTagValue(tokens);
+                    break;
+                case '@pure-unless-callable-is-impure':
+                case '@phpstan-pure-unless-callable-is-impure':
+                    tagValue = this.parsePureUnlessCallableIsImpureTagValue(tokens);
+                    break;
                 case '@var':
                 case '@phpstan-var':
                 case '@psalm-var':
+                case '@phan-var':
                     tagValue = this.parseVarTagValue(tokens);
                     break;
                 case '@return':
                 case '@phpstan-return':
                 case '@psalm-return':
+                case '@phan-return':
+                case '@phan-real-return':
                     tagValue = this.parseReturnTagValue(tokens);
                     break;
                 case '@throws':
@@ -184,8 +193,21 @@ class PhpDocParser {
                     tagValue = this.parseThrowsTagValue(tokens);
                     break;
                 case '@mixin':
+                case '@phan-mixin':
                     tagValue = this.parseMixinTagValue(tokens);
                     break;
+                case '@psalm-require-extends':
+                case '@phpstan-require-extends':
+                    tagValue = this.parseRequireExtendsTagValue(tokens);
+                    break;
+                case '@psalm-require-implements':
+                case '@phpstan-require-implements':
+                    tagValue = this.parseRequireImplementsTagValue(tokens);
+                    break;
+                case '@psalm-inheritors':
+                case '@phpstan-sealed':
+                    tagValue = this.parseSealedTagValue(tokens);
+                    break;
                 case '@deprecated':
                     tagValue = this.parseDeprecatedTagValue(tokens);
                     break;
@@ -198,26 +220,33 @@ class PhpDocParser {
                 case '@psalm-property':
                 case '@psalm-property-read':
                 case '@psalm-property-write':
+                case '@phan-property':
+                case '@phan-property-read':
+                case '@phan-property-write':
                     tagValue = this.parsePropertyTagValue(tokens);
                     break;
                 case '@method':
                 case '@phpstan-method':
                 case '@psalm-method':
+                case '@phan-method':
                     tagValue = this.parseMethodTagValue(tokens);
                     break;
                 case '@template':
                 case '@phpstan-template':
                 case '@psalm-template':
+                case '@phan-template':
                 case '@template-covariant':
                 case '@phpstan-template-covariant':
                 case '@psalm-template-covariant':
                 case '@template-contravariant':
                 case '@phpstan-template-contravariant':
                 case '@psalm-template-contravariant':
-                    tagValue = this.parseTemplateTagValue(tokens, true);
+                    tagValue = this.typeParser.parseTemplateTagValue(tokens, (t) => this.parseOptionalDescription(t, true));
                     break;
                 case '@extends':
                 case '@phpstan-extends':
+                case '@phan-extends':
+                case '@phan-inherits':
                 case '@template-extends':
                     tagValue = this.parseExtendsTagValue('@extends', tokens);
                     break;
@@ -233,6 +262,7 @@ class PhpDocParser {
                     break;
                 case '@phpstan-type':
                 case '@psalm-type':
+                case '@phan-type':
                     tagValue = this.parseTypeAliasTagValue(tokens);
                     break;
                 case '@phpstan-import-type':
@@ -245,6 +275,9 @@ class PhpDocParser {
                 case '@psalm-assert':
                 case '@psalm-assert-if-true':
                 case '@psalm-assert-if-false':
+                case '@phan-assert':
+                case '@phan-assert-if-true':
+                case '@phan-assert-if-false':
                     tagValue = this.parseAssertTagValue(tokens);
                     break;
                 case '@phpstan-this-out':
@@ -309,6 +342,42 @@ class PhpDocParser {
         const description = this.parseOptionalDescription(tokens);
         return new deprecated_tag_value_node_1.DeprecatedTagValueNode(description);
     }
+    parseParamImmediatelyInvokedCallableTagValue(tokens) {
+        const parameterName = this.parseRequiredVariableName(tokens);
+        const description = this.parseOptionalDescription(tokens);
+        return new param_immediately_invoked_callable_tag_value_node_1.ParamImmediatelyInvokedCallableTagValueNode(parameterName, description);
+    }
+    parseParamLaterInvokedCallableTagValue(tokens) {
+        const parameterName = this.parseRequiredVariableName(tokens);
+        const description = this.parseOptionalDescription(tokens);
+        return new param_later_invoked_callable_tag_value_node_1.ParamLaterInvokedCallableTagValueNode(parameterName, description);
+    }
+    parseParamClosureThisTagValue(tokens) {
+        const type = this.typeParser.parse(tokens);
+        const parameterName = this.parseRequiredVariableName(tokens);
+        const description = this.parseOptionalDescription(tokens);
+        return new param_closure_this_tag_value_node_1.ParamClosureThisTagValueNode(type, parameterName, description);
+    }
+    parsePureUnlessCallableIsImpureTagValue(tokens) {
+        const parameterName = this.parseRequiredVariableName(tokens);
+        const description = this.parseOptionalDescription(tokens);
+        return new pure_unless_callable_is_impure_tag_value_node_1.PureUnlessCallableIsImpureTagValueNode(parameterName, description);
+    }
+    parseRequireExtendsTagValue(tokens) {
+        const type = this.typeParser.parse(tokens);
+        const description = this.parseOptionalDescription(tokens, true);
+        return new require_extends_tag_value_node_1.RequireExtendsTagValueNode(type, description);
+    }
+    parseRequireImplementsTagValue(tokens) {
+        const type = this.typeParser.parse(tokens);
+        const description = this.parseOptionalDescription(tokens, true);
+        return new require_implements_tag_value_node_1.RequireImplementsTagValueNode(type, description);
+    }
+    parseSealedTagValue(tokens) {
+        const type = this.typeParser.parse(tokens);
+        const description = this.parseOptionalDescription(tokens, true);
+        return new sealed_tag_value_node_1.SealedTagValueNode(type, description);
+    }
     parsePropertyTagValue(tokens) {
         const type = this.typeParser.parse(tokens);
         const name = this.parseRequiredVariableName(tokens);
@@ -342,7 +411,7 @@ class PhpDocParser {
             do {
                 startLine = tokens.currentTokenLine();
                 startIndex = tokens.currentTokenIndex();
-                const templateType = this.parseTemplateTagValue(tokens, false);
+                const templateType = this.typeParser.parseTemplateTagValue(tokens);
                 templateTypes.push(this.enrichWithAttributes(tokens, templateType, startLine, startIndex));
             } while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA));
             tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET);
@@ -383,24 +452,6 @@ class PhpDocParser {
         }
         return this.enrichWithAttributes(tokens, new method_tag_value_parameter_node_1.MethodTagValueParameterNode(type, isReference, isVariadic, name, defaultValue), startLine, startIndex);
     }
-    parseTemplateTagValue(tokens, parseDescription) {
-        const name = tokens.currentTokenValue();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
-        let bound = null;
-        if (tokens.tryConsumeTokenValue('of') ||
-            tokens.tryConsumeTokenValue('as')) {
-            bound = this.typeParser.parse(tokens);
-        }
-        let defaultValue = null;
-        if (tokens.tryConsumeTokenValue('=')) {
-            defaultValue = this.typeParser.parse(tokens);
-        }
-        let description = '';
-        if (parseDescription) {
-            description = this.parseOptionalDescription(tokens);
-        }
-        return new template_tag_value_node_1.TemplateTagValueNode(name, bound, description, defaultValue);
-    }
     parseExtendsTagValue(tagName, tokens) {
         const startLine = tokens.currentTokenLine();
         const startIndex = tokens.currentTokenIndex();
@@ -423,25 +474,21 @@ class PhpDocParser {
         const alias = tokens.currentTokenValue();
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
         tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_EQUAL);
-        if (this.preserveTypeAliasesWithInvalidTypes) {
-            const startLine = tokens.currentTokenLine();
-            const startIndex = tokens.currentTokenIndex();
-            try {
-                const type = this.typeParser.parse(tokens);
-                if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PHPDOC)) {
-                    if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL)) {
-                        throw new Error('Expected end of line');
-                    }
+        const startLine = tokens.currentTokenLine();
+        const startIndex = tokens.currentTokenIndex();
+        try {
+            const type = this.typeParser.parse(tokens);
+            if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PHPDOC)) {
+                if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL)) {
+                    throw new Error('Expected end of line');
                 }
-                return new type_alias_tag_value_node_1.TypeAliasTagValueNode(alias, type);
-            }
-            catch (e) {
-                this.parseOptionalDescription(tokens);
-                return new type_alias_tag_value_node_1.TypeAliasTagValueNode(alias, this.enrichWithAttributes(tokens, new invalid_type_node_1.InvalidTypeNode(e), startLine, startIndex));
             }
+            return new type_alias_tag_value_node_1.TypeAliasTagValueNode(alias, type);
+        }
+        catch (e) {
+            this.parseOptionalDescription(tokens);
+            return new type_alias_tag_value_node_1.TypeAliasTagValueNode(alias, this.enrichWithAttributes(tokens, new invalid_type_node_1.InvalidTypeNode(e), startLine, startIndex));
         }
-        const type = this.typeParser.parse(tokens);
-        return new type_alias_tag_value_node_1.TypeAliasTagValueNode(alias, type);
     }
     parseTypeAliasImportTagValue(tokens) {
         const importedAlias = tokens.currentTokenValue();
@@ -542,8 +589,7 @@ class PhpDocParser {
                 }
                 tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OTHER);
             }
-            if (this.requireWhitespaceBeforeDescription &&
-                !tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL, lexer_1.Lexer.TOKEN_CLOSE_PHPDOC, lexer_1.Lexer.TOKEN_END) &&
+            if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL, lexer_1.Lexer.TOKEN_CLOSE_PHPDOC, lexer_1.Lexer.TOKEN_END) &&
                 !tokens.isPrecededByHorizontalWhitespace()) {
                 tokens.consumeTokenType(lexer_1.Lexer.TOKEN_HORIZONTAL_WS);
             }

package/dist/phpdoc-parser/parser/string-unescaper.js

@@ -5,12 +5,12 @@ class StringUnescaper {
     static unescapeString(input) {
         const quote = input[0];
         if (quote === "'") {
-            return input.slice(1, input.length - 1).replaceAll(/\\([\\\.])/g, '$1');
+            return input.slice(1, input.length - 1).replaceAll(/\\([\\'])/g, '$1');
         }
         return this.parseEscapeSequences(input.slice(1, input.length - 1), '"');
     }
     static parseEscapeSequences(input, quote) {
-        input = input.replaceAll(new RegExp(`\\${quote}`, 'g'), quote);
+        input = input.replaceAll(new RegExp(`\\\\${quote}`, 'g'), quote);
         return input.replaceAll(/\\([\\nrtfve]|[xX][0-9a-fA-F]{1,2}|[0-7]{1,3}|u\{([0-9a-fA-F]+)\})/g, (substring, ...matches) => {
             const firstCaptureGroup = matches[0];
             if (this.REPLACEMENTS[firstCaptureGroup]) {

package/dist/phpdoc-parser/parser/token-iterator.d.ts

@@ -1,6 +1,8 @@
+import { Comment } from '../ast/comment';
 export declare class TokenIterator {
     private tokens;
     private index;
+    private comments;
     private savePoints;
     private skippedTokenTypes;
     private newline;
@@ -21,6 +23,8 @@ export declare class TokenIterator {
     consumeTokenValue(tokenType: string, tokenValue: string): void;
     tryConsumeTokenValue(tokenValue: string): boolean;
     tryConsumeTokenType(tokenType: string): boolean;
+    flushComments(): Comment[];
+    skipNewLineTokensAndConsumeComments(): void;
     private detectNewline;
     getSkippedHorizontalWhiteSpaceIfAny(): string;
     joinUntil(...tokenType: string[]): string;

package/dist/phpdoc-parser/parser/token-iterator.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenIterator = void 0;
+const comment_1 = require("../ast/comment");
 const lexer_1 = require("../lexer/lexer");
 const parser_exception_1 = require("./parser-exception");
 class TokenIterator {
     constructor(tokens, index = 0) {
+        this.comments = [];
         this.savePoints = [];
         this.skippedTokenTypes = [lexer_1.Lexer.TOKEN_HORIZONTAL_WS];
         this.newline = null;
@@ -110,6 +112,29 @@ class TokenIterator {
         this.skipIrrelevantTokens();
         return true;
     }
+    flushComments() {
+        const res = this.comments;
+        this.comments = [];
+        return res;
+    }
+    skipNewLineTokensAndConsumeComments() {
+        if (this.currentTokenType() === lexer_1.Lexer.TOKEN_COMMENT) {
+            this.comments.push(new comment_1.Comment(this.currentTokenValue(), this.currentTokenLine(), this.currentTokenIndex()));
+            this.next();
+        }
+        if (!this.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL)) {
+            return;
+        }
+        let foundNewLine;
+        do {
+            foundNewLine = this.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
+            if (this.currentTokenType() !== lexer_1.Lexer.TOKEN_COMMENT) {
+                continue;
+            }
+            this.comments.push(new comment_1.Comment(this.currentTokenValue(), this.currentTokenLine(), this.currentTokenIndex()));
+            this.next();
+        } while (foundNewLine);
+    }
     detectNewline() {
         const value = this.currentTokenValue();
         if (value.substring(0, 2) === '\r\n') {
@@ -162,14 +187,17 @@ class TokenIterator {
         this.index = lastToken;
     }
     pushSavePoint() {
-        this.savePoints.push(this.index);
+        this.savePoints.push([this.index, [...this.comments]]);
     }
     dropSavePoint() {
         this.savePoints.pop();
     }
     rollback() {
-        const index = this.savePoints.pop();
-        this.index = index;
+        const savepoint = this.savePoints.pop();
+        if (savepoint === undefined) {
+            throw new Error('No save point to rollback to');
+        }
+        [this.index, this.comments] = savepoint;
     }
     throwError(expectedTokenType, expectedTokenValue = null) {
         throw new parser_exception_1.ParserException(this.currentTokenValue(), this.currentTokenType(), this.currentTokenOffset(), expectedTokenType, expectedTokenValue, this.currentTokenLine());