lambda-live-debugger 1.12.5 → 1.12.7

package/node_modules/path-expression-matcher/src/Matcher.js

@@ -76,6 +76,26 @@ export class MatcherView {
     return current.values !== undefined && attrName in current.values;
   }
 
+  /**
+   * Get the value of a "kept" attribute from the nearest ancestor (or
+   * current node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
+   * @param {string} attrName
+   * @returns {*}
+   */
+  getAnyParentAttr(attrName) {
+    return this._matcher.getAnyParentAttr(attrName);
+  }
+
+  /**
+   * Check whether any ancestor (or the current node) kept the given
+   * attribute via `push(tag, attrs, ns, { keep: [...] })`.
+   * @param {string} attrName
+   * @returns {boolean}
+   */
+  hasAnyParentAttr(attrName) {
+    return this._matcher.hasAnyParentAttr(attrName);
+  }
+
   /**
    * Get current node's sibling position (child index in parent).
    * @returns {number}
@@ -184,6 +204,9 @@ export default class Matcher {
     // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level
     this._pathStringCache = null;
     this._view = new MatcherView(this);
+
+    // Kept-attribute stack: only populated when push() is called with options.keep.
+    this._keptAttrs = [];
   }
 
   /**
@@ -191,8 +214,10 @@ export default class Matcher {
    * @param {string} tagName
    * @param {Object|null} [attrValues=null]
    * @param {string|null} [namespace=null]
+   * @param {Object|null} [options=null]
+   * @param {string[]} [options.keep] - Names of attributes (from attrValues)
    */
