bundlib/dist/bundlib.cjs.js

'use strict';

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

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

function _interopNamespace(e) {
  if (e && e.__esModule) { return e; } else {
    var n = {};
    if (e) {
      Object.keys(e).forEach(function (k) {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () {
            return e[k];
          }
        });
      });
    }
    n['default'] = e;
    return n;
  }
}

var path = require('path');
var readPkg = _interopDefault(require('read-pkg'));
var camelcase = _interopDefault(require('camelcase'));
var builtinModules = _interopDefault(require('builtin-modules'));
var lodash = require('lodash');
var addShebang = _interopDefault(require('rollup-plugin-add-shebang'));
var babel = _interopDefault(require('rollup-plugin-babel'));
var commonjs = _interopDefault(require('rollup-plugin-commonjs'));
var exportEquals = _interopDefault(require('rollup-plugin-export-equals'));
var json = _interopDefault(require('rollup-plugin-json'));
var nodeResolve = _interopDefault(require('rollup-plugin-node-resolve'));
var stripShebang = _interopDefault(require('rollup-plugin-strip-shebang'));
var rollupPluginTerser = require('rollup-plugin-terser');
var typescript2 = _interopDefault(require('rollup-plugin-typescript2'));
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);
}

var keys = Object.keys;
function setProp(name, value, target) {
  target[name] = value;
  return target;
}
function createObject(names, value) {
  return names.reduce(function (result, key) {
    return setProp(key, value, result);
  }, {});
}

function keysOrNull(deps) {
  return deps ? keys(deps) : null;
}

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 === true || value === false;
}
var 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 normalizeBuildFlag(build, key, def) {
  return !build || isNull(build[key]) ? def : !!build[key];
}

function isBrowserFormat(value) {
  return isNull(value) || value === "iife" || value === "amd" || value === "umd";
}

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

