@rio-cloud/cdk-v2-constructs 6.3.1 → 6.3.2

package/node_modules/fast-xml-parser/src/v5/inputSource/BufferSource.js

@@ -0,0 +1,118 @@
+const Constants = {
+  space: 32,
+  tab: 9
+}
+class BufferSource{
+  constructor(bytesArr){
+    this.line = 1;
+    this.cols = 0;
+    this.buffer = bytesArr;
+    this.startIndex = 0;
+  }
+
+
+
+  readCh() {
+    return String.fromCharCode(this.buffer[this.startIndex++]);
+  }
+
+  readChAt(index) {
+    return String.fromCharCode(this.buffer[this.startIndex+index]);
+  }
+
+  readStr(n,from){
+    if(typeof from === "undefined") from = this.startIndex;
+    return this.buffer.slice(from, from + n).toString();
+  }
+
+  readUpto(stopStr) {
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+    const stopBuffer = Buffer.from(stopStr);
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+        let match = true;
+        for (let j = 0; j < stopLength; j++) {
+            if (this.buffer[i + j] !== stopBuffer[j]) {
+                match = false;
+                break;
+            }
+        }
+
+        if (match) {
+            const result = this.buffer.slice(this.startIndex, i).toString();
+            this.startIndex = i + stopLength;
+            return result;
+        }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+}
+
+readUptoCloseTag(stopStr) { //stopStr: "</tagname"
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+    const stopBuffer = Buffer.from(stopStr);
+    let stopIndex = 0;
+    //0: non-matching, 1: matching stop string, 2: matching closing
+    let match = 0;
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+        if(match === 1){//initial part matched
+            if(stopIndex === 0) stopIndex = i;
+            if(this.buffer[i] === Constants.space || this.buffer[i] === Constants.tab) continue;
+            else if(this.buffer[i] === '>'){ //TODO: if it should be equivalent ASCII
+                match = 2;
+                //tag boundary found
+                // this.startIndex
+            }
+        }else{
+            match = 1;
+            for (let j = 0; j < stopLength; j++) {
+                if (this.buffer[i + j] !== stopBuffer[j]) {
+                    match = 0;
+                    break;
+                }
+            }
+        }
+        if (match === 2) {//matched closing part
+            const result = this.buffer.slice(this.startIndex, stopIndex - 1 ).toString();
+            this.startIndex = i + 1;
+            return result;
+        }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+}
+
+  readFromBuffer(n, shouldUpdate) {
+    let ch;
+    if (n === 1) {
+      ch = this.buffer[this.startIndex];
+      if (ch === 10) {
+        this.line++;
+        this.cols = 1;
+      } else {
+        this.cols++;
+      }
+      ch = String.fromCharCode(ch);
+    } else {
+      this.cols += n;
+      ch = this.buffer.slice(this.startIndex, this.startIndex + n).toString();
+    }
+    if (shouldUpdate) this.updateBuffer(n);
+    return ch;
+  }
+
+  updateBufferBoundary(n = 1) { //n: number of characters read
+    this.startIndex += n;
+  }
+
+  canRead(n){
+    n = n || this.startIndex;
+    return this.buffer.length - n + 1 > 0;
+  }
+  
+}
+
+module.exports = BufferSource;

package/node_modules/fast-xml-parser/src/v5/inputSource/StringSource.js

