@renovatebot/good-enough-parser 1.1.24 → 1.2.0

package/dist/esm/query/matchers/tree-matcher.js

@@ -1,118 +1,118 @@
-import { isTree } from '../../parser';
-import { safeHandler } from '../handler';
-import { AbstractMatcher } from './abstract-matcher';
-export class TreeMatcher extends AbstractMatcher {
-    constructor(config) {
-        var _a, _b, _c;
-        super();
-        this.walkDepth = 0;
-        this.matchCount = 0;
-        this.type = (_a = config.type) !== null && _a !== void 0 ? _a : null;
-        this.startsWithValue = (_b = config.startsWith) !== null && _b !== void 0 ? _b : null;
-        this.endsWithValue = (_c = config.endsWith) !== null && _c !== void 0 ? _c : null;
-        this.matcher = config.matcher;
-        this.maxDepth =
-            typeof config.maxDepth === 'number' && config.maxDepth > 0
-                ? config.maxDepth
-                : 1024;
-        this.maxMatches =
-            typeof config.maxMatches === 'number' && config.maxMatches > 0
-                ? config.maxMatches
-                : 1024 * 1024;
-        this.preHandler = safeHandler(config.preHandler);
-        this.postHandler = safeHandler(config.postHandler);
-    }
-    walkToNextSignificantNode(cursor) {
-        const downCursor = cursor.down;
-        if (downCursor && this.walkDepth < this.maxDepth) {
-            this.walkDepth += 1;
-            return downCursor;
-        }
-        let rightCursor = cursor.right;
-        if (rightCursor) {
-            rightCursor = this.matcher
-                ? this.matcher.seekNext(rightCursor)
-                : this.seekNext(rightCursor);
-            if (rightCursor) {
-                return rightCursor;
-            }
-        }
-        const canMoveUp = this.walkDepth > 1;
-        let upperCursor = canMoveUp ? cursor.up : undefined;
-        while (upperCursor && canMoveUp) {
-            rightCursor = upperCursor.right;
-            if (rightCursor) {
-                rightCursor = this.matcher
-                    ? this.matcher.seekNext(rightCursor)
-                    : this.seekNext(rightCursor);
-                if (rightCursor) {
-                    upperCursor = rightCursor;
-                    break;
-                }
-            }
-            upperCursor = upperCursor.up;
-        }
-        if (upperCursor) {
-            this.walkDepth -= 1;
-            return upperCursor;
-        }
-        return undefined;
-    }
-    walkToNextMatch(context, cursor) {
-        if (!cursor || !this.matcher) {
-            return undefined;
-        }
-        let nextCursor = this.walkToNextSignificantNode(cursor);
-        while (nextCursor) {
-            const match = this.matcher.match({ cursor: nextCursor, context });
-            if (match) {
-                this.matchCount += 1;
-                return match;
-            }
-            nextCursor = this.walkToNextSignificantNode(nextCursor);
-        }
-        return undefined;
-    }
-    match(checkpoint) {
-        this.walkDepth = 0;
-        this.matchCount = 0;
-        const rootCursor = this.seekNext(checkpoint.cursor);
-        const rootNode = rootCursor.node;
-        if (isTree(rootNode)) {
-            if (this.type && this.type !== rootNode.type) {
-                return null;
-            }
-            if (this.type === 'wrapped-tree') {
-                const currentTree = rootNode;
-                if (this.startsWithValue &&
-                    currentTree.startsWith.value !== this.startsWithValue) {
-                    return null;
-                }
-                if (this.endsWithValue &&
-                    currentTree.endsWith.value !== this.endsWithValue) {
-                    return null;
-                }
-            }
-            let context = checkpoint.context;
-            context = this.preHandler(context, rootNode);
-            if (this.matcher) {
-                let nextMatch = this.walkToNextMatch(context, rootCursor);
-                while (nextMatch) {
-                    context = nextMatch.context;
-                    if (this.matchCount === this.maxMatches) {
-                        break;
-                    }
-                    nextMatch = this.walkToNextMatch(context, nextMatch.cursor);
-                }
-                if (this.matchCount === 0) {
-                    return null;
-                }
-            }
-            context = this.postHandler(context, rootNode);
-            const cursor = rootNode.type === 'root-tree' ? rootCursor : this.moveRight(rootCursor);
-            return { context, cursor };
-        }
-        return null;
-    }
-}
+import { isTree } from '../../parser';
+import { safeHandler } from '../handler';
+import { AbstractMatcher } from './abstract-matcher';
+export class TreeMatcher extends AbstractMatcher {
+    constructor(config) {
+        var _a, _b, _c;
+        super();
+        this.walkDepth = 0;
+        this.matchCount = 0;
+        this.type = (_a = config.type) !== null && _a !== void 0 ? _a : null;
+        this.startsWithValue = (_b = config.startsWith) !== null && _b !== void 0 ? _b : null;
+        this.endsWithValue = (_c = config.endsWith) !== null && _c !== void 0 ? _c : null;
+        this.matcher = config.matcher;
+        this.maxDepth =
+            typeof config.maxDepth === 'number' && config.maxDepth > 0
+                ? config.maxDepth
+                : 1024;
+        this.maxMatches =
+            typeof config.maxMatches === 'number' && config.maxMatches > 0
+                ? config.maxMatches
+                : 1024 * 1024;
+        this.preHandler = safeHandler(config.preHandler);
+        this.postHandler = safeHandler(config.postHandler);
+    }
+    walkToNextSignificantNode(cursor) {
+        const downCursor = cursor.down;
+        if (downCursor && this.walkDepth < this.maxDepth) {
+            this.walkDepth += 1;
+            return downCursor;
+        }
+        let rightCursor = cursor.right;
+        if (rightCursor) {
+            rightCursor = this.matcher
+                ? this.matcher.seekNext(rightCursor)
+                : this.seekNext(rightCursor);
+            if (rightCursor) {
+                return rightCursor;
+            }
+        }
+        const canMoveUp = this.walkDepth > 1;
+        let upperCursor = canMoveUp ? cursor.up : undefined;
+        while (upperCursor && canMoveUp) {
+            rightCursor = upperCursor.right;
+            if (rightCursor) {
+                rightCursor = this.matcher
+                    ? this.matcher.seekNext(rightCursor)
+                    : this.seekNext(rightCursor);
+                if (rightCursor) {
+                    upperCursor = rightCursor;
+                    break;
+                }
+            }
+            upperCursor = upperCursor.up;
+        }
+        if (upperCursor) {
+            this.walkDepth -= 1;
+            return upperCursor;
+        }
+        return undefined;
+    }
+    walkToNextMatch(context, cursor) {
+        if (!cursor || !this.matcher) {
+            return undefined;
+        }
+        let nextCursor = this.walkToNextSignificantNode(cursor);
+        while (nextCursor) {
+            const match = this.matcher.match({ cursor: nextCursor, context });
+            if (match) {
+                this.matchCount += 1;
+                return match;
+            }
+            nextCursor = this.walkToNextSignificantNode(nextCursor);
+        }
+        return undefined;
+    }
+    match(checkpoint) {
+        this.walkDepth = 0;
+        this.matchCount = 0;
+        const rootCursor = this.seekNext(checkpoint.cursor);
+        const rootNode = rootCursor.node;
+        if (isTree(rootNode)) {
+            if (this.type && this.type !== rootNode.type) {
+                return null;
+            }
+            if (this.type === 'wrapped-tree') {
+                const currentTree = rootNode;
+                if (this.startsWithValue &&
+                    currentTree.startsWith.value !== this.startsWithValue) {
+                    return null;
+                }
+                if (this.endsWithValue &&
+                    currentTree.endsWith.value !== this.endsWithValue) {
+                    return null;
+                }
+            }
+            let context = checkpoint.context;
+            context = this.preHandler(context, rootNode);
+            if (this.matcher) {
+                let nextMatch = this.walkToNextMatch(context, rootCursor);
+                while (nextMatch) {
+                    context = nextMatch.context;
+                    if (this.matchCount === this.maxMatches) {
+                        break;
+                    }
+                    nextMatch = this.walkToNextMatch(context, nextMatch.cursor);
+                }
+                if (this.matchCount === 0) {
+                    return null;
+                }
+            }
+            context = this.postHandler(context, rootNode);
+            const cursor = rootNode.type === 'root-tree' ? rootCursor : this.moveRight(rootCursor);
+            return { context, cursor };
+        }
+        return null;
+    }
+}
 //# sourceMappingURL=tree-matcher.js.map

