lambda-live-debugger 1.8.3 → 1.8.4

package/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js

@@ -40,7 +40,7 @@ export default function readDocType(xmlData, i){
                     const {index} = readNotationExp(xmlData,i+1);
                     i = index;
                 }else if( hasSeq(xmlData, "!--",i) ) comment = true;
-                else throw new Error("Invalid DOCTYPE");
+                else throw new Error(`Invalid DOCTYPE`);
 
                 angleBracketsCount++;
                 exp = "";
@@ -213,8 +213,8 @@ function readElementExp(xmlData, i) {
     i = skipWhitespace(xmlData, i);
     let contentModel = "";
     // Expect '(' to start content model
-    if(xmlData[i] === "E" && hasSeq(xmlData, "MPTY",i)) i+=6;
-    else if(xmlData[i] === "A" && hasSeq(xmlData, "NY",i)) i+=4;
+    if(xmlData[i] === "E" && hasSeq(xmlData, "MPTY",i)) i+=4;
+    else if(xmlData[i] === "A" && hasSeq(xmlData, "NY",i)) i+=2;
     else if (xmlData[i] === "(") {
         i++; // Move past '('
 

package/node_modules/inquirer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inquirer",
-  "version": "12.6.3",
+  "version": "12.8.2",
   "description": "A collection of common interactive command line user interfaces.",
   "keywords": [
     "answer",
@@ -74,16 +74,16 @@
     "tsc": "tshy"
   },
   "dependencies": {
-    "@inquirer/core": "^10.1.13",
-    "@inquirer/prompts": "^7.5.3",
-    "@inquirer/type": "^3.0.7",
+    "@inquirer/core": "^10.1.15",
+    "@inquirer/prompts": "^7.7.1",
+    "@inquirer/type": "^3.0.8",
     "ansi-escapes": "^4.3.2",
     "mute-stream": "^2.0.0",
-    "run-async": "^3.0.0",
+    "run-async": "^4.0.5",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.18.1",
+    "@arethetypeswrong/cli": "^0.18.2",
     "@types/mute-stream": "^0.0.4",
     "tshy": "^3.0.2"
   },
@@ -107,5 +107,5 @@
       "optional": true
     }
   },
-  "gitHead": "dc0770cf6344140b19b2e6b82330fc51084653d1"
+  "gitHead": "5fbae895f0da93446b99ed0b03ccaa6dfb12cf00"
 }

package/node_modules/run-async/README.md

@@ -1,24 +1,21 @@
-Run Async
-=========
+# Run Async
 
