@btc-embedded/cdk-extensions 0.23.3 → 0.23.5

package/node_modules/strnum/strnum.js

@@ -1,105 +1,114 @@
 const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
+const binRegex = /^0b[01]+$/;
+const octRegex = /^0o[0-7]+$/;
 const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
-// const octRegex = /^0x[a-z0-9]+/;
-// const binRegex = /0x[a-z0-9]+/;
 
- 
 const consider = {
-    hex :  true,
-    // oct: false,
+    hex: true,
+    binary: false,
+    octal: false,
     leadingZeros: true,
     decimalPoint: "\.",
     eNotation: true,
-    //skipLike: /regex/
+    //skipLike: /regex/,
+    infinity: "original", // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))
 };
 
-export default function toNumber(str, options = {}){
-    options = Object.assign({}, consider, options );
-    if(!str || typeof str !== "string" ) return str;
-    
-    let trimmedStr  = str.trim();
-    
-    if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
-    else if(str==="0") return 0;
+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;
     else if (options.hex && hexRegex.test(trimmedStr)) {
         return parse_int(trimmedStr, 16);
-    // }else if (options.oct && octRegex.test(str)) {
-    //     return Number.parseInt(val, 8);
-    }else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation
-        return resolveEnotation(str,trimmedStr,options);
-    // }else if (options.parseBin && binRegex.test(str)) {
-    //     return Number.parseInt(val, 2);
-    }else{
+    } 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){
+        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 + 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))){
+            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
+            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;
+                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 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){
+
+                let n = leadingZeros ? numTrimmedByZeros : trimmedStr;
+                if (leadingZeros) {
                     // -009 => -9
-                    return (n === parsedStr) || (sign+n === parsedStr) ? num : str
-                }else  {
+                    return (n === parsedStr) || (sign + n === parsedStr) ? num : str
+                } else {
                     // +9
-                    return (n === parsedStr) || (n === sign+parsedStr) ? num : str
+                    return (n === parsedStr) || (n === sign + parsedStr) ? num : str
                 }
             }
-        }else{ //non-numeric string
+        } 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){
+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 + 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)){
+        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 if(options.leadingZeros && !eAdjacentToLeadingZeros){ //accept with leading zeros
-            //remove leading 0s
-            trimmedStr = (notation[1] || "") + notation[3];
+            } else return str;
+        } else {
+            // No leading zeros — always valid e-notation, parse it
             return Number(trimmedStr);
-        }else return str;
-    }else{
+        }
+    } else {
         return str;
     }
 }
@@ -109,21 +118,46 @@ function resolveEnotation(str,trimmedStr,options){
  * @param {string} numStr without leading zeros
  * @returns 
  */
-function trimZeros(numStr){
-    if(numStr && numStr.indexOf(".") !== -1){//float
+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);
+        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){
-    //polyfill
-    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")
+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

@@ -0,0 +1,189 @@
+# 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

@@ -0,0 +1,54 @@
+{
+  "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

@@ -0,0 +1,74 @@
+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;