devlyn-cli 4.2.0 → 4.2.2

package/node_modules/fast-string-width/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "fast-string-width",
+  "repository": "github:fabiospampinato/fast-string-width",
+  "description": "A fast function for calculating the visual width of a string once printed to the terminal.",
+  "license": "MIT",
+  "version": "3.0.2",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "clean": "tsex clean",
+    "compile": "tsex compile",
+    "compile:watch": "tsex compile --watch",
+    "test": "tsex test",
+    "test:watch": "tsex test --watch",
+    "prepublishOnly": "tsex prepare"
+  },
+  "keywords": [
+    "fast",
+    "string",
+    "width",
+    "cli",
+    "terminal"
+  ],
+  "dependencies": {
+    "fast-string-truncated-width": "^3.0.2"
+  },
+  "devDependencies": {
+    "fava": "^0.3.4",
+    "tsex": "^4.0.2",
+    "typescript": "^5.7.3"
+  }
+}

package/node_modules/fast-string-width/readme.md

@@ -0,0 +1,42 @@
+# Fast String Width
+
+A fast function for calculating the visual width of a string once printed to the terminal.
+
+See [`fast-string-truncated-width`](https://github.com/fabiospampinato/fast-string-truncated-width) for a lower-level version of this.
+
+## Install
+
+```sh
+npm install fast-string-width
+```
+
+## Usage
+
+```ts
+import fastStringWidth from 'fast-string-width';
+
+// The width of various classes of characters is configurable
+
+const options = {
+  controlWidth: 0,
+  tabWidth: 8,
+  emojiWidth: 2,
+  regularWidth: 1,
+  wideWidth: 2
+};
+
+// Calculating the visual width of some strings
+
+fastStringWidth ( 'hello', options ); // => 5
+fastStringWidth ( '\x1b[31mhello', options ); // => 5
+fastStringWidth ( '👨‍👩‍👧‍👦', options ); // => 2
+fastStringWidth ( 'hello👨‍👩‍👧‍👦', options ); // => 7
+
+// Calculating the visual width while tweaking the width of emojis
+
+fastStringWidth ( '👶👶🏽', { ...options, emojiWidth: 1.5 } ); // => 3
+```
+
+## License
+
+MIT © Fabio Spampinato

package/node_modules/fast-wrap-ansi/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2025 James Garbutt
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+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/fast-wrap-ansi/README.md

@@ -0,0 +1,26 @@
+# fast-wrap-ansi
+
+Wordwrap a string, taking ANSI escape codes into account.
+
+A fast, light fork of the `wrap-ansi` package.
+
+
+## Install
+
+```bash
+npm i -S fast-wrap-ansi
+```
+
+## Usage
+
+```ts
+import {wrapAnsi} from 'fast-wrap-ansi';
+
+const str = 'This is a string with some \x1b[31mANSI\x1b[39m codes.';
+const wrapped = wrapAnsi(str, 20);
+console.log(wrapped);
+```
+
+## License
+
+MIT

package/node_modules/fast-wrap-ansi/lib/main.d.ts

@@ -0,0 +1,6 @@
+export interface Options {
+    trim?: boolean;
+    wordWrap?: boolean;
+    hard?: boolean;
+}
+export declare function wrapAnsi(string: string, columns: number, options?: Options): string;

package/node_modules/fast-wrap-ansi/lib/main.js

@@ -0,0 +1,218 @@
+import stringWidth from 'fast-string-width';
+const ESC = '\x1B';
+const CSI = '\x9B';
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = '\u0007';
+const ANSI_CSI = '[';
+const ANSI_OSC = ']';
+const ANSI_SGR_TERMINATOR = 'm';
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, 'y');
+const getClosingCode = (openingCode) => {
+    if (openingCode >= 30 && openingCode <= 37)
+        return 39;
+    if (openingCode >= 90 && openingCode <= 97)
+        return 39;
+    if (openingCode >= 40 && openingCode <= 47)
+        return 49;
+    if (openingCode >= 100 && openingCode <= 107)
+        return 49;
+    if (openingCode === 1 || openingCode === 2)
+        return 22;
+    if (openingCode === 3)
+        return 23;
+    if (openingCode === 4)
+        return 24;
+    if (openingCode === 7)
+        return 27;
+    if (openingCode === 8)
+        return 28;
+    if (openingCode === 9)
+        return 29;
+    if (openingCode === 0)
+        return 0;
+    return undefined;
+};
+const wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+const wrapWord = (rows, word, columns) => {
+    const characters = word[Symbol.iterator]();
+    let isInsideEscape = false;
+    let isInsideLinkEscape = false;
+    let lastRow = rows.at(-1);
+    let visible = lastRow === undefined ? 0 : stringWidth(lastRow);
+    let currentCharacter = characters.next();
+    let nextCharacter = characters.next();
+    let rawCharacterIndex = 0;
+    while (!currentCharacter.done) {
+        const character = currentCharacter.value;
+        const characterLength = stringWidth(character);
+        if (visible + characterLength <= columns) {
+            rows[rows.length - 1] += character;
+        }
+        else {
+            rows.push(character);
+            visible = 0;
+        }
+        if (character === ESC || character === CSI) {
+            isInsideEscape = true;
+            isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+        }
+        if (isInsideEscape) {
+            if (isInsideLinkEscape) {
+                if (character === ANSI_ESCAPE_BELL) {
+                    isInsideEscape = false;
+                    isInsideLinkEscape = false;
+                }
+            }
+            else if (character === ANSI_SGR_TERMINATOR) {
+                isInsideEscape = false;
+            }
+        }
+        else {
+            visible += characterLength;
+            if (visible === columns && !nextCharacter.done) {
+                rows.push('');
+                visible = 0;
+            }
+        }
+        currentCharacter = nextCharacter;
+        nextCharacter = characters.next();
+        rawCharacterIndex += character.length;
+    }
+    lastRow = rows.at(-1);
+    if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+        rows[rows.length - 2] += rows.pop();
+    }
+};
+const stringVisibleTrimSpacesRight = (string) => {
+    const words = string.split(' ');
+    let last = words.length;
+    while (last) {
+        if (stringWidth(words[last - 1])) {
+            break;
+        }
+        last--;
+    }
+    if (last === words.length) {
+        return string;
+    }
+    return words.slice(0, last).join(' ') + words.slice(last).join('');
+};
+const exec = (string, columns, options = {}) => {
+    if (options.trim !== false && string.trim() === '') {
+        return '';
+    }
+    let returnValue = '';
+    let escapeCode;
+    let escapeUrl;
+    const words = string.split(' ');
+    let rows = [''];
+    let rowLength = 0;
+    for (let index = 0; index < words.length; index++) {
+        const word = words[index];
+        if (options.trim !== false) {
+            const row = rows.at(-1) ?? '';
+            const trimmed = row.trimStart();
+            if (row.length !== trimmed.length) {
+                rows[rows.length - 1] = trimmed;
+                rowLength = stringWidth(trimmed);
+            }
+        }
+        if (index !== 0) {
+            if (rowLength >= columns &&
+                (options.wordWrap === false || options.trim === false)) {
+                rows.push('');
+                rowLength = 0;
+            }
+            if (rowLength || options.trim === false) {
+                rows[rows.length - 1] += ' ';
+                rowLength++;
+            }
+        }
+        const wordLength = stringWidth(word);
+        if (options.hard && wordLength > columns) {
+            const remainingColumns = columns - rowLength;
+            const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+            const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+            if (breaksStartingNextLine < breaksStartingThisLine) {
+                rows.push('');
+            }
+            wrapWord(rows, word, columns);
+            rowLength = stringWidth(rows.at(-1) ?? '');
+            continue;
+        }
+        if (rowLength + wordLength > columns && rowLength && wordLength) {
+            if (options.wordWrap === false && rowLength < columns) {
+                wrapWord(rows, word, columns);
+                rowLength = stringWidth(rows.at(-1) ?? '');
+                continue;
+            }
+            rows.push('');
+            rowLength = 0;
+        }
+        if (rowLength + wordLength > columns && options.wordWrap === false) {
+            wrapWord(rows, word, columns);
+            rowLength = stringWidth(rows.at(-1) ?? '');
+            continue;
+        }
+        rows[rows.length - 1] += word;
+        rowLength += wordLength;
+    }
+    if (options.trim !== false) {
+        rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+    }
+    const preString = rows.join('\n');
+    let inSurrogate = false;
+    for (let i = 0; i < preString.length; i++) {
+        const character = preString[i];
+        returnValue += character;
+        if (!inSurrogate) {
+            inSurrogate = character >= '\ud800' && character <= '\udbff';
+            if (inSurrogate) {
+                continue;
+            }
+        }
+        else {
+            inSurrogate = false;
+        }
+        if (character === ESC || character === CSI) {
+            GROUP_REGEX.lastIndex = i + 1;
+            const groupsResult = GROUP_REGEX.exec(preString);
+            const groups = groupsResult?.groups;
+            if (groups?.code !== undefined) {
+                const code = Number.parseFloat(groups.code);
+                escapeCode = code === END_CODE ? undefined : code;
+            }
+            else if (groups?.uri !== undefined) {
+                escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+            }
+        }
+        if (preString[i + 1] === '\n') {
+            if (escapeUrl) {
+                returnValue += wrapAnsiHyperlink('');
+            }
+            const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+            if (escapeCode && closingCode) {
+                returnValue += wrapAnsiCode(closingCode);
+            }
+        }
+        else if (character === '\n') {
+            if (escapeCode && getClosingCode(escapeCode)) {
+                returnValue += wrapAnsiCode(escapeCode);
+            }
+            if (escapeUrl) {
+                returnValue += wrapAnsiHyperlink(escapeUrl);
+            }
+        }
+    }
+    return returnValue;
+};
+const CRLF_OR_LF = /\r?\n/;
+export function wrapAnsi(string, columns, options) {
+    return String(string)
+        .normalize()
+        .split(CRLF_OR_LF)
+        .map((line) => exec(line, columns, options))
+        .join('\n');
+}

