lambda-live-debugger 1.11.6 → 1.12.0-alpha.1

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/pem.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Types copied from path-expression-matcher
+ * @version <version>
+ * @updated <date>
+ *
+ * Update this file when path-expression-matcher releases a new version.
+ * Source: https://github.com/NaturalIntelligence/path-expression-matcher
+ */
+
+/**
+ * Options for creating an Expression
+ */
+export interface ExpressionOptions {
+  /**
+   * Path separator character
+   * @default '.'
+   */
+  separator?: string;
+}
+
+/**
+ * Parsed segment from an expression pattern
+ */
+export interface Segment {
+  type: 'tag' | 'deep-wildcard';
+  tag?: string;
+  namespace?: string;
+  attrName?: string;
+  attrValue?: string;
+  position?: 'first' | 'last' | 'odd' | 'even' | 'nth';
+  positionValue?: number;
+}
+
+/**
+ * Expression - Parses and stores a tag pattern expression.
+ * Patterns are parsed once and stored in an optimized structure for fast matching.
+ * 
+ * @example
+ * ```typescript
+ * const expr = new Expression("root.users.user");
+ * const expr2 = new Expression("..user[id]:first");
+ * const expr3 = new Expression("root/users/user", { separator: '/' });
+ * ```
+ * 
+ * Pattern Syntax:
+ * - `root.users.user`      — Match exact path
+ * - `..user`               — Match "user" at any depth (deep wildcard)
+ * - `user[id]`             — Match user tag with "id" attribute
+ * - `user[id=123]`         — Match user tag where id="123"
+ * - `user:first`           — Match first occurrence of user tag
+ * - `ns::user`             — Match user tag with namespace "ns"
+ * - `ns::user[id]:first`   — Combine namespace, attribute, and position
+ */
+export class Expression {
+  readonly pattern: string;
+  readonly separator: string;
+  readonly segments: Segment[];
+
+  constructor(pattern: string, options?: ExpressionOptions);
+
+  get length(): number;
+  hasDeepWildcard(): boolean;
+  hasAttributeCondition(): boolean;
+  hasPositionSelector(): boolean;
+  toString(): string;
+}
+
+// ---------------------------------------------------------------------------
+// ReadonlyMatcher
+// ---------------------------------------------------------------------------
+
+/**
+ * A live read-only view of a {@link Matcher} instance, returned by {@link Matcher.readOnly}.
+ *
+ * All query and inspection methods work normally and always reflect the current
+ * state of the underlying matcher. State-mutating methods (`push`, `pop`,
+ * `reset`, `updateCurrent`, `restore`) are not present — calling them on the
+ * underlying Proxy throws a `TypeError` at runtime.
+ *
+ * This is the type received by all FXP user callbacks when `jPath: false`.
+ */
+export interface ReadonlyMatcher {
+  readonly separator: string;
+
+  /** Check if current path matches an Expression. */
+  matches(expression: Expression): boolean;
+
+  /** Get current tag name, or `undefined` if path is empty. */
+  getCurrentTag(): string | undefined;
+
+  /** Get current namespace, or `undefined` if not present. */
+  getCurrentNamespace(): string | undefined;
+
+  /** Get attribute value of the current node. */
+  getAttrValue(attrName: string): any;
+
+  /** Check if the current node has a given attribute. */
+  hasAttr(attrName: string): boolean;
+
+  /** Sibling position of the current node (child index in parent). */
+  getPosition(): number;
+
+  /** Occurrence counter of the current tag name at this level. */
+  getCounter(): number;
+
+  /** Number of nodes in the current path. */
+  getDepth(): number;
+
+  /** Current path as a string (e.g. `"root.users.user"`). */
+  toString(separator?: string, includeNamespace?: boolean): string;
+
+  /** Current path as an array of tag names. */
+  toArray(): string[];
+
+  /**
+   * Create a snapshot of the current state.
+   * The snapshot can be passed to the real {@link Matcher.restore} if needed.
+   */
+  snapshot(): MatcherSnapshot;
+}
+
+/** Internal node structure — exposed via snapshot only. */
+export interface PathNode {
+  tag: string;
+  namespace?: string;
+  position: number;
+  counter: number;
+  values?: Record<string, any>;
+}
+
+/** Snapshot of matcher state returned by `snapshot()` and `readOnly().snapshot()`. */
+export interface MatcherSnapshot {
+  path: PathNode[];
+  siblingStacks: Map<string, number>[];
+}

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/util.js

