nodejs
diff --git a/‎lib/internal/event_target.js‎
Lines changed: 3 additions & 3 deletions b/‎lib/internal/event_target.js‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎lib/internal/perf/observe.js‎
Lines changed: 4 additions & 4 deletions b/‎lib/internal/perf/observe.js‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎lib/internal/perf/performance.js‎
Lines changed: 13 additions & 13 deletions b/‎lib/internal/perf/performance.js‎
Lines changed: 13 additions & 13 deletions
diff --git a/‎lib/internal/perf/performance_entry.js‎
Lines changed: 8 additions & 8 deletions b/‎lib/internal/perf/performance_entry.js‎
Lines changed: 8 additions & 8 deletions
diff --git a/‎lib/internal/perf/resource_timing.js‎
Lines changed: 24 additions & 24 deletions b/‎lib/internal/perf/resource_timing.js‎
Lines changed: 24 additions & 24 deletions
@@ -35,7 +35,7 @@ const {
   validateAbortSignal,
   validateObject,
   validateString,
-  validateInternalField,
+  validateThisInternalField,
   kValidateObjectAllowObjects,
 } = require('internal/validators');
 
@@ -1118,7 +1118,7 @@ function defineEventHandler(emitter, name, event = name) {
   // 8.1.5.1 Event handlers - basically `on[eventName]` attributes
   const propName = `on${name}`;
   function get() {
-    validateInternalField(this, kHandlers, 'EventTarget');
+    validateThisInternalField(this, kHandlers, 'EventTarget');
     return this[kHandlers]?.get(event)?.handler ?? null;
   }
   ObjectDefineProperty(get, 'name', {
@@ -1127,7 +1127,7 @@ function defineEventHandler(emitter, name, event = name) {
   });
 
   function set(value) {
-    validateInternalField(this, kHandlers, 'EventTarget');
+    validateThisInternalField(this, kHandlers, 'EventTarget');
     let wrappedHandler = this[kHandlers]?.get(event);
     if (wrappedHandler) {
       if (typeof wrappedHandler.handler === 'function') {
 
@@ -52,7 +52,7 @@ const {
 const {
   validateFunction,
   validateObject,
-  validateInternalField,
+  validateThisInternalField,
 } = require('internal/validators');
 
 const {
@@ -185,12 +185,12 @@ class PerformanceObserverEntryList {
   }
 
   getEntries() {
-    validateInternalField(this, kBuffer, 'PerformanceObserverEntryList');
+    validateThisInternalField(this, kBuffer, 'PerformanceObserverEntryList');
     return ArrayPrototypeSlice(this[kBuffer]);
   }
 
   getEntriesByType(type) {
-    validateInternalField(this, kBuffer, 'PerformanceObserverEntryList');
+    validateThisInternalField(this, kBuffer, 'PerformanceObserverEntryList');
     if (arguments.length === 0) {
       throw new ERR_MISSING_ARGS('type');
     }
@@ -201,7 +201,7 @@ class PerformanceObserverEntryList {
   }
 
   getEntriesByName(name, type = undefined) {
-    validateInternalField(this, kBuffer, 'PerformanceObserverEntryList');
+    validateThisInternalField(this, kBuffer, 'PerformanceObserverEntryList');
     if (arguments.length === 0) {
       throw new ERR_MISSING_ARGS('name');
     }
 
@@ -43,7 +43,7 @@ const nodeTiming = require('internal/perf/nodetiming');
 const timerify = require('internal/perf/timerify');
 const { customInspectSymbol: kInspect, kEnumerableProperty, kEmptyObject } = require('internal/util');
 const { inspect } = require('util');
-const { validateInternalField } = require('internal/validators');
+const { validateThisInternalField } = require('internal/validators');
 const { convertToInt } = require('internal/webidl');
 
 const kPerformanceBrand = Symbol('performance');
@@ -68,7 +68,7 @@ class Performance extends EventTarget {
   }
 
   clearMarks(name = undefined) {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     if (name !== undefined) {
       name = `${name}`;
     }
@@ -77,28 +77,28 @@ class Performance extends EventTarget {
   }
 
   clearMeasures(name = undefined) {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     if (name !== undefined) {
       name = `${name}`;
     }
     clearEntriesFromBuffer('measure', name);
   }
 
   clearResourceTimings(name = undefined) {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     if (name !== undefined) {
       name = `${name}`;
     }
     clearEntriesFromBuffer('resource', name);
   }
 
   getEntries() {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     return filterBufferMapByNameAndType();
   }
 
   getEntriesByName(name, type = undefined) {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     if (arguments.length === 0) {
       throw new ERR_MISSING_ARGS('name');
     }
@@ -110,7 +110,7 @@ class Performance extends EventTarget {
   }
 
   getEntriesByType(type) {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     if (arguments.length === 0) {
       throw new ERR_MISSING_ARGS('type');
     }
@@ -119,28 +119,28 @@ class Performance extends EventTarget {
   }
 
   mark(name, options = kEmptyObject) {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     if (arguments.length === 0) {
       throw new ERR_MISSING_ARGS('name');
     }
     return mark(name, options);
   }
 
   measure(name, startOrMeasureOptions = kEmptyObject, endMark = undefined) {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     if (arguments.length === 0) {
       throw new ERR_MISSING_ARGS('name');
     }
     return measure(name, startOrMeasureOptions, endMark);
   }
 
   now() {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     return now();
   }
 
   setResourceTimingBufferSize(maxSize) {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     if (arguments.length === 0) {
       throw new ERR_MISSING_ARGS('maxSize');
     }
@@ -150,12 +150,12 @@ class Performance extends EventTarget {
   }
 
   get timeOrigin() {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     return getTimeOriginTimestamp();
   }
 
   toJSON() {
-    validateInternalField(this, kPerformanceBrand, 'Performance');
+    validateThisInternalField(this, kPerformanceBrand, 'Performance');
     return {
       nodeTiming: this.nodeTiming,
       timeOrigin: this.timeOrigin,
 
@@ -15,7 +15,7 @@ const {
   customInspectSymbol: kInspect,
   kEnumerableProperty,
 } = require('internal/util');
-const { validateInternalField } = require('internal/validators');
+const { validateThisInternalField } = require('internal/validators');
 
 const { inspect } = require('util');
 
@@ -49,22 +49,22 @@ class PerformanceEntry {
   }
 
   get name() {
-    validateInternalField(this, kName, 'PerformanceEntry');
+    validateThisInternalField(this, kName, 'PerformanceEntry');
     return this[kName];
   }
 
   get entryType() {
-    validateInternalField(this, kEntryType, 'PerformanceEntry');
+    validateThisInternalField(this, kEntryType, 'PerformanceEntry');
     return this[kEntryType];
   }
 
   get startTime() {
-    validateInternalField(this, kStartTime, 'PerformanceEntry');
+    validateThisInternalField(this, kStartTime, 'PerformanceEntry');
     return this[kStartTime];
   }
 
   get duration() {
-    validateInternalField(this, kDuration, 'PerformanceEntry');
+    validateThisInternalField(this, kDuration, 'PerformanceEntry');
     return this[kDuration];
   }
 
@@ -80,7 +80,7 @@ class PerformanceEntry {
   }
 
   toJSON() {
-    validateInternalField(this, kName, 'PerformanceEntry');
+    validateThisInternalField(this, kName, 'PerformanceEntry');
     return {
       name: this[kName],
       entryType: this[kEntryType],
@@ -106,12 +106,12 @@ function createPerformanceEntry(name, type, start, duration) {
  */
 class PerformanceNodeEntry extends PerformanceEntry {
   get detail() {
-    validateInternalField(this, kDetail, 'NodePerformanceEntry');
+    validateThisInternalField(this, kDetail, 'NodePerformanceEntry');
     return this[kDetail];
   }
 
   toJSON() {
-    validateInternalField(this, kName, 'PerformanceEntry');
+    validateThisInternalField(this, kName, 'PerformanceEntry');
     return {
       name: this[kName],
       entryType: this[kEntryType],
 
@@ -14,7 +14,7 @@ const {
 const { PerformanceEntry, kSkipThrow } = require('internal/perf/performance_entry');
 const assert = require('internal/assert');
 const { enqueue, bufferResourceTiming } = require('internal/perf/observe');
-const { validateInternalField } = require('internal/validators');
+const { validateThisInternalField } = require('internal/validators');
 const { kEnumerableProperty } = require('internal/util');
 
 const kCacheMode = Symbol('kCacheMode');
@@ -34,122 +34,122 @@ class PerformanceResourceTiming extends PerformanceEntry {
   }
 
   get name() {
-    validateInternalField(this, kRequestedUrl, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kRequestedUrl, 'PerformanceResourceTiming');
     return this[kRequestedUrl];
   }
 
   get startTime() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].startTime;
   }
 
   get duration() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].endTime - this[kTimingInfo].startTime;
   }
 
   get initiatorType() {
-    validateInternalField(this, kInitiatorType, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kInitiatorType, 'PerformanceResourceTiming');
     return this[kInitiatorType];
   }
 
   get workerStart() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].finalServiceWorkerStartTime;
   }
 
   get redirectStart() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].redirectStartTime;
   }
 
   get redirectEnd() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].redirectEndTime;
   }
 
   get fetchStart() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].postRedirectStartTime;
   }
 
   get domainLookupStart() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].finalConnectionTimingInfo?.domainLookupStartTime;
   }
 
   get domainLookupEnd() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].finalConnectionTimingInfo?.domainLookupEndTime;
   }
 
   get connectStart() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].finalConnectionTimingInfo?.connectionStartTime;
   }
 
   get connectEnd() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].finalConnectionTimingInfo?.connectionEndTime;
   }
 
   get secureConnectionStart() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo]
       .finalConnectionTimingInfo?.secureConnectionStartTime;
   }
 
   get nextHopProtocol() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo]
       .finalConnectionTimingInfo?.ALPNNegotiatedProtocol;
   }
 
   get requestStart() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].finalNetworkRequestStartTime;
   }
 
   get responseStart() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].finalNetworkResponseStartTime;
   }
 
   get responseEnd() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].endTime;
   }
 
   get encodedBodySize() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].encodedBodySize;
   }
 
   get decodedBodySize() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kTimingInfo].decodedBodySize;
   }
 
   get transferSize() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     if (this[kCacheMode] === 'local') return 0;
     if (this[kCacheMode] === 'validated') return 300;
 
     return this[kTimingInfo].encodedBodySize + 300;
   }
 
   get deliveryType() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kDeliveryType];
   }
 
   get responseStatus() {
-    validateInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
     return this[kResponseStatus];
   }
 
   toJSON() {
-    validateInternalField(this, kInitiatorType, 'PerformanceResourceTiming');
+    validateThisInternalField(this, kInitiatorType, 'PerformanceResourceTiming');
     return {
       name: this.name,
       entryType: this.entryType,
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ const {`
`52`	`52`	`const {`
`53`	`53`	`validateFunction,`
`54`	`54`	`validateObject,`
`55`		`- validateInternalField,`
	`55`	`+ validateThisInternalField,`
`56`	`56`	`} = require('internal/validators');`
`57`	`57`
`58`	`58`	`const {`
`@@ -185,12 +185,12 @@ class PerformanceObserverEntryList {`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`getEntries() {`
`188`		`- validateInternalField(this, kBuffer, 'PerformanceObserverEntryList');`
	`188`	`+ validateThisInternalField(this, kBuffer, 'PerformanceObserverEntryList');`
`189`	`189`	`return ArrayPrototypeSlice(this[kBuffer]);`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`getEntriesByType(type) {`
`193`		`- validateInternalField(this, kBuffer, 'PerformanceObserverEntryList');`
	`193`	`+ validateThisInternalField(this, kBuffer, 'PerformanceObserverEntryList');`
`194`	`194`	`if (arguments.length === 0) {`
`195`	`195`	`throw new ERR_MISSING_ARGS('type');`
`196`	`196`	`}`
`@@ -201,7 +201,7 @@ class PerformanceObserverEntryList {`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`getEntriesByName(name, type = undefined) {`
`204`		`- validateInternalField(this, kBuffer, 'PerformanceObserverEntryList');`
	`204`	`+ validateThisInternalField(this, kBuffer, 'PerformanceObserverEntryList');`
`205`	`205`	`if (arguments.length === 0) {`
`206`	`206`	`throw new ERR_MISSING_ARGS('name');`
`207`	`207`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ const nodeTiming = require('internal/perf/nodetiming');`
`43`	`43`	`const timerify = require('internal/perf/timerify');`
`44`	`44`	`const { customInspectSymbol: kInspect, kEnumerableProperty, kEmptyObject } = require('internal/util');`
`45`	`45`	`const { inspect } = require('util');`
`46`		`-const { validateInternalField } = require('internal/validators');`
	`46`	`+const { validateThisInternalField } = require('internal/validators');`
`47`	`47`	`const { convertToInt } = require('internal/webidl');`
`48`	`48`
`49`	`49`	`const kPerformanceBrand = Symbol('performance');`
`@@ -68,7 +68,7 @@ class Performance extends EventTarget {`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`clearMarks(name = undefined) {`
`71`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`71`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`72`	`72`	`if (name !== undefined) {`
`73`	`73`	name = `${name}`;
`74`	`74`	`}`
`@@ -77,28 +77,28 @@ class Performance extends EventTarget {`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`clearMeasures(name = undefined) {`
`80`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`80`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`81`	`81`	`if (name !== undefined) {`
`82`	`82`	name = `${name}`;
`83`	`83`	`}`
`84`	`84`	`clearEntriesFromBuffer('measure', name);`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`clearResourceTimings(name = undefined) {`
`88`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`88`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`89`	`89`	`if (name !== undefined) {`
`90`	`90`	name = `${name}`;
`91`	`91`	`}`
`92`	`92`	`clearEntriesFromBuffer('resource', name);`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`getEntries() {`
`96`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`96`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`97`	`97`	`return filterBufferMapByNameAndType();`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`getEntriesByName(name, type = undefined) {`
`101`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`101`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`102`	`102`	`if (arguments.length === 0) {`
`103`	`103`	`throw new ERR_MISSING_ARGS('name');`
`104`	`104`	`}`
`@@ -110,7 +110,7 @@ class Performance extends EventTarget {`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`getEntriesByType(type) {`
`113`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`113`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`114`	`114`	`if (arguments.length === 0) {`
`115`	`115`	`throw new ERR_MISSING_ARGS('type');`
`116`	`116`	`}`
`@@ -119,28 +119,28 @@ class Performance extends EventTarget {`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`mark(name, options = kEmptyObject) {`
`122`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`122`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`123`	`123`	`if (arguments.length === 0) {`
`124`	`124`	`throw new ERR_MISSING_ARGS('name');`
`125`	`125`	`}`
`126`	`126`	`return mark(name, options);`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`measure(name, startOrMeasureOptions = kEmptyObject, endMark = undefined) {`
`130`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`130`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`131`	`131`	`if (arguments.length === 0) {`
`132`	`132`	`throw new ERR_MISSING_ARGS('name');`
`133`	`133`	`}`
`134`	`134`	`return measure(name, startOrMeasureOptions, endMark);`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`now() {`
`138`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`138`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`139`	`139`	`return now();`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`setResourceTimingBufferSize(maxSize) {`
`143`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`143`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`144`	`144`	`if (arguments.length === 0) {`
`145`	`145`	`throw new ERR_MISSING_ARGS('maxSize');`
`146`	`146`	`}`
`@@ -150,12 +150,12 @@ class Performance extends EventTarget {`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`get timeOrigin() {`
`153`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`153`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`154`	`154`	`return getTimeOriginTimestamp();`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`toJSON() {`
`158`		`- validateInternalField(this, kPerformanceBrand, 'Performance');`
	`158`	`+ validateThisInternalField(this, kPerformanceBrand, 'Performance');`
`159`	`159`	`return {`
`160`	`160`	`nodeTiming: this.nodeTiming,`
`161`	`161`	`timeOrigin: this.timeOrigin,`