@@ -0,0 +1,123 @@
+const whiteSpaces = [" ", "\n", "\t"];
+
+
+class StringSource{
+  constructor(str){
+    this.line = 1;
+    this.cols = 0;
+    this.buffer = str;
+    //a boundary pointer to indicate where from the buffer dat should be read
+    // data before this pointer can be deleted to free the memory
+    this.startIndex = 0;
+  }
+
+  readCh() {
+    return this.buffer[this.startIndex++];
+  }
+
+  readChAt(index) {
+    return this.buffer[this.startIndex+index];
+  }
+
+  readStr(n,from){
+    if(typeof from === "undefined") from = this.startIndex;
+    return this.buffer.substring(from, from + n);
+  }
+
+  readUpto(stopStr) {
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+      let match = true;
+      for (let j = 0; j < stopLength; j++) {
+        if (this.buffer[i + j] !== stopStr[j]) {
+          match = false;
+          break;
+        }
+      }
+
+      if (match) {
+        const result = this.buffer.substring(this.startIndex, i);
+        this.startIndex = i + stopLength;
+        return result;
+      }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+  }
+
+  readUptoCloseTag(stopStr) { //stopStr: "</tagname"
+    const inputLength = this.buffer.length;
+    const stopLength = stopStr.length;
+    let stopIndex = 0;
+    //0: non-matching, 1: matching stop string, 2: matching closing
+    let match = 0;
+
+    for (let i = this.startIndex; i < inputLength; i++) {
+      if(match === 1){//initial part matched
+        if(stopIndex === 0) stopIndex = i;
+        if(this.buffer[i] === ' ' || this.buffer[i] === '\t') continue;
+        else if(this.buffer[i] === '>'){
+          match = 2;
+          //tag boundary found
+          // this.startIndex
+        }
+      }else{
+        match = 1;
+        for (let j = 0; j < stopLength; j++) {
+          if (this.buffer[i + j] !== stopStr[j]) {
+            match = 0;
+            break;
+          }
+        }
+      }
+      if (match === 2) {//matched closing part
+        const result = this.buffer.substring(this.startIndex, stopIndex - 1 );
+        this.startIndex = i + 1;
+        return result;
+      }
+    }
+
+    throw new Error(`Unexpected end of source. Reading '${stopStr}'`);
+  }
+
+  readFromBuffer(n, updateIndex){
+    let ch;
+    if(n===1){
+      ch = this.buffer[this.startIndex];
+      // if(ch === "\n") {
+      //   this.line++;
+      //   this.cols = 1;
+      // }else{
+      //   this.cols++;
+      // }
+    }else{
+      ch = this.buffer.substring(this.startIndex, this.startIndex + n);
+      // if("".indexOf("\n") !== -1){
+      //   //TODO: handle the scenario when there are multiple lines
+      //   //TODO: col should be set to number of chars after last '\n'
+      //   // this.cols = 1;
+      // }else{
+      //   this.cols += n;
+
+      // }
+    }
+    if(updateIndex) this.updateBufferBoundary(n);
+    return ch;
+  }
+
+  //TODO: rename to updateBufferReadIndex
+  
+  updateBufferBoundary(n = 1) { //n: number of characters read
+    this.startIndex += n;
+  }
+
+  canRead(n){
+    n = n || this.startIndex;
+    return this.buffer.length - n + 1 > 0;
+  }
+  
+}
+
+module.exports = StringSource;

package/node_modules/fast-xml-parser/src/v5/valueParsers/EntitiesParser.js

@@ -0,0 +1,107 @@
+const ampEntity = { regex: /&(amp|#38|#x26);/g, val : "&"};
+const htmlEntities = {
+    "space": { regex: /&(nbsp|#160);/g, val: " " },
+    // "lt" : { regex: /&(lt|#60);/g, val: "<" },
+    // "gt" : { regex: /&(gt|#62);/g, val: ">" },
+    // "amp" : { regex: /&(amp|#38);/g, val: "&" },
+    // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
+    // "apos" : { regex: /&(apos|#39);/g, val: "'" },
+    "cent" : { regex: /&(cent|#162);/g, val: "¢" },
+    "pound" : { regex: /&(pound|#163);/g, val: "£" },
+    "yen" : { regex: /&(yen|#165);/g, val: "¥" },
+    "euro" : { regex: /&(euro|#8364);/g, val: "€" },
+    "copyright" : { regex: /&(copy|#169);/g, val: "©" },
+    "reg" : { regex: /&(reg|#174);/g, val: "®" },
+    "inr" : { regex: /&(inr|#8377);/g, val: "₹" },
+    "num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 10)) },
+    "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 16)) },
+};
+
+class EntitiesParser{
+    constructor(replaceHtmlEntities) {
+      this.replaceHtmlEntities = replaceHtmlEntities;
+      this.docTypeEntities = {};
+      this.lastEntities = {
+        "apos" : { regex: /&(apos|#39|#x27);/g, val : "'"},
+        "gt" : { regex: /&(gt|#62|#x3E);/g, val : ">"},
+        "lt" : { regex: /&(lt|#60|#x3C);/g, val : "<"},
+        "quot" : { regex: /&(quot|#34|#x22);/g, val : "\""},
+      };
+    }
+
+    addExternalEntities(externalEntities){
+        const entKeys = Object.keys(externalEntities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.addExternalEntity(ent,externalEntities[ent])
+        }
+    }
+    addExternalEntity(key,val){
+      validateEntityName(key);
+      if(val.indexOf("&") !== -1) {
+        reportWarning(`Entity ${key} is not added as '&' is found in value;`)
+        return;
+      }else{
+        this.lastEntities[ent] = {
+          regex: new RegExp("&"+key+";","g"),
+          val : val
+        }
+      }
+    }
+
+    addDocTypeEntities(entities){
+        const entKeys = Object.keys(entities);
+        for (let i = 0; i < entKeys.length; i++) {
+          const ent = entKeys[i];
+          this.docTypeEntities[ent] = {
+             regex: new RegExp("&"+ent+";","g"),
+             val : entities[ent]
+          }
+        }
+    }
+
+    parse(val){
+        return this.replaceEntitiesValue(val)
+    }
+
+    /**
+     * 1. Replace DOCTYPE entities 
+     * 2. Replace external entities 
+     * 3. Replace HTML entities if asked
+     * @param {string} val 
+     */
+    replaceEntitiesValue(val){
+        if(typeof val === "string" && val.length > 0){
+            for(let entityName in this.docTypeEntities){
+                const entity = this.docTypeEntities[entityName];
+                val = val.replace( entity.regx, entity.val);
+              }
+              for(let entityName in this.lastEntities){
+                const entity = this.lastEntities[entityName];
+                val = val.replace( entity.regex, entity.val);
+              }
+              if(this.replaceHtmlEntities){
+                for(let entityName in htmlEntities){
+                  const entity = htmlEntities[entityName];
+                  val = val.replace( entity.regex, entity.val);
+                }
+              }
+            val = val.replace( ampEntity.regex, ampEntity.val);
+        }
+        return val;
+    }
+};
+
+//an entity name should not contains special characters that may be used in regex
+//Eg !?\\\/[]$%{}^&*()<>
+const specialChar = "!?\\\/[]$%{}^&*()<>|+";
+
+function validateEntityName(name){
+    for (let i = 0; i < specialChar.length; i++) {
+        const ch = specialChar[i];
+        if(name.indexOf(ch) !== -1) throw new Error(`Invalid character ${ch} in entity name`);
+    }
+    return name;
+}
+
+module.exports = EntitiesParser;

package/node_modules/fast-xml-parser/src/v5/valueParsers/booleanParser.js

@@ -0,0 +1,23 @@
+class boolParser{
+    constructor(trueList, falseList){
+        if(trueList)
+            this.trueList = trueList;
+        else
+            this.trueList = ["true"];
+        
+        if(falseList)
+            this.falseList = falseList;
+        else
+            this.falseList = ["false"];
+    }
+    parse(val){
+        if (typeof val === 'string') {
+            //TODO: performance: don't convert
+            const temp = val.toLowerCase();
+            if(this.trueList.indexOf(temp) !== -1) return true;
+            else if(this.falseList.indexOf(temp) !== -1 ) return false;
+        }
+        return val;
+    }
+}
+module.exports = boolParser;

package/node_modules/fast-xml-parser/src/v5/valueParsers/booleanParserExt.js

@@ -0,0 +1,20 @@
+function boolParserExt(val){
+    if(isArray(val)){
+        for (let i = 0; i < val.length; i++) {
+            val[i] = parse(val[i])
+        }
+    }else{
+        val = parse(val)
+    }
+    return val;
+}
+
+function parse(val){
+    if (typeof val === 'string') {
+        const temp = val.toLowerCase();
+        if(temp === 'true' || temp ==="yes" || temp==="1") return true;
+        else if(temp === 'false' || temp ==="no" || temp==="0") return false;
+    }
+    return val;
+}
+module.exports = boolParserExt;

package/node_modules/fast-xml-parser/src/v5/valueParsers/currency.js

@@ -0,0 +1,40 @@
+const defaultOptions = {
+    maxLength: 200,
+    // locale: "en-IN"
+}
+const localeMap = {
+    "$":"en-US",
+    "€":"de-DE",
+    "£":"en-GB",
+    "¥":"ja-JP",
+    "₹":"en-IN",
+}
+const sign = "(?:-|\+)?";
+const digitsAndSeparator = "(?:\d+|\d{1,3}(?:,\d{3})+)";
+const decimalPart = "(?:\.\d{1,2})?";
+const symbol = "(?:\$|€|¥|₹)?";
+
+const currencyCheckRegex = /^\s*(?:-|\+)?(?:\d+|\d{1,3}(?:,\d{3})+)?(?:\.\d{1,2})?\s*(?:\$|€|¥|₹)?\s*$/u;
+
+class CurrencyParser{
+    constructor(options){
+        this.options = options || defaultOptions;
+    }
+    parse(val){
+        if (typeof val === 'string' && val.length <= this.options.maxLength) {
+            if(val.indexOf(",,") !== -1 && val.indexOf(".." !== -1)){
+                const match = val.match(currencyCheckRegex);
+                if(match){
+                    const locale = this.options.locale || localeMap[match[2]||match[5]||"₹"];
+                    const formatter = new Intl.NumberFormat(locale)
+                    val = val.replace(/[^0-9,.]/g, '').trim();
+                    val = Number(val.replace(formatter.format(1000)[1], ''));
+                }
+            }
+        }
+        return val;
+    }
+}
+CurrencyParser.defaultOptions = defaultOptions;
+
+module.exports = CurrencyParser;

package/node_modules/fast-xml-parser/src/v5/valueParsers/join.js

@@ -0,0 +1,14 @@
+/**
+ * 
+ * @param {array} val 
+ * @param {string} by 
+ * @returns 
+ */
+function join(val, by=" "){
+    if(isArray(val)){
+        val.join(by)
+    }
+    return val;
+}
+
+module.exports = join;

package/node_modules/fast-xml-parser/src/v5/valueParsers/number.js

@@ -0,0 +1,16 @@
+const toNumber = require("strnum");
+
+
+class numParser{
+    constructor(options){
+        this.options = options;
+    }
+    parse(val){
+        if (typeof val === 'string') {
+            val = toNumber(val,this.options);
+        }
+        return val;
+    }
+}
+
+module.exports = numParser;

package/node_modules/fast-xml-parser/src/v5/valueParsers/trim.js

@@ -0,0 +1,8 @@
+class trimmer{
+    parse(val){
+        if(typeof val === "string") return val.trim();
+        else return val;
+    }
+}
+
+module.exports = trimmer;

package/node_modules/fast-xml-parser/src/validator.js

@@ -103,6 +103,8 @@ exports.validate = function (xmlData, options) {
             return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
           } else if (attrStr.trim().length > 0) {
             return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
+          } else if (tags.length === 0) {
+            return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' has not been opened.", getLineNumberForPosition(xmlData, tagStartPos));
           } else {
             const otg = tags.pop();
             if (tagName !== otg.tagName) {

package/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js

@@ -79,11 +79,21 @@ Builder.prototype.j2x = function(jObj, level) {
   let attrStr = '';
   let val = '';
   for (let key in jObj) {
+    if(!Object.prototype.hasOwnProperty.call(jObj, key)) continue;
     if (typeof jObj[key] === 'undefined') {
-      // supress undefined node
+      // supress undefined node only if it is not an attribute
+      if (this.isAttribute(key)) {
+        val += '';
+      }
     } else if (jObj[key] === null) {
-      if(key[0] === "?") val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
-      else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+      // null attribute should be ignored by the attribute list, but should not cause the tag closing
+      if (this.isAttribute(key)) {
+        val += '';
+      } else if (key[0] === '?') {
+        val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
+      } else {
+        val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
+      }
       // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
     } else if (jObj[key] instanceof Date) {
       val += this.buildTextValNode(jObj[key], key, '', level);
@@ -105,6 +115,7 @@ Builder.prototype.j2x = function(jObj, level) {
       //repeated nodes
       const arrLen = jObj[key].length;
       let listTagVal = "";
+      let listTagAttr = "";
       for (let j = 0; j < arrLen; j++) {
         const item = jObj[key][j];
         if (typeof item === 'undefined') {
@@ -114,17 +125,27 @@ Builder.prototype.j2x = function(jObj, level) {
           else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
           // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
         } else if (typeof item === 'object') {
-          if(this.options.oneListGroup ){
-            listTagVal += this.j2x(item, level + 1).val;
+          if(this.options.oneListGroup){
+            const result = this.j2x(item, level + 1);
+            listTagVal += result.val;
+            if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) {
+              listTagAttr += result.attrStr
+            }
           }else{
             listTagVal += this.processTextOrObjNode(item, key, level)
           }
         } else {
-          listTagVal += this.buildTextValNode(item, key, '', level);
+          if (this.options.oneListGroup) {
+            let textValue = this.options.tagValueProcessor(key, item);
+            textValue = this.replaceEntitiesValue(textValue);
+            listTagVal += textValue;
+          } else {
+            listTagVal += this.buildTextValNode(item, key, '', level);
+          }
         }
       }
       if(this.options.oneListGroup){
-        listTagVal = this.buildObjectNode(listTagVal, key, '', level);
+        listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);
       }
       val += listTagVal;
     } else {
@@ -176,7 +197,8 @@ Builder.prototype.buildObjectNode = function(val, key, attrStr, level) {
       tagEndExp = "";
     }
   
-    if (attrStr && val.indexOf('<') === -1) {
+    // attrStr is an empty string in case the attribute came as undefined or null
+    if ((attrStr || attrStr === '') && val.indexOf('<') === -1) {
       return ( this.indentate(level) + '<' +  key + attrStr + piClosingChar + '>' + val + tagEndExp );
     } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
       return this.indentate(level) + `<!--${val}-->` + this.newLine;
@@ -249,7 +271,7 @@ function indentate(level) {
 }
 
 function isAttribute(name /*, options*/) {
-  if (name.startsWith(this.options.attributeNamePrefix)) {
+  if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) {
     return name.substr(this.attrPrefixLen);
   } else {
     return false;

package/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js

@@ -21,6 +21,8 @@ function arrToStr(arr, options, jPath, indentation) {
     for (let i = 0; i < arr.length; i++) {
         const tagObj = arr[i];
         const tagName = propName(tagObj);
+        if(tagName === undefined) continue;
+
         let newJPath = "";
         if (jPath.length === 0) newJPath = tagName
         else newJPath = `${jPath}.${tagName}`;
@@ -90,6 +92,7 @@ function propName(obj) {
     const keys = Object.keys(obj);
     for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
+        if(!obj.hasOwnProperty(key)) continue;
         if (key !== ":@") return key;
     }
 }
@@ -98,6 +101,7 @@ function attr_to_str(attrMap, options) {
     let attrStr = "";
     if (attrMap && !options.ignoreAttributes) {
         for (let attr in attrMap) {
+            if(!attrMap.hasOwnProperty(attr)) continue;
             let attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
             attrVal = replaceEntitiesValue(attrVal, options);
             if (attrVal === true && options.suppressBooleanAttributes) {