Memory leak behavior in core-js DOM collection polyfills across versions

Direct Answer

No documented memory leak patterns exist in core-js DOM collection polyfills (NodeList, HTMLCollection, DOMTokenList) that persist across versions 2.x and 3.x. The polyfills use prototype augmentation only; they do not create caches, weak maps, or closure-scoped references to live DOM nodes. Any measurable retention in long-running browser applications comes from the browser engine's internal collection backing stores, not from core-js code paths.

Confirmed Behavior by Version

core-js 2.x (e.g., 2.6.12)

• Single bundled entry point (core-js or core-js/stable) eagerly polyfills all DOM collection prototypes at load time.
• Prototype augmentation adds Symbol.iterator, forEach, keys, values, entries to NodeList.prototype, HTMLCollection.prototype, DOMTokenList.prototype.
• These prototype-chain references persist for the document lifetime — same as any prototype method — but do not retain individual element references beyond normal prototype linkage.

core-js 3.x (e.g., 3.38.x)

• Granular ES module exports (e.g., core-js/stable/dom-collections/iterator, core-js/stable/dom-collections/for-each) allow selective loading via bundlers with tree-shaking.
• The modular approach does not change the prototype-augmentation mechanism; memory retention per polyfill is equivalent to 2.x when the same features are imported.
• core-js/stable entry point still eagerly loads all stable polyfills including DOM collections; tree-shaking only works with explicit subpath imports.

Feature Detection and Initialization

Both versions use globalThis checks and Object.getOwnPropertyDescriptor during module evaluation. These operations create only transient references eligible for garbage collection after evaluation completes. No documented cleanup failures exist in the source code for either major version. Development builds may emit feature-detection warnings; production builds do not.

Where Retention Actually Occurs

• Browser engine internals: V8, SpiderMonkey, JavaScriptCore may retain internal backing stores for collections after iteration — indistinguishable from native collection usage.
• Application code: Storing Array.from(nodeList) results in long-lived maps or caches creates retention attributable to the application, not core-js.
• Legacy fallback shims: In environments with broken native implementations (old IE, legacy WebViews), polyfills may use expando properties on DOM nodes. Those expandos can impede GC if the node is detached but the expando remains reachable — a browser/engine issue, not core-js specific.

Verification Steps (If You Need to Confirm in Your App)

1. Take a Chrome DevTools heap snapshot before loading core-js.
2. Load via import "core-js/stable" (eager) vs selective import "core-js/stable/dom-collections/iterator".
3. Force GC, take another snapshot, compare retained size of DOMCollection prototypes and detached node counts.
4. Run the library's test suite (npm test in cloned repo) — it includes Node.js leak-detection harnesses; no browser heap tests exist.

One Diagnostic Detail That Changes Recommendations

Are you polyfilling in a legacy environment (IE11, old WebView) where native NodeList/HTMLCollection lack Symbol.iterator? If yes, the fallback shim may attach expando properties — profile detached node counts specifically in that environment.