prismatica 0.2.0

package/node_modules/@inquirer/external-editor/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/node_modules/@inquirer/external-editor/dist/index.d.ts

@@ -0,0 +1,35 @@
+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 tempDir;
+    private fileOptions;
+    constructor(text?: string, fileOptions?: FileOptions);
+    run(): string;
+    runAsync(callback?: StringCallback): Promise<string>;
+    private cleanup;
+    private createTempFile;
+    private editorArgs;
+    private readTemporaryFile;
+}

package/node_modules/@inquirer/external-editor/dist/index.js

@@ -0,0 +1,146 @@
+import { detect } from 'chardet';
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, 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 = '';
+    tempDir = '';
+    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.editorArgs(), {
+                    shell: false,
+                    stdio: 'inherit',
+                });
+                if (editorProcess.error) {
+                    throw editorProcess.error;
+                }
+                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.editorArgs(), {
+                    shell: false,
+                    stdio: 'inherit',
+                });
+                editorProcess.once('error', (launchError) => {
+                    reject(new LaunchEditorError(launchError));
+                });
+                editorProcess.once('exit', (code) => {
+                    this.lastExitStatus = code ?? 0;
+                    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.tempDir)
+            return;
+        try {
+            rmSync(this.tempDir, { force: true, recursive: true });
+            this.tempFile = '';
+            this.tempDir = '';
+        }
+        catch (removeFileError) {
+            throw new RemoveFileError(removeFileError);
+        }
+    }
+    createTempFile() {
+        try {
+            const baseDir = path.resolve(this.fileOptions.dir ?? os.tmpdir());
+            this.tempDir = mkdtempSync(path.join(baseDir, 'inquirer-editor-'));
+            const id = randomUUID();
+            const prefix = sanitizeAffix(this.fileOptions.prefix);
+            const postfix = sanitizeAffix(this.fileOptions.postfix);
+            const filename = `${prefix}${id}${postfix}`;
+            this.tempFile = path.join(this.tempDir, filename);
+            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);
+        }
+    }
+    editorArgs() {
+        return [...this.editor.args, this.tempFile];
+    }
+    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/node_modules/@inquirer/external-editor/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/node_modules/@inquirer/external-editor/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/node_modules/@inquirer/external-editor/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@inquirer/external-editor",
+  "version": "3.0.3",
+  "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://github.com/SBoudrias/Inquirer.js.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "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 || ^20.17.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "gitHead": "bfd8710229e3d3c9784bef3bbfbd84c7bd09bb9e"
+}

package/node_modules/@inquirer/figures/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/node_modules/@inquirer/figures/dist/index.d.ts

