webpack 5.110.2 → 5.111.0

package/lib/util/SourceProcessor.js

@@ -261,14 +261,17 @@ class PrintContext {
 		/** @type {NodePrinter<TPath, TNode, TPrintOptions>} */
 		this._printer = printer;
 		// Printed text by node handle, in two columns rather than one `Map`: the
-		// handles are dense integers, and a stylesheet prints ~300k nodes through
-		// a store that never holds more than a few dozen of them at once.
+		// handles are dense integers, and `_moveEpoch` keeps the live set small.
 		/** @type {string[]} each finished node's printed text */
 		this._storeText = [];
 		/** @type {Int32Array} the epoch each slot was written in */
 		this._storeGen = new Int32Array(0);
 		/** @type {number} current epoch; a slot from an older one reads as absent */
 		this._gen = 1;
+		/** @type {number} lowest slot written since the epoch last moved */
+		this._storeLow = 0x7fffffff;
+		/** @type {number} highest slot written since the epoch last moved */
+		this._storeHigh = -1;
 		// Output accumulates into `_tail`, a plain string append, so printing that
 		// never takes anything back costs exactly what appending to one string
 		// costs. A piece is cut off into `_chunks` only for text that may still be
@@ -285,7 +288,7 @@ class PrintContext {
 		this._flattened = 0;
 		/** @type {[number, number, number, number][]} `[chunkIndex, offsetInChunk, srcLine, srcCol]`, output-ordered; a `srcLine` of -1 is one {@link retract} took back with its piece */
 		this._mappings = [];
-		/** @type {Map<number, number> | null} a retractable piece -> the mapping anchored to it, so taking the piece back takes its mapping too */
+		/** @type {number[] | null} by retractable piece index, the mapping anchored to it, so taking the piece back takes its mapping too */
 		this._retractableMappings = null;
 		// A map is built only for a caller that named the input, and that is known
 		// before printing — so a print nobody asks a map of collects none.
@@ -424,8 +427,25 @@ class PrintContext {
 	 * node's text.
 	 */
 	dropStore() {
-		// Bumping the epoch invalidates every slot at once, so this stays O(1) —
-		// it runs per node, and clearing a column by length would not.
+		this._moveEpoch();
+	}
+
+	/**
+	 * Move the epoch on and release the text every slot written under the old one
+	 * holds. Only the range actually written is walked, so the drop stays O(1)
+	 * per node.
+	 * @returns {void}
+	 */
+	_moveEpoch() {
+		const high = this._storeHigh;
+		if (high !== -1) {
+			// `""` rather than a hole: the column is packed, and a hole in it would
+			// cost every read after this one.
+			const text = this._storeText;
+			for (let i = this._storeLow; i <= high; i++) text[i] = "";
+			this._storeLow = 0x7fffffff;
+			this._storeHigh = -1;
+		}
 		this._gen++;
 	}
 
@@ -469,6 +489,8 @@ class PrintContext {
 		if (n >= this._storeText.length) this._growStore(n + 1);
 		this._storeText[n] = text;
 		this._storeGen[n] = this._gen;
+		if (n < this._storeLow) this._storeLow = n;
+		if (n > this._storeHigh) this._storeHigh = n;
 	}
 
 	/**
@@ -552,7 +574,7 @@ class PrintContext {
 	retract(index) {
 		this._chunks[index] = "";
 		if (this._retractableMappings === null) return;
-		const mapping = this._retractableMappings.get(index);
+		const mapping = this._retractableMappings[index];
 		if (mapping !== undefined) this._mappings[mapping][2] = -1;
 	}
 
@@ -598,12 +620,12 @@ class PrintContext {
 		this.anchor(srcOffset, srcLine, srcCol);
 		const mapping = this._mappings.length > before ? before : -1;
 		const at = this.emitRetractable(text === undefined ? this.get(node) : text);
-		this._gen++;
+		this._moveEpoch();
 		if (mapping !== -1) {
-			if (this._retractableMappings === null) {
-				this._retractableMappings = new Map();
-			}
-			this._retractableMappings.set(at, mapping);
+			// Indexed by piece rather than a `Map`: pieces are dense integers, and
+			// nearly every rule minifying goes out as one.
+			if (this._retractableMappings === null) this._retractableMappings = [];
+			this._retractableMappings[at] = mapping;
 		}
 		return at;
 	}
@@ -627,7 +649,7 @@ class PrintContext {
 		this._emit(
 			text === undefined ? this.get(/** @type {TNode} */ (node)) : text
 		);
-		this._gen++;
+		this._moveEpoch();
 	}
 
 	/**
@@ -739,68 +761,44 @@ class PrintContext {
 
 	/**
 	 * @param {SourceMapOptions} options the input's name / content
+	 * @param {string=} code the output {@link result} built, walked for its line breaks
 	 * @returns {SourceMap} the input->output source map
 	 */
