@cdklabs/cdk-construct-connect-datalake 0.0.12 → 0.0.14

package/node_modules/anynum/anynum.js

@@ -0,0 +1,135 @@
+'use strict';
+
+import { TABLE, TABLE_OFFSET, HIGH_MAP, NOT_DIGIT } from './digitTable.js';
+
+const CHAR_0 = 48; // '0'.charCodeAt(0)
+const CHAR_9 = 57; // '9'.charCodeAt(0)
+const CHAR_MINUS = 45; // '-'.charCodeAt(0)
+
+// Unicode minus/hyphen variants worth normalizing to ASCII '-' in numeric context:
+//   U+2212  MINUS SIGN       − (mathematically correct minus)
+//   U+FF0D  FULLWIDTH HYPHEN-MINUS  － (Japanese fullwidth context)
+//   U+FE63  SMALL HYPHEN-MINUS     ﹣ (small form variant)
+//
+// NOT normalized (deliberate):
+//   U+2013  EN DASH  –  (punctuation, not a numeric sign)
+//   U+2014  EM DASH  —  (punctuation)
+//   U+2010  HYPHEN   ‐  (typographic hyphen)
+//
+// Rationale: only characters a human or locale formatter would plausibly use
+// as a numeric minus sign are normalized. Dashes used for punctuation are left
+// alone to avoid mangling non-numeric strings.
+const MINUS_SET = new Set([0x2212, 0xFF0D, 0xFE63]);
+
+/**
+ * Normalize all Unicode decimal digit characters in a string to ASCII (0-9),
+ * and normalize Unicode minus variants to ASCII '-' (U+002D).
+ *
+ * Non-digit, non-minus characters are passed through unchanged.
+ *
+ * Performance design:
+ * - Fast path: if the string has no convertible characters, return it unchanged
+ *   (zero allocation).
+ * - BMP digits (0x0660..0xFFFF excl. surrogates): flat Uint8Array lookup (O(1)).
+ * - Supplementary plane digits (> 0xFFFF, encoded as surrogate pairs): Map lookup.
+ * - Minus variants: checked inline with a small fixed Set.
+ *
+ * @param {string} str
+ * @returns {string}
+ */
+function anynum(str) {
+  if (typeof str !== 'string') return str;
+
+  const len = str.length;
+  if (len === 0) return str;
+
+  // Scan for first character needing conversion.
+  // If none found, return original string (zero allocation).
+  let firstHit = -1;
+
+  for (let i = 0; i < len; i++) {
+    const cc = str.charCodeAt(i);
+
+    // ASCII digit or ASCII minus — already normalized, skip fast
+    if ((cc >= CHAR_0 && cc <= CHAR_9) || cc === CHAR_MINUS) continue;
+
+    // Below first unicode digit script — check minus variants only
+    if (cc < TABLE_OFFSET) {
+      if (MINUS_SET.has(cc)) { firstHit = i; break; }
+      continue;
+    }
+
+    // Surrogate pairs live in BMP range 0xD800-0xDFFF — check before TABLE
+    if (cc >= 0xD800 && cc <= 0xDBFF) {
+      if (i + 1 < len) {
+        const low = str.charCodeAt(i + 1);
+        if (low >= 0xDC00 && low <= 0xDFFF) {
+          const cp = 0x10000 + ((cc - 0xD800) << 10) + (low - 0xDC00);
+          if (HIGH_MAP.has(cp)) { firstHit = i; break; }
+        }
+      }
+      continue;
+    }
+
+    // BMP non-surrogate: flat table lookup; also check minus variants in this range
+    if (TABLE[cc - TABLE_OFFSET] !== NOT_DIGIT || MINUS_SET.has(cc)) {
+      firstHit = i;
+      break;
+    }
+  }
+
+  // Nothing to replace — return original, zero allocation
+  if (firstHit === -1) return str;
+
+  // Build result: copy unchanged prefix, then convert from firstHit onward
+  const chars = [];
+
+  if (firstHit > 0) chars.push(str.slice(0, firstHit));
+
+  for (let i = firstHit; i < len; i++) {
+    const cc = str.charCodeAt(i);
+
+    // ASCII digit or ASCII minus — pass through
+    if ((cc >= CHAR_0 && cc <= CHAR_9) || cc === CHAR_MINUS) {
+      chars.push(str[i]);
+      continue;
+    }
+
+    // Below TABLE_OFFSET — check minus variants, else pass through
+    if (cc < TABLE_OFFSET) {
+      chars.push(MINUS_SET.has(cc) ? '-' : str[i]);
+      continue;
+    }
+
+    // Surrogate pairs
+    if (cc >= 0xD800 && cc <= 0xDBFF) {
+      if (i + 1 < len) {
+        const low = str.charCodeAt(i + 1);
+        if (low >= 0xDC00 && low <= 0xDFFF) {
+          const cp = 0x10000 + ((cc - 0xD800) << 10) + (low - 0xDC00);
+          const d = HIGH_MAP.get(cp);
+          if (d !== undefined) {
+            chars.push(String.fromCharCode(d + 48));
+            i++; // consume low surrogate
+            continue;
+          }
+        }
+      }
+      chars.push(str[i]);
+      continue;
+    }
+
+    // BMP non-surrogate: flat table lookup + minus variants
+    if (MINUS_SET.has(cc)) {
+      chars.push('-');
+      continue;
+    }
+    const d = TABLE[cc - TABLE_OFFSET];
+    chars.push(d !== NOT_DIGIT ? String.fromCharCode(d + 48) : str[i]);
+  }
+
+  return chars.join('');
+}
+
+export { anynum };
+export default anynum;

