@cjser/inquirer__external-editor 3.0.0-cjser.2

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2025 Simon Boudrias
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,159 @@
+# `@inquirer/external-editor`
+
+A Node.js module to edit a string with the user's preferred text editor using $VISUAL or $EDITOR.
+
+> [!NOTE]
+> This package is a replacement for the unmaintained `external-editor`. It includes security fixes.
+
+# Installation
+
+<table>
+<tr>
+  <th>npm</th>
+  <th>yarn</th>
+</tr>
+<tr>
+<td>
+
+```sh
+npm install @inquirer/external-editor
+```
+
+</td>
+<td>
+
+```sh
+yarn add @inquirer/external-editor
+```
+
+</td>
+</tr>
+</table>
+
+## Usage
+
+A simple example using the `edit` function
+
+```ts
+import { edit } from '@inquirer/external-editor';
+
+const data = edit('\n\n# Please write your text above');
+console.log(data);
+```
+
+Example relying on the class construct
+
+```ts
+import {
+  ExternalEditor,
+  CreateFileError,
+  ReadFileError,
+  RemoveFileError,
+  LaunchEditorError,
+} from '@inquirer/external-editor';
+
+try {
+  const editor = new ExternalEditor();
+  const text = editor.run(); // the text is also available in editor.text
+
+  if (editor.lastExitStatus !== 0) {
+    console.log('The editor exited with a non-zero code');
+  }
+
+  // Do things with the text
+  editor.cleanup();
+} catch (err) {
+  if (err instanceof CreateFileError) {
+    console.log('Failed to create the temporary file');
+  } else if (err instanceof ReadFileError) {
+    console.log('Failed to read the temporary file');
+  } else if (err instanceof LaunchEditorError) {
+    console.log('Failed to launch your editor');
+  } else if (err instanceof RemoveFileError) {
+    console.log('Failed to remove the temporary file');
+  } else {
+    throw err;
+  }
+}
+```
+
+#### API
+
+**Convenience Functions**
+
+- `edit(text, config)`
+  - `text` (string) _Optional_ Defaults to empty string
+  - `config` (Config) _Optional_ Options for temporary file creation
+  - **Returns** (string) The contents of the file
+  - Could throw `CreateFileError`, `ReadFileError`, or `LaunchEditorError`, or `RemoveFileError`
+- `editAsync(text, callback, config)`
+  - `text` (string) _Optional_ Defaults to empty string
+  - `callback` (function (error?, text?))
+    - `error` could be of type `CreateFileError`, `ReadFileError`, `LaunchEditorError`, or `RemoveFileError`
+    - `text` (string) The contents of the file
+  - `config` (Config) _Optional_ Options for temporary file creation
+
+**Errors**
+
+- `CreateFileError` Error thrown if the temporary file could not be created.
+- `ReadFileError` Error thrown if the temporary file could not be read.
+- `RemoveFileError` Error thrown if the temporary file could not be removed during cleanup.
+- `LaunchEditorError` Error thrown if the editor could not be launched.
+
+**External Editor Public Methods**
+
+- `new ExternalEditor(text, config)`
+  - `text` (string) _Optional_ Defaults to empty string
+  - `config` (Config) _Optional_ Options for temporary file creation
+  - Could throw `CreateFileError`
+- `run()` Launches the editor.
+  - **Returns** (string) The contents of the file
+  - Could throw `LaunchEditorError` or `ReadFileError`
+- `runAsync(callback)` Launches the editor in an async way
+  - `callback` (function (error?, text?))
+    - `error` could be of type `ReadFileError` or `LaunchEditorError`
+    - `text` (string) The contents of the file
+- `cleanup()` Removes the temporary file.
+  - Could throw `RemoveFileError`
+
+**External Editor Public Properties**
+
+- `text` (string) _readonly_ The text in the temporary file.
+- `editor.bin` (string) The editor determined from the environment.
+- `editor.args` (array) Default arguments for the bin
+- `tempFile` (string) Path to temporary file. Can be changed, but be careful as the temporary file probably already
+  exists and would need be removed manually.
+- `lastExitStatus` (number) The last exit code emitted from the editor.
+
+**Config Options**
+
+- `prefix` (string) _Optional_ A prefix for the file name.
+- `postfix` (string) _Optional_ A postfix for the file name. Useful if you want to provide an extension.
+- `mode` (number) _Optional_ Which mode to create the file with. e.g. 644
+- `dir` (string) _Optional_ Which path to store the file.
+
+## Why Synchronous?
+
+Everything is synchronous to make sure the editor has complete control of the stdin and stdout. Testing has shown
+async launching of the editor can lead to issues when using readline or other packages which try to read from stdin or
+write to stdout. Seeing as this will be used in an interactive CLI environment, I made the decision to force the package
+to be synchronous. If you know a reliable way to force all stdin and stdout to be limited only to the child_process,
+please submit a PR.
+
+If async is really needed, you can use `editAsync` or `runAsync`. If you are using readline or have anything else
+listening to the stdin or you write to stdout, you will most likely have problem, so make sure to remove any other
+listeners on stdin, stdout, or stderr.
+
+## Demo
+
+[![asciicast](https://asciinema.org/a/a1qh9lypbe65mj0ivfuoslz2s.png)](https://asciinema.org/a/a1qh9lypbe65mj0ivfuoslz2s)
+
+# License
+
+Copyright (c) 2025 Simon Boudrias (twitter: [@vaxilart](https://twitter.com/Vaxilart))<br/>
+Licensed under the MIT license.
+
+## cjser
+
+This package is a CommonJS-compatible build generated by cjser for projects that still need `require()` support. The source version matches the original npm package version, with a cjser prerelease suffix for this generated build.
+Original repository: https://github.com/SBoudrias/Inquirer.js

package/dist/errors/CreateFileError.d.ts

@@ -0,0 +1,10 @@
+/***
+ * Node External Editor
+ *
+ * Kevin Gravier <kevin@mrkmg.com>
+ * MIT 2018
+ */
+export declare class CreateFileError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
+}

package/dist/errors/CreateFileError.js

@@ -0,0 +1,13 @@
+/***
+ * Node External Editor
+ *
+ * Kevin Gravier <kevin@mrkmg.com>
+ * MIT 2018
+ */
+export class CreateFileError extends Error {
+    originalError;
+    constructor(originalError) {
+        super(`Failed to create temporary file. ${originalError.message}`);
+        this.originalError = originalError;
+    }
+}

package/dist/errors/LaunchEditorError.d.ts

@@ -0,0 +1,10 @@
+/***
+ * Node External Editor
+ *
+ * Kevin Gravier <kevin@mrkmg.com>
+ * MIT 2018
+ */
+export declare class LaunchEditorError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
+}

package/dist/errors/LaunchEditorError.js

@@ -0,0 +1,13 @@
+/***
+ * Node External Editor
+ *
+ * Kevin Gravier <kevin@mrkmg.com>
+ * MIT 2018
+ */
+export class LaunchEditorError extends Error {
+    originalError;
+    constructor(originalError) {
+        super(`Failed to launch editor. ${originalError.message}`);
+        this.originalError = originalError;
+    }
+}

package/dist/errors/ReadFileError.d.ts

@@ -0,0 +1,10 @@
+/***
+ * Node External Editor
+ *
+ * Kevin Gravier <kevin@mrkmg.com>
+ * MIT 2018
+ */
+export declare class ReadFileError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
+}

package/dist/errors/ReadFileError.js

@@ -0,0 +1,13 @@
+/***
+ * Node External Editor
+ *
+ * Kevin Gravier <kevin@mrkmg.com>
+ * MIT 2018
+ */
+export class ReadFileError extends Error {
+    originalError;
+    constructor(originalError) {
+        super(`Failed to read temporary file. ${originalError.message}`);
+        this.originalError = originalError;
+    }
+}

package/dist/errors/RemoveFileError.d.ts

@@ -0,0 +1,10 @@
+/***
+ * Node External Editor
+ *
+ * Kevin Gravier <kevin@mrkmg.com>
+ * MIT 2018
+ */
+export declare class RemoveFileError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
+}

