@renovatebot/good-enough-parser 1.1.24 → 1.2.0

package/dist/esm/lexer/number.js

@@ -1,15 +1,15 @@
-export function configNumbers(states, { match }) {
-    return {
-        ...states,
-        $: {
-            ...states.$,
-            number: {
-                t: 'regex',
-                type: 'number',
-                match,
-                chunk: null,
-            },
-        },
-    };
-}
+export function configNumbers(states, { match }) {
+    return {
+        ...states,
+        $: {
+            ...states.$,
+            number: {
+                t: 'regex',
+                type: 'number',
+                match,
+                chunk: null,
+            },
+        },
+    };
+}
 //# sourceMappingURL=number.js.map

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

@@ -1,3 +1,3 @@
-import type { OperatorOption, StatesMap } from './types';
-export declare function configOperators(states: StatesMap, operators: OperatorOption[]): StatesMap;
+import type { OperatorOption, StatesMap } from './types';
+export declare function configOperators(states: StatesMap, operators: OperatorOption[]): StatesMap;
 //# sourceMappingURL=operator.d.ts.map

package/dist/esm/lexer/operator.js

@@ -1,21 +1,21 @@
-export function configOperators(states, operators) {
-    const operatorRules = {};
-    operators.map((op, idx) => {
-        const tokenName = `op$${idx}`;
-        const tokenRule = {
-            t: 'string',
-            type: tokenName,
-            match: op,
-            chunk: op,
-        };
-        operatorRules[tokenName] = tokenRule;
-    });
-    return {
-        ...states,
-        $: {
-            ...states.$,
-            ...operatorRules,
-        },
-    };
-}
+export function configOperators(states, operators) {
+    const operatorRules = {};
+    operators.map((op, idx) => {
+        const tokenName = `op$${idx}`;
+        const tokenRule = {
+            t: 'string',
+            type: tokenName,
+            match: op,
+            chunk: op,
+        };
+        operatorRules[tokenName] = tokenRule;
+    });
+    return {
+        ...states,
+        $: {
+            ...states.$,
+            ...operatorRules,
+        },
+    };
+}
 //# sourceMappingURL=operator.js.map

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

@@ -1,5 +1,5 @@
-import type { FallbackRule, LexerRule, OrderedStatesMap, StatesMap } from './types';
-export declare const fallbackRule: Omit<FallbackRule, 'type'>;
-export declare function sortLexerRules(state: LexerRule[]): LexerRule[];
-export declare function createOrderedStateMap(statesMap: StatesMap): OrderedStatesMap;
+import type { FallbackRule, LexerRule, OrderedStatesMap, StatesMap } from './types';
+export declare const fallbackRule: Omit<FallbackRule, 'type'>;
+export declare function sortLexerRules(state: LexerRule[]): LexerRule[];
+export declare function createOrderedStateMap(statesMap: StatesMap): OrderedStatesMap;
 //# sourceMappingURL=rules.d.ts.map

package/dist/esm/lexer/rules.js