-  push(tagName, attrValues = null, namespace = null) {
+  push(tagName, attrValues = null, namespace = null, options = null) {
     this._pathStringCache = null;
 
     // Remove values from previous current node (now becoming ancestor)
@@ -202,26 +227,29 @@ export default class Matcher {
 
     // Get or create sibling tracking for current level
     const currentLevel = this.path.length;
-    if (!this.siblingStacks[currentLevel]) {
-      this.siblingStacks[currentLevel] = new Map();
+    let level = this.siblingStacks[currentLevel];
+    if (!level) {
+      // `counts` tells same-name siblings apart (the "counter" — nth <item>
+      // among other <item>s). `total` is every child seen at this level so
+      // far, kept as a running number instead of re-added from `counts` on
+      // every push — a parent with many differently-named children would
+      // otherwise cost more per child the more distinct names it has.
+      level = { counts: new Map(), total: 0 };
+      this.siblingStacks[currentLevel] = level;
     }
 
-    const siblings = this.siblingStacks[currentLevel];
-
     // Create a unique key for sibling tracking that includes namespace
     const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;
 
     // Calculate counter (how many times this tag appeared at this level)
-    const counter = siblings.get(siblingKey) || 0;
+    const counter = level.counts.get(siblingKey) || 0;
 
-    // Calculate position (total children at this level so far)
-    let position = 0;
-    for (const count of siblings.values()) {
-      position += count;
-    }
+    // Position = total children at this level seen before this one.
+    const position = level.total;
 
-    // Update sibling count for this tag
-    siblings.set(siblingKey, counter + 1);
+    // Update sibling count for this tag, and the level's running total.
+    level.counts.set(siblingKey, counter + 1);
+    level.total++;
 
     // Create new node
     const node = {
@@ -239,6 +267,24 @@ export default class Matcher {
     }
 
     this.path.push(node);
+
+    // Depth of the node we just pushed (1-based, matches this.path.length)
+    const depth = this.path.length;
+
+    // Copy only the requested attributes into the kept-attrs stack. This is
+    // the one part of push() whose cost scales with input (O(keep.length))
+    // rather than being O(1) — by design, since the caller is explicitly
+    // opting in for specific attribute names. No options/keep => zero added
+    // cost beyond the two property reads below.
+    const keep = options !== null ? options.keep : null;
+    if (keep !== null && keep !== undefined && keep.length > 0 && attrValues) {
+      for (let i = 0; i < keep.length; i++) {
+        const name = keep[i];
+        if (attrValues[name] !== undefined) {
+          this._keptAttrs.push({ depth, name, value: attrValues[name] });
+        }
+      }
+    }
   }
 
   /**
@@ -255,6 +301,18 @@ export default class Matcher {
       this.siblingStacks.length = this.path.length + 1;
     }
 
+    // Drop any kept attributes that belonged to the popped node (or deeper).
+    // _keptAttrs is depth-ordered (push only ever appends increasing depths),
+    // so this is a backward scan that stops at the first surviving entry —
+    // typically O(1) since kept attrs are rare by design.
+    const poppedDepth = this.path.length + 1;
+    while (
+      this._keptAttrs.length > 0 &&
+      this._keptAttrs[this._keptAttrs.length - 1].depth >= poppedDepth
+    ) {
+      this._keptAttrs.pop();
+    }
+
     return node;
   }
 
@@ -309,6 +367,38 @@ export default class Matcher {
     return current.values !== undefined && attrName in current.values;
   }
 
+  /**
+   * Get the value of a "kept" attribute from the nearest ancestor (or
+   * current node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
+   * Unlike getAttrValue(), this works regardless of how deep the path has
+   * gone since the attribute was pushed — but only for attribute names that
+   * were explicitly marked with `keep` at push time. Cost is proportional to
+   * the number of currently-kept attributes (typically 0-3), not path depth.
+   * @param {string} attrName
+   * @returns {*} the value, or undefined if no ancestor kept this attribute
+   */
+  getAnyParentAttr(attrName) {
+    const kept = this._keptAttrs;
+    for (let i = kept.length - 1; i >= 0; i--) {
+      if (kept[i].name === attrName) return kept[i].value;
+    }
+    return undefined;
+  }
+
+  /**
+   * Check whether any ancestor (or the current node) kept the given
+   * attribute via `push(tag, attrs, ns, { keep: [...] })`.
+   * @param {string} attrName
+   * @returns {boolean}
+   */
+  hasAnyParentAttr(attrName) {
+    const kept = this._keptAttrs;
+    for (let i = kept.length - 1; i >= 0; i--) {
+      if (kept[i].name === attrName) return true;
+    }
+    return false;
+  }
+
   /**
    * Get current node's sibling position (child index in parent).
    * @returns {number}
@@ -385,6 +475,7 @@ export default class Matcher {
     this._pathStringCache = null;
     this.path = [];
     this.siblingStacks = [];
+    this._keptAttrs = [];
   }
 
   /**
@@ -534,7 +625,8 @@ export default class Matcher {
   snapshot() {
     return {
       path: this.path.map(node => ({ ...node })),
-      siblingStacks: this.siblingStacks.map(map => new Map(map))
+      siblingStacks: this.siblingStacks.map(level => level ? { counts: new Map(level.counts), total: level.total } : level),
+      keptAttrs: this._keptAttrs.map(entry => ({ ...entry }))
     };
   }
 
@@ -545,7 +637,8 @@ export default class Matcher {
   restore(snapshot) {
     this._pathStringCache = null;
     this.path = snapshot.path.map(node => ({ ...node }));
-    this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));
+    this.siblingStacks = snapshot.siblingStacks.map(level => level ? { counts: new Map(level.counts), total: level.total } : level);
+    this._keptAttrs = (snapshot.keptAttrs || []).map(entry => ({ ...entry }));
   }
 
   /**
@@ -567,4 +660,4 @@ export default class Matcher {
   readOnly() {
     return this._view;
   }
-}
+}

package/node_modules/path-expression-matcher/src/index.d.ts

@@ -186,6 +186,42 @@ export interface MatcherSnapshot {
    * Copy of sibling tracking maps
    */
   siblingStacks: Map<string, number>[];
+
+  /**
+   * Copy of the kept-attrs stack (see {@link PushOptions.keep})
+   */
+  keptAttrs: KeptAttrEntry[];
+}
+
+/**
+ * A single entry in the matcher's kept-attrs stack — an attribute value
+ * explicitly retained at push time via `{ keep: [...] }` so it remains
+ * reachable from descendants after the owning node is no longer current.
+ */
+export interface KeptAttrEntry {
+  /** Path depth (1-based) of the node that declared this kept attribute */
+  depth: number;
+  /** Attribute name */
+  name: string;
+  /** Attribute value at push time */
+  value: any;
+}
+
+/**
+ * Options for {@link Matcher#push}
+ */
+export interface PushOptions {
+  /**
+   * Names of attributes (from `attrValues`) to retain for ancestor lookup
+   * (`getAnyParentAttr` / `hasAnyParentAttr`) even after this node is no
+   * longer the current node.
+   *
+   * Use sparingly — this is for attributes you know you'll need much deeper
+   * in the tree (e.g. `xml:space`, a SOAP envelope's `version`), not a
+   * general substitute for `getAttrValue()`. Cost is proportional to
+   * `keep.length`, independent of path depth.
+   */
+  keep?: string[];
 }
 
 /**
@@ -227,6 +263,16 @@ export class MatcherView {
   getCurrentNamespace(): string | undefined;
   getAttrValue(attrName: string): any;
   hasAttr(attrName: string): boolean;
+  /**
+   * Get the value of a "kept" attribute from the nearest ancestor (or current
+   * node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
+   */
+  getAnyParentAttr(attrName: string): any;
+  /**
+   * Check whether any ancestor (or the current node) kept the given
+   * attribute via `push(tag, attrs, ns, { keep: [...] })`.
+   */
+  hasAnyParentAttr(attrName: string): boolean;
   getPosition(): number;
   getCounter(): number;
   /** @deprecated Use getPosition() or getCounter() instead */
@@ -285,15 +331,23 @@ export class Matcher {
    * @param tagName - Name of the tag
    * @param attrValues - Attribute key-value pairs for current node (optional)
    * @param namespace - Namespace for the tag (optional)
+   * @param options - Push options, e.g. `{ keep: ['version'] }` to retain
+   *   specific attributes for ancestor lookup after this node stops being current
    *
    * @example
    * ```typescript
    * matcher.push("user", { id: "123", type: "admin" });
    * matcher.push("user", { id: "456" }, "ns");
    * matcher.push("container", null);
+   * matcher.push("Body", { version: "1.1" }, "soap", { keep: ["version"] });
    * ```
    */
-  push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): void;
+  push(
+    tagName: string,
+    attrValues?: Record<string, any> | null,
+    namespace?: string | null,
+    options?: PushOptions | null
+  ): void;
 
   /**
    * Pop the last tag from the path.
@@ -329,6 +383,18 @@ export class Matcher {
   getCurrentNamespace(): string | undefined;
   getAttrValue(attrName: string): any;
   hasAttr(attrName: string): boolean;
+  /**
+   * Get the value of a "kept" attribute from the nearest ancestor (or current
+   * node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
+   * Cost is proportional to the number of currently-kept attributes, not
+   * path depth.
+   */
+  getAnyParentAttr(attrName: string): any;
+  /**
+   * Check whether any ancestor (or the current node) kept the given
+   * attribute via `push(tag, attrs, ns, { keep: [...] })`.
+   */
+  hasAnyParentAttr(attrName: string): boolean;
   getPosition(): number;
   getCounter(): number;
   /** @deprecated Use getPosition() or getCounter() instead */

package/node_modules/path-expression-matcher/src/index.js

@@ -23,7 +23,8 @@
 
 import Expression from './Expression.js';
 import Matcher from './Matcher.js';
+import { MatcherView } from './Matcher.js';
 import ExpressionSet from './ExpressionSet.js';
 
-export { Expression, Matcher, ExpressionSet };
-export default { Expression, Matcher, ExpressionSet };
+export { Expression, Matcher, MatcherView, ExpressionSet };
+export default { Expression, Matcher, MatcherView, ExpressionSet };

package/node_modules/toml/README.md

@@ -8,18 +8,17 @@ If you haven't heard of TOML, well you're just missing out. [Go check it out now
 TOML Spec Support
 -----------------
 
-toml-node supports [TOML v1.1.0](https://toml.io/en/v1.1.0), scoring **673/680 (99.0%)** on the official [toml-test](https://github.com/toml-lang/toml-test) compliance suite:
+toml-node supports [TOML v1.1.0](https://toml.io/en/v1.1.0), scoring **702/708 (99.2%)** on the official [toml-test](https://github.com/toml-lang/toml-test) compliance suite:
 
 | | Pass | Total | Rate |
 |---|---|---|---|
-| Valid tests | 213 | 214 | 99.5% |
-| Invalid tests | 460 | 466 | 98.7% |
-| **Total** | **673** | **680** | **99.0%** |
+| Valid tests | 218 | 218 | 100% |
+| Invalid tests | 484 | 490 | 98.8% |
+| **Total** | **702** | **708** | **99.2%** |
 
-The 7 remaining failures are inherent JavaScript platform limitations shared by all JS TOML parsers:
+The 6 remaining failures are inherent JavaScript platform limitations shared by all JS TOML parsers: they cover UTF-8 encoding validation, which Node.js handles at the engine level before the parser sees the data.
 
-- 1 valid test: 64-bit integer precision (`Number` can't represent values beyond `Number.MAX_SAFE_INTEGER`)
-- 6 invalid tests: UTF-8 encoding validation (Node.js handles UTF-8 decoding at the engine level before the parser sees the data)
+Note that integers beyond `Number.MAX_SAFE_INTEGER` require the [`bigint` option](#integer-range-and-bigint) to parse losslessly; without it they throw a parse error rather than silently losing precision.
 
 ### Feature Support
 
@@ -60,6 +59,35 @@ try {
 }
 ```
 
+### Nesting Depth Limit
+
+To guard against stack overflow on maliciously deep input, arrays and inline tables may nest at most 500 levels deep by default; input past the limit throws a normal parse error. Adjust the limit with the `maxDepth` option:
+
+```javascript
+toml.parse(someTomlString, { maxDepth: 100 });
+```
+
+### Integer Range and BigInt
+
+TOML requires parsers to handle the full range of 64-bit signed integers, but JavaScript's `number` type can only represent integers up to `Number.MAX_SAFE_INTEGER` (2⁵³ − 1) losslessly. By default, `toml.parse` returns integers as `number` and throws a parse error when a value falls outside the safe range, rather than silently returning a rounded value:
+
+```javascript
+toml.parse('id = 771752188537605140');
+// Error: Integer 771752188537605140 cannot be represented losslessly
+// as a JavaScript number. Use the `bigint` option to parse integers
+// as BigInt values.
+```
+
+Pass `bigint: true` to instead parse **all** integers as `BigInt`, preserving the full 64-bit range:
+
+```javascript
+const data = toml.parse('id = 771752188537605140\ncount = 3', { bigint: true });
+data.id     // 771752188537605140n
+data.count  // 3n
+```
+
+Integers outside the 64-bit signed range always throw, in either mode, as required by the spec. Floats are unaffected by all of this: TOML floats are IEEE 754 binary64 values, which is exactly what a JavaScript `number` is, so every TOML float is represented as faithfully as the spec intends.
+
 ### Date/Time Values
 
 Offset date-times are returned as JavaScript `Date` objects. Local date-times, local dates, and local times are returned as strings since they have no timezone information and can't be losslessly represented as `Date`:
@@ -78,6 +106,52 @@ typeof data.ld             // "string"
 typeof data.lt             // "string"
 ```
 
+#### Temporal Support
+
+Pass `useTemporal: true` to have date/time values returned as
+[Temporal](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Temporal)
+objects instead:
+
+| TOML type        | Returned as               |
+| ---------------- | ------------------------- |
+| Offset date-time | `Temporal.ZonedDateTime`  |
+| Local date-time  | `Temporal.PlainDateTime`  |
+| Local date       | `Temporal.PlainDate`      |
+| Local time       | `Temporal.PlainTime`      |
+
+```javascript
+const data = toml.parse(`
+odt = 1979-05-27T00:32:00-07:00
+ldt = 1979-05-27T07:32:00
+ld  = 1979-05-27
+lt  = 07:32:00
+`, { useTemporal: true });
+
+data.odt.toString()  // "1979-05-27T00:32:00-07:00[-07:00]"
+data.ldt.toString()  // "1979-05-27T07:32:00"
+data.ld.toString()   // "1979-05-27"
+data.lt.toString()   // "07:32:00"
+```
+
+Offset date-times become `Temporal.ZonedDateTime` values whose time zone is
+the original UTC offset (`Z` maps to the `UTC` time zone), so the offset
+written in the TOML document is preserved — unlike the default `Date`
+representation, which loses it. Fractional seconds beyond nanosecond
+precision are truncated, as permitted by the TOML spec.
+
+`useTemporal` requires a runtime with the `Temporal` global. On runtimes
+that don't provide it yet, pass an implementation such as
+[`@js-temporal/polyfill`](https://www.npmjs.com/package/@js-temporal/polyfill)
+via the `temporal` option:
+
+```javascript
+const { Temporal } = require('@js-temporal/polyfill');
+const data = toml.parse(someTomlString, { useTemporal: true, temporal: Temporal });
+```
+
+Once `Temporal` is broadly available, Temporal output is expected to become
+the default behavior in a future major version.
+
 ### Special Float Values
 
 `inf` and `nan` are returned as JavaScript `Infinity` and `NaN`:

package/node_modules/toml/index.d.ts

@@ -1,3 +1,56 @@
 declare module 'toml' {
-  export function parse(input: string): any;
+  /**
+   * A minimal structural subset of the `Temporal` global, used to supply an
+   * alternate implementation (e.g. from `@js-temporal/polyfill`) on runtimes
+   * without native Temporal support.
+   */
+  export interface TemporalLike {
+    ZonedDateTime: { from(item: string): any };
+    PlainDateTime: { from(item: string): any };
+    PlainDate: { from(item: string): any };
+    PlainTime: { from(item: string): any };
+  }
+
+  export interface ParseOptions {
+    /**
+     * Maximum nesting depth for arrays and inline tables. Parsing input nested
+     * deeper than this throws a parse error rather than overflowing the stack.
+     * Defaults to 500.
+     */
+    maxDepth?: number;
+
+    /**
+     * When true, all integer values are returned as `BigInt` instead of
+     * `number`, preserving the full 64-bit signed integer range required by
+     * TOML. When false (the default), integers outside
+     * `Number.MIN_SAFE_INTEGER`..`Number.MAX_SAFE_INTEGER` throw a parse
+     * error rather than silently losing precision.
+     *
+     * Floats are unaffected: TOML floats are IEEE 754 binary64, which is
+     * exactly what a JavaScript number is.
+     */
+    bigint?: boolean;
+
+    /**
+     * When true, date/time values are returned as Temporal objects instead of
+     * the default representations:
+     *
+     * - Offset date-time: `Temporal.ZonedDateTime` (instead of `Date`)
+     * - Local date-time:  `Temporal.PlainDateTime` (instead of `string`)
+     * - Local date:       `Temporal.PlainDate` (instead of `string`)
+     * - Local time:       `Temporal.PlainTime` (instead of `string`)
+     *
+     * Requires a global `Temporal` object, or an implementation passed via
+     * the `temporal` option.
+     */
+    useTemporal?: boolean;
+
+    /**
+     * The Temporal implementation to use when `useTemporal` is set. Defaults
+     * to the global `Temporal` object if one is available.
+     */
+    temporal?: TemporalLike;
+  }
+
+  export function parse(input: string, options?: ParseOptions): any;
 }

package/node_modules/toml/index.js

@@ -2,9 +2,9 @@ var parser = require('./lib/parser');
 var compiler = require('./lib/compiler');
 
 module.exports = {
-  parse: function(input) {
+  parse: function(input, options) {
     var str = input.toString();
-    var nodes = parser.parse(str);
-    return compiler.compile(nodes, str);
+    var nodes = parser.parse(str, options);
+    return compiler.compile(nodes, str, options);
   }
 };

package/node_modules/toml/lib/compiler.js

@@ -1,5 +1,24 @@
 "use strict";
-function compile(nodes, inputText) {
+
+var INT64_MIN = -(2n ** 63n);
+var INT64_MAX = 2n ** 63n - 1n;
+var MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+var MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
+
+function compile(nodes, inputText, options) {
+  options = options || {};
+  var temporal = null;
+  if (options.useTemporal) {
+    temporal = options.temporal || (typeof Temporal !== "undefined" ? Temporal : null);
+    if (!temporal) {
+      throw new Error(
+        "The `useTemporal` option was set, but no Temporal implementation is available. " +
+        "Use a runtime with global `Temporal` support, or provide an implementation " +
+        "(e.g. from the `@js-temporal/polyfill` package) via the `temporal` option."
+      );
+    }
+  }
+
   var assignedPaths = new Set();
   var valueAssignments = new Set();
   var explicitTablePaths = new Set();
@@ -89,13 +108,57 @@ function compile(nodes, inputText) {
 
 
   function reduceValueNode(node) {
-    if (node.type === "Array") {
+    if (node.type === "Integer") {
+      return reduceInteger(node);
+    } else if (node.type === "Array") {
       return reduceArray(node.value);
     } else if (node.type === "InlineTable") {
       return reduceInlineTableNode(node.value);
-    } else {
-      return node.value;
+    } else if (temporal) {
+      switch (node.type) {
+      case "Date":
+        return temporal.ZonedDateTime.from(
+          truncateFractionalSeconds(node.raw) + node.tz +
+          "[" + (node.tz === "Z" ? "UTC" : node.tz) + "]"
+        );
+      case "LocalDateTime":
+        return temporal.PlainDateTime.from(truncateFractionalSeconds(node.value));
+      case "LocalDate":
+        return temporal.PlainDate.from(node.value);
+      case "LocalTime":
+        return temporal.PlainTime.from(truncateFractionalSeconds(node.value));
+      }
+    }
+    return node.value;
+  }
+
+  // TOML allows arbitrary fractional-second precision (implementations may
+  // truncate); Temporal rejects more than 9 digits (nanoseconds).
+  function truncateFractionalSeconds(str) {
+    return str.replace(/\.(\d{9})\d+/, ".$1");
+  }
+
+  // Integer nodes arrive from the parser as BigInt so the full 64-bit
+  // range is preserved exactly.
+  function reduceInteger(node) {
+    var value = node.value;
+    if (value < INT64_MIN || value > INT64_MAX) {
+      genError(
+        "Integer " + value + " is outside the 64-bit signed integer range required by TOML.",
+        node.offset
+      );
+    }
+    if (options.bigint) {
+      return value;
+    }
+    if (value < MIN_SAFE || value > MAX_SAFE) {
+      genError(
+        "Integer " + value + " cannot be represented losslessly as a JavaScript number. " +
+        "Use the `bigint` option to parse integers as BigInt values.",
+        node.offset
+      );
     }
+    return Number(value);
   }
 
   function reduceInlineTableNode(values) {