bundlib/dist/bundlib.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var readPkg = _interopDefault(require('read-pkg'));
var camelcase = _interopDefault(require('camelcase'));
var path = require('path');
var builtinModules = _interopDefault(require('builtin-modules'));
var fs = require('fs');
var resolveFrom = _interopDefault(require('resolve-from'));
var slash = _interopDefault(require('slash'));

function error(msg) {
  return new TypeError(msg);
}
function invalidPkgField(field, type) {
  return error(`Invalid package.json "${field}" field. It has to be of type ${type}`);
}
function invalidOption(option, type) {
  return error(`Invalid "${option}" option. It has to be ${type}`);
}

const keys = Object.keys;
function keysOrNull(deps) {
  return deps ? keys(deps) : null;
}
function setProp(name, value, target) {
  target[name] = value;
  return target;
}
function createObject(names, value) {
  return names.reduce((result, key) => setProp(key, value, result), {});
}

function isNull(value) {
  return value == null;
}
function isObject(value) {
  return !!value && typeof value === 'object';
}
function isString(value) {
  return typeof value === 'string';
}
function isBool(value) {
  return value === !!value;
}
const isArray = Array.isArray;
function isDictionary(value) {
  return isObject(value) && !isArray(value);
}
function isStringOrNull(value) {
  return isNull(value) || isString(value);
}
function isDictionaryOrNull(value) {
  return isNull(value) || isDictionary(value);
}

function createInList(...model) {
  return str => model.some(inList => typeof inList === 'function' ? inList(str) : str === inList);
}

const isModuleOptionKey = createInList('sourcemap', 'min');

const isCJSOptionKey = createInList(isModuleOptionKey, 'esModule', 'interop');

const isBrowserOption = createInList(isCJSOptionKey, 'format', 'name', 'id', 'extend', 'globals');

const isModuleString = createInList('main', 'browser', 'bin');
function isModuleOption(value) {
  return isNull(value) || isBool(value) || isModuleString(value) || isArray(value) && value.every(isModuleString);
}
function normalizeModuleOption(option) {
  const keys = ['main', 'browser', 'bin'];
  return !option ? createObject(keys, false) : option === true ? createObject(keys, true) : isArray(option) ? option.reduce((result, field) => setProp(field, true, result), createObject(keys, false)) : setProp(option, true, createObject(keys, false));
}
function normalizeBuildModule(build, key, field, def) {
  return !build || isNull(build[key]) ? def[field] : build[key];
}

function normalizeBuildFlag(build, key, def) {
  return !build || isNull(build[key]) ? def : !!build[key];
}

const isBrowserFormat = createInList(isNull, 'iife', 'amd', 'umd');

function isValidGlobals(value) {
  return isNull(value) || isObject(value) && (isArray(value) ? value.every(item => isString(item)) : keys(value).every(key => isString(key) && isString(value[key])));
}
function normalizeGlobals(globals) {
  return !globals ? null : isArray(globals) ? globals.reduce((result, value) => setProp(value, value, result), {}) : globals;
}
function normalizeBuildGlobals(build, def) {
  return !build || isNull(build.globals) ? def : normalizeGlobals(build.globals);
}

const isInOpKey = createInList('api', 'bin');

const isMinString = createInList(isModuleString, 'module');
function isValidMinOption(value) {
  return isNull(value) || isBool(value) || isMinString(value) || isArray(value) && value.every(item => isMinString(item));
}
function normalizeMinOption(min) {
  const keys = ['main', 'module', 'browser', 'bin'];
  return !min ? createObject(keys, false) : min === true ? createObject(keys, true) : isArray(min) ? min.reduce((result, field) => setProp(field, true, result), createObject(keys, false)) : setProp(min, true, createObject(keys, false));
}
function normalizeBuildMin(build, field, def) {
  return !build || isNull(build.min) ? def[field] : build.min;
}

