bunchee 4.2.6 → 4.2.8

package/dist/bin/cli.js

@@ -115,7 +115,7 @@ async function fileExists(filePath) {
     }
 }
 
-var version = "4.2.6";
+var version = "4.2.8";
 
 const helpMessage = `
 Usage: bunchee [options]

package/dist/index.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var fs = require('fs/promises');
 var path = require('path');
 var rollup = require('rollup');
+var module$1 = require('module');
+var require$$0 = require('tty');
 var pluginWasm = require('@rollup/plugin-wasm');
 var rollupPluginSwc3 = require('rollup-plugin-swc3');
 var commonjs = require('@rollup/plugin-commonjs');
@@ -12,167 +14,20 @@ var replace = require('@rollup/plugin-replace');
 var esmShim = require('@rollup/plugin-esm-shim');
 var preserveDirectives = require('rollup-preserve-directives');
 var pluginutils = require('@rollup/pluginutils');
-var require$$0 = require('tty');
 var prettyBytes = require('pretty-bytes');
-var module$1 = require('module');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var path__default = /*#__PURE__*/_interopDefault(path);
+var require$$0__default = /*#__PURE__*/_interopDefault(require$$0);
 var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
 var json__default = /*#__PURE__*/_interopDefault(json);
 var replace__default = /*#__PURE__*/_interopDefault(replace);
 var esmShim__default = /*#__PURE__*/_interopDefault(esmShim);
 var preserveDirectives__default = /*#__PURE__*/_interopDefault(preserveDirectives);
-var require$$0__default = /*#__PURE__*/_interopDefault(require$$0);
 var prettyBytes__default = /*#__PURE__*/_interopDefault(prettyBytes);
 
-function minifyCSS(content) {
-    return content.replace(/\/\*[\s\S]*?\*\/|([^:]|^)\/\/.*$|(?:^|\s)(\s+)|\s*([\{\};,:])\s*|\s+(!)\s+/g, (match, p1, p2, p3, p4)=>{
-        if (p1) return p1 === ' ' ? '' : p1;
-        if (p2) return ' ';
-        if (p3) return p3;
-        if (p4) return '!';
-    });
-}
-const helpers = {
-    cssImport: {
-        // have to assign r.type = 'text/css' to make it work in Safari
-        global: `\
-function __insertCSS(code) {
-  if (!code || typeof document == 'undefined') return
-  let head = document.head || document.getElementsByTagName('head')[0]
-  let style = document.createElement('style')
-  style.type = 'text/css'
-  head.appendChild(style)
-  ;style.styleSheet ? (style.styleSheet.cssText = code) : style.appendChild(document.createTextNode(code))
-}
-`,
-        create (code) {
-            return `__insertCSS(${JSON.stringify(code)});`;
-        }
-    },
-    cssAssertionImport: {
-        global: '',
-        create (code) {
-            return `\
-const sheet = new CSSStyleSheet()
-sheet.replaceSync(${JSON.stringify(code)})
-export default sheet`;
-        }
-    }
-};
-function inlineCss(options) {
-    const cssIds = new Set();
-    var _options_exclude;
-    const filter = pluginutils.createFilter([
-        '**/*.css'
-    ], (_options_exclude = options.exclude) != null ? _options_exclude : []);
-    // Follow up for rollup 4 for better support of assertion support https://github.com/rollup/rollup/issues/4818
-    return {
-        name: 'inline-css',
-        transform (code, id) {
-            if (!filter(id)) return;
-            if (options.skip) return '';
-            const cssCode = minifyCSS(code);
-            cssIds.add(id);
-            return {
-                code: helpers.cssImport.create(cssCode),
-                map: {
-                    mappings: ''
-                }
-            };
-        },
-        renderChunk (code, options) {
-            const dependenciesIds = this.getModuleIds();
-            let foundCss = false;
-            for (const depId of dependenciesIds){
-                if (depId && cssIds.has(depId)) {
-                    foundCss = true;
-                    break;
-                }
-            }
-            if (!foundCss) return;
-            return {
-                code: `${helpers.cssImport.global}\n${code}`,
-                map: {
-                    mappings: ''
-                }
-            };
-        }
-    };
-}
-
-function rawContent({ exclude }) {
-    const filter = pluginutils.createFilter([
-        '**/*.data',
-        '**/*.txt'
-    ], exclude);
-    return {
-        name: 'string',
-        transform (code, id) {
-            if (filter(id)) {
-                return {
-                    code: `const data = ${JSON.stringify(code)};\nexport default data;`,
-                    map: null
-                };
-            }
-            return null;
-        }
-    };
-}
-
-// Alias entries to import path
-// e.g.
-// For a resolved file, if it's one of the entries,
-// aliases it as export path, such as <absolute file> -> <pkg>/<export path>
-function aliasEntries({ entries }) {
-    return {
-        name: 'alias',
-        resolveId: {
-            async handler (source, importer, options) {
-                const resolvedId = await this.resolve(source, importer, options);
-                if (resolvedId != null) {
-                    const aliasedId = entries[resolvedId.id];
-                    if (aliasedId != null) {
-                        return {
-                            id: aliasedId,
-                            external: true
-                        };
-                    }
-                }
-                return null;
-            }
-        }
-    };
-}
-
-function prependDirectives() {
-    return {
-        name: 'prependDirective',
-        transform: {
-            order: 'post',
-            handler (code, id) {
-                var _moduleInfo_meta;
-                const moduleInfo = this.getModuleInfo(id);
-                if (moduleInfo == null ? void 0 : (_moduleInfo_meta = moduleInfo.meta) == null ? void 0 : _moduleInfo_meta.preserveDirectives) {
-                    const firstDirective = moduleInfo.meta.preserveDirectives.directives[0];
-                    if (firstDirective) {
-                        const directive = firstDirective.value;
-                        const directiveCode = `'${directive}';`;
-                        return directiveCode + '\n' + code;
-                    }
-                }
-                return {
-                    code,
-                    map: null
-                };
-            }
-        }
-    };
-}
-
 const availableExtensions = [
     'js',
     'cjs',
@@ -209,8 +64,7 @@ const disabledWarnings = new Set([
     'PREFER_NAMED_EXPORTS',
     'UNRESOLVED_IMPORT',
     'THIS_IS_UNDEFINED',
-    'INVALID_ANNOTATION',
-    'SOURCEMAP_BROKEN'
+    'INVALID_ANNOTATION'
 ]);
 
 function getDefaultExportFromCjs (x) {
@@ -361,6 +215,186 @@ const nonNullable = (n)=>Boolean(n);
 const hasAvailableExtension = (filename)=>availableExtensions.includes(path__default.default.extname(filename).slice(1));
 const hasCjsExtension = (filename)=>path__default.default.extname(filename) === '.cjs';
 
+let hasLoggedTsWarning = false;
+function resolveTypescript(cwd) {
+    let ts;
+    const m = new module$1.Module('', undefined);
+    m.paths = module$1.Module._nodeModulePaths(cwd);
+    try {
+        ts = m.require('typescript');
+    } catch (_) {
+        console.error(_);
+        if (!hasLoggedTsWarning) {
+            hasLoggedTsWarning = true;
+            exit('Could not load TypeScript compiler. Try to install `typescript` as dev dependency');
+        }
+    }
+    return ts;
+}
+async function resolveTsConfig(cwd) {
+    let tsCompilerOptions = {};
+    let tsConfigPath;
+    tsConfigPath = path.resolve(cwd, 'tsconfig.json');
+    if (await fileExists(tsConfigPath)) {
+        const ts = resolveTypescript(cwd);
+        const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
+        const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
+        tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
+    } else {
+        return null;
+    }
+    return {
+        tsCompilerOptions,
+        tsConfigPath
+    };
+}
+async function convertCompilerOptions(cwd, json) {
+    const ts = resolveTypescript(cwd);
+    return ts.convertCompilerOptionsFromJson(json, './');
+}
+
+function minifyCSS(content) {
+    return content.replace(/\/\*[\s\S]*?\*\/|([^:]|^)\/\/.*$|(?:^|\s)(\s+)|\s*([\{\};,:])\s*|\s+(!)\s+/g, (match, p1, p2, p3, p4)=>{
+        if (p1) return p1 === ' ' ? '' : p1;
+        if (p2) return ' ';
+        if (p3) return p3;
+        if (p4) return '!';
+    });
+}
+const helpers = {
+    cssImport: {
+        // have to assign r.type = 'text/css' to make it work in Safari
+        global: `\
+function __insertCSS(code) {
+  if (!code || typeof document == 'undefined') return
+  let head = document.head || document.getElementsByTagName('head')[0]
+  let style = document.createElement('style')
+  style.type = 'text/css'
+  head.appendChild(style)
+  ;style.styleSheet ? (style.styleSheet.cssText = code) : style.appendChild(document.createTextNode(code))
+}
+`,
+        create (code) {
+            return `__insertCSS(${JSON.stringify(code)});`;
+        }
+    },
+    cssAssertionImport: {
+        global: '',
+        create (code) {
+            return `\
+const sheet = new CSSStyleSheet()
+sheet.replaceSync(${JSON.stringify(code)})
+export default sheet`;
+        }
+    }
+};
+function inlineCss(options) {
+    const cssIds = new Set();
+    var _options_exclude;
+    const filter = pluginutils.createFilter([
+        '**/*.css'
+    ], (_options_exclude = options.exclude) != null ? _options_exclude : []);
+    // Follow up for rollup 4 for better support of assertion support https://github.com/rollup/rollup/issues/4818
+    return {
+        name: 'inline-css',
+        transform (code, id) {
+            if (!filter(id)) return;
+            if (options.skip) return '';
+            const cssCode = minifyCSS(code);
+            cssIds.add(id);
+            return {
+                code: helpers.cssImport.create(cssCode),
+                map: {
+                    mappings: ''
+                }
+            };
+        },
+        renderChunk (code, options) {
+            const dependenciesIds = this.getModuleIds();
+            let foundCss = false;
+            for (const depId of dependenciesIds){
+                if (depId && cssIds.has(depId)) {
+                    foundCss = true;
+                    break;
+                }
+            }
+            if (!foundCss) return;
+            return {
+                code: `${helpers.cssImport.global}\n${code}`,
+                map: {
+                    mappings: ''
+                }
+            };
+        }
+    };
+}
+
+function rawContent({ exclude }) {
+    const filter = pluginutils.createFilter([
+        '**/*.data',
+        '**/*.txt'
+    ], exclude);
+    return {
+        name: 'string',
+        transform (code, id) {
+            if (filter(id)) {
+                return {
+                    code: `const data = ${JSON.stringify(code)};\nexport default data;`,
+                    map: null
+                };
+            }
+            return null;
+        }
+    };
+}
+
+// Alias entries to import path
+// e.g.
+// For a resolved file, if it's one of the entries,
+// aliases it as export path, such as <absolute file> -> <pkg>/<export path>
+function aliasEntries({ entries }) {
+    return {
+        name: 'alias',
+        resolveId: {
+            async handler (source, importer, options) {
+                const resolvedId = await this.resolve(source, importer, options);
+                if (resolvedId != null) {
+                    const aliasedId = entries[resolvedId.id];
+                    if (aliasedId != null) {
+                        return {
+                            id: aliasedId,
+                            external: true
+                        };
+                    }
+                }
+                return null;
+            }
+        }
+    };
+}
+
+function prependDirectives() {
+    return {
+        name: 'prependDirective',
+        transform: {
+            order: 'post',
+            handler (code, id) {
+                var _moduleInfo_meta;
+                const moduleInfo = this.getModuleInfo(id);
+                if (moduleInfo == null ? void 0 : (_moduleInfo_meta = moduleInfo.meta) == null ? void 0 : _moduleInfo_meta.preserveDirectives) {
+                    const firstDirective = moduleInfo.meta.preserveDirectives.directives[0];
+                    if (firstDirective) {
+                        const directive = firstDirective.value;
+                        const directiveCode = `'${directive}';`;
+                        return directiveCode + '\n' + code;
+                    }
+                }
+                return null;
+            }
+        }
+    };
+}
+
 function getTypings(pkg) {
     return pkg.types || pkg.typings;
 }
@@ -374,11 +408,11 @@ function isExportLike(field) {
     ([key, value])=>typeof value === 'string' && !key.startsWith('.'));
 }
 function constructFullExportCondition(exportCondition, packageType) {
-    const isEsmPkg = isESModulePackage(packageType);
     let fullExportCond;
     if (typeof exportCondition === 'string') {
+        const exportType = getExportTypeFromFile(exportCondition, packageType);
         fullExportCond = {
-            [isEsmPkg ? 'import' : 'require']: exportCondition
+            [exportType]: exportCondition
         };
     } else {
         const exportTypes = Object.keys(exportCondition);
@@ -401,21 +435,32 @@ function joinRelativePath(...segments) {
     }
     return result;
 }
-function findExport(exportPath, exportCondition, paths, packageType) {
+function findExport(exportPath, exportCondition, paths, packageType, currentPath) {
+    // Skip `types` field, it cannot be the entry point
+    if (exportPath === 'types') return;
     if (isExportLike(exportCondition)) {
         const fullExportCondition = constructFullExportCondition(exportCondition, packageType);
-        paths[exportPath] = {
-            ...paths[exportPath],
-            ...fullExportCondition
-        };
+        if (exportPath.startsWith('.')) {
+            paths[exportPath] = {
+                ...paths[exportPath],
+                ...fullExportCondition
+            };
+        } else {
+            // exportPath is exportType, import, require, ...
+            // merge to currentPath
+            paths[currentPath] = {
+                ...paths[currentPath],
+                [exportPath]: fullExportCondition.default
+            };
+        }
         return;
     }
     Object.keys(exportCondition).forEach((subpath)=>{
         if (subpath.startsWith('.')) {
             // subpath is actual export path, ./a, ./b, ...
-            const nestedExportPath = joinRelativePath(exportPath, subpath);
+            const nestedExportPath = joinRelativePath(currentPath, subpath);
             const nestedExportCondition = exportCondition[subpath];
-            findExport(nestedExportPath, nestedExportCondition, paths, packageType);
+            findExport(nestedExportPath, nestedExportCondition, paths, packageType, nestedExportPath);
         } else {
             // subpath is exportType, import, require, ...
             const exportType = subpath;
@@ -423,7 +468,7 @@ function findExport(exportPath, exportCondition, paths, packageType) {
             const nestedExportCondition = {
                 [exportType]: defaultPath
             };
-            findExport(exportPath, nestedExportCondition, paths, packageType);
+            findExport(exportPath, nestedExportCondition, paths, packageType, currentPath);
         }
     });
 }
@@ -453,15 +498,16 @@ function findExport(exportPath, exportCondition, paths, packageType) {
  *
  */ function parseExport(exportsCondition, packageType) {
     const paths = {};
+    const initialPath = '.';
     if (typeof exportsCondition === 'string') {
-        paths['.'] = constructFullExportCondition(exportsCondition, packageType);
+        paths[initialPath] = constructFullExportCondition(exportsCondition, packageType);
     } else if (typeof exportsCondition === 'object') {
         if (isExportLike(exportsCondition)) {
-            paths['.'] = constructFullExportCondition(exportsCondition, packageType);
+            paths[initialPath] = constructFullExportCondition(exportsCondition, packageType);
         } else {
             Object.keys(exportsCondition).forEach((key)=>{
                 const exportCondition = exportsCondition[key];
-                findExport(key, exportCondition, paths, packageType);
+                findExport(key, exportCondition, paths, packageType, initialPath);
             });
         }
     }
@@ -508,13 +554,16 @@ function findExport(exportPath, exportCondition, paths, packageType) {
  * pkg.main and pkg.module will be added to ['.'] if exists
  */ function getExportPaths(pkg, pkgType, resolvedWildcardExports) {
     var _pathsMap_;
-    const pathsMap = {};
+    let pathsMap = {};
     const packageType = pkgType != null ? pkgType : getPackageType(pkg);
     const isEsmPackage = isESModulePackage(packageType);
     const exportsConditions = resolvedWildcardExports != null ? resolvedWildcardExports : pkg.exports;
     if (exportsConditions) {
         const paths = parseExport(exportsConditions, packageType);
-        Object.assign(pathsMap, paths);
+        pathsMap = {
+            ...pathsMap,
+            ...paths
+        };
     }
     if (isEsmPackage && pkg.main && hasCjsExtension(pkg.main)) {
         exit('Cannot export main field with .cjs extension in ESM package, only .mjs and .js extensions are allowed');
@@ -530,10 +579,16 @@ function findExport(exportPath, exportCondition, paths, packageType) {
         defaultMainExport['require'] = pathsMap['.']['require'];
     }
     // Merge the main export into '.' paths
-    const mainExport = Object.assign({}, pathsMap['.'], defaultMainExport);
+    const mainExport = {
+        ...pathsMap['.'],
+        ...defaultMainExport
+    };
     // main export is not empty
     if (Object.keys(mainExport).length > 0) {
-        pathsMap['.'] = mainExport;
+        pathsMap['.'] = {
+            ...pathsMap['.'],
+            ...mainExport
+        };
     }
     return pathsMap;
 }
@@ -640,6 +695,13 @@ function getTypeFilePath(entryFilePath, exportCondition, cwd) {
     const exportName = (exportCondition == null ? void 0 : exportCondition.name) || 'index';
     return entryFilePath ? name + '.d.ts' : path.resolve(firstDistPath ? path.dirname(firstDistPath) : path.join(cwd, 'dist'), (exportName === '.' ? 'index' : exportName) + '.d.ts');
 }
+function getExportTypeFromFile(filename, pkgType) {
+    const isESModule = isESModulePackage(pkgType);
+    const isCjsExt = filename.endsWith('.cjs');
+    const isEsmExt = filename.endsWith('.mjs');
+    const exportType = isEsmExt ? 'import' : isCjsExt ? 'require' : isESModule ? 'import' : 'require';
+    return exportType;
+}
 
 const swcMinifyOptions = {
     compress: true,
@@ -727,23 +789,6 @@ async function buildInputConfig(entry, entries, pkg, options, cwd, { tsConfigPat
             entries: reversedAlias
         })
     ];
-    const baseResolvedTsOptions = {
-        declaration: true,
-        noEmit: false,
-        noEmitOnError: true,
-        emitDeclarationOnly: true,
-        checkJs: false,
-        declarationMap: false,
-        skipLibCheck: true,
-        preserveSymlinks: false,
-        // disable incremental build
-        incremental: false,
-        // use default tsBuildInfoFile value
-        tsBuildInfoFile: '.tsbuildinfo',
-        target: 'esnext',
-        module: 'esnext',
-        jsx: tsCompilerOptions.jsx || 'react-jsx'
-    };
     const typesPlugins = [
         ...commonPlugins,
         inlineCss({
@@ -751,19 +796,25 @@ async function buildInputConfig(entry, entries, pkg, options, cwd, { tsConfigPat
         })
     ];
     if (useTypescript) {
-        const mergedOptions = {
-            ...baseResolvedTsOptions,
-            ...tsCompilerOptions
-        };
-        // error TS5074: Option '--incremental' can only be specified using tsconfig, emitting to single
-        // file or when option '--tsBuildInfoFile' is specified.
-        if (!mergedOptions.incremental) {
-            delete mergedOptions.incremental;
-            delete mergedOptions.tsBuildInfoFile;
-        }
+        const { options: overrideResolvedTsOptions } = await convertCompilerOptions(cwd, {
+            declaration: true,
+            noEmit: false,
+            noEmitOnError: true,
+            emitDeclarationOnly: true,
+            checkJs: false,
+            declarationMap: false,
+            skipLibCheck: true,
+            target: 'ESNext',
+            ...!tsCompilerOptions.jsx ? {
+                jsx: 'react-jsx'
+            } : undefined,
+            // error TS5074: Option '--incremental' can only be specified using tsconfig, emitting to single
+            // file or when option '--tsBuildInfoFile' is specified.
+            incremental: false
+        });
         const dtsPlugin = require('rollup-plugin-dts').default({
-            tsconfig: undefined,
-            compilerOptions: mergedOptions
+            tsconfig: tsConfigPath,
+            compilerOptions: overrideResolvedTsOptions
         });
         typesPlugins.push(dtsPlugin);
     }
@@ -775,6 +826,7 @@ async function buildInputConfig(entry, entries, pkg, options, cwd, { tsConfigPat
         rawContent({
             exclude: /node_modules/
         }),
+        esmShim__default.default(),
         preserveDirectives__default.default(),
         prependDirectives(),
         replace__default.default({
@@ -795,8 +847,7 @@ async function buildInputConfig(entry, entries, pkg, options, cwd, { tsConfigPat
             exclude: 'node_modules',
             tsconfig: tsConfigPath,
             ...swcOptions
-        }),
-        esmShim__default.default()
+        })
     ]).filter(isNotNull);
     return {
         input: entry,
@@ -999,12 +1050,8 @@ async function buildEntryConfig(entries, pkg, exportPaths, bundleConfig, cwd, ts
                 path.join('bin', key),
                 binaryExports[key]
             ]);
-        const isESModule = isESModulePackage(pkg.type);
         const binExportPaths = binPairs.reduce((acc, [binName, binDistPath])=>{
-            const ext = path.extname(binDistPath).slice(1);
-            const isCjsExt = ext === 'cjs';
-            const isEsmExt = ext === 'mjs';
-            const exportType = isEsmExt ? 'import' : isCjsExt ? 'require' : isESModule ? 'import' : 'require';
+            const exportType = getExportTypeFromFile(binDistPath, pkg.type);
             acc[binName] = {
                 [exportType]: binDistPath
             };
@@ -1026,10 +1073,12 @@ async function buildEntryConfig(entries, pkg, exportPaths, bundleConfig, cwd, ts
     }
     const collectEntriesPromises = Object.keys(exportPaths).map(async (entryExport)=>{
         const exportCond = exportPaths[entryExport];
-        await collectEntry('', exportCond, entryExport);
-        for (const exportType of availableExportConventions){
-            if (exportCond[exportType]) {
-                await collectEntry(exportType, exportCond, entryExport);
+        if (entryExport.startsWith('.')) {
+            await collectEntry('', exportCond, entryExport);
+            for (const exportType of availableExportConventions){
+                if (exportCond[exportType]) {
+                    await collectEntry(exportType, exportCond, entryExport);
+                }
             }
         }
     });
@@ -1153,41 +1202,6 @@ function logSizeStats(sizeCollector) {
     });
 }
 
-let hasLoggedTsWarning = false;
-function resolveTypescript(cwd) {
-    let ts;
-    const m = new module$1.Module('', undefined);
-    m.paths = module$1.Module._nodeModulePaths(cwd);
-    try {
-        ts = m.require('typescript');
-    } catch (_) {
-        console.error(_);
-        if (!hasLoggedTsWarning) {
-            hasLoggedTsWarning = true;
-            exit('Could not load TypeScript compiler. Try to install `typescript` as dev dependency');
-        }
-    }
-    return ts;
-}
-async function resolveTsConfig(cwd) {
-    let tsCompilerOptions = {};
-    let tsConfigPath;
-    tsConfigPath = path.resolve(cwd, 'tsconfig.json');
-    if (await fileExists(tsConfigPath)) {
-        const ts = resolveTypescript(cwd);
-        const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
-        const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
-        tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
-    } else {
-        tsConfigPath = undefined;
-        return null;
-    }
-    return {
-        tsCompilerOptions,
-        tsConfigPath
-    };
-}
-
 // TODO: support nested wildcard exportsCondition (e.g. './foo/*')
 const getWildcardExports = (exportsCondition)=>{
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunchee",
-  "version": "4.2.6",
+  "version": "4.2.8",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
@@ -62,7 +62,7 @@
     "rollup": "^4.9.1",
     "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-swc3": "^0.11.0",
-    "rollup-preserve-directives": "^1.1.0",
+    "rollup-preserve-directives": "^1.1.1",
     "tslib": "^2.6.2"
   },
   "peerDependencies": {