@depup/webpack 5.105.4-depup.37

package/lib/runtime/GetMainFilenameRuntimeModule.js

@@ -0,0 +1,49 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+
+class GetMainFilenameRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} name readable name
+	 * @param {string} global global object binding
+	 * @param {string} filename main file name
+	 */
+	constructor(name, global, filename) {
+		super(`get ${name} filename`);
+		/** @type {string} */
+		this.global = global;
+		/** @type {string} */
+		this.filename = filename;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const { global, filename } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { runtimeTemplate } = compilation;
+		const url = compilation.getPath(JSON.stringify(filename), {
+			hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+			hashWithLength: (length) =>
+				`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+			chunk,
+			runtime: chunk.runtime
+		});
+		return Template.asString([
+			`${global} = ${runtimeTemplate.returningFunction(url)};`
+		]);
+	}
+}
+
+module.exports = GetMainFilenameRuntimeModule;

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -0,0 +1,99 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+
+class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
+	 */
+	constructor(runtimeRequirements) {
+		super("trusted types policy");
+		/** @type {ReadOnlyRuntimeRequirements} */
+		this.runtimeRequirements = runtimeRequirements;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.getTrustedTypesPolicy;
+		const wrapPolicyCreationInTryCatch = trustedTypes
+			? trustedTypes.onPolicyCreationFailure === "continue"
+			: false;
+
+		return Template.asString([
+			"var policy;",
+			`${fn} = ${runtimeTemplate.basicFunction("", [
+				"// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
+				"if (policy === undefined) {",
+				Template.indent([
+					"policy = {",
+					Template.indent(
+						[
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScript)
+								? [
+										`createScript: ${runtimeTemplate.returningFunction(
+											"script",
+											"script"
+										)}`
+									]
+								: []),
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScriptUrl)
+								? [
+										`createScriptURL: ${runtimeTemplate.returningFunction(
+											"url",
+											"url"
+										)}`
+									]
+								: [])
+						].join(",\n")
+					),
+					"};",
+					...(trustedTypes
+						? [
+								'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
+								Template.indent([
+									...(wrapPolicyCreationInTryCatch ? ["try {"] : []),
+									...[
+										`policy = trustedTypes.createPolicy(${JSON.stringify(
+											trustedTypes.policyName
+										)}, policy);`
+									].map((line) =>
+										wrapPolicyCreationInTryCatch ? Template.indent(line) : line
+									),
+									...(wrapPolicyCreationInTryCatch
+										? [
+												"} catch (e) {",
+												Template.indent([
+													`console.warn('Could not create trusted-types policy ${JSON.stringify(
+														trustedTypes.policyName
+													)}');`
+												]),
+												"}"
+											]
+										: [])
+								]),
+								"}"
+							]
+						: [])
+				]),
+				"}",
+				"return policy;"
+			])};`
+		]);
+	}
+}
+
+module.exports = GetTrustedTypesPolicyRuntimeModule;

package/lib/runtime/GlobalRuntimeModule.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+class GlobalRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("global");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.global} = (function() {`,
+			Template.indent([
+				"if (typeof globalThis === 'object') return globalThis;",
+				"try {",
+				Template.indent(
+					// This works in non-strict mode
+					// or
+					// This works if eval is allowed (see CSP)
+					"return this || new Function('return this')();"
+				),
+				"} catch (e) {",
+				Template.indent(
+					// This works if the window reference is available
+					"if (typeof window === 'object') return window;"
+				),
+				"}"
+				// It can still be `undefined`, but nothing to do about it...
+				// We return `undefined`, instead of nothing here, so it's
+				// easier to handle this case:
+				//   if (!global) { … }
+			]),
+			"})();"
+		]);
+	}
+}
+
+module.exports = GlobalRuntimeModule;

package/lib/runtime/HasOwnPropertyRuntimeModule.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class HasOwnPropertyRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("hasOwnProperty shorthand");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+
+		return Template.asString([
+			`${RuntimeGlobals.hasOwnProperty} = ${runtimeTemplate.returningFunction(
+				"Object.prototype.hasOwnProperty.call(obj, prop)",
+				"obj, prop"
+			)}`
+		]);
+	}
+}
+
+module.exports = HasOwnPropertyRuntimeModule;

package/lib/runtime/HelperRuntimeModule.js