@@ -0,0 +1,275 @@
+declare const common: {
+    circleQuestionMark: string;
+    questionMarkPrefix: string;
+    square: string;
+    squareDarkShade: string;
+    squareMediumShade: string;
+    squareLightShade: string;
+    squareTop: string;
+    squareBottom: string;
+    squareLeft: string;
+    squareRight: string;
+    squareCenter: string;
+    bullet: string;
+    dot: string;
+    ellipsis: string;
+    pointerSmall: string;
+    triangleUp: string;
+    triangleUpSmall: string;
+    triangleDown: string;
+    triangleDownSmall: string;
+    triangleLeftSmall: string;
+    triangleRightSmall: string;
+    home: string;
+    heart: string;
+    musicNote: string;
+    musicNoteBeamed: string;
+    arrowUp: string;
+    arrowDown: string;
+    arrowLeft: string;
+    arrowRight: string;
+    arrowLeftRight: string;
+    arrowUpDown: string;
+    almostEqual: string;
+    notEqual: string;
+    lessOrEqual: string;
+    greaterOrEqual: string;
+    identical: string;
+    infinity: string;
+    subscriptZero: string;
+    subscriptOne: string;
+    subscriptTwo: string;
+    subscriptThree: string;
+    subscriptFour: string;
+    subscriptFive: string;
+    subscriptSix: string;
+    subscriptSeven: string;
+    subscriptEight: string;
+    subscriptNine: string;
+    oneHalf: string;
+    oneThird: string;
+    oneQuarter: string;
+    oneFifth: string;
+    oneSixth: string;
+    oneEighth: string;
+    twoThirds: string;
+    twoFifths: string;
+    threeQuarters: string;
+    threeFifths: string;
+    threeEighths: string;
+    fourFifths: string;
+    fiveSixths: string;
+    fiveEighths: string;
+    sevenEighths: string;
+    line: string;
+    lineBold: string;
+    lineDouble: string;
+    lineDashed0: string;
+    lineDashed1: string;
+    lineDashed2: string;
+    lineDashed3: string;
+    lineDashed4: string;
+    lineDashed5: string;
+    lineDashed6: string;
+    lineDashed7: string;
+    lineDashed8: string;
+    lineDashed9: string;
+    lineDashed10: string;
+    lineDashed11: string;
+    lineDashed12: string;
+    lineDashed13: string;
+    lineDashed14: string;
+    lineDashed15: string;
+    lineVertical: string;
+    lineVerticalBold: string;
+    lineVerticalDouble: string;
+    lineVerticalDashed0: string;
+    lineVerticalDashed1: string;
+    lineVerticalDashed2: string;
+    lineVerticalDashed3: string;
+    lineVerticalDashed4: string;
+    lineVerticalDashed5: string;
+    lineVerticalDashed6: string;
+    lineVerticalDashed7: string;
+    lineVerticalDashed8: string;
+    lineVerticalDashed9: string;
+    lineVerticalDashed10: string;
+    lineVerticalDashed11: string;
+    lineDownLeft: string;
+    lineDownLeftArc: string;
+    lineDownBoldLeftBold: string;
+    lineDownBoldLeft: string;
+    lineDownLeftBold: string;
+    lineDownDoubleLeftDouble: string;
+    lineDownDoubleLeft: string;
+    lineDownLeftDouble: string;
+    lineDownRight: string;
+    lineDownRightArc: string;
+    lineDownBoldRightBold: string;
+    lineDownBoldRight: string;
+    lineDownRightBold: string;
+    lineDownDoubleRightDouble: string;
+    lineDownDoubleRight: string;
+    lineDownRightDouble: string;
+    lineUpLeft: string;
+    lineUpLeftArc: string;
+    lineUpBoldLeftBold: string;
+    lineUpBoldLeft: string;
+    lineUpLeftBold: string;
+    lineUpDoubleLeftDouble: string;
+    lineUpDoubleLeft: string;
+    lineUpLeftDouble: string;
+    lineUpRight: string;
+    lineUpRightArc: string;
+    lineUpBoldRightBold: string;
+    lineUpBoldRight: string;
+    lineUpRightBold: string;
+    lineUpDoubleRightDouble: string;
+    lineUpDoubleRight: string;
+    lineUpRightDouble: string;
+    lineUpDownLeft: string;
+    lineUpBoldDownBoldLeftBold: string;
+    lineUpBoldDownBoldLeft: string;
+    lineUpDownLeftBold: string;
+    lineUpBoldDownLeftBold: string;
+    lineUpDownBoldLeftBold: string;
+    lineUpDownBoldLeft: string;
+    lineUpBoldDownLeft: string;
+    lineUpDoubleDownDoubleLeftDouble: string;
+    lineUpDoubleDownDoubleLeft: string;
+    lineUpDownLeftDouble: string;
+    lineUpDownRight: string;
+    lineUpBoldDownBoldRightBold: string;
+    lineUpBoldDownBoldRight: string;
+    lineUpDownRightBold: string;
+    lineUpBoldDownRightBold: string;
+    lineUpDownBoldRightBold: string;
+    lineUpDownBoldRight: string;
+    lineUpBoldDownRight: string;
+    lineUpDoubleDownDoubleRightDouble: string;
+    lineUpDoubleDownDoubleRight: string;
+    lineUpDownRightDouble: string;
+    lineDownLeftRight: string;
+    lineDownBoldLeftBoldRightBold: string;
+    lineDownLeftBoldRightBold: string;
+    lineDownBoldLeftRight: string;
+    lineDownBoldLeftBoldRight: string;
+    lineDownBoldLeftRightBold: string;
+    lineDownLeftRightBold: string;
+    lineDownLeftBoldRight: string;
+    lineDownDoubleLeftDoubleRightDouble: string;
+    lineDownDoubleLeftRight: string;
+    lineDownLeftDoubleRightDouble: string;
+    lineUpLeftRight: string;
+    lineUpBoldLeftBoldRightBold: string;
+    lineUpLeftBoldRightBold: string;
+    lineUpBoldLeftRight: string;
+    lineUpBoldLeftBoldRight: string;
+    lineUpBoldLeftRightBold: string;
+    lineUpLeftRightBold: string;
+    lineUpLeftBoldRight: string;
+    lineUpDoubleLeftDoubleRightDouble: string;
+    lineUpDoubleLeftRight: string;
+    lineUpLeftDoubleRightDouble: string;
+    lineUpDownLeftRight: string;
+    lineUpBoldDownBoldLeftBoldRightBold: string;
+    lineUpDownBoldLeftBoldRightBold: string;
+    lineUpBoldDownLeftBoldRightBold: string;
+    lineUpBoldDownBoldLeftRightBold: string;
+    lineUpBoldDownBoldLeftBoldRight: string;
+    lineUpBoldDownLeftRight: string;
+    lineUpDownBoldLeftRight: string;
+    lineUpDownLeftBoldRight: string;
+    lineUpDownLeftRightBold: string;
+    lineUpBoldDownBoldLeftRight: string;
+    lineUpDownLeftBoldRightBold: string;
+    lineUpBoldDownLeftBoldRight: string;
+    lineUpBoldDownLeftRightBold: string;
+    lineUpDownBoldLeftBoldRight: string;
+    lineUpDownBoldLeftRightBold: string;
+    lineUpDoubleDownDoubleLeftDoubleRightDouble: string;
+    lineUpDoubleDownDoubleLeftRight: string;
+    lineUpDownLeftDoubleRightDouble: string;
+    lineCross: string;
+    lineBackslash: string;
+    lineSlash: string;
+};
+declare const specialMainSymbols: {
+    tick: string;
+    info: string;
+    warning: string;
+    cross: string;
+    squareSmall: string;
+    squareSmallFilled: string;
+    circle: string;
+    circleFilled: string;
+    circleDotted: string;
+    circleDouble: string;
+    circleCircle: string;
+    circleCross: string;
+    circlePipe: string;
+    radioOn: string;
+    radioOff: string;
+    checkboxOn: string;
+    checkboxOff: string;
+    checkboxCircleOn: string;
+    checkboxCircleOff: string;
+    pointer: string;
+    triangleUpOutline: string;
+    triangleLeft: string;
+    triangleRight: string;
+    lozenge: string;
+    lozengeOutline: string;
+    hamburger: string;
+    smiley: string;
+    mustache: string;
+    star: string;
+    play: string;
+    nodejs: string;
+    oneSeventh: string;
+    oneNinth: string;
+    oneTenth: string;
+};
+declare const specialFallbackSymbols: {
+    tick: string;
+    info: string;
+    warning: string;
+    cross: string;
+    squareSmall: string;
+    squareSmallFilled: string;
+    circle: string;
+    circleFilled: string;
+    circleDotted: string;
+    circleDouble: string;
+    circleCircle: string;
+    circleCross: string;
+    circlePipe: string;
+    radioOn: string;
+    radioOff: string;
+    checkboxOn: string;
+    checkboxOff: string;
+    checkboxCircleOn: string;
+    checkboxCircleOff: string;
+    pointer: string;
+    triangleUpOutline: string;
+    triangleLeft: string;
+    triangleRight: string;
+    lozenge: string;
+    lozengeOutline: string;
+    hamburger: string;
+    smiley: string;
+    mustache: string;
+    star: string;
+    play: string;
+    nodejs: string;
+    oneSeventh: string;
+    oneNinth: string;
+    oneTenth: string;
+};
+export declare const mainSymbols: typeof common & typeof specialMainSymbols;
+export declare const fallbackSymbols: (typeof common & typeof specialFallbackSymbols) & Record<string, string>;
+declare const figures: typeof mainSymbols | typeof fallbackSymbols;
+export default figures;
+export declare const replaceSymbols: (string: string, { useFallback }?: {
+    useFallback?: boolean;
+}) => string;