@node-minify/core 7.0.0 → 8.0.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { Settings } from '@node-minify/types';
+
+/*!
+ * node-minify
+ * Copyright(c) 2011-2022 Rodolphe Stoclin
+ * MIT Licensed
+ */
+
+/**
+ * Run node-minify.
+ *
+ * @param {Object} settings - Settings from user input
+ */
+declare const minify: (settings: Settings) => Promise<unknown>;
+
+export { minify as default };

package/dist/index.js

@@ -0,0 +1,230 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/setup.ts
+var import_path = __toESM(require("path"));
+var import_globby = __toESM(require("globby"));
+var import_utils = require("@node-minify/utils");
+var defaultSettings = {
+  sync: false,
+  options: {},
+  buffer: 1e3 * 1024,
+  callback: false
+};
+var setup = (inputSettings) => {
+  let settings = Object.assign(import_utils.utils.clone(defaultSettings), inputSettings);
+  if (settings.content) {
+    checkMandatoriesMemoryContent(inputSettings);
+    return settings;
+  }
+  checkMandatories(inputSettings);
+  settings = Object.assign(settings, wildcards(settings.input, settings.publicFolder));
+  settings = Object.assign(
+    settings,
+    checkOutput(settings.input, settings.output, settings.publicFolder, settings.replaceInPlace)
+  );
+  settings = Object.assign(settings, setPublicFolder(settings.input, settings.publicFolder));
+  return settings;
+};
+var checkOutput = (input, output, publicFolder, replaceInPlace) => {
+  let reg = new RegExp("\\$1");
+  if (reg.test(output)) {
+    if (Array.isArray(input)) {
+      const outputMin = input.map(
+        (file) => import_utils.utils.setFileNameMin(file, output, replaceInPlace ? null : publicFolder, replaceInPlace)
+      );
+      return { output: outputMin };
+    } else {
+      return { output: import_utils.utils.setFileNameMin(input, output, replaceInPlace ? null : publicFolder, replaceInPlace) };
+    }
+  }
+};
+var wildcards = (input, publicFolder) => {
+  if (!Array.isArray(input)) {
+    return wildcardsString(input, publicFolder);
+  }
+  return wildcardsArray(input, publicFolder);
+};
+var wildcardsString = (input, publicFolder) => {
+  const output = {};
+  if (input.indexOf("*") > -1) {
+    output.input = getFilesFromWildcards(input, publicFolder);
+  }
+  return output;
+};
+var wildcardsArray = (input, publicFolder) => {
+  let output = {};
+  let isWildcardsPresent = false;
+  output.input = input;
+  const inputWithPublicFolder = input.map((item) => {
+    if (item.indexOf("*") > -1) {
+      isWildcardsPresent = true;
+    }
+    return (publicFolder || "") + item;
+  });
+  if (isWildcardsPresent) {
+    output.input = import_globby.default.sync(inputWithPublicFolder);
+  }
+  for (let i = 0; i < output.input.length; i++) {
+    if (output.input[i].indexOf("*") > -1) {
+      output.input.splice(i, 1);
+      i--;
+    }
+  }
+  return output;
+};
+var getFilesFromWildcards = (input, publicFolder) => {
+  let output = [];
+  if (input.indexOf("*") > -1) {
+    output = import_globby.default.sync((publicFolder || "") + input);
+  }
+  return output;
+};
+var setPublicFolder = (input, publicFolder) => {
+  let output = {};
+  if (typeof publicFolder !== "string") {
+    return output;
+  }
+  publicFolder = import_path.default.normalize(publicFolder);
+  if (Array.isArray(input)) {
+    output.input = input.map((item) => {
+      if (import_path.default.normalize(item).indexOf(publicFolder) > -1) {
+        return item;
+      }
+      return import_path.default.normalize(publicFolder + item);
+    });
+    return output;
+  }
+  input = import_path.default.normalize(input);
+  if (input.indexOf(publicFolder) > -1) {
+    output.input = input;
+    return output;
+  }
+  output.input = import_path.default.normalize(publicFolder + input);
+  return output;
+};
+var checkMandatories = (settings) => {
+  ["compressor", "input", "output"].forEach((item) => mandatory(item, settings));
+};
+var checkMandatoriesMemoryContent = (settings) => {
+  ["compressor", "content"].forEach((item) => mandatory(item, settings));
+};
+var mandatory = (setting, settings) => {
+  if (!settings[setting]) {
+    throw new Error(setting + " is mandatory.");
+  }
+};
+
+// src/compress.ts
+var import_fs = __toESM(require("fs"));
+var import_mkdirp = __toESM(require("mkdirp"));
+var import_utils2 = require("@node-minify/utils");
+var compress = (settings) => {
+  if (typeof settings.compressor !== "function") {
+    throw new Error(`compressor should be a function, maybe you forgot to install the compressor`);
+  }
+  createDirectory(settings.output);
+  if (Array.isArray(settings.output)) {
+    return settings.sync ? compressArrayOfFilesSync(settings) : compressArrayOfFilesAsync(settings);
+  } else {
+    return import_utils2.utils.compressSingleFile(settings);
+  }
+};
+var compressArrayOfFilesSync = (settings) => {
+  return Array.isArray(settings.input) && settings.input.forEach((input, index) => {
+    const content = import_utils2.utils.getContentFromFiles(input);
+    return import_utils2.utils.runSync({ settings, content, index });
+  });
+};
+var compressArrayOfFilesAsync = (settings) => {
+  let sequence = Promise.resolve();
+  Array.isArray(settings.input) && settings.input.forEach((input, index) => {
+    const content = import_utils2.utils.getContentFromFiles(input);
+    sequence = sequence.then(() => import_utils2.utils.runAsync({ settings, content, index }));
+  });
+  return sequence;
+};
+var createDirectory = (file) => {
+  if (Array.isArray(file)) {
+    file = file[0];
+  }
+  const dir = file && file.substr(0, file.lastIndexOf("/"));
+  if (!dir) {
+    return;
+  }
+  if (!import_fs.default.statSync(dir).isDirectory()) {
+    import_mkdirp.default.sync(dir);
+  }
+};
+
+// src/compressInMemory.ts
+var import_utils3 = require("@node-minify/utils");
+var compressInMemory = (settings) => {
+  if (typeof settings.compressor !== "function") {
+    throw new Error(`compressor should be a function, maybe you forgot to install the compressor`);
+  }
+  return import_utils3.utils.compressSingleFile(settings);
+};
+
+// src/index.ts
+var minify = (settings) => {
+  return new Promise((resolve, reject) => {
+    const method = settings.content ? compressInMemory : compress;
+    settings = setup(settings);
+    if (!settings.sync) {
+      method(settings).then((minified) => {
+        if (settings.callback) {
+          settings.callback(null, minified);
+        }
+        resolve(minified);
+      }).catch((err) => {
+        if (settings.callback) {
+          settings.callback(err);
+        }
+        reject(err);
+      });
+    } else {
+      const minified = method(settings);
+      if (settings.callback) {
+        settings.callback(null, minified);
+      }
+      resolve(minified);
+    }
+  });
+};
+var src_default = minify;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});
+/*!
+ * node-minify
+ * Copyright(c) 2011-2022 Rodolphe Stoclin
+ * MIT Licensed
+ */

