@cdklabs/cdk-construct-connect-datalake 0.0.13 → 0.0.15

package/node_modules/watchpack/lib/DirectoryWatcher.js

@@ -28,13 +28,28 @@ let FS_ACCURACY = 2000;
 const IS_OSX = require("os").platform() === "darwin";
 const IS_WIN = require("os").platform() === "win32";
 
-const { WATCHPACK_POLLING } = process.env;
+const { WATCHPACK_POLLING, WATCHPACK_RETRIES } = process.env;
 const FORCE_POLLING =
 	// @ts-expect-error avoid additional checks
 	`${+WATCHPACK_POLLING}` === WATCHPACK_POLLING
 		? +WATCHPACK_POLLING
 		: Boolean(WATCHPACK_POLLING) && WATCHPACK_POLLING !== "false";
 
+// Number of retries (and delay between retries, in ms) when an fs operation
+// returns EBUSY. EBUSY is transient on Windows when an AV scanner, indexer,
+// or another process briefly locks a file; retrying avoids incorrectly
+// reporting the file as removed (see webpack/watchpack#223, #44).
+//
+// Configurable via `WATCHPACK_RETRIES` env var: an integer >= 0, or "false"
+// to disable retries entirely. Unset / invalid values fall back to 3.
+const BUSY_RETRIES = (() => {
+	if (WATCHPACK_RETRIES === undefined) return 3;
+	if (WATCHPACK_RETRIES === "false") return 0;
+	const n = Number(WATCHPACK_RETRIES);
+	return Number.isFinite(n) && n >= 0 ? Math.floor(n) : 3;
+})();
+const BUSY_RETRY_DELAY = 100;
+
 /**
  * @param {string} str string
  * @returns {string} lower cased string
@@ -77,6 +92,38 @@ function ensureFsAccuracy(mtime) {
 	else if (FS_ACCURACY > 1000 && mtime % 1000 !== 0) FS_ACCURACY = 1000;
 }
 
+/**
+ * Call `fs.lstat` with retries on EBUSY. Transient EBUSY errors are common
+ * on Windows when another process (AV scanner, indexer, editor) holds an
+ * open handle on the file. See webpack/watchpack#223, #44.
+ *
+ * The retry count is taken from the `WATCHPACK_RETRIES` env var (default
+ * 3, set to "0" or "false" to disable retrying). The hot path is a single
+ * `fs.lstat` call with one inline callback; the timer and the recursive
+ * call are only scheduled when an EBUSY is actually observed.
+ * @param {string} target target path
+ * @param {{ closed: boolean }} watcher owning watcher (checked between retries)
+ * @param {(err: NodeJS.ErrnoException | null, stats: import("fs").Stats) => void} callback callback
+ * @param {number=} remaining retries remaining (defaults to `BUSY_RETRIES`)
+ */
+function lstatWithRetry(target, watcher, callback, remaining = BUSY_RETRIES) {
+	fs.lstat(target, (err, stats) => {
+		if (
+			err &&
+			/** @type {NodeJS.ErrnoException} */ (err).code === "EBUSY" &&
+			remaining > 0 &&
+			!watcher.closed
+		) {
+			setTimeout(
+				() => lstatWithRetry(target, watcher, callback, remaining - 1),
+				BUSY_RETRY_DELAY,
+			);
+			return;
+		}
+		callback(err, stats);
+	});
+}
+
 /**
  * @typedef {object} FileWatcherEvents
  * @property {(type: EventType) => void} initial-missing initial missing event
@@ -167,6 +214,8 @@ class DirectoryWatcher extends EventEmitter {
 		this.filesWithoutCase = new Map();
 		/** @type {Map<string, Watcher<DirectoryWatcherEvents> | boolean>} */
 		this.directories = new Map();
+		/** @type {Map<string, Watcher<FileWatcherEvents>>} */
+		this._symlinkTargetWatchers = new Map();
 		this.lastWatchEvent = 0;
 		this.initialScan = true;
 		this.ignored = options.ignored || (() => false);
@@ -427,6 +476,10 @@ class DirectoryWatcher extends EventEmitter {
 					(watcher).close();
 					this.directories.set(directory, true);
 				}
+				for (const w of this._symlinkTargetWatchers.values()) {
+					w.close();
+				}
+				this._symlinkTargetWatchers.clear();
 			}
 		}
 	}
