'use strict';
var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
    if (typeof path === "string" && /^\.\.?\//.test(path)) {
        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
        });
    }
    return path;
};
var path = require('path');
var fs = require('fs');
var FLAT_NAMES = [
    'eslint.config.js',
    'eslint.config.mjs',
    'eslint.config.cjs',
    'eslint.config.ts',
    'eslint.config.mts',
    'eslint.config.cts',
];
var RC_NAMES = [
    '.eslintrc.js',
    '.eslintrc.cjs',
    '.eslintrc.yaml',
    '.eslintrc.yml',
    '.eslintrc.json',
    '.eslintrc',
];
/**
 * @param {string} id
 * @param {string} cwd
 */
function resolveFrom(id, cwd) {
    return require.resolve(id, { paths: [cwd, __dirname] });
}
/** @param {string} cwd */
function loadEslint(cwd) {
    var resolved;
    try {
        resolved = resolveFrom('eslint', cwd);
    }
    catch (e) {
        // eslint-disable-next-line preserve-caught-error
        throw new Error('the `--eslint` flag requires `eslint` (8, 9, or 10) to be installed');
    }
    try {
        // eslint-disable-next-line global-require
        return require(__rewriteRelativeImportExtension(resolved));
    }
    catch (e) {
        var reason = /** @type {Error} */ (e).message;
        // eslint-disable-next-line preserve-caught-error
        throw new Error("the `--eslint` flag found `eslint` at ".concat(resolved, " but could not load it, which usually means it requires a newer node than ").concat(process.version, ": ").concat(reason));
    }
}
/** @param {string} cwd */
function eslintMajor(cwd) {
    // eslint-disable-next-line global-require
    return parseInt(String(require(__rewriteRelativeImportExtension(resolveFrom('eslint/package.json', cwd))).version).split('.')[0], 10);
}
/** @param {string} cwd */
function useAtYourOwnRisk(cwd) {
    try {
        // eslint-disable-next-line global-require
        return require(__rewriteRelativeImportExtension(resolveFrom('eslint/use-at-your-own-risk', cwd)));
    }
    catch (e) {
        return {};
    }
}
/** @param {string} cwd */
function loadEspree(cwd) {
    var eslintDir = path.dirname(resolveFrom('eslint/package.json', cwd));
    // eslint-disable-next-line global-require
    return require(__rewriteRelativeImportExtension(require.resolve('espree', { paths: [eslintDir] })));
}
/** @param {string} fromDir */
function detectFormat(fromDir) {
    if (FLAT_NAMES.some(function (name) { return fs.existsSync(path.join(fromDir, name)); })) {
        return 'flat';
    }
    if (RC_NAMES.some(function (name) { return fs.existsSync(path.join(fromDir, name)); })) {
        return 'eslintrc';
    }
    var pkgPath = path.join(fromDir, 'package.json');
    if (fs.existsSync(pkgPath)) {
        try {
            if (JSON.parse(fs.readFileSync(pkgPath, 'utf8')).eslintConfig) {
                return 'eslintrc';
            }
        }
        catch (e) { }
    }
    var parent = path.dirname(fromDir);
    if (parent === fromDir) {
        return false;
    }
    return detectFormat(parent);
}
/**
 * @param {string} format
 * @param {string} cwd
 */
function eslintClass(format, cwd) {
    var eslint = loadEslint(cwd);
    var major = eslintMajor(cwd);
    var legacy = useAtYourOwnRisk(cwd);
    if (format === 'eslintrc') {
        return (major <= 8) ? eslint.ESLint : (legacy.LegacyESLint || eslint.ESLint);
    }
    return (major >= 9) ? eslint.ESLint : (legacy.FlatESLint || eslint.ESLint);
}
/** @param {any} node */
function visitNode(node) {
    if (!node || typeof node !== 'object') {
        return;
    }
    if (typeof node.type === 'string') {
        if (node.start === undefined && node.range) {
            // eslint-disable-next-line no-param-reassign
            node.start = node.range[0];
        }
        if (node.end === undefined && node.range) {
            // eslint-disable-next-line no-param-reassign
            node.end = node.range[1];
        }
    }
    Object.keys(node).forEach(function (key) {
        if (key === 'parent') {
            return;
        }
        /** @type {any} */
        var value = node[key];
        if (Array.isArray(value)) {
            value.forEach(/** @param {any} item */ function (item) { return visitNode(item); });
        }
        else {
            /** @type {any} */
            var obj = value;
            if (obj && typeof obj === 'object' && typeof obj.type === 'string') {
                visitNode(obj);
            }
        }
    });
}
/** @param {any} ast */
function normalizeNodePositions(ast) {
    visitNode(ast);
    return ast;
}
/**
 * @param {any} config
 * @param {string} cwd
 */
function parserFor(config, cwd) {
    var languageOptions = config.languageOptions;
    if (languageOptions) {
        var flatOptions = { ecmaVersion: languageOptions.ecmaVersion, sourceType: languageOptions.sourceType };
        Object.assign(flatOptions, languageOptions.parserOptions);
        return { parser: languageOptions.parser || loadEspree(cwd), options: flatOptions };
    }
    // eslint-disable-next-line global-require
    var rcParser = config.parser ? require(__rewriteRelativeImportExtension(config.parser)) : loadEspree(cwd);
    var rcOptions = {};
    Object.assign(rcOptions, config.parserOptions);
    return { parser: rcParser, options: rcOptions };
}
/**
 * @param {any} config
 * @param {string} cwd
 */
function toParseFn(config, cwd) {
    var resolved = parserFor(config, cwd);
    var parser = resolved.parser;
    var options = resolved.options;
    return /** @param {string} code */ function (code) {
        var result = parser.parseForESLint
            ? parser.parseForESLint(code, options)
            : { ast: parser.parse(code, options) };
        return normalizeNodePositions(result.ast);
    };
}
/**
 * @param {string} filePath
 * @param {string} blockId
 * @param {string} cwd
 */
function resolveParse(filePath, blockId, cwd) {
    var absMarkdown = path.resolve(cwd, filePath);
    var virtualPath = path.join(absMarkdown, "".concat(blockId, ".js"));
    var format = detectFormat(path.dirname(absMarkdown)) || 'flat';
    var Cls = eslintClass(format, cwd);
    var instance = new Cls({ cwd: cwd });
    return Promise.resolve(instance.calculateConfigForFile(virtualPath)).then(function (config) {
        if (!config) {
            return false;
        }
        return toParseFn(config, cwd);
    });
}
module.exports = resolveParse;
module.exports.detectFormat = detectFormat;
module.exports.normalizeNodePositions = normalizeNodePositions;