@rightcapital/phpdoc-parser 0.6.2-renovate-lock-file-maintenance.2572.1.0 → 0.6.2

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

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringUnescaper = void 0;
-class StringUnescaper {
-    static unescapeString(input) {
-        const quote = input[0];
-        if (quote === "'") {
-            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);
-        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]) {
-                return this.REPLACEMENTS[firstCaptureGroup];
-            }
-            if (firstCaptureGroup[0] === 'x' || firstCaptureGroup[0] === 'X') {
-                return String.fromCharCode(parseInt(firstCaptureGroup.slice(1), 16));
-            }
-            if (firstCaptureGroup[0] === 'u') {
-                return String.fromCharCode(parseInt(matches[1], 16));
-            }
-            return String.fromCharCode(parseInt(firstCaptureGroup, 8));
-        });
-    }
-    getType() {
-        return 'Scalar_String';
-    }
-}
-exports.StringUnescaper = StringUnescaper;
-StringUnescaper.REPLACEMENTS = {
-    '\\': '\\',
-    n: '\n',
-    r: '\r',
-    t: '\t',
-    f: '\f',
-    v: '\v',
-    e: '\x1B',
-};

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

@@ -1,44 +0,0 @@
-import { Comment } from '../ast/comment';
-export declare class TokenIterator {
-    private tokens;
-    private index;
-    private comments;
-    private savePoints;
-    private skippedTokenTypes;
-    private newline;
-    constructor(tokens: Array<[string, string, number]>, index?: number);
-    getTokens(): Array<[string, string, number]>;
-    getContentBetween(startPos: number, endPos: number): string;
-    getTokenCount(): number;
-    currentTokenValue(): string;
-    currentTokenType(): string;
-    currentTokenOffset(): number;
-    currentTokenLine(): number;
-    currentTokenIndex(): number;
-    endIndexOfLastRelevantToken(): number;
-    isCurrentTokenValue(tokenValue: string): boolean;
-    isCurrentTokenType(...tokenType: string[]): boolean;
-    isPrecededByHorizontalWhitespace(): boolean;
-    consumeTokenType(tokenType: string): void;
-    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;
-    next(): void;
-    private skipIrrelevantTokens;
-    addEndOfLineToSkippedTokens(): void;
-    removeEndOfLineFromSkippedTokens(): void;
-    forwardToTheEnd(): void;
-    pushSavePoint(): void;
-    dropSavePoint(): void;
-    rollback(): void;
-    throwError(expectedTokenType: string, expectedTokenValue?: string | null): void;
-    hasTokenImmediatelyBefore(pos: number, expectedTokenType: string): boolean;
-    hasTokenImmediatelyAfter(pos: number, expectedTokenType: string): boolean;
-    getDetectedNewline(): string | null;
-    hasParentheses(startPos: number, endPos: number): boolean;
-}

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

