vibebusiness 1.2.73 → 1.2.77

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

@@ -0,0 +1,313 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @param {string} str string
+ * @returns {string} quoted meta
+ */
+const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+
+/**
+ * @param {string} char character to escape for use in character class
+ * @returns {string} escaped character
+ */
+const quoteMetaInCharClass = (char) => {
+	// In character class, only these need escaping: ] \ ^ -
+	if (char === "]" || char === "\\" || char === "^" || char === "-") {
+		return `\\${char}`;
+	}
+	return char;
+};
+
+/**
+ * Converts an array of single characters into an optimized character class string
+ * using ranges where possible. E.g., ["1","2","3","4","a"] => "1-4a"
+ * @param {string[]} chars array of single characters (should be sorted)
+ * @returns {string} optimized character class content (without the brackets)
+ */
+const charsToCharClassContent = (chars) => {
+	if (chars.length === 0) return "";
+	if (chars.length === 1) return quoteMetaInCharClass(chars[0]);
+
+	// Sort by char code
+	const sorted = [...chars].sort((a, b) => a.charCodeAt(0) - b.charCodeAt(0));
+
+	/** @type {string[]} */
+	const parts = [];
+	let rangeStart = sorted[0];
+	let rangeEnd = sorted[0];
+
+	for (let i = 1; i < sorted.length; i++) {
+		const char = sorted[i];
+		const prevCode = rangeEnd.charCodeAt(0);
+		const currCode = char.charCodeAt(0);
+
+		if (currCode === prevCode + 1) {
+			// Extend the range
+			rangeEnd = char;
+		} else {
+			// Flush the current range
+			parts.push(formatRange(rangeStart, rangeEnd));
+			rangeStart = char;
+			rangeEnd = char;
+		}
+	}
+	// Flush the last range
+	parts.push(formatRange(rangeStart, rangeEnd));
+
+	return parts.join("");
+};
+
+/**
+ * Formats a range of characters for use in a character class
+ * @param {string} start start character
+ * @param {string} end end character
+ * @returns {string} formatted range
+ */
+const formatRange = (start, end) => {
+	const startCode = start.charCodeAt(0);
+	const endCode = end.charCodeAt(0);
+	const length = endCode - startCode + 1;
+
+	if (length === 1) {
+		return quoteMetaInCharClass(start);
+	}
+	if (length === 2) {
+		// For 2 chars, just list them (e.g., "ab" instead of "a-b")
+		return quoteMetaInCharClass(start) + quoteMetaInCharClass(end);
+	}
+	// For 3+ chars, use range notation
+	return `${quoteMetaInCharClass(start)}-${quoteMetaInCharClass(end)}`;
+};
+
+/**
+ * @param {string} str string
+ * @returns {string} string
+ */
+const toSimpleString = (str) => {
+	if (`${Number(str)}` === str) {
+		return str;
+	}
+	return JSON.stringify(str);
+};
+
+/**
+ * @param {Record<string | number, boolean>} map value map
+ * @returns {boolean | ((value: string) => string)} true/false, when unconditionally true/false, or a template function to determine the value at runtime
+ */
+const compileBooleanMatcher = (map) => {
+	const positiveItems = Object.keys(map).filter((i) => map[i]);
+	const negativeItems = Object.keys(map).filter((i) => !map[i]);
+	if (positiveItems.length === 0) return false;
+	if (negativeItems.length === 0) return true;
+	return compileBooleanMatcherFromLists(positiveItems, negativeItems);
+};
+
+/**
+ * @param {string[]} positiveItems positive items
+ * @param {string[]} negativeItems negative items
+ * @returns {(value: string) => string} a template function to determine the value at runtime
+ */
+const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
+	if (positiveItems.length === 0) return () => "false";
+	if (negativeItems.length === 0) return () => "true";
+	if (positiveItems.length === 1) {
+		return (value) => `${toSimpleString(positiveItems[0])} == ${value}`;
+	}
+	if (negativeItems.length === 1) {
+		return (value) => `${toSimpleString(negativeItems[0])} != ${value}`;
+	}
+	const positiveRegexp = itemsToRegexp(positiveItems);
+	const negativeRegexp = itemsToRegexp(negativeItems);
+	if (positiveRegexp.length <= negativeRegexp.length) {
+		return (value) => `/^${positiveRegexp}$/.test(${value})`;
+	}
+	return (value) => `!/^${negativeRegexp}$/.test(${value})`;
+};
+
+/** @typedef {string[][]} ListOfCommonItems */
+
+/**
+ * @param {Set<string>} itemsSet items set
+ * @param {(str: string) => string | false} getKey get key function
+ * @param {(str: string[]) => boolean} condition condition
+ * @returns {ListOfCommonItems} list of common items
+ */
+const popCommonItems = (itemsSet, getKey, condition) => {
+	/** @type {Map<string, string[]>} */
+	const map = new Map();
+	for (const item of itemsSet) {
+		const key = getKey(item);
+		if (key) {
+			let list = map.get(key);
+			if (list === undefined) {
+				/** @type {string[]} */
+				list = [];
+				map.set(key, list);
+			}
+			list.push(item);
+		}
+	}
+	/** @type {ListOfCommonItems} */
+	const result = [];
+	for (const list of map.values()) {
+		if (condition(list)) {
+			for (const item of list) {
+				itemsSet.delete(item);
+			}
+			result.push(list);
+		}
+	}
+	return result;
+};
+
+/**
+ * @param {string[]} items items
+ * @returns {string} common prefix
+ */
+const getCommonPrefix = (items) => {
+	let prefix = items[0];
+	for (let i = 1; i < items.length; i++) {
+		const item = items[i];
+		for (let p = 0; p < prefix.length; p++) {
+			if (item[p] !== prefix[p]) {
+				prefix = prefix.slice(0, p);
+				break;
+			}
+		}
+	}
+	return prefix;
+};
+
+/**
+ * @param {string[]} items items
+ * @returns {string} common suffix
+ */
+const getCommonSuffix = (items) => {
+	let suffix = items[0];
+	for (let i = 1; i < items.length; i++) {
+		const item = items[i];
+		for (let p = item.length - 1, s = suffix.length - 1; s >= 0; p--, s--) {
+			if (item[p] !== suffix[s]) {
+				suffix = suffix.slice(s + 1);
+				break;
+			}
+		}
+	}
+	return suffix;
+};
+
+/**
+ * @param {string[]} itemsArr array of items
+ * @returns {string} regexp
+ */
+const itemsToRegexp = (itemsArr) => {
+	if (itemsArr.length === 1) {
+		return quoteMeta(itemsArr[0]);
+	}
+	/** @type {string[]} */
+	const finishedItems = [];
+
+	// merge single char items: (a|b|c|d|ef) => ([abcd]|ef)
+	let countOfSingleCharItems = 0;
+	for (const item of itemsArr) {
+		if (item.length === 1) {
+			countOfSingleCharItems++;
+		}
+	}
+	// special case for only single char items
+	if (countOfSingleCharItems === itemsArr.length) {
+		return `[${charsToCharClassContent(itemsArr)}]`;
+	}
+	/** @type {Set<string>} */
+	const items = new Set(itemsArr.sort());
+	if (countOfSingleCharItems > 2) {
+		/** @type {string[]} */
+		const singleCharItems = [];
+		for (const item of items) {
+			if (item.length === 1) {
+				singleCharItems.push(item);
+				items.delete(item);
+			}
+		}
+		finishedItems.push(`[${charsToCharClassContent(singleCharItems)}]`);
+	}
+
+	// special case for 2 items with common prefix/suffix
+	if (finishedItems.length === 0 && items.size === 2) {
+		const prefix = getCommonPrefix(itemsArr);
+		const suffix = getCommonSuffix(
+			itemsArr.map((item) => item.slice(prefix.length))
+		);
+		if (prefix.length > 0 || suffix.length > 0) {
+			return `${quoteMeta(prefix)}${itemsToRegexp(
+				itemsArr.map((i) => i.slice(prefix.length, -suffix.length || undefined))
+			)}${quoteMeta(suffix)}`;
+		}
+	}
+
+	// special case for 2 items with common suffix
+	if (finishedItems.length === 0 && items.size === 2) {
+		/** @type {SetIterator<string>} */
+		const it = items[Symbol.iterator]();
+		const a = /** @type {string} */ (it.next().value);
+		const b = /** @type {string} */ (it.next().value);
+		if (a.length > 0 && b.length > 0 && a.slice(-1) === b.slice(-1)) {
+			return `${itemsToRegexp([a.slice(0, -1), b.slice(0, -1)])}${quoteMeta(
+				a.slice(-1)
+			)}`;
+		}
+	}
+
+	// find common prefix: (a1|a2|a3|a4|b5) => (a(1|2|3|4)|b5)
+	const prefixed = popCommonItems(
+		items,
+		(item) => (item.length >= 1 ? item[0] : false),
+		(list) => {
+			if (list.length >= 3) return true;
+			if (list.length <= 1) return false;
+			return list[0][1] === list[1][1];
+		}
+	);
+	for (const prefixedItems of prefixed) {
+		const prefix = getCommonPrefix(prefixedItems);
+		finishedItems.push(
+			`${quoteMeta(prefix)}${itemsToRegexp(
+				prefixedItems.map((i) => i.slice(prefix.length))
+			)}`
+		);
+	}
+
+	// find common suffix: (a1|b1|c1|d1|e2) => ((a|b|c|d)1|e2)
+	const suffixed = popCommonItems(
+		items,
+		(item) => (item.length >= 1 ? item.slice(-1) : false),
+		(list) => {
+			if (list.length >= 3) return true;
+			if (list.length <= 1) return false;
+			return list[0].slice(-2) === list[1].slice(-2);
+		}
+	);
+	for (const suffixedItems of suffixed) {
+		const suffix = getCommonSuffix(suffixedItems);
+		finishedItems.push(
+			`${itemsToRegexp(
+				suffixedItems.map((i) => i.slice(0, -suffix.length))
+			)}${quoteMeta(suffix)}`
+		);
+	}
+
+	/** @type {string[]} */
+	const conditional = [...finishedItems, ...Array.from(items, quoteMeta)];
+	if (conditional.length === 1) return conditional[0];
+	return `(${conditional.join("|")})`;
+};
+
+compileBooleanMatcher.fromLists = compileBooleanMatcherFromLists;
+compileBooleanMatcher.itemsToRegexp = itemsToRegexp;
+
+module.exports = compileBooleanMatcher;

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

