Send to zulip

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/lib/xml/browser_parser.js

@@ -0,0 +1,201 @@
+var util = require('../util');
+var Shape = require('../model/shape');
+
+function DomXmlParser() { }
+
+DomXmlParser.prototype.parse = function(xml, shape) {
+  if (xml.replace(/^\s+/, '') === '') return {};
+
+  var result, error;
+  try {
+    if (window.DOMParser) {
+      try {
+        var parser = new DOMParser();
+        result = parser.parseFromString(xml, 'text/xml');
+      } catch (syntaxError) {
+        throw util.error(new Error('Parse error in document'),
+          {
+            originalError: syntaxError,
+            code: 'XMLParserError',
+            retryable: true
+          });
+      }
+
+      if (result.documentElement === null) {
+        throw util.error(new Error('Cannot parse empty document.'),
+          {
+            code: 'XMLParserError',
+            retryable: true
+          });
+      }
+
+      var isError = result.getElementsByTagName('parsererror')[0];
+      if (isError && (isError.parentNode === result ||
+          isError.parentNode.nodeName === 'body' ||
+          isError.parentNode.parentNode === result ||
+          isError.parentNode.parentNode.nodeName === 'body')) {
+        var errorElement = isError.getElementsByTagName('div')[0] || isError;
+        throw util.error(new Error(errorElement.textContent || 'Parser error in document'),
+          {
+            code: 'XMLParserError',
+            retryable: true
+          });
+      }
+    } else if (window.ActiveXObject) {
+      result = new window.ActiveXObject('Microsoft.XMLDOM');
+      result.async = false;
+
+      if (!result.loadXML(xml)) {
+        throw util.error(new Error('Parse error in document'),
+          {
+            code: 'XMLParserError',
+            retryable: true
+          });
+      }
+    } else {
+      throw new Error('Cannot load XML parser');
+    }
+  } catch (e) {
+    error = e;
+  }
+
+  if (result && result.documentElement && !error) {
+    var data = parseXml(result.documentElement, shape);
+    var metadata = getElementByTagName(result.documentElement, 'ResponseMetadata');
+    if (metadata) {
+      data.ResponseMetadata = parseXml(metadata, {});
+    }
+    return data;
+  } else if (error) {
+    throw util.error(error || new Error(), {code: 'XMLParserError', retryable: true});
+  } else { // empty xml document
+    return {};
+  }
+};
+
+function getElementByTagName(xml, tag) {
+  var elements = xml.getElementsByTagName(tag);
+  for (var i = 0, iLen = elements.length; i < iLen; i++) {
+    if (elements[i].parentNode === xml) {
+      return elements[i];
+    }
+  }
+}
+
+function parseXml(xml, shape) {
+  if (!shape) shape = {};
+  switch (shape.type) {
+    case 'structure': return parseStructure(xml, shape);
+    case 'map': return parseMap(xml, shape);
+    case 'list': return parseList(xml, shape);
+    case undefined: case null: return parseUnknown(xml);
+    default: return parseScalar(xml, shape);
+  }
+}
+
+function parseStructure(xml, shape) {
+  var data = {};
+  if (xml === null) return data;
+
+  util.each(shape.members, function(memberName, memberShape) {
+    if (memberShape.isXmlAttribute) {
+      if (Object.prototype.hasOwnProperty.call(xml.attributes, memberShape.name)) {
+        var value = xml.attributes[memberShape.name].value;
+        data[memberName] = parseXml({textContent: value}, memberShape);
+      }
+    } else {
+      var xmlChild = memberShape.flattened ? xml :
+        getElementByTagName(xml, memberShape.name);
+      if (xmlChild) {
+        data[memberName] = parseXml(xmlChild, memberShape);
+      } else if (
+        !memberShape.flattened &&
+        memberShape.type === 'list' &&
+        !shape.api.xmlNoDefaultLists) {
+        data[memberName] = memberShape.defaultValue;
+      }
+    }
+  });
+
+  return data;
+}
+
+function parseMap(xml, shape) {
+  var data = {};
+  var xmlKey = shape.key.name || 'key';
+  var xmlValue = shape.value.name || 'value';
+  var tagName = shape.flattened ? shape.name : 'entry';
+
+  var child = xml.firstElementChild;
+  while (child) {
+    if (child.nodeName === tagName) {
+      var key = getElementByTagName(child, xmlKey).textContent;
+      var value = getElementByTagName(child, xmlValue);
+      data[key] = parseXml(value, shape.value);
+    }
+    child = child.nextElementSibling;
+  }
+  return data;
+}
+
+function parseList(xml, shape) {
+  var data = [];
+  var tagName = shape.flattened ? shape.name : (shape.member.name || 'member');
+
+  var child = xml.firstElementChild;
+  while (child) {
+    if (child.nodeName === tagName) {
+      data.push(parseXml(child, shape.member));
+    }
+    child = child.nextElementSibling;
+  }
+  return data;
+}
+
+function parseScalar(xml, shape) {
+  if (xml.getAttribute) {
+    var encoding = xml.getAttribute('encoding');
+    if (encoding === 'base64') {
+      shape = new Shape.create({type: encoding});
+    }
+  }
+
+  var text = xml.textContent;
+  if (text === '') text = null;
+  if (typeof shape.toType === 'function') {
+    return shape.toType(text);
+  } else {
+    return text;
+  }
+}
+
+function parseUnknown(xml) {
+  if (xml === undefined || xml === null) return '';
+
+  // empty object
+  if (!xml.firstElementChild) {
+    if (xml.parentNode.parentNode === null) return {};
+    if (xml.childNodes.length === 0) return '';
+    else return xml.textContent;
+  }
+
+  // object, parse as structure
+  var shape = {type: 'structure', members: {}};
+  var child = xml.firstElementChild;
+  while (child) {
+    var tag = child.nodeName;
+    if (Object.prototype.hasOwnProperty.call(shape.members, tag)) {
+      // multiple tags of the same name makes it a list
+      shape.members[tag].type = 'list';
+    } else {
+      shape.members[tag] = {name: tag};
+    }
+    child = child.nextElementSibling;
+  }
+  return parseStructure(xml, shape);
+}
+
+/**
+ * @api private
+ */
+module.exports = DomXmlParser;

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/lib/xml/builder.js

