@cdk8s/awscdk-resolver 0.0.608 → 0.0.610

package/node_modules/strnum/README.md

@@ -1,113 +0,0 @@
-# strnum
-Parse string into Number based on configuration
-
-[![strnum downloads](https://img.shields.io/npm/dw/strnum.svg)](https://npm-compare.com/strnum) 
-[![strnum version](https://img.shields.io/npm/v/strnum.svg)](https://www.npmjs.com/package/strnum)
-[![strnum license](https://img.shields.io/npm/l/strnum.svg)](https://github.com/NaturalIntelligence/strnum)
-
-## Users
-
-<a href="https://github.com/aws-amplify" target="_blank"><img src="https://avatars.githubusercontent.com/u/41077760?s=100&v=4"></a>
-<a href="https://github.com/astrapay" target="_blank"><img src="https://avatars.githubusercontent.com/u/90901882?s=100&v=4"></a>
-<a href="https://github.com/process-analytics" target="_blank"><img src="https://avatars.githubusercontent.com/u/60110287?s=100&v=4"></a>
-<a href="https://github.com/NaturalIntelligence" target="_blank"><img src="https://avatars.githubusercontent.com/u/16322633?s=100&v=4"></a>
-Many React Native projects and plugins
-
-## Usage
-
-```bash
-npm install strnum
-```
-```js
-const toNumber = require("strnum");
-
-toNumber(undefined) // undefined
-toNumber(null)) //null
-toNumber("")) // ""
-toNumber("string"); //"string")
-toNumber("12,12"); //"12,12")
-toNumber("12 12"); //"12 12")
-toNumber("12-12"); //"12-12")
-toNumber("12.12.12"); //"12.12.12")
-toNumber("0x2f"); //47)
-toNumber("-0x2f"); //-47)
-toNumber("0x2f", { hex :  true}); //47)
-toNumber("-0x2f", { hex :  true}); //-47)
-toNumber("0x2f", { hex :  false}); //"0x2f")
-toNumber("-0x2f", { hex :  false}); //"-0x2f")
-toNumber("06"); //6)
-toNumber("06", { leadingZeros :  true}); //6)
-toNumber("06", { leadingZeros :  false}); //"06")
-
-toNumber("006"); //6)
-toNumber("006", { leadingZeros :  true}); //6)
-toNumber("006", { leadingZeros :  false}); //"006")
-toNumber("0.0"); //0)
-toNumber("00.00"); //0)
-toNumber("0.06"); //0.06)
-toNumber("00.6"); //0.6)
-toNumber(".006"); //0.006)
-toNumber("6.0"); //6)
-toNumber("06.0"); //6)
-
-toNumber("0.0",  { leadingZeros :  false}); //0)
-toNumber("00.00",  { leadingZeros :  false}); //"00.00")
-toNumber("0.06",  { leadingZeros :  false}); //0.06)
-toNumber("00.6",  { leadingZeros :  false}); //"00.6")
-toNumber(".006", { leadingZeros :  false}); //0.006)
-toNumber("6.0"  ,  { leadingZeros :  false}); //6)
-toNumber("06.0"  ,  { leadingZeros :  false}); //"06.0")
-toNumber("-06"); //-6)
-toNumber("-06", { leadingZeros :  true}); //-6)
-toNumber("-06", { leadingZeros :  false}); //"-06")
-
-toNumber("-0.0"); //-0)
-toNumber("-00.00"); //-0)
-toNumber("-0.06"); //-0.06)
-toNumber("-00.6"); //-0.6)
-toNumber("-.006"); //-0.006)
-toNumber("-6.0"); //-6)
-toNumber("-06.0"); //-6)
-
-toNumber("-0.0"   ,  { leadingZeros :  false}); //-0)
-toNumber("-00.00",  { leadingZeros :  false}); //"-00.00")
-toNumber("-0.06",  { leadingZeros :  false}); //-0.06)
-toNumber("-00.6",  { leadingZeros :  false}); //"-00.6")
-toNumber("-.006",  {leadingZeros :  false}); //-0.006)
-toNumber("-6.0"  ,  { leadingZeros :  false}); //-6)
-toNumber("-06.0"  ,  { leadingZeros :  false}); //"-06.0")
-toNumber("420926189200190257681175017717")  ; //4.209261892001902e+29)
-toNumber("000000000000000000000000017717"  ,  { leadingZeros :  false}); //"000000000000000000000000017717")
-toNumber("000000000000000000000000017717"  ,  { leadingZeros :  true}); //17717)
-toNumber("01.0e2"  ,  { leadingZeros :  false}); //"01.0e2")
-toNumber("-01.0e2"  ,  { leadingZeros :  false}); //"-01.0e2")
-toNumber("01.0e2") ; //100)
-toNumber("-01.0e2") ; //-100)
-toNumber("1.0e2") ; //100)
-
-toNumber("-1.0e2") ; //-100)
-toNumber("1.0e-2"); //0.01)
-
-toNumber("+1212121212"); // 1212121212
-toNumber("+1212121212", { skipLike: /\+[0-9]{10}/} )); //"+1212121212"
-
-toNumber("１e１000", { unicode: true, infinity: "original" }); //"１e１000"
-toNumber("１000", { unicode: true }); //1000
-toNumber("１000", { unicode: false }); //"１000"
-```
-
-Supported Options
-```js
-hex: true,          //when hexadecimal string should be parsed
-leadingZeros: true, //when number with leading zeros like 08 should be parsed. 0.0 is not impacted
-eNotation: true,    //when number with eNotation or number parsed in eNotation should be considered
-skipLike: /regex/   //when string should not be parsed when it matches the specified regular expression
-infinity: "original", // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))
-unicode: false, //when number with unicode numerals should be parsed
-```
-
-
-# Try out our other work
-
-WishIn - You need it if negative thoughts take over all the time <br>
-<a href="https://play.google.com/store/apps/details?id=com.solothought.wishin"> <img src="https://solothought.com/products/assets/images/wishin/YouTubeThumbnail.png" width="500px"/> </a>

package/node_modules/strnum/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "strnum",
-  "version": "2.4.1",
-  "description": "Parse String to Number based on configuration",
-  "type": "module",
-  "main": "strnum.js",
-  "scripts": {
-    "test": "jasmine tests/*_test.js"
-  },
-  "keywords": [
-    "string",
-    "number",
-    "parse",
-    "convert",
-    "unicode"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/NaturalIntelligence/strnum"
-  },
-  "author": "Amit Gupta (https://solothought.work/)",
-  "license": "MIT",
-  "funding": [
-    {
-      "type": "github",
-      "url": "https://github.com/sponsors/NaturalIntelligence"
-    }
-  ],
-  "devDependencies": {
-    "@byspec/numbers": "^0.1.1",
-    "jasmine": "^5.6.0"
-  },
-  "dependencies": {
-    "anynum": "^1.0.1"
-  }
-}

package/node_modules/strnum/strnum.js

@@ -1,171 +0,0 @@
-const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
-const binRegex = /^0b[01]+$/;
-const octRegex = /^0o[0-7]+$/;
-const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
-
-import anynum from "anynum";
-
-const consider = {
-    hex: true,
-    binary: false,
-    octal: false,
-    leadingZeros: true,
-    decimalPoint: "\.",
-    eNotation: true,
-    //skipLike: /regex/,
-    infinity: "original", // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))
-    unicode: false,
-};
-
-export default function toNumber(str, options = {}) {
-    options = Object.assign({}, consider, options);
-    if (!str || typeof str !== "string") return str;
-
-    let trimmedStr = str.trim();
-
-    if (trimmedStr.length === 0) return str;
-    else if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
-    else if (trimmedStr === "0") return 0;
-
-    if (options.unicode) {
-        trimmedStr = anynum(trimmedStr);
-        if (trimmedStr === "0") return 0; // re-check after normalization
-    }
-    if (options.hex && hexRegex.test(trimmedStr)) {
-        return parse_int(trimmedStr, 16);
-    } else if (options.binary && binRegex.test(trimmedStr)) {
-        return parse_int(trimmedStr, 2);
-    } else if (options.octal && octRegex.test(trimmedStr)) {
-        return parse_int(trimmedStr, 8);
-    } else if (!isFinite(trimmedStr)) { //Infinity
-        return handleInfinity(str, Number(trimmedStr), options);
-    } else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation
-        return resolveEnotation(str, trimmedStr, options);
-    } else {
-        //separate negative sign, leading zeros, and rest number
-        const match = numRegex.exec(trimmedStr);
-        // +00.123 => [ , '+', '00', '.123', ..
-        if (match) {
-            const sign = match[1] || "";
-            const leadingZeros = match[2];
-            let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros
-            const decimalAdjacentToLeadingZeros = sign ? // 0., -00., 000.
-                str[leadingZeros.length + 1] === "."
-                : str[leadingZeros.length] === ".";
-
-            //trim ending zeros for floating number
-            if (!options.leadingZeros //leading zeros are not allowed
-                && (leadingZeros.length > 1
-                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))) {
-                // 00, 00.3, +03.24, 03, 03.24
-                return str;
-            }
-            else {//no leading zeros or leading zeros are allowed
-                const num = Number(trimmedStr);
-                const parsedStr = String(num);
-
-                if (num === 0) return num;
-                if (parsedStr.search(/[eE]/) !== -1) { //given number is long and parsed to eNotation
-                    if (options.eNotation) return num;
-                    else return str;
-                } else if (trimmedStr.indexOf(".") !== -1) { //floating number
-                    if (parsedStr === "0") return num; //0.0
-                    else if (parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000
-                    else if (parsedStr === `${sign}${numTrimmedByZeros}`) return num;
-                    else return str;
-                }
-
-                let n = leadingZeros ? numTrimmedByZeros : trimmedStr;
-                if (leadingZeros) {
-                    // -009 => -9
-                    return (n === parsedStr) || (sign + n === parsedStr) ? num : str
-                } else {
-                    // +9
-                    return (n === parsedStr) || (n === sign + parsedStr) ? num : str
-                }
-            }
-        } else { //non-numeric string
-            return str;
-        }
-    }
-}
-
-const eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
-function resolveEnotation(str, trimmedStr, options) {
-    if (!options.eNotation) return str;
-    const notation = trimmedStr.match(eNotationRegx);
-    if (notation) {
-        let sign = notation[1] || "";
-        const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";
-        const leadingZeros = notation[2];
-        const eAdjacentToLeadingZeros = sign ? // 0E.
-            str[leadingZeros.length + 1] === eChar
-            : str[leadingZeros.length] === eChar;
-
-        if (leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;
-        else if (leadingZeros.length === 1
-            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) {
-            return Number(trimmedStr);
-        } else if (leadingZeros.length > 0) {
-            // Has leading zeros — only accept if leadingZeros option allows it
-            if (options.leadingZeros && !eAdjacentToLeadingZeros) {
-                trimmedStr = (notation[1] || "") + notation[3];
-                return Number(trimmedStr);
-            } else return str;
-        } else {
-            // No leading zeros — always valid e-notation, parse it
-            return Number(trimmedStr);
-        }
-    } else {
-        return str;
-    }
-}
-
-/**
- * 
- * @param {string} numStr without leading zeros
- * @returns 
- */
-function trimZeros(numStr) {
-    if (numStr && numStr.indexOf(".") !== -1) {//float
-        numStr = numStr.replace(/0+$/, ""); //remove ending zeros
-        if (numStr === ".") numStr = "0";
-        else if (numStr[0] === ".") numStr = "0" + numStr;
-        else if (numStr[numStr.length - 1] === ".") numStr = numStr.substring(0, numStr.length - 1);
-        return numStr;
-    }
-    return numStr;
-}
-
-function parse_int(numStr, base) {
-    const str = numStr.trim();
-    if (base === 2 || base === 8) numStr = str.substring(2);
-
-    if (parseInt) return parseInt(numStr, base);
-    else if (Number.parseInt) return Number.parseInt(numStr, base);
-    else if (window && window.parseInt) return window.parseInt(numStr, base);
-    else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
-}
-
-/**
- * Handle infinite values based on user option
- * @param {string} str - original input string
- * @param {number} num - parsed number (Infinity or -Infinity)
- * @param {object} options - user options
- * @returns {string|number|null} based on infinity option
- */
-function handleInfinity(str, num, options) {
-    const isPositive = num === Infinity;
-
-    switch (options.infinity.toLowerCase()) {
-        case "null":
-            return null;
-        case "infinity":
-            return num; // Return Infinity or -Infinity
-        case "string":
-            return isPositive ? "Infinity" : "-Infinity";
-        case "original":
-        default:
-            return str; // Return original string like "1e1000"
-    }
-}

package/node_modules/xml-naming/README.md

@@ -1,189 +0,0 @@
-# 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
-```
-
----
-
-### 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'`
-
-### `validate(str, production, opts?)` → `ValidationResult`
-
-`production`: `'name'` | `'ncName'` | `'qName'` | `'nmToken'` | `'nmTokens'`
-
-### `validateAll(strings[], production, opts?)` → `ValidationResult[]`
-
-### `sanitize(str, production?, opts?)` → `string`
-
-`opts`:
-- `xmlVersion`: `'1.0'` | `'1.1'`
-- `replacement`: string (default `'_'`)
-
----
-
-## License
-
-MIT

package/node_modules/xml-naming/package.json

@@ -1,54 +0,0 @@
-{
-  "name": "xml-naming",
-  "version": "0.1.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"
-  },
-  "keywords": [
-    "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/xml-naming/src/index.d.ts

@@ -1,74 +0,0 @@
-export interface ValidationOptions {
-  /** XML specification version to validate against. Defaults to '1.0'. */
-  xmlVersion?: '1.0' | '1.1';
-}
-
-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;
-
-/**
- * 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;