@renovatebot/good-enough-parser 1.1.24 → 1.2.0

package/dist/esm/lang/starlark.js

@@ -1,56 +1,56 @@
-/**
- * @see https://github.com/bazelbuild/starlark/blob/master/spec.md#lexical-elements
- */
-const operators = 
-/* prettier-ignore */ [
-    '+', '-', '*', '//', '%', '**',
-    '~', '&', '|', '^', '<<', '>>',
-    '.', ',', '=', ';', ':',
-    '<', '>', '>=', '<=', '==', '!=',
-    '+=', '-=', '*=', '//=', '%=',
-    '&=', '|=', '^=', '<<=', '>>=',
-];
-const octdigit = '[0-7]';
-const digit = '[0-9]';
-const nonzerodigit = '[1-9]';
-const hexdigit = `(?:${digit}|[a-fA-F])`;
-const octinteger = `(?:0[oO](?:_?${octdigit})+)`;
-const hexinteger = `(?:0[xX](?:_?${hexdigit})+)`;
-const decinteger = `(?:${nonzerodigit}(?:_?${digit})*|0+(?:_?0)*)`;
-const integer = `(?:${decinteger}|${octinteger}|${hexinteger})`;
-const digitpart = `(?:${digit}(?:_?${digit})*)`;
-const fraction = `(?:\\.${digitpart})`;
-const exponent = `(?:[eE][-+]?${digitpart})`;
-const pointfloat = `(?:${digitpart}?${fraction}|${digitpart}\\.)`;
-const exponentfloat = `(?:(?:${digitpart}|${pointfloat})${exponent})`;
-const floatnumber = `(?:${pointfloat}|${exponentfloat})`;
-const numbers = new RegExp(`(?:${integer}|${floatnumber})`);
-export const lexer = {
-    joinLines: '\\',
-    comments: [{ type: 'line-comment', startsWith: '#' }],
-    symbols: /[_a-zA-Z][_a-zA-Z0-9]*/,
-    numbers,
-    operators,
-    brackets: [
-        { startsWith: '{', endsWith: '}' },
-        { startsWith: '[', endsWith: ']' },
-        { startsWith: '(', endsWith: ')' },
-    ],
-    strings: [
-        { startsWith: "'", escapeChar: '\\' },
-        { startsWith: '"', escapeChar: '\\' },
-        { startsWith: "'''", escapeChar: '\\' },
-        { startsWith: '"""', escapeChar: '\\' },
-        { startsWith: "r'", endsWith: "'" },
-        { startsWith: 'r"', endsWith: '"' },
-        { startsWith: "rb'", endsWith: "'" },
-        { startsWith: 'rb"', endsWith: '"' },
-        { startsWith: "br'", endsWith: "'" },
-        { startsWith: 'br"', endsWith: '"' },
-    ],
-};
-export const parser = {
-    useIndentBlocks: true,
-};
-export const lang = { lexer, parser };
+/**
+ * @see https://github.com/bazelbuild/starlark/blob/master/spec.md#lexical-elements
+ */
+const operators = 
+/* prettier-ignore */ [
+    '+', '-', '*', '//', '%', '**',
+    '~', '&', '|', '^', '<<', '>>',
+    '.', ',', '=', ';', ':',
+    '<', '>', '>=', '<=', '==', '!=',
+    '+=', '-=', '*=', '//=', '%=',
+    '&=', '|=', '^=', '<<=', '>>=',
+];
+const octdigit = '[0-7]';
+const digit = '[0-9]';
+const nonzerodigit = '[1-9]';
+const hexdigit = `(?:${digit}|[a-fA-F])`;
+const octinteger = `(?:0[oO](?:_?${octdigit})+)`;
+const hexinteger = `(?:0[xX](?:_?${hexdigit})+)`;
+const decinteger = `(?:${nonzerodigit}(?:_?${digit})*|0+(?:_?0)*)`;
+const integer = `(?:${decinteger}|${octinteger}|${hexinteger})`;
+const digitpart = `(?:${digit}(?:_?${digit})*)`;
+const fraction = `(?:\\.${digitpart})`;
+const exponent = `(?:[eE][-+]?${digitpart})`;
+const pointfloat = `(?:${digitpart}?${fraction}|${digitpart}\\.)`;
+const exponentfloat = `(?:(?:${digitpart}|${pointfloat})${exponent})`;
+const floatnumber = `(?:${pointfloat}|${exponentfloat})`;
+const numbers = new RegExp(`(?:${integer}|${floatnumber})`);
+export const lexer = {
+    joinLines: '\\',
+    comments: [{ type: 'line-comment', startsWith: '#' }],
+    symbols: /[_a-zA-Z][_a-zA-Z0-9]*/,
+    numbers,
+    operators,
+    brackets: [
+        { startsWith: '{', endsWith: '}' },
+        { startsWith: '[', endsWith: ']' },
+        { startsWith: '(', endsWith: ')' },
+    ],
+    strings: [
+        { startsWith: "'", escapeChar: '\\' },
+        { startsWith: '"', escapeChar: '\\' },
+        { startsWith: "'''", escapeChar: '\\' },
+        { startsWith: '"""', escapeChar: '\\' },
+        { startsWith: "r'", endsWith: "'" },
+        { startsWith: 'r"', endsWith: '"' },
+        { startsWith: "rb'", endsWith: "'" },
+        { startsWith: 'rb"', endsWith: '"' },
+        { startsWith: "br'", endsWith: "'" },
+        { startsWith: 'br"', endsWith: '"' },
+    ],
+};
+export const parser = {
+    useIndentBlocks: true,
+};
+export const lang = { lexer, parser };
 //# sourceMappingURL=starlark.js.map

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

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