@@ -1,70 +1,70 @@
-import { fallback as mooFallback } from 'moo';
-export const fallbackRule = {
-    ...mooFallback,
-    t: 'fallback',
-    chunk: null,
-};
-function compareChunksByValue(x, y) {
-    if (typeof x.chunk === 'string' && typeof y.chunk === 'string') {
-        const xChunk = x.chunk;
-        const yChunk = y.chunk;
-        if (yChunk < xChunk) {
-            return 1;
-        }
-        else if (xChunk < yChunk) {
-            return -1;
-        }
-    }
-    return 0;
-}
-function compareChunksByInclusion(x, y) {
-    if (typeof x.chunk === 'string' && typeof y.chunk === 'string') {
-        const xChunk = x.chunk;
-        const yChunk = y.chunk;
-        if (yChunk.startsWith(xChunk)) {
-            return 1;
-        }
-        else if (xChunk.startsWith(yChunk)) {
-            return -1;
-        }
-    }
-    return 0;
-}
-export function sortLexerRules(state) {
-    const values = Object.values(state);
-    if (values.length < 2) {
-        return state;
-    }
-    const fallbackRules = [];
-    const numberRules = [];
-    const chunkRules = [];
-    const otherRules = [];
-    for (const rule of values) {
-        if (rule.t === 'fallback') {
-            fallbackRules.push(rule);
-        }
-        else if (rule.type === 'number') {
-            numberRules.push(rule);
-        }
-        else if (typeof rule.chunk === 'string') {
-            chunkRules.push(rule);
-        }
-        else {
-            otherRules.push(rule);
-        }
-    }
-    chunkRules.sort((x, y) => compareChunksByValue(x, y));
-    chunkRules.sort((x, y) => compareChunksByInclusion(x, y));
-    const res = [...numberRules, ...chunkRules, ...otherRules, ...fallbackRules];
-    return res;
-}
-export function createOrderedStateMap(statesMap) {
-    const result = { $: [] };
-    for (const [stateName, state] of Object.entries(statesMap)) {
-        const stateValues = Object.values(state);
-        const orderedStateValues = sortLexerRules(stateValues);
-        result[stateName] = orderedStateValues;
-    }
-    return result;
-}
+import { fallback as mooFallback } from 'moo';
+export const fallbackRule = {
+    ...mooFallback,
+    t: 'fallback',
+    chunk: null,
+};
+function compareChunksByValue(x, y) {
+    if (typeof x.chunk === 'string' && typeof y.chunk === 'string') {
+        const xChunk = x.chunk;
+        const yChunk = y.chunk;
+        if (yChunk < xChunk) {
+            return 1;
+        }
+        else if (xChunk < yChunk) {
+            return -1;
+        }
+    }
+    return 0;
+}
+function compareChunksByInclusion(x, y) {
+    if (typeof x.chunk === 'string' && typeof y.chunk === 'string') {
+        const xChunk = x.chunk;
+        const yChunk = y.chunk;
+        if (yChunk.startsWith(xChunk)) {
+            return 1;
+        }
+        else if (xChunk.startsWith(yChunk)) {
+            return -1;
+        }
+    }
+    return 0;
+}
+export function sortLexerRules(state) {
+    const values = Object.values(state);
+    if (values.length < 2) {
+        return state;
+    }
+    const fallbackRules = [];
+    const numberRules = [];
+    const chunkRules = [];
+    const otherRules = [];
+    for (const rule of values) {
+        if (rule.t === 'fallback') {
+            fallbackRules.push(rule);
+        }
+        else if (rule.type === 'number') {
+            numberRules.push(rule);
+        }
+        else if (typeof rule.chunk === 'string') {
+            chunkRules.push(rule);
+        }
+        else {
+            otherRules.push(rule);
+        }
+    }
+    chunkRules.sort((x, y) => compareChunksByValue(x, y));
+    chunkRules.sort((x, y) => compareChunksByInclusion(x, y));
+    const res = [...numberRules, ...chunkRules, ...otherRules, ...fallbackRules];
+    return res;
+}
+export function createOrderedStateMap(statesMap) {
+    const result = { $: [] };
+    for (const [stateName, state] of Object.entries(statesMap)) {
+        const stateValues = Object.values(state);
+        const orderedStateValues = sortLexerRules(stateValues);
+        result[stateName] = orderedStateValues;
+    }
+    return result;
+}
 //# sourceMappingURL=rules.js.map

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

@@ -1,3 +1,3 @@
-import type { StatesMap, StringOption } from './types';
-export declare function configStrings(states: StatesMap, opts: StringOption[]): StatesMap;
+import type { StatesMap, StringOption } from './types';
+export declare function configStrings(states: StatesMap, opts: StringOption[]): StatesMap;
 //# sourceMappingURL=string.d.ts.map

package/dist/esm/lexer/string.js

