instabug-reactnative/plugin/build/index.js

React Native plugin for integrating the Instabug SDK

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var require$$0$2 = require('assert');
var require$$0 = require('fs');
var require$$0$1 = require('path');
var require$$1$2 = require('os');
var require$$1 = require('string_decoder');
var require$$1$1 = require('events');
var require$$4 = require('timers');
var require$$0$3 = require('tty');
var require$$1$3 = require('util');
var require$$1$4 = require('url');
var require$$1$5 = require('module');
var require$$0$4 = require('fs/promises');
var crypto = require('crypto');
var require$$0$5 = require('child_process');
var require$$0$6 = require('constants');
var require$$0$7 = require('stream');

function _interopNamespaceDefault(e) {
    var n = Object.create(null);
    if (e) {
        Object.keys(e).forEach(function (k) {
            if (k !== 'default') {
                var d = Object.getOwnPropertyDescriptor(e, k);
                Object.defineProperty(n, k, d.get ? d : {
                    enumerable: true,
                    get: function () { return e[k]; }
                });
            }
        });
    }
    n.default = e;
    return Object.freeze(n);
}

var require$$0__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(require$$0);
var require$$0__namespace = /*#__PURE__*/_interopNamespaceDefault(require$$0$1);

var __assign = function() {
    __assign = Object.assign || function __assign(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
function __spreadArray(to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
}
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
    var e = new Error(message);
    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function getDefaultExportFromCjs (x) {
	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}

function getAugmentedNamespace(n) {
  if (n.__esModule) return n;
  var f = n.default;
	if (typeof f == "function") {
		var a = function a () {
			if (this instanceof a) {
        return Reflect.construct(f, arguments, this.constructor);
			}
			return f.apply(this, arguments);
		};
		a.prototype = f.prototype;
  } else a = {};
  Object.defineProperty(a, '__esModule', {value: true});
	Object.keys(n).forEach(function (k) {
		var d = Object.getOwnPropertyDescriptor(n, k);
		Object.defineProperty(a, k, d.get ? d : {
			enumerable: true,
			get: function () {
				return n[k];
			}
		});
	});
	return a;
}

var build$4 = {};

var android = {};

var AllowBackup = {};

var Manifest = {};

var XML = {};

var xml2js = {};

var defaults = {};

var hasRequiredDefaults;
function requireDefaults () {
	if (hasRequiredDefaults) return defaults;
	hasRequiredDefaults = 1;
	(function() {
	  defaults.defaults = {
	    "0.1": {
	      explicitCharkey: false,
	      trim: true,
	      normalize: true,
	      normalizeTags: false,
	      attrkey: "@",
	      charkey: "#",
	      explicitArray: false,
	      ignoreAttrs: false,
	      mergeAttrs: false,
	      explicitRoot: false,
	      validator: null,
	      xmlns: false,
	      explicitChildren: false,
	      childkey: '@@',
	      charsAsChildren: false,
	      includeWhiteChars: false,
	      async: false,
	      strict: true,
	      attrNameProcessors: null,
	      attrValueProcessors: null,
	      tagNameProcessors: null,
	      valueProcessors: null,
	      emptyTag: ''
	    },
	    "0.2": {
	      explicitCharkey: false,
	      trim: false,
	      normalize: false,
	      normalizeTags: false,
	      attrkey: "$",
	      charkey: "_",
	      explicitArray: true,
	      ignoreAttrs: false,
	      mergeAttrs: false,
	      explicitRoot: true,
	      validator: null,
	      xmlns: false,
	      explicitChildren: false,
	      preserveChildrenOrder: false,
	      childkey: '$$',
	      charsAsChildren: false,
	      includeWhiteChars: false,
	      async: false,
	      strict: true,
	      attrNameProcessors: null,
	      attrValueProcessors: null,
	      tagNameProcessors: null,
	      valueProcessors: null,
	      rootName: 'root',
	      xmldec: {
	        'version': '1.0',
	        'encoding': 'UTF-8',
	        'standalone': true
	      },
	      doctype: null,
	      renderOpts: {
	        'pretty': true,
	        'indent': '  ',
	        'newline': '\n'
	      },
	      headless: false,
	      chunkSize: 10000,
	      emptyTag: '',
	      cdata: false
	    }
	  };
	}).call(commonjsGlobal);
	return defaults;
}

var builder = {};

var lib$6 = {};

var Utility$1 = {};

var hasRequiredUtility$1;
function requireUtility$1 () {
	if (hasRequiredUtility$1) return Utility$1;
	hasRequiredUtility$1 = 1;
	(function() {
	  var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject,
	    slice = [].slice,
	    hasProp = {}.hasOwnProperty;
	  assign = function() {
	    var i, key, len, source, sources, target;
	    target = arguments[0], sources = 2 <= arguments.length ? slice.call(arguments, 1) : [];
	    if (isFunction(Object.assign)) {
	      Object.assign.apply(null, arguments);
	    } else {
	      for (i = 0, len = sources.length; i < len; i++) {
	        source = sources[i];
	        if (source != null) {
	          for (key in source) {
	            if (!hasProp.call(source, key)) continue;
	            target[key] = source[key];
	          }
	        }
	      }
	    }
	    return target;
	  };
	  isFunction = function(val) {
	    return !!val && Object.prototype.toString.call(val) === '[object Function]';
	  };
	  isObject = function(val) {
	    var ref;
	    return !!val && ((ref = typeof val) === 'function' || ref === 'object');
	  };
	  isArray = function(val) {
	    if (isFunction(Array.isArray)) {
	      return Array.isArray(val);
	    } else {
	      return Object.prototype.toString.call(val) === '[object Array]';
	    }
	  };
	  isEmpty = function(val) {
	    var key;
	    if (isArray(val)) {
	      return !val.length;
	    } else {
	      for (key in val) {
	        if (!hasProp.call(val, key)) continue;
	        return false;
	      }
	      return true;
	    }
	  };
	  isPlainObject = function(val) {
	    var ctor, proto;
	    return isObject(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && (typeof ctor === 'function') && (ctor instanceof ctor) && (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));
	  };
	  getValue = function(obj) {
	    if (isFunction(obj.valueOf)) {
	      return obj.valueOf();
	    } else {
	      return obj;
	    }
	  };
	  Utility$1.assign = assign;
	  Utility$1.isFunction = isFunction;
	  Utility$1.isObject = isObject;
	  Utility$1.isArray = isArray;
	  Utility$1.isEmpty = isEmpty;
	  Utility$1.isPlainObject = isPlainObject;
	  Utility$1.getValue = getValue;
	}).call(commonjsGlobal);
	return Utility$1;
}

var XMLDOMImplementation$1 = {exports: {}};

var hasRequiredXMLDOMImplementation$1;
function requireXMLDOMImplementation$1 () {
	if (hasRequiredXMLDOMImplementation$1) return XMLDOMImplementation$1.exports;
	hasRequiredXMLDOMImplementation$1 = 1;
	(function() {
	  XMLDOMImplementation$1.exports = (function() {
	    function XMLDOMImplementation() {}
	    XMLDOMImplementation.prototype.hasFeature = function(feature, version) {
	      return true;
	    };
	    XMLDOMImplementation.prototype.createDocumentType = function(qualifiedName, publicId, systemId) {
	      throw new Error("This DOM method is not implemented.");
	    };
	    XMLDOMImplementation.prototype.createDocument = function(namespaceURI, qualifiedName, doctype) {
	      throw new Error("This DOM method is not implemented.");
	    };
	    XMLDOMImplementation.prototype.createHTMLDocument = function(title) {
	      throw new Error("This DOM method is not implemented.");
	    };
	    XMLDOMImplementation.prototype.getFeature = function(feature, version) {
	      throw new Error("This DOM method is not implemented.");
	    };
	    return XMLDOMImplementation;
	  })();
	}).call(commonjsGlobal);
	return XMLDOMImplementation$1.exports;
}

var XMLDocument$1 = {exports: {}};

var XMLDOMConfiguration$1 = {exports: {}};

var XMLDOMErrorHandler$1 = {exports: {}};

var hasRequiredXMLDOMErrorHandler$1;
function requireXMLDOMErrorHandler$1 () {
	if (hasRequiredXMLDOMErrorHandler$1) return XMLDOMErrorHandler$1.exports;
	hasRequiredXMLDOMErrorHandler$1 = 1;
	(function() {
	  XMLDOMErrorHandler$1.exports = (function() {
	    function XMLDOMErrorHandler() {}
	    XMLDOMErrorHandler.prototype.handleError = function(error) {
	      throw new Error(error);
	    };
	    return XMLDOMErrorHandler;
	  })();
	}).call(commonjsGlobal);
	return XMLDOMErrorHandler$1.exports;
}

var XMLDOMStringList$1 = {exports: {}};

var hasRequiredXMLDOMStringList$1;
function requireXMLDOMStringList$1 () {
	if (hasRequiredXMLDOMStringList$1) return XMLDOMStringList$1.exports;
	hasRequiredXMLDOMStringList$1 = 1;
	(function() {
	  XMLDOMStringList$1.exports = (function() {
	    function XMLDOMStringList(arr) {
	      this.arr = arr || [];
	    }
	    Object.defineProperty(XMLDOMStringList.prototype, 'length', {
	      get: function() {
	        return this.arr.length;
	      }
	    });
	    XMLDOMStringList.prototype.item = function(index) {
	      return this.arr[index] || null;
	    };
	    XMLDOMStringList.prototype.contains = function(str) {
	      return this.arr.indexOf(str) !== -1;
	    };
	    return XMLDOMStringList;
	  })();
	}).call(commonjsGlobal);
	return XMLDOMStringList$1.exports;
}

var hasRequiredXMLDOMConfiguration$1;
function requireXMLDOMConfiguration$1 () {
	if (hasRequiredXMLDOMConfiguration$1) return XMLDOMConfiguration$1.exports;
	hasRequiredXMLDOMConfiguration$1 = 1;
	(function() {
	  var XMLDOMErrorHandler, XMLDOMStringList;
	  XMLDOMErrorHandler = requireXMLDOMErrorHandler$1();
	  XMLDOMStringList = requireXMLDOMStringList$1();
	  XMLDOMConfiguration$1.exports = (function() {
	    function XMLDOMConfiguration() {
	      this.defaultParams = {
	        "canonical-form": false,
	        "cdata-sections": false,
	        "comments": false,
	        "datatype-normalization": false,
	        "element-content-whitespace": true,
	        "entities": true,
	        "error-handler": new XMLDOMErrorHandler(),
	        "infoset": true,
	        "validate-if-schema": false,
	        "namespaces": true,
	        "namespace-declarations": true,
	        "normalize-characters": false,
	        "schema-location": '',
	        "schema-type": '',
	        "split-cdata-sections": true,
	        "validate": false,
	        "well-formed": true
	      };
	      this.params = Object.create(this.defaultParams);
	    }
	    Object.defineProperty(XMLDOMConfiguration.prototype, 'parameterNames', {
	      get: function() {
	        return new XMLDOMStringList(Object.keys(this.defaultParams));
	      }
	    });
	    XMLDOMConfiguration.prototype.getParameter = function(name) {
	      if (this.params.hasOwnProperty(name)) {
	        return this.params[name];
	      } else {
	        return null;
	      }
	    };
	    XMLDOMConfiguration.prototype.canSetParameter = function(name, value) {
	      return true;
	    };
	    XMLDOMConfiguration.prototype.setParameter = function(name, value) {
	      if (value != null) {
	        return this.params[name] = value;
	      } else {
	        return delete this.params[name];
	      }
	    };
	    return XMLDOMConfiguration;
	  })();
	}).call(commonjsGlobal);
	return XMLDOMConfiguration$1.exports;
}

var XMLNode$1 = {exports: {}};

var XMLElement$1 = {exports: {}};

var NodeType$1 = {exports: {}};

var hasRequiredNodeType$1;
function requireNodeType$1 () {
	if (hasRequiredNodeType$1) return NodeType$1.exports;
	hasRequiredNodeType$1 = 1;
	(function() {
	  NodeType$1.exports = {
	    Element: 1,
	    Attribute: 2,
	    Text: 3,
	    CData: 4,
	    EntityReference: 5,
	    EntityDeclaration: 6,
	    ProcessingInstruction: 7,
	    Comment: 8,
	    Document: 9,
	    DocType: 10,
	    DocumentFragment: 11,
	    NotationDeclaration: 12,
	    Declaration: 201,
	    Raw: 202,
	    AttributeDeclaration: 203,
	    ElementDeclaration: 204,
	    Dummy: 205
	  };
	}).call(commonjsGlobal);
	return NodeType$1.exports;
}

var XMLAttribute$1 = {exports: {}};

var hasRequiredXMLAttribute$1;
function requireXMLAttribute$1 () {
	if (hasRequiredXMLAttribute$1) return XMLAttribute$1.exports;
	hasRequiredXMLAttribute$1 = 1;
	(function() {
	  var NodeType;
	  NodeType = requireNodeType$1();
	  requireXMLNode$1();
	  XMLAttribute$1.exports = (function() {
	    function XMLAttribute(parent, name, value) {
	      this.parent = parent;
	      if (this.parent) {
	        this.options = this.parent.options;
	        this.stringify = this.parent.stringify;
	      }
	      if (name == null) {
	        throw new Error("Missing attribute name. " + this.debugInfo(name));
	      }
	      this.name = this.stringify.name(name);
	      this.value = this.stringify.attValue(value);
	      this.type = NodeType.Attribute;
	      this.isId = false;
	      this.schemaTypeInfo = null;
	    }
	    Object.defineProperty(XMLAttribute.prototype, 'nodeType', {
	      get: function() {
	        return this.type;
	      }
	    });
	    Object.defineProperty(XMLAttribute.prototype, 'ownerElement', {
	      get: function() {
	        return this.parent;
	      }
	    });
	    Object.defineProperty(XMLAttribute.prototype, 'textContent', {
	      get: function() {
	        return this.value;
	      },
	      set: function(value) {
	        return this.value = value || '';
	      }
	    });
	    Object.defineProperty(XMLAttribute.prototype, 'namespaceURI', {
	      get: function() {
	        return '';
	      }
	    });
	    Object.defineProperty(XMLAttribute.prototype, 'prefix', {
	      get: function() {
	        return '';
	      }
	    });
	    Object.defineProperty(XMLAttribute.prototype, 'localName', {
	      get: function() {
	        return this.name;
	      }
	    });
	    Object.defineProperty(XMLAttribute.prototype, 'specified', {
	      get: function() {
	        return true;
	      }
	    });
	    XMLAttribute.prototype.clone = function() {
	      return Object.create(this);
	    };
	    XMLAttribute.prototype.toString = function(options) {
	      return this.options.writer.attribute(this, this.options.writer.filterOptions(options));
	    };
	    XMLAttribute.prototype.debugInfo = function(name) {
	      name = name || this.name;
	      if (name == null) {
	        return "parent: <" + this.parent.name + ">";
	      } else {
	        return "attribute: {" + name + "}, parent: <" + this.parent.name + ">";
	      }
	    };
	    XMLAttribute.prototype.isEqualNode = function(node) {
	      if (node.namespaceURI !== this.namespaceURI) {
	        return false;
	      }
	      if (node.prefix !== this.prefix) {
	        return false;
	      }
	      if (node.localName !== this.localName) {
	        return false;
	      }
	      if (node.value !== this.value) {
	        return false;
	      }
	      return true;
	    };
	    return XMLAttribute;
	  })();
	}).call(commonjsGlobal);
	return XMLAttribute$1.exports;
}

var XMLNamedNodeMap$1 = {exports: {}};

var hasRequiredXMLNamedNodeMap$1;
function requireXMLNamedNodeMap$1 () {
	if (hasRequiredXMLNamedNodeMap$1) return XMLNamedNodeMap$1.exports;
	hasRequiredXMLNamedNodeMap$1 = 1;
	(function() {
	  XMLNamedNodeMap$1.exports = (function() {
	    function XMLNamedNodeMap(nodes) {
	      this.nodes = nodes;
	    }
	    Object.defineProperty(XMLNamedNodeMap.prototype, 'length', {
	      get: function() {
	        return Object.keys(this.nodes).length || 0;
	      }
	    });
	    XMLNamedNodeMap.prototype.clone = function() {
	      return this.nodes = null;
	    };
	    XMLNamedNodeMap.prototype.getNamedItem = function(name) {
	      return this.nodes[name];
	    };
	    XMLNamedNodeMap.prototype.setNamedItem = function(node) {
	      var oldNode;
	      oldNode = this.nodes[node.nodeName];
	      this.nodes[node.nodeName] = node;
	      return oldNode || null;
	    };
	    XMLNamedNodeMap.prototype.removeNamedItem = function(name) {
	      var oldNode;
	      oldNode = this.nodes[name];
	      delete this.nodes[name];
	      return oldNode || null;
	    };
	    XMLNamedNodeMap.prototype.item = function(index) {
	      return this.nodes[Object.keys(this.nodes)[index]] || null;
	    };
	    XMLNamedNodeMap.prototype.getNamedItemNS = function(namespaceURI, localName) {
	      throw new Error("This DOM method is not implemented.");
	    };
	    XMLNamedNodeMap.prototype.setNamedItemNS = function(node) {
	      throw new Error("This DOM method is not implemented.");
	    };
	    XMLNamedNodeMap.prototype.removeNamedItemNS = function(namespaceURI, localName) {
	      throw new Error("This DOM method is not implemented.");
	    };
	    return XMLNamedNodeMap;
	  })();
	}).call(commonjsGlobal);
	return XMLNamedNodeMap$1.exports;
}

var hasRequiredXMLElement$1;
function requireXMLElement$1 () {
	if (hasRequiredXMLElement$1) return XMLElement$1.exports;
	hasRequiredXMLElement$1 = 1;
	(function() {
	  var NodeType, XMLAttribute, XMLNamedNodeMap, XMLNode, getValue, isFunction, isObject, ref,
	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  ref = requireUtility$1(), isObject = ref.isObject, isFunction = ref.isFunction, getValue = ref.getValue;
	  XMLNode = requireXMLNode$1();
	  NodeType = requireNodeType$1();
	  XMLAttribute = requireXMLAttribute$1();
	  XMLNamedNodeMap = requireXMLNamedNodeMap$1();
	  XMLElement$1.exports = (function(superClass) {
	    extend(XMLElement, superClass);
	    function XMLElement(parent, name, attributes) {
	      var child, j, len, ref1;
	      XMLElement.__super__.constructor.call(this, parent);
	      if (name == null) {
	        throw new Error("Missing element name. " + this.debugInfo());
	      }
	      this.name = this.stringify.name(name);
	      this.type = NodeType.Element;
	      this.attribs = {};
	      this.schemaTypeInfo = null;
	      if (attributes != null) {
	        this.attribute(attributes);
	      }
	      if (parent.type === NodeType.Document) {
	        this.isRoot = true;
	        this.documentObject = parent;
	        parent.rootObject = this;
	        if (parent.children) {
	          ref1 = parent.children;
	          for (j = 0, len = ref1.length; j < len; j++) {
	            child = ref1[j];
	            if (child.type === NodeType.DocType) {
	              child.name = this.name;
	              break;
	            }
	          }
	        }
	      }
	    }
	    Object.defineProperty(XMLElement.prototype, 'tagName', {
	      get: function() {
	        return this.name;
	      }
	    });
	    Object.defineProperty(XMLElement.prototype, 'namespaceURI', {
	      get: function() {
	        return '';
	      }
	    });
	    Object.defineProperty(XMLElement.prototype, 'prefix', {
	      get: function() {
	        return '';
	      }
	    });
	    Object.defineProperty(XMLElement.prototype, 'localName', {
	      get: function() {
	        return this.name;
	      }
	    });
	    Object.defineProperty(XMLElement.prototype, 'id', {
	      get: function() {
	        throw new Error("This DOM method is not implemented." + this.debugInfo());
	      }
	    });
	    Object.defineProperty(XMLElement.prototype, 'className', {
	      get: function() {
	        throw new Error("This DOM method is not implemented." + this.debugInfo());
	      }
	    });
	    Object.defineProperty(XMLElement.prototype, 'classList', {
	      get: function() {
	        throw new Error("This DOM method is not implemented." + this.debugInfo());
	      }
	    });
	    Object.defineProperty(XMLElement.prototype, 'attributes', {
	      get: function() {
	        if (!this.attributeMap || !this.attributeMap.nodes) {
	          this.attributeMap = new XMLNamedNodeMap(this.attribs);
	        }
	        return this.attributeMap;
	      }
	    });
	    XMLElement.prototype.clone = function() {
	      var att, attName, clonedSelf, ref1;
	      clonedSelf = Object.create(this);
	      if (clonedSelf.isRoot) {
	        clonedSelf.documentObject = null;
	      }
	      clonedSelf.attribs = {};
	      ref1 = this.attribs;
	      for (attName in ref1) {
	        if (!hasProp.call(ref1, attName)) continue;
	        att = ref1[attName];
	        clonedSelf.attribs[attName] = att.clone();
	      }
	      clonedSelf.children = [];
	      this.children.forEach(function(child) {
	        var clonedChild;
	        clonedChild = child.clone();
	        clonedChild.parent = clonedSelf;
	        return clonedSelf.children.push(clonedChild);
	      });
	      return clonedSelf;
	    };
	    XMLElement.prototype.attribute = function(name, value) {
	      var attName, attValue;
	      if (name != null) {
	        name = getValue(name);
	      }
	      if (isObject(name)) {
	        for (attName in name) {
	          if (!hasProp.call(name, attName)) continue;
	          attValue = name[attName];
	          this.attribute(attName, attValue);
	        }
	      } else {
	        if (isFunction(value)) {
	          value = value.apply();
	        }
	        if (this.options.keepNullAttributes && (value == null)) {
	          this.attribs[name] = new XMLAttribute(this, name, "");
	        } else if (value != null) {
	          this.attribs[name] = new XMLAttribute(this, name, value);
	        }
	      }
	      return this;
	    };
	    XMLElement.prototype.removeAttribute = function(name) {
	      var attName, j, len;
	      if (name == null) {
	        throw new Error("Missing attribute name. " + this.debugInfo());
	      }
	      name = getValue(name);
	      if (Array.isArray(name)) {
	        for (j = 0, len = name.length; j < len; j++) {
	          attName = name[j];
	          delete this.attribs[attName];
	        }
	      } else {
	        delete this.attribs[name];
	      }
	      return this;
	    };
	    XMLElement.prototype.toString = function(options) {
	      return this.options.writer.element(this, this.options.writer.filterOptions(options));
	    };
	    XMLElement.prototype.att = function(name, value) {
	      return this.attribute(name, value);
	    };
	    XMLElement.prototype.a = function(name, value) {
	      return this.attribute(name, value);
	    };
	    XMLElement.prototype.getAttribute = function(name) {
	      if (this.attribs.hasOwnProperty(name)) {
	        return this.attribs[name].value;
	      } else {
	        return null;
	      }
	    };
	    XMLElement.prototype.setAttribute = function(name, value) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.getAttributeNode = function(name) {
	      if (this.attribs.hasOwnProperty(name)) {
	        return this.attribs[name];
	      } else {
	        return null;
	      }
	    };
	    XMLElement.prototype.setAttributeNode = function(newAttr) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.removeAttributeNode = function(oldAttr) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.getElementsByTagName = function(name) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.getAttributeNS = function(namespaceURI, localName) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.removeAttributeNS = function(namespaceURI, localName) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.getAttributeNodeNS = function(namespaceURI, localName) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.setAttributeNodeNS = function(newAttr) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.hasAttribute = function(name) {
	      return this.attribs.hasOwnProperty(name);
	    };
	    XMLElement.prototype.hasAttributeNS = function(namespaceURI, localName) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.setIdAttribute = function(name, isId) {
	      if (this.attribs.hasOwnProperty(name)) {
	        return this.attribs[name].isId;
	      } else {
	        return isId;
	      }
	    };
	    XMLElement.prototype.setIdAttributeNS = function(namespaceURI, localName, isId) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.setIdAttributeNode = function(idAttr, isId) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.getElementsByTagName = function(tagname) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.getElementsByClassName = function(classNames) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLElement.prototype.isEqualNode = function(node) {
	      var i, j, ref1;
	      if (!XMLElement.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
	        return false;
	      }
	      if (node.namespaceURI !== this.namespaceURI) {
	        return false;
	      }
	      if (node.prefix !== this.prefix) {
	        return false;
	      }
	      if (node.localName !== this.localName) {
	        return false;
	      }
	      if (node.attribs.length !== this.attribs.length) {
	        return false;
	      }
	      for (i = j = 0, ref1 = this.attribs.length - 1; 0 <= ref1 ? j <= ref1 : j >= ref1; i = 0 <= ref1 ? ++j : --j) {
	        if (!this.attribs[i].isEqualNode(node.attribs[i])) {
	          return false;
	        }
	      }
	      return true;
	    };
	    return XMLElement;
	  })(XMLNode);
	}).call(commonjsGlobal);
	return XMLElement$1.exports;
}

var XMLCData$1 = {exports: {}};

var XMLCharacterData$1 = {exports: {}};

var hasRequiredXMLCharacterData$1;
function requireXMLCharacterData$1 () {
	if (hasRequiredXMLCharacterData$1) return XMLCharacterData$1.exports;
	hasRequiredXMLCharacterData$1 = 1;
	(function() {
	  var XMLNode,
	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  XMLNode = requireXMLNode$1();
	  XMLCharacterData$1.exports = (function(superClass) {
	    extend(XMLCharacterData, superClass);
	    function XMLCharacterData(parent) {
	      XMLCharacterData.__super__.constructor.call(this, parent);
	      this.value = '';
	    }
	    Object.defineProperty(XMLCharacterData.prototype, 'data', {
	      get: function() {
	        return this.value;
	      },
	      set: function(value) {
	        return this.value = value || '';
	      }
	    });
	    Object.defineProperty(XMLCharacterData.prototype, 'length', {
	      get: function() {
	        return this.value.length;
	      }
	    });
	    Object.defineProperty(XMLCharacterData.prototype, 'textContent', {
	      get: function() {
	        return this.value;
	      },
	      set: function(value) {
	        return this.value = value || '';
	      }
	    });
	    XMLCharacterData.prototype.clone = function() {
	      return Object.create(this);
	    };
	    XMLCharacterData.prototype.substringData = function(offset, count) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLCharacterData.prototype.appendData = function(arg) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLCharacterData.prototype.insertData = function(offset, arg) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLCharacterData.prototype.deleteData = function(offset, count) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLCharacterData.prototype.replaceData = function(offset, count, arg) {
	      throw new Error("This DOM method is not implemented." + this.debugInfo());
	    };
	    XMLCharacterData.prototype.isEqualNode = function(node) {
	      if (!XMLCharacterData.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
	        return false;
	      }
	      if (node.data !== this.data) {
	        return false;
	      }
	      return true;
	    };
	    return XMLCharacterData;
	  })(XMLNode);
	}).call(commonjsGlobal);
	return XMLCharacterData$1.exports;
}

var hasRequiredXMLCData$1;
function requireXMLCData$1 () {
	if (hasRequiredXMLCData$1) return XMLCData$1.exports;
	hasRequiredXMLCData$1 = 1;
	(function() {
	  var NodeType, XMLCharacterData,
	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  NodeType = requireNodeType$1();
	  XMLCharacterData = requireXMLCharacterData$1();
	  XMLCData$1.exports = (function(superClass) {
	    extend(XMLCData, superClass);
	    function XMLCData(parent, text) {
	      XMLCData.__super__.constructor.call(this, parent);
	      if (text == null) {
	        throw new Error("Missing CDATA text. " + this.debugInfo());
	      }
	      this.name = "#cdata-section";
	      this.type = NodeType.CData;
	      this.value = this.stringify.cdata(text);
	    }
	    XMLCData.prototype.clone = function() {
	      return Object.create(this);
	    };
	    XMLCData.prototype.toString = function(options) {
	      return this.options.writer.cdata(this, this.options.writer.filterOptions(options));
	    };
	    return XMLCData;
	  })(XMLCharacterData);
	}).call(commonjsGlobal);
	return XMLCData$1.exports;
}

var XMLComment$1 = {exports: {}};

var hasRequiredXMLComment$1;
function requireXMLComment$1 () {
	if (hasRequiredXMLComment$1) return XMLComment$1.exports;
	hasRequiredXMLComment$1 = 1;
	(function() {
	  var NodeType, XMLCharacterData, extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  NodeType = requireNodeType$1();
	  XMLCharacterData = requireXMLCharacterData$1();
	  XMLComment$1.exports = (function(superClass) {
	    extend(XMLComment, superClass);
	    function XMLComment(parent, text) {
	      XMLComment.__super__.constructor.call(this, parent);
	      if (text == null) {
	        throw new Error("Missing comment text. " + this.debugInfo());
	      }
	      this.name = "#comment";
	      this.type = NodeType.Comment;
	      this.value = this.stringify.comment(text);
	    }
	    XMLComment.prototype.clone = function() {
	      return Object.create(this);
	    };
	    XMLComment.prototype.toString = function(options) {
	      return this.options.writer.comment(this, this.options.writer.filterOptions(options));
	    };
	    return XMLComment;
	  })(XMLCharacterData);
	}).call(commonjsGlobal);
	return XMLComment$1.exports;
}

var XMLDeclaration$1 = {exports: {}};

var hasRequiredXMLDeclaration$1;
function requireXMLDeclaration$1 () {
	if (hasRequiredXMLDeclaration$1) return XMLDeclaration$1.exports;
	hasRequiredXMLDeclaration$1 = 1;
	(function() {
	  var NodeType, XMLNode, isObject,
	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  isObject = requireUtility$1().isObject;
	  XMLNode = requireXMLNode$1();
	  NodeType = requireNodeType$1();
	  XMLDeclaration$1.exports = (function(superClass) {
	    extend(XMLDeclaration, superClass);
	    function XMLDeclaration(parent, version, encoding, standalone) {
	      var ref;
	      XMLDeclaration.__super__.constructor.call(this, parent);
	      if (isObject(version)) {
	        ref = version, version = ref.version, encoding = ref.encoding, standalone = ref.standalone;
	      }
	      if (!version) {
	        version = '1.0';
	      }
	      this.type = NodeType.Declaration;
	      this.version = this.stringify.xmlVersion(version);
	      if (encoding != null) {
	        this.encoding = this.stringify.xmlEncoding(encoding);
	      }
	      if (standalone != null) {
	        this.standalone = this.stringify.xmlStandalone(standalone);
	      }
	    }
	    XMLDeclaration.prototype.toString = function(options) {
	      return this.options.writer.declaration(this, this.options.writer.filterOptions(options));
	    };
	    return XMLDeclaration;
	  })(XMLNode);
	}).call(commonjsGlobal);
	return XMLDeclaration$1.exports;
}

var XMLDocType$1 = {exports: {}};

var XMLDTDAttList$1 = {exports: {}};

var hasRequiredXMLDTDAttList$1;
function requireXMLDTDAttList$1 () {
	if (hasRequiredXMLDTDAttList$1) return XMLDTDAttList$1.exports;
	hasRequiredXMLDTDAttList$1 = 1;
	(function() {
	  var NodeType, XMLNode,
	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  XMLNode = requireXMLNode$1();
	  NodeType = requireNodeType$1();
	  XMLDTDAttList$1.exports = (function(superClass) {
	    extend(XMLDTDAttList, superClass);
	    function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
	      XMLDTDAttList.__super__.constructor.call(this, parent);
	      if (elementName == null) {
	        throw new Error("Missing DTD element name. " + this.debugInfo());
	      }
	      if (attributeName == null) {
	        throw new Error("Missing DTD attribute name. " + this.debugInfo(elementName));
	      }
	      if (!attributeType) {
	        throw new Error("Missing DTD attribute type. " + this.debugInfo(elementName));
	      }
	      if (!defaultValueType) {
	        throw new Error("Missing DTD attribute default. " + this.debugInfo(elementName));
	      }
	      if (defaultValueType.indexOf('#') !== 0) {
	        defaultValueType = '#' + defaultValueType;
	      }
	      if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) {
	        throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT. " + this.debugInfo(elementName));
	      }
	      if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
	        throw new Error("Default value only applies to #FIXED or #DEFAULT. " + this.debugInfo(elementName));
	      }
	      this.elementName = this.stringify.name(elementName);
	      this.type = NodeType.AttributeDeclaration;
	      this.attributeName = this.stringify.name(attributeName);
	      this.attributeType = this.stringify.dtdAttType(attributeType);
	      if (defaultValue) {
	        this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
	      }
	      this.defaultValueType = defaultValueType;
	    }
	    XMLDTDAttList.prototype.toString = function(options) {
	      return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options));
	    };
	    return XMLDTDAttList;
	  })(XMLNode);
	}).call(commonjsGlobal);
	return XMLDTDAttList$1.exports;
}

