@ndlib/ndlib-cdk2 1.0.30 → 1.0.32

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/fast-xml-parser/src/v5/XMLParser.js

@@ -0,0 +1,85 @@
+const { buildOptions} = require("./OptionsBuilder");
+const Xml2JsParser = require("./Xml2JsParser");
+
+class XMLParser{
+    
+    constructor(options){
+        this.externalEntities = {};
+        this.options = buildOptions(options);
+        // console.log(this.options)
+    }
+    /**
+     * Parse XML data string to JS object 
+     * @param {string|Buffer} xmlData 
+     * @param {boolean|Object} validationOption 
+     */
+    parse(xmlData){
+        if(Array.isArray(xmlData) && xmlData.byteLength !== undefined){
+            return this.parse(xmlData);
+        }else if( xmlData.toString){
+            xmlData = xmlData.toString();
+        }else{
+            throw new Error("XML data is accepted in String or Bytes[] form.")
+        }
+        // if( validationOption){
+        //     if(validationOption === true) validationOption = {}; //validate with default options
+            
+        //     const result = validator.validate(xmlData, validationOption);
+        //     if (result !== true) {
+        //       throw Error( `${result.err.msg}:${result.err.line}:${result.err.col}` )
+        //     }
+        //   }
+        const parser = new Xml2JsParser(this.options);
+        parser.entityParser.addExternalEntities(this.externalEntities);
+        return parser.parse(xmlData);
+    }
+    /**
+     * Parse XML data buffer to JS object 
+     * @param {string|Buffer} xmlData 
+     * @param {boolean|Object} validationOption 
+     */
+    parseBytesArr(xmlData){
+        if(Array.isArray(xmlData) && xmlData.byteLength !== undefined){
+        }else{
+            throw new Error("XML data is accepted in Bytes[] form.")
+        }
+        const parser = new Xml2JsParser(this.options);
+        parser.entityParser.addExternalEntities(this.externalEntities);
+        return parser.parseBytesArr(xmlData);
+    }
+    /**
+     * Parse XML data stream to JS object 
+     * @param {fs.ReadableStream} xmlDataStream 
+     */
+    parseStream(xmlDataStream){
+        if(!isStream(xmlDataStream)) throw new Error("FXP: Invalid stream input");
+        
+        const orderedObjParser = new Xml2JsParser(this.options);
+        orderedObjParser.entityParser.addExternalEntities(this.externalEntities);
+        return orderedObjParser.parseStream(xmlDataStream);
+    }
+
+    /**
+     * 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;
+        }
+    }
+}
+
+function isStream(stream){
+    if(stream && typeof stream.read === "function" && typeof stream.on === "function" && typeof stream.readableEnded === "boolean") return true;
+    return false;
+}
+
+module.exports = XMLParser;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/fast-xml-parser/src/v5/Xml2JsParser.js

@@ -0,0 +1,237 @@
+const StringSource = require("./inputSource/StringSource");
+const BufferSource = require("./inputSource/BufferSource");
+const {readTagExp,readClosingTagName} = require("./XmlPartReader");
+const {readComment, readCdata,readDocType,readPiTag} = require("./XmlSpecialTagsReader");
+const TagPath = require("./TagPath");
+const TagPathMatcher = require("./TagPathMatcher");
+const EntitiesParser = require('./EntitiesParser');
+
+//To hold the data of current tag
+//This is usually used to compare jpath expression against current tag
+class TagDetail{
+  constructor(name){
+    this.name = name;
+    this.position = 0;
+    // this.attributes = {};
+  }
+}
+
+class Xml2JsParser {
+    constructor(options) {
+      this.options = options;
+      
+      this.currentTagDetail = null;
+      this.tagTextData = "";
+      this.tagsStack = [];
+      this.entityParser = new EntitiesParser(options.htmlEntities);
+      this.stopNodes = [];
+      for (let i = 0; i < this.options.stopNodes.length; i++) {
+        this.stopNodes.push(new TagPath(this.options.stopNodes[i]));
+      }
+    }
+
+    parse(strData) {
+        this.source = new StringSource(strData);
+        this.parseXml();
+        return this.outputBuilder.getOutput();
+    }
+    parseBytesArr(data) {
+        this.source = new BufferSource(data );
+        this.parseXml();
+        return this.outputBuilder.getOutput();
+    }
+  
+    parseXml() {
+      //TODO: Separate TagValueParser as separate class. So no scope issue in node builder class 
+
+      //OutputBuilder should be set in XML Parser
+      this.outputBuilder = this.options.OutputBuilder.getInstance(this.options);
+      this.root = { root: true};
+      this.currentTagDetail = this.root;
+
+      while(this.source.canRead()){
+        let ch = this.source.readCh();
+        if (ch === "") break;
+        
+        if(ch === "<"){//tagStart
+          let nextChar = this.source.readChAt(0);
+          if (nextChar === "" ) throw new Error("Unexpected end of source");
+          
+        
+          if(nextChar === "!" || nextChar === "?"){
+            this.source.updateBufferBoundary();
+            //previously collected text should be added to current node
+            this.addTextNode(); 
+            
+            this.readSpecialTag(nextChar);// Read DOCTYPE, comment, CDATA, PI tag
+          }else if(nextChar === "/"){
+            this.source.updateBufferBoundary();
+            this.readClosingTag();
+            // console.log(this.source.buffer.length, this.source.readable);
+            // console.log(this.tagsStack.length);
+          }else{//opening tag
+            this.readOpeningTag();
+          }
+        }else{
+          this.tagTextData += ch;
+        }
+      }//End While loop
+      if(this.tagsStack.length > 0 || ( this.tagTextData !== "undefined" && this.tagTextData.trimEnd().length > 0) ) throw new Error("Unexpected data in the end of document");
+    }
+  
+    /**
+     * read closing paired tag. Set parent tag in scope.
+     * skip a node on user's choice
+     */
+    readClosingTag(){
+      const tagName = this.processTagName(readClosingTagName(this.source));
+      // console.log(tagName, this.tagsStack.length);
+      this.validateClosingTag(tagName);
+      // All the text data collected, belongs to current tag.
+      if(!this.currentTagDetail.root) this.addTextNode();
+      this.outputBuilder.closeTag();
+      // Since the tag is closed now, parent tag comes in scope
+      this.currentTagDetail = this.tagsStack.pop(); 
+    }
+
+    validateClosingTag(tagName){
+      // This can't be unpaired tag, or a stop tag.
+      if(this.isUnpaired(tagName) || this.isStopNode(tagName)) throw new Error(`Unexpected closing tag '${tagName}'`);
+      // This must match with last opening tag
+      else if(tagName !== this.currentTagDetail.name) 
+        throw new Error(`Unexpected closing tag '${tagName}' expecting '${this.currentTagDetail.name}'`)
+    }
+
+    /**
+     * Read paired, unpaired, self-closing, stop and special tags.
+     * Create a new node
+     * Push paired tag in stack.
+     */
+    readOpeningTag(){
+      //save previously collected text data to current node
+      this.addTextNode();
+
+      //create new tag
+      let tagExp = readTagExp(this, ">" );
+      
+      // process and skip from tagsStack For unpaired tag, self closing tag, and stop node
+      const tagDetail = new TagDetail(tagExp.tagName);
+      if(this.isUnpaired(tagExp.tagName)) {
+        //TODO: this will lead 2 extra stack operation
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.closeTag();
+      } else if(tagExp.selfClosing){
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.closeTag();
+      } else if(this.isStopNode(this.currentTagDetail)){
+        // TODO: let's user set a stop node boundary detector for complex contents like script tag
+        //TODO: pass tag name only to avoid string operations
+        const content = source.readUptoCloseTag(`</${tagExp.tagName}`);
+        this.outputBuilder.addTag(tagDetail);
+        this.outputBuilder.addValue(content);
+        this.outputBuilder.closeTag();
+      }else{//paired tag
+        //set new nested tag in scope.
+        this.tagsStack.push(this.currentTagDetail);
+        this.outputBuilder.addTag(tagDetail);
+        this.currentTagDetail = tagDetail;
+      }
+      // console.log(tagExp.tagName,this.tagsStack.length);
+      // this.options.onClose()
+
+    }
+
+    readSpecialTag(startCh){
+      if(startCh == "!"){
+        let nextChar = this.source.readCh();
+        if (nextChar === null || nextChar === undefined) throw new Error("Unexpected ending of the source");
+        
+        if(nextChar === "-"){//comment
+          readComment(this);
+        }else if(nextChar === "["){//CDATA
+          readCdata(this);
+        }else if(nextChar === "D"){//DOCTYPE
+          readDocType(this);
+        }
+      }else if(startCh === "?"){
+        readPiTag(this);
+      }else{
+        throw new Error(`Invalid tag '<${startCh}' at ${this.source.line}:${this.source.col}`)
+      }
+    }
+    addTextNode = function() {
+      // if(this.currentTagDetail){
+        //save text as child node
+        // if(this.currentTagDetail.tagname !== '!xml')
+        if (this.tagTextData !== undefined && this.tagTextData !== "") { //store previously collected data as textNode
+          if(this.tagTextData.trim().length > 0){
+            //TODO: shift parsing to output builder
+
+            this.outputBuilder.addValue(this.replaceEntities(this.tagTextData));
+          }
+          this.tagTextData = "";
+        }
+      // }
+    }
+
+    processAttrName(name){
+      if(name === "__proto__") name  = "#__proto__";
+      name = resolveNameSpace(name, this.removeNSPrefix);
+      return name;
+    }
+    
+    processTagName(name){
+      if(name === "__proto__") name  = "#__proto__";
+      name = resolveNameSpace(name, this.removeNSPrefix);
+      return name;
+    }
+
+    /**
+     * Generate tags path from tagsStack
+     */
+    tagsPath(tagName){
+      //TODO: return TagPath Object. User can call match method with path
+      return "";
+    }
+
+    isUnpaired(tagName){
+      return this.options.tags.unpaired.indexOf(tagName) !== -1;
+    }
+
+    /**
+     * valid expressions are 
+     * tag nested
+     * * nested
+     * tag nested[attribute]
+     * tag nested[attribute=""]
+     * tag nested[attribute!=""]
+     * tag nested:0 //for future
+     * @param {string} tagName 
+     * @returns 
+     */
+    isStopNode(node){
+      for (let i = 0; i < this.stopNodes.length; i++) {
+        const givenPath = this.stopNodes[i];
+        if(givenPath.match(this.tagsStack, node)) return true;
+      }
+      return false 
+    }
+
+    replaceEntities(text){
+      //TODO: if option is set then replace entities
+      return this.entityParser.parse(text)
+    }
+}
+
+function resolveNameSpace(name, removeNSPrefix) {
+  if (removeNSPrefix) {
+    const parts = name.split(':');
+    if(parts.length === 2){
+      if (parts[0] === 'xmlns') return '';
+      else return parts[1];
+    }else reportError(`Multiple namespaces ${name}`)
+  }
+  return name;
+}
+
+module.exports = Xml2JsParser;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/fast-xml-parser/src/v5/XmlPartReader.js

@@ -0,0 +1,212 @@
+'use strict';
+
+/**
+ * find paired tag for a stop node
+ * @param {string} xmlDoc 
+ * @param {string} tagName 
+ * @param {number} i : start index
+ */
+function readStopNode(xmlDoc, tagName, i){
+    const startIndex = i;
+    // Starting at 1 since we already have an open tag
+    let openTagCount = 1;
+  
+    for (; i < xmlDoc.length; i++) {
+      if( xmlDoc[i] === "<"){ 
+        if (xmlDoc[i+1] === "/") {//close tag
+            const closeIndex = findSubStrIndex(xmlDoc, ">", i, `${tagName} is not closed`);
+            let closeTagName = xmlDoc.substring(i+2,closeIndex).trim();
+            if(closeTagName === tagName){
+              openTagCount--;
+              if (openTagCount === 0) {
+                return {
+                  tagContent: xmlDoc.substring(startIndex, i),
+                  i : closeIndex
+                }
+              }
+            }
+            i=closeIndex;
+          } else if(xmlDoc[i+1] === '?') { 
+            const closeIndex = findSubStrIndex(xmlDoc, "?>", i+1, "StopNode is not closed.")
+            i=closeIndex;
+          } else if(xmlDoc.substr(i + 1, 3) === '!--') { 
+            const closeIndex = findSubStrIndex(xmlDoc, "-->", i+3, "StopNode is not closed.")
+            i=closeIndex;
+          } else if(xmlDoc.substr(i + 1, 2) === '![') { 
+            const closeIndex = findSubStrIndex(xmlDoc, "]]>", i, "StopNode is not closed.") - 2;
+            i=closeIndex;
+          } else {
+            const tagData = readTagExp(xmlDoc, i, '>')
+  
+            if (tagData) {
+              const openTagName = tagData && tagData.tagName;
+              if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length-1] !== "/") {
+                openTagCount++;
+              }
+              i=tagData.closeIndex;
+            }
+          }
+        }
+    }//end for loop
+}
+
+/**
+ * Read closing tag name
+ * @param {Source} source 
+ * @returns tag name
+ */
+function readClosingTagName(source){
+  let text = ""; //temporary data
+  while(source.canRead()){
+    let ch = source.readCh();
+    // if (ch === null || ch === undefined) break;
+    // source.updateBuffer();
+
+    if (ch === ">") return text.trimEnd();
+    else text += ch;
+  }
+  throw new Error(`Unexpected end of source. Reading '${substr}'`);
+}
+
+/**
+ * Read XML tag and build attributes map
+ * This function can be used to read normal tag, pi tag.
+ * This function can't be used to read comment, CDATA, DOCTYPE.
+ * Eg <tag attr = ' some"' attr= ">" bool>
+ * @param {string} xmlDoc 
+ * @param {number} startIndex starting index
+ * @returns tag expression includes tag name & attribute string 
+ */
+function readTagExp(parser) {
+  let inSingleQuotes = false;
+  let inDoubleQuotes = false;
+  let i;
+  let EOE = false;
+
+  for (i = 0; parser.source.canRead(i); i++) {
+    const char = parser.source.readChAt(i);
+
+    if (char === "'" && !inDoubleQuotes) {
+      inSingleQuotes = !inSingleQuotes;
+    } else if (char === '"' && !inSingleQuotes) {
+      inDoubleQuotes = !inDoubleQuotes;
+    } else if (char === '>' && !inSingleQuotes && !inDoubleQuotes) {
+      // If not inside quotes, stop reading at '>'
+      EOE = true;
+      break;
+    }
+
+  }
+  if(inSingleQuotes || inDoubleQuotes){
+    throw new Error("Invalid attribute expression. Quote is not properly closed");
+  }else if(!EOE) throw new Error("Unexpected closing of source. Waiting for '>'");
+  
+  
+  const exp = parser.source.readStr(i);
+  parser.source.updateBufferBoundary(i + 1);
+  return buildTagExpObj(exp, parser)
+}
+
+function readPiExp(parser) {
+  let inSingleQuotes = false;
+  let inDoubleQuotes = false;
+  let i;
+  let EOE = false;
+
+  for (i = 0; parser.source.canRead(i) ; i++) {
+    const currentChar = parser.source.readChAt(i);
+    const nextChar =  parser.source.readChAt(i+1);
+
+    if (currentChar === "'" && !inDoubleQuotes) {
+      inSingleQuotes = !inSingleQuotes;
+    } else if (currentChar === '"' && !inSingleQuotes) {
+      inDoubleQuotes = !inDoubleQuotes;
+    }
+
+    if (!inSingleQuotes && !inDoubleQuotes) {
+      if (currentChar === '?' && nextChar === '>') {
+        EOE = true;
+        break; // Exit the loop when '?>' is found
+      }
+    }
+  }
+  if(inSingleQuotes || inDoubleQuotes){
+    throw new Error("Invalid attribute expression. Quote is not properly closed in PI tag expression");
+  }else if(!EOE) throw new Error("Unexpected closing of source. Waiting for '?>'");
+  
+  if(!parser.options.attributes.ignore){
+    //TODO: use regex to verify attributes if not set to ignore
+  }
+
+  const exp = parser.source.readStr(i);
+  parser.source.updateBufferBoundary(i + 1);
+  return buildTagExpObj(exp, parser)
+}
+
+function buildTagExpObj(exp, parser){
+  const tagExp = {
+    tagName: "",
+    selfClosing: false
+  };
+  let attrsExp = "";
+
+  if(exp[exp.length -1] === "/") tagExp.selfClosing = true;
+
+  //separate tag name
+  let i = 0;
+  for (; i < exp.length; i++) {
+    const char = exp[i];
+    if(char === " "){
+      tagExp.tagName = exp.substring(0, i);
+      attrsExp = exp.substring(i + 1);
+      break;
+    }
+  }
+  //only tag
+  if(tagExp.tagName.length === 0 && i === exp.length)tagExp.tagName = exp;
+
+  tagExp.tagName = tagExp.tagName.trimEnd();
+
+  if(!parser.options.attributes.ignore && attrsExp.length > 0){
+    parseAttributesExp(attrsExp,parser)
+  }
+
+  return tagExp;
+}
+
+const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
+
+function parseAttributesExp(attrStr, parser) {
+  const matches = getAllMatches(attrStr, attrsRegx);
+  const len = matches.length; //don't make it inline
+  for (let i = 0; i < len; i++) {
+    let attrName = parser.processAttrName(matches[i][1]);
+    let attrVal = parser.replaceEntities(matches[i][4] || true);
+    
+    parser.outputBuilder.addAttribute(attrName, attrVal);
+  }
+}
+
+
+const getAllMatches = function(string, regex) {
+  const matches = [];
+  let match = regex.exec(string);
+  while (match) {
+    const allmatches = [];
+    allmatches.startIndex = regex.lastIndex - match[0].length;
+    const len = match.length;
+    for (let index = 0; index < len; index++) {
+      allmatches.push(match[index]);
+    }
+    matches.push(allmatches);
+    match = regex.exec(string);
+  }
+  return matches;
+};
+
+module.exports = {
+    readStopNode: readStopNode,
+    readClosingTagName: readClosingTagName,
+    readTagExp: readTagExp,
+    readPiExp: readPiExp,
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/fast-xml-parser/src/v5/XmlSpecialTagsReader.js

@@ -0,0 +1,118 @@
+const {readPiExp} = require("./XmlPartReader");
+
+function readCdata(parser){
+  //<![ are already read till this point
+  let str = parser.source.readStr(6); //CDATA[
+  parser.source.updateBufferBoundary(6);
+
+  if(str !== "CDATA[") throw new Error(`Invalid CDATA expression at ${parser.source.line}:${parser.source.cols}`);
+
+  let text = parser.source.readUpto("]]>");
+  parser.outputBuilder.addCdata(text);
+}
+function readPiTag(parser){
+  //<? are already read till this point
+  let tagExp = readPiExp(parser, "?>");
+  if(!tagExp) throw new Error("Invalid Pi Tag expression.");
+
+  if (tagExp.tagName === "?xml") {//TODO: test if tagName is just xml
+    parser.outputBuilder.addDeclaration();
+  } else {
+    parser.outputBuilder.addPi("?"+tagExp.tagName);
+  }
+}
+
+function readComment(parser){
+  //<!- are already read till this point
+  let ch = parser.source.readCh();
+  if(ch !== "-") throw new Error(`Invalid comment expression at ${parser.source.line}:${parser.source.cols}`);
+
+  let text = parser.source.readUpto("-->");
+  parser.outputBuilder.addComment(text);
+}
+
+const DOCTYPE_tags = {
+  "EL":/^EMENT\s+([^\s>]+)\s+(ANY|EMPTY|\(.+\)\s*$)/m,
+  "AT":/^TLIST\s+[^\s]+\s+[^\s]+\s+[^\s]+\s+[^\s]+\s+$/m,
+  "NO":/^TATION.+$/m
+}
+function readDocType(parser){
+  //<!D are already read till this point
+  let str = parser.source.readStr(6); //OCTYPE
+  parser.source.updateBufferBoundary(6);
+
+  if(str !== "OCTYPE") throw new Error(`Invalid DOCTYPE expression at ${parser.source.line}:${parser.source.cols}`);
+
+  let hasBody = false, lastch = "";
+
+  while(parser.source.canRead()){
+    //TODO: use readChAt like used in partReader
+    let ch = parser.source.readCh();
+    if(hasBody){
+      if (ch === '<') { //Determine the tag type
+        let str = parser.source.readStr(2);
+        parser.source.updateBufferBoundary(2);
+        if(str === "EN"){ //ENTITY
+          let str = parser.source.readStr(4);
+          parser.source.updateBufferBoundary(4);
+          if(str !== "TITY") throw new Error("Invalid DOCTYPE ENTITY expression");
+
+          registerEntity(parser);
+        }else if(str === "!-") {//comment
+          readComment(parser);
+        }else{ //ELEMENT, ATTLIST, NOTATION
+          let dTagExp = parser.source.readUpto(">");
+          const regx = DOCTYPE_tags[str];
+          if(regx){
+            const match = dTagExp.match(regx);
+            if(!match) throw new Error("Invalid DOCTYPE");
+          }else throw new Error("Invalid DOCTYPE");
+        }
+      }else if( ch === '>' && lastch === "]"){//end of doctype
+        return;  
+      }
+    }else if( ch === '>'){//end of doctype
+      return;
+    }else if( ch === '['){
+      hasBody = true;
+    }else{
+      lastch = ch;
+    }
+  }//End While loop
+
+}
+
+function registerEntity(parser){
+  //read Entity
+  let attrBoundary="";
+  let name ="", val ="";
+  while(source.canRead()){
+    let ch = source.readCh();
+
+    if(attrBoundary){
+      if (ch === attrBoundary){
+        val = text;
+        text = ""
+      }
+    }else if(ch === " " || ch === "\t"){
+      if(!name){
+        name = text.trimStart();
+        text = "";
+      }
+    }else if (ch === '"' || ch === "'") {//start of attrBoundary
+      attrBoundary = ch;
+    }else if(ch === ">"){
+      parser.entityParser.addExternalEntity(name,val);
+      return;
+    }else{
+      text+=ch;
+    }
+  }
+}
+
+module.exports = {
+  readCdata: readCdata,
+  readComment:readComment,
+  readDocType:readDocType,
+  readPiTag:readPiTag
+}