@@ -0,0 +1,102 @@
+var util = require('../util');
+var XmlNode = require('./xml-node').XmlNode;
+var XmlText = require('./xml-text').XmlText;
+
+function XmlBuilder() { }
+
+XmlBuilder.prototype.toXML = function(params, shape, rootElement, noEmpty) {
+  var xml = new XmlNode(rootElement);
+  applyNamespaces(xml, shape, true);
+  serialize(xml, params, shape);
+  return xml.children.length > 0 || noEmpty ? xml.toString() : '';
+};
+
+function serialize(xml, value, shape) {
+  switch (shape.type) {
+    case 'structure': return serializeStructure(xml, value, shape);
+    case 'map': return serializeMap(xml, value, shape);
+    case 'list': return serializeList(xml, value, shape);
+    default: return serializeScalar(xml, value, shape);
+  }
+}
+
+function serializeStructure(xml, params, shape) {
+  util.arrayEach(shape.memberNames, function(memberName) {
+    var memberShape = shape.members[memberName];
+    if (memberShape.location !== 'body') return;
+
+    var value = params[memberName];
+    var name = memberShape.name;
+    if (value !== undefined && value !== null) {
+      if (memberShape.isXmlAttribute) {
+        xml.addAttribute(name, value);
+      } else if (memberShape.flattened) {
+        serialize(xml, value, memberShape);
+      } else {
+        var element = new XmlNode(name);
+        xml.addChildNode(element);
+        applyNamespaces(element, memberShape);
+        serialize(element, value, memberShape);
+      }
+    }
+  });
+}
+
+function serializeMap(xml, map, shape) {
+  var xmlKey = shape.key.name || 'key';
+  var xmlValue = shape.value.name || 'value';
+
+  util.each(map, function(key, value) {
+    var entry = new XmlNode(shape.flattened ? shape.name : 'entry');
+    xml.addChildNode(entry);
+
+    var entryKey = new XmlNode(xmlKey);
+    var entryValue = new XmlNode(xmlValue);
+    entry.addChildNode(entryKey);
+    entry.addChildNode(entryValue);
+
+    serialize(entryKey, key, shape.key);
+    serialize(entryValue, value, shape.value);
+  });
+}
+
+function serializeList(xml, list, shape) {
+  if (shape.flattened) {
+    util.arrayEach(list, function(value) {
+      var name = shape.member.name || shape.name;
+      var element = new XmlNode(name);
+      xml.addChildNode(element);
+      serialize(element, value, shape.member);
+    });
+  } else {
+    util.arrayEach(list, function(value) {
+      var name = shape.member.name || 'member';
+      var element = new XmlNode(name);
+      xml.addChildNode(element);
+      serialize(element, value, shape.member);
+    });
+  }
+}
+
+function serializeScalar(xml, value, shape) {
+  xml.addChildNode(
+    new XmlText(shape.toWireFormat(value))
+  );
+}
+
+function applyNamespaces(xml, shape, isRoot) {
+  var uri, prefix = 'xmlns';
+  if (shape.xmlNamespaceUri) {
+    uri = shape.xmlNamespaceUri;
+    if (shape.xmlNamespacePrefix) prefix += ':' + shape.xmlNamespacePrefix;
+  } else if (isRoot && shape.api.xmlNamespaceUri) {
+    uri = shape.api.xmlNamespaceUri;
+  }
+
+  if (uri) xml.addAttribute(prefix, uri);
+}
+
+/**
+ * @api private
+ */
+module.exports = XmlBuilder;

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/lib/xml/escape-attribute.js