var XMLDTDEntity$1 = {exports: {}};

var hasRequiredXMLDTDEntity$1;
function requireXMLDTDEntity$1 () {
	if (hasRequiredXMLDTDEntity$1) return XMLDTDEntity$1.exports;
	hasRequiredXMLDTDEntity$1 = 1;
	(function() {
	  var NodeType, XMLNode, isObject,
	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  isObject = requireUtility$1().isObject;
	  XMLNode = requireXMLNode$1();
	  NodeType = requireNodeType$1();
	  XMLDTDEntity$1.exports = (function(superClass) {
	    extend(XMLDTDEntity, superClass);
	    function XMLDTDEntity(parent, pe, name, value) {
	      XMLDTDEntity.__super__.constructor.call(this, parent);
	      if (name == null) {
	        throw new Error("Missing DTD entity name. " + this.debugInfo(name));
	      }
	      if (value == null) {
	        throw new Error("Missing DTD entity value. " + this.debugInfo(name));
	      }
	      this.pe = !!pe;
	      this.name = this.stringify.name(name);
	      this.type = NodeType.EntityDeclaration;
	      if (!isObject(value)) {
	        this.value = this.stringify.dtdEntityValue(value);
	        this.internal = true;
	      } else {
	        if (!value.pubID && !value.sysID) {
	          throw new Error("Public and/or system identifiers are required for an external entity. " + this.debugInfo(name));
	        }
	        if (value.pubID && !value.sysID) {
	          throw new Error("System identifier is required for a public external entity. " + this.debugInfo(name));
	        }
	        this.internal = false;
	        if (value.pubID != null) {
	          this.pubID = this.stringify.dtdPubID(value.pubID);
	        }
	        if (value.sysID != null) {
	          this.sysID = this.stringify.dtdSysID(value.sysID);
	        }
	        if (value.nData != null) {
	          this.nData = this.stringify.dtdNData(value.nData);
	        }
	        if (this.pe && this.nData) {
	          throw new Error("Notation declaration is not allowed in a parameter entity. " + this.debugInfo(name));
	        }
	      }
	    }
	    Object.defineProperty(XMLDTDEntity.prototype, 'publicId', {
	      get: function() {
	        return this.pubID;
	      }
	    });
	    Object.defineProperty(XMLDTDEntity.prototype, 'systemId', {
	      get: function() {
	        return this.sysID;
	      }
	    });
	    Object.defineProperty(XMLDTDEntity.prototype, 'notationName', {
	      get: function() {
	        return this.nData || null;
	      }
	    });
	    Object.defineProperty(XMLDTDEntity.prototype, 'inputEncoding', {
	      get: function() {
	        return null;
	      }
	    });
	    Object.defineProperty(XMLDTDEntity.prototype, 'xmlEncoding', {
	      get: function() {
	        return null;
	      }
	    });
	    Object.defineProperty(XMLDTDEntity.prototype, 'xmlVersion', {
	      get: function() {
	        return null;
	      }
	    });
	    XMLDTDEntity.prototype.toString = function(options) {
	      return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options));
	    };
	    return XMLDTDEntity;
	  })(XMLNode);
	}).call(commonjsGlobal);
	return XMLDTDEntity$1.exports;
}