@@ -21,7 +21,7 @@ export function getAllMatches(string, regex) {
   return matches;
 }
 
-export const isName = function(string) {
+export const isName = function (string) {
   const match = regexName.exec(string);
   return !(match === null || typeof match === 'undefined');
 }
@@ -34,28 +34,6 @@ export function isEmptyObject(obj) {
   return Object.keys(obj).length === 0;
 }
 
-/**
- * Copy all the properties of a into b.
- * @param {*} target
- * @param {*} a
- */
-export function merge(target, a, arrayMode) {
-  if (a) {
-    const keys = Object.keys(a); // will return an array of own properties
-    const len = keys.length; //don't make it inline
-    for (let i = 0; i < len; i++) {
-      if (arrayMode === 'strict') {
-        target[keys[i]] = [ a[keys[i]] ];
-      } else {
-        target[keys[i]] = a[keys[i]];
-      }
-    }
-  }
-}
-/* exports.merge =function (b,a){
-  return Object.assign(b,a);
-} */
-
 export function getValue(v) {
   if (exports.isExist(v)) {
     return v;
@@ -64,5 +42,20 @@ export function getValue(v) {
   }
 }
 
-// const fakeCall = function(a) {return a;};
-// const fakeCallNoReturn = function() {};
+/**
+ * Dangerous property names that could lead to prototype pollution or security issues
+ */
+export const DANGEROUS_PROPERTY_NAMES = [
+  // '__proto__',
+  // 'constructor',
+  // 'prototype',
+  'hasOwnProperty',
+  'toString',
+  'valueOf',
+  '__defineGetter__',
+  '__defineSetter__',
+  '__lookupGetter__',
+  '__lookupSetter__'
+];
+
+export const criticalProperties = ["__proto__", "constructor", "prototype"];

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/v6/EntitiesParser.js

@@ -1,106 +1,106 @@
-const ampEntity = { regex: /&(amp|#38|#x26);/g, val : "&"};
+const ampEntity = { regex: /&(amp|#38|#x26);/g, val: "&" };
 const htmlEntities = {
-    "space": { regex: /&(nbsp|#160);/g, val: " " },
-    // "lt" : { regex: /&(lt|#60);/g, val: "<" },
-    // "gt" : { regex: /&(gt|#62);/g, val: ">" },
-    // "amp" : { regex: /&(amp|#38);/g, val: "&" },
-    // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
-    // "apos" : { regex: /&(apos|#39);/g, val: "'" },
-    "cent" : { regex: /&(cent|#162);/g, val: "¢" },
-    "pound" : { regex: /&(pound|#163);/g, val: "£" },
-    "yen" : { regex: /&(yen|#165);/g, val: "¥" },
-    "euro" : { regex: /&(euro|#8364);/g, val: "€" },
-    "copyright" : { regex: /&(copy|#169);/g, val: "©" },
-    "reg" : { regex: /&(reg|#174);/g, val: "®" },
-    "inr" : { regex: /&(inr|#8377);/g, val: "₹" },
-    "num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCodePoint(Number.parseInt(str, 10)) },
-    "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCodePoint(Number.parseInt(str, 16)) },
+  "space": { regex: /&(nbsp|#160);/g, val: " " },
+  // "lt" : { regex: /&(lt|#60);/g, val: "<" },
+  // "gt" : { regex: /&(gt|#62);/g, val: ">" },
+  // "amp" : { regex: /&(amp|#38);/g, val: "&" },
+  // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
+  // "apos" : { regex: /&(apos|#39);/g, val: "'" },
+  "cent": { regex: /&(cent|#162);/g, val: "¢" },
+  "pound": { regex: /&(pound|#163);/g, val: "£" },
+  "yen": { regex: /&(yen|#165);/g, val: "¥" },
+  "euro": { regex: /&(euro|#8364);/g, val: "€" },
+  "copyright": { regex: /&(copy|#169);/g, val: "©" },
+  "reg": { regex: /&(reg|#174);/g, val: "®" },
+  "inr": { regex: /&(inr|#8377);/g, val: "₹" },
+  "num_dec": { regex: /&#([0-9]{1,7});/g, val: (_, str) => String.fromCodePoint(Number.parseInt(str, 10)) },
+  "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str) => String.fromCodePoint(Number.parseInt(str, 16)) },
 };
-export default class EntitiesParser{
-    constructor(replaceHtmlEntities) {
-      this.replaceHtmlEntities = replaceHtmlEntities;
-      this.docTypeEntities = {};
-      this.lastEntities = {
-        "apos" : { regex: /&(apos|#39|#x27);/g, val : "'"},
-        "gt" : { regex: /&(gt|#62|#x3E);/g, val : ">"},
-        "lt" : { regex: /&(lt|#60|#x3C);/g, val : "<"},
-        "quot" : { regex: /&(quot|#34|#x22);/g, val : "\""},
-      };
-    }
+export default class EntitiesParser {
+  constructor(replaceHtmlEntities) {
+    this.replaceHtmlEntities = replaceHtmlEntities;
+    this.docTypeEntities = {};
+    this.lastEntities = {
+      "apos": { regex: /&(apos|#39|#x27);/g, val: "'" },
+      "gt": { regex: /&(gt|#62|#x3E);/g, val: ">" },
+      "lt": { regex: /&(lt|#60|#x3C);/g, val: "<" },
+      "quot": { regex: /&(quot|#34|#x22);/g, val: "\"" },
+    };
+  }
 
-    addExternalEntities(externalEntities){
-        const entKeys = Object.keys(externalEntities);
-        for (let i = 0; i < entKeys.length; i++) {
-          const ent = entKeys[i];
-          this.addExternalEntity(ent,externalEntities[ent])
-        }
+  addExternalEntities(externalEntities) {
+    const entKeys = Object.keys(externalEntities);
+    for (let i = 0; i < entKeys.length; i++) {
+      const ent = entKeys[i];
+      this.addExternalEntity(ent, externalEntities[ent])
     }
-    addExternalEntity(key,val){
-      validateEntityName(key);
-      const escaped = key.replace(/[.\-+*:]/g, '\\.');
-      if(val.indexOf("&") !== -1) {
-        reportWarning(`Entity ${key} is not added as '&' is found in value;`)
-        return;
-      }else{
-        this.lastEntities[key] = {
-          regex: new RegExp("&"+escaped+";","g"),
-          val : val
-        }
+  }
+  addExternalEntity(key, val) {
+    validateEntityName(key);
+    const escaped = key.replace(/[.\-+*:]/g, '\\.');
+    if (val.indexOf("&") !== -1) {
+      reportWarning(`Entity ${key} is not added as '&' is found in value;`)
+      return;
+    } else {
+      this.lastEntities[key] = {
+        regex: new RegExp("&" + escaped + ";", "g"),
+        val: val
       }
     }
+  }
 
-    addDocTypeEntities(entities){
-        const entKeys = Object.keys(entities);
-        for (let i = 0; i < entKeys.length; i++) {
-          const ent = entKeys[i];
-          const escaped = ent.replace(/[.\-+*:]/g, '\\.');
-          this.docTypeEntities[ent] = {
-             regex: new RegExp("&"+escaped+";","g"),
-             val : entities[ent]
-          }
-        }
+  addDocTypeEntities(entities) {
+    const entKeys = Object.keys(entities);
+    for (let i = 0; i < entKeys.length; i++) {
+      const ent = entKeys[i];
+      const escaped = ent.replace(/[.\-+*:]/g, '\\.');
+      this.docTypeEntities[ent] = {
+        regex: new RegExp("&" + escaped + ";", "g"),
+        val: entities[ent]
+      }
     }
+  }
 
-    parse(val){
-        return this.replaceEntitiesValue(val)
-    }
+  parse(val) {
+    return this.replaceEntitiesValue(val)
+  }
 
-    /**
-     * 1. Replace DOCTYPE entities 
-     * 2. Replace external entities 
-     * 3. Replace HTML entities if asked
-     * @param {string} val 
-     */
-    replaceEntitiesValue(val){
-        if(typeof val === "string" && val.length > 0){
-            for(let entityName in this.docTypeEntities){
-                const entity = this.docTypeEntities[entityName];
-                val = val.replace( entity.regx, entity.val);
-              }
-              for(let entityName in this.lastEntities){
-                const entity = this.lastEntities[entityName];
-                val = val.replace( entity.regex, entity.val);
-              }
-              if(this.replaceHtmlEntities){
-                for(let entityName in htmlEntities){
-                  const entity = htmlEntities[entityName];
-                  val = val.replace( entity.regex, entity.val);
-                }
-              }
-            val = val.replace( ampEntity.regex, ampEntity.val);
+  /**
+   * 1. Replace DOCTYPE entities 
+   * 2. Replace external entities 
+   * 3. Replace HTML entities if asked
+   * @param {string} val 
+   */
+  replaceEntitiesValue(val) {
+    if (typeof val === "string" && val.length > 0) {
+      for (let entityName in this.docTypeEntities) {
+        const entity = this.docTypeEntities[entityName];
+        val = val.replace(entity.regx, entity.val);
+      }
+      for (let entityName in this.lastEntities) {
+        const entity = this.lastEntities[entityName];
+        val = val.replace(entity.regex, entity.val);
+      }
+      if (this.replaceHtmlEntities) {
+        for (let entityName in htmlEntities) {
+          const entity = htmlEntities[entityName];
+          val = val.replace(entity.regex, entity.val);
         }
-        return val;
+      }
+      val = val.replace(ampEntity.regex, ampEntity.val);
     }
+    return val;
+  }
 }
 
 //an entity name should not contains special characters that may be used in regex
 //Eg !?\\\/[]$%{}^&*()<>
 const specialChar = "!?\\/[]$%{}^&*()<>|+";
 
-function validateEntityName(name){
-    for (let i = 0; i < specialChar.length; i++) {
-        const ch = specialChar[i];
-        if(name.indexOf(ch) !== -1) throw new Error(`Invalid character ${ch} in entity name`);
-    }
-    return name;
+function validateEntityName(name) {
+  for (let i = 0; i < specialChar.length; i++) {
+    const ch = specialChar[i];
+    if (name.indexOf(ch) !== -1) throw new Error(`Invalid character ${ch} in entity name`);
+  }
+  return name;
 }

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/v6/OptionsBuilder.js

@@ -1,5 +1,5 @@
 
-import {JsObjOutputBuilder} from './OutputBuilders/JsObjBuilder.js';
+import { JsObjOutputBuilder } from './OutputBuilders/JsObjBuilder.js';
 
 export const defaultOptions = {
   preserveOrder: false,
@@ -9,16 +9,16 @@ export const defaultOptions = {
   // isArray: () => false, //User will set it
   htmlEntities: false,
   // skipEmptyListItem: false
-  tags:{
+  tags: {
     unpaired: [],
-    nameFor:{
+    nameFor: {
       cdata: false,
       comment: false,
       text: '#text'
     },
     separateTextProperty: false,
   },
-  attributes:{
+  attributes: {
     ignore: false,
     booleanType: true,
     entities: true,
@@ -34,19 +34,19 @@ export const defaultOptions = {
   stop: [], //given tagPath will not be parsed. innerXML will be set as string value
   OutputBuilder: new JsObjOutputBuilder(),
 };
-   
-export const buildOptions = function(options) {
-  const finalOptions = { ... defaultOptions};
-  copyProperties(finalOptions,options)
+
+export const buildOptions = function (options) {
+  const finalOptions = { ...defaultOptions };
+  copyProperties(finalOptions, options)
   return finalOptions;
 };
 
 function copyProperties(target, source) {
   for (let key in source) {
-    if (source.hasOwnProperty(key)) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
       if (key === 'OutputBuilder') {
         target[key] = source[key];
-      }else if (typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      } else if (typeof source[key] === 'object' && !Array.isArray(source[key])) {
         // Recursively copy nested properties
         if (typeof target[key] === 'undefined') {
           target[key] = {};

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/v6/OutputBuilders/BaseOutputBuilder.js

@@ -1,14 +1,14 @@
-export default class BaseOutputBuilder{
-  constructor(){
+export default class BaseOutputBuilder {
+  constructor() {
     // this.attributes = {};
   }
 
-  addAttribute(name, value){
-    if(this.options.onAttribute){
+  addAttribute(name, value) {
+    if (this.options.onAttribute) {
       //TODO: better to pass tag path
       const v = this.options.onAttribute(name, value, this.tagName);
-      if(v) this.attributes[v.name] = v.value;
-    }else{
+      if (v) this.attributes[v.name] = v.value;
+    } else {
       name = this.options.attributes.prefix + name + this.options.attributes.suffix;
       this.attributes[name] = this.parseValue(value, this.options.attributes.valueParsers);
     }
@@ -19,37 +19,37 @@ export default class BaseOutputBuilder{
    * @param {string} val 
    * @returns {any} parsed value if matching parser found
    */
-    parseValue = function(val, valParsers){
-      for (let i = 0; i < valParsers.length; i++) {
-        let valParser = valParsers[i];
-        if(typeof valParser === "string"){
-          valParser = this.registeredParsers[valParser];
-        }
-        if(valParser){
-          val = valParser.parse(val);
-        }
+  parseValue = function (val, valParsers) {
+    for (let i = 0; i < valParsers.length; i++) {
+      let valParser = valParsers[i];
+      if (typeof valParser === "string") {
+        valParser = this.registeredParsers[valParser];
+      }
+      if (valParser) {
+        val = valParser.parse(val);
       }
-      return val;
     }
+    return val;
+  }
 
   /**
    * To add a nested empty tag.
    * @param {string} key 
    * @param {any} val 
    */
-  _addChild(key, val){}
+  _addChild(key, val) { }
 
   /**
    * skip the comment if property is not set
    */
-  addComment(text){
-    if(this.options.nameFor.comment)
+  addComment(text) {
+    if (this.options.nameFor.comment)
       this._addChild(this.options.nameFor.comment, text);
   }
 
   //store CDATA separately if property is set
   //otherwise add to tag's value
-  addCdata(text){
+  addCdata(text) {
     if (this.options.nameFor.cdata) {
       this._addChild(this.options.nameFor.cdata, text);
     } else {
@@ -59,9 +59,9 @@ export default class BaseOutputBuilder{
 
   addRawValue = text => this.addValue(text);
 
-  addDeclaration(){
-    if(!this.options.declaration){
-    }else{
+  addDeclaration() {
+    if (!this.options.declaration) {
+    } else {
       this.addPi("?xml");
     }
     this.attributes = {}

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/src/v6/OutputBuilders/JsArrBuilder.js

@@ -1,16 +1,16 @@
-import {buildOptions,registerCommonValueParsers} from './ParserOptionsBuilder.js';
+import { buildOptions, registerCommonValueParsers } from './ParserOptionsBuilder.js';
 
-export default class OutputBuilder{
-  constructor(options){
+export default class OutputBuilder {
+  constructor(options) {
     this.options = buildOptions(options);
-      this.registeredParsers = registerCommonValueParsers(this.options);
-    }
-    
-    registerValueParser(name,parserInstance){//existing name will override the parser without warning
-      this.registeredParsers[name] = parserInstance;
-    }
+    this.registeredParsers = registerCommonValueParsers(this.options);
+  }
+
+  registerValueParser(name, parserInstance) {//existing name will override the parser without warning
+    this.registeredParsers[name] = parserInstance;
+  }
 
-  getInstance(parserOptions){
+  getInstance(parserOptions) {
     return new JsArrBuilder(parserOptions, this.options, this.registeredParsers);
   }
 }
@@ -18,9 +18,9 @@ export default class OutputBuilder{
 const rootName = '!js_arr';
 import BaseOutputBuilder from './BaseOutputBuilder.js';
 
-class JsArrBuilder extends BaseOutputBuilder{
+class JsArrBuilder extends BaseOutputBuilder {
 
-  constructor(parserOptions, options,registeredParsers) {
+  constructor(parserOptions, options, registeredParsers) {
     super();
     this.tagsStack = [];
     this.parserOptions = parserOptions;
@@ -32,10 +32,10 @@ class JsArrBuilder extends BaseOutputBuilder{
     this.attributes = {};
   }
 
-  addTag(tag){
+  addTag(tag) {
     //when a new tag is added, it should be added as child of current node
     //TODO: shift this check to the parser
-    if(tag.name === "__proto__") tag.name = "#__proto__";
+    if (tag.name === "__proto__") tag.name = "#__proto__";
 
     this.tagsStack.push(this.currentNode);
     this.currentNode = new Node(tag.name, this.attributes);
@@ -47,23 +47,23 @@ class JsArrBuilder extends BaseOutputBuilder{
    * @param {Node} node 
    * @returns boolean: true if the node should not be added
    */
-  closeTag(){
+  closeTag() {
     const node = this.currentNode;
     this.currentNode = this.tagsStack.pop(); //set parent node in scope
-    if(this.options.onClose !== undefined){
+    if (this.options.onClose !== undefined) {
       //TODO TagPathMatcher 
-      const resultTag = this.options.onClose(node, 
-        new TagPathMatcher(this.tagsStack,node));
+      const resultTag = this.options.onClose(node,
+        new TagPathMatcher(this.tagsStack, node));
 
-      if(resultTag) return;
+      if (resultTag) return;
     }
     this.currentNode.child.push(node);  //to parent node
   }
 
   //Called by parent class methods
-  _addChild(key, val){
+  _addChild(key, val) {
     // if(key === "__proto__") tagName = "#__proto__";
-    this.currentNode.child.push( {[key]: val });
+    this.currentNode.child.push({ [key]: val });
     // this.currentNode.leafType = false;
   }
 
@@ -71,31 +71,31 @@ class JsArrBuilder extends BaseOutputBuilder{
    * Add text value child node 
    * @param {string} text 
    */
-  addValue(text){
-    this.currentNode.child.push( {[this.options.nameFor.text]: this.parseValue(text, this.options.tags.valueParsers) });
+  addValue(text) {
+    this.currentNode.child.push({ [this.options.nameFor.text]: this.parseValue(text, this.options.tags.valueParsers) });
   }
 
-  addPi(name){
+  addPi(name) {
     //TODO: set pi flag
-    if(!this.options.ignorePiTags){
+    if (!this.options.ignorePiTags) {
       const node = new Node(name, this.attributes);
       this.currentNode[":@"] = this.attributes;
       this.currentNode.child.push(node);
     }
     this.attributes = {};
   }
-  getOutput(){
+  getOutput() {
     return this.root.child[0];
   }
 }
 
 
 
-class Node{
-  constructor(tagname, attributes){
+class Node {
+  constructor(tagname, attributes) {
     this.tagname = tagname;
     this.child = []; //nested tags, text, cdata, comments
-    if(attributes && Object.keys(attributes).length > 0)
+    if (attributes && Object.keys(attributes).length > 0)
       this[":@"] = attributes;
   }
 }