@@ -1,243 +0,0 @@
-"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;
-        this.tokens = tokens;
-        this.index = index;
-        this.skipIrrelevantTokens();
-    }
-    getTokens() {
-        return this.tokens;
-    }
-    getContentBetween(startPos, endPos) {
-        if (startPos < 0 || endPos > this.tokens.length) {
-            throw new Error('LogicException');
-        }
-        let content = '';
-        for (let i = startPos; i < endPos; i++) {
-            content += this.tokens[i][lexer_1.Lexer.VALUE_OFFSET];
-        }
-        return content;
-    }
-    getTokenCount() {
-        return this.tokens.length;
-    }
-    currentTokenValue() {
-        return this.tokens[this.index][lexer_1.Lexer.VALUE_OFFSET];
-    }
-    currentTokenType() {
-        return this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET];
-    }
-    currentTokenOffset() {
-        let offset = 0;
-        for (let i = 0; i < this.index; i++) {
-            offset += this.tokens[i][lexer_1.Lexer.VALUE_OFFSET].length;
-        }
-        return offset;
-    }
-    currentTokenLine() {
-        return this.tokens[this.index][lexer_1.Lexer.LINE_OFFSET];
-    }
-    currentTokenIndex() {
-        return this.index;
-    }
-    endIndexOfLastRelevantToken() {
-        let endIndex = this.currentTokenIndex();
-        endIndex--;
-        while (this.skippedTokenTypes.includes(this.tokens[endIndex][lexer_1.Lexer.TYPE_OFFSET])) {
-            if (!this.tokens[endIndex - 1]) {
-                break;
-            }
-            endIndex--;
-        }
-        return endIndex;
-    }
-    isCurrentTokenValue(tokenValue) {
-        return this.tokens[this.index][lexer_1.Lexer.VALUE_OFFSET] === tokenValue;
-    }
-    isCurrentTokenType(...tokenType) {
-        return tokenType.includes(this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET]);
-    }
-    isPrecededByHorizontalWhitespace() {
-        var _a, _b;
-        return (((_b = (_a = this.tokens[this.index - 1]) === null || _a === void 0 ? void 0 : _a[lexer_1.Lexer.TYPE_OFFSET]) !== null && _b !== void 0 ? _b : -1) ===
-            lexer_1.Lexer.TOKEN_HORIZONTAL_WS);
-    }
-    consumeTokenType(tokenType) {
-        if (this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET] !== tokenType) {
-            this.throwError(tokenType);
-        }
-        if (tokenType === lexer_1.Lexer.TOKEN_PHPDOC_EOL) {
-            if (this.newline === null) {
-                this.detectNewline();
-            }
-        }
-        this.index++;
-        this.skipIrrelevantTokens();
-    }
-    consumeTokenValue(tokenType, tokenValue) {
-        if (this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET] !== tokenType ||
-            this.tokens[this.index][lexer_1.Lexer.VALUE_OFFSET] !== tokenValue) {
-            this.throwError(tokenType, tokenValue);
-        }
-        this.index++;
-        this.skipIrrelevantTokens();
-    }
-    tryConsumeTokenValue(tokenValue) {
-        if (this.tokens[this.index][lexer_1.Lexer.VALUE_OFFSET] !== tokenValue) {
-            return false;
-        }
-        this.index++;
-        this.skipIrrelevantTokens();
-        return true;
-    }
-    tryConsumeTokenType(tokenType) {
-        if (this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET] !== tokenType) {
-            return false;
-        }
-        if (tokenType === lexer_1.Lexer.TOKEN_PHPDOC_EOL) {
-            if (this.newline === null) {
-                this.detectNewline();
-            }
-        }
-        this.index++;
-        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') {
-            this.newline = '\r\n';
-        }
-        else if (value.substring(0, 1) === '\n') {
-            this.newline = '\n';
-        }
-    }
-    getSkippedHorizontalWhiteSpaceIfAny() {
-        if (this.index > 0 &&
-            this.tokens[this.index - 1][1] === lexer_1.Lexer.TOKEN_HORIZONTAL_WS) {
-            return this.tokens[this.index - 1][0];
-        }
-        return '';
-    }
-    joinUntil(...tokenType) {
-        let s = '';
-        while (!tokenType.includes(this.tokens[this.index][1])) {
-            s += this.tokens[this.index++][0];
-        }
-        return s;
-    }
-    next() {
-        this.index++;
-        this.skipIrrelevantTokens();
-    }
-    skipIrrelevantTokens() {
-        if (this.tokens[this.index] === undefined) {
-            return;
-        }
-        while (this.skippedTokenTypes.includes(this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET])) {
-            if (this.tokens[this.index + 1] === undefined) {
-                break;
-            }
-            this.index++;
-        }
-    }
-    addEndOfLineToSkippedTokens() {
-        this.skippedTokenTypes = [
-            lexer_1.Lexer.TOKEN_HORIZONTAL_WS,
-            lexer_1.Lexer.TOKEN_PHPDOC_EOL,
-        ];
-    }
-    removeEndOfLineFromSkippedTokens() {
-        this.skippedTokenTypes = [lexer_1.Lexer.TOKEN_HORIZONTAL_WS];
-    }
-    forwardToTheEnd() {
-        const lastToken = this.tokens.length - 1;
-        this.index = lastToken;
-    }
-    pushSavePoint() {
-        this.savePoints.push([this.index, [...this.comments]]);
-    }
-    dropSavePoint() {
-        this.savePoints.pop();
-    }
-    rollback() {
-        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());
-    }
-    hasTokenImmediatelyBefore(pos, expectedTokenType) {
-        const { tokens } = this;
-        pos--;
-        for (; pos >= 0; pos--) {
-            const token = tokens[pos];
-            const type = token[1];
-            if (type === expectedTokenType) {
-                return true;
-            }
-            if (![lexer_1.Lexer.TOKEN_HORIZONTAL_WS, lexer_1.Lexer.TOKEN_PHPDOC_EOL].includes(type)) {
-                break;
-            }
-        }
-        return false;
-    }
-    hasTokenImmediatelyAfter(pos, expectedTokenType) {
-        const { tokens } = this;
-        pos++;
-        for (let c = tokens.length; pos < c; pos++) {
-            const token = tokens[pos];
-            const type = token[1];
-            if (type === expectedTokenType) {
-                return true;
-            }
-            if (![lexer_1.Lexer.TOKEN_HORIZONTAL_WS, lexer_1.Lexer.TOKEN_PHPDOC_EOL].includes(type)) {
-                break;
-            }
-        }
-        return false;
-    }
-    getDetectedNewline() {
-        return this.newline;
-    }
-    hasParentheses(startPos, endPos) {
-        return (this.hasTokenImmediatelyBefore(startPos, lexer_1.Lexer.TOKEN_OPEN_PARENTHESES) &&
-            this.hasTokenImmediatelyAfter(endPos, lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES));
-    }
-}
-exports.TokenIterator = TokenIterator;

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