var XMLDTDElement$1 = {exports: {}};

var hasRequiredXMLDTDElement$1;
function requireXMLDTDElement$1 () {
	if (hasRequiredXMLDTDElement$1) return XMLDTDElement$1.exports;
	hasRequiredXMLDTDElement$1 = 1;
	(function() {
	  var NodeType, XMLNode,
	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  XMLNode = requireXMLNode$1();
	  NodeType = requireNodeType$1();
	  XMLDTDElement$1.exports = (function(superClass) {
	    extend(XMLDTDElement, superClass);
	    function XMLDTDElement(parent, name, value) {
	      XMLDTDElement.__super__.constructor.call(this, parent);
	      if (name == null) {
	        throw new Error("Missing DTD element name. " + this.debugInfo());
	      }
	      if (!value) {
	        value = '(#PCDATA)';
	      }
	      if (Array.isArray(value)) {
	        value = '(' + value.join(',') + ')';
	      }
	      this.name = this.stringify.name(name);
	      this.type = NodeType.ElementDeclaration;
	      this.value = this.stringify.dtdElementValue(value);
	    }
	    XMLDTDElement.prototype.toString = function(options) {
	      return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options));
	    };
	    return XMLDTDElement;
	  })(XMLNode);
	}).call(commonjsGlobal);
	return XMLDTDElement$1.exports;
}

