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

package/README.md

@@ -1,12 +1,20 @@
 # PHPDoc parser TypeScript version
 
+<!-- Badges area start -->
+
+![RightCapital](https://img.shields.io/badge/RightCapital-open_source-gray?labelColor=%235070e6&link=https%3A%2F%2Frightcapital.com)
+![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/RightCapitalHQ/phpdoc-parser/build)
+[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-%23FE5196?logo=conventionalcommits&logoColor=white)](https://conventionalcommits.org)
+
+<!-- Badges area end -->
+
 Next-gen PHPDoc parser with support for intersection types and generics(TypeScript version)
 
 ## What's that
 
 This parser is inspired by the PHPStan's phpdoc-parser library: https://github.com/phpstan/phpdoc-parser
 
-this libraray `@rightcapital/phpdoc-parser` represents PHPDocs with an AST (Abstract Syntax Tree). It supports parsing and modifying PHPDocs by using `TypeScript`/`Javascript`.
+this libraray `@rightcapital/phpdoc-parser` represents PHPDocs with an AST (Abstract Syntax Tree). It supports parsing and modifying PHPDocs by using `TypeScript`/`JavaScript`.
 
 For the complete list of supported PHPDoc features check out PHPStan documentation.
 

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+export { Lexer } from './phpdoc-parser/lexer/lexer';
+export { ConstExprParser } from './phpdoc-parser/parser/const-expr-parser';
+export { StringUnescaper } from './phpdoc-parser/parser/string-unescaper';
+export { ParserException } from './phpdoc-parser/parser/parser-exception';
+export { TokenIterator } from './phpdoc-parser/parser/token-iterator';
+export { PhpDocParser } from './phpdoc-parser/parser/php-doc-parser';
+export { TypeParser } from './phpdoc-parser/parser/type-parser';
+export { BaseNode } from './phpdoc-parser/ast/base-node';
+export { Node } from './phpdoc-parser/ast/node';
+export { NodeTraverser } from './phpdoc-parser/ast/node-traverser';
+export { CloningVisitor } from './phpdoc-parser/ast/node-visitor/cloning-visitor';
+export { NodeVisitor } from './phpdoc-parser/ast/node-visitor';
+export { NodeTraverserState, Attribute } from './phpdoc-parser/ast/types';
+export { IdentifierTypeNode } from './phpdoc-parser/ast/type/identifier-type-node';
+export { CallableTypeParameterNode } from './phpdoc-parser/ast/type/callable-type-parameter-node';
+export { OffsetAccessTypeNode } from './phpdoc-parser/ast/type/offset-access-type-node';
+export { ArrayShapeItemNode } from './phpdoc-parser/ast/type/array-shape-item-node';
+export { ConditionalTypeNode } from './phpdoc-parser/ast/type/conditional-type-node';
+export { ConditionalTypeForParameterNode } from './phpdoc-parser/ast/type/conditional-type-for-parameter-node';
+export { ThisTypeNode } from './phpdoc-parser/ast/type/this-type-node';
+export { IntersectionTypeNode } from './phpdoc-parser/ast/type/intersection-type-node';
+export { ObjectShapeItemNode } from './phpdoc-parser/ast/type/object-shape-item-node';
+export { UnionTypeNode } from './phpdoc-parser/ast/type/union-type-node';
+export { TypeNode } from './phpdoc-parser/ast/type/type-node';
+export { GenericTypeNode } from './phpdoc-parser/ast/type/generic-type-node';
+export { CallableTypeNode } from './phpdoc-parser/ast/type/callable-type-node';
+export { ArrayTypeNode } from './phpdoc-parser/ast/type/array-type-node';
+export { ArrayShapeNode } from './phpdoc-parser/ast/type/array-shape-node';
+export { InvalidTypeNode } from './phpdoc-parser/ast/type/invalid-type-node';
+export { ConstTypeNode } from './phpdoc-parser/ast/type/const-type-node';
+export { ObjectShapeNode } from './phpdoc-parser/ast/type/object-shape-node';
+export { NullableTypeNode } from './phpdoc-parser/ast/type/nullable-type-node';
+export { AbstractNodeVisitor } from './phpdoc-parser/ast/abstract-node-visitor';
+export { ConstExprFloatNode } from './phpdoc-parser/ast/const-expr/const-expr-float-node';
+export { ConstExprArrayItemNode } from './phpdoc-parser/ast/const-expr/const-expr-array-item-node';
+export { ConstExprFalseNode } from './phpdoc-parser/ast/const-expr/const-expr-false-node';
+export { QuoteAwareConstExprStringNode } from './phpdoc-parser/ast/const-expr/quote-aware-const-expr-string-node';
+export { ConstExprNullNode } from './phpdoc-parser/ast/const-expr/const-expr-null-node';
+export { ConstExprIntegerNode } from './phpdoc-parser/ast/const-expr/const-expr-integer-node';
+export { ConstExprNode } from './phpdoc-parser/ast/const-expr/const-expr-node';
+export { ConstExprArrayNode } from './phpdoc-parser/ast/const-expr/const-expr-array-node';
+export { ConstExprStringNode } from './phpdoc-parser/ast/const-expr/const-expr-string-node';
+export { ConstExprTrueNode } from './phpdoc-parser/ast/const-expr/const-expr-true-node';
+export { ConstFetchNode } from './phpdoc-parser/ast/const-expr/const-fetch-node';
+export { ParamOutTagValueNode } from './phpdoc-parser/ast/php-doc/param-out-tag-value-node';
+export { PhpDocNode } from './phpdoc-parser/ast/php-doc/php-doc-node';
+export { AssertTagValueNode } from './phpdoc-parser/ast/php-doc/assert-tag-value-node';
+export { UsesTagValueNode } from './phpdoc-parser/ast/php-doc/uses-tag-value-node';
+export { InvalidTagValueNode } from './phpdoc-parser/ast/php-doc/invalid-tag-value-node';
+export { MethodTagValueNode } from './phpdoc-parser/ast/php-doc/method-tag-value-node';
+export { DeprecatedTagValueNode } from './phpdoc-parser/ast/php-doc/deprecated-tag-value-node';
+export { ExtendsTagValueNode } from './phpdoc-parser/ast/php-doc/extends-tag-value-node';
+export { ParamTagValueNode } from './phpdoc-parser/ast/php-doc/param-tag-value-node';
+export { GenericTagValueNode } from './phpdoc-parser/ast/php-doc/generic-tag-value-node';
+export { TypeAliasTagValueNode } from './phpdoc-parser/ast/php-doc/type-alias-tag-value-node';
+export { AssertTagPropertyValueNode } from './phpdoc-parser/ast/php-doc/assert-tag-property-value-node';
+export { TypelessParamTagValueNode } from './phpdoc-parser/ast/php-doc/typeless-param-tag-value-node';
+export { VarTagValueNode } from './phpdoc-parser/ast/php-doc/var-tag-value-node';
+export { PhpDocTextNode } from './phpdoc-parser/ast/php-doc/php-doc-text-node';
+export { MethodTagValueParameterNode } from './phpdoc-parser/ast/php-doc/method-tag-value-parameter-node';
+export { AssertTagMethodValueNode } from './phpdoc-parser/ast/php-doc/assert-tag-method-value-node';
+export { TemplateTagValueNode } from './phpdoc-parser/ast/php-doc/template-tag-value-node';
+export { ImplementsTagValueNode } from './phpdoc-parser/ast/php-doc/implements-tag-value-node';
+export { ThrowsTagValueNode } from './phpdoc-parser/ast/php-doc/throws-tag-value-node';
+export { SelfOutTagValueNode } from './phpdoc-parser/ast/php-doc/self-out-tag-value-node';
+export { PropertyTagValueNode } from './phpdoc-parser/ast/php-doc/property-tag-value-node';
+export { TypeAliasImportTagValueNode } from './phpdoc-parser/ast/php-doc/type-alias-import-tag-value-node';
+export { PhpDocChildNode } from './phpdoc-parser/ast/php-doc/php-doc-child-node';
+export { MixinTagValueNode } from './phpdoc-parser/ast/php-doc/mixin-tag-value-node';
+export { PhpDocTagNode } from './phpdoc-parser/ast/php-doc/php-doc-tag-node';
+export { PhpDocTagValueNode } from './phpdoc-parser/ast/php-doc/php-doc-tag-value-node';
+export { ReturnTagValueNode } from './phpdoc-parser/ast/php-doc/return-tag-value-node';
+export { Printer } from './phpdoc-parser/printer/printer';

package/dist/index.js

@@ -145,4 +145,3 @@ var return_tag_value_node_1 = require("./phpdoc-parser/ast/php-doc/return-tag-va
 Object.defineProperty(exports, "ReturnTagValueNode", { enumerable: true, get: function () { return return_tag_value_node_1.ReturnTagValueNode; } });
 var printer_1 = require("./phpdoc-parser/printer/printer");
 Object.defineProperty(exports, "Printer", { enumerable: true, get: function () { return printer_1.Printer; } });
-//# sourceMappingURL=index.js.map

package/dist/phpdoc-parser/ast/abstract-node-visitor.d.ts

@@ -0,0 +1,8 @@
+import { Node } from './node';
+import { NodeTraverserBeforeAfterReturn, NodeTraverserEnterReturn, NodeTraverserLeaveReturn, NodeVisitor } from './node-visitor';
+export declare abstract class AbstractNodeVisitor implements NodeVisitor {
+    beforeTraverse(_nodes: Node[]): NodeTraverserBeforeAfterReturn;
+    enterNode(_node: Node): NodeTraverserEnterReturn;
+    leaveNode(_node: Node): NodeTraverserLeaveReturn;
+    afterTraverse(_nodes: Node[]): NodeTraverserBeforeAfterReturn;
+}

package/dist/phpdoc-parser/ast/abstract-node-visitor.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractNodeVisitor = void 0;
+class AbstractNodeVisitor {
+    beforeTraverse(_nodes) {
+        return null;
+    }
+    enterNode(_node) {
+        return null;
+    }
+    leaveNode(_node) {
+        return null;
+    }
+    afterTraverse(_nodes) {
+        return null;
+    }
+}
+exports.AbstractNodeVisitor = AbstractNodeVisitor;

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

@@ -0,0 +1,10 @@
+import { Node } from './node';
+export declare abstract class BaseNode implements Node {
+    private attributes;
+    setAttribute(key: string, value: unknown): void;
+    hasAttribute(key: string): boolean;
+    getAttribute(key: string): unknown;
+    toString(): string;
+    toJSON(): object;
+    abstract getNodeType(): string;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseNode = void 0;
+class BaseNode {
+    constructor() {
+        this.attributes = {};
+    }
+    setAttribute(key, value) {
+        this.attributes[key] = value;
+    }
+    hasAttribute(key) {
+        return this.attributes.hasOwnProperty(key);
+    }
+    getAttribute(key) {
+        if (this.hasAttribute(key)) {
+            return this.attributes[key];
+        }
+        return null;
+    }
+    toString() {
+        throw new Error('Not yet implemented');
+    }
+    toJSON() {
+        return Object.assign({ nodeType: this.getNodeType() }, this);
+    }
+}
+exports.BaseNode = BaseNode;

package/dist/phpdoc-parser/ast/const-expr/const-expr-array-item-node.d.ts

@@ -0,0 +1,8 @@
+import { ConstExprNode } from './const-expr-node';
+export declare class ConstExprArrayItemNode extends ConstExprNode {
+    key: ConstExprNode | null;
+    value: ConstExprNode;
+    constructor(key: ConstExprNode | null, value: ConstExprNode);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/const-expr-array-item-node.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprArrayItemNode = void 0;
+const const_expr_node_1 = require("./const-expr-node");
+class ConstExprArrayItemNode extends const_expr_node_1.ConstExprNode {
+    constructor(key, value) {
+        super();
+        this.key = key;
+        this.value = value;
+    }
+    toString() {
+        if (this.key !== null) {
+            return `${this.key.toString()} =>  ${this.value.toString()}`;
+        }
+        return this.value.toString();
+    }
+    getNodeType() {
+        return 'ConstExprArrayItemNode';
+    }
+}
+exports.ConstExprArrayItemNode = ConstExprArrayItemNode;

package/dist/phpdoc-parser/ast/const-expr/const-expr-array-node.d.ts

@@ -0,0 +1,8 @@
+import { ConstExprArrayItemNode } from './const-expr-array-item-node';
+import { ConstExprNode } from './const-expr-node';
+export declare class ConstExprArrayNode extends ConstExprNode {
+    items: ConstExprArrayItemNode[];
+    constructor(items: ConstExprArrayItemNode[]);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/const-expr-array-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprArrayNode = void 0;
+const const_expr_node_1 = require("./const-expr-node");
+class ConstExprArrayNode extends const_expr_node_1.ConstExprNode {
+    constructor(items) {
+        super();
+        this.items = items;
+    }
+    toString() {
+        return `[${this.items.join(',')}]`;
+    }
+    getNodeType() {
+        return 'ConstExprArrayNode';
+    }
+}
+exports.ConstExprArrayNode = ConstExprArrayNode;

package/dist/phpdoc-parser/ast/const-expr/const-expr-false-node.d.ts

@@ -0,0 +1,5 @@
+import { ConstExprNode } from './const-expr-node';
+export declare class ConstExprFalseNode extends ConstExprNode {
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/const-expr-false-node.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprFalseNode = void 0;
+const const_expr_node_1 = require("./const-expr-node");
+class ConstExprFalseNode extends const_expr_node_1.ConstExprNode {
+    toString() {
+        return 'false';
+    }
+    getNodeType() {
+        return 'ConstExprFalseNode';
+    }
+}
+exports.ConstExprFalseNode = ConstExprFalseNode;

package/dist/phpdoc-parser/ast/const-expr/const-expr-float-node.d.ts

@@ -0,0 +1,7 @@
+import { ConstExprNode } from './const-expr-node';
+export declare class ConstExprFloatNode extends ConstExprNode {
+    value: string;
+    constructor(value: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/const-expr-float-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprFloatNode = void 0;
+const const_expr_node_1 = require("./const-expr-node");
+class ConstExprFloatNode extends const_expr_node_1.ConstExprNode {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return this.value;
+    }
+    getNodeType() {
+        return 'ConstExprFloatNode';
+    }
+}
+exports.ConstExprFloatNode = ConstExprFloatNode;

package/dist/phpdoc-parser/ast/const-expr/const-expr-integer-node.d.ts

@@ -0,0 +1,7 @@
+import { ConstExprNode } from './const-expr-node';
+export declare class ConstExprIntegerNode extends ConstExprNode {
+    value: string;
+    constructor(value: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/const-expr-integer-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprIntegerNode = void 0;
+const const_expr_node_1 = require("./const-expr-node");
+class ConstExprIntegerNode extends const_expr_node_1.ConstExprNode {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return this.value;
+    }
+    getNodeType() {
+        return 'ConstExprIntegerNode';
+    }
+}
+exports.ConstExprIntegerNode = ConstExprIntegerNode;

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

@@ -0,0 +1,25 @@
+import type { ConstExprArrayItemNode } from './const-expr-array-item-node';
+import type { ConstExprArrayNode } from './const-expr-array-node';
+import type { ConstExprFalseNode } from './const-expr-false-node';
+import type { ConstExprFloatNode } from './const-expr-float-node';
+import type { ConstExprIntegerNode } from './const-expr-integer-node';
+import type { ConstExprNullNode } from './const-expr-null-node';
+import type { ConstExprStringNode } from './const-expr-string-node';
+import type { ConstExprTrueNode } from './const-expr-true-node';
+import type { ConstFetchNode } from './const-fetch-node';
+import type { QuoteAwareConstExprStringNode } from './quote-aware-const-expr-string-node';
+import { BaseNode } from '../base-node';
+export declare class ConstExprNode extends BaseNode {
+    getNodeType(): string;
+    isConstExprFloatNode(): this is ConstExprFloatNode;
+    isConstFetchNode(): this is ConstFetchNode;
+    isConstExprArrayItemNode(): this is ConstExprArrayItemNode;
+    isConstExprFalseNode(): this is ConstExprFalseNode;
+    isQuoteAwareConstExprStringNode(): this is QuoteAwareConstExprStringNode;
+    isConstExprNullNode(): this is ConstExprNullNode;
+    isConstExprIntegerNode(): this is ConstExprIntegerNode;
+    isConstExprNode(): this is ConstExprNode;
+    isConstExprArrayNode(): this is ConstExprArrayNode;
+    isConstExprStringNode(): this is ConstExprStringNode;
+    isConstExprTrueNode(): this is ConstExprTrueNode;
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprNode = void 0;
+const base_node_1 = require("../base-node");
+class ConstExprNode extends base_node_1.BaseNode {
+    getNodeType() {
+        return 'ConstExprNode';
+    }
+    isConstExprFloatNode() {
+        return this.getNodeType() === 'ConstExprFloatNode';
+    }
+    isConstFetchNode() {
+        return this.getNodeType() === 'ConstFetchNode';
+    }
+    isConstExprArrayItemNode() {
+        return this.getNodeType() === 'ConstExprArrayItemNode';
+    }
+    isConstExprFalseNode() {
+        return this.getNodeType() === 'ConstExprFalseNode';
+    }
+    isQuoteAwareConstExprStringNode() {
+        return this.getNodeType() === 'QuoteAwareConstExprStringNode';
+    }
+    isConstExprNullNode() {
+        return this.getNodeType() === 'ConstExprNullNode';
+    }
+    isConstExprIntegerNode() {
+        return this.getNodeType() === 'ConstExprIntegerNode';
+    }
+    isConstExprNode() {
+        return this.getNodeType() === 'ConstExprNode';
+    }
+    isConstExprArrayNode() {
+        return this.getNodeType() === 'ConstExprArrayNode';
+    }
+    isConstExprStringNode() {
+        return this.getNodeType() === 'ConstExprStringNode';
+    }
+    isConstExprTrueNode() {
+        return this.getNodeType() === 'ConstExprTrueNode';
+    }
+}
+exports.ConstExprNode = ConstExprNode;

package/dist/phpdoc-parser/ast/const-expr/const-expr-null-node.d.ts

@@ -0,0 +1,5 @@
+import { ConstExprNode } from './const-expr-node';
+export declare class ConstExprNullNode extends ConstExprNode {
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/const-expr-null-node.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprNullNode = void 0;
+const const_expr_node_1 = require("./const-expr-node");
+class ConstExprNullNode extends const_expr_node_1.ConstExprNode {
+    toString() {
+        return 'null';
+    }
+    getNodeType() {
+        return 'ConstExprNullNode';
+    }
+}
+exports.ConstExprNullNode = ConstExprNullNode;

package/dist/phpdoc-parser/ast/const-expr/const-expr-string-node.d.ts

@@ -0,0 +1,7 @@
+import { ConstExprNode } from './const-expr-node';
+export declare class ConstExprStringNode extends ConstExprNode {
+    value: string;
+    constructor(value: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/const-expr-string-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprStringNode = void 0;
+const const_expr_node_1 = require("./const-expr-node");
+class ConstExprStringNode extends const_expr_node_1.ConstExprNode {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return this.value;
+    }
+    getNodeType() {
+        return 'ConstExprStringNode';
+    }
+}
+exports.ConstExprStringNode = ConstExprStringNode;

package/dist/phpdoc-parser/ast/const-expr/const-expr-true-node.d.ts

@@ -0,0 +1,5 @@
+import { ConstExprNode } from './const-expr-node';
+export declare class ConstExprTrueNode extends ConstExprNode {
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/const-expr-true-node.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstExprTrueNode = void 0;
+const const_expr_node_1 = require("./const-expr-node");
+class ConstExprTrueNode extends const_expr_node_1.ConstExprNode {
+    toString() {
+        return 'true';
+    }
+    getNodeType() {
+        return 'ConstExprTrueNode';
+    }
+}
+exports.ConstExprTrueNode = ConstExprTrueNode;

package/dist/phpdoc-parser/ast/const-expr/const-fetch-node.d.ts

@@ -0,0 +1,8 @@
+import { ConstExprNode } from './const-expr-node';
+export declare class ConstFetchNode extends ConstExprNode {
+    className: string;
+    name: string;
+    constructor(className: string, name: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/const-fetch-node.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstFetchNode = void 0;
+const const_expr_node_1 = require("./const-expr-node");
+class ConstFetchNode extends const_expr_node_1.ConstExprNode {
+    constructor(className, name) {
+        super();
+        this.className = className;
+        this.name = name;
+    }
+    toString() {
+        if (this.className === '') {
+            return this.name;
+        }
+        return `${this.className}::${this.name}`;
+    }
+    getNodeType() {
+        return 'ConstFetchNode';
+    }
+}
+exports.ConstFetchNode = ConstFetchNode;

package/dist/phpdoc-parser/ast/const-expr/quote-aware-const-expr-string-node.d.ts

@@ -0,0 +1,10 @@
+import { ConstExprStringNode } from './const-expr-string-node';
+export declare class QuoteAwareConstExprStringNode extends ConstExprStringNode {
+    static readonly SINGLE_QUOTED = 1;
+    static readonly DOUBLE_QUOTED = 2;
+    quoteType: number;
+    constructor(value: string, quoteType: number);
+    toString(): string;
+    private escapeDoubleQuotedString;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/const-expr/quote-aware-const-expr-string-node.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuoteAwareConstExprStringNode = void 0;
+const const_expr_string_node_1 = require("./const-expr-string-node");
+class QuoteAwareConstExprStringNode extends const_expr_string_node_1.ConstExprStringNode {
+    constructor(value, quoteType) {
+        super(value);
+        this.quoteType = quoteType;
+    }
+    toString() {
+        if (this.quoteType === QuoteAwareConstExprStringNode.SINGLE_QUOTED) {
+            return `'${this.value.replace(/'/g, "\\'")}'`;
+        }
+        return `"${this.escapeDoubleQuotedString()}"`;
+    }
+    escapeDoubleQuotedString() {
+        let escaped = this.value.replace(/["\n\r\t\x0B\f\v\\$]/g, '\\$&');
+        const regexes = [
+            /[\x00-\x08\x0E-\x1F]/g,
+            /[\xC0-\xC1]/g,
+            /[\xF5-\xFF]/g,
+            /\xE0[\x80-\x9F]/g,
+            /\xF0[\x80-\x8F]/g,
+            /[\xC2-\xDF](?![\x80-\xBF])/g,
+            /[\xE0-\xEF](?![\x80-\xBF]{2})/g,
+            /[\xF0-\xF4](?![\x80-\xBF]{3})/g,
+            /(?<=[\x00-\x7F\xF5-\xFF])[\x80-\xBF]/g,
+            /(?<![\xC2-\xDF]|[\xE0-\xEF]|[\xE0-\xEF][\x80-\xBF]|[\xF0-\xF4]|[\xF0-\xF4][\x80-\xBF]|[\xF0-\xF4][\x80-\xBF]{2})[\x80-\xBF]/g,
+            /(?<=[\xE0-\xEF])[\x80-\xBF](?![\x80-\xBF])/g,
+            /(?<=[\xF0-\xF4])[\x80-\xBF](?![\x80-\xBF]{2})/g,
+            /(?<=[\xF0-\xF4][\x80-\xBF])[\x80-\xBF](?![\x80-\xBF])/g,
+        ];
+        for (const regex of regexes) {
+            escaped = escaped.replace(regex, (match) => {
+                const hex = match.charCodeAt(0).toString(16);
+                return `\\x${'0'.repeat(2 - hex.length) + hex}`;
+            });
+        }
+        return escaped;
+    }
+    getNodeType() {
+        return 'QuoteAwareConstExprStringNode';
+    }
+}
+exports.QuoteAwareConstExprStringNode = QuoteAwareConstExprStringNode;
+QuoteAwareConstExprStringNode.SINGLE_QUOTED = 1;
+QuoteAwareConstExprStringNode.DOUBLE_QUOTED = 2;

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

@@ -0,0 +1,11 @@
+import { Node } from './node';
+import { NodeVisitor } from './node-visitor';
+export declare class NodeTraverser {
+    private visitors;
+    private stopTraversal;
+    constructor(visitors: NodeVisitor[]);
+    traverse(nodes: Node[]): Node[];
+    private traverseNode;
+    private traverseArray;
+    private ensureReplacementReasonable;
+}