function isMinString(value) {
  return value === "main" || value === "module" || value === "browser" || value === "bin";
}
function isValidMinOption(value) {
  return isNull(value) || isBool(value) || isMinString(value) || isArray(value) && value.every(function (item) {
    return isMinString(item);
  });
}
function normalizeMinOption(min) {
  var keys = ["main", "module", "browser", "bin"];
  return !min ? createObject(keys, false) : min === true ? createObject(keys, true) : isArray(min) ? min.reduce(function (result, field) {
    return 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 isModuleString(value) {
  return value === "main" || value === "browser" || value === "bin";
}
function isModuleOption(value) {
  return isNull(value) || isBool(value) || isModuleString(value) || isArray(value) && value.every(function (item) {
    return isModuleString(item);
  });
}
function normalizeModuleOption(option) {
  var keys = ["main", "browser", "bin"];
  return !option ? createObject(keys, false) : option === true ? createObject(keys, true) : isArray(option) ? option.reduce(function (result, field) {
    return 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 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);
}

function invalidKeys(object, list) {
  var invalid = keys(object).filter(function (key) {
    return list.indexOf(key) === -1;
  });
  return invalid.length ? invalid : null;
}
function listInList(input, model) {
  return input.every(function (str) {
    return model.indexOf(str) >= 0;
  });
}
function allKeysInList(object, model) {
  return listInList(keys(object), model);
}

function _await(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var analizePkg = _async(function (cwd, inputPkg) {
  return _await(inputPkg || readPkg({
    cwd: cwd,
    normalize: false
  }), function (pkg) {
    if (!isDictionary(pkg)) {
      throw error("Invalid package.json content");
    }

    var pkgName = pkg.name,
        pkgMain = pkg.main,
        pkgModule = pkg.module,
        pkgJsNextMain = pkg["jsnext:main"],
        pkgBrowser = pkg.browser,
        pkgBin = pkg.bin,
        pkgTypes = pkg.types,
        typings = pkg.typings,
        runtimeDependencies = pkg.dependencies,
        peerDependencies = pkg.peerDependencies,
        optionalDependencies = pkg.optionalDependencies,
        bundlibOptions = pkg.bundlib;

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

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

    if (invalidOptions) {
      var optionNames = invalidOptions.map(function (name) {
        return "\"" + name + "\"";
      }).join(", ");
      throw error("Unknown options found: (" + optionNames + ")");
    }

    var _ref = bundlibOptions || {},
        inputOption = _ref.input,
        sourcemapOption = _ref.sourcemap,
        esModule = _ref.esModule,
        interop = _ref.interop,
        extend = _ref.extend,
        equals = _ref.equals,
        browserFormat = _ref.format,
        browserName = _ref.name,
        amdId = _ref.id,
        browserGlobals = _ref.globals,
        min = _ref.min,
        cacheOption = _ref.cache,
        mainOptions = _ref.main,
        moduleOptions = _ref.module,
        browserOptions = _ref.browser,
        binaryOptionsOrInput = _ref.bin,
        typesOptions = _ref.types;

    var binaryOptions = isString(binaryOptionsOrInput) ? null : binaryOptionsOrInput;

    if (!isStringOrNull(inputOption) && !(isDictionary(inputOption) && allKeysInList(inputOption, ["api", "bin"]) && keys(inputOption).every(function (key) {
      return 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 (!isNull(mainOptions) && mainOptions !== false && !(isDictionary(mainOptions) && allKeysInList(mainOptions, ["sourcemap", "esModule", "interop", "min"]))) {
      throw invalidOption("main", 'false | { sourcemap?: boolean | "inline", esModule?: boolean, interop?: boolean, min?: boolean }');
    }

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

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

    if (!isNull(binaryOptionsOrInput) && !isString(binaryOptionsOrInput) && binaryOptionsOrInput !== false && !(isDictionary(binaryOptionsOrInput) && allKeysInList(binaryOptionsOrInput, ["sourcemap", "esModule", "interop", "min"]))) {
      throw invalidOption("bin", 'false | { sourcemap?: boolean | "inline", esModule?: boolean, interop?: boolean, min?: boolean }');
    }

    if (!isNull(typesOptions) && typesOptions !== false && !(isDictionary(typesOptions) && allKeysInList(typesOptions, ["equals"]))) {
      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");
    }

    if (!isDictionaryOrNull(optionalDependencies)) {
      throw invalidPkgField("optionalDependencies", "Object");
    }

    var esModuleFile = pkgModule || pkgJsNextMain;
    var typesPath = pkgTypes || typings;
    var apiInput = isStringOrNull(inputOption) ? inputOption : inputOption.api;
    var binInput = isStringOrNull(inputOption) ? null : inputOption.bin;

    if (isString(binaryOptionsOrInput) && !binInput) {
      binInput = binaryOptionsOrInput;
    }

    var input = {
      api: path.resolve(cwd, apiInput || "src/index.ts"),
      bin: path.resolve(cwd, binInput || "src-bin/index.ts")
    };
    var globalSourcemap = normalizeSourcemap(sourcemapOption);
    var globalESModule = normalizeModuleOption(esModule);
    var globalInterop = normalizeModuleOption(interop);
    var globalMin = normalizeMinOption(min);
    var mainOutput = mainOptions === false || !pkgMain ? null : {
      path: path.resolve(cwd, pkgMain),
      sourcemap: normalizeBuildSourcemap(mainOptions, globalSourcemap),
      esModule: normalizeBuildModule(mainOptions, "esModule", "main", globalESModule),
      interop: normalizeBuildModule(mainOptions, "interop", "main", globalInterop),
      min: normalizeBuildMin(mainOptions, "main", globalMin)
    };
    var moduleOutput = moduleOptions === false || !esModuleFile ? null : {
      path: path.resolve(cwd, esModuleFile),
      sourcemap: normalizeBuildSourcemap(moduleOptions, globalSourcemap),
      min: normalizeBuildMin(moduleOptions, "module", globalMin)
    };
    var browserOutput = browserOptions === false || !pkgBrowser ? null : {
      path: path.resolve(cwd, 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)
    };
    var binaryOutput = binaryOptions === false || !pkgBin ? null : {
      path: path.resolve(cwd, pkgBin),
      sourcemap: normalizeBuildSourcemap(binaryOptions, globalSourcemap),
      esModule: normalizeBuildModule(binaryOptions, "esModule", "bin", globalESModule),
      interop: normalizeBuildModule(binaryOptions, "interop", "bin", globalInterop),
      min: normalizeBuildMin(binaryOptions, "bin", globalMin)
    };
    var typesOutput = typesOptions === false || !typesPath ? null : {
      path: path.resolve(cwd, typesPath),
      equals: normalizeBuildFlag(typesOptions, "equals", !!equals)
    };
    var output = {
      main: mainOutput,
      module: moduleOutput,
      browser: browserOutput,
      bin: binaryOutput,
      types: typesOutput
    };
    var dependencies = {
      runtime: keysOrNull(runtimeDependencies),
      peer: keysOrNull(peerDependencies),
      optional: keysOrNull(optionalDependencies)
    };
    var cache = path.resolve(cwd, cacheOption || "node_modules/.cache/bundlib");
    return {
      cwd: cwd,
      pkg: pkg,
      input: input,
      output: output,
      dependencies: dependencies,
      cache: cache
    };
  }, inputPkg);
});

function _async(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

function mapIdExternal(cwd, outputDir, map) {
  var normalizedMap = keys(map).reduce(function (result, source) {
    return setProp(slash(path.resolve(cwd, source)), path.resolve(cwd, map[source]), result);
  }, {});
  return {
    name: "api",
    resolveId: function resolveId(moduleId, from) {
      var resolved = !from ? moduleId : path.join(path.dirname(from), moduleId);
      var target = normalizedMap[slash(resolved)] || normalizedMap[slash(resolved + ".ts")] || normalizedMap[slash(path.join(resolved, "index.ts"))];

      if (!target) {
        return null;
      }

      var relativeTarget = path.relative(outputDir, target);
      return {
        id: !relativeTarget ? "." : relativeTarget[0] === "." ? relativeTarget : path.join(".", relativeTarget),
        external: true,
        moduleSideEffects: false
      };
    }
  };
}

function arrayToExternal(modules) {
  var cache = {};
  return function (source, _, isResolved) {
    if (isResolved || source[0] === ".") {
      return;
    }

    return cache[source] || modules.some(function (moduleName) {
      if (source === moduleName) {
        return cache[source] = true;
      }

      var len = moduleName.length;

      if (source.substr(0, len) === moduleName && source[len].match(/^[/\\]$/)) {
        return cache[source] = true;
      }

      return false;
    });
  };
}

function createOutput(format, file, sourcemap, esModule, interop, extra) {
  var options = {
    file: file,
    format: format,
    sourcemap: sourcemap,
    esModule: esModule,
    interop: interop
  };
  return extra ? Object.assign(options, extra) : options;
}

function createConfig(input, output, external, plugins, chokidar) {
  return {
    input: input,
    output: output,
    external: !external ? function () {
      return false;
    } : arrayToExternal(external),
    plugins: plugins.filter(Boolean),
    watch: {
      chokidar: chokidar,
      exclude: ["node_modules/**"]
    }
  };
}
function createModuleConfig(input, format, file, sourcemap, esModule, interop, external, plugins, chokidar) {
  var output = createOutput(format, file, sourcemap, esModule, interop);
  return createConfig(input, output, external, plugins, chokidar);
}
function createBrowserConfig(input, format, file, sourcemap, esModule, interop, plugins, chokidar, name, extend, globals, id) {
  var extra = {
    name: name,
    extend: extend,
    globals: globals || {}
  };

  if (id && (format === "umd" || format === "amd")) {
    extra.amd = {
      id: id
    };
  }

  var output = createOutput(format, file, sourcemap, esModule, interop, extra);
  return createConfig(input, output, keysOrNull(globals), plugins, chokidar);
}

function extensionMatch(filename, extensions) {
  return extensions.indexOf(path.extname(filename).toLowerCase()) >= 0;
}

function renamePre(filename, pre) {
  var _parse = path.parse(filename),
      dir = _parse.dir,
      name = _parse.name,
      ext = _parse.ext;

  return path.join(dir, name + "." + pre + ext);
}
function renameMin(filename) {
  return renamePre(filename, "min");
}

function _await$1(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var pkgToConfigs = _async$1(function (_ref, _ref2) {
  var cwd = _ref.cwd,
      pkg = _ref.pkg,
      input = _ref.input,
      dependencies = _ref.dependencies,
      cache = _ref.cache,
      output = _ref.output;
  var dev = _ref2.dev,
      watch = _ref2.watch;
  var apiInput = input.api,
      binInput = input.bin;
  var cjsOutput = output.main,
      esOutput = output.module,
      browserOutput = output.browser,
      binaryOutput = output.bin,
      typesOutput = output.types;
  var runtimeDeps = dependencies.runtime,
      peerDeps = dependencies.peer,
      optionalDeps = dependencies.optional;

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

  var typescriptOnlyExtensions = [".ts", ".tsx"];
  var javascriptExtensions = [".js", ".jsx", ".mjs", ".node"];
  var isTypescriptAPIInput = extensionMatch(apiInput, typescriptOnlyExtensions);
  var isTypescriptBinaryInput = extensionMatch(binInput, typescriptOnlyExtensions);

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

  var typescriptExtensions = [].concat(typescriptOnlyExtensions, javascriptExtensions);
  var apiExtensions = isTypescriptAPIInput ? typescriptExtensions : javascriptExtensions;
  var binaryExtensions = isTypescriptBinaryInput ? typescriptExtensions : javascriptExtensions;
  var production = !dev;
  var apiFolder = path.dirname(apiInput);
  var apiFolderContent = apiExtensions.map(function (ext) {
    return path.resolve(apiFolder, "**/*" + ext);
  });
  var cwdFolderContent = binaryExtensions.map(function (ext) {
    return path.resolve(cwd, "**/*" + ext);
  });
  var typesFilename = renamePre(path.basename(apiInput), "d");
  var typesOutputDir = typesOutput ? typesOutput.path : null;

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

  var external = lodash.union(runtimeDeps, peerDeps, optionalDeps, builtinModules);
  var installedDeps = lodash.union(runtimeDeps, keysOrNull(pkg.devDependencies));
  var useUserTypescript = (isTypescriptAPIInput || isTypescriptBinaryInput) && installedDeps.indexOf("typescript") >= 0;
  var useChokidar = !!watch && installedDeps.indexOf("chokidar") >= 0;
  return _await$1(useUserTypescript ? null : new Promise(function (resolve) { resolve(_interopNamespace(require('typescript'))); }), function (typescript) {
    var exclude = /node_modules/;

    function createPlugins(inputIsTypescript, extensions, outputFile, sourcemap, mini, browser, bin) {
      var sourcemapBool = !!sourcemap;
      var declarationDir = inputIsTypescript && !configs.length && !bin && typesOutputDir;
      var tsInclude = bin ? cwdFolderContent : apiFolderContent;
      var cacheRoot = path.join(cache, "rpt2");

      var _shebang;

      return [bin && stripShebang({
        capture: function capture(shebangFromFile) {
          return _shebang = shebangFromFile;
        },
        sourcemap: sourcemapBool
      }), bin && cjsOutput && outputFile && mapIdExternal(cwd, path.dirname(outputFile), setProp(apiInput, cwd, {})), nodeResolve({
        preferBuiltins: !browser,
        extensions: extensions
      }), browser && commonjs({
        sourceMap: sourcemapBool
      }), inputIsTypescript && typescript2({
        typescript: typescript = typescript || require(require.resolve("typescript", {
          paths: [cwd]
        })),
        include: tsInclude,
        cacheRoot: cacheRoot,
        useTsconfigDeclarationDir: true,
        tsconfigDefaults: {
          include: tsInclude,
          exclude: [],
          compilerOptions: {
            esModuleInterop: true,
            resolveJsonModule: true,
            allowSyntheticDefaultImports: true
          }
        },
        tsconfigOverride: {
          compilerOptions: {
            target: "esnext",
            module: "esnext",
            moduleResolution: "node",
            sourceMap: sourcemapBool,
            declaration: !!declarationDir,
            declarationDir: declarationDir || "",
            allowJs: !typesOutputDir,
            emitDeclarationOnly: false
          }
        }
      }), json(), declarationDir && typesOutput && typesOutput.equals && exportEquals({
        file: path.resolve(cwd, path.join(declarationDir, typesFilename))
      }), babel({
        extensions: extensions,
        exclude: exclude,
        babelrc: true,
        presets: [[require.resolve("@babel/preset-env"), {
          loose: true
        }], require.resolve("@babel/preset-react")],
        plugins: [require.resolve("@babel/plugin-syntax-dynamic-import"), require.resolve("babel-plugin-transform-async-to-promises")]
      }), bin && outputFile && addShebang({
        include: outputFile,
        shebang: function shebang() {
          return _shebang || "#!/usr/bin/env node";
        }
      }), mini && rollupPluginTerser.terser({
        sourcemap: sourcemapBool,
        toplevel: true,
        module: true
      })];
    }

    var configs = [];

    if (esOutput) {
      var path$1 = esOutput.path,
          sourcemap = esOutput.sourcemap,
          min = esOutput.min;
      configs.push(createModuleConfig(apiInput, "es", path$1, sourcemap, true, false, external, createPlugins(isTypescriptAPIInput, isTypescriptAPIInput ? typescriptExtensions : javascriptExtensions, path$1, sourcemap, production && !min, false, false), useChokidar));

      if (min) {
        configs.push(createModuleConfig(apiInput, "es", renameMin(path$1), sourcemap, true, false, external, createPlugins(isTypescriptAPIInput, isTypescriptAPIInput ? typescriptExtensions : javascriptExtensions, path$1, sourcemap, true, false, false), useChokidar));
      }
    }

    if (cjsOutput) {
      var _path = cjsOutput.path,
          _sourcemap = cjsOutput.sourcemap,
          esModule = cjsOutput.esModule,
          interop = cjsOutput.interop,
          _min = cjsOutput.min;
      configs.push(createModuleConfig(apiInput, "cjs", _path, _sourcemap, esModule, interop, external, createPlugins(isTypescriptAPIInput, isTypescriptAPIInput ? typescriptExtensions : javascriptExtensions, _path, _sourcemap, production && !_min, false, false), useChokidar));

      if (_min) {
        configs.push(createModuleConfig(apiInput, "cjs", renameMin(_path), _sourcemap, esModule, interop, external, createPlugins(isTypescriptAPIInput, isTypescriptAPIInput ? typescriptExtensions : javascriptExtensions, _path, _sourcemap, true, false, false), useChokidar));
      }
    }

    if (browserOutput) {
      var _path2 = browserOutput.path,
          _sourcemap2 = browserOutput.sourcemap,
          _esModule = browserOutput.esModule,
          _interop = browserOutput.interop,
          format = browserOutput.format,
          name = browserOutput.name,
          extend = browserOutput.extend,
          id = browserOutput.id,
          globals = browserOutput.globals,
          _min2 = browserOutput.min;
      configs.push(createBrowserConfig(apiInput, format, _path2, _sourcemap2, _esModule, _interop, createPlugins(isTypescriptAPIInput, isTypescriptAPIInput ? typescriptExtensions : javascriptExtensions, null, _sourcemap2, production && !_min2, true, false), useChokidar, name, extend, globals, id));

      if (_min2) {
        configs.push(createBrowserConfig(apiInput, format, renameMin(_path2), _sourcemap2, _esModule, _interop, createPlugins(isTypescriptAPIInput, isTypescriptAPIInput ? typescriptExtensions : javascriptExtensions, null, _sourcemap2, true, true, false), useChokidar, name, extend, globals, id));
      }
    }

    if (binaryOutput) {
      var _path3 = binaryOutput.path,
          _sourcemap3 = binaryOutput.sourcemap,
          _esModule2 = binaryOutput.esModule,
          _interop2 = binaryOutput.interop,
          _min3 = binaryOutput.min;
      configs.push(createModuleConfig(binInput, "cjs", _path3, _sourcemap3, _esModule2, _interop2, external, createPlugins(isTypescriptBinaryInput, isTypescriptBinaryInput ? typescriptExtensions : javascriptExtensions, _path3, _sourcemap3, production && !_min3, false, true), useChokidar));

      if (_min3) {
        configs.push(createModuleConfig(binInput, "cjs", renameMin(_path3), _sourcemap3, _esModule2, _interop2, external, createPlugins(isTypescriptBinaryInput, isTypescriptBinaryInput ? typescriptExtensions : javascriptExtensions, _path3, _sourcemap3, true, false, true), useChokidar));
      }
    }

    return configs;
  }, useUserTypescript);
});

function _async$1(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

function _await$2(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var configsFromPkg = _async$2(function (cwd, options, pkgJson) {
  return _await$2(analizePkg(cwd, pkgJson), function (_analizePkg) {
    return _await$2(pkgToConfigs(_analizePkg, options || {}));
  });
});

function _async$2(f) {
  return function () {
    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

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