@renovatebot/good-enough-parser 1.1.24 → 1.2.0

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

@@ -1,33 +1,33 @@
-const skipByDefault = [
-    'whitespace',
-    '_start',
-    'newline',
-    'comment',
-];
-export class AbstractMatcher {
-    canSkip(node) {
-        return skipByDefault.includes(node.type);
-    }
-    seekNext(cursor) {
-        let node = cursor.node;
-        while (this.canSkip(node)) {
-            if (!cursor.right) {
-                return cursor;
-            }
-            cursor = cursor.right;
-            node = cursor.node;
-        }
-        return cursor;
-    }
-    moveRight(cursor) {
-        const result = cursor.right;
-        if (result) {
-            return result;
-        }
-        throw new Error('Cursor error: move right');
-    }
-    nextMatch() {
-        return null;
-    }
-}
+const skipByDefault = [
+    'whitespace',
+    '_start',
+    'newline',
+    'comment',
+];
+export class AbstractMatcher {
+    canSkip(node) {
+        return skipByDefault.includes(node.type);
+    }
+    seekNext(cursor) {
+        let node = cursor.node;
+        while (this.canSkip(node)) {
+            if (!cursor.right) {
+                return cursor;
+            }
+            cursor = cursor.right;
+            node = cursor.node;
+        }
+        return cursor;
+    }
+    moveRight(cursor) {
+        const result = cursor.right;
+        if (result) {
+            return result;
+        }
+        throw new Error('Cursor error: move right');
+    }
+    nextMatch() {
+        return null;
+    }
+}
 //# sourceMappingURL=abstract-matcher.js.map

package/dist/esm/query/matchers/alt-matcher.d.ts

@@ -1,11 +1,11 @@
-import type { AltMatcherOptions, Checkpoint, Matcher } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-export declare class AltMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly alts: Matcher<Ctx>[];
-    private idx;
-    private checkpoint;
-    constructor({ matchers }: AltMatcherOptions<Ctx>);
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-    nextMatch(): Checkpoint<Ctx> | null;
-}
+import type { AltMatcherOptions, Checkpoint, Matcher } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+export declare class AltMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly alts: Matcher<Ctx>[];
+    private idx;
+    private checkpoint;
+    constructor({ matchers }: AltMatcherOptions<Ctx>);
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+    nextMatch(): Checkpoint<Ctx> | null;
+}
 //# sourceMappingURL=alt-matcher.d.ts.map

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

@@ -1,30 +1,30 @@
-import { AbstractMatcher } from './abstract-matcher';
-export class AltMatcher extends AbstractMatcher {
-    constructor({ matchers }) {
-        super();
-        this.idx = -1;
-        this.checkpoint = null;
-        this.alts = matchers;
-    }
-    match(checkpoint) {
-        this.checkpoint = checkpoint;
-        this.idx = -1;
-        return this.nextMatch();
-    }
-    nextMatch() {
-        if (this.checkpoint) {
-            this.idx += 1;
-            let matcher = this.alts[this.idx];
-            while (matcher) {
-                const checkpoint = matcher.match(this.checkpoint);
-                if (checkpoint) {
-                    return checkpoint;
-                }
-                this.idx += 1;
-                matcher = this.alts[this.idx];
-            }
-        }
-        return null;
-    }
-}
+import { AbstractMatcher } from './abstract-matcher';
+export class AltMatcher extends AbstractMatcher {
+    constructor({ matchers }) {
+        super();
+        this.idx = -1;
+        this.checkpoint = null;
+        this.alts = matchers;
+    }
+    match(checkpoint) {
+        this.checkpoint = checkpoint;
+        this.idx = -1;
+        return this.nextMatch();
+    }
+    nextMatch() {
+        if (this.checkpoint) {
+            this.idx += 1;
+            let matcher = this.alts[this.idx];
+            while (matcher) {
+                const checkpoint = matcher.match(this.checkpoint);
+                if (checkpoint) {
+                    return checkpoint;
+                }
+                this.idx += 1;
+                matcher = this.alts[this.idx];
+            }
+        }
+        return null;
+    }
+}
 //# sourceMappingURL=alt-matcher.js.map

package/dist/esm/query/matchers/anchor-matcher.d.ts

