@mirta/rollup 0.3.4 → 0.3.5

package/dist/runtime.mjs

@@ -0,0 +1,1571 @@
+import ts$1 from '@rollup/plugin-typescript';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import replace from '@rollup/plugin-replace';
+import copy from 'rollup-plugin-copy';
+import dts from 'rollup-plugin-dts';
+import ts from 'typescript';
+import nodePath from 'node:path';
+import multi from '@rollup/plugin-multi-entry';
+import ts$2 from 'rollup-plugin-typescript2';
+import dotenv from '@dotenv-run/rollup';
+import { getBabelOutputPlugin } from '@rollup/plugin-babel';
+import { deleteAsync } from 'del';
+import path from 'path';
+import MagicString from 'magic-string';
+import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
+import { findWorkspacePackages } from '@pnpm/workspace.find-packages';
+import { readFileSync } from 'fs';
+
+function del(options = {}) {
+    const { hook = 'buildStart', runOnce = false, targets = [], verbose = false, } = options;
+    let isDeleted = false;
+    return {
+        name: 'del',
+        [hook]: async () => {
+            if (runOnce && isDeleted)
+                return;
+            const paths = await deleteAsync(targets, options);
+            if (verbose || options.dryRun) {
+                const message = options.dryRun
+                    ? `Expected files and folders to be deleted: ${paths.length.toString()}`
+                    : `Deleted files and folders: ${paths.length.toString()}`;
+                console.log(message);
+                if (paths.length)
+                    paths.forEach((path) => {
+                        console.log(path);
+                    });
+            }
+            isDeleted = true;
+        },
+    };
+}
+
+/**
+ * Класс ошибки для обработки проблем с монорепозиторием,
+ * расширяющий стандартный Error.
+ *
+ * @since 0.3.5
+ *
+ **/
+class WorkspaceError extends Error {
+    /**
+     * Приватный конструктор для создания экземпляра ошибки.
+     *
+     * @param message - Сообщение об ошибке.
+     * @param scope - Область, к которой относится ошибка (по умолчанию '@mirta/rollup').
+     *
+     **/
+    constructor(message, scope = '@mirta/rollup') {
+        super(`[${scope}] ${message}`);
+        this.name = 'WorkspaceError';
+        if ('captureStackTrace' in Error)
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            Error.captureStackTrace(this, WorkspaceError.get);
+    }
+    static codeMappings = {
+        noPackageName: (packagePath) => `Package with path "${packagePath}" missing required 'name' field in package.json`,
+        noWorkspaces: () => 'No workspaces configured in root package.json',
+    };
+    static get(code, ...args) {
+        const messageFn = this.codeMappings[code];
+        const message = messageFn(...args);
+        return new WorkspaceError(message);
+    }
+}
+/**
+ * Класс ошибки для обработки проблем с менеджерами пакетов,
+ * расширяющий стандартный Error.
+ *
+ * @since 0.3.5
+ *
+ **/
+class PackageManagerError extends Error {
+    /**
+     * Приватный конструктор для создания экземпляра ошибки.
+     *
+     * @param message - Сообщение об ошибке.
+     * @param scope - Область, к которой относится ошибка (по умолчанию '@mirta/rollup').
+     *
+     **/
+    constructor(message, scope = '@mirta/rollup') {
+        super(`[${scope}] ${message}`);
+        this.name = 'PackageManagerError';
+        if ('captureStackTrace' in Error)
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            Error.captureStackTrace(this, PackageManagerError.get);
+    }
+    static codeMappings = {
+        pnpmOnly: () => 'PNPM is required for building. Other package managers are not supported at this time',
+    };
+    static get(code, ...args) {
+        const messageFn = this.codeMappings[code];
+        const message = messageFn(...args);
+        return new PackageManagerError(message);
+    }
+}
+/**
+ * Класс ошибки для обработки проблем с файлами, расширяющий стандартный Error.
+ *
+ * @since 0.3.5
+ *
+ **/
+class FileError extends Error {
+    /**
+     * Приватный конструктор для создания экземпляра ошибки.
+     *
+     * @param message - Сообщение об ошибке.
+     * @param scope - Область, к которой относится ошибка (по умолчанию '@mirta/rollup').
+     *
+     **/
+    constructor(message, scope = '@mirta/rollup') {
+        super(`[${scope}] ${message}`);
+        this.name = 'FileError';
+        if ('captureStackTrace' in Error)
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            Error.captureStackTrace(this, FileError.get);
+    }
+    /** Карта кодов ошибок с соответствующими сообщениями. */
+    static codeMappings = {
+        /** Ошибка, возникающая при отсутствии файла в указанном расположении. */
+        notFound: (filePath) => `File not found: "${filePath}"`,
+        /** Ошибка, возникающая при отсутствии доступа к указанному файлу. */
+        noAccess: (filePath) => `No access to file "${filePath}"`,
+        /** Ошибка, возникающая при невалидном JSON в файле. */
+        invalidJson: (filePath, message) => `Invalid JSON in file "${filePath}": ${message}`,
+        /** Ошибка парсинга, возникающая по неуточненным причинам. */
+        failedToParse: (filePath, message) => `Failed to parse "${nodePath.basename(filePath)}": ${message}`,
+    };
+    /**
+     * Статический метод для получения экземпляра ошибки по коду.
+     *
+     * @template T - Тип ключа из codeMappings
+     * @param code - Код ошибки
+     * @param args - Аргументы для формирования сообщения
+     * @returns Экземпляр {@link FileError}
+     *
+     **/
+    static get(code, ...args) {
+        const messageFn = this.codeMappings[code];
+        const message = messageFn(...args);
+        return new FileError(message);
+    }
+}
+/**
+ * Класс ошибки сборки под NPM, расширяющий стандартный Error.
+ *
+ * @since 0.3.5
+ *
+ **/
+class NpmBuildError extends Error {
+    /**
+     * Приватный конструктор для создания экземпляра ошибки.
+     *
+     * @param message - Сообщение об ошибке
+     * @param scope - Область действия ошибки (по умолчанию '@mirta/rollup NPM')
+     *
+     **/
+    constructor(message, scope = '@mirta/rollup NPM') {
+        super(`[${scope}] ${message}`);
+        this.name = 'NpmBuildError';
+        if ('captureStackTrace' in Error)
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            Error.captureStackTrace(this, NpmBuildError.get);
+    }
+    /** Карта кодов ошибок с соответствующими сообщениями. */
+    static codeMappings = {
+        /** Ошибка, возникающая когда конфигурация input-файлов Rollup пуста. */
+        inputEmpty: () => 'Rollup Config: Input configuration cannot be empty',
+        /** Ошибка, возникающая когда input-файл не начинается с требуемого префикса. */
+        inputPathRequiresPrefix: (input, prefix) => `Rollup Config: Input path "${input}" must start with required prefix "${prefix}"`,
+        /** Ошибка, возникающая когда input-файл имеет недопустимое расширение. */
+        inputFileExtensionNotSupported: (input) => `Rollup Config: Unsupported input "${input}". Please use valid JS or TS file extension`,
+        /** Ошибка, возникающая из-за дублирования выходного файла несколькими input-файлами. */
+        inputGeneratesDuplicateOutput: (outputFile) => `Rollup Config: Duplicate output file "${outputFile}" produced by multiple inputs. Ensure each input maps to a unique export path`,
+        /** Ошибка, возникающая когда input-файл не ассоциирован с экспортом в package.json. */
+        inputHasNoExport: (input, entry) => `Rollup Config: The input file "${input}" is not associated with corresponding export "${entry}"`,
+        /** Ошибка, возникающая при отсутствии экспорта в package.json. */
+        exportEmpty: () => 'Package Config: Missing export configuration. Please define the "exports" field',
+        /** Ошибка, возникающая при экспорте типов без указания default-импорта. */
+        exportTypesOnly: (types) => `Package Config: Export contains only types "${types}" without specifying a default import in package.json`,
+        /** Ошибка, возникающая при отсутствии соответствия с input-файлом конфигурации Rollup. */
+        exportHasNoInput: (entry) => `Package Config: Export "${entry}" has no corresponding input file in Rollup configuration`,
+        /** Ошибка, возникающая при использовании массива в качестве значения exports. */
+        exportDisallowArrayType: () => 'Package Config: The field "exports" must be either a string or an object, but found an array',
+        /** Ошибка, возникающая при отсутствии точки в начале пути экспорта. */
+        exportMustStartWithDot: (key) => `Package Config: Invalid export path "${key}", it must start with "."`,
+    };
+    /**
+     * Статический метод для получения экземпляра ошибки по коду.
+     *
+     * @template T - Тип ключа из codeMappings
+     * @param code - Код ошибки
+     * @param args - Аргументы для формирования сообщения
+     * @returns Экземпляр {@link NpmBuildError}
+     *
+     **/
+    static get(code, ...args) {
+        const messageFn = this.codeMappings[code];
+        const message = messageFn(...args);
+        return new NpmBuildError(message);
+    }
+}
+/**
+ * Класс ошибки трансформации AST, расширяющий стандартный Error.
+ *
+ * @since 0.3.5
+ *
+ **/
+class AstTransformError extends Error {
+    /**
+     * Приватный конструктор для создания экземпляра ошибки.
+     *
+     * @param message - Сообщение об ошибке
+     * @param scope - Область действия ошибки (по умолчанию '@mirta/rollup AST')
+     *
+     **/
+    constructor(message, scope = '@mirta/rollup AST') {
+        super(`[${scope}] ${message}`);
+        this.name = 'AstTransformError';
+        if ('captureStackTrace' in Error)
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            Error.captureStackTrace(this, AstTransformError.get);
+    }
+    /** Карта кодов ошибок с соответствующими сообщениями. */
+    static codeMappings = {
+        /** Ошибка, возникающая при отсутствии root-файлов в проекте. */
+        noRootFilesInProject: () => 'No root files found in the project. Check your TypeScript configuration (tsconfig.json)',
+        /** Ошибка, возникающая при отсутствии модуля для указанного спецификатора. */
+        moduleNotFound: (modulePath, sourceFileName) => `Module "${modulePath}" not found in "${sourceFileName}"`,
+        /** Ошибка, возникающая когда modulePath содержит недопустимые символы. */
+        invalidPathFormat: (modulePath) => `Invalid format of module path: "${modulePath}"`,
+    };
+    /**
+     * Статический метод для получения экземпляра ошибки по коду.
+     *
+     * @template T - Тип ключа из codeMappings
+     * @param code - Код ошибки
+     * @param args - Аргументы для формирования сообщения
+     * @returns Экземпляр {@link AstTransformError}
+     *
+     **/
+    static get(code, ...args) {
+        const messageFn = this.codeMappings[code];
+        const message = messageFn(...args);
+        return new AstTransformError(message);
+    }
+}
+
+/**
+ * Удаляет расширение файла `.ts`, `.d.ts` или `.js`.
+ *
+ * @param fileName - Полное имя файла
+ * @returns Имя файла без расширения
+ *
+ * @since 0.3.5
+ *
+ **/
+const removeFileExtension = (fileName) => fileName.replace(/\.(?:d\.)?(?:[cm]?[tj]s)$/i, '');
+/**
+ * Находит общий префикс двух путей.
+ *
+ * @param a - Первый путь
+ * @param b - Второй путь
+ * @returns Общий префикс
+ *
+ * @since 0.3.5
+ *
+ **/
+function getCommonPrefix(a, b) {
+    const aParts = nodePath.normalize(a).split(nodePath.sep);
+    const bParts = nodePath.normalize(b).split(nodePath.sep);
+    const minLength = Math.min(aParts.length, bParts.length);
+    let i = 0;
+    while (i < minLength && aParts[i] === bParts[i]) {
+        i++;
+    }
+    return aParts.slice(0, i).join(nodePath.sep);
+}
+/**
+ * Проверяет, является ли указанный файл частью проекта.
+ *
+ * Файл считается проектным, если он:
+ * - Не находится в директории `node_modules`;
+ * - Расположен внутри указанной корневой директории.
+ *
+ * @param fileName - Полный путь к проверяемому файлу.
+ * @param rootDir - Корневая директория проекта.
+ * @returns `true`, если файл принадлежит проекту, иначе false.
+ *
+ * @since 0.3.5
+ *
+ **/
+function isProjectFile(fileName, rootDir) {
+    if (fileName.includes('node_modules'))
+        return false;
+    if (nodePath.relative(rootDir, fileName).startsWith('..'))
+        return false;
+    return true;
+}
+/**
+ * Вычисляет относительный путь от директории исходного файла к целевому файлу,
+ * добавляет имя выходного файла и нормализует путь для совместимости с POSIX-системами.
+ *
+ * @param sourceFilePath - Полный путь к исходному файлу.
+ * @param targetFilePath - Полный путь к целевому файлу.
+ * @param outputName - Имя выходного файла, который будет добавлен к относительному пути.
+ * @returns Нормализованный относительный путь с именем выходного файла.
+ *
+ * @example
+ *
+ * ```ts
+ * const sourceFilePath = '/project/src/index.ts'
+ * const targetFilePath = '/project/src/utils/index.ts'
+ * const outputName = 'utils.d.ts'
+ *
+ * getRelativeOutputPath(sourceFilePath, targetFilePath, outputName) // Возвращает './utils.d.ts'
+ *
+ * ```
+ * @since 0.3.5
+ *
+ **/
+function getRelativeOutputPath(sourceFilePath, targetFilePath, outputFileName) {
+    // Шаг 1: Получаем директорию исходного файла.
+    const sourceDir = nodePath
+        .dirname(sourceFilePath);
+    // Шаг 2: Вычисляем относительный путь от директории исходного файла до целевого файла.
+    const relativeDir = nodePath
+        .dirname(nodePath.relative(sourceDir, targetFilePath));
+    // Шаг 3: Объединяем относительную директорию с именем выходного файла.
+    let relativePath = nodePath
+        .join(relativeDir, outputFileName);
+    relativePath = relativePath
+        .split(nodePath.sep)
+        .join(nodePath.posix.sep);
+    // Шаг 4: Гарантируем, что путь является относительным.
+    if (!relativePath.startsWith('.'))
+        relativePath = `./${relativePath}`;
+    return relativePath;
+}
+/**
+ * Определяет корневую директорию файла на основе конфигурации.
+ *
+ * @param context - Базовый контекст
+ * @param sourceFile - Обрабатываемый файл
+ * @returns Путь к корню проекта
+ * @throws Ошибка, если файлы не найдены
+ *
+ * @since 0.3.5
+ *
+ **/
+function getRootDir(context, sourceFile) {
+    const { compilerOptions, program } = context;
+    // Если rootDirs указаны — ищем, к какому корню относится файл.
+    if (compilerOptions.rootDirs?.length) {
+        const sortedRoots = [...compilerOptions.rootDirs]
+            .sort((a, b) => b.length - a.length);
+        const normalizedFile = nodePath.resolve(sourceFile.fileName);
+        for (const rootDir of sortedRoots) {
+            const normalizedRoot = nodePath.resolve(rootDir);
+            if (normalizedFile.startsWith(normalizedRoot + nodePath.sep))
+                return rootDir;
+        }
+    }
+    // Если rootDir указан — используем его.
+    if (compilerOptions.rootDir)
+        return compilerOptions.rootDir;
+    // Иначе находим общий корень для всех файлов.
+    const fileNames = program.getRootFileNames();
+    if (!fileNames.length)
+        throw AstTransformError.get('noRootFilesInProject');
+    let commonPrefix = nodePath.dirname(fileNames[0]);
+    for (const fileName of fileNames.slice(1)) {
+        commonPrefix = getCommonPrefix(commonPrefix, fileName);
+    }
+    return commonPrefix;
+}
+
+/**
+ * Перечисление типов индексных файлов.
+ * Используется для классификации модулей в зависимости от их отношения к файлам `index`.
+ *
+ * @since 0.3.5
+ *
+ **/
+var IndexType;
+(function (IndexType) {
+    /** Не индексный файл. */
+    IndexType["NonIndex"] = "non-index";
+    /** Явный индекс (например, `import './index'`). */
+    IndexType["Explicit"] = "explicit";
+    /** Неявный индекс (например, `import './dir'`). */
+    IndexType["Implicit"] = "implicit";
+    /** Индекс внутри пакета (например, import 'package/index'). */
+    IndexType["ImplicitPackage"] = "implicit-package";
+})(IndexType || (IndexType = {}));
+
+/**
+ * Проверяет безопасность пути модуля, блокируя подозрительные символы.
+ *
+ * Эта функция проверяет, не содержит ли путь модуля недопустимых символов,
+ * таких как `:` (используется в URL) или `~` (ссылка на домашнюю директорию),
+ * которые могут представлять риск безопасности.
+ *
+ * @param path - Путь модуля для проверки.
+ *
+ * @throws {AstTransformError} Если обнаружены запрещённые символы.
+ *
+ * @example
+ * ```ts
+ * assertPathIsValid('./utils') // OK
+ * assertPathIsValid('http://malicious.com') // Выбросит ошибку
+ *
+ * ```
+ * @since 0.3.5
+ *
+ **/
+function assertPathIsValid(path) {
+    if (path.includes(':') || path.includes('~'))
+        throw AstTransformError.get('invalidPathFormat', path);
+}
+
+/**
+ * Создает кэш файлов по имени без расширения.
+ *
+ * @param program - Программа TypeScript
+ * @returns Карта: ключ - имя файла без расширения, значение - объект файла
+ *
+ * @since 0.3.5
+ *
+ **/
+function createSourceFilesCache(program) {
+    return new Map(program.getSourceFiles().map(sourceFile => [
+        removeFileExtension(sourceFile.fileName),
+        sourceFile,
+    ]));
+}
+/**
+ * Получает файл из программы или создает его при необходимости.
+ * Использует кэш для повышения производительности при повторных запросах.
+ *
+ * @param context - Контекст трансформера, содержащий ссылку на программу и кэш файлов.
+ * @param fileName - Полный путь к файлу, который необходимо найти или создать.
+ * @returns Экземпляр {@link ts.SourceFile} для существующего или созданного файла.
+ *
+ * @since 0.3.5
+ *
+ **/
+function resolveSourceFile(context, fileName) {
+    const { program, compilerOptions } = context;
+    let result = program.getSourceFile(fileName);
+    if (result)
+        return result;
+    // Если кэш уже создан, используем его. Иначе создаем новый.
+    const sourceFilesCache = context.sourceFilesCache ??= createSourceFilesCache(program);
+    const normalizedFileName = removeFileExtension(fileName);
+    // Попытка найти файл в кэше.
+    result = sourceFilesCache.get(normalizedFileName);
+    if (!result) {
+        result = ts.createSourceFile(fileName, '', compilerOptions.target ?? ts.ScriptTarget.ESNext, false);
+        sourceFilesCache.set(normalizedFileName, result);
+    }
+    return result;
+}
+
+/**
+ * Анализирует путь модуля и определяет его тип (явный, неявный, пакетный или обычный).
+ * Собирает метаданные о модуле для дальнейшей обработки путей импорта.
+ *
+ * @param path - Путь модуля из исходного кода (например, './dir' или 'package/index').
+ * @param resolvedModule - Объект, содержащий информацию о разрешённом модуле из TypeScript.
+ * @returns Объект с детализацией пути, включая тип индекса, имя файла, расширение и директорию.
+ *
+ * @since 0.3.5
+ *
+ **/
+function getPathDetails(path, resolvedModule) {
+    const { resolvedFileName, packageId } = resolvedModule;
+    const implicitPackagePath = packageId?.subModuleName;
+    // Указывает, является ли модуль частью пакета (например, 'package/index').
+    const isPackage = !!implicitPackagePath;
+    // Базовые данные разрешённого файла
+    const resolvedBaseName = nodePath.basename(isPackage
+        ? implicitPackagePath
+        : resolvedFileName);
+    const resolvedBaseNameNoExtension = resolvedBaseName
+        ? removeFileExtension(resolvedBaseName)
+        : undefined;
+    // const resolvedExtension = resolvedBaseName
+    //   ? nodePath.extname(resolvedFileName)
+    //   : undefined
+    // Базовые данные оригинального модуля
+    let baseName = isPackage
+        ? undefined
+        : nodePath.basename(path);
+    let baseNameNoExtension = baseName
+        ? removeFileExtension(baseName)
+        : undefined;
+    let extName = baseName
+        ? nodePath.extname(path)
+        : undefined;
+    // Если имя оригинального модуля совпадает с разрешённым, убираем расширение.
+    if (resolvedBaseNameNoExtension
+        && baseName
+        && resolvedBaseNameNoExtension === baseName) {
+        baseNameNoExtension = baseName;
+        extName = undefined;
+    }
+    let indexType;
+    if (isPackage) {
+        // Модуль внутри пакета (например, import 'package/index').
+        indexType = IndexType.ImplicitPackage;
+    }
+    else if (baseNameNoExtension === 'index' && resolvedBaseNameNoExtension === 'index') {
+        // Явный импорт файла index (например, import './dir/index').
+        indexType = IndexType.Explicit;
+    }
+    else if (baseNameNoExtension !== 'index' && resolvedBaseNameNoExtension === 'index') {
+        // Неявный импорт index (например, import './dir').
+        indexType = IndexType.Implicit;
+    }
+    else {
+        // Обычный файл, не связанный с index.
+        indexType = IndexType.NonIndex;
+    }
+    // Для неявных индексов убирает лишние поля оригинального
+    // модуля, чтобы не отображать index и расширения.
+    //
+    if (indexType === IndexType.Implicit) {
+        baseName = undefined;
+        baseNameNoExtension = undefined;
+        extName = undefined;
+    }
+    return {
+        // baseName,
+        // baseNameNoExtension,
+        extName,
+        // resolvedBaseName,
+        resolvedBaseNameNoExtension,
+        // resolvedExtension,
+        // resolvedDir: isPackage
+        //  ? removeSuffix(resolvedFileName, `/${implicitPackageIndex}`)
+        //  : nodePath.dirname(resolvedFileName),
+        indexType,
+        // implicitPackagePath,
+        // resolvedFileName,
+    };
+}
+/**
+ * Генерирует новый относительный путь для импорта модуля, исключая расширения и индексные файлы.
+ * Проверяет безопасность пути и убеждается, что файл находится внутри корня проекта.
+ *
+ * @param context - Контекст трансформера, содержащий информацию о текущем файле и конфигурации.
+ * @param oldPath - Путь модуля из исходного импорта (например, './utils/index').
+ * @returns Относительный путь без расширения и индекса, или `undefined`, если модуль недопустим.
+ *
+ * @since 0.3.5
+ *
+ **/
+function resolveNewModulePath(context, oldPath) {
+    assertPathIsValid(oldPath);
+    const { 
+    // Текущий обрабатываемый файл.
+    sourceFile: currentSourceFile, 
+    // Актуальная конфигурация TypeScript.
+    compilerOptions, } = context;
+    // Получаем модуль импортированного файла.
+    //
+    const { resolvedModule: importedModule } = ts.resolveModuleName(oldPath, currentSourceFile.fileName, compilerOptions, ts.sys);
+    if (!importedModule)
+        throw AstTransformError.get('moduleNotFound', oldPath, currentSourceFile.fileName);
+    if (!isProjectFile(importedModule.resolvedFileName, context.rootDir))
+        return null;
+    // Получает детали пути импортированного модуля.
+    const pathDetails = getPathDetails(oldPath, importedModule);
+    const { indexType, resolvedBaseNameNoExtension, extName } = pathDetails;
+    let outputBaseName = resolvedBaseNameNoExtension ?? '';
+    if (indexType === IndexType.Implicit && outputBaseName.endsWith('index'))
+        outputBaseName = outputBaseName.slice(0, -5);
+    if (outputBaseName && extName)
+        outputBaseName = `${outputBaseName}${extName}`;
+    // Получает исходный файл импортированного модуля.
+    const importedSourceFile = resolveSourceFile(context, importedModule.resolvedFileName);
+    const newPath = getRelativeOutputPath(currentSourceFile.fileName, importedSourceFile.fileName, outputBaseName);
+    return newPath;
+}
+
+const aliasPattern = /^[@#]/;
+/**
+ * Обновляет спецификатор модуля в узле импорта или экспорта.
+ *
+ * @param factory - Фабрика для создания новых узлов AST.
+ * @param node - Узел импорта или экспорта.
+ * @param newModuleSpecifier - Новый относительный путь.
+ * @returns Обновлённый узел.
+ *
+ * @since 0.3.5
+ *
+ **/
+function updateModuleSpecifier(factory, node, newModuleSpecifier) {
+    if (ts.isImportDeclaration(node)) {
+        return factory.updateImportDeclaration(node, node.modifiers, node.importClause, factory.createStringLiteral(newModuleSpecifier), node.attributes);
+    }
+    else if (ts.isExportDeclaration(node)) {
+        return factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, factory.createStringLiteral(newModuleSpecifier), node.attributes);
+    }
+    return node;
+}
+/**
+ * Рекурсивно обходит дочерние узлы AST с текущим визитором.
+ */
+function visitChildren(context, node) {
+    return ts.visitEachChild(node, context.getVisitor(), context.transformationContext);
+}
+/**
+ * Визитор для обработки узлов AST, связанных с импортами.
+ *
+ * Обновляет пути модулей, начинающиеся с `#` или `@`, в файлах объявлений TypeScript.
+ *
+ * @param this - Контекст трансформера, предоставляющий инструменты для работы с AST.
+ * @param node - Текущий узел AST, который проверяется и, при необходимости, обновляется.
+ * @returns Обновленный узел AST или результат рекурсивного обхода дочерних узлов.
+ *
+ * @example
+ * ```ts
+ * // Исходный узел импорта:
+ * import { foo } from '#utils/index'
+ *
+ * // После обработки:
+ * import { foo } from './utils'
+ *
+ * ```
+ * @since 0.3.5
+ *
+ **/
+function nodeVisitor(node) {
+    if (!ts.isImportDeclaration(node) && !ts.isExportDeclaration(node))
+        return visitChildren(this, node);
+    const moduleSpecifier = node.moduleSpecifier;
+    if (!moduleSpecifier || !ts.isStringLiteral(moduleSpecifier))
+        return visitChildren(this, node);
+    // Извлекаем путь импорта/экспорта (указывается в кавычках после from).
+    const { text: oldPath } = moduleSpecifier;
+    // Проверяем, относится ли спецификатор к алиасу проекта (`#`) или кастомному алиасу (`@`).
+    // Такие спецификаторы требуют пересчета в относительный путь.
+    //
+    if (!aliasPattern.test(oldPath))
+        return visitChildren(this, node);
+    const cachedNewPath = this.pathsCache.get(oldPath);
+    const newPath = cachedNewPath === undefined
+        ? resolveNewModulePath(this, oldPath)
+        : cachedNewPath;
+    if (cachedNewPath === undefined)
+        this.pathsCache.set(oldPath, newPath);
+    if (!newPath)
+        return node;
+    // Обновляем узел импорта новым значением пути.
+    // Если путь не удалось преобразовать, возвращаем исходный узел.
+    //
+    return updateModuleSpecifier(this.factory, node, newPath);
+}
+
+/**
+ * Фабрика трансформеров для Rollup, предназначенная для обработки файлов объявлений TypeScript (`.d.ts`).
+ * Создаёт трансформер, который модифицирует пути импортов в декларациях, исключая расширения и индексные файлы.
+ *
+ * @param program - Экземпляр программы TypeScript, предоставляющий доступ к всем файлам проекта.
+ * @returns Фабрика трансформеров, применяющаяся ко всем `.d.ts`-файлам.
+ *
+ * @since 0.3.5
+ *
+ **/
+function dtsAliasTransformerFactory(program) {
+    return (context) => {
+        const compilerOptions = program.getCompilerOptions();
+        /**
+         * Базовый контекст для работы с AST-трансформером.
+         * Содержит общие параметры и ссылки на программу TypeScript.
+         *
+         **/
+        const visitorContextBase = {
+            compilerOptions,
+            program,
+            factory: context.factory,
+            transformationContext: context,
+        };
+        return (sourceFile) => {
+            /**
+             * Обработка происходит только для файлов объявлений (`.d.ts`).
+             * Обычные файлы (`*.ts`) игнорируются.
+             *
+             **/
+            if (!sourceFile.isDeclarationFile)
+                return sourceFile;
+            /**
+             * Контекст визитора, расширенный информацией о текущем файле и корне проекта.
+             * Используется для передачи данных в `nodeVisitor`.
+             *
+             **/
+            const visitorContext = {
+                ...visitorContextBase,
+                sourceFile,
+                rootDir: getRootDir(visitorContextBase, sourceFile),
+                pathsCache: new Map(),
+                getVisitor() {
+                    return nodeVisitor.bind(this);
+                },
+            };
+            /**
+             * Рекурсивный обход AST с применением визитора.
+             * Обрабатывает все узлы файла, начиная с корня.
+             *
+             **/
+            return ts.visitEachChild(sourceFile, visitorContext.getVisitor(), context);
+        };
+    };
+}
+
+/**
+ * Экспортируемый трансформер для Rollup, предназначенный для обработки файлов объявлений TypeScript (`.d.ts`).
+ * Используется в фазе `afterDeclarations`, чтобы корректировать пути импортов после генерации типов.
+ *
+ * @returns Объект трансформера, который может быть передан в конфигурацию Rollup.
+ *
+ * @example
+ * Пример использования в конфигурации Rollup:
+ * ```ts
+ * import { dtsAlias } from '#ast/dts-alias';
+ *
+ * export default {
+ *   plugins: [
+ *     typescript({
+ *       transformers: {
+ *         afterDeclarations: [
+ *           dtsAlias()
+ *         ]
+ *       }
+ *     })
+ *   ]
+ * }
+ *
+ * ```
+ * @since 0.3.5
+ *
+ **/
+const dtsAlias = () => ({
+    type: 'program',
+    factory: dtsAliasTransformerFactory,
+});
+
+/**
+ * Синхронно парсит файл `package.json` и возвращает его содержимое в виде
+ * типизированного объекта. Обрабатывает распространённые ошибки
+ * файловой системы и синтаксические ошибки JSON с помощью пользовательских исключений.
+ *
+ * @param filePath - Абсолютный или относительный путь к файлу `package.json`.
+ * @returns Объект типа {@link Package}, представляющий данные из файла.
+ * @throws {FileError} При ошибке обработки файла.
+ *
+ * @since 0.3.5
+ *
+ **/
+function parsePackageJson(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (e) {
+        if (e instanceof SyntaxError)
+            throw FileError.get('invalidJson', filePath, e.message);
+        if (e instanceof Error) {
+            if ('code' in e) {
+                switch (e.code) {
+                    case 'ENOENT':
+                        throw FileError.get('notFound', filePath);
+                    case 'EACCES':
+                    case 'EPERM':
+                        throw FileError.get('noAccess', filePath);
+                }
+            }
+            throw FileError.get('failedToParse', filePath, e.message);
+        }
+        throw FileError.get('failedToParse', filePath, String(e));
+    }
+}
+
+/**
+ * Преобразует входные данные в массив, исключая "ложные" значения (`false`, `null`, `undefined`).
+ *
+ * @param input - Входные данные, которые могут быть:
+ *   - массивом элементов типа `TItem | false | null | undefined`;
+ *   - отдельным элементом типа `TItem | false | null | undefined`.
+ * @returns Массив элементов типа `TItem`, содержащий только "истинные" значения.
+ *
+ * @example
+ *
+ * ```ts
+ * ensureCompactArray([1, null, 2]) // [1, 2]
+ *
+ * ensureCompactArray(undefined) // []
+ *
+ * ensureCompactArray('test') // ['test']
+ *
+ * ```
+ * @since 0.3.5
+ *
+ **/
+function ensureCompactArray(input) {
+    if (Array.isArray(input))
+        return input.filter(Boolean);
+    if (input)
+        return [input];
+    return [];
+}
+
+/**
+ * Создаёт фильтр для определения внешних модулей на основе указанных правил.
+ *
+ * @param cwd Рабочая директория проекта (используется для проверки относительных путей)
+ * @param externals Набор паттернов или функций для определения внешних модулей
+ * @returns Функция-предикат, которая принимает параметры модуля и возвращает true,
+ *          если модуль должен быть считаться внешним
+ *
+ * @returns Функция-предикат `(target: string, importer: string | undefined, isResolved: boolean): boolean`,
+ *          которая возвращает `true`, если модуль считается внешним.
+ *
+ * @since 0.3.5
+ *
+ **/
+function createExternalFilter(cwd, ...externals) {
+    /**
+     * Функция-предикат для определения внешнего модуля
+     *
+     * @param target Целевой путь/имя модуля
+     * @param importer Имя файла, который импортирует модуль (если доступно)
+     * @param isResolved Флаг, указывающий, был ли модуль успешно разрешён
+     * @returns `true`, если модуль внешний, иначе false
+     */
+    return (target, importer, isResolved) => {
+        for (const external of externals) {
+            // Шаг 1: Пользовательская функция
+            if (typeof external === 'function') {
+                if (external(target, importer, isResolved))
+                    return true;
+            }
+            else {
+                // Шаг 2: Массив паттернов
+                const isExternal = ensureCompactArray(external).some((item) => {
+                    if (item instanceof RegExp)
+                        return item.test(target);
+                    return item === target;
+                });
+                if (isExternal)
+                    return true;
+            }
+        }
+        // Шаг 3: Путь вне cwd (только для обнаруженных модулей)
+        if (isResolved && cwd && nodePath.isAbsolute(target)) {
+            const relativePath = nodePath.relative(cwd, target);
+            // Если путь вне cwd, отмечаем его как внешний
+            if (relativePath.startsWith('..') || nodePath.isAbsolute(relativePath)) {
+                if ((process.env.NODE_ENV !== 'production'))
+                    console.debug(`Skipping non-project "${relativePath}"`);
+                return true;
+            }
+        }
+        // Шаг 4: По умолчанию — внутренний
+        return false;
+    };
+}
+
+const dtsOutputDir = 'dist/dts';
+/**
+ * Удаляет префикс './dist/' из пути.
+ * @param path Путь к файлу.
+ * @returns Нормализованный путь.
+ *
+ * @since 0.3.5
+ *
+ **/
+function sliceDistPrefix(path) {
+    return path.startsWith('./dist/')
+        ? path.slice(7)
+        : path;
+}
+/**
+ * Нормализует входные данные в массив строк.
+ *
+ * @param input Входные данные (строка, массив или объект).
+ * @returns Массив путей к входным файлам.
+ * @throws {NpmBuildError} Если входная конфигурация пуста.
+ *
+ * @since 0.3.4
+ *
+ **/
+function normalizeInput(input) {
+    const inputs = [];
+    // Нормализация входных данных.
+    // Строка, массив или объект преобразуются в единый массив строк inputs.
+    if (typeof input === 'string') {
+        inputs.push(input);
+    }
+    else if (Array.isArray(input)) {
+        inputs.push(...input);
+    }
+    else if (typeof input === 'object') {
+        inputs.push(...Object.values(input));
+    }
+    if (inputs.length === 0)
+        throw NpmBuildError.get('inputEmpty');
+    return inputs;
+}
+/**
+ * Проверяет, является ли объект условной записью экспорта.
+ *
+ * @param source Объект для проверки.
+ * @returns `true`, если объект содержит поле `import`.
+ *
+ * @since 0.3.5
+ *
+ **/
+function isConditionalEntry(source) {
+    return 'import' in source;
+}
+/**
+ * Обрабатывает условную запись экспорта.
+ *
+ * @param source Условная запись.
+ * @returns Объект с полями entry и types.
+ *
+ * @since 0.3.5
+ *
+ **/
+function processConditionalEntry(source) {
+    const result = {};
+    if (source.import) {
+        if (typeof source.import === 'string') {
+            // Путь точки входа определён, типизация отсутствует.
+            result.entry = source.import;
+        }
+        else {
+            result.entry = source.import.default;
+            result.types = source.import.types;
+        }
+    }
+    return result;
+}
+/**
+ * Проверяет наличие точки входа для типизации.
+ *
+ * @param entry Путь к точке входа.
+ * @param types Путь к файлу типов.
+ * @throws {NpmBuildError} Если отсутствует точка входа.
+ *
+ * @since 0.3.5
+ *
+ **/
+function assertTypesHaveEntry(entry, types) {
+    if (types && !entry)
+        throw NpmBuildError.get('exportTypesOnly', types);
+}
+/**
+ * Нормализует поле `exports` из package.json в словарь точек входа.
+ *
+ * @param exportsField Значение поля `exports`.
+ * @returns Словарь точек входа с метаданными.
+ * @throws {NpmBuildError} Если конфигурация экспорта отсутствует или некорректна.
+ *
+ * @since 0.3.5
+ *
+ **/
+function normalizeExports(exportsField) {
+    if (!exportsField)
+        throw NpmBuildError.get('exportEmpty');
+    if (Array.isArray(exportsField))
+        throw NpmBuildError.get('exportDisallowArrayType');
+    const result = {};
+    if (typeof exportsField === 'string') {
+        result[exportsField] = {};
+        return result;
+    }
+    if (isConditionalEntry(exportsField)) {
+        const { entry, types } = processConditionalEntry(exportsField);
+        assertTypesHaveEntry(entry, types);
+        if (entry)
+            result[entry] = types
+                ? { dtsOutputFile: types }
+                : {};
+        return result;
+    }
+    for (const [key, value] of Object.entries(exportsField)) {
+        if (!value)
+            continue;
+        if (!key.startsWith('.'))
+            throw NpmBuildError.get('exportMustStartWithDot', key);
+        let entry, types;
+        if (typeof value === 'string') {
+            // Путь точки входа определён, типизация отсутствует.
+            entry = value;
+        }
+        else if (isConditionalEntry(value)) {
+            ({ entry, types } = processConditionalEntry(value));
+        }
+        else {
+            entry = value.default;
+            types = value.types;
+        }
+        assertTypesHaveEntry(entry, types);
+        if (entry)
+            result[entry] = types
+                ? { dtsOutputFile: types }
+                : {};
+    }
+    return result;
+}
+/**
+ * Создаёт отображение между входными файлами и выходными путями.
+ *
+ * @param inputs Массив исходных файлов.
+ * @param normalizedExports Нормализованные дескрипторы экспорта.
+ * @param skipExports Позволяет пропустить проверку экспорта.
+ * @returns Словарь связей вход-выход.
+ * @throws {NpmBuildError} Если входной файл не связан с экспортом.
+ *
+ * @since 0.3.4
+ *
+ **/
+function getInputBindings(inputs, normalizedExports, skipExports) {
+    const bodyPattern = /^src\/(.*)\.[jt]s$/;
+    const result = {};
+    const usedExports = new Set();
+    const producingOutputs = new Set();
+    for (const input of inputs) {
+        if (!input.startsWith('src/'))
+            throw NpmBuildError.get('inputPathRequiresPrefix', input, 'src/');
+        const match = bodyPattern.exec(input);
+        if (!match)
+            throw NpmBuildError.get('inputFileExtensionNotSupported', input);
+        const outputFile = `${match[1]}.mjs`;
+        if (producingOutputs.has(outputFile))
+            throw NpmBuildError.get('inputGeneratesDuplicateOutput', outputFile);
+        producingOutputs.add(outputFile);
+        const exportEntry = `./dist/${outputFile}`;
+        usedExports.add(exportEntry);
+        const descriptor = normalizedExports[exportEntry];
+        // Проверяем наличие ключа в словаре экспорта (при необходимости).
+        if (!descriptor && !skipExports)
+            throw NpmBuildError.get('inputHasNoExport', input, exportEntry);
+        result[input] = {
+            outputFile,
+            dtsSourceFile: `${dtsOutputDir}/${match[1]}.d.ts`,
+            dtsOutputFile: descriptor?.dtsOutputFile,
+        };
+    }
+    for (const key of Object.keys(normalizedExports)) {
+        // Выявляем незадействованные ключи в словаре экспорта (обратная проверка).
+        if (!usedExports.has(key))
+            throw NpmBuildError.get('exportHasNoInput', key);
+    }
+    return result;
+}
+// Проверка TypeScript выполняется только для первой конфигурации.
+let hasTsChecked = false;
+/**
+ * Определяет конфигурацию сборки на основе package.json.
+ *
+ * @param options Опции конфигурации Rollup.
+ * @returns Массив конфигураций Rollup.
+ *
+ * @since 0.3.0
+ *
+ **/
+function definePackageConfig(options = {}) {
+    const { cwd = process.cwd(), input = 'src/index.ts', external = [], plugins, skipExports = false, } = options;
+    const pkgPath = nodePath.resolve(cwd, 'package.json');
+    const externalFilter = createExternalFilter(cwd, [
+        /node_modules/,
+        pkgPath,
+    ], external);
+    const { exports = {} } = parsePackageJson(pkgPath);
+    const normalizedExports = !skipExports
+        ? normalizeExports(exports)
+        : {};
+    const inputBindings = getInputBindings(normalizeInput(input), normalizedExports, skipExports);
+    // Создаёт отображение между файлами типов `.d.ts` и их выходными путями
+    const dtsMappings = Object.values(inputBindings)
+        .reduce((mappings, nextValue) => {
+        if (nextValue?.dtsOutputFile)
+            mappings[nextValue.dtsSourceFile] = sliceDistPrefix(nextValue.dtsOutputFile);
+        return mappings;
+    }, {});
+    const dtsInputs = Object.keys(dtsMappings);
+    const rollupConfigs = [
+        createBuildConfig('mjs', {
+            cwd,
+            input,
+            external: externalFilter,
+            emitDeclarations: dtsInputs.length > 0,
+            plugins,
+            output: {
+                dir: 'dist/',
+                format: 'es',
+                importAttributesKey: 'with',
+                entryFileNames(chunk) {
+                    if (chunk.facadeModuleId) {
+                        const localPath = nodePath
+                            .relative(cwd, chunk.facadeModuleId)
+                            .replaceAll(nodePath.sep, nodePath.posix.sep);
+                        const binding = inputBindings[localPath];
+                        if (binding)
+                            return binding.outputFile;
+                    }
+                    return `${chunk.name}.mjs`;
+                },
+                chunkFileNames: '[name].mjs',
+            },
+        }),
+    ];
+    if (dtsInputs.length > 0) {
+        rollupConfigs.push({
+            input: dtsInputs,
+            external: externalFilter,
+            plugins: [
+                nodeResolve(),
+                commonjs(),
+                dts(),
+                del({
+                    targets: [dtsOutputDir],
+                    hook: 'closeBundle',
+                }),
+            ],
+            output: {
+                dir: 'dist/',
+                format: 'es',
+                entryFileNames(chunk) {
+                    if (chunk.facadeModuleId) {
+                        const localPath = nodePath
+                            .relative(cwd, chunk.facadeModuleId)
+                            .replaceAll(nodePath.sep, nodePath.posix.sep);
+                        if (dtsMappings[localPath])
+                            return dtsMappings[localPath];
+                    }
+                    return `${chunk.name}.mts`;
+                },
+            },
+        });
+    }
+    return rollupConfigs;
+}
+/**
+ * Создаёт конфигурацию сборки Rollup.
+ *
+ * @param buildName Имя сборки.
+ * @param options Параметры сборки.
+ * @returns Конфигурация Rollup.
+ *
+ * @since 0.3.0
+ *
+ **/
+function createBuildConfig(buildName, options) {
+    const { cwd, external, input, emitDeclarations, plugins = [], output } = options;
+    output.sourcemap = !!process.env.SOURCE_MAP;
+    output.externalLiveBindings = false;
+    process.env.NODE_ENV === 'production';
+    const tsPlugin = ts$1({
+        tsconfig: nodePath.resolve(cwd, './tsconfig.build.json'),
+        compilerOptions: {
+            noCheck: hasTsChecked,
+            declaration: emitDeclarations,
+            declarationDir: emitDeclarations ? dtsOutputDir : void 0,
+        },
+        exclude: [
+            'packages/*/tests',
+        ],
+        transformers: {
+            afterDeclarations: [
+                dtsAlias(),
+            ],
+        },
+    });
+    // При запуске команды build, проверки TS и генерация определений
+    // выполняются единожды - для первой конфигурации.
+    hasTsChecked = true;
+    return {
+        input,
+        external,
+        plugins: [
+            tsPlugin,
+            createReplacePlugin(),
+            nodeResolve(),
+            commonjs(),
+            ...plugins,
+            copy({
+                targets: [
+                    { src: 'public/*', dest: 'dist' },
+                ],
+            }),
+        ],
+        output,
+    };
+}
+/**
+ * Создаёт плагин замены значений.
+ *
+ * @param isProduction Признак production-сборки.
+ * @param isBundlerEsmBuild Признак сборки для bundler ESM.
+ * @param isNodeBuild Признак сборки для Node.js.
+ * @returns Плагин замены.
+ *
+ * @since 0.3.0
+ *
+ **/
+function createReplacePlugin(isProduction, isBundlerEsmBuild, isNodeBuild) {
+    const replacements = {
+        // Preserve to be handled by bundlers
+        __DEV__: `(process.env.NODE_ENV !== 'production')`
+            ,
+        __TEST__: `(process.env.NODE_ENV === 'test')`
+            ,
+    };
+    // Allow inline overrides like
+    // __DEV__=true pnpm build
+    Object.keys(replacements).forEach((key) => {
+        if (key in process.env)
+            replacements[key] = process.env[key];
+    });
+    return replace({
+        preventAssignment: true,
+        values: replacements,
+        delimiters: ['\\b', '\\b(?![\\.\\:])'],
+    });
+}
+
+// Абсолютный путь к результирующему каталогу.
+const outputDir$1 = path.join(process.cwd(), 'dist');
+const modulesDir = path.join(outputDir$1, 'wb-rules-modules');
+// Расположение обрабатываемого чанка.
+const getChunkDir = (fileName) => path.dirname(path.join(outputDir$1, fileName));
+// Шаблон для отлова конструкций require.
+const patternRequire = /require\(['"]([^'"]+)'\)/g;
+/**
+ * Плагин Rollup, перестраивающий пути импорта модулей
+ * относительно каталога wb-rules-modules.
+ * */
+function wbRulesImports() {
+    return {
+        name: 'wbRulesImports',
+        // Выполняется перед записью содержимого
+        // в результирующий файл.
+        renderChunk(code, chunk) {
+            // Виртуальный каталог не обрабатываем.
+            if (chunk.fileName.startsWith('_virtual'))
+                return;
+            const magicString = new MagicString(code);
+            let hasReplacements = false;
+            let start;
+            let end;
+            const chunkDir = getChunkDir(chunk.fileName);
+            // Преобразует путь подключения модуля в формат,
+            // поддерживаемый контроллером Wirenboard.
+            function rebaseRequire(match) {
+                // Начальная позиция оригинального вхождения
+                start = match.index;
+                // Конечная позиция оригинального вхождения
+                end = start + match[0].length;
+                // Преобразует путь подключаемого модуля в абсолютный,
+                // опираясь на каталог с текущим обрабатываемым файлом.
+                const requireAbsolutePath = path.resolve(chunkDir, match[1]);
+                // Если абсолютный путь начинается с каталога модулей...
+                if (requireAbsolutePath.startsWith(modulesDir)) {
+                    const parsed = path.parse(path.relative(modulesDir, requireAbsolutePath));
+                    const rebased = path
+                        .join(parsed.dir, parsed.name)
+                        .replaceAll(path.sep, path.posix.sep);
+                    // Удаляет расширение файла для полного соответствия
+                    // принципам импорта модулей wb-rules.
+                    const replacement = match[0]
+                        .replace(match[1], rebased);
+                    magicString.overwrite(start, end, replacement);
+                    // Признак произведённой замены.
+                    return true;
+                }
+            }
+            // Строит полный список конструкций require
+            // в обрабатываемом файле.
+            const matches = [...code.matchAll(patternRequire)];
+            for (const match of matches) {
+                if (rebaseRequire(match))
+                    hasReplacements = true;
+            }
+            // Если никаких замен не было, то файл пропускается.
+            if (!hasReplacements)
+                return null;
+            return {
+                code: magicString.toString(),
+            };
+        },
+    };
+}
+
+/**
+ * Определяет корень монорепозитория по текущей директории.
+ *
+ * @param cwd - Текущая рабочая директория для поиска
+ * @returns Promise<string | undefined> - Абсолютный путь к корню или undefined
+ * @throws {PackageManagerError} Если используется неподдерживаемый менеджер пакетов
+ *
+ * @remarks
+ * Поддерживает только PNPM в текущей реализации.
+ *
+ * @since 0.3.5
+ *
+ **/
+async function findMonorepoDirAsync(cwd) {
+    if (process.env.PNPM_HOME)
+        return await findWorkspaceDir(cwd);
+    // TODO: реализовать поддержку остальных пакетных менеджеров.
+    throw PackageManagerError.get('pnpmOnly');
+}
+/**
+ * Формирует относительный путь в формате posix.
+ *
+ * @param workspaceDir - Корневая директория монорепозитория
+ * @param packageRootDir - Директория конкретного пакета
+ * @returns Стандартизированный относительный путь с завершающим слешем
+ *
+ **/
+function getWorkspacePath(workspaceDir, packageRootDir) {
+    return nodePath.relative(workspaceDir, packageRootDir)
+        .replaceAll(nodePath.sep, nodePath.posix.sep) + '/';
+}
+/**
+ * Получает полную информацию о структуре монорепозитория.
+ *
+ * @param cwd - Текущая рабочая директория для поиска
+ * @returns Объект контекста {@link MonorepoContext} или undefined
+ * @throws {WorkspaceError} Если проект определён как монорепозиторий и отсутствует секция `workspaces` в package.json
+ *
+ * @since 0.3.5
+ *
+ **/
+async function getMonorepoContextAsync(cwd) {
+    const monorepoDir = await findMonorepoDirAsync(cwd);
+    if (monorepoDir) {
+        const pkg = parsePackageJson(`${monorepoDir}/package.json`);
+        if (!pkg.workspaces)
+            throw WorkspaceError.get('noWorkspaces');
+        const packages = await findWorkspacePackages(monorepoDir, {
+            patterns: pkg.workspaces,
+        });
+        const context = {
+            rootDir: monorepoDir,
+            packages: packages
+                // Не рассматриваем корневой каталог в качестве пакета.
+                .filter(x => x.rootDir !== monorepoDir)
+                // Сортируем по длине пути к корню монорепозитория (самые длинные первыми).
+                .sort((a, b) => b.rootDir.length - a.rootDir.length)
+                // Создаём массив объектов с информацией о пакетах монорепозитория.
+                .map(item => ({
+                workspacePath: getWorkspacePath(monorepoDir, item.rootDir),
+                name: item.manifest.name,
+            })),
+        };
+        return context;
+    }
+}
+/**
+ * Поиск пакета по имени чанка
+ *
+ * @param context - Контекст монорепозитория
+ * @param chunkName - Имя чанка (обычно путь к файлу)
+ * @returns PackageDefinition | undefined - Найденный пакет или undefined
+ *
+ * @since 0.3.5
+ *
+ **/
+function findMonorepoPackageByChunkName(context, chunkName) {
+    for (const pkg of context.packages) {
+        if (chunkName.startsWith(pkg.workspacePath)) {
+            return pkg;
+        }
+    }
+}
+/**
+ * Преобразует путь к чанку в путь внутри node_modules
+ *
+ * @param chunkName - Полный путь к чанку
+ * @param pkgDefinition - Определение пакета
+ * @returns Строка в формате node_modules/<package-name>/<relative-path>
+ * @throws {WorkspaceError} Если имя пакета не указано
+ *
+ * @since 0.3.5
+ *
+ **/
+function mapChunkToPackage(chunkName, pkgDefinition) {
+    if (!pkgDefinition.name)
+        throw WorkspaceError.get('noPackageName', pkgDefinition.workspacePath);
+    return 'node_modules/'.concat(pkgDefinition.name, '/', nodePath.posix.relative(pkgDefinition.workspacePath, chunkName));
+}
+
+const packagesPattern = /(.*)node_modules[\\/]@?(.+)[\\/](.+)?/;
+const entryMatchers = {
+    'wb-rules': /(?:src[\\/])?wb-rules[\\/](.*)/,
+    'wb-rules-modules': /(?:src[\\/])?wb-rules-modules[\\/](.*)/,
+};
+/**
+ * Парсит путь к исходному файлу и возвращает имя модуля формата `wb-rules-modules/...`.
+ * Используется для обработки путей внутри node_modules.
+ *
+ * @param sourcePath - путь к исходному файлу
+ * @returns Строка с именем модуля или undefined
+ *
+ * @since 0.3.2
+ *
+ **/
+function tryGetPackageEntryPath(sourcePath) {
+    sourcePath = sourcePath.replaceAll(nodePath.sep, nodePath.posix.sep);
+    const pathParts = [];
+    do {
+        const match = packagesPattern.exec(sourcePath);
+        if (!match)
+            break;
+        if (match[3])
+            pathParts.unshift(match[3]);
+        pathParts.unshift('packages/' + match[2].replace(/\/dist$/, ''));
+        sourcePath = match[1];
+    } while (sourcePath);
+    if (pathParts.length)
+        return `wb-rules-modules/${pathParts.join('/')}.js`;
+}
+/**
+ * Определяет имя входного файла для типов `wb-rules` и `wb-rules-modules`.
+ *
+ * @param sourcePath - путь к исходному файлу
+ * @param type - тип модуля (wb-rules или wb-rules-modules)
+ * @returns Строка с именем файла или undefined
+ *
+ * @since 0.3.5
+ *
+ **/
+function tryGetEntryPath(sourcePath, type) {
+    const match = entryMatchers[type].exec(sourcePath);
+    if (!match)
+        return;
+    return `${type}/${match[1]}.js`;
+}
+/**
+ * Проверяет различные сценарии и возвращает корректный путь выходного файла.
+ *
+ * @param filePath - Исходный путь к файлу.
+ * @returns Строка с корректным путём.
+ *
+ * @since 0.3.0
+ *
+ **/
+function getEntryPath(filePath) {
+    if (filePath.startsWith('_virtual'))
+        return filePath;
+    return tryGetPackageEntryPath(filePath)
+        ?? tryGetEntryPath(filePath, 'wb-rules-modules')
+        ?? tryGetEntryPath(filePath, 'wb-rules')
+        // None of the above matched.
+        ?? filePath;
+}
+
+const env = process.env.NODE_ENV;
+const isProduction = env === 'production';
+const outputDir = {
+    es5: 'dist/es5',
+};
+/**
+ * Основная функция, возвращающая конфигурацию Rollup.
+ * Обрабатывает входные файлы, плагины и настройку выходных путей.
+ *
+ * @param options - опции конфигурации
+ * @returns Объект RollupOptions
+ *
+ * @since 0.3.0
+ *
+ **/
+async function defineRuntimeConfig(options = {}) {
+    const { cwd = process.cwd(), external, dotenv: dotenvOptions = {}, plugins = [], } = options;
+    const monorepoContext = await getMonorepoContextAsync(cwd);
+    const defaultPlugins = [
+        // Очистка директории dist перед сборкой
+        del({
+            targets: 'dist/*',
+        }),
+        // Поддержка множественных входных файлов
+        multi({
+            exclude: ['src/wb-rules/*.disabled.[jt]s'],
+            preserveModules: true,
+        }),
+        // Поиск зависимостей в node_modules
+        nodeResolve(),
+        // Транспиляция TypeScript
+        ts$2({ clean: true }),
+        // Обработка импортов для wb-rules
+        wbRulesImports(),
+        // Загрузка переменных окружения
+        dotenv(dotenvOptions),
+        // Замена условных флагов в коде
+        replace({
+            preventAssignment: true,
+            values: {
+                __DEV__: JSON.stringify(!isProduction),
+                // Автоматически меняется в процессе тестирования
+                __TEST__: 'false',
+            },
+        }),
+        // Транспиляция через Babel
+        getBabelOutputPlugin({
+            presets: ['@babel/preset-env'],
+            plugins: [
+                '@babel/plugin-transform-spread',
+                'array-includes',
+            ],
+        }),
+        // Очистка виртуальных файлов после сборки
+        del({
+            targets: 'dist/*/_virtual',
+            hook: 'closeBundle',
+        }),
+    ];
+    return {
+        input: 'src/wb-rules/*.[jt]s',
+        external,
+        plugins: [
+            ...defaultPlugins,
+            ...plugins,
+        ],
+        output: {
+            format: 'cjs',
+            strict: false,
+            dir: outputDir.es5,
+            preserveModules: true,
+            entryFileNames(chunkInfo) {
+                let chunkName = chunkInfo.name;
+                // Адаптация путей при сборке в монорепозитории.
+                if (monorepoContext) {
+                    const { rootDir } = monorepoContext;
+                    const absolutePath = nodePath.resolve(rootDir, chunkInfo.name);
+                    if (absolutePath.startsWith(cwd)) {
+                        // Путь в текущем проекте, не требует встраивания отдельным пакетом.
+                        chunkName = nodePath
+                            .relative(cwd, absolutePath)
+                            .replaceAll(nodePath.sep, nodePath.posix.sep);
+                    }
+                    else {
+                        // Ищем пакет монорепозитория, в котором находится указанный путь.
+                        const pkgDefinition = findMonorepoPackageByChunkName(monorepoContext, chunkName);
+                        if (pkgDefinition)
+                            chunkName = mapChunkToPackage(chunkName, pkgDefinition);
+                    }
+                }
+                return getEntryPath(chunkName);
+            },
+        },
+    };
+}
+
+export { defineRuntimeConfig as a, definePackageConfig as d };