vibebusiness 1.2.73 → 1.2.77

package/.next/standalone/node_modules/enhanced-resolve/lib/UseFilePlugin.js

@@ -0,0 +1,55 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class UseFilePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} filename filename
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, filename, target) {
+		this.source = source;
+		this.filename = filename;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("UseFilePlugin", (request, resolveContext, callback) => {
+				const filePath = resolver.join(
+					/** @type {string} */ (request.path),
+					this.filename,
+				);
+
+				/** @type {ResolveRequest} */
+				const obj = {
+					...request,
+					path: filePath,
+					relativePath:
+						request.relativePath &&
+						resolver.join(request.relativePath, this.filename),
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					`using path: ${filePath}`,
+					resolveContext,
+					callback,
+				);
+			});
+	}
+};

package/.next/standalone/node_modules/enhanced-resolve/lib/createInnerContext.js

@@ -0,0 +1,46 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
+
+/**
+ * @param {ResolveContext} options options for inner context
+ * @param {null | string} message message to log
+ * @returns {ResolveContext} inner context
+ */
+module.exports = function createInnerContext(options, message) {
+	let messageReported = false;
+	let innerLog;
+	if (options.log) {
+		if (message) {
+			/**
+			 * @param {string} msg message
+			 */
+			innerLog = (msg) => {
+				if (!messageReported) {
+					/** @type {((str: string) => void)} */
+					(options.log)(message);
+					messageReported = true;
+				}
+
+				/** @type {((str: string) => void)} */
+				(options.log)(`  ${msg}`);
+			};
+		} else {
+			innerLog = options.log;
+		}
+	}
+
+	return {
+		log: innerLog,
+		yield: options.yield,
+		fileDependencies: options.fileDependencies,
+		contextDependencies: options.contextDependencies,
+		missingDependencies: options.missingDependencies,
+		stack: options.stack,
+	};
+};

package/.next/standalone/node_modules/enhanced-resolve/lib/forEachBail.js

@@ -0,0 +1,50 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+
+/**
+ * @template T
+ * @template Z
+ * @callback Iterator
+ * @param {T} item item
+ * @param {(err?: null | Error, result?: null | Z) => void} callback callback
+ * @param {number} i index
+ * @returns {void}
+ */
+
+/**
+ * @template T
+ * @template Z
+ * @param {T[]} array array
+ * @param {Iterator<T, Z>} iterator iterator
+ * @param {(err?: null | Error, result?: null | Z, i?: number) => void} callback callback after all items are iterated
+ * @returns {void}
+ */
+module.exports = function forEachBail(array, iterator, callback) {
+	if (array.length === 0) return callback();
+
+	let i = 0;
+	const next = () => {
+		/** @type {boolean | undefined} */
+		let loop;
+		iterator(
+			array[i++],
+			(err, result) => {
+				if (err || result !== undefined || i >= array.length) {
+					return callback(err, result, i);
+				}
+				if (loop === false) while (next());
+				loop = true;
+			},
+			i,
+		);
+		if (!loop) loop = false;
+		return loop;
+	};
+	while (next());
+};

package/.next/standalone/node_modules/enhanced-resolve/lib/getInnerRequest.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+
+/**
+ * @param {Resolver} resolver resolver
+ * @param {ResolveRequest} request string
+ * @returns {string} inner request
+ */
+module.exports = function getInnerRequest(resolver, request) {
+	if (
+		typeof request.__innerRequest === "string" &&
+		request.__innerRequest_request === request.request &&
+		request.__innerRequest_relativePath === request.relativePath
+	) {
+		return request.__innerRequest;
+	}
+	/** @type {string | undefined} */
+	let innerRequest;
+	if (request.request) {
+		innerRequest = request.request;
+		if (/^\.\.?(?:\/|$)/.test(innerRequest) && request.relativePath) {
+			innerRequest = resolver.join(request.relativePath, innerRequest);
+		}
+	} else {
+		innerRequest = request.relativePath;
+	}
+	// eslint-disable-next-line camelcase
+	request.__innerRequest_request = request.request;
+	// eslint-disable-next-line camelcase
+	request.__innerRequest_relativePath = request.relativePath;
+	return (request.__innerRequest = /** @type {string} */ (innerRequest));
+};