@@ -0,0 +1,232 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Template = require("../Template");
+
+/** @typedef {import("eslint-scope").Scope} Scope */
+/** @typedef {import("eslint-scope").Reference} Reference */
+/** @typedef {import("eslint-scope").Variable} Variable */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {Set<string>} UsedNames */
+
+const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
+const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
+
+/**
+ * @param {Variable} variable variable
+ * @returns {Reference[]} references
+ */
+const getAllReferences = (variable) => {
+	let set = variable.references;
+	// Look for inner scope variables too (like in class Foo { t() { Foo } })
+	const identifiers = new Set(variable.identifiers);
+	for (const scope of variable.scope.childScopes) {
+		for (const innerVar of scope.variables) {
+			if (innerVar.identifiers.some((id) => identifiers.has(id))) {
+				set = [...set, ...innerVar.references];
+				break;
+			}
+		}
+	}
+	return set;
+};
+
+/**
+ * @param {Node | Node[]} ast ast
+ * @param {Node} node node
+ * @returns {undefined | Node[]} result
+ */
+const getPathInAst = (ast, node) => {
+	if (ast === node) {
+		return [];
+	}
+
+	const nr = /** @type {Range} */ (node.range);
+
+	/**
+	 * @param {Node} n node
+	 * @returns {Node[] | undefined} result
+	 */
+	const enterNode = (n) => {
+		if (!n) return;
+		const r = n.range;
+		if (r && r[0] <= nr[0] && r[1] >= nr[1]) {
+			const path = getPathInAst(n, node);
+			if (path) {
+				path.push(n);
+				return path;
+			}
+		}
+	};
+
+	if (Array.isArray(ast)) {
+		for (let i = 0; i < ast.length; i++) {
+			const enterResult = enterNode(ast[i]);
+			if (enterResult !== undefined) return enterResult;
+		}
+	} else if (ast && typeof ast === "object") {
+		const keys =
+			/** @type {(keyof Node)[]} */
+			(Object.keys(ast));
+		for (let i = 0; i < keys.length; i++) {
+			// We are making the faster check in `enterNode` using `n.range`
+			const value =
+				ast[
+					/** @type {Exclude<keyof Node, "range" | "loc" | "leadingComments" | "trailingComments">} */
+					(keys[i])
+				];
+			if (Array.isArray(value)) {
+				const pathResult = getPathInAst(value, node);
+				if (pathResult !== undefined) return pathResult;
+			} else if (value && typeof value === "object") {
+				const enterResult = enterNode(value);
+				if (enterResult !== undefined) return enterResult;
+			}
+		}
+	}
+};
+
+/**
+ * @param {string} oldName old name
+ * @param {UsedNames} usedNamed1 used named 1
+ * @param {UsedNames} usedNamed2 used named 2
+ * @param {string} extraInfo extra info
+ * @returns {string} found new name
+ */
+function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
+	let name = oldName;
+
+	if (name === DEFAULT_EXPORT) {
+		name = "";
+	}
+	if (name === NAMESPACE_OBJECT_EXPORT) {
+		name = "namespaceObject";
+	}
+
+	// Remove uncool stuff
+	extraInfo = extraInfo.replace(
+		/\.+\/|(?:\/index)?\.[a-zA-Z0-9]{1,4}(?:$|\s|\?)|\s*\+\s*\d+\s*modules/g,
+		""
+	);
+
+	const splittedInfo = extraInfo.split("/");
+	while (splittedInfo.length) {
+		name = splittedInfo.pop() + (name ? `_${name}` : "");
+		const nameIdent = Template.toIdentifier(name);
+		if (
+			!usedNamed1.has(nameIdent) &&
+			(!usedNamed2 || !usedNamed2.has(nameIdent))
+		) {
+			return nameIdent;
+		}
+	}
+
+	let i = 0;
+	let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+	while (
+		usedNamed1.has(nameWithNumber) ||
+		// eslint-disable-next-line no-unmodified-loop-condition
+		(usedNamed2 && usedNamed2.has(nameWithNumber))
+	) {
+		i++;
+		nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+	}
+	return nameWithNumber;
+}
+
+/** @typedef {Set<Scope>} ScopeSet */
+
+/**
+ * @param {Scope | null} s scope
+ * @param {UsedNames} nameSet name set
+ * @param {ScopeSet} scopeSet1 scope set 1
+ * @param {ScopeSet} scopeSet2 scope set 2
+ */
+const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
+	let scope = s;
+	while (scope) {
+		if (scopeSet1.has(scope)) break;
+		if (scopeSet2.has(scope)) break;
+		scopeSet1.add(scope);
+		for (const variable of scope.variables) {
+			nameSet.add(variable.name);
+		}
+		scope = scope.upper;
+	}
+};
+
+const RESERVED_NAMES = new Set(
+	[
+		// internal names (should always be renamed)
+		DEFAULT_EXPORT,
+		NAMESPACE_OBJECT_EXPORT,
+
+		// keywords
+		"abstract,arguments,async,await,boolean,break,byte,case,catch,char,class,const,continue",
+		"debugger,default,delete,do,double,else,enum,eval,export,extends,false,final,finally,float",
+		"for,function,goto,if,implements,import,in,instanceof,int,interface,let,long,native,new,null",
+		"package,private,protected,public,return,short,static,super,switch,synchronized,this,throw",
+		"throws,transient,true,try,typeof,var,void,volatile,while,with,yield",
+
+		// commonjs/amd
+		"module,__dirname,__filename,exports,require,define",
+
+		// js globals
+		"Array,Date,eval,function,hasOwnProperty,Infinity,isFinite,isNaN,isPrototypeOf,length,Math",
+		"NaN,name,Number,Object,prototype,String,Symbol,toString,undefined,valueOf",
+
+		// browser globals
+		"alert,all,anchor,anchors,area,assign,blur,button,checkbox,clearInterval,clearTimeout",
+		"clientInformation,close,closed,confirm,constructor,crypto,decodeURI,decodeURIComponent",
+		"defaultStatus,document,element,elements,embed,embeds,encodeURI,encodeURIComponent,escape",
+		"event,fileUpload,focus,form,forms,frame,innerHeight,innerWidth,layer,layers,link,location",
+		"mimeTypes,navigate,navigator,frames,frameRate,hidden,history,image,images,offscreenBuffering",
+		"open,opener,option,outerHeight,outerWidth,packages,pageXOffset,pageYOffset,parent,parseFloat",
+		"parseInt,password,pkcs11,plugin,prompt,propertyIsEnum,radio,reset,screenX,screenY,scroll",
+		"secure,select,self,setInterval,setTimeout,status,submit,taint,text,textarea,top,unescape",
+		"untaint,window",
+
+		// window events
+		"onblur,onclick,onerror,onfocus,onkeydown,onkeypress,onkeyup,onmouseover,onload,onmouseup,onmousedown,onsubmit"
+	]
+		.join(",")
+		.split(",")
+);
+
+/** @typedef {{ usedNames: UsedNames, alreadyCheckedScopes: ScopeSet }} ScopeInfo */
+/** @typedef {Map<string, ScopeInfo>} UsedNamesInScopeInfo */
+
+/**
+ * @param {UsedNamesInScopeInfo} usedNamesInScopeInfo used names in scope info
+ * @param {string} module module identifier
+ * @param {string} id export id
+ * @returns {ScopeInfo} info
+ */
+const getUsedNamesInScopeInfo = (usedNamesInScopeInfo, module, id) => {
+	const key = `${module}-${id}`;
+	let info = usedNamesInScopeInfo.get(key);
+	if (info === undefined) {
+		info = {
+			usedNames: new Set(),
+			alreadyCheckedScopes: new Set()
+		};
+		usedNamesInScopeInfo.set(key, info);
+	}
+	return info;
+};
+
+module.exports = {
+	DEFAULT_EXPORT,
+	NAMESPACE_OBJECT_EXPORT,
+	RESERVED_NAMES,
+	addScopeSymbols,
+	findNewName,
+	getAllReferences,
+	getPathInAst,
+	getUsedNamesInScopeInfo
+};

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