package/node_modules/anynum/digitTable.js

@@ -0,0 +1,116 @@
+/**
+ * Flat lookup table: maps Unicode code point → ASCII digit (0-9).
+ * Only decimal digit characters (Unicode category Nd) are included.
+ *
+ * Strategy: Int32Array of size (maxCodePoint - minCodePoint + 1).
+ * Value 0xFF means "not a digit". Value 0-9 is the ASCII digit value.
+ * This gives O(1) lookup with no branching, no bisect, no loop.
+ *
+ * Memory: range is 0x0660 to 0x1FBF0 → ~129,936 entries × 1 byte = ~127 KB.
+ * Acceptable for a one-time init; lookup is a single array index.
+ */
+
+// All known Unicode Nd (decimal digit) script zero code points.
+// Each script has exactly 10 consecutive digits: zero+0 .. zero+9.
+const SCRIPT_ZEROS = [
+  // Basic Latin (ASCII) — included for completeness / pass-through
+  0x0030, // 0-9
+
+  // Arabic scripts
+  0x0660, // Arabic-Indic ٠١٢٣٤٥٦٧٨٩
+  0x06F0, // Extended Arabic-Indic (Urdu/Persian/Sindhi) ۰۱۲۳
+
+  // Indic scripts
+  0x0966, // Devanagari ०१२३४५६७८९
+  0x09E6, // Bengali ০১২৩৪৫৬৭৮৯
+  0x0A66, // Gurmukhi ੦੧੨੩੪੫੬੭੮੯
+  0x0AE6, // Gujarati ૦૧૨૩૪૫૬૭૮૯
+  0x0B66, // Odia ୦୧୨୩୪୫୬୭୮୯
+  0x0BE6, // Tamil ௦௧௨௩௪௫௬௭௮௯
+  0x0C66, // Telugu ౦౧౨౩౪౫౬౭౮౯
+  0x0CE6, // Kannada ೦೧೨೩೪೫೬೭೮೯
+  0x0D66, // Malayalam ൦൧൨൩൪൫൬൭൮൯
+  0x0DE6, // Sinhala Archaic ෦෧෨෩෪෫෬෭෮෯
+
+  // Southeast Asian scripts
+  0x0E50, // Thai ๐๑๒๓๔๕๖๗๘๙
+  0x0ED0, // Lao ໐໑໒໓໔໕໖໗໘໙
+  0x0F20, // Tibetan ༠༡༢༣༤༥༦༧༨༩
+  0x1040, // Myanmar ၀၁၂၃၄၅၆၇၈၉
+  0x1090, // Myanmar Shan ႐႑႒႓႔႕႖႗႘႙
+  0x17E0, // Khmer ០១២៣៤៥៦៧៨៩
+  0x1810, // Mongolian ᠐᠑᠒᠓᠔᠕᠖᠗᠘᠙
+  0x1946, // Limbu ᥆᥇᥈᥉᥊᥋᥌᥍᥎᥏
+  0x19D0, // New Tai Lue ᧐᧑᧒᧓᧔᧕᧖᧗᧘᧙
+  0x1A80, // Tai Tham Hora ᪀᪁᪂᪃᪄᪅᪆᪇᪈᪉
+  0x1A90, // Tai Tham Tham ᪐᪑᪒᪓᪔᪕᪖᪗᪘᪙
+  0x1B50, // Balinese ᭐᭑᭒᭓᭔᭕᭖᭗᭘᭙
+  0x1BB0, // Sundanese ᮰᮱᮲᮳᮴᮵᮶᮷᮸᮹
+  0x1C40, // Lepcha ᱀᱁᱂᱃᱄᱅᱆᱇᱈᱉
+  0x1C50, // Ol Chiki ᱐᱑᱒᱓᱔᱕᱖᱗᱘᱙
+
+  // Fullwidth (CJK context)
+  0xFF10, // Fullwidth ０１２３４５６７８９
+
+  // Mathematical digit variants (Unicode math block)
+  0x1D7CE, // Mathematical Bold
+  0x1D7D8, // Mathematical Double-Struck
+  0x1D7E2, // Mathematical Sans-Serif
+  0x1D7EC, // Mathematical Sans-Serif Bold
+  0x1D7F6, // Mathematical Monospace
+
+  // Other scripts
+  0x104A0, // Osmanya 𐒠𐒡𐒢𐒣𐒤𐒥𐒦𐒧𐒨𐒩
+  0x10D30, // Hanifi Rohingya 𐴰𐴱𐴲𐴳𐴴𐴵𐴶𐴷𐴸𐴹
+  0x11066, // Brahmi 𑁦𑁧𑁨𑁩𑁪𑁫𑁬𑁭𑁮𑁯
+  0x110F0, // Sora Sompeng 𑃰𑃱𑃲𑃳𑃴𑃵𑃶𑃷𑃸𑃹
+  0x11136, // Chakma 𑄶𑄷𑄸𑄹𑄺𑄻𑄼𑄽𑄾𑄿
+  0x111D0, // Sharada 𑇐𑇑𑇒𑇓𑇔𑇕𑇖𑇗𑇘𑇙
+  0x112F0, // Khudawadi 𑋰𑋱𑋲𑋳𑋴𑋵𑋶𑋷𑋸𑋹
+  0x11450, // Newa 𑑐𑑑𑑒𑑓𑑔𑑕𑑖𑑗𑑘𑑙
+  0x114D0, // Tirhuta 𑓐𑓑𑓒𑓓𑓔𑓕𑓖𑓗𑓘𑓙
+  0x11650, // Modi 𑙐𑙑𑙒𑙓𑙔𑙕𑙖𑙗𑙘𑙙
+  0x116C0, // Takri 𑛀𑛁𑛂𑛃𑛄𑛅𑛆𑛇𑛈𑛉
+  0x11730, // Ahom 𑜰𑜱𑜲𑜳𑜴𑜵𑜶𑜷𑜸𑜹
+  0x118E0, // Warang Citi 𑣠𑣡𑣢𑣣𑣤𑣥𑣦𑣧𑣨𑣩
+  0x11950, // Dives Akuru 𑥐𑥑𑥒𑥓𑥔𑥕𑥖𑥗𑥘𑥙
+  0x11BF0, // Khitan Small Script 𑯰𑯱𑯲𑯳𑯴𑯵𑯶𑯷𑯸𑯹
+  0x11C50, // Bhaiksuki 𑱐𑱑𑱒𑱓𑱔𑱕𑱖𑱗𑱘𑱙
+  0x11D50, // Masaram Gondi 𑵐𑵑𑵒𑵓𑵔𑵕𑵖𑵗𑵘𑵙
+  0x11DA0, // Gunjala Gondi 𑶠𑶡𑶢𑶣𑶤𑶥𑶦𑶧𑶨𑶩
+  0x11F50, // Kawi 𑽐𑽑𑽒𑽓𑽔𑽕𑽖𑽗𑽘𑽙
+  0x16A60, // Mro 𖩠𖩡𖩢𖩣𖩤𖩥𖩦𖩧𖩨𖩩
+  0x16AC0, // Tangsa 𖫀𖫁𖫂𖫃𖫄𖫅𖫆𖫇𖫈𖫉
+  0x16B50, // Pahawh Hmong 𖭐𖭑𖭒𖭓𖭔𖭕𖭖𖭗𖭘𖭙
+  0x1E140, // Nyiakeng Puachue Hmong 𞅀𞅁𞅂𞅃𞅄𞅅𞅆𞅇𞅈𞅉
+  0x1E2F0, // Wancho 𞋰𞋱𞋲𞋳𞋴𞋵𞋶𞋷𞋸𞋹
+  0x1E4F0, // Nag Mundari 𞓰𞓱𞓲𞓳𞓴𞓵𞓶𞓷𞓸𞓹
+  0x1E950, // Adlam 𞥐𞥑𞥒𞥓𞥔𞥕𞥖𞥗𞥘𞥙
+  0x1FBF0, // Segmented digit symbols 🯰🯱🯲🯳🯴🯵🯶🯷🯸🯹
+];
+
+// Build a sparse Map for scripts above 0xFFFF (surrogate-pair range).
+// These can't go into a flat Uint8Array indexed by code point efficiently.
+const NOT_DIGIT = 0xFF;
+const HIGH_MAP = new Map(); // codePoint → digit value (0-9)
+
+const LOW_MAX = 0xFFFF;
+const LOW_MIN = 0x0660; // first non-ASCII digit script
+
+// Flat Uint8Array covering 0x0660 .. 0xFFFF
+const TABLE_OFFSET = LOW_MIN;
+const TABLE_SIZE = LOW_MAX - LOW_MIN + 1;
+const TABLE = new Uint8Array(TABLE_SIZE).fill(NOT_DIGIT);
+
+for (const zero of SCRIPT_ZEROS) {
+  for (let d = 0; d < 10; d++) {
+    const cp = zero + d;
+    if (cp <= LOW_MAX) {
+      TABLE[cp - TABLE_OFFSET] = d;
+    } else {
+      HIGH_MAP.set(cp, d);
+    }
+  }
+}
+
+export { TABLE, TABLE_OFFSET, HIGH_MAP, NOT_DIGIT };