@@ -1,18 +1,18 @@
-import type { Token } from '../../lexer/types';
-import type { Cursor, Tree } from '../../parser';
-import type { Checkpoint } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-export declare class BeginMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
-export declare class EndMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
-export declare class VoidMatcher<Ctx, T extends Tree | Token> extends AbstractMatcher<Ctx> {
-    private handler;
-    constructor(handler: (context: Ctx, t: T) => Ctx);
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-    moveRight(cursor: Cursor): Cursor;
-    seekNext(cursor: Cursor): Cursor;
-}
+import type { Token } from '../../lexer/types';
+import type { Cursor, Tree } from '../../parser';
+import type { Checkpoint } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+export declare class BeginMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
+export declare class EndMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
+export declare class VoidMatcher<Ctx, T extends Tree | Token> extends AbstractMatcher<Ctx> {
+    private handler;
+    constructor(handler: (context: Ctx, t: T) => Ctx);
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+    moveRight(cursor: Cursor): Cursor;
+    seekNext(cursor: Cursor): Cursor;
+}
 //# sourceMappingURL=anchor-matcher.d.ts.map

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

@@ -1,45 +1,45 @@
-import { clone } from '../../util/clone';
-import { AbstractMatcher } from './abstract-matcher';
-export class BeginMatcher extends AbstractMatcher {
-    match(checkpoint) {
-        var _a;
-        let { cursor } = checkpoint;
-        if (((_a = cursor.node) === null || _a === void 0 ? void 0 : _a.type) === '_start') {
-            cursor = this.moveRight(cursor);
-            return { ...checkpoint, cursor };
-        }
-        return null;
-    }
-}
-export class EndMatcher extends AbstractMatcher {
-    match(checkpoint) {
-        var _a;
-        let { cursor } = checkpoint;
-        cursor = this.seekNext(cursor);
-        if (((_a = cursor.node) === null || _a === void 0 ? void 0 : _a.type) === '_end') {
-            return checkpoint;
-        }
-        return null;
-    }
-}
-export class VoidMatcher extends AbstractMatcher {
-    constructor(handler) {
-        super();
-        this.handler = (context, t) => handler(clone(context), t);
-    }
-    match(checkpoint) {
-        var _a;
-        const { cursor, context } = checkpoint;
-        const prevCursor = (_a = cursor.left) !== null && _a !== void 0 ? _a : cursor;
-        const node = prevCursor.node;
-        const newContext = this.handler(context, node);
-        return { cursor, context: newContext };
-    }
-    moveRight(cursor) {
-        return cursor;
-    }
-    seekNext(cursor) {
-        return cursor;
-    }
-}
+import { clone } from '../../util/clone';
+import { AbstractMatcher } from './abstract-matcher';
+export class BeginMatcher extends AbstractMatcher {
+    match(checkpoint) {
+        var _a;
+        let { cursor } = checkpoint;
+        if (((_a = cursor.node) === null || _a === void 0 ? void 0 : _a.type) === '_start') {
+            cursor = this.moveRight(cursor);
+            return { ...checkpoint, cursor };
+        }
+        return null;
+    }
+}
+export class EndMatcher extends AbstractMatcher {
+    match(checkpoint) {
+        var _a;
+        let { cursor } = checkpoint;
+        cursor = this.seekNext(cursor);
+        if (((_a = cursor.node) === null || _a === void 0 ? void 0 : _a.type) === '_end') {
+            return checkpoint;
+        }
+        return null;
+    }
+}
+export class VoidMatcher extends AbstractMatcher {
+    constructor(handler) {
+        super();
+        this.handler = (context, t) => handler(clone(context), t);
+    }
+    match(checkpoint) {
+        var _a;
+        const { cursor, context } = checkpoint;
+        const prevCursor = (_a = cursor.left) !== null && _a !== void 0 ? _a : cursor;
+        const node = prevCursor.node;
+        const newContext = this.handler(context, node);
+        return { cursor, context: newContext };
+    }
+    moveRight(cursor) {
+        return cursor;
+    }
+    seekNext(cursor) {
+        return cursor;
+    }
+}
 //# sourceMappingURL=anchor-matcher.js.map

package/dist/esm/query/matchers/comment-matcher.d.ts