function normalizeBuildName(cwd, browserName, nameOption, pkgName) {
  return browserName || nameOption || pkgName && camelcase(path.basename(pkgName)) || camelcase(path.basename(cwd)) || null;
}

function normalizeSourcemap(sourcemap) {
  return sourcemap === 'inline' ? 'inline' : sourcemap !== false;
}
function normalizeBuildSourcemap(build, def) {
  return !build || isNull(build.sourcemap) ? def : normalizeSourcemap(build.sourcemap);
}

const isTypesOptionKey = createInList('equals');

function invalidKeys(object, list) {
  const invalid = keys(object).filter(key => !list.includes(key));
  return invalid.length ? invalid : null;
}
function keysInList(obj, inList) {
  return keys(obj).every(inList);
}

async function analizePkg(cwd, inputPkg) {
  const pkg = inputPkg || (await readPkg({
    cwd,
    normalize: false
  }));

  if (!isDictionary(pkg)) {
    throw error('Invalid package.json content');
  }

  const {
    name: pkgName,
    main: pkgMain,
    module: pkgModule,
    'jsnext:main': pkgJsNextMain,
    browser: pkgBrowser,
    bin: pkgBin,
    types: pkgTypes,
    typings,
    dependencies: runtimeDependencies,
    devDependencies,
    peerDependencies,
    bundlib: bundlibOptions = {}
  } = pkg;

  if (!isDictionaryOrNull(bundlibOptions)) {
    throw invalidPkgField('bundlib', 'Object');
  }

  const invalidOptions = invalidKeys(bundlibOptions, ['input', 'extend', 'esModule', 'interop', 'equals', 'sourcemap', 'format', 'name', 'id', 'globals', 'min', 'cache', 'project', 'main', 'module', 'browser', 'bin', 'types']);

  if (invalidOptions) {
    const optionNames = invalidOptions.map(name => `"${name}"`).join(', ');
    throw error(`Unknown options found: (${optionNames})`);
  }

  const {
    input: inputOption,
    sourcemap: sourcemapOption,
    esModule,
    interop,
    extend,
    format: browserFormat,
    name: browserName,
    id: amdId,
    globals: browserGlobals,
    min,
    cache: cacheOption,
    project: projectOption,
    main: mainOptions,
    module: moduleOptions,
    browser: browserOptions,
    bin: binaryOptions,
    types: typesOptions
  } = bundlibOptions;

  if (!isStringOrNull(inputOption) && !(isDictionary(inputOption) && keysInList(inputOption, isInOpKey) && keys(inputOption).every(key => isString(inputOption[key])))) {
    throw invalidOption('input', 'string | { api?: string, bin?: string }');
  }

  if (!isNull(sourcemapOption) && !isBool(sourcemapOption) && sourcemapOption !== 'inline') {
    throw invalidOption('sourcemap', 'boolean | "inline"');
  }

  if (!isModuleOption(esModule)) {
    throw invalidOption('esModule', 'boolean | "main" | "browser" | "bin" | Array<"main" | "browser" | "bin">');
  }

  if (!isModuleOption(interop)) {
    throw invalidOption('interop', 'boolean | "main" | "browser" | "bin" | Array<"main" | "browser" | "bin">');
  }

  if (!isBrowserFormat(browserFormat)) {
    throw invalidOption('format', '"amd" | "iife" | "amd"');
  }

  if (!isStringOrNull(browserName)) {
    throw invalidOption('name', 'string');
  }

  if (!isStringOrNull(amdId)) {
    throw invalidOption('id', 'string');
  }

  if (!isValidGlobals(browserGlobals)) {
    throw invalidOption('globals', 'Object<string, string> | string[]');
  }

  if (!isValidMinOption(min)) {
    throw invalidOption('min', 'boolean | "main" | "module" | "browser" | "bin" | Array<"main" | "module" | "browser" | "bin">');
  }

  if (!isStringOrNull(cacheOption)) {
    throw invalidOption('cache', 'string');
  }

  if (!isStringOrNull(projectOption)) {
    throw invalidOption('project', 'string');
  }

  if (!isNull(mainOptions) && mainOptions !== false && !(isDictionary(mainOptions) && keysInList(mainOptions, isCJSOptionKey))) {
    throw invalidOption('main', 'false | { sourcemap?: boolean | "inline", esModule?: boolean, interop?: boolean, min?: boolean }');
  }

  if (!isNull(moduleOptions) && moduleOptions !== false && !(isDictionary(moduleOptions) && keysInList(moduleOptions, isModuleOptionKey))) {
    throw invalidOption('module', 'false | { sourcemap?: boolean | "inline", min?: boolean }');
  }

  if (!isNull(browserOptions) && browserOptions !== false && !(isDictionary(browserOptions) && keysInList(browserOptions, isBrowserOption) && isBrowserFormat(browserOptions.format) && ['name', 'id'].every(key => isStringOrNull(browserOptions[key])) && isValidGlobals(browserOptions.globals))) {
    throw invalidOption('browser', 'false | { sourcemap?: boolean | "inline", esModule?: boolean, interop?: boolean, min?: boolean, ... }');
  }

  if (!isNull(binaryOptions) && binaryOptions !== false && !(isDictionary(binaryOptions) && keysInList(binaryOptions, isCJSOptionKey))) {
    throw invalidOption('bin', 'false | { sourcemap?: boolean | "inline", esModule?: boolean, interop?: boolean, min?: boolean }');
  }

  if (!isNull(typesOptions) && typesOptions !== false && !(isDictionary(typesOptions) && keysInList(typesOptions, isTypesOptionKey))) {
    throw invalidOption('types', 'false | { equals?: boolean }');
  }

  if (mainOptions !== false && !isStringOrNull(pkgMain)) {
    throw invalidPkgField('main', 'string');
  }

  if (moduleOptions !== false && !isStringOrNull(pkgModule)) {
    throw invalidPkgField('module', 'string');
  }

  if (!pkgModule && moduleOptions !== false && !isStringOrNull(pkgJsNextMain)) {
    throw invalidPkgField('jsnext:main', 'string');
  }

  if (browserOptions !== false && !isStringOrNull(pkgBrowser)) {
    throw invalidPkgField('browser', 'string');
  }

  if (binaryOptions !== false && !isStringOrNull(pkgBin)) {
    throw invalidPkgField('bin', 'string');
  }

  if (!isDictionaryOrNull(runtimeDependencies)) {
    throw invalidPkgField('dependencies', 'Object');
  }

  if (!isDictionaryOrNull(peerDependencies)) {
    throw invalidPkgField('peerDependencies', 'Object');
  }

  const esModuleFile = pkgModule || pkgJsNextMain;
  const typesPath = pkgTypes || typings;
  const {
    api: apiInput,
    bin: binInput
  } = isStringOrNull(inputOption) ? {
    api: inputOption
  } : inputOption;
  const input = {
    api: apiInput || null,
    bin: binInput || null
  };
  const globalSourcemap = normalizeSourcemap(sourcemapOption);
  const globalESModule = normalizeModuleOption(esModule);
  const globalInterop = normalizeModuleOption(interop);
  const globalMin = normalizeMinOption(min);
  const mainOutput = mainOptions === false || !pkgMain ? null : {
    path: pkgMain,
    sourcemap: normalizeBuildSourcemap(mainOptions, globalSourcemap),
    esModule: normalizeBuildModule(mainOptions, 'esModule', 'main', globalESModule),
    interop: normalizeBuildModule(mainOptions, 'interop', 'main', globalInterop),
    min: normalizeBuildMin(mainOptions, 'main', globalMin)
  };
  const moduleOutput = moduleOptions === false || !esModuleFile ? null : {
    path: esModuleFile,
    sourcemap: normalizeBuildSourcemap(moduleOptions, globalSourcemap),
    min: normalizeBuildMin(moduleOptions, 'module', globalMin)
  };
  const browserOutput = browserOptions === false || !pkgBrowser ? null : {
    path: pkgBrowser,
    sourcemap: normalizeBuildSourcemap(browserOptions, globalSourcemap),
    esModule: normalizeBuildModule(browserOptions, 'esModule', 'browser', globalESModule),
    interop: normalizeBuildModule(browserOptions, 'interop', 'browser', globalInterop),
    min: normalizeBuildMin(browserOptions, 'browser', globalMin),
    format: browserOptions && !isNull(browserOptions.format) ? browserOptions.format : browserFormat || 'umd',
    name: normalizeBuildName(cwd, browserOptions ? browserOptions.name : null, browserName, pkgName),
    id: browserOptions && browserOptions.id || amdId || null,
    globals: normalizeBuildGlobals(browserOptions, normalizeGlobals(browserGlobals)),
    extend: normalizeBuildFlag(browserOptions, 'extend', !!extend)
  };
  const binaryOutput = binaryOptions === false || !pkgBin ? null : {
    path: pkgBin,
    sourcemap: normalizeBuildSourcemap(binaryOptions, globalSourcemap),
    esModule: normalizeBuildModule(binaryOptions, 'esModule', 'bin', globalESModule),
    interop: normalizeBuildModule(binaryOptions, 'interop', 'bin', globalInterop),
    min: normalizeBuildMin(binaryOptions, 'bin', globalMin)
  };
  const typesOutput = typesOptions === false || !typesPath ? null : {
    path: typesPath
  };
  const output = {
    main: mainOutput,
    module: moduleOutput,
    browser: browserOutput,
    bin: binaryOutput,
    types: typesOutput
  };
  const dependencies = {
    runtime: runtimeDependencies || null,
    dev: devDependencies || null,
    peer: peerDependencies || null
  };
  const cache = cacheOption || null;
  const project = projectOption || null;
  return {
    cwd,
    pkg,
    input,
    output,
    dependencies,
    cache,
    project
  };
}

