weboptimizer 2.0.1439 → 2.0.1441

package/browser.d.ts

@@ -0,0 +1,11 @@
+import { Browser, InitializedBrowser } from './type';
+export declare const browser: Browser;
+/**
+ * Provides a generic browser api in node or web contexts.
+ * @param replaceWindow - Indicates whether a potential existing window object
+ * should be replaced or not.
+ *
+ * @returns Determined environment.
+ */
+export declare const getInitializedBrowser: (replaceWindow?: boolean) => Promise<InitializedBrowser>;
+export default getInitializedBrowser;

package/configurator.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="webpack-env" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ResolvedConfiguration } from './type';
+export declare let loadedConfiguration: null | ResolvedConfiguration;
+/**
+ * Main entry point to determine current configuration.
+ * @param context - Location from where to build current application.
+ * @param currentWorkingDirectory - Current working directory to use as
+ * reference.
+ * @param commandLineArguments - Arguments to take into account.
+ * @param webOptimizerPath - Current optimizer context path.
+ * @param environment - Environment variables to take into account.
+ *
+ * @returns Nothing.
+ */
+export declare const load: (context?: string, currentWorkingDirectory?: string, commandLineArguments?: Array<string>, webOptimizerPath?: string, environment?: NodeJS.ProcessEnv) => ResolvedConfiguration;
+/**
+ * Get cached or determined configuration object.
+ * @returns Nothing.
+ */
+export declare const get: () => ResolvedConfiguration;
+export default get;

package/ejsLoader.d.ts

@@ -0,0 +1,35 @@
+import { Encoding, Mapping } from 'clientnode/type';
+import { Options, TemplateFunction as EJSTemplateFunction } from 'ejs';
+import { LoaderContext } from 'webpack';
+import { Extensions, Replacements } from './type';
+export type PreCompiledTemplateFunction = ((...parameters: Array<unknown>) => string);
+export type TemplateFunction = EJSTemplateFunction | PreCompiledTemplateFunction;
+export type CompilerOptions = Options & {
+    encoding: Encoding;
+    isString?: boolean;
+};
+export type CompileFunction = (template: string, options?: Partial<CompilerOptions>, compileSteps?: number) => TemplateFunction;
+export type LoaderConfiguration = Mapping<unknown> & {
+    compiler: Partial<CompilerOptions>;
+    compileSteps: number;
+    compress: {
+        html: Mapping<unknown>;
+        javaScript: Mapping<unknown>;
+    };
+    context: string;
+    debug: boolean;
+    extensions: Extensions;
+    locals?: Mapping<unknown>;
+    module: {
+        aliases: Mapping<string>;
+        replacements: Replacements;
+    };
+};
+/**
+ * Main transformation function.
+ * @param source - Input string to transform.
+ *
+ * @returns Transformed string.
+ */
+export declare const loader: (this: LoaderContext<LoaderConfiguration>, source: string) => string;
+export default loader;

package/helper.d.ts