package/node_modules/anynum/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "anynum",
+  "version": "1.0.0",
+  "description": "Normalize all Unicode decimal digits (Devanagari, Arabic, Thai, etc.) to ASCII numerals. Zero dependencies, performance-first.",
+  "type": "module",
+  "main": "./anynum.js",
+  "files": [
+    "anynum.js",
+    "digitTable.js",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jasmine tests/anynum.test.js",
+    "bench": "node test/bench.js"
+  },
+  "keywords": [
+    "unicode",
+    "digits",
+    "normalize",
+    "devanagari",
+    "arabic",
+    "hindi",
+    "japanese",
+    "indic",
+    "asian",
+    "math",
+    "numerals",
+    "strnum"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NaturalIntelligence/anynum"
+  },
+  "author": "Amit Gupta (https://solothought.work/)",
+  "license": "MIT",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/NaturalIntelligence"
+    }
+  ]
+}

package/node_modules/watchpack/README.md

@@ -131,3 +131,12 @@ const fileTimesOld = wp.getTimes();
 // this include timestamps from files not directly watched
 // key: absolute path, value: timestamp as number
 ```
+
+## Environment variables
+
+- `WATCHPACK_POLLING`: when set, overrides the `poll` option (see above).
+- `WATCHPACK_RETRIES`: number of times to retry `fs.lstat` when it returns
+  `EBUSY` (default: `3`). Useful on Windows where anti-virus scanners,
+  indexers or editors briefly lock files — without retries watchpack would
+  see a spurious `remove` and stop tracking the file. Set to `0` or
+  `"false"` to disable retrying.

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;