package/.next/standalone/node_modules/enhanced-resolve/lib/getPaths.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @param {string} path path
+ * @returns {{ paths: string[], segments: string[] }}} paths and segments
+ */
+module.exports = function getPaths(path) {
+	if (path === "/") return { paths: ["/"], segments: [""] };
+	const parts = path.split(/(.*?[\\/]+)/);
+	const paths = [path];
+	const segments = [parts[parts.length - 1]];
+	let part = parts[parts.length - 1];
+	path = path.slice(0, Math.max(0, path.length - part.length - 1));
+	for (let i = parts.length - 2; i > 2; i -= 2) {
+		paths.push(path);
+		part = parts[i];
+		path = path.slice(0, Math.max(0, path.length - part.length)) || "/";
+		segments.push(part.slice(0, -1));
+	}
+	[, part] = parts;
+	segments.push(part);
+	paths.push(part);
+	return {
+		paths,
+		segments,
+	};
+};
+
+/**
+ * @param {string} path path
+ * @returns {string | null} basename or null
+ */
+module.exports.basename = function basename(path) {
+	const i = path.lastIndexOf("/");
+	const j = path.lastIndexOf("\\");
+	const resolvedPath = i < 0 ? j : j < 0 ? i : i < j ? j : i;
+	if (resolvedPath < 0) return null;
+	const basename = path.slice(resolvedPath + 1);
+	return basename;
+};

package/.next/standalone/node_modules/enhanced-resolve/lib/index.js

@@ -0,0 +1,229 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const memoize = require("./util/memoize");
+
+/** @typedef {import("./CachedInputFileSystem").BaseFileSystem} BaseFileSystem */
+/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").Context} Context */
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").ResolveCallback} ResolveCallback */
+/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
+/** @typedef {import("./ResolverFactory").Plugin} Plugin */
+/** @typedef {import("./ResolverFactory").UserResolveOptions} ResolveOptions */
+
+/**
+ * @typedef {{
+ * (context: Context, path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void,
+ * (context: Context, path: string, request: string, callback: ResolveCallback): void,
+ * (path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void,
+ * (path: string, request: string, callback: ResolveCallback): void
+ * }} ResolveFunctionAsync
+ */
+
+/**
+ * @typedef {{
+ * (context: Context, path: string, request: string): string | false,
+ * (path: string, request: string): string | false
+ * }} ResolveFunction
+ */
+
+const getCachedFileSystem = memoize(() => require("./CachedInputFileSystem"));
+
+const getNodeFileSystem = memoize(() => {
+	const fs = require("graceful-fs");
+
+	const CachedInputFileSystem = getCachedFileSystem();
+
+	return new CachedInputFileSystem(fs, 4000);
+});
+const getNodeContext = memoize(() => ({
+	environments: ["node+es3+es5+process+native"],
+}));
+
+const getResolverFactory = memoize(() => require("./ResolverFactory"));
+
+const getAsyncResolver = memoize(() =>
+	getResolverFactory().createResolver({
+		conditionNames: ["node"],
+		extensions: [".js", ".json", ".node"],
+		fileSystem: getNodeFileSystem(),
+	}),
+);
+
+/**
+ * @type {ResolveFunctionAsync}
+ */
+const resolve =
+	/**
+	 * @param {object | string} context context
+	 * @param {string} path path
+	 * @param {string | ResolveContext | ResolveCallback} request request
+	 * @param {ResolveContext | ResolveCallback=} resolveContext resolve context
+	 * @param {ResolveCallback=} callback callback
+	 */
+	(context, path, request, resolveContext, callback) => {
+		if (typeof context === "string") {
+			callback = /** @type {ResolveCallback} */ (resolveContext);
+			resolveContext = /** @type {ResolveContext} */ (request);
+			request = path;
+			path = context;
+			context = getNodeContext();
+		}
+		if (typeof callback !== "function") {
+			callback = /** @type {ResolveCallback} */ (resolveContext);
+		}
+		getAsyncResolver().resolve(
+			context,
+			path,
+			/** @type {string} */ (request),
+			/** @type {ResolveContext} */ (resolveContext),
+			/** @type {ResolveCallback} */ (callback),
+		);
+	};
+
+const getSyncResolver = memoize(() =>
+	getResolverFactory().createResolver({
+		conditionNames: ["node"],
+		extensions: [".js", ".json", ".node"],
+		useSyncFileSystemCalls: true,
+		fileSystem: getNodeFileSystem(),
+	}),
+);
+
+/**
+ * @type {ResolveFunction}
+ */
+const resolveSync =
+	/**
+	 * @param {object | string} context context
+	 * @param {string} path path
+	 * @param {string=} request request
+	 * @returns {string | false} result
+	 */
+	(context, path, request) => {
+		if (typeof context === "string") {
+			request = path;
+			path = context;
+			context = getNodeContext();
+		}
+		return getSyncResolver().resolveSync(
+			context,
+			path,
+			/** @type {string} */ (request),
+		);
+	};
+
+/** @typedef {Omit<ResolveOptions, "fileSystem"> & Partial<Pick<ResolveOptions, "fileSystem">>} ResolveOptionsOptionalFS */
+
+/**
+ * @param {ResolveOptionsOptionalFS} options Resolver options
+ * @returns {ResolveFunctionAsync} Resolver function
+ */
+function create(options) {
+	const resolver = getResolverFactory().createResolver({
+		fileSystem: getNodeFileSystem(),
+		...options,
+	});
+	/**
+	 * @param {object | string} context Custom context
+	 * @param {string} path Base path
+	 * @param {string | ResolveContext | ResolveCallback} request String to resolve
+	 * @param {ResolveContext | ResolveCallback=} resolveContext Resolve context
+	 * @param {ResolveCallback=} callback Result callback
+	 */
+	return function create(context, path, request, resolveContext, callback) {
+		if (typeof context === "string") {
+			callback = /** @type {ResolveCallback} */ (resolveContext);
+			resolveContext = /** @type {ResolveContext} */ (request);
+			request = path;
+			path = context;
+			context = getNodeContext();
+		}
+		if (typeof callback !== "function") {
+			callback = /** @type {ResolveCallback} */ (resolveContext);
+		}
+		resolver.resolve(
+			context,
+			path,
+			/** @type {string} */ (request),
+			/** @type {ResolveContext} */ (resolveContext),
+			callback,
+		);
+	};
+}
+
+/**
+ * @param {ResolveOptionsOptionalFS} options Resolver options
+ * @returns {ResolveFunction} Resolver function
+ */
+function createSync(options) {
+	const resolver = getResolverFactory().createResolver({
+		useSyncFileSystemCalls: true,
+		fileSystem: getNodeFileSystem(),
+		...options,
+	});
+	/**
+	 * @param {object | string} context custom context
+	 * @param {string} path base path
+	 * @param {string=} request request to resolve
+	 * @returns {string | false} Resolved path or false
+	 */
+	return function createSync(context, path, request) {
+		if (typeof context === "string") {
+			request = path;
+			path = context;
+			context = getNodeContext();
+		}
+		return resolver.resolveSync(context, path, /** @type {string} */ (request));
+	};
+}
+
+/**
+ * @template A
+ * @template B
+ * @param {A} obj input a
+ * @param {B} exports input b
+ * @returns {A & B} merged
+ */
+const mergeExports = (obj, exports) => {
+	const descriptors = Object.getOwnPropertyDescriptors(exports);
+	Object.defineProperties(obj, descriptors);
+	return /** @type {A & B} */ (Object.freeze(obj));
+};
+
+module.exports = mergeExports(resolve, {
+	get sync() {
+		return resolveSync;
+	},
+	create: mergeExports(create, {
+		get sync() {
+			return createSync;
+		},
+	}),
+	get ResolverFactory() {
+		return getResolverFactory();
+	},
+	get CachedInputFileSystem() {
+		return getCachedFileSystem();
+	},
+	get CloneBasenamePlugin() {
+		return require("./CloneBasenamePlugin");
+	},
+	get LogInfoPlugin() {
+		return require("./LogInfoPlugin");
+	},
+	get TsconfigPathsPlugin() {
+		return require("./TsconfigPathsPlugin");
+	},
+	get forEachBail() {
+		return require("./forEachBail");
+	},
+});