@powerlines/plugin-env 0.15.13 → 0.15.15

package/dist/node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs

@@ -0,0 +1,138 @@
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const basename = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+
+//#endregion
+export { basename, dirname, extname, isAbsolute, join, normalize, resolve };

package/dist/node_modules/.pnpm/pkg-types@2.3.0/node_modules/pkg-types/dist/index.cjs

@@ -0,0 +1,127 @@
+const require_rolldown_runtime = require('../../../../../../_virtual/rolldown_runtime.cjs');
+const require_pathe_M_eThtNZ = require('../../../../pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.cjs');
+const require_index = require('../../../../exsolve@1.0.8/node_modules/exsolve/dist/index.cjs');
+const require_confbox_DnMsyigM = require('../../../../confbox@0.2.2/node_modules/confbox/dist/shared/confbox.DnMsyigM.cjs');
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let node_url = require("node:url");
+
+//#region ../../node_modules/.pnpm/pkg-types@2.3.0/node_modules/pkg-types/dist/index.mjs
+const defaultFindOptions = {
+	startingFrom: ".",
+	rootPattern: /^node_modules$/,
+	reverse: false,
+	test: (filePath) => {
+		try {
+			if ((0, node_fs.statSync)(filePath).isFile()) return true;
+		} catch {}
+	}
+};
+async function findFile(filename, _options = {}) {
+	const filenames = Array.isArray(filename) ? filename : [filename];
+	const options = {
+		...defaultFindOptions,
+		..._options
+	};
+	const basePath = require_pathe_M_eThtNZ.resolve(options.startingFrom);
+	const leadingSlash = basePath[0] === "/";
+	const segments = basePath.split("/").filter(Boolean);
+	if (filenames.includes(segments.at(-1)) && await options.test(basePath)) return basePath;
+	if (leadingSlash) segments[0] = "/" + segments[0];
+	let root = segments.findIndex((r) => r.match(options.rootPattern));
+	if (root === -1) root = 0;
+	if (options.reverse) for (let index = root + 1; index <= segments.length; index++) for (const filename2 of filenames) {
+		const filePath = require_pathe_M_eThtNZ.join(...segments.slice(0, index), filename2);
+		if (await options.test(filePath)) return filePath;
+	}
+	else for (let index = segments.length; index > root; index--) for (const filename2 of filenames) {
+		const filePath = require_pathe_M_eThtNZ.join(...segments.slice(0, index), filename2);
+		if (await options.test(filePath)) return filePath;
+	}
+	throw new Error(`Cannot find matching ${filename} in ${options.startingFrom} or parent directories`);
+}
+function findNearestFile(filename, options = {}) {
+	return findFile(filename, options);
+}
+function _resolvePath(id, opts = {}) {
+	if (id instanceof URL || id.startsWith("file://")) return require_pathe_M_eThtNZ.normalize((0, node_url.fileURLToPath)(id));
+	if (require_pathe_M_eThtNZ.isAbsolute(id)) return require_pathe_M_eThtNZ.normalize(id);
+	return require_index.resolveModulePath(id, {
+		...opts,
+		from: opts.from || opts.parent || opts.url
+	});
+}
+const lockFiles = [
+	"yarn.lock",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"npm-shrinkwrap.json",
+	"bun.lockb",
+	"bun.lock",
+	"deno.lock"
+];
+const packageFiles = [
+	"package.json",
+	"package.json5",
+	"package.yaml"
+];
+const workspaceFiles = [
+	"pnpm-workspace.yaml",
+	"lerna.json",
+	"turbo.json",
+	"rush.json",
+	"deno.json",
+	"deno.jsonc"
+];
+const FileCache = /* @__PURE__ */ new Map();
+async function readPackageJSON(id, options = {}) {
+	const resolvedPath = await resolvePackageJSON(id, options);
+	const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+	if (options.cache && cache.has(resolvedPath)) return cache.get(resolvedPath);
+	const blob = await node_fs.promises.readFile(resolvedPath, "utf8");
+	let parsed;
+	try {
+		parsed = require_confbox_DnMsyigM.x(blob);
+	} catch {
+		parsed = require_confbox_DnMsyigM.h(blob);
+	}
+	cache.set(resolvedPath, parsed);
+	return parsed;
+}
+async function resolvePackageJSON(id = process.cwd(), options = {}) {
+	return findNearestFile("package.json", {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
+}
+const workspaceTests = {
+	workspaceFile: (opts) => findFile(workspaceFiles, opts).then((r) => require_pathe_M_eThtNZ.dirname(r)),
+	gitConfig: (opts) => findFile(".git/config", opts).then((r) => require_pathe_M_eThtNZ.resolve(r, "../..")),
+	lockFile: (opts) => findFile(lockFiles, opts).then((r) => require_pathe_M_eThtNZ.dirname(r)),
+	packageJson: (opts) => findFile(packageFiles, opts).then((r) => require_pathe_M_eThtNZ.dirname(r))
+};
+async function findWorkspaceDir(id = process.cwd(), options = {}) {
+	const startingFrom = _resolvePath(id, options);
+	const tests = options.tests || [
+		"workspaceFile",
+		"gitConfig",
+		"lockFile",
+		"packageJson"
+	];
+	for (const testName of tests) {
+		const test = workspaceTests[testName];
+		if (options[testName] === false || !test) continue;
+		const direction = options[testName] || (testName === "gitConfig" ? "closest" : "furthest");
+		const detected = await test({
+			...options,
+			startingFrom,
+			reverse: direction === "furthest"
+		}).catch(() => {});
+		if (detected) return detected;
+	}
+	throw new Error(`Cannot detect workspace root from ${id}`);
+}
+
+//#endregion
+exports.findWorkspaceDir = findWorkspaceDir;
+exports.readPackageJSON = readPackageJSON;

package/dist/node_modules/.pnpm/pkg-types@2.3.0/node_modules/pkg-types/dist/index.mjs

@@ -0,0 +1,125 @@
+import { dirname, isAbsolute, join, normalize, resolve } from "../../../../pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs";
+import { resolveModulePath } from "../../../../exsolve@1.0.8/node_modules/exsolve/dist/index.mjs";
+import { h, x } from "../../../../confbox@0.2.2/node_modules/confbox/dist/shared/confbox.DnMsyigM.mjs";
+import { promises, statSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+//#region ../../node_modules/.pnpm/pkg-types@2.3.0/node_modules/pkg-types/dist/index.mjs
+const defaultFindOptions = {
+	startingFrom: ".",
+	rootPattern: /^node_modules$/,
+	reverse: false,
+	test: (filePath) => {
+		try {
+			if (statSync(filePath).isFile()) return true;
+		} catch {}
+	}
+};
+async function findFile(filename, _options = {}) {
+	const filenames = Array.isArray(filename) ? filename : [filename];
+	const options = {
+		...defaultFindOptions,
+		..._options
+	};
+	const basePath = resolve(options.startingFrom);
+	const leadingSlash = basePath[0] === "/";
+	const segments = basePath.split("/").filter(Boolean);
+	if (filenames.includes(segments.at(-1)) && await options.test(basePath)) return basePath;
+	if (leadingSlash) segments[0] = "/" + segments[0];
+	let root = segments.findIndex((r) => r.match(options.rootPattern));
+	if (root === -1) root = 0;
+	if (options.reverse) for (let index = root + 1; index <= segments.length; index++) for (const filename2 of filenames) {
+		const filePath = join(...segments.slice(0, index), filename2);
+		if (await options.test(filePath)) return filePath;
+	}
+	else for (let index = segments.length; index > root; index--) for (const filename2 of filenames) {
+		const filePath = join(...segments.slice(0, index), filename2);
+		if (await options.test(filePath)) return filePath;
+	}
+	throw new Error(`Cannot find matching ${filename} in ${options.startingFrom} or parent directories`);
+}
+function findNearestFile(filename, options = {}) {
+	return findFile(filename, options);
+}
+function _resolvePath(id, opts = {}) {
+	if (id instanceof URL || id.startsWith("file://")) return normalize(fileURLToPath(id));
+	if (isAbsolute(id)) return normalize(id);
+	return resolveModulePath(id, {
+		...opts,
+		from: opts.from || opts.parent || opts.url
+	});
+}
+const lockFiles = [
+	"yarn.lock",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"npm-shrinkwrap.json",
+	"bun.lockb",
+	"bun.lock",
+	"deno.lock"
+];
+const packageFiles = [
+	"package.json",
+	"package.json5",
+	"package.yaml"
+];
+const workspaceFiles = [
+	"pnpm-workspace.yaml",
+	"lerna.json",
+	"turbo.json",
+	"rush.json",
+	"deno.json",
+	"deno.jsonc"
+];
+const FileCache = /* @__PURE__ */ new Map();
+async function readPackageJSON(id, options = {}) {
+	const resolvedPath = await resolvePackageJSON(id, options);
+	const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
+	if (options.cache && cache.has(resolvedPath)) return cache.get(resolvedPath);
+	const blob = await promises.readFile(resolvedPath, "utf8");
+	let parsed;
+	try {
+		parsed = x(blob);
+	} catch {
+		parsed = h(blob);
+	}
+	cache.set(resolvedPath, parsed);
+	return parsed;
+}
+async function resolvePackageJSON(id = process.cwd(), options = {}) {
+	return findNearestFile("package.json", {
+		...options,
+		startingFrom: _resolvePath(id, options)
+	});
+}
+const workspaceTests = {
+	workspaceFile: (opts) => findFile(workspaceFiles, opts).then((r) => dirname(r)),
+	gitConfig: (opts) => findFile(".git/config", opts).then((r) => resolve(r, "../..")),
+	lockFile: (opts) => findFile(lockFiles, opts).then((r) => dirname(r)),
+	packageJson: (opts) => findFile(packageFiles, opts).then((r) => dirname(r))
+};
+async function findWorkspaceDir(id = process.cwd(), options = {}) {
+	const startingFrom = _resolvePath(id, options);
+	const tests = options.tests || [
+		"workspaceFile",
+		"gitConfig",
+		"lockFile",
+		"packageJson"
+	];
+	for (const testName of tests) {
+		const test = workspaceTests[testName];
+		if (options[testName] === false || !test) continue;
+		const direction = options[testName] || (testName === "gitConfig" ? "closest" : "furthest");
+		const detected = await test({
+			...options,
+			startingFrom,
+			reverse: direction === "furthest"
+		}).catch(() => {});
+		if (detected) return detected;
+	}
+	throw new Error(`Cannot detect workspace root from ${id}`);
+}
+
+//#endregion
+export { findWorkspaceDir, readPackageJSON };

package/dist/node_modules/.pnpm/rc9@2.1.2/node_modules/rc9/dist/index.cjs

@@ -0,0 +1,138 @@
+const require_rolldown_runtime = require('../../../../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../../destr@2.0.5/node_modules/destr/dist/index.cjs');
+require('../../../../defu@6.1.4/node_modules/defu/dist/defu.cjs');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_os = require("node:os");
+
+//#region ../../node_modules/.pnpm/rc9@2.1.2/node_modules/rc9/dist/index.mjs
+function isBuffer(obj) {
+	return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+}
+function keyIdentity(key) {
+	return key;
+}
+function flatten(target, opts) {
+	opts = opts || {};
+	const delimiter = opts.delimiter || ".";
+	const maxDepth = opts.maxDepth;
+	const transformKey = opts.transformKey || keyIdentity;
+	const output = {};
+	function step(object, prev, currentDepth) {
+		currentDepth = currentDepth || 1;
+		Object.keys(object).forEach(function(key) {
+			const value = object[key];
+			const isarray = opts.safe && Array.isArray(value);
+			const type = Object.prototype.toString.call(value);
+			const isbuffer = isBuffer(value);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+			const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+			if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) return step(value, newKey, currentDepth + 1);
+			output[newKey] = value;
+		});
+	}
+	step(target);
+	return output;
+}
+function unflatten(target, opts) {
+	opts = opts || {};
+	const delimiter = opts.delimiter || ".";
+	const overwrite = opts.overwrite || false;
+	const transformKey = opts.transformKey || keyIdentity;
+	const result = {};
+	if (isBuffer(target) || Object.prototype.toString.call(target) !== "[object Object]") return target;
+	function getkey(key) {
+		const parsedKey = Number(key);
+		return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+	}
+	function addKeys(keyPrefix, recipient, target$1) {
+		return Object.keys(target$1).reduce(function(result$1, key) {
+			result$1[keyPrefix + delimiter + key] = target$1[key];
+			return result$1;
+		}, recipient);
+	}
+	function isEmpty(val) {
+		const type = Object.prototype.toString.call(val);
+		const isArray = type === "[object Array]";
+		const isObject = type === "[object Object]";
+		if (!val) return true;
+		else if (isArray) return !val.length;
+		else if (isObject) return !Object.keys(val).length;
+	}
+	target = Object.keys(target).reduce(function(result$1, key) {
+		const type = Object.prototype.toString.call(target[key]);
+		if (!(type === "[object Object]" || type === "[object Array]") || isEmpty(target[key])) {
+			result$1[key] = target[key];
+			return result$1;
+		} else return addKeys(key, result$1, flatten(target[key], opts));
+	}, {});
+	Object.keys(target).forEach(function(key) {
+		const split = key.split(delimiter).map(transformKey);
+		let key1 = getkey(split.shift());
+		let key2 = getkey(split[0]);
+		let recipient = result;
+		while (key2 !== void 0) {
+			if (key1 === "__proto__") return;
+			const type = Object.prototype.toString.call(recipient[key1]);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+			if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") return;
+			if (overwrite && !isobject || !overwrite && recipient[key1] == null) recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+			recipient = recipient[key1];
+			if (split.length > 0) {
+				key1 = getkey(split.shift());
+				key2 = getkey(split[0]);
+			}
+		}
+		recipient[key1] = unflatten(target[key], opts);
+	});
+	return result;
+}
+const RE_KEY_VAL = /^\s*([^\s=]+)\s*=\s*(.*)?\s*$/;
+const RE_LINES = /\n|\r|\r\n/;
+const defaults = {
+	name: ".conf",
+	dir: process.cwd(),
+	flat: false
+};
+function withDefaults(options) {
+	if (typeof options === "string") options = { name: options };
+	return {
+		...defaults,
+		...options
+	};
+}
+function parse(contents, options = {}) {
+	const config = {};
+	const lines = contents.split(RE_LINES);
+	for (const line of lines) {
+		const match = line.match(RE_KEY_VAL);
+		if (!match) continue;
+		const key = match[1];
+		if (!key || key === "__proto__" || key === "constructor") continue;
+		const value = require_index.destr((match[2] || "").trim());
+		if (key.endsWith("[]")) {
+			const nkey = key.slice(0, Math.max(0, key.length - 2));
+			config[nkey] = (config[nkey] || []).concat(value);
+			continue;
+		}
+		config[key] = value;
+	}
+	return options.flat ? config : unflatten(config, { overwrite: true });
+}
+function parseFile(path, options) {
+	if (!(0, node_fs.existsSync)(path)) return {};
+	return parse((0, node_fs.readFileSync)(path, "utf8"), options);
+}
+function read(options) {
+	options = withDefaults(options);
+	return parseFile((0, node_path.resolve)(options.dir, options.name), options);
+}
+function readUser(options) {
+	options = withDefaults(options);
+	options.dir = process.env.XDG_CONFIG_HOME || (0, node_os.homedir)();
+	return read(options);
+}
+
+//#endregion
+exports.read = read;
+exports.readUser = readUser;

package/dist/node_modules/.pnpm/rc9@2.1.2/node_modules/rc9/dist/index.mjs

@@ -0,0 +1,136 @@
+import { destr } from "../../../../destr@2.0.5/node_modules/destr/dist/index.mjs";
+import "../../../../defu@6.1.4/node_modules/defu/dist/defu.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+
+//#region ../../node_modules/.pnpm/rc9@2.1.2/node_modules/rc9/dist/index.mjs
+function isBuffer(obj) {
+	return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+}
+function keyIdentity(key) {
+	return key;
+}
+function flatten(target, opts) {
+	opts = opts || {};
+	const delimiter$1 = opts.delimiter || ".";
+	const maxDepth = opts.maxDepth;
+	const transformKey = opts.transformKey || keyIdentity;
+	const output = {};
+	function step(object, prev, currentDepth) {
+		currentDepth = currentDepth || 1;
+		Object.keys(object).forEach(function(key) {
+			const value = object[key];
+			const isarray = opts.safe && Array.isArray(value);
+			const type = Object.prototype.toString.call(value);
+			const isbuffer = isBuffer(value);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+			const newKey = prev ? prev + delimiter$1 + transformKey(key) : transformKey(key);
+			if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) return step(value, newKey, currentDepth + 1);
+			output[newKey] = value;
+		});
+	}
+	step(target);
+	return output;
+}
+function unflatten(target, opts) {
+	opts = opts || {};
+	const delimiter$1 = opts.delimiter || ".";
+	const overwrite = opts.overwrite || false;
+	const transformKey = opts.transformKey || keyIdentity;
+	const result = {};
+	if (isBuffer(target) || Object.prototype.toString.call(target) !== "[object Object]") return target;
+	function getkey(key) {
+		const parsedKey = Number(key);
+		return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+	}
+	function addKeys(keyPrefix, recipient, target$1) {
+		return Object.keys(target$1).reduce(function(result$1, key) {
+			result$1[keyPrefix + delimiter$1 + key] = target$1[key];
+			return result$1;
+		}, recipient);
+	}
+	function isEmpty(val) {
+		const type = Object.prototype.toString.call(val);
+		const isArray = type === "[object Array]";
+		const isObject = type === "[object Object]";
+		if (!val) return true;
+		else if (isArray) return !val.length;
+		else if (isObject) return !Object.keys(val).length;
+	}
+	target = Object.keys(target).reduce(function(result$1, key) {
+		const type = Object.prototype.toString.call(target[key]);
+		if (!(type === "[object Object]" || type === "[object Array]") || isEmpty(target[key])) {
+			result$1[key] = target[key];
+			return result$1;
+		} else return addKeys(key, result$1, flatten(target[key], opts));
+	}, {});
+	Object.keys(target).forEach(function(key) {
+		const split = key.split(delimiter$1).map(transformKey);
+		let key1 = getkey(split.shift());
+		let key2 = getkey(split[0]);
+		let recipient = result;
+		while (key2 !== void 0) {
+			if (key1 === "__proto__") return;
+			const type = Object.prototype.toString.call(recipient[key1]);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+			if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") return;
+			if (overwrite && !isobject || !overwrite && recipient[key1] == null) recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+			recipient = recipient[key1];
+			if (split.length > 0) {
+				key1 = getkey(split.shift());
+				key2 = getkey(split[0]);
+			}
+		}
+		recipient[key1] = unflatten(target[key], opts);
+	});
+	return result;
+}
+const RE_KEY_VAL = /^\s*([^\s=]+)\s*=\s*(.*)?\s*$/;
+const RE_LINES = /\n|\r|\r\n/;
+const defaults = {
+	name: ".conf",
+	dir: process.cwd(),
+	flat: false
+};
+function withDefaults(options) {
+	if (typeof options === "string") options = { name: options };
+	return {
+		...defaults,
+		...options
+	};
+}
+function parse(contents, options = {}) {
+	const config = {};
+	const lines = contents.split(RE_LINES);
+	for (const line of lines) {
+		const match = line.match(RE_KEY_VAL);
+		if (!match) continue;
+		const key = match[1];
+		if (!key || key === "__proto__" || key === "constructor") continue;
+		const value = destr((match[2] || "").trim());
+		if (key.endsWith("[]")) {
+			const nkey = key.slice(0, Math.max(0, key.length - 2));
+			config[nkey] = (config[nkey] || []).concat(value);
+			continue;
+		}
+		config[key] = value;
+	}
+	return options.flat ? config : unflatten(config, { overwrite: true });
+}
+function parseFile(path$1, options) {
+	if (!existsSync(path$1)) return {};
+	return parse(readFileSync(path$1, "utf8"), options);
+}
+function read(options) {
+	options = withDefaults(options);
+	return parseFile(resolve(options.dir, options.name), options);
+}
+function readUser(options) {
+	options = withDefaults(options);
+	options.dir = process.env.XDG_CONFIG_HOME || homedir();
+	return read(options);
+}
+
+//#endregion
+export { read, readUser };