Index: imaps-frontend/node_modules/webpack/lib/rules/BasicEffectRulePlugin.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/rules/BasicEffectRulePlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/rules/BasicEffectRulePlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+
+class BasicEffectRulePlugin {
+	/**
+	 * @param {string} ruleProperty the rule property
+	 * @param {string=} effectType the effect type
+	 */
+	constructor(ruleProperty, effectType) {
+		this.ruleProperty = ruleProperty;
+		this.effectType = effectType || ruleProperty;
+	}
+
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			"BasicEffectRulePlugin",
+			(path, rule, unhandledProperties, result, references) => {
+				if (unhandledProperties.has(this.ruleProperty)) {
+					unhandledProperties.delete(this.ruleProperty);
+
+					const value =
+						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
+
+					result.effects.push({
+						type: this.effectType,
+						value
+					});
+				}
+			}
+		);
+	}
+}
+
+module.exports = BasicEffectRulePlugin;
Index: imaps-frontend/node_modules/webpack/lib/rules/BasicMatcherRulePlugin.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/rules/BasicMatcherRulePlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/rules/BasicMatcherRulePlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,54 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
+
+class BasicMatcherRulePlugin {
+	/**
+	 * @param {string} ruleProperty the rule property
+	 * @param {string=} dataProperty the data property
+	 * @param {boolean=} invert if true, inverts the condition
+	 */
+	constructor(ruleProperty, dataProperty, invert) {
+		this.ruleProperty = ruleProperty;
+		this.dataProperty = dataProperty || ruleProperty;
+		this.invert = invert || false;
+	}
+
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			"BasicMatcherRulePlugin",
+			(path, rule, unhandledProperties, result) => {
+				if (unhandledProperties.has(this.ruleProperty)) {
+					unhandledProperties.delete(this.ruleProperty);
+					const value =
+						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
+					const condition = ruleSetCompiler.compileCondition(
+						`${path}.${this.ruleProperty}`,
+						value
+					);
+					const fn = condition.fn;
+					result.conditions.push({
+						property: this.dataProperty,
+						matchWhenEmpty: this.invert
+							? !condition.matchWhenEmpty
+							: condition.matchWhenEmpty,
+						fn: this.invert ? v => !fn(v) : fn
+					});
+				}
+			}
+		);
+	}
+}
+
+module.exports = BasicMatcherRulePlugin;
Index: imaps-frontend/node_modules/webpack/lib/rules/ObjectMatcherRulePlugin.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/rules/ObjectMatcherRulePlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/rules/ObjectMatcherRulePlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,64 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
+/** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
+
+class ObjectMatcherRulePlugin {
+	/**
+	 * @param {string} ruleProperty the rule property
+	 * @param {string=} dataProperty the data property
+	 * @param {RuleConditionFunction=} additionalConditionFunction need to check
+	 */
+	constructor(ruleProperty, dataProperty, additionalConditionFunction) {
+		this.ruleProperty = ruleProperty;
+		this.dataProperty = dataProperty || ruleProperty;
+		this.additionalConditionFunction = additionalConditionFunction;
+	}
+
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		const { ruleProperty, dataProperty } = this;
+		ruleSetCompiler.hooks.rule.tap(
+			"ObjectMatcherRulePlugin",
+			(path, rule, unhandledProperties, result) => {
+				if (unhandledProperties.has(ruleProperty)) {
+					unhandledProperties.delete(ruleProperty);
+					const value =
+						/** @type {Record<string, any>} */
+						(rule[/** @type {keyof RuleSetRule} */ (ruleProperty)]);
+					for (const property of Object.keys(value)) {
+						const nestedDataProperties = property.split(".");
+						const condition = ruleSetCompiler.compileCondition(
+							`${path}.${ruleProperty}.${property}`,
+							value[property]
+						);
+						if (this.additionalConditionFunction) {
+							result.conditions.push({
+								property: [dataProperty],
+								matchWhenEmpty: condition.matchWhenEmpty,
+								fn: this.additionalConditionFunction
+							});
+						}
+						result.conditions.push({
+							property: [dataProperty, ...nestedDataProperties],
+							matchWhenEmpty: condition.matchWhenEmpty,
+							fn: condition.fn
+						});
+					}
+				}
+			}
+		);
+	}
+}
+
+module.exports = ObjectMatcherRulePlugin;
Index: imaps-frontend/node_modules/webpack/lib/rules/RuleSetCompiler.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/rules/RuleSetCompiler.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/rules/RuleSetCompiler.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,400 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { SyncHook } = require("tapable");
+
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
+
+/** @typedef {function(string | EffectData): boolean} RuleConditionFunction */
+
+/**
+ * @typedef {object} RuleCondition
+ * @property {string | string[]} property
+ * @property {boolean} matchWhenEmpty
+ * @property {RuleConditionFunction} fn
+ */
+
+/**
+ * @typedef {object} Condition
+ * @property {boolean} matchWhenEmpty
+ * @property {RuleConditionFunction} fn
+ */
+
+/**
+ * @typedef {Record<string, TODO>} EffectData
+ */
+
+/**
+ * @typedef {object} CompiledRule
+ * @property {RuleCondition[]} conditions
+ * @property {(Effect|function(EffectData): Effect[])[]} effects
+ * @property {CompiledRule[]=} rules
+ * @property {CompiledRule[]=} oneOf
+ */
+
+/**
+ * @typedef {object} Effect
+ * @property {string} type
+ * @property {any} value
+ */
+
+/**
+ * @typedef {object} RuleSet
+ * @property {Map<string, any>} references map of references in the rule set (may grow over time)
+ * @property {function(EffectData): Effect[]} exec execute the rule set
+ */
+
+/** @typedef {{ apply: (function(RuleSetCompiler): void) }} RuleSetPlugin */
+
+class RuleSetCompiler {
+	/**
+	 * @param {RuleSetPlugin[]} plugins plugins
+	 */
+	constructor(plugins) {
+		this.hooks = Object.freeze({
+			/** @type {SyncHook<[string, RuleSetRule, Set<string>, CompiledRule, Map<string | undefined, any>]>} */
+			rule: new SyncHook([
+				"path",
+				"rule",
+				"unhandledProperties",
+				"compiledRule",
+				"references"
+			])
+		});
+		if (plugins) {
+			for (const plugin of plugins) {
+				plugin.apply(this);
+			}
+		}
+	}
+
+	/**
+	 * @param {TODO[]} ruleSet raw user provided rules
+	 * @returns {RuleSet} compiled RuleSet
+	 */
+	compile(ruleSet) {
+		const refs = new Map();
+		const rules = this.compileRules("ruleSet", ruleSet, refs);
+
+		/**
+		 * @param {EffectData} data data passed in
+		 * @param {CompiledRule} rule the compiled rule
+		 * @param {Effect[]} effects an array where effects are pushed to
+		 * @returns {boolean} true, if the rule has matched
+		 */
+		const execRule = (data, rule, effects) => {
+			for (const condition of rule.conditions) {
+				const p = condition.property;
+				if (Array.isArray(p)) {
+					/** @type {EffectData | string | undefined} */
+					let current = data;
+					for (const subProperty of p) {
+						if (
+							current &&
+							typeof current === "object" &&
+							Object.prototype.hasOwnProperty.call(current, subProperty)
+						) {
+							current = current[subProperty];
+						} else {
+							current = undefined;
+							break;
+						}
+					}
+					if (current !== undefined) {
+						if (!condition.fn(current)) return false;
+						continue;
+					}
+				} else if (p in data) {
+					const value = data[p];
+					if (value !== undefined) {
+						if (!condition.fn(value)) return false;
+						continue;
+					}
+				}
+				if (!condition.matchWhenEmpty) {
+					return false;
+				}
+			}
+			for (const effect of rule.effects) {
+				if (typeof effect === "function") {
+					const returnedEffects = effect(data);
+					for (const effect of returnedEffects) {
+						effects.push(effect);
+					}
+				} else {
+					effects.push(effect);
+				}
+			}
+			if (rule.rules) {
+				for (const childRule of rule.rules) {
+					execRule(data, childRule, effects);
+				}
+			}
+			if (rule.oneOf) {
+				for (const childRule of rule.oneOf) {
+					if (execRule(data, childRule, effects)) {
+						break;
+					}
+				}
+			}
+			return true;
+		};
+
+		return {
+			references: refs,
+			exec: data => {
+				/** @type {Effect[]} */
+				const effects = [];
+				for (const rule of rules) {
+					execRule(data, rule, effects);
+				}
+				return effects;
+			}
+		};
+	}
+
+	/**
+	 * @param {string} path current path
+	 * @param {RuleSetRules} rules the raw rules provided by user
+	 * @param {Map<string, any>} refs references
+	 * @returns {CompiledRule[]} rules
+	 */
+	compileRules(path, rules, refs) {
+		return rules
+			.filter(Boolean)
+			.map((rule, i) =>
+				this.compileRule(
+					`${path}[${i}]`,
+					/** @type {RuleSetRule} */ (rule),
+					refs
+				)
+			);
+	}
+
+	/**
+	 * @param {string} path current path
+	 * @param {RuleSetRule} rule the raw rule provided by user
+	 * @param {Map<string, any>} refs references
+	 * @returns {CompiledRule} normalized and compiled rule for processing
+	 */
+	compileRule(path, rule, refs) {
+		const unhandledProperties = new Set(
+			Object.keys(rule).filter(
+				key => rule[/** @type {keyof RuleSetRule} */ (key)] !== undefined
+			)
+		);
+
+		/** @type {CompiledRule} */
+		const compiledRule = {
+			conditions: [],
+			effects: [],
+			rules: undefined,
+			oneOf: undefined
+		};
+
+		this.hooks.rule.call(path, rule, unhandledProperties, compiledRule, refs);
+
+		if (unhandledProperties.has("rules")) {
+			unhandledProperties.delete("rules");
+			const rules = rule.rules;
+			if (!Array.isArray(rules))
+				throw this.error(path, rules, "Rule.rules must be an array of rules");
+			compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs);
+		}
+
+		if (unhandledProperties.has("oneOf")) {
+			unhandledProperties.delete("oneOf");
+			const oneOf = rule.oneOf;
+			if (!Array.isArray(oneOf))
+				throw this.error(path, oneOf, "Rule.oneOf must be an array of rules");
+			compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs);
+		}
+
+		if (unhandledProperties.size > 0) {
+			throw this.error(
+				path,
+				rule,
+				`Properties ${Array.from(unhandledProperties).join(", ")} are unknown`
+			);
+		}
+
+		return compiledRule;
+	}
+
+	/**
+	 * @param {string} path current path
+	 * @param {any} condition user provided condition value
+	 * @returns {Condition} compiled condition
+	 */
+	compileCondition(path, condition) {
+		if (condition === "") {
+			return {
+				matchWhenEmpty: true,
+				fn: str => str === ""
+			};
+		}
+		if (!condition) {
+			throw this.error(
+				path,
+				condition,
+				"Expected condition but got falsy value"
+			);
+		}
+		if (typeof condition === "string") {
+			return {
+				matchWhenEmpty: condition.length === 0,
+				fn: str => typeof str === "string" && str.startsWith(condition)
+			};
+		}
+		if (typeof condition === "function") {
+			try {
+				return {
+					matchWhenEmpty: condition(""),
+					fn: condition
+				};
+			} catch (_err) {
+				throw this.error(
+					path,
+					condition,
+					"Evaluation of condition function threw error"
+				);
+			}
+		}
+		if (condition instanceof RegExp) {
+			return {
+				matchWhenEmpty: condition.test(""),
+				fn: v => typeof v === "string" && condition.test(v)
+			};
+		}
+		if (Array.isArray(condition)) {
+			const items = condition.map((c, i) =>
+				this.compileCondition(`${path}[${i}]`, c)
+			);
+			return this.combineConditionsOr(items);
+		}
+
+		if (typeof condition !== "object") {
+			throw this.error(
+				path,
+				condition,
+				`Unexpected ${typeof condition} when condition was expected`
+			);
+		}
+
+		const conditions = [];
+		for (const key of Object.keys(condition)) {
+			const value = condition[key];
+			switch (key) {
+				case "or":
+					if (value) {
+						if (!Array.isArray(value)) {
+							throw this.error(
+								`${path}.or`,
+								condition.or,
+								"Expected array of conditions"
+							);
+						}
+						conditions.push(this.compileCondition(`${path}.or`, value));
+					}
+					break;
+				case "and":
+					if (value) {
+						if (!Array.isArray(value)) {
+							throw this.error(
+								`${path}.and`,
+								condition.and,
+								"Expected array of conditions"
+							);
+						}
+						let i = 0;
+						for (const item of value) {
+							conditions.push(this.compileCondition(`${path}.and[${i}]`, item));
+							i++;
+						}
+					}
+					break;
+				case "not":
+					if (value) {
+						const matcher = this.compileCondition(`${path}.not`, value);
+						const fn = matcher.fn;
+						conditions.push({
+							matchWhenEmpty: !matcher.matchWhenEmpty,
+							fn: /** @type {RuleConditionFunction} */ (v => !fn(v))
+						});
+					}
+					break;
+				default:
+					throw this.error(
+						`${path}.${key}`,
+						condition[key],
+						`Unexpected property ${key} in condition`
+					);
+			}
+		}
+		if (conditions.length === 0) {
+			throw this.error(
+				path,
+				condition,
+				"Expected condition, but got empty thing"
+			);
+		}
+		return this.combineConditionsAnd(conditions);
+	}
+
+	/**
+	 * @param {Condition[]} conditions some conditions
+	 * @returns {Condition} merged condition
+	 */
+	combineConditionsOr(conditions) {
+		if (conditions.length === 0) {
+			return {
+				matchWhenEmpty: false,
+				fn: () => false
+			};
+		} else if (conditions.length === 1) {
+			return conditions[0];
+		}
+		return {
+			matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
+			fn: v => conditions.some(c => c.fn(v))
+		};
+	}
+
+	/**
+	 * @param {Condition[]} conditions some conditions
+	 * @returns {Condition} merged condition
+	 */
+	combineConditionsAnd(conditions) {
+		if (conditions.length === 0) {
+			return {
+				matchWhenEmpty: false,
+				fn: () => false
+			};
+		} else if (conditions.length === 1) {
+			return conditions[0];
+		}
+		return {
+			matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
+			fn: v => conditions.every(c => c.fn(v))
+		};
+	}
+
+	/**
+	 * @param {string} path current path
+	 * @param {any} value value at the error location
+	 * @param {string} message message explaining the problem
+	 * @returns {Error} an error object
+	 */
+	error(path, value, message) {
+		return new Error(
+			`Compiling RuleSet failed: ${message} (at ${path}: ${value})`
+		);
+	}
+}
+
+module.exports = RuleSetCompiler;
Index: imaps-frontend/node_modules/webpack/lib/rules/UseEffectRulePlugin.js
===================================================================
--- imaps-frontend/node_modules/webpack/lib/rules/UseEffectRulePlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/webpack/lib/rules/UseEffectRulePlugin.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,200 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const util = require("util");
+
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoader} RuleSetLoader */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").Effect} Effect */
+
+class UseEffectRulePlugin {
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			"UseEffectRulePlugin",
+			(path, rule, unhandledProperties, result, references) => {
+				/**
+				 * @param {keyof RuleSetRule} property property
+				 * @param {string} correctProperty correct property
+				 */
+				const conflictWith = (property, correctProperty) => {
+					if (unhandledProperties.has(property)) {
+						throw ruleSetCompiler.error(
+							`${path}.${property}`,
+							rule[property],
+							`A Rule must not have a '${property}' property when it has a '${correctProperty}' property`
+						);
+					}
+				};
+
+				if (unhandledProperties.has("use")) {
+					unhandledProperties.delete("use");
+					unhandledProperties.delete("enforce");
+
+					conflictWith("loader", "use");
+					conflictWith("options", "use");
+
+					const use = rule.use;
+					const enforce = rule.enforce;
+
+					const type = enforce ? `use-${enforce}` : "use";
+
+					/**
+					 * @param {string} path options path
+					 * @param {string} defaultIdent default ident when none is provided
+					 * @param {object} item user provided use value
+					 * @returns {Effect|function(any): Effect[]} effect
+					 */
+					const useToEffect = (path, defaultIdent, item) => {
+						if (typeof item === "function") {
+							return data => useToEffectsWithoutIdent(path, item(data));
+						}
+						return useToEffectRaw(path, defaultIdent, item);
+					};
+
+					/**
+					 * @param {string} path options path
+					 * @param {string} defaultIdent default ident when none is provided
+					 * @param {{ ident?: string, loader?: RuleSetLoader, options?: RuleSetLoaderOptions }} item user provided use value
+					 * @returns {Effect} effect
+					 */
+					const useToEffectRaw = (path, defaultIdent, item) => {
+						if (typeof item === "string") {
+							return {
+								type,
+								value: {
+									loader: item,
+									options: undefined,
+									ident: undefined
+								}
+							};
+						}
+						const loader = item.loader;
+						const options = item.options;
+						let ident = item.ident;
+						if (options && typeof options === "object") {
+							if (!ident) ident = defaultIdent;
+							references.set(ident, options);
+						}
+						if (typeof options === "string") {
+							util.deprecate(
+								() => {},
+								`Using a string as loader options is deprecated (${path}.options)`,
+								"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
+							)();
+						}
+						return {
+							type: enforce ? `use-${enforce}` : "use",
+							value: {
+								loader,
+								options,
+								ident
+							}
+						};
+					};
+
+					/**
+					 * @param {string} path options path
+					 * @param {any} items user provided use value
+					 * @returns {Effect[]} effects
+					 */
+					const useToEffectsWithoutIdent = (path, items) => {
+						if (Array.isArray(items)) {
+							return items
+								.filter(Boolean)
+								.map((item, idx) =>
+									useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
+								);
+						}
+						return [useToEffectRaw(path, "[[missing ident]]", items)];
+					};
+
+					/**
+					 * @param {string} path current path
+					 * @param {any} items user provided use value
+					 * @returns {(Effect|function(any): Effect[])[]} effects
+					 */
+					const useToEffects = (path, items) => {
+						if (Array.isArray(items)) {
+							return items.filter(Boolean).map((item, idx) => {
+								const subPath = `${path}[${idx}]`;
+								return useToEffect(subPath, subPath, item);
+							});
+						}
+						return [useToEffect(path, path, items)];
+					};
+
+					if (typeof use === "function") {
+						result.effects.push(data =>
+							useToEffectsWithoutIdent(
+								`${path}.use`,
+								use(/** @type {TODO} */ (data))
+							)
+						);
+					} else {
+						for (const effect of useToEffects(`${path}.use`, use)) {
+							result.effects.push(effect);
+						}
+					}
+				}
+
+				if (unhandledProperties.has("loader")) {
+					unhandledProperties.delete("loader");
+					unhandledProperties.delete("options");
+					unhandledProperties.delete("enforce");
+
+					const loader = /** @type {RuleSetLoader} */ (rule.loader);
+					const options = rule.options;
+					const enforce = rule.enforce;
+
+					if (loader.includes("!")) {
+						throw ruleSetCompiler.error(
+							`${path}.loader`,
+							loader,
+							"Exclamation mark separated loader lists has been removed in favor of the 'use' property with arrays"
+						);
+					}
+
+					if (loader.includes("?")) {
+						throw ruleSetCompiler.error(
+							`${path}.loader`,
+							loader,
+							"Query arguments on 'loader' has been removed in favor of the 'options' property"
+						);
+					}
+
+					if (typeof options === "string") {
+						util.deprecate(
+							() => {},
+							`Using a string as loader options is deprecated (${path}.options)`,
+							"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
+						)();
+					}
+
+					const ident =
+						options && typeof options === "object" ? path : undefined;
+					references.set(ident, options);
+					result.effects.push({
+						type: enforce ? `use-${enforce}` : "use",
+						value: {
+							loader,
+							options,
+							ident
+						}
+					});
+				}
+			}
+		);
+	}
+}
+
+module.exports = UseEffectRulePlugin;
