lambda-live-debugger 1.8.2 → 1.8.4

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

@@ -17,7 +17,7 @@ export default function readDocType(xmlData, i){
         let exp = "";
         for(;i<xmlData.length;i++){
             if (xmlData[i] === '<' && !comment) { //Determine the tag type
-                if( hasBody && isEntity(xmlData, i)){
+                if( hasBody && hasSeq(xmlData, "!ENTITY",i)){
                     i += 7; 
                     let entityName, val;
                     [entityName, val,i] = readEntityExp(xmlData,i+1);
@@ -27,20 +27,20 @@ export default function readDocType(xmlData, i){
                             val: val
                         };
                 }
-                else if( hasBody && isElement(xmlData, i))  {
+                else if( hasBody && hasSeq(xmlData, "!ELEMENT",i))  {
                     i += 8;//Not supported
                     const {index} = readElementExp(xmlData,i+1);
                     i = index;
-                }else if( hasBody && isAttlist(xmlData, i)){
+                }else if( hasBody && hasSeq(xmlData, "!ATTLIST",i)){
                     i += 8;//Not supported
                     // const {index} = readAttlistExp(xmlData,i+1);
                     // i = index;
-                }else if( hasBody && isNotation(xmlData, i)) {
+                }else if( hasBody && hasSeq(xmlData, "!NOTATION",i)) {
                     i += 9;//Not supported
                     const {index} = readNotationExp(xmlData,i+1);
                     i = index;
-                }else if( isComment) comment = true;
-                else throw new Error("Invalid DOCTYPE");
+                }else if( hasSeq(xmlData, "!--",i) ) comment = true;
+                else throw new Error(`Invalid DOCTYPE`);
 
                 angleBracketsCount++;
                 exp = "";
@@ -188,8 +188,12 @@ function readIdentifierVal(xmlData, i, type) {
 }
 
 function readElementExp(xmlData, i) {
+    // <!ELEMENT br EMPTY>
+    // <!ELEMENT div ANY>
+    // <!ELEMENT title (#PCDATA)>
+    // <!ELEMENT book (title, author+)>
     // <!ELEMENT name (content-model)>
-
+    
     // Skip leading whitespace after <!ELEMENT
     i = skipWhitespace(xmlData, i);
 
@@ -207,24 +211,26 @@ function readElementExp(xmlData, i) {
 
     // Skip whitespace after element name
     i = skipWhitespace(xmlData, i);
-
+    let contentModel = "";
     // Expect '(' to start content model
-    if (xmlData[i] !== "(") {
-        throw new Error(`Expected '(', found "${xmlData[i]}"`);
-    }
-    i++; // Move past '('
+    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 '('
 
-    // Read content model
-    let contentModel = "";
-    while (i < xmlData.length && xmlData[i] !== ")") {
-        contentModel += xmlData[i];
-        i++;
-    }
+        // Read content model
+        while (i < xmlData.length && xmlData[i] !== ")") {
+            contentModel += xmlData[i];
+            i++;
+        }
+        if (xmlData[i] !== ")") {
+            throw new Error("Unterminated content model");
+        }
 
-    if (xmlData[i] !== ")") {
-        throw new Error("Unterminated content model");
+    }else{
+        throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
     }
-
+    
     return {
         elementName,
         contentModel: contentModel.trim(),
@@ -348,56 +354,11 @@ function readAttlistExp(xmlData, i) {
     }
 }
 
-function isComment(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === '-' &&
-    xmlData[i+3] === '-') return true
-    return false
-}
-function isEntity(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'E' &&
-    xmlData[i+3] === 'N' &&
-    xmlData[i+4] === 'T' &&
-    xmlData[i+5] === 'I' &&
-    xmlData[i+6] === 'T' &&
-    xmlData[i+7] === 'Y') return true
-    return false
-}
-function isElement(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'E' &&
-    xmlData[i+3] === 'L' &&
-    xmlData[i+4] === 'E' &&
-    xmlData[i+5] === 'M' &&
-    xmlData[i+6] === 'E' &&
-    xmlData[i+7] === 'N' &&
-    xmlData[i+8] === 'T') return true
-    return false
-}
-
-function isAttlist(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'A' &&
-    xmlData[i+3] === 'T' &&
-    xmlData[i+4] === 'T' &&
-    xmlData[i+5] === 'L' &&
-    xmlData[i+6] === 'I' &&
-    xmlData[i+7] === 'S' &&
-    xmlData[i+8] === 'T') return true
-    return false
-}
-function isNotation(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'N' &&
-    xmlData[i+3] === 'O' &&
-    xmlData[i+4] === 'T' &&
-    xmlData[i+5] === 'A' &&
-    xmlData[i+6] === 'T' &&
-    xmlData[i+7] === 'I' &&
-    xmlData[i+8] === 'O' &&
-    xmlData[i+9] === 'N') return true
-    return false
+function hasSeq(data, seq,i){
+    for(let j=0;j<seq.length;j++){
+        if(seq[j]!==data[i+j+1]) return false;
+    }
+    return true;
 }
 
 function validateEntityName(name){

package/node_modules/inquirer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inquirer",
-  "version": "12.6.0",
+  "version": "12.8.2",
   "description": "A collection of common interactive command line user interfaces.",
   "keywords": [
     "answer",
@@ -74,17 +74,16 @@
     "tsc": "tshy"
   },
   "dependencies": {
-    "@inquirer/core": "^10.1.10",
-    "@inquirer/prompts": "^7.5.0",
-    "@inquirer/type": "^3.0.6",
+    "@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.17.4",
-    "@repo/tsconfig": "workspace:*",
+    "@arethetypeswrong/cli": "^0.18.2",
     "@types/mute-stream": "^0.0.4",
     "tshy": "^3.0.2"
   },
@@ -108,5 +107,5 @@
       "optional": true
     }
   },
-  "gitHead": "238c3af2ecf5fefb9b010fda99bb3a532fa4f61a"
+  "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
 }