package/dist/esm/lang/types.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=types.js.map

package/dist/esm/lexer/bracket.d.ts

@@ -1,7 +1,7 @@
-import type { BracketOption, StatesMap } from './types';
-export declare function isBracketKey(key: string): boolean;
-export declare function isLeftKey(key: string): boolean;
-export declare function isRightKey(key: string): boolean;
-export declare function getCounterpartBracketKey(rightKey: string): string | undefined;
-export declare function configBrackets(states: StatesMap, opts: BracketOption[]): StatesMap;
+import type { BracketOption, StatesMap } from './types';
+export declare function isBracketKey(key: string): boolean;
+export declare function isLeftKey(key: string): boolean;
+export declare function isRightKey(key: string): boolean;
+export declare function getCounterpartBracketKey(rightKey: string): string | undefined;
+export declare function configBrackets(states: StatesMap, opts: BracketOption[]): StatesMap;
 //# sourceMappingURL=bracket.d.ts.map

package/dist/esm/lexer/bracket.js

@@ -1,50 +1,50 @@
-export function isBracketKey(key) {
-    return key.startsWith('bracket$');
-}
-export function isLeftKey(key) {
-    return key.endsWith('$left');
-}
-export function isRightKey(key) {
-    return key.endsWith('$right');
-}
-export function getCounterpartBracketKey(rightKey) {
-    const [tokenName, idx, side] = rightKey.split('$');
-    const sides = new Set(['left', 'right']);
-    let result;
-    if (tokenName === 'bracket' && typeof side === 'string' && sides.has(side)) {
-        sides.delete(side);
-        const [counterpart] = [...sides];
-        result = [tokenName, idx, counterpart].join('$');
-    }
-    return result;
-}
-export function configBrackets(states, opts) {
-    const bracketDefs = {};
-    opts.forEach((option, idx) => {
-        const tokenKey = `bracket$${idx}`;
-        const leftTokenKey = `${tokenKey}$left`;
-        const leftTokenRule = {
-            t: 'string',
-            type: leftTokenKey,
-            match: option.startsWith,
-            chunk: option.startsWith,
-        };
-        const rightTokenKey = `${tokenKey}$right`;
-        const rightTokenRule = {
-            t: 'string',
-            type: rightTokenKey,
-            match: option.endsWith,
-            chunk: option.endsWith,
-        };
-        bracketDefs[leftTokenKey] = leftTokenRule;
-        bracketDefs[rightTokenKey] = rightTokenRule;
-    });
-    return {
-        ...states,
-        $: {
-            ...states.$,
-            ...bracketDefs,
-        },
-    };
-}
+export function isBracketKey(key) {
+    return key.startsWith('bracket$');
+}
+export function isLeftKey(key) {
+    return key.endsWith('$left');
+}
+export function isRightKey(key) {
+    return key.endsWith('$right');
+}
+export function getCounterpartBracketKey(rightKey) {
+    const [tokenName, idx, side] = rightKey.split('$');
+    const sides = new Set(['left', 'right']);
+    let result;
+    if (tokenName === 'bracket' && typeof side === 'string' && sides.has(side)) {
+        sides.delete(side);
+        const [counterpart] = [...sides];
+        result = [tokenName, idx, counterpart].join('$');
+    }
+    return result;
+}
+export function configBrackets(states, opts) {
+    const bracketDefs = {};
+    opts.forEach((option, idx) => {
+        const tokenKey = `bracket$${idx}`;
+        const leftTokenKey = `${tokenKey}$left`;
+        const leftTokenRule = {
+            t: 'string',
+            type: leftTokenKey,
+            match: option.startsWith,
+            chunk: option.startsWith,
+        };
+        const rightTokenKey = `${tokenKey}$right`;
+        const rightTokenRule = {
+            t: 'string',
+            type: rightTokenKey,
+            match: option.endsWith,
+            chunk: option.endsWith,
+        };
+        bracketDefs[leftTokenKey] = leftTokenRule;
+        bracketDefs[rightTokenKey] = rightTokenRule;
+    });
+    return {
+        ...states,
+        $: {
+            ...states.$,
+            ...bracketDefs,
+        },
+    };
+}
 //# sourceMappingURL=bracket.js.map