@@ -1,47 +0,0 @@
-import type { BaseNode } from '../ast/base-node';
-import { TemplateTagValueNode } from '../ast/php-doc/template-tag-value-node';
-import { GenericTypeNode } from '../ast/type/generic-type-node';
-import { IdentifierTypeNode } from '../ast/type/identifier-type-node';
-import type { TypeNode } from '../ast/type/type-node';
-import type { ConstExprParser } from './const-expr-parser';
-import type { TokenIterator } from './token-iterator';
-export declare class TypeParser {
-    private constExprParser;
-    private useLinesAttributes;
-    private useIndexAttributes;
-    constructor(constExprParser?: ConstExprParser | null, usedAttributes?: {
-        lines?: boolean;
-        indexes?: boolean;
-    });
-    parse(tokens: TokenIterator): TypeNode;
-    private enrichTypeOnUnionOrIntersection;
-    enrichWithAttributes<T extends BaseNode>(tokens: TokenIterator, type: T, startLine: number, startIndex: number): T;
-    parseTemplateTagValue(tokens: TokenIterator, parseDescription?: (tokens: TokenIterator) => string): TemplateTagValueNode;
-    private subParse;
-    private parseAtomic;
-    private parseUnion;
-    private subParseUnion;
-    private parseIntersection;
-    private subParseIntersection;
-    private parseConditional;
-    private parseConditionalForParameter;
-    private parseNullable;
-    isHtml(tokens: TokenIterator): boolean;
-    parseGeneric(tokens: TokenIterator, baseType: IdentifierTypeNode): GenericTypeNode;
-    private parseGenericTypeArgument;
-    private parseCallable;
-    private parseCallableTemplates;
-    private parseCallableTemplateArgument;
-    private parseCallableParameter;
-    private parseCallableReturnType;
-    private tryParseCallable;
-    private tryParseArrayOrOffsetAccess;
-    private parseArrayShape;
-    private parseArrayShapeItem;
-    private parseArrayShapeKey;
-    private parseArrayShapeUnsealedType;
-    private parseListShapeUnsealedType;
-    private parseObjectShape;
-    private parseObjectShapeItem;
-    private parseObjectShapeKey;
-}