@gjsify/utils 0.0.2

package/lib/cjs/cancel-handler.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cancel_handler_exports = {};
+__export(cancel_handler_exports, {
+  closeCancelHandler: () => closeCancelHandler,
+  createCancelHandler: () => createCancelHandler,
+  getCancelHandler: () => getCancelHandler
+});
+module.exports = __toCommonJS(cancel_handler_exports);
+let nextRid = 1;
+const resources = {};
+const createCancelHandler = () => {
+  const rid = nextRid++;
+  const cancelHandler = {};
+  imports.signals.addSignalMethods(cancelHandler);
+  resources[rid] = cancelHandler;
+  return rid;
+};
+const closeCancelHandler = (rid) => {
+  const cancelHandler = getCancelHandler(rid);
+  cancelHandler?.emit("close");
+  delete resources[rid];
+};
+const getCancelHandler = (rid) => {
+  return resources[rid];
+};

package/lib/cjs/cli.js

@@ -0,0 +1,40 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cli_exports = {};
+__export(cli_exports, {
+  cli: () => cli
+});
+module.exports = __toCommonJS(cli_exports);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+const byteArray = imports.byteArray;
+const cli = (commandLine) => {
+  const [res, out, err, status] = import_glib_2.default.spawn_command_line_sync(commandLine);
+  if (err.byteLength)
+    throw new Error(byteArray.toString(err));
+  return byteArray.toString(out);
+};

package/lib/cjs/error.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_exports = {};
+__export(error_exports, {
+  initErrorV8Methods: () => initErrorV8Methods
+});
+module.exports = __toCommonJS(error_exports);
+const initErrorV8Methods = (ErrorConstructor) => {
+  if (!Error.captureStackTrace) {
+    Error.captureStackTrace = function(targetObject, constructorOpt) {
+      const container = new Error();
+      const target = constructorOpt || targetObject;
+      Object.defineProperty(target, "stack", {
+        configurable: true,
+        get: function getStack() {
+          var stack = container.stack;
+          Object.defineProperty(this, "stack", {
+            value: stack
+          });
+          return stack;
+        }
+      });
+    };
+  }
+};

package/lib/cjs/file.js

@@ -0,0 +1,42 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_exports = {};
+__export(file_exports, {
+  readJSON: () => readJSON
+});
+module.exports = __toCommonJS(file_exports);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+const byteArray = imports.byteArray;
+const readJSON = (path) => {
+  const [ok, contents] = import_glib_2.default.file_get_contents(path);
+  if (ok) {
+    const map = JSON.parse(byteArray.toString(contents));
+    return map;
+  }
+  throw new Error(`Error on require "${path}"`);
+};

package/lib/cjs/fs.js

