lambda-live-debugger 1.11.3 → 1.11.4

package/node_modules/iconv-lite/lib/index.d.ts

@@ -9,27 +9,30 @@
  * This file provides detailed typings for the public API of iconv-lite
  *-------------------------------------------------------------------------------------------- */
 
+import type Stream = require("stream")
 import type { Encoding } from "../types/encodings"
 
-// --- Options ---
-
 declare namespace iconv {
   export interface DecodeOptions {
-    /** Strip the byte order mark (BOM) from the input, when decoding. @default true */
+    /**
+     * Strip the Byte Order Mark (BOM) from the input,
+     * when decoding, if the codec is BOM-aware. @default true
+     */
     stripBOM?: boolean;
     /** Override the default endianness for `UTF-16` and `UTF-32` decodings. */
     defaultEncoding?: "utf16be" | "utf32be";
   }
 
   export interface EncodeOptions {
-    /** Add a byte order mark (BOM) to the output, when encoding. @default false */
+    /**
+     * Add a Byte Order Mark (BOM) to the output, when encoding,
+     * if the codec is BOM-aware. @default false
+     */
     addBOM?: boolean;
     /** Override the default endianness for `UTF-32` encoding. */
     defaultEncoding?: "utf32be";
   }
 
-  // --- Return values ---
-
   export interface EncoderStream {
     write(str: string): Buffer;
     end(): Buffer | undefined;
@@ -41,91 +44,86 @@ declare namespace iconv {
   }
 
   export interface Codec {
-    encoder: new (options?: EncodeOptions, codec?: any) => EncoderStream;
-    decoder: new (options?: DecodeOptions, codec?: any) => DecoderStream;
+    encoder: new (options?: EncodeOptions, codec?: Codec) => EncoderStream;
+    decoder: new (options?: DecodeOptions, codec?: Codec) => DecoderStream;
+    bomAware?: boolean;
     [key: string]: any;
   }
 
-  const iconv: {
-    // --- Basic API ---
-
-    /** Encodes a `string` into a `Buffer`, using the provided `encoding`. */
-    encode(content: string, encoding: Encoding, options?: EncodeOptions): Buffer;
-
-    /** Decodes a `Buffer` into a `string`, using the provided `encoding`. */
-    decode(buffer: Buffer | Uint8Array, encoding: Encoding, options?: DecodeOptions): string;
+  /** Encodes a `string` into a `Buffer`, using the provided `encoding`. */
+  export function encode (content: string, encoding: Encoding, options?: EncodeOptions): Buffer
 
-    /** Checks if a given encoding is supported by `iconv-lite`. */
-    encodingExists(encoding: string): encoding is Encoding;
+  /** Decodes a `Buffer` into a `string`, using the provided `encoding`. */
+  export function decode (buffer: Buffer | Uint8Array, encoding: Encoding, options?: DecodeOptions): string
 
-    // --- Legacy aliases ---
+  /** Checks if a given encoding is supported by `iconv-lite`. */
+  export function encodingExists (encoding: string): encoding is Encoding
 
-    /** Legacy alias for {@link iconv.encode}. */
-    toEncoding: typeof iconv.encode;
+  /** Legacy alias for {@link iconv.encode}. */
+  export const toEncoding: typeof iconv.encode
 
-    /** Legacy alias for {@link iconv.decode}. */
-    fromEncoding: typeof iconv.decode;
+  /** Legacy alias for {@link iconv.decode}. */
+  export const fromEncoding: typeof iconv.decode
 
-    // --- Stream API ---
+  /** Creates a stream that decodes binary data from a given `encoding` into strings. */
+  export function decodeStream (encoding: Encoding, options?: DecodeOptions): NodeJS.ReadWriteStream
 
-    /** Creates a stream that decodes binary data from a given `encoding` into strings. */
-    decodeStream(encoding: Encoding, options?: DecodeOptions): NodeJS.ReadWriteStream;
+  /** Creates a stream that encodes strings into binary data in a given `encoding`. */
+  export function encodeStream (encoding: Encoding, options?: EncodeOptions): NodeJS.ReadWriteStream
 
-    /** Creates a stream that encodes strings into binary data in a given `encoding`. */
-    encodeStream(encoding: Encoding, options?: EncodeOptions): NodeJS.ReadWriteStream;
+  /**
+   * Explicitly enable Streaming API in browser environments by passing in:
+   * ```js
+   * require('stream')
+   * ```
+   * @example iconv.enableStreamingAPI(require('stream'));
+   */
+  export function enableStreamingAPI (stream_module: { Transform: typeof Stream.Transform }): void
 
-    /**
-     * Explicitly enable Streaming API in browser environments by passing in:
-     * ```js
-     * require('stream')
-     * ```
-     * @example iconv.enableStreamingAPI(require('stream'));
-     */
-    enableStreamingAPI(stream_module: any): void;
-
-    // --- Low-level stream APIs ---
-
-    /** Creates and returns a low-level encoder stream. */
-    getEncoder(encoding: Encoding, options?: EncodeOptions): EncoderStream;
+  /** Creates and returns a low-level encoder stream. */
+  export function getEncoder (encoding: Encoding, options?: EncodeOptions): EncoderStream
 
-    /** Creates and returns a low-level decoder stream. */
-    getDecoder(encoding: Encoding, options?: DecodeOptions): DecoderStream;
+  /** Creates and returns a low-level decoder stream. */
+  export function getDecoder (encoding: Encoding, options?: DecodeOptions): DecoderStream
 
-    /**
-     * Returns a codec object for the given `encoding`.
-     * @throws If the `encoding` is not recognized.
-     */
-    getCodec(encoding: Encoding): Codec;
+  /**
+   * Returns a codec object for the given `encoding`.
+   * @throws If the `encoding` is not recognized.
+   */
+  export function getCodec (encoding: Encoding): Codec
 
-    /** Strips all non-alphanumeric characters and appended year from `encoding`. */
-    _canonicalizeEncoding(encoding: Encoding): string;
+  /** Strips all non-alphanumeric characters and appended year from `encoding`. */
+  export function _canonicalizeEncoding (encoding: Encoding): string
 
-    // --- Properties ---
+  /** A cache of all loaded encoding definitions. */
+  export let encodings: Record<
+    Encoding,
+    | string
+    | {
+      type: string;
+      [key: string]: any;
+    }
+  > | null
 
-    /** A cache of all loaded encoding definitions. */
-    encodings: Record<
-      Encoding,
-      | string
-      | {
-        type: string;
-        [key: string]: any;
-      }
-    > | null;
+  /** A cache of initialized codec objects. */
+  export let _codecDataCache: Record<string, Codec>
 
-    /** A cache of initialized codec objects. */
-    _codecDataCache: Record<string, Codec>;
+  /** The character used for untranslatable `Unicode` characters. @default "�" */
+  export let defaultCharUnicode: string
 
-    /** The character used for untranslatable `Unicode` characters. @default "�" */
-    defaultCharUnicode: string;
+  /** The character used for untranslatable `single-byte` characters. @default "?" */
+  export let defaultCharSingleByte: string
 
-    /** The character used for untranslatable `single-byte` characters. @default "?" */
-    defaultCharSingleByte: string;
+  /**
+   * Skip deprecation warning when strings are used instead of Buffers during decoding.
+   * Note: {@link iconv.decode} converts the string to Buffer regardless.
+   */
+  export let skipDecodeWarning: boolean
 
-    /** @readonly Whether or not, Streaming API is enabled. */
-    readonly supportsStreams: boolean;
-  }
+  /** @readonly Whether or not, Streaming API is enabled. */
+  export const supportsStreams: boolean
 
   export type { iconv as Iconv, Encoding }
-  export { iconv as default }
 }
+
 export = iconv

package/node_modules/iconv-lite/lib/index.js

@@ -4,22 +4,21 @@ var Buffer = require("safer-buffer").Buffer
 
 var bomHandling = require("./bom-handling")
 var mergeModules = require("./helpers/merge-exports")
-var iconv = module.exports
 
 // All codecs and aliases are kept here, keyed by encoding name/alias.
 // They are lazy loaded in `iconv.getCodec` from `encodings/index.js`.
 // Cannot initialize with { __proto__: null } because Boolean({ __proto__: null }) === true
-iconv.encodings = null
+module.exports.encodings = null
 
 // Characters emitted in case of error.
-iconv.defaultCharUnicode = "�"
-iconv.defaultCharSingleByte = "?"
+module.exports.defaultCharUnicode = "�"
+module.exports.defaultCharSingleByte = "?"
 
 // Public API.
-iconv.encode = function encode (str, encoding, options) {
+module.exports.encode = function encode (str, encoding, options) {
   str = "" + (str || "") // Ensure string.
 
-  var encoder = iconv.getEncoder(encoding, options)
+  var encoder = module.exports.getEncoder(encoding, options)
 
   var res = encoder.write(str)
   var trail = encoder.end()
@@ -27,17 +26,17 @@ iconv.encode = function encode (str, encoding, options) {
   return (trail && trail.length > 0) ? Buffer.concat([res, trail]) : res
 }
 
-iconv.decode = function decode (buf, encoding, options) {
+module.exports.decode = function decode (buf, encoding, options) {
   if (typeof buf === "string") {
-    if (!iconv.skipDecodeWarning) {
+    if (!module.exports.skipDecodeWarning) {
       console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding")
-      iconv.skipDecodeWarning = true
+      module.exports.skipDecodeWarning = true
     }
 
     buf = Buffer.from("" + (buf || ""), "binary") // Ensure buffer.
   }
 
-  var decoder = iconv.getDecoder(encoding, options)
+  var decoder = module.exports.getDecoder(encoding, options)
 
   var res = decoder.write(buf)
   var trail = decoder.end()
@@ -45,9 +44,9 @@ iconv.decode = function decode (buf, encoding, options) {
   return trail ? (res + trail) : res
 }
 
-iconv.encodingExists = function encodingExists (enc) {
+module.exports.encodingExists = function encodingExists (enc) {
   try {
-    iconv.getCodec(enc)
+    module.exports.getCodec(enc)
     return true
   } catch (e) {
     return false
@@ -55,31 +54,31 @@ iconv.encodingExists = function encodingExists (enc) {
 }
 
 // Legacy aliases to convert functions
-iconv.toEncoding = iconv.encode
-iconv.fromEncoding = iconv.decode
+module.exports.toEncoding = module.exports.encode
+module.exports.fromEncoding = module.exports.decode
 
 // Search for a codec in iconv.encodings. Cache codec data in iconv._codecDataCache.
-iconv._codecDataCache = { __proto__: null }
+module.exports._codecDataCache = { __proto__: null }
 
-iconv.getCodec = function getCodec (encoding) {
-  if (!iconv.encodings) {
+module.exports.getCodec = function getCodec (encoding) {
+  if (!module.exports.encodings) {
     var raw = require("../encodings")
     // TODO: In future versions when old nodejs support is removed can use object.assign
-    iconv.encodings = { __proto__: null } // Initialize as empty object.
-    mergeModules(iconv.encodings, raw)
+    module.exports.encodings = { __proto__: null } // Initialize as empty object.
+    mergeModules(module.exports.encodings, raw)
   }
 
   // Canonicalize encoding name: strip all non-alphanumeric chars and appended year.
-  var enc = iconv._canonicalizeEncoding(encoding)
+  var enc = module.exports._canonicalizeEncoding(encoding)
 
   // Traverse iconv.encodings to find actual codec.
   var codecOptions = {}
   while (true) {
-    var codec = iconv._codecDataCache[enc]
+    var codec = module.exports._codecDataCache[enc]
 
     if (codec) { return codec }
 
-    var codecDef = iconv.encodings[enc]
+    var codecDef = module.exports.encodings[enc]
 
     switch (typeof codecDef) {
       case "string": // Direct alias to other encoding.
@@ -100,9 +99,9 @@ iconv.getCodec = function getCodec (encoding) {
         // The codec function must load all tables and return object with .encoder and .decoder methods.
         // It'll be called only once (for each different options object).
         //
-        codec = new codecDef(codecOptions, iconv)
+        codec = new codecDef(codecOptions, module.exports)
 
-        iconv._codecDataCache[codecOptions.encodingName] = codec // Save it to be reused later.
+        module.exports._codecDataCache[codecOptions.encodingName] = codec // Save it to be reused later.
         return codec
 
       default:
@@ -111,13 +110,13 @@ iconv.getCodec = function getCodec (encoding) {
   }
 }
 
-iconv._canonicalizeEncoding = function (encoding) {
+module.exports._canonicalizeEncoding = function (encoding) {
   // Canonicalize encoding name: strip all non-alphanumeric chars and appended year.
   return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "")
 }
 
-iconv.getEncoder = function getEncoder (encoding, options) {
-  var codec = iconv.getCodec(encoding)
+module.exports.getEncoder = function getEncoder (encoding, options) {
+  var codec = module.exports.getCodec(encoding)
   var encoder = new codec.encoder(options, codec)
 
   if (codec.bomAware && options && options.addBOM) { encoder = new bomHandling.PrependBOM(encoder, options) }
@@ -125,8 +124,8 @@ iconv.getEncoder = function getEncoder (encoding, options) {
   return encoder
 }
 
-iconv.getDecoder = function getDecoder (encoding, options) {
-  var codec = iconv.getCodec(encoding)
+module.exports.getDecoder = function getDecoder (encoding, options) {
+  var codec = module.exports.getCodec(encoding)
   var decoder = new codec.decoder(options, codec)
 
   if (codec.bomAware && !(options && options.stripBOM === false)) { decoder = new bomHandling.StripBOM(decoder, options) }
@@ -139,26 +138,26 @@ iconv.getDecoder = function getDecoder (encoding, options) {
 // up to 100Kb to the output bundle. To avoid unnecessary code bloat, we don't enable Streaming API in browser by default.
 // If you would like to enable it explicitly, please add the following code to your app:
 // > iconv.enableStreamingAPI(require('stream'));
-iconv.enableStreamingAPI = function enableStreamingAPI (streamModule) {
-  if (iconv.supportsStreams) { return }
+module.exports.enableStreamingAPI = function enableStreamingAPI (streamModule) {
+  if (module.exports.supportsStreams) { return }
 
   // Dependency-inject stream module to create IconvLite stream classes.
   var streams = require("./streams")(streamModule)
 
   // Not public API yet, but expose the stream classes.
-  iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream
-  iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream
+  module.exports.IconvLiteEncoderStream = streams.IconvLiteEncoderStream
+  module.exports.IconvLiteDecoderStream = streams.IconvLiteDecoderStream
 
   // Streaming API.
-  iconv.encodeStream = function encodeStream (encoding, options) {
-    return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options)
+  module.exports.encodeStream = function encodeStream (encoding, options) {
+    return new module.exports.IconvLiteEncoderStream(module.exports.getEncoder(encoding, options), options)
   }
 
-  iconv.decodeStream = function decodeStream (encoding, options) {
-    return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options)
+  module.exports.decodeStream = function decodeStream (encoding, options) {
+    return new module.exports.IconvLiteDecoderStream(module.exports.getDecoder(encoding, options), options)
   }
 
-  iconv.supportsStreams = true
+  module.exports.supportsStreams = true
 }
 
 // Enable Streaming API automatically if 'stream' module is available and non-empty (the majority of environments).
@@ -168,10 +167,10 @@ try {
 } catch (e) {}
 
 if (streamModule && streamModule.Transform) {
-  iconv.enableStreamingAPI(streamModule)
+  module.exports.enableStreamingAPI(streamModule)
 } else {
   // In rare cases where 'stream' module is not available by default, throw a helpful exception.
-  iconv.encodeStream = iconv.decodeStream = function () {
+  module.exports.encodeStream = module.exports.decodeStream = function () {
     throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.")
   }
 }

package/node_modules/iconv-lite/package.json

@@ -1,7 +1,7 @@
 {
     "name": "iconv-lite",
     "description": "Convert character encodings in pure javascript.",
-    "version": "0.7.1",
+    "version": "0.7.2",
     "license": "MIT",
     "keywords": [
         "iconv",
@@ -14,6 +14,11 @@
     "typings": "./lib/index.d.ts",
     "homepage": "https://github.com/pillarjs/iconv-lite",
     "bugs": "https://github.com/pillarjs/iconv-lite/issues",
+    "files": [
+        "lib/",
+        "encodings/",
+        "types/"
+    ],
     "funding": {
       "type": "opencollective",
       "url": "https://opencollective.com/express"

package/node_modules/inquirer/dist/types.d.ts

@@ -22,10 +22,10 @@ type WidenAnswerLiterals<T> = T extends string ? string : T extends number ? num
     [K in keyof Mutable<T>]: Mutable<T>[K] extends infer V ? V extends undefined ? never : WidenAnswerLiterals<V> : never;
 } : T;
 type MergeAnswerObjects<Base, Override> = Prettify<Omit<Base, keyof Override> & Override>;
-type AsyncCallbackFunction<R> = (...args: [error: null | undefined, value: R] | [error: Error, value: undefined]) => void;
-export type AsyncGetterFunction<R, A extends Answers> = (this: {
-    async: () => AsyncCallbackFunction<R>;
-}, answers: NoInfer<Prettify<Partial<A>>>) => void | R | Promise<R>;
+export type AsyncGetterFunction<T, A extends Answers> = (this: {
+    async: () => (...args: [error: null | undefined, value: T] | [error: Error, value: undefined]) => void;
+}, answers: NoInfer<Prettify<Partial<A>>>) => void | T | Promise<T>;
+type MaybeAsyncValue<T, A extends Answers> = T | AsyncGetterFunction<T, A>;
 /**
  * Allows to inject a custom question type into inquirer module.
  *
@@ -45,21 +45,22 @@ export interface QuestionMap {
         message: string;
     };
 }
-type KeyValueOrAsyncGetterFunction<T, k extends string, A extends Answers> = T extends Record<string, any> ? T[k] | AsyncGetterFunction<T[k], A> : never;
+type KeyValueOrAsyncGetterFunction<T, k extends string, A extends Answers> = T extends Record<string, any> ? MaybeAsyncValue<T[k], A> : never;
 export type Question<A extends Answers = Answers, Type extends string = string> = {
     type: Type;
     name: string;
-    message: string | AsyncGetterFunction<string, A>;
+    message: MaybeAsyncValue<string, A>;
     default?: any;
     choices?: any;
+    validate?: (value: any, answers: NoInfer<Partial<A>>) => boolean | string | Promise<boolean | string>;
     filter?: (answer: any, answers: NoInfer<Partial<A>>) => any;
     askAnswered?: boolean;
-    when?: boolean | AsyncGetterFunction<boolean, A>;
+    when?: MaybeAsyncValue<boolean, A>;
 };
 type QuestionWithGetters<Type extends string, Q extends Record<string, any>, A extends Answers> = DistributiveMerge<Q, {
     type: Type;
     askAnswered?: boolean;
-    when?: boolean | AsyncGetterFunction<boolean, A>;
+    when?: MaybeAsyncValue<boolean, A>;
     filter?(input: any, answers: NoInfer<A>): any;
     message: KeyValueOrAsyncGetterFunction<Q, 'message', A>;
     default?: KeyValueOrAsyncGetterFunction<Q, 'default', A>;
@@ -84,14 +85,14 @@ export type QuestionDictionary<A extends Answers, Q> = {
 };
 export type DictionaryAnswers<A extends Answers, Prefilled extends Answers> = MergeAnswerObjects<NormalizeAnswers<Answers<Extract<keyof A, string>>>, WidenAnswerLiterals<Prefilled>>;
 export type PromptModulePublicQuestion<A extends Answers, Flat extends Answers = A> = {
-    type: 'input' | 'confirm' | 'editor' | 'password' | 'number' | 'rawlist' | 'expand' | 'checkbox' | 'search' | 'select' | 'list';
+    type: 'input' | 'confirm' | 'editor' | 'password' | 'number' | 'rawlist' | 'expand' | 'checkbox' | 'search' | 'select';
     name: Extract<keyof Flat, string>;
-    message: string | AsyncGetterFunction<string, A>;
+    message: MaybeAsyncValue<string, A>;
     default?: unknown;
     choices?: unknown;
     filter?: (input: any, answers: NoInfer<Partial<A>>) => any;
     askAnswered?: boolean;
-    when?: boolean | AsyncGetterFunction<boolean, A>;
+    when?: MaybeAsyncValue<boolean, A>;
 } & Record<string, unknown>;
 export type StreamOptions = Prettify<Context & {
     skipTTYChecks?: boolean;

package/node_modules/inquirer/dist/ui/prompt.js

@@ -159,12 +159,20 @@ export default class PromptsRunner {
                 return choiceObj;
             });
         }
-        return Object.assign({}, question, {
+        // Wrap the validate function to pass answers as second parameter for backward compatibility
+        const wrappedQuestion = Object.assign({}, question, {
             message,
             default: defaultValue,
             choices,
             type: question.type in this.prompts ? question.type : 'input',
         });
+        if (question.validate) {
+            const originalValidate = question.validate;
+            wrappedQuestion.validate = (value) => {
+                return originalValidate(value, this.answers);
+            };
+        }
+        return wrappedQuestion;
     };
     fetchAnswer = async (rawQuestion) => {
         const question = await this.prepareQuestion(rawQuestion);

package/node_modules/inquirer/dist/ui/skipped-renderer.d.ts

@@ -0,0 +1,13 @@
+import { Answers, Question } from '../types.ts';
+type RendererFunction<A extends Answers = Answers> = (question: Question<A>) => string;
+type SkippedRendererType<A extends Answers = Answers> = {
+    [key: string]: RendererFunction<A>;
+    confirm: RendererFunction<A>;
+    select: RendererFunction<A>;
+    checkbox: RendererFunction<A>;
+    editor: RendererFunction<A>;
+    password: RendererFunction<A>;
+    default: RendererFunction<A>;
+};
+declare const SkippedRenderer: SkippedRendererType;
+export default SkippedRenderer;

package/node_modules/inquirer/dist/ui/skipped-renderer.js

@@ -0,0 +1,57 @@
+import { makeTheme } from '@inquirer/core';
+const theme = makeTheme();
+const prefix = typeof theme.prefix === 'string' ? theme.prefix : theme.prefix.idle;
+const SkippedRenderer = {
+    confirm: (question) => {
+        const defaultVal = question.default;
+        const answerText = defaultVal === true ? 'Yes' : defaultVal === false ? 'No' : '';
+        return renderLine(question.message.toString(), answerText);
+    },
+    select: (question) => {
+        const defaultVal = question.default;
+        let answerText = String(defaultVal);
+        if (question.choices && defaultVal !== undefined) {
+            const selectedChoice = question.choices.find((c) => c.value === defaultVal);
+            answerText = selectedChoice ? selectedChoice.name : String(defaultVal);
+        }
+        return renderLine(question.message.toString(), answerText);
+    },
+    checkbox: (question) => {
+        const defaultVal = question.default;
+        let answerText = '';
+        if (Array.isArray(defaultVal) && question.choices) {
+            const selectedNames = question.choices
+                .filter((c) => defaultVal.includes(c.value))
+                .map((c) => c.name);
+            answerText = selectedNames.join(', ');
+        }
+        else if (defaultVal !== undefined) {
+            answerText = String(defaultVal);
+        }
+        return renderLine(question.message.toString(), answerText);
+    },
+    editor: (question) => {
+        const answerText = question.default !== undefined ? '[Default Content]' : '';
+        return renderLine(question.message.toString(), answerText);
+    },
+    password: (question) => {
+        const defaultVal = question.default;
+        let answerText = '';
+        if (defaultVal !== undefined) {
+            answerText = '[PASSWORD SET]';
+        }
+        return renderLine(question.message.toString(), answerText);
+    },
+    default: (question) => {
+        const answerText = question.default !== undefined ? String(question.default) : '';
+        return renderLine(question.message.toString(), answerText);
+    },
+    list: (question) => SkippedRenderer.select(question),
+    rawlist: (question) => SkippedRenderer.select(question),
+    input: (question) => SkippedRenderer.default(question),
+    number: (question) => SkippedRenderer.default(question),
+};
+function renderLine(message, answerText) {
+    return theme.style.help(`${prefix} ${message} ${answerText}`);
+}
+export default SkippedRenderer;

package/node_modules/inquirer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inquirer",
-  "version": "13.1.0",
+  "version": "13.2.2",
   "description": "A collection of common interactive command line user interfaces.",
   "keywords": [
     "answer",
@@ -42,44 +42,43 @@
     "zsh"
   ],
   "homepage": "https://github.com/SBoudrias/Inquirer.js/blob/main/packages/inquirer/README.md",
+  "license": "MIT",
+  "author": "Simon Boudrias <admin@simonboudrias.com>",
   "repository": {
     "type": "git",
     "url": "https://github.com/SBoudrias/Inquirer.js.git"
   },
-  "license": "MIT",
-  "author": "Simon Boudrias <admin@simonboudrias.com>",
-  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
   "type": "module",
+  "sideEffects": false,
   "exports": {
-    "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
   },
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "tsc": "tsc"
   },
   "dependencies": {
-    "@inquirer/ansi": "^2.0.2",
-    "@inquirer/core": "^11.1.0",
-    "@inquirer/prompts": "^8.1.0",
-    "@inquirer/type": "^4.0.2",
+    "@inquirer/ansi": "^2.0.3",
+    "@inquirer/core": "^11.1.1",
+    "@inquirer/prompts": "^8.2.0",
+    "@inquirer/type": "^4.0.3",
     "mute-stream": "^3.0.0",
     "run-async": "^4.0.6",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@repo/tsconfig": "0.0.0",
     "@types/mute-stream": "^0.0.4",
     "typescript": "^5.9.3"
   },
-  "engines": {
-    "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
-  },
   "peerDependencies": {
     "@types/node": ">=18"
   },
@@ -88,10 +87,10 @@
       "optional": true
     }
   },
-  "publishConfig": {
-    "access": "public"
+  "engines": {
+    "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "gitHead": "7eedd8e1de71764d0d30e762c97992ceb9f68ed3"
+  "gitHead": "dc4c581ee9f36eb313fdf690040cb907c58401a1"
 }