package/node_modules/fast-wrap-ansi/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "fast-wrap-ansi",
+  "version": "0.2.2",
+  "files": [
+    "lib"
+  ],
+  "description": "A tiny and fast text wrap library which takes ANSI escapes into account.",
+  "keywords": [
+    "wrap",
+    "ansi",
+    "term",
+    "colors"
+  ],
+  "homepage": "https://github.com/43081j/fast-wrap-ansi#readme",
+  "bugs": {
+    "url": "https://github.com/43081j/fast-wrap-ansi/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/43081j/fast-wrap-ansi.git"
+  },
+  "license": "MIT",
+  "author": "James Garbutt (https://github.com/43081j)",
+  "type": "module",
+  "main": "lib/main.js",
+  "scripts": {
+    "format": "prettier --write src test",
+    "lint": "npm run lint:js && npm run lint:format && npm run lint:types",
+    "lint:js": "eslint src test",
+    "lint:format": "prettier --check src test",
+    "lint:types": "npx tsc --noEmit -p tsconfig.test.json",
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.8.0",
+    "eslint": "^10.4.0",
+    "fast-wrap-ansi-prod": "npm:fast-wrap-ansi@*",
+    "picocolors": "^1.1.1",
+    "prettier": "^3.8.3",
+    "tinybench": "^6.0.2",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.3",
+    "vitest": "^4.1.6",
+    "wrap-ansi": "^10.0.0"
+  },
+  "dependencies": {
+    "fast-string-width": "^3.0.2"
+  }
+}

