@renovatebot/good-enough-parser 1.1.24 → 1.2.0

package/dist/cjs/query/options.js

@@ -1,150 +1,150 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.coerceStrOptions = exports.coerceTreeOptions = exports.coerceManyOptions = exports.coerceNumOptions = exports.coerceCommentOptions = exports.coerceOpOptions = exports.coerceSymOptions = void 0;
-const regex_1 = require("./regex");
-function coerceSymOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || (0, regex_1.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 };
-}
-exports.coerceSymOptions = coerceSymOptions;
-function coerceOpOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || (0, regex_1.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 };
-}
-exports.coerceOpOptions = coerceOpOptions;
-function coerceCommentOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || (0, regex_1.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 };
-}
-exports.coerceCommentOptions = coerceCommentOptions;
-function coerceNumOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || (0, regex_1.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 };
-}
-exports.coerceNumOptions = coerceNumOptions;
-function coerceManyOptions(builder, arg2, arg3) {
-    if (typeof arg2 === 'number' && typeof arg3 === 'number') {
-        return { builder, min: arg2, max: arg3 };
-    }
-    return { builder, min: 1, max: null };
-}
-exports.coerceManyOptions = coerceManyOptions;
-function coerceTreeOptions(arg1) {
-    if (typeof arg1 === 'string') {
-        return { type: arg1 };
-    }
-    else if (!arg1) {
-        return { type: null };
-    }
-    else {
-        return arg1;
-    }
-}
-exports.coerceTreeOptions = coerceTreeOptions;
-function coerceStrOptions(arg1, arg2) {
-    if (typeof arg1 === 'string' || (0, regex_1.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' ||
-            (0, regex_1.isRegex)(arg1.match)) {
-            return {
-                type: 'str-content',
-                ...arg1,
-            };
-        }
-        return {
-            type: 'str-tree',
-            ...arg1,
-        };
-    }
-    return {
-        type: 'str-tree',
-        match: null,
-        preHandler: null,
-        postHandler: null,
-    };
-}
-exports.coerceStrOptions = coerceStrOptions;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coerceStrOptions = exports.coerceTreeOptions = exports.coerceManyOptions = exports.coerceNumOptions = exports.coerceCommentOptions = exports.coerceOpOptions = exports.coerceSymOptions = void 0;
+const regex_1 = require("./regex");
+function coerceSymOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || (0, regex_1.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 };
+}
+exports.coerceSymOptions = coerceSymOptions;
+function coerceOpOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || (0, regex_1.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 };
+}
+exports.coerceOpOptions = coerceOpOptions;
+function coerceCommentOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || (0, regex_1.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 };
+}
+exports.coerceCommentOptions = coerceCommentOptions;
+function coerceNumOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || (0, regex_1.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 };
+}
+exports.coerceNumOptions = coerceNumOptions;
+function coerceManyOptions(builder, arg2, arg3) {
+    if (typeof arg2 === 'number' && typeof arg3 === 'number') {
+        return { builder, min: arg2, max: arg3 };
+    }
+    return { builder, min: 1, max: null };
+}
+exports.coerceManyOptions = coerceManyOptions;
+function coerceTreeOptions(arg1) {
+    if (typeof arg1 === 'string') {
+        return { type: arg1 };
+    }
+    else if (!arg1) {
+        return { type: null };
+    }
+    else {
+        return arg1;
+    }
+}
+exports.coerceTreeOptions = coerceTreeOptions;
+function coerceStrOptions(arg1, arg2) {
+    if (typeof arg1 === 'string' || (0, regex_1.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' ||
+            (0, regex_1.isRegex)(arg1.match)) {
+            return {
+                type: 'str-content',
+                ...arg1,
+            };
+        }
+        return {
+            type: 'str-tree',
+            ...arg1,
+        };
+    }
+    return {
+        type: 'str-tree',
+        match: null,
+        preHandler: null,
+        postHandler: null,
+    };
+}
+exports.coerceStrOptions = coerceStrOptions;
 //# sourceMappingURL=options.js.map

package/dist/cjs/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/cjs/query/regex.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRegex = void 0;
-function isRegex(input) {
-    if (input instanceof RegExp) {
-        return true;
-    }
-    if (input && typeof input === 'object' && input.constructor.name === 'RE2') {
-        return true;
-    }
-    return false;
-}
-exports.isRegex = isRegex;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRegex = void 0;
+function isRegex(input) {
+    if (input instanceof RegExp) {
+        return true;
+    }
+    if (input && typeof input === 'object' && input.constructor.name === 'RE2') {
+        return true;
+    }
+    return false;
+}
+exports.isRegex = isRegex;
 //# sourceMappingURL=regex.js.map