var XMLDTDNotation$1 = {exports: {}};

var hasRequiredXMLDTDNotation$1;
function requireXMLDTDNotation$1 () {
	if (hasRequiredXMLDTDNotation$1) return XMLDTDNotation$1.exports;
	hasRequiredXMLDTDNotation$1 = 1;
	(function() {
	  var NodeType, XMLNode,
	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  XMLNode = requireXMLNode$1();
	  NodeType = requireNodeType$1();
	  XMLDTDNotation$1.exports = (function(superClass) {
	    extend(XMLDTDNotation, superClass);
	    function XMLDTDNotation(parent, name, value) {
	      XMLDTDNotation.__super__.constructor.call(this, parent);
	      if (name == null) {
	        throw new Error("Missing DTD notation name. " + this.debugInfo(name));
	      }
	      if (!value.pubID && !value.sysID) {
	        throw new Error("Public or system identifiers are required for an external entity. " + this.debugInfo(name));
	      }
	      this.name = this.stringify.name(name);
	      this.type = NodeType.NotationDeclaration;
	      if (value.pubID != null) {
	        this.pubID = this.stringify.dtdPubID(value.pubID);
	      }
	      if (value.sysID != null) {
	        this.sysID = this.stringify.dtdSysID(value.sysID);
	      }
	    }
	    Object.defineProperty(XMLDTDNotation.prototype, 'publicId', {
	      get: function() {
	        return this.pubID;
	      }
	    });
	    Object.defineProperty(XMLDTDNotation.prototype, 'systemId', {
	      get: function() {
	        return this.sysID;
	      }
	    });
	    XMLDTDNotation.prototype.toString = function(options) {
	      return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));
	    };
	    return XMLDTDNotation;
	  })(XMLNode);
	}).call(commonjsGlobal);
	return XMLDTDNotation$1.exports;
}