@@ -1,11 +1,11 @@
-import type { Node } from '../../parser';
-import type { Checkpoint, CommentMatcherHandler, CommentMatcherOptions, CommentMatcherValue } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-export declare class CommentMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly comment: CommentMatcherValue;
-    readonly handler: CommentMatcherHandler<Ctx>;
-    constructor({ value, handler }: CommentMatcherOptions<Ctx>);
-    canSkip(node: Node): boolean;
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
+import type { Node } from '../../parser';
+import type { Checkpoint, CommentMatcherHandler, CommentMatcherOptions, CommentMatcherValue } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+export declare class CommentMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly comment: CommentMatcherValue;
+    readonly handler: CommentMatcherHandler<Ctx>;
+    constructor({ value, handler }: CommentMatcherOptions<Ctx>);
+    canSkip(node: Node): boolean;
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
 //# sourceMappingURL=comment-matcher.d.ts.map

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

@@ -1,36 +1,36 @@
-import { safeHandler } from '../handler';
-import { isRegex } from '../regex';
-import { AbstractMatcher } from './abstract-matcher';
-const skipBeforeComment = ['whitespace', '_start', 'newline'];
-export class CommentMatcher extends AbstractMatcher {
-    constructor({ value, handler }) {
-        super();
-        this.comment = value;
-        this.handler = safeHandler(handler);
-    }
-    canSkip(node) {
-        return skipBeforeComment.includes(node.type);
-    }
-    match(checkpoint) {
-        var _a;
-        const context = checkpoint.context;
-        const cursor = this.seekNext(checkpoint.cursor);
-        const node = cursor.node;
-        if ((node === null || node === void 0 ? void 0 : node.type) === 'comment') {
-            let isMatched = true;
-            if (typeof this.comment === 'string') {
-                isMatched = this.comment === node.value;
-            }
-            else if (isRegex(this.comment)) {
-                isMatched = this.comment.test(node.value);
-            }
-            if (isMatched) {
-                const nextContext = this.handler(context, node);
-                const nextCursor = (_a = cursor.right) !== null && _a !== void 0 ? _a : cursor;
-                return { context: nextContext, cursor: nextCursor };
-            }
-        }
-        return null;
-    }
-}
+import { safeHandler } from '../handler';
+import { isRegex } from '../regex';
+import { AbstractMatcher } from './abstract-matcher';
+const skipBeforeComment = ['whitespace', '_start', 'newline'];
+export class CommentMatcher extends AbstractMatcher {
+    constructor({ value, handler }) {
+        super();
+        this.comment = value;
+        this.handler = safeHandler(handler);
+    }
+    canSkip(node) {
+        return skipBeforeComment.includes(node.type);
+    }
+    match(checkpoint) {
+        var _a;
+        const context = checkpoint.context;
+        const cursor = this.seekNext(checkpoint.cursor);
+        const node = cursor.node;
+        if ((node === null || node === void 0 ? void 0 : node.type) === 'comment') {
+            let isMatched = true;
+            if (typeof this.comment === 'string') {
+                isMatched = this.comment === node.value;
+            }
+            else if (isRegex(this.comment)) {
+                isMatched = this.comment.test(node.value);
+            }
+            if (isMatched) {
+                const nextContext = this.handler(context, node);
+                const nextCursor = (_a = cursor.right) !== null && _a !== void 0 ? _a : cursor;
+                return { context: nextContext, cursor: nextCursor };
+            }
+        }
+        return null;
+    }
+}
 //# sourceMappingURL=comment-matcher.js.map

package/dist/esm/query/matchers/index.d.ts

@@ -1,7 +1,7 @@
-export * from './abstract-matcher';
-export * from './alt-matcher';
-export * from './many-matcher';
-export * from './op-matcher';
-export * from './seq-matcher';
-export * from './sym-matcher';
+export * from './abstract-matcher';
+export * from './alt-matcher';
+export * from './many-matcher';
+export * from './op-matcher';
+export * from './seq-matcher';
+export * from './sym-matcher';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/query/matchers/index.js

@@ -1,7 +1,7 @@
-export * from './abstract-matcher';
-export * from './alt-matcher';
-export * from './many-matcher';
-export * from './op-matcher';
-export * from './seq-matcher';
-export * from './sym-matcher';
+export * from './abstract-matcher';
+export * from './alt-matcher';
+export * from './many-matcher';
+export * from './op-matcher';
+export * from './seq-matcher';
+export * from './sym-matcher';
 //# sourceMappingURL=index.js.map