const hasOwn = Object.prototype.hasOwnProperty;

function arrayToExternal(...modules) {
  const filtered = modules.reduce((result, list) => list ? [...result, ...list] : result, []);

  if (!filtered.length) {
    return () => false;
  }

  const cache = {};
  return (source, importer, isResolved) => {
    if (isResolved || source.startsWith('.')) {
      return;
    }

    if (hasOwn.call(cache, source)) {
      return cache[source];
    }

    return cache[source] = filtered.some(moduleName => {
      if (source === moduleName) {
        return true;
      }

      const len = moduleName.length;
      return source.substr(0, len) === moduleName && /^[/\\]$/.test(source[len]);
    });
  };
}

function createConfig(input, output, external, plugins, chokidar) {
  const watch = {
    exclude: ['node_modules/**']
  };

  if (chokidar) {
    watch.chokidar = chokidar === true ? {} : chokidar;
  }

  return {
    input,
    output,
    external,
    plugins,
    watch
  };
}
function createModuleConfig(input, format, file, sourcemap, esModule, interop, external, plugins, chokidar) {
  return createConfig(input, {
    file,
    format,
    sourcemap,
    esModule,
    interop
  }, external, plugins, chokidar);
}
const requiresId = createInList('amd', 'umd');
function createBrowserConfig(input, format, file, sourcemap, esModule, interop, isExternal, plugins, chokidar, name, extend, globals, id) {
  const output = {
    file,
    format,
    sourcemap,
    esModule,
    interop,
    extend,
    name,
    globals: globals || {}
  };

  if (id && requiresId(format)) {
    output.amd = {
      id
    };
  }

  return createConfig(input, output, isExternal, plugins, chokidar);
}