@@ -0,0 +1,284 @@
+import { Encoding, Mapping } from 'clientnode/type';
+import { BuildConfiguration, Extensions, GivenInjection, GivenInjectionConfiguration, NormalizedGivenInjection, PathConfiguration, PackageDescriptor, Replacements, ResolvedBuildConfiguration, SpecificExtensions } from './type';
+export declare const KNOWN_FILE_EXTENSIONS: Array<string>;
+/**
+ * Provides a class of static methods with generic use cases.
+ */
+export declare class Helper {
+    /**
+     * Determines whether given file path is within given list of file
+     * locations.
+     * @param filePath - Path to file to check.
+     * @param locationsToCheck - Locations to take into account.
+     *
+     * @returns Value "true" if given file path is within one of given
+     * locations or "false" otherwise.
+     */
+    static isFilePathInLocation(this: void, filePath: string, locationsToCheck: Array<string>): boolean;
+    /**
+     * Strips loader informations form given module request including loader
+     * prefix and query parameter.
+     * @param moduleID - Module request to strip.
+     *
+     * @returns Given module id stripped.
+     */
+    static stripLoader(this: void, moduleID: string): string;
+    /**
+     * Converts given list of path to a normalized list with unique values.
+     * @param paths - File paths.
+     *
+     * @returns The given file path list with normalized unique values.
+     */
+    static normalizePaths(this: void, paths: Array<string>): Array<string>;
+    /**
+     * Applies file path/name placeholder replacements with given bundle
+     * associated informations.
+     * @param template - File path to process placeholder in.
+     * @param scope - Scope to use for processing.
+     *
+     * @returns Processed file path.
+     */
+    static renderFilePathTemplate(this: void, template: string, scope?: Mapping<number | string>): string;
+    /**
+     * Converts given request to a resolved request with given context
+     * embedded.
+     * @param request - Request to determine.
+     * @param context - Context of given request to resolve relative to.
+     * @param referencePath - Path to resolve local modules relative to.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param relativeModuleLocations - List of relative directory paths to
+     * search for modules in.
+     *
+     * @returns A new resolved request.
+     */
+    static applyContext(this: void, request: string, context?: string, referencePath?: string, aliases?: Mapping, moduleReplacements?: Replacements, relativeModuleLocations?: Array<string>): false | string;
+    /**
+     * Check if given request points to an external dependency not maintained
+     * by current package context.
+     * @param request - Request to determine.
+     * @param context - Context of current project.
+     * @param requestContext - Context of given request to resolve relative to.
+     * @param normalizedGivenInjection - Mapping of chunk names to modules
+     * which should be injected.
+     * @param relativeExternalModuleLocations - Array of paths where external
+     * modules take place.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param extensions - List of file and module extensions to take into
+     * account.
+     * @param referencePath - Path to resolve local modules relative to.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     * @param relativeModuleLocations - List of relative file path to search
+     * for modules in.
+     * @param packageEntryFileNames - List of package entry file names to
+     * search for. The magic name "__package__" will search for an appreciate
+     * entry in a "package.json" file.
+     * @param packageMainPropertyNames - List of package file main property
+     * names to search for package representing entry module definitions.
+     * @param packageAliasPropertyNames - List of package file alias property
+     * names to search for package specific module aliases.
+     * @param includePattern - Array of regular expressions to explicitly mark
+     * as external dependency.
+     * @param excludePattern - Array of regular expressions to explicitly mark
+     * as internal dependency.
+     * @param inPlaceNormalLibrary - Indicates whether normal libraries should
+     * be external or not.
+     * @param inPlaceDynamicLibrary - Indicates whether requests with
+     * integrated loader configurations should be marked as external or not.
+     * @param encoding - Encoding for file names to use during file traversing.
+     *
+     * @returns A new resolved request indicating whether given request is an
+     * external one.
+     */
+    static determineExternalRequest(this: void, request: string, context?: string, requestContext?: string, normalizedGivenInjection?: NormalizedGivenInjection, relativeExternalModuleLocations?: Array<string>, aliases?: Mapping, moduleReplacements?: Replacements, extensions?: Extensions, referencePath?: string, pathsToIgnore?: Array<string>, relativeModuleLocations?: Array<string>, packageEntryFileNames?: Array<string>, packageMainPropertyNames?: Array<string>, packageAliasPropertyNames?: Array<string>, includePattern?: Array<string | RegExp>, excludePattern?: Array<string | RegExp>, inPlaceNormalLibrary?: boolean, inPlaceDynamicLibrary?: boolean, encoding?: Encoding): null | string;
+    /**
+     * Determines asset type of given file.
+     * @param filePath - Path to file to analyse.
+     * @param buildConfiguration - Meta informations for available asset
+     * types.
+     * @param paths - List of paths to search if given path doesn't reference
+     * a file directly.
+     *
+     * @returns Determined file type or "null" of given file couldn't be
+     * determined.
+     */
+    static determineAssetType(this: void, filePath: string, buildConfiguration: BuildConfiguration, paths: PathConfiguration): null | string;
+    /**
+     * Adds a property with a stored array of all matching file paths, which
+     * matches each build configuration in given entry path and converts given
+     * build configuration into a sorted array were javaScript files takes
+     * precedence.
+     * @param configuration - Given build configurations.
+     * @param entryPath - Path to analyse nested structure.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     * @param mainFileBasenames - File basenames to sort into the front.
+     *
+     * @returns Converted build configuration.
+     */
+    static resolveBuildConfigurationFilePaths(this: void, configuration: BuildConfiguration, entryPath?: string, pathsToIgnore?: Array<string>, mainFileBasenames?: Array<string>): ResolvedBuildConfiguration;
+    /**
+     * Determines all file and directory paths related to given internal
+     * modules as array.
+     * @param givenInjection - List of module ids or module file paths.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of module replacements to take into
+     * account.
+     * @param extensions - List of file and module extensions to take into
+     * account.
+     * @param context - File path to resolve relative to.
+     * @param referencePath - Path to search for local modules.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     * @param relativeModuleLocations - List of relative file path to search
+     * for modules in.
+     * @param packageEntryFileNames - List of package entry file names to
+     * search for. The magic name "__package__" will search for an appreciate
+     * entry in a "package.json" file.
+     * @param packageMainPropertyNames - List of package file main property
+     * names to search for package representing entry module definitions.
+     * @param packageAliasPropertyNames - List of package file alias property
+     * names to search for package specific module aliases.
+     * @param encoding - File name encoding to use during file traversing.
+     *
+     * @returns Object with a file path and directory path key mapping to
+     * corresponding list of paths.
+     */
+    static determineModuleLocations(this: void, givenInjection: GivenInjection, aliases?: Mapping, moduleReplacements?: Replacements, extensions?: SpecificExtensions, context?: string, referencePath?: string, pathsToIgnore?: Array<string>, relativeModuleLocations?: Array<string>, packageEntryFileNames?: Array<string>, packageMainPropertyNames?: Array<string>, packageAliasPropertyNames?: Array<string>, encoding?: Encoding): {
+        directoryPaths: Array<string>;
+        filePaths: Array<string>;
+    };
+    /**
+     * Determines a list of concrete file paths for given module id pointing to
+     * a folder which isn't a package.
+     * @param normalizedGivenInjection - Injection data structure of modules
+     * with folder references to resolve.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param context - File path to determine relative to.
+     * @param referencePath - Path to resolve local modules relative to.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     *
+     * @returns Given injections with resolved folder pointing modules.
+     */
+    static resolveModulesInFolders(this: void, normalizedGivenInjection: NormalizedGivenInjection, aliases?: Mapping, moduleReplacements?: Replacements, context?: string, referencePath?: string, pathsToIgnore?: Array<string>): NormalizedGivenInjection;
+    /**
+     * Every injection definition type can be represented as plain object
+     * (mapping from chunk name to array of module ids). This method converts
+     * each representation into the normalized plain object notation.
+     * @param givenInjection - Given entry injection to normalize.
+     *
+     * @returns Normalized representation of given entry injection.
+     */
+    static normalizeGivenInjection(this: void, givenInjection: GivenInjection): NormalizedGivenInjection;
+    /**
+     * Determines all concrete file paths for given injection which are marked
+     * with the "__auto__" indicator.
+     * @param givenInjection - Given entry and external injection to take
+     * into account.
+     * @param buildConfigurations - Resolved build configuration.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param extensions - List of file and module extensions to take into
+     * account.
+     * @param context - File path to use as starting point.
+     * @param referencePath - Reference path from where local files should be
+     * resolved.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     *
+     * @returns Given injection with resolved marked indicators.
+     */
+    static resolveAutoInjection<T extends GivenInjectionConfiguration>(this: void, givenInjection: T, buildConfigurations: ResolvedBuildConfiguration, aliases?: Mapping, moduleReplacements?: Replacements, extensions?: Extensions, context?: string, referencePath?: string, pathsToIgnore?: Array<string>): T;
+    /**
+     * Determines all module file paths.
+     * @param buildConfigurations - Resolved build configuration.
+     * @param moduleFilePathsToExclude - A list of modules file paths to
+     * exclude (specified by path or id) or a mapping from chunk names to
+     * module ids.
+     * @param context - File path to use as starting point.
+     *
+     * @returns All determined module file paths.
+     */
+    static getAutoInjection(this: void, buildConfigurations: ResolvedBuildConfiguration, moduleFilePathsToExclude: Array<string>, context: string): Mapping;
+    /**
+     * Determines a resolved module file path in given package path.
+     * @param packagePath - Path to package to resolve in.
+     * @param packageMainPropertyNames - List of package file main property
+     * names to search for package representing entry module definitions.
+     * @param packageAliasPropertyNames - List of package file alias property
+     * names to search for package specific module aliases.
+     * @param encoding - Encoding to use for file names during file traversing.
+     *
+     * @returns Path if found and / or additional package aliases to consider.
+     */
+    static determineModuleFilePathInPackage(this: void, packagePath: string, packageMainPropertyNames?: Array<string>, packageAliasPropertyNames?: Array<string>, encoding?: Encoding): {
+        fileName: null | string;
+        packageAliases: Mapping | null;
+    };
+    /**
+     * Determines a concrete file path for given module id.
+     * @param moduleID - Module id to determine.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param extensions - List of file and module extensions to take into
+     * account.
+     * @param context - File path to determine relative to.
+     * @param referencePath - Path to resolve local modules relative to.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     * @param relativeModuleLocations - List of relative file path to search
+     * for modules in.
+     * @param packageEntryFileNames - List of package entry file names to
+     * search for. The magic name "__package__" will search for an appreciate
+     * entry in a "package.json" file.
+     * @param packageMainPropertyNames - List of package file main property
+     * names to search for package representing entry module definitions.
+     * @param packageAliasPropertyNames - List of package file alias property
+     * names to search for package specific module aliases.
+     * @param encoding - Encoding to use for file names during file traversing.
+     *
+     * @returns File path or given module id if determinations has failed or
+     * wasn't necessary.
+     */
+    static determineModuleFilePath(this: void, moduleID: false | string, aliases?: Mapping, moduleReplacements?: Replacements, extensions?: SpecificExtensions, context?: string, referencePath?: string, pathsToIgnore?: Array<string>, relativeModuleLocations?: Array<string>, packageEntryFileNames?: Array<string>, packageMainPropertyNames?: Array<string>, packageAliasPropertyNames?: Array<string>, encoding?: Encoding): null | string;
+    /**
+     * Determines a concrete file path for given module id.
+     * @param moduleID - Module id to determine.
+     * @param aliases - Mapping of aliases to take into account.
+     *
+     * @returns The alias applied given module id.
+     */
+    static applyAliases(this: void, moduleID: string, aliases: Mapping): string;
+    /**
+     * Determines a concrete file path for given module id.
+     * @param moduleID - Module id to determine.
+     * @param replacements - Mapping of regular expressions to their
+     * corresponding replacements.
+     *
+     * @returns The replacement applied given module id.
+     */
+    static applyModuleReplacements(this: void, moduleID: false | string, replacements: Replacements): false | string;
+    /**
+     * Determines the nearest package configuration file from given file path.
+     * @param start - Reference location to search from.
+     * @param fileName - Package configuration file name.
+     *
+     * @returns Determined file path.
+     */
+    static findPackageDescriptorFilePath(this: void, start: Array<string> | string, fileName?: string): null | string;
+    /**
+     * Determines the nearest package configuration from given module file
+     * path.
+     * @param modulePath - Module path to take as reference location (leaf in
+     * tree).
+     * @param fileName - Package configuration file name.
+     *
+     * @returns A object containing found parsed configuration an their
+     * corresponding file path.
+     */
+    static getClosestPackageDescriptor(this: void, modulePath: string, fileName?: string): null | PackageDescriptor;
+}
+export default Helper;