package/dist/esm/query/matchers/many-matcher.d.ts

@@ -1,14 +1,14 @@
-import type { Checkpoint, ManyMatcherOptions, Matcher } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-export declare class ManyMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly manyOf: Matcher<Ctx>;
-    readonly min: number;
-    readonly max: number | null;
-    private idx;
-    private matches;
-    constructor({ matcher, min, max }: ManyMatcherOptions<Ctx>);
-    private nextRound;
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-    nextMatch(): Checkpoint<Ctx> | null;
-}
+import type { Checkpoint, ManyMatcherOptions, Matcher } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+export declare class ManyMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly manyOf: Matcher<Ctx>;
+    readonly min: number;
+    readonly max: number | null;
+    private idx;
+    private matches;
+    constructor({ matcher, min, max }: ManyMatcherOptions<Ctx>);
+    private nextRound;
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+    nextMatch(): Checkpoint<Ctx> | null;
+}
 //# sourceMappingURL=many-matcher.d.ts.map

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

@@ -1,58 +1,58 @@
-import { AbstractMatcher } from './abstract-matcher';
-export class ManyMatcher extends AbstractMatcher {
-    constructor({ matcher, min, max }) {
-        super();
-        this.idx = 0;
-        this.matches = [];
-        if (min < 0) {
-            throw new Error(`Invalid minimal bound: ${min}`);
-        }
-        if (max !== null && min > max) {
-            throw new Error(`Invalid boundaries: ${min} > ${max}`);
-        }
-        this.manyOf = matcher;
-        this.min = min;
-        this.max = max;
-    }
-    nextRound(checkpoints) {
-        const results = [];
-        for (const oldCheckpoint of checkpoints) {
-            const newCheckpoint = this.manyOf.match(oldCheckpoint);
-            if (!newCheckpoint) {
-                continue;
-            }
-            const matchResults = [newCheckpoint];
-            let nextResult = this.manyOf.nextMatch();
-            while (nextResult) {
-                matchResults.push(nextResult);
-                nextResult = this.manyOf.nextMatch();
-            }
-            results.unshift(...matchResults);
-        }
-        return results;
-    }
-    match(checkpoint) {
-        var _a;
-        this.idx = 0;
-        let roundResults = [checkpoint];
-        this.matches = this.min === 0 ? [checkpoint] : [];
-        let round = 1;
-        while (this.max !== null ? round <= this.max : true) {
-            roundResults = this.nextRound(roundResults);
-            if (roundResults.length) {
-                this.matches.unshift(...roundResults);
-                round += 1;
-            }
-            else {
-                break;
-            }
-        }
-        return (_a = this.matches[this.idx]) !== null && _a !== void 0 ? _a : null;
-    }
-    nextMatch() {
-        var _a;
-        this.idx += 1;
-        return (_a = this.matches[this.idx]) !== null && _a !== void 0 ? _a : null;
-    }
-}
+import { AbstractMatcher } from './abstract-matcher';
+export class ManyMatcher extends AbstractMatcher {
+    constructor({ matcher, min, max }) {
+        super();
+        this.idx = 0;
+        this.matches = [];
+        if (min < 0) {
+            throw new Error(`Invalid minimal bound: ${min}`);
+        }
+        if (max !== null && min > max) {
+            throw new Error(`Invalid boundaries: ${min} > ${max}`);
+        }
+        this.manyOf = matcher;
+        this.min = min;
+        this.max = max;
+    }
+    nextRound(checkpoints) {
+        const results = [];
+        for (const oldCheckpoint of checkpoints) {
+            const newCheckpoint = this.manyOf.match(oldCheckpoint);
+            if (!newCheckpoint) {
+                continue;
+            }
+            const matchResults = [newCheckpoint];
+            let nextResult = this.manyOf.nextMatch();
+            while (nextResult) {
+                matchResults.push(nextResult);
+                nextResult = this.manyOf.nextMatch();
+            }
+            results.unshift(...matchResults);
+        }
+        return results;
+    }
+    match(checkpoint) {
+        var _a;
+        this.idx = 0;
+        let roundResults = [checkpoint];
+        this.matches = this.min === 0 ? [checkpoint] : [];
+        let round = 1;
+        while (this.max !== null ? round <= this.max : true) {
+            roundResults = this.nextRound(roundResults);
+            if (roundResults.length) {
+                this.matches.unshift(...roundResults);
+                round += 1;
+            }
+            else {
+                break;
+            }
+        }
+        return (_a = this.matches[this.idx]) !== null && _a !== void 0 ? _a : null;
+    }
+    nextMatch() {
+        var _a;
+        this.idx += 1;
+        return (_a = this.matches[this.idx]) !== null && _a !== void 0 ? _a : null;
+    }
+}
 //# sourceMappingURL=many-matcher.js.map