package/dist/esm/query/options.d.ts

@@ -1,11 +1,11 @@
-import type { Node, TreeType } from '../parser/types';
-import type { StrContentMatcherHandler } from './matchers/str-matcher';
-import type { CommentMatcherHandler, CommentMatcherOptions, CommentMatcherValue, ManyBuilderOpts, NumMatcherHandler, NumMatcherOptions, NumMatcherValue, OpMatcherHandler, OpMatcherOptions, OpMatcherValue, QueryBuilder, StrBuilderOptions, StrBuilderOptionsBase, SymMatcherHandler, SymMatcherOptions, SymMatcherValue, TreeBuilderOptions } from './types';
-export declare function coerceSymOptions<Ctx>(arg1?: SymMatcherValue | SymMatcherOptions<Ctx> | SymMatcherHandler<Ctx>, arg2?: SymMatcherHandler<Ctx>): SymMatcherOptions<Ctx>;
-export declare function coerceOpOptions<Ctx>(arg1?: OpMatcherValue | OpMatcherOptions<Ctx> | OpMatcherHandler<Ctx>, arg2?: OpMatcherHandler<Ctx>): OpMatcherOptions<Ctx>;
-export declare function coerceCommentOptions<Ctx>(arg1?: CommentMatcherValue | CommentMatcherOptions<Ctx> | CommentMatcherHandler<Ctx>, arg2?: CommentMatcherHandler<Ctx>): CommentMatcherOptions<Ctx>;
-export declare function coerceNumOptions<Ctx>(arg1?: NumMatcherValue | NumMatcherOptions<Ctx> | NumMatcherHandler<Ctx>, arg2?: NumMatcherHandler<Ctx>): NumMatcherOptions<Ctx>;
-export declare function coerceManyOptions<Ctx>(builder: QueryBuilder<Ctx, Node>, arg2?: number, arg3?: number): ManyBuilderOpts<Ctx>;
-export declare function coerceTreeOptions<Ctx>(arg1: TreeBuilderOptions<Ctx> | TreeType | undefined): TreeBuilderOptions<Ctx>;
-export declare function coerceStrOptions<Ctx>(arg1: string | RegExp | StrContentMatcherHandler<Ctx> | StrBuilderOptionsBase<Ctx> | undefined, arg2: StrContentMatcherHandler<Ctx> | undefined): StrBuilderOptions<Ctx>;
+import type { Node, TreeType } from '../parser/types';
+import type { StrContentMatcherHandler } from './matchers/str-matcher';
+import type { CommentMatcherHandler, CommentMatcherOptions, CommentMatcherValue, ManyBuilderOpts, NumMatcherHandler, NumMatcherOptions, NumMatcherValue, OpMatcherHandler, OpMatcherOptions, OpMatcherValue, QueryBuilder, StrBuilderOptions, StrBuilderOptionsBase, SymMatcherHandler, SymMatcherOptions, SymMatcherValue, TreeBuilderOptions } from './types';
+export declare function coerceSymOptions<Ctx>(arg1?: SymMatcherValue | SymMatcherOptions<Ctx> | SymMatcherHandler<Ctx>, arg2?: SymMatcherHandler<Ctx>): SymMatcherOptions<Ctx>;
+export declare function coerceOpOptions<Ctx>(arg1?: OpMatcherValue | OpMatcherOptions<Ctx> | OpMatcherHandler<Ctx>, arg2?: OpMatcherHandler<Ctx>): OpMatcherOptions<Ctx>;
+export declare function coerceCommentOptions<Ctx>(arg1?: CommentMatcherValue | CommentMatcherOptions<Ctx> | CommentMatcherHandler<Ctx>, arg2?: CommentMatcherHandler<Ctx>): CommentMatcherOptions<Ctx>;
+export declare function coerceNumOptions<Ctx>(arg1?: NumMatcherValue | NumMatcherOptions<Ctx> | NumMatcherHandler<Ctx>, arg2?: NumMatcherHandler<Ctx>): NumMatcherOptions<Ctx>;
+export declare function coerceManyOptions<Ctx>(builder: QueryBuilder<Ctx, Node>, arg2?: number, arg3?: number): ManyBuilderOpts<Ctx>;
+export declare function coerceTreeOptions<Ctx>(arg1: TreeBuilderOptions<Ctx> | TreeType | undefined): TreeBuilderOptions<Ctx>;
+export declare function coerceStrOptions<Ctx>(arg1: string | RegExp | StrContentMatcherHandler<Ctx> | StrBuilderOptionsBase<Ctx> | undefined, arg2: StrContentMatcherHandler<Ctx> | undefined): StrBuilderOptions<Ctx>;
 //# sourceMappingURL=options.d.ts.map