package/node_modules/mute-stream/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/mute-stream/README.md

@@ -0,0 +1,68 @@
+# mute-stream
+
+Bytes go in, but they don't come out (when muted).
+
+This is a basic pass-through stream, but when muted, the bytes are
+silently dropped, rather than being passed through.
+
+## Usage
+
+```javascript
+const MuteStream = require('mute-stream')
+
+const ms = new MuteStream(options)
+
+ms.pipe(process.stdout)
+ms.write('foo') // writes 'foo' to stdout
+ms.mute()
+ms.write('bar') // does not write 'bar'
+ms.unmute()
+ms.write('baz') // writes 'baz' to stdout
+
+// can also be used to mute incoming data
+const ms = new MuteStream()
+input.pipe(ms)
+
+ms.on('data', function (c) {
+  console.log('data: ' + c)
+})
+
+input.emit('data', 'foo') // logs 'foo'
+ms.mute()
+input.emit('data', 'bar') // does not log 'bar'
+ms.unmute()
+input.emit('data', 'baz') // logs 'baz'
+```
+
+## Options
+
+All options are optional.
+
+* `replace` Set to a string to replace each character with the
+  specified string when muted.  (So you can show `****` instead of the
+  password, for example.)
+
+* `prompt` If you are using a replacement char, and also using a
+  prompt with a readline stream (as for a `Password: *****` input),
+  then specify what the prompt is so that backspace will work
+  properly.  Otherwise, pressing backspace will overwrite the prompt
+  with the replacement character, which is weird.
+
+## ms.mute()
+
+Set `muted` to `true`.  Turns `.write()` into a no-op.
+
+## ms.unmute()
+
+Set `muted` to `false`
+
+## ms.isTTY
+
+True if the pipe destination is a TTY, or if the incoming pipe source is
+a TTY.
+
+## Other stream methods...
+
+The other standard readable and writable stream methods are all
+available.  The MuteStream object acts as a facade to its pipe source
+and destination.

package/node_modules/mute-stream/lib/index.js