package/index.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env babel-node
+/// <reference types="webpack-env" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * Main entry point.
+ * @param context - Location from where to build current application.
+ * @param currentWorkingDirectory - Current working directory to use as
+ * reference.
+ * @param commandLineArguments - Arguments to take into account.
+ * @param webOptimizerPath - Current optimizer context path.
+ * @param environment - Environment variables to take into account.
+ *
+ * @returns Nothing.
+ */
+declare const main: (context?: string, currentWorkingDirectory?: string, commandLineArguments?: Array<string>, webOptimizerPath?: string, environment?: NodeJS.ProcessEnv) => Promise<() => void>;
+export default main;

package/index.js

@@ -69,9 +69,10 @@ var main = function main(context) {
       return _regenerator["default"].wrap(function _callee2$(_context3) {
         while (1) switch (_context3.prev = _context3.next) {
           case 0:
+            if (environment.PATH && !environment.PATH.includes(':node_modules/.bin')) environment.PATH += ':node_modules/.bin';else environment.PATH = 'node_modules/.bin';
             configuration = (0, _configurator.load)(context, currentWorkingDirectory, commandLineArguments, webOptimizerPath, environment);
             clear = _clientnode["default"].noop();
-            _context3.prev = 2;
+            _context3.prev = 3;
             // region controller
             processOptions = {
               cwd: configuration.path.context,
@@ -86,7 +87,7 @@ var main = function main(context) {
             possibleArguments = ['build', 'build:types', 'clear', 'document', 'lint', 'preinstall', 'serve', 'test', 'test:browser', 'test:coverage', 'test:coverage:report', 'check:types'];
             closeEventHandlers = [];
             if (!(configuration.givenCommandLineArguments.length > 2)) {
-              _context3.next = 117;
+              _context3.next = 118;
               break;
             }
             // region temporary save dynamically given configurations
@@ -97,28 +98,28 @@ var main = function main(context) {
             if (configuration.givenCommandLineArguments.length > 3 && _clientnode["default"].stringParseEncodedObject(configuration.givenCommandLineArguments[configuration.givenCommandLineArguments.length - 1], configuration, 'configuration')) configuration.givenCommandLineArguments.pop();
             count = 0;
             filePath = (0, _path.resolve)(configuration.path.context, ".dynamicConfiguration-".concat(count, ".json"));
-          case 14:
+          case 15:
             if (!true) {
-              _context3.next = 23;
+              _context3.next = 24;
               break;
             }
             filePath = (0, _path.resolve)(configuration.path.context, ".dynamicConfiguration-".concat(count, ".json"));
-            _context3.next = 18;
+            _context3.next = 19;
             return _clientnode["default"].isFile(filePath);
-          case 18:
+          case 19:
             if (_context3.sent) {
-              _context3.next = 20;
+              _context3.next = 21;
               break;
             }
-            return _context3.abrupt("break", 23);
-          case 20:
+            return _context3.abrupt("break", 24);
+          case 21:
             count += 1;
-            _context3.next = 14;
+            _context3.next = 15;
             break;
-          case 23:
-            _context3.next = 25;
+          case 24:
+            _context3.next = 26;
             return (0, _promises.writeFile)(filePath, JSON.stringify(dynamicConfiguration));
-          case 25:
+          case 26:
             additionalArguments = commandLineArguments.splice(3); /// region register exit handler to tidy up
             clear = function clear(error) {
               // NOTE: Close handler have to be synchronous.
@@ -137,14 +138,14 @@ var main = function main(context) {
                 during pre-install phase.
             */
             if (!(!['build', 'build:types', 'preinstall', 'serve', 'test', 'test:browser', 'test:coverage', 'test:coverage:report'].includes(configuration.givenCommandLineArguments[2]) && possibleArguments.includes(configuration.givenCommandLineArguments[2]))) {
-              _context3.next = 66;
+              _context3.next = 67;
               break;
             }
             if (!((0, _path.resolve)(configuration.path.target.base) === (0, _path.resolve)(configuration.path.context))) {
-              _context3.next = 56;
+              _context3.next = 57;
               break;
             }
-            _context3.next = 32;
+            _context3.next = 33;
             return _clientnode["default"].walkDirectoryRecursively(configuration.path.target.base, /*#__PURE__*/function () {
               var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(file) {
                 var type, _file$stats;
@@ -198,60 +199,60 @@ var main = function main(context) {
                 return _ref2.apply(this, arguments);
               };
             }());
-          case 32:
+          case 33:
             _context3.t0 = _createForOfIteratorHelper;
-            _context3.next = 35;
+            _context3.next = 36;
             return _clientnode["default"].walkDirectoryRecursively(configuration.path.target.base, function () {
               return false;
             }, configuration.encoding);
-          case 35:
+          case 36:
             _context3.t1 = _context3.sent;
             _iterator = (0, _context3.t0)(_context3.t1);
-            _context3.prev = 37;
+            _context3.prev = 38;
             _iterator.s();
-          case 39:
+          case 40:
             if ((_step = _iterator.n()).done) {
-              _context3.next = 46;
+              _context3.next = 47;
               break;
             }
             file = _step.value;
             if (!file.name.startsWith('npm-debug')) {
-              _context3.next = 44;
+              _context3.next = 45;
               break;
             }
-            _context3.next = 44;
+            _context3.next = 45;
             return (0, _promises.unlink)(file.path);
-          case 44:
-            _context3.next = 39;
+          case 45:
+            _context3.next = 40;
             break;
-          case 46:
-            _context3.next = 51;
+          case 47:
+            _context3.next = 52;
             break;
-          case 48:
-            _context3.prev = 48;
-            _context3.t2 = _context3["catch"](37);
+          case 49:
+            _context3.prev = 49;
+            _context3.t2 = _context3["catch"](38);
             _iterator.e(_context3.t2);
-          case 51:
-            _context3.prev = 51;
+          case 52:
+            _context3.prev = 52;
             _iterator.f();
-            return _context3.finish(51);
-          case 54:
-            _context3.next = 58;
+            return _context3.finish(52);
+          case 55:
+            _context3.next = 59;
             break;
-          case 56:
-            _context3.next = 58;
+          case 57:
+            _context3.next = 59;
             return (0, _rimraf.rimraf)(configuration.path.target.base);
-          case 58:
-            _context3.next = 60;
+          case 59:
+            _context3.next = 61;
             return _clientnode["default"].isDirectory(configuration.path.apiDocumentation);
-          case 60:
+          case 61:
             if (!_context3.sent) {
-              _context3.next = 63;
+              _context3.next = 64;
               break;
             }
-            _context3.next = 63;
+            _context3.next = 64;
             return (0, _rimraf.rimraf)(configuration.path.apiDocumentation);
-          case 63:
+          case 64:
             _iterator2 = _createForOfIteratorHelper(configuration.path.tidyUpOnClear);
             try {
               for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
@@ -266,7 +267,7 @@ var main = function main(context) {
               _iterator2.f();
             }
             (0, _rimraf.sync)((0, _globAll.sync)(configuration.path.tidyUpOnClearGlobs));
-          case 66:
+          case 67:
             // endregion
             // region handle build
             buildConfigurations = _helper["default"].resolveBuildConfigurationFilePaths(configuration.buildContext.types, configuration.path.source.asset.base, configuration.path.ignore.concat(configuration.module.directoryNames, configuration.loader.directoryNames).map(function (filePath) {
@@ -275,7 +276,7 @@ var main = function main(context) {
               return !configuration.path.context.startsWith(filePath);
             }), configuration["package"].main.fileNames);
             if (!['build', 'document', 'test', 'test:coverage', 'test:coverage:report'].includes(commandLineArguments[2])) {
-              _context3.next = 74;
+              _context3.next = 75;
               break;
             }
             tidiedUp = false;
@@ -389,11 +390,11 @@ var main = function main(context) {
             }));
             // endregion
             // region handle pre-install
-            _context3.next = 109;
+            _context3.next = 110;
             break;
-          case 74:
+          case 75:
             if (!(configuration.library && configuration.givenCommandLineArguments[2] === 'preinstall')) {
-              _context3.next = 109;
+              _context3.next = 110;
               break;
             }
             // Perform all file specific preprocessing stuff.
@@ -402,17 +403,17 @@ var main = function main(context) {
               file: configuration.extensions.file.internal
             }, configuration.path.context, configuration.path.source.asset.base, configuration.path.ignore).filePaths;
             _iterator7 = _createForOfIteratorHelper(buildConfigurations);
-            _context3.prev = 78;
+            _context3.prev = 79;
             _iterator7.s();
-          case 80:
+          case 81:
             if ((_step7 = _iterator7.n()).done) {
-              _context3.next = 101;
+              _context3.next = 102;
               break;
             }
             buildConfiguration = _step7.value;
             expression = buildConfiguration[configuration.givenCommandLineArguments[2]].trim();
             _iterator8 = _createForOfIteratorHelper(buildConfiguration.filePaths);
-            _context3.prev = 84;
+            _context3.prev = 85;
             _loop = /*#__PURE__*/_regenerator["default"].mark(function _loop() {
               var filePath, evaluated;
               return _regenerator["default"].wrap(function _loop$(_context2) {
@@ -455,41 +456,41 @@ var main = function main(context) {
               }, _loop);
             });
             _iterator8.s();
-          case 87:
+          case 88:
             if ((_step8 = _iterator8.n()).done) {
-              _context3.next = 91;
+              _context3.next = 92;
               break;
             }
-            return _context3.delegateYield(_loop(), "t3", 89);
-          case 89:
-            _context3.next = 87;
+            return _context3.delegateYield(_loop(), "t3", 90);
+          case 90:
+            _context3.next = 88;
             break;
-          case 91:
-            _context3.next = 96;
+          case 92:
+            _context3.next = 97;
             break;
-          case 93:
-            _context3.prev = 93;
-            _context3.t4 = _context3["catch"](84);
+          case 94:
+            _context3.prev = 94;
+            _context3.t4 = _context3["catch"](85);
             _iterator8.e(_context3.t4);
-          case 96:
-            _context3.prev = 96;
+          case 97:
+            _context3.prev = 97;
             _iterator8.f();
-            return _context3.finish(96);
-          case 99:
-            _context3.next = 80;
+            return _context3.finish(97);
+          case 100:
+            _context3.next = 81;
             break;
-          case 101:
-            _context3.next = 106;
+          case 102:
+            _context3.next = 107;
             break;
-          case 103:
-            _context3.prev = 103;
-            _context3.t5 = _context3["catch"](78);
+          case 104:
+            _context3.prev = 104;
+            _context3.t5 = _context3["catch"](79);
             _iterator7.e(_context3.t5);
-          case 106:
-            _context3.prev = 106;
+          case 107:
+            _context3.prev = 107;
             _iterator7.f();
-            return _context3.finish(106);
-          case 109:
+            return _context3.finish(107);
+          case 110:
             // endregion
             // region handle remaining tasks
             handleTask = function handleTask(type) {
@@ -536,18 +537,18 @@ var main = function main(context) {
               }
             }; /// region a-/synchronous
             if (!['document', 'test', 'test:coverage', 'test:coverage:report'].includes(configuration.givenCommandLineArguments[2])) {
-              _context3.next = 116;
+              _context3.next = 117;
               break;
             }
-            _context3.next = 113;
+            _context3.next = 114;
             return Promise.all(processPromises);
-          case 113:
+          case 114:
             handleTask(configuration.givenCommandLineArguments[2]);
-            _context3.next = 117;
+            _context3.next = 118;
             break;
-          case 116:
-            if (['build:types', 'check:types', 'lint', 'serve', 'test:browser'].includes(configuration.givenCommandLineArguments[2])) handleTask(configuration.givenCommandLineArguments[2]);
           case 117:
+            if (['build:types', 'check:types', 'lint', 'serve', 'test:browser'].includes(configuration.givenCommandLineArguments[2])) handleTask(configuration.givenCommandLineArguments[2]);
+          case 118:
             finished = false;
             closeHandler = function closeHandler() {
               if (!finished) for (var _i2 = 0, _closeEventHandlers = closeEventHandlers; _i2 < _closeEventHandlers.length; _i2++) {
@@ -570,37 +571,37 @@ var main = function main(context) {
             if (require.main === module && (configuration.givenCommandLineArguments.length < 3 || !possibleArguments.includes(configuration.givenCommandLineArguments[2]))) console.info("Give one of \"".concat(possibleArguments.join('", "'), "\" as command ") + 'line argument. You can provide a json string as second ' + 'parameter to dynamically overwrite some configurations.\n');
             // endregion
             // region forward nested return codes
-            _context3.prev = 122;
-            _context3.next = 125;
+            _context3.prev = 123;
+            _context3.next = 126;
             return Promise.all(processPromises);
-          case 125:
-            _context3.next = 131;
+          case 126:
+            _context3.next = 132;
             break;
-          case 127:
-            _context3.prev = 127;
-            _context3.t6 = _context3["catch"](122);
+          case 128:
+            _context3.prev = 128;
+            _context3.t6 = _context3["catch"](123);
             console.error(_context3.t6);
             process.exit(_context3.t6.returnCode);
-          case 131:
-            _context3.next = 140;
+          case 132:
+            _context3.next = 141;
             break;
-          case 133:
-            _context3.prev = 133;
-            _context3.t7 = _context3["catch"](2);
+          case 134:
+            _context3.prev = 134;
+            _context3.t7 = _context3["catch"](3);
             if (!configuration.debug) {
-              _context3.next = 139;
+              _context3.next = 140;
               break;
             }
             throw _context3.t7;
-          case 139:
-            console.error(_context3.t7);
           case 140:
-            return _context3.abrupt("return", clear);
+            console.error(_context3.t7);
           case 141:
+            return _context3.abrupt("return", clear);
+          case 142:
           case "end":
             return _context3.stop();
         }
-      }, _callee2, null, [[2, 133], [37, 48, 51, 54], [78, 103, 106, 109], [84, 93, 96, 99], [122, 127]]);
+      }, _callee2, null, [[3, 134], [38, 49, 52, 55], [79, 104, 107, 110], [85, 94, 97, 100], [123, 128]]);
     }))();
   } catch (e) {
     return Promise.reject(e);

package/jestEnvironmentBrowser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Implements the default browser environment to run script context in.
+ */
+export declare class BrowserEnvironment {
+    /**
+     * @returns Nothing.
+     */
+    setup(): Promise<void>;
+    /**
+     * @returns Nothing.
+     */
+    teardown(): void;
+    /**
+     * @returns Null.
+     */
+    runScript(): null;
+}
+export default BrowserEnvironment;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weboptimizer",
-  "version": "2.0.1439",
+  "version": "2.0.1441",
   "description": "A generic web optimizer, (module) bundler and development environment.",
   "keywords": [
     "webpack",
@@ -69,7 +69,7 @@
     "build:types": "tsc --declaration --emitDeclarationOnly",
     "check": "yarn check:types; yarn lint",
     "check:types": "tsc --noEmit",
-    "clear": "rimraf apiDocumentation 'plugins/*.d.ts' 'plugins/*.js' browser.d.ts configurator.d.ts ejsLoader.d.ts helper.d.ts index.d.ts jestEnvironmentBrowser.d.ts stylelintConfigurator.d.ts type.d.ts webpackConfigurator.d.ts '*.js' '*.compiled.*' '*.compiled' 'test/*.js' 'test/*.compiled.*' 'test/*.d.ts' '*.html' '*.log' node_modules/weboptimizer .coverage .nyc_output || true",
+    "clear": "rimraf apiDocumentation 'plugins/*.d.ts' 'plugins/*.js' browser.d.ts configurator.d.ts ejsLoader.d.ts helper.d.ts index.d.ts jestSetup.d.ts jestEnvironmentBrowser.d.ts stylelintConfigurator.d.ts type.d.ts webpackConfigurator.d.ts '*.js' '*.compiled.*' '*.compiled' 'test/*.js' 'test/*.compiled.*' 'test/*.d.ts' '*.html' '*.log' node_modules/weboptimizer .coverage .nyc_output || true",
     "document": "yarn build:plain && jsdoc --package ./package.json --readme ./readme.md --destination apiDocumentation *.js",
     "lint": "yarn lint:base",
     "lint:base": "eslint --ignore-pattern '**/exclude/*' --ignore-pattern '*.compiled.*' --ignore-pattern '*.d.ts' --ignore-pattern '*.js' --parser-options=project:tsconfig.json '*.ts' 'test/*.ts'",

package/stylelintConfigurator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/type.d.ts

@@ -0,0 +1,483 @@
+/// <reference types="webpack-env" />
+/// <reference types="node" />
+import { AnyFunction, Encoding, Mapping, PlainObject, SecondParameter } from 'clientnode/type';
+import FaviconWebpackPlugin from 'favicons-webpack-plugin';
+import { FaviconWebpackPlugionOptions as FaviconWebpackPluginOptions } from 'favicons-webpack-plugin/src/options';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import ImageMinimizerWebpackPlugin, { PluginOptions as ImageMinimizerOptions } from 'image-minimizer-webpack-plugin';
+import { JSDOM } from 'jsdom';
+import MiniCSSExtractPlugin from 'mini-css-extract-plugin';
+import TerserWebpackPlugin from 'terser-webpack-plugin';
+import { DefinePlugin as WebpackDefinePlugin, Configuration as BaseWebpackConfiguration, IgnorePlugin as WebpackIgnorePlugin, library as webpackLibrary, ModuleOptions as WebpackModuleOptions, RuleSetRule as WebpackRuleSetRule, RuleSetUseItem as WebpackRuleSetUseItem, WebpackOptionsNormalized } from 'webpack';
+import { WebpackPartial as WorkboxBaseCommonOptions, BasePartial as WorkboxCommonOptions, WebpackGenerateSWOptions as WorkboxGenerateSWOptions, WebpackInjectManifestOptions as WorkboxInjectManifestOptions } from 'workbox-build';
+import OfflinePlugin from 'workbox-webpack-plugin';
+export interface Browser {
+    debug: boolean;
+    domContentLoaded: boolean;
+    DOM: typeof JSDOM | null;
+    initialized: boolean;
+    instance: JSDOM | null;
+    window: null | Window;
+    windowLoaded: boolean;
+}
+export interface InitializedBrowser extends Browser {
+    DOM: typeof JSDOM;
+    instance: JSDOM;
+    window: Window;
+}
+export interface PackageConfiguration {
+    name: string;
+    version: string;
+}
+export interface PackageDescriptor {
+    configuration: PackageConfiguration;
+    filePath: string;
+}
+export type Replacements = Mapping<SecondParameter<string['replace']>>;
+export type Resolvable = {
+    [_K in '__evaluate__' | '__execute__']?: Resolvable;
+} & Mapping<unknown>;
+export interface RedundantRequest {
+    path: string;
+    version: string;
+}
+export type ExternalAliases = Mapping<Mapping | string | ((_request: string, _key: string) => string)>;
+export type GivenInjection = AnyFunction | string | Array<string> | Mapping<string | Array<string>>;
+export type NormalizedGivenInjection = Mapping<Array<string>>;
+export interface GivenInjectionConfiguration {
+    autoExclude: Array<string>;
+    entry: GivenInjection;
+    external: GivenInjection;
+}
+export type IgnorePattern = WebpackIgnorePlugin['options'] | {
+    contextRegExp?: string;
+    resourceRegExp?: string;
+};
+export interface InjectionConfiguration {
+    autoExclude: Array<string>;
+    chunks: NonNullable<BaseWebpackConfiguration['optimization']>['splitChunks'];
+    entry: {
+        given: GivenInjection;
+        normalized: NormalizedGivenInjection;
+    };
+    external: {
+        aliases: ExternalAliases;
+        implicit: {
+            pattern: {
+                exclude: Array<RegExp | string>;
+                include: Array<RegExp | string>;
+            };
+        };
+        modules: BaseWebpackConfiguration['externals'];
+    };
+    externalAliases: Mapping;
+    ignorePattern: Array<IgnorePattern> | IgnorePattern;
+    implicitExternalExcludePattern: Array<RegExp | string>;
+    implicitExternalIncludePattern: Array<RegExp | string>;
+}
+export interface HTMLTransformationOptions {
+    hashAlgorithm: string;
+    htmlPlugin: typeof HtmlWebpackPlugin;
+    files: Array<HTMLConfiguration>;
+}
+export interface InPlaceAssetsIntoHTMLOptions {
+    cascadingStyleSheet: InPlaceAssetConfiguration;
+    javaScript: InPlaceAssetConfiguration;
+    htmlPlugin: typeof HtmlWebpackPlugin;
+}
+export interface AssetPathConfiguration {
+    base: string;
+    cascadingStyleSheet: string;
+    data: string;
+    font: string;
+    image: string;
+    javaScript: string;
+    template: string;
+}
+export interface BasePathConfiguration {
+    base: string;
+    context: string;
+    source: {
+        asset: AssetPathConfiguration;
+        base: string;
+    };
+    target: {
+        asset: AssetPathConfiguration;
+        base: string;
+        manifest: string;
+        public: string;
+    };
+}
+export interface PathConfiguration extends BasePathConfiguration {
+    apiDocumentation: string;
+    base: string;
+    configuration: {
+        javaScript: string;
+        json: string;
+        typeScript: string;
+    };
+    context: string;
+    ignore: Array<string>;
+    tidyUp: Array<string>;
+    tidyUpGlobs: Array<string>;
+    tidyUpOnClear: Array<string>;
+    tidyUpOnClearGlobs: Array<string>;
+}
+export type DefaultPathConfiguration = BasePathConfiguration & Resolvable;
+export interface BuildConfigurationItem {
+    extension: string;
+    ignoredExtension: string;
+    filePathPattern: string;
+    outputExtension: string;
+}
+export type BuildConfiguration = Mapping<BuildConfigurationItem>;
+export declare const SubConfigurationTypes: readonly ["debug", "document", "test", "test:browser"];
+export declare const TaskTypes: readonly ["build", "serve", "debug", "document", "test", "test:browser"];
+export type BooleanExpression = boolean | null | string;
+export interface AdditionalLoaderConfiguration {
+    exclude?: BooleanExpression;
+    include?: BooleanExpression;
+    test: string;
+    use: Array<WebpackLoader> | WebpackLoader | string;
+}
+export interface AdditionalLoaderConfigurations {
+    post: Array<AdditionalLoaderConfiguration>;
+    pre: Array<AdditionalLoaderConfiguration>;
+}
+export interface AdditionalLoader {
+    post: Array<string>;
+    pre: Array<string>;
+}
+export interface WebpackLoader {
+    loader: string;
+    options?: Mapping<unknown>;
+}
+export type ResourceLoaderConfiguration = WebpackLoader & {
+    exclude: BooleanExpression;
+    include: BooleanExpression;
+    loader: Array<string>;
+    regularExpression: string;
+};
+export interface LoaderConfiguration extends ResourceLoaderConfiguration {
+    additional: AdditionalLoaderConfigurations;
+}
+export interface WebpackLoaderConfiguration {
+    exclude: WebpackLoaderIndicator;
+    include: WebpackLoaderIndicator;
+    test: RegExp;
+    use: Array<WebpackLoader> | WebpackLoader;
+}
+export type WebpackLoaderIndicator = WebpackRuleSetRule['include'];
+export interface Command {
+    arguments: Array<string>;
+    command: string;
+    indicator?: string;
+}
+export interface CommandLineArguments {
+    build: Command;
+    document: Array<Command> | Command;
+    lint: Array<Command> | Command;
+    serve: Array<Command> | Command;
+    test: Array<Command> | Command;
+    'test:browser': Array<Command> | Command;
+    'check:types': Array<Command> | Command;
+}
+export type NodeEnvironment = BaseWebpackConfiguration['node'] & {
+    '#': string;
+};
+export interface PluginConfiguration {
+    name: {
+        initializer: string;
+        module: string;
+    };
+    parameters: Array<unknown>;
+}
+export interface DefaultConfiguration {
+    contextType: string;
+    debug: boolean;
+    document: PlainObject;
+    encoding: Encoding;
+    givenCommandLineArguments: Array<string>;
+    library: boolean;
+    nodeEnvironment: NodeEnvironment;
+    path: DefaultPathConfiguration;
+    plugins: Array<PluginConfiguration>;
+    test: PlainObject;
+    'test:browser': PlainObject;
+}
+export type ExportFormat = 'amd' | 'amd-require' | 'assign' | 'global' | 'jsonp' | 'var' | 'this' | 'commonjs' | 'commonjs2' | 'umd';
+export interface HTMLConfiguration {
+    filename: string;
+    template: {
+        filePath: string;
+        options?: PlainObject;
+        postCompileOptions: PlainObject;
+        request: string;
+        use: Array<WebpackLoader> | WebpackLoader;
+    };
+}
+export interface MetaConfiguration {
+    default: DefaultConfiguration;
+    debug: Resolvable;
+    library: Resolvable;
+}
+export interface ResolvedBuildConfigurationItem extends BuildConfigurationItem {
+    filePaths: Array<string>;
+    type: string;
+}
+export interface Extensions {
+    file: {
+        external: Array<string>;
+        internal: Array<string>;
+    };
+}
+export interface SpecificExtensions {
+    file: Array<string>;
+}
+export interface InPlaceAssetConfiguration {
+    body?: Array<RegExp | string> | RegExp | string;
+    head?: Array<RegExp | string> | RegExp | string;
+}
+export interface InPlaceConfiguration {
+    cascadingStyleSheet: InPlaceAssetConfiguration;
+    externalLibrary: {
+        normal: boolean;
+        dynamic: boolean;
+    };
+    javaScript: InPlaceAssetConfiguration;
+    otherMaximumFileSizeLimitInByte: number;
+}
+export interface ResolvedConfiguration {
+    assetPattern: Mapping<{
+        excludeFilePathRegularExpression: string;
+        includeFilePathRegularExpression: string;
+        pattern: string;
+    }>;
+    buildContext: {
+        definitions: WebpackDefinePlugin['definitions'];
+        types: BuildConfiguration;
+    };
+    cache?: {
+        main?: WebpackOptionsNormalized['cache'];
+        unsafe?: WebpackModuleOptions['unsafeCache'];
+    };
+    commandLine: CommandLineArguments;
+    contextType: string;
+    debug: boolean;
+    development: {
+        includeClient?: boolean | null;
+        server: (WebpackOptionsNormalized['devServer'] & {
+            hot: boolean;
+            host: string;
+            https: boolean;
+            liveReload: boolean;
+            port: number;
+        });
+        tool: WebpackOptionsNormalized['devtool'];
+    };
+    document: PlainObject;
+    encoding: Encoding;
+    exportFormat: {
+        external: ExportFormat;
+        globalObject: string;
+        self: ExportFormat;
+    };
+    extensions: Extensions;
+    favicon: FaviconWebpackPluginOptions;
+    files: {
+        additionalPaths: Array<string>;
+        compose: {
+            cascadingStyleSheet: string | ((_asset: unknown) => string);
+            image: string;
+            javaScript: string;
+        };
+        defaultHTML: HTMLConfiguration;
+        html: Array<HTMLConfiguration>;
+    };
+    givenCommandLineArguments: Array<string>;
+    hashAlgorithm: string;
+    injection: InjectionConfiguration;
+    inPlace: InPlaceConfiguration;
+    library: boolean;
+    libraryName: string;
+    loader: {
+        aliases: Mapping;
+        directoryNames: Array<string>;
+        extensions: {
+            file: Array<string>;
+        };
+        resolveSymlinks: boolean;
+    };
+    module: {
+        additional: AdditionalLoaderConfigurations;
+        aliases: Mapping;
+        cascadingStyleSheet: ResourceLoaderConfiguration;
+        directoryNames: Array<string>;
+        enforceDeduplication: boolean;
+        html: LoaderConfiguration;
+        locations: {
+            directoryPaths: Array<string>;
+            filePaths: Array<string>;
+        };
+        optimizer: BaseWebpackConfiguration['optimization'] & {
+            babelMinify?: {
+                bundle?: {
+                    plugin?: PlainObject;
+                    transform?: PlainObject;
+                };
+                module?: PlainObject;
+            };
+            cssnano: PlainObject;
+            data: ResourceLoaderConfiguration;
+            font: {
+                eot: ResourceLoaderConfiguration;
+                svg: ResourceLoaderConfiguration;
+                ttf: ResourceLoaderConfiguration;
+                woff: ResourceLoaderConfiguration;
+            };
+            htmlMinifier?: PlainObject;
+            image: {
+                content: ImageMinimizerOptions<unknown, unknown>;
+                exclude: string;
+                loader: Array<string>;
+            };
+        };
+        preprocessor: {
+            cascadingStyleSheet: WebpackLoader & {
+                additional: AdditionalLoader & {
+                    plugins: AdditionalLoader;
+                };
+                postcssPresetEnv: PlainObject;
+            };
+            ejs: LoaderConfiguration;
+            html: LoaderConfiguration;
+            javaScript: LoaderConfiguration;
+            json: {
+                exclude: string;
+                loader: string;
+            };
+        };
+        provide: Mapping | null;
+        replacements: {
+            context: Array<[string, string]>;
+            normal: Replacements;
+        };
+        resolveSymlinks: boolean;
+        skipParseRegularExpressions: WebpackModuleOptions['noParse'];
+        style: WebpackLoader;
+    };
+    name: string;
+    needed: Mapping<boolean>;
+    nodeENV: false | null | string;
+    nodeEnvironment: NodeEnvironment;
+    offline: {
+        common: WorkboxBaseCommonOptions & WorkboxCommonOptions;
+        injectionManifest: WorkboxInjectManifestOptions;
+        serviceWorker: WorkboxGenerateSWOptions;
+        use: 'injectionManifest' | 'serviceWorker';
+    };
+    package: {
+        aliasPropertyNames: Array<string>;
+        main: {
+            fileNames: Array<string>;
+            propertyNames: Array<string>;
+        };
+    };
+    path: PathConfiguration;
+    performanceHints: BaseWebpackConfiguration['performance'];
+    plugins: Array<PluginConfiguration>;
+    showConfiguration: boolean;
+    stylelint: PlainObject;
+    targetTechnology: {
+        boilerplate: string;
+        payload: string;
+    };
+    test: PlainObject;
+    'test:browser': PlainObject;
+    webpack: WebpackConfiguration;
+}
+export type ResolvedBuildConfiguration = Array<ResolvedBuildConfigurationItem>;
+export type RuntimeInformation = PlainObject & {
+    givenCommandLineArguments: Array<string>;
+};
+export interface WebpackConfiguration extends BaseWebpackConfiguration {
+    devServer: Mapping<unknown>;
+    replaceWebOptimizer: WebpackConfiguration;
+}
+export type RuleSet = Array<WebpackRuleSetUseItem>;
+export type RuleSetRule = WebpackRuleSetRule & {
+    use: RuleSet;
+};
+export interface GenericLoader {
+    ejs: RuleSetRule;
+    script: RuleSetRule;
+    html: {
+        ejs: RuleSetRule;
+        html: RuleSetRule;
+        main: {
+            test: RegExp;
+            use: Array<WebpackLoader> | WebpackLoader;
+        };
+    };
+    style: RuleSetRule;
+    font: {
+        eot: RuleSetRule;
+        svg: RuleSetRule;
+        ttf: RuleSetRule;
+        woff: RuleSetRule;
+    };
+    image: RuleSetRule;
+    data: RuleSetRule;
+}
+export type Loader = GenericLoader & Mapping<WebpackRuleSetRule>;
+export interface EvaluationScope {
+    configuration: ResolvedConfiguration;
+    isFilePathInDependencies: (_filePath: string) => boolean;
+    loader: Loader;
+    require: typeof require;
+}
+export interface WebpackBaseAssets {
+    outputName: string;
+    plugin: HtmlWebpackPlugin;
+}
+export interface WebpackAssets extends WebpackBaseAssets {
+    bodyTags: HtmlWebpackPlugin.HtmlTagObject[];
+    headTags: HtmlWebpackPlugin.HtmlTagObject[];
+    outputName: string;
+    publicPath: string;
+    plugin: HtmlWebpackPlugin;
+}
+export type WebpackPlugin = webpackLibrary.AbstractLibraryPlugin<unknown> & Mapping<unknown>;
+export type WebpackPlugins = Mapping<WebpackPlugin> & {
+    Favicon?: typeof FaviconWebpackPlugin;
+    GenerateServiceWorker?: typeof OfflinePlugin.GenerateSW;
+    HTML?: typeof HtmlWebpackPlugin;
+    ImageMinimizer?: typeof ImageMinimizerWebpackPlugin;
+    InjectManifest?: typeof OfflinePlugin.InjectManifest;
+    Offline?: {
+        GenerateSW: typeof OfflinePlugin.GenerateSW;
+        InjectManifest: typeof OfflinePlugin.InjectManifest;
+    };
+    MiniCSSExtract?: typeof MiniCSSExtractPlugin;
+    Terser?: typeof TerserWebpackPlugin;
+};
+export type WebpackResolveData = Parameters<WebpackIgnorePlugin['checkIgnore']>[0];
+export type WebpackExtendedResolveData = WebpackResolveData & {
+    createData: {
+        rawRequest: string;
+        request: string;
+        resource: string;
+        userRequest: string;
+    };
+};
+export interface HTMLWebpackPluginAssetTagGroupsData {
+    bodyTags: HtmlWebpackPlugin.HtmlTagObject[];
+    headTags: HtmlWebpackPlugin.HtmlTagObject[];
+    outputName: string;
+    plugin: HtmlWebpackPlugin;
+}
+export interface HTMLWebpackPluginBeforeEmitData {
+    html: string;
+    outputName: string;
+    plugin: HtmlWebpackPlugin;
+}

package/webpackConfigurator.d.ts

@@ -0,0 +1,4 @@
+import { WebpackConfiguration } from './type';
+export declare const optionalRequire: <T = unknown>(id: string) => T | null;
+export declare let webpackConfiguration: WebpackConfiguration;
+export default webpackConfiguration;