const TS_ONLY_EXTENSIONS = ['.ts', '.tsx'];
const JS_EXTENSIONS = ['.js', '.jsx', '.mjs', '.es6', '.es', '.node'];
const TS_EXTENSIONS = [...TS_ONLY_EXTENSIONS, ...JS_EXTENSIONS];

function findFirst(...filenames) {
  for (const filename of filenames) {
    if (fs.existsSync(filename)) {
      return filename;
    }
  }

  return null;
}

function createIsInstalled(...dependencies) {
  return id => !!dependencies.reduce((r, o) => ({ ...r,
    ...o
  }), {})[id];
}

function createPluginLoader(cwd, isInstalled) {
  return (id, named) => {
    if (!isInstalled(id)) {
      return null;
    }

    const content = require(resolveFrom(cwd, id));

    return named ? content[named] : 'default' in content ? content.default : content;
  };
}

function mapIdExternal(cwd, outputDir, map) {
  const normalizedMap = keys(map).reduce((result, source) => setProp(slash(path.resolve(cwd, source)), path.resolve(cwd, map[source]), result), {});
  return {
    name: 'api',

    resolveId(moduleId, from) {
      const resolved = !from ? moduleId : path.join(path.dirname(from), moduleId);
      const target = normalizedMap[slash(resolved)] || normalizedMap[slash(resolved + '.ts')] || normalizedMap[slash(path.join(resolved, 'index.ts'))];

      if (!target) {
        return null;
      }

      const relativeTarget = path.relative(outputDir, target);
      return {
        id: !relativeTarget ? '.' : relativeTarget.startsWith('.') ? relativeTarget : path.join('.', relativeTarget),
        external: true,
        moduleSideEffects: false
      };
    }

  };
}

