vibebusiness 1.2.73 → 1.2.77

package/.next/standalone/node_modules/webpack/lib/rules/UseEffectRulePlugin.js

@@ -0,0 +1,236 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const util = require("util");
+
+/** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoader} RuleSetLoader */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").Effect} Effect */
+/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
+/** @typedef {import("./RuleSetCompiler").EffectUseType} EffectUseType */
+
+const PLUGIN_NAME = "UseEffectRulePlugin";
+
+class UseEffectRulePlugin {
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			PLUGIN_NAME,
+			(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 = /** @type {RuleSetUse} */ (rule.use);
+					const enforce = rule.enforce;
+
+					const type =
+						/** @type {EffectUseType} */
+						(enforce ? `use-${enforce}` : "use");
+
+					/**
+					 * @param {string} path options path
+					 * @param {string} defaultIdent default ident when none is provided
+					 * @param {RuleSetUseItem} item user provided use value
+					 * @returns {(Effect | ((effectData: EffectData) => Effect[]))} effect
+					 */
+					const useToEffect = (path, defaultIdent, item) => {
+						if (typeof item === "function") {
+							return (data) =>
+								useToEffectsWithoutIdent(
+									path,
+									/** @type {RuleSetUseItem | RuleSetUseItem[]} */
+									(item(data))
+								);
+						}
+						return useToEffectRaw(path, defaultIdent, item);
+					};
+
+					/**
+					 * @param {string} path options path
+					 * @param {string} defaultIdent default ident when none is provided
+					 * @param {Exclude<NonNullable<RuleSetUseItem>, EXPECTED_FUNCTION>} 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 = /** @type {string} */ (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 {RuleSetUseItem | (Falsy | RuleSetUseItem)[]} 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]]",
+									/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+									(item)
+								)
+							);
+						}
+						return [
+							useToEffectRaw(
+								path,
+								"[[missing ident]]",
+								/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+								(items)
+							)
+						];
+					};
+
+					/**
+					 * @param {string} path current path
+					 * @param {RuleSetUse} items user provided use value
+					 * @returns {(Effect | ((effectData: EffectData) => 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,
+									/** @type {RuleSetUseItem} */
+									(item)
+								);
+							});
+						}
+						return [
+							useToEffect(path, path, /** @type {RuleSetUseItem} */ (items))
+						];
+					};
+
+					if (typeof use === "function") {
+						result.effects.push((data) =>
+							useToEffectsWithoutIdent(`${path}.use`, use(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;
+
+					if (ident) {
+						references.set(
+							ident,
+							/** @type {RuleSetLoaderOptions} */
+							(options)
+						);
+					}
+
+					result.effects.push({
+						type: enforce ? `use-${enforce}` : "use",
+						value: {
+							loader,
+							options,
+							ident
+						}
+					});
+				}
+			}
+		);
+	}
+}
+
+module.exports = UseEffectRulePlugin;

package/.next/standalone/node_modules/webpack/lib/runtime/AsyncModuleRuntimeModule.js

