vibebusiness 1.2.73 → 1.2.77

package/.next/standalone/node_modules/webpack/lib/util/createHash.js

@@ -0,0 +1,91 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Hash")} Hash */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
+
+/** @type {typeof import("crypto") | undefined} */
+let crypto;
+/** @type {typeof import("./hash/xxhash64") | undefined} */
+let createXXHash64;
+/** @type {typeof import("./hash/md4") | undefined} */
+let createMd4;
+/** @type {typeof import("./hash/DebugHash") | undefined} */
+let DebugHash;
+/** @type {typeof import("./hash/BatchedHash") | undefined} */
+let BatchedHash;
+/** @type {typeof import("./hash/BulkUpdateHash") | undefined} */
+let BulkUpdateHash;
+
+/**
+ * Creates a hash by name or function
+ * @param {HashFunction} algorithm the algorithm name or a constructor creating a hash
+ * @returns {Hash} the hash
+ */
+module.exports = (algorithm) => {
+	if (typeof algorithm === "function") {
+		if (BulkUpdateHash === undefined) {
+			BulkUpdateHash = require("./hash/BulkUpdateHash");
+		}
+		// eslint-disable-next-line new-cap
+		return new BulkUpdateHash(() => new algorithm());
+	}
+	switch (algorithm) {
+		// TODO add non-cryptographic algorithm here
+		case "debug":
+			if (DebugHash === undefined) {
+				DebugHash = require("./hash/DebugHash");
+			}
+			return new DebugHash();
+		case "xxhash64":
+			if (createXXHash64 === undefined) {
+				createXXHash64 = require("./hash/xxhash64");
+				if (BatchedHash === undefined) {
+					BatchedHash = require("./hash/BatchedHash");
+				}
+			}
+			return new /** @type {typeof import("./hash/BatchedHash")} */ (
+				BatchedHash
+			)(createXXHash64());
+		case "md4":
+			if (createMd4 === undefined) {
+				createMd4 = require("./hash/md4");
+				if (BatchedHash === undefined) {
+					BatchedHash = require("./hash/BatchedHash");
+				}
+			}
+			return new /** @type {typeof import("./hash/BatchedHash")} */ (
+				BatchedHash
+			)(createMd4());
+		case "native-md4":
+			if (crypto === undefined) crypto = require("crypto");
+			if (BulkUpdateHash === undefined) {
+				BulkUpdateHash = require("./hash/BulkUpdateHash");
+			}
+			return new BulkUpdateHash(
+				() =>
+					/** @type {Hash} */ (
+						/** @type {typeof import("crypto")} */
+						(crypto).createHash("md4")
+					),
+				"md4"
+			);
+		default:
+			if (crypto === undefined) crypto = require("crypto");
+			if (BulkUpdateHash === undefined) {
+				BulkUpdateHash = require("./hash/BulkUpdateHash");
+			}
+			return new BulkUpdateHash(
+				() =>
+					/** @type {Hash} */ (
+						/** @type {typeof import("crypto")} */
+						(crypto).createHash(algorithm)
+					),
+				algorithm
+			);
+	}
+};

package/.next/standalone/node_modules/webpack/lib/util/dataURL.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+// data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
+// http://www.ietf.org/rfc/rfc2397.txt
+const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64)?)?,(.*)$/i;
+
+/**
+ * @param {string} uri data URI
+ * @returns {Buffer | null} decoded data
+ */
+const decodeDataURI = (uri) => {
+	const match = URIRegEx.exec(uri);
+	if (!match) return null;
+
+	const isBase64 = match[3];
+	const body = match[4];
+
+	if (isBase64) {
+		return Buffer.from(body, "base64");
+	}
+
+	// CSS allows to use `data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" style="stroke: rgb(223,224,225); stroke-width: 2px; fill: none; stroke-dasharray: 6px 3px" /></svg>`
+	// so we return original body if we can't `decodeURIComponent`
+	try {
+		return Buffer.from(decodeURIComponent(body), "ascii");
+	} catch (_) {
+		return Buffer.from(body, "ascii");
+	}
+};
+
+module.exports = {
+	URIRegEx,
+	decodeDataURI
+};

package/.next/standalone/node_modules/webpack/lib/util/deprecation.js