@@ -550,7 +603,7 @@ class DirectoryWatcher extends EventEmitter {
 			const checkStats = () => {
 				if (this.closed) return;
 				this._activeEvents.set(filename, false);
-				fs.lstat(target, (err, stats) => {
+				lstatWithRetry(target, this, (err, stats) => {
 					if (this.closed) return;
 					if (this._activeEvents.get(filename) === true) {
 						process.nextTick(checkStats);
@@ -559,6 +612,9 @@ class DirectoryWatcher extends EventEmitter {
 					this._activeEvents.delete(filename);
 					// ENOENT happens when the file/directory doesn't exist
 					// EPERM happens when the containing directory doesn't exist
+					// EBUSY happens when another process has the file locked (e.g.
+					// Windows AV scanner). lstatWithRetry already retried before
+					// giving up here.
 					if (err) {
 						if (
 							err.code !== "ENOENT" &&
@@ -575,6 +631,13 @@ class DirectoryWatcher extends EventEmitter {
 					}
 					this.lastWatchEvent = Date.now();
 					if (!stats) {
+						// On EBUSY we keep the tracked state: the file is likely still
+						// there and a later event or scan will reconcile. Emitting a
+						// remove here would make the watch appear to stop after a
+						// transient lock (webpack/watchpack#223, #44).
+						if (err && err.code === "EBUSY" && BUSY_RETRIES > 0) {
+							return;
+						}
 						this.setMissing(target, false, eventType);
 					} else if (stats.isDirectory()) {
 						this.setDirectory(target, +stats.birthtime || 1, false, eventType);
@@ -724,7 +787,20 @@ class DirectoryWatcher extends EventEmitter {
 			fs.readdir(this.path, (err, items) => {
 				if (this.closed) return;
 				if (err) {
-					if (err.code === "ENOENT" || err.code === "EPERM") {
+					// Mirror the lstat error handling below: treat permission /
+					// invalid-argument / no-device errors on the directory itself
+					// as removed rather than logging "Watchpack Error (initial
+					// scan)". These surface for unreadable mounts (WSL `/mnt/c`,
+					// fuse mounts), unmounted devices (`/efi`), and libuv's
+					// post-Node 22.17 `EINVAL` on protected Windows paths
+					// (see #187).
+					if (
+						err.code === "ENOENT" ||
+						err.code === "EPERM" ||
+						err.code === "EACCES" ||
+						err.code === "ENODEV" ||
+						(err.code === "EINVAL" && IS_WIN)
+					) {
 						this.onDirectoryRemoved("scan readdir failed");
 					} else {
 						this.onScanError(err);
@@ -801,7 +877,7 @@ class DirectoryWatcher extends EventEmitter {
 					}
 				});
 				for (const itemPath of itemPaths) {
-					fs.lstat(itemPath, (err2, stats) => {
+					lstatWithRetry(itemPath, this, (err2, stats) => {
 						if (this.closed) return;
 						if (err2) {
 							if (
@@ -809,39 +885,115 @@ class DirectoryWatcher extends EventEmitter {
 								err2.code === "EPERM" ||
 								err2.code === "EACCES" ||
 								err2.code === "EBUSY" ||
+								err2.code === "ENODEV" ||
 								// TODO https://github.com/libuv/libuv/pull/4566
 								(err2.code === "EINVAL" && IS_WIN)
 							) {
-								this.setMissing(itemPath, initial, `scan (${err2.code})`);
+								// readdir saw the entry but we can't stat it due to a
+								// transient lock — keep the previously-known entry instead
+								// of incorrectly flagging it as missing.
+								if (
+									!(
+										err2.code === "EBUSY" &&
+										BUSY_RETRIES > 0 &&
+										this.files.has(itemPath)
+									)
+								) {
+									this.setMissing(itemPath, initial, `scan (${err2.code})`);
+								}
 							} else {
 								this.onScanError(err2);
 							}
 							itemFinished();
 							return;
 						}
-						if (stats.isFile() || stats.isSymbolicLink()) {
-							if (stats.mtime) {
-								ensureFsAccuracy(+stats.mtime);
+						/**
+						 * @param {string | null} realPath resolved real path for an outside-dir symlink target
+						 */
+						const apply = (realPath) => {
+							if (stats.isFile() || stats.isSymbolicLink()) {
+								if (stats.mtime) ensureFsAccuracy(+stats.mtime);
+								this.setFileTime(
+									itemPath,
+									+stats.mtime || +stats.ctime || 1,
+									initial,
+									true,
+									"scan (file)",
+								);
+								if (realPath && !this._symlinkTargetWatchers.has(itemPath)) {
+									const w = this.watcherManager.watchFile(realPath, Date.now());
+									if (w) {
+										w.on("change", (mtime, type, wInitial) => {
+											if (wInitial) return;
+											this.setFileTime(itemPath, mtime, false, false, type);
+										});
+										this._symlinkTargetWatchers.set(itemPath, w);
+									}
+								}
+							} else if (
+								stats.isDirectory() &&
+								(!initial || !this.directories.has(itemPath))
+							) {
+								this.setDirectory(
+									itemPath,
+									+stats.birthtime || 1,
+									initial,
+									"scan (dir)",
+								);
 							}
-							this.setFileTime(
-								itemPath,
-								+stats.mtime || +stats.ctime || 1,
-								initial,
-								true,
-								"scan (file)",
-							);
-						} else if (
-							stats.isDirectory() &&
-							(!initial || !this.directories.has(itemPath))
+							itemFinished();
+						};
+						if (
+							this.options.followSymlinks &&
+							this.nestedWatching &&
+							stats.isSymbolicLink()
 						) {
-							this.setDirectory(
-								itemPath,
-								+stats.birthtime || 1,
-								initial,
-								"scan (dir)",
-							);
+							fs.realpath(itemPath, (err3, realPath) => {
+								if (this.closed) return;
+								if (
+									err3 ||
+									!realPath ||
+									withoutCase(path.dirname(realPath)) === withoutCase(this.path)
+								) {
+									apply(null);
+									return;
+								}
+								// Cycle protection: when the symlink's target is the symlink
+								// path itself or one of its ancestors, descending would
+								// create an unbounded chain of `DirectoryWatcher`s as we walk
+								// back into territory we are already watching. Treat the
+								// symlink as a plain entry instead so the symlink itself is
+								// still tracked but no recursion happens.
+								const rel = path.relative(realPath, itemPath);
+								if (!path.isAbsolute(rel) && !rel.startsWith("..")) {
+									apply(null);
+									return;
+								}
+								fs.stat(realPath, (err4, targetStats) => {
+									if (this.closed) return;
+									if (err4 || !targetStats) {
+										apply(null);
+									} else if (targetStats.isFile()) {
+										apply(realPath);
+									} else if (targetStats.isDirectory()) {
+										// Treat a symlink whose target is a directory as a
+										// nested watched directory so files inside the target
+										// propagate change events to the symlink path.
+										this.setDirectory(
+											itemPath,
+											+targetStats.birthtime || +stats.birthtime || 1,
+											initial,
+											"scan (dir)",
+										);
+										itemFinished();
+									} else {
+										apply(null);
+									}
+								});
+							});
+							return;
 						}
-						itemFinished();
+						apply(null);
 					});
 				}
 				itemFinished();
@@ -939,6 +1091,7 @@ class DirectoryWatcher extends EventEmitter {
 	}
 
 	close() {
+		if (this.closed) return;
 		this.closed = true;
 		this.initialScan = false;
 		if (this.watcher) {
@@ -952,6 +1105,10 @@ class DirectoryWatcher extends EventEmitter {
 			}
 			this.directories.clear();
 		}
+		for (const w of this._symlinkTargetWatchers.values()) {
+			w.close();
+		}
+		this._symlinkTargetWatchers.clear();
 		if (this.parentWatcher) {
 			this.parentWatcher.close();
 			this.parentWatcher = null;

package/node_modules/watchpack/lib/index.js

@@ -5,9 +5,9 @@
 "use strict";
 
 const { EventEmitter } = require("events");
-const globToRegExp = require("glob-to-regexp");
 const LinkResolver = require("./LinkResolver");
 const getWatcherManager = require("./getWatcherManager");
+const globToRegExp = require("./util/globToRegExp");
 const watchEventSource = require("./watchEventSource");
 
 /** @typedef {import("./getWatcherManager").WatcherManager} WatcherManager */
@@ -45,8 +45,9 @@ const watchEventSource = require("./watchEventSource");
 /** @typedef {`scan (${string})` | "change" | "rename" | `watch ${string}` | `directory-removed ${string}`} EventType */
 /** @typedef {{ safeTime: number, timestamp: number, accuracy: number }} Entry */
 /** @typedef {{ safeTime: number }} OnlySafeTimeEntry */
+
 // eslint-disable-next-line jsdoc/ts-no-empty-object-type
-/** @typedef {{}} ExistenceOnlyTimeEntry */
+/** @typedef {{  }} ExistenceOnlyTimeEntry */
 /** @typedef {Map<string, Entry | OnlySafeTimeEntry | ExistenceOnlyTimeEntry | null>} TimeInfoEntries */
 /** @typedef {Set<string>} Changes */
 /** @typedef {Set<string>} Removals */
@@ -60,10 +61,8 @@ const watchEventSource = require("./watchEventSource");
  */
 function addWatchersToSet(watchers, set) {
 	for (const ww of watchers) {
-		const w = ww.watcher;
-		if (!set.has(w.directoryWatcher)) {
-			set.add(w.directoryWatcher);
-		}
+		// Set.add is already idempotent, so skip the redundant has() probe.
+		set.add(ww.watcher.directoryWatcher);
 	}
 }
 
@@ -75,31 +74,47 @@ const stringToRegexp = (ignored) => {
 	if (ignored.length === 0) {
 		return;
 	}
-	const { source } = globToRegExp(ignored, { globstar: true, extended: true });
-	return `${source.slice(0, -1)}(?:$|\\/)`;
+	return `^${globToRegExp(ignored)}(?:$|\\/)`;
 };
 
+/**
+ * Normalizes path separators for regex testing. `String.prototype.replace`
+ * always allocates a new string, even when the pattern finds nothing; for
+ * POSIX paths (the common case) that allocation is pure overhead. Check for
+ * a backslash with `indexOf` first so we skip the copy on paths that are
+ * already normalized.
+ * @param {string} item item
+ * @returns {string} item with backslashes normalized to forward slashes
+ */
+const normalizeSeparators = (item) =>
+	item.includes("\\") ? item.replace(/\\/g, "/") : item;
+
 /**
  * @param {Ignored=} ignored ignored
  * @returns {(item: string) => boolean} ignored to function
  */
 const ignoredToFunction = (ignored) => {
 	if (Array.isArray(ignored)) {
-		const stringRegexps = ignored.map((i) => stringToRegexp(i)).filter(Boolean);
+		const stringRegexps =
+			/** @type {string[]} */
+			(ignored.map((i) => stringToRegexp(i)).filter(Boolean));
 		if (stringRegexps.length === 0) {
 			return () => false;
 		}
-		const regexp = new RegExp(stringRegexps.join("|"));
-		return (item) => regexp.test(item.replace(/\\/g, "/"));
+		const regexp =
+			stringRegexps.length === 1
+				? new RegExp(stringRegexps[0])
+				: new RegExp(stringRegexps.join("|"));
+		return (item) => regexp.test(normalizeSeparators(item));
 	} else if (typeof ignored === "string") {
 		const stringRegexp = stringToRegexp(ignored);
 		if (!stringRegexp) {
 			return () => false;
 		}
 		const regexp = new RegExp(stringRegexp);
-		return (item) => regexp.test(item.replace(/\\/g, "/"));
+		return (item) => regexp.test(normalizeSeparators(item));
 	} else if (ignored instanceof RegExp) {
-		return (item) => ignored.test(item.replace(/\\/g, "/"));
+		return (item) => ignored.test(normalizeSeparators(item));
 	} else if (typeof ignored === "function") {
 		return ignored;
 	} else if (ignored) {
@@ -463,8 +478,10 @@ class Watchpack extends EventEmitter {
 		/** @type {Record<string, number>} */
 		const obj = Object.create(null);
 		for (const w of directoryWatchers) {
+			// getTimes() returns a prototype-less object, so for...in is safe
+			// and avoids the throwaway array that Object.keys would allocate.
 			const times = w.getTimes();
-			for (const file of Object.keys(times)) obj[file] = times[file];
+			for (const file in times) obj[file] = times[file];
 		}
 		return obj;
 	}
@@ -551,4 +568,27 @@ class Watchpack extends EventEmitter {
 	}
 }
 
-module.exports = Watchpack;
+/**
+ * @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));
+};
+
+/** @typedef {typeof Watchpack & { util: { readonly globToRegExp: typeof globToRegExp } }} WatchpackExports */
+
+module.exports = /** @type {WatchpackExports} */ (
+	mergeExports(Watchpack, {
+		util: {
+			get globToRegExp() {
+				return globToRegExp;
+			},
+		},
+	})
+);

package/node_modules/watchpack/lib/reducePlan.js

@@ -67,45 +67,66 @@ module.exports = (plan, limit) => {
 			}
 		}
 	}
-	// Reduce until limit reached
-	while (currentCount > limit) {
-		// Select node that helps reaching the limit most effectively without overmerging
-		const overLimit = currentCount - limit;
-		let bestNode;
-		let bestCost = Infinity;
+	// Reduce until limit reached. When no reduction is needed at all, skip
+	// building the candidate set entirely to avoid paying for the setup on the
+	// common fast path.
+	if (currentCount > limit) {
+		// Pre-filter candidate nodes so the inner selection loop skips structural
+		// non-candidates entirely. `children` length and parent presence are
+		// fixed after tree construction; only `entries` can change (it can only
+		// decrease), so a node that fails the `entries` check in a later round
+		// is simply skipped via `continue`. When we merge a subtree we drop the
+		// descendants from the candidate set to keep it shrinking over
+		// iterations.
+		/** @type {Set<TreeNode<T>>} */
+		const candidates = new Set();
 		for (const node of treeMap.values()) {
-			if (node.entries <= 1 || !node.children || !node.parent) continue;
+			if (!node.parent || !node.children) continue;
 			if (node.children.length === 0) continue;
 			if (node.children.length === 1 && !node.value) continue;
-			// Try to select the node with has just a bit more entries than we need to reduce
-			// When just a bit more is over 30% over the limit,
-			// also consider just a bit less entries then we need to reduce
-			const cost =
-				node.entries - 1 >= overLimit
-					? node.entries - 1 - overLimit
-					: overLimit - node.entries + 1 + limit * 0.3;
-			if (cost < bestCost) {
-				bestNode = node;
-				bestCost = cost;
-			}
-		}
-		if (!bestNode) break;
-		// Merge all children
-		const reduction = bestNode.entries - 1;
-		bestNode.active = true;
-		bestNode.entries = 1;
-		currentCount -= reduction;
-		let { parent } = bestNode;
-		while (parent) {
-			parent.entries -= reduction;
-			parent = parent.parent;
+			candidates.add(node);
 		}
-		const queue = new Set(bestNode.children);
-		for (const node of queue) {
-			node.active = false;
-			node.entries = 0;
-			if (node.children) {
-				for (const child of node.children) queue.add(child);
+		const costBias = limit * 0.3;
+		while (currentCount > limit) {
+			// Select node that helps reaching the limit most effectively without overmerging
+			const overLimit = currentCount - limit;
+			let bestNode;
+			let bestCost = Infinity;
+			for (const node of candidates) {
+				if (node.entries <= 1) continue;
+				// Try to select the node with has just a bit more entries than we need to reduce
+				// When just a bit more is over 30% over the limit,
+				// also consider just a bit less entries then we need to reduce
+				const diff = node.entries - 1 - overLimit;
+				const cost = diff >= 0 ? diff : -diff + costBias;
+				if (cost < bestCost) {
+					bestNode = node;
+					bestCost = cost;
+					// A cost of 0 means the merge reduces exactly to the limit;
+					// no further candidate can improve on that, so stop scanning.
+					if (cost === 0) break;
+				}
+			}
+			if (!bestNode) break;
+			// Merge all children
+			const reduction = bestNode.entries - 1;
+			bestNode.active = true;
+			bestNode.entries = 1;
+			candidates.delete(bestNode);
+			currentCount -= reduction;
+			let { parent } = bestNode;
+			while (parent) {
+				parent.entries -= reduction;
+				parent = parent.parent;
+			}
+			const queue = new Set(bestNode.children);
+			for (const node of queue) {
+				node.active = false;
+				node.entries = 0;
+				candidates.delete(node);
+				if (node.children) {
+					for (const child of node.children) queue.add(child);
+				}
 			}
 		}
 	}

package/node_modules/watchpack/lib/util/globToRegExp.js

@@ -0,0 +1,142 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+// Based on https://github.com/fitzgen/glob-to-regexp (MIT)
+// Specialized for watchpack: `extended` and `globstar` always enabled.
+// Returns the regexp source without `^`/`$` anchors.
+
+const CC_EXCLAMATION = 33; // "!"
+const CC_DOLLAR = 36; // "$"
+const CC_LEFT_PARENTHESIS = 40; // "("
+const CC_RIGHT_PARENTHESIS = 41; // ")"
+const CC_ASTERISK = 42; // "*"
+const CC_PLUS = 43; // "+"
+const CC_COMMA = 44; // ","
+const CC_DOT = 46; // "."
+const CC_SLASH = 47; // "/"
+const CC_EQUAL = 61; // "="
+const CC_QUESTION_MARK = 63; // "?"
+const CC_LEFT_BRACKET = 91; // "["
+const CC_RIGHT_BRACKET = 93; // "]"
+const CC_CARET = 94; // "^"
+const CC_LEFT_BRACE = 123; // "{"
+const CC_PIPE = 124; // "|"
+const CC_RIGHT_BRACE = 125; // "}"
+
+/**
+ * @param {string} glob glob pattern
+ * @returns {string} regexp source without anchors
+ */
+module.exports = (glob) => {
+	if (typeof glob !== "string") {
+		throw new TypeError("Expected a string");
+	}
+
+	const len = glob.length;
+	let reStr = "";
+	let inGroup = false;
+	// Start of the current run of literal characters, copied with one slice
+	let literalStart = 0;
+
+	for (let i = 0; i < len; i++) {
+		const cc = glob.charCodeAt(i);
+		const tokenStart = i;
+		let mapped;
+
+		switch (cc) {
+			case CC_SLASH:
+				mapped = "\\/";
+				break;
+			case CC_DOLLAR:
+				mapped = "\\$";
+				break;
+			case CC_CARET:
+				mapped = "\\^";
+				break;
+			case CC_PLUS:
+				mapped = "\\+";
+				break;
+			case CC_DOT:
+				mapped = "\\.";
+				break;
+			case CC_LEFT_PARENTHESIS:
+				mapped = "\\(";
+				break;
+			case CC_RIGHT_PARENTHESIS:
+				mapped = "\\)";
+				break;
+			case CC_EQUAL:
+				mapped = "\\=";
+				break;
+			case CC_EXCLAMATION:
+				mapped = "\\!";
+				break;
+			case CC_PIPE:
+				mapped = "\\|";
+				break;
+			case CC_QUESTION_MARK:
+				mapped = ".";
+				break;
+			case CC_LEFT_BRACKET:
+				mapped = "[";
+				break;
+			case CC_RIGHT_BRACKET:
+				mapped = "]";
+				break;
+			case CC_LEFT_BRACE:
+				inGroup = true;
+				mapped = "(";
+				break;
+			case CC_RIGHT_BRACE:
+				inGroup = false;
+				mapped = ")";
+				break;
+			case CC_COMMA:
+				mapped = inGroup ? "|" : "\\,";
+				break;
+			case CC_ASTERISK: {
+				const atStart = i === 0;
+				const afterSlash = !atStart && glob.charCodeAt(i - 1) === CC_SLASH;
+				let starCount = 1;
+				while (i + 1 < len && glob.charCodeAt(i + 1) === CC_ASTERISK) {
+					starCount++;
+					i++;
+				}
+				const atEnd = i + 1 === len;
+				const beforeSlash = !atEnd && glob.charCodeAt(i + 1) === CC_SLASH;
+				if (
+					starCount > 1 &&
+					(atStart || afterSlash) &&
+					(atEnd || beforeSlash)
+				) {
+					// Globstar segment, matches zero or more path segments
+					mapped = "((?:[^/]*(?:\\/|$))*)";
+					i++; // Move over the "/"
+				} else {
+					// Not a globstar, matches one path segment
+					mapped = "([^/]*)";
+				}
+				break;
+			}
+			default:
+				// Literal character, extend the current run
+				continue;
+		}
+
+		if (literalStart < tokenStart) {
+			reStr += glob.slice(literalStart, tokenStart);
+		}
+		reStr += mapped;
+		literalStart = i + 1;
+	}
+
+	if (literalStart < len) {
+		reStr += literalStart === 0 ? glob : glob.slice(literalStart);
+	}
+
+	return reStr;
+};