package/dist/cjs/query/types.d.ts

@@ -1,101 +1,101 @@
-import type { CommentToken, MinorToken, NumberToken, OperatorToken, SymbolToken } from '../lexer/types';
-import type { Cursor, Node, StringTree, TemplateTree, Tree, TreeType } from '../parser/types';
-import type { StrContentMatcherHandler } from './matchers/str-matcher';
-export interface Checkpoint<Ctx> {
-    cursor: Cursor;
-    context: Ctx;
-}
-export type NodeHandler<Ctx, T extends Node> = (ctx: Ctx, tree: T) => Ctx;
-export type SymMatcherValue = string | RegExp | null;
-export type SymMatcherHandler<Ctx> = NodeHandler<Ctx, SymbolToken>;
-export interface SymMatcherOptions<Ctx> {
-    value: SymMatcherValue;
-    handler: SymMatcherHandler<Ctx> | null;
-}
-export type OpMatcherValue = string | RegExp | null;
-export type OpMatcherHandler<Ctx> = NodeHandler<Ctx, OperatorToken>;
-export interface OpMatcherOptions<Ctx> {
-    value: OpMatcherValue;
-    handler: OpMatcherHandler<Ctx> | null;
-}
-export type CommentMatcherValue = string | RegExp | null;
-export type CommentMatcherHandler<Ctx> = NodeHandler<Ctx, CommentToken>;
-export interface CommentMatcherOptions<Ctx> {
-    value: CommentMatcherValue;
-    handler: CommentMatcherHandler<Ctx> | null;
-}
-export type NumMatcherValue = string | RegExp | null;
-export type NumMatcherHandler<Ctx> = NodeHandler<Ctx, NumberToken>;
-export interface NumMatcherOptions<Ctx> {
-    value: NumMatcherValue;
-    handler: NumMatcherHandler<Ctx> | null;
-}
-export interface SeqMatcherOptions<Ctx> {
-    matchers: Matcher<Ctx>[];
-}
-export type TreeMatcherType = TreeType | null;
-export type TreeMatcherHandler<Ctx> = NodeHandler<Ctx, Tree>;
-export interface TreeOptionsBase<Ctx> {
-    type?: TreeMatcherType;
-    startsWith?: string | null;
-    endsWith?: string | null;
-    maxDepth?: number | null;
-    maxMatches?: number | null;
-    preHandler?: TreeMatcherHandler<Ctx>;
-    postHandler?: TreeMatcherHandler<Ctx>;
-}
-export interface Matcher<Ctx> {
-    seekNext(cursor: Cursor): Cursor;
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-    nextMatch(): Checkpoint<Ctx> | null;
-    readonly preventSkipping?: MinorToken['type'];
-}
-export interface ManyBuilderOpts<Ctx> {
-    builder: QueryBuilder<Ctx, Node>;
-    min: number;
-    max: number | null;
-}
-export interface ManyMatcherOptions<Ctx> {
-    matcher: Matcher<Ctx>;
-    min: number;
-    max: number | null;
-}
-export interface TreeBuilderOptions<Ctx> extends TreeOptionsBase<Ctx> {
-    search?: QueryBuilder<Ctx, Node> | null;
-}
-export interface AltMatcherOptions<Ctx> {
-    matchers: Matcher<Ctx>[];
-}
-export type StrTreeHandler<Ctx> = NodeHandler<Ctx, StringTree>;
-export interface StrTreeOptionsBase<Ctx> {
-    preHandler?: StrTreeHandler<Ctx> | null;
-    postHandler?: StrTreeHandler<Ctx> | null;
-}
-type StrTplHandler<Ctx> = NodeHandler<Ctx, TemplateTree>;
-export interface StrTplOptionsBase<Ctx> {
-    preHandler?: StrTplHandler<Ctx> | null;
-    postHandler?: StrTplHandler<Ctx> | null;
-}
-export interface StrContentBuilderOptionsBase<Ctx> {
-    match?: string | RegExp | null;
-    handler?: StrContentMatcherHandler<Ctx> | null;
-}
-export interface StrTreeBuilderOptionsBase<Ctx> {
-    match?: (string | RegExp | QueryBuilder<Ctx, Node>)[] | null;
-    preHandler?: NodeHandler<Ctx, StringTree> | null;
-    postHandler?: NodeHandler<Ctx, StringTree> | null;
-}
-export type StrBuilderOptionsBase<Ctx> = StrContentBuilderOptionsBase<Ctx> | StrTreeBuilderOptionsBase<Ctx>;
-export interface StrContentBuilderOptions<Ctx> extends StrContentBuilderOptionsBase<Ctx> {
-    type: 'str-content';
-}
-export interface StrTreeBuilderOptions<Ctx> extends StrTreeBuilderOptionsBase<Ctx> {
-    type: 'str-tree';
-}
-export type StrBuilderOptions<Ctx> = StrContentBuilderOptions<Ctx> | StrTreeBuilderOptions<Ctx>;
-export interface QueryBuilder<Ctx, T extends Node> {
-    handler(fn: (ctx: Ctx, t: T) => Ctx): QueryBuilder<Ctx, T>;
-    build(): Matcher<Ctx>;
-}
-export {};
+import type { CommentToken, MinorToken, NumberToken, OperatorToken, SymbolToken } from '../lexer/types';
+import type { Cursor, Node, StringTree, TemplateTree, Tree, TreeType } from '../parser/types';
+import type { StrContentMatcherHandler } from './matchers/str-matcher';
+export interface Checkpoint<Ctx> {
+    cursor: Cursor;
+    context: Ctx;
+}
+export type NodeHandler<Ctx, T extends Node> = (ctx: Ctx, tree: T) => Ctx;
+export type SymMatcherValue = string | RegExp | null;
+export type SymMatcherHandler<Ctx> = NodeHandler<Ctx, SymbolToken>;
+export interface SymMatcherOptions<Ctx> {
+    value: SymMatcherValue;
+    handler: SymMatcherHandler<Ctx> | null;
+}
+export type OpMatcherValue = string | RegExp | null;
+export type OpMatcherHandler<Ctx> = NodeHandler<Ctx, OperatorToken>;
+export interface OpMatcherOptions<Ctx> {
+    value: OpMatcherValue;
+    handler: OpMatcherHandler<Ctx> | null;
+}
+export type CommentMatcherValue = string | RegExp | null;
+export type CommentMatcherHandler<Ctx> = NodeHandler<Ctx, CommentToken>;
+export interface CommentMatcherOptions<Ctx> {
+    value: CommentMatcherValue;
+    handler: CommentMatcherHandler<Ctx> | null;
+}
+export type NumMatcherValue = string | RegExp | null;
+export type NumMatcherHandler<Ctx> = NodeHandler<Ctx, NumberToken>;
+export interface NumMatcherOptions<Ctx> {
+    value: NumMatcherValue;
+    handler: NumMatcherHandler<Ctx> | null;
+}
+export interface SeqMatcherOptions<Ctx> {
+    matchers: Matcher<Ctx>[];
+}
+export type TreeMatcherType = TreeType | null;
+export type TreeMatcherHandler<Ctx> = NodeHandler<Ctx, Tree>;
+export interface TreeOptionsBase<Ctx> {
+    type?: TreeMatcherType;
+    startsWith?: string | null;
+    endsWith?: string | null;
+    maxDepth?: number | null;
+    maxMatches?: number | null;
+    preHandler?: TreeMatcherHandler<Ctx>;
+    postHandler?: TreeMatcherHandler<Ctx>;
+}
+export interface Matcher<Ctx> {
+    seekNext(cursor: Cursor): Cursor;
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+    nextMatch(): Checkpoint<Ctx> | null;
+    readonly preventSkipping?: MinorToken['type'];
+}
+export interface ManyBuilderOpts<Ctx> {
+    builder: QueryBuilder<Ctx, Node>;
+    min: number;
+    max: number | null;
+}
+export interface ManyMatcherOptions<Ctx> {
+    matcher: Matcher<Ctx>;
+    min: number;
+    max: number | null;
+}
+export interface TreeBuilderOptions<Ctx> extends TreeOptionsBase<Ctx> {
+    search?: QueryBuilder<Ctx, Node> | null;
+}
+export interface AltMatcherOptions<Ctx> {
+    matchers: Matcher<Ctx>[];
+}
+export type StrTreeHandler<Ctx> = NodeHandler<Ctx, StringTree>;
+export interface StrTreeOptionsBase<Ctx> {
+    preHandler?: StrTreeHandler<Ctx> | null;
+    postHandler?: StrTreeHandler<Ctx> | null;
+}
+type StrTplHandler<Ctx> = NodeHandler<Ctx, TemplateTree>;
+export interface StrTplOptionsBase<Ctx> {
+    preHandler?: StrTplHandler<Ctx> | null;
+    postHandler?: StrTplHandler<Ctx> | null;
+}
+export interface StrContentBuilderOptionsBase<Ctx> {
+    match?: string | RegExp | null;
+    handler?: StrContentMatcherHandler<Ctx> | null;
+}
+export interface StrTreeBuilderOptionsBase<Ctx> {
+    match?: (string | RegExp | QueryBuilder<Ctx, Node>)[] | null;
+    preHandler?: NodeHandler<Ctx, StringTree> | null;
+    postHandler?: NodeHandler<Ctx, StringTree> | null;
+}
+export type StrBuilderOptionsBase<Ctx> = StrContentBuilderOptionsBase<Ctx> | StrTreeBuilderOptionsBase<Ctx>;
+export interface StrContentBuilderOptions<Ctx> extends StrContentBuilderOptionsBase<Ctx> {
+    type: 'str-content';
+}
+export interface StrTreeBuilderOptions<Ctx> extends StrTreeBuilderOptionsBase<Ctx> {
+    type: 'str-tree';
+}
+export type StrBuilderOptions<Ctx> = StrContentBuilderOptions<Ctx> | StrTreeBuilderOptions<Ctx>;
+export interface QueryBuilder<Ctx, T extends Node> {
+    handler(fn: (ctx: Ctx, t: T) => Ctx): QueryBuilder<Ctx, T>;
+    build(): Matcher<Ctx>;
+}
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/cjs/query/types.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/dist/cjs/util/clone.d.ts

