@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/config/defineConfig.js

@@ -0,0 +1,31 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} Configuration */
+/** @typedef {import("../MultiCompiler").MultiWebpackOptions} MultiConfiguration */
+
+/**
+ * @template T
+ * @typedef {T | Promise<T>} MaybePromise
+ */
+
+/**
+ * Function style configuration, called with the `--env` values and CLI arguments.
+ * @typedef {(env: Record<string, EXPECTED_ANY>, argv: Record<string, EXPECTED_ANY>) => MaybePromise<Configuration | MultiConfiguration>} ConfigurationFactory
+ */
+
+/** @typedef {MaybePromise<Configuration | MultiConfiguration | ConfigurationFactory | ConfigurationFactory[]>} DefineConfigInput */
+
+/**
+ * A type helper for authoring configuration files, no-op at runtime.
+ * @template {DefineConfigInput} T
+ * @param {T} config webpack configuration
+ * @returns {T} the same configuration
+ */
+const defineConfig = (config) => config;
+
+module.exports = defineConfig;

package/lib/config/normalization.js

@@ -22,15 +22,17 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").PluginsNormalized} PluginsNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 
 /**
+ * Defines the webpack options interception type used by this module.
  * @typedef {object} WebpackOptionsInterception
  * @property {WebpackOptionsNormalized["devtool"]=} devtool
  */
 
 const handledDeprecatedNoEmitOnErrors = util.deprecate(
 	/**
+	 * Handles the callback logic for this hook.
 	 * @param {boolean} noEmitOnErrors no emit on errors
 	 * @param {boolean | undefined} emitOnErrors emit on errors
 	 * @returns {boolean} emit on errors
@@ -48,6 +50,7 @@ const handledDeprecatedNoEmitOnErrors = util.deprecate(
 );
 
 /**
+ * Returns result value.
  * @template T
  * @template R
  * @param {T | undefined} value value or not
@@ -58,12 +61,14 @@ const nestedConfig = (value, fn) =>
 	value === undefined ? fn(/** @type {T} */ ({})) : fn(value);
 
 /**
+ * Returns result value.
  * @template T
  * @param {T | undefined} value value or not
  * @returns {T} result value
  */
 const cloneObject = (value) => /** @type {T} */ ({ ...value });
 /**
+ * Optional nested config.
  * @template T
  * @template R
  * @param {T | undefined} value value or not
@@ -74,6 +79,7 @@ const optionalNestedConfig = (value, fn) =>
 	value === undefined ? undefined : fn(value);
 
 /**
+ * Returns cloned value.
  * @template T
  * @template R
  * @param {T[] | undefined} value array or not
@@ -83,6 +89,7 @@ const optionalNestedConfig = (value, fn) =>
 const nestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : fn([]));
 
 /**
+ * Optional nested array.
  * @template T
  * @template R
  * @param {T[] | undefined} value array or not
@@ -93,6 +100,7 @@ const optionalNestedArray = (value, fn) =>
 	Array.isArray(value) ? fn(value) : undefined;
 
 /**
+ * Keyed nested config.
  * @template T
  * @template R
  * @param {Record<string, T> | undefined} value value or not
@@ -126,6 +134,31 @@ const keyedNestedConfig = (value, fn, customKeys) => {
 };
 
 /**
+ * Normalize `output.resourceHints` into its object form: the scalar / array /
+ * function shorthand becomes `{ initial: <value> }` (with `"preload"` aliased to
+ * `true`); an object is passed through, its `initial` getting the same alias.
+ * @param {import("../../declarations/WebpackOptions").ResourceHints=} resourceHints raw value
+ * @returns {import("../../declarations/WebpackOptions").ResourceHintsOptions | undefined} normalized object form
+ */
+const normalizeResourceHints = (resourceHints) => {
+	if (resourceHints === undefined) return undefined;
+	/**
+	 * @param {import("../../declarations/WebpackOptions").ResourceHintsInitial=} value initial value
+	 * @returns {import("../../declarations/WebpackOptions").ResourceHintsInitial | undefined} `"preload"` aliased to `true`
+	 */
+	const alias = (value) => (value === "preload" ? true : value);
+	if (
+		typeof resourceHints === "object" &&
+		!Array.isArray(resourceHints) &&
+		typeof resourceHints !== "function"
+	) {
+		return { ...resourceHints, initial: alias(resourceHints.initial) };
+	}
+	return { initial: alias(resourceHints) };
+};
+
+/**
+ * Gets normalized webpack options.
  * @param {WebpackOptions} config input config
  * @returns {WebpackOptionsNormalized} normalized options
  */