-[![npm](https://badge.fury.io/js/run-async.svg)](http://badge.fury.io/js/run-async) [![tests](https://travis-ci.org/SBoudrias/run-async.svg?branch=master)](http://travis-ci.org/SBoudrias/run-async) [![dependencies](https://david-dm.org/SBoudrias/run-async.svg?theme=shields.io)](https://david-dm.org/SBoudrias/run-async)
+[![npm](https://badge.fury.io/js/run-async.svg)](http://badge.fury.io/js/run-async)
 
 Utility method to run a function either synchronously or asynchronously using a series of common patterns. This is useful for library author accepting sync or async functions as parameter. `runAsync` will always run them as an async method, and normalize the multiple signature.
 
-Installation
-=========
+# Installation
 
 ```bash
 npm install --save run-async
 ```
 
-Usage
-=========
+# Usage
 
 Here's a simple example print the function results and three options a user can provide a function.
 
 ```js
-var runAsync = require('run-async');
+var runAsync = require("run-async");
 
 var printAfter = function (func) {
   var cb = function (err, returnValue) {
@@ -29,51 +26,56 @@ var printAfter = function (func) {
 ```
 
 #### Using `this.async`
+
 ```js
 printAfter(function () {
   var done = this.async();
 
   setTimeout(function () {
-    done(null, 'done running with callback');
+    done(null, "done running with callback");
   }, 10);
 });
 ```
 
 #### Returning a promise
+
 ```js
 printAfter(function () {
   return new Promise(function (resolve, reject) {
-    resolve('done running with promises');
+    resolve("done running with promises");
   });
 });
 ```
 
 #### Synchronous function
+
 ```js
 printAfter(function () {
-  return 'done running sync function';
+  return "done running sync function";
 });
 ```
 
 #### Custom done factory
+
 ```js
-var runAsync = require('run-async');
+var runAsync = require("run-async");
 
-runAsync(function() {
+runAsync(function () {
   var callback = this.customAsync();
   callback(null, a + b);
-}, 'customAsync')(1, 2)
+}, "customAsync")(1, 2);
 ```
 
 #### Passing context to async method
+
 ```js
-var runAsync = require('run-async');
+var runAsync = require("run-async");
 
-runAsync(function() {
+runAsync(function () {
   assert(this.isBound);
   var callback = this.async();
   callback(null, a + b);
-}).call({ isBound: true }, 1, 2)
+}).call({ isBound: true }, 1, 2);
 ```
 
 ### runAsync.cb
@@ -81,20 +83,22 @@ runAsync(function() {
 `runAsync.cb` supports all the function types that `runAsync` does and additionally a traditional **callback as the last argument** signature:
 
 ```js
-var runAsync = require('run-async');
+var runAsync = require("run-async");
 
 // IMPORTANT: The wrapped function must have a fixed number of parameters.
-runAsync.cb(function(a, b, cb) {
-  cb(null, a + b);
-}, function(err, result) {
-  console.log(result)
-})(1, 2)
+runAsync.cb(
+  function (a, b, cb) {
+    cb(null, a + b);
+  },
+  function (err, result) {
+    console.log(result);
+  },
+)(1, 2);
 ```
 
 If your version of node support Promises natively (node >= 0.12), `runAsync` will return a promise. Example: `runAsync(func)(arg1, arg2).then(cb)`
 
-Licence
-========
+# Licence
 
 Copyright (c) 2014 Simon Boudrias (twitter: @vaxilart)  
 Licensed under the MIT license.

package/node_modules/run-async/index.d.ts

@@ -0,0 +1,5 @@
+declare function runAsync<F extends (...args: any[]) => any>(
+  func: F,
+): (...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>;
+
+export = runAsync;

package/node_modules/run-async/index.js

@@ -1,7 +1,9 @@
-'use strict';
-
 function isPromise(obj) {
-  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+  return (
+    !!obj &&
+    (typeof obj === "object" || typeof obj === "function") &&
+    typeof obj.then === "function"
+  );
 }
 
 /**
@@ -17,15 +19,14 @@ function isPromise(obj) {
  *                                return a Promise (Node >= 0.12) or call the callbacks.
  */
 
-var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
-  if (typeof cb === 'string') {
+var runAsync = (module.exports = function (func, cb, proxyProperty = "async") {
+  if (typeof cb === "string") {
     proxyProperty = cb;
     cb = undefined;
   }
   cb = cb || function () {};
 
   return function () {
-
     var args = arguments;
     var originalThis = this;
 
@@ -33,20 +34,20 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
       var resolved = false;
       const wrappedResolve = function (value) {
         if (resolved) {
-          console.warn('Run-async promise already resolved.')
+          console.warn("Run-async promise already resolved.");
         }
         resolved = true;
         resolve(value);
-      }
+      };
 
       var rejected = false;
       const wrappedReject = function (value) {
         if (rejected) {
-          console.warn('Run-async promise already rejected.')
+          console.warn("Run-async promise already rejected.");
         }
         rejected = true;
         reject(value);
-      }
+      };
 
       var usingCallback = false;
       var callbackConflict = false;
@@ -54,11 +55,15 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
 
       var doneFactory = function () {
         if (contextEnded) {
-          console.warn('Run-async async() called outside a valid run-async context, callback will be ignored.');
-          return function() {};
+          console.warn(
+            "Run-async async() called outside a valid run-async context, callback will be ignored.",
+          );
+          return function () {};
         }
         if (callbackConflict) {
-          console.warn('Run-async wrapped function (async) returned a promise.\nCalls to async() callback can have unexpected results.');
+          console.warn(
+            "Run-async wrapped function (async) returned a promise.\nCalls to async() callback can have unexpected results.",
+          );
         }
         usingCallback = true;
         return function (err, value) {
@@ -76,7 +81,9 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
           get(_target, prop) {
             if (prop === proxyProperty) {
               if (prop in _target) {
-                console.warn(`${proxyProperty} property is been shadowed by run-sync`);
+                console.warn(
+                  `${proxyProperty} property is been shadowed by run-sync`,
+                );
               }
               return doneFactory;
             }
@@ -92,7 +99,9 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
 
       if (usingCallback) {
         if (isPromise(answer)) {
-          console.warn('Run-async wrapped function (sync) returned a promise but async() callback must be executed to resolve.');
+          console.warn(
+            "Run-async wrapped function (sync) returned a promise but async() callback must be executed to resolve.",
+          );
         }
       } else {
         if (isPromise(answer)) {
@@ -108,8 +117,8 @@ var runAsync = module.exports = function (func, cb, proxyProperty = 'async') {
     promise.then(cb.bind(null, null), cb);
 
     return promise;
-  }
-};
+  };
+});
 
 runAsync.cb = function (func, cb) {
   return runAsync(function () {

package/node_modules/run-async/package.json

@@ -1,10 +1,19 @@
 {
   "name": "run-async",
-  "version": "3.0.0",
+  "version": "4.0.5",
   "description": "Utility method to run function either synchronously or asynchronously using the common `this.async()` style.",
-  "main": "index.js",
+  "exports": {
+    "types": "./index.d.ts",
+    "default": "./index.js"
+  },
+  "sideEffects": false,
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
   "scripts": {
-    "test": "mocha -R spec"
+    "test": "node --test test.js",
+    "lint": "npx oxlint && npx prettier --check ."
   },
   "engines": {
     "node": ">=0.12.0"
@@ -15,12 +24,10 @@
     "flow-control",
     "async"
   ],
-  "files": [
-    "index.js"
-  ],
   "author": "Simon Boudrias <admin@simonboudrias.com>",
   "license": "MIT",
   "devDependencies": {
-    "mocha": "^10.2.0"
+    "oxlint": "^1.2.0",
+    "prettier": "^3.5.3"
   }
 }

package/node_modules/undici-types/agent.d.ts

@@ -1,17 +1,17 @@
 import { URL } from 'url'
 import Pool from './pool'
-import Dispatcher from "./dispatcher";
+import Dispatcher from './dispatcher'
 
 export default Agent
 
-declare class Agent extends Dispatcher{
-  constructor(opts?: Agent.Options)
+declare class Agent extends Dispatcher {
+  constructor (opts?: Agent.Options)
   /** `true` after `dispatcher.close()` has been called. */
-  closed: boolean;
+  closed: boolean
   /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
-  destroyed: boolean;
+  destroyed: boolean
   /** Dispatches a request. */
-  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
 }
 
 declare namespace Agent {
@@ -21,7 +21,7 @@ declare namespace Agent {
     /** Integer. Default: `0` */
     maxRedirections?: number;
 
-    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options["interceptors"]
+    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
   }
 
   export interface DispatchOptions extends Dispatcher.DispatchOptions {

package/node_modules/undici-types/api.d.ts

@@ -2,42 +2,42 @@ import { URL, UrlObject } from 'url'
 import { Duplex } from 'stream'
 import Dispatcher from './dispatcher'
 
-export {
-  request,
-  stream,
-  pipeline,
-  connect,
-  upgrade,
-}
-
 /** Performs an HTTP request. */
-declare function request(
+declare function request<TOpaque = null> (
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
-): Promise<Dispatcher.ResponseData>;
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+): Promise<Dispatcher.ResponseData<TOpaque>>
 
 /** A faster version of `request`. */
-declare function stream(
+declare function stream<TOpaque = null> (
   url: string | URL | UrlObject,
-  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path'>,
-  factory: Dispatcher.StreamFactory
-): Promise<Dispatcher.StreamData>;
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path'>,
+  factory: Dispatcher.StreamFactory<TOpaque>
+): Promise<Dispatcher.StreamData<TOpaque>>
 
 /** For easy use with `stream.pipeline`. */
-declare function pipeline(
+declare function pipeline<TOpaque = null> (
   url: string | URL | UrlObject,
-  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions, 'origin' | 'path'>,
-  handler: Dispatcher.PipelineHandler
-): Duplex;
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions<TOpaque>, 'origin' | 'path'>,
+  handler: Dispatcher.PipelineHandler<TOpaque>
+): Duplex
 
 /** Starts two-way communications with the requested resource. */
-declare function connect(
+declare function connect<TOpaque = null> (
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions, 'origin' | 'path'>
-): Promise<Dispatcher.ConnectData>;
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin' | 'path'>
+): Promise<Dispatcher.ConnectData<TOpaque>>
 
 /** Upgrade to a different protocol. */
-declare function upgrade(
+declare function upgrade (
   url: string | URL | UrlObject,
   options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>
-): Promise<Dispatcher.UpgradeData>;
+): Promise<Dispatcher.UpgradeData>
+
+export {
+  request,
+  stream,
+  pipeline,
+  connect,
+  upgrade
+}

package/node_modules/undici-types/balanced-pool.d.ts

@@ -4,26 +4,26 @@ import { URL } from 'url'
 
 export default BalancedPool
 
-type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
 
 declare class BalancedPool extends Dispatcher {
-  constructor(url: string | string[] | URL | URL[], options?: Pool.Options);
+  constructor (url: string | string[] | URL | URL[], options?: Pool.Options)
 
-  addUpstream(upstream: string | URL): BalancedPool;
-  removeUpstream(upstream: string | URL): BalancedPool;
-  upstreams: Array<string>;
+  addUpstream (upstream: string | URL): BalancedPool
+  removeUpstream (upstream: string | URL): BalancedPool
+  upstreams: Array<string>
 
   /** `true` after `pool.close()` has been called. */
-  closed: boolean;
+  closed: boolean
   /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
-  destroyed: boolean;
+  destroyed: boolean
 
   // Override dispatcher APIs.
-  override connect(
+  override connect (
     options: BalancedPoolConnectOptions
-  ): Promise<Dispatcher.ConnectData>;
-  override connect(
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
     options: BalancedPoolConnectOptions,
     callback: (err: Error | null, data: Dispatcher.ConnectData) => void
-  ): void;
+  ): void
 }

package/node_modules/undici-types/cache-interceptor.d.ts

@@ -0,0 +1,172 @@
+import { Readable, Writable } from 'node:stream'
+
+export default CacheHandler
+
+declare namespace CacheHandler {
+  export type CacheMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
+
+  export interface CacheHandlerOptions {
+    store: CacheStore
+
+    cacheByDefault?: number
+
+    type?: CacheOptions['type']
+  }
+
+  export interface CacheOptions {
+    store?: CacheStore
+
+    /**
+     * The methods to cache
+     * Note we can only cache safe methods. Unsafe methods (i.e. PUT, POST)
+     *  invalidate the cache for a origin.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-respons
+     * @see https://www.rfc-editor.org/rfc/rfc9110#section-9.2.1
+     */
+    methods?: CacheMethods[]
+
+    /**
+     * RFC9111 allows for caching responses that we aren't explicitly told to
+     *  cache or to not cache.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#section-3-5
+     * @default undefined
+     */
+    cacheByDefault?: number
+
+    /**
+     * TODO docs
+     * @default 'shared'
+     */
+    type?: 'shared' | 'private'
+  }
+
+  export interface CacheControlDirectives {
+    'max-stale'?: number;
+    'min-fresh'?: number;
+    'max-age'?: number;
+    's-maxage'?: number;
+    'stale-while-revalidate'?: number;
+    'stale-if-error'?: number;
+    public?: true;
+    private?: true | string[];
+    'no-store'?: true;
+    'no-cache'?: true | string[];
+    'must-revalidate'?: true;
+    'proxy-revalidate'?: true;
+    immutable?: true;
+    'no-transform'?: true;
+    'must-understand'?: true;
+    'only-if-cached'?: true;
+  }
+
+  export interface CacheKey {
+    origin: string
+    method: string
+    path: string
+    headers?: Record<string, string | string[]>
+  }
+
+  export interface CacheValue {
+    statusCode: number
+    statusMessage: string
+    headers: Record<string, string | string[]>
+    vary?: Record<string, string | string[] | null>
+    etag?: string
+    cacheControlDirectives?: CacheControlDirectives
+    cachedAt: number
+    staleAt: number
+    deleteAt: number
+  }
+
+  export interface DeleteByUri {
+    origin: string
+    method: string
+    path: string
+  }
+
+  type GetResult = {
+    statusCode: number
+    statusMessage: string
+    headers: Record<string, string | string[]>
+    vary?: Record<string, string | string[] | null>
+    etag?: string
+    body?: Readable | Iterable<Buffer> | AsyncIterable<Buffer> | Buffer | Iterable<string> | AsyncIterable<string> | string
+    cacheControlDirectives: CacheControlDirectives,
+    cachedAt: number
+    staleAt: number
+    deleteAt: number
+  }
+
+  /**
+   * Underlying storage provider for cached responses
+   */
+  export interface CacheStore {
+    get(key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream(key: CacheKey, val: CacheValue): Writable | undefined
+
+    delete(key: CacheKey): void | Promise<void>
+  }
+
+  export interface MemoryCacheStoreOpts {
+    /**
+       * @default Infinity
+       */
+    maxCount?: number
+
+    /**
+     * @default Infinity
+     */
+    maxSize?: number
+
+    /**
+     * @default Infinity
+     */
+    maxEntrySize?: number
+
+    errorCallback?: (err: Error) => void
+  }
+
+  export class MemoryCacheStore implements CacheStore {
+    constructor (opts?: MemoryCacheStoreOpts)
+
+    get (key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream (key: CacheKey, value: CacheValue): Writable | undefined
+
+    delete (key: CacheKey): void | Promise<void>
+  }
+
+  export interface SqliteCacheStoreOpts {
+    /**
+     * Location of the database
+     * @default ':memory:'
+     */
+    location?: string
+
+    /**
+     * @default Infinity
+     */
+    maxCount?: number
+
+    /**
+     * @default Infinity
+     */
+    maxEntrySize?: number
+  }
+
+  export class SqliteCacheStore implements CacheStore {
+    constructor (opts?: SqliteCacheStoreOpts)
+
+    /**
+     * Closes the connection to the database
+     */
+    close (): void
+
+    get (key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream (key: CacheKey, value: CacheValue): Writable | undefined
+
+    delete (key: CacheKey): void | Promise<void>
+  }
+}