@@ -1,2 +1,2 @@
-export { klona as clone } from 'klona/lite';
+export { klona as clone } from 'klona/lite';
 //# sourceMappingURL=clone.d.ts.map

package/dist/cjs/util/clone.js

@@ -1,6 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clone = void 0;
-var lite_1 = require("klona/lite");
-Object.defineProperty(exports, "clone", { enumerable: true, get: function () { return lite_1.klona; } });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = void 0;
+var lite_1 = require("klona/lite");
+Object.defineProperty(exports, "clone", { enumerable: true, get: function () { return lite_1.klona; } });
 //# sourceMappingURL=clone.js.map

package/dist/cjs/util/regex.d.ts

@@ -1,2 +1,2 @@
-export declare function escape(input: string): string;
+export declare function escape(input: string): string;
 //# sourceMappingURL=regex.d.ts.map

package/dist/cjs/util/regex.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escape = void 0;
-function escape(input) {
-    return input.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
-exports.escape = escape;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escape = void 0;
+function escape(input) {
+    return input.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+exports.escape = escape;
 //# sourceMappingURL=regex.js.map

package/dist/esm/index.d.ts

@@ -1,5 +1,5 @@
-export * as lang from './lang';
-export * as lexer from './lexer';
-export * as parser from './parser';
-export * as query from './query';
+export * as lang from './lang';
+export * as lexer from './lexer';
+export * as parser from './parser';
+export * as query from './query';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -1,9 +1,9 @@
-import * as lang_1 from './lang';
-export { lang_1 as lang };
-import * as lexer_1 from './lexer';
-export { lexer_1 as lexer };
-import * as parser_1 from './parser';
-export { parser_1 as parser };
-import * as query_1 from './query';
-export { query_1 as query };
+import * as lang_1 from './lang';
+export { lang_1 as lang };
+import * as lexer_1 from './lexer';
+export { lexer_1 as lexer };
+import * as parser_1 from './parser';
+export { parser_1 as parser };
+import * as query_1 from './query';
+export { query_1 as query };
 //# sourceMappingURL=index.js.map

package/dist/esm/lang/groovy.d.ts

@@ -1,7 +1,7 @@
-import type { LexerConfig } from '../lexer/types';
-import type { ParserConfig } from '../parser/types';
-import type { LanguageConfig } from './types';
-export declare const lexer: LexerConfig;
-export declare const parser: ParserConfig;
-export declare const lang: LanguageConfig;
+import type { LexerConfig } from '../lexer/types';
+import type { ParserConfig } from '../parser/types';
+import type { LanguageConfig } from './types';
+export declare const lexer: LexerConfig;
+export declare const parser: ParserConfig;
+export declare const lang: LanguageConfig;
 //# sourceMappingURL=groovy.d.ts.map