var hasRequiredXMLDocType$1;
function requireXMLDocType$1 () {
	if (hasRequiredXMLDocType$1) return XMLDocType$1.exports;
	hasRequiredXMLDocType$1 = 1;
	(function() {
	  var NodeType, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLNamedNodeMap, XMLNode, isObject,
	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	    hasProp = {}.hasOwnProperty;
	  isObject = requireUtility$1().isObject;
	  XMLNode = requireXMLNode$1();
	  NodeType = requireNodeType$1();
	  XMLDTDAttList = requireXMLDTDAttList$1();
	  XMLDTDEntity = requireXMLDTDEntity$1();
	  XMLDTDElement = requireXMLDTDElement$1();
	  XMLDTDNotation = requireXMLDTDNotation$1();
	  XMLNamedNodeMap = requireXMLNamedNodeMap$1();
	  XMLDocType$1.exports = (function(superClass) {
	    extend(XMLDocType, superClass);
	    function XMLDocType(parent, pubID, sysID) {
	      var child, i, len, ref, ref1, ref2;
	      XMLDocType.__super__.constructor.call(this, parent);
	      this.type = NodeType.DocType;
	      if (parent.children) {
	        ref = parent.children;
	        for (i = 0, len = ref.length; i < len; i++) {
	          child = ref[i];
	          if (child.type === NodeType.Element) {
	            this.name = child.name;
	            break;
	          }
	        }
	      }
	      this.documentObject = parent;
	      if (isObject(pubID)) {
	        ref1 = pubID, pubID = ref1.pubID, sysID = ref1.sysID;
	      }
	      if (sysID == null) {
	        ref2 = [pubID, sysID], sysID = ref2[0], pubID = ref2[1];
	      }
	      if (pubID != null) {
	        this.pubID = this.stringify.dtdPubID(pubID);
	      }
	      if (sysID != null) {
	        this.sysID = this.stringify.dtdSysID(sysID);
	      }
	    }
	    Object.defineProperty(XMLDocType.prototype, 'entities', {
	      get: function() {
	        var child, i, len, nodes, ref;
	        nodes = {};
	        ref = this.children;
	        for (i = 0, len = ref.length; i < len; i++) {
	          child = ref[i];
	          if ((child.type === NodeType.EntityDeclaration) && !child.pe) {
	            nodes[child.name] = child;
	          }
	        }
	        return new XMLNamedNodeMap(nodes);
	      }
	    });
	    Object.defineProperty(XMLDocType.prototype, 'notations', {
	      get: function() {
	        var child, i, len, nodes, ref;
	        nodes = {};
	        ref = this.children;
	        for (i = 0, len = ref.length; i < len; i++) {
	          child = ref[i];
	          if (child.type === NodeType.NotationDeclaration) {
	            nodes[child.name] = child;
	          }
	        }
	        return new XMLNamedNodeMap(nodes);
	      }
	    });
	    Object.defineProperty(XMLDocType.prototype, 'publicId', {
	      get: function() {
	        return this.pubID;
	      }
	    });
	    Object.defineProperty(XMLDocType.prototype, 'systemId', {
	      get: function() {
	        return this.sysID;
	      }
	    });
	    Object.defineProperty(XMLDocType.prototype, 'internalSubset', {
	      get: function() {
	        throw new Error("This DOM method is not implemented." + this.debugInfo());
	      }
	    });
	    XMLDocType.prototype.element = function(name, value) {
	      var child;
	      child = new XMLDTDElement(this, name, value);
	      this.children.push(child);
	      return this;
	    };
	    XMLDocType.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
	      var child;
	      child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
	      this.children.push(child);
	      return this;
	    };
	    XMLDocType.prototype.entity = function(name, value) {
	      var child;
	      child = new XMLDTDEntity(this, false, name, value);
	      this.children.push(child);
	      return this;
	    };
	    XMLDocType.prototype.pEntity = function(name, value) {
	      var child;
	      child = new XMLDTDEntity(this, true, name, value);
	      this.children.push(child);
	      return this;
	    };
	    XMLDocType.prototype.notation = function(name, value) {
	      var child;
	      child = new XMLDTDNotation(this, name, value);
	      this.children.push(child);
	      return this;
	    };
	    XMLDocType.prototype.toString = function(options) {
	      return this.options.writer.docType(this, this.options.writer.filterOptions(options));
	    };
	    XMLDocType.prototype.ele = function(name, value) {
	      return this.element(name, value);
	    };
	    XMLDocType.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
	      return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
	    };
	    XMLDocType.prototype.ent = function(name, value) {
	      return this.entity(name, value);
	    };
	    XMLDocType.prototype.pent = function(name, value) {
	      return this.pEntity(name, value);
	    };
	    XMLDocType.prototype.not = function(name, value) {
	      return this.notation(name, value);
	    };
	    XMLDocType.prototype.up = function() {
	      return this.root() || this.documentObject;
	    };
	    XMLDocType.prototype.isEqualNode = function(node) {
	      if (!XMLDocType.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
	        return false;
	      }
	      if (node.name !== this.name) {
	        return false;
	      }
	      if (node.publicId !== this.publicId) {
	        return false;
	      }
	      if (node.systemId !== this.systemId) {
	        return false;
	      }