package/dist/esm/query/matchers/num-matcher.d.ts

@@ -1,9 +1,9 @@
-import type { Checkpoint, NumMatcherHandler, NumMatcherOptions, NumMatcherValue } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-export declare class NumMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly num: NumMatcherValue;
-    readonly handler: NumMatcherHandler<Ctx>;
-    constructor({ value, handler }: NumMatcherOptions<Ctx>);
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
+import type { Checkpoint, NumMatcherHandler, NumMatcherOptions, NumMatcherValue } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+export declare class NumMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly num: NumMatcherValue;
+    readonly handler: NumMatcherHandler<Ctx>;
+    constructor({ value, handler }: NumMatcherOptions<Ctx>);
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
 //# sourceMappingURL=num-matcher.d.ts.map

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

@@ -1,31 +1,31 @@
-import { safeHandler } from '../handler';
-import { isRegex } from '../regex';
-import { AbstractMatcher } from './abstract-matcher';
-export class NumMatcher extends AbstractMatcher {
-    constructor({ value, handler }) {
-        super();
-        this.num = value;
-        this.handler = safeHandler(handler);
-    }
-    match(checkpoint) {
-        let context = checkpoint.context;
-        let cursor = this.seekNext(checkpoint.cursor);
-        const node = cursor.node;
-        if ((node === null || node === void 0 ? void 0 : node.type) === 'number') {
-            let isMatched = true;
-            if (typeof this.num === 'string') {
-                isMatched = this.num === node.value;
-            }
-            else if (isRegex(this.num)) {
-                isMatched = this.num.test(node.value);
-            }
-            if (isMatched) {
-                context = this.handler(context, node);
-                cursor = this.moveRight(cursor);
-                return { cursor, context };
-            }
-        }
-        return null;
-    }
-}
+import { safeHandler } from '../handler';
+import { isRegex } from '../regex';
+import { AbstractMatcher } from './abstract-matcher';
+export class NumMatcher extends AbstractMatcher {
+    constructor({ value, handler }) {
+        super();
+        this.num = value;
+        this.handler = safeHandler(handler);
+    }
+    match(checkpoint) {
+        let context = checkpoint.context;
+        let cursor = this.seekNext(checkpoint.cursor);
+        const node = cursor.node;
+        if ((node === null || node === void 0 ? void 0 : node.type) === 'number') {
+            let isMatched = true;
+            if (typeof this.num === 'string') {
+                isMatched = this.num === node.value;
+            }
+            else if (isRegex(this.num)) {
+                isMatched = this.num.test(node.value);
+            }
+            if (isMatched) {
+                context = this.handler(context, node);
+                cursor = this.moveRight(cursor);
+                return { cursor, context };
+            }
+        }
+        return null;
+    }
+}
 //# sourceMappingURL=num-matcher.js.map

package/dist/esm/query/matchers/op-matcher.d.ts

@@ -1,9 +1,9 @@
-import type { Checkpoint, OpMatcherHandler, OpMatcherOptions, OpMatcherValue } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-export declare class OpMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly op: OpMatcherValue;
-    readonly handler: OpMatcherHandler<Ctx>;
-    constructor({ value, handler }: OpMatcherOptions<Ctx>);
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
+import type { Checkpoint, OpMatcherHandler, OpMatcherOptions, OpMatcherValue } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+export declare class OpMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly op: OpMatcherValue;
+    readonly handler: OpMatcherHandler<Ctx>;
+    constructor({ value, handler }: OpMatcherOptions<Ctx>);
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
 //# sourceMappingURL=op-matcher.d.ts.map