package/dist/esm/lexer/comment.d.ts

@@ -1,4 +1,4 @@
-import type { CommentOption, StatesMap } from './types';
-export declare function esc(input: string): string;
-export declare function configComments(states: StatesMap, opts: CommentOption[]): StatesMap;
+import type { CommentOption, StatesMap } from './types';
+export declare function esc(input: string): string;
+export declare function configComments(states: StatesMap, opts: CommentOption[]): StatesMap;
 //# sourceMappingURL=comment.d.ts.map

package/dist/esm/lexer/comment.js

@@ -1,40 +1,40 @@
-export function esc(input) {
-    return input.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&');
-}
-export function configComments(states, opts) {
-    const commentRules = {};
-    opts.forEach((option, idx) => {
-        const tokenName = `comment$${idx}`;
-        const start = esc(option.startsWith);
-        if (option.type === 'line-comment') {
-            const anyChars = '.*?';
-            const rule = {
-                t: 'regex',
-                type: tokenName,
-                match: new RegExp(`${start}${anyChars}$`),
-                chunk: option.startsWith,
-            };
-            commentRules[tokenName] = rule;
-        }
-        else if (option.type === 'multiline-comment') {
-            const anyChars = '[^]*?';
-            const end = esc(option.endsWith);
-            const rule = {
-                t: 'regex',
-                type: tokenName,
-                match: new RegExp(`${start}${anyChars}${end}`),
-                lineBreaks: true,
-                chunk: option.startsWith,
-            };
-            commentRules[tokenName] = rule;
-        }
-    });
-    return {
-        ...states,
-        $: {
-            ...states.$,
-            ...commentRules,
-        },
-    };
-}
+export function esc(input) {
+    return input.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&');
+}
+export function configComments(states, opts) {
+    const commentRules = {};
+    opts.forEach((option, idx) => {
+        const tokenName = `comment$${idx}`;
+        const start = esc(option.startsWith);
+        if (option.type === 'line-comment') {
+            const anyChars = '.*?';
+            const rule = {
+                t: 'regex',
+                type: tokenName,
+                match: new RegExp(`${start}${anyChars}$`),
+                chunk: option.startsWith,
+            };
+            commentRules[tokenName] = rule;
+        }
+        else if (option.type === 'multiline-comment') {
+            const anyChars = '[^]*?';
+            const end = esc(option.endsWith);
+            const rule = {
+                t: 'regex',
+                type: tokenName,
+                match: new RegExp(`${start}${anyChars}${end}`),
+                lineBreaks: true,
+                chunk: option.startsWith,
+            };
+            commentRules[tokenName] = rule;
+        }
+    });
+    return {
+        ...states,
+        $: {
+            ...states.$,
+            ...commentRules,
+        },
+    };
+}
 //# sourceMappingURL=comment.js.map

package/dist/esm/lexer/index.d.ts

@@ -1,6 +1,6 @@
-import type { Lexer, LexerConfig, OrderedStatesMap } from './types';
-export * from './token';
-export * from './types';
-export declare function configureLexerRules(lexerConfig: LexerConfig): OrderedStatesMap;
-export declare function createLexer(options: LexerConfig): Lexer;
+import type { Lexer, LexerConfig, OrderedStatesMap } from './types';
+export * from './token';
+export * from './types';
+export declare function configureLexerRules(lexerConfig: LexerConfig): OrderedStatesMap;
+export declare function createLexer(options: LexerConfig): Lexer;
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/lexer/index.js