@@ -0,0 +1,126 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Gengkun He @ahabhgk
+*/
+
+"use strict";
+
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+// Copy from css-loader
+/**
+ * @param {string} string string
+ * @returns {string} result
+ */
+const preserveCamelCase = (string) => {
+	let result = string;
+	let isLastCharLower = false;
+	let isLastCharUpper = false;
+	let isLastLastCharUpper = false;
+
+	for (let i = 0; i < result.length; i++) {
+		const character = result[i];
+
+		if (isLastCharLower && /\p{Lu}/u.test(character)) {
+			result = `${result.slice(0, i)}-${result.slice(i)}`;
+			isLastCharLower = false;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = true;
+			i += 1;
+		} else if (
+			isLastCharUpper &&
+			isLastLastCharUpper &&
+			/\p{Ll}/u.test(character)
+		) {
+			result = `${result.slice(0, i - 1)}-${result.slice(i - 1)}`;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = false;
+			isLastCharLower = true;
+		} else {
+			isLastCharLower =
+				character.toLowerCase() === character &&
+				character.toUpperCase() !== character;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper =
+				character.toUpperCase() === character &&
+				character.toLowerCase() !== character;
+		}
+	}
+
+	return result;
+};
+
+// Copy from css-loader
+/**
+ * @param {string} input input
+ * @returns {string} result
+ */
+module.exports.camelCase = (input) => {
+	let result = input.trim();
+
+	if (result.length === 0) {
+		return "";
+	}
+
+	if (result.length === 1) {
+		return result.toLowerCase();
+	}
+
+	const hasUpperCase = result !== result.toLowerCase();
+
+	if (hasUpperCase) {
+		result = preserveCamelCase(result);
+	}
+
+	return result
+		.replace(/^[_.\- ]+/, "")
+		.toLowerCase()
+		.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toUpperCase())
+		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, (m) => m.toUpperCase());
+};
+
+/**
+ * @param {string} input input
+ * @param {CssGeneratorExportsConvention | undefined} convention convention
+ * @returns {string[]} results
+ */
+module.exports.cssExportConvention = (input, convention) => {
+	/** @type {Set<string>} */
+	const set = new Set();
+	if (typeof convention === "function") {
+		set.add(convention(input));
+	} else {
+		switch (convention) {
+			case "camel-case": {
+				set.add(input);
+				set.add(module.exports.camelCase(input));
+				break;
+			}
+			case "camel-case-only": {
+				set.add(module.exports.camelCase(input));
+				break;
+			}
+			case "dashes": {
+				set.add(input);
+				set.add(module.exports.dashesCamelCase(input));
+				break;
+			}
+			case "dashes-only": {
+				set.add(module.exports.dashesCamelCase(input));
+				break;
+			}
+			case "as-is": {
+				set.add(input);
+				break;
+			}
+		}
+	}
+	return [...set];
+};
+
+// Copy from css-loader
+/**
+ * @param {string} input input
+ * @returns {string} result
+ */
+module.exports.dashesCamelCase = (input) =>
+	input.replace(/-+(\w)/g, (match, firstLetter) => firstLetter.toUpperCase());

package/.next/standalone/node_modules/webpack/lib/util/create-schema-validation.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const memoize = require("./memoize");
+
+/** @typedef {import("schema-utils").Schema} Schema */
+/** @typedef {import("schema-utils").ValidationErrorConfiguration} ValidationErrorConfiguration */
+
+const getValidate = memoize(() => require("schema-utils").validate);
+
+/**
+ * @template {object | object[]} T
+ * @param {((value: T) => boolean) | undefined} check check
+ * @param {() => Schema} getSchema get schema fn
+ * @param {ValidationErrorConfiguration} options options
+ * @returns {(value?: T) => void} validate
+ */
+const createSchemaValidation = (check, getSchema, options) => {
+	getSchema = memoize(getSchema);
+	return (value) => {
+		if (check && value && !check(value)) {
+			getValidate()(
+				getSchema(),
+				/** @type {EXPECTED_OBJECT | EXPECTED_OBJECT[]} */
+				(value),
+				options
+			);
+			require("util").deprecate(
+				() => {},
+				"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+				"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+			)();
+		}
+	};
+};
+
+module.exports = createSchemaValidation;