package/dist/errors/RemoveFileError.js

@@ -0,0 +1,13 @@
+/***
+ * Node External Editor
+ *
+ * Kevin Gravier <kevin@mrkmg.com>
+ * MIT 2018
+ */
+export class RemoveFileError extends Error {
+    originalError;
+    constructor(originalError) {
+        super(`Failed to remove temporary file. ${originalError.message}`);
+        this.originalError = originalError;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+export declare class CreateFileError extends Error {
+    name: string;
+    originalError: unknown;
+    constructor(originalError: unknown);
+}
+export declare class LaunchEditorError extends Error {
+    name: string;
+    originalError: unknown;
+    constructor(originalError: unknown);
+}
+export declare class ReadFileError extends Error {
+    name: string;
+    originalError: unknown;
+    constructor(originalError: unknown);
+}
+export declare class RemoveFileError extends Error {
+    name: string;
+    originalError: unknown;
+    constructor(originalError: unknown);
+}

package/dist/errors.js

@@ -0,0 +1,32 @@
+export class CreateFileError extends Error {
+    name = 'CreateFileError';
+    originalError;
+    constructor(originalError) {
+        super(`Failed to create temporary file.${originalError instanceof Error ? ` ${originalError.message}` : ''}`, { cause: originalError });
+        this.originalError = originalError;
+    }
+}
+export class LaunchEditorError extends Error {
+    name = 'LaunchEditorError';
+    originalError;
+    constructor(originalError) {
+        super(`Failed to launch editor.${originalError instanceof Error ? ` ${originalError.message}` : ''}`, { cause: originalError });
+        this.originalError = originalError;
+    }
+}
+export class ReadFileError extends Error {
+    name = 'ReadFileError';
+    originalError;
+    constructor(originalError) {
+        super(`Failed to read temporary file.${originalError instanceof Error ? ` ${originalError.message}` : ''}`, { cause: originalError });
+        this.originalError = originalError;
+    }
+}
+export class RemoveFileError extends Error {
+    name = 'RemoveFileError';
+    originalError;
+    constructor(originalError) {
+        super(`Failed to remove temporary file.${originalError instanceof Error ? ` ${originalError.message}` : ''}`, { cause: originalError });
+        this.originalError = originalError;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { CreateFileError, LaunchEditorError, ReadFileError, RemoveFileError } from './errors.ts';
+import { type EditorParams } from './parse-editor-command.ts';
+type StringCallback = (err: Error | undefined, result: string | undefined) => void;
+export type FileOptions = {
+    prefix?: string;
+    postfix?: string;
+    mode?: number;
+    template?: string;
+    dir?: string;
+};
+/** @deprecated Use FileOptions */
+export type IFileOptions = FileOptions;
+export { CreateFileError, LaunchEditorError, ReadFileError, RemoveFileError };
+export declare function edit(text?: string, fileOptions?: FileOptions): string;
+type EditAsync = {
+    /** @deprecated Use editAsync(text, options) returning a Promise instead */
+    (text: string, callback: StringCallback, fileOptions?: FileOptions): Promise<string>;
+    (text?: string, fileOptions?: FileOptions): Promise<string>;
+};
+export declare const editAsync: EditAsync;
+export declare class ExternalEditor {
+    editor: EditorParams;
+    lastExitStatus: number;
+    private text;
+    private tempFile;
+    private fileOptions;
+    constructor(text?: string, fileOptions?: FileOptions);
+    run(): string;
+    runAsync(callback?: StringCallback): Promise<string>;
+    private cleanup;
+    private createTempFile;
+    private readTemporaryFile;
+}

package/dist/index.js

@@ -0,0 +1,133 @@
+import { detect } from 'chardet';
+import { spawn, spawnSync } from 'node:child_process';
+import { readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { randomUUID } from 'node:crypto';
+import iconv from 'iconv-lite';
+import { CreateFileError, LaunchEditorError, ReadFileError, RemoveFileError, } from "./errors.js";
+import { parseEditorCommand } from "./parse-editor-command.js";
+export { CreateFileError, LaunchEditorError, ReadFileError, RemoveFileError };
+export function edit(text = '', fileOptions) {
+    return new ExternalEditor(text, fileOptions).run();
+}
+export const editAsync = (text, callbackOrOptions, fileOptions) => {
+    const callback = typeof callbackOrOptions === 'function' ? callbackOrOptions : undefined;
+    const options = typeof callbackOrOptions === 'function' ? fileOptions : callbackOrOptions;
+    return new ExternalEditor(text, options).runAsync(callback);
+};
+function sanitizeAffix(affix) {
+    if (!affix)
+        return '';
+    return affix.replace(/[^a-zA-Z0-9_.-]/g, '_');
+}
+export class ExternalEditor {
+    editor;
+    lastExitStatus = 0;
+    text = '';
+    tempFile = '';
+    fileOptions = {};
+    constructor(text = '', fileOptions = {}) {
+        this.text = text;
+        this.fileOptions = fileOptions;
+        this.editor = parseEditorCommand(process.env['VISUAL'] ??
+            process.env['EDITOR'] ??
+            (process.platform.startsWith('win') ? 'notepad' : 'vim'));
+    }
+    run() {
+        this.createTempFile();
+        try {
+            try {
+                const editorProcess = spawnSync(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: 'inherit' });
+                this.lastExitStatus = editorProcess.status ?? 0;
+            }
+            catch (launchError) {
+                throw new LaunchEditorError(launchError);
+            }
+            this.readTemporaryFile();
+            return this.text;
+        }
+        finally {
+            this.cleanup();
+        }
+    }
+    runAsync(callback) {
+        this.createTempFile();
+        const promise = new Promise((resolve, reject) => {
+            try {
+                const editorProcess = spawn(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: 'inherit' });
+                editorProcess.on('exit', (code) => {
+                    this.lastExitStatus = code;
+                    resolve();
+                });
+            }
+            catch (launchError) {
+                reject(new LaunchEditorError(launchError));
+            }
+        })
+            .then(() => {
+            this.readTemporaryFile();
+            return this.text;
+        })
+            .finally(() => {
+            this.cleanup();
+        });
+        if (callback) {
+            promise.then((text) => callback(undefined, text), (err) => callback(err instanceof Error ? err : new Error(String(err)), undefined));
+        }
+        return promise;
+    }
+    cleanup() {
+        if (!this.tempFile)
+            return;
+        try {
+            unlinkSync(this.tempFile);
+            this.tempFile = '';
+        }
+        catch (removeFileError) {
+            throw new RemoveFileError(removeFileError);
+        }
+    }
+    createTempFile() {
+        try {
+            const baseDir = this.fileOptions.dir ?? os.tmpdir();
+            const id = randomUUID();
+            const prefix = sanitizeAffix(this.fileOptions.prefix);
+            const postfix = sanitizeAffix(this.fileOptions.postfix);
+            const filename = `${prefix}${id}${postfix}`;
+            const candidate = path.resolve(baseDir, filename);
+            const baseResolved = path.resolve(baseDir) + path.sep;
+            if (!candidate.startsWith(baseResolved)) {
+                throw new Error('Resolved temporary file escaped the base directory');
+            }
+            this.tempFile = candidate;
+            const opt = { encoding: 'utf8', flag: 'wx' };
+            if (Object.prototype.hasOwnProperty.call(this.fileOptions, 'mode')) {
+                opt.mode = this.fileOptions.mode;
+            }
+            writeFileSync(this.tempFile, this.text, opt);
+        }
+        catch (createFileError) {
+            throw new CreateFileError(createFileError);
+        }
+    }
+    readTemporaryFile() {
+        try {
+            const tempFileBuffer = readFileSync(this.tempFile);
+            if (tempFileBuffer.length === 0) {
+                this.text = '';
+            }
+            else {
+                let encoding = detect(tempFileBuffer) ?? 'utf8';
+                if (!iconv.encodingExists(encoding)) {
+                    // Probably a bad idea, but will at least prevent crashing
+                    encoding = 'utf8';
+                }
+                this.text = iconv.decode(tempFileBuffer, encoding);
+            }
+        }
+        catch (readFileError) {
+            throw new ReadFileError(readFileError);
+        }
+    }
+}

package/dist/parse-editor-command.d.ts

@@ -0,0 +1,5 @@
+export type EditorParams = {
+    args: string[];
+    bin: string;
+};
+export declare function parseEditorCommand(editor: string): EditorParams;

package/dist/parse-editor-command.js

@@ -0,0 +1,28 @@
+export function parseEditorCommand(editor) {
+    let bin;
+    let rest;
+    if (editor.startsWith('"')) {
+        const closeQuote = editor.indexOf('"', 1);
+        if (closeQuote === -1) {
+            // Unmatched quote — treat the whole string as the binary
+            bin = editor.slice(1);
+            rest = '';
+        }
+        else {
+            bin = editor.substring(1, closeQuote);
+            rest = editor.substring(closeQuote + 1).trim();
+        }
+    }
+    else {
+        const firstSpace = editor.indexOf(' ');
+        if (firstSpace === -1) {
+            bin = editor;
+            rest = '';
+        }
+        else {
+            bin = editor.substring(0, firstSpace);
+            rest = editor.substring(firstSpace + 1).trim();
+        }
+    }
+    return { bin, args: rest ? rest.split(/\s+/) : [] };
+}

package/dist-cjser/index.cjs

@@ -0,0 +1,230 @@
+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);
+
+// packages/@cjser/inquirer__external-editor.tmp-26-1778156888407/dist/index.js
+var index_exports = {};
+__export(index_exports, {
+  CreateFileError: () => CreateFileError,
+  ExternalEditor: () => ExternalEditor,
+  LaunchEditorError: () => LaunchEditorError,
+  ReadFileError: () => ReadFileError,
+  RemoveFileError: () => RemoveFileError,
+  edit: () => edit,
+  editAsync: () => editAsync
+});
+module.exports = __toCommonJS(index_exports);
+var import_chardet = require("chardet");
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_crypto = require("node:crypto");
+var import_iconv_lite = __toESM(require("iconv-lite"), 1);
+
+// packages/@cjser/inquirer__external-editor.tmp-26-1778156888407/dist/errors.js
+var CreateFileError = class extends Error {
+  name = "CreateFileError";
+  originalError;
+  constructor(originalError) {
+    super(`Failed to create temporary file.${originalError instanceof Error ? ` ${originalError.message}` : ""}`, { cause: originalError });
+    this.originalError = originalError;
+  }
+};
+var LaunchEditorError = class extends Error {
+  name = "LaunchEditorError";
+  originalError;
+  constructor(originalError) {
+    super(`Failed to launch editor.${originalError instanceof Error ? ` ${originalError.message}` : ""}`, { cause: originalError });
+    this.originalError = originalError;
+  }
+};
+var ReadFileError = class extends Error {
+  name = "ReadFileError";
+  originalError;
+  constructor(originalError) {
+    super(`Failed to read temporary file.${originalError instanceof Error ? ` ${originalError.message}` : ""}`, { cause: originalError });
+    this.originalError = originalError;
+  }
+};
+var RemoveFileError = class extends Error {
+  name = "RemoveFileError";
+  originalError;
+  constructor(originalError) {
+    super(`Failed to remove temporary file.${originalError instanceof Error ? ` ${originalError.message}` : ""}`, { cause: originalError });
+    this.originalError = originalError;
+  }
+};
+
+// packages/@cjser/inquirer__external-editor.tmp-26-1778156888407/dist/parse-editor-command.js
+function parseEditorCommand(editor) {
+  let bin;
+  let rest;
+  if (editor.startsWith('"')) {
+    const closeQuote = editor.indexOf('"', 1);
+    if (closeQuote === -1) {
+      bin = editor.slice(1);
+      rest = "";
+    } else {
+      bin = editor.substring(1, closeQuote);
+      rest = editor.substring(closeQuote + 1).trim();
+    }
+  } else {
+    const firstSpace = editor.indexOf(" ");
+    if (firstSpace === -1) {
+      bin = editor;
+      rest = "";
+    } else {
+      bin = editor.substring(0, firstSpace);
+      rest = editor.substring(firstSpace + 1).trim();
+    }
+  }
+  return { bin, args: rest ? rest.split(/\s+/) : [] };
+}
+
+// packages/@cjser/inquirer__external-editor.tmp-26-1778156888407/dist/index.js
+function edit(text = "", fileOptions) {
+  return new ExternalEditor(text, fileOptions).run();
+}
+var editAsync = (text, callbackOrOptions, fileOptions) => {
+  const callback = typeof callbackOrOptions === "function" ? callbackOrOptions : void 0;
+  const options = typeof callbackOrOptions === "function" ? fileOptions : callbackOrOptions;
+  return new ExternalEditor(text, options).runAsync(callback);
+};
+function sanitizeAffix(affix) {
+  if (!affix)
+    return "";
+  return affix.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
+var ExternalEditor = class {
+  editor;
+  lastExitStatus = 0;
+  text = "";
+  tempFile = "";
+  fileOptions = {};
+  constructor(text = "", fileOptions = {}) {
+    this.text = text;
+    this.fileOptions = fileOptions;
+    this.editor = parseEditorCommand(process.env["VISUAL"] ?? process.env["EDITOR"] ?? (process.platform.startsWith("win") ? "notepad" : "vim"));
+  }
+  run() {
+    this.createTempFile();
+    try {
+      try {
+        const editorProcess = (0, import_node_child_process.spawnSync)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+        this.lastExitStatus = editorProcess.status ?? 0;
+      } catch (launchError) {
+        throw new LaunchEditorError(launchError);
+      }
+      this.readTemporaryFile();
+      return this.text;
+    } finally {
+      this.cleanup();
+    }
+  }
+  runAsync(callback) {
+    this.createTempFile();
+    const promise = new Promise((resolve, reject) => {
+      try {
+        const editorProcess = (0, import_node_child_process.spawn)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+        editorProcess.on("exit", (code) => {
+          this.lastExitStatus = code;
+          resolve();
+        });
+      } catch (launchError) {
+        reject(new LaunchEditorError(launchError));
+      }
+    }).then(() => {
+      this.readTemporaryFile();
+      return this.text;
+    }).finally(() => {
+      this.cleanup();
+    });
+    if (callback) {
+      promise.then((text) => callback(void 0, text), (err) => callback(err instanceof Error ? err : new Error(String(err)), void 0));
+    }
+    return promise;
+  }
+  cleanup() {
+    if (!this.tempFile)
+      return;
+    try {
+      (0, import_node_fs.unlinkSync)(this.tempFile);
+      this.tempFile = "";
+    } catch (removeFileError) {
+      throw new RemoveFileError(removeFileError);
+    }
+  }
+  createTempFile() {
+    try {
+      const baseDir = this.fileOptions.dir ?? import_node_os.default.tmpdir();
+      const id = (0, import_node_crypto.randomUUID)();
+      const prefix = sanitizeAffix(this.fileOptions.prefix);
+      const postfix = sanitizeAffix(this.fileOptions.postfix);
+      const filename = `${prefix}${id}${postfix}`;
+      const candidate = import_node_path.default.resolve(baseDir, filename);
+      const baseResolved = import_node_path.default.resolve(baseDir) + import_node_path.default.sep;
+      if (!candidate.startsWith(baseResolved)) {
+        throw new Error("Resolved temporary file escaped the base directory");
+      }
+      this.tempFile = candidate;
+      const opt = { encoding: "utf8", flag: "wx" };
+      if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
+        opt.mode = this.fileOptions.mode;
+      }
+      (0, import_node_fs.writeFileSync)(this.tempFile, this.text, opt);
+    } catch (createFileError) {
+      throw new CreateFileError(createFileError);
+    }
+  }
+  readTemporaryFile() {
+    try {
+      const tempFileBuffer = (0, import_node_fs.readFileSync)(this.tempFile);
+      if (tempFileBuffer.length === 0) {
+        this.text = "";
+      } else {
+        let encoding = (0, import_chardet.detect)(tempFileBuffer) ?? "utf8";
+        if (!import_iconv_lite.default.encodingExists(encoding)) {
+          encoding = "utf8";
+        }
+        this.text = import_iconv_lite.default.decode(tempFileBuffer, encoding);
+      }
+    } catch (readFileError) {
+      throw new ReadFileError(readFileError);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateFileError,
+  ExternalEditor,
+  LaunchEditorError,
+  ReadFileError,
+  RemoveFileError,
+  edit,
+  editAsync
+});

package/package.json

@@ -0,0 +1,129 @@
+{
+  "name": "@cjser/inquirer__external-editor",
+  "version": "3.0.0-cjser.2",
+  "description": "Edit a string with the users preferred text editor using $VISUAL or $ENVIRONMENT",
+  "keywords": [
+    "answer",
+    "answers",
+    "ask",
+    "base",
+    "cli",
+    "command",
+    "command-line",
+    "confirm",
+    "editor",
+    "enquirer",
+    "external",
+    "external-editor",
+    "generate",
+    "generator",
+    "hyper",
+    "input",
+    "inquire",
+    "inquirer",
+    "interface",
+    "iterm",
+    "javascript",
+    "menu",
+    "node",
+    "nodejs",
+    "prompt",
+    "promptly",
+    "prompts",
+    "question",
+    "readline",
+    "scaffold",
+    "scaffolder",
+    "scaffolding",
+    "stdin",
+    "stdout",
+    "terminal",
+    "tty",
+    "ui",
+    "user",
+    "visual",
+    "yeoman",
+    "yo",
+    "zsh"
+  ],
+  "homepage": "https://github.com/SBoudrias/Inquirer.js/blob/main/packages/external-editor/README.md",
+  "license": "MIT",
+  "author": "Simon Boudrias <admin@simonboudrias.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://code.moenext.com/3rdeye/cjser.git"
+  },
+  "files": [
+    "dist",
+    "dist-cjser"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist-cjser/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "tsc": "tsc"
+  },
+  "dependencies": {
+    "chardet": "^2.1.1",
+    "iconv-lite": "^0.7.2"
+  },
+  "devDependencies": {
+    "@types/chardet": "^1.0.0",
+    "@types/node": "^25.5.2",
+    "typescript": "^6.0.2"
+  },
+  "peerDependencies": {
+    "@types/node": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "@types/node": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
+  },
+  "main": "./dist-cjser/index.cjs",
+  "types": "./dist/index.d.ts",
+  "gitHead": "e68fe01d65359e083581c48c4a18cd8f97d88842",
+  "cjser": {
+    "sourceVersion": "3.0.0",
+    "cjserVersion": 2,
+    "original": {
+      "name": "@inquirer/external-editor",
+      "version": "3.0.0",
+      "main": "./dist/index.js",
+      "exports": {
+        ".": {
+          "types": "./dist/index.d.ts",
+          "default": "./dist/index.js"
+        },
+        "./package.json": "./package.json"
+      },
+      "repository": {
+        "type": "git",
+        "url": "https://github.com/SBoudrias/Inquirer.js.git"
+      },
+      "dependencies": {
+        "chardet": "^2.1.1",
+        "iconv-lite": "^0.7.2"
+      },
+      "files": [
+        "dist"
+      ],
+      "scripts": {
+        "tsc": "tsc"
+      }
+    }
+  }
+}