@@ -1,178 +1,178 @@
-import { clone } from '../util/clone';
-import { escape } from '../util/regex';
-import { getCounterpartBracketKey, isBracketKey, isRightKey } from './bracket';
-import { fallbackRule } from './rules';
-function copyStateDefinition(state) {
-    const result = clone(state);
-    Object.entries(result).forEach(([key, val]) => {
-        result[key] = clone(val);
-    });
-    return result;
-}
-function exprTplStatesMap($, { tplEndToken, tplEnd }) {
-    const rootState = {};
-    const tplState = copyStateDefinition($);
-    for (const [bracketKey, bracketRule] of Object.entries(tplState)) {
-        if (bracketRule.t === 'string' &&
-            isBracketKey(bracketKey) &&
-            isRightKey(bracketKey) &&
-            (bracketRule.match.startsWith(tplEnd) ||
-                tplEnd.startsWith(bracketRule.match))) {
-            const counterpartKey = getCounterpartBracketKey(bracketKey);
-            if (!counterpartKey) {
-                throw new Error('String template definition conflicts with brackets');
-            }
-            const counterpartRule = tplState[counterpartKey];
-            if (!counterpartRule || counterpartRule.t !== 'string') {
-                throw new Error('String template definition conflicts with brackets');
-            }
-            delete tplState[bracketKey];
-            counterpartRule.push = '$';
-            rootState[counterpartKey] = clone(counterpartRule);
-            rootState[bracketKey] = { ...bracketRule, pop: 1 };
-        }
-    }
-    const tplEndRule = {
-        t: 'string',
-        type: tplEndToken,
-        match: tplEnd,
-        chunk: tplEnd,
-        pop: 1,
-    };
-    tplState[tplEndToken] = tplEndRule;
-    return { $: rootState, tplState };
-}
-export function configStrings(states, opts) {
-    if (!opts.length) {
-        return states;
-    }
-    const $ = copyStateDefinition(states.$);
-    const strStates = {};
-    const exprTplPreStates = [];
-    const tplStates = {};
-    opts.forEach((strOpt, strIdx) => {
-        const { startsWith: strStart, endsWith: strEnd = strStart, escapeChar, templates: tplOpts, } = strOpt;
-        const strToken = `str$${strIdx}`;
-        const strStartToken = `${strToken}$start`;
-        const strEndToken = `${strToken}$end`;
-        const strValueToken = `${strToken}$value`;
-        const strStateName = `${strToken}$state`;
-        const strState = {
-            ...(escapeChar && strEnd[0]
-                ? {
-                    // 1. Escape the escape character (e.g. \\) to prevent it from escaping the delimiter
-                    [`${strToken}$escape_bs`]: {
-                        t: 'string',
-                        type: strValueToken,
-                        match: `${escapeChar}${escapeChar}`,
-                        chunk: `${escapeChar}${escapeChar}`,
-                    },
-                    // 2. Escape the delimiter (e.g. \")
-                    [`${strToken}$escape`]: {
-                        t: 'string',
-                        type: strValueToken,
-                        match: `${escapeChar}${strEnd[0]}`,
-                        chunk: `${escapeChar}${strEnd[0]}`,
-                    },
-                }
-                : {}),
-            [strEndToken]: {
-                t: 'string',
-                type: strEndToken,
-                match: strEnd,
-                chunk: strEnd,
-                pop: 1,
-            },
-            [strValueToken]: { ...fallbackRule, type: strValueToken },
-        };
-        tplOpts === null || tplOpts === void 0 ? void 0 : tplOpts.forEach((tplOpt, tplIdx) => {
-            var _a;
-            const { startsWith: tplStart } = tplOpt;
-            if (tplOpt.type === 'expr') {
-                const tplToken = `${strToken}$tpl$${tplIdx}`;
-                const tplStartToken = `${tplToken}$start`;
-                const tplEndToken = `${tplToken}$end`;
-                const tplStateName = `${tplToken}$state`;
-                strState[tplStartToken] = {
-                    t: 'string',
-                    type: tplStartToken,
-                    match: tplStart,
-                    chunk: tplStart,
-                    push: tplStateName,
-                };
-                const { endsWith: tplEnd } = tplOpt;
-                exprTplPreStates.push({ tplStateName, tplEndToken, tplEnd });
-            }
-            if (tplOpt.type === 'var') {
-                const tplToken = `${strToken}$tpl$${tplIdx}`;
-                const tplStartToken = `${tplToken}$start`;
-                const tplTokenName = `${tplToken}$token`;
-                const { operators = [], symbols } = tplOpt;
-                let symRegex = symbols;
-                if (!symRegex && ((_a = $.symbol) === null || _a === void 0 ? void 0 : _a.t) === 'regex') {
-                    symRegex = $.symbol.match;
-                }
-                if (!symRegex) {
-                    throw new Error(`String definition isn't found for template definition`);
-                }
-                const start = escape(tplStart);
-                const symSource = symRegex.source;
-                let varTplSource = `${start}${symSource}`;
-                const opRules = {};
-                if (operators.length) {
-                    const opSource = `(?:${operators.map(escape).join('|')})`;
-                    varTplSource += `(?:${opSource}${symSource})*`;
-                    operators.forEach((match, idx) => {
-                        const type = `op$${idx}`;
-                        opRules[type] = {
-                            t: 'string',
-                            type,
-                            match,
-                            chunk: match,
-                        };
-                    });
-                }
-                const match = new RegExp(varTplSource);
-                strState[tplTokenName] = {
-                    t: 'regex',
-                    type: tplTokenName,
-                    match,
-                    chunk: tplStart,
-                };
-                const tplStartRule = {
-                    t: 'string',
-                    type: tplStartToken,
-                    match: tplStart,
-                    chunk: tplStart,
-                };
-                const symbolRule = {
-                    t: 'regex',
-                    type: 'symbol',
-                    match: symRegex,
-                    chunk: null,
-                };
-                tplStates[tplTokenName] = {
-                    [tplStartToken]: tplStartRule,
-                    symbol: symbolRule,
-                    ...opRules,
-                };
-            }
-        });
-        strStates[strStateName] = strState;
-        $[strStartToken] = {
-            t: 'string',
-            type: strStartToken,
-            match: strStart,
-            chunk: strStart,
-            push: strStateName,
-        };
-    });
-    for (const exprTplStateInput of exprTplPreStates) {
-        const { tplStateName } = exprTplStateInput;
-        const exprTplStates = exprTplStatesMap($, exprTplStateInput);
-        Object.assign($, exprTplStates.$);
-        tplStates[tplStateName] = exprTplStates.tplState;
-    }
-    return { $, ...strStates, ...tplStates };
-}
+import { clone } from '../util/clone';
+import { escape } from '../util/regex';
+import { getCounterpartBracketKey, isBracketKey, isRightKey } from './bracket';
+import { fallbackRule } from './rules';
+function copyStateDefinition(state) {
+    const result = clone(state);
+    Object.entries(result).forEach(([key, val]) => {
+        result[key] = clone(val);
+    });
+    return result;
+}
+function exprTplStatesMap($, { tplEndToken, tplEnd }) {
+    const rootState = {};
+    const tplState = copyStateDefinition($);
+    for (const [bracketKey, bracketRule] of Object.entries(tplState)) {
+        if (bracketRule.t === 'string' &&
+            isBracketKey(bracketKey) &&
+            isRightKey(bracketKey) &&
+            (bracketRule.match.startsWith(tplEnd) ||
+                tplEnd.startsWith(bracketRule.match))) {
+            const counterpartKey = getCounterpartBracketKey(bracketKey);
+            if (!counterpartKey) {
+                throw new Error('String template definition conflicts with brackets');
+            }
+            const counterpartRule = tplState[counterpartKey];
+            if (!counterpartRule || counterpartRule.t !== 'string') {
+                throw new Error('String template definition conflicts with brackets');
+            }
+            delete tplState[bracketKey];
+            counterpartRule.push = '$';
+            rootState[counterpartKey] = clone(counterpartRule);
+            rootState[bracketKey] = { ...bracketRule, pop: 1 };
+        }
+    }
+    const tplEndRule = {
+        t: 'string',
+        type: tplEndToken,
+        match: tplEnd,
+        chunk: tplEnd,
+        pop: 1,
+    };
+    tplState[tplEndToken] = tplEndRule;
+    return { $: rootState, tplState };
+}
+export function configStrings(states, opts) {
+    if (!opts.length) {
+        return states;
+    }
+    const $ = copyStateDefinition(states.$);
+    const strStates = {};
+    const exprTplPreStates = [];
+    const tplStates = {};
+    opts.forEach((strOpt, strIdx) => {
+        const { startsWith: strStart, endsWith: strEnd = strStart, escapeChar, templates: tplOpts, } = strOpt;
+        const strToken = `str$${strIdx}`;
+        const strStartToken = `${strToken}$start`;
+        const strEndToken = `${strToken}$end`;
+        const strValueToken = `${strToken}$value`;
+        const strStateName = `${strToken}$state`;
+        const strState = {
+            ...(escapeChar && strEnd[0]
+                ? {
+                    // 1. Escape the escape character (e.g. \\) to prevent it from escaping the delimiter
+                    [`${strToken}$escape_bs`]: {
+                        t: 'string',
+                        type: strValueToken,
+                        match: `${escapeChar}${escapeChar}`,
+                        chunk: `${escapeChar}${escapeChar}`,
+                    },
+                    // 2. Escape the delimiter (e.g. \")
+                    [`${strToken}$escape`]: {
+                        t: 'string',
+                        type: strValueToken,
+                        match: `${escapeChar}${strEnd[0]}`,
+                        chunk: `${escapeChar}${strEnd[0]}`,
+                    },
+                }
+                : {}),
+            [strEndToken]: {
+                t: 'string',
+                type: strEndToken,
+                match: strEnd,
+                chunk: strEnd,
+                pop: 1,
+            },
+            [strValueToken]: { ...fallbackRule, type: strValueToken },
+        };
+        tplOpts === null || tplOpts === void 0 ? void 0 : tplOpts.forEach((tplOpt, tplIdx) => {
+            var _a;
+            const { startsWith: tplStart } = tplOpt;
+            if (tplOpt.type === 'expr') {
+                const tplToken = `${strToken}$tpl$${tplIdx}`;
+                const tplStartToken = `${tplToken}$start`;
+                const tplEndToken = `${tplToken}$end`;
+                const tplStateName = `${tplToken}$state`;
+                strState[tplStartToken] = {
+                    t: 'string',
+                    type: tplStartToken,
+                    match: tplStart,
+                    chunk: tplStart,
+                    push: tplStateName,
+                };
+                const { endsWith: tplEnd } = tplOpt;
+                exprTplPreStates.push({ tplStateName, tplEndToken, tplEnd });
+            }
+            if (tplOpt.type === 'var') {
+                const tplToken = `${strToken}$tpl$${tplIdx}`;
+                const tplStartToken = `${tplToken}$start`;
+                const tplTokenName = `${tplToken}$token`;
+                const { operators = [], symbols } = tplOpt;
+                let symRegex = symbols;
+                if (!symRegex && ((_a = $.symbol) === null || _a === void 0 ? void 0 : _a.t) === 'regex') {
+                    symRegex = $.symbol.match;
+                }
+                if (!symRegex) {
+                    throw new Error(`String definition isn't found for template definition`);
+                }
+                const start = escape(tplStart);
+                const symSource = symRegex.source;
+                let varTplSource = `${start}${symSource}`;
+                const opRules = {};
+                if (operators.length) {
+                    const opSource = `(?:${operators.map(escape).join('|')})`;
+                    varTplSource += `(?:${opSource}${symSource})*`;
+                    operators.forEach((match, idx) => {
+                        const type = `op$${idx}`;
+                        opRules[type] = {
+                            t: 'string',
+                            type,
+                            match,
+                            chunk: match,
+                        };
+                    });
+                }
+                const match = new RegExp(varTplSource);
+                strState[tplTokenName] = {
+                    t: 'regex',
+                    type: tplTokenName,
+                    match,
+                    chunk: tplStart,
+                };
+                const tplStartRule = {
+                    t: 'string',
+                    type: tplStartToken,
+                    match: tplStart,
+                    chunk: tplStart,
+                };
+                const symbolRule = {
+                    t: 'regex',
+                    type: 'symbol',
+                    match: symRegex,
+                    chunk: null,
+                };
+                tplStates[tplTokenName] = {
+                    [tplStartToken]: tplStartRule,
+                    symbol: symbolRule,
+                    ...opRules,
+                };
+            }
+        });
+        strStates[strStateName] = strState;
+        $[strStartToken] = {
+            t: 'string',
+            type: strStartToken,
+            match: strStart,
+            chunk: strStart,
+            push: strStateName,
+        };
+    });
+    for (const exprTplStateInput of exprTplPreStates) {
+        const { tplStateName } = exprTplStateInput;
+        const exprTplStates = exprTplStatesMap($, exprTplStateInput);
+        Object.assign($, exprTplStates.$);
+        tplStates[tplStateName] = exprTplStates.tplState;
+    }
+    return { $, ...strStates, ...tplStates };
+}
 //# sourceMappingURL=string.js.map

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

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

package/dist/esm/lexer/symbol.js

@@ -1,15 +1,15 @@
-export function configSymbols(states, { match }) {
-    return {
-        ...states,
-        $: {
-            ...states.$,
-            symbol: {
-                t: 'regex',
-                type: 'symbol',
-                match,
-                chunk: null,
-            },
-        },
-    };
-}
+export function configSymbols(states, { match }) {
+    return {
+        ...states,
+        $: {
+            ...states.$,
+            symbol: {
+                t: 'regex',
+                type: 'symbol',
+                match,
+                chunk: null,
+            },
+        },
+    };
+}
 //# sourceMappingURL=symbol.js.map

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

@@ -1,4 +1,4 @@
-import type { Token as MooToken } from 'moo';
-import type { Token } from './types';
-export declare function coerceToken({ type, value, offset, line, col, lineBreaks }: MooToken, parent?: MooToken): Token;
+import type { Token as MooToken } from 'moo';
+import type { Token } from './types';
+export declare function coerceToken({ type, value, offset, line, col, lineBreaks }: MooToken, parent?: MooToken): Token;
 //# sourceMappingURL=token.d.ts.map