@cdklabs/cdk-construct-connect-datalake 0.0.14 → 0.0.16

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

@@ -1,71 +0,0 @@
-import { buildOptions } from './OptionsBuilder.js';
-import OrderedObjParser from './OrderedObjParser.js';
-import prettify from './node2json.js';
-import { validate } from "../validator.js";
-import XmlNode from './xmlNode.js';
-
-export default class XMLParser {
-
-    constructor(options) {
-        this.externalEntities = {};
-        this.options = buildOptions(options);
-
-    }
-    /**
-     * Parse XML dats to JS object 
-     * @param {string|Uint8Array} xmlData 
-     * @param {boolean|Object} validationOption 
-     */
-    parse(xmlData, validationOption) {
-        if (typeof xmlData !== "string" && xmlData.toString) {
-            xmlData = xmlData.toString();
-        } else if (typeof xmlData !== "string") {
-            throw new Error("XML data is accepted in String or Bytes[] form.")
-        }
-
-        if (validationOption) {
-            if (validationOption === true) validationOption = {}; //validate with default options
-
-            const result = validate(xmlData, validationOption);
-            if (result !== true) {
-                throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`)
-            }
-        }
-        const orderedObjParser = new OrderedObjParser(this.options, this.externalEntities);
-        // orderedObjParser.entityDecoder.setExternalEntities(this.externalEntities);
-        const orderedResult = orderedObjParser.parseXml(xmlData);
-        if (this.options.preserveOrder || orderedResult === undefined) return orderedResult;
-        else return prettify(orderedResult, this.options, orderedObjParser.matcher, orderedObjParser.readonlyMatcher);
-    }
-
-    /**
-     * Add Entity which is not by default supported by this library
-     * @param {string} key 
-     * @param {string} value 
-     */
-    addEntity(key, value) {
-        if (value.indexOf("&") !== -1) {
-            throw new Error("Entity value can't have '&'")
-        } else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) {
-            throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '
'")
-        } else if (value === "&") {
-            throw new Error("An entity with value '&' is not permitted");
-        } else {
-            this.externalEntities[key] = value;
-        }
-    }
-
-    /**
-     * Returns a Symbol that can be used to access the metadata
-     * property on a node.
-     * 
-     * If Symbol is not available in the environment, an ordinary property is used
-     * and the name of the property is here returned.
-     * 
-     * The XMLMetaData property is only present when `captureMetaData`
-     * is true in the options.
-     */
-    static getMetaDataSymbol() {
-        return XmlNode.getMetaDataSymbol();
-    }
-}

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

@@ -1,177 +0,0 @@
-'use strict';
-
-import XmlNode from './xmlNode.js';
-import { Matcher } from 'path-expression-matcher';
-
-const METADATA_SYMBOL = XmlNode.getMetaDataSymbol();
-
-/**
- * Helper function to strip attribute prefix from attribute map
- * @param {object} attrs - Attributes with prefix (e.g., {"@_class": "code"})
- * @param {string} prefix - Attribute prefix to remove (e.g., "@_")
- * @returns {object} Attributes without prefix (e.g., {"class": "code"})
- */
-function stripAttributePrefix(attrs, prefix) {
-  if (!attrs || typeof attrs !== 'object') return {};
-  if (!prefix) return attrs;
-
-  const rawAttrs = {};
-  for (const key in attrs) {
-    if (key.startsWith(prefix)) {
-      const rawName = key.substring(prefix.length);
-      rawAttrs[rawName] = attrs[key];
-    } else {
-      // Attribute without prefix (shouldn't normally happen, but be safe)
-      rawAttrs[key] = attrs[key];
-    }
-  }
-  return rawAttrs;
-}
-
-/**
- * 
- * @param {array} node 
- * @param {any} options 
- * @param {Matcher} matcher - Path matcher instance
- * @returns 
- */
-export default function prettify(node, options, matcher, readonlyMatcher) {
-  return compress(node, options, matcher, readonlyMatcher);
-}
-
-/**
- * @param {array} arr 
- * @param {object} options 
- * @param {Matcher} matcher - Path matcher instance
- * @returns object
- */
-function compress(arr, options, matcher, readonlyMatcher) {
-  let text;
-  const compressedObj = {}; //This is intended to be a plain object
-  for (let i = 0; i < arr.length; i++) {
-    const tagObj = arr[i];
-    const property = propName(tagObj);
-
-    // Push current property to matcher WITH RAW ATTRIBUTES (no prefix)
-    if (property !== undefined && property !== options.textNodeName) {
-      const rawAttrs = stripAttributePrefix(
-        tagObj[":@"] || {},
-        options.attributeNamePrefix
-      );
-      matcher.push(property, rawAttrs);
-    }
-
-    if (property === options.textNodeName) {
-      if (text === undefined) text = tagObj[property];
-      else text += "" + tagObj[property];
-    } else if (property === undefined) {
-      continue;
-    } else if (tagObj[property]) {
-
-      let val = compress(tagObj[property], options, matcher, readonlyMatcher);
-      const isLeaf = isLeafTag(val, options);
-
-      if (Object.keys(val).length === 0 && options.alwaysCreateTextNode) {
-        val[options.textNodeName] = "";
-      }
-
-      if (tagObj[":@"]) {
-        assignAttributes(val, tagObj[":@"], readonlyMatcher, options);
-      } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) {
-        val = val[options.textNodeName];
-      } else if (Object.keys(val).length === 0) {
-        if (options.alwaysCreateTextNode) val[options.textNodeName] = "";
-        else val = "";
-      }
-
-      if (tagObj[METADATA_SYMBOL] !== undefined && typeof val === "object" && val !== null) {
-        val[METADATA_SYMBOL] = tagObj[METADATA_SYMBOL]; // copy over metadata
-      }
-
-
-      if (compressedObj[property] !== undefined && Object.prototype.hasOwnProperty.call(compressedObj, property)) {
-        if (!Array.isArray(compressedObj[property])) {
-          compressedObj[property] = [compressedObj[property]];
-        }
-        compressedObj[property].push(val);
-      } else {
-        //TODO: if a node is not an array, then check if it should be an array
-        //also determine if it is a leaf node
-
-        // Pass jPath string or readonlyMatcher based on options.jPath setting
-        const jPathOrMatcher = options.jPath ? readonlyMatcher.toString() : readonlyMatcher;
-        if (options.isArray(property, jPathOrMatcher, isLeaf)) {
-          compressedObj[property] = [val];
-        } else {
-          compressedObj[property] = val;
-        }
-      }
-
-      // Pop property from matcher after processing
-      if (property !== undefined && property !== options.textNodeName) {
-        matcher.pop();
-      }
-    }
-
-  }
-  // if(text && text.length > 0) compressedObj[options.textNodeName] = text;
-  if (typeof text === "string") {
-    if (text.length > 0) compressedObj[options.textNodeName] = text;
-  } else if (text !== undefined) compressedObj[options.textNodeName] = text;
-
-
-  return compressedObj;
-}
-
-function propName(obj) {
-  const keys = Object.keys(obj);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    if (key !== ":@") return key;
-  }
-}
-
-function assignAttributes(obj, attrMap, readonlyMatcher, options) {
-  if (attrMap) {
-    const keys = Object.keys(attrMap);
-    const len = keys.length; //don't make it inline
-    for (let i = 0; i < len; i++) {
-      const atrrName = keys[i];  // This is the PREFIXED name (e.g., "@_class")
-
-      // Strip prefix for matcher path (for isArray callback)
-      const rawAttrName = atrrName.startsWith(options.attributeNamePrefix)
-        ? atrrName.substring(options.attributeNamePrefix.length)
-        : atrrName;
-
-      // For attributes, we need to create a temporary path
-      // Pass jPath string or matcher based on options.jPath setting
-      const jPathOrMatcher = options.jPath
-        ? readonlyMatcher.toString() + "." + rawAttrName
-        : readonlyMatcher;
-
-      if (options.isArray(atrrName, jPathOrMatcher, true, true)) {
-        obj[atrrName] = [attrMap[atrrName]];
-      } else {
-        obj[atrrName] = attrMap[atrrName];
-      }
-    }
-  }
-}
-
-function isLeafTag(obj, options) {
-  const { textNodeName } = options;
-  const propCount = Object.keys(obj).length;
-
-  if (propCount === 0) {
-    return true;
-  }
-
-  if (
-    propCount === 1 &&
-    (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)
-  ) {
-    return true;
-  }
-
-  return false;
-}

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

@@ -1,40 +0,0 @@
-'use strict';
-
-let METADATA_SYMBOL;
-
-if (typeof Symbol !== "function") {
-  METADATA_SYMBOL = "@@xmlMetadata";
-} else {
-  METADATA_SYMBOL = Symbol("XML Node Metadata");
-}
-
-export default class XmlNode {
-  constructor(tagname) {
-    this.tagname = tagname;
-    this.child = []; //nested tags, text, cdata, comments in order
-    this[":@"] = Object.create(null); //attributes map
-  }
-  add(key, val) {
-    // this.child.push( {name : key, val: val, isCdata: isCdata });
-    if (key === "__proto__") key = "#__proto__";
-    this.child.push({ [key]: val });
-  }
-  addChild(node, startIndex) {
-    if (node.tagname === "__proto__") node.tagname = "#__proto__";
-    if (node[":@"] && Object.keys(node[":@"]).length > 0) {
-      this.child.push({ [node.tagname]: node.child, [":@"]: node[":@"] });
-    } else {
-      this.child.push({ [node.tagname]: node.child });
-    }
-    // if requested, add the startIndex
-    if (startIndex !== undefined) {
-      // Note: for now we just overwrite the metadata. If we had more complex metadata,
-      // we might need to do an object append here:  metadata = { ...metadata, startIndex }
-      this.child[this.child.length - 1][METADATA_SYMBOL] = { startIndex };
-    }
-  }
-  /** symbol used for metadata */
-  static getMetaDataSymbol() {
-    return METADATA_SYMBOL;
-  }
-}

package/node_modules/@aws-sdk/xml-builder/node_modules/strnum/CHANGELOG.md

@@ -1,51 +0,0 @@
-
-**2.4.0 / 2026-06-09**
-- support unicode numerals using 'anynum'
-
-**2.3.0 / 2026-05-07**
-- support octal and binary, test with @byspec/numbers
-- test with @byspec/numbers
-
-
-**2.2.3 / 2026-04-07**
-- remove unnecessary files from npm package
-
-**2.2.2 / 2026-03-23**
-- fix for space string
-
-
-**2.2.1 / 2026-03-19**
-- fix false positive for eNotation when no leading zeros
-
-**2.2.0 / 2026-02-28**
-- support infinity
-
-**2.1.0 / 2025-05-01**
-- fix e-notation 
-  - to return string when invalid enotation is found. Eg `E24`
-  - to return valid number when only leading zero before e char is present
-
-**2.0.5 / 2025-02-27**
-- changes done in 1.1.2
-
-**1.1.2 / 2025-02-27**
-- fix skiplike for 0
-
-**1.1.1 / 2025-02-21**
-- All recent fixes of version 2
-
-**2.0.4 / 2025-02-20**
-- remove console log
-
-**2.0.3 / 2025-02-20**
-- fix for string which are falsly identified as e-notation
-
-**2.0.1 / 2025-02-20**
-- fix: handle only zeros
-- fix: return original string when NaN
-
-**2.0.0 / 2025-02-20**
-- Migrating to ESM modules. No functional change
-
-**1.1.0 / 2025-02-20**
-- fix (#9): support missing floating point and e notations

package/node_modules/@aws-sdk/xml-builder/node_modules/strnum/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 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/@aws-sdk/xml-builder/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/@aws-sdk/xml-builder/node_modules/strnum/package.json

@@ -1,35 +0,0 @@
-{
-  "name": "strnum",
-  "version": "2.4.0",
-  "description": "Parse String to Number based on configuration",
-  "type": "module",
-  "main": "strnum.js",
-  "scripts": {
-    "test": "jasmine tests/*_test.js"
-  },
-  "keywords": [
-    "string",
-    "number",
-    "parse",
-    "convert"
-  ],
-  "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.0"
-  }
-}

package/node_modules/@aws-sdk/xml-builder/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"
-    }
-}