@kasperpeulen/vitest-plugin-nextjs 0.0.0-stage → 0.1.0-alpha.0

package/dist/node/path.js

@@ -0,0 +1,384 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+const { basename, delimiter, dirname, extname, format, isAbsolute, join, normalize, parse, relative, resolve, sep } = (/* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function assertPath(path) {
+		if (typeof path !== "string") throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
+	}
+	function normalizeStringPosix(path, allowAboveRoot) {
+		var res = "";
+		var lastSegmentLength = 0;
+		var lastSlash = -1;
+		var dots = 0;
+		var code;
+		for (var i = 0; i <= path.length; ++i) {
+			if (i < path.length) code = path.charCodeAt(i);
+			else if (code === 47) break;
+			else code = 47;
+			if (code === 47) {
+				if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) {
+					if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+						if (res.length > 2) {
+							var lastSlashIndex = res.lastIndexOf("/");
+							if (lastSlashIndex !== res.length - 1) {
+								if (lastSlashIndex === -1) {
+									res = "";
+									lastSegmentLength = 0;
+								} else {
+									res = res.slice(0, lastSlashIndex);
+									lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+								}
+								lastSlash = i;
+								dots = 0;
+								continue;
+							}
+						} else if (res.length === 2 || res.length === 1) {
+							res = "";
+							lastSegmentLength = 0;
+							lastSlash = i;
+							dots = 0;
+							continue;
+						}
+					}
+					if (allowAboveRoot) {
+						if (res.length > 0) res += "/..";
+						else res = "..";
+						lastSegmentLength = 2;
+					}
+				} else {
+					if (res.length > 0) res += "/" + path.slice(lastSlash + 1, i);
+					else res = path.slice(lastSlash + 1, i);
+					lastSegmentLength = i - lastSlash - 1;
+				}
+				lastSlash = i;
+				dots = 0;
+			} else if (code === 46 && dots !== -1) ++dots;
+			else dots = -1;
+		}
+		return res;
+	}
+	function _format(sep, pathObject) {
+		var dir = pathObject.dir || pathObject.root;
+		var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+		if (!dir) return base;
+		if (dir === pathObject.root) return dir + base;
+		return dir + sep + base;
+	}
+	var posix = {
+		resolve: function resolve() {
+			var resolvedPath = "";
+			var resolvedAbsolute = false;
+			var cwd;
+			for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+				var path;
+				if (i >= 0) path = arguments[i];
+				else {
+					if (cwd === void 0) cwd = process.cwd();
+					path = cwd;
+				}
+				assertPath(path);
+				if (path.length === 0) continue;
+				resolvedPath = path + "/" + resolvedPath;
+				resolvedAbsolute = path.charCodeAt(0) === 47;
+			}
+			resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+			if (resolvedAbsolute) {
+				if (resolvedPath.length > 0) return "/" + resolvedPath;
+				else return "/";
+			} else if (resolvedPath.length > 0) return resolvedPath;
+			else return ".";
+		},
+		normalize: function normalize(path) {
+			assertPath(path);
+			if (path.length === 0) return ".";
+			var isAbsolute = path.charCodeAt(0) === 47;
+			var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+			path = normalizeStringPosix(path, !isAbsolute);
+			if (path.length === 0 && !isAbsolute) path = ".";
+			if (path.length > 0 && trailingSeparator) path += "/";
+			if (isAbsolute) return "/" + path;
+			return path;
+		},
+		isAbsolute: function isAbsolute(path) {
+			assertPath(path);
+			return path.length > 0 && path.charCodeAt(0) === 47;
+		},
+		join: function join() {
+			if (arguments.length === 0) return ".";
+			var joined;
+			for (var i = 0; i < arguments.length; ++i) {
+				var arg = arguments[i];
+				assertPath(arg);
+				if (arg.length > 0) {
+					if (joined === void 0) joined = arg;
+					else joined += "/" + arg;
+				}
+			}
+			if (joined === void 0) return ".";
+			return posix.normalize(joined);
+		},
+		relative: function relative(from, to) {
+			assertPath(from);
+			assertPath(to);
+			if (from === to) return "";
+			from = posix.resolve(from);
+			to = posix.resolve(to);
+			if (from === to) return "";
+			var fromStart = 1;
+			for (; fromStart < from.length; ++fromStart) if (from.charCodeAt(fromStart) !== 47) break;
+			var fromEnd = from.length;
+			var fromLen = fromEnd - fromStart;
+			var toStart = 1;
+			for (; toStart < to.length; ++toStart) if (to.charCodeAt(toStart) !== 47) break;
+			var toLen = to.length - toStart;
+			var length = fromLen < toLen ? fromLen : toLen;
+			var lastCommonSep = -1;
+			var i = 0;
+			for (; i <= length; ++i) {
+				if (i === length) {
+					if (toLen > length) {
+						if (to.charCodeAt(toStart + i) === 47) return to.slice(toStart + i + 1);
+						else if (i === 0) return to.slice(toStart + i);
+					} else if (fromLen > length) {
+						if (from.charCodeAt(fromStart + i) === 47) lastCommonSep = i;
+						else if (i === 0) lastCommonSep = 0;
+					}
+					break;
+				}
+				var fromCode = from.charCodeAt(fromStart + i);
+				if (fromCode !== to.charCodeAt(toStart + i)) break;
+				else if (fromCode === 47) lastCommonSep = i;
+			}
+			var out = "";
+			for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) if (i === fromEnd || from.charCodeAt(i) === 47) {
+				if (out.length === 0) out += "..";
+				else out += "/..";
+			}
+			if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
+			else {
+				toStart += lastCommonSep;
+				if (to.charCodeAt(toStart) === 47) ++toStart;
+				return to.slice(toStart);
+			}
+		},
+		_makeLong: function _makeLong(path) {
+			return path;
+		},
+		dirname: function dirname(path) {
+			assertPath(path);
+			if (path.length === 0) return ".";
+			var code = path.charCodeAt(0);
+			var hasRoot = code === 47;
+			var end = -1;
+			var matchedSlash = true;
+			for (var i = path.length - 1; i >= 1; --i) {
+				code = path.charCodeAt(i);
+				if (code === 47) {
+					if (!matchedSlash) {
+						end = i;
+						break;
+					}
+				} else matchedSlash = false;
+			}
+			if (end === -1) return hasRoot ? "/" : ".";
+			if (hasRoot && end === 1) return "//";
+			return path.slice(0, end);
+		},
+		basename: function basename(path, ext) {
+			if (ext !== void 0 && typeof ext !== "string") throw new TypeError("\"ext\" argument must be a string");
+			assertPath(path);
+			var start = 0;
+			var end = -1;
+			var matchedSlash = true;
+			var i;
+			if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
+				if (ext.length === path.length && ext === path) return "";
+				var extIdx = ext.length - 1;
+				var firstNonSlashEnd = -1;
+				for (i = path.length - 1; i >= 0; --i) {
+					var code = path.charCodeAt(i);
+					if (code === 47) {
+						if (!matchedSlash) {
+							start = i + 1;
+							break;
+						}
+					} else {
+						if (firstNonSlashEnd === -1) {
+							matchedSlash = false;
+							firstNonSlashEnd = i + 1;
+						}
+						if (extIdx >= 0) {
+							if (code === ext.charCodeAt(extIdx)) {
+								if (--extIdx === -1) end = i;
+							} else {
+								extIdx = -1;
+								end = firstNonSlashEnd;
+							}
+						}
+					}
+				}
+				if (start === end) end = firstNonSlashEnd;
+				else if (end === -1) end = path.length;
+				return path.slice(start, end);
+			} else {
+				for (i = path.length - 1; i >= 0; --i) if (path.charCodeAt(i) === 47) {
+					if (!matchedSlash) {
+						start = i + 1;
+						break;
+					}
+				} else if (end === -1) {
+					matchedSlash = false;
+					end = i + 1;
+				}
+				if (end === -1) return "";
+				return path.slice(start, end);
+			}
+		},
+		extname: function extname(path) {
+			assertPath(path);
+			var startDot = -1;
+			var startPart = 0;
+			var end = -1;
+			var matchedSlash = true;
+			var preDotState = 0;
+			for (var i = path.length - 1; i >= 0; --i) {
+				var code = path.charCodeAt(i);
+				if (code === 47) {
+					if (!matchedSlash) {
+						startPart = i + 1;
+						break;
+					}
+					continue;
+				}
+				if (end === -1) {
+					matchedSlash = false;
+					end = i + 1;
+				}
+				if (code === 46) {
+					if (startDot === -1) startDot = i;
+					else if (preDotState !== 1) preDotState = 1;
+				} else if (startDot !== -1) preDotState = -1;
+			}
+			if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) return "";
+			return path.slice(startDot, end);
+		},
+		format: function format(pathObject) {
+			if (pathObject === null || typeof pathObject !== "object") throw new TypeError("The \"pathObject\" argument must be of type Object. Received type " + typeof pathObject);
+			return _format("/", pathObject);
+		},
+		parse: function parse(path) {
+			assertPath(path);
+			var ret = {
+				root: "",
+				dir: "",
+				base: "",
+				ext: "",
+				name: ""
+			};
+			if (path.length === 0) return ret;
+			var code = path.charCodeAt(0);
+			var isAbsolute = code === 47;
+			var start;
+			if (isAbsolute) {
+				ret.root = "/";
+				start = 1;
+			} else start = 0;
+			var startDot = -1;
+			var startPart = 0;
+			var end = -1;
+			var matchedSlash = true;
+			var i = path.length - 1;
+			var preDotState = 0;
+			for (; i >= start; --i) {
+				code = path.charCodeAt(i);
+				if (code === 47) {
+					if (!matchedSlash) {
+						startPart = i + 1;
+						break;
+					}
+					continue;
+				}
+				if (end === -1) {
+					matchedSlash = false;
+					end = i + 1;
+				}
+				if (code === 46) {
+					if (startDot === -1) startDot = i;
+					else if (preDotState !== 1) preDotState = 1;
+				} else if (startDot !== -1) preDotState = -1;
+			}
+			if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+				if (end !== -1) {
+					if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
+					else ret.base = ret.name = path.slice(startPart, end);
+				}
+			} else {
+				if (startPart === 0 && isAbsolute) {
+					ret.name = path.slice(1, startDot);
+					ret.base = path.slice(1, end);
+				} else {
+					ret.name = path.slice(startPart, startDot);
+					ret.base = path.slice(startPart, end);
+				}
+				ret.ext = path.slice(startDot, end);
+			}
+			if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
+			else if (isAbsolute) ret.dir = "/";
+			return ret;
+		},
+		sep: "/",
+		delimiter: ":",
+		win32: null,
+		posix: null
+	};
+	posix.posix = posix;
+	module.exports = posix;
+})))(), 1)).default;
+const toNamespacedPath = (file) => file;
+const posix = {
+	basename,
+	delimiter,
+	dirname,
+	extname,
+	format,
+	isAbsolute,
+	join,
+	normalize,
+	parse,
+	relative,
+	resolve,
+	sep,
+	toNamespacedPath
+};
+Object.assign(posix, {
+	posix,
+	win32: posix,
+	_makeLong: toNamespacedPath
+});
+const win32 = posix;
+var path_default = {
+	...posix,
+	posix,
+	win32
+};
+//#endregion
+export { basename, path_default as default, delimiter, dirname, extname, format, isAbsolute, join, normalize, parse, posix, relative, resolve, sep, toNamespacedPath, win32 };

package/dist/node/perf_hooks.js

@@ -0,0 +1,313 @@
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/_internal/utils.mjs
+/* @__NO_SIDE_EFFECTS__ */
+function createNotImplementedError(name) {
+	return /* @__PURE__ */ new Error(`[unenv] ${name} is not implemented yet!`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/perf_hooks/histogram.mjs
+var Histogram = class {
+	min = 0x8000000000000000;
+	max = 0;
+	mean = NaN;
+	exceeds = 0;
+	stddev = NaN;
+	count = 0;
+	countBigInt = BigInt(0);
+	exceedsBigInt = BigInt(0);
+	maxBigInt = 0;
+	minBigInt = BigInt(9223372036854775807n);
+	percentiles = /* @__PURE__ */ new Map();
+	percentilesBigInt = /* @__PURE__ */ new Map();
+	percentileBigInt(_percentile) {
+		throw /* @__PURE__ */ createNotImplementedError("Histogram.percentileBigInt");
+	}
+	percentile(percentile) {
+		return this.percentiles.get(percentile) ?? NaN;
+	}
+	reset() {
+		throw /* @__PURE__ */ createNotImplementedError("Histogram.reset");
+	}
+};
+var IntervalHistogram = class extends Histogram {
+	enable() {
+		return true;
+	}
+	disable() {
+		return true;
+	}
+};
+var RecordableHistogram = class extends Histogram {
+	record(val) {
+		throw /* @__PURE__ */ createNotImplementedError("RecordableHistogram.record");
+	}
+	recordDelta() {
+		throw /* @__PURE__ */ createNotImplementedError("RecordableHistogram.recordDelta");
+	}
+	add(other) {
+		throw /* @__PURE__ */ createNotImplementedError("RecordableHistogram.add");
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/perf_hooks/performance.mjs
+const _timeOrigin = globalThis.performance?.timeOrigin ?? Date.now();
+const _performanceNow = globalThis.performance?.now ? globalThis.performance.now.bind(globalThis.performance) : () => Date.now() - _timeOrigin;
+const nodeTiming = {
+	name: "node",
+	entryType: "node",
+	startTime: 0,
+	duration: 0,
+	nodeStart: 0,
+	v8Start: 0,
+	bootstrapComplete: 0,
+	environment: 0,
+	loopStart: 0,
+	loopExit: 0,
+	idleTime: 0,
+	uvMetricsInfo: {
+		loopCount: 0,
+		events: 0,
+		eventsWaiting: 0
+	},
+	detail: void 0,
+	toJSON() {
+		return this;
+	}
+};
+var PerformanceEntry = class {
+	__unenv__ = true;
+	detail;
+	entryType = "event";
+	name;
+	startTime;
+	constructor(name, options) {
+		this.name = name;
+		this.startTime = options?.startTime || _performanceNow();
+		this.detail = options?.detail;
+	}
+	get duration() {
+		return _performanceNow() - this.startTime;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			entryType: this.entryType,
+			startTime: this.startTime,
+			duration: this.duration,
+			detail: this.detail
+		};
+	}
+};
+const PerformanceMark = class PerformanceMark extends PerformanceEntry {
+	entryType = "mark";
+	constructor() {
+		super(...arguments);
+	}
+	get duration() {
+		return 0;
+	}
+};
+var PerformanceMeasure = class extends PerformanceEntry {
+	entryType = "measure";
+};
+var PerformanceResourceTiming = class extends PerformanceEntry {
+	entryType = "resource";
+	serverTiming = [];
+	connectEnd = 0;
+	connectStart = 0;
+	decodedBodySize = 0;
+	domainLookupEnd = 0;
+	domainLookupStart = 0;
+	encodedBodySize = 0;
+	fetchStart = 0;
+	initiatorType = "";
+	name = "";
+	nextHopProtocol = "";
+	redirectEnd = 0;
+	redirectStart = 0;
+	requestStart = 0;
+	responseEnd = 0;
+	responseStart = 0;
+	secureConnectionStart = 0;
+	startTime = 0;
+	transferSize = 0;
+	workerStart = 0;
+	responseStatus = 0;
+};
+var PerformanceObserverEntryList = class {
+	__unenv__ = true;
+	getEntries() {
+		return [];
+	}
+	getEntriesByName(_name, _type) {
+		return [];
+	}
+	getEntriesByType(type) {
+		return [];
+	}
+};
+var Performance = class {
+	__unenv__ = true;
+	timeOrigin = _timeOrigin;
+	eventCounts = /* @__PURE__ */ new Map();
+	_entries = [];
+	_resourceTimingBufferSize = 0;
+	navigation = void 0;
+	timing = void 0;
+	timerify(_fn, _options) {
+		throw /* @__PURE__ */ createNotImplementedError("Performance.timerify");
+	}
+	get nodeTiming() {
+		return nodeTiming;
+	}
+	eventLoopUtilization() {
+		return {};
+	}
+	markResourceTiming() {
+		return new PerformanceResourceTiming("");
+	}
+	onresourcetimingbufferfull = null;
+	now() {
+		if (this.timeOrigin === _timeOrigin) return _performanceNow();
+		return Date.now() - this.timeOrigin;
+	}
+	clearMarks(markName) {
+		this._entries = markName ? this._entries.filter((e) => e.name !== markName) : this._entries.filter((e) => e.entryType !== "mark");
+	}
+	clearMeasures(measureName) {
+		this._entries = measureName ? this._entries.filter((e) => e.name !== measureName) : this._entries.filter((e) => e.entryType !== "measure");
+	}
+	clearResourceTimings() {
+		this._entries = this._entries.filter((e) => e.entryType !== "resource" || e.entryType !== "navigation");
+	}
+	getEntries() {
+		return this._entries;
+	}
+	getEntriesByName(name, type) {
+		return this._entries.filter((e) => e.name === name && (!type || e.entryType === type));
+	}
+	getEntriesByType(type) {
+		return this._entries.filter((e) => e.entryType === type);
+	}
+	mark(name, options) {
+		const entry = new PerformanceMark(name, options);
+		this._entries.push(entry);
+		return entry;
+	}
+	measure(measureName, startOrMeasureOptions, endMark) {
+		let start;
+		let end;
+		if (typeof startOrMeasureOptions === "string") {
+			start = this.getEntriesByName(startOrMeasureOptions, "mark")[0]?.startTime;
+			end = this.getEntriesByName(endMark, "mark")[0]?.startTime;
+		} else {
+			start = Number.parseFloat(startOrMeasureOptions?.start) || this.now();
+			end = Number.parseFloat(startOrMeasureOptions?.end) || this.now();
+		}
+		const entry = new PerformanceMeasure(measureName, {
+			startTime: start,
+			detail: {
+				start,
+				end
+			}
+		});
+		this._entries.push(entry);
+		return entry;
+	}
+	setResourceTimingBufferSize(maxSize) {
+		this._resourceTimingBufferSize = maxSize;
+	}
+	addEventListener(type, listener, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Performance.addEventListener");
+	}
+	removeEventListener(type, listener, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Performance.removeEventListener");
+	}
+	dispatchEvent(event) {
+		throw /* @__PURE__ */ createNotImplementedError("Performance.dispatchEvent");
+	}
+	toJSON() {
+		return this;
+	}
+};
+var PerformanceObserver = class {
+	__unenv__ = true;
+	static supportedEntryTypes = [];
+	_callback = null;
+	constructor(callback) {
+		this._callback = callback;
+	}
+	takeRecords() {
+		return [];
+	}
+	disconnect() {
+		throw /* @__PURE__ */ createNotImplementedError("PerformanceObserver.disconnect");
+	}
+	observe(options) {
+		throw /* @__PURE__ */ createNotImplementedError("PerformanceObserver.observe");
+	}
+	bind(fn) {
+		return fn;
+	}
+	runInAsyncScope(fn, thisArg, ...args) {
+		return fn.call(thisArg, ...args);
+	}
+	asyncId() {
+		return 0;
+	}
+	triggerAsyncId() {
+		return 0;
+	}
+	emitDestroy() {
+		return this;
+	}
+};
+const performance = globalThis.performance && "addEventListener" in globalThis.performance ? globalThis.performance : new Performance();
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/perf_hooks.mjs
+const constants = {
+	NODE_PERFORMANCE_GC_MAJOR: 4,
+	NODE_PERFORMANCE_GC_MINOR: 1,
+	NODE_PERFORMANCE_GC_INCREMENTAL: 8,
+	NODE_PERFORMANCE_GC_WEAKCB: 16,
+	NODE_PERFORMANCE_GC_FLAGS_NO: 0,
+	NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED: 2,
+	NODE_PERFORMANCE_GC_FLAGS_FORCED: 4,
+	NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING: 8,
+	NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE: 16,
+	NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY: 32,
+	NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE: 64,
+	NODE_PERFORMANCE_ENTRY_TYPE_GC: 0,
+	NODE_PERFORMANCE_ENTRY_TYPE_HTTP: 1,
+	NODE_PERFORMANCE_ENTRY_TYPE_HTTP2: 2,
+	NODE_PERFORMANCE_ENTRY_TYPE_NET: 3,
+	NODE_PERFORMANCE_ENTRY_TYPE_DNS: 4,
+	NODE_PERFORMANCE_MILESTONE_TIME_ORIGIN_TIMESTAMP: 0,
+	NODE_PERFORMANCE_MILESTONE_TIME_ORIGIN: 1,
+	NODE_PERFORMANCE_MILESTONE_ENVIRONMENT: 2,
+	NODE_PERFORMANCE_MILESTONE_NODE_START: 3,
+	NODE_PERFORMANCE_MILESTONE_V8_START: 4,
+	NODE_PERFORMANCE_MILESTONE_LOOP_START: 5,
+	NODE_PERFORMANCE_MILESTONE_LOOP_EXIT: 6,
+	NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE: 7
+};
+const monitorEventLoopDelay = function(_options) {
+	return new IntervalHistogram();
+};
+const createHistogram = function(_options) {
+	return new RecordableHistogram();
+};
+var perf_hooks_default = {
+	Performance,
+	PerformanceMark,
+	PerformanceEntry,
+	PerformanceMeasure,
+	PerformanceObserverEntryList,
+	PerformanceObserver,
+	PerformanceResourceTiming,
+	performance,
+	constants,
+	createHistogram,
+	monitorEventLoopDelay
+};
+//#endregion
+export { Performance, PerformanceEntry, PerformanceMark, PerformanceMeasure, PerformanceObserver, PerformanceObserverEntryList, PerformanceResourceTiming, constants, createHistogram, perf_hooks_default as default, monitorEventLoopDelay, performance };