package/dist/index.mjs

@@ -0,0 +1,200 @@
+// src/setup.ts
+import path from "path";
+import globby from "globby";
+import { utils } from "@node-minify/utils";
+var defaultSettings = {
+  sync: false,
+  options: {},
+  buffer: 1e3 * 1024,
+  callback: false
+};
+var setup = (inputSettings) => {
+  let settings = Object.assign(utils.clone(defaultSettings), inputSettings);
+  if (settings.content) {
+    checkMandatoriesMemoryContent(inputSettings);
+    return settings;
+  }
+  checkMandatories(inputSettings);
+  settings = Object.assign(settings, wildcards(settings.input, settings.publicFolder));
+  settings = Object.assign(
+    settings,
+    checkOutput(settings.input, settings.output, settings.publicFolder, settings.replaceInPlace)
+  );
+  settings = Object.assign(settings, setPublicFolder(settings.input, settings.publicFolder));
+  return settings;
+};
+var checkOutput = (input, output, publicFolder, replaceInPlace) => {
+  let reg = new RegExp("\\$1");
+  if (reg.test(output)) {
+    if (Array.isArray(input)) {
+      const outputMin = input.map(
+        (file) => utils.setFileNameMin(file, output, replaceInPlace ? null : publicFolder, replaceInPlace)
+      );
+      return { output: outputMin };
+    } else {
+      return { output: utils.setFileNameMin(input, output, replaceInPlace ? null : publicFolder, replaceInPlace) };
+    }
+  }
+};
+var wildcards = (input, publicFolder) => {
+  if (!Array.isArray(input)) {
+    return wildcardsString(input, publicFolder);
+  }
+  return wildcardsArray(input, publicFolder);
+};
+var wildcardsString = (input, publicFolder) => {
+  const output = {};
+  if (input.indexOf("*") > -1) {
+    output.input = getFilesFromWildcards(input, publicFolder);
+  }
+  return output;
+};
+var wildcardsArray = (input, publicFolder) => {
+  let output = {};
+  let isWildcardsPresent = false;
+  output.input = input;
+  const inputWithPublicFolder = input.map((item) => {
+    if (item.indexOf("*") > -1) {
+      isWildcardsPresent = true;
+    }
+    return (publicFolder || "") + item;
+  });
+  if (isWildcardsPresent) {
+    output.input = globby.sync(inputWithPublicFolder);
+  }
+  for (let i = 0; i < output.input.length; i++) {
+    if (output.input[i].indexOf("*") > -1) {
+      output.input.splice(i, 1);
+      i--;
+    }
+  }
+  return output;
+};
+var getFilesFromWildcards = (input, publicFolder) => {
+  let output = [];
+  if (input.indexOf("*") > -1) {
+    output = globby.sync((publicFolder || "") + input);
+  }
+  return output;
+};
+var setPublicFolder = (input, publicFolder) => {
+  let output = {};
+  if (typeof publicFolder !== "string") {
+    return output;
+  }
+  publicFolder = path.normalize(publicFolder);
+  if (Array.isArray(input)) {
+    output.input = input.map((item) => {
+      if (path.normalize(item).indexOf(publicFolder) > -1) {
+        return item;
+      }
+      return path.normalize(publicFolder + item);
+    });
+    return output;
+  }
+  input = path.normalize(input);
+  if (input.indexOf(publicFolder) > -1) {
+    output.input = input;
+    return output;
+  }
+  output.input = path.normalize(publicFolder + input);
+  return output;
+};
+var checkMandatories = (settings) => {
+  ["compressor", "input", "output"].forEach((item) => mandatory(item, settings));
+};
+var checkMandatoriesMemoryContent = (settings) => {
+  ["compressor", "content"].forEach((item) => mandatory(item, settings));
+};
+var mandatory = (setting, settings) => {
+  if (!settings[setting]) {
+    throw new Error(setting + " is mandatory.");
+  }
+};
+
+// src/compress.ts
+import fs from "fs";
+import mkdirp from "mkdirp";
+import { utils as utils2 } from "@node-minify/utils";
+var compress = (settings) => {
+  if (typeof settings.compressor !== "function") {
+    throw new Error(`compressor should be a function, maybe you forgot to install the compressor`);
+  }
+  createDirectory(settings.output);
+  if (Array.isArray(settings.output)) {
+    return settings.sync ? compressArrayOfFilesSync(settings) : compressArrayOfFilesAsync(settings);
+  } else {
+    return utils2.compressSingleFile(settings);
+  }
+};
+var compressArrayOfFilesSync = (settings) => {
+  return Array.isArray(settings.input) && settings.input.forEach((input, index) => {
+    const content = utils2.getContentFromFiles(input);
+    return utils2.runSync({ settings, content, index });
+  });
+};
+var compressArrayOfFilesAsync = (settings) => {
+  let sequence = Promise.resolve();
+  Array.isArray(settings.input) && settings.input.forEach((input, index) => {
+    const content = utils2.getContentFromFiles(input);
+    sequence = sequence.then(() => utils2.runAsync({ settings, content, index }));
+  });
+  return sequence;
+};
+var createDirectory = (file) => {
+  if (Array.isArray(file)) {
+    file = file[0];
+  }
+  const dir = file && file.substr(0, file.lastIndexOf("/"));
+  if (!dir) {
+    return;
+  }
+  if (!fs.statSync(dir).isDirectory()) {
+    mkdirp.sync(dir);
+  }
+};
+
+// src/compressInMemory.ts
+import { utils as utils3 } from "@node-minify/utils";
+var compressInMemory = (settings) => {
+  if (typeof settings.compressor !== "function") {
+    throw new Error(`compressor should be a function, maybe you forgot to install the compressor`);
+  }
+  return utils3.compressSingleFile(settings);
+};
+
+// src/index.ts
+var minify = (settings) => {
+  return new Promise((resolve, reject) => {
+    const method = settings.content ? compressInMemory : compress;
+    settings = setup(settings);
+    if (!settings.sync) {
+      method(settings).then((minified) => {
+        if (settings.callback) {
+          settings.callback(null, minified);
+        }
+        resolve(minified);
+      }).catch((err) => {
+        if (settings.callback) {
+          settings.callback(err);
+        }
+        reject(err);
+      });
+    } else {
+      const minified = method(settings);
+      if (settings.callback) {
+        settings.callback(null, minified);
+      }
+      resolve(minified);
+    }
+  });
+};
+var src_default = minify;
+export {
+  src_default as default
+};
+/*!
+ * node-minify
+ * Copyright(c) 2011-2022 Rodolphe Stoclin
+ * MIT Licensed
+ */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@node-minify/core",
-  "version": "7.0.0",
+  "version": "8.0.0-beta.0",
   "description": "core of @node-minify",
   "keywords": [
     "compressor",
@@ -10,16 +10,23 @@
   "author": "Rodolphe Stoclin <srodolphe@gmail.com>",
   "homepage": "https://github.com/srod/node-minify/tree/master/packages/core#readme",
   "license": "MIT",
-  "main": "lib/core.js",
   "engines": {
     "node": ">=14.0.0"
   },
   "directories": {
-    "lib": "lib",
+    "lib": "dist",
     "test": "__tests__"
   },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "require": "./dist/index.js",
+    "import": "./dist/index.mjs",
+    "types": "./dist/index.d.ts"
+  },
   "files": [
-    "lib"
+    "dist/**/*"
   ],
   "publishConfig": {
     "access": "public"
@@ -31,10 +38,19 @@
   "bugs": {
     "url": "https://github.com/srod/node-minify/issues"
   },
+  "scripts": {
+    "clean": "pnpm dlx rimraf dist",
+    "build": "npm run clean && tsup src/index.ts --format cjs,esm --dts --clean",
+    "prepublishOnly": "npm run build"
+  },
   "dependencies": {
-    "@node-minify/utils": "^7.0.0",
-    "globby": "11.0.4",
+    "@node-minify/utils": "8.0.0-beta.0",
+    "globby": "11.1.0",
     "mkdirp": "1.0.4"
   },
-  "gitHead": "8b5bda6f1ac9fe7180006f2a19ec3253e8fff4ec"
+  "devDependencies": {
+    "@node-minify/types": "8.0.0-beta.0",
+    "@types/mkdirp": "^1.0.2"
+  },
+  "gitHead": "0507c6190577e1939997a8231b07952ba167a780"
 }

