lambda-live-debugger 1.12.5 → 1.12.6

package/node_modules/fast-xml-parser/node_modules/xml-naming/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Natural Intelligence
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/fast-xml-parser/node_modules/xml-naming/README.md

@@ -0,0 +1,287 @@
+# xml-naming
+[![xml-naming downloads](https://img.shields.io/npm/dw/xml-naming.svg)](https://npm-compare.com/xml-naming) 
+[![xml-naming version](https://img.shields.io/npm/v/xml-naming.svg)](https://www.npmjs.com/package/xml-naming)
+[![xml-naming license](https://img.shields.io/npm/l/xml-naming.svg)](https://github.com/NaturalIntelligence/xml-naming)
+
+Validates XML name productions as defined in the [XML 1.0](https://www.w3.org/TR/xml/) and [XML 1.1](https://www.w3.org/TR/xml11/) specifications.
+
+Covers all five productions:
+
+| Production | Description | Colon | Digit/hyphen start |
+|---|---|---|---|
+| `Name` | General XML name | ✅ | ❌ |
+| `NCName` | Non-Colonized name | ❌ | ❌ |
+| `QName` | Namespace-qualified name (`prefix:local`) | ✅ (one only) | ❌ |
+| `NMToken` | Name token (relaxed start) | ✅ | ✅ |
+| `NMTokens` | Whitespace-separated NMToken list | ✅ | ✅ |
+
+Used internally by [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser), [fast-xml-validator](https://github.com/NaturalIntelligence/fast-xml-validator), [@nodable\flexible-xml-parser](https://github.com/nodable/flexible-xml-parser)  and [fast-svg-parser](https://github.com/amitguptagwl/fast-svg-parser).
+
+---
+
+## Install
+
+```bash
+npm install xml-naming
+```
+
+---
+
+## Usage
+
+### Boolean validators
+
+```js
+import { name, ncName, qName, nmToken, nmTokens } from 'xml-naming';
+
+// Name — colon allowed anywhere, used for DOCTYPE entity names
+name('foo')          // true
+name('a:b:c')        // true  ← multiple colons fine for Name
+name('1foo')         // false ← digit start invalid
+
+// NCName — no colon, used for SVG id attributes, namespace prefixes
+ncName('my-id')      // true
+ncName('xlink:href') // false ← colon not allowed
+
+// QName — exactly one colon as prefix separator, used for element/attribute names
+qName('svg:circle')  // true
+qName('foo')         // true  ← unprefixed QName is valid
+qName('a:b:c')       // false ← only one colon allowed
+qName(':foo')        // false ← cannot start with colon
+
+// NMToken — any NameChar at start, used for DTD NMTOKEN attributes
+nmToken('123')       // true  ← digit start is fine
+nmToken('-bar')      // true
+nmToken('foo bar')   // false ← space not allowed
+
+// NMTokens — whitespace-separated NMToken list
+nmTokens('tok1 tok2 -foo 123')  // true
+```
+
+### XML version option
+
+All validators accept an optional `{ xmlVersion }` option:
+
+```js
+import { name } from 'xml-naming';
+
+name('\u0085', { xmlVersion: '1.0' })  // false — NEL (Next Line), not in 1.0 ranges
+name('\u0085', { xmlVersion: '1.1' })  // true  — explicitly allowed in 1.1
+
+name('\uD800\uDC00', { xmlVersion: '1.0' })  // false
+name('\uD800\uDC00', { xmlVersion: '1.1' })  // true
+```
+
+---
+
+### ASCII-only fast path
+
+All validators, `validate`, `validateAll`, and `sanitize` also accept `{ asciiOnly: true }`.
+When set, matching is restricted to the ASCII subset of the NameStartChar/NameChar
+productions and skips unicode-aware regex matching entirely — no `\u00C0-\uFFFD`-style
+ranges, and (for XML 1.1) no `/u` regex flag. Unicode-aware regexes are measurably slower
+than plain ASCII matching in JS engines, so this is a real performance win when you know
+your input is ASCII-only, which is the common case for HTML/SVG ids and most XML tags.
+
+**This is opt-in and defaults to `false`** for backward compatibility: turning it on
+changes behavior, since it rejects legitimate non-ASCII XML names that would otherwise be
+valid. Only enable it when you control the input and know it's ASCII (e.g. internal
+identifiers, machine-generated names), not for validating arbitrary user- or
+externally-supplied XML/SVG content.
+
+```js
+import { name, sanitize } from 'xml-naming';
+
+name('café', { asciiOnly: true })   // false — 'é' is not ASCII, even though it's
+name('café')                        //  true    a valid XML 1.0/1.1 NameChar
+
+sanitize('café', 'name', { asciiOnly: true })  // 'caf_' — non-ASCII replaced too
+sanitize('café', 'name')                       // 'café' — left untouched by default
+```
+
+---
+
+### Memoized validator (`createValidator`)
+
+Real documents tend to reuse a small vocabulary of tag/attribute names across many
+siblings (`id`, `class`, `href`, ... repeated across hundreds of elements). Calling the
+plain boolean validators re-runs the regex on every call, even for names seen before.
+
+`createValidator(production, opts)` returns a memoized validator function: `xmlVersion`
+and `asciiOnly` are fixed at creation time (so the regex is resolved once, not per call),
+and repeated inputs after the first are served from an internal cache instead of
+re-matching the regex.
+
+```js
+import { createValidator } from 'xml-naming';
+
+const isQName = createValidator('qName', { xmlVersion: '1.0' });
+
+isQName('sku');   // false → regex test (cache miss), result cached
+isQName('sku');   // false → cache hit, no regex run
+```
+
+Use one instance per document/parse (or reuse across a session — your choice), rather
+than creating one per call:
+
+```js
+// e.g. inside a parser, once per parse call:
+const isValidTag = createValidator('qName', { asciiOnly: true });
+
+for (const tagName of tagNames) {
+  if (!isValidTag(tagName)) throw new Error(`Invalid tag name: ${tagName}`);
+}
+```
+
+Because the validator is a plain function, this loop already gets short-circuit
+behaviour (via `break`/`throw` on first failure) and zero extra allocation on the happy
+path — no separate "bulk" API is needed for that.
+
+**Cache bound:** the internal cache is capped by `maxCacheSize` (default `2048`). Once
+the cap is reached, new distinct strings are still validated correctly, they're just no
+longer cached — existing cached entries keep being served. This keeps memory bounded
+even against high-cardinality or adversarial input (e.g. externally-supplied names that
+never repeat), without the cost of a full LRU or the perf cliff of reset-and-refill.
+
+Call `.reset()` on the returned function to clear the cache manually, e.g. between
+unrelated parse calls if you're reusing one validator instance across a long-running
+process:
+
+```js
+isQName.reset();
+```
+
+The cache is private to each `createValidator()` instance — there's no shared/global
+cache, so unrelated callers never interfere with each other.
+
+---
+
+### Diagnostic validation
+
+```js
+import { validate } from 'xml-naming';
+
+validate('svg:circle', 'qName')
+// { valid: true, production: 'qName', input: 'svg:circle' }
+
+validate('1foo', 'ncName')
+// {
+//   valid: false,
+//   production: 'ncName',
+//   input: '1foo',
+//   reason: 'First character "1" is not a valid NameStartChar',
+//   position: 0
+// }
+
+validate('foo:bar', 'ncName')
+// {
+//   valid: false,
+//   production: 'ncName',
+//   input: 'foo:bar',
+//   reason: 'Colon is not allowed in NCName',
+//   position: 3
+// }
+
+validate('a:b:c', 'qName')
+// {
+//   valid: false,
+//   production: 'qName',
+//   input: 'a:b:c',
+//   reason: 'QName can have at most one colon',
+//   position: 3
+// }
+```
+
+---
+
+### Batch validation
+
+```js
+import { validateAll } from 'xml-naming';
+
+validateAll(['svg', 'circle', '123bad', 'xlink:href'], 'ncName')
+// [
+//   { valid: true,  production: 'ncName', input: 'svg' },
+//   { valid: true,  production: 'ncName', input: 'circle' },
+//   { valid: false, production: 'ncName', input: '123bad',    reason: '...', position: 0 },
+//   { valid: false, production: 'ncName', input: 'xlink:href',reason: '...', position: 5 }
+// ]
+```
+
+---
+
+### Sanitize / auto-fix
+
+Useful when generating XML/SVG programmatically from user-supplied strings:
+
+```js
+import { sanitize } from 'xml-naming';
+
+sanitize('123abc',    'ncName')  // '_123abc'   ← digit start fixed
+sanitize('my element','name')   // 'my_element' ← space replaced
+sanitize('foo:bar',   'ncName') // 'foobar'     ← colon stripped
+sanitize('hello!',    'name')   // 'hello_'     ← illegal char replaced
+
+// Custom replacement character
+sanitize('my element', 'name', { replacement: '-' })  // 'my-element'
+```
+
+---
+
+## Which production should I use?
+
+| Context | Production |
+|---|---|
+| XML element/attribute names (namespace-aware) | `qName` |
+| SVG `id` attribute values | `ncName` |
+| Namespace prefix alone | `ncName` |
+| DOCTYPE `<!ENTITY name ...>` | `name` |
+| DOCTYPE `<!NOTATION name ...>` | `name` |
+| DTD `NMTOKEN` attribute values | `nmToken` |
+| DTD `NMTOKENS` attribute values | `nmTokens` |
+
+> **Note:** DOCTYPE entity and notation names must use `Name`, not `QName`. Colons carry no namespace meaning in the DTD subset.
+
+---
+
+## API
+
+### `name(str, opts?)` → `boolean`
+### `ncName(str, opts?)` → `boolean`
+### `qName(str, opts?)` → `boolean`
+### `nmToken(str, opts?)` → `boolean`
+### `nmTokens(str, opts?)` → `boolean`
+
+`opts`:
+- `xmlVersion`: `'1.0'` (default) | `'1.1'`
+- `asciiOnly`: boolean (default `false`) — ASCII-only fast path, see above
+
+### `createValidator(production, opts?)` → memoized `(str) => boolean`, with `.reset()`
+
+`opts`:
+- `xmlVersion`: `'1.0'` (default) | `'1.1'`
+- `asciiOnly`: boolean (default `false`)
+- `maxCacheSize`: number (default `2048`) — cache stops accepting new entries once reached; existing entries keep serving hits
+
+### `validate(str, production, opts?)` → `ValidationResult`
+
+`production`: `'name'` | `'ncName'` | `'qName'` | `'nmToken'` | `'nmTokens'`
+
+`opts`: same as boolean validators (`xmlVersion`, `asciiOnly`)
+
+### `validateAll(strings[], production, opts?)` → `ValidationResult[]`
+
+`opts`: same as `validate`
+
+### `sanitize(str, production?, opts?)` → `string`
+
+`opts`:
+- `xmlVersion`: `'1.0'` | `'1.1'`
+- `replacement`: string (default `'_'`)
+- `asciiOnly`: boolean (default `false`) — also replaces non-ASCII characters, not just XML-illegal ones
+
+---
+
+## License
+
+MIT

package/node_modules/fast-xml-parser/node_modules/xml-naming/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "xml-naming",
+  "version": "0.3.0",
+  "description": "Validates XML name productions — Name, NCName, QName, NMToken, NMTokens — for XML 1.0 and 1.1",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "types": "./src/index.d.ts"
+    }
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jasmine specs/*spec.js",
+    "perf": "node specs/perf.js"
+  },
+  "keywords": [
+    "fast",
+    "xml",
+    "xml-name",
+    "ncname",
+    "qname",
+    "nmtoken",
+    "xml-validation",
+    "xml-namespace",
+    "name-validator",
+    "xml-1.0",
+    "xml-1.1"
+  ],
+  "author": "Amit Gupta (https://solothought.com)",
+  "license": "MIT",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/NaturalIntelligence"
+    }
+  ],
+  "devDependencies": {
+    "jasmine": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NaturalIntelligence/xml-naming"
+  },
+  "bugs": {
+    "url": "https://github.com/NaturalIntelligence/xml-naming/issues"
+  }
+}

package/node_modules/fast-xml-parser/node_modules/xml-naming/src/index.d.ts

@@ -0,0 +1,108 @@
+export interface ValidationOptions {
+  /** XML specification version to validate against. Defaults to '1.0'. */
+  xmlVersion?: '1.0' | '1.1';
+  /**
+   * Restrict matching to the ASCII subset of the NameStartChar/NameChar
+   * productions and skip unicode-aware regex matching entirely. Faster,
+   * especially for XML 1.1 (which otherwise requires the `/u` regex flag),
+   * but rejects legitimate non-ASCII XML names. Off by default for
+   * backward compatibility — opt in only when inputs are known to be ASCII.
+   * Defaults to false.
+   */
+  asciiOnly?: boolean;
+}
+
+export interface SanitizeOptions extends ValidationOptions {
+  /** Character used to replace invalid characters. Defaults to '_'. */
+  replacement?: string;
+}
+
+export type Production = 'name' | 'ncName' | 'qName' | 'nmToken' | 'nmTokens';
+
+export interface ValidationResult {
+  valid: boolean;
+  production: Production;
+  input: string;
+  /** Present only when valid is false. */
+  reason?: string;
+  /** Index of the first offending character. Present only when valid is false. */
+  position?: number;
+}
+
+/**
+ * Returns true if the string is a valid XML Name.
+ * Colons are permitted anywhere (Name production).
+ * Used for: DOCTYPE entity names, notation names, DTD element declarations.
+ */
+export function name(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid NCName (Non-Colonized Name).
+ * Colons are not permitted.
+ * Used for: namespace prefixes, local names, SVG id attributes.
+ */
+export function ncName(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid QName (Qualified Name).
+ * Allows exactly one colon as a prefix separator: prefix:localName.
+ * Used for: element and attribute names in namespace-aware XML/SVG.
+ */
+export function qName(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid NMToken.
+ * Same character set as Name but no restriction on the first character.
+ * Used for: DTD NMTOKEN attribute values.
+ */
+export function nmToken(str: string, opts?: ValidationOptions): boolean;
+
+/**
+ * Returns true if the string is a valid NMTokens value.
+ * A whitespace-separated list of NMToken values.
+ * Used for: DTD NMTOKENS attribute values.
+ */
+export function nmTokens(str: string, opts?: ValidationOptions): boolean;
+
+export interface CreateValidatorOptions extends ValidationOptions {
+  /**
+   * Max number of distinct strings to cache. Once reached, new strings are
+   * still validated correctly but are no longer cached; existing cached
+   * entries keep being served. Defaults to 2048.
+   */
+  maxCacheSize?: number;
+}
+
+export interface MemoizedValidator {
+  (str: string): boolean;
+  /** Clears the internal cache. */
+  reset(): void;
+}
+
+/**
+ * Returns a memoized boolean validator function for a single production.
+ * `opts` (xmlVersion, asciiOnly) are fixed at creation time. Repeated calls
+ * with the same string after the first are served from an internal cache
+ * instead of re-running the regex — useful when validating a small, reused
+ * vocabulary of names (e.g. tag/attribute names across many siblings in a
+ * document) many times.
+ */
+export function createValidator(production: Production, opts?: CreateValidatorOptions): MemoizedValidator;
+
+/**
+ * Validates a string against a named XML production and returns a detailed result.
+ */
+export function validate(str: string, production: Production, opts?: ValidationOptions): ValidationResult;
+
+/**
+ * Validates an array of strings against a named XML production.
+ */
+export function validateAll(strings: string[], production: Production, opts?: ValidationOptions): ValidationResult[];
+
+/**
+ * Transforms an invalid string into the nearest valid XML name for the given production.
+ * - Strips or replaces illegal characters
+ * - Fixes invalid start characters by prepending the replacement character
+ * - Removes colons for NCName production
+ */
+export function sanitize(str: string, production?: Production, opts?: SanitizeOptions): string;