@@ -1,137 +1,137 @@
-import { compile as mooCompile, states as mooStates, } from 'moo';
-import { configBrackets } from './bracket';
-import { configComments } from './comment';
-import { configNumbers } from './number';
-import { configOperators } from './operator';
-import { createOrderedStateMap, fallbackRule } from './rules';
-import { configStrings } from './string';
-import { configSymbols } from './symbol';
-import { coerceToken } from './token';
-export * from './token';
-export * from './types';
-export function configureLexerRules(lexerConfig) {
-    const whitespace = lexerConfig.joinLines
-        ? {
-            t: 'regex',
-            type: 'whitespace',
-            match: new RegExp(`(?:${lexerConfig.joinLines}\\r?\\n|[ \\t\\r])+`),
-            lineBreaks: true,
-            chunk: null,
-        }
-        : {
-            t: 'regex',
-            type: 'whitespace',
-            match: /[ \t\r]+/,
-            chunk: null,
-        };
-    let result = {
-        $: {
-            whitespace,
-            newline: {
-                t: 'regex',
-                type: 'newline',
-                match: /\r?\n/,
-                chunk: null,
-                lineBreaks: true,
-            },
-            _: { ...fallbackRule, type: '_' },
-        },
-    };
-    const { comments, symbols, operators, brackets, strings, numbers } = lexerConfig;
-    result = configComments(result, comments);
-    result = configSymbols(result, { match: symbols });
-    result = configOperators(result, operators);
-    result = configBrackets(result, brackets);
-    result = configStrings(result, strings);
-    result = configNumbers(result, { match: numbers });
-    const orderedResult = createOrderedStateMap(result);
-    return orderedResult;
-}
-function isVarToken(key) {
-    return typeof key === 'string' && /^str\$\d+\$tpl\$\d+\$token$/.test(key);
-}
-function getVarEndToken({ type, value, offset, line, col, lineBreaks, }) {
-    return {
-        type: type === null || type === void 0 ? void 0 : type.replace(/\$[^$]+$/, '$end'),
-        value: '',
-        text: '',
-        offset: offset + value.length,
-        line: line + lineBreaks,
-        col: col + value.length,
-        lineBreaks: 0,
-    };
-}
-function getSubLexers(states) {
-    const result = {};
-    for (const [key, rules] of Object.entries(states)) {
-        if (isVarToken(key)) {
-            result[key] = mooCompile(rules);
-        }
-    }
-    return result;
-}
-export function createLexer(options) {
-    const rules = configureLexerRules(options);
-    const subLexers = getSubLexers(rules);
-    const mainLexer = mooStates(rules);
-    let subLexer;
-    let subLexerToken;
-    const result = {
-        reset(input) {
-            Object.values(subLexers).forEach((subLexer) => subLexer.reset());
-            subLexer = undefined;
-            subLexerToken = undefined;
-            if (typeof input === 'undefined' || input === null) {
-                mainLexer.reset();
-            }
-            else {
-                mainLexer.reset(input);
-            }
-            return result;
-        },
-        [Symbol.iterator]() {
-            const next = () => {
-                const mooLexer = subLexer !== null && subLexer !== void 0 ? subLexer : mainLexer;
-                const mooIter = mooLexer[Symbol.iterator]();
-                const nextElem = mooIter.next();
-                if (nextElem.done) {
-                    if (subLexer && subLexerToken) {
-                        const subLexerType = subLexerToken.type;
-                        mooLexer.reset();
-                        if (isVarToken(subLexerType)) {
-                            const x = getVarEndToken(subLexerToken);
-                            const value = coerceToken(x);
-                            subLexer = undefined;
-                            subLexerToken = undefined;
-                            return { done: false, value };
-                        }
-                        else {
-                            subLexer = undefined;
-                            subLexerToken = undefined;
-                            return next();
-                        }
-                    }
-                    else {
-                        return { done: true, value: null };
-                    }
-                }
-                const mooToken = nextElem.value;
-                if (!subLexer) {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    const mooTokenType = mooToken.type;
-                    subLexer = subLexers[mooTokenType];
-                    if (subLexer) {
-                        subLexerToken = mooToken;
-                        subLexer.reset(mooToken.value);
-                        return next();
-                    }
-                }
-                const value = coerceToken(mooToken, subLexerToken);
-                return { done: false, value };
-            };
-            return { next };
-        },
-    };
-    return result;
-}
+import { compile as mooCompile, states as mooStates, } from 'moo';
+import { configBrackets } from './bracket';
+import { configComments } from './comment';
+import { configNumbers } from './number';
+import { configOperators } from './operator';
+import { createOrderedStateMap, fallbackRule } from './rules';
+import { configStrings } from './string';
+import { configSymbols } from './symbol';
+import { coerceToken } from './token';
+export * from './token';
+export * from './types';
+export function configureLexerRules(lexerConfig) {
+    const whitespace = lexerConfig.joinLines
+        ? {
+            t: 'regex',
+            type: 'whitespace',
+            match: new RegExp(`(?:${lexerConfig.joinLines}\\r?\\n|[ \\t\\r])+`),
+            lineBreaks: true,
+            chunk: null,
+        }
+        : {
+            t: 'regex',
+            type: 'whitespace',
+            match: /[ \t\r]+/,
+            chunk: null,
+        };
+    let result = {
+        $: {
+            whitespace,
+            newline: {
+                t: 'regex',
+                type: 'newline',
+                match: /\r?\n/,
+                chunk: null,
+                lineBreaks: true,
+            },
+            _: { ...fallbackRule, type: '_' },
+        },
+    };
+    const { comments, symbols, operators, brackets, strings, numbers } = lexerConfig;
+    result = configComments(result, comments);
+    result = configSymbols(result, { match: symbols });
+    result = configOperators(result, operators);
+    result = configBrackets(result, brackets);
+    result = configStrings(result, strings);
+    result = configNumbers(result, { match: numbers });
+    const orderedResult = createOrderedStateMap(result);
+    return orderedResult;
+}
+function isVarToken(key) {
+    return typeof key === 'string' && /^str\$\d+\$tpl\$\d+\$token$/.test(key);
+}
+function getVarEndToken({ type, value, offset, line, col, lineBreaks, }) {
+    return {
+        type: type === null || type === void 0 ? void 0 : type.replace(/\$[^$]+$/, '$end'),
+        value: '',
+        text: '',
+        offset: offset + value.length,
+        line: line + lineBreaks,
+        col: col + value.length,
+        lineBreaks: 0,
+    };
+}
+function getSubLexers(states) {
+    const result = {};
+    for (const [key, rules] of Object.entries(states)) {
+        if (isVarToken(key)) {
+            result[key] = mooCompile(rules);
+        }
+    }
+    return result;
+}
+export function createLexer(options) {
+    const rules = configureLexerRules(options);
+    const subLexers = getSubLexers(rules);
+    const mainLexer = mooStates(rules);
+    let subLexer;
+    let subLexerToken;
+    const result = {
+        reset(input) {
+            Object.values(subLexers).forEach((subLexer) => subLexer.reset());
+            subLexer = undefined;
+            subLexerToken = undefined;
+            if (typeof input === 'undefined' || input === null) {
+                mainLexer.reset();
+            }
+            else {
+                mainLexer.reset(input);
+            }
+            return result;
+        },
+        [Symbol.iterator]() {
+            const next = () => {
+                const mooLexer = subLexer !== null && subLexer !== void 0 ? subLexer : mainLexer;
+                const mooIter = mooLexer[Symbol.iterator]();
+                const nextElem = mooIter.next();
+                if (nextElem.done) {
+                    if (subLexer && subLexerToken) {
+                        const subLexerType = subLexerToken.type;
+                        mooLexer.reset();
+                        if (isVarToken(subLexerType)) {
+                            const x = getVarEndToken(subLexerToken);
+                            const value = coerceToken(x);
+                            subLexer = undefined;
+                            subLexerToken = undefined;
+                            return { done: false, value };
+                        }
+                        else {
+                            subLexer = undefined;
+                            subLexerToken = undefined;
+                            return next();
+                        }
+                    }
+                    else {
+                        return { done: true, value: null };
+                    }
+                }
+                const mooToken = nextElem.value;
+                if (!subLexer) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const mooTokenType = mooToken.type;
+                    subLexer = subLexers[mooTokenType];
+                    if (subLexer) {
+                        subLexerToken = mooToken;
+                        subLexer.reset(mooToken.value);
+                        return next();
+                    }
+                }
+                const value = coerceToken(mooToken, subLexerToken);
+                return { done: false, value };
+            };
+            return { next };
+        },
+    };
+    return result;
+}
 //# sourceMappingURL=index.js.map

package/dist/esm/lexer/number.d.ts

@@ -1,3 +1,3 @@
-import type { NumberOption, StatesMap } from './types';
-export declare function configNumbers(states: StatesMap, { match }: NumberOption): StatesMap;
+import type { NumberOption, StatesMap } from './types';
+export declare function configNumbers(states: StatesMap, { match }: NumberOption): StatesMap;
 //# sourceMappingURL=number.d.ts.map