package/lib/compress.js

@@ -1,108 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.compress = void 0;
-
-var _fs = _interopRequireDefault(require("fs"));
-
-var _mkdirp = _interopRequireDefault(require("mkdirp"));
-
-var _utils = require("@node-minify/utils");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/*!
- * node-minify
- * Copyright(c) 2011-2022 Rodolphe Stoclin
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-/**
- * Run compressor.
- *
- * @param {Object} settings
- */
-const compress = settings => {
-  if (typeof settings.compressor !== 'function') {
-    throw new Error(`compressor should be a function, maybe you forgot to install the compressor`);
-  }
-
-  createDirectory(settings.output);
-
-  if (Array.isArray(settings.output)) {
-    return settings.sync ? compressArrayOfFilesSync(settings) : compressArrayOfFilesAsync(settings);
-  } else {
-    return _utils.utils.compressSingleFile(settings);
-  }
-};
-/**
- * Compress an array of files in sync.
- *
- * @param {Object} settings
- */
-
-
-exports.compress = compress;
-
-const compressArrayOfFilesSync = settings => {
-  return settings.input.forEach((input, index) => {
-    const content = _utils.utils.getContentFromFiles(input);
-
-    return _utils.utils.runSync({
-      settings,
-      content,
-      index
-    });
-  });
-};
-/**
- * Compress an array of files in async.
- *
- * @param {Object} settings
- */
-
-
-const compressArrayOfFilesAsync = settings => {
-  let sequence = Promise.resolve();
-  settings.input.forEach((input, index) => {
-    const content = _utils.utils.getContentFromFiles(input);
-
-    sequence = sequence.then(() => _utils.utils.runAsync({
-      settings,
-      content,
-      index
-    }));
-  });
-  return sequence;
-};
-/**
- * Create folder of the target file.
- *
- * @param {String} file - Full path of the file
- */
-
-
-const createDirectory = file => {
-  if (Array.isArray(file)) {
-    file = file[0];
-  }
-
-  const dir = file && file.substr(0, file.lastIndexOf('/'));
-
-  if (!dir) {
-    return;
-  }
-
-  if (!_fs.default.statSync(dir).isDirectory()) {
-    _mkdirp.default.sync(dir);
-  }
-};
-/**
- * Expose `compress()`.
- */