package/dist/esm/query/options.js

@@ -1,140 +1,140 @@
-import { isRegex } from './regex';
-export function coerceSymOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || isRegex(arg1)) {
-        return {
-            value: arg1,
-            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
-        };
-    }
-    if (typeof arg1 === 'function') {
-        return {
-            value: null,
-            handler: arg1,
-        };
-    }
-    if (arg1 !== null && typeof arg1 === 'object') {
-        return arg1;
-    }
-    return { value: null, handler: null };
-}
-export function coerceOpOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || isRegex(arg1)) {
-        return {
-            value: arg1,
-            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
-        };
-    }
-    if (typeof arg1 === 'function') {
-        return {
-            value: null,
-            handler: arg1,
-        };
-    }
-    if (arg1 !== null && typeof arg1 === 'object') {
-        return arg1;
-    }
-    return { value: null, handler: null };
-}
-export function coerceCommentOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || isRegex(arg1)) {
-        return {
-            value: arg1,
-            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
-        };
-    }
-    if (typeof arg1 === 'function') {
-        return {
-            value: null,
-            handler: arg1,
-        };
-    }
-    if (arg1 !== null && typeof arg1 === 'object') {
-        return arg1;
-    }
-    return { value: null, handler: null };
-}
-export function coerceNumOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || isRegex(arg1)) {
-        return {
-            value: arg1,
-            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
-        };
-    }
-    if (typeof arg1 === 'function') {
-        return {
-            value: null,
-            handler: arg1,
-        };
-    }
-    if (arg1 !== null && typeof arg1 === 'object') {
-        return arg1;
-    }
-    return { value: null, handler: null };
-}
-export function coerceManyOptions(builder, arg2, arg3) {
-    if (typeof arg2 === 'number' && typeof arg3 === 'number') {
-        return { builder, min: arg2, max: arg3 };
-    }
-    return { builder, min: 1, max: null };
-}
-export function coerceTreeOptions(arg1) {
-    if (typeof arg1 === 'string') {
-        return { type: arg1 };
-    }
-    else if (!arg1) {
-        return { type: null };
-    }
-    else {
-        return arg1;
-    }
-}
-export function coerceStrOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || isRegex(arg1)) {
-        if (arg1 === '') {
-            return {
-                type: 'str-tree',
-                match: [],
-                postHandler: arg2
-                    ? (ctx, tree) => arg2(ctx, {
-                        ...tree.startsWith,
-                        type: 'string-value',
-                        value: arg1,
-                    })
-                    : null,
-            };
-        }
-        return {
-            type: 'str-content',
-            match: arg1,
-            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
-        };
-    }
-    else if (typeof arg1 === 'function') {
-        return {
-            type: 'str-content',
-            match: null,
-            handler: arg1,
-        };
-    }
-    else if (arg1) {
-        if (arg1['handler'] ||
-            typeof arg1.match === 'string' ||
-            isRegex(arg1.match)) {
-            return {
-                type: 'str-content',
-                ...arg1,
-            };
-        }
-        return {
-            type: 'str-tree',
-            ...arg1,
-        };
-    }
-    return {
-        type: 'str-tree',
-        match: null,
-        preHandler: null,
-        postHandler: null,
-    };
-}
+import { isRegex } from './regex';
+export function coerceSymOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || isRegex(arg1)) {
+        return {
+            value: arg1,
+            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
+        };
+    }
+    if (typeof arg1 === 'function') {
+        return {
+            value: null,
+            handler: arg1,
+        };
+    }
+    if (arg1 !== null && typeof arg1 === 'object') {
+        return arg1;
+    }
+    return { value: null, handler: null };
+}
+export function coerceOpOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || isRegex(arg1)) {
+        return {
+            value: arg1,
+            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
+        };
+    }
+    if (typeof arg1 === 'function') {
+        return {
+            value: null,
+            handler: arg1,
+        };
+    }
+    if (arg1 !== null && typeof arg1 === 'object') {
+        return arg1;
+    }
+    return { value: null, handler: null };
+}
+export function coerceCommentOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || isRegex(arg1)) {
+        return {
+            value: arg1,
+            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
+        };
+    }
+    if (typeof arg1 === 'function') {
+        return {
+            value: null,
+            handler: arg1,
+        };
+    }
+    if (arg1 !== null && typeof arg1 === 'object') {
+        return arg1;
+    }
+    return { value: null, handler: null };
+}
+export function coerceNumOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || isRegex(arg1)) {
+        return {
+            value: arg1,
+            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
+        };
+    }
+    if (typeof arg1 === 'function') {
+        return {
+            value: null,
+            handler: arg1,
+        };
+    }
+    if (arg1 !== null && typeof arg1 === 'object') {
+        return arg1;
+    }
+    return { value: null, handler: null };
+}
+export function coerceManyOptions(builder, arg2, arg3) {
+    if (typeof arg2 === 'number' && typeof arg3 === 'number') {
+        return { builder, min: arg2, max: arg3 };
+    }
+    return { builder, min: 1, max: null };
+}
+export function coerceTreeOptions(arg1) {
+    if (typeof arg1 === 'string') {
+        return { type: arg1 };
+    }
+    else if (!arg1) {
+        return { type: null };
+    }
+    else {
+        return arg1;
+    }
+}
+export function coerceStrOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || isRegex(arg1)) {
+        if (arg1 === '') {
+            return {
+                type: 'str-tree',
+                match: [],
+                postHandler: arg2
+                    ? (ctx, tree) => arg2(ctx, {
+                        ...tree.startsWith,
+                        type: 'string-value',
+                        value: arg1,
+                    })
+                    : null,
+            };
+        }
+        return {
+            type: 'str-content',
+            match: arg1,
+            handler: arg2 !== null && arg2 !== void 0 ? arg2 : null,
+        };
+    }
+    else if (typeof arg1 === 'function') {
+        return {
+            type: 'str-content',
+            match: null,
+            handler: arg1,
+        };
+    }
+    else if (arg1) {
+        if (arg1['handler'] ||
+            typeof arg1.match === 'string' ||
+            isRegex(arg1.match)) {
+            return {
+                type: 'str-content',
+                ...arg1,
+            };
+        }
+        return {
+            type: 'str-tree',
+            ...arg1,
+        };
+    }
+    return {
+        type: 'str-tree',
+        match: null,
+        preHandler: null,
+        postHandler: null,
+    };
+}
 //# sourceMappingURL=options.js.map

package/dist/esm/query/regex.d.ts

@@ -1,2 +1,2 @@
-export declare function isRegex(input: unknown): input is RegExp;
+export declare function isRegex(input: unknown): input is RegExp;
 //# sourceMappingURL=regex.d.ts.map

package/dist/esm/query/regex.js

@@ -1,10 +1,10 @@
-export function isRegex(input) {
-    if (input instanceof RegExp) {
-        return true;
-    }
-    if (input && typeof input === 'object' && input.constructor.name === 'RE2') {
-        return true;
-    }
-    return false;
-}
+export function isRegex(input) {
+    if (input instanceof RegExp) {
+        return true;
+    }
+    if (input && typeof input === 'object' && input.constructor.name === 'RE2') {
+        return true;
+    }
+    return false;
+}
 //# sourceMappingURL=regex.js.map