@@ -0,0 +1,350 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const util = require("util");
+
+/** @type {Map<string, () => void>} */
+const deprecationCache = new Map();
+
+/**
+ * @typedef {object} FakeHookMarker
+ * @property {true} _fakeHook it's a fake hook
+ */
+
+/**
+ * @template T
+ * @typedef {T & FakeHookMarker} FakeHook<T>
+ */
+
+/**
+ * @param {string} message deprecation message
+ * @param {string} code deprecation code
+ * @returns {() => void} function to trigger deprecation
+ */
+const createDeprecation = (message, code) => {
+	const cached = deprecationCache.get(message);
+	if (cached !== undefined) return cached;
+	const fn = util.deprecate(
+		() => {},
+		message,
+		`DEP_WEBPACK_DEPRECATION_${code}`
+	);
+	deprecationCache.set(message, fn);
+	return fn;
+};
+
+/** @typedef {"concat" | "entry" | "filter" | "find" | "findIndex" | "includes" | "indexOf" | "join" | "lastIndexOf" | "map" | "reduce" | "reduceRight" | "slice" | "some"} COPY_METHODS_NAMES */
+
+/** @type {COPY_METHODS_NAMES[]} */
+const COPY_METHODS = [
+	"concat",
+	"entry",
+	"filter",
+	"find",
+	"findIndex",
+	"includes",
+	"indexOf",
+	"join",
+	"lastIndexOf",
+	"map",
+	"reduce",
+	"reduceRight",
+	"slice",
+	"some"
+];
+
+/** @typedef {"copyWithin" | "entries" | "fill" | "keys" | "pop" | "reverse" | "shift" | "splice" | "sort" | "unshift"} DISABLED_METHODS_NAMES */
+
+/** @type {DISABLED_METHODS_NAMES[]} */
+const DISABLED_METHODS = [
+	"copyWithin",
+	"entries",
+	"fill",
+	"keys",
+	"pop",
+	"reverse",
+	"shift",
+	"splice",
+	"sort",
+	"unshift"
+];
+
+/**
+ * @template T
+ * @typedef {Set<T> & { [Symbol.isConcatSpreadable]: boolean } & { push: (...items: T[]) => void, length?: number } & { [P in DISABLED_METHODS_NAMES]: () => void } & { [P in COPY_METHODS_NAMES]: P extends keyof Array<T> ? () => Pick<Array<T>, P> : never }} SetWithDeprecatedArrayMethods
+ */
+
+/**
+ * @template T
+ * @param {Set<T>} set new set
+ * @param {string} name property name
+ * @returns {void}
+ */
+module.exports.arrayToSetDeprecation = (set, name) => {
+	for (const method of COPY_METHODS) {
+		if (/** @type {SetWithDeprecatedArrayMethods<T>} */ (set)[method]) continue;
+		const d = createDeprecation(
+			`${name} was changed from Array to Set (using Array method '${method}' is deprecated)`,
+			"ARRAY_TO_SET"
+		);
+		/** @type {EXPECTED_ANY} */
+		(set)[method] =
+			// eslint-disable-next-line func-names
+			function () {
+				d();
+				// eslint-disable-next-line unicorn/prefer-spread
+				const array = Array.from(this);
+				return Array.prototype[
+					/** @type {keyof COPY_METHODS} */ (method)
+				].apply(
+					array,
+					// eslint-disable-next-line prefer-rest-params
+					arguments
+				);
+			};
+	}
+	const dPush = createDeprecation(
+		`${name} was changed from Array to Set (using Array method 'push' is deprecated)`,
+		"ARRAY_TO_SET_PUSH"
+	);
+	const dLength = createDeprecation(
+		`${name} was changed from Array to Set (using Array property 'length' is deprecated)`,
+		"ARRAY_TO_SET_LENGTH"
+	);
+	const dIndexer = createDeprecation(
+		`${name} was changed from Array to Set (indexing Array is deprecated)`,
+		"ARRAY_TO_SET_INDEXER"
+	);
+	/** @type {SetWithDeprecatedArrayMethods<T>} */
+	(set).push = function push() {
+		dPush();
+		// eslint-disable-next-line prefer-rest-params, unicorn/prefer-spread
+		for (const item of Array.from(arguments)) {
+			this.add(item);
+		}
+		return this.size;
+	};
+	for (const method of DISABLED_METHODS) {
+		if (/** @type {SetWithDeprecatedArrayMethods<T>} */ (set)[method]) continue;
+
+		/** @type {SetWithDeprecatedArrayMethods<T>} */
+		(set)[method] = () => {
+			throw new Error(
+				`${name} was changed from Array to Set (using Array method '${method}' is not possible)`
+			);
+		};
+	}
+	/**
+	 * @param {number} index index
+	 * @returns {() => T | undefined} value
+	 */
+	const createIndexGetter = (index) => {
+		/**
+		 * @this {Set<T>} a Set
+		 * @returns {T | undefined} the value at this location
+		 */
+		// eslint-disable-next-line func-style
+		const fn = function () {
+			dIndexer();
+			let i = 0;
+			for (const item of this) {
+				if (i++ === index) return item;
+			}
+		};
+		return fn;
+	};
+	/**
+	 * @param {number} index index
+	 */
+	const defineIndexGetter = (index) => {
+		Object.defineProperty(set, index, {
+			get: createIndexGetter(index),
+			set(value) {
+				throw new Error(
+					`${name} was changed from Array to Set (indexing Array with write is not possible)`
+				);
+			}
+		});
+	};
+	defineIndexGetter(0);
+	let indexerDefined = 1;
+	Object.defineProperty(set, "length", {
+		get() {
+			dLength();
+			const length = this.size;
+			for (indexerDefined; indexerDefined < length + 1; indexerDefined++) {
+				defineIndexGetter(indexerDefined);
+			}
+			return length;
+		},
+		set(value) {
+			throw new Error(
+				`${name} was changed from Array to Set (writing to Array property 'length' is not possible)`
+			);
+		}
+	});
+	/** @type {SetWithDeprecatedArrayMethods<T>} */
+	(set)[Symbol.isConcatSpreadable] = true;
+};
+
+/**
+ * @template T
+ * @param {string} name name
+ * @returns {{ new <T = EXPECTED_ANY>(values?: ReadonlyArray<T> | null): SetDeprecatedArray<T> }} SetDeprecatedArray
+ */
+module.exports.createArrayToSetDeprecationSet = (name) => {
+	let initialized = false;
+
+	/**
+	 * @template T
+	 */
+	class SetDeprecatedArray extends Set {
+		/**
+		 * @param {ReadonlyArray<T> | null=} items items
+		 */
+		constructor(items) {
+			super(items);
+			if (!initialized) {
+				initialized = true;
+				module.exports.arrayToSetDeprecation(
+					/** @type {SetWithDeprecatedArrayMethods<T>} */
+					(SetDeprecatedArray.prototype),
+					name
+				);
+			}
+		}
+	}
+	return SetDeprecatedArray;
+};
+
+/**
+ * @template {object} T
+ * @param {T} fakeHook fake hook implementation
+ * @param {string=} message deprecation message (not deprecated when unset)
+ * @param {string=} code deprecation code (not deprecated when unset)
+ * @returns {FakeHook<T>} fake hook which redirects
+ */
+module.exports.createFakeHook = (fakeHook, message, code) => {
+	if (message && code) {
+		fakeHook = deprecateAllProperties(fakeHook, message, code);
+	}
+	return Object.freeze(
+		Object.assign(fakeHook, { _fakeHook: /** @type {true} */ (true) })
+	);
+};
+
+/**
+ * @template T
+ * @param {T} obj object
+ * @param {string} message deprecation message
+ * @param {string} code deprecation code
+ * @returns {T} object with property access deprecated
+ */
+const deprecateAllProperties = (obj, message, code) => {
+	const newObj = {};
+	const descriptors = Object.getOwnPropertyDescriptors(obj);
+	for (const name of Object.keys(descriptors)) {
+		const descriptor = descriptors[name];
+		if (typeof descriptor.value === "function") {
+			Object.defineProperty(newObj, name, {
+				...descriptor,
+				value: util.deprecate(descriptor.value, message, code)
+			});
+		} else if (descriptor.get || descriptor.set) {
+			Object.defineProperty(newObj, name, {
+				...descriptor,
+				get: descriptor.get && util.deprecate(descriptor.get, message, code),
+				set: descriptor.set && util.deprecate(descriptor.set, message, code)
+			});
+		} else {
+			let value = descriptor.value;
+			Object.defineProperty(newObj, name, {
+				configurable: descriptor.configurable,
+				enumerable: descriptor.enumerable,
+				get: util.deprecate(() => value, message, code),
+				set: descriptor.writable
+					? util.deprecate(
+							/**
+							 * @template T
+							 * @param {T} v value
+							 * @returns {T} result
+							 */
+							(v) => (value = v),
+							message,
+							code
+						)
+					: undefined
+			});
+		}
+	}
+	return /** @type {T} */ (newObj);
+};
+
+module.exports.deprecateAllProperties = deprecateAllProperties;
+
+/**
+ * @template {object} T
+ * @param {T} obj object
+ * @param {string} name property name
+ * @param {string} code deprecation code
+ * @param {string} note additional note
+ * @returns {T} frozen object with deprecation when modifying
+ */
+module.exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
+	const message = `${name} will be frozen in future, all modifications are deprecated.${
+		note && `\n${note}`
+	}`;
+	return /** @type {T} */ (
+		new Proxy(obj, {
+			set: util.deprecate(
+				/**
+				 * @param {object} target target
+				 * @param {string | symbol} property property
+				 * @param {EXPECTED_ANY} value value
+				 * @param {EXPECTED_ANY} receiver receiver
+				 * @returns {boolean} result
+				 */
+				(target, property, value, receiver) =>
+					Reflect.set(target, property, value, receiver),
+				message,
+				code
+			),
+			defineProperty: util.deprecate(
+				/**
+				 * @param {object} target target
+				 * @param {string | symbol} property property
+				 * @param {PropertyDescriptor} descriptor descriptor
+				 * @returns {boolean} result
+				 */
+				(target, property, descriptor) =>
+					Reflect.defineProperty(target, property, descriptor),
+				message,
+				code
+			),
+			deleteProperty: util.deprecate(
+				/**
+				 * @param {object} target target
+				 * @param {string | symbol} property property
+				 * @returns {boolean} result
+				 */
+				(target, property) => Reflect.deleteProperty(target, property),
+				message,
+				code
+			),
+			setPrototypeOf: util.deprecate(
+				/**
+				 * @param {object} target target
+				 * @param {EXPECTED_OBJECT | null} proto proto
+				 * @returns {boolean} result
+				 */
+				(target, proto) => Reflect.setPrototypeOf(target, proto),
+				message,
+				code
+			)
+		})
+	);
+};