Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/imagemin/index.js b/node_modules/imagemin/index.js
new file mode 100644
index 0000000..93b7525
--- /dev/null
+++ b/node_modules/imagemin/index.js
@@ -0,0 +1,73 @@
+'use strict';
+const {promisify} = require('util');
+const path = require('path');
+const fs = require('graceful-fs');
+const fileType = require('file-type');
+const globby = require('globby');
+const makeDir = require('make-dir');
+const pPipe = require('p-pipe');
+const replaceExt = require('replace-ext');
+const junk = require('junk');
+
+const readFile = promisify(fs.readFile);
+const writeFile = promisify(fs.writeFile);
+
+const handleFile = async (sourcePath, {destination, plugins = []}) => {
+ if (plugins && !Array.isArray(plugins)) {
+ throw new TypeError('The `plugins` option should be an `Array`');
+ }
+
+ let data = await readFile(sourcePath);
+ data = await (plugins.length > 0 ? pPipe(...plugins)(data) : data);
+
+ let destinationPath = destination ? path.join(destination, path.basename(sourcePath)) : undefined;
+ destinationPath = (fileType(data) && fileType(data).ext === 'webp') ? replaceExt(destinationPath, '.webp') : destinationPath;
+
+ const returnValue = {
+ data,
+ sourcePath,
+ destinationPath
+ };
+
+ if (!destinationPath) {
+ return returnValue;
+ }
+
+ await makeDir(path.dirname(returnValue.destinationPath));
+ await writeFile(returnValue.destinationPath, returnValue.data);
+
+ return returnValue;
+};
+
+module.exports = async (input, {glob = true, ...options} = {}) => {
+ if (!Array.isArray(input)) {
+ throw new TypeError(`Expected an \`Array\`, got \`${typeof input}\``);
+ }
+
+ const filePaths = glob ? await globby(input, {onlyFiles: true}) : input;
+
+ return Promise.all(
+ filePaths
+ .filter(filePath => junk.not(path.basename(filePath)))
+ .map(async filePath => {
+ try {
+ return await handleFile(filePath, options);
+ } catch (error) {
+ error.message = `Error occurred when handling file: ${input}\n\n${error.stack}`;
+ throw error;
+ }
+ })
+ );
+};
+
+module.exports.buffer = async (input, {plugins = []} = {}) => {
+ if (!Buffer.isBuffer(input)) {
+ throw new TypeError(`Expected a \`Buffer\`, got \`${typeof input}\``);
+ }
+
+ if (plugins.length === 0) {
+ return input;
+ }
+
+ return pPipe(...plugins)(input);
+};
diff --git a/node_modules/imagemin/license b/node_modules/imagemin/license
new file mode 100644
index 0000000..038c983
--- /dev/null
+++ b/node_modules/imagemin/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Imagemin (github.com/imagemin)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/.bin/semver b/node_modules/imagemin/node_modules/.bin/semver
new file mode 100644
index 0000000..7e36527
--- /dev/null
+++ b/node_modules/imagemin/node_modules/.bin/semver
@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+ *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+ "$basedir/node" "$basedir/../semver/bin/semver.js" "$@"
+ ret=$?
+else
+ node "$basedir/../semver/bin/semver.js" "$@"
+ ret=$?
+fi
+exit $ret
diff --git a/node_modules/imagemin/node_modules/.bin/semver.cmd b/node_modules/imagemin/node_modules/.bin/semver.cmd
new file mode 100644
index 0000000..164cdea
--- /dev/null
+++ b/node_modules/imagemin/node_modules/.bin/semver.cmd
@@ -0,0 +1,17 @@
+@ECHO off
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+ SET "_prog=%dp0%\node.exe"
+) ELSE (
+ SET "_prog=node"
+ SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+"%_prog%" "%dp0%\..\semver\bin\semver.js" %*
+ENDLOCAL
+EXIT /b %errorlevel%
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
diff --git a/node_modules/imagemin/node_modules/.bin/semver.ps1 b/node_modules/imagemin/node_modules/.bin/semver.ps1
new file mode 100644
index 0000000..6a85e34
--- /dev/null
+++ b/node_modules/imagemin/node_modules/.bin/semver.ps1
@@ -0,0 +1,18 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+ # Fix case when both the Windows and Linux builds of Node
+ # are installed in the same directory
+ $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+ & "$basedir/node$exe" "$basedir/../semver/bin/semver.js" $args
+ $ret=$LASTEXITCODE
+} else {
+ & "node$exe" "$basedir/../semver/bin/semver.js" $args
+ $ret=$LASTEXITCODE
+}
+exit $ret
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/LICENSE b/node_modules/imagemin/node_modules/@nodelib/fs.stat/LICENSE
new file mode 100644
index 0000000..65a9994
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/README.md b/node_modules/imagemin/node_modules/@nodelib/fs.stat/README.md
new file mode 100644
index 0000000..686f047
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/README.md
@@ -0,0 +1,126 @@
+# @nodelib/fs.stat
+
+> Get the status of a file with some features.
+
+## :bulb: Highlights
+
+Wrapper around standard method `fs.lstat` and `fs.stat` with some features.
+
+* :beginner: Normally follows symbolic link.
+* :gear: Can safely work with broken symbolic link.
+
+## Install
+
+```console
+npm install @nodelib/fs.stat
+```
+
+## Usage
+
+```ts
+import * as fsStat from '@nodelib/fs.stat';
+
+fsStat.stat('path', (error, stats) => { /* … */ });
+```
+
+## API
+
+### .stat(path, [optionsOrSettings], callback)
+
+Returns an instance of `fs.Stats` class for provided path with standard callback-style.
+
+```ts
+fsStat.stat('path', (error, stats) => { /* … */ });
+fsStat.stat('path', {}, (error, stats) => { /* … */ });
+fsStat.stat('path', new fsStat.Settings(), (error, stats) => { /* … */ });
+```
+
+### .statSync(path, [optionsOrSettings])
+
+Returns an instance of `fs.Stats` class for provided path.
+
+```ts
+const stats = fsStat.stat('path');
+const stats = fsStat.stat('path', {});
+const stats = fsStat.stat('path', new fsStat.Settings());
+```
+
+#### path
+
+* Required: `true`
+* Type: `string | Buffer | URL`
+
+A path to a file. If a URL is provided, it must use the `file:` protocol.
+
+#### optionsOrSettings
+
+* Required: `false`
+* Type: `Options | Settings`
+* Default: An instance of `Settings` class
+
+An [`Options`](#options) object or an instance of [`Settings`](#settings) class.
+
+> :book: When you pass a plain object, an instance of the `Settings` class will be created automatically. If you plan to call the method frequently, use a pre-created instance of the `Settings` class.
+
+### Settings([options])
+
+A class of full settings of the package.
+
+```ts
+const settings = new fsStat.Settings({ followSymbolicLink: false });
+
+const stats = fsStat.stat('path', settings);
+```
+
+## Options
+
+### `followSymbolicLink`
+
+* Type: `boolean`
+* Default: `true`
+
+Follow symbolic link or not. Call `fs.stat` on symbolic link if `true`.
+
+### `markSymbolicLink`
+
+* Type: `boolean`
+* Default: `false`
+
+Mark symbolic link by setting the return value of `isSymbolicLink` function to always `true` (even after `fs.stat`).
+
+> :book: Can be used if you want to know what is hidden behind a symbolic link, but still continue to know that it is a symbolic link.
+
+### `throwErrorOnBrokenSymbolicLink`
+
+* Type: `boolean`
+* Default: `true`
+
+Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
+
+### `fs`
+
+* Type: [`FileSystemAdapter`](./src/adapters/fs.ts)
+* Default: A default FS methods
+
+By default, the built-in Node.js module (`fs`) is used to work with the file system. You can replace any method with your own.
+
+```ts
+interface FileSystemAdapter {
+ lstat?: typeof fs.lstat;
+ stat?: typeof fs.stat;
+ lstatSync?: typeof fs.lstatSync;
+ statSync?: typeof fs.statSync;
+}
+
+const settings = new fsStat.Settings({
+ fs: { lstat: fakeLstat }
+});
+```
+
+## Changelog
+
+See the [Releases section of our GitHub project](https://github.com/nodelib/nodelib/releases) for changelog for each release version.
+
+## License
+
+This software is released under the terms of the MIT license.
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/adapters/fs.d.ts b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/adapters/fs.d.ts
new file mode 100644
index 0000000..dbb8986
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/adapters/fs.d.ts
@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export declare type FileSystemAdapter = {
+ lstat: typeof fs.lstat;
+ stat: typeof fs.stat;
+ lstatSync: typeof fs.lstatSync;
+ statSync: typeof fs.statSync;
+};
+export declare const FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export declare function createFileSystemAdapter(fsMethods?: Partial<FileSystemAdapter>): FileSystemAdapter;
+//# sourceMappingURL=fs.d.ts.map
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/adapters/fs.js b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/adapters/fs.js
new file mode 100644
index 0000000..80e3427
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/adapters/fs.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+exports.FILE_SYSTEM_ADAPTER = {
+ lstat: fs.lstat,
+ stat: fs.stat,
+ lstatSync: fs.lstatSync,
+ statSync: fs.statSync
+};
+function createFileSystemAdapter(fsMethods) {
+ if (fsMethods === undefined) {
+ return exports.FILE_SYSTEM_ADAPTER;
+ }
+ return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+}
+exports.createFileSystemAdapter = createFileSystemAdapter;
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/index.d.ts b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/index.d.ts
new file mode 100644
index 0000000..97d5ed7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/index.d.ts
@@ -0,0 +1,13 @@
+import { FileSystemAdapter } from './adapters/fs';
+import * as async from './providers/async';
+import Settings, { Options } from './settings';
+import { Stats } from './types';
+declare type AsyncCallback = async.AsyncCallback;
+declare function stat(path: string, callback: AsyncCallback): void;
+declare function stat(path: string, optionsOrSettings: Options | Settings, callback: AsyncCallback): void;
+declare namespace stat {
+ function __promisify__(path: string, optionsOrSettings?: Options | Settings): Promise<Stats>;
+}
+declare function statSync(path: string, optionsOrSettings?: Options | Settings): Stats;
+export { Settings, stat, statSync, AsyncCallback, FileSystemAdapter, Options, Stats };
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/index.js b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/index.js
new file mode 100644
index 0000000..40491a4
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/index.js
@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const async = require("./providers/async");
+const sync = require("./providers/sync");
+const settings_1 = require("./settings");
+exports.Settings = settings_1.default;
+function stat(path, optionsOrSettingsOrCallback, callback) {
+ if (typeof optionsOrSettingsOrCallback === 'function') {
+ return async.read(path, getSettings(), optionsOrSettingsOrCallback);
+ }
+ async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
+}
+exports.stat = stat;
+function statSync(path, optionsOrSettings) {
+ const settings = getSettings(optionsOrSettings);
+ return sync.read(path, settings);
+}
+exports.statSync = statSync;
+function getSettings(settingsOrOptions = {}) {
+ if (settingsOrOptions instanceof settings_1.default) {
+ return settingsOrOptions;
+ }
+ return new settings_1.default(settingsOrOptions);
+}
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/async.d.ts b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/async.d.ts
new file mode 100644
index 0000000..9914f7c
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/async.d.ts
@@ -0,0 +1,5 @@
+import Settings from '../settings';
+import { ErrnoException, Stats } from '../types';
+export declare type AsyncCallback = (err: ErrnoException, stats: Stats) => void;
+export declare function read(path: string, settings: Settings, callback: AsyncCallback): void;
+//# sourceMappingURL=async.d.ts.map
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/async.js b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/async.js
new file mode 100644
index 0000000..39a2d78
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/async.js
@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function read(path, settings, callback) {
+ settings.fs.lstat(path, (lstatError, lstat) => {
+ if (lstatError !== null) {
+ return callFailureCallback(callback, lstatError);
+ }
+ if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+ return callSuccessCallback(callback, lstat);
+ }
+ settings.fs.stat(path, (statError, stat) => {
+ if (statError !== null) {
+ if (settings.throwErrorOnBrokenSymbolicLink) {
+ return callFailureCallback(callback, statError);
+ }
+ return callSuccessCallback(callback, lstat);
+ }
+ if (settings.markSymbolicLink) {
+ stat.isSymbolicLink = () => true;
+ }
+ callSuccessCallback(callback, stat);
+ });
+ });
+}
+exports.read = read;
+function callFailureCallback(callback, error) {
+ callback(error);
+}
+function callSuccessCallback(callback, result) {
+ callback(null, result);
+}
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/sync.d.ts b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/sync.d.ts
new file mode 100644
index 0000000..6dcce9d
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/sync.d.ts
@@ -0,0 +1,4 @@
+import Settings from '../settings';
+import { Stats } from '../types';
+export declare function read(path: string, settings: Settings): Stats;
+//# sourceMappingURL=sync.d.ts.map
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/sync.js b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/sync.js
new file mode 100644
index 0000000..6200dcc
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/providers/sync.js
@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function read(path, settings) {
+ const lstat = settings.fs.lstatSync(path);
+ if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+ return lstat;
+ }
+ try {
+ const stat = settings.fs.statSync(path);
+ if (settings.markSymbolicLink) {
+ stat.isSymbolicLink = () => true;
+ }
+ return stat;
+ }
+ catch (error) {
+ if (!settings.throwErrorOnBrokenSymbolicLink) {
+ return lstat;
+ }
+ throw error;
+ }
+}
+exports.read = read;
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/settings.d.ts b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/settings.d.ts
new file mode 100644
index 0000000..a7fd1b4
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/settings.d.ts
@@ -0,0 +1,17 @@
+import * as fs from './adapters/fs';
+export declare type Options = {
+ followSymbolicLink?: boolean;
+ fs?: Partial<fs.FileSystemAdapter>;
+ markSymbolicLink?: boolean;
+ throwErrorOnBrokenSymbolicLink?: boolean;
+};
+export default class Settings {
+ private readonly _options;
+ readonly followSymbolicLink: boolean;
+ readonly fs: fs.FileSystemAdapter;
+ readonly markSymbolicLink: boolean;
+ readonly throwErrorOnBrokenSymbolicLink: boolean;
+ constructor(_options?: Options);
+ private _getValue;
+}
+//# sourceMappingURL=settings.d.ts.map
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/settings.js b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/settings.js
new file mode 100644
index 0000000..d3603a3
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/settings.js
@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("./adapters/fs");
+class Settings {
+ constructor(_options = {}) {
+ this._options = _options;
+ this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
+ this.fs = fs.createFileSystemAdapter(this._options.fs);
+ this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
+ this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+ }
+ _getValue(option, value) {
+ return option === undefined ? value : option;
+ }
+}
+exports.default = Settings;
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/types/index.d.ts b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/types/index.d.ts
new file mode 100644
index 0000000..0f34b09
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/types/index.d.ts
@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export declare type Stats = fs.Stats;
+export declare type ErrnoException = NodeJS.ErrnoException;
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/types/index.js b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/types/index.js
new file mode 100644
index 0000000..c8ad2e5
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/out/types/index.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/imagemin/node_modules/@nodelib/fs.stat/package.json b/node_modules/imagemin/node_modules/@nodelib/fs.stat/package.json
new file mode 100644
index 0000000..20f7716
--- /dev/null
+++ b/node_modules/imagemin/node_modules/@nodelib/fs.stat/package.json
@@ -0,0 +1,58 @@
+{
+ "_from": "@nodelib/fs.stat@^2.0.2",
+ "_id": "@nodelib/fs.stat@2.0.3",
+ "_inBundle": false,
+ "_integrity": "sha512-bQBFruR2TAwoevBEd/NWMoAAtNGzTRgdrqnYCc7dhzfoNvqPzLyqlEQnzZ3kVnNrSp25iyxE00/3h2fqGAGArA==",
+ "_location": "/imagemin/@nodelib/fs.stat",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "@nodelib/fs.stat@^2.0.2",
+ "name": "@nodelib/fs.stat",
+ "escapedName": "@nodelib%2ffs.stat",
+ "scope": "@nodelib",
+ "rawSpec": "^2.0.2",
+ "saveSpec": null,
+ "fetchSpec": "^2.0.2"
+ },
+ "_requiredBy": [
+ "/imagemin/fast-glob"
+ ],
+ "_resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.3.tgz",
+ "_shasum": "34dc5f4cabbc720f4e60f75a747e7ecd6c175bd3",
+ "_spec": "@nodelib/fs.stat@^2.0.2",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\fast-glob",
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Get the status of a file with some features",
+ "engines": {
+ "node": ">= 8"
+ },
+ "gitHead": "3b1ef7554ad7c061b3580858101d483fba847abf",
+ "keywords": [
+ "NodeLib",
+ "fs",
+ "FileSystem",
+ "file system",
+ "stat"
+ ],
+ "license": "MIT",
+ "main": "out/index.js",
+ "name": "@nodelib/fs.stat",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.stat"
+ },
+ "scripts": {
+ "build": "npm run clean && npm run compile && npm run lint && npm test",
+ "clean": "rimraf {tsconfig.tsbuildinfo,out}",
+ "compile": "tsc -b .",
+ "compile:watch": "tsc -p . --watch --sourceMap",
+ "lint": "eslint \"src/**/*.ts\" --cache",
+ "test": "mocha \"out/**/*.spec.js\" -s 0",
+ "watch": "npm run clean && npm run compile:watch"
+ },
+ "typings": "out/index.d.ts",
+ "version": "2.0.3"
+}
diff --git a/node_modules/imagemin/node_modules/array-union/index.d.ts b/node_modules/imagemin/node_modules/array-union/index.d.ts
new file mode 100644
index 0000000..379fc1d
--- /dev/null
+++ b/node_modules/imagemin/node_modules/array-union/index.d.ts
@@ -0,0 +1,25 @@
+/**
+Create an array of unique values, in order, from the input arrays.
+
+@example
+```
+import arrayUnion = require('array-union');
+
+arrayUnion([1, 1, 2, 3], [2, 3]);
+//=> [1, 2, 3]
+
+arrayUnion(['foo', 'foo', 'bar']);
+//=> ['foo', 'bar']
+
+arrayUnion(['🐱', '🦄', '🐻'], ['🦄', '🌈']);
+//=> ['🐱', '🦄', '🐻', '🌈']
+
+arrayUnion(['🐱', '🦄'], ['🐻', '🦄'], ['🐶', '🌈', '🌈']);
+//=> ['🐱', '🦄', '🐻', '🐶', '🌈']
+```
+*/
+declare function arrayUnion<ArgumentsType extends readonly unknown[]>(
+ ...arguments: readonly ArgumentsType[]
+): ArgumentsType;
+
+export = arrayUnion;
diff --git a/node_modules/imagemin/node_modules/array-union/index.js b/node_modules/imagemin/node_modules/array-union/index.js
new file mode 100644
index 0000000..7f85d3d
--- /dev/null
+++ b/node_modules/imagemin/node_modules/array-union/index.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (...arguments_) => {
+ return [...new Set([].concat(...arguments_))];
+};
diff --git a/node_modules/imagemin/node_modules/array-union/license b/node_modules/imagemin/node_modules/array-union/license
new file mode 100644
index 0000000..e7af2f7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/array-union/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/array-union/package.json b/node_modules/imagemin/node_modules/array-union/package.json
new file mode 100644
index 0000000..a28a0cd
--- /dev/null
+++ b/node_modules/imagemin/node_modules/array-union/package.json
@@ -0,0 +1,70 @@
+{
+ "_from": "array-union@^2.1.0",
+ "_id": "array-union@2.1.0",
+ "_inBundle": false,
+ "_integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
+ "_location": "/imagemin/array-union",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "array-union@^2.1.0",
+ "name": "array-union",
+ "escapedName": "array-union",
+ "rawSpec": "^2.1.0",
+ "saveSpec": null,
+ "fetchSpec": "^2.1.0"
+ },
+ "_requiredBy": [
+ "/imagemin/globby"
+ ],
+ "_resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
+ "_shasum": "b798420adbeb1de828d84acd8a2e23d3efe85e8d",
+ "_spec": "array-union@^2.1.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\globby",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "bugs": {
+ "url": "https://github.com/sindresorhus/array-union/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Create an array of unique values, in order, from the input arrays",
+ "devDependencies": {
+ "ava": "^1.4.1",
+ "tsd": "^0.7.2",
+ "xo": "^0.24.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js",
+ "index.d.ts"
+ ],
+ "homepage": "https://github.com/sindresorhus/array-union#readme",
+ "keywords": [
+ "array",
+ "set",
+ "uniq",
+ "unique",
+ "duplicate",
+ "remove",
+ "union",
+ "combine",
+ "merge"
+ ],
+ "license": "MIT",
+ "name": "array-union",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/sindresorhus/array-union.git"
+ },
+ "scripts": {
+ "test": "xo && ava && tsd"
+ },
+ "version": "2.1.0"
+}
diff --git a/node_modules/imagemin/node_modules/array-union/readme.md b/node_modules/imagemin/node_modules/array-union/readme.md
new file mode 100644
index 0000000..2474a1a
--- /dev/null
+++ b/node_modules/imagemin/node_modules/array-union/readme.md
@@ -0,0 +1,34 @@
+# array-union [](https://travis-ci.org/sindresorhus/array-union)
+
+> Create an array of unique values, in order, from the input arrays
+
+
+## Install
+
+```
+$ npm install array-union
+```
+
+
+## Usage
+
+```js
+const arrayUnion = require('array-union');
+
+arrayUnion([1, 1, 2, 3], [2, 3]);
+//=> [1, 2, 3]
+
+arrayUnion(['foo', 'foo', 'bar']);
+//=> ['foo', 'bar']
+
+arrayUnion(['🐱', '🦄', '🐻'], ['🦄', '🌈']);
+//=> ['🐱', '🦄', '🐻', '🌈']
+
+arrayUnion(['🐱', '🦄'], ['🐻', '🦄'], ['🐶', '🌈', '🌈']);
+//=> ['🐱', '🦄', '🐻', '🐶', '🌈']
+```
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)
diff --git a/node_modules/imagemin/node_modules/braces/CHANGELOG.md b/node_modules/imagemin/node_modules/braces/CHANGELOG.md
new file mode 100644
index 0000000..36f798b
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/CHANGELOG.md
@@ -0,0 +1,184 @@
+# Release history
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+<details>
+ <summary><strong>Guiding Principles</strong></summary>
+
+- Changelogs are for humans, not machines.
+- There should be an entry for every single version.
+- The same types of changes should be grouped.
+- Versions and sections should be linkable.
+- The latest version comes first.
+- The release date of each versions is displayed.
+- Mention whether you follow Semantic Versioning.
+
+</details>
+
+<details>
+ <summary><strong>Types of changes</strong></summary>
+
+Changelog entries are classified using the following labels _(from [keep-a-changelog](http://keepachangelog.com/)_):
+
+- `Added` for new features.
+- `Changed` for changes in existing functionality.
+- `Deprecated` for soon-to-be removed features.
+- `Removed` for now removed features.
+- `Fixed` for any bug fixes.
+- `Security` in case of vulnerabilities.
+
+</details>
+
+## [3.0.0] - 2018-04-08
+
+v3.0 is a complete refactor, resulting in a faster, smaller codebase, with fewer deps, and a more accurate parser and compiler.
+
+**Breaking Changes**
+
+- The undocumented `.makeRe` method was removed
+
+**Non-breaking changes**
+
+- Caching was removed
+
+## [2.3.2] - 2018-04-08
+
+- start refactoring
+- cover sets
+- better range handling
+
+## [2.3.1] - 2018-02-17
+
+- Remove unnecessary escape in Regex. (#14)
+
+## [2.3.0] - 2017-10-19
+
+- minor code reorganization
+- optimize regex
+- expose `maxLength` option
+
+## [2.2.1] - 2017-05-30
+
+- don't condense when braces contain extglobs
+
+## [2.2.0] - 2017-05-28
+
+- ensure word boundaries are preserved
+- fixes edge case where extglob characters precede a brace pattern
+
+## [2.1.1] - 2017-04-27
+
+- use snapdragon-node
+- handle edge case
+- optimizations, lint
+
+## [2.0.4] - 2017-04-11
+
+- pass opts to compiler
+- minor optimization in create method
+- re-write parser handlers to remove negation regex
+
+## [2.0.3] - 2016-12-10
+
+- use split-string
+- clear queue at the end
+- adds sequences example
+- add unit tests
+
+## [2.0.2] - 2016-10-21
+
+- fix comma handling in nested extglobs
+
+## [2.0.1] - 2016-10-20
+
+- add comments
+- more tests, ensure quotes are stripped
+
+## [2.0.0] - 2016-10-19
+
+- don't expand braces inside character classes
+- add quantifier pattern
+
+## [1.8.5] - 2016-05-21
+
+- Refactor (#10)
+
+## [1.8.4] - 2016-04-20
+
+- fixes https://github.com/jonschlinkert/micromatch/issues/66
+
+## [1.8.0] - 2015-03-18
+
+- adds exponent examples, tests
+- fixes the first example in https://github.com/jonschlinkert/micromatch/issues/38
+
+## [1.6.0] - 2015-01-30
+
+- optimizations, `bash` mode:
+- improve path escaping
+
+## [1.5.0] - 2015-01-28
+
+- Merge pull request #5 from eush77/lib-files
+
+## [1.4.0] - 2015-01-24
+
+- add extglob tests
+- externalize exponent function
+- better whitespace handling
+
+## [1.3.0] - 2015-01-24
+
+- make regex patterns explicity
+
+## [1.1.0] - 2015-01-11
+
+- don't create a match group with `makeRe`
+
+## [1.0.0] - 2014-12-23
+
+- Merge commit '97b05f5544f8348736a8efaecf5c32bbe3e2ad6e'
+- support empty brace syntax
+- better bash coverage
+- better support for regex strings
+
+## [0.1.4] - 2014-11-14
+
+- improve recognition of bad args, recognize mismatched argument types
+- support escaping
+- remove pathname-expansion
+- support whitespace in patterns
+
+## [0.1.0]
+
+- first commit
+
+[2.3.2]: https://github.com/micromatch/braces/compare/2.3.1...2.3.2
+[2.3.1]: https://github.com/micromatch/braces/compare/2.3.0...2.3.1
+[2.3.0]: https://github.com/micromatch/braces/compare/2.2.1...2.3.0
+[2.2.1]: https://github.com/micromatch/braces/compare/2.2.0...2.2.1
+[2.2.0]: https://github.com/micromatch/braces/compare/2.1.1...2.2.0
+[2.1.1]: https://github.com/micromatch/braces/compare/2.1.0...2.1.1
+[2.1.0]: https://github.com/micromatch/braces/compare/2.0.4...2.1.0
+[2.0.4]: https://github.com/micromatch/braces/compare/2.0.3...2.0.4
+[2.0.3]: https://github.com/micromatch/braces/compare/2.0.2...2.0.3
+[2.0.2]: https://github.com/micromatch/braces/compare/2.0.1...2.0.2
+[2.0.1]: https://github.com/micromatch/braces/compare/2.0.0...2.0.1
+[2.0.0]: https://github.com/micromatch/braces/compare/1.8.5...2.0.0
+[1.8.5]: https://github.com/micromatch/braces/compare/1.8.4...1.8.5
+[1.8.4]: https://github.com/micromatch/braces/compare/1.8.0...1.8.4
+[1.8.0]: https://github.com/micromatch/braces/compare/1.6.0...1.8.0
+[1.6.0]: https://github.com/micromatch/braces/compare/1.5.0...1.6.0
+[1.5.0]: https://github.com/micromatch/braces/compare/1.4.0...1.5.0
+[1.4.0]: https://github.com/micromatch/braces/compare/1.3.0...1.4.0
+[1.3.0]: https://github.com/micromatch/braces/compare/1.2.0...1.3.0
+[1.2.0]: https://github.com/micromatch/braces/compare/1.1.0...1.2.0
+[1.1.0]: https://github.com/micromatch/braces/compare/1.0.0...1.1.0
+[1.0.0]: https://github.com/micromatch/braces/compare/0.1.4...1.0.0
+[0.1.4]: https://github.com/micromatch/braces/compare/0.1.0...0.1.4
+
+[Unreleased]: https://github.com/micromatch/braces/compare/0.1.0...HEAD
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/braces/LICENSE b/node_modules/imagemin/node_modules/braces/LICENSE
new file mode 100644
index 0000000..d32ab44
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2018, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/braces/README.md b/node_modules/imagemin/node_modules/braces/README.md
new file mode 100644
index 0000000..cba2f60
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/README.md
@@ -0,0 +1,593 @@
+# braces [](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [](https://www.npmjs.com/package/braces) [](https://npmjs.org/package/braces) [](https://npmjs.org/package/braces) [](https://travis-ci.org/micromatch/braces)
+
+> Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save braces
+```
+
+## v3.0.0 Released!!
+
+See the [changelog](CHANGELOG.md) for details.
+
+## Why use braces?
+
+Brace patterns make globs more powerful by adding the ability to match specific ranges and sequences of characters.
+
+* **Accurate** - complete support for the [Bash 4.3 Brace Expansion](www.gnu.org/software/bash/) specification (passes all of the Bash braces tests)
+* **[fast and performant](#benchmarks)** - Starts fast, runs fast and [scales well](#performance) as patterns increase in complexity.
+* **Organized code base** - The parser and compiler are easy to maintain and update when edge cases crop up.
+* **Well-tested** - Thousands of test assertions, and passes all of the Bash, minimatch, and [brace-expansion](https://github.com/juliangruber/brace-expansion) unit tests (as of the date this was written).
+* **Safer** - You shouldn't have to worry about users defining aggressive or malicious brace patterns that can break your application. Braces takes measures to prevent malicious regex that can be used for DDoS attacks (see [catastrophic backtracking](https://www.regular-expressions.info/catastrophic.html)).
+* [Supports lists](#lists) - (aka "sets") `a/{b,c}/d` => `['a/b/d', 'a/c/d']`
+* [Supports sequences](#sequences) - (aka "ranges") `{01..03}` => `['01', '02', '03']`
+* [Supports steps](#steps) - (aka "increments") `{2..10..2}` => `['2', '4', '6', '8', '10']`
+* [Supports escaping](#escaping) - To prevent evaluation of special characters.
+
+## Usage
+
+The main export is a function that takes one or more brace `patterns` and `options`.
+
+```js
+const braces = require('braces');
+// braces(patterns[, options]);
+
+console.log(braces(['{01..05}', '{a..e}']));
+//=> ['(0[1-5])', '([a-e])']
+
+console.log(braces(['{01..05}', '{a..e}'], { expand: true }));
+//=> ['01', '02', '03', '04', '05', 'a', 'b', 'c', 'd', 'e']
+```
+
+### Brace Expansion vs. Compilation
+
+By default, brace patterns are compiled into strings that are optimized for creating regular expressions and matching.
+
+**Compiled**
+
+```js
+console.log(braces('a/{x,y,z}/b'));
+//=> ['a/(x|y|z)/b']
+console.log(braces(['a/{01..20}/b', 'a/{1..5}/b']));
+//=> [ 'a/(0[1-9]|1[0-9]|20)/b', 'a/([1-5])/b' ]
+```
+
+**Expanded**
+
+Enable brace expansion by setting the `expand` option to true, or by using [braces.expand()](#expand) (returns an array similar to what you'd expect from Bash, or `echo {1..5}`, or [minimatch](https://github.com/isaacs/minimatch)):
+
+```js
+console.log(braces('a/{x,y,z}/b', { expand: true }));
+//=> ['a/x/b', 'a/y/b', 'a/z/b']
+
+console.log(braces.expand('{01..10}'));
+//=> ['01','02','03','04','05','06','07','08','09','10']
+```
+
+### Lists
+
+Expand lists (like Bash "sets"):
+
+```js
+console.log(braces('a/{foo,bar,baz}/*.js'));
+//=> ['a/(foo|bar|baz)/*.js']
+
+console.log(braces.expand('a/{foo,bar,baz}/*.js'));
+//=> ['a/foo/*.js', 'a/bar/*.js', 'a/baz/*.js']
+```
+
+### Sequences
+
+Expand ranges of characters (like Bash "sequences"):
+
+```js
+console.log(braces.expand('{1..3}')); // ['1', '2', '3']
+console.log(braces.expand('a/{1..3}/b')); // ['a/1/b', 'a/2/b', 'a/3/b']
+console.log(braces('{a..c}', { expand: true })); // ['a', 'b', 'c']
+console.log(braces('foo/{a..c}', { expand: true })); // ['foo/a', 'foo/b', 'foo/c']
+
+// supports zero-padded ranges
+console.log(braces('a/{01..03}/b')); //=> ['a/(0[1-3])/b']
+console.log(braces('a/{001..300}/b')); //=> ['a/(0{2}[1-9]|0[1-9][0-9]|[12][0-9]{2}|300)/b']
+```
+
+See [fill-range](https://github.com/jonschlinkert/fill-range) for all available range-expansion options.
+
+### Steppped ranges
+
+Steps, or increments, may be used with ranges:
+
+```js
+console.log(braces.expand('{2..10..2}'));
+//=> ['2', '4', '6', '8', '10']
+
+console.log(braces('{2..10..2}'));
+//=> ['(2|4|6|8|10)']
+```
+
+When the [.optimize](#optimize) method is used, or [options.optimize](#optionsoptimize) is set to true, sequences are passed to [to-regex-range](https://github.com/jonschlinkert/to-regex-range) for expansion.
+
+### Nesting
+
+Brace patterns may be nested. The results of each expanded string are not sorted, and left to right order is preserved.
+
+**"Expanded" braces**
+
+```js
+console.log(braces.expand('a{b,c,/{x,y}}/e'));
+//=> ['ab/e', 'ac/e', 'a/x/e', 'a/y/e']
+
+console.log(braces.expand('a/{x,{1..5},y}/c'));
+//=> ['a/x/c', 'a/1/c', 'a/2/c', 'a/3/c', 'a/4/c', 'a/5/c', 'a/y/c']
+```
+
+**"Optimized" braces**
+
+```js
+console.log(braces('a{b,c,/{x,y}}/e'));
+//=> ['a(b|c|/(x|y))/e']
+
+console.log(braces('a/{x,{1..5},y}/c'));
+//=> ['a/(x|([1-5])|y)/c']
+```
+
+### Escaping
+
+**Escaping braces**
+
+A brace pattern will not be expanded or evaluted if _either the opening or closing brace is escaped_:
+
+```js
+console.log(braces.expand('a\\{d,c,b}e'));
+//=> ['a{d,c,b}e']
+
+console.log(braces.expand('a{d,c,b\\}e'));
+//=> ['a{d,c,b}e']
+```
+
+**Escaping commas**
+
+Commas inside braces may also be escaped:
+
+```js
+console.log(braces.expand('a{b\\,c}d'));
+//=> ['a{b,c}d']
+
+console.log(braces.expand('a{d\\,c,b}e'));
+//=> ['ad,ce', 'abe']
+```
+
+**Single items**
+
+Following bash conventions, a brace pattern is also not expanded when it contains a single character:
+
+```js
+console.log(braces.expand('a{b}c'));
+//=> ['a{b}c']
+```
+
+## Options
+
+### options.maxLength
+
+**Type**: `Number`
+
+**Default**: `65,536`
+
+**Description**: Limit the length of the input string. Useful when the input string is generated or your application allows users to pass a string, et cetera.
+
+```js
+console.log(braces('a/{b,c}/d', { maxLength: 3 })); //=> throws an error
+```
+
+### options.expand
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: Generate an "expanded" brace pattern (alternatively you can use the `braces.expand()` method, which does the same thing).
+
+```js
+console.log(braces('a/{b,c}/d', { expand: true }));
+//=> [ 'a/b/d', 'a/c/d' ]
+```
+
+### options.nodupes
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: Remove duplicates from the returned array.
+
+### options.rangeLimit
+
+**Type**: `Number`
+
+**Default**: `1000`
+
+**Description**: To prevent malicious patterns from being passed by users, an error is thrown when `braces.expand()` is used or `options.expand` is true and the generated range will exceed the `rangeLimit`.
+
+You can customize `options.rangeLimit` or set it to `Inifinity` to disable this altogether.
+
+**Examples**
+
+```js
+// pattern exceeds the "rangeLimit", so it's optimized automatically
+console.log(braces.expand('{1..1000}'));
+//=> ['([1-9]|[1-9][0-9]{1,2}|1000)']
+
+// pattern does not exceed "rangeLimit", so it's NOT optimized
+console.log(braces.expand('{1..100}'));
+//=> ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '100']
+```
+
+### options.transform
+
+**Type**: `Function`
+
+**Default**: `undefined`
+
+**Description**: Customize range expansion.
+
+**Example: Transforming non-numeric values**
+
+```js
+const alpha = braces.expand('x/{a..e}/y', {
+ transform(value, index) {
+ // When non-numeric values are passed, "value" is a character code.
+ return 'foo/' + String.fromCharCode(value) + '-' + index;
+ }
+});
+console.log(alpha);
+//=> [ 'x/foo/a-0/y', 'x/foo/b-1/y', 'x/foo/c-2/y', 'x/foo/d-3/y', 'x/foo/e-4/y' ]
+```
+
+**Example: Transforming numeric values**
+
+```js
+const numeric = braces.expand('{1..5}', {
+ transform(value) {
+ // when numeric values are passed, "value" is a number
+ return 'foo/' + value * 2;
+ }
+});
+console.log(numeric);
+//=> [ 'foo/2', 'foo/4', 'foo/6', 'foo/8', 'foo/10' ]
+```
+
+### options.quantifiers
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: In regular expressions, quanitifiers can be used to specify how many times a token can be repeated. For example, `a{1,3}` will match the letter `a` one to three times.
+
+Unfortunately, regex quantifiers happen to share the same syntax as [Bash lists](#lists)
+
+The `quantifiers` option tells braces to detect when [regex quantifiers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#quantifiers) are defined in the given pattern, and not to try to expand them as lists.
+
+**Examples**
+
+```js
+const braces = require('braces');
+console.log(braces('a/b{1,3}/{x,y,z}'));
+//=> [ 'a/b(1|3)/(x|y|z)' ]
+console.log(braces('a/b{1,3}/{x,y,z}', {quantifiers: true}));
+//=> [ 'a/b{1,3}/(x|y|z)' ]
+console.log(braces('a/b{1,3}/{x,y,z}', {quantifiers: true, expand: true}));
+//=> [ 'a/b{1,3}/x', 'a/b{1,3}/y', 'a/b{1,3}/z' ]
+```
+
+### options.unescape
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Description**: Strip backslashes that were used for escaping from the result.
+
+## What is "brace expansion"?
+
+Brace expansion is a type of parameter expansion that was made popular by unix shells for generating lists of strings, as well as regex-like matching when used alongside wildcards (globs).
+
+In addition to "expansion", braces are also used for matching. In other words:
+
+* [brace expansion](#brace-expansion) is for generating new lists
+* [brace matching](#brace-matching) is for filtering existing lists
+
+<details>
+<summary><strong>More about brace expansion</strong> (click to expand)</summary>
+
+There are two main types of brace expansion:
+
+1. **lists**: which are defined using comma-separated values inside curly braces: `{a,b,c}`
+2. **sequences**: which are defined using a starting value and an ending value, separated by two dots: `a{1..3}b`. Optionally, a third argument may be passed to define a "step" or increment to use: `a{1..100..10}b`. These are also sometimes referred to as "ranges".
+
+Here are some example brace patterns to illustrate how they work:
+
+**Sets**
+
+```
+{a,b,c} => a b c
+{a,b,c}{1,2} => a1 a2 b1 b2 c1 c2
+```
+
+**Sequences**
+
+```
+{1..9} => 1 2 3 4 5 6 7 8 9
+{4..-4} => 4 3 2 1 0 -1 -2 -3 -4
+{1..20..3} => 1 4 7 10 13 16 19
+{a..j} => a b c d e f g h i j
+{j..a} => j i h g f e d c b a
+{a..z..3} => a d g j m p s v y
+```
+
+**Combination**
+
+Sets and sequences can be mixed together or used along with any other strings.
+
+```
+{a,b,c}{1..3} => a1 a2 a3 b1 b2 b3 c1 c2 c3
+foo/{a,b,c}/bar => foo/a/bar foo/b/bar foo/c/bar
+```
+
+The fact that braces can be "expanded" from relatively simple patterns makes them ideal for quickly generating test fixtures, file paths, and similar use cases.
+
+## Brace matching
+
+In addition to _expansion_, brace patterns are also useful for performing regular-expression-like matching.
+
+For example, the pattern `foo/{1..3}/bar` would match any of following strings:
+
+```
+foo/1/bar
+foo/2/bar
+foo/3/bar
+```
+
+But not:
+
+```
+baz/1/qux
+baz/2/qux
+baz/3/qux
+```
+
+Braces can also be combined with [glob patterns](https://github.com/jonschlinkert/micromatch) to perform more advanced wildcard matching. For example, the pattern `*/{1..3}/*` would match any of following strings:
+
+```
+foo/1/bar
+foo/2/bar
+foo/3/bar
+baz/1/qux
+baz/2/qux
+baz/3/qux
+```
+
+## Brace matching pitfalls
+
+Although brace patterns offer a user-friendly way of matching ranges or sets of strings, there are also some major disadvantages and potential risks you should be aware of.
+
+### tldr
+
+**"brace bombs"**
+
+* brace expansion can eat up a huge amount of processing resources
+* as brace patterns increase _linearly in size_, the system resources required to expand the pattern increase exponentially
+* users can accidentally (or intentially) exhaust your system's resources resulting in the equivalent of a DoS attack (bonus: no programming knowledge is required!)
+
+For a more detailed explanation with examples, see the [geometric complexity](#geometric-complexity) section.
+
+### The solution
+
+Jump to the [performance section](#performance) to see how Braces solves this problem in comparison to other libraries.
+
+### Geometric complexity
+
+At minimum, brace patterns with sets limited to two elements have quadradic or `O(n^2)` complexity. But the complexity of the algorithm increases exponentially as the number of sets, _and elements per set_, increases, which is `O(n^c)`.
+
+For example, the following sets demonstrate quadratic (`O(n^2)`) complexity:
+
+```
+{1,2}{3,4} => (2X2) => 13 14 23 24
+{1,2}{3,4}{5,6} => (2X2X2) => 135 136 145 146 235 236 245 246
+```
+
+But add an element to a set, and we get a n-fold Cartesian product with `O(n^c)` complexity:
+
+```
+{1,2,3}{4,5,6}{7,8,9} => (3X3X3) => 147 148 149 157 158 159 167 168 169 247 248
+ 249 257 258 259 267 268 269 347 348 349 357
+ 358 359 367 368 369
+```
+
+Now, imagine how this complexity grows given that each element is a n-tuple:
+
+```
+{1..100}{1..100} => (100X100) => 10,000 elements (38.4 kB)
+{1..100}{1..100}{1..100} => (100X100X100) => 1,000,000 elements (5.76 MB)
+```
+
+Although these examples are clearly contrived, they demonstrate how brace patterns can quickly grow out of control.
+
+**More information**
+
+Interested in learning more about brace expansion?
+
+* [linuxjournal/bash-brace-expansion](http://www.linuxjournal.com/content/bash-brace-expansion)
+* [rosettacode/Brace_expansion](https://rosettacode.org/wiki/Brace_expansion)
+* [cartesian product](https://en.wikipedia.org/wiki/Cartesian_product)
+
+</details>
+
+## Performance
+
+Braces is not only screaming fast, it's also more accurate the other brace expansion libraries.
+
+### Better algorithms
+
+Fortunately there is a solution to the ["brace bomb" problem](#brace-matching-pitfalls): _don't expand brace patterns into an array when they're used for matching_.
+
+Instead, convert the pattern into an optimized regular expression. This is easier said than done, and braces is the only library that does this currently.
+
+**The proof is in the numbers**
+
+Minimatch gets exponentially slower as patterns increase in complexity, braces does not. The following results were generated using `braces()` and `minimatch.braceExpand()`, respectively.
+
+| **Pattern** | **braces** | **[minimatch][]** |
+| --- | --- | --- |
+| `{1..9007199254740991}`[^1] | `298 B` (5ms 459μs)| N/A (freezes) |
+| `{1..1000000000000000}` | `41 B` (1ms 15μs) | N/A (freezes) |
+| `{1..100000000000000}` | `40 B` (890μs) | N/A (freezes) |
+| `{1..10000000000000}` | `39 B` (2ms 49μs) | N/A (freezes) |
+| `{1..1000000000000}` | `38 B` (608μs) | N/A (freezes) |
+| `{1..100000000000}` | `37 B` (397μs) | N/A (freezes) |
+| `{1..10000000000}` | `35 B` (983μs) | N/A (freezes) |
+| `{1..1000000000}` | `34 B` (798μs) | N/A (freezes) |
+| `{1..100000000}` | `33 B` (733μs) | N/A (freezes) |
+| `{1..10000000}` | `32 B` (5ms 632μs) | `78.89 MB` (16s 388ms 569μs) |
+| `{1..1000000}` | `31 B` (1ms 381μs) | `6.89 MB` (1s 496ms 887μs) |
+| `{1..100000}` | `30 B` (950μs) | `588.89 kB` (146ms 921μs) |
+| `{1..10000}` | `29 B` (1ms 114μs) | `48.89 kB` (14ms 187μs) |
+| `{1..1000}` | `28 B` (760μs) | `3.89 kB` (1ms 453μs) |
+| `{1..100}` | `22 B` (345μs) | `291 B` (196μs) |
+| `{1..10}` | `10 B` (533μs) | `20 B` (37μs) |
+| `{1..3}` | `7 B` (190μs) | `5 B` (27μs) |
+
+### Faster algorithms
+
+When you need expansion, braces is still much faster.
+
+_(the following results were generated using `braces.expand()` and `minimatch.braceExpand()`, respectively)_
+
+| **Pattern** | **braces** | **[minimatch][]** |
+| --- | --- | --- |
+| `{1..10000000}` | `78.89 MB` (2s 698ms 642μs) | `78.89 MB` (18s 601ms 974μs) |
+| `{1..1000000}` | `6.89 MB` (458ms 576μs) | `6.89 MB` (1s 491ms 621μs) |
+| `{1..100000}` | `588.89 kB` (20ms 728μs) | `588.89 kB` (156ms 919μs) |
+| `{1..10000}` | `48.89 kB` (2ms 202μs) | `48.89 kB` (13ms 641μs) |
+| `{1..1000}` | `3.89 kB` (1ms 796μs) | `3.89 kB` (1ms 958μs) |
+| `{1..100}` | `291 B` (424μs) | `291 B` (211μs) |
+| `{1..10}` | `20 B` (487μs) | `20 B` (72μs) |
+| `{1..3}` | `5 B` (166μs) | `5 B` (27μs) |
+
+If you'd like to run these comparisons yourself, see [test/support/generate.js](test/support/generate.js).
+
+## Benchmarks
+
+### Running benchmarks
+
+Install dev dependencies:
+
+```bash
+npm i -d && npm benchmark
+```
+
+### Latest results
+
+Braces is more accurate, without sacrificing performance.
+
+```bash
+# range (expanded)
+ braces x 29,040 ops/sec ±3.69% (91 runs sampled))
+ minimatch x 4,735 ops/sec ±1.28% (90 runs sampled)
+
+# range (optimized for regex)
+ braces x 382,878 ops/sec ±0.56% (94 runs sampled)
+ minimatch x 1,040 ops/sec ±0.44% (93 runs sampled)
+
+# nested ranges (expanded)
+ braces x 19,744 ops/sec ±2.27% (92 runs sampled))
+ minimatch x 4,579 ops/sec ±0.50% (93 runs sampled)
+
+# nested ranges (optimized for regex)
+ braces x 246,019 ops/sec ±2.02% (93 runs sampled)
+ minimatch x 1,028 ops/sec ±0.39% (94 runs sampled)
+
+# set (expanded)
+ braces x 138,641 ops/sec ±0.53% (95 runs sampled)
+ minimatch x 219,582 ops/sec ±0.98% (94 runs sampled)
+
+# set (optimized for regex)
+ braces x 388,408 ops/sec ±0.41% (95 runs sampled)
+ minimatch x 44,724 ops/sec ±0.91% (89 runs sampled)
+
+# nested sets (expanded)
+ braces x 84,966 ops/sec ±0.48% (94 runs sampled)
+ minimatch x 140,720 ops/sec ±0.37% (95 runs sampled)
+
+# nested sets (optimized for regex)
+ braces x 263,340 ops/sec ±2.06% (92 runs sampled)
+ minimatch x 28,714 ops/sec ±0.40% (90 runs sampled)
+```
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 197 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 4 | [doowb](https://github.com/doowb) |
+| 1 | [es128](https://github.com/es128) |
+| 1 | [eush77](https://github.com/eush77) |
+| 1 | [hemanth](https://github.com/hemanth) |
+| 1 | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 08, 2019._
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/braces/index.js b/node_modules/imagemin/node_modules/braces/index.js
new file mode 100644
index 0000000..0eee0f5
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/index.js
@@ -0,0 +1,170 @@
+'use strict';
+
+const stringify = require('./lib/stringify');
+const compile = require('./lib/compile');
+const expand = require('./lib/expand');
+const parse = require('./lib/parse');
+
+/**
+ * Expand the given pattern or create a regex-compatible string.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+ * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
+ */
+
+const braces = (input, options = {}) => {
+ let output = [];
+
+ if (Array.isArray(input)) {
+ for (let pattern of input) {
+ let result = braces.create(pattern, options);
+ if (Array.isArray(result)) {
+ output.push(...result);
+ } else {
+ output.push(result);
+ }
+ }
+ } else {
+ output = [].concat(braces.create(input, options));
+ }
+
+ if (options && options.expand === true && options.nodupes === true) {
+ output = [...new Set(output)];
+ }
+ return output;
+};
+
+/**
+ * Parse the given `str` with the given `options`.
+ *
+ * ```js
+ * // braces.parse(pattern, [, options]);
+ * const ast = braces.parse('a/{b,c}/d');
+ * console.log(ast);
+ * ```
+ * @param {String} pattern Brace pattern to parse
+ * @param {Object} options
+ * @return {Object} Returns an AST
+ * @api public
+ */
+
+braces.parse = (input, options = {}) => parse(input, options);
+
+/**
+ * Creates a braces string from an AST, or an AST node.
+ *
+ * ```js
+ * const braces = require('braces');
+ * let ast = braces.parse('foo/{a,b}/bar');
+ * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.stringify = (input, options = {}) => {
+ if (typeof input === 'string') {
+ return stringify(braces.parse(input, options), options);
+ }
+ return stringify(input, options);
+};
+
+/**
+ * Compiles a brace pattern into a regex-compatible, optimized string.
+ * This method is called by the main [braces](#braces) function by default.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.compile('a/{b,c}/d'));
+ * //=> ['a/(b|c)/d']
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.compile = (input, options = {}) => {
+ if (typeof input === 'string') {
+ input = braces.parse(input, options);
+ }
+ return compile(input, options);
+};
+
+/**
+ * Expands a brace pattern into an array. This method is called by the
+ * main [braces](#braces) function when `options.expand` is true. Before
+ * using this method it's recommended that you read the [performance notes](#performance))
+ * and advantages of using [.compile](#compile) instead.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.expand('a/{b,c}/d'));
+ * //=> ['a/b/d', 'a/c/d'];
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.expand = (input, options = {}) => {
+ if (typeof input === 'string') {
+ input = braces.parse(input, options);
+ }
+
+ let result = expand(input, options);
+
+ // filter out empty strings if specified
+ if (options.noempty === true) {
+ result = result.filter(Boolean);
+ }
+
+ // filter out duplicates if specified
+ if (options.nodupes === true) {
+ result = [...new Set(result)];
+ }
+
+ return result;
+};
+
+/**
+ * Processes a brace pattern and returns either an expanded array
+ * (if `options.expand` is true), a highly optimized regex-compatible string.
+ * This method is called by the main [braces](#braces) function.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+ * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.create = (input, options = {}) => {
+ if (input === '' || input.length < 3) {
+ return [input];
+ }
+
+ return options.expand !== true
+ ? braces.compile(input, options)
+ : braces.expand(input, options);
+};
+
+/**
+ * Expose "braces"
+ */
+
+module.exports = braces;
diff --git a/node_modules/imagemin/node_modules/braces/lib/compile.js b/node_modules/imagemin/node_modules/braces/lib/compile.js
new file mode 100644
index 0000000..3e984a4
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/lib/compile.js
@@ -0,0 +1,57 @@
+'use strict';
+
+const fill = require('fill-range');
+const utils = require('./utils');
+
+const compile = (ast, options = {}) => {
+ let walk = (node, parent = {}) => {
+ let invalidBlock = utils.isInvalidBrace(parent);
+ let invalidNode = node.invalid === true && options.escapeInvalid === true;
+ let invalid = invalidBlock === true || invalidNode === true;
+ let prefix = options.escapeInvalid === true ? '\\' : '';
+ let output = '';
+
+ if (node.isOpen === true) {
+ return prefix + node.value;
+ }
+ if (node.isClose === true) {
+ return prefix + node.value;
+ }
+
+ if (node.type === 'open') {
+ return invalid ? (prefix + node.value) : '(';
+ }
+
+ if (node.type === 'close') {
+ return invalid ? (prefix + node.value) : ')';
+ }
+
+ if (node.type === 'comma') {
+ return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
+ }
+
+ if (node.value) {
+ return node.value;
+ }
+
+ if (node.nodes && node.ranges > 0) {
+ let args = utils.reduce(node.nodes);
+ let range = fill(...args, { ...options, wrap: false, toRegex: true });
+
+ if (range.length !== 0) {
+ return args.length > 1 && range.length > 1 ? `(${range})` : range;
+ }
+ }
+
+ if (node.nodes) {
+ for (let child of node.nodes) {
+ output += walk(child, node);
+ }
+ }
+ return output;
+ };
+
+ return walk(ast);
+};
+
+module.exports = compile;
diff --git a/node_modules/imagemin/node_modules/braces/lib/constants.js b/node_modules/imagemin/node_modules/braces/lib/constants.js
new file mode 100644
index 0000000..a937943
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/lib/constants.js
@@ -0,0 +1,57 @@
+'use strict';
+
+module.exports = {
+ MAX_LENGTH: 1024 * 64,
+
+ // Digits
+ CHAR_0: '0', /* 0 */
+ CHAR_9: '9', /* 9 */
+
+ // Alphabet chars.
+ CHAR_UPPERCASE_A: 'A', /* A */
+ CHAR_LOWERCASE_A: 'a', /* a */
+ CHAR_UPPERCASE_Z: 'Z', /* Z */
+ CHAR_LOWERCASE_Z: 'z', /* z */
+
+ CHAR_LEFT_PARENTHESES: '(', /* ( */
+ CHAR_RIGHT_PARENTHESES: ')', /* ) */
+
+ CHAR_ASTERISK: '*', /* * */
+
+ // Non-alphabetic chars.
+ CHAR_AMPERSAND: '&', /* & */
+ CHAR_AT: '@', /* @ */
+ CHAR_BACKSLASH: '\\', /* \ */
+ CHAR_BACKTICK: '`', /* ` */
+ CHAR_CARRIAGE_RETURN: '\r', /* \r */
+ CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
+ CHAR_COLON: ':', /* : */
+ CHAR_COMMA: ',', /* , */
+ CHAR_DOLLAR: '$', /* . */
+ CHAR_DOT: '.', /* . */
+ CHAR_DOUBLE_QUOTE: '"', /* " */
+ CHAR_EQUAL: '=', /* = */
+ CHAR_EXCLAMATION_MARK: '!', /* ! */
+ CHAR_FORM_FEED: '\f', /* \f */
+ CHAR_FORWARD_SLASH: '/', /* / */
+ CHAR_HASH: '#', /* # */
+ CHAR_HYPHEN_MINUS: '-', /* - */
+ CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
+ CHAR_LEFT_CURLY_BRACE: '{', /* { */
+ CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
+ CHAR_LINE_FEED: '\n', /* \n */
+ CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
+ CHAR_PERCENT: '%', /* % */
+ CHAR_PLUS: '+', /* + */
+ CHAR_QUESTION_MARK: '?', /* ? */
+ CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
+ CHAR_RIGHT_CURLY_BRACE: '}', /* } */
+ CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
+ CHAR_SEMICOLON: ';', /* ; */
+ CHAR_SINGLE_QUOTE: '\'', /* ' */
+ CHAR_SPACE: ' ', /* */
+ CHAR_TAB: '\t', /* \t */
+ CHAR_UNDERSCORE: '_', /* _ */
+ CHAR_VERTICAL_LINE: '|', /* | */
+ CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
+};
diff --git a/node_modules/imagemin/node_modules/braces/lib/expand.js b/node_modules/imagemin/node_modules/braces/lib/expand.js
new file mode 100644
index 0000000..376c748
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/lib/expand.js
@@ -0,0 +1,113 @@
+'use strict';
+
+const fill = require('fill-range');
+const stringify = require('./stringify');
+const utils = require('./utils');
+
+const append = (queue = '', stash = '', enclose = false) => {
+ let result = [];
+
+ queue = [].concat(queue);
+ stash = [].concat(stash);
+
+ if (!stash.length) return queue;
+ if (!queue.length) {
+ return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
+ }
+
+ for (let item of queue) {
+ if (Array.isArray(item)) {
+ for (let value of item) {
+ result.push(append(value, stash, enclose));
+ }
+ } else {
+ for (let ele of stash) {
+ if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
+ result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));
+ }
+ }
+ }
+ return utils.flatten(result);
+};
+
+const expand = (ast, options = {}) => {
+ let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
+
+ let walk = (node, parent = {}) => {
+ node.queue = [];
+
+ let p = parent;
+ let q = parent.queue;
+
+ while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
+ p = p.parent;
+ q = p.queue;
+ }
+
+ if (node.invalid || node.dollar) {
+ q.push(append(q.pop(), stringify(node, options)));
+ return;
+ }
+
+ if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
+ q.push(append(q.pop(), ['{}']));
+ return;
+ }
+
+ if (node.nodes && node.ranges > 0) {
+ let args = utils.reduce(node.nodes);
+
+ if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+ throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+ }
+
+ let range = fill(...args, options);
+ if (range.length === 0) {
+ range = stringify(node, options);
+ }
+
+ q.push(append(q.pop(), range));
+ node.nodes = [];
+ return;
+ }
+
+ let enclose = utils.encloseBrace(node);
+ let queue = node.queue;
+ let block = node;
+
+ while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
+ block = block.parent;
+ queue = block.queue;
+ }
+
+ for (let i = 0; i < node.nodes.length; i++) {
+ let child = node.nodes[i];
+
+ if (child.type === 'comma' && node.type === 'brace') {
+ if (i === 1) queue.push('');
+ queue.push('');
+ continue;
+ }
+
+ if (child.type === 'close') {
+ q.push(append(q.pop(), queue, enclose));
+ continue;
+ }
+
+ if (child.value && child.type !== 'open') {
+ queue.push(append(queue.pop(), child.value));
+ continue;
+ }
+
+ if (child.nodes) {
+ walk(child, node);
+ }
+ }
+
+ return queue;
+ };
+
+ return utils.flatten(walk(ast));
+};
+
+module.exports = expand;
diff --git a/node_modules/imagemin/node_modules/braces/lib/parse.js b/node_modules/imagemin/node_modules/braces/lib/parse.js
new file mode 100644
index 0000000..145ea26
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/lib/parse.js
@@ -0,0 +1,333 @@
+'use strict';
+
+const stringify = require('./stringify');
+
+/**
+ * Constants
+ */
+
+const {
+ MAX_LENGTH,
+ CHAR_BACKSLASH, /* \ */
+ CHAR_BACKTICK, /* ` */
+ CHAR_COMMA, /* , */
+ CHAR_DOT, /* . */
+ CHAR_LEFT_PARENTHESES, /* ( */
+ CHAR_RIGHT_PARENTHESES, /* ) */
+ CHAR_LEFT_CURLY_BRACE, /* { */
+ CHAR_RIGHT_CURLY_BRACE, /* } */
+ CHAR_LEFT_SQUARE_BRACKET, /* [ */
+ CHAR_RIGHT_SQUARE_BRACKET, /* ] */
+ CHAR_DOUBLE_QUOTE, /* " */
+ CHAR_SINGLE_QUOTE, /* ' */
+ CHAR_NO_BREAK_SPACE,
+ CHAR_ZERO_WIDTH_NOBREAK_SPACE
+} = require('./constants');
+
+/**
+ * parse
+ */
+
+const parse = (input, options = {}) => {
+ if (typeof input !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+
+ let opts = options || {};
+ let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+ if (input.length > max) {
+ throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+ }
+
+ let ast = { type: 'root', input, nodes: [] };
+ let stack = [ast];
+ let block = ast;
+ let prev = ast;
+ let brackets = 0;
+ let length = input.length;
+ let index = 0;
+ let depth = 0;
+ let value;
+ let memo = {};
+
+ /**
+ * Helpers
+ */
+
+ const advance = () => input[index++];
+ const push = node => {
+ if (node.type === 'text' && prev.type === 'dot') {
+ prev.type = 'text';
+ }
+
+ if (prev && prev.type === 'text' && node.type === 'text') {
+ prev.value += node.value;
+ return;
+ }
+
+ block.nodes.push(node);
+ node.parent = block;
+ node.prev = prev;
+ prev = node;
+ return node;
+ };
+
+ push({ type: 'bos' });
+
+ while (index < length) {
+ block = stack[stack.length - 1];
+ value = advance();
+
+ /**
+ * Invalid chars
+ */
+
+ if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
+ continue;
+ }
+
+ /**
+ * Escaped chars
+ */
+
+ if (value === CHAR_BACKSLASH) {
+ push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
+ continue;
+ }
+
+ /**
+ * Right square bracket (literal): ']'
+ */
+
+ if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+ push({ type: 'text', value: '\\' + value });
+ continue;
+ }
+
+ /**
+ * Left square bracket: '['
+ */
+
+ if (value === CHAR_LEFT_SQUARE_BRACKET) {
+ brackets++;
+
+ let closed = true;
+ let next;
+
+ while (index < length && (next = advance())) {
+ value += next;
+
+ if (next === CHAR_LEFT_SQUARE_BRACKET) {
+ brackets++;
+ continue;
+ }
+
+ if (next === CHAR_BACKSLASH) {
+ value += advance();
+ continue;
+ }
+
+ if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+ brackets--;
+
+ if (brackets === 0) {
+ break;
+ }
+ }
+ }
+
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Parentheses
+ */
+
+ if (value === CHAR_LEFT_PARENTHESES) {
+ block = push({ type: 'paren', nodes: [] });
+ stack.push(block);
+ push({ type: 'text', value });
+ continue;
+ }
+
+ if (value === CHAR_RIGHT_PARENTHESES) {
+ if (block.type !== 'paren') {
+ push({ type: 'text', value });
+ continue;
+ }
+ block = stack.pop();
+ push({ type: 'text', value });
+ block = stack[stack.length - 1];
+ continue;
+ }
+
+ /**
+ * Quotes: '|"|`
+ */
+
+ if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+ let open = value;
+ let next;
+
+ if (options.keepQuotes !== true) {
+ value = '';
+ }
+
+ while (index < length && (next = advance())) {
+ if (next === CHAR_BACKSLASH) {
+ value += next + advance();
+ continue;
+ }
+
+ if (next === open) {
+ if (options.keepQuotes === true) value += next;
+ break;
+ }
+
+ value += next;
+ }
+
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Left curly brace: '{'
+ */
+
+ if (value === CHAR_LEFT_CURLY_BRACE) {
+ depth++;
+
+ let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+ let brace = {
+ type: 'brace',
+ open: true,
+ close: false,
+ dollar,
+ depth,
+ commas: 0,
+ ranges: 0,
+ nodes: []
+ };
+
+ block = push(brace);
+ stack.push(block);
+ push({ type: 'open', value });
+ continue;
+ }
+
+ /**
+ * Right curly brace: '}'
+ */
+
+ if (value === CHAR_RIGHT_CURLY_BRACE) {
+ if (block.type !== 'brace') {
+ push({ type: 'text', value });
+ continue;
+ }
+
+ let type = 'close';
+ block = stack.pop();
+ block.close = true;
+
+ push({ type, value });
+ depth--;
+
+ block = stack[stack.length - 1];
+ continue;
+ }
+
+ /**
+ * Comma: ','
+ */
+
+ if (value === CHAR_COMMA && depth > 0) {
+ if (block.ranges > 0) {
+ block.ranges = 0;
+ let open = block.nodes.shift();
+ block.nodes = [open, { type: 'text', value: stringify(block) }];
+ }
+
+ push({ type: 'comma', value });
+ block.commas++;
+ continue;
+ }
+
+ /**
+ * Dot: '.'
+ */
+
+ if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+ let siblings = block.nodes;
+
+ if (depth === 0 || siblings.length === 0) {
+ push({ type: 'text', value });
+ continue;
+ }
+
+ if (prev.type === 'dot') {
+ block.range = [];
+ prev.value += value;
+ prev.type = 'range';
+
+ if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+ block.invalid = true;
+ block.ranges = 0;
+ prev.type = 'text';
+ continue;
+ }
+
+ block.ranges++;
+ block.args = [];
+ continue;
+ }
+
+ if (prev.type === 'range') {
+ siblings.pop();
+
+ let before = siblings[siblings.length - 1];
+ before.value += prev.value + value;
+ prev = before;
+ block.ranges--;
+ continue;
+ }
+
+ push({ type: 'dot', value });
+ continue;
+ }
+
+ /**
+ * Text
+ */
+
+ push({ type: 'text', value });
+ }
+
+ // Mark imbalanced braces and brackets as invalid
+ do {
+ block = stack.pop();
+
+ if (block.type !== 'root') {
+ block.nodes.forEach(node => {
+ if (!node.nodes) {
+ if (node.type === 'open') node.isOpen = true;
+ if (node.type === 'close') node.isClose = true;
+ if (!node.nodes) node.type = 'text';
+ node.invalid = true;
+ }
+ });
+
+ // get the location of the block on parent.nodes (block's siblings)
+ let parent = stack[stack.length - 1];
+ let index = parent.nodes.indexOf(block);
+ // replace the (invalid) block with it's nodes
+ parent.nodes.splice(index, 1, ...block.nodes);
+ }
+ } while (stack.length > 0);
+
+ push({ type: 'eos' });
+ return ast;
+};
+
+module.exports = parse;
diff --git a/node_modules/imagemin/node_modules/braces/lib/stringify.js b/node_modules/imagemin/node_modules/braces/lib/stringify.js
new file mode 100644
index 0000000..414b7bc
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/lib/stringify.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const utils = require('./utils');
+
+module.exports = (ast, options = {}) => {
+ let stringify = (node, parent = {}) => {
+ let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+ let invalidNode = node.invalid === true && options.escapeInvalid === true;
+ let output = '';
+
+ if (node.value) {
+ if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
+ return '\\' + node.value;
+ }
+ return node.value;
+ }
+
+ if (node.value) {
+ return node.value;
+ }
+
+ if (node.nodes) {
+ for (let child of node.nodes) {
+ output += stringify(child);
+ }
+ }
+ return output;
+ };
+
+ return stringify(ast);
+};
+
diff --git a/node_modules/imagemin/node_modules/braces/lib/utils.js b/node_modules/imagemin/node_modules/braces/lib/utils.js
new file mode 100644
index 0000000..e3551a6
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/lib/utils.js
@@ -0,0 +1,112 @@
+'use strict';
+
+exports.isInteger = num => {
+ if (typeof num === 'number') {
+ return Number.isInteger(num);
+ }
+ if (typeof num === 'string' && num.trim() !== '') {
+ return Number.isInteger(Number(num));
+ }
+ return false;
+};
+
+/**
+ * Find a node of the given type
+ */
+
+exports.find = (node, type) => node.nodes.find(node => node.type === type);
+
+/**
+ * Find a node of the given type
+ */
+
+exports.exceedsLimit = (min, max, step = 1, limit) => {
+ if (limit === false) return false;
+ if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+ return ((Number(max) - Number(min)) / Number(step)) >= limit;
+};
+
+/**
+ * Escape the given node with '\\' before node.value
+ */
+
+exports.escapeNode = (block, n = 0, type) => {
+ let node = block.nodes[n];
+ if (!node) return;
+
+ if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
+ if (node.escaped !== true) {
+ node.value = '\\' + node.value;
+ node.escaped = true;
+ }
+ }
+};
+
+/**
+ * Returns true if the given brace node should be enclosed in literal braces
+ */
+
+exports.encloseBrace = node => {
+ if (node.type !== 'brace') return false;
+ if ((node.commas >> 0 + node.ranges >> 0) === 0) {
+ node.invalid = true;
+ return true;
+ }
+ return false;
+};
+
+/**
+ * Returns true if a brace node is invalid.
+ */
+
+exports.isInvalidBrace = block => {
+ if (block.type !== 'brace') return false;
+ if (block.invalid === true || block.dollar) return true;
+ if ((block.commas >> 0 + block.ranges >> 0) === 0) {
+ block.invalid = true;
+ return true;
+ }
+ if (block.open !== true || block.close !== true) {
+ block.invalid = true;
+ return true;
+ }
+ return false;
+};
+
+/**
+ * Returns true if a node is an open or close node
+ */
+
+exports.isOpenOrClose = node => {
+ if (node.type === 'open' || node.type === 'close') {
+ return true;
+ }
+ return node.open === true || node.close === true;
+};
+
+/**
+ * Reduce an array of text nodes.
+ */
+
+exports.reduce = nodes => nodes.reduce((acc, node) => {
+ if (node.type === 'text') acc.push(node.value);
+ if (node.type === 'range') node.type = 'text';
+ return acc;
+}, []);
+
+/**
+ * Flatten an array
+ */
+
+exports.flatten = (...args) => {
+ const result = [];
+ const flat = arr => {
+ for (let i = 0; i < arr.length; i++) {
+ let ele = arr[i];
+ Array.isArray(ele) ? flat(ele, result) : ele !== void 0 && result.push(ele);
+ }
+ return result;
+ };
+ flat(args);
+ return result;
+};
diff --git a/node_modules/imagemin/node_modules/braces/package.json b/node_modules/imagemin/node_modules/braces/package.json
new file mode 100644
index 0000000..e05f50b
--- /dev/null
+++ b/node_modules/imagemin/node_modules/braces/package.json
@@ -0,0 +1,123 @@
+{
+ "_from": "braces@^3.0.1",
+ "_id": "braces@3.0.2",
+ "_inBundle": false,
+ "_integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+ "_location": "/imagemin/braces",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "braces@^3.0.1",
+ "name": "braces",
+ "escapedName": "braces",
+ "rawSpec": "^3.0.1",
+ "saveSpec": null,
+ "fetchSpec": "^3.0.1"
+ },
+ "_requiredBy": [
+ "/imagemin/micromatch"
+ ],
+ "_resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+ "_shasum": "3454e1a462ee8d599e236df336cd9ea4f8afe107",
+ "_spec": "braces@^3.0.1",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\micromatch",
+ "author": {
+ "name": "Jon Schlinkert",
+ "url": "https://github.com/jonschlinkert"
+ },
+ "bugs": {
+ "url": "https://github.com/micromatch/braces/issues"
+ },
+ "bundleDependencies": false,
+ "contributors": [
+ {
+ "name": "Brian Woodward",
+ "url": "https://twitter.com/doowb"
+ },
+ {
+ "name": "Elan Shanker",
+ "url": "https://github.com/es128"
+ },
+ {
+ "name": "Eugene Sharygin",
+ "url": "https://github.com/eush77"
+ },
+ {
+ "name": "hemanth.hm",
+ "url": "http://h3manth.com"
+ },
+ {
+ "name": "Jon Schlinkert",
+ "url": "http://twitter.com/jonschlinkert"
+ }
+ ],
+ "dependencies": {
+ "fill-range": "^7.0.1"
+ },
+ "deprecated": false,
+ "description": "Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.",
+ "devDependencies": {
+ "ansi-colors": "^3.2.4",
+ "bash-path": "^2.0.1",
+ "gulp-format-md": "^2.0.0",
+ "mocha": "^6.1.1"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js",
+ "lib"
+ ],
+ "homepage": "https://github.com/micromatch/braces",
+ "keywords": [
+ "alpha",
+ "alphabetical",
+ "bash",
+ "brace",
+ "braces",
+ "expand",
+ "expansion",
+ "filepath",
+ "fill",
+ "fs",
+ "glob",
+ "globbing",
+ "letter",
+ "match",
+ "matches",
+ "matching",
+ "number",
+ "numerical",
+ "path",
+ "range",
+ "ranges",
+ "sh"
+ ],
+ "license": "MIT",
+ "main": "index.js",
+ "name": "braces",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/micromatch/braces.git"
+ },
+ "scripts": {
+ "benchmark": "node benchmark",
+ "test": "mocha"
+ },
+ "verb": {
+ "toc": false,
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "lint": {
+ "reflinks": true
+ },
+ "plugins": [
+ "gulp-format-md"
+ ]
+ },
+ "version": "3.0.2"
+}
diff --git a/node_modules/imagemin/node_modules/dir-glob/index.js b/node_modules/imagemin/node_modules/dir-glob/index.js
new file mode 100644
index 0000000..c21cdf3
--- /dev/null
+++ b/node_modules/imagemin/node_modules/dir-glob/index.js
@@ -0,0 +1,75 @@
+'use strict';
+const path = require('path');
+const pathType = require('path-type');
+
+const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
+
+const getPath = (filepath, cwd) => {
+ const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
+ return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
+};
+
+const addExtensions = (file, extensions) => {
+ if (path.extname(file)) {
+ return `**/${file}`;
+ }
+
+ return `**/${file}.${getExtensions(extensions)}`;
+};
+
+const getGlob = (directory, options) => {
+ if (options.files && !Array.isArray(options.files)) {
+ throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
+ }
+
+ if (options.extensions && !Array.isArray(options.extensions)) {
+ throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
+ }
+
+ if (options.files && options.extensions) {
+ return options.files.map(x => path.posix.join(directory, addExtensions(x, options.extensions)));
+ }
+
+ if (options.files) {
+ return options.files.map(x => path.posix.join(directory, `**/${x}`));
+ }
+
+ if (options.extensions) {
+ return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
+ }
+
+ return [path.posix.join(directory, '**')];
+};
+
+module.exports = async (input, options) => {
+ options = {
+ cwd: process.cwd(),
+ ...options
+ };
+
+ if (typeof options.cwd !== 'string') {
+ throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+ }
+
+ const globs = await Promise.all([].concat(input).map(async x => {
+ const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
+ return isDirectory ? getGlob(x, options) : x;
+ }));
+
+ return [].concat.apply([], globs); // eslint-disable-line prefer-spread
+};
+
+module.exports.sync = (input, options) => {
+ options = {
+ cwd: process.cwd(),
+ ...options
+ };
+
+ if (typeof options.cwd !== 'string') {
+ throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+ }
+
+ const globs = [].concat(input).map(x => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
+
+ return [].concat.apply([], globs); // eslint-disable-line prefer-spread
+};
diff --git a/node_modules/imagemin/node_modules/dir-glob/license b/node_modules/imagemin/node_modules/dir-glob/license
new file mode 100644
index 0000000..db6bc32
--- /dev/null
+++ b/node_modules/imagemin/node_modules/dir-glob/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Kevin Mårtensson <kevinmartensson@gmail.com> (github.com/kevva)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/dir-glob/package.json b/node_modules/imagemin/node_modules/dir-glob/package.json
new file mode 100644
index 0000000..e095dc4
--- /dev/null
+++ b/node_modules/imagemin/node_modules/dir-glob/package.json
@@ -0,0 +1,70 @@
+{
+ "_from": "dir-glob@^3.0.1",
+ "_id": "dir-glob@3.0.1",
+ "_inBundle": false,
+ "_integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
+ "_location": "/imagemin/dir-glob",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "dir-glob@^3.0.1",
+ "name": "dir-glob",
+ "escapedName": "dir-glob",
+ "rawSpec": "^3.0.1",
+ "saveSpec": null,
+ "fetchSpec": "^3.0.1"
+ },
+ "_requiredBy": [
+ "/imagemin/globby"
+ ],
+ "_resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
+ "_shasum": "56dbf73d992a4a93ba1584f4534063fd2e41717f",
+ "_spec": "dir-glob@^3.0.1",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\globby",
+ "author": {
+ "name": "Kevin Mårtensson",
+ "email": "kevinmartensson@gmail.com",
+ "url": "github.com/kevva"
+ },
+ "bugs": {
+ "url": "https://github.com/kevva/dir-glob/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "path-type": "^4.0.0"
+ },
+ "deprecated": false,
+ "description": "Convert directories to glob compatible strings",
+ "devDependencies": {
+ "ava": "^2.1.0",
+ "del": "^4.1.1",
+ "make-dir": "^3.0.0",
+ "rimraf": "^2.5.0",
+ "xo": "^0.24.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js"
+ ],
+ "homepage": "https://github.com/kevva/dir-glob#readme",
+ "keywords": [
+ "convert",
+ "directory",
+ "extensions",
+ "files",
+ "glob"
+ ],
+ "license": "MIT",
+ "name": "dir-glob",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/kevva/dir-glob.git"
+ },
+ "scripts": {
+ "test": "xo && ava"
+ },
+ "version": "3.0.1"
+}
diff --git a/node_modules/imagemin/node_modules/dir-glob/readme.md b/node_modules/imagemin/node_modules/dir-glob/readme.md
new file mode 100644
index 0000000..cb7313f
--- /dev/null
+++ b/node_modules/imagemin/node_modules/dir-glob/readme.md
@@ -0,0 +1,76 @@
+# dir-glob [](https://travis-ci.org/kevva/dir-glob)
+
+> Convert directories to glob compatible strings
+
+
+## Install
+
+```
+$ npm install dir-glob
+```
+
+
+## Usage
+
+```js
+const dirGlob = require('dir-glob');
+
+(async () => {
+ console.log(await dirGlob(['index.js', 'test.js', 'fixtures']));
+ //=> ['index.js', 'test.js', 'fixtures/**']
+
+ console.log(await dirGlob(['index.js', 'inner_folder'], {cwd: 'fixtures'}));
+ //=> ['index.js', 'inner_folder/**']
+
+ console.log(await dirGlob(['lib/**', 'fixtures'], {
+ files: ['test', 'unicorn']
+ extensions: ['js']
+ }));
+ //=> ['lib/**', 'fixtures/**/test.js', 'fixtures/**/unicorn.js']
+
+ console.log(await dirGlob(['lib/**', 'fixtures'], {
+ files: ['test', 'unicorn', '*.jsx'],
+ extensions: ['js', 'png']
+ }));
+ //=> ['lib/**', 'fixtures/**/test.{js,png}', 'fixtures/**/unicorn.{js,png}', 'fixtures/**/*.jsx']
+})();
+```
+
+
+## API
+
+### dirGlob(input, options?)
+
+Returns a `Promise<string[]>` with globs.
+
+### dirGlob.sync(input, options?)
+
+Returns a `string[]` with globs.
+
+#### input
+
+Type: `string | string[]`
+
+Paths.
+
+#### options
+
+Type: `object`
+
+##### extensions
+
+Type: `string[]`
+
+Append extensions to the end of your globs.
+
+##### files
+
+Type: `string[]`
+
+Only glob for certain files.
+
+##### cwd
+
+Type: `string[]`
+
+Test in specific directory.
diff --git a/node_modules/imagemin/node_modules/fast-glob/LICENSE b/node_modules/imagemin/node_modules/fast-glob/LICENSE
new file mode 100644
index 0000000..65a9994
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Denis Malinochkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/fast-glob/README.md b/node_modules/imagemin/node_modules/fast-glob/README.md
new file mode 100644
index 0000000..f698d58
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/README.md
@@ -0,0 +1,793 @@
+# fast-glob
+
+> It's a very fast and efficient [glob][glob_definition] library for [Node.js][node_js].
+
+This package provides methods for traversing the file system and returning pathnames that matched a defined set of a specified pattern according to the rules used by the Unix Bash shell with some simplifications, meanwhile results are returned in **arbitrary order**. Quick, simple, effective.
+
+## Table of Contents
+
+<details>
+<summary><strong>Details</strong></summary>
+
+* [Highlights](#highlights)
+* [Donation](#donation)
+* [Old and modern mode](#old-and-modern-mode)
+* [Pattern syntax](#pattern-syntax)
+ * [Basic syntax](#basic-syntax)
+ * [Advanced syntax](#advanced-syntax)
+* [Installation](#installation)
+* [API](#api)
+ * [Asynchronous](#asynchronous)
+ * [Synchronous](#synchronous)
+ * [Stream](#stream)
+ * [patterns](#patterns)
+ * [[options]](#options)
+ * [Helpers](#helpers)
+ * [generateTasks](#generatetaskspatterns-options)
+ * [isDynamicPattern](#isdynamicpatternpattern-options)
+ * [escapePath](#escapepathpattern)
+* [Options](#options-3)
+ * [Common](#common)
+ * [concurrency](#concurrency)
+ * [cwd](#cwd)
+ * [deep](#deep)
+ * [followSymbolicLinks](#followsymboliclinks)
+ * [fs](#fs)
+ * [ignore](#ignore)
+ * [suppressErrors](#suppresserrors)
+ * [throwErrorOnBrokenSymbolicLink](#throwerroronbrokensymboliclink)
+ * [Output control](#output-control)
+ * [absolute](#absolute)
+ * [markDirectories](#markdirectories)
+ * [objectMode](#objectmode)
+ * [onlyDirectories](#onlydirectories)
+ * [onlyFiles](#onlyfiles)
+ * [stats](#stats)
+ * [unique](#unique)
+ * [Matching control](#matching-control)
+ * [braceExpansion](#braceexpansion)
+ * [caseSensitiveMatch](#casesensitivematch)
+ * [dot](#dot)
+ * [extglob](#extglob)
+ * [globstar](#globstar)
+ * [baseNameMatch](#basenamematch)
+* [FAQ](#faq)
+ * [What is a static or dynamic pattern?](#what-is-a-static-or-dynamic-pattern)
+ * [How to write patterns on Windows?](#how-to-write-patterns-on-windows)
+ * [Why are parentheses match wrong?](#why-are-parentheses-match-wrong)
+ * [How to exclude directory from reading?](#how-to-exclude-directory-from-reading)
+ * [How to use UNC path?](#how-to-use-unc-path)
+ * [Compatible with `node-glob`?](#compatible-with-node-glob)
+* [Benchmarks](#benchmarks)
+ * [Server](#server)
+ * [Nettop](#nettop)
+* [Changelog](#changelog)
+* [License](#license)
+
+</details>
+
+## Highlights
+
+* Fast. Probably the fastest.
+* Supports multiple and negative patterns.
+* Synchronous, Promise and Stream API.
+* Object mode. Can return more than just strings.
+* Error-tolerant.
+
+## Donation
+
+Do you like this project? Support it by donating, creating an issue or pull request.
+
+[][paypal_mrmlnc]
+
+## Old and modern mode
+
+This package works in two modes, depending on the environment in which it is used.
+
+* **Old mode**. Node.js below 10.10 or when the [`stats`](#stats) option is *enabled*.
+* **Modern mode**. Node.js 10.10+ and the [`stats`](#stats) option is *disabled*.
+
+The modern mode is faster. Learn more about the [internal mechanism][nodelib_fs_scandir_old_and_modern_modern].
+
+## Pattern syntax
+
+> :warning: Always use forward-slashes in glob expressions (patterns and [`ignore`](#ignore) option). Use backslashes for escaping characters.
+
+There is more than one form of syntax: basic and advanced. Below is a brief overview of the supported features. Also pay attention to our [FAQ](#faq).
+
+> :book: This package uses a [`micromatch`][micromatch] as a library for pattern matching.
+
+### Basic syntax
+
+* An asterisk (`*`) — matches everything except slashes (path separators), hidden files (names starting with `.`).
+* A double star or globstar (`**`) — matches zero or more directories.
+* Question mark (`?`) – matches any single character except slashes (path separators).
+* Sequence (`[seq]`) — matches any character in sequence.
+
+> :book: A few additional words about the [basic matching behavior][picomatch_matching_behavior].
+
+Some examples:
+
+* `src/**/*.js` — matches all files in the `src` directory (any level of nesting) that have the `.js` extension.
+* `src/*.??` — matches all files in the `src` directory (only first level of nesting) that have a two-character extension.
+* `file-[01].js` — matches files: `file-0.js`, `file-1.js`.
+
+### Advanced syntax
+
+* [Escapes characters][micromatch_backslashes] (`\\`) — matching special characters (`$^*+?()[]`) as literals.
+* [POSIX character classes][picomatch_posix_brackets] (`[[:digit:]]`).
+* [Extended globs][micromatch_extglobs] (`?(pattern-list)`).
+* [Bash style brace expansions][micromatch_braces] (`{}`).
+* [Regexp character classes][micromatch_regex_character_classes] (`[1-5]`).
+* [Regex groups][regular_expressions_brackets] (`(a|b)`).
+
+> :book: A few additional words about the [advanced matching behavior][micromatch_extended_globbing].
+
+Some examples:
+
+* `src/**/*.{css,scss}` — matches all files in the `src` directory (any level of nesting) that have the `.css` or `.scss` extension.
+* `file-[[:digit:]].js` — matches files: `file-0.js`, `file-1.js`, …, `file-9.js`.
+* `file-{1..3}.js` — matches files: `file-1.js`, `file-2.js`, `file-3.js`.
+* `file-(1|2)` — matches files: `file-1.js`, `file-2.js`.
+
+## Installation
+
+```console
+npm install fast-glob
+```
+
+## API
+
+### Asynchronous
+
+```js
+fg(patterns, [options])
+```
+
+Returns a `Promise` with an array of matching entries.
+
+```js
+const fg = require('fast-glob');
+
+const entries = await fg(['.editorconfig', '**/index.js'], { dot: true });
+
+// ['.editorconfig', 'services/index.js']
+```
+
+### Synchronous
+
+```js
+fg.sync(patterns, [options])
+```
+
+Returns an array of matching entries.
+
+```js
+const fg = require('fast-glob');
+
+const entries = fg.sync(['.editorconfig', '**/index.js'], { dot: true });
+
+// ['.editorconfig', 'services/index.js']
+```
+
+### Stream
+
+```js
+fg.stream(patterns, [options])
+```
+
+Returns a [`ReadableStream`][node_js_stream_readable_streams] when the `data` event will be emitted with matching entry.
+
+```js
+const fg = require('fast-glob');
+
+const stream = fg.stream(['.editorconfig', '**/index.js'], { dot: true });
+
+for await (const entry of stream) {
+ // .editorconfig
+ // services/index.js
+}
+```
+
+#### patterns
+
+* Required: `true`
+* Type: `string | string[]`
+
+Any correct pattern(s).
+
+> :1234: [Pattern syntax](#pattern-syntax)
+>
+> :warning: This package does not respect the order of patterns. First, all the negative patterns are applied, and only then the positive patterns. If you want to get a certain order of records, use sorting or split calls.
+
+#### [options]
+
+* Required: `false`
+* Type: [`Options`](#options-3)
+
+See [Options](#options-3) section.
+
+### Helpers
+
+#### `generateTasks(patterns, [options])`
+
+Returns the internal representation of patterns ([`Task`](./src/managers/tasks.ts) is a combining patterns by base directory).
+
+```js
+fg.generateTasks('*');
+
+[{
+ base: '.', // Parent directory for all patterns inside this task
+ dynamic: true, // Dynamic or static patterns are in this task
+ patterns: ['*'],
+ positive: ['*'],
+ negative: []
+}]
+```
+
+##### patterns
+
+* Required: `true`
+* Type: `string | string[]`
+
+Any correct pattern(s).
+
+##### [options]
+
+* Required: `false`
+* Type: [`Options`](#options-3)
+
+See [Options](#options-3) section.
+
+#### `isDynamicPattern(pattern, [options])`
+
+Returns `true` if the passed pattern is a dynamic pattern.
+
+> :1234: [What is a static or dynamic pattern?](#what-is-a-static-or-dynamic-pattern)
+
+```js
+fg.isDynamicPattern('*'); // true
+fg.isDynamicPattern('abc'); // false
+```
+
+##### pattern
+
+* Required: `true`
+* Type: `string`
+
+Any correct pattern.
+
+##### [options]
+
+* Required: `false`
+* Type: [`Options`](#options-3)
+
+See [Options](#options-3) section.
+
+#### `escapePath(pattern)`
+
+Returns a path with escaped special characters (`*?|(){}[]`, `!` at the beginning of line, `@+!` before the opening parenthesis).
+
+```js
+fg.escapePath('!abc'); // \\!abc
+fg.escapePath('C:/Program Files (x86)'); // C:/Program Files \\(x86\\)
+```
+
+##### pattern
+
+* Required: `true`
+* Type: `string`
+
+Any string, for example, a path to a file.
+
+## Options
+
+### Common options
+
+#### concurrency
+
+* Type: `number`
+* Default: `os.cpus().length`
+
+Specifies the maximum number of concurrent requests from a reader to read directories.
+
+> :book: The higher the number, the higher the performance and load on the file system. If you want to read in quiet mode, set the value to a comfortable number or `1`.
+
+#### cwd
+
+* Type: `string`
+* Default: `process.cwd()`
+
+The current working directory in which to search.
+
+#### deep
+
+* Type: `number`
+* Default: `Infinity`
+
+Specifies the maximum depth of a read directory relative to the start directory.
+
+For example, you have the following tree:
+
+```js
+dir/
+└── one/ // 1
+ └── two/ // 2
+ └── file.js // 3
+```
+
+```js
+// With base directory
+fg.sync('dir/**', { onlyFiles: false, deep: 1 }); // ['dir/one']
+fg.sync('dir/**', { onlyFiles: false, deep: 2 }); // ['dir/one', 'dir/one/two']
+
+// With cwd option
+fg.sync('**', { onlyFiles: false, cwd: 'dir', deep: 1 }); // ['one']
+fg.sync('**', { onlyFiles: false, cwd: 'dir', deep: 2 }); // ['one', 'one/two']
+```
+
+> :book: If you specify a pattern with some base directory, this directory will not participate in the calculation of the depth of the found directories. Think of it as a [`cwd`](#cwd) option.
+
+#### followSymbolicLinks
+
+* Type: `boolean`
+* Default: `true`
+
+Indicates whether to traverse descendants of symbolic link directories.
+
+> :book: If the [`stats`](#stats) option is specified, the information about the symbolic link (`fs.lstat`) will be replaced with information about the entry (`fs.stat`) behind it.
+
+#### fs
+
+* Type: `FileSystemAdapter`
+* Default: `fs.*`
+
+Custom implementation of methods for working with the file system.
+
+```ts
+export interface FileSystemAdapter {
+ lstat?: typeof fs.lstat;
+ stat?: typeof fs.stat;
+ lstatSync?: typeof fs.lstatSync;
+ statSync?: typeof fs.statSync;
+ readdir?: typeof fs.readdir;
+ readdirSync?: typeof fs.readdirSync;
+}
+```
+
+#### ignore
+
+* Type: `string[]`
+* Default: `[]`
+
+An array of glob patterns to exclude matches. This is an alternative way to use negative patterns.
+
+```js
+dir/
+├── package-lock.json
+└── package.json
+```
+
+```js
+fg.sync(['*.json', '!package-lock.json']); // ['package.json']
+fg.sync('*.json', { ignore: ['package-lock.json'] }); // ['package.json']
+```
+
+#### suppressErrors
+
+* Type: `boolean`
+* Default: `false`
+
+By default this package suppress only `ENOENT` errors. Set to `true` to suppress any error.
+
+> :book: Can be useful when the directory has entries with a special level of access.
+
+#### throwErrorOnBrokenSymbolicLink
+
+* Type: `boolean`
+* Default: `false`
+
+Throw an error when symbolic link is broken if `true` or safely return `lstat` call if `false`.
+
+> :book: This option has no effect on errors when reading the symbolic link directory.
+
+### Output control
+
+#### absolute
+
+* Type: `boolean`
+* Default: `false`
+
+Return the absolute path for entries.
+
+```js
+fg.sync('*.js', { absolute: false }); // ['index.js']
+fg.sync('*.js', { absolute: true }); // ['/home/user/index.js']
+```
+
+> :book: This option is required if you want to use negative patterns with absolute path, for example, `!${__dirname}/*.js`.
+
+#### markDirectories
+
+* Type: `boolean`
+* Default: `false`
+
+Mark the directory path with the final slash.
+
+```js
+fs.sync('*', { onlyFiles: false, markDirectories: false }); // ['index.js', 'controllers']
+fs.sync('*', { onlyFiles: false, markDirectories: true }); // ['index.js', 'controllers/']
+```
+
+#### objectMode
+
+* Type: `boolean`
+* Default: `false`
+
+Returns objects (instead of strings) describing entries.
+
+```js
+fg.sync('*', { objectMode: false }); // ['src/index.js']
+fg.sync('*', { objectMode: true }); // [{ name: 'index.js', path: 'src/index.js', dirent: <fs.Dirent> }]
+```
+
+The object has the following fields:
+
+* name (`string`) — the last part of the path (basename)
+* path (`string`) — full path relative to the pattern base directory
+* dirent ([`fs.Dirent`][node_js_fs_class_fs_dirent]) — instance of `fs.Direct`
+
+> :book: An object is an internal representation of entry, so getting it does not affect performance.
+
+#### onlyDirectories
+
+* Type: `boolean`
+* Default: `false`
+
+Return only directories.
+
+```js
+fg.sync('*', { onlyDirectories: false }); // ['index.js', 'src']
+fg.sync('*', { onlyDirectories: true }); // ['src']
+```
+
+> :book: If `true`, the [`onlyFiles`](#onlyfiles) option is automatically `false`.
+
+#### onlyFiles
+
+* Type: `boolean`
+* Default: `true`
+
+Return only files.
+
+```js
+fg.sync('*', { onlyFiles: false }); // ['index.js', 'src']
+fg.sync('*', { onlyFiles: true }); // ['index.js']
+```
+
+#### stats
+
+* Type: `boolean`
+* Default: `false`
+
+Enables an [object mode](#objectmode) with an additional field:
+
+* stats ([`fs.Stats`][node_js_fs_class_fs_stats]) — instance of `fs.Stats`
+
+```js
+fg.sync('*', { stats: false }); // ['src/index.js']
+fg.sync('*', { stats: true }); // [{ name: 'index.js', path: 'src/index.js', dirent: <fs.Dirent>, stats: <fs.Stats> }]
+```
+
+> :book: Returns `fs.stat` instead of `fs.lstat` for symbolic links when the [`followSymbolicLinks`](#followsymboliclinks) option is specified.
+>
+> :warning: Unlike [object mode](#objectmode) this mode requires additional calls to the file system. On average, this mode is slower at least twice. See [old and modern mode](#old-and-modern-mode) for more details.
+
+#### unique
+
+* Type: `boolean`
+* Default: `true`
+
+Ensures that the returned entries are unique.
+
+```js
+fg.sync(['*.json', 'package.json'], { unique: false }); // ['package.json', 'package.json']
+fg.sync(['*.json', 'package.json'], { unique: true }); // ['package.json']
+```
+
+If `true` and similar entries are found, the result is the first found.
+
+### Matching control
+
+#### braceExpansion
+
+* Type: `boolean`
+* Default: `true`
+
+Enables Bash-like brace expansion.
+
+> :1234: [Syntax description][bash_hackers_syntax_expansion_brace] or more [detailed description][micromatch_braces].
+
+```js
+dir/
+├── abd
+├── acd
+└── a{b,c}d
+```
+
+```js
+fg.sync('a{b,c}d', { braceExpansion: false }); // ['a{b,c}d']
+fg.sync('a{b,c}d', { braceExpansion: true }); // ['abd', 'acd']
+```
+
+#### caseSensitiveMatch
+
+* Type: `boolean`
+* Default: `true`
+
+Enables a [case-sensitive][wikipedia_case_sensitivity] mode for matching files.
+
+```js
+dir/
+├── file.txt
+└── File.txt
+```
+
+```js
+fg.sync('file.txt', { caseSensitiveMatch: false }); // ['file.txt', 'File.txt']
+fg.sync('file.txt', { caseSensitiveMatch: true }); // ['file.txt']
+```
+
+#### dot
+
+* Type: `boolean`
+* Default: `false`
+
+Allow patterns to match entries that begin with a period (`.`).
+
+> :book: Note that an explicit dot in a portion of the pattern will always match dot files.
+
+```js
+dir/
+├── .editorconfig
+└── package.json
+```
+
+```js
+fg.sync('*', { dot: false }); // ['package.json']
+fg.sync('*', { dot: true }); // ['.editorconfig', 'package.json']
+```
+
+#### extglob
+
+* Type: `boolean`
+* Default: `true`
+
+Enables Bash-like `extglob` functionality.
+
+> :1234: [Syntax description][micromatch_extglobs].
+
+```js
+dir/
+├── README.md
+└── package.json
+```
+
+```js
+fg.sync('*.+(json|md)', { extglob: false }); // []
+fg.sync('*.+(json|md)', { extglob: true }); // ['README.md', 'package.json']
+```
+
+#### globstar
+
+* Type: `boolean`
+* Default: `true`
+
+Enables recursively repeats a pattern containing `**`. If `false`, `**` behaves exactly like `*`.
+
+```js
+dir/
+└── a
+ └── b
+```
+
+```js
+fg.sync('**', { onlyFiles: false, globstar: false }); // ['a']
+fg.sync('**', { onlyFiles: false, globstar: true }); // ['a', 'a/b']
+```
+
+#### baseNameMatch
+
+* Type: `boolean`
+* Default: `false`
+
+If set to `true`, then patterns without slashes will be matched against the basename of the path if it contains slashes.
+
+```js
+dir/
+└── one/
+ └── file.md
+```
+
+```js
+fg.sync('*.md', { baseNameMatch: false }); // []
+fg.sync('*.md', { baseNameMatch: true }); // ['one/file.md']
+```
+
+## FAQ
+
+## What is a static or dynamic pattern?
+
+All patterns can be divided into two types:
+
+* **static**. A pattern is considered static if it can be used to get an entry on the file system without using matching mechanisms. For example, the `file.js` pattern is a static pattern because we can just verify that it exists on the file system.
+* **dynamic**. A pattern is considered dynamic if it cannot be used directly to find occurrences without using a matching mechanisms. For example, the `*` pattern is a dynamic pattern because we cannot use this pattern directly.
+
+A pattern is considered dynamic if it contains the following characters (`…` — any characters or their absence) or options:
+
+* The [`caseSensitiveMatch`](#casesensitivematch) option is disabled
+* `\\` (the escape character)
+* `*`, `?`, `!` (at the beginning of line)
+* `[…]`
+* `(…|…)`
+* `@(…)`, `!(…)`, `*(…)`, `?(…)`, `+(…)` (respects the [`extglob`](#extglob) option)
+* `{…,…}`, `{…..…}` (respects the [`braceExpansion`](#braceexpansion) option)
+
+## How to write patterns on Windows?
+
+Always use forward-slashes in glob expressions (patterns and [`ignore`](#ignore) option). Use backslashes for escaping characters. With the [`cwd`](#cwd) option use a convenient format.
+
+**Bad**
+
+```ts
+[
+ 'directory\\*',
+ path.join(process.cwd(), '**')
+]
+```
+
+**Good**
+
+```ts
+[
+ 'directory/*',
+ path.join(process.cwd(), '**').replace(/\\/g, '/')
+]
+```
+
+> :book: Use the [`normalize-path`][npm_normalize_path] or the [`unixify`][npm_unixify] package to convert Windows-style path to a Unix-style path.
+
+Read more about [matching with backslashes][micromatch_backslashes].
+
+## Why are parentheses match wrong?
+
+```js
+dir/
+└── (special-*file).txt
+```
+
+```js
+fg.sync(['(special-*file).txt']) // []
+```
+
+Refers to Bash. You need to escape special characters:
+
+```js
+fg.sync(['\\(special-*file\\).txt']) // ['(special-*file).txt']
+```
+
+Read more about [matching special characters as literals][picomatch_matching_special_characters_as_literals].
+
+## How to exclude directory from reading?
+
+You can use a negative pattern like this: `!**/node_modules` or `!**/node_modules/**`. Also you can use [`ignore`](#ignore) option. Just look at the example below.
+
+```js
+first/
+├── file.md
+└── second/
+ └── file.txt
+```
+
+If you don't want to read the `second` directory, you must write the following pattern: `!**/second` or `!**/second/**`.
+
+```js
+fg.sync(['**/*.md', '!**/second']); // ['first/file.md']
+fg.sync(['**/*.md'], { ignore: ['**/second/**'] }); // ['first/file.md']
+```
+
+> :warning: When you write `!**/second/**/*` it means that the directory will be **read**, but all the entries will not be included in the results.
+
+You have to understand that if you write the pattern to exclude directories, then the directory will not be read under any circumstances.
+
+## How to use UNC path?
+
+You cannot use [Uniform Naming Convention (UNC)][unc_path] paths as patterns (due to syntax), but you can use them as [`cwd`](#cwd) directory.
+
+```ts
+fg.sync('*', { cwd: '\\\\?\\C:\\Python27' /* or //?/C:/Python27 */ });
+fg.sync('Python27/*', { cwd: '\\\\?\\C:\\' /* or //?/C:/ */ });
+```
+
+## Compatible with `node-glob`?
+
+| node-glob | fast-glob |
+| :----------: | :-------: |
+| `cwd` | [`cwd`](#cwd) |
+| `root` | – |
+| `dot` | [`dot`](#dot) |
+| `nomount` | – |
+| `mark` | [`markDirectories`](#markdirectories) |
+| `nosort` | – |
+| `nounique` | [`unique`](#unique) |
+| `nobrace` | [`braceExpansion`](#braceexpansion) |
+| `noglobstar` | [`globstar`](#globstar) |
+| `noext` | [`extglob`](#extglob) |
+| `nocase` | [`caseSensitiveMatch`](#casesensitivematch) |
+| `matchBase` | [`baseNameMatch`](#basenamematch) |
+| `nodir` | [`onlyFiles`](#onlyfiles) |
+| `ignore` | [`ignore`](#ignore) |
+| `follow` | [`followSymbolicLinks`](#followsymboliclinks) |
+| `realpath` | – |
+| `absolute` | [`absolute`](#absolute) |
+
+## Benchmarks
+
+### Server
+
+Link: [Vultr Bare Metal][vultr_pricing_baremetal]
+
+* Processor: E3-1270v6 (8 CPU)
+* RAM: 32GB
+* Disk: SSD ([Intel DC S3520 SSDSC2BB240G7][intel_ssd])
+
+You can see results [here][github_gist_benchmark_server] for latest release.
+
+### Nettop
+
+Link: [Zotac bi323][zotac_bi323]
+
+* Processor: Intel N3150 (4 CPU)
+* RAM: 8GB
+* Disk: SSD ([Silicon Power SP060GBSS3S55S25][silicon_power_ssd])
+
+You can see results [here][github_gist_benchmark_nettop] for latest release.
+
+## Changelog
+
+See the [Releases section of our GitHub project][github_releases] for changelog for each release version.
+
+## License
+
+This software is released under the terms of the MIT license.
+
+[bash_hackers_syntax_expansion_brace]: https://wiki.bash-hackers.org/syntax/expansion/brace
+[github_gist_benchmark_nettop]: https://gist.github.com/mrmlnc/f06246b197f53c356895fa35355a367c#file-fg-benchmark-nettop-product-txt
+[github_gist_benchmark_server]: https://gist.github.com/mrmlnc/f06246b197f53c356895fa35355a367c#file-fg-benchmark-server-product-txt
+[github_releases]: https://github.com/mrmlnc/fast-glob/releases
+[glob_definition]: https://en.wikipedia.org/wiki/Glob_(programming)
+[glob_linux_man]: http://man7.org/linux/man-pages/man3/glob.3.html
+[intel_ssd]: https://ark.intel.com/content/www/us/en/ark/products/93012/intel-ssd-dc-s3520-series-240gb-2-5in-sata-6gb-s-3d1-mlc.html
+[micromatch_backslashes]: https://github.com/micromatch/micromatch#backslashes
+[micromatch_braces]: https://github.com/micromatch/braces
+[micromatch_extended_globbing]: https://github.com/micromatch/micromatch#extended-globbing
+[micromatch_extglobs]: https://github.com/micromatch/micromatch#extglobs
+[micromatch_regex_character_classes]: https://github.com/micromatch/micromatch#regex-character-classes
+[micromatch]: https://github.com/micromatch/micromatch
+[node_js_fs_class_fs_dirent]: https://nodejs.org/api/fs.html#fs_class_fs_dirent
+[node_js_fs_class_fs_stats]: https://nodejs.org/api/fs.html#fs_class_fs_stats
+[node_js_stream_readable_streams]: https://nodejs.org/api/stream.html#stream_readable_streams
+[node_js]: https://nodejs.org/en
+[nodelib_fs_scandir_old_and_modern_modern]: https://github.com/nodelib/nodelib/blob/master/packages/fs/fs.scandir/README.md#old-and-modern-mode
+[npm_normalize_path]: https://www.npmjs.com/package/normalize-path
+[npm_unixify]: https://www.npmjs.com/package/unixify
+[paypal_mrmlnc]:https://paypal.me/mrmlnc
+[picomatch_matching_behavior]: https://github.com/micromatch/picomatch#matching-behavior-vs-bash
+[picomatch_matching_special_characters_as_literals]: https://github.com/micromatch/picomatch#matching-special-characters-as-literals
+[picomatch_posix_brackets]: https://github.com/micromatch/picomatch#posix-brackets
+[regular_expressions_brackets]: https://www.regular-expressions.info/brackets.html
+[silicon_power_ssd]: https://www.silicon-power.com/web/product-1
+[unc_path]: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dtyp/62e862f4-2a51-452e-8eeb-dc4ff5ee33cc
+[vultr_pricing_baremetal]: https://www.vultr.com/pricing/baremetal
+[wikipedia_case_sensitivity]: https://en.wikipedia.org/wiki/Case_sensitivity
+[zotac_bi323]: https://www.zotac.com/ee/product/mini_pcs/zbox-bi323
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/index.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/index.d.ts
new file mode 100644
index 0000000..553e514
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/index.d.ts
@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import * as taskManager from './managers/tasks';
+import { Options as OptionsInternal } from './settings';
+import { Entry as EntryInternal, FileSystemAdapter as FileSystemAdapterInternal, Pattern as PatternInternal } from './types';
+declare type EntryObjectModePredicate = {
+ [TKey in keyof Pick<OptionsInternal, 'objectMode'>]-?: true;
+};
+declare type EntryStatsPredicate = {
+ [TKey in keyof Pick<OptionsInternal, 'stats'>]-?: true;
+};
+declare type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
+declare function FastGlob(source: PatternInternal | PatternInternal[], options: OptionsInternal & EntryObjectPredicate): Promise<EntryInternal[]>;
+declare function FastGlob(source: PatternInternal | PatternInternal[], options?: OptionsInternal): Promise<string[]>;
+declare namespace FastGlob {
+ type Options = OptionsInternal;
+ type Entry = EntryInternal;
+ type Task = taskManager.Task;
+ type Pattern = PatternInternal;
+ type FileSystemAdapter = FileSystemAdapterInternal;
+ function sync(source: PatternInternal | PatternInternal[], options: OptionsInternal & EntryObjectPredicate): EntryInternal[];
+ function sync(source: PatternInternal | PatternInternal[], options?: OptionsInternal): string[];
+ function stream(source: PatternInternal | PatternInternal[], options?: OptionsInternal): NodeJS.ReadableStream;
+ function generateTasks(source: PatternInternal | PatternInternal[], options?: OptionsInternal): Task[];
+ function isDynamicPattern(source: PatternInternal, options?: OptionsInternal): boolean;
+ function escapePath(source: PatternInternal): PatternInternal;
+}
+export = FastGlob;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/index.js b/node_modules/imagemin/node_modules/fast-glob/out/index.js
new file mode 100644
index 0000000..cf8dea5
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/index.js
@@ -0,0 +1,67 @@
+"use strict";
+const taskManager = require("./managers/tasks");
+const async_1 = require("./providers/async");
+const stream_1 = require("./providers/stream");
+const sync_1 = require("./providers/sync");
+const settings_1 = require("./settings");
+const utils = require("./utils");
+async function FastGlob(source, options) {
+ assertPatternsInput(source);
+ const works = getWorks(source, async_1.default, options);
+ const result = await Promise.all(works);
+ return utils.array.flatten(result);
+}
+// https://github.com/typescript-eslint/typescript-eslint/issues/60
+// eslint-disable-next-line no-redeclare
+(function (FastGlob) {
+ function sync(source, options) {
+ assertPatternsInput(source);
+ const works = getWorks(source, sync_1.default, options);
+ return utils.array.flatten(works);
+ }
+ FastGlob.sync = sync;
+ function stream(source, options) {
+ assertPatternsInput(source);
+ const works = getWorks(source, stream_1.default, options);
+ /**
+ * The stream returned by the provider cannot work with an asynchronous iterator.
+ * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
+ * This affects performance (+25%). I don't see best solution right now.
+ */
+ return utils.stream.merge(works);
+ }
+ FastGlob.stream = stream;
+ function generateTasks(source, options) {
+ assertPatternsInput(source);
+ const patterns = [].concat(source);
+ const settings = new settings_1.default(options);
+ return taskManager.generate(patterns, settings);
+ }
+ FastGlob.generateTasks = generateTasks;
+ function isDynamicPattern(source, options) {
+ assertPatternsInput(source);
+ const settings = new settings_1.default(options);
+ return utils.pattern.isDynamicPattern(source, settings);
+ }
+ FastGlob.isDynamicPattern = isDynamicPattern;
+ function escapePath(source) {
+ assertPatternsInput(source);
+ return utils.path.escape(source);
+ }
+ FastGlob.escapePath = escapePath;
+})(FastGlob || (FastGlob = {}));
+function getWorks(source, _Provider, options) {
+ const patterns = [].concat(source);
+ const settings = new settings_1.default(options);
+ const tasks = taskManager.generate(patterns, settings);
+ const provider = new _Provider(settings);
+ return tasks.map(provider.read, provider);
+}
+function assertPatternsInput(input) {
+ const source = [].concat(input);
+ const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
+ if (!isValidSource) {
+ throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+ }
+}
+module.exports = FastGlob;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/managers/tasks.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/managers/tasks.d.ts
new file mode 100644
index 0000000..ff8e11e
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/managers/tasks.d.ts
@@ -0,0 +1,16 @@
+import Settings from '../settings';
+import { Pattern, PatternsGroup } from '../types';
+export declare type Task = {
+ base: string;
+ dynamic: boolean;
+ patterns: Pattern[];
+ positive: Pattern[];
+ negative: Pattern[];
+};
+export declare function generate(patterns: Pattern[], settings: Settings): Task[];
+export declare function convertPatternsToTasks(positive: Pattern[], negative: Pattern[], dynamic: boolean): Task[];
+export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
+export declare function getNegativePatternsAsPositive(patterns: Pattern[], ignore: Pattern[]): Pattern[];
+export declare function groupPatternsByBaseDirectory(patterns: Pattern[]): PatternsGroup;
+export declare function convertPatternGroupsToTasks(positive: PatternsGroup, negative: Pattern[], dynamic: boolean): Task[];
+export declare function convertPatternGroupToTask(base: string, positive: Pattern[], negative: Pattern[], dynamic: boolean): Task;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/managers/tasks.js b/node_modules/imagemin/node_modules/fast-glob/out/managers/tasks.js
new file mode 100644
index 0000000..f4f33da
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/managers/tasks.js
@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = void 0;
+const utils = require("../utils");
+function generate(patterns, settings) {
+ const positivePatterns = getPositivePatterns(patterns);
+ const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);
+ const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
+ const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
+ const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
+ const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
+ return staticTasks.concat(dynamicTasks);
+}
+exports.generate = generate;
+function convertPatternsToTasks(positive, negative, dynamic) {
+ const positivePatternsGroup = groupPatternsByBaseDirectory(positive);
+ // When we have a global group – there is no reason to divide the patterns into independent tasks.
+ // In this case, the global task covers the rest.
+ if ('.' in positivePatternsGroup) {
+ const task = convertPatternGroupToTask('.', positive, negative, dynamic);
+ return [task];
+ }
+ return convertPatternGroupsToTasks(positivePatternsGroup, negative, dynamic);
+}
+exports.convertPatternsToTasks = convertPatternsToTasks;
+function getPositivePatterns(patterns) {
+ return utils.pattern.getPositivePatterns(patterns);
+}
+exports.getPositivePatterns = getPositivePatterns;
+function getNegativePatternsAsPositive(patterns, ignore) {
+ const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
+ const positive = negative.map(utils.pattern.convertToPositivePattern);
+ return positive;
+}
+exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+function groupPatternsByBaseDirectory(patterns) {
+ const group = {};
+ return patterns.reduce((collection, pattern) => {
+ const base = utils.pattern.getBaseDirectory(pattern);
+ if (base in collection) {
+ collection[base].push(pattern);
+ }
+ else {
+ collection[base] = [pattern];
+ }
+ return collection;
+ }, group);
+}
+exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+function convertPatternGroupsToTasks(positive, negative, dynamic) {
+ return Object.keys(positive).map((base) => {
+ return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+ });
+}
+exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+function convertPatternGroupToTask(base, positive, negative, dynamic) {
+ return {
+ dynamic,
+ positive,
+ negative,
+ base,
+ patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
+ };
+}
+exports.convertPatternGroupToTask = convertPatternGroupToTask;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/async.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/async.d.ts
new file mode 100644
index 0000000..a2dc7a9
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/async.d.ts
@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { Task } from '../managers/tasks';
+import ReaderStream from '../readers/stream';
+import { EntryItem, ReaderOptions } from '../types';
+import Provider from './provider';
+export default class ProviderAsync extends Provider<Promise<EntryItem[]>> {
+ protected _reader: ReaderStream;
+ read(task: Task): Promise<EntryItem[]>;
+ api(root: string, task: Task, options: ReaderOptions): Readable;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/async.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/async.js
new file mode 100644
index 0000000..477aae5
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/async.js
@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("../readers/stream");
+const provider_1 = require("./provider");
+class ProviderAsync extends provider_1.default {
+ constructor() {
+ super(...arguments);
+ this._reader = new stream_1.default(this._settings);
+ }
+ read(task) {
+ const root = this._getRootDirectory(task);
+ const options = this._getReaderOptions(task);
+ const entries = [];
+ return new Promise((resolve, reject) => {
+ const stream = this.api(root, task, options);
+ stream.once('error', reject);
+ stream.on('data', (entry) => entries.push(options.transform(entry)));
+ stream.once('end', () => resolve(entries));
+ });
+ }
+ api(root, task, options) {
+ if (task.dynamic) {
+ return this._reader.dynamic(root, options);
+ }
+ return this._reader.static(task.patterns, options);
+ }
+}
+exports.default = ProviderAsync;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/deep.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/deep.d.ts
new file mode 100644
index 0000000..377fab8
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/deep.d.ts
@@ -0,0 +1,16 @@
+import { MicromatchOptions, EntryFilterFunction, Pattern } from '../../types';
+import Settings from '../../settings';
+export default class DeepFilter {
+ private readonly _settings;
+ private readonly _micromatchOptions;
+ constructor(_settings: Settings, _micromatchOptions: MicromatchOptions);
+ getFilter(basePath: string, positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
+ private _getMatcher;
+ private _getNegativePatternsRe;
+ private _filter;
+ private _isSkippedByDeep;
+ private _getEntryLevel;
+ private _isSkippedSymbolicLink;
+ private _isSkippedByPositivePatterns;
+ private _isSkippedByNegativePatterns;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/deep.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/deep.js
new file mode 100644
index 0000000..644bf41
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/deep.js
@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+const partial_1 = require("../matchers/partial");
+class DeepFilter {
+ constructor(_settings, _micromatchOptions) {
+ this._settings = _settings;
+ this._micromatchOptions = _micromatchOptions;
+ }
+ getFilter(basePath, positive, negative) {
+ const matcher = this._getMatcher(positive);
+ const negativeRe = this._getNegativePatternsRe(negative);
+ return (entry) => this._filter(basePath, entry, matcher, negativeRe);
+ }
+ _getMatcher(patterns) {
+ return new partial_1.default(patterns, this._settings, this._micromatchOptions);
+ }
+ _getNegativePatternsRe(patterns) {
+ const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
+ return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
+ }
+ _filter(basePath, entry, matcher, negativeRe) {
+ if (this._isSkippedByDeep(basePath, entry.path)) {
+ return false;
+ }
+ if (this._isSkippedSymbolicLink(entry)) {
+ return false;
+ }
+ const filepath = utils.path.removeLeadingDotSegment(entry.path);
+ if (this._isSkippedByPositivePatterns(filepath, matcher)) {
+ return false;
+ }
+ return this._isSkippedByNegativePatterns(filepath, negativeRe);
+ }
+ _isSkippedByDeep(basePath, entryPath) {
+ /**
+ * Avoid unnecessary depth calculations when it doesn't matter.
+ */
+ if (this._settings.deep === Infinity) {
+ return false;
+ }
+ return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
+ }
+ _getEntryLevel(basePath, entryPath) {
+ const entryPathDepth = entryPath.split('/').length;
+ if (basePath === '') {
+ return entryPathDepth;
+ }
+ const basePathDepth = basePath.split('/').length;
+ return entryPathDepth - basePathDepth;
+ }
+ _isSkippedSymbolicLink(entry) {
+ return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
+ }
+ _isSkippedByPositivePatterns(entryPath, matcher) {
+ return !this._settings.baseNameMatch && !matcher.match(entryPath);
+ }
+ _isSkippedByNegativePatterns(entryPath, patternsRe) {
+ return !utils.pattern.matchAny(entryPath, patternsRe);
+ }
+}
+exports.default = DeepFilter;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/entry.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/entry.d.ts
new file mode 100644
index 0000000..ee71281
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/entry.d.ts
@@ -0,0 +1,16 @@
+import Settings from '../../settings';
+import { EntryFilterFunction, MicromatchOptions, Pattern } from '../../types';
+export default class EntryFilter {
+ private readonly _settings;
+ private readonly _micromatchOptions;
+ readonly index: Map<string, undefined>;
+ constructor(_settings: Settings, _micromatchOptions: MicromatchOptions);
+ getFilter(positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
+ private _filter;
+ private _isDuplicateEntry;
+ private _createIndexRecord;
+ private _onlyFileFilter;
+ private _onlyDirectoryFilter;
+ private _isSkippedByAbsoluteNegativePatterns;
+ private _isMatchToPatterns;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/entry.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/entry.js
new file mode 100644
index 0000000..97d3978
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/entry.js
@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class EntryFilter {
+ constructor(_settings, _micromatchOptions) {
+ this._settings = _settings;
+ this._micromatchOptions = _micromatchOptions;
+ this.index = new Map();
+ }
+ getFilter(positive, negative) {
+ const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
+ const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
+ return (entry) => this._filter(entry, positiveRe, negativeRe);
+ }
+ _filter(entry, positiveRe, negativeRe) {
+ if (this._settings.unique && this._isDuplicateEntry(entry)) {
+ return false;
+ }
+ if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
+ return false;
+ }
+ if (this._isSkippedByAbsoluteNegativePatterns(entry.path, negativeRe)) {
+ return false;
+ }
+ const filepath = this._settings.baseNameMatch ? entry.name : entry.path;
+ const isMatched = this._isMatchToPatterns(filepath, positiveRe) && !this._isMatchToPatterns(entry.path, negativeRe);
+ if (this._settings.unique && isMatched) {
+ this._createIndexRecord(entry);
+ }
+ return isMatched;
+ }
+ _isDuplicateEntry(entry) {
+ return this.index.has(entry.path);
+ }
+ _createIndexRecord(entry) {
+ this.index.set(entry.path, undefined);
+ }
+ _onlyFileFilter(entry) {
+ return this._settings.onlyFiles && !entry.dirent.isFile();
+ }
+ _onlyDirectoryFilter(entry) {
+ return this._settings.onlyDirectories && !entry.dirent.isDirectory();
+ }
+ _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
+ if (!this._settings.absolute) {
+ return false;
+ }
+ const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
+ return utils.pattern.matchAny(fullpath, patternsRe);
+ }
+ _isMatchToPatterns(entryPath, patternsRe) {
+ const filepath = utils.path.removeLeadingDotSegment(entryPath);
+ return utils.pattern.matchAny(filepath, patternsRe);
+ }
+}
+exports.default = EntryFilter;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/error.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/error.d.ts
new file mode 100644
index 0000000..170eb25
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/error.d.ts
@@ -0,0 +1,8 @@
+import Settings from '../../settings';
+import { ErrorFilterFunction } from '../../types';
+export default class ErrorFilter {
+ private readonly _settings;
+ constructor(_settings: Settings);
+ getFilter(): ErrorFilterFunction;
+ private _isNonFatalError;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/error.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/error.js
new file mode 100644
index 0000000..1c6f241
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/filters/error.js
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class ErrorFilter {
+ constructor(_settings) {
+ this._settings = _settings;
+ }
+ getFilter() {
+ return (error) => this._isNonFatalError(error);
+ }
+ _isNonFatalError(error) {
+ return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+ }
+}
+exports.default = ErrorFilter;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/matcher.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/matcher.d.ts
new file mode 100644
index 0000000..f3773d4
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/matcher.d.ts
@@ -0,0 +1,33 @@
+import { Pattern, MicromatchOptions, PatternRe } from '../../types';
+import Settings from '../../settings';
+export declare type PatternSegment = StaticPatternSegment | DynamicPatternSegment;
+declare type StaticPatternSegment = {
+ dynamic: false;
+ pattern: Pattern;
+};
+declare type DynamicPatternSegment = {
+ dynamic: true;
+ pattern: Pattern;
+ patternRe: PatternRe;
+};
+export declare type PatternSection = PatternSegment[];
+export declare type PatternInfo = {
+ /**
+ * Indicates that the pattern has a globstar (more than a single section).
+ */
+ complete: boolean;
+ pattern: Pattern;
+ segments: PatternSegment[];
+ sections: PatternSection[];
+};
+export default abstract class Matcher {
+ private readonly _patterns;
+ private readonly _settings;
+ private readonly _micromatchOptions;
+ protected readonly _storage: PatternInfo[];
+ constructor(_patterns: Pattern[], _settings: Settings, _micromatchOptions: MicromatchOptions);
+ private _fillStorage;
+ private _getPatternSegments;
+ private _splitSegmentsIntoSections;
+}
+export {};
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/matcher.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/matcher.js
new file mode 100644
index 0000000..752d2c2
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/matcher.js
@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class Matcher {
+ constructor(_patterns, _settings, _micromatchOptions) {
+ this._patterns = _patterns;
+ this._settings = _settings;
+ this._micromatchOptions = _micromatchOptions;
+ this._storage = [];
+ this._fillStorage();
+ }
+ _fillStorage() {
+ /**
+ * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level).
+ * So, before expand patterns with brace expansion into separated patterns.
+ */
+ const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns);
+ for (const pattern of patterns) {
+ const segments = this._getPatternSegments(pattern);
+ const sections = this._splitSegmentsIntoSections(segments);
+ this._storage.push({
+ complete: sections.length <= 1,
+ pattern,
+ segments,
+ sections
+ });
+ }
+ }
+ _getPatternSegments(pattern) {
+ const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
+ return parts.map((part) => {
+ const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
+ if (!dynamic) {
+ return {
+ dynamic: false,
+ pattern: part
+ };
+ }
+ return {
+ dynamic: true,
+ pattern: part,
+ patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
+ };
+ });
+ }
+ _splitSegmentsIntoSections(segments) {
+ return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+ }
+}
+exports.default = Matcher;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/partial.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/partial.d.ts
new file mode 100644
index 0000000..91520f6
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/partial.d.ts
@@ -0,0 +1,4 @@
+import Matcher from './matcher';
+export default class PartialMatcher extends Matcher {
+ match(filepath: string): boolean;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/partial.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/partial.js
new file mode 100644
index 0000000..1dfffeb
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/matchers/partial.js
@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const matcher_1 = require("./matcher");
+class PartialMatcher extends matcher_1.default {
+ match(filepath) {
+ const parts = filepath.split('/');
+ const levels = parts.length;
+ const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
+ for (const pattern of patterns) {
+ const section = pattern.sections[0];
+ /**
+ * In this case, the pattern has a globstar and we must read all directories unconditionally,
+ * but only if the level has reached the end of the first group.
+ *
+ * fixtures/{a,b}/**
+ * ^ true/false ^ always true
+ */
+ if (!pattern.complete && levels > section.length) {
+ return true;
+ }
+ const match = parts.every((part, index) => {
+ const segment = pattern.segments[index];
+ if (segment.dynamic && segment.patternRe.test(part)) {
+ return true;
+ }
+ if (!segment.dynamic && segment.pattern === part) {
+ return true;
+ }
+ return false;
+ });
+ if (match) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
+exports.default = PartialMatcher;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/provider.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/provider.d.ts
new file mode 100644
index 0000000..1053460
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/provider.d.ts
@@ -0,0 +1,19 @@
+import { Task } from '../managers/tasks';
+import Settings from '../settings';
+import { MicromatchOptions, ReaderOptions } from '../types';
+import DeepFilter from './filters/deep';
+import EntryFilter from './filters/entry';
+import ErrorFilter from './filters/error';
+import EntryTransformer from './transformers/entry';
+export default abstract class Provider<T> {
+ protected readonly _settings: Settings;
+ readonly errorFilter: ErrorFilter;
+ readonly entryFilter: EntryFilter;
+ readonly deepFilter: DeepFilter;
+ readonly entryTransformer: EntryTransformer;
+ constructor(_settings: Settings);
+ abstract read(_task: Task): T;
+ protected _getRootDirectory(task: Task): string;
+ protected _getReaderOptions(task: Task): ReaderOptions;
+ protected _getMicromatchOptions(): MicromatchOptions;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/provider.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/provider.js
new file mode 100644
index 0000000..da88ee0
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/provider.js
@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const deep_1 = require("./filters/deep");
+const entry_1 = require("./filters/entry");
+const error_1 = require("./filters/error");
+const entry_2 = require("./transformers/entry");
+class Provider {
+ constructor(_settings) {
+ this._settings = _settings;
+ this.errorFilter = new error_1.default(this._settings);
+ this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
+ this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
+ this.entryTransformer = new entry_2.default(this._settings);
+ }
+ _getRootDirectory(task) {
+ return path.resolve(this._settings.cwd, task.base);
+ }
+ _getReaderOptions(task) {
+ const basePath = task.base === '.' ? '' : task.base;
+ return {
+ basePath,
+ pathSegmentSeparator: '/',
+ concurrency: this._settings.concurrency,
+ deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+ entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+ errorFilter: this.errorFilter.getFilter(),
+ followSymbolicLinks: this._settings.followSymbolicLinks,
+ fs: this._settings.fs,
+ stats: this._settings.stats,
+ throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+ transform: this.entryTransformer.getTransformer()
+ };
+ }
+ _getMicromatchOptions() {
+ return {
+ dot: this._settings.dot,
+ matchBase: this._settings.baseNameMatch,
+ nobrace: !this._settings.braceExpansion,
+ nocase: !this._settings.caseSensitiveMatch,
+ noext: !this._settings.extglob,
+ noglobstar: !this._settings.globstar,
+ posix: true,
+ strictSlashes: false
+ };
+ }
+}
+exports.default = Provider;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/stream.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/stream.d.ts
new file mode 100644
index 0000000..3d02a1f
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/stream.d.ts
@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { Task } from '../managers/tasks';
+import ReaderStream from '../readers/stream';
+import { ReaderOptions } from '../types';
+import Provider from './provider';
+export default class ProviderStream extends Provider<Readable> {
+ protected _reader: ReaderStream;
+ read(task: Task): Readable;
+ api(root: string, task: Task, options: ReaderOptions): Readable;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/stream.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/stream.js
new file mode 100644
index 0000000..85da62e
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/stream.js
@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const stream_2 = require("../readers/stream");
+const provider_1 = require("./provider");
+class ProviderStream extends provider_1.default {
+ constructor() {
+ super(...arguments);
+ this._reader = new stream_2.default(this._settings);
+ }
+ read(task) {
+ const root = this._getRootDirectory(task);
+ const options = this._getReaderOptions(task);
+ const source = this.api(root, task, options);
+ const destination = new stream_1.Readable({ objectMode: true, read: () => { } });
+ source
+ .once('error', (error) => destination.emit('error', error))
+ .on('data', (entry) => destination.emit('data', options.transform(entry)))
+ .once('end', () => destination.emit('end'));
+ destination
+ .once('close', () => source.destroy());
+ return destination;
+ }
+ api(root, task, options) {
+ if (task.dynamic) {
+ return this._reader.dynamic(root, options);
+ }
+ return this._reader.static(task.patterns, options);
+ }
+}
+exports.default = ProviderStream;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/sync.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/sync.d.ts
new file mode 100644
index 0000000..9c0fe1e
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/sync.d.ts
@@ -0,0 +1,9 @@
+import { Task } from '../managers/tasks';
+import ReaderSync from '../readers/sync';
+import { Entry, EntryItem, ReaderOptions } from '../types';
+import Provider from './provider';
+export default class ProviderSync extends Provider<EntryItem[]> {
+ protected _reader: ReaderSync;
+ read(task: Task): EntryItem[];
+ api(root: string, task: Task, options: ReaderOptions): Entry[];
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/sync.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/sync.js
new file mode 100644
index 0000000..d70aa1b
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/sync.js
@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sync_1 = require("../readers/sync");
+const provider_1 = require("./provider");
+class ProviderSync extends provider_1.default {
+ constructor() {
+ super(...arguments);
+ this._reader = new sync_1.default(this._settings);
+ }
+ read(task) {
+ const root = this._getRootDirectory(task);
+ const options = this._getReaderOptions(task);
+ const entries = this.api(root, task, options);
+ return entries.map(options.transform);
+ }
+ api(root, task, options) {
+ if (task.dynamic) {
+ return this._reader.dynamic(root, options);
+ }
+ return this._reader.static(task.patterns, options);
+ }
+}
+exports.default = ProviderSync;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/transformers/entry.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/providers/transformers/entry.d.ts
new file mode 100644
index 0000000..e9b85fa
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/transformers/entry.d.ts
@@ -0,0 +1,8 @@
+import Settings from '../../settings';
+import { EntryTransformerFunction } from '../../types';
+export default class EntryTransformer {
+ private readonly _settings;
+ constructor(_settings: Settings);
+ getTransformer(): EntryTransformerFunction;
+ private _transform;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/providers/transformers/entry.js b/node_modules/imagemin/node_modules/fast-glob/out/providers/transformers/entry.js
new file mode 100644
index 0000000..d11903c
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/providers/transformers/entry.js
@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+class EntryTransformer {
+ constructor(_settings) {
+ this._settings = _settings;
+ }
+ getTransformer() {
+ return (entry) => this._transform(entry);
+ }
+ _transform(entry) {
+ let filepath = entry.path;
+ if (this._settings.absolute) {
+ filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+ filepath = utils.path.unixify(filepath);
+ }
+ if (this._settings.markDirectories && entry.dirent.isDirectory()) {
+ filepath += '/';
+ }
+ if (!this._settings.objectMode) {
+ return filepath;
+ }
+ return Object.assign(Object.assign({}, entry), { path: filepath });
+ }
+}
+exports.default = EntryTransformer;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/readers/reader.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/readers/reader.d.ts
new file mode 100644
index 0000000..2af16b6
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/readers/reader.d.ts
@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+import * as fsStat from '@nodelib/fs.stat';
+import Settings from '../settings';
+import { Entry, ErrnoException, Pattern, ReaderOptions } from '../types';
+export default abstract class Reader<T> {
+ protected readonly _settings: Settings;
+ protected readonly _fsStatSettings: fsStat.Settings;
+ constructor(_settings: Settings);
+ abstract dynamic(root: string, options: ReaderOptions): T;
+ abstract static(patterns: Pattern[], options: ReaderOptions): T;
+ protected _getFullEntryPath(filepath: string): string;
+ protected _makeEntry(stats: fs.Stats, pattern: Pattern): Entry;
+ protected _isFatalError(error: ErrnoException): boolean;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/readers/reader.js b/node_modules/imagemin/node_modules/fast-glob/out/readers/reader.js
new file mode 100644
index 0000000..7b40255
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/readers/reader.js
@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fsStat = require("@nodelib/fs.stat");
+const utils = require("../utils");
+class Reader {
+ constructor(_settings) {
+ this._settings = _settings;
+ this._fsStatSettings = new fsStat.Settings({
+ followSymbolicLink: this._settings.followSymbolicLinks,
+ fs: this._settings.fs,
+ throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+ });
+ }
+ _getFullEntryPath(filepath) {
+ return path.resolve(this._settings.cwd, filepath);
+ }
+ _makeEntry(stats, pattern) {
+ const entry = {
+ name: pattern,
+ path: pattern,
+ dirent: utils.fs.createDirentFromStats(pattern, stats)
+ };
+ if (this._settings.stats) {
+ entry.stats = stats;
+ }
+ return entry;
+ }
+ _isFatalError(error) {
+ return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
+ }
+}
+exports.default = Reader;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/readers/stream.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/readers/stream.d.ts
new file mode 100644
index 0000000..1c74cac
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/readers/stream.d.ts
@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import * as fsStat from '@nodelib/fs.stat';
+import * as fsWalk from '@nodelib/fs.walk';
+import { Pattern, ReaderOptions } from '../types';
+import Reader from './reader';
+export default class ReaderStream extends Reader<Readable> {
+ protected _walkStream: typeof fsWalk.walkStream;
+ protected _stat: typeof fsStat.stat;
+ dynamic(root: string, options: ReaderOptions): Readable;
+ static(patterns: Pattern[], options: ReaderOptions): Readable;
+ private _getEntry;
+ private _getStat;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/readers/stream.js b/node_modules/imagemin/node_modules/fast-glob/out/readers/stream.js
new file mode 100644
index 0000000..317c6d5
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/readers/stream.js
@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const fsStat = require("@nodelib/fs.stat");
+const fsWalk = require("@nodelib/fs.walk");
+const reader_1 = require("./reader");
+class ReaderStream extends reader_1.default {
+ constructor() {
+ super(...arguments);
+ this._walkStream = fsWalk.walkStream;
+ this._stat = fsStat.stat;
+ }
+ dynamic(root, options) {
+ return this._walkStream(root, options);
+ }
+ static(patterns, options) {
+ const filepaths = patterns.map(this._getFullEntryPath, this);
+ const stream = new stream_1.PassThrough({ objectMode: true });
+ stream._write = (index, _enc, done) => {
+ return this._getEntry(filepaths[index], patterns[index], options)
+ .then((entry) => {
+ if (entry !== null && options.entryFilter(entry)) {
+ stream.push(entry);
+ }
+ if (index === filepaths.length - 1) {
+ stream.end();
+ }
+ done();
+ })
+ .catch(done);
+ };
+ for (let i = 0; i < filepaths.length; i++) {
+ stream.write(i);
+ }
+ return stream;
+ }
+ _getEntry(filepath, pattern, options) {
+ return this._getStat(filepath)
+ .then((stats) => this._makeEntry(stats, pattern))
+ .catch((error) => {
+ if (options.errorFilter(error)) {
+ return null;
+ }
+ throw error;
+ });
+ }
+ _getStat(filepath) {
+ return new Promise((resolve, reject) => {
+ this._stat(filepath, this._fsStatSettings, (error, stats) => {
+ return error === null ? resolve(stats) : reject(error);
+ });
+ });
+ }
+}
+exports.default = ReaderStream;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/readers/sync.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/readers/sync.d.ts
new file mode 100644
index 0000000..c96ffee
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/readers/sync.d.ts
@@ -0,0 +1,12 @@
+import * as fsStat from '@nodelib/fs.stat';
+import * as fsWalk from '@nodelib/fs.walk';
+import { Entry, Pattern, ReaderOptions } from '../types';
+import Reader from './reader';
+export default class ReaderSync extends Reader<Entry[]> {
+ protected _walkSync: typeof fsWalk.walkSync;
+ protected _statSync: typeof fsStat.statSync;
+ dynamic(root: string, options: ReaderOptions): Entry[];
+ static(patterns: Pattern[], options: ReaderOptions): Entry[];
+ private _getEntry;
+ private _getStat;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/readers/sync.js b/node_modules/imagemin/node_modules/fast-glob/out/readers/sync.js
new file mode 100644
index 0000000..4704d65
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/readers/sync.js
@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fsStat = require("@nodelib/fs.stat");
+const fsWalk = require("@nodelib/fs.walk");
+const reader_1 = require("./reader");
+class ReaderSync extends reader_1.default {
+ constructor() {
+ super(...arguments);
+ this._walkSync = fsWalk.walkSync;
+ this._statSync = fsStat.statSync;
+ }
+ dynamic(root, options) {
+ return this._walkSync(root, options);
+ }
+ static(patterns, options) {
+ const entries = [];
+ for (const pattern of patterns) {
+ const filepath = this._getFullEntryPath(pattern);
+ const entry = this._getEntry(filepath, pattern, options);
+ if (entry === null || !options.entryFilter(entry)) {
+ continue;
+ }
+ entries.push(entry);
+ }
+ return entries;
+ }
+ _getEntry(filepath, pattern, options) {
+ try {
+ const stats = this._getStat(filepath);
+ return this._makeEntry(stats, pattern);
+ }
+ catch (error) {
+ if (options.errorFilter(error)) {
+ return null;
+ }
+ throw error;
+ }
+ }
+ _getStat(filepath) {
+ return this._statSync(filepath, this._fsStatSettings);
+ }
+}
+exports.default = ReaderSync;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/settings.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/settings.d.ts
new file mode 100644
index 0000000..1984854
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/settings.d.ts
@@ -0,0 +1,164 @@
+import { FileSystemAdapter, Pattern } from './types';
+export declare const DEFAULT_FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export declare type Options = {
+ /**
+ * Return the absolute path for entries.
+ *
+ * @default false
+ */
+ absolute?: boolean;
+ /**
+ * If set to `true`, then patterns without slashes will be matched against
+ * the basename of the path if it contains slashes.
+ *
+ * @default false
+ */
+ baseNameMatch?: boolean;
+ /**
+ * Enables Bash-like brace expansion.
+ *
+ * @default true
+ */
+ braceExpansion?: boolean;
+ /**
+ * Enables a case-sensitive mode for matching files.
+ *
+ * @default true
+ */
+ caseSensitiveMatch?: boolean;
+ /**
+ * Specifies the maximum number of concurrent requests from a reader to read
+ * directories.
+ *
+ * @default os.cpus().length
+ */
+ concurrency?: number;
+ /**
+ * The current working directory in which to search.
+ *
+ * @default process.cwd()
+ */
+ cwd?: string;
+ /**
+ * Specifies the maximum depth of a read directory relative to the start
+ * directory.
+ *
+ * @default Infinity
+ */
+ deep?: number;
+ /**
+ * Allow patterns to match entries that begin with a period (`.`).
+ *
+ * @default false
+ */
+ dot?: boolean;
+ /**
+ * Enables Bash-like `extglob` functionality.
+ *
+ * @default true
+ */
+ extglob?: boolean;
+ /**
+ * Indicates whether to traverse descendants of symbolic link directories.
+ *
+ * @default true
+ */
+ followSymbolicLinks?: boolean;
+ /**
+ * Custom implementation of methods for working with the file system.
+ *
+ * @default fs.*
+ */
+ fs?: Partial<FileSystemAdapter>;
+ /**
+ * Enables recursively repeats a pattern containing `**`.
+ * If `false`, `**` behaves exactly like `*`.
+ *
+ * @default true
+ */
+ globstar?: boolean;
+ /**
+ * An array of glob patterns to exclude matches.
+ * This is an alternative way to use negative patterns.
+ *
+ * @default []
+ */
+ ignore?: Pattern[];
+ /**
+ * Mark the directory path with the final slash.
+ *
+ * @default false
+ */
+ markDirectories?: boolean;
+ /**
+ * Returns objects (instead of strings) describing entries.
+ *
+ * @default false
+ */
+ objectMode?: boolean;
+ /**
+ * Return only directories.
+ *
+ * @default false
+ */
+ onlyDirectories?: boolean;
+ /**
+ * Return only files.
+ *
+ * @default true
+ */
+ onlyFiles?: boolean;
+ /**
+ * Enables an object mode (`objectMode`) with an additional `stats` field.
+ *
+ * @default false
+ */
+ stats?: boolean;
+ /**
+ * By default this package suppress only `ENOENT` errors.
+ * Set to `true` to suppress any error.
+ *
+ * @default false
+ */
+ suppressErrors?: boolean;
+ /**
+ * Throw an error when symbolic link is broken if `true` or safely
+ * return `lstat` call if `false`.
+ *
+ * @default false
+ */
+ throwErrorOnBrokenSymbolicLink?: boolean;
+ /**
+ * Ensures that the returned entries are unique.
+ *
+ * @default true
+ */
+ unique?: boolean;
+};
+export default class Settings {
+ private readonly _options;
+ readonly absolute: boolean;
+ readonly baseNameMatch: boolean;
+ readonly braceExpansion: boolean;
+ readonly caseSensitiveMatch: boolean;
+ readonly concurrency: number;
+ readonly cwd: string;
+ readonly deep: number;
+ readonly dot: boolean;
+ readonly extglob: boolean;
+ readonly followSymbolicLinks: boolean;
+ readonly fs: FileSystemAdapter;
+ readonly globstar: boolean;
+ readonly ignore: Pattern[];
+ readonly markDirectories: boolean;
+ readonly objectMode: boolean;
+ readonly onlyDirectories: boolean;
+ readonly onlyFiles: boolean;
+ readonly stats: boolean;
+ readonly suppressErrors: boolean;
+ readonly throwErrorOnBrokenSymbolicLink: boolean;
+ readonly unique: boolean;
+ constructor(_options?: Options);
+ private _getValue;
+ private _getFileSystemMethods;
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/settings.js b/node_modules/imagemin/node_modules/fast-glob/out/settings.js
new file mode 100644
index 0000000..e91f1e8
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/settings.js
@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+const fs = require("fs");
+const os = require("os");
+const CPU_COUNT = os.cpus().length;
+exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
+ lstat: fs.lstat,
+ lstatSync: fs.lstatSync,
+ stat: fs.stat,
+ statSync: fs.statSync,
+ readdir: fs.readdir,
+ readdirSync: fs.readdirSync
+};
+class Settings {
+ constructor(_options = {}) {
+ this._options = _options;
+ this.absolute = this._getValue(this._options.absolute, false);
+ this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
+ this.braceExpansion = this._getValue(this._options.braceExpansion, true);
+ this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
+ this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
+ this.cwd = this._getValue(this._options.cwd, process.cwd());
+ this.deep = this._getValue(this._options.deep, Infinity);
+ this.dot = this._getValue(this._options.dot, false);
+ this.extglob = this._getValue(this._options.extglob, true);
+ this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
+ this.fs = this._getFileSystemMethods(this._options.fs);
+ this.globstar = this._getValue(this._options.globstar, true);
+ this.ignore = this._getValue(this._options.ignore, []);
+ this.markDirectories = this._getValue(this._options.markDirectories, false);
+ this.objectMode = this._getValue(this._options.objectMode, false);
+ this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
+ this.onlyFiles = this._getValue(this._options.onlyFiles, true);
+ this.stats = this._getValue(this._options.stats, false);
+ this.suppressErrors = this._getValue(this._options.suppressErrors, false);
+ this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
+ this.unique = this._getValue(this._options.unique, true);
+ if (this.onlyDirectories) {
+ this.onlyFiles = false;
+ }
+ if (this.stats) {
+ this.objectMode = true;
+ }
+ }
+ _getValue(option, value) {
+ return option === undefined ? value : option;
+ }
+ _getFileSystemMethods(methods = {}) {
+ return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
+ }
+}
+exports.default = Settings;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/types/index.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/types/index.d.ts
new file mode 100644
index 0000000..9950399
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/types/index.d.ts
@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import * as fsWalk from '@nodelib/fs.walk';
+export declare type ErrnoException = NodeJS.ErrnoException;
+export declare type Entry = fsWalk.Entry;
+export declare type EntryItem = string | Entry;
+export declare type Pattern = string;
+export declare type PatternRe = RegExp;
+export declare type PatternsGroup = Record<string, Pattern[]>;
+export declare type ReaderOptions = fsWalk.Options & {
+ transform(entry: Entry): EntryItem;
+ deepFilter: DeepFilterFunction;
+ entryFilter: EntryFilterFunction;
+ errorFilter: ErrorFilterFunction;
+ fs: FileSystemAdapter;
+ stats: boolean;
+};
+export declare type ErrorFilterFunction = fsWalk.ErrorFilterFunction;
+export declare type EntryFilterFunction = fsWalk.EntryFilterFunction;
+export declare type DeepFilterFunction = fsWalk.DeepFilterFunction;
+export declare type EntryTransformerFunction = (entry: Entry) => EntryItem;
+export declare type MicromatchOptions = {
+ dot?: boolean;
+ matchBase?: boolean;
+ nobrace?: boolean;
+ nocase?: boolean;
+ noext?: boolean;
+ noglobstar?: boolean;
+ posix?: boolean;
+ strictSlashes?: boolean;
+};
+export declare type FileSystemAdapter = fsWalk.FileSystemAdapter;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/types/index.js b/node_modules/imagemin/node_modules/fast-glob/out/types/index.js
new file mode 100644
index 0000000..c8ad2e5
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/types/index.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/array.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/utils/array.d.ts
new file mode 100644
index 0000000..98e7325
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/array.d.ts
@@ -0,0 +1,2 @@
+export declare function flatten<T>(items: T[][]): T[];
+export declare function splitWhen<T>(items: T[], predicate: (item: T) => boolean): T[][];
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/array.js b/node_modules/imagemin/node_modules/fast-glob/out/utils/array.js
new file mode 100644
index 0000000..50c406e
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/array.js
@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitWhen = exports.flatten = void 0;
+function flatten(items) {
+ return items.reduce((collection, item) => [].concat(collection, item), []);
+}
+exports.flatten = flatten;
+function splitWhen(items, predicate) {
+ const result = [[]];
+ let groupIndex = 0;
+ for (const item of items) {
+ if (predicate(item)) {
+ groupIndex++;
+ result[groupIndex] = [];
+ }
+ else {
+ result[groupIndex].push(item);
+ }
+ }
+ return result;
+}
+exports.splitWhen = splitWhen;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/errno.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/utils/errno.d.ts
new file mode 100644
index 0000000..1c08d3b
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/errno.d.ts
@@ -0,0 +1,2 @@
+import { ErrnoException } from '../types';
+export declare function isEnoentCodeError(error: ErrnoException): boolean;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/errno.js b/node_modules/imagemin/node_modules/fast-glob/out/utils/errno.js
new file mode 100644
index 0000000..f0bd801
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/errno.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnoentCodeError = void 0;
+function isEnoentCodeError(error) {
+ return error.code === 'ENOENT';
+}
+exports.isEnoentCodeError = isEnoentCodeError;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/fs.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/utils/fs.d.ts
new file mode 100644
index 0000000..64c61ce
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/fs.d.ts
@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+import { Dirent } from '@nodelib/fs.walk';
+export declare function createDirentFromStats(name: string, stats: fs.Stats): Dirent;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/fs.js b/node_modules/imagemin/node_modules/fast-glob/out/utils/fs.js
new file mode 100644
index 0000000..ace7c74
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/fs.js
@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDirentFromStats = void 0;
+class DirentFromStats {
+ constructor(name, stats) {
+ this.name = name;
+ this.isBlockDevice = stats.isBlockDevice.bind(stats);
+ this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+ this.isDirectory = stats.isDirectory.bind(stats);
+ this.isFIFO = stats.isFIFO.bind(stats);
+ this.isFile = stats.isFile.bind(stats);
+ this.isSocket = stats.isSocket.bind(stats);
+ this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+ }
+}
+function createDirentFromStats(name, stats) {
+ return new DirentFromStats(name, stats);
+}
+exports.createDirentFromStats = createDirentFromStats;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/index.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/utils/index.d.ts
new file mode 100644
index 0000000..f634cad
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/index.d.ts
@@ -0,0 +1,8 @@
+import * as array from './array';
+import * as errno from './errno';
+import * as fs from './fs';
+import * as path from './path';
+import * as pattern from './pattern';
+import * as stream from './stream';
+import * as string from './string';
+export { array, errno, fs, path, pattern, stream, string };
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/index.js b/node_modules/imagemin/node_modules/fast-glob/out/utils/index.js
new file mode 100644
index 0000000..0f92c16
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/index.js
@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = exports.stream = exports.pattern = exports.path = exports.fs = exports.errno = exports.array = void 0;
+const array = require("./array");
+exports.array = array;
+const errno = require("./errno");
+exports.errno = errno;
+const fs = require("./fs");
+exports.fs = fs;
+const path = require("./path");
+exports.path = path;
+const pattern = require("./pattern");
+exports.pattern = pattern;
+const stream = require("./stream");
+exports.stream = stream;
+const string = require("./string");
+exports.string = string;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/path.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/utils/path.d.ts
new file mode 100644
index 0000000..9606d8b
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/path.d.ts
@@ -0,0 +1,8 @@
+import { Pattern } from '../types';
+/**
+ * Designed to work only with simple paths: `dir\\file`.
+ */
+export declare function unixify(filepath: string): string;
+export declare function makeAbsolute(cwd: string, filepath: string): string;
+export declare function escape(pattern: Pattern): Pattern;
+export declare function removeLeadingDotSegment(entry: string): string;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/path.js b/node_modules/imagemin/node_modules/fast-glob/out/utils/path.js
new file mode 100644
index 0000000..2544032
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/path.js
@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLeadingDotSegment = exports.escape = exports.makeAbsolute = exports.unixify = void 0;
+const path = require("path");
+const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
+const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
+/**
+ * Designed to work only with simple paths: `dir\\file`.
+ */
+function unixify(filepath) {
+ return filepath.replace(/\\/g, '/');
+}
+exports.unixify = unixify;
+function makeAbsolute(cwd, filepath) {
+ return path.resolve(cwd, filepath);
+}
+exports.makeAbsolute = makeAbsolute;
+function escape(pattern) {
+ return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+exports.escape = escape;
+function removeLeadingDotSegment(entry) {
+ // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
+ // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+ if (entry.charAt(0) === '.') {
+ const secondCharactery = entry.charAt(1);
+ if (secondCharactery === '/' || secondCharactery === '\\') {
+ return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
+ }
+ }
+ return entry;
+}
+exports.removeLeadingDotSegment = removeLeadingDotSegment;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/pattern.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/utils/pattern.d.ts
new file mode 100644
index 0000000..f910eb7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/pattern.d.ts
@@ -0,0 +1,25 @@
+import { MicromatchOptions, Pattern, PatternRe } from '../types';
+declare type PatternTypeOptions = {
+ braceExpansion?: boolean;
+ caseSensitiveMatch?: boolean;
+ extglob?: boolean;
+};
+export declare function isStaticPattern(pattern: Pattern, options?: PatternTypeOptions): boolean;
+export declare function isDynamicPattern(pattern: Pattern, options?: PatternTypeOptions): boolean;
+export declare function convertToPositivePattern(pattern: Pattern): Pattern;
+export declare function convertToNegativePattern(pattern: Pattern): Pattern;
+export declare function isNegativePattern(pattern: Pattern): boolean;
+export declare function isPositivePattern(pattern: Pattern): boolean;
+export declare function getNegativePatterns(patterns: Pattern[]): Pattern[];
+export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
+export declare function getBaseDirectory(pattern: Pattern): string;
+export declare function hasGlobStar(pattern: Pattern): boolean;
+export declare function endsWithSlashGlobStar(pattern: Pattern): boolean;
+export declare function isAffectDepthOfReadingPattern(pattern: Pattern): boolean;
+export declare function expandPatternsWithBraceExpansion(patterns: Pattern[]): Pattern[];
+export declare function expandBraceExpansion(pattern: Pattern): Pattern[];
+export declare function getPatternParts(pattern: Pattern, options: MicromatchOptions): Pattern[];
+export declare function makeRe(pattern: Pattern, options: MicromatchOptions): PatternRe;
+export declare function convertPatternsToRe(patterns: Pattern[], options: MicromatchOptions): PatternRe[];
+export declare function matchAny(entry: string, patternsRe: PatternRe[]): boolean;
+export {};
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/pattern.js b/node_modules/imagemin/node_modules/fast-glob/out/utils/pattern.js
new file mode 100644
index 0000000..b82ccd0
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/pattern.js
@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0;
+const path = require("path");
+const globParent = require("glob-parent");
+const micromatch = require("micromatch");
+const picomatch = require("picomatch");
+const GLOBSTAR = '**';
+const ESCAPE_SYMBOL = '\\';
+const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
+const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[.*]/;
+const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\(.*\|.*\)/;
+const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\(.*\)/;
+const BRACE_EXPANSIONS_SYMBOLS_RE = /{.*(?:,|\.\.).*}/;
+function isStaticPattern(pattern, options = {}) {
+ return !isDynamicPattern(pattern, options);
+}
+exports.isStaticPattern = isStaticPattern;
+function isDynamicPattern(pattern, options = {}) {
+ /**
+ * A special case with an empty string is necessary for matching patterns that start with a forward slash.
+ * An empty string cannot be a dynamic pattern.
+ * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
+ */
+ if (pattern === '') {
+ return false;
+ }
+ /**
+ * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
+ * filepath directly (without read directory).
+ */
+ if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
+ return true;
+ }
+ if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
+ return true;
+ }
+ if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
+ return true;
+ }
+ if (options.braceExpansion !== false && BRACE_EXPANSIONS_SYMBOLS_RE.test(pattern)) {
+ return true;
+ }
+ return false;
+}
+exports.isDynamicPattern = isDynamicPattern;
+function convertToPositivePattern(pattern) {
+ return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
+}
+exports.convertToPositivePattern = convertToPositivePattern;
+function convertToNegativePattern(pattern) {
+ return '!' + pattern;
+}
+exports.convertToNegativePattern = convertToNegativePattern;
+function isNegativePattern(pattern) {
+ return pattern.startsWith('!') && pattern[1] !== '(';
+}
+exports.isNegativePattern = isNegativePattern;
+function isPositivePattern(pattern) {
+ return !isNegativePattern(pattern);
+}
+exports.isPositivePattern = isPositivePattern;
+function getNegativePatterns(patterns) {
+ return patterns.filter(isNegativePattern);
+}
+exports.getNegativePatterns = getNegativePatterns;
+function getPositivePatterns(patterns) {
+ return patterns.filter(isPositivePattern);
+}
+exports.getPositivePatterns = getPositivePatterns;
+function getBaseDirectory(pattern) {
+ return globParent(pattern, { flipBackslashes: false });
+}
+exports.getBaseDirectory = getBaseDirectory;
+function hasGlobStar(pattern) {
+ return pattern.includes(GLOBSTAR);
+}
+exports.hasGlobStar = hasGlobStar;
+function endsWithSlashGlobStar(pattern) {
+ return pattern.endsWith('/' + GLOBSTAR);
+}
+exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
+function isAffectDepthOfReadingPattern(pattern) {
+ const basename = path.basename(pattern);
+ return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+}
+exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+function expandPatternsWithBraceExpansion(patterns) {
+ return patterns.reduce((collection, pattern) => {
+ return collection.concat(expandBraceExpansion(pattern));
+ }, []);
+}
+exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
+function expandBraceExpansion(pattern) {
+ return micromatch.braces(pattern, {
+ expand: true,
+ nodupes: true
+ });
+}
+exports.expandBraceExpansion = expandBraceExpansion;
+function getPatternParts(pattern, options) {
+ let { parts } = picomatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
+ /**
+ * The scan method returns an empty array in some cases.
+ * See micromatch/picomatch#58 for more details.
+ */
+ if (parts.length === 0) {
+ parts = [pattern];
+ }
+ /**
+ * The scan method does not return an empty part for the pattern with a forward slash.
+ * This is another part of micromatch/picomatch#58.
+ */
+ if (parts[0].startsWith('/')) {
+ parts[0] = parts[0].slice(1);
+ parts.unshift('');
+ }
+ return parts;
+}
+exports.getPatternParts = getPatternParts;
+function makeRe(pattern, options) {
+ return micromatch.makeRe(pattern, options);
+}
+exports.makeRe = makeRe;
+function convertPatternsToRe(patterns, options) {
+ return patterns.map((pattern) => makeRe(pattern, options));
+}
+exports.convertPatternsToRe = convertPatternsToRe;
+function matchAny(entry, patternsRe) {
+ return patternsRe.some((patternRe) => patternRe.test(entry));
+}
+exports.matchAny = matchAny;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/stream.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/utils/stream.d.ts
new file mode 100644
index 0000000..aafacef
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/stream.d.ts
@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+export declare function merge(streams: Readable[]): NodeJS.ReadableStream;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/stream.js b/node_modules/imagemin/node_modules/fast-glob/out/utils/stream.js
new file mode 100644
index 0000000..b32028c
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/stream.js
@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = void 0;
+const merge2 = require("merge2");
+function merge(streams) {
+ const mergedStream = merge2(streams);
+ streams.forEach((stream) => {
+ stream.once('error', (error) => mergedStream.emit('error', error));
+ });
+ mergedStream.once('close', () => propagateCloseEventToSources(streams));
+ mergedStream.once('end', () => propagateCloseEventToSources(streams));
+ return mergedStream;
+}
+exports.merge = merge;
+function propagateCloseEventToSources(streams) {
+ streams.forEach((stream) => stream.emit('close'));
+}
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/string.d.ts b/node_modules/imagemin/node_modules/fast-glob/out/utils/string.d.ts
new file mode 100644
index 0000000..c884735
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/string.d.ts
@@ -0,0 +1,2 @@
+export declare function isString(input: unknown): input is string;
+export declare function isEmpty(input: string): boolean;
diff --git a/node_modules/imagemin/node_modules/fast-glob/out/utils/string.js b/node_modules/imagemin/node_modules/fast-glob/out/utils/string.js
new file mode 100644
index 0000000..76e7ea5
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/out/utils/string.js
@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = exports.isString = void 0;
+function isString(input) {
+ return typeof input === 'string';
+}
+exports.isString = isString;
+function isEmpty(input) {
+ return input === '';
+}
+exports.isEmpty = isEmpty;
diff --git a/node_modules/imagemin/node_modules/fast-glob/package.json b/node_modules/imagemin/node_modules/fast-glob/package.json
new file mode 100644
index 0000000..2764442
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fast-glob/package.json
@@ -0,0 +1,120 @@
+{
+ "_from": "fast-glob@^3.0.3",
+ "_id": "fast-glob@3.2.4",
+ "_inBundle": false,
+ "_integrity": "sha512-kr/Oo6PX51265qeuCYsyGypiO5uJFgBS0jksyG7FUeCyQzNwYnzrNIMR1NXfkZXsMYXYLRAHgISHBz8gQcxKHQ==",
+ "_location": "/imagemin/fast-glob",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "fast-glob@^3.0.3",
+ "name": "fast-glob",
+ "escapedName": "fast-glob",
+ "rawSpec": "^3.0.3",
+ "saveSpec": null,
+ "fetchSpec": "^3.0.3"
+ },
+ "_requiredBy": [
+ "/imagemin/globby"
+ ],
+ "_resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.4.tgz",
+ "_shasum": "d20aefbf99579383e7f3cc66529158c9b98554d3",
+ "_spec": "fast-glob@^3.0.3",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\globby",
+ "author": {
+ "name": "Denis Malinochkin",
+ "url": "https://mrmlnc.com"
+ },
+ "bugs": {
+ "url": "https://github.com/mrmlnc/fast-glob/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "@nodelib/fs.stat": "^2.0.2",
+ "@nodelib/fs.walk": "^1.2.3",
+ "glob-parent": "^5.1.0",
+ "merge2": "^1.3.0",
+ "micromatch": "^4.0.2",
+ "picomatch": "^2.2.1"
+ },
+ "deprecated": false,
+ "description": "It's a very fast and efficient glob library for Node.js",
+ "devDependencies": {
+ "@nodelib/fs.macchiato": "^1.0.1",
+ "@types/compute-stdev": "^1.0.0",
+ "@types/easy-table": "^0.0.32",
+ "@types/glob": "^7.1.1",
+ "@types/glob-parent": "^5.1.0",
+ "@types/is-ci": "^2.0.0",
+ "@types/merge2": "^1.1.4",
+ "@types/micromatch": "^4.0.0",
+ "@types/minimist": "^1.2.0",
+ "@types/mocha": "^5.2.7",
+ "@types/node": "^12.7.8",
+ "@types/rimraf": "^2.0.2",
+ "@types/sinon": "^7.5.0",
+ "compute-stdev": "^1.0.0",
+ "easy-table": "^1.1.1",
+ "eslint": "^6.5.1",
+ "eslint-config-mrmlnc": "^1.1.0",
+ "execa": "^2.0.4",
+ "fast-glob": "^3.0.4",
+ "glob": "^7.1.4",
+ "is-ci": "^2.0.0",
+ "log-update": "^4.0.0",
+ "minimist": "^1.2.0",
+ "mocha": "^6.2.1",
+ "rimraf": "^3.0.0",
+ "sinon": "^7.5.0",
+ "tiny-glob": "^0.2.6",
+ "typescript": "^3.6.3"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "homepage": "https://github.com/mrmlnc/fast-glob#readme",
+ "keywords": [
+ "glob",
+ "patterns",
+ "fast",
+ "implementation"
+ ],
+ "license": "MIT",
+ "main": "out/index.js",
+ "name": "fast-glob",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/mrmlnc/fast-glob.git"
+ },
+ "scripts": {
+ "bench": "npm run bench-async && npm run bench-stream && npm run bench-sync",
+ "bench-async": "npm run bench-async-flatten && npm run bench-async-deep && npm run bench-async-partial-flatten && npm run bench-async-partial-deep",
+ "bench-async-deep": "node ./out/benchmark --mode async --pattern \"**\"",
+ "bench-async-flatten": "node ./out/benchmark --mode async --pattern \"*\"",
+ "bench-async-partial-deep": "node ./out/benchmark --mode async --pattern \"{fixtures,out}/**\"",
+ "bench-async-partial-flatten": "node ./out/benchmark --mode async --pattern \"{fixtures,out}/{first,second}/*\"",
+ "bench-stream": "npm run bench-stream-flatten && npm run bench-stream-deep && npm run bench-stream-partial-flatten && npm run bench-stream-partial-deep",
+ "bench-stream-deep": "node ./out/benchmark --mode stream --pattern \"**\"",
+ "bench-stream-flatten": "node ./out/benchmark --mode stream --pattern \"*\"",
+ "bench-stream-partial-deep": "node ./out/benchmark --mode stream --pattern \"{fixtures,out}/**\"",
+ "bench-stream-partial-flatten": "node ./out/benchmark --mode stream --pattern \"{fixtures,out}/{first,second}/*\"",
+ "bench-sync": "npm run bench-sync-flatten && npm run bench-sync-deep && npm run bench-sync-partial-flatten && npm run bench-sync-partial-deep",
+ "bench-sync-deep": "node ./out/benchmark --mode sync --pattern \"**\"",
+ "bench-sync-flatten": "node ./out/benchmark --mode sync --pattern \"*\"",
+ "bench-sync-partial-deep": "node ./out/benchmark --mode sync --pattern \"{fixtures,out}/**\"",
+ "bench-sync-partial-flatten": "node ./out/benchmark --mode sync --pattern \"{fixtures,out}/{first,second}/*\"",
+ "build": "npm run clean && npm run compile && npm run lint && npm test",
+ "clean": "rimraf out",
+ "compile": "tsc",
+ "lint": "eslint \"src/**/*.ts\" --cache",
+ "smoke": "mocha \"out/**/*.smoke.js\" -s 0",
+ "smoke:async": "mocha \"out/**/*.smoke.js\" -s 0 --grep \"\\(async\\)\"",
+ "smoke:stream": "mocha \"out/**/*.smoke.js\" -s 0 --grep \"\\(stream\\)\"",
+ "smoke:sync": "mocha \"out/**/*.smoke.js\" -s 0 --grep \"\\(sync\\)\"",
+ "test": "mocha \"out/**/*.spec.js\" -s 0",
+ "watch": "npm run clean && npm run compile -- --sourceMap --watch"
+ },
+ "typings": "out/index.d.ts",
+ "version": "3.2.4"
+}
diff --git a/node_modules/imagemin/node_modules/file-type/index.d.ts b/node_modules/imagemin/node_modules/file-type/index.d.ts
new file mode 100644
index 0000000..d0d9ca6
--- /dev/null
+++ b/node_modules/imagemin/node_modules/file-type/index.d.ts
@@ -0,0 +1,337 @@
+/// <reference types="node"/>
+import {Readable as ReadableStream} from 'stream';
+
+declare namespace fileType {
+ type FileType =
+ | 'jpg'
+ | 'png'
+ | 'apng'
+ | 'gif'
+ | 'webp'
+ | 'flif'
+ | 'cr2'
+ | 'orf'
+ | 'arw'
+ | 'dng'
+ | 'nef'
+ | 'rw2'
+ | 'raf'
+ | 'tif'
+ | 'bmp'
+ | 'jxr'
+ | 'psd'
+ | 'zip'
+ | 'tar'
+ | 'rar'
+ | 'gz'
+ | 'bz2'
+ | '7z'
+ | 'dmg'
+ | 'mp4'
+ | 'mid'
+ | 'mkv'
+ | 'webm'
+ | 'mov'
+ | 'avi'
+ | 'wmv'
+ | 'mpg'
+ | 'mp2'
+ | 'mp3'
+ | 'm4a'
+ | 'ogg'
+ | 'opus'
+ | 'flac'
+ | 'wav'
+ | 'qcp'
+ | 'amr'
+ | 'pdf'
+ | 'epub'
+ | 'mobi'
+ | 'exe'
+ | 'swf'
+ | 'rtf'
+ | 'woff'
+ | 'woff2'
+ | 'eot'
+ | 'ttf'
+ | 'otf'
+ | 'ico'
+ | 'flv'
+ | 'ps'
+ | 'xz'
+ | 'sqlite'
+ | 'nes'
+ | 'crx'
+ | 'xpi'
+ | 'cab'
+ | 'deb'
+ | 'ar'
+ | 'rpm'
+ | 'Z'
+ | 'lz'
+ | 'msi'
+ | 'mxf'
+ | 'mts'
+ | 'wasm'
+ | 'blend'
+ | 'bpg'
+ | 'docx'
+ | 'pptx'
+ | 'xlsx'
+ | '3gp'
+ | '3g2'
+ | 'jp2'
+ | 'jpm'
+ | 'jpx'
+ | 'mj2'
+ | 'aif'
+ | 'odt'
+ | 'ods'
+ | 'odp'
+ | 'xml'
+ | 'heic'
+ | 'cur'
+ | 'ktx'
+ | 'ape'
+ | 'wv'
+ | 'asf'
+ | 'wma'
+ | 'dcm'
+ | 'mpc'
+ | 'ics'
+ | 'glb'
+ | 'pcap'
+ | 'dsf'
+ | 'lnk'
+ | 'alias'
+ | 'voc'
+ | 'ac3'
+ | 'm4b'
+ | 'm4p'
+ | 'm4v'
+ | 'f4a'
+ | 'f4b'
+ | 'f4p'
+ | 'f4v'
+ | 'mie'
+ | 'ogv'
+ | 'ogm'
+ | 'oga'
+ | 'spx'
+ | 'ogx'
+ | 'arrow'
+ | 'shp';
+
+ type MimeType =
+ | 'image/jpeg'
+ | 'image/png'
+ | 'image/gif'
+ | 'image/webp'
+ | 'image/flif'
+ | 'image/x-canon-cr2'
+ | 'image/tiff'
+ | 'image/bmp'
+ | 'image/vnd.ms-photo'
+ | 'image/vnd.adobe.photoshop'
+ | 'application/epub+zip'
+ | 'application/x-xpinstall'
+ | 'application/vnd.oasis.opendocument.text'
+ | 'application/vnd.oasis.opendocument.spreadsheet'
+ | 'application/vnd.oasis.opendocument.presentation'
+ | 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+ | 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+ | 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+ | 'application/zip'
+ | 'application/x-tar'
+ | 'application/x-rar-compressed'
+ | 'application/gzip'
+ | 'application/x-bzip2'
+ | 'application/x-7z-compressed'
+ | 'application/x-apple-diskimage'
+ | 'video/mp4'
+ | 'audio/midi'
+ | 'video/x-matroska'
+ | 'video/webm'
+ | 'video/quicktime'
+ | 'video/vnd.avi'
+ | 'audio/vnd.wave'
+ | 'audio/qcelp'
+ | 'audio/x-ms-wma'
+ | 'video/x-ms-asf'
+ | 'application/vnd.ms-asf'
+ | 'video/mpeg'
+ | 'video/3gpp'
+ | 'audio/mpeg'
+ | 'audio/mp4' // RFC 4337
+ | 'audio/opus'
+ | 'video/ogg'
+ | 'audio/ogg'
+ | 'application/ogg'
+ | 'audio/x-flac'
+ | 'audio/ape'
+ | 'audio/wavpack'
+ | 'audio/amr'
+ | 'application/pdf'
+ | 'application/x-msdownload'
+ | 'application/x-shockwave-flash'
+ | 'application/rtf'
+ | 'application/wasm'
+ | 'font/woff'
+ | 'font/woff2'
+ | 'application/vnd.ms-fontobject'
+ | 'font/ttf'
+ | 'font/otf'
+ | 'image/x-icon'
+ | 'video/x-flv'
+ | 'application/postscript'
+ | 'application/x-xz'
+ | 'application/x-sqlite3'
+ | 'application/x-nintendo-nes-rom'
+ | 'application/x-google-chrome-extension'
+ | 'application/vnd.ms-cab-compressed'
+ | 'application/x-deb'
+ | 'application/x-unix-archive'
+ | 'application/x-rpm'
+ | 'application/x-compress'
+ | 'application/x-lzip'
+ | 'application/x-msi'
+ | 'application/x-mie'
+ | 'application/x-apache-arrow'
+ | 'application/mxf'
+ | 'video/mp2t'
+ | 'application/x-blender'
+ | 'image/bpg'
+ | 'image/jp2'
+ | 'image/jpx'
+ | 'image/jpm'
+ | 'image/mj2'
+ | 'audio/aiff'
+ | 'application/xml'
+ | 'application/x-mobipocket-ebook'
+ | 'image/heif'
+ | 'image/heif-sequence'
+ | 'image/heic'
+ | 'image/heic-sequence'
+ | 'image/ktx'
+ | 'application/dicom'
+ | 'audio/x-musepack'
+ | 'text/calendar'
+ | 'model/gltf-binary'
+ | 'application/vnd.tcpdump.pcap'
+ | 'audio/x-dsf' // Non-standard
+ | 'application/x.ms.shortcut' // Invented by us
+ | 'application/x.apple.alias' // Invented by us
+ | 'audio/x-voc'
+ | 'audio/vnd.dolby.dd-raw'
+ | 'audio/x-m4a'
+ | 'image/apng'
+ | 'image/x-olympus-orf'
+ | 'image/x-sony-arw'
+ | 'image/x-adobe-dng'
+ | 'image/x-nikon-nef'
+ | 'image/x-panasonic-rw2'
+ | 'image/x-fujifilm-raf'
+ | 'video/x-m4v'
+ | 'video/3gpp2'
+ | 'application/x-esri-shape';
+
+ interface FileTypeResult {
+ /**
+ One of the supported [file types](https://github.com/sindresorhus/file-type#supported-file-types).
+ */
+ ext: FileType;
+
+ /**
+ The detected [MIME type](https://en.wikipedia.org/wiki/Internet_media_type).
+ */
+ mime: MimeType;
+ }
+
+ type ReadableStreamWithFileType = ReadableStream & {
+ readonly fileType?: FileTypeResult;
+ };
+}
+
+declare const fileType: {
+ /**
+ Detect the file type of a `Buffer`/`Uint8Array`/`ArrayBuffer`. The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
+
+ @param buffer - It only needs the first `.minimumBytes` bytes. The exception is detection of `docx`, `pptx`, and `xlsx` which potentially requires reading the whole file.
+ @returns The detected file type and MIME type or `undefined` when there was no match.
+
+ @example
+ ```
+ import readChunk = require('read-chunk');
+ import fileType = require('file-type');
+
+ const buffer = readChunk.sync('unicorn.png', 0, fileType.minimumBytes);
+
+ fileType(buffer);
+ //=> {ext: 'png', mime: 'image/png'}
+
+
+ // Or from a remote location:
+
+ import * as http from 'http';
+
+ const url = 'https://assets-cdn.github.com/images/spinners/octocat-spinner-32.gif';
+
+ http.get(url, response => {
+ response.on('readable', () => {
+ const chunk = response.read(fileType.minimumBytes);
+ response.destroy();
+ console.log(fileType(chunk));
+ //=> {ext: 'gif', mime: 'image/gif'}
+ });
+ });
+ ```
+ */
+ (buffer: Buffer | Uint8Array | ArrayBuffer): fileType.FileTypeResult | undefined;
+
+ /**
+ The minimum amount of bytes needed to detect a file type. Currently, it's 4100 bytes, but it can change, so don't hard-code it.
+ */
+ readonly minimumBytes: number;
+
+ /**
+ Supported file extensions.
+ */
+ readonly extensions: readonly fileType.FileType[];
+
+ /**
+ Supported MIME types.
+ */
+ readonly mimeTypes: readonly fileType.MimeType[];
+
+ /**
+ Detect the file type of a readable stream.
+
+ @param readableStream - A readable stream containing a file to examine, see: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+ @returns A `Promise` which resolves to the original readable stream argument, but with an added `fileType` property, which is an object like the one returned from `fileType()`.
+
+ @example
+ ```
+ import * as fs from 'fs';
+ import * as crypto from 'crypto';
+ import fileType = require('file-type');
+
+ (async () => {
+ const read = fs.createReadStream('encrypted.enc');
+ const decipher = crypto.createDecipheriv(alg, key, iv);
+
+ const stream = await fileType.stream(read.pipe(decipher));
+
+ console.log(stream.fileType);
+ //=> {ext: 'mov', mime: 'video/quicktime'}
+
+ const write = fs.createWriteStream(`decrypted.${stream.fileType.ext}`);
+ stream.pipe(write);
+ })();
+ ```
+ */
+ readonly stream: (
+ readableStream: ReadableStream
+ ) => Promise<fileType.ReadableStreamWithFileType>;
+};
+
+export = fileType;
diff --git a/node_modules/imagemin/node_modules/file-type/index.js b/node_modules/imagemin/node_modules/file-type/index.js
new file mode 100644
index 0000000..53fb7a4
--- /dev/null
+++ b/node_modules/imagemin/node_modules/file-type/index.js
@@ -0,0 +1,1077 @@
+'use strict';
+const {
+ multiByteIndexOf,
+ stringToBytes,
+ readUInt64LE,
+ tarHeaderChecksumMatches,
+ uint8ArrayUtf8ByteString
+} = require('./util');
+const supported = require('./supported');
+
+const xpiZipFilename = stringToBytes('META-INF/mozilla.rsa');
+const oxmlContentTypes = stringToBytes('[Content_Types].xml');
+const oxmlRels = stringToBytes('_rels/.rels');
+
+const fileType = input => {
+ if (!(input instanceof Uint8Array || input instanceof ArrayBuffer || Buffer.isBuffer(input))) {
+ throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
+ }
+
+ const buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
+
+ if (!(buffer && buffer.length > 1)) {
+ return;
+ }
+
+ const check = (header, options) => {
+ options = {
+ offset: 0,
+ ...options
+ };
+
+ for (let i = 0; i < header.length; i++) {
+ // If a bitmask is set
+ if (options.mask) {
+ // If header doesn't equal `buf` with bits masked off
+ if (header[i] !== (options.mask[i] & buffer[i + options.offset])) {
+ return false;
+ }
+ } else if (header[i] !== buffer[i + options.offset]) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ const checkString = (header, options) => check(stringToBytes(header), options);
+
+ if (check([0xFF, 0xD8, 0xFF])) {
+ return {
+ ext: 'jpg',
+ mime: 'image/jpeg'
+ };
+ }
+
+ if (check([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])) {
+ // APNG format (https://wiki.mozilla.org/APNG_Specification)
+ // 1. Find the first IDAT (image data) chunk (49 44 41 54)
+ // 2. Check if there is an "acTL" chunk before the IDAT one (61 63 54 4C)
+
+ // Offset calculated as follows:
+ // - 8 bytes: PNG signature
+ // - 4 (length) + 4 (chunk type) + 13 (chunk data) + 4 (CRC): IHDR chunk
+ const startIndex = 33;
+ const firstImageDataChunkIndex = buffer.findIndex((el, i) => i >= startIndex && buffer[i] === 0x49 && buffer[i + 1] === 0x44 && buffer[i + 2] === 0x41 && buffer[i + 3] === 0x54);
+ const sliced = buffer.subarray(startIndex, firstImageDataChunkIndex);
+
+ if (sliced.findIndex((el, i) => sliced[i] === 0x61 && sliced[i + 1] === 0x63 && sliced[i + 2] === 0x54 && sliced[i + 3] === 0x4C) >= 0) {
+ return {
+ ext: 'apng',
+ mime: 'image/apng'
+ };
+ }
+
+ return {
+ ext: 'png',
+ mime: 'image/png'
+ };
+ }
+
+ if (check([0x47, 0x49, 0x46])) {
+ return {
+ ext: 'gif',
+ mime: 'image/gif'
+ };
+ }
+
+ if (check([0x57, 0x45, 0x42, 0x50], {offset: 8})) {
+ return {
+ ext: 'webp',
+ mime: 'image/webp'
+ };
+ }
+
+ if (check([0x46, 0x4C, 0x49, 0x46])) {
+ return {
+ ext: 'flif',
+ mime: 'image/flif'
+ };
+ }
+
+ // `cr2`, `orf`, and `arw` need to be before `tif` check
+ if (
+ (check([0x49, 0x49, 0x2A, 0x0]) || check([0x4D, 0x4D, 0x0, 0x2A])) &&
+ check([0x43, 0x52], {offset: 8})
+ ) {
+ return {
+ ext: 'cr2',
+ mime: 'image/x-canon-cr2'
+ };
+ }
+
+ if (check([0x49, 0x49, 0x52, 0x4F, 0x08, 0x00, 0x00, 0x00, 0x18])) {
+ return {
+ ext: 'orf',
+ mime: 'image/x-olympus-orf'
+ };
+ }
+
+ if (
+ check([0x49, 0x49, 0x2A, 0x00]) &&
+ (check([0x10, 0xFB, 0x86, 0x01], {offset: 4}) || check([0x08, 0x00, 0x00, 0x00], {offset: 4})) &&
+ // This pattern differentiates ARW from other TIFF-ish file types:
+ check([0x00, 0xFE, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x01], {offset: 9})
+ ) {
+ return {
+ ext: 'arw',
+ mime: 'image/x-sony-arw'
+ };
+ }
+
+ if (
+ check([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00]) &&
+ (check([0x2D, 0x00, 0xFE, 0x00], {offset: 8}) ||
+ check([0x27, 0x00, 0xFE, 0x00], {offset: 8}))
+ ) {
+ return {
+ ext: 'dng',
+ mime: 'image/x-adobe-dng'
+ };
+ }
+
+ if (
+ check([0x49, 0x49, 0x2A, 0x00]) &&
+ check([0x1C, 0x00, 0xFE, 0x00], {offset: 8})
+ ) {
+ return {
+ ext: 'nef',
+ mime: 'image/x-nikon-nef'
+ };
+ }
+
+ if (check([0x49, 0x49, 0x55, 0x00, 0x18, 0x00, 0x00, 0x00, 0x88, 0xE7, 0x74, 0xD8])) {
+ return {
+ ext: 'rw2',
+ mime: 'image/x-panasonic-rw2'
+ };
+ }
+
+ // `raf` is here just to keep all the raw image detectors together.
+ if (checkString('FUJIFILMCCD-RAW')) {
+ return {
+ ext: 'raf',
+ mime: 'image/x-fujifilm-raf'
+ };
+ }
+
+ if (
+ check([0x49, 0x49, 0x2A, 0x0]) ||
+ check([0x4D, 0x4D, 0x0, 0x2A])
+ ) {
+ return {
+ ext: 'tif',
+ mime: 'image/tiff'
+ };
+ }
+
+ if (check([0x42, 0x4D])) {
+ return {
+ ext: 'bmp',
+ mime: 'image/bmp'
+ };
+ }
+
+ if (check([0x49, 0x49, 0xBC])) {
+ return {
+ ext: 'jxr',
+ mime: 'image/vnd.ms-photo'
+ };
+ }
+
+ if (check([0x38, 0x42, 0x50, 0x53])) {
+ return {
+ ext: 'psd',
+ mime: 'image/vnd.adobe.photoshop'
+ };
+ }
+
+ // Zip-based file formats
+ // Need to be before the `zip` check
+ const zipHeader = [0x50, 0x4B, 0x3, 0x4];
+ if (check(zipHeader)) {
+ if (
+ check([0x6D, 0x69, 0x6D, 0x65, 0x74, 0x79, 0x70, 0x65, 0x61, 0x70, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2F, 0x65, 0x70, 0x75, 0x62, 0x2B, 0x7A, 0x69, 0x70], {offset: 30})
+ ) {
+ return {
+ ext: 'epub',
+ mime: 'application/epub+zip'
+ };
+ }
+
+ // Assumes signed `.xpi` from addons.mozilla.org
+ if (check(xpiZipFilename, {offset: 30})) {
+ return {
+ ext: 'xpi',
+ mime: 'application/x-xpinstall'
+ };
+ }
+
+ if (checkString('mimetypeapplication/vnd.oasis.opendocument.text', {offset: 30})) {
+ return {
+ ext: 'odt',
+ mime: 'application/vnd.oasis.opendocument.text'
+ };
+ }
+
+ if (checkString('mimetypeapplication/vnd.oasis.opendocument.spreadsheet', {offset: 30})) {
+ return {
+ ext: 'ods',
+ mime: 'application/vnd.oasis.opendocument.spreadsheet'
+ };
+ }
+
+ if (checkString('mimetypeapplication/vnd.oasis.opendocument.presentation', {offset: 30})) {
+ return {
+ ext: 'odp',
+ mime: 'application/vnd.oasis.opendocument.presentation'
+ };
+ }
+
+ // The docx, xlsx and pptx file types extend the Office Open XML file format:
+ // https://en.wikipedia.org/wiki/Office_Open_XML_file_formats
+ // We look for:
+ // - one entry named '[Content_Types].xml' or '_rels/.rels',
+ // - one entry indicating specific type of file.
+ // MS Office, OpenOffice and LibreOffice may put the parts in different order, so the check should not rely on it.
+ let zipHeaderIndex = 0; // The first zip header was already found at index 0
+ let oxmlFound = false;
+ let type;
+
+ do {
+ const offset = zipHeaderIndex + 30;
+
+ if (!oxmlFound) {
+ oxmlFound = (check(oxmlContentTypes, {offset}) || check(oxmlRels, {offset}));
+ }
+
+ if (!type) {
+ if (checkString('word/', {offset})) {
+ type = {
+ ext: 'docx',
+ mime: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+ };
+ } else if (checkString('ppt/', {offset})) {
+ type = {
+ ext: 'pptx',
+ mime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+ };
+ } else if (checkString('xl/', {offset})) {
+ type = {
+ ext: 'xlsx',
+ mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+ };
+ }
+ }
+
+ if (oxmlFound && type) {
+ return type;
+ }
+
+ zipHeaderIndex = multiByteIndexOf(buffer, zipHeader, offset);
+ } while (zipHeaderIndex >= 0);
+
+ // No more zip parts available in the buffer, but maybe we are almost certain about the type?
+ if (type) {
+ return type;
+ }
+ }
+
+ if (
+ check([0x50, 0x4B]) &&
+ (buffer[2] === 0x3 || buffer[2] === 0x5 || buffer[2] === 0x7) &&
+ (buffer[3] === 0x4 || buffer[3] === 0x6 || buffer[3] === 0x8)
+ ) {
+ return {
+ ext: 'zip',
+ mime: 'application/zip'
+ };
+ }
+
+ if (
+ check([0x30, 0x30, 0x30, 0x30, 0x30, 0x30], {offset: 148, mask: [0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8]}) && // Valid tar checksum
+ tarHeaderChecksumMatches(buffer)
+ ) {
+ return {
+ ext: 'tar',
+ mime: 'application/x-tar'
+ };
+ }
+
+ if (
+ check([0x52, 0x61, 0x72, 0x21, 0x1A, 0x7]) &&
+ (buffer[6] === 0x0 || buffer[6] === 0x1)
+ ) {
+ return {
+ ext: 'rar',
+ mime: 'application/x-rar-compressed'
+ };
+ }
+
+ if (check([0x1F, 0x8B, 0x8])) {
+ return {
+ ext: 'gz',
+ mime: 'application/gzip'
+ };
+ }
+
+ if (check([0x42, 0x5A, 0x68])) {
+ return {
+ ext: 'bz2',
+ mime: 'application/x-bzip2'
+ };
+ }
+
+ if (check([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])) {
+ return {
+ ext: '7z',
+ mime: 'application/x-7z-compressed'
+ };
+ }
+
+ if (check([0x78, 0x01])) {
+ return {
+ ext: 'dmg',
+ mime: 'application/x-apple-diskimage'
+ };
+ }
+
+ // `mov` format variants
+ if (
+ check([0x66, 0x72, 0x65, 0x65], {offset: 4}) || // `free`
+ check([0x6D, 0x64, 0x61, 0x74], {offset: 4}) || // `mdat` MJPEG
+ check([0x6D, 0x6F, 0x6F, 0x76], {offset: 4}) || // `moov`
+ check([0x77, 0x69, 0x64, 0x65], {offset: 4}) // `wide`
+ ) {
+ return {
+ ext: 'mov',
+ mime: 'video/quicktime'
+ };
+ }
+
+ // File Type Box (https://en.wikipedia.org/wiki/ISO_base_media_file_format)
+ // It's not required to be first, but it's recommended to be. Almost all ISO base media files start with `ftyp` box.
+ // `ftyp` box must contain a brand major identifier, which must consist of ISO 8859-1 printable characters.
+ // Here we check for 8859-1 printable characters (for simplicity, it's a mask which also catches one non-printable character).
+ if (
+ checkString('ftyp', {offset: 4}) &&
+ (buffer[8] & 0x60) !== 0x00 // Brand major, first character ASCII?
+ ) {
+ // They all can have MIME `video/mp4` except `application/mp4` special-case which is hard to detect.
+ // For some cases, we're specific, everything else falls to `video/mp4` with `mp4` extension.
+ const brandMajor = uint8ArrayUtf8ByteString(buffer, 8, 12).replace('\0', ' ').trim();
+ switch (brandMajor) {
+ case 'mif1':
+ return {ext: 'heic', mime: 'image/heif'};
+ case 'msf1':
+ return {ext: 'heic', mime: 'image/heif-sequence'};
+ case 'heic': case 'heix':
+ return {ext: 'heic', mime: 'image/heic'};
+ case 'hevc': case 'hevx':
+ return {ext: 'heic', mime: 'image/heic-sequence'};
+ case 'qt':
+ return {ext: 'mov', mime: 'video/quicktime'};
+ case 'M4V': case 'M4VH': case 'M4VP':
+ return {ext: 'm4v', mime: 'video/x-m4v'};
+ case 'M4P':
+ return {ext: 'm4p', mime: 'video/mp4'};
+ case 'M4B':
+ return {ext: 'm4b', mime: 'audio/mp4'};
+ case 'M4A':
+ return {ext: 'm4a', mime: 'audio/x-m4a'};
+ case 'F4V':
+ return {ext: 'f4v', mime: 'video/mp4'};
+ case 'F4P':
+ return {ext: 'f4p', mime: 'video/mp4'};
+ case 'F4A':
+ return {ext: 'f4a', mime: 'audio/mp4'};
+ case 'F4B':
+ return {ext: 'f4b', mime: 'audio/mp4'};
+ default:
+ if (brandMajor.startsWith('3g')) {
+ if (brandMajor.startsWith('3g2')) {
+ return {ext: '3g2', mime: 'video/3gpp2'};
+ }
+
+ return {ext: '3gp', mime: 'video/3gpp'};
+ }
+
+ return {ext: 'mp4', mime: 'video/mp4'};
+ }
+ }
+
+ if (check([0x4D, 0x54, 0x68, 0x64])) {
+ return {
+ ext: 'mid',
+ mime: 'audio/midi'
+ };
+ }
+
+ // https://github.com/threatstack/libmagic/blob/master/magic/Magdir/matroska
+ if (check([0x1A, 0x45, 0xDF, 0xA3])) {
+ const sliced = buffer.subarray(4, 4 + 4096);
+ const idPos = sliced.findIndex((el, i, arr) => arr[i] === 0x42 && arr[i + 1] === 0x82);
+
+ if (idPos !== -1) {
+ const docTypePos = idPos + 3;
+ const findDocType = type => [...type].every((c, i) => sliced[docTypePos + i] === c.charCodeAt(0));
+
+ if (findDocType('matroska')) {
+ return {
+ ext: 'mkv',
+ mime: 'video/x-matroska'
+ };
+ }
+
+ if (findDocType('webm')) {
+ return {
+ ext: 'webm',
+ mime: 'video/webm'
+ };
+ }
+ }
+ }
+
+ // RIFF file format which might be AVI, WAV, QCP, etc
+ if (check([0x52, 0x49, 0x46, 0x46])) {
+ if (check([0x41, 0x56, 0x49], {offset: 8})) {
+ return {
+ ext: 'avi',
+ mime: 'video/vnd.avi'
+ };
+ }
+
+ if (check([0x57, 0x41, 0x56, 0x45], {offset: 8})) {
+ return {
+ ext: 'wav',
+ mime: 'audio/vnd.wave'
+ };
+ }
+
+ // QLCM, QCP file
+ if (check([0x51, 0x4C, 0x43, 0x4D], {offset: 8})) {
+ return {
+ ext: 'qcp',
+ mime: 'audio/qcelp'
+ };
+ }
+ }
+
+ // ASF_Header_Object first 80 bytes
+ if (check([0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11, 0xA6, 0xD9])) {
+ // Search for header should be in first 1KB of file.
+
+ let offset = 30;
+ do {
+ const objectSize = readUInt64LE(buffer, offset + 16);
+ if (check([0x91, 0x07, 0xDC, 0xB7, 0xB7, 0xA9, 0xCF, 0x11, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65], {offset})) {
+ // Sync on Stream-Properties-Object (B7DC0791-A9B7-11CF-8EE6-00C00C205365)
+ if (check([0x40, 0x9E, 0x69, 0xF8, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B], {offset: offset + 24})) {
+ // Found audio:
+ return {
+ ext: 'wma',
+ mime: 'audio/x-ms-wma'
+ };
+ }
+
+ if (check([0xC0, 0xEF, 0x19, 0xBC, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B], {offset: offset + 24})) {
+ // Found video:
+ return {
+ ext: 'wmv',
+ mime: 'video/x-ms-asf'
+ };
+ }
+
+ break;
+ }
+
+ offset += objectSize;
+ } while (offset + 24 <= buffer.length);
+
+ // Default to ASF generic extension
+ return {
+ ext: 'asf',
+ mime: 'application/vnd.ms-asf'
+ };
+ }
+
+ if (
+ check([0x0, 0x0, 0x1, 0xBA]) ||
+ check([0x0, 0x0, 0x1, 0xB3])
+ ) {
+ return {
+ ext: 'mpg',
+ mime: 'video/mpeg'
+ };
+ }
+
+ // Check for MPEG header at different starting offsets
+ for (let start = 0; start < 2 && start < (buffer.length - 16); start++) {
+ if (
+ check([0x49, 0x44, 0x33], {offset: start}) || // ID3 header
+ check([0xFF, 0xE2], {offset: start, mask: [0xFF, 0xE6]}) // MPEG 1 or 2 Layer 3 header
+ ) {
+ return {
+ ext: 'mp3',
+ mime: 'audio/mpeg'
+ };
+ }
+
+ if (
+ check([0xFF, 0xE4], {offset: start, mask: [0xFF, 0xE6]}) // MPEG 1 or 2 Layer 2 header
+ ) {
+ return {
+ ext: 'mp2',
+ mime: 'audio/mpeg'
+ };
+ }
+
+ if (
+ check([0xFF, 0xF8], {offset: start, mask: [0xFF, 0xFC]}) // MPEG 2 layer 0 using ADTS
+ ) {
+ return {
+ ext: 'mp2',
+ mime: 'audio/mpeg'
+ };
+ }
+
+ if (
+ check([0xFF, 0xF0], {offset: start, mask: [0xFF, 0xFC]}) // MPEG 4 layer 0 using ADTS
+ ) {
+ return {
+ ext: 'mp4',
+ mime: 'audio/mpeg'
+ };
+ }
+ }
+
+ // Needs to be before `ogg` check
+ if (check([0x4F, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64], {offset: 28})) {
+ return {
+ ext: 'opus',
+ mime: 'audio/opus'
+ };
+ }
+
+ // If 'OggS' in first bytes, then OGG container
+ if (check([0x4F, 0x67, 0x67, 0x53])) {
+ // This is a OGG container
+
+ // If ' theora' in header.
+ if (check([0x80, 0x74, 0x68, 0x65, 0x6F, 0x72, 0x61], {offset: 28})) {
+ return {
+ ext: 'ogv',
+ mime: 'video/ogg'
+ };
+ }
+
+ // If '\x01video' in header.
+ if (check([0x01, 0x76, 0x69, 0x64, 0x65, 0x6F, 0x00], {offset: 28})) {
+ return {
+ ext: 'ogm',
+ mime: 'video/ogg'
+ };
+ }
+
+ // If ' FLAC' in header https://xiph.org/flac/faq.html
+ if (check([0x7F, 0x46, 0x4C, 0x41, 0x43], {offset: 28})) {
+ return {
+ ext: 'oga',
+ mime: 'audio/ogg'
+ };
+ }
+
+ // 'Speex ' in header https://en.wikipedia.org/wiki/Speex
+ if (check([0x53, 0x70, 0x65, 0x65, 0x78, 0x20, 0x20], {offset: 28})) {
+ return {
+ ext: 'spx',
+ mime: 'audio/ogg'
+ };
+ }
+
+ // If '\x01vorbis' in header
+ if (check([0x01, 0x76, 0x6F, 0x72, 0x62, 0x69, 0x73], {offset: 28})) {
+ return {
+ ext: 'ogg',
+ mime: 'audio/ogg'
+ };
+ }
+
+ // Default OGG container https://www.iana.org/assignments/media-types/application/ogg
+ return {
+ ext: 'ogx',
+ mime: 'application/ogg'
+ };
+ }
+
+ if (check([0x66, 0x4C, 0x61, 0x43])) {
+ return {
+ ext: 'flac',
+ mime: 'audio/x-flac'
+ };
+ }
+
+ if (check([0x4D, 0x41, 0x43, 0x20])) { // 'MAC '
+ return {
+ ext: 'ape',
+ mime: 'audio/ape'
+ };
+ }
+
+ if (check([0x77, 0x76, 0x70, 0x6B])) { // 'wvpk'
+ return {
+ ext: 'wv',
+ mime: 'audio/wavpack'
+ };
+ }
+
+ if (check([0x23, 0x21, 0x41, 0x4D, 0x52, 0x0A])) {
+ return {
+ ext: 'amr',
+ mime: 'audio/amr'
+ };
+ }
+
+ if (check([0x25, 0x50, 0x44, 0x46])) {
+ return {
+ ext: 'pdf',
+ mime: 'application/pdf'
+ };
+ }
+
+ if (check([0x4D, 0x5A])) {
+ return {
+ ext: 'exe',
+ mime: 'application/x-msdownload'
+ };
+ }
+
+ if (
+ (buffer[0] === 0x43 || buffer[0] === 0x46) &&
+ check([0x57, 0x53], {offset: 1})
+ ) {
+ return {
+ ext: 'swf',
+ mime: 'application/x-shockwave-flash'
+ };
+ }
+
+ if (check([0x7B, 0x5C, 0x72, 0x74, 0x66])) {
+ return {
+ ext: 'rtf',
+ mime: 'application/rtf'
+ };
+ }
+
+ if (check([0x00, 0x61, 0x73, 0x6D])) {
+ return {
+ ext: 'wasm',
+ mime: 'application/wasm'
+ };
+ }
+
+ if (
+ check([0x77, 0x4F, 0x46, 0x46]) &&
+ (
+ check([0x00, 0x01, 0x00, 0x00], {offset: 4}) ||
+ check([0x4F, 0x54, 0x54, 0x4F], {offset: 4})
+ )
+ ) {
+ return {
+ ext: 'woff',
+ mime: 'font/woff'
+ };
+ }
+
+ if (
+ check([0x77, 0x4F, 0x46, 0x32]) &&
+ (
+ check([0x00, 0x01, 0x00, 0x00], {offset: 4}) ||
+ check([0x4F, 0x54, 0x54, 0x4F], {offset: 4})
+ )
+ ) {
+ return {
+ ext: 'woff2',
+ mime: 'font/woff2'
+ };
+ }
+
+ if (
+ check([0x4C, 0x50], {offset: 34}) &&
+ (
+ check([0x00, 0x00, 0x01], {offset: 8}) ||
+ check([0x01, 0x00, 0x02], {offset: 8}) ||
+ check([0x02, 0x00, 0x02], {offset: 8})
+ )
+ ) {
+ return {
+ ext: 'eot',
+ mime: 'application/vnd.ms-fontobject'
+ };
+ }
+
+ if (check([0x00, 0x01, 0x00, 0x00, 0x00])) {
+ return {
+ ext: 'ttf',
+ mime: 'font/ttf'
+ };
+ }
+
+ if (check([0x4F, 0x54, 0x54, 0x4F, 0x00])) {
+ return {
+ ext: 'otf',
+ mime: 'font/otf'
+ };
+ }
+
+ if (check([0x00, 0x00, 0x01, 0x00])) {
+ return {
+ ext: 'ico',
+ mime: 'image/x-icon'
+ };
+ }
+
+ if (check([0x00, 0x00, 0x02, 0x00])) {
+ return {
+ ext: 'cur',
+ mime: 'image/x-icon'
+ };
+ }
+
+ if (check([0x46, 0x4C, 0x56, 0x01])) {
+ return {
+ ext: 'flv',
+ mime: 'video/x-flv'
+ };
+ }
+
+ if (check([0x25, 0x21])) {
+ return {
+ ext: 'ps',
+ mime: 'application/postscript'
+ };
+ }
+
+ if (check([0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00])) {
+ return {
+ ext: 'xz',
+ mime: 'application/x-xz'
+ };
+ }
+
+ if (check([0x53, 0x51, 0x4C, 0x69])) {
+ return {
+ ext: 'sqlite',
+ mime: 'application/x-sqlite3'
+ };
+ }
+
+ if (check([0x4E, 0x45, 0x53, 0x1A])) {
+ return {
+ ext: 'nes',
+ mime: 'application/x-nintendo-nes-rom'
+ };
+ }
+
+ if (check([0x43, 0x72, 0x32, 0x34])) {
+ return {
+ ext: 'crx',
+ mime: 'application/x-google-chrome-extension'
+ };
+ }
+
+ if (
+ check([0x4D, 0x53, 0x43, 0x46]) ||
+ check([0x49, 0x53, 0x63, 0x28])
+ ) {
+ return {
+ ext: 'cab',
+ mime: 'application/vnd.ms-cab-compressed'
+ };
+ }
+
+ // Needs to be before `ar` check
+ if (check([0x21, 0x3C, 0x61, 0x72, 0x63, 0x68, 0x3E, 0x0A, 0x64, 0x65, 0x62, 0x69, 0x61, 0x6E, 0x2D, 0x62, 0x69, 0x6E, 0x61, 0x72, 0x79])) {
+ return {
+ ext: 'deb',
+ mime: 'application/x-deb'
+ };
+ }
+
+ if (check([0x21, 0x3C, 0x61, 0x72, 0x63, 0x68, 0x3E])) {
+ return {
+ ext: 'ar',
+ mime: 'application/x-unix-archive'
+ };
+ }
+
+ if (check([0xED, 0xAB, 0xEE, 0xDB])) {
+ return {
+ ext: 'rpm',
+ mime: 'application/x-rpm'
+ };
+ }
+
+ if (
+ check([0x1F, 0xA0]) ||
+ check([0x1F, 0x9D])
+ ) {
+ return {
+ ext: 'Z',
+ mime: 'application/x-compress'
+ };
+ }
+
+ if (check([0x4C, 0x5A, 0x49, 0x50])) {
+ return {
+ ext: 'lz',
+ mime: 'application/x-lzip'
+ };
+ }
+
+ if (check([0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E])) {
+ return {
+ ext: 'msi',
+ mime: 'application/x-msi'
+ };
+ }
+
+ if (check([0x06, 0x0E, 0x2B, 0x34, 0x02, 0x05, 0x01, 0x01, 0x0D, 0x01, 0x02, 0x01, 0x01, 0x02])) {
+ return {
+ ext: 'mxf',
+ mime: 'application/mxf'
+ };
+ }
+
+ if (check([0x47], {offset: 4}) && (check([0x47], {offset: 192}) || check([0x47], {offset: 196}))) {
+ return {
+ ext: 'mts',
+ mime: 'video/mp2t'
+ };
+ }
+
+ if (check([0x42, 0x4C, 0x45, 0x4E, 0x44, 0x45, 0x52])) {
+ return {
+ ext: 'blend',
+ mime: 'application/x-blender'
+ };
+ }
+
+ if (check([0x42, 0x50, 0x47, 0xFB])) {
+ return {
+ ext: 'bpg',
+ mime: 'image/bpg'
+ };
+ }
+
+ if (check([0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20, 0x0D, 0x0A, 0x87, 0x0A])) {
+ // JPEG-2000 family
+
+ if (check([0x6A, 0x70, 0x32, 0x20], {offset: 20})) {
+ return {
+ ext: 'jp2',
+ mime: 'image/jp2'
+ };
+ }
+
+ if (check([0x6A, 0x70, 0x78, 0x20], {offset: 20})) {
+ return {
+ ext: 'jpx',
+ mime: 'image/jpx'
+ };
+ }
+
+ if (check([0x6A, 0x70, 0x6D, 0x20], {offset: 20})) {
+ return {
+ ext: 'jpm',
+ mime: 'image/jpm'
+ };
+ }
+
+ if (check([0x6D, 0x6A, 0x70, 0x32], {offset: 20})) {
+ return {
+ ext: 'mj2',
+ mime: 'image/mj2'
+ };
+ }
+ }
+
+ if (check([0x46, 0x4F, 0x52, 0x4D])) {
+ return {
+ ext: 'aif',
+ mime: 'audio/aiff'
+ };
+ }
+
+ if (checkString('<?xml ')) {
+ return {
+ ext: 'xml',
+ mime: 'application/xml'
+ };
+ }
+
+ if (check([0x42, 0x4F, 0x4F, 0x4B, 0x4D, 0x4F, 0x42, 0x49], {offset: 60})) {
+ return {
+ ext: 'mobi',
+ mime: 'application/x-mobipocket-ebook'
+ };
+ }
+
+ if (check([0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A])) {
+ return {
+ ext: 'ktx',
+ mime: 'image/ktx'
+ };
+ }
+
+ if (check([0x44, 0x49, 0x43, 0x4D], {offset: 128})) {
+ return {
+ ext: 'dcm',
+ mime: 'application/dicom'
+ };
+ }
+
+ // Musepack, SV7
+ if (check([0x4D, 0x50, 0x2B])) {
+ return {
+ ext: 'mpc',
+ mime: 'audio/x-musepack'
+ };
+ }
+
+ // Musepack, SV8
+ if (check([0x4D, 0x50, 0x43, 0x4B])) {
+ return {
+ ext: 'mpc',
+ mime: 'audio/x-musepack'
+ };
+ }
+
+ if (check([0x42, 0x45, 0x47, 0x49, 0x4E, 0x3A])) {
+ return {
+ ext: 'ics',
+ mime: 'text/calendar'
+ };
+ }
+
+ if (check([0x67, 0x6C, 0x54, 0x46, 0x02, 0x00, 0x00, 0x00])) {
+ return {
+ ext: 'glb',
+ mime: 'model/gltf-binary'
+ };
+ }
+
+ if (check([0xD4, 0xC3, 0xB2, 0xA1]) || check([0xA1, 0xB2, 0xC3, 0xD4])) {
+ return {
+ ext: 'pcap',
+ mime: 'application/vnd.tcpdump.pcap'
+ };
+ }
+
+ // Sony DSD Stream File (DSF)
+ if (check([0x44, 0x53, 0x44, 0x20])) {
+ return {
+ ext: 'dsf',
+ mime: 'audio/x-dsf' // Non-standard
+ };
+ }
+
+ if (check([0x4C, 0x00, 0x00, 0x00, 0x01, 0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46])) {
+ return {
+ ext: 'lnk',
+ mime: 'application/x.ms.shortcut' // Invented by us
+ };
+ }
+
+ if (check([0x62, 0x6F, 0x6F, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x72, 0x6B, 0x00, 0x00, 0x00, 0x00])) {
+ return {
+ ext: 'alias',
+ mime: 'application/x.apple.alias' // Invented by us
+ };
+ }
+
+ if (checkString('Creative Voice File')) {
+ return {
+ ext: 'voc',
+ mime: 'audio/x-voc'
+ };
+ }
+
+ if (check([0x0B, 0x77])) {
+ return {
+ ext: 'ac3',
+ mime: 'audio/vnd.dolby.dd-raw'
+ };
+ }
+
+ if ((check([0x7E, 0x10, 0x04]) || check([0x7E, 0x18, 0x04])) && check([0x30, 0x4D, 0x49, 0x45], {offset: 4})) {
+ return {
+ ext: 'mie',
+ mime: 'application/x-mie'
+ };
+ }
+
+ if (check([0x41, 0x52, 0x52, 0x4F, 0x57, 0x31, 0x00, 0x00])) {
+ return {
+ ext: 'arrow',
+ mime: 'application/x-apache-arrow'
+ };
+ }
+
+ if (check([0x27, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], {offset: 2})) {
+ return {
+ ext: 'shp',
+ mime: 'application/x-esri-shape'
+ };
+ }
+};
+
+module.exports = fileType;
+
+Object.defineProperty(fileType, 'minimumBytes', {value: 4100});
+
+fileType.stream = readableStream => new Promise((resolve, reject) => {
+ // Using `eval` to work around issues when bundling with Webpack
+ const stream = eval('require')('stream'); // eslint-disable-line no-eval
+
+ readableStream.on('error', reject);
+ readableStream.once('readable', () => {
+ const pass = new stream.PassThrough();
+ const chunk = readableStream.read(module.exports.minimumBytes) || readableStream.read();
+ try {
+ pass.fileType = fileType(chunk);
+ } catch (error) {
+ reject(error);
+ }
+
+ readableStream.unshift(chunk);
+
+ if (stream.pipeline) {
+ resolve(stream.pipeline(readableStream, pass, () => {}));
+ } else {
+ resolve(readableStream.pipe(pass));
+ }
+ });
+});
+
+Object.defineProperty(fileType, 'extensions', {
+ get() {
+ return new Set(supported.extensions);
+ }
+});
+
+Object.defineProperty(fileType, 'mimeTypes', {
+ get() {
+ return new Set(supported.mimeTypes);
+ }
+});
diff --git a/node_modules/imagemin/node_modules/file-type/license b/node_modules/imagemin/node_modules/file-type/license
new file mode 100644
index 0000000..e7af2f7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/file-type/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/file-type/package.json b/node_modules/imagemin/node_modules/file-type/package.json
new file mode 100644
index 0000000..6327711
--- /dev/null
+++ b/node_modules/imagemin/node_modules/file-type/package.json
@@ -0,0 +1,204 @@
+{
+ "_from": "file-type@^12.0.0",
+ "_id": "file-type@12.4.2",
+ "_inBundle": false,
+ "_integrity": "sha512-UssQP5ZgIOKelfsaB5CuGAL+Y+q7EmONuiwF3N5HAH0t27rvrttgi6Ra9k/+DVaY9UF6+ybxu5pOXLUdA8N7Vg==",
+ "_location": "/imagemin/file-type",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "file-type@^12.0.0",
+ "name": "file-type",
+ "escapedName": "file-type",
+ "rawSpec": "^12.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^12.0.0"
+ },
+ "_requiredBy": [
+ "/imagemin"
+ ],
+ "_resolved": "https://registry.npmjs.org/file-type/-/file-type-12.4.2.tgz",
+ "_shasum": "a344ea5664a1d01447ee7fb1b635f72feb6169d9",
+ "_spec": "file-type@^12.0.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "bugs": {
+ "url": "https://github.com/sindresorhus/file-type/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Detect the file type of a Buffer/Uint8Array/ArrayBuffer",
+ "devDependencies": {
+ "@types/node": "^12.7.2",
+ "ava": "^2.3.0",
+ "noop-stream": "^0.1.0",
+ "pify": "^4.0.1",
+ "read-chunk": "^3.2.0",
+ "tsd": "^0.7.1",
+ "xo": "^0.24.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js",
+ "index.d.ts",
+ "supported.js",
+ "util.js"
+ ],
+ "homepage": "https://github.com/sindresorhus/file-type#readme",
+ "keywords": [
+ "mime",
+ "file",
+ "type",
+ "archive",
+ "image",
+ "img",
+ "pic",
+ "picture",
+ "flash",
+ "photo",
+ "video",
+ "detect",
+ "check",
+ "is",
+ "exif",
+ "exe",
+ "binary",
+ "buffer",
+ "uint8array",
+ "jpg",
+ "png",
+ "apng",
+ "gif",
+ "webp",
+ "flif",
+ "cr2",
+ "orf",
+ "arw",
+ "dng",
+ "nef",
+ "rw2",
+ "raf",
+ "tif",
+ "bmp",
+ "jxr",
+ "psd",
+ "zip",
+ "tar",
+ "rar",
+ "gz",
+ "bz2",
+ "7z",
+ "dmg",
+ "mp4",
+ "mid",
+ "mkv",
+ "webm",
+ "mov",
+ "avi",
+ "mpg",
+ "mp2",
+ "mp3",
+ "m4a",
+ "ogg",
+ "opus",
+ "flac",
+ "wav",
+ "amr",
+ "pdf",
+ "epub",
+ "mobi",
+ "swf",
+ "rtf",
+ "woff",
+ "woff2",
+ "eot",
+ "ttf",
+ "otf",
+ "ico",
+ "flv",
+ "ps",
+ "xz",
+ "sqlite",
+ "xpi",
+ "cab",
+ "deb",
+ "ar",
+ "rpm",
+ "Z",
+ "lz",
+ "msi",
+ "mxf",
+ "mts",
+ "wasm",
+ "webassembly",
+ "blend",
+ "bpg",
+ "docx",
+ "pptx",
+ "xlsx",
+ "3gp",
+ "jp2",
+ "jpm",
+ "jpx",
+ "mj2",
+ "aif",
+ "odt",
+ "ods",
+ "odp",
+ "xml",
+ "heic",
+ "wma",
+ "ics",
+ "glb",
+ "pcap",
+ "dsf",
+ "lnk",
+ "alias",
+ "voc",
+ "ac3",
+ "3g2",
+ "m4b",
+ "m4p",
+ "m4v",
+ "f4a",
+ "f4b",
+ "f4p",
+ "f4v",
+ "mie",
+ "qcp",
+ "wmv",
+ "asf",
+ "ogv",
+ "ogm",
+ "oga",
+ "spx",
+ "ogx",
+ "ape",
+ "wv",
+ "cur",
+ "nes",
+ "crx",
+ "ktx",
+ "dcm",
+ "mpc",
+ "arrow",
+ "shp"
+ ],
+ "license": "MIT",
+ "name": "file-type",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/sindresorhus/file-type.git"
+ },
+ "scripts": {
+ "test": "xo && ava && tsd"
+ },
+ "version": "12.4.2"
+}
diff --git a/node_modules/imagemin/node_modules/file-type/readme.md b/node_modules/imagemin/node_modules/file-type/readme.md
new file mode 100644
index 0000000..6565e96
--- /dev/null
+++ b/node_modules/imagemin/node_modules/file-type/readme.md
@@ -0,0 +1,273 @@
+# file-type [](https://travis-ci.org/sindresorhus/file-type)
+
+> Detect the file type of a Buffer/Uint8Array/ArrayBuffer
+
+The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
+
+
+## Install
+
+```
+$ npm install file-type
+```
+
+
+## Usage
+
+##### Node.js
+
+```js
+const readChunk = require('read-chunk');
+const fileType = require('file-type');
+
+const buffer = readChunk.sync('unicorn.png', 0, fileType.minimumBytes);
+
+fileType(buffer);
+//=> {ext: 'png', mime: 'image/png'}
+```
+
+Or from a remote location:
+
+```js
+const https = require('https');
+const fileType = require('file-type');
+
+const url = 'https://upload.wikimedia.org/wikipedia/en/a/a9/Example.jpg';
+
+https.get(url, response => {
+ response.on('readable', () => {
+ const chunk = response.read(fileType.minimumBytes);
+ response.destroy();
+
+ console.log(fileType(chunk));
+ //=> {ext: 'jpg', mime: 'image/jpeg'}
+ });
+});
+```
+
+Or from a stream:
+
+```js
+const stream = require('stream');
+const fs = require('fs');
+const crypto = require('crypto');
+const fileType = require('file-type');
+
+(async () => {
+ const read = fs.createReadStream('encrypted.enc');
+ const decipher = crypto.createDecipheriv(alg, key, iv);
+
+ const fileTypeStream = await fileType.stream(stream.pipeline(read, decipher));
+
+ console.log(fileTypeStream.fileType);
+ //=> {ext: 'mov', mime: 'video/quicktime'}
+
+ const write = fs.createWriteStream(`decrypted.${fileTypeStream.fileType.ext}`);
+ fileTypeStream.pipe(write);
+})();
+```
+
+
+##### Browser
+
+```js
+const xhr = new XMLHttpRequest();
+xhr.open('GET', 'unicorn.png');
+xhr.responseType = 'arraybuffer';
+
+xhr.onload = () => {
+ fileType(new Uint8Array(this.response));
+ //=> {ext: 'png', mime: 'image/png'}
+};
+
+xhr.send();
+```
+
+
+## API
+
+### fileType(input)
+
+Returns an `object` with:
+
+- `ext` - One of the [supported file types](#supported-file-types)
+- `mime` - The [MIME type](https://en.wikipedia.org/wiki/Internet_media_type)
+
+Or `undefined` when there is no match.
+
+#### input
+
+Type: `Buffer | Uint8Array | ArrayBuffer`
+
+It only needs the first `.minimumBytes` bytes. The exception is detection of `docx`, `pptx`, and `xlsx` which potentially requires reading the whole file.
+
+### fileType.minimumBytes
+
+Type: `number`
+
+The minimum amount of bytes needed to detect a file type. Currently, it's 4100 bytes, but it can change, so don't hardcode it.
+
+### fileType.stream(readableStream)
+
+Detect the file type of a readable stream.
+
+Returns a `Promise` which resolves to the original readable stream argument, but with an added `fileType` property, which is an object like the one returned from `fileType()`.
+
+*Note:* This method is only for Node.js.
+
+#### readableStream
+
+Type: [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable)
+
+### fileType.extensions
+
+Returns a set of supported file extensions.
+
+### fileType.mimeTypes
+
+Returns a set of supported MIME types.
+
+
+## Supported file types
+
+- [`jpg`](https://en.wikipedia.org/wiki/JPEG)
+- [`png`](https://en.wikipedia.org/wiki/Portable_Network_Graphics)
+- [`apng`](https://en.wikipedia.org/wiki/APNG) - Animated Portable Network Graphics
+- [`gif`](https://en.wikipedia.org/wiki/GIF)
+- [`webp`](https://en.wikipedia.org/wiki/WebP)
+- [`flif`](https://en.wikipedia.org/wiki/Free_Lossless_Image_Format)
+- [`cr2`](https://fileinfo.com/extension/cr2) - Canon Raw image file (v2)
+- [`orf`](https://en.wikipedia.org/wiki/ORF_format) - Olympus Raw image file
+- [`arw`](https://en.wikipedia.org/wiki/Raw_image_format#ARW) - Sony Alpha Raw image file
+- [`dng`](https://en.wikipedia.org/wiki/Digital_Negative) - Adobe Digital Negative image file
+- [`nef`](https://www.nikonusa.com/en/learn-and-explore/a/products-and-innovation/nikon-electronic-format-nef.html) - Nikon Electronic Format image file
+- [`rw2`](https://en.wikipedia.org/wiki/Raw_image_format) - Panasonic RAW image file
+- [`raf`](https://en.wikipedia.org/wiki/Raw_image_format) - Fujifilm RAW image file
+- [`tif`](https://en.wikipedia.org/wiki/Tagged_Image_File_Format)
+- [`bmp`](https://en.wikipedia.org/wiki/BMP_file_format)
+- [`jxr`](https://en.wikipedia.org/wiki/JPEG_XR)
+- [`psd`](https://en.wikipedia.org/wiki/Adobe_Photoshop#File_format)
+- [`zip`](https://en.wikipedia.org/wiki/Zip_(file_format))
+- [`tar`](https://en.wikipedia.org/wiki/Tar_(computing)#File_format)
+- [`rar`](https://en.wikipedia.org/wiki/RAR_(file_format))
+- [`gz`](https://en.wikipedia.org/wiki/Gzip)
+- [`bz2`](https://en.wikipedia.org/wiki/Bzip2)
+- [`7z`](https://en.wikipedia.org/wiki/7z)
+- [`dmg`](https://en.wikipedia.org/wiki/Apple_Disk_Image)
+- [`mp4`](https://en.wikipedia.org/wiki/MPEG-4_Part_14#Filename_extensions)
+- [`mid`](https://en.wikipedia.org/wiki/MIDI)
+- [`mkv`](https://en.wikipedia.org/wiki/Matroska)
+- [`webm`](https://en.wikipedia.org/wiki/WebM)
+- [`mov`](https://en.wikipedia.org/wiki/QuickTime_File_Format)
+- [`avi`](https://en.wikipedia.org/wiki/Audio_Video_Interleave)
+- [`mpg`](https://en.wikipedia.org/wiki/MPEG-1)
+- [`mp2`](https://en.wikipedia.org/wiki/MPEG-1_Audio_Layer_II)
+- [`mp3`](https://en.wikipedia.org/wiki/MP3)
+- [`ogg`](https://en.wikipedia.org/wiki/Ogg)
+- [`ogv`](https://en.wikipedia.org/wiki/Ogg)
+- [`ogm`](https://en.wikipedia.org/wiki/Ogg)
+- [`oga`](https://en.wikipedia.org/wiki/Ogg)
+- [`spx`](https://en.wikipedia.org/wiki/Ogg)
+- [`ogx`](https://en.wikipedia.org/wiki/Ogg)
+- [`opus`](https://en.wikipedia.org/wiki/Opus_(audio_format))
+- [`flac`](https://en.wikipedia.org/wiki/FLAC)
+- [`wav`](https://en.wikipedia.org/wiki/WAV)
+- [`qcp`](https://en.wikipedia.org/wiki/QCP)
+- [`amr`](https://en.wikipedia.org/wiki/Adaptive_Multi-Rate_audio_codec)
+- [`pdf`](https://en.wikipedia.org/wiki/Portable_Document_Format)
+- [`epub`](https://en.wikipedia.org/wiki/EPUB)
+- [`mobi`](https://en.wikipedia.org/wiki/Mobipocket) - Mobipocket
+- [`exe`](https://en.wikipedia.org/wiki/.exe)
+- [`swf`](https://en.wikipedia.org/wiki/SWF)
+- [`rtf`](https://en.wikipedia.org/wiki/Rich_Text_Format)
+- [`woff`](https://en.wikipedia.org/wiki/Web_Open_Font_Format)
+- [`woff2`](https://en.wikipedia.org/wiki/Web_Open_Font_Format)
+- [`eot`](https://en.wikipedia.org/wiki/Embedded_OpenType)
+- [`ttf`](https://en.wikipedia.org/wiki/TrueType)
+- [`otf`](https://en.wikipedia.org/wiki/OpenType)
+- [`ico`](https://en.wikipedia.org/wiki/ICO_(file_format))
+- [`flv`](https://en.wikipedia.org/wiki/Flash_Video)
+- [`ps`](https://en.wikipedia.org/wiki/Postscript)
+- [`xz`](https://en.wikipedia.org/wiki/Xz)
+- [`sqlite`](https://www.sqlite.org/fileformat2.html)
+- [`nes`](https://fileinfo.com/extension/nes)
+- [`crx`](https://developer.chrome.com/extensions/crx)
+- [`xpi`](https://en.wikipedia.org/wiki/XPInstall)
+- [`cab`](https://en.wikipedia.org/wiki/Cabinet_(file_format))
+- [`deb`](https://en.wikipedia.org/wiki/Deb_(file_format))
+- [`ar`](https://en.wikipedia.org/wiki/Ar_(Unix))
+- [`rpm`](https://fileinfo.com/extension/rpm)
+- [`Z`](https://fileinfo.com/extension/z)
+- [`lz`](https://en.wikipedia.org/wiki/Lzip)
+- [`msi`](https://en.wikipedia.org/wiki/Windows_Installer)
+- [`mxf`](https://en.wikipedia.org/wiki/Material_Exchange_Format)
+- [`mts`](https://en.wikipedia.org/wiki/.m2ts)
+- [`wasm`](https://en.wikipedia.org/wiki/WebAssembly)
+- [`blend`](https://wiki.blender.org/index.php/Dev:Source/Architecture/File_Format)
+- [`bpg`](https://bellard.org/bpg/)
+- [`docx`](https://en.wikipedia.org/wiki/Office_Open_XML)
+- [`pptx`](https://en.wikipedia.org/wiki/Office_Open_XML)
+- [`xlsx`](https://en.wikipedia.org/wiki/Office_Open_XML)
+- [`jp2`](https://en.wikipedia.org/wiki/JPEG_2000) - JPEG 2000
+- [`jpm`](https://en.wikipedia.org/wiki/JPEG_2000) - JPEG 2000
+- [`jpx`](https://en.wikipedia.org/wiki/JPEG_2000) - JPEG 2000
+- [`mj2`](https://en.wikipedia.org/wiki/Motion_JPEG_2000) - Motion JPEG 2000
+- [`aif`](https://en.wikipedia.org/wiki/Audio_Interchange_File_Format)
+- [`odt`](https://en.wikipedia.org/wiki/OpenDocument) - OpenDocument for word processing
+- [`ods`](https://en.wikipedia.org/wiki/OpenDocument) - OpenDocument for spreadsheets
+- [`odp`](https://en.wikipedia.org/wiki/OpenDocument) - OpenDocument for presentations
+- [`xml`](https://en.wikipedia.org/wiki/XML)
+- [`heic`](https://nokiatech.github.io/heif/technical.html)
+- [`cur`](https://en.wikipedia.org/wiki/ICO_(file_format))
+- [`ktx`](https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/)
+- [`ape`](https://en.wikipedia.org/wiki/Monkey%27s_Audio) - Monkey's Audio
+- [`wv`](https://en.wikipedia.org/wiki/WavPack) - WavPack
+- [`asf`](https://en.wikipedia.org/wiki/Advanced_Systems_Format) - Advanced Systems Format
+- [`wma`](https://en.wikipedia.org/wiki/Windows_Media_Audio) - Windows Media Audio
+- [`wmv`](https://en.wikipedia.org/wiki/Windows_Media_Video) - Windows Media Video
+- [`dcm`](https://en.wikipedia.org/wiki/DICOM#Data_format) - DICOM Image File
+- [`mpc`](https://en.wikipedia.org/wiki/Musepack) - Musepack (SV7 & SV8)
+- [`ics`](https://en.wikipedia.org/wiki/ICalendar#Data_format) - iCalendar
+- [`glb`](https://github.com/KhronosGroup/glTF) - GL Transmission Format
+- [`pcap`](https://wiki.wireshark.org/Development/LibpcapFileFormat) - Libpcap File Format
+- [`dsf`](https://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf) - Sony DSD Stream File (DSF)
+- [`lnk`](https://en.wikipedia.org/wiki/Shortcut_%28computing%29#Microsoft_Windows) - Microsoft Windows file shortcut
+- [`alias`](https://en.wikipedia.org/wiki/Alias_%28Mac_OS%29) - macOS Alias file
+- [`voc`](https://wiki.multimedia.cx/index.php/Creative_Voice) - Creative Voice File
+- [`ac3`](https://www.atsc.org/standard/a522012-digital-audio-compression-ac-3-e-ac-3-standard-12172012/) - ATSC A/52 Audio File
+- [`3gp`](https://en.wikipedia.org/wiki/3GP_and_3G2#3GP) - Multimedia container format defined by the Third Generation Partnership Project (3GPP) for 3G UMTS multimedia services
+- [`3g2`](https://en.wikipedia.org/wiki/3GP_and_3G2#3G2) - Multimedia container format defined by the 3GPP2 for 3G CDMA2000 multimedia services
+- [`m4v`](https://en.wikipedia.org/wiki/M4V) - MPEG-4 Visual bitstreams
+- [`m4p`](https://en.wikipedia.org/wiki/MPEG-4_Part_14#Filename_extensions) - MPEG-4 files with audio streams encrypted by FairPlay Digital Rights Management as were sold through the iTunes Store
+- [`m4a`](https://en.wikipedia.org/wiki/M4A) - Audio-only MPEG-4 files
+- [`m4b`](https://en.wikipedia.org/wiki/M4B) - Audiobook and podcast MPEG-4 files, which also contain metadata including chapter markers, images, and hyperlinks
+- [`f4v`](https://en.wikipedia.org/wiki/Flash_Video) - ISO base media file format used by Adobe Flash Player
+- [`f4p`](https://en.wikipedia.org/wiki/Flash_Video) - ISO base media file format protected by Adobe Access DRM used by Adobe Flash Player
+- [`f4a`](https://en.wikipedia.org/wiki/Flash_Video) - Audio-only ISO base media file format used by Adobe Flash Player
+- [`f4b`](https://en.wikipedia.org/wiki/Flash_Video) - Audiobook and podcast ISO base media file format used by Adobe Flash Player
+- [`mie`](https://en.wikipedia.org/wiki/Sidecar_file) - Dedicated meta information format which supports storage of binary as well as textual meta information
+- [`shp`](https://en.wikipedia.org/wiki/Shapefile) - Geospatial vector data format
+- [`arrow`](https://arrow.apache.org) - Columnar format for tables of data
+
+*SVG isn't included as it requires the whole file to be read, but you can get it [here](https://github.com/sindresorhus/is-svg).*
+
+*Pull requests are welcome for additional commonly used file types, except for `doc`, `xls`, `ppt`.*
+
+
+## file-type for enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of file-type and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-file-type?utm_source=npm-file-type&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+
+
+## Related
+
+- [file-type-cli](https://github.com/sindresorhus/file-type-cli) - CLI for this module
+
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Mikael Finstad](https://github.com/mifi)
+- [Ben Brook](https://github.com/bencmbrook)
diff --git a/node_modules/imagemin/node_modules/file-type/supported.js b/node_modules/imagemin/node_modules/file-type/supported.js
new file mode 100644
index 0000000..cf3c5e1
--- /dev/null
+++ b/node_modules/imagemin/node_modules/file-type/supported.js
@@ -0,0 +1,237 @@
+'use strict';
+
+module.exports = {
+ extensions: [
+ 'jpg',
+ 'png',
+ 'apng',
+ 'gif',
+ 'webp',
+ 'flif',
+ 'cr2',
+ 'orf',
+ 'arw',
+ 'dng',
+ 'nef',
+ 'rw2',
+ 'raf',
+ 'tif',
+ 'bmp',
+ 'jxr',
+ 'psd',
+ 'zip',
+ 'tar',
+ 'rar',
+ 'gz',
+ 'bz2',
+ '7z',
+ 'dmg',
+ 'mp4',
+ 'mid',
+ 'mkv',
+ 'webm',
+ 'mov',
+ 'avi',
+ 'mpg',
+ 'mp2',
+ 'mp3',
+ 'm4a',
+ 'oga',
+ 'ogg',
+ 'ogv',
+ 'opus',
+ 'flac',
+ 'wav',
+ 'spx',
+ 'amr',
+ 'pdf',
+ 'epub',
+ 'exe',
+ 'swf',
+ 'rtf',
+ 'wasm',
+ 'woff',
+ 'woff2',
+ 'eot',
+ 'ttf',
+ 'otf',
+ 'ico',
+ 'flv',
+ 'ps',
+ 'xz',
+ 'sqlite',
+ 'nes',
+ 'crx',
+ 'xpi',
+ 'cab',
+ 'deb',
+ 'ar',
+ 'rpm',
+ 'Z',
+ 'lz',
+ 'msi',
+ 'mxf',
+ 'mts',
+ 'blend',
+ 'bpg',
+ 'docx',
+ 'pptx',
+ 'xlsx',
+ '3gp',
+ '3g2',
+ 'jp2',
+ 'jpm',
+ 'jpx',
+ 'mj2',
+ 'aif',
+ 'qcp',
+ 'odt',
+ 'ods',
+ 'odp',
+ 'xml',
+ 'mobi',
+ 'heic',
+ 'cur',
+ 'ktx',
+ 'ape',
+ 'wv',
+ 'wmv',
+ 'wma',
+ 'dcm',
+ 'ics',
+ 'glb',
+ 'pcap',
+ 'dsf',
+ 'lnk',
+ 'alias',
+ 'voc',
+ 'ac3',
+ 'm4v',
+ 'm4p',
+ 'm4b',
+ 'f4v',
+ 'f4p',
+ 'f4b',
+ 'f4a',
+ 'mie',
+ 'asf',
+ 'ogm',
+ 'ogx',
+ 'mpc',
+ 'arrow',
+ 'shp'
+ ],
+ mimeTypes: [
+ 'image/jpeg',
+ 'image/png',
+ 'image/gif',
+ 'image/webp',
+ 'image/flif',
+ 'image/x-canon-cr2',
+ 'image/tiff',
+ 'image/bmp',
+ 'image/vnd.ms-photo',
+ 'image/vnd.adobe.photoshop',
+ 'application/epub+zip',
+ 'application/x-xpinstall',
+ 'application/vnd.oasis.opendocument.text',
+ 'application/vnd.oasis.opendocument.spreadsheet',
+ 'application/vnd.oasis.opendocument.presentation',
+ 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+ 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+ 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+ 'application/zip',
+ 'application/x-tar',
+ 'application/x-rar-compressed',
+ 'application/gzip',
+ 'application/x-bzip2',
+ 'application/x-7z-compressed',
+ 'application/x-apple-diskimage',
+ 'application/x-apache-arrow',
+ 'video/mp4',
+ 'audio/midi',
+ 'video/x-matroska',
+ 'video/webm',
+ 'video/quicktime',
+ 'video/vnd.avi',
+ 'audio/vnd.wave',
+ 'audio/qcelp',
+ 'audio/x-ms-wma',
+ 'video/x-ms-asf',
+ 'application/vnd.ms-asf',
+ 'video/mpeg',
+ 'video/3gpp',
+ 'audio/mpeg',
+ 'audio/mp4', // RFC 4337
+ 'audio/opus',
+ 'video/ogg',
+ 'audio/ogg',
+ 'application/ogg',
+ 'audio/x-flac',
+ 'audio/ape',
+ 'audio/wavpack',
+ 'audio/amr',
+ 'application/pdf',
+ 'application/x-msdownload',
+ 'application/x-shockwave-flash',
+ 'application/rtf',
+ 'application/wasm',
+ 'font/woff',
+ 'font/woff2',
+ 'application/vnd.ms-fontobject',
+ 'font/ttf',
+ 'font/otf',
+ 'image/x-icon',
+ 'video/x-flv',
+ 'application/postscript',
+ 'application/x-xz',
+ 'application/x-sqlite3',
+ 'application/x-nintendo-nes-rom',
+ 'application/x-google-chrome-extension',
+ 'application/vnd.ms-cab-compressed',
+ 'application/x-deb',
+ 'application/x-unix-archive',
+ 'application/x-rpm',
+ 'application/x-compress',
+ 'application/x-lzip',
+ 'application/x-msi',
+ 'application/x-mie',
+ 'application/mxf',
+ 'video/mp2t',
+ 'application/x-blender',
+ 'image/bpg',
+ 'image/jp2',
+ 'image/jpx',
+ 'image/jpm',
+ 'image/mj2',
+ 'audio/aiff',
+ 'application/xml',
+ 'application/x-mobipocket-ebook',
+ 'image/heif',
+ 'image/heif-sequence',
+ 'image/heic',
+ 'image/heic-sequence',
+ 'image/ktx',
+ 'application/dicom',
+ 'audio/x-musepack',
+ 'text/calendar',
+ 'model/gltf-binary',
+ 'application/vnd.tcpdump.pcap',
+ 'audio/x-dsf', // Non-standard
+ 'application/x.ms.shortcut', // Invented by us
+ 'application/x.apple.alias', // Invented by us
+ 'audio/x-voc',
+ 'audio/vnd.dolby.dd-raw',
+ 'audio/x-m4a',
+ 'image/apng',
+ 'image/x-olympus-orf',
+ 'image/x-sony-arw',
+ 'image/x-adobe-dng',
+ 'image/x-nikon-nef',
+ 'image/x-panasonic-rw2',
+ 'image/x-fujifilm-raf',
+ 'video/x-m4v',
+ 'video/3gpp2',
+ 'application/x-esri-shape'
+ ]
+};
diff --git a/node_modules/imagemin/node_modules/file-type/util.js b/node_modules/imagemin/node_modules/file-type/util.js
new file mode 100644
index 0000000..a26d646
--- /dev/null
+++ b/node_modules/imagemin/node_modules/file-type/util.js
@@ -0,0 +1,87 @@
+'use strict';
+
+exports.stringToBytes = string => [...string].map(character => character.charCodeAt(0));
+
+const uint8ArrayUtf8ByteString = (array, start, end) => {
+ return String.fromCharCode(...array.slice(start, end));
+};
+
+exports.readUInt64LE = (buffer, offset = 0) => {
+ let n = buffer[offset];
+ let mul = 1;
+ let i = 0;
+
+ while (++i < 8) {
+ mul *= 0x100;
+ n += buffer[offset + i] * mul;
+ }
+
+ return n;
+};
+
+exports.tarHeaderChecksumMatches = buffer => { // Does not check if checksum field characters are valid
+ if (buffer.length < 512) { // `tar` header size, cannot compute checksum without it
+ return false;
+ }
+
+ const MASK_8TH_BIT = 0x80;
+
+ let sum = 256; // Intitalize sum, with 256 as sum of 8 spaces in checksum field
+ let signedBitSum = 0; // Initialize signed bit sum
+
+ for (let i = 0; i < 148; i++) {
+ const byte = buffer[i];
+ sum += byte;
+ signedBitSum += byte & MASK_8TH_BIT; // Add signed bit to signed bit sum
+ }
+
+ // Skip checksum field
+
+ for (let i = 156; i < 512; i++) {
+ const byte = buffer[i];
+ sum += byte;
+ signedBitSum += byte & MASK_8TH_BIT; // Add signed bit to signed bit sum
+ }
+
+ const readSum = parseInt(uint8ArrayUtf8ByteString(buffer, 148, 154), 8); // Read sum in header
+
+ // Some implementations compute checksum incorrectly using signed bytes
+ return (
+ // Checksum in header equals the sum we calculated
+ readSum === sum ||
+
+ // Checksum in header equals sum we calculated plus signed-to-unsigned delta
+ readSum === (sum - (signedBitSum << 1))
+ );
+};
+
+exports.multiByteIndexOf = (buffer, bytesToSearch, startAt = 0) => {
+ // `Buffer#indexOf()` can search for multiple bytes
+ if (Buffer && Buffer.isBuffer(buffer)) {
+ return buffer.indexOf(Buffer.from(bytesToSearch), startAt);
+ }
+
+ const nextBytesMatch = (buffer, bytes, startIndex) => {
+ for (let i = 1; i < bytes.length; i++) {
+ if (bytes[i] !== buffer[startIndex + i]) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ // `Uint8Array#indexOf()` can search for only a single byte
+ let index = buffer.indexOf(bytesToSearch[0], startAt);
+ while (index >= 0) {
+ if (nextBytesMatch(buffer, bytesToSearch, index)) {
+ return index;
+ }
+
+ index = buffer.indexOf(bytesToSearch[0], index + 1);
+ }
+
+ return -1;
+};
+
+exports.uint8ArrayUtf8ByteString = uint8ArrayUtf8ByteString;
diff --git a/node_modules/imagemin/node_modules/fill-range/LICENSE b/node_modules/imagemin/node_modules/fill-range/LICENSE
new file mode 100644
index 0000000..9af4a67
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fill-range/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-present, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/fill-range/README.md b/node_modules/imagemin/node_modules/fill-range/README.md
new file mode 100644
index 0000000..8d756fe
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fill-range/README.md
@@ -0,0 +1,237 @@
+# fill-range [](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [](https://www.npmjs.com/package/fill-range) [](https://npmjs.org/package/fill-range) [](https://npmjs.org/package/fill-range) [](https://travis-ci.org/jonschlinkert/fill-range)
+
+> Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save fill-range
+```
+
+## Usage
+
+Expands numbers and letters, optionally using a `step` as the last argument. _(Numbers may be defined as JavaScript numbers or strings)_.
+
+```js
+const fill = require('fill-range');
+// fill(from, to[, step, options]);
+
+console.log(fill('1', '10')); //=> ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
+console.log(fill('1', '10', { toRegex: true })); //=> [1-9]|10
+```
+
+**Params**
+
+* `from`: **{String|Number}** the number or letter to start with
+* `to`: **{String|Number}** the number or letter to end with
+* `step`: **{String|Number|Object|Function}** Optionally pass a [step](#optionsstep) to use.
+* `options`: **{Object|Function}**: See all available [options](#options)
+
+## Examples
+
+By default, an array of values is returned.
+
+**Alphabetical ranges**
+
+```js
+console.log(fill('a', 'e')); //=> ['a', 'b', 'c', 'd', 'e']
+console.log(fill('A', 'E')); //=> [ 'A', 'B', 'C', 'D', 'E' ]
+```
+
+**Numerical ranges**
+
+Numbers can be defined as actual numbers or strings.
+
+```js
+console.log(fill(1, 5)); //=> [ 1, 2, 3, 4, 5 ]
+console.log(fill('1', '5')); //=> [ 1, 2, 3, 4, 5 ]
+```
+
+**Negative ranges**
+
+Numbers can be defined as actual numbers or strings.
+
+```js
+console.log(fill('-5', '-1')); //=> [ '-5', '-4', '-3', '-2', '-1' ]
+console.log(fill('-5', '5')); //=> [ '-5', '-4', '-3', '-2', '-1', '0', '1', '2', '3', '4', '5' ]
+```
+
+**Steps (increments)**
+
+```js
+// numerical ranges with increments
+console.log(fill('0', '25', 4)); //=> [ '0', '4', '8', '12', '16', '20', '24' ]
+console.log(fill('0', '25', 5)); //=> [ '0', '5', '10', '15', '20', '25' ]
+console.log(fill('0', '25', 6)); //=> [ '0', '6', '12', '18', '24' ]
+
+// alphabetical ranges with increments
+console.log(fill('a', 'z', 4)); //=> [ 'a', 'e', 'i', 'm', 'q', 'u', 'y' ]
+console.log(fill('a', 'z', 5)); //=> [ 'a', 'f', 'k', 'p', 'u', 'z' ]
+console.log(fill('a', 'z', 6)); //=> [ 'a', 'g', 'm', 's', 'y' ]
+```
+
+## Options
+
+### options.step
+
+**Type**: `number` (formatted as a string or number)
+
+**Default**: `undefined`
+
+**Description**: The increment to use for the range. Can be used with letters or numbers.
+
+**Example(s)**
+
+```js
+// numbers
+console.log(fill('1', '10', 2)); //=> [ '1', '3', '5', '7', '9' ]
+console.log(fill('1', '10', 3)); //=> [ '1', '4', '7', '10' ]
+console.log(fill('1', '10', 4)); //=> [ '1', '5', '9' ]
+
+// letters
+console.log(fill('a', 'z', 5)); //=> [ 'a', 'f', 'k', 'p', 'u', 'z' ]
+console.log(fill('a', 'z', 7)); //=> [ 'a', 'h', 'o', 'v' ]
+console.log(fill('a', 'z', 9)); //=> [ 'a', 'j', 's' ]
+```
+
+### options.strictRanges
+
+**Type**: `boolean`
+
+**Default**: `false`
+
+**Description**: By default, `null` is returned when an invalid range is passed. Enable this option to throw a `RangeError` on invalid ranges.
+
+**Example(s)**
+
+The following are all invalid:
+
+```js
+fill('1.1', '2'); // decimals not supported in ranges
+fill('a', '2'); // incompatible range values
+fill(1, 10, 'foo'); // invalid "step" argument
+```
+
+### options.stringify
+
+**Type**: `boolean`
+
+**Default**: `undefined`
+
+**Description**: Cast all returned values to strings. By default, integers are returned as numbers.
+
+**Example(s)**
+
+```js
+console.log(fill(1, 5)); //=> [ 1, 2, 3, 4, 5 ]
+console.log(fill(1, 5, { stringify: true })); //=> [ '1', '2', '3', '4', '5' ]
+```
+
+### options.toRegex
+
+**Type**: `boolean`
+
+**Default**: `undefined`
+
+**Description**: Create a regex-compatible source string, instead of expanding values to an array.
+
+**Example(s)**
+
+```js
+// alphabetical range
+console.log(fill('a', 'e', { toRegex: true })); //=> '[a-e]'
+// alphabetical with step
+console.log(fill('a', 'z', 3, { toRegex: true })); //=> 'a|d|g|j|m|p|s|v|y'
+// numerical range
+console.log(fill('1', '100', { toRegex: true })); //=> '[1-9]|[1-9][0-9]|100'
+// numerical range with zero padding
+console.log(fill('000001', '100000', { toRegex: true }));
+//=> '0{5}[1-9]|0{4}[1-9][0-9]|0{3}[1-9][0-9]{2}|0{2}[1-9][0-9]{3}|0[1-9][0-9]{4}|100000'
+```
+
+### options.transform
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+**Description**: Customize each value in the returned array (or [string](#optionstoRegex)). _(you can also pass this function as the last argument to `fill()`)_.
+
+**Example(s)**
+
+```js
+// add zero padding
+console.log(fill(1, 5, value => String(value).padStart(4, '0')));
+//=> ['0001', '0002', '0003', '0004', '0005']
+```
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 116 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 4 | [paulmillr](https://github.com/paulmillr) |
+| 2 | [realityking](https://github.com/realityking) |
+| 2 | [bluelovers](https://github.com/bluelovers) |
+| 1 | [edorivai](https://github.com/edorivai) |
+| 1 | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+Please consider supporting me on Patreon, or [start your own Patreon page](https://patreon.com/invite/bxpbvm)!
+
+<a href="https://www.patreon.com/jonschlinkert">
+<img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" height="50">
+</a>
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 08, 2019._
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/fill-range/index.js b/node_modules/imagemin/node_modules/fill-range/index.js
new file mode 100644
index 0000000..97ce35a
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fill-range/index.js
@@ -0,0 +1,249 @@
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+const util = require('util');
+const toRegexRange = require('to-regex-range');
+
+const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+
+const transform = toNumber => {
+ return value => toNumber === true ? Number(value) : String(value);
+};
+
+const isValidValue = value => {
+ return typeof value === 'number' || (typeof value === 'string' && value !== '');
+};
+
+const isNumber = num => Number.isInteger(+num);
+
+const zeros = input => {
+ let value = `${input}`;
+ let index = -1;
+ if (value[0] === '-') value = value.slice(1);
+ if (value === '0') return false;
+ while (value[++index] === '0');
+ return index > 0;
+};
+
+const stringify = (start, end, options) => {
+ if (typeof start === 'string' || typeof end === 'string') {
+ return true;
+ }
+ return options.stringify === true;
+};
+
+const pad = (input, maxLength, toNumber) => {
+ if (maxLength > 0) {
+ let dash = input[0] === '-' ? '-' : '';
+ if (dash) input = input.slice(1);
+ input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
+ }
+ if (toNumber === false) {
+ return String(input);
+ }
+ return input;
+};
+
+const toMaxLen = (input, maxLength) => {
+ let negative = input[0] === '-' ? '-' : '';
+ if (negative) {
+ input = input.slice(1);
+ maxLength--;
+ }
+ while (input.length < maxLength) input = '0' + input;
+ return negative ? ('-' + input) : input;
+};
+
+const toSequence = (parts, options) => {
+ parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+ parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+
+ let prefix = options.capture ? '' : '?:';
+ let positives = '';
+ let negatives = '';
+ let result;
+
+ if (parts.positives.length) {
+ positives = parts.positives.join('|');
+ }
+
+ if (parts.negatives.length) {
+ negatives = `-(${prefix}${parts.negatives.join('|')})`;
+ }
+
+ if (positives && negatives) {
+ result = `${positives}|${negatives}`;
+ } else {
+ result = positives || negatives;
+ }
+
+ if (options.wrap) {
+ return `(${prefix}${result})`;
+ }
+
+ return result;
+};
+
+const toRange = (a, b, isNumbers, options) => {
+ if (isNumbers) {
+ return toRegexRange(a, b, { wrap: false, ...options });
+ }
+
+ let start = String.fromCharCode(a);
+ if (a === b) return start;
+
+ let stop = String.fromCharCode(b);
+ return `[${start}-${stop}]`;
+};
+
+const toRegex = (start, end, options) => {
+ if (Array.isArray(start)) {
+ let wrap = options.wrap === true;
+ let prefix = options.capture ? '' : '?:';
+ return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+ }
+ return toRegexRange(start, end, options);
+};
+
+const rangeError = (...args) => {
+ return new RangeError('Invalid range arguments: ' + util.inspect(...args));
+};
+
+const invalidRange = (start, end, options) => {
+ if (options.strictRanges === true) throw rangeError([start, end]);
+ return [];
+};
+
+const invalidStep = (step, options) => {
+ if (options.strictRanges === true) {
+ throw new TypeError(`Expected step "${step}" to be a number`);
+ }
+ return [];
+};
+
+const fillNumbers = (start, end, step = 1, options = {}) => {
+ let a = Number(start);
+ let b = Number(end);
+
+ if (!Number.isInteger(a) || !Number.isInteger(b)) {
+ if (options.strictRanges === true) throw rangeError([start, end]);
+ return [];
+ }
+
+ // fix negative zero
+ if (a === 0) a = 0;
+ if (b === 0) b = 0;
+
+ let descending = a > b;
+ let startString = String(start);
+ let endString = String(end);
+ let stepString = String(step);
+ step = Math.max(Math.abs(step), 1);
+
+ let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+ let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+ let toNumber = padded === false && stringify(start, end, options) === false;
+ let format = options.transform || transform(toNumber);
+
+ if (options.toRegex && step === 1) {
+ return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+ }
+
+ let parts = { negatives: [], positives: [] };
+ let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+ let range = [];
+ let index = 0;
+
+ while (descending ? a >= b : a <= b) {
+ if (options.toRegex === true && step > 1) {
+ push(a);
+ } else {
+ range.push(pad(format(a, index), maxLen, toNumber));
+ }
+ a = descending ? a - step : a + step;
+ index++;
+ }
+
+ if (options.toRegex === true) {
+ return step > 1
+ ? toSequence(parts, options)
+ : toRegex(range, null, { wrap: false, ...options });
+ }
+
+ return range;
+};
+
+const fillLetters = (start, end, step = 1, options = {}) => {
+ if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {
+ return invalidRange(start, end, options);
+ }
+
+
+ let format = options.transform || (val => String.fromCharCode(val));
+ let a = `${start}`.charCodeAt(0);
+ let b = `${end}`.charCodeAt(0);
+
+ let descending = a > b;
+ let min = Math.min(a, b);
+ let max = Math.max(a, b);
+
+ if (options.toRegex && step === 1) {
+ return toRange(min, max, false, options);
+ }
+
+ let range = [];
+ let index = 0;
+
+ while (descending ? a >= b : a <= b) {
+ range.push(format(a, index));
+ a = descending ? a - step : a + step;
+ index++;
+ }
+
+ if (options.toRegex === true) {
+ return toRegex(range, null, { wrap: false, options });
+ }
+
+ return range;
+};
+
+const fill = (start, end, step, options = {}) => {
+ if (end == null && isValidValue(start)) {
+ return [start];
+ }
+
+ if (!isValidValue(start) || !isValidValue(end)) {
+ return invalidRange(start, end, options);
+ }
+
+ if (typeof step === 'function') {
+ return fill(start, end, 1, { transform: step });
+ }
+
+ if (isObject(step)) {
+ return fill(start, end, 0, step);
+ }
+
+ let opts = { ...options };
+ if (opts.capture === true) opts.wrap = true;
+ step = step || opts.step || 1;
+
+ if (!isNumber(step)) {
+ if (step != null && !isObject(step)) return invalidStep(step, opts);
+ return fill(start, end, 1, step);
+ }
+
+ if (isNumber(start) && isNumber(end)) {
+ return fillNumbers(start, end, step, opts);
+ }
+
+ return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+};
+
+module.exports = fill;
diff --git a/node_modules/imagemin/node_modules/fill-range/package.json b/node_modules/imagemin/node_modules/fill-range/package.json
new file mode 100644
index 0000000..0027ecf
--- /dev/null
+++ b/node_modules/imagemin/node_modules/fill-range/package.json
@@ -0,0 +1,114 @@
+{
+ "_from": "fill-range@^7.0.1",
+ "_id": "fill-range@7.0.1",
+ "_inBundle": false,
+ "_integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+ "_location": "/imagemin/fill-range",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "fill-range@^7.0.1",
+ "name": "fill-range",
+ "escapedName": "fill-range",
+ "rawSpec": "^7.0.1",
+ "saveSpec": null,
+ "fetchSpec": "^7.0.1"
+ },
+ "_requiredBy": [
+ "/imagemin/braces"
+ ],
+ "_resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+ "_shasum": "1919a6a7c75fe38b2c7c77e5198535da9acdda40",
+ "_spec": "fill-range@^7.0.1",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\braces",
+ "author": {
+ "name": "Jon Schlinkert",
+ "url": "https://github.com/jonschlinkert"
+ },
+ "bugs": {
+ "url": "https://github.com/jonschlinkert/fill-range/issues"
+ },
+ "bundleDependencies": false,
+ "contributors": [
+ {
+ "name": "Edo Rivai",
+ "url": "edo.rivai.nl"
+ },
+ {
+ "name": "Jon Schlinkert",
+ "url": "http://twitter.com/jonschlinkert"
+ },
+ {
+ "name": "Paul Miller",
+ "url": "paulmillr.com"
+ },
+ {
+ "name": "Rouven Weßling",
+ "url": "www.rouvenwessling.de"
+ },
+ {
+ "url": "https://github.com/wtgtybhertgeghgtwtg"
+ }
+ ],
+ "dependencies": {
+ "to-regex-range": "^5.0.1"
+ },
+ "deprecated": false,
+ "description": "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`",
+ "devDependencies": {
+ "gulp-format-md": "^2.0.0",
+ "mocha": "^6.1.1"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js"
+ ],
+ "homepage": "https://github.com/jonschlinkert/fill-range",
+ "keywords": [
+ "alpha",
+ "alphabetical",
+ "array",
+ "bash",
+ "brace",
+ "expand",
+ "expansion",
+ "fill",
+ "glob",
+ "match",
+ "matches",
+ "matching",
+ "number",
+ "numerical",
+ "range",
+ "ranges",
+ "regex",
+ "sh"
+ ],
+ "license": "MIT",
+ "main": "index.js",
+ "name": "fill-range",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/jonschlinkert/fill-range.git"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "verb": {
+ "toc": false,
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "lint": {
+ "reflinks": true
+ }
+ },
+ "version": "7.0.1"
+}
diff --git a/node_modules/imagemin/node_modules/glob-parent/LICENSE b/node_modules/imagemin/node_modules/glob-parent/LICENSE
new file mode 100644
index 0000000..63222d7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/glob-parent/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2015, 2019 Elan Shanker
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/glob-parent/README.md b/node_modules/imagemin/node_modules/glob-parent/README.md
new file mode 100644
index 0000000..36a2793
--- /dev/null
+++ b/node_modules/imagemin/node_modules/glob-parent/README.md
@@ -0,0 +1,137 @@
+<p align="center">
+ <a href="https://gulpjs.com">
+ <img height="257" width="114" src="https://raw.githubusercontent.com/gulpjs/artwork/master/gulp-2x.png">
+ </a>
+</p>
+
+# glob-parent
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Azure Pipelines Build Status][azure-pipelines-image]][azure-pipelines-url] [![Travis Build Status][travis-image]][travis-url] [![AppVeyor Build Status][appveyor-image]][appveyor-url] [![Coveralls Status][coveralls-image]][coveralls-url] [![Gitter chat][gitter-image]][gitter-url]
+
+Extract the non-magic parent path from a glob string.
+
+## Usage
+
+```js
+var globParent = require('glob-parent');
+
+globParent('path/to/*.js'); // 'path/to'
+globParent('/root/path/to/*.js'); // '/root/path/to'
+globParent('/*.js'); // '/'
+globParent('*.js'); // '.'
+globParent('**/*.js'); // '.'
+globParent('path/{to,from}'); // 'path'
+globParent('path/!(to|from)'); // 'path'
+globParent('path/?(to|from)'); // 'path'
+globParent('path/+(to|from)'); // 'path'
+globParent('path/*(to|from)'); // 'path'
+globParent('path/@(to|from)'); // 'path'
+globParent('path/**/*'); // 'path'
+
+// if provided a non-glob path, returns the nearest dir
+globParent('path/foo/bar.js'); // 'path/foo'
+globParent('path/foo/'); // 'path/foo'
+globParent('path/foo'); // 'path' (see issue #3 for details)
+```
+
+## API
+
+### `globParent(maybeGlobString, [options])`
+
+Takes a string and returns the part of the path before the glob begins. Be aware of Escaping rules and Limitations below.
+
+#### options
+
+```js
+{
+ // Disables the automatic conversion of slashes for Windows
+ flipBackslashes: true
+}
+```
+
+## Escaping
+
+The following characters have special significance in glob patterns and must be escaped if you want them to be treated as regular path characters:
+
+- `?` (question mark) unless used as a path segment alone
+- `*` (asterisk)
+- `|` (pipe)
+- `(` (opening parenthesis)
+- `)` (closing parenthesis)
+- `{` (opening curly brace)
+- `}` (closing curly brace)
+- `[` (opening bracket)
+- `]` (closing bracket)
+
+**Example**
+
+```js
+globParent('foo/[bar]/') // 'foo'
+globParent('foo/\\[bar]/') // 'foo/[bar]'
+```
+
+## Limitations
+
+### Braces & Brackets
+This library attempts a quick and imperfect method of determining which path
+parts have glob magic without fully parsing/lexing the pattern. There are some
+advanced use cases that can trip it up, such as nested braces where the outer
+pair is escaped and the inner one contains a path separator. If you find
+yourself in the unlikely circumstance of being affected by this or need to
+ensure higher-fidelity glob handling in your library, it is recommended that you
+pre-process your input with [expand-braces] and/or [expand-brackets].
+
+### Windows
+Backslashes are not valid path separators for globs. If a path with backslashes
+is provided anyway, for simple cases, glob-parent will replace the path
+separator for you and return the non-glob parent path (now with
+forward-slashes, which are still valid as Windows path separators).
+
+This cannot be used in conjunction with escape characters.
+
+```js
+// BAD
+globParent('C:\\Program Files \\(x86\\)\\*.ext') // 'C:/Program Files /(x86/)'
+
+// GOOD
+globParent('C:/Program Files\\(x86\\)/*.ext') // 'C:/Program Files (x86)'
+```
+
+If you are using escape characters for a pattern without path parts (i.e.
+relative to `cwd`), prefix with `./` to avoid confusing glob-parent.
+
+```js
+// BAD
+globParent('foo \\[bar]') // 'foo '
+globParent('foo \\[bar]*') // 'foo '
+
+// GOOD
+globParent('./foo \\[bar]') // 'foo [bar]'
+globParent('./foo \\[bar]*') // '.'
+```
+
+## License
+
+ISC
+
+[expand-braces]: https://github.com/jonschlinkert/expand-braces
+[expand-brackets]: https://github.com/jonschlinkert/expand-brackets
+
+[downloads-image]: https://img.shields.io/npm/dm/glob-parent.svg
+[npm-url]: https://www.npmjs.com/package/glob-parent
+[npm-image]: https://img.shields.io/npm/v/glob-parent.svg
+
+[azure-pipelines-url]: https://dev.azure.com/gulpjs/gulp/_build/latest?definitionId=2&branchName=master
+[azure-pipelines-image]: https://dev.azure.com/gulpjs/gulp/_apis/build/status/glob-parent?branchName=master
+
+[travis-url]: https://travis-ci.org/gulpjs/glob-parent
+[travis-image]: https://img.shields.io/travis/gulpjs/glob-parent.svg?label=travis-ci
+
+[appveyor-url]: https://ci.appveyor.com/project/gulpjs/glob-parent
+[appveyor-image]: https://img.shields.io/appveyor/ci/gulpjs/glob-parent.svg?label=appveyor
+
+[coveralls-url]: https://coveralls.io/r/gulpjs/glob-parent
+[coveralls-image]: https://img.shields.io/coveralls/gulpjs/glob-parent/master.svg
+
+[gitter-url]: https://gitter.im/gulpjs/gulp
+[gitter-image]: https://badges.gitter.im/gulpjs/gulp.svg
diff --git a/node_modules/imagemin/node_modules/glob-parent/index.js b/node_modules/imagemin/node_modules/glob-parent/index.js
new file mode 100644
index 0000000..789dbbf
--- /dev/null
+++ b/node_modules/imagemin/node_modules/glob-parent/index.js
@@ -0,0 +1,41 @@
+'use strict';
+
+var isGlob = require('is-glob');
+var pathPosixDirname = require('path').posix.dirname;
+var isWin32 = require('os').platform() === 'win32';
+
+var slash = '/';
+var backslash = /\\/g;
+var enclosure = /[\{\[].*[\/]*.*[\}\]]$/;
+var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+
+/**
+ * @param {string} str
+ * @param {Object} opts
+ * @param {boolean} [opts.flipBackslashes=true]
+ */
+module.exports = function globParent(str, opts) {
+ var options = Object.assign({ flipBackslashes: true }, opts);
+
+ // flip windows path separators
+ if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
+ str = str.replace(backslash, slash);
+ }
+
+ // special case for strings ending in enclosure containing path separator
+ if (enclosure.test(str)) {
+ str += slash;
+ }
+
+ // preserves full path in case of trailing path separator
+ str += 'a';
+
+ // remove path parts that are globby
+ do {
+ str = pathPosixDirname(str);
+ } while (isGlob(str) || globby.test(str));
+
+ // remove escape chars and return result
+ return str.replace(escaped, '$1');
+};
diff --git a/node_modules/imagemin/node_modules/glob-parent/package.json b/node_modules/imagemin/node_modules/glob-parent/package.json
new file mode 100644
index 0000000..e693912
--- /dev/null
+++ b/node_modules/imagemin/node_modules/glob-parent/package.json
@@ -0,0 +1,90 @@
+{
+ "_from": "glob-parent@^5.1.0",
+ "_id": "glob-parent@5.1.1",
+ "_inBundle": false,
+ "_integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
+ "_location": "/imagemin/glob-parent",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "glob-parent@^5.1.0",
+ "name": "glob-parent",
+ "escapedName": "glob-parent",
+ "rawSpec": "^5.1.0",
+ "saveSpec": null,
+ "fetchSpec": "^5.1.0"
+ },
+ "_requiredBy": [
+ "/imagemin/fast-glob"
+ ],
+ "_resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
+ "_shasum": "b6c1ef417c4e5663ea498f1c45afac6916bbc229",
+ "_spec": "glob-parent@^5.1.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\fast-glob",
+ "author": {
+ "name": "Gulp Team",
+ "email": "team@gulpjs.com",
+ "url": "https://gulpjs.com/"
+ },
+ "bugs": {
+ "url": "https://github.com/gulpjs/glob-parent/issues"
+ },
+ "bundleDependencies": false,
+ "contributors": [
+ {
+ "name": "Elan Shanker",
+ "url": "https://github.com/es128"
+ },
+ {
+ "name": "Blaine Bublitz",
+ "email": "blaine.bublitz@gmail.com"
+ }
+ ],
+ "dependencies": {
+ "is-glob": "^4.0.1"
+ },
+ "deprecated": false,
+ "description": "Extract the non-magic parent path from a glob string.",
+ "devDependencies": {
+ "coveralls": "^3.0.11",
+ "eslint": "^2.13.1",
+ "eslint-config-gulp": "^3.0.1",
+ "expect": "^1.20.2",
+ "mocha": "^6.0.2",
+ "nyc": "^13.3.0"
+ },
+ "engines": {
+ "node": ">= 6"
+ },
+ "files": [
+ "LICENSE",
+ "index.js"
+ ],
+ "homepage": "https://github.com/gulpjs/glob-parent#readme",
+ "keywords": [
+ "glob",
+ "parent",
+ "strip",
+ "path",
+ "dirname",
+ "directory",
+ "base",
+ "wildcard"
+ ],
+ "license": "ISC",
+ "main": "index.js",
+ "name": "glob-parent",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/gulpjs/glob-parent.git"
+ },
+ "scripts": {
+ "azure-pipelines": "nyc mocha --async-only --reporter xunit -O output=test.xunit",
+ "coveralls": "nyc report --reporter=text-lcov | coveralls",
+ "lint": "eslint .",
+ "pretest": "npm run lint",
+ "test": "nyc mocha --async-only"
+ },
+ "version": "5.1.1"
+}
diff --git a/node_modules/imagemin/node_modules/globby/gitignore.js b/node_modules/imagemin/node_modules/globby/gitignore.js
new file mode 100644
index 0000000..3feaad6
--- /dev/null
+++ b/node_modules/imagemin/node_modules/globby/gitignore.js
@@ -0,0 +1,117 @@
+'use strict';
+const {promisify} = require('util');
+const fs = require('fs');
+const path = require('path');
+const fastGlob = require('fast-glob');
+const gitIgnore = require('ignore');
+const slash = require('slash');
+
+const DEFAULT_IGNORE = [
+ '**/node_modules/**',
+ '**/flow-typed/**',
+ '**/coverage/**',
+ '**/.git'
+];
+
+const readFileP = promisify(fs.readFile);
+
+const mapGitIgnorePatternTo = base => ignore => {
+ if (ignore.startsWith('!')) {
+ return '!' + path.posix.join(base, ignore.slice(1));
+ }
+
+ return path.posix.join(base, ignore);
+};
+
+const parseGitIgnore = (content, options) => {
+ const base = slash(path.relative(options.cwd, path.dirname(options.fileName)));
+
+ return content
+ .split(/\r?\n/)
+ .filter(Boolean)
+ .filter(line => !line.startsWith('#'))
+ .map(mapGitIgnorePatternTo(base));
+};
+
+const reduceIgnore = files => {
+ return files.reduce((ignores, file) => {
+ ignores.add(parseGitIgnore(file.content, {
+ cwd: file.cwd,
+ fileName: file.filePath
+ }));
+ return ignores;
+ }, gitIgnore());
+};
+
+const ensureAbsolutePathForCwd = (cwd, p) => {
+ if (path.isAbsolute(p)) {
+ if (p.startsWith(cwd)) {
+ return p;
+ }
+
+ throw new Error(`Path ${p} is not in cwd ${cwd}`);
+ }
+
+ return path.join(cwd, p);
+};
+
+const getIsIgnoredPredecate = (ignores, cwd) => {
+ return p => ignores.ignores(slash(path.relative(cwd, ensureAbsolutePathForCwd(cwd, p))));
+};
+
+const getFile = async (file, cwd) => {
+ const filePath = path.join(cwd, file);
+ const content = await readFileP(filePath, 'utf8');
+
+ return {
+ cwd,
+ filePath,
+ content
+ };
+};
+
+const getFileSync = (file, cwd) => {
+ const filePath = path.join(cwd, file);
+ const content = fs.readFileSync(filePath, 'utf8');
+
+ return {
+ cwd,
+ filePath,
+ content
+ };
+};
+
+const normalizeOptions = ({
+ ignore = [],
+ cwd = slash(process.cwd())
+} = {}) => {
+ return {ignore, cwd};
+};
+
+module.exports = async options => {
+ options = normalizeOptions(options);
+
+ const paths = await fastGlob('**/.gitignore', {
+ ignore: DEFAULT_IGNORE.concat(options.ignore),
+ cwd: options.cwd
+ });
+
+ const files = await Promise.all(paths.map(file => getFile(file, options.cwd)));
+ const ignores = reduceIgnore(files);
+
+ return getIsIgnoredPredecate(ignores, options.cwd);
+};
+
+module.exports.sync = options => {
+ options = normalizeOptions(options);
+
+ const paths = fastGlob.sync('**/.gitignore', {
+ ignore: DEFAULT_IGNORE.concat(options.ignore),
+ cwd: options.cwd
+ });
+
+ const files = paths.map(file => getFileSync(file, options.cwd));
+ const ignores = reduceIgnore(files);
+
+ return getIsIgnoredPredecate(ignores, options.cwd);
+};
diff --git a/node_modules/imagemin/node_modules/globby/index.d.ts b/node_modules/imagemin/node_modules/globby/index.d.ts
new file mode 100644
index 0000000..abec630
--- /dev/null
+++ b/node_modules/imagemin/node_modules/globby/index.d.ts
@@ -0,0 +1,176 @@
+import {IOptions as NodeGlobOptions} from 'glob';
+import {Options as FastGlobOptions} from 'fast-glob';
+
+declare namespace globby {
+ type ExpandDirectoriesOption =
+ | boolean
+ | readonly string[]
+ | {files?: readonly string[]; extensions?: readonly string[]};
+
+ interface GlobbyOptions extends FastGlobOptions {
+ /**
+ If set to `true`, `globby` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `Object` with `files` and `extensions` like in the example below.
+
+ Note that if you set this option to `false`, you won't get back matched directories unless you set `onlyFiles: false`.
+
+ @default true
+
+ @example
+ ```
+ import globby = require('globby');
+
+ (async () => {
+ const paths = await globby('images', {
+ expandDirectories: {
+ files: ['cat', 'unicorn', '*.jpg'],
+ extensions: ['png']
+ }
+ });
+ console.log(paths);
+ //=> ['cat.png', 'unicorn.png', 'cow.jpg', 'rainbow.jpg']
+ })();
+ ```
+ */
+ readonly expandDirectories?: ExpandDirectoriesOption;
+
+ /**
+ Respect ignore patterns in `.gitignore` files that apply to the globbed files.
+
+ @default false
+ */
+ readonly gitignore?: boolean;
+ }
+
+ interface GlobTask {
+ readonly pattern: string;
+ readonly options: globby.GlobbyOptions;
+ }
+
+ interface GitignoreOptions {
+ readonly cwd?: string;
+ readonly ignore?: readonly string[];
+ }
+
+ type FilterFunction = (path: string) => boolean;
+}
+
+interface Gitignore {
+ /**
+ `.gitignore` files matched by the ignore config are not used for the resulting filter function.
+
+ @returns A filter function indicating whether a given path is ignored via a `.gitignore` file.
+
+ @example
+ ```
+ import {gitignore} from 'globby';
+
+ (async () => {
+ const isIgnored = await gitignore();
+ console.log(isIgnored('some/file'));
+ })();
+ ```
+ */
+ (options?: globby.GitignoreOptions): Promise<globby.FilterFunction>;
+
+ /**
+ @returns A filter function indicating whether a given path is ignored via a `.gitignore` file.
+ */
+ sync(options?: globby.GitignoreOptions): globby.FilterFunction;
+}
+
+declare const globby: {
+ /**
+ Find files and directories using glob patterns.
+
+ Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+
+ @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+ @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-1) in addition to the ones in this package.
+ @returns The matching paths.
+
+ @example
+ ```
+ import globby = require('globby');
+
+ (async () => {
+ const paths = await globby(['*', '!cake']);
+
+ console.log(paths);
+ //=> ['unicorn', 'rainbow']
+ })();
+ ```
+ */
+ (
+ patterns: string | readonly string[],
+ options?: globby.GlobbyOptions
+ ): Promise<string[]>;
+
+ /**
+ Find files and directories using glob patterns.
+
+ Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+
+ @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+ @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-1) in addition to the ones in this package.
+ @returns The matching paths.
+ */
+ sync(
+ patterns: string | readonly string[],
+ options?: globby.GlobbyOptions
+ ): string[];
+
+ /**
+ Find files and directories using glob patterns.
+
+ Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+
+ @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+ @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-1) in addition to the ones in this package.
+ @returns The stream of matching paths.
+
+ @example
+ ```
+ import globby = require('globby');
+
+ (async () => {
+ for await (const path of globby.stream('*.tmp')) {
+ console.log(path);
+ }
+ })();
+ ```
+ */
+ stream(
+ patterns: string | readonly string[],
+ options?: globby.GlobbyOptions
+ ): NodeJS.ReadableStream;
+
+ /**
+ Note that you should avoid running the same tasks multiple times as they contain a file system cache. Instead, run this method each time to ensure file system changes are taken into consideration.
+
+ @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+ @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-1) in addition to the ones in this package.
+ @returns An object in the format `{pattern: string, options: object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
+ */
+ generateGlobTasks(
+ patterns: string | readonly string[],
+ options?: globby.GlobbyOptions
+ ): globby.GlobTask[];
+
+ /**
+ Note that the options affect the results. If `noext: true` is set, then `+(a|b)` will not be considered a magic pattern. If the pattern has a brace expansion, like `a/{b/c,x/y}`, then that is considered magical, unless `nobrace: true` is set.
+
+ This function is backed by [`node-glob`](https://github.com/isaacs/node-glob#globhasmagicpattern-options).
+
+ @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+ @param options - See the [`node-glob` options](https://github.com/isaacs/node-glob#globhasmagicpattern-options).
+ @returns Whether there are any special glob characters in the `patterns`.
+ */
+ hasMagic(
+ patterns: string | readonly string[],
+ options?: NodeGlobOptions
+ ): boolean;
+
+ readonly gitignore: Gitignore;
+};
+
+export = globby;
diff --git a/node_modules/imagemin/node_modules/globby/index.js b/node_modules/imagemin/node_modules/globby/index.js
new file mode 100644
index 0000000..764441c
--- /dev/null
+++ b/node_modules/imagemin/node_modules/globby/index.js
@@ -0,0 +1,178 @@
+'use strict';
+const fs = require('fs');
+const arrayUnion = require('array-union');
+const merge2 = require('merge2');
+const glob = require('glob');
+const fastGlob = require('fast-glob');
+const dirGlob = require('dir-glob');
+const gitignore = require('./gitignore');
+const {FilterStream, UniqueStream} = require('./stream-utils');
+
+const DEFAULT_FILTER = () => false;
+
+const isNegative = pattern => pattern[0] === '!';
+
+const assertPatternsInput = patterns => {
+ if (!patterns.every(pattern => typeof pattern === 'string')) {
+ throw new TypeError('Patterns must be a string or an array of strings');
+ }
+};
+
+const checkCwdOption = (options = {}) => {
+ if (!options.cwd) {
+ return;
+ }
+
+ let stat;
+ try {
+ stat = fs.statSync(options.cwd);
+ } catch (_) {
+ return;
+ }
+
+ if (!stat.isDirectory()) {
+ throw new Error('The `cwd` option must be a path to a directory');
+ }
+};
+
+const getPathString = p => p.stats instanceof fs.Stats ? p.path : p;
+
+const generateGlobTasks = (patterns, taskOptions) => {
+ patterns = arrayUnion([].concat(patterns));
+ assertPatternsInput(patterns);
+ checkCwdOption(taskOptions);
+
+ const globTasks = [];
+
+ taskOptions = {
+ ignore: [],
+ expandDirectories: true,
+ ...taskOptions
+ };
+
+ for (const [index, pattern] of patterns.entries()) {
+ if (isNegative(pattern)) {
+ continue;
+ }
+
+ const ignore = patterns
+ .slice(index)
+ .filter(isNegative)
+ .map(pattern => pattern.slice(1));
+
+ const options = {
+ ...taskOptions,
+ ignore: taskOptions.ignore.concat(ignore)
+ };
+
+ globTasks.push({pattern, options});
+ }
+
+ return globTasks;
+};
+
+const globDirs = (task, fn) => {
+ let options = {};
+ if (task.options.cwd) {
+ options.cwd = task.options.cwd;
+ }
+
+ if (Array.isArray(task.options.expandDirectories)) {
+ options = {
+ ...options,
+ files: task.options.expandDirectories
+ };
+ } else if (typeof task.options.expandDirectories === 'object') {
+ options = {
+ ...options,
+ ...task.options.expandDirectories
+ };
+ }
+
+ return fn(task.pattern, options);
+};
+
+const getPattern = (task, fn) => task.options.expandDirectories ? globDirs(task, fn) : [task.pattern];
+
+const getFilterSync = options => {
+ return options && options.gitignore ?
+ gitignore.sync({cwd: options.cwd, ignore: options.ignore}) :
+ DEFAULT_FILTER;
+};
+
+const globToTask = task => glob => {
+ const {options} = task;
+ if (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) {
+ options.ignore = dirGlob.sync(options.ignore);
+ }
+
+ return {
+ pattern: glob,
+ options
+ };
+};
+
+module.exports = async (patterns, options) => {
+ const globTasks = generateGlobTasks(patterns, options);
+
+ const getFilter = async () => {
+ return options && options.gitignore ?
+ gitignore({cwd: options.cwd, ignore: options.ignore}) :
+ DEFAULT_FILTER;
+ };
+
+ const getTasks = async () => {
+ const tasks = await Promise.all(globTasks.map(async task => {
+ const globs = await getPattern(task, dirGlob);
+ return Promise.all(globs.map(globToTask(task)));
+ }));
+
+ return arrayUnion(...tasks);
+ };
+
+ const [filter, tasks] = await Promise.all([getFilter(), getTasks()]);
+ const paths = await Promise.all(tasks.map(task => fastGlob(task.pattern, task.options)));
+
+ return arrayUnion(...paths).filter(path_ => !filter(getPathString(path_)));
+};
+
+module.exports.sync = (patterns, options) => {
+ const globTasks = generateGlobTasks(patterns, options);
+
+ const tasks = globTasks.reduce((tasks, task) => {
+ const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
+ return tasks.concat(newTask);
+ }, []);
+
+ const filter = getFilterSync(options);
+
+ return tasks.reduce(
+ (matches, task) => arrayUnion(matches, fastGlob.sync(task.pattern, task.options)),
+ []
+ ).filter(path_ => !filter(path_));
+};
+
+module.exports.stream = (patterns, options) => {
+ const globTasks = generateGlobTasks(patterns, options);
+
+ const tasks = globTasks.reduce((tasks, task) => {
+ const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
+ return tasks.concat(newTask);
+ }, []);
+
+ const filter = getFilterSync(options);
+ const filterStream = new FilterStream(p => !filter(p));
+ const uniqueStream = new UniqueStream();
+
+ return merge2(tasks.map(task => fastGlob.stream(task.pattern, task.options)))
+ .pipe(filterStream)
+ .pipe(uniqueStream);
+};
+
+module.exports.generateGlobTasks = generateGlobTasks;
+
+module.exports.hasMagic = (patterns, options) => []
+ .concat(patterns)
+ .some(pattern => glob.hasMagic(pattern, options));
+
+module.exports.gitignore = gitignore;
diff --git a/node_modules/imagemin/node_modules/globby/license b/node_modules/imagemin/node_modules/globby/license
new file mode 100644
index 0000000..e7af2f7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/globby/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/globby/package.json b/node_modules/imagemin/node_modules/globby/package.json
new file mode 100644
index 0000000..76e5126
--- /dev/null
+++ b/node_modules/imagemin/node_modules/globby/package.json
@@ -0,0 +1,115 @@
+{
+ "_from": "globby@^10.0.0",
+ "_id": "globby@10.0.2",
+ "_inBundle": false,
+ "_integrity": "sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg==",
+ "_location": "/imagemin/globby",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "globby@^10.0.0",
+ "name": "globby",
+ "escapedName": "globby",
+ "rawSpec": "^10.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^10.0.0"
+ },
+ "_requiredBy": [
+ "/imagemin"
+ ],
+ "_resolved": "https://registry.npmjs.org/globby/-/globby-10.0.2.tgz",
+ "_shasum": "277593e745acaa4646c3ab411289ec47a0392543",
+ "_spec": "globby@^10.0.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "bugs": {
+ "url": "https://github.com/sindresorhus/globby/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "@types/glob": "^7.1.1",
+ "array-union": "^2.1.0",
+ "dir-glob": "^3.0.1",
+ "fast-glob": "^3.0.3",
+ "glob": "^7.1.3",
+ "ignore": "^5.1.1",
+ "merge2": "^1.2.3",
+ "slash": "^3.0.0"
+ },
+ "deprecated": false,
+ "description": "Extends `glob` with support for multiple patterns and exposes a Promise API",
+ "devDependencies": {
+ "ava": "^2.1.0",
+ "get-stream": "^5.1.0",
+ "glob-stream": "^6.1.0",
+ "globby": "github:sindresorhus/globby#master",
+ "matcha": "^0.7.0",
+ "rimraf": "^2.6.3",
+ "tsd": "^0.7.3",
+ "xo": "^0.24.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js",
+ "gitignore.js",
+ "index.d.ts",
+ "stream-utils.js"
+ ],
+ "homepage": "https://github.com/sindresorhus/globby#readme",
+ "keywords": [
+ "all",
+ "array",
+ "directories",
+ "expand",
+ "files",
+ "filesystem",
+ "filter",
+ "find",
+ "fnmatch",
+ "folders",
+ "fs",
+ "glob",
+ "globbing",
+ "globs",
+ "gulpfriendly",
+ "match",
+ "matcher",
+ "minimatch",
+ "multi",
+ "multiple",
+ "paths",
+ "pattern",
+ "patterns",
+ "traverse",
+ "util",
+ "utility",
+ "wildcard",
+ "wildcards",
+ "promise",
+ "gitignore",
+ "git"
+ ],
+ "license": "MIT",
+ "name": "globby",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/sindresorhus/globby.git"
+ },
+ "scripts": {
+ "bench": "npm update glob-stream fast-glob && matcha bench.js",
+ "test": "xo && ava && tsd"
+ },
+ "version": "10.0.2",
+ "xo": {
+ "ignores": [
+ "fixtures"
+ ]
+ }
+}
diff --git a/node_modules/imagemin/node_modules/globby/readme.md b/node_modules/imagemin/node_modules/globby/readme.md
new file mode 100644
index 0000000..e8781c7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/globby/readme.md
@@ -0,0 +1,178 @@
+# globby [](https://travis-ci.org/sindresorhus/globby)
+
+> User-friendly glob matching
+
+Based on [`fast-glob`](https://github.com/mrmlnc/fast-glob), but adds a bunch of useful features and a nicer API.
+
+
+## Features
+
+- Promise API
+- Multiple patterns
+- Negated patterns: `['foo*', '!foobar']`
+- Expands directories: `dir` → `dir/**/*`
+- Supports `.gitignore`
+
+
+## Install
+
+```
+$ npm install globby
+```
+
+
+## Usage
+
+```
+├── unicorn
+├── cake
+└── rainbow
+```
+
+```js
+const globby = require('globby');
+
+(async () => {
+ const paths = await globby(['*', '!cake']);
+
+ console.log(paths);
+ //=> ['unicorn', 'rainbow']
+})();
+```
+
+
+## API
+
+Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+
+### globby(patterns, options?)
+
+Returns a `Promise<string[]>` of matching paths.
+
+#### patterns
+
+Type: `string | string[]`
+
+See supported `minimatch` [patterns](https://github.com/isaacs/minimatch#usage).
+
+#### options
+
+Type: `object`
+
+See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-1) in addition to the ones below.
+
+##### expandDirectories
+
+Type: `boolean | string[] | object`<br>
+Default: `true`
+
+If set to `true`, `globby` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `object` with `files` and `extensions` like below:
+
+```js
+const globby = require('globby');
+
+(async () => {
+ const paths = await globby('images', {
+ expandDirectories: {
+ files: ['cat', 'unicorn', '*.jpg'],
+ extensions: ['png']
+ }
+ });
+
+ console.log(paths);
+ //=> ['cat.png', 'unicorn.png', 'cow.jpg', 'rainbow.jpg']
+})();
+```
+
+Note that if you set this option to `false`, you won't get back matched directories unless you set `onlyFiles: false`.
+
+##### gitignore
+
+Type: `boolean`<br>
+Default: `false`
+
+Respect ignore patterns in `.gitignore` files that apply to the globbed files.
+
+### globby.sync(patterns, options?)
+
+Returns `string[]` of matching paths.
+
+### globby.stream(patterns, options?)
+
+Returns a [`stream.Readable`](https://nodejs.org/api/stream.html#stream_readable_streams) of matching paths.
+
+Since Node.js 10, [readable streams are iterable](https://nodejs.org/api/stream.html#stream_readable_symbol_asynciterator), so you can loop over glob matches in a [`for await...of` loop](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of) like this:
+
+```js
+const globby = require('globby');
+
+(async () => {
+ for await (const path of globby.stream('*.tmp')) {
+ console.log(path);
+ }
+})();
+```
+
+### globby.generateGlobTasks(patterns, options?)
+
+Returns an `object[]` in the format `{pattern: string, options: Object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
+
+Note that you should avoid running the same tasks multiple times as they contain a file system cache. Instead, run this method each time to ensure file system changes are taken into consideration.
+
+### globby.hasMagic(patterns, options?)
+
+Returns a `boolean` of whether there are any special glob characters in the `patterns`.
+
+Note that the options affect the results. If `noext: true` is set, then `+(a|b)` will not be considered a magic pattern. If the pattern has a brace expansion, like `a/{b/c,x/y}`, then that is considered magical, unless `nobrace: true` is set.
+
+This function is backed by [`node-glob`](https://github.com/isaacs/node-glob#globhasmagicpattern-options)
+
+### globby.gitignore(options?)
+
+Returns a `Promise<(path: string) => boolean>` indicating whether a given path is ignored via a `.gitignore` file.
+
+Takes `cwd?: string` and `ignore?: string[]` as options. `.gitignore` files matched by the ignore config are not
+used for the resulting filter function.
+
+```js
+const {gitignore} = require('globby');
+
+(async () => {
+ const isIgnored = await gitignore();
+ console.log(isIgnored('some/file'));
+})();
+```
+
+### globby.gitignore.sync(options?)
+
+Returns a `(path: string) => boolean` indicating whether a given path is ignored via a `.gitignore` file.
+
+Takes the same options as `globby.gitignore`.
+
+
+## Globbing patterns
+
+Just a quick overview.
+
+- `*` matches any number of characters, but not `/`
+- `?` matches a single character, but not `/`
+- `**` matches any number of characters, including `/`, as long as it's the only thing in a path part
+- `{}` allows for a comma-separated list of "or" expressions
+- `!` at the beginning of a pattern will negate the match
+
+[Various patterns and expected matches.](https://github.com/sindresorhus/multimatch/blob/master/test/test.js)
+
+
+## globby for enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of globby and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-globby?utm_source=npm-globby&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+
+
+## Related
+
+- [multimatch](https://github.com/sindresorhus/multimatch) - Match against a list instead of the filesystem
+- [matcher](https://github.com/sindresorhus/matcher) - Simple wildcard matching
+- [del](https://github.com/sindresorhus/del) - Delete files and directories
+- [make-dir](https://github.com/sindresorhus/make-dir) - Make a directory and its parents if needed
diff --git a/node_modules/imagemin/node_modules/globby/stream-utils.js b/node_modules/imagemin/node_modules/globby/stream-utils.js
new file mode 100644
index 0000000..98aedc8
--- /dev/null
+++ b/node_modules/imagemin/node_modules/globby/stream-utils.js
@@ -0,0 +1,46 @@
+'use strict';
+const {Transform} = require('stream');
+
+class ObjectTransform extends Transform {
+ constructor() {
+ super({
+ objectMode: true
+ });
+ }
+}
+
+class FilterStream extends ObjectTransform {
+ constructor(filter) {
+ super();
+ this._filter = filter;
+ }
+
+ _transform(data, encoding, callback) {
+ if (this._filter(data)) {
+ this.push(data);
+ }
+
+ callback();
+ }
+}
+
+class UniqueStream extends ObjectTransform {
+ constructor() {
+ super();
+ this._pushed = new Set();
+ }
+
+ _transform(data, encoding, callback) {
+ if (!this._pushed.has(data)) {
+ this.push(data);
+ this._pushed.add(data);
+ }
+
+ callback();
+ }
+}
+
+module.exports = {
+ FilterStream,
+ UniqueStream
+};
diff --git a/node_modules/imagemin/node_modules/ignore/CHANGELOG.md b/node_modules/imagemin/node_modules/ignore/CHANGELOG.md
new file mode 100644
index 0000000..dc38d63
--- /dev/null
+++ b/node_modules/imagemin/node_modules/ignore/CHANGELOG.md
@@ -0,0 +1,32 @@
+# `node-ignore` 5 ChangeLog
+
+# 5.x
+
+## 2018-08-14, Version 5.0.1
+
+- **PATCH**: fixes for windows.
+- **PATCH**: improves tests for typescript and windows.
+
+## 2018-08-13, Version 5.0.0
+
+- **SEMVER-MAJOR**: [#20](https://github.com/kaelzhang/node-ignore/issues/20): it will throw if an invalid pathname passes into `.ignores(pathname)`, see [Upgrade 4.x -> 5.x](https://github.com/kaelzhang/node-ignore#upgrade-4x---5x).
+- **FEATURE**: [#31](https://github.com/kaelzhang/node-ignore/issues/31): adds a new method [`.test(pathname)`](https://github.com/kaelzhang/node-ignore#testpathname-pathname-since-500).
+- **BENCHMARK**: improves performance by 26%.
+
+# 4.x
+
+## 2018-08-12, Version 4.0.6
+
+- **PATCH**: `Object.prototype` methods will not ruin the result any more.
+
+## ~ 2018-08-09, Version 4.0.1 - 4.0.5
+
+- **PATCH**: updates README.md about frequent asked quesions from github issues.
+
+## 2018-06-22, Version 4.0.0
+
+- **SEMVER-MAJOR**: Drop support for node < 6 by default.
+- **FEATURE**: supports the missing character ranges and sets, such as `*.[a-z]` and `*.[jJ][pP][gG]`
+- **FEATURE**: new option: `ignorecase` to make `ignore` case insensitive.
+- **FEATURE**: supports question mark which matches a single character.
+- **PATCH**: fixes typescript declaration.
diff --git a/node_modules/imagemin/node_modules/ignore/LICENSE-MIT b/node_modules/imagemin/node_modules/ignore/LICENSE-MIT
new file mode 100644
index 0000000..825533e
--- /dev/null
+++ b/node_modules/imagemin/node_modules/ignore/LICENSE-MIT
@@ -0,0 +1,21 @@
+Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors
+http://kael.me/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/ignore/README.md b/node_modules/imagemin/node_modules/ignore/README.md
new file mode 100644
index 0000000..4bdac9d
--- /dev/null
+++ b/node_modules/imagemin/node_modules/ignore/README.md
@@ -0,0 +1,392 @@
+<table><thead>
+ <tr>
+ <th>Linux</th>
+ <th>OS X</th>
+ <th>Windows</th>
+ <th>Coverage</th>
+ <th>Downloads</th>
+ </tr>
+</thead><tbody><tr>
+ <td colspan="2" align="center">
+ <a href="https://travis-ci.org/kaelzhang/node-ignore">
+ <img
+ src="https://travis-ci.org/kaelzhang/node-ignore.svg?branch=master"
+ alt="Build Status" /></a>
+ </td>
+ <td align="center">
+ <a href="https://ci.appveyor.com/project/kaelzhang/node-ignore">
+ <img
+ src="https://ci.appveyor.com/api/projects/status/github/kaelzhang/node-ignore?branch=master&svg=true"
+ alt="Windows Build Status" /></a>
+ </td>
+ <td align="center">
+ <a href="https://codecov.io/gh/kaelzhang/node-ignore">
+ <img
+ src="https://codecov.io/gh/kaelzhang/node-ignore/branch/master/graph/badge.svg"
+ alt="Coverage Status" /></a>
+ </td>
+ <td align="center">
+ <a href="https://www.npmjs.org/package/ignore">
+ <img
+ src="http://img.shields.io/npm/dm/ignore.svg"
+ alt="npm module downloads per month" /></a>
+ </td>
+</tr></tbody></table>
+
+# ignore
+
+`ignore` is a manager, filter and parser which implemented in pure JavaScript according to the [.gitignore spec 2.22.1](http://git-scm.com/docs/gitignore).
+
+`ignore` is used by eslint, gitbook and [many others](https://www.npmjs.com/browse/depended/ignore).
+
+Pay **ATTENTION** that [`minimatch`](https://www.npmjs.org/package/minimatch) (which used by `fstream-ignore`) does not follow the gitignore spec.
+
+To filter filenames according to a .gitignore file, I recommend this npm package, `ignore`.
+
+To parse an `.npmignore` file, you should use `minimatch`, because an `.npmignore` file is parsed by npm using `minimatch` and it does not work in the .gitignore way.
+
+### Tested on
+
+`ignore` is fully tested, and has more than **five hundreds** of unit tests.
+
+- Linux + Node: `0.8` - `7.x`
+- Windows + Node: `0.10` - `7.x`, node < `0.10` is not tested due to the lack of support of appveyor.
+
+Actually, `ignore` does not rely on any versions of node specially.
+
+Since `4.0.0`, ignore will no longer support `node < 6` by default, to use in node < 6, `require('ignore/legacy')`. For details, see [CHANGELOG](https://github.com/kaelzhang/node-ignore/blob/master/CHANGELOG.md).
+
+## Table Of Main Contents
+
+- [Usage](#usage)
+- [`Pathname` Conventions](#pathname-conventions)
+- See Also:
+ - [`glob-gitignore`](https://www.npmjs.com/package/glob-gitignore) matches files using patterns and filters them according to gitignore rules.
+- [Upgrade Guide](#upgrade-guide)
+
+## Install
+
+```sh
+npm i ignore
+```
+
+## Usage
+
+```js
+import ignore from 'ignore'
+const ig = ignore().add(['.abc/*', '!.abc/d/'])
+```
+
+### Filter the given paths
+
+```js
+const paths = [
+ '.abc/a.js', // filtered out
+ '.abc/d/e.js' // included
+]
+
+ig.filter(paths) // ['.abc/d/e.js']
+ig.ignores('.abc/a.js') // true
+```
+
+### As the filter function
+
+```js
+paths.filter(ig.createFilter()); // ['.abc/d/e.js']
+```
+
+### Win32 paths will be handled
+
+```js
+ig.filter(['.abc\\a.js', '.abc\\d\\e.js'])
+// if the code above runs on windows, the result will be
+// ['.abc\\d\\e.js']
+```
+
+## Why another ignore?
+
+- `ignore` is a standalone module, and is much simpler so that it could easy work with other programs, unlike [isaacs](https://npmjs.org/~isaacs)'s [fstream-ignore](https://npmjs.org/package/fstream-ignore) which must work with the modules of the fstream family.
+
+- `ignore` only contains utility methods to filter paths according to the specified ignore rules, so
+ - `ignore` never try to find out ignore rules by traversing directories or fetching from git configurations.
+ - `ignore` don't cares about sub-modules of git projects.
+
+- Exactly according to [gitignore man page](http://git-scm.com/docs/gitignore), fixes some known matching issues of fstream-ignore, such as:
+ - '`/*.js`' should only match '`a.js`', but not '`abc/a.js`'.
+ - '`**/foo`' should match '`foo`' anywhere.
+ - Prevent re-including a file if a parent directory of that file is excluded.
+ - Handle trailing whitespaces:
+ - `'a '`(one space) should not match `'a '`(two spaces).
+ - `'a \ '` matches `'a '`
+ - All test cases are verified with the result of `git check-ignore`.
+
+# Methods
+
+## .add(pattern: string | Ignore): this
+## .add(patterns: Array<string | Ignore>): this
+
+- **pattern** `String | Ignore` An ignore pattern string, or the `Ignore` instance
+- **patterns** `Array<String | Ignore>` Array of ignore patterns.
+
+Adds a rule or several rules to the current manager.
+
+Returns `this`
+
+Notice that a line starting with `'#'`(hash) is treated as a comment. Put a backslash (`'\'`) in front of the first hash for patterns that begin with a hash, if you want to ignore a file with a hash at the beginning of the filename.
+
+```js
+ignore().add('#abc').ignores('#abc') // false
+ignore().add('\#abc').ignores('#abc') // true
+```
+
+`pattern` could either be a line of ignore pattern or a string of multiple ignore patterns, which means we could just `ignore().add()` the content of a ignore file:
+
+```js
+ignore()
+.add(fs.readFileSync(filenameOfGitignore).toString())
+.filter(filenames)
+```
+
+`pattern` could also be an `ignore` instance, so that we could easily inherit the rules of another `Ignore` instance.
+
+## <strike>.addIgnoreFile(path)</strike>
+
+REMOVED in `3.x` for now.
+
+To upgrade `ignore@2.x` up to `3.x`, use
+
+```js
+import fs from 'fs'
+
+if (fs.existsSync(filename)) {
+ ignore().add(fs.readFileSync(filename).toString())
+}
+```
+
+instead.
+
+## .filter(paths: Array<Pathname>): Array<Pathname>
+
+```ts
+type Pathname = string
+```
+
+Filters the given array of pathnames, and returns the filtered array.
+
+- **paths** `Array.<Pathname>` The array of `pathname`s to be filtered.
+
+### `Pathname` Conventions:
+
+#### 1. `Pathname` should be a `path.relative()`d pathname
+
+`Pathname` should be a string that have been `path.join()`ed, or the return value of `path.relative()` to the current directory,
+
+```js
+// WRONG, an error will be thrown
+ig.ignores('./abc')
+
+// WRONG, for it will never happen, and an error will be thrown
+// If the gitignore rule locates at the root directory,
+// `'/abc'` should be changed to `'abc'`.
+// ```
+// path.relative('/', '/abc') -> 'abc'
+// ```
+ig.ignores('/abc')
+
+// WRONG, that it is an absolute path on Windows, an error will be thrown
+ig.ignores('C:\\abc')
+
+// Right
+ig.ignores('abc')
+
+// Right
+ig.ignores(path.join('./abc')) // path.join('./abc') -> 'abc'
+```
+
+In other words, each `Pathname` here should be a relative path to the directory of the gitignore rules.
+
+Suppose the dir structure is:
+
+```
+/path/to/your/repo
+ |-- a
+ | |-- a.js
+ |
+ |-- .b
+ |
+ |-- .c
+ |-- .DS_store
+```
+
+Then the `paths` might be like this:
+
+```js
+[
+ 'a/a.js'
+ '.b',
+ '.c/.DS_store'
+]
+```
+
+#### 2. filenames and dirnames
+
+`node-ignore` does NO `fs.stat` during path matching, so for the example below:
+
+```js
+// First, we add a ignore pattern to ignore a directory
+ig.add('config/')
+
+// `ig` does NOT know if 'config', in the real world,
+// is a normal file, directory or something.
+
+ig.ignores('config')
+// `ig` treats `config` as a file, so it returns `false`
+
+ig.ignores('config/')
+// returns `true`
+```
+
+Specially for people who develop some library based on `node-ignore`, it is important to understand that.
+
+Usually, you could use [`glob`](http://npmjs.org/package/glob) with `option.mark = true` to fetch the structure of the current directory:
+
+```js
+import glob from 'glob'
+
+glob('**', {
+ // Adds a / character to directory matches.
+ mark: true
+}, (err, files) => {
+ if (err) {
+ return console.error(err)
+ }
+
+ let filtered = ignore().add(patterns).filter(files)
+ console.log(filtered)
+})
+```
+
+## .ignores(pathname: Pathname): boolean
+
+> new in 3.2.0
+
+Returns `Boolean` whether `pathname` should be ignored.
+
+```js
+ig.ignores('.abc/a.js') // true
+```
+
+## .createFilter()
+
+Creates a filter function which could filter an array of paths with `Array.prototype.filter`.
+
+Returns `function(path)` the filter function.
+
+## .test(pathname: Pathname) since 5.0.0
+
+Returns `TestResult`
+
+```ts
+interface TestResult {
+ ignored: boolean
+ // true if the `pathname` is finally unignored by some negative pattern
+ unignored: boolean
+}
+```
+
+- `{ignored: true, unignored: false}`: the `pathname` is ignored
+- `{ignored: false, unignored: true}`: the `pathname` is unignored
+- `{ignored: false, unignored: false}`: the `pathname` is never matched by any ignore rules.
+
+## `options.ignorecase` since 4.0.0
+
+Similar as the `core.ignorecase` option of [git-config](https://git-scm.com/docs/git-config), `node-ignore` will be case insensitive if `options.ignorecase` is set to `true` (the default value), otherwise case sensitive.
+
+```js
+const ig = ignore({
+ ignorecase: false
+})
+
+ig.add('*.png')
+
+ig.ignores('*.PNG') // false
+```
+
+## static `ignore.isPathValid(pathname): boolean` since 5.0.0
+
+Check whether the `pathname` is an valid `path.relative()`d path according to the [convention](#1-pathname-should-be-a-pathrelatived-pathname).
+
+This method is **NOT** used to check if an ignore pattern is valid.
+
+```js
+ignore.isPathValid('./foo') // false
+```
+
+****
+
+# Upgrade Guide
+
+## Upgrade 4.x -> 5.x
+
+Since `5.0.0`, if an invalid `Pathname` passed into `ig.ignores()`, an error will be thrown, while `ignore < 5.0.0` did not make sure what the return value was, as well as
+
+```ts
+.ignores(pathname: Pathname): boolean
+
+.filter(pathnames: Array<Pathname>): Array<Pathname>
+
+.createFilter(): (pathname: Pathname) => boolean
+
+.test(pathname: Pathname): {ignored: boolean, unignored: boolean}
+```
+
+See the convention [here](#1-pathname-should-be-a-pathrelatived-pathname) for details.
+
+If there are invalid pathnames, the conversion and filtration should be done by users.
+
+```js
+import {isPathValid} from 'ignore' // introduced in 5.0.0
+
+const paths = [
+ // invalid
+ //////////////////
+ '',
+ false,
+ '../foo',
+ '.',
+ //////////////////
+
+ // valid
+ 'foo'
+]
+.filter(isValidPath)
+
+ig.filter(paths)
+```
+
+## Upgrade 3.x -> 4.x
+
+Since `4.0.0`, `ignore` will no longer support node < 6, to use `ignore` in node < 6:
+
+```js
+var ignore = require('ignore/legacy')
+```
+
+## Upgrade 2.x -> 3.x
+
+- All `options` of 2.x are unnecessary and removed, so just remove them.
+- `ignore()` instance is no longer an [`EventEmitter`](nodejs.org/api/events.html), and all events are unnecessary and removed.
+- `.addIgnoreFile()` is removed, see the [.addIgnoreFile](#addignorefilepath) section for details.
+
+****
+
+# Collaborators
+
+- [@whitecolor](https://github.com/whitecolor) *Alex*
+- [@SamyPesse](https://github.com/SamyPesse) *Samy Pessé*
+- [@azproduction](https://github.com/azproduction) *Mikhail Davydov*
+- [@TrySound](https://github.com/TrySound) *Bogdan Chadkin*
+- [@JanMattner](https://github.com/JanMattner) *Jan Mattner*
+- [@ntwb](https://github.com/ntwb) *Stephen Edgar*
+- [@kasperisager](https://github.com/kasperisager) *Kasper Isager*
+- [@sandersn](https://github.com/sandersn) *Nathan Shively-Sanders*
diff --git a/node_modules/imagemin/node_modules/ignore/index.d.ts b/node_modules/imagemin/node_modules/ignore/index.d.ts
new file mode 100644
index 0000000..66657af
--- /dev/null
+++ b/node_modules/imagemin/node_modules/ignore/index.d.ts
@@ -0,0 +1,63 @@
+type Pathname = string
+
+interface TestResult {
+ ignored: boolean
+ unignored: boolean
+}
+
+export interface Ignore {
+ /**
+ * Adds a rule rules to the current manager.
+ * @param {string | Ignore} pattern
+ * @returns IgnoreBase
+ */
+ add(pattern: string | Ignore): this
+ /**
+ * Adds several rules to the current manager.
+ * @param {string[]} patterns
+ * @returns IgnoreBase
+ */
+ add(patterns: (string | Ignore)[]): this
+
+ /**
+ * Filters the given array of pathnames, and returns the filtered array.
+ * NOTICE that each path here should be a relative path to the root of your repository.
+ * @param paths the array of paths to be filtered.
+ * @returns The filtered array of paths
+ */
+ filter(pathnames: Pathname[]): Pathname[]
+ /**
+ * Creates a filter function which could filter
+ * an array of paths with Array.prototype.filter.
+ */
+ createFilter(): (pathname: Pathname) => boolean
+
+ /**
+ * Returns Boolean whether pathname should be ignored.
+ * @param {string} pathname a path to check
+ * @returns boolean
+ */
+ ignores(pathname: Pathname): boolean
+
+ /**
+ * Returns whether pathname should be ignored or unignored
+ * @param {string} pathname a path to check
+ * @returns TestResult
+ */
+ test(pathname: Pathname): TestResult
+}
+
+interface Options {
+ ignorecase?: boolean
+}
+
+/**
+ * Creates new ignore manager.
+ */
+declare function ignore(options?: Options): Ignore
+
+declare namespace ignore {
+ export function isPathValid (pathname: string): boolean
+}
+
+export default ignore
diff --git a/node_modules/imagemin/node_modules/ignore/index.js b/node_modules/imagemin/node_modules/ignore/index.js
new file mode 100644
index 0000000..9dcee20
--- /dev/null
+++ b/node_modules/imagemin/node_modules/ignore/index.js
@@ -0,0 +1,597 @@
+// A simple implementation of make-array
+function makeArray (subject) {
+ return Array.isArray(subject)
+ ? subject
+ : [subject]
+}
+
+const EMPTY = ''
+const SPACE = ' '
+const ESCAPE = '\\'
+const REGEX_TEST_BLANK_LINE = /^\s+$/
+const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/
+const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/
+const REGEX_SPLITALL_CRLF = /\r?\n/g
+// /foo,
+// ./foo,
+// ../foo,
+// .
+// ..
+const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/
+
+const SLASH = '/'
+const KEY_IGNORE = typeof Symbol !== 'undefined'
+ ? Symbol.for('node-ignore')
+ /* istanbul ignore next */
+ : 'node-ignore'
+
+const define = (object, key, value) =>
+ Object.defineProperty(object, key, {value})
+
+const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g
+
+// Sanitize the range of a regular expression
+// The cases are complicated, see test cases for details
+const sanitizeRange = range => range.replace(
+ REGEX_REGEXP_RANGE,
+ (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)
+ ? match
+ // Invalid range (out of order) which is ok for gitignore rules but
+ // fatal for JavaScript regular expression, so eliminate it.
+ : EMPTY
+)
+
+// See fixtures #59
+const cleanRangeBackSlash = slashes => {
+ const {length} = slashes
+ return slashes.slice(0, length - length % 2)
+}
+
+// > If the pattern ends with a slash,
+// > it is removed for the purpose of the following description,
+// > but it would only find a match with a directory.
+// > In other words, foo/ will match a directory foo and paths underneath it,
+// > but will not match a regular file or a symbolic link foo
+// > (this is consistent with the way how pathspec works in general in Git).
+// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
+// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
+// you could use option `mark: true` with `glob`
+
+// '`foo/`' should not continue with the '`..`'
+const REPLACERS = [
+
+ // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+ [
+ // (a\ ) -> (a )
+ // (a ) -> (a)
+ // (a \ ) -> (a )
+ /\\?\s+$/,
+ match => match.indexOf('\\') === 0
+ ? SPACE
+ : EMPTY
+ ],
+
+ // replace (\ ) with ' '
+ [
+ /\\\s/g,
+ () => SPACE
+ ],
+
+ // Escape metacharacters
+ // which is written down by users but means special for regular expressions.
+
+ // > There are 12 characters with special meanings:
+ // > - the backslash \,
+ // > - the caret ^,
+ // > - the dollar sign $,
+ // > - the period or dot .,
+ // > - the vertical bar or pipe symbol |,
+ // > - the question mark ?,
+ // > - the asterisk or star *,
+ // > - the plus sign +,
+ // > - the opening parenthesis (,
+ // > - the closing parenthesis ),
+ // > - and the opening square bracket [,
+ // > - the opening curly brace {,
+ // > These special characters are often called "metacharacters".
+ [
+ /[\\$.|*+(){^]/g,
+ match => `\\${match}`
+ ],
+
+ [
+ // > a question mark (?) matches a single character
+ /(?!\\)\?/g,
+ () => '[^/]'
+ ],
+
+ // leading slash
+ [
+
+ // > A leading slash matches the beginning of the pathname.
+ // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+ // A leading slash matches the beginning of the pathname
+ /^\//,
+ () => '^'
+ ],
+
+ // replace special metacharacter slash after the leading slash
+ [
+ /\//g,
+ () => '\\/'
+ ],
+
+ [
+ // > A leading "**" followed by a slash means match in all directories.
+ // > For example, "**/foo" matches file or directory "foo" anywhere,
+ // > the same as pattern "foo".
+ // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+ // > under directory "foo".
+ // Notice that the '*'s have been replaced as '\\*'
+ /^\^*\\\*\\\*\\\//,
+
+ // '**/foo' <-> 'foo'
+ () => '^(?:.*\\/)?'
+ ],
+
+ // starting
+ [
+ // there will be no leading '/'
+ // (which has been replaced by section "leading slash")
+ // If starts with '**', adding a '^' to the regular expression also works
+ /^(?=[^^])/,
+ function startingReplacer () {
+ // If has a slash `/` at the beginning or middle
+ return !/\/(?!$)/.test(this)
+ // > Prior to 2.22.1
+ // > If the pattern does not contain a slash /,
+ // > Git treats it as a shell glob pattern
+ // Actually, if there is only a trailing slash,
+ // git also treats it as a shell glob pattern
+
+ // After 2.22.1 (compatible but clearer)
+ // > If there is a separator at the beginning or middle (or both)
+ // > of the pattern, then the pattern is relative to the directory
+ // > level of the particular .gitignore file itself.
+ // > Otherwise the pattern may also match at any level below
+ // > the .gitignore level.
+ ? '(?:^|\\/)'
+
+ // > Otherwise, Git treats the pattern as a shell glob suitable for
+ // > consumption by fnmatch(3)
+ : '^'
+ }
+ ],
+
+ // two globstars
+ [
+ // Use lookahead assertions so that we could match more than one `'/**'`
+ /\\\/\\\*\\\*(?=\\\/|$)/g,
+
+ // Zero, one or several directories
+ // should not use '*', or it will be replaced by the next replacer
+
+ // Check if it is not the last `'/**'`
+ (_, index, str) => index + 6 < str.length
+
+ // case: /**/
+ // > A slash followed by two consecutive asterisks then a slash matches
+ // > zero or more directories.
+ // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
+ // '/**/'
+ ? '(?:\\/[^\\/]+)*'
+
+ // case: /**
+ // > A trailing `"/**"` matches everything inside.
+
+ // #21: everything inside but it should not include the current folder
+ : '\\/.+'
+ ],
+
+ // intermediate wildcards
+ [
+ // Never replace escaped '*'
+ // ignore rule '\*' will match the path '*'
+
+ // 'abc.*/' -> go
+ // 'abc.*' -> skip this rule
+ /(^|[^\\]+)\\\*(?=.+)/g,
+
+ // '*.js' matches '.js'
+ // '*.js' doesn't match 'abc'
+ (_, p1) => `${p1}[^\\/]*`
+ ],
+
+ [
+ // unescape, revert step 3 except for back slash
+ // For example, if a user escape a '\\*',
+ // after step 3, the result will be '\\\\\\*'
+ /\\\\\\(?=[$.|*+(){^])/g,
+ () => ESCAPE
+ ],
+
+ [
+ // '\\\\' -> '\\'
+ /\\\\/g,
+ () => ESCAPE
+ ],
+
+ [
+ // > The range notation, e.g. [a-zA-Z],
+ // > can be used to match one of the characters in a range.
+
+ // `\` is escaped by step 3
+ /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+ (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE
+ // '\\[bar]' -> '\\\\[bar\\]'
+ ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`
+ : close === ']'
+ ? endEscape.length % 2 === 0
+ // A normal case, and it is a range notation
+ // '[bar]'
+ // '[bar\\\\]'
+ ? `[${sanitizeRange(range)}${endEscape}]`
+ // Invalid range notaton
+ // '[bar\\]' -> '[bar\\\\]'
+ : '[]'
+ : '[]'
+ ],
+
+ // ending
+ [
+ // 'js' will not match 'js.'
+ // 'ab' will not match 'abc'
+ /(?:[^*])$/,
+
+ // WTF!
+ // https://git-scm.com/docs/gitignore
+ // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+ // which re-fixes #24, #38
+
+ // > If there is a separator at the end of the pattern then the pattern
+ // > will only match directories, otherwise the pattern can match both
+ // > files and directories.
+
+ // 'js*' will not match 'a.js'
+ // 'js/' will not match 'a.js'
+ // 'js' will match 'a.js' and 'a.js/'
+ match => /\/$/.test(match)
+ // foo/ will not match 'foo'
+ ? `${match}$`
+ // foo matches 'foo' and 'foo/'
+ : `${match}(?=$|\\/$)`
+ ],
+
+ // trailing wildcard
+ [
+ /(\^|\\\/)?\\\*$/,
+ (_, p1) => {
+ const prefix = p1
+ // '\^':
+ // '/*' does not match EMPTY
+ // '/*' does not match everything
+
+ // '\\\/':
+ // 'abc/*' does not match 'abc/'
+ ? `${p1}[^/]+`
+
+ // 'a*' matches 'a'
+ // 'a*' matches 'aa'
+ : '[^/]*'
+
+ return `${prefix}(?=$|\\/$)`
+ }
+ ],
+]
+
+// A simple cache, because an ignore rule only has only one certain meaning
+const regexCache = Object.create(null)
+
+// @param {pattern}
+const makeRegex = (pattern, negative, ignorecase) => {
+ const r = regexCache[pattern]
+ if (r) {
+ return r
+ }
+
+ // const replacers = negative
+ // ? NEGATIVE_REPLACERS
+ // : POSITIVE_REPLACERS
+
+ const source = REPLACERS.reduce(
+ (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+ pattern
+ )
+
+ return regexCache[pattern] = ignorecase
+ ? new RegExp(source, 'i')
+ : new RegExp(source)
+}
+
+const isString = subject => typeof subject === 'string'
+
+// > A blank line matches no files, so it can serve as a separator for readability.
+const checkPattern = pattern => pattern
+ && isString(pattern)
+ && !REGEX_TEST_BLANK_LINE.test(pattern)
+
+ // > A line starting with # serves as a comment.
+ && pattern.indexOf('#') !== 0
+
+const splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF)
+
+class IgnoreRule {
+ constructor (
+ origin,
+ pattern,
+ negative,
+ regex
+ ) {
+ this.origin = origin
+ this.pattern = pattern
+ this.negative = negative
+ this.regex = regex
+ }
+}
+
+const createRule = (pattern, ignorecase) => {
+ const origin = pattern
+ let negative = false
+
+ // > An optional prefix "!" which negates the pattern;
+ if (pattern.indexOf('!') === 0) {
+ negative = true
+ pattern = pattern.substr(1)
+ }
+
+ pattern = pattern
+ // > Put a backslash ("\") in front of the first "!" for patterns that
+ // > begin with a literal "!", for example, `"\!important!.txt"`.
+ .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')
+ // > Put a backslash ("\") in front of the first hash for patterns that
+ // > begin with a hash.
+ .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#')
+
+ const regex = makeRegex(pattern, negative, ignorecase)
+
+ return new IgnoreRule(
+ origin,
+ pattern,
+ negative,
+ regex
+ )
+}
+
+const throwError = (message, Ctor) => {
+ throw new Ctor(message)
+}
+
+const checkPath = (path, originalPath, doThrow) => {
+ if (!isString(path)) {
+ return doThrow(
+ `path must be a string, but got \`${originalPath}\``,
+ TypeError
+ )
+ }
+
+ // We don't know if we should ignore EMPTY, so throw
+ if (!path) {
+ return doThrow(`path must not be empty`, TypeError)
+ }
+
+ // Check if it is a relative path
+ if (checkPath.isNotRelative(path)) {
+ const r = '`path.relative()`d'
+ return doThrow(
+ `path should be a ${r} string, but got "${originalPath}"`,
+ RangeError
+ )
+ }
+
+ return true
+}
+
+const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path)
+
+checkPath.isNotRelative = isNotRelative
+checkPath.convert = p => p
+
+class Ignore {
+ constructor ({
+ ignorecase = true
+ } = {}) {
+ this._rules = []
+ this._ignorecase = ignorecase
+ define(this, KEY_IGNORE, true)
+ this._initCache()
+ }
+
+ _initCache () {
+ this._ignoreCache = Object.create(null)
+ this._testCache = Object.create(null)
+ }
+
+ _addPattern (pattern) {
+ // #32
+ if (pattern && pattern[KEY_IGNORE]) {
+ this._rules = this._rules.concat(pattern._rules)
+ this._added = true
+ return
+ }
+
+ if (checkPattern(pattern)) {
+ const rule = createRule(pattern, this._ignorecase)
+ this._added = true
+ this._rules.push(rule)
+ }
+ }
+
+ // @param {Array<string> | string | Ignore} pattern
+ add (pattern) {
+ this._added = false
+
+ makeArray(
+ isString(pattern)
+ ? splitPattern(pattern)
+ : pattern
+ ).forEach(this._addPattern, this)
+
+ // Some rules have just added to the ignore,
+ // making the behavior changed.
+ if (this._added) {
+ this._initCache()
+ }
+
+ return this
+ }
+
+ // legacy
+ addPattern (pattern) {
+ return this.add(pattern)
+ }
+
+ // | ignored : unignored
+ // negative | 0:0 | 0:1 | 1:0 | 1:1
+ // -------- | ------- | ------- | ------- | --------
+ // 0 | TEST | TEST | SKIP | X
+ // 1 | TESTIF | SKIP | TEST | X
+
+ // - SKIP: always skip
+ // - TEST: always test
+ // - TESTIF: only test if checkUnignored
+ // - X: that never happen
+
+ // @param {boolean} whether should check if the path is unignored,
+ // setting `checkUnignored` to `false` could reduce additional
+ // path matching.
+
+ // @returns {TestResult} true if a file is ignored
+ _testOne (path, checkUnignored) {
+ let ignored = false
+ let unignored = false
+
+ this._rules.forEach(rule => {
+ const {negative} = rule
+ if (
+ unignored === negative && ignored !== unignored
+ || negative && !ignored && !unignored && !checkUnignored
+ ) {
+ return
+ }
+
+ const matched = rule.regex.test(path)
+
+ if (matched) {
+ ignored = !negative
+ unignored = negative
+ }
+ })
+
+ return {
+ ignored,
+ unignored
+ }
+ }
+
+ // @returns {TestResult}
+ _test (originalPath, cache, checkUnignored, slices) {
+ const path = originalPath
+ // Supports nullable path
+ && checkPath.convert(originalPath)
+
+ checkPath(path, originalPath, throwError)
+
+ return this._t(path, cache, checkUnignored, slices)
+ }
+
+ _t (path, cache, checkUnignored, slices) {
+ if (path in cache) {
+ return cache[path]
+ }
+
+ if (!slices) {
+ // path/to/a.js
+ // ['path', 'to', 'a.js']
+ slices = path.split(SLASH)
+ }
+
+ slices.pop()
+
+ // If the path has no parent directory, just test it
+ if (!slices.length) {
+ return cache[path] = this._testOne(path, checkUnignored)
+ }
+
+ const parent = this._t(
+ slices.join(SLASH) + SLASH,
+ cache,
+ checkUnignored,
+ slices
+ )
+
+ // If the path contains a parent directory, check the parent first
+ return cache[path] = parent.ignored
+ // > It is not possible to re-include a file if a parent directory of
+ // > that file is excluded.
+ ? parent
+ : this._testOne(path, checkUnignored)
+ }
+
+ ignores (path) {
+ return this._test(path, this._ignoreCache, false).ignored
+ }
+
+ createFilter () {
+ return path => !this.ignores(path)
+ }
+
+ filter (paths) {
+ return makeArray(paths).filter(this.createFilter())
+ }
+
+ // @returns {TestResult}
+ test (path) {
+ return this._test(path, this._testCache, true)
+ }
+}
+
+const factory = options => new Ignore(options)
+
+const returnFalse = () => false
+
+const isPathValid = path =>
+ checkPath(path && checkPath.convert(path), path, returnFalse)
+
+factory.isPathValid = isPathValid
+
+// Fixes typescript
+factory.default = factory
+
+module.exports = factory
+
+// Windows
+// --------------------------------------------------------------
+/* istanbul ignore if */
+if (
+ // Detect `process` so that it can run in browsers.
+ typeof process !== 'undefined'
+ && (
+ process.env && process.env.IGNORE_TEST_WIN32
+ || process.platform === 'win32'
+ )
+) {
+ /* eslint no-control-regex: "off" */
+ const makePosix = str => /^\\\\\?\\/.test(str)
+ || /["<>|\u0000-\u001F]+/u.test(str)
+ ? str
+ : str.replace(/\\/g, '/')
+
+ checkPath.convert = makePosix
+
+ // 'C:\\foo' <- 'C:\\foo' has been converted to 'C:/'
+ // 'd:\\foo'
+ const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i
+ checkPath.isNotRelative = path =>
+ REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)
+ || isNotRelative(path)
+}
diff --git a/node_modules/imagemin/node_modules/ignore/legacy.js b/node_modules/imagemin/node_modules/ignore/legacy.js
new file mode 100644
index 0000000..176bf62
--- /dev/null
+++ b/node_modules/imagemin/node_modules/ignore/legacy.js
@@ -0,0 +1,495 @@
+"use strict";
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+// A simple implementation of make-array
+function makeArray(subject) {
+ return Array.isArray(subject) ? subject : [subject];
+}
+
+var EMPTY = '';
+var SPACE = ' ';
+var ESCAPE = '\\';
+var REGEX_TEST_BLANK_LINE = /^\s+$/;
+var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+var REGEX_SPLITALL_CRLF = /\r?\n/g; // /foo,
+// ./foo,
+// ../foo,
+// .
+// ..
+
+var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+var SLASH = '/';
+var KEY_IGNORE = typeof Symbol !== 'undefined' ? Symbol["for"]('node-ignore')
+/* istanbul ignore next */
+: 'node-ignore';
+
+var define = function define(object, key, value) {
+ return Object.defineProperty(object, key, {
+ value: value
+ });
+};
+
+var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g; // Sanitize the range of a regular expression
+// The cases are complicated, see test cases for details
+
+var sanitizeRange = function sanitizeRange(range) {
+ return range.replace(REGEX_REGEXP_RANGE, function (match, from, to) {
+ return from.charCodeAt(0) <= to.charCodeAt(0) ? match // Invalid range (out of order) which is ok for gitignore rules but
+ // fatal for JavaScript regular expression, so eliminate it.
+ : EMPTY;
+ });
+}; // See fixtures #59
+
+
+var cleanRangeBackSlash = function cleanRangeBackSlash(slashes) {
+ var length = slashes.length;
+ return slashes.slice(0, length - length % 2);
+}; // > If the pattern ends with a slash,
+// > it is removed for the purpose of the following description,
+// > but it would only find a match with a directory.
+// > In other words, foo/ will match a directory foo and paths underneath it,
+// > but will not match a regular file or a symbolic link foo
+// > (this is consistent with the way how pathspec works in general in Git).
+// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
+// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
+// you could use option `mark: true` with `glob`
+// '`foo/`' should not continue with the '`..`'
+
+
+var REPLACERS = [// > Trailing spaces are ignored unless they are quoted with backslash ("\")
+[// (a\ ) -> (a )
+// (a ) -> (a)
+// (a \ ) -> (a )
+/\\?\s+$/, function (match) {
+ return match.indexOf('\\') === 0 ? SPACE : EMPTY;
+}], // replace (\ ) with ' '
+[/\\\s/g, function () {
+ return SPACE;
+}], // Escape metacharacters
+// which is written down by users but means special for regular expressions.
+// > There are 12 characters with special meanings:
+// > - the backslash \,
+// > - the caret ^,
+// > - the dollar sign $,
+// > - the period or dot .,
+// > - the vertical bar or pipe symbol |,
+// > - the question mark ?,
+// > - the asterisk or star *,
+// > - the plus sign +,
+// > - the opening parenthesis (,
+// > - the closing parenthesis ),
+// > - and the opening square bracket [,
+// > - the opening curly brace {,
+// > These special characters are often called "metacharacters".
+[/[\\$.|*+(){^]/g, function (match) {
+ return "\\".concat(match);
+}], [// > a question mark (?) matches a single character
+/(?!\\)\?/g, function () {
+ return '[^/]';
+}], // leading slash
+[// > A leading slash matches the beginning of the pathname.
+// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+// A leading slash matches the beginning of the pathname
+/^\//, function () {
+ return '^';
+}], // replace special metacharacter slash after the leading slash
+[/\//g, function () {
+ return '\\/';
+}], [// > A leading "**" followed by a slash means match in all directories.
+// > For example, "**/foo" matches file or directory "foo" anywhere,
+// > the same as pattern "foo".
+// > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+// > under directory "foo".
+// Notice that the '*'s have been replaced as '\\*'
+/^\^*\\\*\\\*\\\//, // '**/foo' <-> 'foo'
+function () {
+ return '^(?:.*\\/)?';
+}], // starting
+[// there will be no leading '/'
+// (which has been replaced by section "leading slash")
+// If starts with '**', adding a '^' to the regular expression also works
+/^(?=[^^])/, function startingReplacer() {
+ // If has a slash `/` at the beginning or middle
+ return !/\/(?!$)/.test(this) // > Prior to 2.22.1
+ // > If the pattern does not contain a slash /,
+ // > Git treats it as a shell glob pattern
+ // Actually, if there is only a trailing slash,
+ // git also treats it as a shell glob pattern
+ // After 2.22.1 (compatible but clearer)
+ // > If there is a separator at the beginning or middle (or both)
+ // > of the pattern, then the pattern is relative to the directory
+ // > level of the particular .gitignore file itself.
+ // > Otherwise the pattern may also match at any level below
+ // > the .gitignore level.
+ ? '(?:^|\\/)' // > Otherwise, Git treats the pattern as a shell glob suitable for
+ // > consumption by fnmatch(3)
+ : '^';
+}], // two globstars
+[// Use lookahead assertions so that we could match more than one `'/**'`
+/\\\/\\\*\\\*(?=\\\/|$)/g, // Zero, one or several directories
+// should not use '*', or it will be replaced by the next replacer
+// Check if it is not the last `'/**'`
+function (_, index, str) {
+ return index + 6 < str.length // case: /**/
+ // > A slash followed by two consecutive asterisks then a slash matches
+ // > zero or more directories.
+ // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
+ // '/**/'
+ ? '(?:\\/[^\\/]+)*' // case: /**
+ // > A trailing `"/**"` matches everything inside.
+ // #21: everything inside but it should not include the current folder
+ : '\\/.+';
+}], // intermediate wildcards
+[// Never replace escaped '*'
+// ignore rule '\*' will match the path '*'
+// 'abc.*/' -> go
+// 'abc.*' -> skip this rule
+/(^|[^\\]+)\\\*(?=.+)/g, // '*.js' matches '.js'
+// '*.js' doesn't match 'abc'
+function (_, p1) {
+ return "".concat(p1, "[^\\/]*");
+}], [// unescape, revert step 3 except for back slash
+// For example, if a user escape a '\\*',
+// after step 3, the result will be '\\\\\\*'
+/\\\\\\(?=[$.|*+(){^])/g, function () {
+ return ESCAPE;
+}], [// '\\\\' -> '\\'
+/\\\\/g, function () {
+ return ESCAPE;
+}], [// > The range notation, e.g. [a-zA-Z],
+// > can be used to match one of the characters in a range.
+// `\` is escaped by step 3
+/(\\)?\[([^\]/]*?)(\\*)($|\])/g, function (match, leadEscape, range, endEscape, close) {
+ return leadEscape === ESCAPE // '\\[bar]' -> '\\\\[bar\\]'
+ ? "\\[".concat(range).concat(cleanRangeBackSlash(endEscape)).concat(close) : close === ']' ? endEscape.length % 2 === 0 // A normal case, and it is a range notation
+ // '[bar]'
+ // '[bar\\\\]'
+ ? "[".concat(sanitizeRange(range)).concat(endEscape, "]") // Invalid range notaton
+ // '[bar\\]' -> '[bar\\\\]'
+ : '[]' : '[]';
+}], // ending
+[// 'js' will not match 'js.'
+// 'ab' will not match 'abc'
+/(?:[^*])$/, // WTF!
+// https://git-scm.com/docs/gitignore
+// changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+// which re-fixes #24, #38
+// > If there is a separator at the end of the pattern then the pattern
+// > will only match directories, otherwise the pattern can match both
+// > files and directories.
+// 'js*' will not match 'a.js'
+// 'js/' will not match 'a.js'
+// 'js' will match 'a.js' and 'a.js/'
+function (match) {
+ return /\/$/.test(match) // foo/ will not match 'foo'
+ ? "".concat(match, "$") // foo matches 'foo' and 'foo/'
+ : "".concat(match, "(?=$|\\/$)");
+}], // trailing wildcard
+[/(\^|\\\/)?\\\*$/, function (_, p1) {
+ var prefix = p1 // '\^':
+ // '/*' does not match EMPTY
+ // '/*' does not match everything
+ // '\\\/':
+ // 'abc/*' does not match 'abc/'
+ ? "".concat(p1, "[^/]+") // 'a*' matches 'a'
+ // 'a*' matches 'aa'
+ : '[^/]*';
+ return "".concat(prefix, "(?=$|\\/$)");
+}]]; // A simple cache, because an ignore rule only has only one certain meaning
+
+var regexCache = Object.create(null); // @param {pattern}
+
+var makeRegex = function makeRegex(pattern, negative, ignorecase) {
+ var r = regexCache[pattern];
+
+ if (r) {
+ return r;
+ } // const replacers = negative
+ // ? NEGATIVE_REPLACERS
+ // : POSITIVE_REPLACERS
+
+
+ var source = REPLACERS.reduce(function (prev, current) {
+ return prev.replace(current[0], current[1].bind(pattern));
+ }, pattern);
+ return regexCache[pattern] = ignorecase ? new RegExp(source, 'i') : new RegExp(source);
+};
+
+var isString = function isString(subject) {
+ return typeof subject === 'string';
+}; // > A blank line matches no files, so it can serve as a separator for readability.
+
+
+var checkPattern = function checkPattern(pattern) {
+ return pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) // > A line starting with # serves as a comment.
+ && pattern.indexOf('#') !== 0;
+};
+
+var splitPattern = function splitPattern(pattern) {
+ return pattern.split(REGEX_SPLITALL_CRLF);
+};
+
+var IgnoreRule = function IgnoreRule(origin, pattern, negative, regex) {
+ _classCallCheck(this, IgnoreRule);
+
+ this.origin = origin;
+ this.pattern = pattern;
+ this.negative = negative;
+ this.regex = regex;
+};
+
+var createRule = function createRule(pattern, ignorecase) {
+ var origin = pattern;
+ var negative = false; // > An optional prefix "!" which negates the pattern;
+
+ if (pattern.indexOf('!') === 0) {
+ negative = true;
+ pattern = pattern.substr(1);
+ }
+
+ pattern = pattern // > Put a backslash ("\") in front of the first "!" for patterns that
+ // > begin with a literal "!", for example, `"\!important!.txt"`.
+ .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!') // > Put a backslash ("\") in front of the first hash for patterns that
+ // > begin with a hash.
+ .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#');
+ var regex = makeRegex(pattern, negative, ignorecase);
+ return new IgnoreRule(origin, pattern, negative, regex);
+};
+
+var throwError = function throwError(message, Ctor) {
+ throw new Ctor(message);
+};
+
+var checkPath = function checkPath(path, originalPath, doThrow) {
+ if (!isString(path)) {
+ return doThrow("path must be a string, but got `".concat(originalPath, "`"), TypeError);
+ } // We don't know if we should ignore EMPTY, so throw
+
+
+ if (!path) {
+ return doThrow("path must not be empty", TypeError);
+ } // Check if it is a relative path
+
+
+ if (checkPath.isNotRelative(path)) {
+ var r = '`path.relative()`d';
+ return doThrow("path should be a ".concat(r, " string, but got \"").concat(originalPath, "\""), RangeError);
+ }
+
+ return true;
+};
+
+var isNotRelative = function isNotRelative(path) {
+ return REGEX_TEST_INVALID_PATH.test(path);
+};
+
+checkPath.isNotRelative = isNotRelative;
+
+checkPath.convert = function (p) {
+ return p;
+};
+
+var Ignore = /*#__PURE__*/function () {
+ function Ignore() {
+ var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+ _ref$ignorecase = _ref.ignorecase,
+ ignorecase = _ref$ignorecase === void 0 ? true : _ref$ignorecase;
+
+ _classCallCheck(this, Ignore);
+
+ this._rules = [];
+ this._ignorecase = ignorecase;
+ define(this, KEY_IGNORE, true);
+
+ this._initCache();
+ }
+
+ _createClass(Ignore, [{
+ key: "_initCache",
+ value: function _initCache() {
+ this._ignoreCache = Object.create(null);
+ this._testCache = Object.create(null);
+ }
+ }, {
+ key: "_addPattern",
+ value: function _addPattern(pattern) {
+ // #32
+ if (pattern && pattern[KEY_IGNORE]) {
+ this._rules = this._rules.concat(pattern._rules);
+ this._added = true;
+ return;
+ }
+
+ if (checkPattern(pattern)) {
+ var rule = createRule(pattern, this._ignorecase);
+ this._added = true;
+
+ this._rules.push(rule);
+ }
+ } // @param {Array<string> | string | Ignore} pattern
+
+ }, {
+ key: "add",
+ value: function add(pattern) {
+ this._added = false;
+ makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._addPattern, this); // Some rules have just added to the ignore,
+ // making the behavior changed.
+
+ if (this._added) {
+ this._initCache();
+ }
+
+ return this;
+ } // legacy
+
+ }, {
+ key: "addPattern",
+ value: function addPattern(pattern) {
+ return this.add(pattern);
+ } // | ignored : unignored
+ // negative | 0:0 | 0:1 | 1:0 | 1:1
+ // -------- | ------- | ------- | ------- | --------
+ // 0 | TEST | TEST | SKIP | X
+ // 1 | TESTIF | SKIP | TEST | X
+ // - SKIP: always skip
+ // - TEST: always test
+ // - TESTIF: only test if checkUnignored
+ // - X: that never happen
+ // @param {boolean} whether should check if the path is unignored,
+ // setting `checkUnignored` to `false` could reduce additional
+ // path matching.
+ // @returns {TestResult} true if a file is ignored
+
+ }, {
+ key: "_testOne",
+ value: function _testOne(path, checkUnignored) {
+ var ignored = false;
+ var unignored = false;
+
+ this._rules.forEach(function (rule) {
+ var negative = rule.negative;
+
+ if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+ return;
+ }
+
+ var matched = rule.regex.test(path);
+
+ if (matched) {
+ ignored = !negative;
+ unignored = negative;
+ }
+ });
+
+ return {
+ ignored: ignored,
+ unignored: unignored
+ };
+ } // @returns {TestResult}
+
+ }, {
+ key: "_test",
+ value: function _test(originalPath, cache, checkUnignored, slices) {
+ var path = originalPath // Supports nullable path
+ && checkPath.convert(originalPath);
+ checkPath(path, originalPath, throwError);
+ return this._t(path, cache, checkUnignored, slices);
+ }
+ }, {
+ key: "_t",
+ value: function _t(path, cache, checkUnignored, slices) {
+ if (path in cache) {
+ return cache[path];
+ }
+
+ if (!slices) {
+ // path/to/a.js
+ // ['path', 'to', 'a.js']
+ slices = path.split(SLASH);
+ }
+
+ slices.pop(); // If the path has no parent directory, just test it
+
+ if (!slices.length) {
+ return cache[path] = this._testOne(path, checkUnignored);
+ }
+
+ var parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices); // If the path contains a parent directory, check the parent first
+
+
+ return cache[path] = parent.ignored // > It is not possible to re-include a file if a parent directory of
+ // > that file is excluded.
+ ? parent : this._testOne(path, checkUnignored);
+ }
+ }, {
+ key: "ignores",
+ value: function ignores(path) {
+ return this._test(path, this._ignoreCache, false).ignored;
+ }
+ }, {
+ key: "createFilter",
+ value: function createFilter() {
+ var _this = this;
+
+ return function (path) {
+ return !_this.ignores(path);
+ };
+ }
+ }, {
+ key: "filter",
+ value: function filter(paths) {
+ return makeArray(paths).filter(this.createFilter());
+ } // @returns {TestResult}
+
+ }, {
+ key: "test",
+ value: function test(path) {
+ return this._test(path, this._testCache, true);
+ }
+ }]);
+
+ return Ignore;
+}();
+
+var factory = function factory(options) {
+ return new Ignore(options);
+};
+
+var returnFalse = function returnFalse() {
+ return false;
+};
+
+var isPathValid = function isPathValid(path) {
+ return checkPath(path && checkPath.convert(path), path, returnFalse);
+};
+
+factory.isPathValid = isPathValid; // Fixes typescript
+
+factory["default"] = factory;
+module.exports = factory; // Windows
+// --------------------------------------------------------------
+
+/* istanbul ignore if */
+
+if ( // Detect `process` so that it can run in browsers.
+typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === 'win32')) {
+ /* eslint no-control-regex: "off" */
+ var makePosix = function makePosix(str) {
+ return /^\\\\\?\\/.test(str) || /[\0-\x1F"<>\|]+/.test(str) ? str : str.replace(/\\/g, '/');
+ };
+
+ checkPath.convert = makePosix; // 'C:\\foo' <- 'C:\\foo' has been converted to 'C:/'
+ // 'd:\\foo'
+
+ var REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+
+ checkPath.isNotRelative = function (path) {
+ return REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+ };
+}
diff --git a/node_modules/imagemin/node_modules/ignore/package.json b/node_modules/imagemin/node_modules/ignore/package.json
new file mode 100644
index 0000000..127fcdc
--- /dev/null
+++ b/node_modules/imagemin/node_modules/ignore/package.json
@@ -0,0 +1,98 @@
+{
+ "_from": "ignore@^5.1.1",
+ "_id": "ignore@5.1.8",
+ "_inBundle": false,
+ "_integrity": "sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==",
+ "_location": "/imagemin/ignore",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "ignore@^5.1.1",
+ "name": "ignore",
+ "escapedName": "ignore",
+ "rawSpec": "^5.1.1",
+ "saveSpec": null,
+ "fetchSpec": "^5.1.1"
+ },
+ "_requiredBy": [
+ "/imagemin/globby"
+ ],
+ "_resolved": "https://registry.npmjs.org/ignore/-/ignore-5.1.8.tgz",
+ "_shasum": "f150a8b50a34289b33e22f5889abd4d8016f0e57",
+ "_spec": "ignore@^5.1.1",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\globby",
+ "author": {
+ "name": "kael"
+ },
+ "bugs": {
+ "url": "https://github.com/kaelzhang/node-ignore/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Ignore is a manager and filter for .gitignore rules, the one used by eslint, gitbook and many others.",
+ "devDependencies": {
+ "@babel/cli": "^7.8.4",
+ "@babel/core": "^7.9.6",
+ "@babel/preset-env": "^7.9.6",
+ "codecov": "^3.7.0",
+ "debug": "^4.1.1",
+ "eslint": "^7.0.0",
+ "eslint-config-ostai": "^3.0.0",
+ "eslint-plugin-import": "^2.20.2",
+ "mkdirp": "^1.0.4",
+ "pre-suf": "^1.1.1",
+ "rimraf": "^3.0.2",
+ "spawn-sync": "^2.0.0",
+ "tap": "^14.10.7",
+ "tmp": "0.2.1",
+ "typescript": "^3.9.3"
+ },
+ "engines": {
+ "node": ">= 4"
+ },
+ "files": [
+ "legacy.js",
+ "index.js",
+ "index.d.ts",
+ "LICENSE-MIT"
+ ],
+ "homepage": "https://github.com/kaelzhang/node-ignore#readme",
+ "keywords": [
+ "ignore",
+ ".gitignore",
+ "gitignore",
+ "npmignore",
+ "rules",
+ "manager",
+ "filter",
+ "regexp",
+ "regex",
+ "fnmatch",
+ "glob",
+ "asterisks",
+ "regular-expression"
+ ],
+ "license": "MIT",
+ "name": "ignore",
+ "repository": {
+ "type": "git",
+ "url": "git+ssh://git@github.com/kaelzhang/node-ignore.git"
+ },
+ "scripts": {
+ "build": "babel -o legacy.js index.js",
+ "posttest": "tap --coverage-report=html && codecov",
+ "prepublishOnly": "npm run build",
+ "test": "npm run test:only",
+ "test:cases": "tap test/*.js --coverage",
+ "test:git": "tap test/git-check-ignore.js",
+ "test:ignore": "tap test/ignore.js",
+ "test:lint": "eslint .",
+ "test:only": "npm run test:lint && npm run test:tsc && npm run test:ts && npm run test:cases",
+ "test:others": "tap test/others.js",
+ "test:ts": "node ./test/ts/simple.js",
+ "test:tsc": "tsc ./test/ts/simple.ts --lib ES6",
+ "test:win32": "IGNORE_TEST_WIN32=1 npm run test"
+ },
+ "version": "5.1.8"
+}
diff --git a/node_modules/imagemin/node_modules/is-glob/LICENSE b/node_modules/imagemin/node_modules/is-glob/LICENSE
new file mode 100644
index 0000000..3f2eca1
--- /dev/null
+++ b/node_modules/imagemin/node_modules/is-glob/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2017, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/is-glob/README.md b/node_modules/imagemin/node_modules/is-glob/README.md
new file mode 100644
index 0000000..59444eb
--- /dev/null
+++ b/node_modules/imagemin/node_modules/is-glob/README.md
@@ -0,0 +1,206 @@
+# is-glob [](https://www.npmjs.com/package/is-glob) [](https://npmjs.org/package/is-glob) [](https://npmjs.org/package/is-glob) [](https://travis-ci.org/micromatch/is-glob) [](https://ci.appveyor.com/project/micromatch/is-glob)
+
+> Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a better user experience.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save is-glob
+```
+
+You might also be interested in [is-valid-glob](https://github.com/jonschlinkert/is-valid-glob) and [has-glob](https://github.com/jonschlinkert/has-glob).
+
+## Usage
+
+```js
+var isGlob = require('is-glob');
+```
+
+### Default behavior
+
+**True**
+
+Patterns that have glob characters or regex patterns will return `true`:
+
+```js
+isGlob('!foo.js');
+isGlob('*.js');
+isGlob('**/abc.js');
+isGlob('abc/*.js');
+isGlob('abc/(aaa|bbb).js');
+isGlob('abc/[a-z].js');
+isGlob('abc/{a,b}.js');
+//=> true
+```
+
+Extglobs
+
+```js
+isGlob('abc/@(a).js');
+isGlob('abc/!(a).js');
+isGlob('abc/+(a).js');
+isGlob('abc/*(a).js');
+isGlob('abc/?(a).js');
+//=> true
+```
+
+**False**
+
+Escaped globs or extglobs return `false`:
+
+```js
+isGlob('abc/\\@(a).js');
+isGlob('abc/\\!(a).js');
+isGlob('abc/\\+(a).js');
+isGlob('abc/\\*(a).js');
+isGlob('abc/\\?(a).js');
+isGlob('\\!foo.js');
+isGlob('\\*.js');
+isGlob('\\*\\*/abc.js');
+isGlob('abc/\\*.js');
+isGlob('abc/\\(aaa|bbb).js');
+isGlob('abc/\\[a-z].js');
+isGlob('abc/\\{a,b}.js');
+//=> false
+```
+
+Patterns that do not have glob patterns return `false`:
+
+```js
+isGlob('abc.js');
+isGlob('abc/def/ghi.js');
+isGlob('foo.js');
+isGlob('abc/@.js');
+isGlob('abc/+.js');
+isGlob('abc/?.js');
+isGlob();
+isGlob(null);
+//=> false
+```
+
+Arrays are also `false` (If you want to check if an array has a glob pattern, use [has-glob](https://github.com/jonschlinkert/has-glob)):
+
+```js
+isGlob(['**/*.js']);
+isGlob(['foo.js']);
+//=> false
+```
+
+### Option strict
+
+When `options.strict === false` the behavior is less strict in determining if a pattern is a glob. Meaning that
+some patterns that would return `false` may return `true`. This is done so that matching libraries like [micromatch](https://github.com/micromatch/micromatch) have a chance at determining if the pattern is a glob or not.
+
+**True**
+
+Patterns that have glob characters or regex patterns will return `true`:
+
+```js
+isGlob('!foo.js', {strict: false});
+isGlob('*.js', {strict: false});
+isGlob('**/abc.js', {strict: false});
+isGlob('abc/*.js', {strict: false});
+isGlob('abc/(aaa|bbb).js', {strict: false});
+isGlob('abc/[a-z].js', {strict: false});
+isGlob('abc/{a,b}.js', {strict: false});
+//=> true
+```
+
+Extglobs
+
+```js
+isGlob('abc/@(a).js', {strict: false});
+isGlob('abc/!(a).js', {strict: false});
+isGlob('abc/+(a).js', {strict: false});
+isGlob('abc/*(a).js', {strict: false});
+isGlob('abc/?(a).js', {strict: false});
+//=> true
+```
+
+**False**
+
+Escaped globs or extglobs return `false`:
+
+```js
+isGlob('\\!foo.js', {strict: false});
+isGlob('\\*.js', {strict: false});
+isGlob('\\*\\*/abc.js', {strict: false});
+isGlob('abc/\\*.js', {strict: false});
+isGlob('abc/\\(aaa|bbb).js', {strict: false});
+isGlob('abc/\\[a-z].js', {strict: false});
+isGlob('abc/\\{a,b}.js', {strict: false});
+//=> false
+```
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [assemble](https://www.npmjs.com/package/assemble): Get the rocks out of your socks! Assemble makes you fast at creating web projects… [more](https://github.com/assemble/assemble) | [homepage](https://github.com/assemble/assemble "Get the rocks out of your socks! Assemble makes you fast at creating web projects. Assemble is used by thousands of projects for rapid prototyping, creating themes, scaffolds, boilerplates, e-books, UI components, API documentation, blogs, building websit")
+* [base](https://www.npmjs.com/package/base): Framework for rapidly creating high quality, server-side node.js applications, using plugins like building blocks | [homepage](https://github.com/node-base/base "Framework for rapidly creating high quality, server-side node.js applications, using plugins like building blocks")
+* [update](https://www.npmjs.com/package/update): Be scalable! Update is a new, open source developer framework and CLI for automating updates… [more](https://github.com/update/update) | [homepage](https://github.com/update/update "Be scalable! Update is a new, open source developer framework and CLI for automating updates of any kind in code projects.")
+* [verb](https://www.npmjs.com/package/verb): Documentation generator for GitHub projects. Verb is extremely powerful, easy to use, and is used… [more](https://github.com/verbose/verb) | [homepage](https://github.com/verbose/verb "Documentation generator for GitHub projects. Verb is extremely powerful, easy to use, and is used on hundreds of projects of all sizes to generate everything from API docs to readmes.")
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 47 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 5 | [doowb](https://github.com/doowb) |
+| 1 | [phated](https://github.com/phated) |
+| 1 | [danhper](https://github.com/danhper) |
+| 1 | [paulmillr](https://github.com/paulmillr) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on March 27, 2019._
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/is-glob/index.js b/node_modules/imagemin/node_modules/is-glob/index.js
new file mode 100644
index 0000000..5582651
--- /dev/null
+++ b/node_modules/imagemin/node_modules/is-glob/index.js
@@ -0,0 +1,48 @@
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isExtglob = require('is-extglob');
+var chars = { '{': '}', '(': ')', '[': ']'};
+var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
+var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
+
+module.exports = function isGlob(str, options) {
+ if (typeof str !== 'string' || str === '') {
+ return false;
+ }
+
+ if (isExtglob(str)) {
+ return true;
+ }
+
+ var regex = strictRegex;
+ var match;
+
+ // optionally relax regex
+ if (options && options.strict === false) {
+ regex = relaxedRegex;
+ }
+
+ while ((match = regex.exec(str))) {
+ if (match[2]) return true;
+ var idx = match.index + match[0].length;
+
+ // if an open bracket/brace/paren is escaped,
+ // set the index to the next closing character
+ var open = match[1];
+ var close = open ? chars[open] : null;
+ if (open && close) {
+ var n = str.indexOf(close, idx);
+ if (n !== -1) {
+ idx = n + 1;
+ }
+ }
+
+ str = str.slice(idx);
+ }
+ return false;
+};
diff --git a/node_modules/imagemin/node_modules/is-glob/package.json b/node_modules/imagemin/node_modules/is-glob/package.json
new file mode 100644
index 0000000..dc4f335
--- /dev/null
+++ b/node_modules/imagemin/node_modules/is-glob/package.json
@@ -0,0 +1,121 @@
+{
+ "_from": "is-glob@^4.0.1",
+ "_id": "is-glob@4.0.1",
+ "_inBundle": false,
+ "_integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
+ "_location": "/imagemin/is-glob",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "is-glob@^4.0.1",
+ "name": "is-glob",
+ "escapedName": "is-glob",
+ "rawSpec": "^4.0.1",
+ "saveSpec": null,
+ "fetchSpec": "^4.0.1"
+ },
+ "_requiredBy": [
+ "/imagemin/glob-parent"
+ ],
+ "_resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
+ "_shasum": "7567dbe9f2f5e2467bc77ab83c4a29482407a5dc",
+ "_spec": "is-glob@^4.0.1",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\glob-parent",
+ "author": {
+ "name": "Jon Schlinkert",
+ "url": "https://github.com/jonschlinkert"
+ },
+ "bugs": {
+ "url": "https://github.com/micromatch/is-glob/issues"
+ },
+ "bundleDependencies": false,
+ "contributors": [
+ {
+ "name": "Brian Woodward",
+ "url": "https://twitter.com/doowb"
+ },
+ {
+ "name": "Daniel Perez",
+ "url": "https://tuvistavie.com"
+ },
+ {
+ "name": "Jon Schlinkert",
+ "url": "http://twitter.com/jonschlinkert"
+ }
+ ],
+ "dependencies": {
+ "is-extglob": "^2.1.1"
+ },
+ "deprecated": false,
+ "description": "Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a better user experience.",
+ "devDependencies": {
+ "gulp-format-md": "^0.1.10",
+ "mocha": "^3.0.2"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "files": [
+ "index.js"
+ ],
+ "homepage": "https://github.com/micromatch/is-glob",
+ "keywords": [
+ "bash",
+ "braces",
+ "check",
+ "exec",
+ "expression",
+ "extglob",
+ "glob",
+ "globbing",
+ "globstar",
+ "is",
+ "match",
+ "matches",
+ "pattern",
+ "regex",
+ "regular",
+ "string",
+ "test"
+ ],
+ "license": "MIT",
+ "main": "index.js",
+ "name": "is-glob",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/micromatch/is-glob.git"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "verb": {
+ "layout": "default",
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "related": {
+ "list": [
+ "assemble",
+ "base",
+ "update",
+ "verb"
+ ]
+ },
+ "reflinks": [
+ "assemble",
+ "bach",
+ "base",
+ "composer",
+ "gulp",
+ "has-glob",
+ "is-valid-glob",
+ "micromatch",
+ "npm",
+ "scaffold",
+ "verb",
+ "vinyl"
+ ]
+ },
+ "version": "4.0.1"
+}
diff --git a/node_modules/imagemin/node_modules/is-number/LICENSE b/node_modules/imagemin/node_modules/is-number/LICENSE
new file mode 100644
index 0000000..9af4a67
--- /dev/null
+++ b/node_modules/imagemin/node_modules/is-number/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-present, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/is-number/README.md b/node_modules/imagemin/node_modules/is-number/README.md
new file mode 100644
index 0000000..eb8149e
--- /dev/null
+++ b/node_modules/imagemin/node_modules/is-number/README.md
@@ -0,0 +1,187 @@
+# is-number [](https://www.npmjs.com/package/is-number) [](https://npmjs.org/package/is-number) [](https://npmjs.org/package/is-number) [](https://travis-ci.org/jonschlinkert/is-number)
+
+> Returns true if the value is a finite number.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save is-number
+```
+
+## Why is this needed?
+
+In JavaScript, it's not always as straightforward as it should be to reliably check if a value is a number. It's common for devs to use `+`, `-`, or `Number()` to cast a string value to a number (for example, when values are returned from user input, regex matches, parsers, etc). But there are many non-intuitive edge cases that yield unexpected results:
+
+```js
+console.log(+[]); //=> 0
+console.log(+''); //=> 0
+console.log(+' '); //=> 0
+console.log(typeof NaN); //=> 'number'
+```
+
+This library offers a performant way to smooth out edge cases like these.
+
+## Usage
+
+```js
+const isNumber = require('is-number');
+```
+
+See the [tests](./test.js) for more examples.
+
+### true
+
+```js
+isNumber(5e3); // true
+isNumber(0xff); // true
+isNumber(-1.1); // true
+isNumber(0); // true
+isNumber(1); // true
+isNumber(1.1); // true
+isNumber(10); // true
+isNumber(10.10); // true
+isNumber(100); // true
+isNumber('-1.1'); // true
+isNumber('0'); // true
+isNumber('012'); // true
+isNumber('0xff'); // true
+isNumber('1'); // true
+isNumber('1.1'); // true
+isNumber('10'); // true
+isNumber('10.10'); // true
+isNumber('100'); // true
+isNumber('5e3'); // true
+isNumber(parseInt('012')); // true
+isNumber(parseFloat('012')); // true
+```
+
+### False
+
+Everything else is false, as you would expect:
+
+```js
+isNumber(Infinity); // false
+isNumber(NaN); // false
+isNumber(null); // false
+isNumber(undefined); // false
+isNumber(''); // false
+isNumber(' '); // false
+isNumber('foo'); // false
+isNumber([1]); // false
+isNumber([]); // false
+isNumber(function () {}); // false
+isNumber({}); // false
+```
+
+## Release history
+
+### 7.0.0
+
+* Refactor. Now uses `.isFinite` if it exists.
+* Performance is about the same as v6.0 when the value is a string or number. But it's now 3x-4x faster when the value is not a string or number.
+
+### 6.0.0
+
+* Optimizations, thanks to @benaadams.
+
+### 5.0.0
+
+**Breaking changes**
+
+* removed support for `instanceof Number` and `instanceof String`
+
+## Benchmarks
+
+As with all benchmarks, take these with a grain of salt. See the [benchmarks](./benchmark/index.js) for more detail.
+
+```
+# all
+v7.0 x 413,222 ops/sec ±2.02% (86 runs sampled)
+v6.0 x 111,061 ops/sec ±1.29% (85 runs sampled)
+parseFloat x 317,596 ops/sec ±1.36% (86 runs sampled)
+fastest is 'v7.0'
+
+# string
+v7.0 x 3,054,496 ops/sec ±1.05% (89 runs sampled)
+v6.0 x 2,957,781 ops/sec ±0.98% (88 runs sampled)
+parseFloat x 3,071,060 ops/sec ±1.13% (88 runs sampled)
+fastest is 'parseFloat,v7.0'
+
+# number
+v7.0 x 3,146,895 ops/sec ±0.89% (89 runs sampled)
+v6.0 x 3,214,038 ops/sec ±1.07% (89 runs sampled)
+parseFloat x 3,077,588 ops/sec ±1.07% (87 runs sampled)
+fastest is 'v6.0'
+```
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [is-plain-object](https://www.npmjs.com/package/is-plain-object): Returns true if an object was created by the `Object` constructor. | [homepage](https://github.com/jonschlinkert/is-plain-object "Returns true if an object was created by the `Object` constructor.")
+* [is-primitive](https://www.npmjs.com/package/is-primitive): Returns `true` if the value is a primitive. | [homepage](https://github.com/jonschlinkert/is-primitive "Returns `true` if the value is a primitive. ")
+* [isobject](https://www.npmjs.com/package/isobject): Returns true if the value is an object and not an array or null. | [homepage](https://github.com/jonschlinkert/isobject "Returns true if the value is an object and not an array or null.")
+* [kind-of](https://www.npmjs.com/package/kind-of): Get the native type of a value. | [homepage](https://github.com/jonschlinkert/kind-of "Get the native type of a value.")
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 49 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 5 | [charlike-old](https://github.com/charlike-old) |
+| 1 | [benaadams](https://github.com/benaadams) |
+| 1 | [realityking](https://github.com/realityking) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+
+### License
+
+Copyright © 2018, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.6.0, on June 15, 2018._
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/is-number/index.js b/node_modules/imagemin/node_modules/is-number/index.js
new file mode 100644
index 0000000..27f19b7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/is-number/index.js
@@ -0,0 +1,18 @@
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+module.exports = function(num) {
+ if (typeof num === 'number') {
+ return num - num === 0;
+ }
+ if (typeof num === 'string' && num.trim() !== '') {
+ return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+ }
+ return false;
+};
diff --git a/node_modules/imagemin/node_modules/is-number/package.json b/node_modules/imagemin/node_modules/is-number/package.json
new file mode 100644
index 0000000..8032c6e
--- /dev/null
+++ b/node_modules/imagemin/node_modules/is-number/package.json
@@ -0,0 +1,122 @@
+{
+ "_from": "is-number@^7.0.0",
+ "_id": "is-number@7.0.0",
+ "_inBundle": false,
+ "_integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+ "_location": "/imagemin/is-number",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "is-number@^7.0.0",
+ "name": "is-number",
+ "escapedName": "is-number",
+ "rawSpec": "^7.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^7.0.0"
+ },
+ "_requiredBy": [
+ "/imagemin/to-regex-range"
+ ],
+ "_resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+ "_shasum": "7535345b896734d5f80c4d06c50955527a14f12b",
+ "_spec": "is-number@^7.0.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\to-regex-range",
+ "author": {
+ "name": "Jon Schlinkert",
+ "url": "https://github.com/jonschlinkert"
+ },
+ "bugs": {
+ "url": "https://github.com/jonschlinkert/is-number/issues"
+ },
+ "bundleDependencies": false,
+ "contributors": [
+ {
+ "name": "Jon Schlinkert",
+ "url": "http://twitter.com/jonschlinkert"
+ },
+ {
+ "name": "Olsten Larck",
+ "url": "https://i.am.charlike.online"
+ },
+ {
+ "name": "Rouven Weßling",
+ "url": "www.rouvenwessling.de"
+ }
+ ],
+ "deprecated": false,
+ "description": "Returns true if a number or string value is a finite number. Useful for regex matches, parsing, user input, etc.",
+ "devDependencies": {
+ "ansi": "^0.3.1",
+ "benchmark": "^2.1.4",
+ "gulp-format-md": "^1.0.0",
+ "mocha": "^3.5.3"
+ },
+ "engines": {
+ "node": ">=0.12.0"
+ },
+ "files": [
+ "index.js"
+ ],
+ "homepage": "https://github.com/jonschlinkert/is-number",
+ "keywords": [
+ "cast",
+ "check",
+ "coerce",
+ "coercion",
+ "finite",
+ "integer",
+ "is",
+ "isnan",
+ "is-nan",
+ "is-num",
+ "is-number",
+ "isnumber",
+ "isfinite",
+ "istype",
+ "kind",
+ "math",
+ "nan",
+ "num",
+ "number",
+ "numeric",
+ "parseFloat",
+ "parseInt",
+ "test",
+ "type",
+ "typeof",
+ "value"
+ ],
+ "license": "MIT",
+ "main": "index.js",
+ "name": "is-number",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/jonschlinkert/is-number.git"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "verb": {
+ "toc": false,
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "related": {
+ "list": [
+ "is-plain-object",
+ "is-primitive",
+ "isobject",
+ "kind-of"
+ ]
+ },
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "lint": {
+ "reflinks": true
+ }
+ },
+ "version": "7.0.0"
+}
diff --git a/node_modules/imagemin/node_modules/make-dir/index.d.ts b/node_modules/imagemin/node_modules/make-dir/index.d.ts
new file mode 100644
index 0000000..3a78251
--- /dev/null
+++ b/node_modules/imagemin/node_modules/make-dir/index.d.ts
@@ -0,0 +1,66 @@
+/// <reference types="node"/>
+import * as fs from 'fs';
+
+declare namespace makeDir {
+ interface Options {
+ /**
+ Directory [permissions](https://x-team.com/blog/file-system-permissions-umask-node-js/).
+
+ @default 0o777
+ */
+ readonly mode?: number;
+
+ /**
+ Use a custom `fs` implementation. For example [`graceful-fs`](https://github.com/isaacs/node-graceful-fs).
+
+ Using a custom `fs` implementation will block the use of the native `recursive` option if `fs.mkdir` or `fs.mkdirSync` is not the native function.
+
+ @default require('fs')
+ */
+ readonly fs?: typeof fs;
+ }
+}
+
+declare const makeDir: {
+ /**
+ Make a directory and its parents if needed - Think `mkdir -p`.
+
+ @param path - Directory to create.
+ @returns The path to the created directory.
+
+ @example
+ ```
+ import makeDir = require('make-dir');
+
+ (async () => {
+ const path = await makeDir('unicorn/rainbow/cake');
+
+ console.log(path);
+ //=> '/Users/sindresorhus/fun/unicorn/rainbow/cake'
+
+ // Multiple directories:
+ const paths = await Promise.all([
+ makeDir('unicorn/rainbow'),
+ makeDir('foo/bar')
+ ]);
+
+ console.log(paths);
+ // [
+ // '/Users/sindresorhus/fun/unicorn/rainbow',
+ // '/Users/sindresorhus/fun/foo/bar'
+ // ]
+ })();
+ ```
+ */
+ (path: string, options?: makeDir.Options): Promise<string>;
+
+ /**
+ Synchronously make a directory and its parents if needed - Think `mkdir -p`.
+
+ @param path - Directory to create.
+ @returns The path to the created directory.
+ */
+ sync(path: string, options?: makeDir.Options): string;
+};
+
+export = makeDir;
diff --git a/node_modules/imagemin/node_modules/make-dir/index.js b/node_modules/imagemin/node_modules/make-dir/index.js
new file mode 100644
index 0000000..75889d8
--- /dev/null
+++ b/node_modules/imagemin/node_modules/make-dir/index.js
@@ -0,0 +1,156 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const {promisify} = require('util');
+const semver = require('semver');
+
+const useNativeRecursiveOption = semver.satisfies(process.version, '>=10.12.0');
+
+// https://github.com/nodejs/node/issues/8987
+// https://github.com/libuv/libuv/pull/1088
+const checkPath = pth => {
+ if (process.platform === 'win32') {
+ const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''));
+
+ if (pathHasInvalidWinCharacters) {
+ const error = new Error(`Path contains invalid characters: ${pth}`);
+ error.code = 'EINVAL';
+ throw error;
+ }
+ }
+};
+
+const processOptions = options => {
+ // https://github.com/sindresorhus/make-dir/issues/18
+ const defaults = {
+ mode: 0o777,
+ fs
+ };
+
+ return {
+ ...defaults,
+ ...options
+ };
+};
+
+const permissionError = pth => {
+ // This replicates the exception of `fs.mkdir` with native the
+ // `recusive` option when run on an invalid drive under Windows.
+ const error = new Error(`operation not permitted, mkdir '${pth}'`);
+ error.code = 'EPERM';
+ error.errno = -4048;
+ error.path = pth;
+ error.syscall = 'mkdir';
+ return error;
+};
+
+const makeDir = async (input, options) => {
+ checkPath(input);
+ options = processOptions(options);
+
+ const mkdir = promisify(options.fs.mkdir);
+ const stat = promisify(options.fs.stat);
+
+ if (useNativeRecursiveOption && options.fs.mkdir === fs.mkdir) {
+ const pth = path.resolve(input);
+
+ await mkdir(pth, {
+ mode: options.mode,
+ recursive: true
+ });
+
+ return pth;
+ }
+
+ const make = async pth => {
+ try {
+ await mkdir(pth, options.mode);
+
+ return pth;
+ } catch (error) {
+ if (error.code === 'EPERM') {
+ throw error;
+ }
+
+ if (error.code === 'ENOENT') {
+ if (path.dirname(pth) === pth) {
+ throw permissionError(pth);
+ }
+
+ if (error.message.includes('null bytes')) {
+ throw error;
+ }
+
+ await make(path.dirname(pth));
+
+ return make(pth);
+ }
+
+ try {
+ const stats = await stat(pth);
+ if (!stats.isDirectory()) {
+ throw new Error('The path is not a directory');
+ }
+ } catch (_) {
+ throw error;
+ }
+
+ return pth;
+ }
+ };
+
+ return make(path.resolve(input));
+};
+
+module.exports = makeDir;
+
+module.exports.sync = (input, options) => {
+ checkPath(input);
+ options = processOptions(options);
+
+ if (useNativeRecursiveOption && options.fs.mkdirSync === fs.mkdirSync) {
+ const pth = path.resolve(input);
+
+ fs.mkdirSync(pth, {
+ mode: options.mode,
+ recursive: true
+ });
+
+ return pth;
+ }
+
+ const make = pth => {
+ try {
+ options.fs.mkdirSync(pth, options.mode);
+ } catch (error) {
+ if (error.code === 'EPERM') {
+ throw error;
+ }
+
+ if (error.code === 'ENOENT') {
+ if (path.dirname(pth) === pth) {
+ throw permissionError(pth);
+ }
+
+ if (error.message.includes('null bytes')) {
+ throw error;
+ }
+
+ make(path.dirname(pth));
+ return make(pth);
+ }
+
+ try {
+ if (!options.fs.statSync(pth).isDirectory()) {
+ throw new Error('The path is not a directory');
+ }
+ } catch (_) {
+ throw error;
+ }
+ }
+
+ return pth;
+ };
+
+ return make(path.resolve(input));
+};
diff --git a/node_modules/imagemin/node_modules/make-dir/license b/node_modules/imagemin/node_modules/make-dir/license
new file mode 100644
index 0000000..e7af2f7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/make-dir/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/make-dir/package.json b/node_modules/imagemin/node_modules/make-dir/package.json
new file mode 100644
index 0000000..4155070
--- /dev/null
+++ b/node_modules/imagemin/node_modules/make-dir/package.json
@@ -0,0 +1,91 @@
+{
+ "_from": "make-dir@^3.0.0",
+ "_id": "make-dir@3.1.0",
+ "_inBundle": false,
+ "_integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+ "_location": "/imagemin/make-dir",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "make-dir@^3.0.0",
+ "name": "make-dir",
+ "escapedName": "make-dir",
+ "rawSpec": "^3.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^3.0.0"
+ },
+ "_requiredBy": [
+ "/imagemin"
+ ],
+ "_resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+ "_shasum": "415e967046b3a7f1d185277d84aa58203726a13f",
+ "_spec": "make-dir@^3.0.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "bugs": {
+ "url": "https://github.com/sindresorhus/make-dir/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "semver": "^6.0.0"
+ },
+ "deprecated": false,
+ "description": "Make a directory and its parents if needed - Think `mkdir -p`",
+ "devDependencies": {
+ "@types/graceful-fs": "^4.1.3",
+ "@types/node": "^13.7.1",
+ "ava": "^1.4.0",
+ "codecov": "^3.2.0",
+ "graceful-fs": "^4.1.15",
+ "nyc": "^15.0.0",
+ "path-type": "^4.0.0",
+ "tempy": "^0.2.1",
+ "tsd": "^0.11.0",
+ "xo": "^0.25.4"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js",
+ "index.d.ts"
+ ],
+ "funding": "https://github.com/sponsors/sindresorhus",
+ "homepage": "https://github.com/sindresorhus/make-dir#readme",
+ "keywords": [
+ "mkdir",
+ "mkdirp",
+ "make",
+ "directories",
+ "dir",
+ "dirs",
+ "folders",
+ "directory",
+ "folder",
+ "path",
+ "parent",
+ "parents",
+ "intermediate",
+ "recursively",
+ "recursive",
+ "create",
+ "fs",
+ "filesystem",
+ "file-system"
+ ],
+ "license": "MIT",
+ "name": "make-dir",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/sindresorhus/make-dir.git"
+ },
+ "scripts": {
+ "test": "xo && nyc ava && tsd"
+ },
+ "version": "3.1.0"
+}
diff --git a/node_modules/imagemin/node_modules/make-dir/readme.md b/node_modules/imagemin/node_modules/make-dir/readme.md
new file mode 100644
index 0000000..a10a1a4
--- /dev/null
+++ b/node_modules/imagemin/node_modules/make-dir/readme.md
@@ -0,0 +1,125 @@
+# make-dir [](https://travis-ci.org/sindresorhus/make-dir) [](https://codecov.io/gh/sindresorhus/make-dir)
+
+> Make a directory and its parents if needed - Think `mkdir -p`
+
+## Advantages over [`mkdirp`](https://github.com/substack/node-mkdirp)
+
+- Promise API *(Async/await ready!)*
+- Fixes many `mkdirp` issues: [#96](https://github.com/substack/node-mkdirp/pull/96) [#70](https://github.com/substack/node-mkdirp/issues/70) [#66](https://github.com/substack/node-mkdirp/issues/66)
+- 100% test coverage
+- CI-tested on macOS, Linux, and Windows
+- Actively maintained
+- Doesn't bundle a CLI
+- Uses the native `fs.mkdir/mkdirSync` [`recursive` option](https://nodejs.org/dist/latest/docs/api/fs.html#fs_fs_mkdir_path_options_callback) in Node.js >=10.12.0 unless [overridden](#fs)
+
+## Install
+
+```
+$ npm install make-dir
+```
+
+## Usage
+
+```
+$ pwd
+/Users/sindresorhus/fun
+$ tree
+.
+```
+
+```js
+const makeDir = require('make-dir');
+
+(async () => {
+ const path = await makeDir('unicorn/rainbow/cake');
+
+ console.log(path);
+ //=> '/Users/sindresorhus/fun/unicorn/rainbow/cake'
+})();
+```
+
+```
+$ tree
+.
+└── unicorn
+ └── rainbow
+ └── cake
+```
+
+Multiple directories:
+
+```js
+const makeDir = require('make-dir');
+
+(async () => {
+ const paths = await Promise.all([
+ makeDir('unicorn/rainbow'),
+ makeDir('foo/bar')
+ ]);
+
+ console.log(paths);
+ /*
+ [
+ '/Users/sindresorhus/fun/unicorn/rainbow',
+ '/Users/sindresorhus/fun/foo/bar'
+ ]
+ */
+})();
+```
+
+## API
+
+### makeDir(path, options?)
+
+Returns a `Promise` for the path to the created directory.
+
+### makeDir.sync(path, options?)
+
+Returns the path to the created directory.
+
+#### path
+
+Type: `string`
+
+Directory to create.
+
+#### options
+
+Type: `object`
+
+##### mode
+
+Type: `integer`\
+Default: `0o777`
+
+Directory [permissions](https://x-team.com/blog/file-system-permissions-umask-node-js/).
+
+##### fs
+
+Type: `object`\
+Default: `require('fs')`
+
+Use a custom `fs` implementation. For example [`graceful-fs`](https://github.com/isaacs/node-graceful-fs).
+
+Using a custom `fs` implementation will block the use of the native `recursive` option if `fs.mkdir` or `fs.mkdirSync` is not the native function.
+
+## Related
+
+- [make-dir-cli](https://github.com/sindresorhus/make-dir-cli) - CLI for this module
+- [del](https://github.com/sindresorhus/del) - Delete files and directories
+- [globby](https://github.com/sindresorhus/globby) - User-friendly glob matching
+- [cpy](https://github.com/sindresorhus/cpy) - Copy files
+- [cpy-cli](https://github.com/sindresorhus/cpy-cli) - Copy files on the command-line
+- [move-file](https://github.com/sindresorhus/move-file) - Move a file
+
+---
+
+<div align="center">
+ <b>
+ <a href="https://tidelift.com/subscription/pkg/npm-make-dir?utm_source=npm-make-dir&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+ </b>
+ <br>
+ <sub>
+ Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+ </sub>
+</div>
diff --git a/node_modules/imagemin/node_modules/micromatch/CHANGELOG.md b/node_modules/imagemin/node_modules/micromatch/CHANGELOG.md
new file mode 100644
index 0000000..25fa58c
--- /dev/null
+++ b/node_modules/imagemin/node_modules/micromatch/CHANGELOG.md
@@ -0,0 +1,108 @@
+# Release history
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+<details>
+ <summary><strong>Guiding Principles</strong></summary>
+
+- Changelogs are for humans, not machines.
+- There should be an entry for every single version.
+- The same types of changes should be grouped.
+- Versions and sections should be linkable.
+- The latest version comes first.
+- The release date of each versions is displayed.
+- Mention whether you follow Semantic Versioning.
+
+</details>
+
+<details>
+ <summary><strong>Types of changes</strong></summary>
+
+Changelog entries are classified using the following labels _(from [keep-a-changelog](http://keepachangelog.com/)_):
+
+- `Added` for new features.
+- `Changed` for changes in existing functionality.
+- `Deprecated` for soon-to-be removed features.
+- `Removed` for now removed features.
+- `Fixed` for any bug fixes.
+- `Security` in case of vulnerabilities.
+
+</details>
+
+## [4.0.0] - 2019-03-20
+
+### Added
+
+- Adds support for `options.onMatch`. See the readme for details
+- Adds support for `options.onIgnore`. See the readme for details
+- Adds support for `options.onResult`. See the readme for details
+
+
+### Breaking changes
+
+- Removed support for passing an array of brace patterns to `micromatch.braces()`.
+- To strictly enforce closing brackets (for `{`, `[`, and `(`), you must now use `strictBrackets=true` instead of `strictErrors`.
+- `cache` - caching and all related options and methods have been removed
+- `options.unixify` was renamed to `options.windows`
+- `options.nodupes` Was removed. Duplicates are always removed by default. You can override this with custom behavior by using the `onMatch`, `onResult` and `onIgnore` functions.
+- `options.snapdragon` was removed, as snapdragon is no longer used.
+- `options.sourcemap` was removed, as snapdragon is no longer used, which provided sourcemap support.
+
+## [3.0.0] - 2017-04-11
+
+Complete overhaul, with 36,000+ new unit tests validated against actual output generated by Bash and minimatch. More specifically, 35,000+ of the tests:
+
+ - micromatch results are directly compared to bash results
+ - in rare cases, when micromatch and bash disagree, micromatch's results are compared to minimatch's results
+ - micromatch is much more accurate than minimatch, so there were cases where I had to make assumptions. I'll try to document these.
+
+This refactor introduces a parser and compiler that are supersets of more granular parsers and compilers from other sub-modules. Each of these sub-modules has a singular responsibility and focuses on a certain type of matching that aligns with a specific part of the Bash "expansion" API.
+
+These sub-modules work like plugins to seamlessly create the micromatch parser/compiler, so that strings are parsed in one pass, an [AST is created](https://gist.github.com/jonschlinkert/099c8914f56529f75bc757cc9e5e8e2a), then a new string is generated by the compiler.
+
+Here are those sub-modules with links to related prs on those modules if you want to see how they contribute to this code:
+
+[nanomatch](https://github.com/jonschlinkert/nanomatch) (new library) - glob expansion (`*`, `**`, `?` and `[...]`))
+[braces](https://github.com/jonschlinkert/braces/pull/10) - brace expansion (`{1..10}`, `{a,b,c}`, etc)
+[extglob](https://github.com/jonschlinkert/extglob/pull/5) - extended globs (`!(a|b)`, `@(!(foo|bar))`, etc)
+[expand-brackets](https://github.com/jonschlinkert/expand-brackets/pull/5) - POSIX character classes `[[:alpha:][:digit:]]`
+
+**Added**
+
+ - source map support (optionally created when using parse or compile - I have no idea what the use case is yet, but they come for free) (note that source maps are not generated for brace expansion at present, since the braces compiler uses a different strategy. I'll update if/when this changes).
+ - parser is exposed, so that implementors can customize or override specific micromatch parsers if necessary
+ - compiler is exposed, so that implementors can customize or override specific micromatch compilers if necessary
+
+**Fixed**
+
+ - more accurate matching (passes 100% of Bash 4.3 of the brace expansion and extglob unit tests, as well as all Bash glob tests that are relevant to node.js usage, all minimatch tests, all brace-expansion tests, and also passes a couple of tests that bash fails)
+ - even safer - micromatch has always generated optimized patterns so it's not subject to DoS exploits like minimatch (completely different than the regex DoS issue, minimatch and multimatch are still openly exposed to being used for DoS attacks), but more safeguards were built into this refactor
+
+**Changed**
+
+ - the public API of this library did not change in this version and should be safe to upgrade without changing implentor code. However, we have released this as a major version for the following reasons:
+ - out of an abundance of caution due to the large amount of code changed in this release
+ - we have improved parser accuracy to such a degree that some implementors using invalid globs have noted change in behavior. If this is the case for you, please check that you are using a valid glob expression before logging a bug with this library
+
+## [1.0.1] - 2016-12-12
+
+**Added**
+
+- Support for windows path edge cases where backslashes are used in brackets or other unusual combinations.
+
+## [1.0.0] - 2016-12-12
+
+Stable release.
+
+## [0.1.0] - 2016-10-08
+
+First release.
+
+
+[Unreleased]: https://github.com/jonschlinkert/micromatch/compare/0.1.0...HEAD
+[0.2.0]: https://github.com/jonschlinkert/micromatch/compare/0.1.0...0.2.0
+
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog
diff --git a/node_modules/imagemin/node_modules/micromatch/LICENSE b/node_modules/imagemin/node_modules/micromatch/LICENSE
new file mode 100644
index 0000000..9af4a67
--- /dev/null
+++ b/node_modules/imagemin/node_modules/micromatch/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-present, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/micromatch/README.md b/node_modules/imagemin/node_modules/micromatch/README.md
new file mode 100644
index 0000000..e38f7ca
--- /dev/null
+++ b/node_modules/imagemin/node_modules/micromatch/README.md
@@ -0,0 +1,1000 @@
+# micromatch [](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [](https://www.npmjs.com/package/micromatch) [](https://npmjs.org/package/micromatch) [](https://npmjs.org/package/micromatch) [](https://travis-ci.org/micromatch/micromatch)
+
+> Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Table of Contents
+
+<details>
+<summary><strong>Details</strong></summary>
+
+- [Install](#install)
+- [Quickstart](#quickstart)
+- [Why use micromatch?](#why-use-micromatch)
+ * [Matching features](#matching-features)
+- [Switching to micromatch](#switching-to-micromatch)
+ * [From minimatch](#from-minimatch)
+ * [From multimatch](#from-multimatch)
+- [API](#api)
+- [Options](#options)
+- [Options Examples](#options-examples)
+ * [options.basename](#optionsbasename)
+ * [options.bash](#optionsbash)
+ * [options.expandRange](#optionsexpandrange)
+ * [options.format](#optionsformat)
+ * [options.ignore](#optionsignore)
+ * [options.matchBase](#optionsmatchbase)
+ * [options.noextglob](#optionsnoextglob)
+ * [options.nonegate](#optionsnonegate)
+ * [options.noglobstar](#optionsnoglobstar)
+ * [options.nonull](#optionsnonull)
+ * [options.nullglob](#optionsnullglob)
+ * [options.onIgnore](#optionsonignore)
+ * [options.onMatch](#optionsonmatch)
+ * [options.onResult](#optionsonresult)
+ * [options.posixSlashes](#optionsposixslashes)
+ * [options.unescape](#optionsunescape)
+- [Extended globbing](#extended-globbing)
+ * [Extglobs](#extglobs)
+ * [Braces](#braces)
+ * [Regex character classes](#regex-character-classes)
+ * [Regex groups](#regex-groups)
+ * [POSIX bracket expressions](#posix-bracket-expressions)
+- [Notes](#notes)
+ * [Bash 4.3 parity](#bash-43-parity)
+ * [Backslashes](#backslashes)
+- [Benchmarks](#benchmarks)
+ * [Running benchmarks](#running-benchmarks)
+ * [Latest results](#latest-results)
+- [Contributing](#contributing)
+- [About](#about)
+
+</details>
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save micromatch
+```
+
+## Quickstart
+
+```js
+const micromatch = require('micromatch');
+// micromatch(list, patterns[, options]);
+```
+
+The [main export](#micromatch) takes a list of strings and one or more glob patterns:
+
+```js
+console.log(micromatch(['foo', 'bar', 'baz', 'qux'], ['f*', 'b*'])) //=> ['foo', 'bar', 'baz']
+console.log(micromatch(['foo', 'bar', 'baz', 'qux'], ['*', '!b*'])) //=> ['foo', 'qux']
+```
+
+Use [.isMatch()](#ismatch) to for boolean matching:
+
+```js
+console.log(micromatch.isMatch('foo', 'f*')) //=> true
+console.log(micromatch.isMatch('foo', ['b*', 'f*'])) //=> true
+```
+
+[Switching](#switching-to-micromatch) from minimatch and multimatch is easy!
+
+<br>
+
+## Why use micromatch?
+
+> micromatch is a [replacement](#switching-to-micromatch) for minimatch and multimatch
+
+* Supports all of the same matching features as [minimatch](https://github.com/isaacs/minimatch) and [multimatch](https://github.com/sindresorhus/multimatch)
+* More complete support for the Bash 4.3 specification than minimatch and multimatch. Micromatch passes _all of the spec tests_ from bash, including some that bash still fails.
+* **Fast & Performant** - Loads in about 5ms and performs [fast matches](#benchmarks).
+* **Glob matching** - Using wildcards (`*` and `?`), globstars (`**`) for nested directories
+* **[Advanced globbing](#advanced-globbing)** - Supports [extglobs](#extglobs), [braces](#braces), and [POSIX brackets](#posix-bracket-expressions), and support for escaping special characters with `\` or quotes.
+* **Accurate** - Covers more scenarios [than minimatch](https://github.com/yarnpkg/yarn/pull/3339)
+* **Well tested** - More than 5,000 [test assertions](./test)
+* **Windows support** - More reliable windows support than minimatch and multimatch.
+* **[Safe](https://github.com/micromatch/braces#braces-is-safe)** - Micromatch is not subject to DoS with brace patterns like minimatch and multimatch.
+
+### Matching features
+
+* Support for multiple glob patterns (no need for wrappers like multimatch)
+* Wildcards (`**`, `*.js`)
+* Negation (`'!a/*.js'`, `'*!(b).js']`)
+* [extglobs](#extglobs) (`+(x|y)`, `!(a|b)`)
+* [POSIX character classes](#posix-bracket-expressions) (`[[:alpha:][:digit:]]`)
+* [brace expansion](https://github.com/micromatch/braces) (`foo/{1..5}.md`, `bar/{a,b,c}.js`)
+* regex character classes (`foo-[1-5].js`)
+* regex logical "or" (`foo/(abc|xyz).js`)
+
+You can mix and match these features to create whatever patterns you need!
+
+## Switching to micromatch
+
+_(There is one notable difference between micromatch and minimatch in regards to how backslashes are handled. See [the notes about backslashes](#backslashes) for more information.)_
+
+### From minimatch
+
+Use [micromatch.isMatch()](#ismatch) instead of `minimatch()`:
+
+```js
+console.log(micromatch.isMatch('foo', 'b*')); //=> false
+```
+
+Use [micromatch.match()](#match) instead of `minimatch.match()`:
+
+```js
+console.log(micromatch.match(['foo', 'bar'], 'b*')); //=> 'bar'
+```
+
+### From multimatch
+
+Same signature:
+
+```js
+console.log(micromatch(['foo', 'bar', 'baz'], ['f*', '*z'])); //=> ['foo', 'baz']
+```
+
+## API
+
+**Params**
+
+* **{String|Array<string>}**: list List of strings to match.
+* **{String|Array<string>}**: patterns One or more glob patterns to use for matching.
+* **{Object}**: options See available [options](#options)
+* `returns` **{Array}**: Returns an array of matches
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm(list, patterns[, options]);
+
+console.log(mm(['a.js', 'a.txt'], ['*.js']));
+//=> [ 'a.js' ]
+```
+
+### [.matcher](index.js#L98)
+
+Returns a matcher function from the given glob `pattern` and `options`. The returned function takes a string to match as its only argument and returns true if the string is a match.
+
+**Params**
+
+* `pattern` **{String}**: Glob pattern
+* `options` **{Object}**
+* `returns` **{Function}**: Returns a matcher function.
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm.matcher(pattern[, options]);
+
+const isMatch = mm.matcher('*.!(*a)');
+console.log(isMatch('a.a')); //=> false
+console.log(isMatch('a.b')); //=> true
+```
+
+### [.isMatch](index.js#L117)
+
+Returns true if **any** of the given glob `patterns` match the specified `string`.
+
+**Params**
+
+* **{String}**: str The string to test.
+* **{String|Array}**: patterns One or more glob patterns to use for matching.
+* **{Object}**: See available [options](#options).
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm.isMatch(string, patterns[, options]);
+
+console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true
+console.log(mm.isMatch('a.a', 'b.*')); //=> false
+```
+
+### [.not](index.js#L136)
+
+Returns a list of strings that _**do not match any**_ of the given `patterns`.
+
+**Params**
+
+* `list` **{Array}**: Array of strings to match.
+* `patterns` **{String|Array}**: One or more glob pattern to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Array}**: Returns an array of strings that **do not match** the given patterns.
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm.not(list, patterns[, options]);
+
+console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));
+//=> ['b.b', 'c.c']
+```
+
+### [.contains](index.js#L176)
+
+Returns true if the given `string` contains the given pattern. Similar to [.isMatch](#isMatch) but the pattern can match any part of the string.
+
+**Params**
+
+* `str` **{String}**: The string to match.
+* `patterns` **{String|Array}**: Glob pattern to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if the patter matches any part of `str`.
+
+**Example**
+
+```js
+var mm = require('micromatch');
+// mm.contains(string, pattern[, options]);
+
+console.log(mm.contains('aa/bb/cc', '*b'));
+//=> true
+console.log(mm.contains('aa/bb/cc', '*d'));
+//=> false
+```
+
+### [.matchKeys](index.js#L218)
+
+Filter the keys of the given object with the given `glob` pattern and `options`. Does not attempt to match nested keys. If you need this feature, use [glob-object](https://github.com/jonschlinkert/glob-object) instead.
+
+**Params**
+
+* `object` **{Object}**: The object with keys to filter.
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Object}**: Returns an object with only keys that match the given patterns.
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm.matchKeys(object, patterns[, options]);
+
+const obj = { aa: 'a', ab: 'b', ac: 'c' };
+console.log(mm.matchKeys(obj, '*b'));
+//=> { ab: 'b' }
+```
+
+### [.some](index.js#L247)
+
+Returns true if some of the strings in the given `list` match any of the given glob `patterns`.
+
+**Params**
+
+* `list` **{String|Array}**: The string or array of strings to test. Returns as soon as the first match is found.
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm.some(list, patterns[, options]);
+
+console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+// true
+console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));
+// false
+```
+
+### [.every](index.js#L283)
+
+Returns true if every string in the given `list` matches any of the given glob `patterns`.
+
+**Params**
+
+* `list` **{String|Array}**: The string or array of strings to test.
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm.every(list, patterns[, options]);
+
+console.log(mm.every('foo.js', ['foo.js']));
+// true
+console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));
+// true
+console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+// false
+console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));
+// false
+```
+
+### [.all](index.js#L322)
+
+Returns true if **all** of the given `patterns` match the specified string.
+
+**Params**
+
+* `str` **{String|Array}**: The string to test.
+* `patterns` **{String|Array}**: One or more glob patterns to use for matching.
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm.all(string, patterns[, options]);
+
+console.log(mm.all('foo.js', ['foo.js']));
+// true
+
+console.log(mm.all('foo.js', ['*.js', '!foo.js']));
+// false
+
+console.log(mm.all('foo.js', ['*.js', 'foo.js']));
+// true
+
+console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
+// true
+```
+
+### [.capture](index.js#L349)
+
+Returns an array of matches captured by `pattern` in `string, or`null` if the pattern did not match.
+
+**Params**
+
+* `glob` **{String}**: Glob pattern to use for matching.
+* `input` **{String}**: String to match
+* `options` **{Object}**: See available [options](#options) for changing how matches are performed
+* `returns` **{Boolean}**: Returns an array of captures if the input matches the glob pattern, otherwise `null`.
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm.capture(pattern, string[, options]);
+
+console.log(mm.capture('test/*.js', 'test/foo.js'));
+//=> ['foo']
+console.log(mm.capture('test/*.js', 'foo/bar.css'));
+//=> null
+```
+
+### [.makeRe](index.js#L375)
+
+Create a regular expression from the given glob `pattern`.
+
+**Params**
+
+* `pattern` **{String}**: A glob pattern to convert to regex.
+* `options` **{Object}**
+* `returns` **{RegExp}**: Returns a regex created from the given pattern.
+
+**Example**
+
+```js
+const mm = require('micromatch');
+// mm.makeRe(pattern[, options]);
+
+console.log(mm.makeRe('*.js'));
+//=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
+```
+
+### [.scan](index.js#L391)
+
+Scan a glob pattern to separate the pattern into segments. Used by the [split](#split) method.
+
+**Params**
+
+* `pattern` **{String}**
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an object with
+
+**Example**
+
+```js
+const mm = require('micromatch');
+const state = mm.scan(pattern[, options]);
+```
+
+### [.parse](index.js#L407)
+
+Parse a glob pattern to create the source string for a regular expression.
+
+**Params**
+
+* `glob` **{String}**
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an object with useful properties and output to be used as regex source string.
+
+**Example**
+
+```js
+const mm = require('micromatch');
+const state = mm(pattern[, options]);
+```
+
+### [.braces](index.js#L434)
+
+Process the given brace `pattern`.
+
+**Params**
+
+* `pattern` **{String}**: String with brace pattern to process.
+* `options` **{Object}**: Any [options](#options) to change how expansion is performed. See the [braces](https://github.com/micromatch/braces) library for all available options.
+* `returns` **{Array}**
+
+**Example**
+
+```js
+const { braces } = require('micromatch');
+console.log(braces('foo/{a,b,c}/bar'));
+//=> [ 'foo/(a|b|c)/bar' ]
+
+console.log(braces('foo/{a,b,c}/bar', { expand: true }));
+//=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]
+```
+
+## Options
+
+| **Option** | **Type** | **Default value** | **Description** |
+| --- | --- | --- | --- |
+| `basename` | `boolean` | `false` | If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. |
+| `bash` | `boolean` | `false` | Follow bash matching rules more strictly - disallows backslashes as escape characters, and treats single stars as globstars (`**`). |
+| `capture` | `boolean` | `undefined` | Return regex matches in supporting methods. |
+| `contains` | `boolean` | `undefined` | Allows glob to match any part of the given string(s). |
+| `cwd` | `string` | `process.cwd()` | Current working directory. Used by `picomatch.split()` |
+| `debug` | `boolean` | `undefined` | Debug regular expressions when an error is thrown. |
+| `dot` | `boolean` | `false` | Match dotfiles. Otherwise dotfiles are ignored unless a `.` is explicitly defined in the pattern. |
+| `expandRange` | `function` | `undefined` | Custom function for expanding ranges in brace patterns, such as `{a..z}`. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. This option is overridden by the `expandBrace` option. |
+| `failglob` | `boolean` | `false` | Similar to the `failglob` behavior in Bash, throws an error when no matches are found. Based on the bash option of the same name. |
+| `fastpaths` | `boolean` | `true` | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to `false`. |
+| `flags` | `boolean` | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. |
+| [format](#optionsformat) | `function` | `undefined` | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. |
+| `ignore` | `array\|string` | `undefined` | One or more glob patterns for excluding strings that should not be matched from the result. |
+| `keepQuotes` | `boolean` | `false` | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes. |
+| `literalBrackets` | `boolean` | `undefined` | When `true`, brackets in the glob pattern will be escaped so that only literal brackets will be matched. |
+| `lookbehinds` | `boolean` | `true` | Support regex positive and negative lookbehinds. Note that you must be using Node 8.1.10 or higher to enable regex lookbehinds. |
+| `matchBase` | `boolean` | `false` | Alias for `basename` |
+| `maxLength` | `boolean` | `65536` | Limit the max length of the input string. An error is thrown if the input string is longer than this value. |
+| `nobrace` | `boolean` | `false` | Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters. |
+| `nobracket` | `boolean` | `undefined` | Disable matching with regex brackets. |
+| `nocase` | `boolean` | `false` | Perform case-insensitive matching. Equivalent to the regex `i` flag. Note that this option is ignored when the `flags` option is defined. |
+| `nodupes` | `boolean` | `true` | Deprecated, use `nounique` instead. This option will be removed in a future major release. By default duplicates are removed. Disable uniquification by setting this option to false. |
+| `noext` | `boolean` | `false` | Alias for `noextglob` |
+| `noextglob` | `boolean` | `false` | Disable support for matching with [extglobs](#extglobs) (like `+(a\|b)`) |
+| `noglobstar` | `boolean` | `false` | Disable support for matching nested directories with globstars (`**`) |
+| `nonegate` | `boolean` | `false` | Disable support for negating with leading `!` |
+| `noquantifiers` | `boolean` | `false` | Disable support for regex quantifiers (like `a{1,2}`) and treat them as brace patterns to be expanded. |
+| [onIgnore](#optionsonIgnore) | `function` | `undefined` | Function to be called on ignored items. |
+| [onMatch](#optionsonMatch) | `function` | `undefined` | Function to be called on matched items. |
+| [onResult](#optionsonResult) | `function` | `undefined` | Function to be called on all items, regardless of whether or not they are matched or ignored. |
+| `posix` | `boolean` | `false` | Support [POSIX character classes](#posix-bracket-expressions) ("posix brackets"). |
+| `posixSlashes` | `boolean` | `undefined` | Convert all slashes in file paths to forward slashes. This does not convert slashes in the glob pattern itself |
+| `prepend` | `boolean` | `undefined` | String to prepend to the generated regex used for matching. |
+| `regex` | `boolean` | `false` | Use regular expression rules for `+` (instead of matching literal `+`), and for stars that follow closing parentheses or brackets (as in `)*` and `]*`). |
+| `strictBrackets` | `boolean` | `undefined` | Throw an error if brackets, braces, or parens are imbalanced. |
+| `strictSlashes` | `boolean` | `undefined` | When true, picomatch won't match trailing slashes with single stars. |
+| `unescape` | `boolean` | `undefined` | Remove preceding backslashes from escaped glob characters before creating the regular expression to perform matches. |
+| `unixify` | `boolean` | `undefined` | Alias for `posixSlashes`, for backwards compatitibility. |
+
+## Options Examples
+
+### options.basename
+
+Allow glob patterns without slashes to match a file path based on its basename. Same behavior as [minimatch](https://github.com/isaacs/minimatch) option `matchBase`.
+
+**Type**: `Boolean`
+
+**Default**: `false`
+
+**Example**
+
+```js
+micromatch(['a/b.js', 'a/c.md'], '*.js');
+//=> []
+
+micromatch(['a/b.js', 'a/c.md'], '*.js', { basename: true });
+//=> ['a/b.js']
+```
+
+### options.bash
+
+Enabled by default, this option enforces bash-like behavior with stars immediately following a bracket expression. Bash bracket expressions are similar to regex character classes, but unlike regex, a star following a bracket expression **does not repeat the bracketed characters**. Instead, the star is treated the same as any other star.
+
+**Type**: `Boolean`
+
+**Default**: `true`
+
+**Example**
+
+```js
+const files = ['abc', 'ajz'];
+console.log(micromatch(files, '[a-c]*'));
+//=> ['abc', 'ajz']
+
+console.log(micromatch(files, '[a-c]*', { bash: false }));
+```
+
+### options.expandRange
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+Custom function for expanding ranges in brace patterns. The [fill-range](https://github.com/jonschlinkert/fill-range) library is ideal for this purpose, or you can use custom code to do whatever you need.
+
+**Example**
+
+The following example shows how to create a glob that matches a numeric folder name between `01` and `25`, with leading zeros.
+
+```js
+const fill = require('fill-range');
+const regex = micromatch.makeRe('foo/{01..25}/bar', {
+ expandRange(a, b) {
+ return `(${fill(a, b, { toRegex: true })})`;
+ }
+});
+
+console.log(regex)
+//=> /^(?:foo\/((?:0[1-9]|1[0-9]|2[0-5]))\/bar)$/
+
+console.log(regex.test('foo/00/bar')) // false
+console.log(regex.test('foo/01/bar')) // true
+console.log(regex.test('foo/10/bar')) // true
+console.log(regex.test('foo/22/bar')) // true
+console.log(regex.test('foo/25/bar')) // true
+console.log(regex.test('foo/26/bar')) // false
+```
+
+### options.format
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+Custom function for formatting strings before they're matched.
+
+**Example**
+
+```js
+// strip leading './' from strings
+const format = str => str.replace(/^\.\//, '');
+const isMatch = picomatch('foo/*.js', { format });
+console.log(isMatch('./foo/bar.js')) //=> true
+```
+
+### options.ignore
+
+String or array of glob patterns to match files to ignore.
+
+**Type**: `String|Array`
+
+**Default**: `undefined`
+
+```js
+const isMatch = micromatch.matcher('*', { ignore: 'f*' });
+console.log(isMatch('foo')) //=> false
+console.log(isMatch('bar')) //=> true
+console.log(isMatch('baz')) //=> true
+```
+
+### options.matchBase
+
+Alias for [options.basename](#options-basename).
+
+### options.noextglob
+
+Disable extglob support, so that [extglobs](#extglobs) are regarded as literal characters.
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Examples**
+
+```js
+console.log(micromatch(['a/z', 'a/b', 'a/!(z)'], 'a/!(z)'));
+//=> ['a/b', 'a/!(z)']
+
+console.log(micromatch(['a/z', 'a/b', 'a/!(z)'], 'a/!(z)', { noextglob: true }));
+//=> ['a/!(z)'] (matches only as literal characters)
+```
+
+### options.nonegate
+
+Disallow negation (`!`) patterns, and treat leading `!` as a literal character to match.
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+### options.noglobstar
+
+Disable matching with globstars (`**`).
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+```js
+micromatch(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**');
+//=> ['a/b', 'a/b/c', 'a/b/c/d']
+
+micromatch(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**', {noglobstar: true});
+//=> ['a/b']
+```
+
+### options.nonull
+
+Alias for [options.nullglob](#options-nullglob).
+
+### options.nullglob
+
+If `true`, when no matches are found the actual (arrayified) glob pattern is returned instead of an empty array. Same behavior as [minimatch](https://github.com/isaacs/minimatch) option `nonull`.
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+### options.onIgnore
+
+```js
+const onIgnore = ({ glob, regex, input, output }) => {
+ console.log({ glob, regex, input, output });
+ // { glob: '*', regex: /^(?:(?!\.)(?=.)[^\/]*?\/?)$/, input: 'foo', output: 'foo' }
+};
+
+const isMatch = micromatch.matcher('*', { onIgnore, ignore: 'f*' });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+### options.onMatch
+
+```js
+const onMatch = ({ glob, regex, input, output }) => {
+ console.log({ input, output });
+ // { input: 'some\\path', output: 'some/path' }
+ // { input: 'some\\path', output: 'some/path' }
+ // { input: 'some\\path', output: 'some/path' }
+};
+
+const isMatch = micromatch.matcher('**', { onMatch, posixSlashes: true });
+isMatch('some\\path');
+isMatch('some\\path');
+isMatch('some\\path');
+```
+
+### options.onResult
+
+```js
+const onResult = ({ glob, regex, input, output }) => {
+ console.log({ glob, regex, input, output });
+};
+
+const isMatch = micromatch('*', { onResult, ignore: 'f*' });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+### options.posixSlashes
+
+Convert path separators on returned files to posix/unix-style forward slashes. Aliased as `unixify` for backwards compatibility.
+
+**Type**: `Boolean`
+
+**Default**: `true` on windows, `false` everywhere else.
+
+**Example**
+
+```js
+console.log(micromatch.match(['a\\b\\c'], 'a/**'));
+//=> ['a/b/c']
+
+console.log(micromatch.match(['a\\b\\c'], { posixSlashes: false }));
+//=> ['a\\b\\c']
+```
+
+### options.unescape
+
+Remove backslashes from escaped glob characters before creating the regular expression to perform matches.
+
+**Type**: `Boolean`
+
+**Default**: `undefined`
+
+**Example**
+
+In this example we want to match a literal `*`:
+
+```js
+console.log(micromatch.match(['abc', 'a\\*c'], 'a\\*c'));
+//=> ['a\\*c']
+
+console.log(micromatch.match(['abc', 'a\\*c'], 'a\\*c', { unescape: true }));
+//=> ['a*c']
+```
+
+<br>
+<br>
+
+## Extended globbing
+
+Micromatch supports the following extended globbing features.
+
+### Extglobs
+
+Extended globbing, as described by the bash man page:
+
+| **pattern** | **regex equivalent** | **description** |
+| --- | --- | --- |
+| `?(pattern)` | `(pattern)?` | Matches zero or one occurrence of the given patterns |
+| `*(pattern)` | `(pattern)*` | Matches zero or more occurrences of the given patterns |
+| `+(pattern)` | `(pattern)+` | Matches one or more occurrences of the given patterns |
+| `@(pattern)` | `(pattern)` <sup>*</sup> | Matches one of the given patterns |
+| `!(pattern)` | N/A (equivalent regex is much more complicated) | Matches anything except one of the given patterns |
+
+<sup><strong>*</strong></sup> Note that `@` isn't a regex character.
+
+### Braces
+
+Brace patterns can be used to match specific ranges or sets of characters.
+
+**Example**
+
+The pattern `{f,b}*/{1..3}/{b,q}*` would match any of following strings:
+
+```
+foo/1/bar
+foo/2/bar
+foo/3/bar
+baz/1/qux
+baz/2/qux
+baz/3/qux
+```
+
+Visit [braces](https://github.com/micromatch/braces) to see the full range of features and options related to brace expansion, or to create brace matching or expansion related issues.
+
+### Regex character classes
+
+Given the list: `['a.js', 'b.js', 'c.js', 'd.js', 'E.js']`:
+
+* `[ac].js`: matches both `a` and `c`, returning `['a.js', 'c.js']`
+* `[b-d].js`: matches from `b` to `d`, returning `['b.js', 'c.js', 'd.js']`
+* `[b-d].js`: matches from `b` to `d`, returning `['b.js', 'c.js', 'd.js']`
+* `a/[A-Z].js`: matches and uppercase letter, returning `['a/E.md']`
+
+Learn about [regex character classes](http://www.regular-expressions.info/charclass.html).
+
+### Regex groups
+
+Given `['a.js', 'b.js', 'c.js', 'd.js', 'E.js']`:
+
+* `(a|c).js`: would match either `a` or `c`, returning `['a.js', 'c.js']`
+* `(b|d).js`: would match either `b` or `d`, returning `['b.js', 'd.js']`
+* `(b|[A-Z]).js`: would match either `b` or an uppercase letter, returning `['b.js', 'E.js']`
+
+As with regex, parens can be nested, so patterns like `((a|b)|c)/b` will work. Although brace expansion might be friendlier to use, depending on preference.
+
+### POSIX bracket expressions
+
+POSIX brackets are intended to be more user-friendly than regex character classes. This of course is in the eye of the beholder.
+
+**Example**
+
+```js
+console.log(micromatch.isMatch('a1', '[[:alpha:][:digit:]]')) //=> true
+console.log(micromatch.isMatch('a1', '[[:alpha:][:alpha:]]')) //=> false
+```
+
+***
+
+## Notes
+
+### Bash 4.3 parity
+
+Whenever possible matching behavior is based on behavior Bash 4.3, which is mostly consistent with minimatch.
+
+However, it's suprising how many edge cases and rabbit holes there are with glob matching, and since there is no real glob specification, and micromatch is more accurate than both Bash and minimatch, there are cases where best-guesses were made for behavior. In a few cases where Bash had no answers, we used wildmatch (used by git) as a fallback.
+
+### Backslashes
+
+There is an important, notable difference between minimatch and micromatch _in regards to how backslashes are handled_ in glob patterns.
+
+* Micromatch exclusively and explicitly reserves backslashes for escaping characters in a glob pattern, even on windows, which is consistent with bash behavior. _More importantly, unescaping globs can result in unsafe regular expressions_.
+* Minimatch converts all backslashes to forward slashes, which means you can't use backslashes to escape any characters in your glob patterns.
+
+We made this decision for micromatch for a couple of reasons:
+
+* Consistency with bash conventions.
+* Glob patterns are not filepaths. They are a type of [regular language](https://en.wikipedia.org/wiki/Regular_language) that is converted to a JavaScript regular expression. Thus, when forward slashes are defined in a glob pattern, the resulting regular expression will match windows or POSIX path separators just fine.
+
+**A note about joining paths to globs**
+
+Note that when you pass something like `path.join('foo', '*')` to micromatch, you are creating a filepath and expecting it to still work as a glob pattern. This causes problems on windows, since the `path.sep` is `\\`.
+
+In other words, since `\\` is reserved as an escape character in globs, on windows `path.join('foo', '*')` would result in `foo\\*`, which tells micromatch to match `*` as a literal character. This is the same behavior as bash.
+
+To solve this, you might be inspired to do something like `'foo\\*'.replace(/\\/g, '/')`, but this causes another, potentially much more serious, problem.
+
+## Benchmarks
+
+### Running benchmarks
+
+Install dependencies for running benchmarks:
+
+```sh
+$ cd bench && npm install
+```
+
+Run the benchmarks:
+
+```sh
+$ npm run bench
+```
+
+### Latest results
+
+As of April 10, 2019 (longer bars are better):
+
+```sh
+# .makeRe star
+ micromatch x 1,724,735 ops/sec ±1.69% (87 runs sampled))
+ minimatch x 649,565 ops/sec ±1.93% (91 runs sampled)
+
+# .makeRe star; dot=true
+ micromatch x 1,302,127 ops/sec ±1.43% (92 runs sampled)
+ minimatch x 556,242 ops/sec ±0.71% (86 runs sampled)
+
+# .makeRe globstar
+ micromatch x 1,393,992 ops/sec ±0.71% (89 runs sampled)
+ minimatch x 1,112,801 ops/sec ±2.02% (91 runs sampled)
+
+# .makeRe globstars
+ micromatch x 1,419,097 ops/sec ±0.34% (94 runs sampled)
+ minimatch x 541,207 ops/sec ±1.66% (93 runs sampled)
+
+# .makeRe with leading star
+ micromatch x 1,247,825 ops/sec ±0.97% (94 runs sampled)
+ minimatch x 489,660 ops/sec ±0.63% (94 runs sampled)
+
+# .makeRe - braces
+ micromatch x 206,301 ops/sec ±1.62% (81 runs sampled))
+ minimatch x 115,986 ops/sec ±0.59% (94 runs sampled)
+
+# .makeRe braces - range (expanded)
+ micromatch x 27,782 ops/sec ±0.79% (88 runs sampled)
+ minimatch x 4,683 ops/sec ±1.20% (92 runs sampled)
+
+# .makeRe braces - range (compiled)
+ micromatch x 134,056 ops/sec ±2.73% (77 runs sampled))
+ minimatch x 977 ops/sec ±0.85% (91 runs sampled)d)
+
+# .makeRe braces - nested ranges (expanded)
+ micromatch x 18,353 ops/sec ±0.95% (91 runs sampled)
+ minimatch x 4,514 ops/sec ±1.04% (93 runs sampled)
+
+# .makeRe braces - nested ranges (compiled)
+ micromatch x 38,916 ops/sec ±1.85% (82 runs sampled)
+ minimatch x 980 ops/sec ±0.54% (93 runs sampled)d)
+
+# .makeRe braces - set (compiled)
+ micromatch x 141,088 ops/sec ±1.70% (70 runs sampled))
+ minimatch x 43,385 ops/sec ±0.87% (93 runs sampled)
+
+# .makeRe braces - nested sets (compiled)
+ micromatch x 87,272 ops/sec ±2.85% (71 runs sampled))
+ minimatch x 25,327 ops/sec ±1.59% (86 runs sampled)
+```
+
+## Contributing
+
+All contributions are welcome! Please read [the contributing guide](.github/contributing.md) to get started.
+
+**Bug reports**
+
+Please create an issue if you encounter a bug or matching behavior that doesn't seem correct. If you find a matching-related issue, please:
+
+* [research existing issues first](../../issues) (open and closed)
+* visit the [GNU Bash documentation](https://www.gnu.org/software/bash/manual/) to see how Bash deals with the pattern
+* visit the [minimatch](https://github.com/isaacs/minimatch) documentation to cross-check expected behavior in node.js
+* if all else fails, since there is no real specification for globs we will probably need to discuss expected behavior and decide how to resolve it. which means any detail you can provide to help with this discussion would be greatly appreciated.
+
+**Platform issues**
+
+It's important to us that micromatch work consistently on all platforms. If you encounter any platform-specific matching or path related issues, please let us know (pull requests are also greatly appreciated).
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [braces](https://www.npmjs.com/package/braces): Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support… [more](https://github.com/micromatch/braces) | [homepage](https://github.com/micromatch/braces "Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.")
+* [expand-brackets](https://www.npmjs.com/package/expand-brackets): Expand POSIX bracket expressions (character classes) in glob patterns. | [homepage](https://github.com/micromatch/expand-brackets "Expand POSIX bracket expressions (character classes) in glob patterns.")
+* [extglob](https://www.npmjs.com/package/extglob): Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob… [more](https://github.com/micromatch/extglob) | [homepage](https://github.com/micromatch/extglob "Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob patterns.")
+* [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or `step` to… [more](https://github.com/jonschlinkert/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`")
+* [nanomatch](https://www.npmjs.com/package/nanomatch): Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash… [more](https://github.com/micromatch/nanomatch) | [homepage](https://github.com/micromatch/nanomatch "Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)")
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 475 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 12 | [es128](https://github.com/es128) |
+| 8 | [doowb](https://github.com/doowb) |
+| 3 | [paulmillr](https://github.com/paulmillr) |
+| 2 | [TrySound](https://github.com/TrySound) |
+| 2 | [MartinKolarik](https://github.com/MartinKolarik) |
+| 2 | [Tvrqvoise](https://github.com/Tvrqvoise) |
+| 2 | [tunnckoCore](https://github.com/tunnckoCore) |
+| 1 | [amilajack](https://github.com/amilajack) |
+| 1 | [mrmlnc](https://github.com/mrmlnc) |
+| 1 | [devongovett](https://github.com/devongovett) |
+| 1 | [DianeLooney](https://github.com/DianeLooney) |
+| 1 | [UltCombo](https://github.com/UltCombo) |
+| 1 | [tomByrer](https://github.com/tomByrer) |
+| 1 | [fidian](https://github.com/fidian) |
+| 1 | [simlu](https://github.com/simlu) |
+| 1 | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 10, 2019._
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/micromatch/index.js b/node_modules/imagemin/node_modules/micromatch/index.js
new file mode 100644
index 0000000..1d5b3d1
--- /dev/null
+++ b/node_modules/imagemin/node_modules/micromatch/index.js
@@ -0,0 +1,467 @@
+'use strict';
+
+const util = require('util');
+const braces = require('braces');
+const picomatch = require('picomatch');
+const utils = require('picomatch/lib/utils');
+const isEmptyString = val => typeof val === 'string' && (val === '' || val === './');
+
+/**
+ * Returns an array of strings that match one or more glob patterns.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm(list, patterns[, options]);
+ *
+ * console.log(mm(['a.js', 'a.txt'], ['*.js']));
+ * //=> [ 'a.js' ]
+ * ```
+ * @param {String|Array<string>} list List of strings to match.
+ * @param {String|Array<string>} patterns One or more glob patterns to use for matching.
+ * @param {Object} options See available [options](#options)
+ * @return {Array} Returns an array of matches
+ * @summary false
+ * @api public
+ */
+
+const micromatch = (list, patterns, options) => {
+ patterns = [].concat(patterns);
+ list = [].concat(list);
+
+ let omit = new Set();
+ let keep = new Set();
+ let items = new Set();
+ let negatives = 0;
+
+ let onResult = state => {
+ items.add(state.output);
+ if (options && options.onResult) {
+ options.onResult(state);
+ }
+ };
+
+ for (let i = 0; i < patterns.length; i++) {
+ let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);
+ let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+ if (negated) negatives++;
+
+ for (let item of list) {
+ let matched = isMatch(item, true);
+
+ let match = negated ? !matched.isMatch : matched.isMatch;
+ if (!match) continue;
+
+ if (negated) {
+ omit.add(matched.output);
+ } else {
+ omit.delete(matched.output);
+ keep.add(matched.output);
+ }
+ }
+ }
+
+ let result = negatives === patterns.length ? [...items] : [...keep];
+ let matches = result.filter(item => !omit.has(item));
+
+ if (options && matches.length === 0) {
+ if (options.failglob === true) {
+ throw new Error(`No matches found for "${patterns.join(', ')}"`);
+ }
+
+ if (options.nonull === true || options.nullglob === true) {
+ return options.unescape ? patterns.map(p => p.replace(/\\/g, '')) : patterns;
+ }
+ }
+
+ return matches;
+};
+
+/**
+ * Backwards compatibility
+ */
+
+micromatch.match = micromatch;
+
+/**
+ * Returns a matcher function from the given glob `pattern` and `options`.
+ * The returned function takes a string to match as its only argument and returns
+ * true if the string is a match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matcher(pattern[, options]);
+ *
+ * const isMatch = mm.matcher('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @param {String} `pattern` Glob pattern
+ * @param {Object} `options`
+ * @return {Function} Returns a matcher function.
+ * @api public
+ */
+
+micromatch.matcher = (pattern, options) => picomatch(pattern, options);
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.isMatch(string, patterns[, options]);
+ *
+ * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(mm.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String} str The string to test.
+ * @param {String|Array} patterns One or more glob patterns to use for matching.
+ * @param {Object} [options] See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+/**
+ * Backwards compatibility
+ */
+
+micromatch.any = micromatch.isMatch;
+
+/**
+ * Returns a list of strings that _**do not match any**_ of the given `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.not(list, patterns[, options]);
+ *
+ * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));
+ * //=> ['b.b', 'c.c']
+ * ```
+ * @param {Array} `list` Array of strings to match.
+ * @param {String|Array} `patterns` One or more glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array} Returns an array of strings that **do not match** the given patterns.
+ * @api public
+ */
+
+micromatch.not = (list, patterns, options = {}) => {
+ patterns = [].concat(patterns).map(String);
+ let result = new Set();
+ let items = [];
+
+ let onResult = state => {
+ if (options.onResult) options.onResult(state);
+ items.push(state.output);
+ };
+
+ let matches = micromatch(list, patterns, { ...options, onResult });
+
+ for (let item of items) {
+ if (!matches.includes(item)) {
+ result.add(item);
+ }
+ }
+ return [...result];
+};
+
+/**
+ * Returns true if the given `string` contains the given pattern. Similar
+ * to [.isMatch](#isMatch) but the pattern can match any part of the string.
+ *
+ * ```js
+ * var mm = require('micromatch');
+ * // mm.contains(string, pattern[, options]);
+ *
+ * console.log(mm.contains('aa/bb/cc', '*b'));
+ * //=> true
+ * console.log(mm.contains('aa/bb/cc', '*d'));
+ * //=> false
+ * ```
+ * @param {String} `str` The string to match.
+ * @param {String|Array} `patterns` Glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if the patter matches any part of `str`.
+ * @api public
+ */
+
+micromatch.contains = (str, pattern, options) => {
+ if (typeof str !== 'string') {
+ throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+ }
+
+ if (Array.isArray(pattern)) {
+ return pattern.some(p => micromatch.contains(str, p, options));
+ }
+
+ if (typeof pattern === 'string') {
+ if (isEmptyString(str) || isEmptyString(pattern)) {
+ return false;
+ }
+
+ if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) {
+ return true;
+ }
+ }
+
+ return micromatch.isMatch(str, pattern, { ...options, contains: true });
+};
+
+/**
+ * Filter the keys of the given object with the given `glob` pattern
+ * and `options`. Does not attempt to match nested keys. If you need this feature,
+ * use [glob-object][] instead.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matchKeys(object, patterns[, options]);
+ *
+ * const obj = { aa: 'a', ab: 'b', ac: 'c' };
+ * console.log(mm.matchKeys(obj, '*b'));
+ * //=> { ab: 'b' }
+ * ```
+ * @param {Object} `object` The object with keys to filter.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Object} Returns an object with only keys that match the given patterns.
+ * @api public
+ */
+
+micromatch.matchKeys = (obj, patterns, options) => {
+ if (!utils.isObject(obj)) {
+ throw new TypeError('Expected the first argument to be an object');
+ }
+ let keys = micromatch(Object.keys(obj), patterns, options);
+ let res = {};
+ for (let key of keys) res[key] = obj[key];
+ return res;
+};
+
+/**
+ * Returns true if some of the strings in the given `list` match any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.some(list, patterns[, options]);
+ *
+ * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // true
+ * console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch.some = (list, patterns, options) => {
+ let items = [].concat(list);
+
+ for (let pattern of [].concat(patterns)) {
+ let isMatch = picomatch(String(pattern), options);
+ if (items.some(item => isMatch(item))) {
+ return true;
+ }
+ }
+ return false;
+};
+
+/**
+ * Returns true if every string in the given `list` matches
+ * any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.every(list, patterns[, options]);
+ *
+ * console.log(mm.every('foo.js', ['foo.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // false
+ * console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch.every = (list, patterns, options) => {
+ let items = [].concat(list);
+
+ for (let pattern of [].concat(patterns)) {
+ let isMatch = picomatch(String(pattern), options);
+ if (!items.every(item => isMatch(item))) {
+ return false;
+ }
+ }
+ return true;
+};
+
+/**
+ * Returns true if **all** of the given `patterns` match
+ * the specified string.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.all(string, patterns[, options]);
+ *
+ * console.log(mm.all('foo.js', ['foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', '!foo.js']));
+ * // false
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
+ * // true
+ * ```
+ * @param {String|Array} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch.all = (str, patterns, options) => {
+ if (typeof str !== 'string') {
+ throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+ }
+
+ return [].concat(patterns).every(p => picomatch(p, options)(str));
+};
+
+/**
+ * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.capture(pattern, string[, options]);
+ *
+ * console.log(mm.capture('test/*.js', 'test/foo.js'));
+ * //=> ['foo']
+ * console.log(mm.capture('test/*.js', 'foo/bar.css'));
+ * //=> null
+ * ```
+ * @param {String} `glob` Glob pattern to use for matching.
+ * @param {String} `input` String to match
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns an array of captures if the input matches the glob pattern, otherwise `null`.
+ * @api public
+ */
+
+micromatch.capture = (glob, input, options) => {
+ let posix = utils.isWindows(options);
+ let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
+ let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
+
+ if (match) {
+ return match.slice(1).map(v => v === void 0 ? '' : v);
+ }
+};
+
+/**
+ * Create a regular expression from the given glob `pattern`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.makeRe(pattern[, options]);
+ *
+ * console.log(mm.makeRe('*.js'));
+ * //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
+ * ```
+ * @param {String} `pattern` A glob pattern to convert to regex.
+ * @param {Object} `options`
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+micromatch.makeRe = (...args) => picomatch.makeRe(...args);
+
+/**
+ * Scan a glob pattern to separate the pattern into segments. Used
+ * by the [split](#split) method.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm.scan(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+micromatch.scan = (...args) => picomatch.scan(...args);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm(pattern[, options]);
+ * ```
+ * @param {String} `glob`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as regex source string.
+ * @api public
+ */
+
+micromatch.parse = (patterns, options) => {
+ let res = [];
+ for (let pattern of [].concat(patterns || [])) {
+ for (let str of braces(String(pattern), options)) {
+ res.push(picomatch.parse(str, options));
+ }
+ }
+ return res;
+};
+
+/**
+ * Process the given brace `pattern`.
+ *
+ * ```js
+ * const { braces } = require('micromatch');
+ * console.log(braces('foo/{a,b,c}/bar'));
+ * //=> [ 'foo/(a|b|c)/bar' ]
+ *
+ * console.log(braces('foo/{a,b,c}/bar', { expand: true }));
+ * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]
+ * ```
+ * @param {String} `pattern` String with brace pattern to process.
+ * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.
+ * @return {Array}
+ * @api public
+ */
+
+micromatch.braces = (pattern, options) => {
+ if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+ if ((options && options.nobrace === true) || !/\{.*\}/.test(pattern)) {
+ return [pattern];
+ }
+ return braces(pattern, options);
+};
+
+/**
+ * Expand braces
+ */
+
+micromatch.braceExpand = (pattern, options) => {
+ if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+ return micromatch.braces(pattern, { ...options, expand: true });
+};
+
+/**
+ * Expose micromatch
+ */
+
+module.exports = micromatch;
diff --git a/node_modules/imagemin/node_modules/micromatch/package.json b/node_modules/imagemin/node_modules/micromatch/package.json
new file mode 100644
index 0000000..4f68fad
--- /dev/null
+++ b/node_modules/imagemin/node_modules/micromatch/package.json
@@ -0,0 +1,191 @@
+{
+ "_from": "micromatch@^4.0.2",
+ "_id": "micromatch@4.0.2",
+ "_inBundle": false,
+ "_integrity": "sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==",
+ "_location": "/imagemin/micromatch",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "micromatch@^4.0.2",
+ "name": "micromatch",
+ "escapedName": "micromatch",
+ "rawSpec": "^4.0.2",
+ "saveSpec": null,
+ "fetchSpec": "^4.0.2"
+ },
+ "_requiredBy": [
+ "/imagemin/fast-glob"
+ ],
+ "_resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.2.tgz",
+ "_shasum": "4fcb0999bf9fbc2fcbdd212f6d629b9a56c39259",
+ "_spec": "micromatch@^4.0.2",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\fast-glob",
+ "author": {
+ "name": "Jon Schlinkert",
+ "url": "https://github.com/jonschlinkert"
+ },
+ "bugs": {
+ "url": "https://github.com/micromatch/micromatch/issues"
+ },
+ "bundleDependencies": false,
+ "contributors": [
+ {
+ "url": "https://github.com/DianeLooney"
+ },
+ {
+ "name": "Amila Welihinda",
+ "url": "amilajack.com"
+ },
+ {
+ "name": "Bogdan Chadkin",
+ "url": "https://github.com/TrySound"
+ },
+ {
+ "name": "Brian Woodward",
+ "url": "https://twitter.com/doowb"
+ },
+ {
+ "name": "Devon Govett",
+ "url": "http://badassjs.com"
+ },
+ {
+ "name": "Elan Shanker",
+ "url": "https://github.com/es128"
+ },
+ {
+ "name": "Fabrício Matté",
+ "url": "https://ultcombo.js.org"
+ },
+ {
+ "name": "Jon Schlinkert",
+ "url": "http://twitter.com/jonschlinkert"
+ },
+ {
+ "name": "Martin Kolárik",
+ "url": "https://kolarik.sk"
+ },
+ {
+ "name": "Olsten Larck",
+ "url": "https://i.am.charlike.online"
+ },
+ {
+ "name": "Paul Miller",
+ "url": "paulmillr.com"
+ },
+ {
+ "name": "Tom Byrer",
+ "url": "https://github.com/tomByrer"
+ },
+ {
+ "name": "Tyler Akins",
+ "url": "http://rumkin.com"
+ },
+ {
+ "name": "Peter Bright",
+ "email": "drpizza@quiscalusmexicanus.org",
+ "url": "https://github.com/drpizza"
+ }
+ ],
+ "dependencies": {
+ "braces": "^3.0.1",
+ "picomatch": "^2.0.5"
+ },
+ "deprecated": false,
+ "description": "Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch.",
+ "devDependencies": {
+ "fill-range": "^7.0.1",
+ "gulp-format-md": "^2.0.0",
+ "minimatch": "^3.0.4",
+ "mocha": "^5.2.0",
+ "time-require": "github:jonschlinkert/time-require"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js"
+ ],
+ "homepage": "https://github.com/micromatch/micromatch",
+ "keywords": [
+ "bash",
+ "bracket",
+ "character-class",
+ "expand",
+ "expansion",
+ "expression",
+ "extglob",
+ "extglobs",
+ "file",
+ "files",
+ "filter",
+ "find",
+ "glob",
+ "globbing",
+ "globs",
+ "globstar",
+ "lookahead",
+ "lookaround",
+ "lookbehind",
+ "match",
+ "matcher",
+ "matches",
+ "matching",
+ "micromatch",
+ "minimatch",
+ "multimatch",
+ "negate",
+ "negation",
+ "path",
+ "pattern",
+ "patterns",
+ "posix",
+ "regex",
+ "regexp",
+ "regular",
+ "shell",
+ "star",
+ "wildcard"
+ ],
+ "license": "MIT",
+ "main": "index.js",
+ "name": "micromatch",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/micromatch/micromatch.git"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "verb": {
+ "toc": "collapsible",
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "lint": {
+ "reflinks": true
+ },
+ "related": {
+ "list": [
+ "braces",
+ "expand-brackets",
+ "extglob",
+ "fill-range",
+ "nanomatch"
+ ]
+ },
+ "reflinks": [
+ "extglob",
+ "fill-range",
+ "glob-object",
+ "minimatch",
+ "multimatch"
+ ]
+ },
+ "version": "4.0.2"
+}
diff --git a/node_modules/imagemin/node_modules/p-pipe/index.d.ts b/node_modules/imagemin/node_modules/p-pipe/index.d.ts
new file mode 100644
index 0000000..36cf14f
--- /dev/null
+++ b/node_modules/imagemin/node_modules/p-pipe/index.d.ts
@@ -0,0 +1,152 @@
+declare namespace pPipe {
+ type UnaryFunction<ValueType, ReturnType> = (
+ value: ValueType
+ ) => ReturnType | PromiseLike<ReturnType>;
+
+ type Pipeline<ValueType, ReturnType> = (
+ value?: ValueType
+ ) => Promise<ReturnType>;
+}
+
+/**
+Compose promise-returning & async functions into a reusable pipeline.
+
+@param ...input - Iterated over sequentially when returned `function` is called.
+@returns The `input` functions are applied from left to right.
+
+@example
+```
+import pPipe = require('p-pipe');
+
+const addUnicorn = async string => `${string} Unicorn`;
+const addRainbow = async string => `${string} Rainbow`;
+
+const pipeline = pPipe(addUnicorn, addRainbow);
+
+(async () => {
+ console.log(await pipeline('❤️'));
+ //=> '❤️ Unicorn Rainbow'
+})();
+```
+*/
+declare function pPipe<ValueType, ReturnType>(
+ f1: pPipe.UnaryFunction<ValueType, ReturnType>
+): pPipe.Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ReturnType>(
+ f1: pPipe.UnaryFunction<ValueType, ResultValue1>,
+ f2: pPipe.UnaryFunction<ResultValue1, ReturnType>
+): pPipe.Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ResultValue2, ReturnType>(
+ f1: pPipe.UnaryFunction<ValueType, ResultValue1>,
+ f2: pPipe.UnaryFunction<ResultValue1, ResultValue2>,
+ f3: pPipe.UnaryFunction<ResultValue2, ReturnType>
+): pPipe.Pipeline<ValueType, ReturnType>;
+declare function pPipe<
+ ValueType,
+ ResultValue1,
+ ResultValue2,
+ ResultValue3,
+ ReturnType
+>(
+ f1: pPipe.UnaryFunction<ValueType, ResultValue1>,
+ f2: pPipe.UnaryFunction<ResultValue1, ResultValue2>,
+ f3: pPipe.UnaryFunction<ResultValue2, ResultValue3>,
+ f4: pPipe.UnaryFunction<ResultValue3, ReturnType>
+): pPipe.Pipeline<ValueType, ReturnType>;
+declare function pPipe<
+ ValueType,
+ ResultValue1,
+ ResultValue2,
+ ResultValue3,
+ ResultValue4,
+ ReturnType
+>(
+ f1: pPipe.UnaryFunction<ValueType, ResultValue1>,
+ f2: pPipe.UnaryFunction<ResultValue1, ResultValue2>,
+ f3: pPipe.UnaryFunction<ResultValue2, ResultValue3>,
+ f4: pPipe.UnaryFunction<ResultValue3, ResultValue4>,
+ f5: pPipe.UnaryFunction<ResultValue4, ReturnType>
+): pPipe.Pipeline<ValueType, ReturnType>;
+declare function pPipe<
+ ValueType,
+ ResultValue1,
+ ResultValue2,
+ ResultValue3,
+ ResultValue4,
+ ResultValue5,
+ ReturnType
+>(
+ f1: pPipe.UnaryFunction<ValueType, ResultValue1>,
+ f2: pPipe.UnaryFunction<ResultValue1, ResultValue2>,
+ f3: pPipe.UnaryFunction<ResultValue2, ResultValue3>,
+ f4: pPipe.UnaryFunction<ResultValue3, ResultValue4>,
+ f5: pPipe.UnaryFunction<ResultValue4, ResultValue5>,
+ f6: pPipe.UnaryFunction<ResultValue5, ReturnType>
+): pPipe.Pipeline<ValueType, ReturnType>;
+declare function pPipe<
+ ValueType,
+ ResultValue1,
+ ResultValue2,
+ ResultValue3,
+ ResultValue4,
+ ResultValue5,
+ ResultValue6,
+ ReturnType
+>(
+ f1: pPipe.UnaryFunction<ValueType, ResultValue1>,
+ f2: pPipe.UnaryFunction<ResultValue1, ResultValue2>,
+ f3: pPipe.UnaryFunction<ResultValue2, ResultValue3>,
+ f4: pPipe.UnaryFunction<ResultValue3, ResultValue4>,
+ f5: pPipe.UnaryFunction<ResultValue4, ResultValue5>,
+ f6: pPipe.UnaryFunction<ResultValue5, ResultValue6>,
+ f7: pPipe.UnaryFunction<ResultValue6, ReturnType>
+): pPipe.Pipeline<ValueType, ReturnType>;
+declare function pPipe<
+ ValueType,
+ ResultValue1,
+ ResultValue2,
+ ResultValue3,
+ ResultValue4,
+ ResultValue5,
+ ResultValue6,
+ ResultValue7,
+ ReturnType
+>(
+ f1: pPipe.UnaryFunction<ValueType, ResultValue1>,
+ f2: pPipe.UnaryFunction<ResultValue1, ResultValue2>,
+ f3: pPipe.UnaryFunction<ResultValue2, ResultValue3>,
+ f4: pPipe.UnaryFunction<ResultValue3, ResultValue4>,
+ f5: pPipe.UnaryFunction<ResultValue4, ResultValue5>,
+ f6: pPipe.UnaryFunction<ResultValue5, ResultValue6>,
+ f7: pPipe.UnaryFunction<ResultValue6, ResultValue7>,
+ f8: pPipe.UnaryFunction<ResultValue7, ReturnType>
+): pPipe.Pipeline<ValueType, ReturnType>;
+declare function pPipe<
+ ValueType,
+ ResultValue1,
+ ResultValue2,
+ ResultValue3,
+ ResultValue4,
+ ResultValue5,
+ ResultValue6,
+ ResultValue7,
+ ResultValue8,
+ ReturnType
+>(
+ f1: pPipe.UnaryFunction<ValueType, ResultValue1>,
+ f2: pPipe.UnaryFunction<ResultValue1, ResultValue2>,
+ f3: pPipe.UnaryFunction<ResultValue2, ResultValue3>,
+ f4: pPipe.UnaryFunction<ResultValue3, ResultValue4>,
+ f5: pPipe.UnaryFunction<ResultValue4, ResultValue5>,
+ f6: pPipe.UnaryFunction<ResultValue5, ResultValue6>,
+ f7: pPipe.UnaryFunction<ResultValue6, ResultValue7>,
+ f8: pPipe.UnaryFunction<ResultValue7, ResultValue8>,
+ f9: pPipe.UnaryFunction<ResultValue8, ReturnType>
+): pPipe.Pipeline<ValueType, ReturnType>;
+
+// Fallbacks if more than 9 functions are passed as input (not type-safe).
+declare function pPipe(
+ ...functions: (pPipe.UnaryFunction<any, unknown>)[]
+): pPipe.Pipeline<unknown, unknown>;
+
+export = pPipe;
diff --git a/node_modules/imagemin/node_modules/p-pipe/index.js b/node_modules/imagemin/node_modules/p-pipe/index.js
new file mode 100644
index 0000000..e6154bd
--- /dev/null
+++ b/node_modules/imagemin/node_modules/p-pipe/index.js
@@ -0,0 +1,17 @@
+'use strict';
+
+module.exports = (...functions) => {
+ if (functions.length === 0) {
+ throw new Error('Expected at least one argument');
+ }
+
+ return async input => {
+ let currentValue = input;
+
+ for (const fn of functions) {
+ currentValue = await fn(currentValue); // eslint-disable-line no-await-in-loop
+ }
+
+ return currentValue;
+ };
+};
diff --git a/node_modules/imagemin/node_modules/p-pipe/license b/node_modules/imagemin/node_modules/p-pipe/license
new file mode 100644
index 0000000..fa7ceba
--- /dev/null
+++ b/node_modules/imagemin/node_modules/p-pipe/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/p-pipe/package.json b/node_modules/imagemin/node_modules/p-pipe/package.json
new file mode 100644
index 0000000..036afaf
--- /dev/null
+++ b/node_modules/imagemin/node_modules/p-pipe/package.json
@@ -0,0 +1,77 @@
+{
+ "_from": "p-pipe@^3.0.0",
+ "_id": "p-pipe@3.1.0",
+ "_inBundle": false,
+ "_integrity": "sha512-08pj8ATpzMR0Y80x50yJHn37NF6vjrqHutASaX5LiH5npS9XPvrUmscd9MF5R4fuYRHOxQR1FfMIlF7AzwoPqw==",
+ "_location": "/imagemin/p-pipe",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "p-pipe@^3.0.0",
+ "name": "p-pipe",
+ "escapedName": "p-pipe",
+ "rawSpec": "^3.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^3.0.0"
+ },
+ "_requiredBy": [
+ "/imagemin"
+ ],
+ "_resolved": "https://registry.npmjs.org/p-pipe/-/p-pipe-3.1.0.tgz",
+ "_shasum": "48b57c922aa2e1af6a6404cb7c6bf0eb9cc8e60e",
+ "_spec": "p-pipe@^3.0.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "https://sindresorhus.com"
+ },
+ "bugs": {
+ "url": "https://github.com/sindresorhus/p-pipe/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Compose promise-returning & async functions into a reusable pipeline",
+ "devDependencies": {
+ "ava": "^1.4.1",
+ "sinon": "^7.3.1",
+ "tsd": "^0.7.2",
+ "xo": "^0.24.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js",
+ "index.d.ts"
+ ],
+ "funding": "https://github.com/sponsors/sindresorhus",
+ "homepage": "https://github.com/sindresorhus/p-pipe#readme",
+ "keywords": [
+ "promise",
+ "pipe",
+ "pipeline",
+ "compose",
+ "composition",
+ "combine",
+ "flow",
+ "serial",
+ "functions",
+ "reusable",
+ "async",
+ "await",
+ "promises",
+ "bluebird"
+ ],
+ "license": "MIT",
+ "name": "p-pipe",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/sindresorhus/p-pipe.git"
+ },
+ "scripts": {
+ "test": "xo && ava && tsd"
+ },
+ "version": "3.1.0"
+}
diff --git a/node_modules/imagemin/node_modules/p-pipe/readme.md b/node_modules/imagemin/node_modules/p-pipe/readme.md
new file mode 100644
index 0000000..1986aa5
--- /dev/null
+++ b/node_modules/imagemin/node_modules/p-pipe/readme.md
@@ -0,0 +1,56 @@
+# p-pipe [](https://travis-ci.com/sindresorhus/p-pipe)
+
+> Compose promise-returning & async functions into a reusable pipeline
+
+## Install
+
+```
+$ npm install p-pipe
+```
+
+## Usage
+
+```js
+const pPipe = require('p-pipe');
+
+const addUnicorn = async string => `${string} Unicorn`;
+const addRainbow = async string => `${string} Rainbow`;
+
+const pipeline = pPipe(addUnicorn, addRainbow);
+
+(async () => {
+ console.log(await pipeline('❤️'));
+ //=> '❤️ Unicorn Rainbow'
+})();
+```
+
+## API
+
+### pPipe(input…)
+
+The `input` functions are applied from left to right.
+
+#### input
+
+Type: `Function`
+
+Expected to return a `Promise` or any value.
+
+## Related
+
+- [p-each-series](https://github.com/sindresorhus/p-each-series) - Iterate over promises serially
+- [p-series](https://github.com/sindresorhus/p-series) - Run promise-returning & async functions in series
+- [p-waterfall](https://github.com/sindresorhus/p-waterfall) - Run promise-returning & async functions in series, each passing its result to the next
+- [More…](https://github.com/sindresorhus/promise-fun)
+
+---
+
+<div align="center">
+ <b>
+ <a href="https://tidelift.com/subscription/pkg/npm-p-pipe?utm_source=npm-p-pipe&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+ </b>
+ <br>
+ <sub>
+ Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+ </sub>
+</div>
diff --git a/node_modules/imagemin/node_modules/path-type/index.d.ts b/node_modules/imagemin/node_modules/path-type/index.d.ts
new file mode 100644
index 0000000..910a50a
--- /dev/null
+++ b/node_modules/imagemin/node_modules/path-type/index.d.ts
@@ -0,0 +1,51 @@
+export type PathTypeFunction = (path: string) => Promise<boolean>;
+
+/**
+ * Check whether the passed `path` is a file.
+ *
+ * @param path - The path to check.
+ * @returns Whether the `path` is a file.
+ */
+export const isFile: PathTypeFunction;
+
+/**
+ * Check whether the passed `path` is a directory.
+ *
+ * @param path - The path to check.
+ * @returns Whether the `path` is a directory.
+ */
+export const isDirectory: PathTypeFunction;
+
+/**
+ * Check whether the passed `path` is a symlink.
+ *
+ * @param path - The path to check.
+ * @returns Whether the `path` is a symlink.
+ */
+export const isSymlink: PathTypeFunction;
+
+export type PathTypeSyncFunction = (path: string) => boolean;
+
+/**
+ * Synchronously check whether the passed `path` is a file.
+ *
+ * @param path - The path to check.
+ * @returns Whether the `path` is a file.
+ */
+export const isFileSync: PathTypeSyncFunction;
+
+/**
+ * Synchronously check whether the passed `path` is a directory.
+ *
+ * @param path - The path to check.
+ * @returns Whether the `path` is a directory.
+ */
+export const isDirectorySync: PathTypeSyncFunction;
+
+/**
+ * Synchronously check whether the passed `path` is a symlink.
+ *
+ * @param path - The path to check.
+ * @returns Whether the `path` is a directory.
+ */
+export const isSymlinkSync: PathTypeSyncFunction;
diff --git a/node_modules/imagemin/node_modules/path-type/index.js b/node_modules/imagemin/node_modules/path-type/index.js
new file mode 100644
index 0000000..b8f34b2
--- /dev/null
+++ b/node_modules/imagemin/node_modules/path-type/index.js
@@ -0,0 +1,43 @@
+'use strict';
+const {promisify} = require('util');
+const fs = require('fs');
+
+async function isType(fsStatType, statsMethodName, filePath) {
+ if (typeof filePath !== 'string') {
+ throw new TypeError(`Expected a string, got ${typeof filePath}`);
+ }
+
+ try {
+ const stats = await promisify(fs[fsStatType])(filePath);
+ return stats[statsMethodName]();
+ } catch (error) {
+ if (error.code === 'ENOENT') {
+ return false;
+ }
+
+ throw error;
+ }
+}
+
+function isTypeSync(fsStatType, statsMethodName, filePath) {
+ if (typeof filePath !== 'string') {
+ throw new TypeError(`Expected a string, got ${typeof filePath}`);
+ }
+
+ try {
+ return fs[fsStatType](filePath)[statsMethodName]();
+ } catch (error) {
+ if (error.code === 'ENOENT') {
+ return false;
+ }
+
+ throw error;
+ }
+}
+
+exports.isFile = isType.bind(null, 'stat', 'isFile');
+exports.isDirectory = isType.bind(null, 'stat', 'isDirectory');
+exports.isSymlink = isType.bind(null, 'lstat', 'isSymbolicLink');
+exports.isFileSync = isTypeSync.bind(null, 'statSync', 'isFile');
+exports.isDirectorySync = isTypeSync.bind(null, 'statSync', 'isDirectory');
+exports.isSymlinkSync = isTypeSync.bind(null, 'lstatSync', 'isSymbolicLink');
diff --git a/node_modules/imagemin/node_modules/path-type/license b/node_modules/imagemin/node_modules/path-type/license
new file mode 100644
index 0000000..e7af2f7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/path-type/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/path-type/package.json b/node_modules/imagemin/node_modules/path-type/package.json
new file mode 100644
index 0000000..4e4dc75
--- /dev/null
+++ b/node_modules/imagemin/node_modules/path-type/package.json
@@ -0,0 +1,77 @@
+{
+ "_from": "path-type@^4.0.0",
+ "_id": "path-type@4.0.0",
+ "_inBundle": false,
+ "_integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
+ "_location": "/imagemin/path-type",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "path-type@^4.0.0",
+ "name": "path-type",
+ "escapedName": "path-type",
+ "rawSpec": "^4.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^4.0.0"
+ },
+ "_requiredBy": [
+ "/imagemin/dir-glob"
+ ],
+ "_resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
+ "_shasum": "84ed01c0a7ba380afe09d90a8c180dcd9d03043b",
+ "_spec": "path-type@^4.0.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\dir-glob",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "bugs": {
+ "url": "https://github.com/sindresorhus/path-type/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Check if a path is a file, directory, or symlink",
+ "devDependencies": {
+ "ava": "^1.3.1",
+ "nyc": "^13.3.0",
+ "tsd-check": "^0.3.0",
+ "xo": "^0.24.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js",
+ "index.d.ts"
+ ],
+ "homepage": "https://github.com/sindresorhus/path-type#readme",
+ "keywords": [
+ "path",
+ "fs",
+ "type",
+ "is",
+ "check",
+ "directory",
+ "dir",
+ "file",
+ "filepath",
+ "symlink",
+ "symbolic",
+ "link",
+ "stat",
+ "stats",
+ "filesystem"
+ ],
+ "license": "MIT",
+ "name": "path-type",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/sindresorhus/path-type.git"
+ },
+ "scripts": {
+ "test": "xo && nyc ava && tsd-check"
+ },
+ "version": "4.0.0"
+}
diff --git a/node_modules/imagemin/node_modules/path-type/readme.md b/node_modules/imagemin/node_modules/path-type/readme.md
new file mode 100644
index 0000000..4c972fa
--- /dev/null
+++ b/node_modules/imagemin/node_modules/path-type/readme.md
@@ -0,0 +1,72 @@
+# path-type [](https://travis-ci.org/sindresorhus/path-type)
+
+> Check if a path is a file, directory, or symlink
+
+
+## Install
+
+```
+$ npm install path-type
+```
+
+
+## Usage
+
+```js
+const {isFile} = require('path-type');
+
+(async () => {
+ console.log(await isFile('package.json'));
+ //=> true
+})();
+```
+
+
+## API
+
+### isFile(path)
+
+Check whether the passed `path` is a file.
+
+Returns a `Promise<boolean>`.
+
+#### path
+
+Type: `string`
+
+The path to check.
+
+### isDirectory(path)
+
+Check whether the passed `path` is a directory.
+
+Returns a `Promise<boolean>`.
+
+### isSymlink(path)
+
+Check whether the passed `path` is a symlink.
+
+Returns a `Promise<boolean>`.
+
+### isFileSync(path)
+
+Synchronously check whether the passed `path` is a file.
+
+Returns a `boolean`.
+
+### isDirectorySync(path)
+
+Synchronously check whether the passed `path` is a directory.
+
+Returns a `boolean`.
+
+### isSymlinkSync(path)
+
+Synchronously check whether the passed `path` is a symlink.
+
+Returns a `boolean`.
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)
diff --git a/node_modules/imagemin/node_modules/semver/CHANGELOG.md b/node_modules/imagemin/node_modules/semver/CHANGELOG.md
new file mode 100644
index 0000000..f567dd3
--- /dev/null
+++ b/node_modules/imagemin/node_modules/semver/CHANGELOG.md
@@ -0,0 +1,70 @@
+# changes log
+
+## 6.2.0
+
+* Coerce numbers to strings when passed to semver.coerce()
+* Add `rtl` option to coerce from right to left
+
+## 6.1.3
+
+* Handle X-ranges properly in includePrerelease mode
+
+## 6.1.2
+
+* Do not throw when testing invalid version strings
+
+## 6.1.1
+
+* Add options support for semver.coerce()
+* Handle undefined version passed to Range.test
+
+## 6.1.0
+
+* Add semver.compareBuild function
+* Support `*` in semver.intersects
+
+## 6.0
+
+* Fix `intersects` logic.
+
+ This is technically a bug fix, but since it is also a change to behavior
+ that may require users updating their code, it is marked as a major
+ version increment.
+
+## 5.7
+
+* Add `minVersion` method
+
+## 5.6
+
+* Move boolean `loose` param to an options object, with
+ backwards-compatibility protection.
+* Add ability to opt out of special prerelease version handling with
+ the `includePrerelease` option flag.
+
+## 5.5
+
+* Add version coercion capabilities
+
+## 5.4
+
+* Add intersection checking
+
+## 5.3
+
+* Add `minSatisfying` method
+
+## 5.2
+
+* Add `prerelease(v)` that returns prerelease components
+
+## 5.1
+
+* Add Backus-Naur for ranges
+* Remove excessively cute inspection methods
+
+## 5.0
+
+* Remove AMD/Browserified build artifacts
+* Fix ltr and gtr when using the `*` range
+* Fix for range `*` with a prerelease identifier
diff --git a/node_modules/imagemin/node_modules/semver/LICENSE b/node_modules/imagemin/node_modules/semver/LICENSE
new file mode 100644
index 0000000..19129e3
--- /dev/null
+++ b/node_modules/imagemin/node_modules/semver/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/semver/README.md b/node_modules/imagemin/node_modules/semver/README.md
new file mode 100644
index 0000000..2293a14
--- /dev/null
+++ b/node_modules/imagemin/node_modules/semver/README.md
@@ -0,0 +1,443 @@
+semver(1) -- The semantic versioner for npm
+===========================================
+
+## Install
+
+```bash
+npm install semver
+````
+
+## Usage
+
+As a node module:
+
+```js
+const semver = require('semver')
+
+semver.valid('1.2.3') // '1.2.3'
+semver.valid('a.b.c') // null
+semver.clean(' =v1.2.3 ') // '1.2.3'
+semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
+semver.gt('1.2.3', '9.8.7') // false
+semver.lt('1.2.3', '9.8.7') // true
+semver.minVersion('>=1.0.0') // '1.0.0'
+semver.valid(semver.coerce('v2')) // '2.0.0'
+semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
+```
+
+As a command-line utility:
+
+```
+$ semver -h
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+ Print versions that match the specified range.
+
+-i --increment [<level>]
+ Increment a version by the specified level. Level can
+ be one of: major, minor, patch, premajor, preminor,
+ prepatch, or prerelease. Default level is 'patch'.
+ Only one version may be specified.
+
+--preid <identifier>
+ Identifier to be used to prefix premajor, preminor,
+ prepatch or prerelease version increments.
+
+-l --loose
+ Interpret versions and ranges loosely
+
+-p --include-prerelease
+ Always include prerelease versions in range matching
+
+-c --coerce
+ Coerce a string into SemVer if possible
+ (does not imply --loose)
+
+--rtl
+ Coerce version strings right to left
+
+--ltr
+ Coerce version strings left to right (default)
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.
+```
+
+## Versions
+
+A "version" is described by the `v2.0.0` specification found at
+<https://semver.org/>.
+
+A leading `"="` or `"v"` character is stripped off and ignored.
+
+## Ranges
+
+A `version range` is a set of `comparators` which specify versions
+that satisfy the range.
+
+A `comparator` is composed of an `operator` and a `version`. The set
+of primitive `operators` is:
+
+* `<` Less than
+* `<=` Less than or equal to
+* `>` Greater than
+* `>=` Greater than or equal to
+* `=` Equal. If no operator is specified, then equality is assumed,
+ so this operator is optional, but MAY be included.
+
+For example, the comparator `>=1.2.7` would match the versions
+`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
+or `1.1.0`.
+
+Comparators can be joined by whitespace to form a `comparator set`,
+which is satisfied by the **intersection** of all of the comparators
+it includes.
+
+A range is composed of one or more comparator sets, joined by `||`. A
+version matches a range if and only if every comparator in at least
+one of the `||`-separated comparator sets is satisfied by the version.
+
+For example, the range `>=1.2.7 <1.3.0` would match the versions
+`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
+or `1.1.0`.
+
+The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
+`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
+
+### Prerelease Tags
+
+If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
+it will only be allowed to satisfy comparator sets if at least one
+comparator with the same `[major, minor, patch]` tuple also has a
+prerelease tag.
+
+For example, the range `>1.2.3-alpha.3` would be allowed to match the
+version `1.2.3-alpha.7`, but it would *not* be satisfied by
+`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
+than" `1.2.3-alpha.3` according to the SemVer sort rules. The version
+range only accepts prerelease tags on the `1.2.3` version. The
+version `3.4.5` *would* satisfy the range, because it does not have a
+prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
+
+The purpose for this behavior is twofold. First, prerelease versions
+frequently are updated very quickly, and contain many breaking changes
+that are (by the author's design) not yet fit for public consumption.
+Therefore, by default, they are excluded from range matching
+semantics.
+
+Second, a user who has opted into using a prerelease version has
+clearly indicated the intent to use *that specific* set of
+alpha/beta/rc versions. By including a prerelease tag in the range,
+the user is indicating that they are aware of the risk. However, it
+is still not appropriate to assume that they have opted into taking a
+similar risk on the *next* set of prerelease versions.
+
+Note that this behavior can be suppressed (treating all prerelease
+versions as if they were normal versions, for the purpose of range
+matching) by setting the `includePrerelease` flag on the options
+object to any
+[functions](https://github.com/npm/node-semver#functions) that do
+range matching.
+
+#### Prerelease Identifiers
+
+The method `.inc` takes an additional `identifier` string argument that
+will append the value of the string as a prerelease identifier:
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta')
+// '1.2.4-beta.0'
+```
+
+command-line example:
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta
+1.2.4-beta.0
+```
+
+Which then can be used to increment further:
+
+```bash
+$ semver 1.2.4-beta.0 -i prerelease
+1.2.4-beta.1
+```
+
+### Advanced Range Syntax
+
+Advanced range syntax desugars to primitive comparators in
+deterministic ways.
+
+Advanced ranges may be combined in the same way as primitive
+comparators using white space or `||`.
+
+#### Hyphen Ranges `X.Y.Z - A.B.C`
+
+Specifies an inclusive set.
+
+* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+
+If a partial version is provided as the first version in the inclusive
+range, then the missing pieces are replaced with zeroes.
+
+* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
+
+If a partial version is provided as the second version in the
+inclusive range, then all versions that start with the supplied parts
+of the tuple are accepted, but nothing that would be greater than the
+provided tuple parts.
+
+* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0`
+* `1.2.3 - 2` := `>=1.2.3 <3.0.0`
+
+#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
+
+Any of `X`, `x`, or `*` may be used to "stand in" for one of the
+numeric values in the `[major, minor, patch]` tuple.
+
+* `*` := `>=0.0.0` (Any version satisfies)
+* `1.x` := `>=1.0.0 <2.0.0` (Matching major version)
+* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions)
+
+A partial version range is treated as an X-Range, so the special
+character is in fact optional.
+
+* `""` (empty string) := `*` := `>=0.0.0`
+* `1` := `1.x.x` := `>=1.0.0 <2.0.0`
+* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0`
+
+#### Tilde Ranges `~1.2.3` `~1.2` `~1`
+
+Allows patch-level changes if a minor version is specified on the
+comparator. Allows minor-level changes if not.
+
+* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0`
+* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`)
+* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`)
+* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0`
+* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`)
+* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`)
+* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in
+ the `1.2.3` version will be allowed, if they are greater than or
+ equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but
+ `1.2.4-beta.2` would not, because it is a prerelease of a
+ different `[major, minor, patch]` tuple.
+
+#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
+
+Allows changes that do not modify the left-most non-zero element in the
+`[major, minor, patch]` tuple. In other words, this allows patch and
+minor updates for versions `1.0.0` and above, patch updates for
+versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
+
+Many authors treat a `0.x` version as if the `x` were the major
+"breaking-change" indicator.
+
+Caret ranges are ideal when an author may make breaking changes
+between `0.2.4` and `0.3.0` releases, which is a common practice.
+However, it presumes that there will *not* be breaking changes between
+`0.2.4` and `0.2.5`. It allows for changes that are presumed to be
+additive (but non-breaking), according to commonly observed practices.
+
+* `^1.2.3` := `>=1.2.3 <2.0.0`
+* `^0.2.3` := `>=0.2.3 <0.3.0`
+* `^0.0.3` := `>=0.0.3 <0.0.4`
+* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in
+ the `1.2.3` version will be allowed, if they are greater than or
+ equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but
+ `1.2.4-beta.2` would not, because it is a prerelease of a
+ different `[major, minor, patch]` tuple.
+* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4` Note that prereleases in the
+ `0.0.3` version *only* will be allowed, if they are greater than or
+ equal to `beta`. So, `0.0.3-pr.2` would be allowed.
+
+When parsing caret ranges, a missing `patch` value desugars to the
+number `0`, but will allow flexibility within that value, even if the
+major and minor versions are both `0`.
+
+* `^1.2.x` := `>=1.2.0 <2.0.0`
+* `^0.0.x` := `>=0.0.0 <0.1.0`
+* `^0.0` := `>=0.0.0 <0.1.0`
+
+A missing `minor` and `patch` values will desugar to zero, but also
+allow flexibility within those values, even if the major version is
+zero.
+
+* `^1.x` := `>=1.0.0 <2.0.0`
+* `^0.x` := `>=0.0.0 <1.0.0`
+
+### Range Grammar
+
+Putting all this together, here is a Backus-Naur grammar for ranges,
+for the benefit of parser authors:
+
+```bnf
+range-set ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen ::= partial ' - ' partial
+simple ::= primitive | partial | tilde | caret
+primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr ::= 'x' | 'X' | '*' | nr
+nr ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
+tilde ::= '~' partial
+caret ::= '^' partial
+qualifier ::= ( '-' pre )? ( '+' build )?
+pre ::= parts
+build ::= parts
+parts ::= part ( '.' part ) *
+part ::= nr | [-0-9A-Za-z]+
+```
+
+## Functions
+
+All methods and classes take a final `options` object argument. All
+options in this object are `false` by default. The options supported
+are:
+
+- `loose` Be more forgiving about not-quite-valid semver strings.
+ (Any resulting output will always be 100% strict compliant, of
+ course.) For backwards compatibility reasons, if the `options`
+ argument is a boolean value instead of an object, it is interpreted
+ to be the `loose` param.
+- `includePrerelease` Set to suppress the [default
+ behavior](https://github.com/npm/node-semver#prerelease-tags) of
+ excluding prerelease tagged versions from ranges unless they are
+ explicitly opted into.
+
+Strict-mode Comparators and Ranges will be strict about the SemVer
+strings that they parse.
+
+* `valid(v)`: Return the parsed version, or null if it's not valid.
+* `inc(v, release)`: Return the version incremented by the release
+ type (`major`, `premajor`, `minor`, `preminor`, `patch`,
+ `prepatch`, or `prerelease`), or null if it's not valid
+ * `premajor` in one call will bump the version up to the next major
+ version and down to a prerelease of that major version.
+ `preminor`, and `prepatch` work the same way.
+ * If called from a non-prerelease version, the `prerelease` will work the
+ same as `prepatch`. It increments the patch version, then makes a
+ prerelease. If the input version is already a prerelease it simply
+ increments it.
+* `prerelease(v)`: Returns an array of prerelease components, or null
+ if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
+* `major(v)`: Return the major version number.
+* `minor(v)`: Return the minor version number.
+* `patch(v)`: Return the patch version number.
+* `intersects(r1, r2, loose)`: Return true if the two supplied ranges
+ or comparators intersect.
+* `parse(v)`: Attempt to parse a string as a semantic version, returning either
+ a `SemVer` object or `null`.
+
+### Comparison
+
+* `gt(v1, v2)`: `v1 > v2`
+* `gte(v1, v2)`: `v1 >= v2`
+* `lt(v1, v2)`: `v1 < v2`
+* `lte(v1, v2)`: `v1 <= v2`
+* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
+ even if they're not the exact same string. You already know how to
+ compare strings.
+* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
+* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
+ the corresponding function above. `"==="` and `"!=="` do simple
+ string comparison, but are included for completeness. Throws if an
+ invalid comparison string is provided.
+* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
+ `v2` is greater. Sorts in ascending order if passed to `Array.sort()`.
+* `rcompare(v1, v2)`: The reverse of compare. Sorts an array of versions
+ in descending order when passed to `Array.sort()`.
+* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions
+ are equal. Sorts in ascending order if passed to `Array.sort()`.
+ `v2` is greater. Sorts in ascending order if passed to `Array.sort()`.
+* `diff(v1, v2)`: Returns difference between two versions by the release type
+ (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
+ or null if the versions are the same.
+
+### Comparators
+
+* `intersects(comparator)`: Return true if the comparators intersect
+
+### Ranges
+
+* `validRange(range)`: Return the valid range or null if it's not valid
+* `satisfies(version, range)`: Return true if the version satisfies the
+ range.
+* `maxSatisfying(versions, range)`: Return the highest version in the list
+ that satisfies the range, or `null` if none of them do.
+* `minSatisfying(versions, range)`: Return the lowest version in the list
+ that satisfies the range, or `null` if none of them do.
+* `minVersion(range)`: Return the lowest version that can possibly match
+ the given range.
+* `gtr(version, range)`: Return `true` if version is greater than all the
+ versions possible in the range.
+* `ltr(version, range)`: Return `true` if version is less than all the
+ versions possible in the range.
+* `outside(version, range, hilo)`: Return true if the version is outside
+ the bounds of the range in either the high or low direction. The
+ `hilo` argument must be either the string `'>'` or `'<'`. (This is
+ the function called by `gtr` and `ltr`.)
+* `intersects(range)`: Return true if any of the ranges comparators intersect
+
+Note that, since ranges may be non-contiguous, a version might not be
+greater than a range, less than a range, *or* satisfy a range! For
+example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
+until `2.0.0`, so the version `1.2.10` would not be greater than the
+range (because `2.0.1` satisfies, which is higher), nor less than the
+range (since `1.2.8` satisfies, which is lower), and it also does not
+satisfy the range.
+
+If you want to know if a version satisfies or does not satisfy a
+range, use the `satisfies(version, range)` function.
+
+### Coercion
+
+* `coerce(version, options)`: Coerces a string to semver if possible
+
+This aims to provide a very forgiving translation of a non-semver string to
+semver. It looks for the first digit in a string, and consumes all
+remaining characters which satisfy at least a partial semver (e.g., `1`,
+`1.2`, `1.2.3`) up to the max permitted length (256 characters). Longer
+versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`). All
+surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
+`3.4.0`). Only text which lacks digits will fail coercion (`version one`
+is not valid). The maximum length for any semver component considered for
+coercion is 16 characters; longer components will be ignored
+(`10000000000000000.4.7.4` becomes `4.7.4`). The maximum value for any
+semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+components are invalid (`9999999999999999.4.7.4` is likely invalid).
+
+If the `options.rtl` flag is set, then `coerce` will return the right-most
+coercible tuple that does not share an ending index with a longer coercible
+tuple. For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
+`4.0.0`. `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
+any other overlapping SemVer tuple.
+
+### Clean
+
+* `clean(version)`: Clean a string to be a valid semver if possible
+
+This will return a cleaned and trimmed semver version. If the provided version is not valid a null will be returned. This does not work for ranges.
+
+ex.
+* `s.clean(' = v 2.1.5foo')`: `null`
+* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean(' = v 2.1.5-foo')`: `null`
+* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean('=v2.1.5')`: `'2.1.5'`
+* `s.clean(' =v2.1.5')`: `2.1.5`
+* `s.clean(' 2.1.5 ')`: `'2.1.5'`
+* `s.clean('~1.0.0')`: `null`
diff --git a/node_modules/imagemin/node_modules/semver/bin/semver.js b/node_modules/imagemin/node_modules/semver/bin/semver.js
new file mode 100644
index 0000000..666034a
--- /dev/null
+++ b/node_modules/imagemin/node_modules/semver/bin/semver.js
@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+var argv = process.argv.slice(2)
+
+var versions = []
+
+var range = []
+
+var inc = null
+
+var version = require('../package.json').version
+
+var loose = false
+
+var includePrerelease = false
+
+var coerce = false
+
+var rtl = false
+
+var identifier
+
+var semver = require('../semver')
+
+var reverse = false
+
+var options = {}
+
+main()
+
+function main () {
+ if (!argv.length) return help()
+ while (argv.length) {
+ var a = argv.shift()
+ var indexOfEqualSign = a.indexOf('=')
+ if (indexOfEqualSign !== -1) {
+ a = a.slice(0, indexOfEqualSign)
+ argv.unshift(a.slice(indexOfEqualSign + 1))
+ }
+ switch (a) {
+ case '-rv': case '-rev': case '--rev': case '--reverse':
+ reverse = true
+ break
+ case '-l': case '--loose':
+ loose = true
+ break
+ case '-p': case '--include-prerelease':
+ includePrerelease = true
+ break
+ case '-v': case '--version':
+ versions.push(argv.shift())
+ break
+ case '-i': case '--inc': case '--increment':
+ switch (argv[0]) {
+ case 'major': case 'minor': case 'patch': case 'prerelease':
+ case 'premajor': case 'preminor': case 'prepatch':
+ inc = argv.shift()
+ break
+ default:
+ inc = 'patch'
+ break
+ }
+ break
+ case '--preid':
+ identifier = argv.shift()
+ break
+ case '-r': case '--range':
+ range.push(argv.shift())
+ break
+ case '-c': case '--coerce':
+ coerce = true
+ break
+ case '--rtl':
+ rtl = true
+ break
+ case '--ltr':
+ rtl = false
+ break
+ case '-h': case '--help': case '-?':
+ return help()
+ default:
+ versions.push(a)
+ break
+ }
+ }
+
+ var options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }
+
+ versions = versions.map(function (v) {
+ return coerce ? (semver.coerce(v, options) || { version: v }).version : v
+ }).filter(function (v) {
+ return semver.valid(v)
+ })
+ if (!versions.length) return fail()
+ if (inc && (versions.length !== 1 || range.length)) { return failInc() }
+
+ for (var i = 0, l = range.length; i < l; i++) {
+ versions = versions.filter(function (v) {
+ return semver.satisfies(v, range[i], options)
+ })
+ if (!versions.length) return fail()
+ }
+ return success(versions)
+}
+
+function failInc () {
+ console.error('--inc can only be used on a single version with no range')
+ fail()
+}
+
+function fail () { process.exit(1) }
+
+function success () {
+ var compare = reverse ? 'rcompare' : 'compare'
+ versions.sort(function (a, b) {
+ return semver[compare](a, b, options)
+ }).map(function (v) {
+ return semver.clean(v, options)
+ }).map(function (v) {
+ return inc ? semver.inc(v, inc, options, identifier) : v
+ }).forEach(function (v, i, _) { console.log(v) })
+}
+
+function help () {
+ console.log(['SemVer ' + version,
+ '',
+ 'A JavaScript implementation of the https://semver.org/ specification',
+ 'Copyright Isaac Z. Schlueter',
+ '',
+ 'Usage: semver [options] <version> [<version> [...]]',
+ 'Prints valid versions sorted by SemVer precedence',
+ '',
+ 'Options:',
+ '-r --range <range>',
+ ' Print versions that match the specified range.',
+ '',
+ '-i --increment [<level>]',
+ ' Increment a version by the specified level. Level can',
+ ' be one of: major, minor, patch, premajor, preminor,',
+ " prepatch, or prerelease. Default level is 'patch'.",
+ ' Only one version may be specified.',
+ '',
+ '--preid <identifier>',
+ ' Identifier to be used to prefix premajor, preminor,',
+ ' prepatch or prerelease version increments.',
+ '',
+ '-l --loose',
+ ' Interpret versions and ranges loosely',
+ '',
+ '-p --include-prerelease',
+ ' Always include prerelease versions in range matching',
+ '',
+ '-c --coerce',
+ ' Coerce a string into SemVer if possible',
+ ' (does not imply --loose)',
+ '',
+ '--rtl',
+ ' Coerce version strings right to left',
+ '',
+ '--ltr',
+ ' Coerce version strings left to right (default)',
+ '',
+ 'Program exits successfully if any valid version satisfies',
+ 'all supplied ranges, and prints all satisfying versions.',
+ '',
+ 'If no satisfying versions are found, then exits failure.',
+ '',
+ 'Versions are printed in ascending order, so supplying',
+ 'multiple versions to the utility will just sort them.'
+ ].join('\n'))
+}
diff --git a/node_modules/imagemin/node_modules/semver/package.json b/node_modules/imagemin/node_modules/semver/package.json
new file mode 100644
index 0000000..2b5626c
--- /dev/null
+++ b/node_modules/imagemin/node_modules/semver/package.json
@@ -0,0 +1,60 @@
+{
+ "_from": "semver@^6.0.0",
+ "_id": "semver@6.3.0",
+ "_inBundle": false,
+ "_integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+ "_location": "/imagemin/semver",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "semver@^6.0.0",
+ "name": "semver",
+ "escapedName": "semver",
+ "rawSpec": "^6.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^6.0.0"
+ },
+ "_requiredBy": [
+ "/imagemin/make-dir"
+ ],
+ "_resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+ "_shasum": "ee0a64c8af5e8ceea67687b133761e1becbd1d3d",
+ "_spec": "semver@^6.0.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\make-dir",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "bugs": {
+ "url": "https://github.com/npm/node-semver/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "The semantic version parser used by npm.",
+ "devDependencies": {
+ "tap": "^14.3.1"
+ },
+ "files": [
+ "bin",
+ "range.bnf",
+ "semver.js"
+ ],
+ "homepage": "https://github.com/npm/node-semver#readme",
+ "license": "ISC",
+ "main": "semver.js",
+ "name": "semver",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/npm/node-semver.git"
+ },
+ "scripts": {
+ "postpublish": "git push origin --follow-tags",
+ "postversion": "npm publish",
+ "preversion": "npm test",
+ "test": "tap"
+ },
+ "tap": {
+ "check-coverage": true
+ },
+ "version": "6.3.0"
+}
diff --git a/node_modules/imagemin/node_modules/semver/range.bnf b/node_modules/imagemin/node_modules/semver/range.bnf
new file mode 100644
index 0000000..d4c6ae0
--- /dev/null
+++ b/node_modules/imagemin/node_modules/semver/range.bnf
@@ -0,0 +1,16 @@
+range-set ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen ::= partial ' - ' partial
+simple ::= primitive | partial | tilde | caret
+primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr ::= 'x' | 'X' | '*' | nr
+nr ::= '0' | [1-9] ( [0-9] ) *
+tilde ::= '~' partial
+caret ::= '^' partial
+qualifier ::= ( '-' pre )? ( '+' build )?
+pre ::= parts
+build ::= parts
+parts ::= part ( '.' part ) *
+part ::= nr | [-0-9A-Za-z]+
diff --git a/node_modules/imagemin/node_modules/semver/semver.js b/node_modules/imagemin/node_modules/semver/semver.js
new file mode 100644
index 0000000..636fa43
--- /dev/null
+++ b/node_modules/imagemin/node_modules/semver/semver.js
@@ -0,0 +1,1596 @@
+exports = module.exports = SemVer
+
+var debug
+/* istanbul ignore next */
+if (typeof process === 'object' &&
+ process.env &&
+ process.env.NODE_DEBUG &&
+ /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
+ debug = function () {
+ var args = Array.prototype.slice.call(arguments, 0)
+ args.unshift('SEMVER')
+ console.log.apply(console, args)
+ }
+} else {
+ debug = function () {}
+}
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+exports.SEMVER_SPEC_VERSION = '2.0.0'
+
+var MAX_LENGTH = 256
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
+ /* istanbul ignore next */ 9007199254740991
+
+// Max safe segment length for coercion.
+var MAX_SAFE_COMPONENT_LENGTH = 16
+
+// The actual regexps go on exports.re
+var re = exports.re = []
+var src = exports.src = []
+var t = exports.tokens = {}
+var R = 0
+
+function tok (n) {
+ t[n] = R++
+}
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+tok('NUMERICIDENTIFIER')
+src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*'
+tok('NUMERICIDENTIFIERLOOSE')
+src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+'
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+tok('NONNUMERICIDENTIFIER')
+src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+tok('MAINVERSION')
+src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[t.NUMERICIDENTIFIER] + ')'
+
+tok('MAINVERSIONLOOSE')
+src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')'
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+tok('PRERELEASEIDENTIFIER')
+src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] +
+ '|' + src[t.NONNUMERICIDENTIFIER] + ')'
+
+tok('PRERELEASEIDENTIFIERLOOSE')
+src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] +
+ '|' + src[t.NONNUMERICIDENTIFIER] + ')'
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+tok('PRERELEASE')
+src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] +
+ '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))'
+
+tok('PRERELEASELOOSE')
+src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] +
+ '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))'
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+tok('BUILDIDENTIFIER')
+src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+tok('BUILD')
+src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] +
+ '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))'
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups. The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+tok('FULL')
+tok('FULLPLAIN')
+src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] +
+ src[t.PRERELEASE] + '?' +
+ src[t.BUILD] + '?'
+
+src[t.FULL] = '^' + src[t.FULLPLAIN] + '$'
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+tok('LOOSEPLAIN')
+src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] +
+ src[t.PRERELEASELOOSE] + '?' +
+ src[t.BUILD] + '?'
+
+tok('LOOSE')
+src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$'
+
+tok('GTLT')
+src[t.GTLT] = '((?:<|>)?=?)'
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+tok('XRANGEIDENTIFIERLOOSE')
+src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
+tok('XRANGEIDENTIFIER')
+src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*'
+
+tok('XRANGEPLAIN')
+src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
+ '(?:' + src[t.PRERELEASE] + ')?' +
+ src[t.BUILD] + '?' +
+ ')?)?'
+
+tok('XRANGEPLAINLOOSE')
+src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:' + src[t.PRERELEASELOOSE] + ')?' +
+ src[t.BUILD] + '?' +
+ ')?)?'
+
+tok('XRANGE')
+src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$'
+tok('XRANGELOOSE')
+src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$'
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+tok('COERCE')
+src[t.COERCE] = '(^|[^\\d])' +
+ '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
+ '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+ '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+ '(?:$|[^\\d])'
+tok('COERCERTL')
+re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g')
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+tok('LONETILDE')
+src[t.LONETILDE] = '(?:~>?)'
+
+tok('TILDETRIM')
+src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+'
+re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g')
+var tildeTrimReplace = '$1~'
+
+tok('TILDE')
+src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$'
+tok('TILDELOOSE')
+src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$'
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+tok('LONECARET')
+src[t.LONECARET] = '(?:\\^)'
+
+tok('CARETTRIM')
+src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+'
+re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g')
+var caretTrimReplace = '$1^'
+
+tok('CARET')
+src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$'
+tok('CARETLOOSE')
+src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$'
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+tok('COMPARATORLOOSE')
+src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$'
+tok('COMPARATOR')
+src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$'
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+tok('COMPARATORTRIM')
+src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] +
+ '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')'
+
+// this one has to use the /g flag
+re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g')
+var comparatorTrimReplace = '$1$2$3'
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+tok('HYPHENRANGE')
+src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[t.XRANGEPLAIN] + ')' +
+ '\\s*$'
+
+tok('HYPHENRANGELOOSE')
+src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[t.XRANGEPLAINLOOSE] + ')' +
+ '\\s*$'
+
+// Star ranges basically just allow anything at all.
+tok('STAR')
+src[t.STAR] = '(<|>)?=?\\s*\\*'
+
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (var i = 0; i < R; i++) {
+ debug(i, src[i])
+ if (!re[i]) {
+ re[i] = new RegExp(src[i])
+ }
+}
+
+exports.parse = parse
+function parse (version, options) {
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+
+ if (version instanceof SemVer) {
+ return version
+ }
+
+ if (typeof version !== 'string') {
+ return null
+ }
+
+ if (version.length > MAX_LENGTH) {
+ return null
+ }
+
+ var r = options.loose ? re[t.LOOSE] : re[t.FULL]
+ if (!r.test(version)) {
+ return null
+ }
+
+ try {
+ return new SemVer(version, options)
+ } catch (er) {
+ return null
+ }
+}
+
+exports.valid = valid
+function valid (version, options) {
+ var v = parse(version, options)
+ return v ? v.version : null
+}
+
+exports.clean = clean
+function clean (version, options) {
+ var s = parse(version.trim().replace(/^[=v]+/, ''), options)
+ return s ? s.version : null
+}
+
+exports.SemVer = SemVer
+
+function SemVer (version, options) {
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+ if (version instanceof SemVer) {
+ if (version.loose === options.loose) {
+ return version
+ } else {
+ version = version.version
+ }
+ } else if (typeof version !== 'string') {
+ throw new TypeError('Invalid Version: ' + version)
+ }
+
+ if (version.length > MAX_LENGTH) {
+ throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
+ }
+
+ if (!(this instanceof SemVer)) {
+ return new SemVer(version, options)
+ }
+
+ debug('SemVer', version, options)
+ this.options = options
+ this.loose = !!options.loose
+
+ var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
+
+ if (!m) {
+ throw new TypeError('Invalid Version: ' + version)
+ }
+
+ this.raw = version
+
+ // these are actually numbers
+ this.major = +m[1]
+ this.minor = +m[2]
+ this.patch = +m[3]
+
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+ throw new TypeError('Invalid major version')
+ }
+
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+ throw new TypeError('Invalid minor version')
+ }
+
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+ throw new TypeError('Invalid patch version')
+ }
+
+ // numberify any prerelease numeric ids
+ if (!m[4]) {
+ this.prerelease = []
+ } else {
+ this.prerelease = m[4].split('.').map(function (id) {
+ if (/^[0-9]+$/.test(id)) {
+ var num = +id
+ if (num >= 0 && num < MAX_SAFE_INTEGER) {
+ return num
+ }
+ }
+ return id
+ })
+ }
+
+ this.build = m[5] ? m[5].split('.') : []
+ this.format()
+}
+
+SemVer.prototype.format = function () {
+ this.version = this.major + '.' + this.minor + '.' + this.patch
+ if (this.prerelease.length) {
+ this.version += '-' + this.prerelease.join('.')
+ }
+ return this.version
+}
+
+SemVer.prototype.toString = function () {
+ return this.version
+}
+
+SemVer.prototype.compare = function (other) {
+ debug('SemVer.compare', this.version, this.options, other)
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options)
+ }
+
+ return this.compareMain(other) || this.comparePre(other)
+}
+
+SemVer.prototype.compareMain = function (other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options)
+ }
+
+ return compareIdentifiers(this.major, other.major) ||
+ compareIdentifiers(this.minor, other.minor) ||
+ compareIdentifiers(this.patch, other.patch)
+}
+
+SemVer.prototype.comparePre = function (other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options)
+ }
+
+ // NOT having a prerelease is > having one
+ if (this.prerelease.length && !other.prerelease.length) {
+ return -1
+ } else if (!this.prerelease.length && other.prerelease.length) {
+ return 1
+ } else if (!this.prerelease.length && !other.prerelease.length) {
+ return 0
+ }
+
+ var i = 0
+ do {
+ var a = this.prerelease[i]
+ var b = other.prerelease[i]
+ debug('prerelease compare', i, a, b)
+ if (a === undefined && b === undefined) {
+ return 0
+ } else if (b === undefined) {
+ return 1
+ } else if (a === undefined) {
+ return -1
+ } else if (a === b) {
+ continue
+ } else {
+ return compareIdentifiers(a, b)
+ }
+ } while (++i)
+}
+
+SemVer.prototype.compareBuild = function (other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options)
+ }
+
+ var i = 0
+ do {
+ var a = this.build[i]
+ var b = other.build[i]
+ debug('prerelease compare', i, a, b)
+ if (a === undefined && b === undefined) {
+ return 0
+ } else if (b === undefined) {
+ return 1
+ } else if (a === undefined) {
+ return -1
+ } else if (a === b) {
+ continue
+ } else {
+ return compareIdentifiers(a, b)
+ }
+ } while (++i)
+}
+
+// preminor will bump the version up to the next minor release, and immediately
+// down to pre-release. premajor and prepatch work the same way.
+SemVer.prototype.inc = function (release, identifier) {
+ switch (release) {
+ case 'premajor':
+ this.prerelease.length = 0
+ this.patch = 0
+ this.minor = 0
+ this.major++
+ this.inc('pre', identifier)
+ break
+ case 'preminor':
+ this.prerelease.length = 0
+ this.patch = 0
+ this.minor++
+ this.inc('pre', identifier)
+ break
+ case 'prepatch':
+ // If this is already a prerelease, it will bump to the next version
+ // drop any prereleases that might already exist, since they are not
+ // relevant at this point.
+ this.prerelease.length = 0
+ this.inc('patch', identifier)
+ this.inc('pre', identifier)
+ break
+ // If the input is a non-prerelease version, this acts the same as
+ // prepatch.
+ case 'prerelease':
+ if (this.prerelease.length === 0) {
+ this.inc('patch', identifier)
+ }
+ this.inc('pre', identifier)
+ break
+
+ case 'major':
+ // If this is a pre-major version, bump up to the same major version.
+ // Otherwise increment major.
+ // 1.0.0-5 bumps to 1.0.0
+ // 1.1.0 bumps to 2.0.0
+ if (this.minor !== 0 ||
+ this.patch !== 0 ||
+ this.prerelease.length === 0) {
+ this.major++
+ }
+ this.minor = 0
+ this.patch = 0
+ this.prerelease = []
+ break
+ case 'minor':
+ // If this is a pre-minor version, bump up to the same minor version.
+ // Otherwise increment minor.
+ // 1.2.0-5 bumps to 1.2.0
+ // 1.2.1 bumps to 1.3.0
+ if (this.patch !== 0 || this.prerelease.length === 0) {
+ this.minor++
+ }
+ this.patch = 0
+ this.prerelease = []
+ break
+ case 'patch':
+ // If this is not a pre-release version, it will increment the patch.
+ // If it is a pre-release it will bump up to the same patch version.
+ // 1.2.0-5 patches to 1.2.0
+ // 1.2.0 patches to 1.2.1
+ if (this.prerelease.length === 0) {
+ this.patch++
+ }
+ this.prerelease = []
+ break
+ // This probably shouldn't be used publicly.
+ // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
+ case 'pre':
+ if (this.prerelease.length === 0) {
+ this.prerelease = [0]
+ } else {
+ var i = this.prerelease.length
+ while (--i >= 0) {
+ if (typeof this.prerelease[i] === 'number') {
+ this.prerelease[i]++
+ i = -2
+ }
+ }
+ if (i === -1) {
+ // didn't increment anything
+ this.prerelease.push(0)
+ }
+ }
+ if (identifier) {
+ // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+ // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+ if (this.prerelease[0] === identifier) {
+ if (isNaN(this.prerelease[1])) {
+ this.prerelease = [identifier, 0]
+ }
+ } else {
+ this.prerelease = [identifier, 0]
+ }
+ }
+ break
+
+ default:
+ throw new Error('invalid increment argument: ' + release)
+ }
+ this.format()
+ this.raw = this.version
+ return this
+}
+
+exports.inc = inc
+function inc (version, release, loose, identifier) {
+ if (typeof (loose) === 'string') {
+ identifier = loose
+ loose = undefined
+ }
+
+ try {
+ return new SemVer(version, loose).inc(release, identifier).version
+ } catch (er) {
+ return null
+ }
+}
+
+exports.diff = diff
+function diff (version1, version2) {
+ if (eq(version1, version2)) {
+ return null
+ } else {
+ var v1 = parse(version1)
+ var v2 = parse(version2)
+ var prefix = ''
+ if (v1.prerelease.length || v2.prerelease.length) {
+ prefix = 'pre'
+ var defaultResult = 'prerelease'
+ }
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return prefix + key
+ }
+ }
+ }
+ return defaultResult // may be undefined
+ }
+}
+
+exports.compareIdentifiers = compareIdentifiers
+
+var numeric = /^[0-9]+$/
+function compareIdentifiers (a, b) {
+ var anum = numeric.test(a)
+ var bnum = numeric.test(b)
+
+ if (anum && bnum) {
+ a = +a
+ b = +b
+ }
+
+ return a === b ? 0
+ : (anum && !bnum) ? -1
+ : (bnum && !anum) ? 1
+ : a < b ? -1
+ : 1
+}
+
+exports.rcompareIdentifiers = rcompareIdentifiers
+function rcompareIdentifiers (a, b) {
+ return compareIdentifiers(b, a)
+}
+
+exports.major = major
+function major (a, loose) {
+ return new SemVer(a, loose).major
+}
+
+exports.minor = minor
+function minor (a, loose) {
+ return new SemVer(a, loose).minor
+}
+
+exports.patch = patch
+function patch (a, loose) {
+ return new SemVer(a, loose).patch
+}
+
+exports.compare = compare
+function compare (a, b, loose) {
+ return new SemVer(a, loose).compare(new SemVer(b, loose))
+}
+
+exports.compareLoose = compareLoose
+function compareLoose (a, b) {
+ return compare(a, b, true)
+}
+
+exports.compareBuild = compareBuild
+function compareBuild (a, b, loose) {
+ var versionA = new SemVer(a, loose)
+ var versionB = new SemVer(b, loose)
+ return versionA.compare(versionB) || versionA.compareBuild(versionB)
+}
+
+exports.rcompare = rcompare
+function rcompare (a, b, loose) {
+ return compare(b, a, loose)
+}
+
+exports.sort = sort
+function sort (list, loose) {
+ return list.sort(function (a, b) {
+ return exports.compareBuild(a, b, loose)
+ })
+}
+
+exports.rsort = rsort
+function rsort (list, loose) {
+ return list.sort(function (a, b) {
+ return exports.compareBuild(b, a, loose)
+ })
+}
+
+exports.gt = gt
+function gt (a, b, loose) {
+ return compare(a, b, loose) > 0
+}
+
+exports.lt = lt
+function lt (a, b, loose) {
+ return compare(a, b, loose) < 0
+}
+
+exports.eq = eq
+function eq (a, b, loose) {
+ return compare(a, b, loose) === 0
+}
+
+exports.neq = neq
+function neq (a, b, loose) {
+ return compare(a, b, loose) !== 0
+}
+
+exports.gte = gte
+function gte (a, b, loose) {
+ return compare(a, b, loose) >= 0
+}
+
+exports.lte = lte
+function lte (a, b, loose) {
+ return compare(a, b, loose) <= 0
+}
+
+exports.cmp = cmp
+function cmp (a, op, b, loose) {
+ switch (op) {
+ case '===':
+ if (typeof a === 'object')
+ a = a.version
+ if (typeof b === 'object')
+ b = b.version
+ return a === b
+
+ case '!==':
+ if (typeof a === 'object')
+ a = a.version
+ if (typeof b === 'object')
+ b = b.version
+ return a !== b
+
+ case '':
+ case '=':
+ case '==':
+ return eq(a, b, loose)
+
+ case '!=':
+ return neq(a, b, loose)
+
+ case '>':
+ return gt(a, b, loose)
+
+ case '>=':
+ return gte(a, b, loose)
+
+ case '<':
+ return lt(a, b, loose)
+
+ case '<=':
+ return lte(a, b, loose)
+
+ default:
+ throw new TypeError('Invalid operator: ' + op)
+ }
+}
+
+exports.Comparator = Comparator
+function Comparator (comp, options) {
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+
+ if (comp instanceof Comparator) {
+ if (comp.loose === !!options.loose) {
+ return comp
+ } else {
+ comp = comp.value
+ }
+ }
+
+ if (!(this instanceof Comparator)) {
+ return new Comparator(comp, options)
+ }
+
+ debug('comparator', comp, options)
+ this.options = options
+ this.loose = !!options.loose
+ this.parse(comp)
+
+ if (this.semver === ANY) {
+ this.value = ''
+ } else {
+ this.value = this.operator + this.semver.version
+ }
+
+ debug('comp', this)
+}
+
+var ANY = {}
+Comparator.prototype.parse = function (comp) {
+ var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
+ var m = comp.match(r)
+
+ if (!m) {
+ throw new TypeError('Invalid comparator: ' + comp)
+ }
+
+ this.operator = m[1] !== undefined ? m[1] : ''
+ if (this.operator === '=') {
+ this.operator = ''
+ }
+
+ // if it literally is just '>' or '' then allow anything.
+ if (!m[2]) {
+ this.semver = ANY
+ } else {
+ this.semver = new SemVer(m[2], this.options.loose)
+ }
+}
+
+Comparator.prototype.toString = function () {
+ return this.value
+}
+
+Comparator.prototype.test = function (version) {
+ debug('Comparator.test', version, this.options.loose)
+
+ if (this.semver === ANY || version === ANY) {
+ return true
+ }
+
+ if (typeof version === 'string') {
+ try {
+ version = new SemVer(version, this.options)
+ } catch (er) {
+ return false
+ }
+ }
+
+ return cmp(version, this.operator, this.semver, this.options)
+}
+
+Comparator.prototype.intersects = function (comp, options) {
+ if (!(comp instanceof Comparator)) {
+ throw new TypeError('a Comparator is required')
+ }
+
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+
+ var rangeTmp
+
+ if (this.operator === '') {
+ if (this.value === '') {
+ return true
+ }
+ rangeTmp = new Range(comp.value, options)
+ return satisfies(this.value, rangeTmp, options)
+ } else if (comp.operator === '') {
+ if (comp.value === '') {
+ return true
+ }
+ rangeTmp = new Range(this.value, options)
+ return satisfies(comp.semver, rangeTmp, options)
+ }
+
+ var sameDirectionIncreasing =
+ (this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '>=' || comp.operator === '>')
+ var sameDirectionDecreasing =
+ (this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '<=' || comp.operator === '<')
+ var sameSemVer = this.semver.version === comp.semver.version
+ var differentDirectionsInclusive =
+ (this.operator === '>=' || this.operator === '<=') &&
+ (comp.operator === '>=' || comp.operator === '<=')
+ var oppositeDirectionsLessThan =
+ cmp(this.semver, '<', comp.semver, options) &&
+ ((this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '<=' || comp.operator === '<'))
+ var oppositeDirectionsGreaterThan =
+ cmp(this.semver, '>', comp.semver, options) &&
+ ((this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '>=' || comp.operator === '>'))
+
+ return sameDirectionIncreasing || sameDirectionDecreasing ||
+ (sameSemVer && differentDirectionsInclusive) ||
+ oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
+}
+
+exports.Range = Range
+function Range (range, options) {
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+
+ if (range instanceof Range) {
+ if (range.loose === !!options.loose &&
+ range.includePrerelease === !!options.includePrerelease) {
+ return range
+ } else {
+ return new Range(range.raw, options)
+ }
+ }
+
+ if (range instanceof Comparator) {
+ return new Range(range.value, options)
+ }
+
+ if (!(this instanceof Range)) {
+ return new Range(range, options)
+ }
+
+ this.options = options
+ this.loose = !!options.loose
+ this.includePrerelease = !!options.includePrerelease
+
+ // First, split based on boolean or ||
+ this.raw = range
+ this.set = range.split(/\s*\|\|\s*/).map(function (range) {
+ return this.parseRange(range.trim())
+ }, this).filter(function (c) {
+ // throw out any that are not relevant for whatever reason
+ return c.length
+ })
+
+ if (!this.set.length) {
+ throw new TypeError('Invalid SemVer Range: ' + range)
+ }
+
+ this.format()
+}
+
+Range.prototype.format = function () {
+ this.range = this.set.map(function (comps) {
+ return comps.join(' ').trim()
+ }).join('||').trim()
+ return this.range
+}
+
+Range.prototype.toString = function () {
+ return this.range
+}
+
+Range.prototype.parseRange = function (range) {
+ var loose = this.options.loose
+ range = range.trim()
+ // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+ var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
+ range = range.replace(hr, hyphenReplace)
+ debug('hyphen replace', range)
+ // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+ range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
+ debug('comparator trim', range, re[t.COMPARATORTRIM])
+
+ // `~ 1.2.3` => `~1.2.3`
+ range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
+
+ // `^ 1.2.3` => `^1.2.3`
+ range = range.replace(re[t.CARETTRIM], caretTrimReplace)
+
+ // normalize spaces
+ range = range.split(/\s+/).join(' ')
+
+ // At this point, the range is completely trimmed and
+ // ready to be split into comparators.
+
+ var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
+ var set = range.split(' ').map(function (comp) {
+ return parseComparator(comp, this.options)
+ }, this).join(' ').split(/\s+/)
+ if (this.options.loose) {
+ // in loose mode, throw out any that are not valid comparators
+ set = set.filter(function (comp) {
+ return !!comp.match(compRe)
+ })
+ }
+ set = set.map(function (comp) {
+ return new Comparator(comp, this.options)
+ }, this)
+
+ return set
+}
+
+Range.prototype.intersects = function (range, options) {
+ if (!(range instanceof Range)) {
+ throw new TypeError('a Range is required')
+ }
+
+ return this.set.some(function (thisComparators) {
+ return (
+ isSatisfiable(thisComparators, options) &&
+ range.set.some(function (rangeComparators) {
+ return (
+ isSatisfiable(rangeComparators, options) &&
+ thisComparators.every(function (thisComparator) {
+ return rangeComparators.every(function (rangeComparator) {
+ return thisComparator.intersects(rangeComparator, options)
+ })
+ })
+ )
+ })
+ )
+ })
+}
+
+// take a set of comparators and determine whether there
+// exists a version which can satisfy it
+function isSatisfiable (comparators, options) {
+ var result = true
+ var remainingComparators = comparators.slice()
+ var testComparator = remainingComparators.pop()
+
+ while (result && remainingComparators.length) {
+ result = remainingComparators.every(function (otherComparator) {
+ return testComparator.intersects(otherComparator, options)
+ })
+
+ testComparator = remainingComparators.pop()
+ }
+
+ return result
+}
+
+// Mostly just for testing and legacy API reasons
+exports.toComparators = toComparators
+function toComparators (range, options) {
+ return new Range(range, options).set.map(function (comp) {
+ return comp.map(function (c) {
+ return c.value
+ }).join(' ').trim().split(' ')
+ })
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+function parseComparator (comp, options) {
+ debug('comp', comp, options)
+ comp = replaceCarets(comp, options)
+ debug('caret', comp)
+ comp = replaceTildes(comp, options)
+ debug('tildes', comp)
+ comp = replaceXRanges(comp, options)
+ debug('xrange', comp)
+ comp = replaceStars(comp, options)
+ debug('stars', comp)
+ return comp
+}
+
+function isX (id) {
+ return !id || id.toLowerCase() === 'x' || id === '*'
+}
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes (comp, options) {
+ return comp.trim().split(/\s+/).map(function (comp) {
+ return replaceTilde(comp, options)
+ }).join(' ')
+}
+
+function replaceTilde (comp, options) {
+ var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
+ return comp.replace(r, function (_, M, m, p, pr) {
+ debug('tilde', comp, _, M, m, p, pr)
+ var ret
+
+ if (isX(M)) {
+ ret = ''
+ } else if (isX(m)) {
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+ } else if (isX(p)) {
+ // ~1.2 == >=1.2.0 <1.3.0
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+ } else if (pr) {
+ debug('replaceTilde pr', pr)
+ ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+ ' <' + M + '.' + (+m + 1) + '.0'
+ } else {
+ // ~1.2.3 == >=1.2.3 <1.3.0
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0'
+ }
+
+ debug('tilde return', ret)
+ return ret
+ })
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets (comp, options) {
+ return comp.trim().split(/\s+/).map(function (comp) {
+ return replaceCaret(comp, options)
+ }).join(' ')
+}
+
+function replaceCaret (comp, options) {
+ debug('caret', comp, options)
+ var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
+ return comp.replace(r, function (_, M, m, p, pr) {
+ debug('caret', comp, _, M, m, p, pr)
+ var ret
+
+ if (isX(M)) {
+ ret = ''
+ } else if (isX(m)) {
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+ } else if (isX(p)) {
+ if (M === '0') {
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+ } else {
+ ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'
+ }
+ } else if (pr) {
+ debug('replaceCaret pr', pr)
+ if (M === '0') {
+ if (m === '0') {
+ ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+ ' <' + M + '.' + m + '.' + (+p + 1)
+ } else {
+ ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+ ' <' + M + '.' + (+m + 1) + '.0'
+ }
+ } else {
+ ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+ ' <' + (+M + 1) + '.0.0'
+ }
+ } else {
+ debug('no pr')
+ if (M === '0') {
+ if (m === '0') {
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + m + '.' + (+p + 1)
+ } else {
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0'
+ }
+ } else {
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + (+M + 1) + '.0.0'
+ }
+ }
+
+ debug('caret return', ret)
+ return ret
+ })
+}
+
+function replaceXRanges (comp, options) {
+ debug('replaceXRanges', comp, options)
+ return comp.split(/\s+/).map(function (comp) {
+ return replaceXRange(comp, options)
+ }).join(' ')
+}
+
+function replaceXRange (comp, options) {
+ comp = comp.trim()
+ var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
+ return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
+ debug('xRange', comp, ret, gtlt, M, m, p, pr)
+ var xM = isX(M)
+ var xm = xM || isX(m)
+ var xp = xm || isX(p)
+ var anyX = xp
+
+ if (gtlt === '=' && anyX) {
+ gtlt = ''
+ }
+
+ // if we're including prereleases in the match, then we need
+ // to fix this to -0, the lowest possible prerelease value
+ pr = options.includePrerelease ? '-0' : ''
+
+ if (xM) {
+ if (gtlt === '>' || gtlt === '<') {
+ // nothing is allowed
+ ret = '<0.0.0-0'
+ } else {
+ // nothing is forbidden
+ ret = '*'
+ }
+ } else if (gtlt && anyX) {
+ // we know patch is an x, because we have any x at all.
+ // replace X with 0
+ if (xm) {
+ m = 0
+ }
+ p = 0
+
+ if (gtlt === '>') {
+ // >1 => >=2.0.0
+ // >1.2 => >=1.3.0
+ // >1.2.3 => >= 1.2.4
+ gtlt = '>='
+ if (xm) {
+ M = +M + 1
+ m = 0
+ p = 0
+ } else {
+ m = +m + 1
+ p = 0
+ }
+ } else if (gtlt === '<=') {
+ // <=0.7.x is actually <0.8.0, since any 0.7.x should
+ // pass. Similarly, <=7.x is actually <8.0.0, etc.
+ gtlt = '<'
+ if (xm) {
+ M = +M + 1
+ } else {
+ m = +m + 1
+ }
+ }
+
+ ret = gtlt + M + '.' + m + '.' + p + pr
+ } else if (xm) {
+ ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr
+ } else if (xp) {
+ ret = '>=' + M + '.' + m + '.0' + pr +
+ ' <' + M + '.' + (+m + 1) + '.0' + pr
+ }
+
+ debug('xRange return', ret)
+
+ return ret
+ })
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars (comp, options) {
+ debug('replaceStars', comp, options)
+ // Looseness is ignored here. star is always as loose as it gets!
+ return comp.trim().replace(re[t.STAR], '')
+}
+
+// This function is passed to string.replace(re[t.HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0
+function hyphenReplace ($0,
+ from, fM, fm, fp, fpr, fb,
+ to, tM, tm, tp, tpr, tb) {
+ if (isX(fM)) {
+ from = ''
+ } else if (isX(fm)) {
+ from = '>=' + fM + '.0.0'
+ } else if (isX(fp)) {
+ from = '>=' + fM + '.' + fm + '.0'
+ } else {
+ from = '>=' + from
+ }
+
+ if (isX(tM)) {
+ to = ''
+ } else if (isX(tm)) {
+ to = '<' + (+tM + 1) + '.0.0'
+ } else if (isX(tp)) {
+ to = '<' + tM + '.' + (+tm + 1) + '.0'
+ } else if (tpr) {
+ to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr
+ } else {
+ to = '<=' + to
+ }
+
+ return (from + ' ' + to).trim()
+}
+
+// if ANY of the sets match ALL of its comparators, then pass
+Range.prototype.test = function (version) {
+ if (!version) {
+ return false
+ }
+
+ if (typeof version === 'string') {
+ try {
+ version = new SemVer(version, this.options)
+ } catch (er) {
+ return false
+ }
+ }
+
+ for (var i = 0; i < this.set.length; i++) {
+ if (testSet(this.set[i], version, this.options)) {
+ return true
+ }
+ }
+ return false
+}
+
+function testSet (set, version, options) {
+ for (var i = 0; i < set.length; i++) {
+ if (!set[i].test(version)) {
+ return false
+ }
+ }
+
+ if (version.prerelease.length && !options.includePrerelease) {
+ // Find the set of versions that are allowed to have prereleases
+ // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+ // That should allow `1.2.3-pr.2` to pass.
+ // However, `1.2.4-alpha.notready` should NOT be allowed,
+ // even though it's within the range set by the comparators.
+ for (i = 0; i < set.length; i++) {
+ debug(set[i].semver)
+ if (set[i].semver === ANY) {
+ continue
+ }
+
+ if (set[i].semver.prerelease.length > 0) {
+ var allowed = set[i].semver
+ if (allowed.major === version.major &&
+ allowed.minor === version.minor &&
+ allowed.patch === version.patch) {
+ return true
+ }
+ }
+ }
+
+ // Version has a -pre, but it's not one of the ones we like.
+ return false
+ }
+
+ return true
+}
+
+exports.satisfies = satisfies
+function satisfies (version, range, options) {
+ try {
+ range = new Range(range, options)
+ } catch (er) {
+ return false
+ }
+ return range.test(version)
+}
+
+exports.maxSatisfying = maxSatisfying
+function maxSatisfying (versions, range, options) {
+ var max = null
+ var maxSV = null
+ try {
+ var rangeObj = new Range(range, options)
+ } catch (er) {
+ return null
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) {
+ // satisfies(v, range, options)
+ if (!max || maxSV.compare(v) === -1) {
+ // compare(max, v, true)
+ max = v
+ maxSV = new SemVer(max, options)
+ }
+ }
+ })
+ return max
+}
+
+exports.minSatisfying = minSatisfying
+function minSatisfying (versions, range, options) {
+ var min = null
+ var minSV = null
+ try {
+ var rangeObj = new Range(range, options)
+ } catch (er) {
+ return null
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) {
+ // satisfies(v, range, options)
+ if (!min || minSV.compare(v) === 1) {
+ // compare(min, v, true)
+ min = v
+ minSV = new SemVer(min, options)
+ }
+ }
+ })
+ return min
+}
+
+exports.minVersion = minVersion
+function minVersion (range, loose) {
+ range = new Range(range, loose)
+
+ var minver = new SemVer('0.0.0')
+ if (range.test(minver)) {
+ return minver
+ }
+
+ minver = new SemVer('0.0.0-0')
+ if (range.test(minver)) {
+ return minver
+ }
+
+ minver = null
+ for (var i = 0; i < range.set.length; ++i) {
+ var comparators = range.set[i]
+
+ comparators.forEach(function (comparator) {
+ // Clone to avoid manipulating the comparator's semver object.
+ var compver = new SemVer(comparator.semver.version)
+ switch (comparator.operator) {
+ case '>':
+ if (compver.prerelease.length === 0) {
+ compver.patch++
+ } else {
+ compver.prerelease.push(0)
+ }
+ compver.raw = compver.format()
+ /* fallthrough */
+ case '':
+ case '>=':
+ if (!minver || gt(minver, compver)) {
+ minver = compver
+ }
+ break
+ case '<':
+ case '<=':
+ /* Ignore maximum versions */
+ break
+ /* istanbul ignore next */
+ default:
+ throw new Error('Unexpected operation: ' + comparator.operator)
+ }
+ })
+ }
+
+ if (minver && range.test(minver)) {
+ return minver
+ }
+
+ return null
+}
+
+exports.validRange = validRange
+function validRange (range, options) {
+ try {
+ // Return '*' instead of '' so that truthiness works.
+ // This will throw if it's invalid anyway
+ return new Range(range, options).range || '*'
+ } catch (er) {
+ return null
+ }
+}
+
+// Determine if version is less than all the versions possible in the range
+exports.ltr = ltr
+function ltr (version, range, options) {
+ return outside(version, range, '<', options)
+}
+
+// Determine if version is greater than all the versions possible in the range.
+exports.gtr = gtr
+function gtr (version, range, options) {
+ return outside(version, range, '>', options)
+}
+
+exports.outside = outside
+function outside (version, range, hilo, options) {
+ version = new SemVer(version, options)
+ range = new Range(range, options)
+
+ var gtfn, ltefn, ltfn, comp, ecomp
+ switch (hilo) {
+ case '>':
+ gtfn = gt
+ ltefn = lte
+ ltfn = lt
+ comp = '>'
+ ecomp = '>='
+ break
+ case '<':
+ gtfn = lt
+ ltefn = gte
+ ltfn = gt
+ comp = '<'
+ ecomp = '<='
+ break
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"')
+ }
+
+ // If it satisifes the range it is not outside
+ if (satisfies(version, range, options)) {
+ return false
+ }
+
+ // From now on, variable terms are as if we're in "gtr" mode.
+ // but note that everything is flipped for the "ltr" function.
+
+ for (var i = 0; i < range.set.length; ++i) {
+ var comparators = range.set[i]
+
+ var high = null
+ var low = null
+
+ comparators.forEach(function (comparator) {
+ if (comparator.semver === ANY) {
+ comparator = new Comparator('>=0.0.0')
+ }
+ high = high || comparator
+ low = low || comparator
+ if (gtfn(comparator.semver, high.semver, options)) {
+ high = comparator
+ } else if (ltfn(comparator.semver, low.semver, options)) {
+ low = comparator
+ }
+ })
+
+ // If the edge version comparator has a operator then our version
+ // isn't outside it
+ if (high.operator === comp || high.operator === ecomp) {
+ return false
+ }
+
+ // If the lowest version comparator has an operator and our version
+ // is less than it then it isn't higher than the range
+ if ((!low.operator || low.operator === comp) &&
+ ltefn(version, low.semver)) {
+ return false
+ } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+ return false
+ }
+ }
+ return true
+}
+
+exports.prerelease = prerelease
+function prerelease (version, options) {
+ var parsed = parse(version, options)
+ return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+}
+
+exports.intersects = intersects
+function intersects (r1, r2, options) {
+ r1 = new Range(r1, options)
+ r2 = new Range(r2, options)
+ return r1.intersects(r2)
+}
+
+exports.coerce = coerce
+function coerce (version, options) {
+ if (version instanceof SemVer) {
+ return version
+ }
+
+ if (typeof version === 'number') {
+ version = String(version)
+ }
+
+ if (typeof version !== 'string') {
+ return null
+ }
+
+ options = options || {}
+
+ var match = null
+ if (!options.rtl) {
+ match = version.match(re[t.COERCE])
+ } else {
+ // Find the right-most coercible string that does not share
+ // a terminus with a more left-ward coercible string.
+ // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+ //
+ // Walk through the string checking with a /g regexp
+ // Manually set the index so as to pick up overlapping matches.
+ // Stop when we get a match that ends at the string end, since no
+ // coercible string can be more right-ward without the same terminus.
+ var next
+ while ((next = re[t.COERCERTL].exec(version)) &&
+ (!match || match.index + match[0].length !== version.length)
+ ) {
+ if (!match ||
+ next.index + next[0].length !== match.index + match[0].length) {
+ match = next
+ }
+ re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
+ }
+ // leave it in a clean state
+ re[t.COERCERTL].lastIndex = -1
+ }
+
+ if (match === null) {
+ return null
+ }
+
+ return parse(match[2] +
+ '.' + (match[3] || '0') +
+ '.' + (match[4] || '0'), options)
+}
diff --git a/node_modules/imagemin/node_modules/slash/index.d.ts b/node_modules/imagemin/node_modules/slash/index.d.ts
new file mode 100644
index 0000000..f9d07d1
--- /dev/null
+++ b/node_modules/imagemin/node_modules/slash/index.d.ts
@@ -0,0 +1,25 @@
+/**
+Convert Windows backslash paths to slash paths: `foo\\bar` ➔ `foo/bar`.
+
+[Forward-slash paths can be used in Windows](http://superuser.com/a/176395/6877) as long as they're not extended-length paths and don't contain any non-ascii characters.
+
+@param path - A Windows backslash path.
+@returns A path with forward slashes.
+
+@example
+```
+import * as path from 'path';
+import slash = require('slash');
+
+const string = path.join('foo', 'bar');
+// Unix => foo/bar
+// Windows => foo\\bar
+
+slash(string);
+// Unix => foo/bar
+// Windows => foo/bar
+```
+*/
+declare function slash(path: string): string;
+
+export = slash;
diff --git a/node_modules/imagemin/node_modules/slash/index.js b/node_modules/imagemin/node_modules/slash/index.js
new file mode 100644
index 0000000..103fbea
--- /dev/null
+++ b/node_modules/imagemin/node_modules/slash/index.js
@@ -0,0 +1,11 @@
+'use strict';
+module.exports = path => {
+ const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+ const hasNonAscii = /[^\u0000-\u0080]+/.test(path); // eslint-disable-line no-control-regex
+
+ if (isExtendedLengthPath || hasNonAscii) {
+ return path;
+ }
+
+ return path.replace(/\\/g, '/');
+};
diff --git a/node_modules/imagemin/node_modules/slash/license b/node_modules/imagemin/node_modules/slash/license
new file mode 100644
index 0000000..e7af2f7
--- /dev/null
+++ b/node_modules/imagemin/node_modules/slash/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/slash/package.json b/node_modules/imagemin/node_modules/slash/package.json
new file mode 100644
index 0000000..a871b1f
--- /dev/null
+++ b/node_modules/imagemin/node_modules/slash/package.json
@@ -0,0 +1,67 @@
+{
+ "_from": "slash@^3.0.0",
+ "_id": "slash@3.0.0",
+ "_inBundle": false,
+ "_integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
+ "_location": "/imagemin/slash",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "slash@^3.0.0",
+ "name": "slash",
+ "escapedName": "slash",
+ "rawSpec": "^3.0.0",
+ "saveSpec": null,
+ "fetchSpec": "^3.0.0"
+ },
+ "_requiredBy": [
+ "/imagemin/globby"
+ ],
+ "_resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
+ "_shasum": "6539be870c165adbd5240220dbe361f1bc4d4634",
+ "_spec": "slash@^3.0.0",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\globby",
+ "author": {
+ "name": "Sindre Sorhus",
+ "email": "sindresorhus@gmail.com",
+ "url": "sindresorhus.com"
+ },
+ "bugs": {
+ "url": "https://github.com/sindresorhus/slash/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "Convert Windows backslash paths to slash paths",
+ "devDependencies": {
+ "ava": "^1.4.1",
+ "tsd": "^0.7.2",
+ "xo": "^0.24.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js",
+ "index.d.ts"
+ ],
+ "homepage": "https://github.com/sindresorhus/slash#readme",
+ "keywords": [
+ "path",
+ "seperator",
+ "slash",
+ "backslash",
+ "windows",
+ "convert"
+ ],
+ "license": "MIT",
+ "name": "slash",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/sindresorhus/slash.git"
+ },
+ "scripts": {
+ "test": "xo && ava && tsd"
+ },
+ "version": "3.0.0"
+}
diff --git a/node_modules/imagemin/node_modules/slash/readme.md b/node_modules/imagemin/node_modules/slash/readme.md
new file mode 100644
index 0000000..f0ef4ac
--- /dev/null
+++ b/node_modules/imagemin/node_modules/slash/readme.md
@@ -0,0 +1,44 @@
+# slash [](https://travis-ci.org/sindresorhus/slash)
+
+> Convert Windows backslash paths to slash paths: `foo\\bar` ➔ `foo/bar`
+
+[Forward-slash paths can be used in Windows](http://superuser.com/a/176395/6877) as long as they're not extended-length paths and don't contain any non-ascii characters.
+
+This was created since the `path` methods in Node.js outputs `\\` paths on Windows.
+
+
+## Install
+
+```
+$ npm install slash
+```
+
+
+## Usage
+
+```js
+const path = require('path');
+const slash = require('slash');
+
+const string = path.join('foo', 'bar');
+// Unix => foo/bar
+// Windows => foo\\bar
+
+slash(string);
+// Unix => foo/bar
+// Windows => foo/bar
+```
+
+
+## API
+
+### slash(path)
+
+Type: `string`
+
+Accepts a Windows backslash path and returns a path with forward slashes.
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)
diff --git a/node_modules/imagemin/node_modules/to-regex-range/LICENSE b/node_modules/imagemin/node_modules/to-regex-range/LICENSE
new file mode 100644
index 0000000..7cccaf9
--- /dev/null
+++ b/node_modules/imagemin/node_modules/to-regex-range/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/imagemin/node_modules/to-regex-range/README.md b/node_modules/imagemin/node_modules/to-regex-range/README.md
new file mode 100644
index 0000000..38887da
--- /dev/null
+++ b/node_modules/imagemin/node_modules/to-regex-range/README.md
@@ -0,0 +1,305 @@
+# to-regex-range [](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [](https://www.npmjs.com/package/to-regex-range) [](https://npmjs.org/package/to-regex-range) [](https://npmjs.org/package/to-regex-range) [](https://travis-ci.org/micromatch/to-regex-range)
+
+> Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than 2.78 million test assertions.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save to-regex-range
+```
+
+<details>
+<summary><strong>What does this do?</strong></summary>
+
+<br>
+
+This libary generates the `source` string to be passed to `new RegExp()` for matching a range of numbers.
+
+**Example**
+
+```js
+const toRegexRange = require('to-regex-range');
+const regex = new RegExp(toRegexRange('15', '95'));
+```
+
+A string is returned so that you can do whatever you need with it before passing it to `new RegExp()` (like adding `^` or `$` boundaries, defining flags, or combining it another string).
+
+<br>
+
+</details>
+
+<details>
+<summary><strong>Why use this library?</strong></summary>
+
+<br>
+
+### Convenience
+
+Creating regular expressions for matching numbers gets deceptively complicated pretty fast.
+
+For example, let's say you need a validation regex for matching part of a user-id, postal code, social security number, tax id, etc:
+
+* regex for matching `1` => `/1/` (easy enough)
+* regex for matching `1` through `5` => `/[1-5]/` (not bad...)
+* regex for matching `1` or `5` => `/(1|5)/` (still easy...)
+* regex for matching `1` through `50` => `/([1-9]|[1-4][0-9]|50)/` (uh-oh...)
+* regex for matching `1` through `55` => `/([1-9]|[1-4][0-9]|5[0-5])/` (no prob, I can do this...)
+* regex for matching `1` through `555` => `/([1-9]|[1-9][0-9]|[1-4][0-9]{2}|5[0-4][0-9]|55[0-5])/` (maybe not...)
+* regex for matching `0001` through `5555` => `/(0{3}[1-9]|0{2}[1-9][0-9]|0[1-9][0-9]{2}|[1-4][0-9]{3}|5[0-4][0-9]{2}|55[0-4][0-9]|555[0-5])/` (okay, I get the point!)
+
+The numbers are contrived, but they're also really basic. In the real world you might need to generate a regex on-the-fly for validation.
+
+**Learn more**
+
+If you're interested in learning more about [character classes](http://www.regular-expressions.info/charclass.html) and other regex features, I personally have always found [regular-expressions.info](http://www.regular-expressions.info/charclass.html) to be pretty useful.
+
+### Heavily tested
+
+As of April 07, 2019, this library runs [>1m test assertions](./test/test.js) against generated regex-ranges to provide brute-force verification that results are correct.
+
+Tests run in ~280ms on my MacBook Pro, 2.5 GHz Intel Core i7.
+
+### Optimized
+
+Generated regular expressions are optimized:
+
+* duplicate sequences and character classes are reduced using quantifiers
+* smart enough to use `?` conditionals when number(s) or range(s) can be positive or negative
+* uses fragment caching to avoid processing the same exact string more than once
+
+<br>
+
+</details>
+
+## Usage
+
+Add this library to your javascript application with the following line of code
+
+```js
+const toRegexRange = require('to-regex-range');
+```
+
+The main export is a function that takes two integers: the `min` value and `max` value (formatted as strings or numbers).
+
+```js
+const source = toRegexRange('15', '95');
+//=> 1[5-9]|[2-8][0-9]|9[0-5]
+
+const regex = new RegExp(`^${source}$`);
+console.log(regex.test('14')); //=> false
+console.log(regex.test('50')); //=> true
+console.log(regex.test('94')); //=> true
+console.log(regex.test('96')); //=> false
+```
+
+## Options
+
+### options.capture
+
+**Type**: `boolean`
+
+**Deafault**: `undefined`
+
+Wrap the returned value in parentheses when there is more than one regex condition. Useful when you're dynamically generating ranges.
+
+```js
+console.log(toRegexRange('-10', '10'));
+//=> -[1-9]|-?10|[0-9]
+
+console.log(toRegexRange('-10', '10', { capture: true }));
+//=> (-[1-9]|-?10|[0-9])
+```
+
+### options.shorthand
+
+**Type**: `boolean`
+
+**Deafault**: `undefined`
+
+Use the regex shorthand for `[0-9]`:
+
+```js
+console.log(toRegexRange('0', '999999'));
+//=> [0-9]|[1-9][0-9]{1,5}
+
+console.log(toRegexRange('0', '999999', { shorthand: true }));
+//=> \d|[1-9]\d{1,5}
+```
+
+### options.relaxZeros
+
+**Type**: `boolean`
+
+**Default**: `true`
+
+This option relaxes matching for leading zeros when when ranges are zero-padded.
+
+```js
+const source = toRegexRange('-0010', '0010');
+const regex = new RegExp(`^${source}$`);
+console.log(regex.test('-10')); //=> true
+console.log(regex.test('-010')); //=> true
+console.log(regex.test('-0010')); //=> true
+console.log(regex.test('10')); //=> true
+console.log(regex.test('010')); //=> true
+console.log(regex.test('0010')); //=> true
+```
+
+When `relaxZeros` is false, matching is strict:
+
+```js
+const source = toRegexRange('-0010', '0010', { relaxZeros: false });
+const regex = new RegExp(`^${source}$`);
+console.log(regex.test('-10')); //=> false
+console.log(regex.test('-010')); //=> false
+console.log(regex.test('-0010')); //=> true
+console.log(regex.test('10')); //=> false
+console.log(regex.test('010')); //=> false
+console.log(regex.test('0010')); //=> true
+```
+
+## Examples
+
+| **Range** | **Result** | **Compile time** |
+| --- | --- | --- |
+| `toRegexRange(-10, 10)` | `-[1-9]\|-?10\|[0-9]` | _132μs_ |
+| `toRegexRange(-100, -10)` | `-1[0-9]\|-[2-9][0-9]\|-100` | _50μs_ |
+| `toRegexRange(-100, 100)` | `-[1-9]\|-?[1-9][0-9]\|-?100\|[0-9]` | _42μs_ |
+| `toRegexRange(001, 100)` | `0{0,2}[1-9]\|0?[1-9][0-9]\|100` | _109μs_ |
+| `toRegexRange(001, 555)` | `0{0,2}[1-9]\|0?[1-9][0-9]\|[1-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]` | _51μs_ |
+| `toRegexRange(0010, 1000)` | `0{0,2}1[0-9]\|0{0,2}[2-9][0-9]\|0?[1-9][0-9]{2}\|1000` | _31μs_ |
+| `toRegexRange(1, 50)` | `[1-9]\|[1-4][0-9]\|50` | _24μs_ |
+| `toRegexRange(1, 55)` | `[1-9]\|[1-4][0-9]\|5[0-5]` | _23μs_ |
+| `toRegexRange(1, 555)` | `[1-9]\|[1-9][0-9]\|[1-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]` | _30μs_ |
+| `toRegexRange(1, 5555)` | `[1-9]\|[1-9][0-9]{1,2}\|[1-4][0-9]{3}\|5[0-4][0-9]{2}\|55[0-4][0-9]\|555[0-5]` | _43μs_ |
+| `toRegexRange(111, 555)` | `11[1-9]\|1[2-9][0-9]\|[2-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]` | _38μs_ |
+| `toRegexRange(29, 51)` | `29\|[34][0-9]\|5[01]` | _24μs_ |
+| `toRegexRange(31, 877)` | `3[1-9]\|[4-9][0-9]\|[1-7][0-9]{2}\|8[0-6][0-9]\|87[0-7]` | _32μs_ |
+| `toRegexRange(5, 5)` | `5` | _8μs_ |
+| `toRegexRange(5, 6)` | `5\|6` | _11μs_ |
+| `toRegexRange(1, 2)` | `1\|2` | _6μs_ |
+| `toRegexRange(1, 5)` | `[1-5]` | _15μs_ |
+| `toRegexRange(1, 10)` | `[1-9]\|10` | _22μs_ |
+| `toRegexRange(1, 100)` | `[1-9]\|[1-9][0-9]\|100` | _25μs_ |
+| `toRegexRange(1, 1000)` | `[1-9]\|[1-9][0-9]{1,2}\|1000` | _31μs_ |
+| `toRegexRange(1, 10000)` | `[1-9]\|[1-9][0-9]{1,3}\|10000` | _34μs_ |
+| `toRegexRange(1, 100000)` | `[1-9]\|[1-9][0-9]{1,4}\|100000` | _36μs_ |
+| `toRegexRange(1, 1000000)` | `[1-9]\|[1-9][0-9]{1,5}\|1000000` | _42μs_ |
+| `toRegexRange(1, 10000000)` | `[1-9]\|[1-9][0-9]{1,6}\|10000000` | _42μs_ |
+
+## Heads up!
+
+**Order of arguments**
+
+When the `min` is larger than the `max`, values will be flipped to create a valid range:
+
+```js
+toRegexRange('51', '29');
+```
+
+Is effectively flipped to:
+
+```js
+toRegexRange('29', '51');
+//=> 29|[3-4][0-9]|5[0-1]
+```
+
+**Steps / increments**
+
+This library does not support steps (increments). A pr to add support would be welcome.
+
+## History
+
+### v2.0.0 - 2017-04-21
+
+**New features**
+
+Adds support for zero-padding!
+
+### v1.0.0
+
+**Optimizations**
+
+Repeating ranges are now grouped using quantifiers. rocessing time is roughly the same, but the generated regex is much smaller, which should result in faster matching.
+
+## Attribution
+
+Inspired by the python library [range-regex](https://github.com/dimka665/range-regex).
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+$ npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+$ npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [expand-range](https://www.npmjs.com/package/expand-range): Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. Used… [more](https://github.com/jonschlinkert/expand-range) | [homepage](https://github.com/jonschlinkert/expand-range "Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. Used by micromatch.")
+* [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or `step` to… [more](https://github.com/jonschlinkert/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`")
+* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/micromatch/micromatch "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.")
+* [repeat-element](https://www.npmjs.com/package/repeat-element): Create an array by repeating the given value n times. | [homepage](https://github.com/jonschlinkert/repeat-element "Create an array by repeating the given value n times.")
+* [repeat-string](https://www.npmjs.com/package/repeat-string): Repeat the given string n times. Fastest implementation for repeating a string. | [homepage](https://github.com/jonschlinkert/repeat-string "Repeat the given string n times. Fastest implementation for repeating a string.")
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 63 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 3 | [doowb](https://github.com/doowb) |
+| 2 | [realityking](https://github.com/realityking) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+Please consider supporting me on Patreon, or [start your own Patreon page](https://patreon.com/invite/bxpbvm)!
+
+<a href="https://www.patreon.com/jonschlinkert">
+<img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" height="50">
+</a>
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 07, 2019._
\ No newline at end of file
diff --git a/node_modules/imagemin/node_modules/to-regex-range/index.js b/node_modules/imagemin/node_modules/to-regex-range/index.js
new file mode 100644
index 0000000..77fbace
--- /dev/null
+++ b/node_modules/imagemin/node_modules/to-regex-range/index.js
@@ -0,0 +1,288 @@
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+const isNumber = require('is-number');
+
+const toRegexRange = (min, max, options) => {
+ if (isNumber(min) === false) {
+ throw new TypeError('toRegexRange: expected the first argument to be a number');
+ }
+
+ if (max === void 0 || min === max) {
+ return String(min);
+ }
+
+ if (isNumber(max) === false) {
+ throw new TypeError('toRegexRange: expected the second argument to be a number.');
+ }
+
+ let opts = { relaxZeros: true, ...options };
+ if (typeof opts.strictZeros === 'boolean') {
+ opts.relaxZeros = opts.strictZeros === false;
+ }
+
+ let relax = String(opts.relaxZeros);
+ let shorthand = String(opts.shorthand);
+ let capture = String(opts.capture);
+ let wrap = String(opts.wrap);
+ let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+
+ if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
+ return toRegexRange.cache[cacheKey].result;
+ }
+
+ let a = Math.min(min, max);
+ let b = Math.max(min, max);
+
+ if (Math.abs(a - b) === 1) {
+ let result = min + '|' + max;
+ if (opts.capture) {
+ return `(${result})`;
+ }
+ if (opts.wrap === false) {
+ return result;
+ }
+ return `(?:${result})`;
+ }
+
+ let isPadded = hasPadding(min) || hasPadding(max);
+ let state = { min, max, a, b };
+ let positives = [];
+ let negatives = [];
+
+ if (isPadded) {
+ state.isPadded = isPadded;
+ state.maxLen = String(state.max).length;
+ }
+
+ if (a < 0) {
+ let newMin = b < 0 ? Math.abs(b) : 1;
+ negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+ a = state.a = 0;
+ }
+
+ if (b >= 0) {
+ positives = splitToPatterns(a, b, state, opts);
+ }
+
+ state.negatives = negatives;
+ state.positives = positives;
+ state.result = collatePatterns(negatives, positives, opts);
+
+ if (opts.capture === true) {
+ state.result = `(${state.result})`;
+ } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+ state.result = `(?:${state.result})`;
+ }
+
+ toRegexRange.cache[cacheKey] = state;
+ return state.result;
+};
+
+function collatePatterns(neg, pos, options) {
+ let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];
+ let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];
+ let intersected = filterPatterns(neg, pos, '-?', true, options) || [];
+ let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+ return subpatterns.join('|');
+}
+
+function splitToRanges(min, max) {
+ let nines = 1;
+ let zeros = 1;
+
+ let stop = countNines(min, nines);
+ let stops = new Set([max]);
+
+ while (min <= stop && stop <= max) {
+ stops.add(stop);
+ nines += 1;
+ stop = countNines(min, nines);
+ }
+
+ stop = countZeros(max + 1, zeros) - 1;
+
+ while (min < stop && stop <= max) {
+ stops.add(stop);
+ zeros += 1;
+ stop = countZeros(max + 1, zeros) - 1;
+ }
+
+ stops = [...stops];
+ stops.sort(compare);
+ return stops;
+}
+
+/**
+ * Convert a range to a regex pattern
+ * @param {Number} `start`
+ * @param {Number} `stop`
+ * @return {String}
+ */
+
+function rangeToPattern(start, stop, options) {
+ if (start === stop) {
+ return { pattern: start, count: [], digits: 0 };
+ }
+
+ let zipped = zip(start, stop);
+ let digits = zipped.length;
+ let pattern = '';
+ let count = 0;
+
+ for (let i = 0; i < digits; i++) {
+ let [startDigit, stopDigit] = zipped[i];
+
+ if (startDigit === stopDigit) {
+ pattern += startDigit;
+
+ } else if (startDigit !== '0' || stopDigit !== '9') {
+ pattern += toCharacterClass(startDigit, stopDigit, options);
+
+ } else {
+ count++;
+ }
+ }
+
+ if (count) {
+ pattern += options.shorthand === true ? '\\d' : '[0-9]';
+ }
+
+ return { pattern, count: [count], digits };
+}
+
+function splitToPatterns(min, max, tok, options) {
+ let ranges = splitToRanges(min, max);
+ let tokens = [];
+ let start = min;
+ let prev;
+
+ for (let i = 0; i < ranges.length; i++) {
+ let max = ranges[i];
+ let obj = rangeToPattern(String(start), String(max), options);
+ let zeros = '';
+
+ if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+ if (prev.count.length > 1) {
+ prev.count.pop();
+ }
+
+ prev.count.push(obj.count[0]);
+ prev.string = prev.pattern + toQuantifier(prev.count);
+ start = max + 1;
+ continue;
+ }
+
+ if (tok.isPadded) {
+ zeros = padZeros(max, tok, options);
+ }
+
+ obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+ tokens.push(obj);
+ start = max + 1;
+ prev = obj;
+ }
+
+ return tokens;
+}
+
+function filterPatterns(arr, comparison, prefix, intersection, options) {
+ let result = [];
+
+ for (let ele of arr) {
+ let { string } = ele;
+
+ // only push if _both_ are negative...
+ if (!intersection && !contains(comparison, 'string', string)) {
+ result.push(prefix + string);
+ }
+
+ // or _both_ are positive
+ if (intersection && contains(comparison, 'string', string)) {
+ result.push(prefix + string);
+ }
+ }
+ return result;
+}
+
+/**
+ * Zip strings
+ */
+
+function zip(a, b) {
+ let arr = [];
+ for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+ return arr;
+}
+
+function compare(a, b) {
+ return a > b ? 1 : b > a ? -1 : 0;
+}
+
+function contains(arr, key, val) {
+ return arr.some(ele => ele[key] === val);
+}
+
+function countNines(min, len) {
+ return Number(String(min).slice(0, -len) + '9'.repeat(len));
+}
+
+function countZeros(integer, zeros) {
+ return integer - (integer % Math.pow(10, zeros));
+}
+
+function toQuantifier(digits) {
+ let [start = 0, stop = ''] = digits;
+ if (stop || start > 1) {
+ return `{${start + (stop ? ',' + stop : '')}}`;
+ }
+ return '';
+}
+
+function toCharacterClass(a, b, options) {
+ return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+}
+
+function hasPadding(str) {
+ return /^-?(0+)\d/.test(str);
+}
+
+function padZeros(value, tok, options) {
+ if (!tok.isPadded) {
+ return value;
+ }
+
+ let diff = Math.abs(tok.maxLen - String(value).length);
+ let relax = options.relaxZeros !== false;
+
+ switch (diff) {
+ case 0:
+ return '';
+ case 1:
+ return relax ? '0?' : '0';
+ case 2:
+ return relax ? '0{0,2}' : '00';
+ default: {
+ return relax ? `0{0,${diff}}` : `0{${diff}}`;
+ }
+ }
+}
+
+/**
+ * Cache
+ */
+
+toRegexRange.cache = {};
+toRegexRange.clearCache = () => (toRegexRange.cache = {});
+
+/**
+ * Expose `toRegexRange`
+ */
+
+module.exports = toRegexRange;
diff --git a/node_modules/imagemin/node_modules/to-regex-range/package.json b/node_modules/imagemin/node_modules/to-regex-range/package.json
new file mode 100644
index 0000000..8d1f39b
--- /dev/null
+++ b/node_modules/imagemin/node_modules/to-regex-range/package.json
@@ -0,0 +1,125 @@
+{
+ "_from": "to-regex-range@^5.0.1",
+ "_id": "to-regex-range@5.0.1",
+ "_inBundle": false,
+ "_integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+ "_location": "/imagemin/to-regex-range",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "to-regex-range@^5.0.1",
+ "name": "to-regex-range",
+ "escapedName": "to-regex-range",
+ "rawSpec": "^5.0.1",
+ "saveSpec": null,
+ "fetchSpec": "^5.0.1"
+ },
+ "_requiredBy": [
+ "/imagemin/fill-range"
+ ],
+ "_resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+ "_shasum": "1648c44aae7c8d988a326018ed72f5b4dd0392e4",
+ "_spec": "to-regex-range@^5.0.1",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar\\node_modules\\imagemin\\node_modules\\fill-range",
+ "author": {
+ "name": "Jon Schlinkert",
+ "url": "https://github.com/jonschlinkert"
+ },
+ "bugs": {
+ "url": "https://github.com/micromatch/to-regex-range/issues"
+ },
+ "bundleDependencies": false,
+ "contributors": [
+ {
+ "name": "Jon Schlinkert",
+ "url": "http://twitter.com/jonschlinkert"
+ },
+ {
+ "name": "Rouven Weßling",
+ "url": "www.rouvenwessling.de"
+ }
+ ],
+ "dependencies": {
+ "is-number": "^7.0.0"
+ },
+ "deprecated": false,
+ "description": "Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than 2.78 million test assertions.",
+ "devDependencies": {
+ "fill-range": "^6.0.0",
+ "gulp-format-md": "^2.0.0",
+ "mocha": "^6.0.2",
+ "text-table": "^0.2.0",
+ "time-diff": "^0.3.1"
+ },
+ "engines": {
+ "node": ">=8.0"
+ },
+ "files": [
+ "index.js"
+ ],
+ "homepage": "https://github.com/micromatch/to-regex-range",
+ "keywords": [
+ "bash",
+ "date",
+ "expand",
+ "expansion",
+ "expression",
+ "glob",
+ "match",
+ "match date",
+ "match number",
+ "match numbers",
+ "match year",
+ "matches",
+ "matching",
+ "number",
+ "numbers",
+ "numerical",
+ "range",
+ "ranges",
+ "regex",
+ "regexp",
+ "regular",
+ "regular expression",
+ "sequence"
+ ],
+ "license": "MIT",
+ "main": "index.js",
+ "name": "to-regex-range",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/micromatch/to-regex-range.git"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "verb": {
+ "layout": "default",
+ "toc": false,
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "lint": {
+ "reflinks": true
+ },
+ "helpers": {
+ "examples": {
+ "displayName": "examples"
+ }
+ },
+ "related": {
+ "list": [
+ "expand-range",
+ "fill-range",
+ "micromatch",
+ "repeat-element",
+ "repeat-string"
+ ]
+ }
+ },
+ "version": "5.0.1"
+}
diff --git a/node_modules/imagemin/package.json b/node_modules/imagemin/package.json
new file mode 100644
index 0000000..e8243e1
--- /dev/null
+++ b/node_modules/imagemin/package.json
@@ -0,0 +1,85 @@
+{
+ "_from": "imagemin@^7.0.1",
+ "_id": "imagemin@7.0.1",
+ "_inBundle": false,
+ "_integrity": "sha512-33AmZ+xjZhg2JMCe+vDf6a9mzWukE7l+wAtesjE7KyteqqKjzxv7aVQeWnul1Ve26mWvEQqyPwl0OctNBfSR9w==",
+ "_location": "/imagemin",
+ "_phantomChildren": {
+ "@nodelib/fs.walk": "1.2.4",
+ "@types/glob": "7.1.3",
+ "glob": "7.1.6",
+ "is-extglob": "2.1.1",
+ "merge2": "1.4.1",
+ "picomatch": "2.2.2"
+ },
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "imagemin@^7.0.1",
+ "name": "imagemin",
+ "escapedName": "imagemin",
+ "rawSpec": "^7.0.1",
+ "saveSpec": null,
+ "fetchSpec": "^7.0.1"
+ },
+ "_requiredBy": [
+ "#DEV:/"
+ ],
+ "_resolved": "https://registry.npmjs.org/imagemin/-/imagemin-7.0.1.tgz",
+ "_shasum": "f6441ca647197632e23db7d971fffbd530c87dbf",
+ "_spec": "imagemin@^7.0.1",
+ "_where": "C:\\Users\\marcr\\Desktop\\KorAp\\Git\\Kalamar",
+ "bugs": {
+ "url": "https://github.com/imagemin/imagemin/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "file-type": "^12.0.0",
+ "globby": "^10.0.0",
+ "graceful-fs": "^4.2.2",
+ "junk": "^3.1.0",
+ "make-dir": "^3.0.0",
+ "p-pipe": "^3.0.0",
+ "replace-ext": "^1.0.0"
+ },
+ "deprecated": false,
+ "description": "Minify images seamlessly",
+ "devDependencies": {
+ "ava": "^2.1.0",
+ "del": "^4.1.1",
+ "imagemin-jpegtran": "^6.0.0",
+ "imagemin-svgo": "^7.0.0",
+ "imagemin-webp": "^5.0.0",
+ "is-jpg": "^2.0.0",
+ "tempy": "^0.3.0",
+ "xo": "^0.24.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "files": [
+ "index.js"
+ ],
+ "homepage": "https://github.com/imagemin/imagemin#readme",
+ "keywords": [
+ "minify",
+ "compress",
+ "image",
+ "images",
+ "jpeg",
+ "jpg",
+ "png",
+ "gif",
+ "svg"
+ ],
+ "license": "MIT",
+ "name": "imagemin",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/imagemin/imagemin.git"
+ },
+ "scripts": {
+ "test": "xo && ava"
+ },
+ "version": "7.0.1"
+}
diff --git a/node_modules/imagemin/readme.md b/node_modules/imagemin/readme.md
new file mode 100644
index 0000000..62d6d5b
--- /dev/null
+++ b/node_modules/imagemin/readme.md
@@ -0,0 +1,119 @@
+# imagemin [](https://travis-ci.org/imagemin/imagemin)
+
+> Minify images seamlessly
+
+---
+
+<div align="center">
+ <sup>Gumlet is helping make open source sustainable by sponsoring Sindre Sorhus.</sup>
+ <a href="https://www.gumlet.com">
+ <div>
+ <img src="https://sindresorhus.com/assets/thanks/gumlet-logo.svg" width="300"/>
+ </div>
+ <sup><b>Optimised Image Delivery made simple</b></sup>
+ </a>
+</div>
+
+---
+
+
+## Install
+
+```
+$ npm install imagemin
+```
+
+
+## Usage
+
+```js
+const imagemin = require('imagemin');
+const imageminJpegtran = require('imagemin-jpegtran');
+const imageminPngquant = require('imagemin-pngquant');
+
+(async () => {
+ const files = await imagemin(['images/*.{jpg,png}'], {
+ destination: 'build/images',
+ plugins: [
+ imageminJpegtran(),
+ imageminPngquant({
+ quality: [0.6, 0.8]
+ })
+ ]
+ });
+
+ console.log(files);
+ //=> [{data: <Buffer 89 50 4e …>, destinationPath: 'build/images/foo.jpg'}, …]
+})();
+```
+
+
+## API
+
+### imagemin(input, options?)
+
+Returns `Promise<object[]>` in the format `{data: Buffer, sourcePath: string, destinationPath: string}`.
+
+#### input
+
+Type: `string[]`
+
+File paths or [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+
+#### options
+
+Type: `object`
+
+##### destination
+
+Type: `string`
+
+Set the destination folder to where your files will be written. If no destination is specified, no files will be written.
+
+##### plugins
+
+Type: `Array`
+
+[Plugins](https://www.npmjs.com/browse/keyword/imageminplugin) to use.
+
+##### glob
+
+Type: `boolean`<br>
+Default: `true`
+
+Enable globbing when matching file paths.
+
+### imagemin.buffer(buffer, options?)
+
+Returns `Promise<Buffer>`.
+
+#### buffer
+
+Type: `Buffer`
+
+Buffer to optimize.
+
+#### options
+
+Type: `object`
+
+##### plugins
+
+Type: `Array`
+
+[Plugins](https://www.npmjs.com/browse/keyword/imageminplugin) to use.
+
+## Hosted API
+
+We also provide a hosted API for imagemin which may simplify your use case.
+
+<a href="https://imagemin.saasify.sh">
+ <img src="https://badges.saasify.sh?text=View%20Hosted%20API" height="40"/>
+</a>
+
+## Related
+
+- [imagemin-cli](https://github.com/imagemin/imagemin-cli) - CLI for this module
+- [imagemin-app](https://github.com/imagemin/imagemin-app) - GUI app for this module
+- [gulp-imagemin](https://github.com/sindresorhus/gulp-imagemin) - Gulp plugin
+- [grunt-contrib-imagemin](https://github.com/gruntjs/grunt-contrib-imagemin) - Grunt plugin