@@ -359,6 +392,9 @@ const getNormalizedWebpackOptions = (config) => ({
 			hotUpdateChunkFilename: output.hotUpdateChunkFilename,
 			hotUpdateGlobal: output.hotUpdateGlobal,
 			hotUpdateMainFilename: output.hotUpdateMainFilename,
+			html: output.html,
+			htmlChunkFilename: output.htmlChunkFilename,
+			htmlFilename: output.htmlFilename,
 			ignoreBrowserWarnings: output.ignoreBrowserWarnings,
 			iife: output.iife,
 			importFunctionName: output.importFunctionName,
@@ -392,10 +428,12 @@ const getNormalizedWebpackOptions = (config) => ({
 			path: output.path,
 			pathinfo: output.pathinfo,
 			publicPath: output.publicPath,
+			resourceHints: normalizeResourceHints(output.resourceHints),
 			sourceMapFilename: output.sourceMapFilename,
 			sourcePrefix: output.sourcePrefix,
 			strictModuleErrorHandling: output.strictModuleErrorHandling,
 			strictModuleExceptionHandling: output.strictModuleExceptionHandling,
+			strictModuleResolution: output.strictModuleResolution,
 			trustedTypes: optionalNestedConfig(
 				output.trustedTypes,
 				(trustedTypes) => {
@@ -408,8 +446,10 @@ const getNormalizedWebpackOptions = (config) => ({
 			),
 			uniqueName: output.uniqueName,
 			wasmLoading: output.wasmLoading,
+			wasmStreamingFallback: output.wasmStreamingFallback,
 			webassemblyModuleFilename: output.webassemblyModuleFilename,
 			workerPublicPath: output.workerPublicPath,
+			workerChunkFilename: output.workerChunkFilename,
 			workerChunkLoading: output.workerChunkLoading,
 			workerWasmLoading: output.workerWasmLoading
 		};
@@ -500,6 +540,7 @@ const getNormalizedWebpackOptions = (config) => ({
 });
 
 /**
+ * Gets normalized entry static.
  * @param {EntryStatic} entry static entry options
  * @returns {EntryStaticNormalized} normalized static entry options
  */
@@ -539,6 +580,7 @@ const getNormalizedEntryStatic = (entry) => {
 							(Array.isArray(value.import) ? value.import : [value.import])
 					),
 				filename: value.filename,
+				html: value.html,
 				layer: value.layer,
 				runtime: value.runtime,
 				baseUri: value.baseUri,
@@ -546,6 +588,7 @@ const getNormalizedEntryStatic = (entry) => {
 				chunkLoading: value.chunkLoading,
 				asyncChunks: value.asyncChunks,
 				wasmLoading: value.wasmLoading,
+				worker: value.worker,
 				dependOn:
 					/** @type {EntryDescriptionNormalized["dependOn"]} */
 					(
@@ -562,6 +605,7 @@ const getNormalizedEntryStatic = (entry) => {
 };
 
 /**
+ * Gets normalized optimization runtime chunk.
  * @param {OptimizationRuntimeChunk=} runtimeChunk runtimeChunk option
  * @returns {OptimizationRuntimeChunkNormalized=} normalized runtimeChunk option
  */
@@ -589,6 +633,7 @@ const getNormalizedOptimizationRuntimeChunk = (runtimeChunk) => {
 };
 
 /**
+ * Apply webpack options interception.
  * @param {WebpackOptionsNormalized} options options to be intercepted
  * @returns {{ options: WebpackOptionsNormalized, interception?: WebpackOptionsInterception }} options and interception
  */

package/lib/config/target.js

@@ -12,6 +12,7 @@ const getBrowserslistTargetHandler = memoize(() =>
 );
 
 /**
+ * Gets default target.
  * @param {string} context the context directory
  * @returns {string} default target
  */
@@ -21,16 +22,21 @@ const getDefaultTarget = (context) => {
 };
 
 /**
+ * Defines the platform target properties type used by this module.
  * @typedef {object} PlatformTargetProperties
  * @property {boolean | null=} web web platform, importing of http(s) and std: is available
  * @property {boolean | null=} browser browser platform, running in a normal web browser
  * @property {boolean | null=} webworker (Web)Worker platform, running in a web/shared/service worker
  * @property {boolean | null=} node node platform, require of node built-in modules is available
+ * @property {boolean | null=} deno deno platform, node built-in modules (via the `node:` specifier) and web APIs are available
+ * @property {boolean | null=} bun bun platform, bun and node built-in modules are available
  * @property {boolean | null=} nwjs nwjs platform, require of legacy nw.gui is available
  * @property {boolean | null=} electron electron platform, require of some electron built-in modules is available
+ * @property {boolean | null=} universal universal ESM target spanning both web and node (target `"universal"` or `["web", "node"]`)
  */
 
 /**
+ * Defines the electron context target properties type used by this module.
  * @typedef {object} ElectronContextTargetProperties
  * @property {boolean | null} electronMain in main context
  * @property {boolean | null} electronPreload in preload context
@@ -38,12 +44,15 @@ const getDefaultTarget = (context) => {
  */
 
 /**
+ * Defines the api target properties type used by this module.
  * @typedef {object} ApiTargetProperties
  * @property {boolean | null} require has require function available
  * @property {boolean | null} nodeBuiltins has node.js built-in modules available
  * @property {boolean | null} nodePrefixForCoreModules node.js allows to use `node:` prefix for core modules
+ * @property {boolean | null} nodeBuiltinModuleGetter node.js exposes `process.getBuiltinModule()` to synchronously load core modules
  * @property {boolean | null} importMetaDirnameAndFilename node.js allows to use `import.meta.dirname` and `import.meta.filename`
  * @property {boolean | null} document has document available (allows script tags)
+ * @property {(boolean | null)=} modulePreload supports `<link rel="modulepreload">` (optional; absent means "assume supported")
  * @property {boolean | null} importScripts has importScripts available
  * @property {boolean | null} importScriptsInWorker has importScripts available when creating a worker
  * @property {boolean | null} fetchWasm has fetch function available for WebAssembly
@@ -51,10 +60,15 @@ const getDefaultTarget = (context) => {
  */
 
 /**
+ * Defines the ecma target properties type used by this module.
  * @typedef {object} EcmaTargetProperties
  * @property {boolean | null} globalThis has globalThis variable available
+ * @property {boolean | null} symbol `Symbol` is available
+ * @property {boolean | null} hasOwn `Object.hasOwn` is available
  * @property {boolean | null} bigIntLiteral big int literal syntax is available
- * @property {boolean | null} const const and let variable declarations are available
+ * @property {boolean | null} const const variable declarations are available
+ * @property {boolean | null} let let variable declarations are available
+ * @property {boolean | null} logicalAssignment logical assignment operators (`||=`, `&&=`, `??=`) are available
  * @property {boolean | null} methodShorthand object method shorthand is available
  * @property {boolean | null} arrowFunction arrow functions are available
  * @property {boolean | null} forOf for of iteration is available
@@ -63,16 +77,20 @@ const getDefaultTarget = (context) => {
  * @property {boolean | null} dynamicImportInWorker async import() is available when creating a worker
  * @property {boolean | null} module ESM syntax is available (when in module)
  * @property {boolean | null} optionalChaining optional chaining is available
+ * @property {boolean | null} spread spread and rest in array/object literals and calls is available
  * @property {boolean | null} templateLiteral template literal is available
  * @property {boolean | null} asyncFunction async functions and await are available
+ * @property {boolean | null} generator generator functions and yield are available
  */
 
 /**
+ * Defines the shared type used by this module.
  * @template T
  * @typedef {{ [P in keyof T]?: never }} Never<T>
  */
 
 /**
+ * Defines the shared type used by this module.
  * @template A
  * @template B
  * @typedef {(A & Never<B>) | (Never<A> & B) | (A & B)} Mix<A, B>
@@ -81,6 +99,7 @@ const getDefaultTarget = (context) => {
 /** @typedef {Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>} TargetProperties */
 
 /**
+ * Returns check if version is greater or equal.
  * @param {string} major major version
  * @param {string | undefined} minor minor version
  * @returns {(vMajor: number, vMinor?: number) => boolean | undefined} check if version is greater or equal
@@ -125,6 +144,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 		/^web$/,
 		() => ({
 			node: false,
+			deno: false,
+			bun: false,
 			web: true,
 			webworker: null,
 			browser: true,
@@ -146,6 +167,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 		/^webworker$/,
 		() => ({
 			node: false,
+			deno: false,
+			bun: false,
 			web: true,
 			webworker: true,
 			browser: true,
@@ -161,6 +184,39 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 			global: false
 		})
 	],
+	[
+		"universal",
+		"Universal target running in browser, web worker, Node.js, Electron and NW.js. Output is always ECMAScript modules.",
+		/^universal$/,
+		// merged web + webworker + node + electron + nwjs properties; output is
+		// always ESM, so `require` (sync CommonJS) is never available
+		() => ({
+			node: null,
+			deno: null,
+			bun: null,
+			web: null,
+			webworker: null,
+			browser: null,
+			electron: null,
+			nwjs: null,
+
+			electronMain: null,
+			electronPreload: null,
+			electronRenderer: null,
+
+			document: null,
+			importScriptsInWorker: null,
+			fetchWasm: null,
+			nodeBuiltins: null,
+			importScripts: null,
+			require: false,
+			global: null,
+
+			module: true,
+			dynamicImport: true,
+			dynamicImportInWorker: true
+		})
+	],
 	[
 		"[async-]node[X[.Y]]",
 		"Node.js in version X.Y. The 'async-' prefix will load chunks asynchronously via 'fs' and 'vm' instead of 'require()'. Examples: node14.5, async-node10.",
@@ -170,6 +226,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 			// see https://node.green/
 			return {
 				node: true,
+				deno: false,
+				bun: false,
 				web: false,
 				webworker: false,
 				browser: false,
@@ -180,6 +238,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				nodeBuiltins: true,
 				// v16.0.0, v14.18.0
 				nodePrefixForCoreModules: Number(major) < 15 ? v(14, 18) : v(16),
+				// v22.3.0, backported to v20.16.0; use the conservative single threshold
+				nodeBuiltinModuleGetter: v(22, 3),
 				// Added in: v21.2.0, v20.11.0, but Node.js will output experimental warning, we don't want it
 				// v24.0.0, v22.16.0 - This property is no longer experimental.
 				importMetaDirnameAndFilename: v(22, 16),
@@ -190,12 +250,18 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				importScriptsInWorker: false,
 
 				globalThis: v(12),
+				symbol: v(0, 12),
+				hasOwn: v(16, 9),
 				const: v(6),
+				let: v(6),
+				logicalAssignment: v(15),
 				templateLiteral: v(4),
 				optionalChaining: v(14),
+				spread: v(8, 3),
 				methodShorthand: v(4),
 				arrowFunction: v(6),
 				asyncFunction: v(7, 6),
+				generator: v(4),
 				forOf: v(5),
 				destructuring: v(6),
 				bigIntLiteral: v(10, 4),
@@ -205,6 +271,110 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 			};
 		}
 	],
+	[
+		"deno[X[.Y]]",
+		"Deno in version X.Y. Emits ESM output; node.js built-ins are available via the required 'node:' specifier and web APIs (fetch, WebAssembly, ...) are available too. Examples: deno2, deno1.40.",
+		/^deno((\d+)(?:\.(\d+))?)?$/,
+		(_, major, minor) => {
+			const v = versionDependent(major, minor);
+			// Deno ships a modern V8, so syntax features are available since 1.0.
+			return {
+				node: true,
+				deno: true,
+				web: true,
+				webworker: false,
+				browser: false,
+				electron: false,
+				nwjs: false,
+
+				require: false,
+				nodeBuiltins: true,
+				// Deno only resolves node.js core modules through the `node:` specifier
+				nodePrefixForCoreModules: true,
+				// process.getBuiltinModule() - v2.1.0
+				nodeBuiltinModuleGetter: v(2, 1),
+				// import.meta.dirname / import.meta.filename - v1.40.0
+				importMetaDirnameAndFilename: v(1, 40),
+				global: false,
+				document: false,
+				fetchWasm: true,
+				importScripts: false,
+				importScriptsInWorker: false,
+
+				globalThis: true,
+				symbol: true,
+				hasOwn: true,
+				bigIntLiteral: true,
+				const: true,
+				let: true,
+				logicalAssignment: true,
+				methodShorthand: true,
+				arrowFunction: true,
+				forOf: true,
+				destructuring: true,
+				dynamicImport: true,
+				dynamicImportInWorker: true,
+				module: true,
+				optionalChaining: true,
+				spread: true,
+				templateLiteral: true,
+				asyncFunction: true,
+				generator: true
+			};
+		}
+	],
+	[
+		"bun[X[.Y]]",
+		"Bun in version X.Y. Output is always ECMAScript modules. Examples: bun, bun1.1.",
+		/^bun((\d+)(?:\.(\d+))?)?$/,
+		() => ({
+			// Bun is a modern, Node.js-compatible runtime; every released version
+			// supports the full modern ECMAScript feature set, so the version is
+			// accepted but does not gate any feature. Output is always ESM, so sync
+			// CommonJS `require` is never available.
+			node: true,
+			bun: true,
+			web: false,
+			webworker: false,
+			browser: false,
+			electron: false,
+			nwjs: false,
+
+			require: false,
+			nodeBuiltins: true,
+			nodePrefixForCoreModules: true,
+			nodeBuiltinModuleGetter: true,
+			importMetaDirnameAndFilename: true,
+			// Bun implements web-standard globals; use `globalThis` and load wasm
+			// via `fetch()` (Bun's fetch resolves `file:` URLs) like the deno target,
+			// instead of proprietary `Bun.*` runtime APIs.
+			global: false,
+			document: false,
+			fetchWasm: true,
+			importScripts: false,
+			importScriptsInWorker: false,
+
+			globalThis: true,
+			symbol: true,
+			hasOwn: true,
+			const: true,
+			let: true,
+			logicalAssignment: true,
+			templateLiteral: true,
+			optionalChaining: true,
+			spread: true,
+			methodShorthand: true,
+			arrowFunction: true,
+			asyncFunction: true,
+			generator: true,
+			forOf: true,
+			destructuring: true,
+			bigIntLiteral: true,
+			dynamicImport: true,
+			dynamicImportInWorker: true,
+			module: true
+		})
+	],
 	[
 		"electron[X[.Y]]-main/preload/renderer",
 		"Electron in version X.Y. Script is running in main, preload resp. renderer context.",
@@ -214,6 +384,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 			// see https://node.green/ + https://github.com/electron/releases
 			return {
 				node: true,
+				deno: false,
+				bun: false,
 				web: context !== "main",
 				webworker: false,
 				browser: false,
@@ -239,18 +411,26 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				importScriptsInWorker: true,
 
 				globalThis: v(5),
+				symbol: v(0, 24),
+				hasOwn: v(16),
 				const: v(1, 1),
+				let: v(1, 1),
+				// 10.0.0 - Chromium 85
+				logicalAssignment: v(10),
 				templateLiteral: v(1, 1),
 				optionalChaining: v(8),
+				spread: v(2),
 				methodShorthand: v(1, 1),
 				arrowFunction: v(1, 1),
 				asyncFunction: v(1, 7),
+				generator: v(1, 1),
 				forOf: v(0, 36),
 				destructuring: v(1, 1),
 				bigIntLiteral: v(4),
 				dynamicImport: v(11),
 				dynamicImportInWorker: v(11),
-				module: v(11)
+				// 28.0.0 - ESM support was added
+				module: v(28)
 			};
 		}
 	],
@@ -263,6 +443,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 			// see https://node.green/ + https://github.com/nwjs/nw.js/blob/nw48/CHANGELOG.md
 			return {
 				node: true,
+				deno: false,
+				bun: false,
 				web: true,
 				webworker: null,
 				browser: false,
@@ -278,12 +460,19 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 				require: false,
 
 				globalThis: v(0, 43),
+				symbol: v(0, 12),
+				hasOwn: v(0, 58),
 				const: v(0, 15),
+				let: v(0, 15),
+				// 0.48.0 - Chromium 85
+				logicalAssignment: v(0, 48),
 				templateLiteral: v(0, 13),
 				optionalChaining: v(0, 44),
+				spread: v(0, 23),
 				methodShorthand: v(0, 15),
 				arrowFunction: v(0, 15),
 				asyncFunction: v(0, 21),
+				generator: v(0, 15),
 				forOf: v(0, 13),
 				destructuring: v(0, 15),
 				bigIntLiteral: v(0, 32),
@@ -302,15 +491,21 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 			if (v < 1000) v += 2009;
 			return {
 				const: v >= 2015,
+				let: v >= 2015,
+				logicalAssignment: v >= 2021,
 				templateLiteral: v >= 2015,
 				optionalChaining: v >= 2020,
+				spread: v >= 2018,
 				methodShorthand: v >= 2015,
 				arrowFunction: v >= 2015,
 				forOf: v >= 2015,
 				destructuring: v >= 2015,
 				module: v >= 2015,
 				asyncFunction: v >= 2017,
+				generator: v >= 2015,
 				globalThis: v >= 2020,
+				symbol: v >= 2015,
+				hasOwn: v >= 2022,
 				bigIntLiteral: v >= 2020,
 				dynamicImport: v >= 2020,
 				dynamicImportInWorker: v >= 2020
@@ -320,6 +515,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 ];
 
 /**
+ * Gets target properties.
  * @param {string} target the target
  * @param {string} context the context directory
  * @returns {TargetProperties} target properties
@@ -341,6 +537,7 @@ const getTargetProperties = (target, context) => {
 };
 
 /**
+ * Merges target properties.
  * @param {TargetProperties[]} targetProperties array of target properties
  * @returns {TargetProperties} merged target properties
  */
@@ -377,6 +574,7 @@ const mergeTargetProperties = (targetProperties) => {
 };
 
 /**
+ * Gets targets properties.
  * @param {string[]} targets the targets
  * @param {string} context the context directory
  * @returns {TargetProperties} target properties

package/lib/container/ContainerEntryDependency.js

@@ -12,6 +12,7 @@ const makeSerializable = require("../util/makeSerializable");
 
 class ContainerEntryDependency extends Dependency {
 	/**
+	 * Creates an instance of ContainerEntryDependency.
 	 * @param {string} name entry name
 	 * @param {ExposesList} exposes list of exposed modules
 	 * @param {string} shareScope name of the share scope
@@ -27,6 +28,7 @@ class ContainerEntryDependency extends Dependency {
 	}
 
 	/**
+	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {