@cdk8s/awscdk-resolver 0.0.134 → 0.0.136

package/node_modules/fast-xml-parser/src/fxp.d.ts

@@ -1,81 +1,375 @@
 type X2jOptions = {
-  preserveOrder: boolean;
-  attributeNamePrefix: string;
-  attributesGroupName: false | string;
-  textNodeName: string;
-  ignoreAttributes: boolean;
-  removeNSPrefix: boolean;
-  allowBooleanAttributes: boolean;
-  parseTagValue: boolean;
-  parseAttributeValue: boolean;
-  trimValues: boolean;
-  cdataPropName: false | string;
-  commentPropName: false | string;
-    /**
-Control how tag value should be parsed. Called only if tag value is not empty
-
-@returns {undefined|null} `undefined` or `null` to set original value.
-@returns {unknown} 
-1. Different value or value with different data type to set new value. <br>
-2. Same value to set parsed value if `parseTagValue: true`.
-   */
-  tagValueProcessor: (tagName: string, tagValue: string, jPath: string, hasAttributes: boolean, isLeafNode: boolean) => unknown;
-  attributeValueProcessor: (attrName: string, attrValue: string, jPath: string) => unknown;
-  numberParseOptions: strnumOptions;
-  stopNodes: string[];
-  unpairedTags: string[];
-  alwaysCreateTextNode: boolean;
-  isArray: (tagName: string, jPath: string, isLeafNode: boolean, isAttribute: boolean) => boolean;
-  processEntities: boolean;
-  htmlEntities: boolean;
-  ignoreDeclaration: boolean;
-  ignorePiTags: boolean;
-  transformTagName: ((tagName: string) => string) | false;
-  transformAttributeName: ((attributeName: string) => string) | false;
-    /**
-Change the tag name when a different name is returned. Skip the tag from parsed result when false is returned. 
-Modify `attrs` object to control attributes for the given tag.
-
-@returns {string} new tag name.
-@returns false to skip the tag
-   */
-  updateTag: (tagName: string, jPath: string, attrs: {[k: string]: string}) =>  string | boolean;
+  /**
+   * Preserve the order of tags in resulting JS object
+   * 
+   * Defaults to `false`
+   */
+  preserveOrder?: boolean;
+
+  /**
+   * Give a prefix to the attribute name in the resulting JS object
+   * 
+   * Defaults to '@_'
+   */  
+  attributeNamePrefix?: string;
+
+  /**
+   * A name to group all attributes of a tag under, or `false` to disable
+   * 
+   * Defaults to `false`
+   */
+  attributesGroupName?: false | string;
+
+  /**
+   * The name of the next node in the resulting JS
+   * 
+   * Defaults to `#text`
+   */
+  textNodeName?: string;
+
+  /**
+   * Whether to ignore attributes when parsing
+   * 
+   * Defaults to `true`
+   */
+  ignoreAttributes?: boolean;
+
+  /**
+   * Whether to remove namespace string from tag and attribute names
+   * 
+   * Defaults to `false`
+   */
+  removeNSPrefix?: boolean;
+
+  /**
+   * Whether to allow attributes without value
+   * 
+   * Defaults to `false`
+   */
+  allowBooleanAttributes?: boolean;
+
+  /**
+   * Whether to parse tag value with `strnum` package
+   * 
+   * Defaults to `true`
+   */
+  parseTagValue?: boolean;
+
+  /**
+   * Whether to parse tag value with `strnum` package
+   * 
+   * Defaults to `false`
+   */
+  parseAttributeValue?: boolean;
+
+  /**
+   * Whether to remove surrounding whitespace from tag or attribute value
+   * 
+   * Defaults to `true`
+   */
+  trimValues?: boolean;
+
+  /**
+   * Give a property name to set CDATA values to instead of merging to tag's text value
+   * 
+   * Defaults to `false`
+   */
+  cdataPropName?: false | string;
+
+  /**
+   * If set, parse comments and set as this property
+   * 
+   * Defaults to `false`
+   */
+  commentPropName?: false | string;
+
+  /**
+   * Control how tag value should be parsed. Called only if tag value is not empty
+   * 
+   * @returns {undefined|null} `undefined` or `null` to set original value.
+   * @returns {unknown} 
+   * 
+   * 1. Different value or value with different data type to set new value.
+   * 2. Same value to set parsed value if `parseTagValue: true`.
+   * 
+   * Defaults to `(tagName, val, jPath, hasAttributes, isLeafNode) => val`
+   */
+  tagValueProcessor?: (tagName: string, tagValue: string, jPath: string, hasAttributes: boolean, isLeafNode: boolean) => unknown;
+
+  /**
+   * Control how attribute value should be parsed
+   * 
+   * @param attrName 
+   * @param attrValue 
+   * @param jPath 
+   * @returns {undefined|null} `undefined` or `null` to set original value
+   * @returns {unknown}
+   * 
+   * Defaults to `(attrName, val, jPath) => val`
+   */
+  attributeValueProcessor?: (attrName: string, attrValue: string, jPath: string) => unknown;
+
+  /**
+   * Options to pass to `strnum` for parsing numbers
+   * 
+   * Defaults to `{ hex: true, leadingZeros: true, eNotation: true }`
+   */
+  numberParseOptions?: strnumOptions;
+
+  /**
+   * Nodes to stop parsing at
+   * 
+   * Defaults to `[]`
+   */
+  stopNodes?: string[];
+
+  /**
+   * List of tags without closing tags
+   * 
+   * Defaults to `[]`
+   */
+  unpairedTags?: string[];
+
+  /**
+   * Whether to always create a text node
+   * 
+   * Defaults to `false`
+   */
+  alwaysCreateTextNode?: boolean;
+
+  /**
+   * Determine whether a tag should be parsed as an array
+   * 
+   * @param tagName 
+   * @param jPath 
+   * @param isLeafNode 
+   * @param isAttribute 
+   * @returns {boolean}
+   * 
+   * Defaults to `() => false`
+   */
+  isArray?: (tagName: string, jPath: string, isLeafNode: boolean, isAttribute: boolean) => boolean;
+
+  /**
+   * Whether to process default and DOCTYPE entities
+   * 
+   * Defaults to `true`
+   */
+  processEntities?: boolean;
+
+  /**
+   * Whether to process HTML entities
+   * 
+   * Defaults to `false`
+   */
+  htmlEntities?: boolean;
+
+  /**
+   * Whether to ignore the declaration tag from output
+   * 
+   * Defaults to `false`
+   */
+  ignoreDeclaration?: boolean;
+
+  /**
+   * Whether to ignore Pi tags
+   * 
+   * Defaults to `false`
+   */
+  ignorePiTags?: boolean;
+
+  /**
+   * Transform tag names
+   * 
+   * Defaults to `false`
+   */
+  transformTagName?: ((tagName: string) => string) | false;
+
+  /**
+   * Transform attribute names
+   * 
+   * Defaults to `false`
+   */
+  transformAttributeName?: ((attributeName: string) => string) | false;
+
+  /**
+   * Change the tag name when a different name is returned. Skip the tag from parsed result when false is returned.
+   * Modify `attrs` object to control attributes for the given tag.
+   * 
+   * @returns {string} new tag name.
+   * @returns false to skip the tag
+   * 
+   * Defaults to `(tagName, jPath, attrs) => tagName`
+   */
+  updateTag?: (tagName: string, jPath: string, attrs: {[k: string]: string}) =>  string | boolean;
 };
+
 type strnumOptions = {
   hex: boolean;
   leadingZeros: boolean,
   skipLike?: RegExp,
   eNotation?: boolean
 }
-type X2jOptionsOptional = Partial<X2jOptions>;
+
 type validationOptions = {
-  allowBooleanAttributes: boolean;
-  unpairedTags: string[];
+  /**
+   * Whether to allow attributes without value
+   * 
+   * Defaults to `false`
+   */
+  allowBooleanAttributes?: boolean;
+  
+  /**
+   * List of tags without closing tags
+   * 
+   * Defaults to `[]`
+   */
+  unpairedTags?: string[];
 };
-type validationOptionsOptional = Partial<validationOptions>;
 
 type XmlBuilderOptions = {
-  attributeNamePrefix: string;
-  attributesGroupName: false | string;
-  textNodeName: string;
-  ignoreAttributes: boolean;
-  cdataPropName: false | string;
-  commentPropName: false | string;
-  format: boolean;
-  indentBy: string;
-  arrayNodeName: string;
-  suppressEmptyNode: boolean;
-  suppressUnpairedNode: boolean;
-  suppressBooleanAttributes: boolean;
-  preserveOrder: boolean;
-  unpairedTags: string[];
-  stopNodes: string[];
-  tagValueProcessor: (name: string, value: unknown) => string;
-  attributeValueProcessor: (name: string, value: unknown) => string;
-  processEntities: boolean;
-  oneListGroup: boolean;
+  /**
+   * Give a prefix to the attribute name in the resulting JS object
+   * 
+   * Defaults to '@_'
+   */  
+  attributeNamePrefix?: string;
+
+  /**
+   * A name to group all attributes of a tag under, or `false` to disable
+   * 
+   * Defaults to `false`
+   */
+  attributesGroupName?: false | string;
+
+  /**
+   * The name of the next node in the resulting JS
+   * 
+   * Defaults to `#text`
+   */
+  textNodeName?: string;
+
+  /**
+   * Whether to ignore attributes when parsing
+   * 
+   * Defaults to `true`
+   */
+  ignoreAttributes?: boolean;
+
+  /**
+   * Give a property name to set CDATA values to instead of merging to tag's text value
+   * 
+   * Defaults to `false`
+   */
+  cdataPropName?: false | string;
+
+  /**
+   * If set, parse comments and set as this property
+   * 
+   * Defaults to `false`
+   */
+  commentPropName?: false | string;
+
+  /**
+   * Whether to make output pretty instead of single line
+   * 
+   * Defaults to `false`
+   */
+  format?: boolean;
+
+
+  /**
+   * If `format` is set to `true`, sets the indent string
+   * 
+   * Defaults to `  `
+   */
+  indentBy?: string;
+
+  /**
+   * Give a name to a top-level array
+   * 
+   * Defaults to `undefined`
+   */
+  arrayNodeName?: string;
+
+  /**
+   * Create empty tags for tags with no text value
+   * 
+   * Defaults to `false`
+   */
+  suppressEmptyNode?: boolean;
+
+  /**
+   * Suppress an unpaired tag
+   * 
+   * Defaults to `true`
+   */
+  suppressUnpairedNode?: boolean;
+
+  /**
+   * Don't put a value for boolean attributes
+   * 
+   * Defaults to `true`
+   */
+  suppressBooleanAttributes?: boolean;
+
+  /**
+   * Preserve the order of tags in resulting JS object
+   * 
+   * Defaults to `false`
+   */
+  preserveOrder?: boolean;
+
+  /**
+   * List of tags without closing tags
+   * 
+   * Defaults to `[]`
+   */
+  unpairedTags?: string[];
+
+  /**
+   * Nodes to stop parsing at
+   * 
+   * Defaults to `[]`
+   */
+  stopNodes?: string[];
+
+  /**
+   * Control how tag value should be parsed. Called only if tag value is not empty
+   * 
+   * @returns {undefined|null} `undefined` or `null` to set original value.
+   * @returns {unknown} 
+   * 
+   * 1. Different value or value with different data type to set new value.
+   * 2. Same value to set parsed value if `parseTagValue: true`.
+   * 
+   * Defaults to `(tagName, val, jPath, hasAttributes, isLeafNode) => val`
+   */
+  tagValueProcessor?: (name: string, value: unknown) => unknown;
+
+  /**
+   * Control how attribute value should be parsed
+   * 
+   * @param attrName 
+   * @param attrValue 
+   * @param jPath 
+   * @returns {undefined|null} `undefined` or `null` to set original value
+   * @returns {unknown}
+   * 
+   * Defaults to `(attrName, val, jPath) => val`
+   */
+  attributeValueProcessor?: (name: string, value: unknown) => unknown;
+
+  /**
+   * Whether to process default and DOCTYPE entities
+   * 
+   * Defaults to `true`
+   */
+  processEntities?: boolean;
+
+
+  oneListGroup?: boolean;
 };
-type XmlBuilderOptionsOptional = Partial<XmlBuilderOptions>;
 
 type ESchema = string | object | Array<string|object>;
 
@@ -89,20 +383,20 @@ type ValidationError = {
 };
 
 export class XMLParser {
-  constructor(options?: X2jOptionsOptional);
-  parse(xmlData: string | Buffer ,validationOptions?: validationOptionsOptional | boolean): any;
+  constructor(options?: X2jOptions);
+  parse(xmlData: string | Buffer ,validationOptions?: validationOptions | boolean): any;
   /**
    * Add Entity which is not by default supported by this library
-   * @param entityIndentifier {string} Eg: 'ent' for &ent;
+   * @param entityIdentifier {string} Eg: 'ent' for &ent;
    * @param entityValue {string} Eg: '\r'
    */
-  addEntity(entityIndentifier: string, entityValue: string): void;
+  addEntity(entityIdentifier: string, entityValue: string): void;
 }
 
 export class XMLValidator{
-  static validate(  xmlData: string,  options?: validationOptionsOptional): true | ValidationError;
+  static validate(  xmlData: string,  options?: validationOptions): true | ValidationError;
 }
 export class XMLBuilder {
-  constructor(options?: XmlBuilderOptionsOptional);
+  constructor(options?: XmlBuilderOptions);
   build(jObj: any): any;
 }

package/node_modules/fast-xml-parser/src/v5/CharsSymbol.js

@@ -0,0 +1,16 @@
+modules.export = {
+  "<" : "<", //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/node_modules/fast-xml-parser/src/v5/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/OptionsBuilder.js

@@ -0,0 +1,64 @@
+
+const JsObjOutputBuilder = require("./OutputBuilders/JsObjBuilder");
+
+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(),
+};
+   
+const buildOptions = function(options) {
+  const finalOptions = { ... defaultOptions};
+  copyProperties(finalOptions,options)
+  return finalOptions;
+};
+
+function copyProperties(target, source) {
+  for (let key in source) {
+    if (source.hasOwnProperty(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];
+      }
+    }
+  }
+}
+
+exports.buildOptions = buildOptions;
+exports.defaultOptions = defaultOptions;