@@ -0,0 +1,142 @@
+const Stream = require('stream')
+
+class MuteStream extends Stream {
+  #isTTY = null
+
+  constructor (opts = {}) {
+    super(opts)
+    this.writable = this.readable = true
+    this.muted = false
+    this.on('pipe', this._onpipe)
+    this.replace = opts.replace
+
+    // For readline-type situations
+    // This much at the start of a line being redrawn after a ctrl char
+    // is seen (such as backspace) won't be redrawn as the replacement
+    this._prompt = opts.prompt || null
+    this._hadControl = false
+  }
+
+  #destSrc (key, def) {
+    if (this._dest) {
+      return this._dest[key]
+    }
+    if (this._src) {
+      return this._src[key]
+    }
+    return def
+  }
+
+  #proxy (method, ...args) {
+    if (typeof this._dest?.[method] === 'function') {
+      this._dest[method](...args)
+    }
+    if (typeof this._src?.[method] === 'function') {
+      this._src[method](...args)
+    }
+  }
+
+  get isTTY () {
+    if (this.#isTTY !== null) {
+      return this.#isTTY
+    }
+    return this.#destSrc('isTTY', false)
+  }
+
+  // basically just get replace the getter/setter with a regular value
+  set isTTY (val) {
+    this.#isTTY = val
+  }
+
+  get rows () {
+    return this.#destSrc('rows')
+  }
+
+  get columns () {
+    return this.#destSrc('columns')
+  }
+
+  mute () {
+    this.muted = true
+  }
+
+  unmute () {
+    this.muted = false
+  }
+
+  _onpipe (src) {
+    this._src = src
+  }
+
+  pipe (dest, options) {
+    this._dest = dest
+    return super.pipe(dest, options)
+  }
+
+  pause () {
+    if (this._src) {
+      return this._src.pause()
+    }
+  }
+
+  resume () {
+    if (this._src) {
+      return this._src.resume()
+    }
+  }
+
+  write (c) {
+    if (this.muted) {
+      if (!this.replace) {
+        return true
+      }
+      // eslint-disable-next-line no-control-regex
+      if (c.match(/^\u001b/)) {
+        if (c.indexOf(this._prompt) === 0) {
+          c = c.slice(this._prompt.length)
+          c = c.replace(/./g, this.replace)
+          c = this._prompt + c
+        }
+        this._hadControl = true
+        return this.emit('data', c)
+      } else {
+        if (this._prompt && this._hadControl &&
+          c.indexOf(this._prompt) === 0) {
+          this._hadControl = false
+          this.emit('data', this._prompt)
+          c = c.slice(this._prompt.length)
+        }
+        c = c.toString().replace(/./g, this.replace)
+      }
+    }
+    this.emit('data', c)
+  }
+
+  end (c) {
+    if (this.muted) {
+      if (c && this.replace) {
+        c = c.toString().replace(/./g, this.replace)
+      } else {
+        c = null
+      }
+    }
+    if (c) {
+      this.emit('data', c)
+    }
+    this.emit('end')
+  }
+
+  destroy (...args) {
+    return this.#proxy('destroy', ...args)
+  }
+
+  destroySoon (...args) {
+    return this.#proxy('destroySoon', ...args)
+  }
+
+  close (...args) {
+    return this.#proxy('close', ...args)
+  }
+}
+
+module.exports = MuteStream

package/node_modules/mute-stream/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "mute-stream",
+  "version": "3.0.0",
+  "main": "lib/index.js",
+  "devDependencies": {
+    "@npmcli/eslint-config": "^5.0.0",
+    "@npmcli/template-oss": "4.27.1",
+    "tap": "^16.3.0"
+  },
+  "scripts": {
+    "test": "tap",
+    "lint": "npm run eslint",
+    "postlint": "template-oss-check",
+    "template-oss-apply": "template-oss-apply --force",
+    "lintfix": "npm run eslint -- --fix",
+    "snap": "tap",
+    "posttest": "npm run lint",
+    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/mute-stream.git"
+  },
+  "keywords": [
+    "mute",
+    "stream",
+    "pipe"
+  ],
+  "author": "GitHub Inc.",
+  "license": "ISC",
+  "description": "Bytes go in, but they don't come out (when muted).",
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "tap": {
+    "statements": 70,
+    "branches": 60,
+    "functions": 81,
+    "lines": 70,
+    "nyc-arg": [
+      "--exclude",
+      "tap-snapshots/**"
+    ]
+  },
+  "engines": {
+    "node": "^20.17.0 || >=22.9.0"
+  },
+  "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+    "version": "4.27.1",
+    "publish": true
+  }
+}