-	sourceMap(options) {
+	sourceMap(options, code) {
 		let out = "";
 		let genLine = 0;
 		let genCol = 0;
 		let srcLine = 0;
 		let srcCol = 0;
 		let atLineStart = true;
-		// Where each anchor landed, walked once alongside the mappings — both are
-		// in output order, so this is one pass over the output, not a position
-		// recomputed per mapping. An anchor can sit inside a piece rather than at
-		// its start, since output accumulates into the piece it is appending to.
+		// Walked over the flat output rather than piece by piece: a piece is a rope
+		// until something reads it, and reading each one flattens each one.
+		const text = code === undefined ? this.result() : code;
 		const chunks = this._chunks;
-		const tail = this._tail;
-		/**
-		 * @param {number} i piece index, `chunks.length` being the tail
-		 * @returns {string} that piece
-		 */
-		const pieceAt = (i) => (i === chunks.length ? tail : chunks[i]);
 		let atChunk = 0;
+		let chunkStart = 0;
 		let atOffset = 0;
 		let atLine = 0;
 		let atCol = 0;
-		// Offset of the next newline at or after the cursor, `-1` for none left in
-		// this piece. Carried rather than searched for per mapping: `indexOf` has no
-		// end bound, so asking it again for each of a piece's mappings scans again to
-		// the end of the piece every time — and minified output, the case with no
-		// newlines at all, is the one where that is the whole piece.
-		let nextNewline = pieceAt(0).indexOf("\n");
-		/**
-		 * @param {string} text the piece to walk
-		 * @param {number} to offset to walk to
-		 */
-		const advanceOver = (text, to) => {
-			while (nextNewline !== -1 && nextNewline < to) {
-				atLine++;
-				atCol = 0;
-				atOffset = nextNewline + 1;
-				nextNewline = text.indexOf("\n", atOffset);
-			}
-			atCol += to - atOffset;
-			atOffset = to;
-		};
-		/**
-		 * @param {number} chunk piece index to advance to
-		 * @param {number} offset offset within it
-		 */
-		const advanceTo = (chunk, offset) => {
-			while (atChunk < chunk) {
-				const text = pieceAt(atChunk);
-				advanceOver(text, text.length);
-				atChunk++;
-				atOffset = 0;
-				nextNewline = pieceAt(atChunk).indexOf("\n");
-			}
-			if (offset > atOffset) advanceOver(pieceAt(atChunk), offset);
-		};
+		// Offset of the next newline at or after the cursor, `-1` for none left.
+		// Carried rather than searched for per mapping: `indexOf` has no end bound.
+		let nextNewline = text.indexOf("\n");
 		for (const [chunkIndex, chunkOffset, sl, sc] of this._mappings) {
 			// Its piece was taken back, so there is no output left to anchor.
 			if (sl === -1) continue;
-			advanceTo(chunkIndex, chunkOffset);
+			// A piece's length is stored, so summing them costs nothing per byte.
+			while (atChunk < chunkIndex) chunkStart += chunks[atChunk++].length;
+			const to = chunkStart + chunkOffset;
+			if (to > atOffset) {
+				while (nextNewline !== -1 && nextNewline < to) {
+					atLine++;
+					atCol = 0;
+					atOffset = nextNewline + 1;
+					nextNewline = text.indexOf("\n", atOffset);
+				}
+				atCol += to - atOffset;
+				atOffset = to;
+			}
 			const gl = atLine;
 			const gc = atCol;
 			while (genLine < gl) {
@@ -915,7 +913,11 @@ class PrintContext {
 		if (this._insertIdx < this._inserts.length) this._flushBefore(Infinity);
 		// Nothing was ever cut into its own piece, so there is nothing to join.
 		const chunks = this._chunks;
-		return chunks.length === 0 ? this._tail : chunks.join("") + this._tail;
+		if (chunks.length === 0) return this._tail;
+		// The tail joins as a piece of its own, so the output comes back flat
+		// rather than as a rope over the join that every reader flattens again.
+		this._cutTail();
+		return chunks.join("");
 	}
 }
 
@@ -1030,16 +1032,21 @@ class SourceProcessor {
 		);
 		this._grammar(input, this._visitors, ctx, opts);
 		const name = /** @type {{ source?: string, content?: string }} */ (opts);
-		const build = () => ({
-			code: ctx.result(),
-			// Built only for a caller that named the input: building one walks the
-			// whole output for its line breaks, and the minifier prints an inline
-			// `style=""` — which asks for no map — thousands of times a document.
-			map:
-				name.source === undefined
-					? undefined
-					: ctx.sourceMap({ source: name.source, content: name.content })
-		});
+		const build = () => {
+			const code = ctx.result();
+			return {
+				code,
+				// Built only for a caller that named the input: a map walks the whole
+				// output, and an inline `style=""` asks for none thousands of times a page.
+				map:
+					name.source === undefined
+						? undefined
+						: ctx.sourceMap(
+								{ source: name.source, content: name.content },
+								code
+							)
+			};
+		};
 		if (this._deferred !== null) {
 			const finish = this._deferred;
 

package/lib/util/URLAbsoluteSpecifier.js

@@ -17,6 +17,7 @@ const _0CharCode = "0".charCodeAt(0);
 const _9CharCode = "9".charCodeAt(0);
 const plusCharCode = "+".charCodeAt(0);
 const hyphenCharCode = "-".charCodeAt(0);
+const dotCharCode = ".".charCodeAt(0);
 const colonCharCode = ":".charCodeAt(0);
 const hashCharCode = "#".charCodeAt(0);
 const queryCharCode = "?".charCodeAt(0);
@@ -46,7 +47,8 @@ function getScheme(specifier) {
 		(ch >= aUpperCaseCharCode && ch <= zUpperCaseCharCode) ||
 		(ch >= _0CharCode && ch <= _9CharCode) ||
 		ch === plusCharCode ||
-		ch === hyphenCharCode
+		ch === hyphenCharCode ||
+		ch === dotCharCode
 	) {
 		if (++i === specifier.length) return;
 		ch = specifier.charCodeAt(i);

package/lib/util/async.js

@@ -0,0 +1,292 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * Wraps the shared completion callback for one item, so an iterator that
+ * reports twice fails loudly instead of settling the run early.
+ * @template E
+ * @param {(err?: E | null) => void} done shared completion callback
+ * @returns {(err?: E | null) => void} completion callback for a single item
+ */
+const once = (done) => {
+	/** @type {((err?: E | null) => void) | undefined} */
+	let pending = done;
+	return (err) => {
+		const fn = pending;
+		if (fn === undefined) throw new Error("Callback was already called");
+		pending = undefined;
+		fn(err);
+	};
+};
+
+/**
+ * Runs `iterator` over every item with unlimited concurrency.
+ * Every item is started from one flat loop, so a synchronous iterator never
+ * grows the stack.
+ * @template T
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {(item: T, callback: (err?: E | null) => void) => void} iterator called once per item
+ * @param {(err?: E | null) => void} callback called when every item is done, or with the first error
+ * @returns {void}
+ */
+const each = (collection, iterator, callback) => {
+	let remaining = 1;
+	let finished = false;
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const done = (err) => {
+		if (finished) return;
+		if (err) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		if (--remaining === 0) {
+			finished = true;
+			callback(null);
+		}
+	};
+
+	if (Array.isArray(collection)) {
+		const array = /** @type {T[]} */ (collection);
+		const length = array.length;
+		if (length === 0) return callback(null);
+		remaining = length;
+		// Dispatching continues past an error on purpose: callers rely on every
+		// item being started, e.g. to close every watcher when one close fails.
+		for (let i = 0; i < length; i++) iterator(array[i], once(done));
+		return;
+	}
+
+	// `remaining` starts at 1 so that completion cannot fire while items of a
+	// collection of unknown length are still being dispatched.
+	for (const item of collection) {
+		remaining++;
+		iterator(item, once(done));
+	}
+	done(null);
+};
+
+/**
+ * Runs `iterator` over every item, keeping at most `limit` of them in flight.
+ * A synchronous iterator is drained by the dispatch loop instead of by
+ * recursion, so the stack stays flat however long the collection is.
+ * @template T
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {number} limit maximum number of items in flight
+ * @param {(item: T, callback: (err?: E | null) => void) => void} iterator called once per item
+ * @param {(err?: E | null) => void} callback called when every item is done, or with the first error
+ * @returns {void}
+ */
+const eachLimit = (collection, limit, iterator, callback) => {
+	const array = Array.isArray(collection)
+		? /** @type {T[]} */ (collection)
+		: undefined;
+	const length = array === undefined ? 0 : array.length;
+	const values =
+		array === undefined ? collection[Symbol.iterator]() : undefined;
+	let index = 0;
+	let running = 0;
+	let exhausted = false;
+	let finished = false;
+	let dispatching = false;
+
+	const dispatch = () => {
+		// A re-entrant call returns at once; the loop already running sees the
+		// slot the completed item freed and takes the next one itself.
+		if (dispatching) return;
+		dispatching = true;
+		while (running < limit && !exhausted) {
+			// `finished` is set from `done`, which an iterator may call before it
+			// returns, so it has to be re-read on every turn of this loop.
+			if (finished) break;
+			/** @type {T} */
+			let item;
+			if (array === undefined) {
+				const next = /** @type {Iterator<T>} */ (values).next();
+				if (next.done) {
+					exhausted = true;
+					break;
+				}
+				item = next.value;
+			} else {
+				if (index === length) {
+					exhausted = true;
+					break;
+				}
+				item = array[index++];
+			}
+			running++;
+			iterator(item, once(done));
+		}
+		dispatching = false;
+		if (exhausted && running === 0 && !finished) {
+			finished = true;
+			callback(null);
+		}
+	};
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const done = (err) => {
+		if (finished) return;
+		running--;
+		if (err) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		dispatch();
+	};
+
+	if (limit < 1) return callback(null);
+
+	dispatch();
+};
+
+/**
+ * Runs `iterator` over every item with unlimited concurrency and collects the
+ * results in the order of the collection, not the order of completion.
+ * @template T
+ * @template R
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {(item: T, callback: (err?: E | null, result?: R) => void) => void} iterator called once per item
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const map = (collection, iterator, callback) => {
+	const array = Array.isArray(collection)
+		? /** @type {T[]} */ (collection)
+		: undefined;
+	// Pre-sized, because growing it or `Array.from` costs measurably more on
+	// the small collections this is called with.
+	/** @type {R[]} */
+	// eslint-disable-next-line unicorn/no-new-array
+	const results = array === undefined ? [] : new Array(array.length);
+	let remaining = 1;
+	let finished = false;
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const settle = (err) => {
+		if (finished) return;
+		if (err) {
+			finished = true;
+			callback(err, results);
+			return;
+		}
+		if (--remaining === 0) {
+			finished = true;
+			callback(null, results);
+		}
+	};
+
+	/**
+	 * @param {number} index position the result of that item belongs at
+	 * @returns {(err?: E | null, result?: R) => void} completion callback for that item
+	 */
+	const createCallback = (index) => {
+		let position = index;
+		return (err, result) => {
+			const at = position;
+			if (at === -1) throw new Error("Callback was already called");
+			position = -1;
+			// A result arriving after the run settled must not reach `results`,
+			// which the callback already handed to the caller.
+			if (finished) return;
+			if (!err) results[at] = /** @type {R} */ (result);
+			settle(err);
+		};
+	};
+
+	if (array !== undefined) {
+		const length = array.length;
+		if (length === 0) return callback(null, results);
+		remaining = length;
+		for (let i = 0; i < length; i++) iterator(array[i], createCallback(i));
+		return;
+	}
+
+	let index = 0;
+	for (const item of collection) {
+		remaining++;
+		iterator(item, createCallback(index++));
+	}
+	results.length = index;
+	settle(null);
+};
+
+/**
+ * Runs `iterator` over every item, at most `limit` of them in flight, and
+ * collects the results in the order of the collection, not of completion.
+ * @template T
+ * @template R
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {number} limit maximum number of items in flight
+ * @param {(item: T, callback: (err?: E | null, result?: R) => void) => void} iterator called once per item
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const mapLimit = (collection, limit, iterator, callback) => {
+	/** @type {R[]} */
+	const results = [];
+	let index = 0;
+	eachLimit(
+		collection,
+		limit,
+		(item, done) => {
+			// the dispatch loop hands out one item at a time, so this counts the
+			// position of the item rather than of whichever finishes first
+			const position = index++;
+			iterator(item, (err, result) => {
+				if (err) return done(err);
+				results[position] = /** @type {R} */ (result);
+				done(null);
+			});
+		},
+		(err) => {
+			if (err) return callback(err);
+			callback(null, results);
+		}
+	);
+};
+
+/**
+ * @template R
+ * @template E
+ * @param {(callback: (err?: E | null, result?: R) => void) => void} task task to run
+ * @param {(err?: E | null, result?: R) => void} callback called when the task is done
+ * @returns {void}
+ */
+const runTask = (task, callback) => task(callback);
+
+/**
+ * Runs every task in parallel and collects the results in task order.
+ * @template R
+ * @template E
+ * @param {((callback: (err?: E | null, result?: R) => void) => void)[]} tasks tasks to run
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const parallel = (tasks, callback) => map(tasks, runTask, callback);
+
+module.exports.each = each;
+module.exports.eachLimit = eachLimit;
+module.exports.map = map;
+module.exports.mapLimit = mapLimit;
+module.exports.parallel = parallel;

package/lib/util/buildDiagnostics.js

@@ -0,0 +1,69 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+/** @import Module, { BuildDiagnostics, BuildInfo } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+
+/**
+ * The diagnostics record of a build info, created on first use so a module nothing reports about carries none.
+ * @param {BuildInfo} buildInfo the build info of the module
+ * @returns {BuildDiagnostics} the record
+ */
+const getBuildDiagnostics = (buildInfo) => {
+	let diagnostics = buildInfo.diagnostics;
+	if (diagnostics === undefined) {
+		diagnostics = buildInfo.diagnostics = {
+			optimizationBailouts: undefined,
+			sideEffectStatement: undefined,
+			ineffectivePureAnnotations: undefined,
+			topLevelThis: undefined,
+			usesEval: undefined,
+			notCacheableReasons: undefined
+		};
+	}
+	return diagnostics;
+};
+
+/**
+ * Records a bailout a parser plugin found, where a module restored from the cache still has it for the module graph to report.
+ * @param {BuildInfo} buildInfo the build info of the module being parsed
+ * @param {string} reason the bailout as reported
+ * @returns {void}
+ */
+const recordOptimizationBailout = (buildInfo, reason) => {
+	const diagnostics = getBuildDiagnostics(buildInfo);
+	const bailouts =
+		diagnostics.optimizationBailouts || (diagnostics.optimizationBailouts = []);
+	bailouts.push(reason);
+};
+
+/**
+ * Replays the bailouts parser plugins recorded for a module into the module graph,
+ * which a module reused from the cache never parses into.
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the built or still valid module
+ * @returns {void}
+ */
+const replayOptimizationBailouts = (moduleGraph, module) => {
+	const buildInfo = module.buildInfo;
+	if (buildInfo === undefined) return;
+	const diagnostics = buildInfo.diagnostics;
+	if (
+		diagnostics === undefined ||
+		diagnostics.optimizationBailouts === undefined
+	) {
+		return;
+	}
+	const bailouts = moduleGraph.getOptimizationBailout(module);
+	for (const reason of diagnostics.optimizationBailouts) bailouts.push(reason);
+};
+
+module.exports = {
+	getBuildDiagnostics,
+	recordOptimizationBailout,
+	replayOptimizationBailouts
+};

package/lib/util/conventions.js

@@ -115,7 +115,11 @@ module.exports.cssExportConvention = (input, convention) => {
 	const set = new Set();
 	if (typeof convention === "function") {
 		const result = convention(input);
-		const validate = (/** @type {string} */ name) => {
+		/**
+		 * @param {string} name name returned by the convention function
+		 * @returns {void}
+		 */
+		const validate = (name) => {
 			if (typeof name !== "string" || name.length === 0) {
 				throw new Error(
 					`exportsConvention function must return a non-empty string or an array of non-empty strings, got ${safeStringify(result)}`

package/lib/util/fs.js

@@ -167,7 +167,7 @@ const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
  * @typedef {{
  * (path: PathOrFileDescriptor, options?: { encoding?: null | undefined, flag?: string | undefined } | null): Buffer,
  * (path: PathOrFileDescriptor, options: { encoding: BufferEncoding, flag?: string | undefined } | BufferEncoding): string,
- * (path: PathOrFileDescriptor, options?: (ObjectEncodingOptions & { flag?: string | undefined }) | BufferEncoding | null): string | Buffer,
+ * (path: PathOrFileDescriptor, options: ObjectEncodingOptions & { flag?: string | undefined }): string | Buffer,
  * }} ReadFileSync
  */
 
@@ -402,6 +402,21 @@ const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
  * @typedef {(path: PathLike, options?: BufferEncoding | ReadStreamOptions) => NodeJS.ReadableStream} CreateReadStream
  */
 
+/**
+ * Defines the symlink type used by this module.
+ * @typedef {(target: PathLike, path: PathLike, type: "dir" | "file" | "junction" | null | undefined, callback: NoParamCallback) => void} Symlink
+ */
+
+/**
+ * Defines the chmod type used by this module.
+ * @typedef {(path: PathLike, mode: number | string, callback: NoParamCallback) => void} Chmod
+ */
+
+/**
+ * Defines the utimes type used by this module.
+ * @typedef {(path: PathLike, atime: number | string | Date, mtime: number | string | Date, callback: NoParamCallback) => void} Utimes
+ */
+
 /**
  * Defines the output file system type used by this module.
  * @typedef {object} OutputFileSystem
@@ -410,6 +425,10 @@ const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
  * @property {Rmdir=} rmdir
  * @property {WriteFile} writeFile
  * @property {Unlink=} unlink
+ * @property {Symlink=} symlink
+ * @property {Readlink=} readlink
+ * @property {Chmod=} chmod
+ * @property {Utimes=} utimes
  * @property {Stat} stat
  * @property {LStat=} lstat
  * @property {ReadFile} readFile
@@ -755,6 +774,13 @@ const lstatReadlinkAbsolute = (fs, p, callback) => {
  */
 const isAbsolute = (pathname) => ABSOLUTE_PATH_REGEXP.test(pathname);
 
+/**
+ * What of a file's mode is its permissions — the type bits above them are not
+ * settable, and the set-user-id and sticky bits are not carried over a copy.
+ */
+const PERMISSIONS_MASK = 0o777;
+
+module.exports.PERMISSIONS_MASK = PERMISSIONS_MASK;
 module.exports.dirname = dirname;
 module.exports.isAbsolute = isAbsolute;
 module.exports.join = join;