package/lib/compressInMemory.js

@@ -1,37 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.compressInMemory = void 0;
-
-var _utils = require("@node-minify/utils");
-
-/*!
- * node-minify
- * Copyright(c) 2011-2022 Rodolphe Stoclin
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-/**
- * Run compressor.
- *
- * @param {Object} settings
- */
-const compressInMemory = settings => {
-  if (typeof settings.compressor !== 'function') {
-    throw new Error(`compressor should be a function, maybe you forgot to install the compressor`);
-  }
-
-  return _utils.utils.compressSingleFile(settings);
-};
-/**
- * Expose `compress()`.
- */
-
-
-exports.compressInMemory = compressInMemory;

package/lib/core.js

@@ -1,59 +0,0 @@
-"use strict";
-
-var _setup = require("./setup");
-
-var _compress = require("./compress");
-
-var _compressInMemory = require("./compressInMemory");
-
-/*!
- * node-minify
- * Copyright(c) 2011-2022 Rodolphe Stoclin
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-/**
- * Run node-minify.
- *
- * @param {Object} settings - Settings from user input
- */
-const minify = settings => {
-  return new Promise((resolve, reject) => {
-    const method = settings.content ? _compressInMemory.compressInMemory : _compress.compress;
-    settings = (0, _setup.setup)(settings);
-
-    if (!settings.sync) {
-      method(settings).then(minified => {
-        if (settings.callback) {
-          settings.callback(null, minified);
-        }
-
-        resolve(minified);
-      }).catch(err => {
-        if (settings.callback) {
-          settings.callback(err);
-        }
-
-        reject(err);
-      });
-    } else {
-      const minified = method(settings);
-
-      if (settings.callback) {
-        settings.callback(null, minified);
-      }
-
-      resolve(minified);
-    }
-  });
-};
-/**
- * Expose `minify()`.
- */
-
-
-module.exports = minify;

package/lib/setup.js

@@ -1,250 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.setup = void 0;
-
-var _path = _interopRequireDefault(require("path"));
-
-var _globby = _interopRequireDefault(require("globby"));
-
-var _utils = require("@node-minify/utils");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/*!
- * node-minify
- * Copyright(c) 2011-2022 Rodolphe Stoclin
- * MIT Licensed
- */
-
-/**
- * Module dependencies.
- */
-
-/**
- * Default settings.
- */
-const defaultSettings = {
-  sync: false,
-  options: {},
-  buffer: 1000 * 1024,
-  callback: false
-};
-/**
- * Run setup.
- *
- * @param {Object} inputSettings
- * @return {Object}
- */
-
-const setup = inputSettings => {
-  let settings = Object.assign(_utils.utils.clone(defaultSettings), inputSettings); // In memory
-
-  if (settings.content) {
-    checkMandatoriesMemoryContent(inputSettings);
-    return settings;
-  }
-
-  checkMandatories(inputSettings);
-  settings = Object.assign(settings, wildcards(settings.input, settings.publicFolder));
-  settings = Object.assign(settings, checkOutput(settings.input, settings.output, settings.publicFolder, settings.replaceInPlace));
-  settings = Object.assign(settings, setPublicFolder(settings.input, settings.publicFolder));
-  return settings;
-};
-/**
- * Check the output path, searching for $1
- * if exist, returns the path remplacing $1 by file name
- *
- * @param {String|Array} input - Path file
- * @param {String} output - Path to the output file
- * @param {String} publicFolder - Path to the public folder
- * @param {Boolean} replaceInPlace - True to replace file in same folder
- * @return {Object}
- */
-
-
-exports.setup = setup;
-
-const checkOutput = (input, output, publicFolder, replaceInPlace) => {
-  let reg = new RegExp('\\$1');
-
-  if (reg.test(output)) {
-    if (Array.isArray(input)) {
-      const outputMin = input.map(file => _utils.utils.setFileNameMin(file, output, replaceInPlace ? null : publicFolder, replaceInPlace));
-      return {
-        output: outputMin
-      };
-    } else {
-      return {
-        output: _utils.utils.setFileNameMin(input, output, replaceInPlace ? null : publicFolder, replaceInPlace)
-      };
-    }
-  }
-};
-/**
- * Handle wildcards in a path, get the real path of each files.
- *
- * @param {String|Array} input - Path with wildcards
- * @param {String} publicFolder - Path to the public folder
- * @return {Object}
- */
-
-
-const wildcards = (input, publicFolder) => {
-  // If it's a string
-  if (!Array.isArray(input)) {
-    return wildcardsString(input, publicFolder);
-  }
-
-  return wildcardsArray(input, publicFolder);
-};
-/**
- * Handle wildcards in a path (string only), get the real path of each files.
- *
- * @param {String} input - Path with wildcards
- * @param {String} publicFolder - Path to the public folder
- * @return {Object}
- */
-
-
-const wildcardsString = (input, publicFolder) => {
-  const output = {};
-
-  if (input.indexOf('*') > -1) {
-    output.input = getFilesFromWildcards(input, publicFolder);
-  }
-
-  return output;
-};
-/**
- * Handle wildcards in a path (array only), get the real path of each files.
- *
- * @param {Array} input - Path with wildcards
- * @param {String} publicFolder - Path to the public folder
- * @return {Object}
- */
-
-
-const wildcardsArray = (input, publicFolder) => {
-  let output = {};
-  let isWildcardsPresent = false;
-  output.input = input; // Transform all wildcards to path file
-
-  const inputWithPublicFolder = input.map(item => {
-    if (item.indexOf('*') > -1) {
-      isWildcardsPresent = true;
-    }
-
-    return (publicFolder || '') + item;
-  });
-
-  if (isWildcardsPresent) {
-    output.input = _globby.default.sync(inputWithPublicFolder);
-  } // Remove all wildcards from array
-
-
-  for (let i = 0; i < output.input.length; i++) {
-    if (output.input[i].indexOf('*') > -1) {
-      output.input.splice(i, 1);
-      i--;
-    }
-  }
-
-  return output;
-};
-/**
- * Get the real path of each files.
- *
- * @param {String} input - Path with wildcards
- * @param {String} publicFolder - Path to the public folder
- * @return {Object}
- */
-
-
-const getFilesFromWildcards = (input, publicFolder) => {
-  let output = [];
-
-  if (input.indexOf('*') > -1) {
-    output = _globby.default.sync((publicFolder || '') + input);
-  }
-
-  return output;
-};
-/**
- * Prepend the public folder to each file.
- *
- * @param {String|Array} input - Path to file(s)
- * @param {String} publicFolder - Path to the public folder
- * @return {Object}
- */
-
-
-const setPublicFolder = (input, publicFolder) => {
-  let output = {};
-
-  if (typeof publicFolder !== 'string') {
-    return output;
-  }
-
-  publicFolder = _path.default.normalize(publicFolder);
-
-  if (Array.isArray(input)) {
-    output.input = input.map(item => {
-      // Check if publicFolder is already in path
-      if (_path.default.normalize(item).indexOf(publicFolder) > -1) {
-        return item;
-      }
-
-      return _path.default.normalize(publicFolder + item);
-    });
-    return output;
-  }
-
-  input = _path.default.normalize(input); // Check if publicFolder is already in path
-
-  if (input.indexOf(publicFolder) > -1) {
-    output.input = input;
-    return output;
-  }
-
-  output.input = _path.default.normalize(publicFolder + input);
-  return output;
-};
-/**
- * Check if some settings are here.
- *
- * @param {Object} settings
- */
-
-
-const checkMandatories = settings => {
-  ['compressor', 'input', 'output'].forEach(item => mandatory(item, settings));
-};
-/**
- * Check if some settings are here for memory content.
- *
- * @param {Object} settings
- */
-
-
-const checkMandatoriesMemoryContent = settings => {
-  ['compressor', 'content'].forEach(item => mandatory(item, settings));
-};
-/**
- * Check if the setting exist.
- *
- * @param {String} setting
- * @param {Object} settings
- */
-
-
-const mandatory = (setting, settings) => {
-  if (!settings[setting]) {
-    throw new Error(setting + ' is mandatory.');
-  }
-};
-/**
- * Expose `setup()`.
- */