function renamePre(filename, pre) {
  const {
    dir,
    name,
    ext
  } = path.parse(filename);
  return path.join(dir, `${name}.${pre}${ext}`);
}
function renameMin(filename) {
  return renamePre(filename, 'min');
}

function extensionMatch(filename, extensions) {
  return extensions.includes(path.extname(filename).toLowerCase());
}

function pkgToConfigs({
  cwd,
  input,
  output,
  dependencies,
  cache,
  project
}, {
  dev,
  watch
}) {
  const {
    api: apiInput1,
    bin: binInput1
  } = input;
  const {
    main: cjsOutput,
    module: esOutput,
    browser: browserOutput,
    bin: binaryOutput,
    types: typesOutput
  } = output;
  const {
    runtime: runtimeDeps,
    dev: devDeps,
    peer: peerDeps
  } = dependencies;
  const bundlibCache = path.resolve(cwd, cache || 'node_modules/.cache/bundlib');

  if (browserOutput) {
    const {
      format,
      name
    } = browserOutput;

    if ((format === 'iife' || format === 'umd') && !name) {
      throw error('option \'name\' is required for IIFE and UMD builds');
    }
  }

  const isInstalled = createIsInstalled(runtimeDeps, devDeps);
  const pluginLoader = createPluginLoader(cwd, isInstalled);
  const loadPluginTypescript2 = pluginLoader('rollup-plugin-typescript2');
  const loadPluginTypescript = pluginLoader('@rollup/plugin-typescript');
  const loadPluginESLint = pluginLoader('rollup-plugin-eslint', 'eslint');
  const loadPluginNodeResolve = pluginLoader('@rollup/plugin-node-resolve');
  const loadPluginCommonJS = pluginLoader('@rollup/plugin-commonjs');
  const loadPluginJSON = pluginLoader('@rollup/plugin-json');
  const loadPluginBabel = pluginLoader('rollup-plugin-babel');
  const loadPluginBuble = pluginLoader('@rollup/plugin-buble');
  const loadPluginTerser = pluginLoader('rollup-plugin-terser', 'terser');
  const loadPluginStripShebang = pluginLoader('rollup-plugin-strip-shebang');
  const loadPluginAddShebang = pluginLoader('rollup-plugin-add-shebang');
  const loadPluginExportEquals = pluginLoader('rollup-plugin-export-equals');
  const useTypescriptPlugin = !!loadPluginTypescript2 || !!loadPluginTypescript;
  const isInstalledChokidar = isInstalled('chokidar');
  const apiInput = apiInput1 ? path.resolve(cwd, apiInput1) : (useTypescriptPlugin ? findFirst(...['index.ts', 'index.tsx'].map(filename => path.resolve(cwd, 'src', filename))) : null) || path.resolve(cwd, 'src', 'index.js');
  const binInput = binInput1 ? path.resolve(cwd, binInput1) : (useTypescriptPlugin ? findFirst(...['index.ts'].map(filename => path.resolve(cwd, 'src-bin', filename))) : null) || path.resolve(cwd, 'src-bin', 'index.js');
  const isTypescriptAPIInput = extensionMatch(apiInput, TS_ONLY_EXTENSIONS);
  const isTypescriptBinaryInput = extensionMatch(binInput, TS_ONLY_EXTENSIONS);

  if (typesOutput && !isTypescriptAPIInput) {
    throw error('can\'t generate types from javascript source');
  }

  const apiExtensions = isTypescriptAPIInput ? TS_EXTENSIONS : JS_EXTENSIONS;
  const binaryExtensions = isTypescriptBinaryInput ? TS_EXTENSIONS : JS_EXTENSIONS;
  const production = !dev;
  const apiFolder = path.dirname(apiInput);
  const apiFolderContent = apiExtensions.map(ext => path.resolve(apiFolder, `**/*${ext}`));
  const cwdFolderContent = binaryExtensions.map(ext => path.resolve(cwd, `**/*${ext}`));
  const typesFilename = renamePre(path.basename(apiInput), 'd');
  let typesOutputDir = typesOutput ? path.resolve(cwd, typesOutput.path) : null;

  if (typesOutputDir && extensionMatch(typesOutputDir, ['.ts'])) {
    typesOutputDir = path.dirname(typesOutputDir);
  }

  const isExternal = arrayToExternal(keysOrNull(runtimeDeps), keysOrNull(peerDeps), builtinModules);
  const useChokidar = isInstalledChokidar && !!watch;
  const exclude = /node_modules/;
  const configs = [];

  function createPlugins(inputIsTypescript, extensions, outputFile, sourcemap, mini, browser, bin) {
    const sourcemapBool = !!sourcemap;
    const declarationDir = inputIsTypescript && configs.length === 0 && !bin && typesOutputDir;
    const include = bin ? cwdFolderContent : apiFolderContent;
    const cacheRoot = path.join(bundlibCache, 'rpt2');
    let shebang;
    const plugins = [loadPluginESLint && loadPluginESLint({
      include,
      exclude,
      throwOnWarning: false,
      throwOnError: false
    }), bin && loadPluginStripShebang && loadPluginStripShebang({
      capture: shebangFromFile => shebang = shebangFromFile,
      sourcemap: sourcemapBool
    }), bin && cjsOutput && outputFile && mapIdExternal(cwd, path.dirname(outputFile), setProp(apiInput, cwd, {})), loadPluginNodeResolve && loadPluginNodeResolve({
      preferBuiltins: !browser,
      extensions,
      rootDir: cwd
    }), browser && loadPluginCommonJS && loadPluginCommonJS({
      sourceMap: sourcemapBool
    }), inputIsTypescript && loadPluginTypescript2 && loadPluginTypescript2({
      cacheRoot,
      useTsconfigDeclarationDir: true,
      tsconfigDefaults: {
        exclude: []
      },
      tsconfigOverride: {
        compilerOptions: {
          sourceMap: sourcemapBool,
          declaration: !!declarationDir,
          ...(declarationDir && {
            declarationDir
          })
        }
      },
      ...(project && {
        tsconfig: path.resolve(cwd, project)
      })
    }), inputIsTypescript && loadPluginTypescript && loadPluginTypescript(), loadPluginJSON && loadPluginJSON({
      preferConst: true
    }), declarationDir && typesOutput && loadPluginExportEquals && loadPluginExportEquals({
      file: path.resolve(cwd, path.join(declarationDir, typesFilename))
    }), loadPluginBabel && loadPluginBabel({
      include,
      extensions,
      exclude
    }), loadPluginBuble && loadPluginBuble(), bin && outputFile && loadPluginAddShebang && loadPluginAddShebang({
      include: outputFile,
      shebang: () => shebang || '#!/usr/bin/env node'
    }), mini && loadPluginTerser && loadPluginTerser({
      sourcemap: sourcemapBool,
      toplevel: true,
      module: true,
      compress: {
        passes: 2
      }
    })];
    return plugins.filter(Boolean);
  }

  if (esOutput) {
    const {
      path: path$1,
      sourcemap,
      min
    } = esOutput;
    const resolvedPath = path.resolve(cwd, path$1);
    configs.push(createModuleConfig(apiInput, 'es', resolvedPath, sourcemap, true, false, isExternal, createPlugins(isTypescriptAPIInput, apiExtensions, resolvedPath, sourcemap, production && !min, false, false), useChokidar));

    if (min) {
      configs.push(createModuleConfig(apiInput, 'es', renameMin(resolvedPath), sourcemap, true, false, isExternal, createPlugins(isTypescriptAPIInput, apiExtensions, resolvedPath, sourcemap, true, false, false), useChokidar));
    }
  }

  if (cjsOutput) {
    const {
      path: path$1,
      sourcemap,
      esModule,
      interop,
      min
    } = cjsOutput;
    const resolvedPath = path.resolve(cwd, path$1);
    configs.push(createModuleConfig(apiInput, 'cjs', resolvedPath, sourcemap, esModule, interop, isExternal, createPlugins(isTypescriptAPIInput, apiExtensions, resolvedPath, sourcemap, production && !min, false, false), useChokidar));

    if (min) {
      configs.push(createModuleConfig(apiInput, 'cjs', renameMin(resolvedPath), sourcemap, esModule, interop, isExternal, createPlugins(isTypescriptAPIInput, apiExtensions, resolvedPath, sourcemap, true, false, false), useChokidar));
    }
  }

  if (browserOutput) {
    const {
      path: path$1,
      sourcemap,
      esModule,
      interop,
      format,
      name,
      extend,
      id,
      globals,
      min
    } = browserOutput;
    const resolvedPath = path.resolve(cwd, path$1);
    const isBrowserExternal = arrayToExternal(keysOrNull(globals));
    configs.push(createBrowserConfig(apiInput, format, resolvedPath, sourcemap, esModule, interop, isBrowserExternal, createPlugins(isTypescriptAPIInput, apiExtensions, null, sourcemap, production && !min, true, false), useChokidar, name, extend, globals, id));

    if (min) {
      configs.push(createBrowserConfig(apiInput, format, renameMin(resolvedPath), sourcemap, esModule, interop, isBrowserExternal, createPlugins(isTypescriptAPIInput, apiExtensions, null, sourcemap, true, true, false), useChokidar, name, extend, globals, id));
    }
  }

  if (binaryOutput) {
    const {
      path: path$1,
      sourcemap,
      esModule,
      interop,
      min
    } = binaryOutput;
    const resolvedPath = path.resolve(cwd, path$1);
    configs.push(createModuleConfig(binInput, 'cjs', resolvedPath, sourcemap, esModule, interop, isExternal, createPlugins(isTypescriptBinaryInput, binaryExtensions, resolvedPath, sourcemap, production && !min, false, true), useChokidar));

    if (min) {
      configs.push(createModuleConfig(binInput, 'cjs', renameMin(resolvedPath), sourcemap, esModule, interop, isExternal, createPlugins(isTypescriptBinaryInput, binaryExtensions, resolvedPath, sourcemap, true, false, true), useChokidar));
    }
  }

  return configs;
}

async function configsFromPkg(cwd, options, pkgJson) {
  return pkgToConfigs((await analizePkg(cwd, pkgJson)), options || {});
}

exports.analizePkg = analizePkg;
exports.configsFromPkg = configsFromPkg;
//# sourceMappingURL=bundlib.js.map