@@ -0,0 +1,13 @@
+/**
+ * Escapes characters that can not be in an XML attribute.
+ */
+function escapeAttribute(value) {
+    return value.replace(/&/g, '&amp;').replace(/'/g, '&apos;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+/**
+ * @api private
+ */
+module.exports = {
+    escapeAttribute: escapeAttribute
+};

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/lib/xml/escape-element.js

@@ -0,0 +1,19 @@
+/**
+ * Escapes characters that can not be in an XML element.
+ */
+function escapeElement(value) {
+    return value.replace(/&/g, '&')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/\r/g, '&#x0D;')
+                .replace(/\n/g, '&#x0A;')
+                .replace(/\u0085/g, '&#x85;')
+                .replace(/\u2028/, '&#x2028;');
+}
+
+/**
+ * @api private
+ */
+module.exports = {
+    escapeElement: escapeElement
+};

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/lib/xml/node_parser.js

@@ -0,0 +1,163 @@
+var AWS = require('../core');
+var util = AWS.util;
+var Shape = AWS.Model.Shape;
+
+var xml2js = require('xml2js');
+
+/**
+ * @api private
+ */
+var options = {  // options passed to xml2js parser
+  explicitCharkey: false, // undocumented
+  trim: false,            // trim the leading/trailing whitespace from text nodes
+  normalize: false,       // trim interior whitespace inside text nodes
+  explicitRoot: false,    // return the root node in the resulting object?
+  emptyTag: null,         // the default value for empty nodes
+  explicitArray: true,    // always put child nodes in an array
+  ignoreAttrs: false,     // ignore attributes, only create text nodes
+  mergeAttrs: false,      // merge attributes and child elements
+  validator: null         // a callable validator
+};
+
+function NodeXmlParser() { }
+
+NodeXmlParser.prototype.parse = function(xml, shape) {
+  shape = shape || {};
+
+  var result = null;
+  var error = null;
+
+  var parser = new xml2js.Parser(options);
+  parser.parseString(xml, function (e, r) {
+    error = e;
+    result = r;
+  });
+
+  if (result) {
+    var data = parseXml(result, shape);
+    if (result.ResponseMetadata) {
+      data.ResponseMetadata = parseXml(result.ResponseMetadata[0], {});
+    }
+    return data;
+  } else if (error) {
+    throw util.error(error, {code: 'XMLParserError', retryable: true});
+  } else { // empty xml document
+    return parseXml({}, shape);
+  }
+};
+
+function parseXml(xml, shape) {
+  switch (shape.type) {
+    case 'structure': return parseStructure(xml, shape);
+    case 'map': return parseMap(xml, shape);
+    case 'list': return parseList(xml, shape);
+    case undefined: case null: return parseUnknown(xml);
+    default: return parseScalar(xml, shape);
+  }
+}
+
+function parseStructure(xml, shape) {
+  var data = {};
+  if (xml === null) return data;
+
+  util.each(shape.members, function(memberName, memberShape) {
+    var xmlName = memberShape.name;
+    if (Object.prototype.hasOwnProperty.call(xml, xmlName) && Array.isArray(xml[xmlName])) {
+      var xmlChild = xml[xmlName];
+      if (!memberShape.flattened) xmlChild = xmlChild[0];
+
+      data[memberName] = parseXml(xmlChild, memberShape);
+    } else if (memberShape.isXmlAttribute &&
+               xml.$ && Object.prototype.hasOwnProperty.call(xml.$, xmlName)) {
+      data[memberName] = parseScalar(xml.$[xmlName], memberShape);
+    } else if (memberShape.type === 'list' && !shape.api.xmlNoDefaultLists) {
+      data[memberName] = memberShape.defaultValue;
+    }
+  });
+
+  return data;
+}
+
+function parseMap(xml, shape) {
+  var data = {};
+  if (xml === null) return data;
+
+  var xmlKey = shape.key.name || 'key';
+  var xmlValue = shape.value.name || 'value';
+  var iterable = shape.flattened ? xml : xml.entry;
+
+  if (Array.isArray(iterable)) {
+    util.arrayEach(iterable, function(child) {
+      data[child[xmlKey][0]] = parseXml(child[xmlValue][0], shape.value);
+    });
+  }
+
+  return data;
+}
+
+function parseList(xml, shape) {
+  var data = [];
+  var name = shape.member.name || 'member';
+  if (shape.flattened) {
+    util.arrayEach(xml, function(xmlChild) {
+      data.push(parseXml(xmlChild, shape.member));
+    });
+  } else if (xml && Array.isArray(xml[name])) {
+    util.arrayEach(xml[name], function(child) {
+      data.push(parseXml(child, shape.member));
+    });
+  }
+
+  return data;
+}
+
+function parseScalar(text, shape) {
+  if (text && text.$ && text.$.encoding === 'base64') {
+    shape = new Shape.create({type: text.$.encoding});
+  }
+  if (text && text._) text = text._;
+
+  if (typeof shape.toType === 'function') {
+    return shape.toType(text);
+  } else {
+    return text;
+  }
+}
+
+function parseUnknown(xml) {
+  if (xml === undefined || xml === null) return '';
+  if (typeof xml === 'string') return xml;
+
+  // parse a list
+  if (Array.isArray(xml)) {
+    var arr = [];
+    for (i = 0; i < xml.length; i++) {
+      arr.push(parseXml(xml[i], {}));
+    }
+    return arr;
+  }
+
+  // empty object
+  var keys = Object.keys(xml), i;
+  if (keys.length === 0 || (keys.length === 1 && keys[0] === '$')) {
+    return {};
+  }
+
+  // object, parse as structure
+  var data = {};
+  for (i = 0; i < keys.length; i++) {
+    var key = keys[i], value = xml[key];
+    if (key === '$') continue;
+    if (value.length > 1) { // this member is a list
+      data[key] = parseList(value, {member: {}});
+    } else { // this member is a single item
+      data[key] = parseXml(value[0], {});
+    }
+  }
+  return data;
+}
+
+/**
+ * @api private
+ */
+module.exports = NodeXmlParser;

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/lib/xml/xml-node.js

@@ -0,0 +1,45 @@
+var escapeAttribute = require('./escape-attribute').escapeAttribute;
+
+/**
+ * Represents an XML node.
+ * @api private
+ */
+function XmlNode(name, children) {
+    if (children === void 0) { children = []; }
+    this.name = name;
+    this.children = children;
+    this.attributes = {};
+}
+XmlNode.prototype.addAttribute = function (name, value) {
+    this.attributes[name] = value;
+    return this;
+};
+XmlNode.prototype.addChildNode = function (child) {
+    this.children.push(child);
+    return this;
+};
+XmlNode.prototype.removeAttribute = function (name) {
+    delete this.attributes[name];
+    return this;
+};
+XmlNode.prototype.toString = function () {
+    var hasChildren = Boolean(this.children.length);
+    var xmlText = '<' + this.name;
+    // add attributes
+    var attributes = this.attributes;
+    for (var i = 0, attributeNames = Object.keys(attributes); i < attributeNames.length; i++) {
+        var attributeName = attributeNames[i];
+        var attribute = attributes[attributeName];
+        if (typeof attribute !== 'undefined' && attribute !== null) {
+            xmlText += ' ' + attributeName + '=\"' + escapeAttribute('' + attribute) + '\"';
+        }
+    }
+    return xmlText += !hasChildren ? '/>' : '>' + this.children.map(function (c) { return c.toString(); }).join('') + '</' + this.name + '>';
+};
+
+/**
+ * @api private
+ */
+module.exports = {
+    XmlNode: XmlNode
+};

aws/lambda-nodejs18.x/UpdateZulipStreams/node_modules/aws-sdk/lib/xml/xml-text.js

@@ -0,0 +1,20 @@
+var escapeElement = require('./escape-element').escapeElement;
+
+/**
+ * Represents an XML text value.
+ * @api private
+ */
+function XmlText(value) {
+    this.value = value;
+}
+
+XmlText.prototype.toString = function () {
+    return escapeElement('' + this.value);
+};
+
+/**
+ * @api private
+ */
+module.exports = {
+    XmlText: XmlText
+};