@@ -0,0 +1,50 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fs_exports = {};
+__export(fs_exports, {
+  existsFD: () => existsFD,
+  existsSync: () => existsSync
+});
+module.exports = __toCommonJS(fs_exports);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+const existsFD = (fd) => {
+  try {
+    let stream = import_gio_2.default.UnixInputStream.new(fd, false);
+    stream.close(null);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+function existsSync(path) {
+  if (typeof path !== "string" || path === "") {
+    return false;
+  }
+  const file = import_gio_2.default.File.new_for_path(path);
+  return file.query_exists(null);
+}

package/lib/cjs/index.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./types/index.js"), module.exports);
+__reExport(src_exports, require("./cancel-handler.js"), module.exports);
+__reExport(src_exports, require("./cli.js"), module.exports);
+__reExport(src_exports, require("./error.js"), module.exports);
+__reExport(src_exports, require("./file.js"), module.exports);
+__reExport(src_exports, require("./fs.js"), module.exports);
+__reExport(src_exports, require("./log.js"), module.exports);
+__reExport(src_exports, require("./message.js"), module.exports);
+__reExport(src_exports, require("./os.js"), module.exports);
+__reExport(src_exports, require("./path.js"), module.exports);
+__reExport(src_exports, require("./process.js"), module.exports);
+__reExport(src_exports, require("./system.js"), module.exports);
+__reExport(src_exports, require("./tty.js"), module.exports);
+__reExport(src_exports, require("./version.js"), module.exports);

package/lib/cjs/log.js

@@ -0,0 +1,188 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+__export(log_exports, {
+  LogSignals: () => LogSignals,
+  extractErrorData: () => extractErrorData,
+  logLevelToString: () => logLevelToString,
+  logSignals: () => logSignals,
+  parseStackTrace: () => parseStackTrace
+});
+module.exports = __toCommonJS(log_exports);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+const logLevelToString = (logLevel) => {
+  switch (logLevel) {
+    case import_glib_2.default.LogLevelFlags.FLAG_FATAL:
+      return "FLAG_FATAL";
+    case import_glib_2.default.LogLevelFlags.FLAG_RECURSION:
+      return "FLAG_RECURSION";
+    case import_glib_2.default.LogLevelFlags.LEVEL_CRITICAL:
+      return "LEVEL_CRITICAL";
+    case import_glib_2.default.LogLevelFlags.LEVEL_DEBUG:
+      return "LEVEL_DEBUG";
+    case import_glib_2.default.LogLevelFlags.LEVEL_ERROR:
+      return "LEVEL_ERROR";
+    case import_glib_2.default.LogLevelFlags.LEVEL_INFO:
+      return "LEVEL_INFO";
+    case import_glib_2.default.LogLevelFlags.LEVEL_MASK:
+      return "LEVEL_MASK";
+    case import_glib_2.default.LogLevelFlags.LEVEL_MESSAGE:
+      return "LEVEL_MESSAGE";
+    case import_glib_2.default.LogLevelFlags.LEVEL_WARNING:
+      return "LEVEL_WARNING";
+    default:
+      return "UNKNOWN";
+  }
+};
+const STACK_TRACE_REGEX = /^.*@(.*):(\d+):(\d+)/;
+const parseStackTrace = (stackTraceLine) => {
+  const match = stackTraceLine.match(STACK_TRACE_REGEX);
+  if (match) {
+    const [, fileName, lineNumber, columnNumber] = match;
+    return { fileName, lineNumber: Number(lineNumber), columnNumber: Number(columnNumber), line: stackTraceLine };
+  }
+  return null;
+};
+const getStackTraceStartLineIndex = (lines) => {
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (STACK_TRACE_REGEX.test(line)) {
+      return i;
+    }
+  }
+  return -1;
+};
+const extractErrorData = (errorMessage) => {
+  const lines = errorMessage.split("\n");
+  for (let line of lines) {
+    line = line.trim();
+  }
+  const endOfErrorType = lines[0].indexOf(": ");
+  let errorType = "Error";
+  if (endOfErrorType > 0) {
+    errorType = lines[0].slice(0, endOfErrorType);
+    if (globalThis[errorType]) {
+      lines[0] = lines[0].slice(endOfErrorType + 2);
+    } else {
+      errorType = "Error";
+    }
+  }
+  let stackTraceLineIndex = getStackTraceStartLineIndex(lines);
+  const message = lines.slice(0, stackTraceLineIndex).join("\n");
+  const stackTraceLines = lines.slice(stackTraceLineIndex);
+  const frames = [];
+  for (const stackTraceLine of stackTraceLines) {
+    const frame = parseStackTrace(stackTraceLine);
+    if (frame) {
+      frames.push(frame);
+    }
+  }
+  return {
+    errorType,
+    message,
+    frames,
+    stackTraceLines
+  };
+};
+const reconstructErrorFromMessage = (errorMessage) => {
+  const { errorType, frames, message, stackTraceLines } = extractErrorData(errorMessage);
+  const ErrorType = globalThis[errorType];
+  const error = new ErrorType();
+  error.message = message;
+  error.stack = stackTraceLines.join("\n");
+  return {
+    error,
+    errorType,
+    frames,
+    message,
+    stackTraceLines
+  };
+};
+class LogSignals {
+  static instance;
+  /** This is a singleton because log_set_writer_func may only be called once */
+  constructor() {
+    this.initHandler();
+  }
+  static getSingleton() {
+    if (LogSignals.instance) {
+      return LogSignals.instance;
+    }
+    LogSignals.instance = new LogSignals();
+    return LogSignals.instance;
+  }
+  initHandler() {
+    import_glib_2.default.log_set_writer_func((level, fields) => {
+      const decoder = new TextDecoder("utf-8");
+      const message = decoder.decode(fields?.MESSAGE);
+      const priority = Number(decoder.decode(fields?.PRIORITY));
+      const domain = decoder.decode(fields?.GLIB_DOMAIN);
+      const data = {
+        message,
+        priority,
+        domain
+      };
+      if (!this.handler(level, data)) {
+        level |= import_glib_2.default.LogLevelFlags.FLAG_RECURSION;
+        import_glib_2.default.log_default_handler(domain, level, message, null);
+      }
+      return import_glib_2.default.LogWriterOutput.HANDLED;
+    });
+  }
+  /**
+   * A log handler to emit `unhandledRejection` and `uncaughtException` events
+   * @param level The log level
+   * @param data The structured log data
+   * @returns `true` to catch the log or `false` to output the error to the console as usual
+    */
+  handler(level, structuredData) {
+    if (level === import_glib_2.default.LogLevelFlags.LEVEL_WARNING && structuredData.domain === "Gjs" && structuredData.message.startsWith("Unhandled promise rejection")) {
+      try {
+        const errorData = reconstructErrorFromMessage(structuredData.message);
+        const fakePromise = new Promise(() => {
+        });
+        logSignals.emit("unhandledRejection", structuredData, {
+          reason: errorData.error,
+          promise: fakePromise,
+          errorType: errorData.errorType,
+          frames: errorData.frames,
+          message: errorData.message,
+          stackTraceLines: errorData.stackTraceLines
+        });
+      } catch (error) {
+        printerr(error);
+      }
+    } else if (level === import_glib_2.default.LogLevelFlags.LEVEL_CRITICAL) {
+      const errorData = reconstructErrorFromMessage(structuredData.message);
+      logSignals.emit("uncaughtException", structuredData, errorData);
+    }
+    return false;
+  }
+}
+imports.signals.addSignalMethods(LogSignals.prototype);
+const logSignals = LogSignals.getSingleton();

package/lib/cjs/message.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var message_exports = {};
+__export(message_exports, {
+  notImplemented: () => notImplemented,
+  warnNotImplemented: () => warnNotImplemented
+});
+module.exports = __toCommonJS(message_exports);
+const notImplemented = (msg) => {
+  const message = msg ? `Not implemented: ${msg}` : "Not implemented";
+  throw new Error(message);
+};
+const warnNotImplemented = (msg) => {
+  const message = msg ? `Not implemented: ${msg}` : "Not implemented";
+  console.warn(message);
+  return message;
+};

package/lib/cjs/os.js

@@ -0,0 +1,110 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var os_exports = {};
+__export(os_exports, {
+  getArch: () => getArch,
+  getEnv: () => getEnv,
+  getOs: () => getOs,
+  getTarget: () => getTarget,
+  getUserInfo: () => getUserInfo,
+  getVendor: () => getVendor
+});
+module.exports = __toCommonJS(os_exports);
+var import_cli = require("./cli.js");
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+let _arch = "";
+let _os = "";
+let _target = "";
+const userInfo = {};
+const getArch = () => {
+  if (_arch) {
+    return _arch;
+  }
+  _arch = (0, import_cli.cli)("uname -m").trim();
+  return _arch;
+};
+const getOs = () => {
+  if (_os) {
+    return _os;
+  }
+  const os = (0, import_cli.cli)("uname -o").trim();
+  if (/\bDarwin\b/i.test(os)) {
+    _os = "darwin";
+    return _os;
+  }
+  if (/\bLinux\b/i.test(os)) {
+    _os = "linux";
+    return _os;
+  }
+  _os = "win32";
+  return _os;
+};
+const getVendor = () => "gjsify";
+const getEnv = () => "gnu";
+const getTarget = () => {
+  if (_target) {
+    return _target;
+  }
+  _target = `${getArch()}-${getVendor()}-${getOs()}-${getEnv()}`;
+  return _target;
+};
+const extractUserInfo = (passwd, username) => {
+  const lines = passwd.split("\n");
+  for (const line of lines) {
+    const parts = line.split(":");
+    if (parts[0] === username) {
+      return {
+        username: parts[0],
+        // password: parts[1],
+        userId: parseInt(parts[2], 10),
+        groupId: parseInt(parts[3], 10),
+        userInfo: parts[4],
+        homeDirectory: parts[5],
+        shell: parts[6]
+      };
+    }
+  }
+  return null;
+};
+const getUserInfo = (username) => {
+  const file = import_gio_2.default.File.new_for_path("/etc/passwd");
+  if (!username) {
+    username = import_glib_2.default.get_user_name();
+  }
+  if (userInfo[username]) {
+    return userInfo[username];
+  }
+  const [success, contents] = file.load_contents(null);
+  if (!success) {
+    throw new Error(`Failed to load ${file.get_path()}`);
+  }
+  const contentStr = new TextDecoder().decode(contents);
+  userInfo[username] = extractUserInfo(contentStr, username);
+  return userInfo[username];
+};

package/lib/cjs/path.js

@@ -0,0 +1,79 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var path_exports = {};
+__export(path_exports, {
+  getNodeModulesPath: () => getNodeModulesPath,
+  getPathSeparator: () => getPathSeparator,
+  getProgramDir: () => getProgramDir,
+  getProgramExe: () => getProgramExe,
+  resolve: () => resolve
+});
+module.exports = __toCommonJS(path_exports);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+const { File } = import_gio_2.default;
+const _getProgramDir = (programFile) => {
+  const info = programFile.query_info("standard::", import_gio_2.default.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+  if (info.get_is_symlink()) {
+    const symlinkFile = programFile.get_parent().resolve_relative_path(info.get_symlink_target());
+    return symlinkFile.get_parent();
+  } else {
+    return programFile.get_parent();
+  }
+};
+const resolve = (dir, ...filenames) => {
+  let file = File.new_for_path(dir);
+  for (const filename of filenames) {
+    file = file.resolve_relative_path(filename);
+  }
+  return file;
+};
+const getProgramExe = () => {
+  const currentDir = import_glib_2.default.get_current_dir();
+  return File.new_for_path(currentDir).resolve_relative_path(imports.system.programInvocationName);
+};
+const getProgramDir = () => {
+  return _getProgramDir(getProgramExe()).get_path();
+};
+const getPathSeparator = () => {
+  const currentDir = import_glib_2.default.get_current_dir();
+  return /^\//.test(currentDir) ? "/" : "\\";
+};
+const getNodeModulesPath = () => {
+  let dir = File.new_for_path(getProgramDir());
+  let found = false;
+  do {
+    dir = dir.resolve_relative_path("..");
+    const nodeModulesDir = dir.resolve_relative_path("node_modules");
+    found = nodeModulesDir.query_exists(null);
+    if (found) {
+      dir = nodeModulesDir;
+    }
+  } while (dir.has_parent(null) && !found);
+  return dir;
+};