@@ -0,0 +1,199 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class AsyncModuleRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {boolean=} deferInterop if defer import is used.
+	 */
+	constructor(deferInterop = false) {
+		super("async module");
+		/** @type {boolean} */
+		this._deferInterop = deferInterop;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.asyncModule;
+		const defer = this._deferInterop;
+		return Template.asString([
+			'var hasSymbol = typeof Symbol === "function";',
+			'var webpackQueues = hasSymbol ? Symbol("webpack queues") : "__webpack_queues__";',
+			`var webpackExports = ${
+				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
+			}hasSymbol ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
+			'var webpackError = hasSymbol ? Symbol("webpack error") : "__webpack_error__";',
+			defer
+				? Template.asString([
+						`var webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = hasSymbol ? Symbol("webpack done") : "__webpack_done__";`,
+						`var webpackDefer = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol} = hasSymbol ? Symbol("webpack defer") : "__webpack_defer__";`,
+						`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies} = ${runtimeTemplate.basicFunction(
+							"asyncDeps",
+							[
+								Template.indent([
+									"var hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {",
+									Template.indent([
+										"var cache = __webpack_module_cache__[id];",
+										"return !cache || cache[webpackDone] === false;"
+									]),
+									"});",
+									"if (hasUnresolvedAsyncSubgraph) {",
+									Template.indent([
+										"return ({ then(onFulfilled, onRejected) { return Promise.all(asyncDeps.map(__webpack_require__)).then(onFulfilled, onRejected) } })"
+									]),
+									"}"
+								])
+							]
+						)}`
+					])
+				: "",
+			`var resolveQueue = ${runtimeTemplate.basicFunction("queue", [
+				"if(queue && queue.d < 1) {",
+				Template.indent([
+					"queue.d = 1;",
+					`queue.forEach(${runtimeTemplate.expressionFunction(
+						"fn.r--",
+						"fn"
+					)});`,
+					`queue.forEach(${runtimeTemplate.expressionFunction(
+						"fn.r-- ? fn.r++ : fn()",
+						"fn"
+					)});`
+				]),
+				"}"
+			])}`,
+			`var wrapDeps = ${runtimeTemplate.returningFunction(
+				`deps.map(${runtimeTemplate.basicFunction("dep", [
+					'if(dep !== null && typeof dep === "object") {',
+					Template.indent([
+						defer
+							? Template.asString([
+									"if(!dep[webpackQueues] && dep[webpackDefer]) {",
+									Template.indent([
+										`var asyncDeps = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(dep[webpackDefer]);`,
+										"if (asyncDeps) {",
+										Template.indent([
+											"var d = dep;",
+											"dep = {",
+											Template.indent([
+												"then(onFulfilled, onRejected) {",
+												Template.indent([
+													`asyncDeps.then(${runtimeTemplate.returningFunction(
+														"onFulfilled(d)"
+													)}, onRejected);`
+												]),
+												"}"
+											]),
+											"};"
+										]),
+										"} else return dep;"
+									]),
+									"}"
+								])
+							: "",
+						"if(dep[webpackQueues]) return dep;",
+						"if(dep.then) {",
+						Template.indent([
+							"var queue = [];",
+							"queue.d = 0;",
+							`dep.then(${runtimeTemplate.basicFunction("r", [
+								"obj[webpackExports] = r;",
+								"resolveQueue(queue);"
+							])}, ${runtimeTemplate.basicFunction("e", [
+								"obj[webpackError] = e;",
+								"resolveQueue(queue);"
+							])});`,
+							"var obj = {};",
+							defer ? "obj[webpackDefer] = false;" : "",
+							`obj[webpackQueues] = ${runtimeTemplate.expressionFunction(
+								"fn(queue)",
+								"fn"
+							)};`,
+							"return obj;"
+						]),
+						"}"
+					]),
+					"}",
+					"var ret = {};",
+					`ret[webpackQueues] = ${runtimeTemplate.emptyFunction()};`,
+					"ret[webpackExports] = dep;",
+					"return ret;"
+				])})`,
+				"deps"
+			)};`,
+			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
+				"var queue;",
+				"hasAwait && ((queue = []).d = -1);",
+				"var depQueues = new Set();",
+				"var exports = module.exports;",
+				"var currentDeps;",
+				"var outerResolve;",
+				"var reject;",
+				`var promise = new Promise(${runtimeTemplate.basicFunction(
+					"resolve, rej",
+					["reject = rej;", "outerResolve = resolve;"]
+				)});`,
+				"promise[webpackExports] = exports;",
+				`promise[webpackQueues] = ${runtimeTemplate.expressionFunction(
+					`queue && fn(queue), depQueues.forEach(fn), promise["catch"](${runtimeTemplate.emptyFunction()})`,
+					"fn"
+				)};`,
+				"module.exports = promise;",
+				`var handle = ${runtimeTemplate.basicFunction("deps", [
+					"currentDeps = wrapDeps(deps);",
+					"var fn;",
+					`var getResult = ${runtimeTemplate.returningFunction(
+						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
+							defer ? "if(d[webpackDefer]) return d;" : "",
+							"if(d[webpackError]) throw d[webpackError];",
+							"return d[webpackExports];"
+						])})`
+					)}`,
+					`var promise = new Promise(${runtimeTemplate.basicFunction(
+						"resolve",
+						[
+							`fn = ${runtimeTemplate.expressionFunction(
+								"resolve(getResult)",
+								""
+							)};`,
+							"fn.r = 0;",
+							`var fnQueue = ${runtimeTemplate.expressionFunction(
+								"q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)))",
+								"q"
+							)};`,
+							`currentDeps.map(${runtimeTemplate.expressionFunction(
+								`${
+									defer ? "dep[webpackDefer]||" : ""
+								}dep[webpackQueues](fnQueue)`,
+								"dep"
+							)});`
+						]
+					)});`,
+					"return fn.r ? promise : getResult();"
+				])}`,
+				`var done = ${runtimeTemplate.expressionFunction(
+					`(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)${
+						defer ? ", promise[webpackDone] = true" : ""
+					}`,
+					"err"
+				)}`,
+				"body(handle, done);",
+				"queue && queue.d < 0 && (queue.d = 0);"
+			])};`
+		]);
+	}
+}
+
+module.exports = AsyncModuleRuntimeModule;

package/.next/standalone/node_modules/webpack/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -0,0 +1,90 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
+const { getUndoPath } = require("../util/identifier");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+
+class AutoPublicPathRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("publicPath", RuntimeModule.STAGE_BASIC);
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { scriptType, importMetaName, path, environment } =
+			compilation.outputOptions;
+		const chunkName = compilation.getPath(
+			JavascriptModulesPlugin.getChunkFilenameTemplate(
+				/** @type {Chunk} */
+				(this.chunk),
+				compilation.outputOptions
+			),
+			{
+				chunk: this.chunk,
+				contentHashType: "javascript"
+			}
+		);
+		const undoPath = getUndoPath(
+			chunkName,
+			/** @type {string} */ (path),
+			false
+		);
+
+		const global = environment.globalThis
+			? "globalThis"
+			: RuntimeGlobals.global;
+
+		return Template.asString([
+			"var scriptUrl;",
+			scriptType === "module"
+				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
+				: Template.asString([
+						`if (${global}.importScripts) scriptUrl = ${global}.location + "";`,
+						`var document = ${global}.document;`,
+						"if (!scriptUrl && document) {",
+						Template.indent([
+							// Technically we could use `document.currentScript instanceof window.HTMLScriptElement`,
+							// but an attacker could try to inject `<script>HTMLScriptElement = HTMLImageElement</script>`
+							// and use `<img name="currentScript" src="https://attacker.controlled.server/"></img>`
+							"if (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')",
+							Template.indent("scriptUrl = document.currentScript.src;"),
+							"if (!scriptUrl) {",
+							Template.indent([
+								'var scripts = document.getElementsByTagName("script");',
+								"if(scripts.length) {",
+								Template.indent([
+									"var i = scripts.length - 1;",
+									"while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;"
+								]),
+								"}"
+							]),
+							"}"
+						]),
+						"}"
+					]),
+			"// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration",
+			'// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
+			'if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");',
+			'scriptUrl = scriptUrl.replace(/^blob:/, "").replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
+			!undoPath
+				? `${RuntimeGlobals.publicPath} = scriptUrl;`
+				: `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(
+						undoPath
+					)};`
+		]);
+	}
+}
+
+module.exports = AutoPublicPathRuntimeModule;

package/.next/standalone/node_modules/webpack/lib/runtime/BaseUriRuntimeModule.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("../Chunk")} Chunk */
+
+class BaseUriRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("base uri", RuntimeModule.STAGE_ATTACH);
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const options =
+			/** @type {EntryDescription} */
+			(chunk.getEntryOptions());
+		return `${RuntimeGlobals.baseURI} = ${
+			options.baseUri === undefined
+				? "undefined"
+				: JSON.stringify(options.baseUri)
+		};`;
+	}
+}
+
+module.exports = BaseUriRuntimeModule;

package/.next/standalone/node_modules/webpack/lib/runtime/ChunkNameRuntimeModule.js

@@ -0,0 +1,28 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+
+class ChunkNameRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} chunkName the chunk's name
+	 */
+	constructor(chunkName) {
+		super("chunkName");
+		/** @type {string} */
+		this.chunkName = chunkName;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		return `${RuntimeGlobals.chunkName} = ${JSON.stringify(this.chunkName)};`;
+	}
+}
+
+module.exports = ChunkNameRuntimeModule;

package/.next/standalone/node_modules/webpack/lib/runtime/CompatGetDefaultExportRuntimeModule.js

@@ -0,0 +1,40 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("compat get default export");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.compatGetDefaultExport;
+		return Template.asString([
+			"// getDefaultExport function for compatibility with non-harmony modules",
+			`${fn} = ${runtimeTemplate.basicFunction("module", [
+				"var getter = module && module.__esModule ?",
+				Template.indent([
+					`${runtimeTemplate.returningFunction("module['default']")} :`,
+					`${runtimeTemplate.returningFunction("module")};`
+				]),
+				`${RuntimeGlobals.definePropertyGetters}(getter, { a: getter });`,
+				"return getter;"
+			])};`
+		]);
+	}
+}
+
+module.exports = CompatGetDefaultExportRuntimeModule;