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

package/dist/node/net.js

@@ -0,0 +1,392 @@
+import { EventEmitter } from "node:events";
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/_internal/utils.mjs
+/* @__NO_SIDE_EFFECTS__ */
+function mergeFns(...functions) {
+	return function(...args) {
+		for (const fn of functions) fn(...args);
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function createNotImplementedError(name) {
+	return /* @__PURE__ */ new Error(`[unenv] ${name} is not implemented yet!`);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function notImplemented(name) {
+	const fn = () => {
+		throw /* @__PURE__ */ createNotImplementedError(name);
+	};
+	return Object.assign(fn, { __unenv__: true });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function notImplementedClass(name) {
+	return class {
+		__unenv__ = true;
+		constructor() {
+			throw 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/stream/readable.mjs
+var _Readable = class _Readable extends EventEmitter {
+	__unenv__ = true;
+	readableEncoding = null;
+	readableEnded = true;
+	readableFlowing = false;
+	readableHighWaterMark = 0;
+	readableLength = 0;
+	readableObjectMode = false;
+	readableAborted = false;
+	readableDidRead = false;
+	closed = false;
+	errored = null;
+	readable = false;
+	destroyed = false;
+	static from(_iterable, options) {
+		return new _Readable(options);
+	}
+	constructor(_opts) {
+		super();
+	}
+	_read(_size) {}
+	read(_size) {}
+	setEncoding(_encoding) {
+		return this;
+	}
+	pause() {
+		return this;
+	}
+	resume() {
+		return this;
+	}
+	isPaused() {
+		return true;
+	}
+	unpipe(_destination) {
+		return this;
+	}
+	unshift(_chunk, _encoding) {}
+	wrap(_oldStream) {
+		return this;
+	}
+	push(_chunk, _encoding) {
+		return false;
+	}
+	_destroy(_error, _callback) {
+		this.removeAllListeners();
+	}
+	destroy(error) {
+		this.destroyed = true;
+		this._destroy(error);
+		return this;
+	}
+	pipe(_destenition, _options) {
+		return {};
+	}
+	compose(stream, options) {
+		throw new Error("[unenv] Method not implemented.");
+	}
+	[Symbol.asyncDispose]() {
+		this.destroy();
+		return Promise.resolve();
+	}
+	async *[Symbol.asyncIterator]() {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.asyncIterator");
+	}
+	iterator(options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.iterator");
+	}
+	map(fn, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.map");
+	}
+	filter(fn, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.filter");
+	}
+	forEach(fn, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.forEach");
+	}
+	reduce(fn, initialValue, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.reduce");
+	}
+	find(fn, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.find");
+	}
+	findIndex(fn, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.findIndex");
+	}
+	some(fn, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.some");
+	}
+	toArray(options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.toArray");
+	}
+	every(fn, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.every");
+	}
+	flatMap(fn, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.flatMap");
+	}
+	drop(limit, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.drop");
+	}
+	take(limit, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.take");
+	}
+	asIndexedPairs(options) {
+		throw /* @__PURE__ */ createNotImplementedError("Readable.asIndexedPairs");
+	}
+};
+const Readable = globalThis.Readable || _Readable;
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/stream/writable.mjs
+var _Writable = class extends EventEmitter {
+	__unenv__ = true;
+	writable = true;
+	writableEnded = false;
+	writableFinished = false;
+	writableHighWaterMark = 0;
+	writableLength = 0;
+	writableObjectMode = false;
+	writableCorked = 0;
+	closed = false;
+	errored = null;
+	writableNeedDrain = false;
+	destroyed = false;
+	_data;
+	_encoding = "utf-8";
+	constructor(_opts) {
+		super();
+	}
+	pipe(_destenition, _options) {
+		return {};
+	}
+	_write(chunk, encoding, callback) {
+		if (this.writableEnded) {
+			if (callback) callback();
+			return;
+		}
+		if (this._data === void 0) this._data = chunk;
+		else {
+			const a = typeof this._data === "string" ? Buffer.from(this._data, this._encoding || encoding || "utf8") : this._data;
+			const b = typeof chunk === "string" ? Buffer.from(chunk, encoding || this._encoding || "utf8") : chunk;
+			this._data = Buffer.concat([a, b]);
+		}
+		this._encoding = encoding;
+		if (callback) callback();
+	}
+	_writev(_chunks, _callback) {}
+	_destroy(_error, _callback) {}
+	_final(_callback) {}
+	write(chunk, arg2, arg3) {
+		const encoding = typeof arg2 === "string" ? this._encoding : "utf-8";
+		const cb = typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : void 0;
+		this._write(chunk, encoding, cb);
+		return true;
+	}
+	setDefaultEncoding(_encoding) {
+		return this;
+	}
+	end(arg1, arg2, arg3) {
+		const callback = typeof arg1 === "function" ? arg1 : typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : void 0;
+		if (this.writableEnded) {
+			if (callback) callback();
+			return this;
+		}
+		const data = arg1 === callback ? void 0 : arg1;
+		if (data) {
+			const encoding = arg2 === callback ? void 0 : arg2;
+			this.write(data, encoding, callback);
+		}
+		this.writableEnded = true;
+		this.writableFinished = true;
+		this.emit("close");
+		this.emit("finish");
+		return this;
+	}
+	cork() {}
+	uncork() {}
+	destroy(_error) {
+		this.destroyed = true;
+		delete this._data;
+		this.removeAllListeners();
+		return this;
+	}
+	compose(stream, options) {
+		throw new Error("[h3] Method not implemented.");
+	}
+};
+const Writable = globalThis.Writable || _Writable;
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/stream/duplex.mjs
+const __Duplex = class {
+	allowHalfOpen = true;
+	_destroy;
+	constructor(readable = new Readable(), writable = new Writable()) {
+		Object.assign(this, readable);
+		Object.assign(this, writable);
+		this._destroy = /* @__PURE__ */ mergeFns(readable._destroy, writable._destroy);
+	}
+};
+function getDuplex() {
+	Object.assign(__Duplex.prototype, Readable.prototype);
+	Object.assign(__Duplex.prototype, Writable.prototype);
+	return __Duplex;
+}
+const _Duplex = /* @__PURE__ */ getDuplex();
+const Duplex = globalThis.Duplex || _Duplex;
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/net/socket.mjs
+var Socket = class extends Duplex {
+	__unenv__ = true;
+	bufferSize = 0;
+	bytesRead = 0;
+	bytesWritten = 0;
+	connecting = false;
+	destroyed = false;
+	pending = false;
+	localAddress = "";
+	localPort = 0;
+	remoteAddress = "";
+	remoteFamily = "";
+	remotePort = 0;
+	autoSelectFamilyAttemptedAddresses = [];
+	readyState = "readOnly";
+	constructor(_options) {
+		super();
+	}
+	write(_buffer, _arg1, _arg2) {
+		return false;
+	}
+	connect(_arg1, _arg2, _arg3) {
+		return this;
+	}
+	end(_arg1, _arg2, _arg3) {
+		return this;
+	}
+	setEncoding(_encoding) {
+		return this;
+	}
+	pause() {
+		return this;
+	}
+	resume() {
+		return this;
+	}
+	setTimeout(_timeout, _callback) {
+		return this;
+	}
+	setNoDelay(_noDelay) {
+		return this;
+	}
+	setKeepAlive(_enable, _initialDelay) {
+		return this;
+	}
+	address() {
+		return {};
+	}
+	unref() {
+		return this;
+	}
+	ref() {
+		return this;
+	}
+	destroySoon() {
+		this.destroy();
+	}
+	resetAndDestroy() {
+		const err = /* @__PURE__ */ new Error("ERR_SOCKET_CLOSED");
+		err.code = "ERR_SOCKET_CLOSED";
+		this.destroy(err);
+		return this;
+	}
+};
+var SocketAddress = class {
+	__unenv__ = true;
+	address;
+	family;
+	port;
+	flowlabel;
+	static parse(_address, _port) {}
+	constructor(options) {
+		this.address = options.address;
+		this.family = options.family;
+		this.port = options.port;
+		this.flowlabel = options.flowlabel;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/net/server.mjs
+var Server = class extends EventEmitter {
+	__unenv__ = true;
+	maxConnections = 1;
+	connections = 0;
+	listening = false;
+	constructor(arg1, arg2) {
+		super();
+	}
+	listen() {
+		throw /* @__PURE__ */ createNotImplementedError("node:net.Server.listen()");
+	}
+	close(callback) {
+		throw /* @__PURE__ */ createNotImplementedError("node:net.Server.close()");
+	}
+	address() {
+		return null;
+	}
+	getConnections(cb) {
+		cb(null, 0);
+	}
+	ref() {
+		return this;
+	}
+	unref() {
+		return this;
+	}
+	[Symbol.asyncDispose]() {
+		return Promise.resolve();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/net.mjs
+const createServer = /* @__PURE__ */ notImplemented("net.createServer");
+const BlockList = /* @__PURE__ */ notImplementedClass("net.BlockList");
+const connect = /* @__PURE__ */ notImplemented("net.connect");
+const createConnection = /* @__PURE__ */ notImplemented("net.createConnection");
+const getDefaultAutoSelectFamily = /* @__PURE__ */ notImplemented("net.getDefaultAutoSelectFamily");
+const setDefaultAutoSelectFamily = /* @__PURE__ */ notImplemented("net.setDefaultAutoSelectFamily");
+const getDefaultAutoSelectFamilyAttemptTimeout = /* @__PURE__ */ notImplemented("net.getDefaultAutoSelectFamilyAttemptTimeout");
+const setDefaultAutoSelectFamilyAttemptTimeout = /* @__PURE__ */ notImplemented("net.setDefaultAutoSelectFamilyAttemptTimeout");
+const IPV4Regex = /^(?:\d{1,3}\.){3}\d{1,3}$/;
+const isIPv4 = (host) => IPV4Regex.test(host);
+const IPV6Regex = /^([\dA-Fa-f]{1,4}:){7}[\dA-Fa-f]{1,4}$/;
+const isIPv6 = (host) => IPV6Regex.test(host);
+const isIP = (host) => {
+	if (isIPv4(host)) return 4;
+	if (isIPv6(host)) return 6;
+	return 0;
+};
+const _createServerHandle = /* @__PURE__ */ notImplemented("net._createServerHandle");
+const _normalizeArgs = /* @__PURE__ */ notImplemented("net._normalizeArgs");
+const _setSimultaneousAccepts = /* @__PURE__ */ notImplemented("net._setSimultaneousAccepts");
+const exports = {
+	Socket,
+	Stream: Socket,
+	Server,
+	BlockList,
+	SocketAddress,
+	createServer,
+	connect,
+	createConnection,
+	isIPv4,
+	isIPv6,
+	isIP,
+	getDefaultAutoSelectFamily,
+	getDefaultAutoSelectFamilyAttemptTimeout,
+	setDefaultAutoSelectFamily,
+	setDefaultAutoSelectFamilyAttemptTimeout,
+	_createServerHandle,
+	_normalizeArgs,
+	_setSimultaneousAccepts
+};
+//#endregion
+export { BlockList, Server, Socket, Socket as Stream, SocketAddress, _createServerHandle, _normalizeArgs, _setSimultaneousAccepts, connect, createConnection, createServer, exports as default, getDefaultAutoSelectFamily, getDefaultAutoSelectFamilyAttemptTimeout, isIP, isIPv4, isIPv6, setDefaultAutoSelectFamily, setDefaultAutoSelectFamilyAttemptTimeout };

package/dist/node/os.js

@@ -0,0 +1,259 @@
+//#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!`);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function notImplemented(name) {
+	const fn = () => {
+		throw /* @__PURE__ */ createNotImplementedError(name);
+	};
+	return Object.assign(fn, { __unenv__: true });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/os.mjs
+const constants = {
+	UV_UDP_REUSEADDR: 4,
+	dlopen: {
+		RTLD_LAZY: 1,
+		RTLD_NOW: 2,
+		RTLD_GLOBAL: 256,
+		RTLD_LOCAL: 0,
+		RTLD_DEEPBIND: 8
+	},
+	errno: {
+		E2BIG: 7,
+		EACCES: 13,
+		EADDRINUSE: 98,
+		EADDRNOTAVAIL: 99,
+		EAFNOSUPPORT: 97,
+		EAGAIN: 11,
+		EALREADY: 114,
+		EBADF: 9,
+		EBADMSG: 74,
+		EBUSY: 16,
+		ECANCELED: 125,
+		ECHILD: 10,
+		ECONNABORTED: 103,
+		ECONNREFUSED: 111,
+		ECONNRESET: 104,
+		EDEADLK: 35,
+		EDESTADDRREQ: 89,
+		EDOM: 33,
+		EDQUOT: 122,
+		EEXIST: 17,
+		EFAULT: 14,
+		EFBIG: 27,
+		EHOSTUNREACH: 113,
+		EIDRM: 43,
+		EILSEQ: 84,
+		EINPROGRESS: 115,
+		EINTR: 4,
+		EINVAL: 22,
+		EIO: 5,
+		EISCONN: 106,
+		EISDIR: 21,
+		ELOOP: 40,
+		EMFILE: 24,
+		EMLINK: 31,
+		EMSGSIZE: 90,
+		EMULTIHOP: 72,
+		ENAMETOOLONG: 36,
+		ENETDOWN: 100,
+		ENETRESET: 102,
+		ENETUNREACH: 101,
+		ENFILE: 23,
+		ENOBUFS: 105,
+		ENODATA: 61,
+		ENODEV: 19,
+		ENOENT: 2,
+		ENOEXEC: 8,
+		ENOLCK: 37,
+		ENOLINK: 67,
+		ENOMEM: 12,
+		ENOMSG: 42,
+		ENOPROTOOPT: 92,
+		ENOSPC: 28,
+		ENOSR: 63,
+		ENOSTR: 60,
+		ENOSYS: 38,
+		ENOTCONN: 107,
+		ENOTDIR: 20,
+		ENOTEMPTY: 39,
+		ENOTSOCK: 88,
+		ENOTSUP: 95,
+		ENOTTY: 25,
+		ENXIO: 6,
+		EOPNOTSUPP: 95,
+		EOVERFLOW: 75,
+		EPERM: 1,
+		EPIPE: 32,
+		EPROTO: 71,
+		EPROTONOSUPPORT: 93,
+		EPROTOTYPE: 91,
+		ERANGE: 34,
+		EROFS: 30,
+		ESPIPE: 29,
+		ESRCH: 3,
+		ESTALE: 116,
+		ETIME: 62,
+		ETIMEDOUT: 110,
+		ETXTBSY: 26,
+		EWOULDBLOCK: 11,
+		EXDEV: 18
+	},
+	signals: {
+		SIGHUP: 1,
+		SIGINT: 2,
+		SIGQUIT: 3,
+		SIGILL: 4,
+		SIGTRAP: 5,
+		SIGABRT: 6,
+		SIGIOT: 6,
+		SIGBUS: 7,
+		SIGFPE: 8,
+		SIGKILL: 9,
+		SIGUSR1: 10,
+		SIGSEGV: 11,
+		SIGUSR2: 12,
+		SIGPIPE: 13,
+		SIGALRM: 14,
+		SIGTERM: 15,
+		SIGCHLD: 17,
+		SIGSTKFLT: 16,
+		SIGCONT: 18,
+		SIGSTOP: 19,
+		SIGTSTP: 20,
+		SIGTTIN: 21,
+		SIGTTOU: 22,
+		SIGURG: 23,
+		SIGXCPU: 24,
+		SIGXFSZ: 25,
+		SIGVTALRM: 26,
+		SIGPROF: 27,
+		SIGWINCH: 28,
+		SIGIO: 29,
+		SIGPOLL: 29,
+		SIGPWR: 30,
+		SIGSYS: 31
+	},
+	priority: {
+		PRIORITY_LOW: 19,
+		PRIORITY_BELOW_NORMAL: 10,
+		PRIORITY_NORMAL: 0,
+		PRIORITY_ABOVE_NORMAL: -7,
+		PRIORITY_HIGH: -14,
+		PRIORITY_HIGHEST: -20
+	}
+};
+const NUM_CPUS = 8;
+const availableParallelism = () => NUM_CPUS;
+const arch = () => "";
+const machine = () => "";
+const endianness = () => "LE";
+const cpus = () => {
+	const info = {
+		model: "",
+		speed: 0,
+		times: {
+			user: 0,
+			nice: 0,
+			sys: 0,
+			idle: 0,
+			irq: 0
+		}
+	};
+	return Array.from({ length: NUM_CPUS }, () => info);
+};
+const getPriority = () => 0;
+const setPriority = /* @__PURE__ */ notImplemented("os.setPriority");
+const homedir = () => "/";
+const tmpdir = () => "/tmp";
+const devNull = "/dev/null";
+const freemem = () => 0;
+const totalmem = () => 0;
+const loadavg = () => [
+	0,
+	0,
+	0
+];
+const uptime = () => 0;
+const hostname = () => "";
+const networkInterfaces = () => {
+	return { lo0: [
+		{
+			address: "127.0.0.1",
+			netmask: "255.0.0.0",
+			family: "IPv4",
+			mac: "00:00:00:00:00:00",
+			internal: true,
+			cidr: "127.0.0.1/8"
+		},
+		{
+			address: "::1",
+			netmask: "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
+			family: "IPv6",
+			mac: "00:00:00:00:00:00",
+			internal: true,
+			cidr: "::1/128",
+			scopeid: 0
+		},
+		{
+			address: "fe80::1",
+			netmask: "ffff:ffff:ffff:ffff::",
+			family: "IPv6",
+			mac: "00:00:00:00:00:00",
+			internal: true,
+			cidr: "fe80::1/64",
+			scopeid: 1
+		}
+	] };
+};
+const platform = () => "linux";
+const type = () => "Linux";
+const release = () => "";
+const version = () => "";
+const userInfo = (opts) => {
+	const encode = (str) => {
+		if (opts?.encoding) {
+			const buff = Buffer.from(str);
+			return opts.encoding === "buffer" ? buff : buff.toString(opts.encoding);
+		}
+		return str;
+	};
+	return {
+		gid: 1e3,
+		uid: 1e3,
+		homedir: encode("/"),
+		shell: encode("/bin/sh"),
+		username: encode("root")
+	};
+};
+const EOL = "\n";
+var os_default = {
+	arch,
+	availableParallelism,
+	constants,
+	cpus,
+	EOL: "\n",
+	endianness,
+	devNull,
+	freemem,
+	getPriority,
+	homedir,
+	hostname,
+	loadavg,
+	machine,
+	networkInterfaces,
+	platform,
+	release,
+	setPriority,
+	tmpdir,
+	totalmem,
+	type,
+	uptime,
+	userInfo,
+	version
+};
+//#endregion
+export { EOL, arch, availableParallelism, constants, cpus, os_default as default, devNull, endianness, freemem, getPriority, homedir, hostname, loadavg, machine, networkInterfaces, platform, release, setPriority, tmpdir, totalmem, type, uptime, userInfo, version };

package/dist/node/path/posix.js

@@ -0,0 +1,25 @@
+import path from "@kasperpeulen/vitest-plugin-nextjs/node/path";
+//#region src/node/path/posix.ts
+const missing = (name) => function() {
+	throw new Error(`vitest-plugin-rsc: ${name} of Node.js is not there in the browser`);
+};
+const own = path.posix;
+const basename = own.basename ?? missing("path/posix.basename");
+const dirname = own.dirname ?? missing("path/posix.dirname");
+const extname = own.extname ?? missing("path/posix.extname");
+const format = own.format ?? missing("path/posix.format");
+const isAbsolute = own.isAbsolute ?? missing("path/posix.isAbsolute");
+const join = own.join ?? missing("path/posix.join");
+const normalize = own.normalize ?? missing("path/posix.normalize");
+const parse = own.parse ?? missing("path/posix.parse");
+const relative = own.relative ?? missing("path/posix.relative");
+const resolve = own.resolve ?? missing("path/posix.resolve");
+const toNamespacedPath = own.toNamespacedPath ?? missing("path/posix.toNamespacedPath");
+const sep = own.sep ?? missing("path/posix.sep");
+const delimiter = own.delimiter ?? missing("path/posix.delimiter");
+const posix = own.posix ?? missing("path/posix.posix");
+const win32 = own.win32 ?? missing("path/posix.win32");
+const _makeLong = own._makeLong ?? missing("path/posix._makeLong");
+const matchesGlob = own.matchesGlob ?? missing("path/posix.matchesGlob");
+//#endregion
+export { _makeLong, basename, own as default, delimiter, dirname, extname, format, isAbsolute, join, matchesGlob, normalize, parse, posix, relative, resolve, sep, toNamespacedPath, win32 };

package/dist/node/path/win32.js

@@ -0,0 +1,25 @@
+import path from "@kasperpeulen/vitest-plugin-nextjs/node/path";
+//#region src/node/path/win32.ts
+const missing = (name) => function() {
+	throw new Error(`vitest-plugin-rsc: ${name} of Node.js is not there in the browser`);
+};
+const own = path.win32;
+const basename = own.basename ?? missing("path/win32.basename");
+const dirname = own.dirname ?? missing("path/win32.dirname");
+const extname = own.extname ?? missing("path/win32.extname");
+const format = own.format ?? missing("path/win32.format");
+const isAbsolute = own.isAbsolute ?? missing("path/win32.isAbsolute");
+const join = own.join ?? missing("path/win32.join");
+const normalize = own.normalize ?? missing("path/win32.normalize");
+const parse = own.parse ?? missing("path/win32.parse");
+const relative = own.relative ?? missing("path/win32.relative");
+const resolve = own.resolve ?? missing("path/win32.resolve");
+const toNamespacedPath = own.toNamespacedPath ?? missing("path/win32.toNamespacedPath");
+const sep = own.sep ?? missing("path/win32.sep");
+const delimiter = own.delimiter ?? missing("path/win32.delimiter");
+const posix = own.posix ?? missing("path/win32.posix");
+const win32 = own.win32 ?? missing("path/win32.win32");
+const _makeLong = own._makeLong ?? missing("path/win32._makeLong");
+const matchesGlob = own.matchesGlob ?? missing("path/win32.matchesGlob");
+//#endregion
+export { _makeLong, basename, own as default, delimiter, dirname, extname, format, isAbsolute, join, matchesGlob, normalize, parse, posix, relative, resolve, sep, toNamespacedPath, win32 };