@@ -0,0 +1,18 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeModule = require("../RuntimeModule");
+
+class HelperRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} name a readable name
+	 */
+	constructor(name) {
+		super(name);
+	}
+}
+
+module.exports = HelperRuntimeModule;

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -0,0 +1,174 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const { SyncWaterfallHook } = require("tapable");
+const Compilation = require("../Compilation");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Chunk")} Chunk */
+
+/**
+ * @typedef {object} LoadScriptCompilationHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} createScript
+ */
+
+/** @type {WeakMap<Compilation, LoadScriptCompilationHooks>} */
+const compilationHooksMap = new WeakMap();
+
+class LoadScriptRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {LoadScriptCompilationHooks} hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				createScript: new SyncWaterfallHook(["source", "chunk"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	/**
+	 * @param {boolean=} withCreateScriptUrl use create script url for trusted types
+	 * @param {boolean=} withFetchPriority use `fetchPriority` attribute
+	 */
+	constructor(withCreateScriptUrl, withFetchPriority) {
+		super("load script");
+		/** @type {boolean | undefined} */
+		this._withCreateScriptUrl = withCreateScriptUrl;
+		/** @type {boolean | undefined} */
+		this._withFetchPriority = withFetchPriority;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate, outputOptions } = compilation;
+		const {
+			scriptType,
+			chunkLoadTimeout: loadTimeout,
+			crossOriginLoading,
+			uniqueName,
+			charset
+		} = outputOptions;
+		const fn = RuntimeGlobals.loadScript;
+
+		const { createScript } =
+			LoadScriptRuntimeModule.getCompilationHooks(compilation);
+
+		const code = Template.asString([
+			"script = document.createElement('script');",
+			scriptType ? `script.type = ${JSON.stringify(scriptType)};` : "",
+			charset ? "script.charset = 'utf-8';" : "",
+			`if (${RuntimeGlobals.scriptNonce}) {`,
+			Template.indent(
+				`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
+			),
+			"}",
+			uniqueName
+				? 'script.setAttribute("data-webpack", dataWebpackPrefix + key);'
+				: "",
+			this._withFetchPriority
+				? Template.asString([
+						"if(fetchPriority) {",
+						Template.indent(
+							'script.setAttribute("fetchpriority", fetchPriority);'
+						),
+						"}"
+					])
+				: "",
+			`script.src = ${
+				this._withCreateScriptUrl
+					? `${RuntimeGlobals.createScriptUrl}(url)`
+					: "url"
+			};`,
+			crossOriginLoading
+				? crossOriginLoading === "use-credentials"
+					? 'script.crossOrigin = "use-credentials";'
+					: Template.asString([
+							"if (script.src.indexOf(window.location.origin + '/') !== 0) {",
+							Template.indent(
+								`script.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+							),
+							"}"
+						])
+				: ""
+		]);
+
+		return Template.asString([
+			"var inProgress = {};",
+			uniqueName
+				? `var dataWebpackPrefix = ${JSON.stringify(`${uniqueName}:`)};`
+				: "// data-webpack is not used as build has no uniqueName",
+			"// loadScript function to load a script via script tag",
+			`${fn} = ${runtimeTemplate.basicFunction(
+				`url, done, key, chunkId${
+					this._withFetchPriority ? ", fetchPriority" : ""
+				}`,
+				[
+					"if(inProgress[url]) { inProgress[url].push(done); return; }",
+					"var script, needAttach;",
+					"if(key !== undefined) {",
+					Template.indent([
+						'var scripts = document.getElementsByTagName("script");',
+						"for(var i = 0; i < scripts.length; i++) {",
+						Template.indent([
+							"var s = scripts[i];",
+							`if(s.getAttribute("src") == url${
+								uniqueName
+									? ' || s.getAttribute("data-webpack") == dataWebpackPrefix + key'
+									: ""
+							}) { script = s; break; }`
+						]),
+						"}"
+					]),
+					"}",
+					"if(!script) {",
+					Template.indent([
+						"needAttach = true;",
+						createScript.call(code, /** @type {Chunk} */ (this.chunk))
+					]),
+					"}",
+					"inProgress[url] = [done];",
+					`var onScriptComplete = ${runtimeTemplate.basicFunction(
+						"prev, event",
+						Template.asString([
+							"// avoid mem leaks in IE.",
+							"script.onerror = script.onload = null;",
+							"clearTimeout(timeout);",
+							"var doneFns = inProgress[url];",
+							"delete inProgress[url];",
+							"script.parentNode && script.parentNode.removeChild(script);",
+							`doneFns && doneFns.forEach(${runtimeTemplate.returningFunction(
+								"fn(event)",
+								"fn"
+							)});`,
+							"if(prev) return prev(event);"
+						])
+					)}`,
+					`var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
+					"script.onerror = onScriptComplete.bind(null, script.onerror);",
+					"script.onload = onScriptComplete.bind(null, script.onload);",
+					"needAttach && document.head.appendChild(script);"
+				]
+			)};`
+		]);
+	}
+}
+
+module.exports = LoadScriptRuntimeModule;

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -0,0 +1,232 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("../Module").ExportsType} ExportsType */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
+
+/**
+ * @param {ExportsType} exportsType exports type
+ * @returns {string} mode
+ */
+function getMakeDeferredNamespaceModeFromExportsType(exportsType) {
+	// number is from createFakeNamespaceObject mode ^ 1
+	if (exportsType === "namespace") return `/* ${exportsType} */ 8`;
+	if (exportsType === "default-only") return `/* ${exportsType} */ 0`;
+	if (exportsType === "default-with-named") return `/* ${exportsType} */ 2`;
+	if (exportsType === "dynamic") return `/* ${exportsType} */ 6`;
+	throw new Error(`Unknown exports type: ${exportsType}`);
+}
+
+/**
+ * @param {string} moduleId moduleId
+ * @param {ExportsType} exportsType exportsType
+ * @param {(ModuleId | null)[]} asyncDepsIds asyncDepsIds
+ * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+ * @returns {string} call make optimized deferred namespace object
+ */
+function getOptimizedDeferredModule(
+	moduleId,
+	exportsType,
+	asyncDepsIds,
+	runtimeRequirements
+) {
+	runtimeRequirements.add(RuntimeGlobals.makeOptimizedDeferredNamespaceObject);
+	const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
+	return `${RuntimeGlobals.makeOptimizedDeferredNamespaceObject}(${moduleId}, ${mode}${
+		asyncDepsIds.length > 0
+			? `, ${JSON.stringify(asyncDepsIds.filter((x) => x !== null))}`
+			: ""
+	})`;
+}
+
+class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {boolean} hasAsyncRuntime if async module is used.
+	 */
+	constructor(hasAsyncRuntime) {
+		super("make optimized deferred namespace object");
+		/** @type {boolean} */
+		this.hasAsyncRuntime = hasAsyncRuntime;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		if (!this.compilation) return null;
+		const fn = RuntimeGlobals.makeOptimizedDeferredNamespaceObject;
+		const hasAsync = this.hasAsyncRuntime;
+		return Template.asString([
+			// Note: must be a function (not arrow), because this is used in body!
+			`${fn} = function(moduleId, mode${hasAsync ? ", asyncDeps" : ""}) {`,
+			Template.indent([
+				"var r = this;",
+				hasAsync ? "var isAsync = asyncDeps && asyncDeps.length;" : "",
+				"var obj = {",
+				Template.indent([
+					"get a() {",
+					Template.indent([
+						"var exports = r(moduleId);",
+						hasAsync
+							? `if(isAsync) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
+							: "",
+						// if exportsType is "namespace" we can generate the most optimized code,
+						// on the second access, we can avoid trigger the getter.
+						// we can also do this if exportsType is "dynamic" and there is a "__esModule" property on it.
+						'if(mode & 8 || (mode & 4 && exports.__esModule)) Object.defineProperty(this, "a", { value: exports });',
+						"return exports;"
+					]),
+					"}"
+				]),
+				"};",
+				hasAsync
+					? `if(isAsync) obj[${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}] = asyncDeps;`
+					: "",
+				"return obj;"
+			]),
+			"};"
+		]);
+	}
+}
+
+class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {boolean} hasAsyncRuntime if async module is used.
+	 */
+	constructor(hasAsyncRuntime) {
+		super("make deferred namespace object");
+		/** @type {boolean} */
+		this.hasAsyncRuntime = hasAsyncRuntime;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		if (!this.compilation) return null;
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.makeDeferredNamespaceObject;
+		const hasAsync = this.hasAsyncRuntime;
+		const init = runtimeTemplate.supportsOptionalChaining()
+			? "init?.();"
+			: "if (init) init();";
+		return `${fn} = ${runtimeTemplate.basicFunction("moduleId, mode", [
+			"var cachedModule = __webpack_module_cache__[moduleId];",
+			"if (cachedModule && cachedModule.error === undefined) {",
+			Template.indent([
+				"var exports = cachedModule.exports;",
+				hasAsync
+					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in exports) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
+					: "",
+				"if (mode & 8) return exports;",
+				`return ${RuntimeGlobals.createFakeNamespaceObject}(exports, mode);`
+			]),
+			"}",
+			"",
+			`var init = ${runtimeTemplate.basicFunction("", [
+				`ns = ${RuntimeGlobals.require}(moduleId);`,
+				hasAsync
+					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in ns) ns = ns[${RuntimeGlobals.asyncModuleExportSymbol}];`
+					: "",
+				"init = null;",
+				"if (mode & 8 || mode & 4 && ns.__esModule && typeof ns === 'object') {",
+				Template.indent([
+					"delete handler.defineProperty;",
+					"delete handler.deleteProperty;",
+					"delete handler.set;",
+					"delete handler.get;",
+					"delete handler.has;",
+					"delete handler.ownKeys;",
+					"delete handler.getOwnPropertyDescriptor;"
+				]),
+				"} else {",
+				Template.indent([
+					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, mode);`
+				]),
+				"}"
+			])};`,
+			"",
+			"var ns = __webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });",
+			"var handler = {",
+			Template.indent([
+				"__proto__: null,",
+				`get: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent([
+						'case "__esModule": return true;',
+						'case Symbol.toStringTag: return "Deferred Module";',
+						'case "then": return undefined;'
+					]),
+					"}",
+					init,
+					"return ns[name];"
+				])},`,
+				`has: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent(
+						[
+							'case "__esModule":',
+							"case Symbol.toStringTag:",
+							hasAsync
+								? `case ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}:`
+								: "",
+							Template.indent("return true;"),
+							'case "then":',
+							Template.indent("return false;")
+						].filter(Boolean)
+					),
+					"}",
+					init,
+					"return name in ns;"
+				])},`,
+				`ownKeys: ${runtimeTemplate.basicFunction("", [
+					init,
+					`var keys = Reflect.ownKeys(ns).filter(${runtimeTemplate.expressionFunction('x !== "then" && x !== Symbol.toStringTag', "x")}).concat([Symbol.toStringTag]);`,
+					"return keys;"
+				])},`,
+				`getOwnPropertyDescriptor: ${runtimeTemplate.basicFunction("_, name", [
+					"switch (name) {",
+					Template.indent([
+						'case "__esModule": return { value: true, configurable: !(mode & 8) };',
+						'case Symbol.toStringTag: return { value: "Deferred Module", configurable: !(mode & 8) };',
+						'case "then": return undefined;'
+					]),
+					"}",
+					init,
+					"var desc = Reflect.getOwnPropertyDescriptor(ns, name);",
+					'if (mode & 2 && name == "default" && !desc) {',
+					Template.indent("desc = { value: ns, configurable: true };"),
+					"}",
+					"return desc;"
+				])},`,
+				`defineProperty: ${runtimeTemplate.basicFunction("_, name", [
+					init,
+					// Note: This behavior does not match the spec one, but since webpack does not do it either
+					// for a normal Module Namespace object (in MakeNamespaceObjectRuntimeModule), let's keep it simple.
+					"return false;"
+				])},`,
+				`deleteProperty: ${runtimeTemplate.returningFunction("false")},`,
+				`set: ${runtimeTemplate.returningFunction("false")},`
+			]),
+			"}",
+			// we don't fully emulate ES Module semantics in this Proxy to align with normal webpack esm namespace object.
+			"return new Proxy(ns, handler);"
+		])};`;
+	}
+}
+
+module.exports.MakeDeferredNamespaceObjectRuntimeModule =
+	MakeDeferredNamespaceObjectRuntimeModule;
+module.exports.MakeOptimizedDeferredNamespaceObjectRuntimeModule =
+	MakeOptimizedDeferredNamespaceObjectRuntimeModule;
+module.exports.getMakeDeferredNamespaceModeFromExportsType =
+	getMakeDeferredNamespaceModeFromExportsType;
+module.exports.getOptimizedDeferredModule = getOptimizedDeferredModule;

package/lib/runtime/MakeNamespaceObjectRuntimeModule.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class MakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("make namespace object");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.makeNamespaceObject;
+		return Template.asString([
+			"// define __esModule on exports",
+			`${fn} = ${runtimeTemplate.basicFunction("exports", [
+				"if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {",
+				Template.indent([
+					"Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });"
+				]),
+				"}",
+				"Object.defineProperty(exports, '__esModule', { value: true });"
+			])};`
+		]);
+	}
+}
+
+module.exports = MakeNamespaceObjectRuntimeModule;