FM / dependencies

/var/www/flurhymez/node_modules/webpack/lib/dependencies/

/var/www/flurhymez/node_modules/webpack/lib/dependencies

Name	Size	Mode	Actions
AMDDefineDependency.js	7553	0644	edit dl rm
AMDDefineDependencyParserPlugin.js	10159	0644	edit dl rm
AMDPlugin.js	6306	0644	edit dl rm
AMDRequireArrayDependency.js	2409	0644	edit dl rm
AMDRequireContextDependency.js	1027	0644	edit dl rm
AMDRequireDependenciesBlock.js	533	0644	edit dl rm
AMDRequireDependenciesBlockParserPlugin.js	7777	0644	edit dl rm
AMDRequireDependency.js	5086	0644	edit dl rm
AMDRequireItemDependency.js	764	0644	edit dl rm
AMDRuntimeModules.js	1067	0644	edit dl rm
CachedConstDependency.js	2847	0644	edit dl rm
CommonJsDependencyHelpers.js	1330	0644	edit dl rm
CommonJsExportRequireDependency.js	10482	0644	edit dl rm
CommonJsExportsDependency.js	4006	0644	edit dl rm
CommonJsExportsParserPlugin.js	10479	0644	edit dl rm
CommonJsFullRequireDependency.js	3757	0644	edit dl rm
CommonJsImportsParserPlugin.js	11945	0644	edit dl rm
CommonJsPlugin.js	8338	0644	edit dl rm
CommonJsRequireContextDependency.js	1267	0644	edit dl rm
CommonJsRequireDependency.js	752	0644	edit dl rm
CommonJsSelfReferenceDependency.js	3861	0644	edit dl rm
ConstDependency.js	3220	0644	edit dl rm
ContextDependency.js	3797	0644	edit dl rm
ContextDependencyHelpers.js	6808	0644	edit dl rm
ContextDependencyTemplateAsId.js	1791	0644	edit dl rm
ContextDependencyTemplateAsRequireCall.js	1834	0644	edit dl rm
ContextElementDependency.js	1795	0644	edit dl rm
CreateScriptUrlDependency.js	1568	0644	edit dl rm
CriticalDependencyWarning.js	568	0644	edit dl rm
DelegatedSourceDependency.js	575	0644	edit dl rm
DllEntryDependency.js	819	0644	edit dl rm
DynamicExports.js	1838	0644	edit dl rm
EntryDependency.js	581	0644	edit dl rm
ExportsInfoDependency.js	3743	0644	edit dl rm
getFunctionExpression.js	1377	0644	edit dl rm
HarmonyAcceptDependency.js	3759	0644	edit dl rm
HarmonyAcceptImportDependency.js	961	0644	edit dl rm
HarmonyCompatibilityDependency.js	2663	0644	edit dl rm
HarmonyDetectionParserPlugin.js	2713	0644	edit dl rm
HarmonyExportDependencyParserPlugin.js	5803	0644	edit dl rm
HarmonyExportExpressionDependency.js	5474	0644	edit dl rm
HarmonyExportHeaderDependency.js	1819	0644	edit dl rm
HarmonyExportImportedSpecifierDependency.js	34880	0644	edit dl rm
HarmonyExportInitFragment.js	4431	0644	edit dl rm
HarmonyExports.js	1196	0644	edit dl rm
HarmonyExportSpecifierDependency.js	3021	0644	edit dl rm
HarmonyImportDependency.js	11065	0644	edit dl rm
HarmonyImportDependencyParserPlugin.js	8581	0644	edit dl rm
HarmonyImportSideEffectDependency.js	2821	0644	edit dl rm
HarmonyImportSpecifierDependency.js	9395	0644	edit dl rm
HarmonyModulesPlugin.js	4071	0644	edit dl rm
HarmonyTopLevelThisParserPlugin.js	715	0644	edit dl rm
ImportContextDependency.js	1112	0644	edit dl rm
ImportDependency.js	2989	0644	edit dl rm
ImportEagerDependency.js	2020	0644	edit dl rm
ImportMetaHotAcceptDependency.js	805	0644	edit dl rm
ImportMetaHotDeclineDependency.js	812	0644	edit dl rm
ImportMetaPlugin.js	5750	0644	edit dl rm
ImportParserPlugin.js	7850	0644	edit dl rm
ImportPlugin.js	2172	0644	edit dl rm
ImportWeakDependency.js	2004	0644	edit dl rm
JsonExportsDependency.js	2338	0644	edit dl rm
LoaderDependency.js	437	0644	edit dl rm
LoaderImportDependency.js	482	0644	edit dl rm
LoaderPlugin.js	7877	0644	edit dl rm
LocalModule.js	743	0644	edit dl rm
LocalModuleDependency.js	1856	0644	edit dl rm
LocalModulesHelpers.js	1093	0644	edit dl rm
ModuleDecoratorDependency.js	3861	0644	edit dl rm
ModuleDependency.js	2037	0644	edit dl rm
ModuleDependencyTemplateAsId.js	1171	0644	edit dl rm
ModuleDependencyTemplateAsRequireId.js	1243	0644	edit dl rm
ModuleHotAcceptDependency.js	778	0644	edit dl rm
ModuleHotDeclineDependency.js	785	0644	edit dl rm
NullDependency.js	1282	0644	edit dl rm
PrefetchDependency.js	387	0644	edit dl rm
processExportInfo.js	1777	0644	edit dl rm
ProvidedDependency.js	3205	0644	edit dl rm
PureExpressionDependency.js	3664	0644	edit dl rm
RequireContextDependency.js	950	0644	edit dl rm
RequireContextDependencyParserPlugin.js	1564	0644	edit dl rm
RequireContextPlugin.js	4177	0644	edit dl rm
RequireEnsureDependenciesBlock.js	549	0644	edit dl rm
RequireEnsureDependenciesBlockParserPlugin.js	3708	0644	edit dl rm
RequireEnsureDependency.js	2734	0644	edit dl rm
RequireEnsureItemDependency.js	708	0644	edit dl rm
RequireEnsurePlugin.js	1807	0644	edit dl rm
RequireHeaderDependency.js	1721	0644	edit dl rm
RequireIncludeDependency.js	2237	0644	edit dl rm
RequireIncludeDependencyParserPlugin.js	2046	0644	edit dl rm
RequireIncludePlugin.js	1191	0644	edit dl rm
RequireResolveContextDependency.js	1069	0644	edit dl rm
RequireResolveDependency.js	1369	0644	edit dl rm
RequireResolveHeaderDependency.js	1792	0644	edit dl rm
RuntimeRequirementsDependency.js	2311	0644	edit dl rm
StaticExportsDependency.js	1620	0644	edit dl rm
SystemPlugin.js	3821	0644	edit dl rm
SystemRuntimeModule.js	698	0644	edit dl rm
UnsupportedDependency.js	1642	0644	edit dl rm
URLDependency.js	4640	0644	edit dl rm
URLPlugin.js	3188	0644	edit dl rm
WebAssemblyExportImportedDependency.js	2073	0644	edit dl rm
WebAssemblyImportDependency.js	2676	0644	edit dl rm
WebpackIsIncludedDependency.js	2520	0644	edit dl rm
WorkerDependency.js	2994	0644	edit dl rm
WorkerPlugin.js	13501	0644	edit dl rm

Edit: /var/www/flurhymez/node_modules/webpack/lib/dependencies/WorkerPlugin.js (13501B)

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

"use strict";

const { pathToFileURL } = require("url");
const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
const CommentCompilationWarning = require("../CommentCompilationWarning");
const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
const { equals } = require("../util/ArrayHelpers");
const createHash = require("../util/createHash");
const { contextify } = require("../util/identifier");
const EnableWasmLoadingPlugin = require("../wasm/EnableWasmLoadingPlugin");
const ConstDependency = require("./ConstDependency");
const CreateScriptUrlDependency = require("./CreateScriptUrlDependency");
const {
	harmonySpecifierTag
} = require("./HarmonyImportDependencyParserPlugin");
const WorkerDependency = require("./WorkerDependency");

/** @typedef {import("estree").Expression} Expression */
/** @typedef {import("estree").ObjectExpression} ObjectExpression */
/** @typedef {import("estree").Pattern} Pattern */
/** @typedef {import("estree").Property} Property */
/** @typedef {import("estree").SpreadElement} SpreadElement */
/** @typedef {import("../Compiler")} Compiler */
/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
/** @typedef {import("../Parser").ParserState} ParserState */
/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
/** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */

const getUrl = module => {
	return pathToFileURL(module.resource).toString();
};

const DEFAULT_SYNTAX = [
	"Worker",
	"SharedWorker",
	"navigator.serviceWorker.register()",
	"Worker from worker_threads"
];

/** @type {WeakMap<ParserState, number>} */
const workerIndexMap = new WeakMap();

class WorkerPlugin {
	constructor(chunkLoading, wasmLoading, module) {
		this._chunkLoading = chunkLoading;
		this._wasmLoading = wasmLoading;
		this._module = module;
	}
	/**
	 * Apply the plugin
	 * @param {Compiler} compiler the compiler instance
	 * @returns {void}
	 */
	apply(compiler) {
		if (this._chunkLoading) {
			new EnableChunkLoadingPlugin(this._chunkLoading).apply(compiler);
		}
		if (this._wasmLoading) {
			new EnableWasmLoadingPlugin(this._wasmLoading).apply(compiler);
		}
		const cachedContextify = contextify.bindContextCache(
			compiler.context,
			compiler.root
		);
		compiler.hooks.thisCompilation.tap(
			"WorkerPlugin",
			(compilation, { normalModuleFactory }) => {
				compilation.dependencyFactories.set(
					WorkerDependency,
					normalModuleFactory
				);
				compilation.dependencyTemplates.set(
					WorkerDependency,
					new WorkerDependency.Template()
				);
				compilation.dependencyTemplates.set(
					CreateScriptUrlDependency,
					new CreateScriptUrlDependency.Template()
				);

/**
				 * @param {JavascriptParser} parser the parser
				 * @param {Expression} expr expression
				 * @returns {[BasicEvaluatedExpression, [number, number]]} parsed
				 */
				const parseModuleUrl = (parser, expr) => {
					if (
						expr.type !== "NewExpression" ||
						expr.callee.type === "Super" ||
						expr.arguments.length !== 2
					)
						return;
					const [arg1, arg2] = expr.arguments;
					if (arg1.type === "SpreadElement") return;
					if (arg2.type === "SpreadElement") return;
					const callee = parser.evaluateExpression(expr.callee);
					if (!callee.isIdentifier() || callee.identifier !== "URL") return;
					const arg2Value = parser.evaluateExpression(arg2);
					if (
						!arg2Value.isString() ||
						!arg2Value.string.startsWith("file://") ||
						arg2Value.string !== getUrl(parser.state.module)
					) {
						return;
					}
					const arg1Value = parser.evaluateExpression(arg1);
					return [arg1Value, [arg1.range[0], arg2.range[1]]];
				};

/**
				 * @param {JavascriptParser} parser the parser
				 * @param {ObjectExpression} expr expression
				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Record<string, any>, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
				 */
				const parseObjectExpression = (parser, expr) => {
					/** @type {Record<string, any>} */
					const values = {};
					/** @type {Record<string, Expression | Pattern>} */
					const expressions = {};
					/** @type {(Property | SpreadElement)[]} */
					const otherElements = [];
					let spread = false;
					for (const prop of expr.properties) {
						if (prop.type === "SpreadElement") {
							spread = true;
						} else if (
							prop.type === "Property" &&
							!prop.method &&
							!prop.computed &&
							prop.key.type === "Identifier"
						) {
							expressions[prop.key.name] = prop.value;
							if (!prop.shorthand && !prop.value.type.endsWith("Pattern")) {
								const value = parser.evaluateExpression(
									/** @type {Expression} */ (prop.value)
								);
								if (value.isCompileTimeValue())
									values[prop.key.name] = value.asCompileTimeValue();
							}
						} else {
							otherElements.push(prop);
						}
					}
					const insertType = expr.properties.length > 0 ? "comma" : "single";
					const insertLocation =
						expr.properties[expr.properties.length - 1].range[1];
					return {
						expressions,
						otherElements,
						values,
						spread,
						insertType,
						insertLocation
					};
				};

/**
				 * @param {JavascriptParser} parser the parser
				 * @param {object} parserOptions options
				 */
				const parserPlugin = (parser, parserOptions) => {
					if (parserOptions.worker === false) return;
					const options = !Array.isArray(parserOptions.worker)
						? ["..."]
						: parserOptions.worker;
					const handleNewWorker = expr => {
						if (expr.arguments.length === 0 || expr.arguments.length > 2)
							return;
						const [arg1, arg2] = expr.arguments;
						if (arg1.type === "SpreadElement") return;
						if (arg2 && arg2.type === "SpreadElement") return;
						const parsedUrl = parseModuleUrl(parser, arg1);
						if (!parsedUrl) return;
						const [url, range] = parsedUrl;
						if (!url.isString()) return;
						const {
							expressions,
							otherElements,
							values: options,
							spread: hasSpreadInOptions,
							insertType,
							insertLocation
						} = arg2 && arg2.type === "ObjectExpression"
							? parseObjectExpression(parser, arg2)
							: {
									expressions: {},
									otherElements: [],
									values: {},
									spread: false,
									insertType: arg2 ? "spread" : "argument",
									insertLocation: arg2 ? arg2.range : arg1.range[1]
							  };
						const { options: importOptions, errors: commentErrors } =
							parser.parseCommentOptions(expr.range);

if (commentErrors) {
							for (const e of commentErrors) {
								const { comment } = e;
								parser.state.module.addWarning(
									new CommentCompilationWarning(
										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
										comment.loc
									)
								);
							}
						}

/** @type {EntryOptions} */
						let entryOptions = {};

if (importOptions) {
							if (importOptions.webpackIgnore !== undefined) {
								if (typeof importOptions.webpackIgnore !== "boolean") {
									parser.state.module.addWarning(
										new UnsupportedFeatureWarning(
											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
											expr.loc
										)
									);
								} else {
									if (importOptions.webpackIgnore) {
										return false;
									}
								}
							}
							if (importOptions.webpackEntryOptions !== undefined) {
								if (
									typeof importOptions.webpackEntryOptions !== "object" ||
									importOptions.webpackEntryOptions === null
								) {
									parser.state.module.addWarning(
										new UnsupportedFeatureWarning(
											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
											expr.loc
										)
									);
								} else {
									Object.assign(
										entryOptions,
										importOptions.webpackEntryOptions
									);
								}
							}
							if (importOptions.webpackChunkName !== undefined) {
								if (typeof importOptions.webpackChunkName !== "string") {
									parser.state.module.addWarning(
										new UnsupportedFeatureWarning(
											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
											expr.loc
										)
									);
								} else {
									entryOptions.name = importOptions.webpackChunkName;
								}
							}
						}

if (
							!Object.prototype.hasOwnProperty.call(entryOptions, "name") &&
							options &&
							typeof options.name === "string"
						) {
							entryOptions.name = options.name;
						}

if (entryOptions.runtime === undefined) {
							let i = workerIndexMap.get(parser.state) || 0;
							workerIndexMap.set(parser.state, i + 1);
							let name = `${cachedContextify(
								parser.state.module.identifier()
							)}|${i}`;
							const hash = createHash(compilation.outputOptions.hashFunction);
							hash.update(name);
							const digest = /** @type {string} */ (
								hash.digest(compilation.outputOptions.hashDigest)
							);
							entryOptions.runtime = digest.slice(
								0,
								compilation.outputOptions.hashDigestLength
							);
						}

const block = new AsyncDependenciesBlock({
							name: entryOptions.name,
							entryOptions: {
								chunkLoading: this._chunkLoading,
								wasmLoading: this._wasmLoading,
								...entryOptions
							}
						});
						block.loc = expr.loc;
						const dep = new WorkerDependency(url.string, range);
						dep.loc = expr.loc;
						block.addDependency(dep);
						parser.state.module.addBlock(block);

if (compilation.outputOptions.trustedTypes) {
							const dep = new CreateScriptUrlDependency(
								expr.arguments[0].range
							);
							dep.loc = expr.loc;
							parser.state.module.addDependency(dep);
						}

if (expressions.type) {
							const expr = expressions.type;
							if (options.type !== false) {
								const dep = new ConstDependency(
									this._module ? '"module"' : "undefined",
									expr.range
								);
								dep.loc = expr.loc;
								parser.state.module.addPresentationalDependency(dep);
								expressions.type = undefined;
							}
						} else if (insertType === "comma") {
							if (this._module || hasSpreadInOptions) {
								const dep = new ConstDependency(
									`, type: ${this._module ? '"module"' : "undefined"}`,
									insertLocation
								);
								dep.loc = expr.loc;
								parser.state.module.addPresentationalDependency(dep);
							}
						} else if (insertType === "spread") {
							const dep1 = new ConstDependency(
								"Object.assign({}, ",
								insertLocation[0]
							);
							const dep2 = new ConstDependency(
								`, { type: ${this._module ? '"module"' : "undefined"} })`,
								insertLocation[1]
							);
							dep1.loc = expr.loc;
							dep2.loc = expr.loc;
							parser.state.module.addPresentationalDependency(dep1);
							parser.state.module.addPresentationalDependency(dep2);
						} else if (insertType === "argument") {
							if (this._module) {
								const dep = new ConstDependency(
									', { type: "module" }',
									insertLocation
								);
								dep.loc = expr.loc;
								parser.state.module.addPresentationalDependency(dep);
							}
						}

parser.walkExpression(expr.callee);
						for (const key of Object.keys(expressions)) {
							if (expressions[key]) parser.walkExpression(expressions[key]);
						}
						for (const prop of otherElements) {
							parser.walkProperty(prop);
						}
						if (insertType === "spread") {
							parser.walkExpression(arg2);
						}

return true;
					};
					const processItem = item => {
						if (item.endsWith("()")) {
							parser.hooks.call
								.for(item.slice(0, -2))
								.tap("WorkerPlugin", handleNewWorker);
						} else {
							const match = /^(.+?)()?\s+from\s+(.+)$/.exec(item);
							if (match) {
								const ids = match[1].split(".");
								const call = match[2];
								const source = match[3];
								(call ? parser.hooks.call : parser.hooks.new)
									.for(harmonySpecifierTag)
									.tap("WorkerPlugin", expr => {
										const settings = /** @type {HarmonySettings} */ (
											parser.currentTagData
										);
										if (
											!settings ||
											settings.source !== source ||
											!equals(settings.ids, ids)
										) {
											return;
										}
										return handleNewWorker(expr);
									});
							} else {
								parser.hooks.new.for(item).tap("WorkerPlugin", handleNewWorker);
							}
						}
					};
					for (const item of options) {
						if (item === "...") {
							DEFAULT_SYNTAX.forEach(processItem);
						} else processItem(item);
					}
				};
				normalModuleFactory.hooks.parser
					.for("javascript/auto")
					.tap("WorkerPlugin", parserPlugin);
				normalModuleFactory.hooks.parser
					.for("javascript/esm")
					.tap("WorkerPlugin", parserPlugin);
			}
		);
	}
}
module.exports = WorkerPlugin;

cmd: