devbrain-cli 0.2.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/fxp.js

@@ -0,0 +1,14 @@
+'use strict';
+
+import { validate } from './validator.js';
+import XMLParser from './xmlparser/XMLParser.js';
+import XMLBuilder from './xmlbuilder/json2xml.js';
+
+const XMLValidator = {
+  validate: validate
+}
+export {
+  XMLParser,
+  XMLValidator,
+  XMLBuilder
+};

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/ignoreAttributes.js

@@ -0,0 +1,18 @@
+export default function getIgnoreAttributesFn(ignoreAttributes) {
+    if (typeof ignoreAttributes === 'function') {
+        return ignoreAttributes
+    }
+    if (Array.isArray(ignoreAttributes)) {
+        return (attrName) => {
+            for (const pattern of ignoreAttributes) {
+                if (typeof pattern === 'string' && attrName === pattern) {
+                    return true
+                }
+                if (pattern instanceof RegExp && pattern.test(attrName)) {
+                    return true
+                }
+            }
+        }
+    }
+    return () => false
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/util.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const nameStartChar = ':A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+const nameChar = nameStartChar + '\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
+export const nameRegexp = '[' + nameStartChar + '][' + nameChar + ']*';
+const regexName = new RegExp('^' + nameRegexp + '$');
+
+export function getAllMatches(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;
+}
+
+export const isName = function (string) {
+  const match = regexName.exec(string);
+  return !(match === null || typeof match === 'undefined');
+}
+
+export function isExist(v) {
+  return typeof v !== 'undefined';
+}
+
+export function isEmptyObject(obj) {
+  return Object.keys(obj).length === 0;
+}
+
+export function getValue(v) {
+  if (exports.isExist(v)) {
+    return v;
+  } else {
+    return '';
+  }
+}
+
+/**
+ * Dangerous property names that could lead to prototype pollution or security issues
+ */
+export const DANGEROUS_PROPERTY_NAMES = [
+  // '__proto__',
+  // 'constructor',
+  // 'prototype',
+  'hasOwnProperty',
+  'toString',
+  'valueOf',
+  '__defineGetter__',
+  '__defineSetter__',
+  '__lookupGetter__',
+  '__lookupSetter__'
+];
+
+export const criticalProperties = ["__proto__", "constructor", "prototype"];

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/CharsSymbol.js

@@ -0,0 +1,16 @@
+export default {
+  "<" : "<", //tag start
+  ">" : ">", //tag end
+  "/" : "/", //close tag
+  "!" : "!", //comment or docttype
+  "!--" : "!--", //comment
+  "-->" : "-->", //comment end
+  "?" : "?", //pi
+  "?>" : "?>", //pi end
+  "?xml" : "?xml", //pi end
+  "![" : "![", //cdata
+  "]]>" : "]]>", //cdata end
+  "[" : "[",
+  "-" : "-",
+  "D" : "D",
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/EntitiesParser.js

@@ -0,0 +1,106 @@
+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.fromCodePoint(Number.parseInt(str, 10)) },
+  "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str) => String.fromCodePoint(Number.parseInt(str, 16)) },
+};
+export default 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);
+    const escaped = key.replace(/[.\-+*:]/g, '\\.');
+    if (val.indexOf("&") !== -1) {
+      reportWarning(`Entity ${key} is not added as '&' is found in value;`)
+      return;
+    } else {
+      this.lastEntities[key] = {
+        regex: new RegExp("&" + escaped + ";", "g"),
+        val: val
+      }
+    }
+  }
+
+  addDocTypeEntities(entities) {
+    const entKeys = Object.keys(entities);
+    for (let i = 0; i < entKeys.length; i++) {
+      const ent = entKeys[i];
+      const escaped = ent.replace(/[.\-+*:]/g, '\\.');
+      this.docTypeEntities[ent] = {
+        regex: new RegExp("&" + escaped + ";", "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;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/OptionsBuilder.js

@@ -0,0 +1,61 @@
+
+import { JsObjOutputBuilder } from './OutputBuilders/JsObjBuilder.js';
+
+export const defaultOptions = {
+  preserveOrder: false,
+  removeNSPrefix: false, // remove NS from tag name or attribute name if true
+  //ignoreRootElement : false,
+  stopNodes: [], //nested tags will not be parsed even for errors
+  // isArray: () => false, //User will set it
+  htmlEntities: false,
+  // skipEmptyListItem: false
+  tags: {
+    unpaired: [],
+    nameFor: {
+      cdata: false,
+      comment: false,
+      text: '#text'
+    },
+    separateTextProperty: false,
+  },
+  attributes: {
+    ignore: false,
+    booleanType: true,
+    entities: true,
+  },
+
+  // select: ["img[src]"],
+  // stop: ["anim", "[ads]"]
+  only: [], // rest tags will be skipped. It will result in flat array
+  hierarchy: false, //will be used when a particular tag is set to be parsed.
+  skip: [], // will be skipped from parse result. on('skip') will be triggered
+
+  select: [], // on('select', tag => tag ) will be called if match
+  stop: [], //given tagPath will not be parsed. innerXML will be set as string value
+  OutputBuilder: new JsObjOutputBuilder(),
+};
+
+export const buildOptions = function (options) {
+  const finalOptions = { ...defaultOptions };
+  copyProperties(finalOptions, options)
+  return finalOptions;
+};
+
+function copyProperties(target, source) {
+  for (let key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (key === 'OutputBuilder') {
+        target[key] = source[key];
+      } else if (typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        // Recursively copy nested properties
+        if (typeof target[key] === 'undefined') {
+          target[key] = {};
+        }
+        copyProperties(target[key], source[key]);
+      } else {
+        // Copy non-nested properties
+        target[key] = source[key];
+      }
+    }
+  }
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/OutputBuilders/BaseOutputBuilder.js

@@ -0,0 +1,69 @@
+export default class BaseOutputBuilder {
+  constructor() {
+    // this.attributes = {};
+  }
+
+  addAttribute(name, value) {
+    if (this.options.onAttribute) {
+      //TODO: better to pass tag path
+      const v = this.options.onAttribute(name, value, this.tagName);
+      if (v) this.attributes[v.name] = v.value;
+    } else {
+      name = this.options.attributes.prefix + name + this.options.attributes.suffix;
+      this.attributes[name] = this.parseValue(value, this.options.attributes.valueParsers);
+    }
+  }
+
+  /**
+   * parse value by chain of parsers
+   * @param {string} val 
+   * @returns {any} parsed value if matching parser found
+   */
+  parseValue = function (val, valParsers) {
+    for (let i = 0; i < valParsers.length; i++) {
+      let valParser = valParsers[i];
+      if (typeof valParser === "string") {
+        valParser = this.registeredParsers[valParser];
+      }
+      if (valParser) {
+        val = valParser.parse(val);
+      }
+    }
+    return val;
+  }
+
+  /**
+   * To add a nested empty tag.
+   * @param {string} key 
+   * @param {any} val 
+   */
+  _addChild(key, val) { }
+
+  /**
+   * skip the comment if property is not set
+   */
+  addComment(text) {
+    if (this.options.nameFor.comment)
+      this._addChild(this.options.nameFor.comment, text);
+  }
+
+  //store CDATA separately if property is set
+  //otherwise add to tag's value
+  addCdata(text) {
+    if (this.options.nameFor.cdata) {
+      this._addChild(this.options.nameFor.cdata, text);
+    } else {
+      this.addRawValue(text || "");
+    }
+  }
+
+  addRawValue = text => this.addValue(text);
+
+  addDeclaration() {
+    if (!this.options.declaration) {
+    } else {
+      this.addPi("?xml");
+    }
+    this.attributes = {}
+  }
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/OutputBuilders/JsArrBuilder.js

@@ -0,0 +1,103 @@
+import { buildOptions, registerCommonValueParsers } from './ParserOptionsBuilder.js';
+
+export default class OutputBuilder {
+  constructor(options) {
+    this.options = buildOptions(options);
+    this.registeredParsers = registerCommonValueParsers(this.options);
+  }
+
+  registerValueParser(name, parserInstance) {//existing name will override the parser without warning
+    this.registeredParsers[name] = parserInstance;
+  }
+
+  getInstance(parserOptions) {
+    return new JsArrBuilder(parserOptions, this.options, this.registeredParsers);
+  }
+}
+
+const rootName = '!js_arr';
+import BaseOutputBuilder from './BaseOutputBuilder.js';
+
+class JsArrBuilder extends BaseOutputBuilder {
+
+  constructor(parserOptions, options, registeredParsers) {
+    super();
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+    this.options = options;
+    this.registeredParsers = registeredParsers;
+
+    this.root = new Node(rootName);
+    this.currentNode = this.root;
+    this.attributes = {};
+  }
+
+  addTag(tag) {
+    //when a new tag is added, it should be added as child of current node
+    //TODO: shift this check to the parser
+    if (tag.name === "__proto__") tag.name = "#__proto__";
+
+    this.tagsStack.push(this.currentNode);
+    this.currentNode = new Node(tag.name, this.attributes);
+    this.attributes = {};
+  }
+
+  /**
+   * Check if the node should be added by checking user's preference
+   * @param {Node} node 
+   * @returns boolean: true if the node should not be added
+   */
+  closeTag() {
+    const node = this.currentNode;
+    this.currentNode = this.tagsStack.pop(); //set parent node in scope
+    if (this.options.onClose !== undefined) {
+      //TODO TagPathMatcher 
+      const resultTag = this.options.onClose(node,
+        new TagPathMatcher(this.tagsStack, node));
+
+      if (resultTag) return;
+    }
+    this.currentNode.child.push(node);  //to parent node
+  }
+
+  //Called by parent class methods
+  _addChild(key, val) {
+    // if(key === "__proto__") tagName = "#__proto__";
+    this.currentNode.child.push({ [key]: val });
+    // this.currentNode.leafType = false;
+  }
+
+  /**
+   * Add text value child node 
+   * @param {string} text 
+   */
+  addValue(text) {
+    this.currentNode.child.push({ [this.options.nameFor.text]: this.parseValue(text, this.options.tags.valueParsers) });
+  }
+
+  addPi(name) {
+    //TODO: set pi flag
+    if (!this.options.ignorePiTags) {
+      const node = new Node(name, this.attributes);
+      this.currentNode[":@"] = this.attributes;
+      this.currentNode.child.push(node);
+    }
+    this.attributes = {};
+  }
+  getOutput() {
+    return this.root.child[0];
+  }
+}
+
+
+
+class Node {
+  constructor(tagname, attributes) {
+    this.tagname = tagname;
+    this.child = []; //nested tags, text, cdata, comments
+    if (attributes && Object.keys(attributes).length > 0)
+      this[":@"] = attributes;
+  }
+}
+
+module.exports = OutputBuilder;

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/fast-xml-parser/src/v6/OutputBuilders/JsMinArrBuilder.js

@@ -0,0 +1,100 @@
+import {buildOptions,registerCommonValueParsers} from"./ParserOptionsBuilder.js";
+
+export default class OutputBuilder{
+  constructor(options){
+    this.options = buildOptions(options);
+      this.registeredParsers = registerCommonValueParsers(this.options);
+    }
+    
+    registerValueParser(name,parserInstance){//existing name will override the parser without warning
+      this.registeredParsers[name] = parserInstance;
+    }
+
+  getInstance(parserOptions){
+    return new JsMinArrBuilder(parserOptions, this.options, this.registeredParsers);
+  }
+}
+
+import BaseOutputBuilder  from "./BaseOutputBuilder.js";
+const rootName = '^';
+
+class JsMinArrBuilder extends BaseOutputBuilder{
+
+  constructor(parserOptions, options,registeredParsers) {
+    super();
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+    this.options = options;
+    this.registeredParsers = registeredParsers;
+
+    this.root = {[rootName]: []};
+    this.currentNode = this.root;
+    this.currentNodeTagName = rootName;
+    this.attributes = {};
+  }
+
+  addTag(tag){
+    //when a new tag is added, it should be added as child of current node
+    //TODO: shift this check to the parser
+    if(tag.name === "__proto__") tag.name = "#__proto__";
+
+    this.tagsStack.push([this.currentNodeTagName,this.currentNode]); //this.currentNode is parent node here
+    this.currentNodeTagName = tag.name;
+    this.currentNode = { [tag.name]:[]}
+    if(Object.keys(this.attributes).length > 0){
+      this.currentNode[":@"] = this.attributes;
+      this.attributes = {};
+    }
+  }
+
+  /**
+   * Check if the node should be added by checking user's preference
+   * @param {Node} node 
+   * @returns boolean: true if the node should not be added
+   */
+  closeTag(){
+    const node = this.currentNode;
+    const nodeName = this.currentNodeTagName;
+    const arr = this.tagsStack.pop(); //set parent node in scope
+    this.currentNodeTagName = arr[0];
+    this.currentNode = arr[1];
+
+    if(this.options.onClose !== undefined){
+      //TODO TagPathMatcher 
+      const resultTag = this.options.onClose(node, 
+        new TagPathMatcher(this.tagsStack,node));
+
+      if(resultTag) return;
+    }
+    this.currentNode[this.currentNodeTagName].push(node);  //to parent node
+  }
+
+  //Called by parent class methods
+  _addChild(key, val){
+    // if(key === "__proto__") tagName = "#__proto__";
+    this.currentNode.push( {[key]: val });
+    // this.currentNode.leafType = false;
+  }
+
+  /**
+   * Add text value child node 
+   * @param {string} text 
+   */
+  addValue(text){
+    this.currentNode[this.currentNodeTagName].push( {[this.options.nameFor.text]: this.parseValue(text, this.options.tags.valueParsers) });
+  }
+
+  addPi(name){
+    if(!this.options.ignorePiTags){
+      const node = { [name]:[]}
+      if(this.attributes){
+        node[":@"] = this.attributes;
+      }
+      this.currentNode.push(node);
+    }
+    this.attributes = {};
+  }
+  getOutput(){
+    return this.root[rootName];
+  }
+}