elm-pages 3.0.0-beta.20 → 3.0.0-beta.21

package/generator/dead-code-review/node_modules/xmlbuilder/lib/XMLDOMImplementation.js

@@ -0,0 +1,55 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  // Implements the DOMImplementation interface
+  var XMLDOMImplementation;
+
+  module.exports = XMLDOMImplementation = class XMLDOMImplementation {
+    // Tests if the DOM implementation implements a specific feature.
+
+    // `feature` package name of the feature to test. In Level 1, the
+    //           legal values are "HTML" and "XML" (case-insensitive).
+    // `version` version number of the package name to test. 
+    //           In Level 1, this is the string "1.0". If the version is 
+    //           not specified, supporting any version of the feature will 
+    //           cause the method to return true.
+    hasFeature(feature, version) {
+      return true;
+    }
+
+    // Creates a new document type declaration.
+
+    // `qualifiedName` qualified name of the document type to be created
+    // `publicId` public identifier of the external subset
+    // `systemId` system identifier of the external subset
+    createDocumentType(qualifiedName, publicId, systemId) {
+      throw new Error("This DOM method is not implemented.");
+    }
+
+    // Creates a new document.
+
+    // `namespaceURI` namespace URI of the document element to create
+    // `qualifiedName` the qualified name of the document to be created
+    // `doctype` the type of document to be created or null
+    createDocument(namespaceURI, qualifiedName, doctype) {
+      throw new Error("This DOM method is not implemented.");
+    }
+
+    // Creates a new HTML document.
+
+    // `title` document title
+    createHTMLDocument(title) {
+      throw new Error("This DOM method is not implemented.");
+    }
+
+    // Returns a specialized object which implements the specialized APIs 
+    // of the specified feature and version.
+
+    // `feature` name of the feature requested.
+    // `version` version number of the feature to test
+    getFeature(feature, version) {
+      throw new Error("This DOM method is not implemented.");
+    }
+
+  };
+
+}).call(this);

package/generator/dead-code-review/node_modules/xmlbuilder/lib/XMLDOMStringList.js

@@ -0,0 +1,44 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  // Represents a list of string entries
+  var XMLDOMStringList;
+
+  module.exports = XMLDOMStringList = (function() {
+    class XMLDOMStringList {
+      // Initializes a new instance of `XMLDOMStringList`
+      // This is just a wrapper around an ordinary
+      // JS array.
+
+      // `arr` the array of string values
+      constructor(arr) {
+        this.arr = arr || [];
+      }
+
+      // Returns the indexth item in the collection.
+
+      // `index` index into the collection
+      item(index) {
+        return this.arr[index] || null;
+      }
+
+      // Test if a string is part of this DOMStringList.
+
+      // `str` the string to look for
+      contains(str) {
+        return this.arr.indexOf(str) !== -1;
+      }
+
+    };
+
+    // Returns the number of strings in the list.
+    Object.defineProperty(XMLDOMStringList.prototype, 'length', {
+      get: function() {
+        return this.arr.length;
+      }
+    });
+
+    return XMLDOMStringList;
+
+  }).call(this);
+
+}).call(this);

package/generator/dead-code-review/node_modules/xmlbuilder/lib/XMLDTDAttList.js

@@ -0,0 +1,66 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var NodeType, XMLDTDAttList, XMLNode;
+
+  XMLNode = require('./XMLNode');
+
+  NodeType = require('./NodeType');
+
+  // Represents an attribute list
+  module.exports = XMLDTDAttList = class XMLDTDAttList extends XMLNode {
+    // Initializes a new instance of `XMLDTDAttList`
+
+    // `parent` the parent `XMLDocType` element
+    // `elementName` the name of the element containing this attribute
+    // `attributeName` attribute name
+    // `attributeType` type of the attribute
+    // `defaultValueType` default value type (either #REQUIRED, #IMPLIED,
+    //                    #FIXED or #DEFAULT)
+    // `defaultValue` default value of the attribute
+    //                (only used for #FIXED or #DEFAULT)
+    constructor(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+      super(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;
+    }
+
+    // Converts the XML fragment to string
+
+    // `options.pretty` pretty prints the result
+    // `options.indent` indentation for pretty print
+    // `options.offset` how many indentations to add to every line for pretty print
+    // `options.newline` newline sequence for pretty print
+    toString(options) {
+      return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options));
+    }
+
+  };
+
+}).call(this);

package/generator/dead-code-review/node_modules/xmlbuilder/lib/XMLDTDElement.js

@@ -0,0 +1,44 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var NodeType, XMLDTDElement, XMLNode;
+
+  XMLNode = require('./XMLNode');
+
+  NodeType = require('./NodeType');
+
+  // Represents an attribute
+  module.exports = XMLDTDElement = class XMLDTDElement extends XMLNode {
+    // Initializes a new instance of `XMLDTDElement`
+
+    // `parent` the parent `XMLDocType` element
+    // `name` element name
+    // `value` element content (defaults to #PCDATA)
+    constructor(parent, name, value) {
+      super(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);
+    }
+
+    // Converts the XML fragment to string
+
+    // `options.pretty` pretty prints the result
+    // `options.indent` indentation for pretty print
+    // `options.offset` how many indentations to add to every line for pretty print
+    // `options.newline` newline sequence for pretty print
+    toString(options) {
+      return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options));
+    }
+
+  };
+
+}).call(this);

package/generator/dead-code-review/node_modules/xmlbuilder/lib/XMLDTDEntity.js

@@ -0,0 +1,115 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var NodeType, XMLDTDEntity, XMLNode, isObject;
+
+  ({isObject} = require('./Utility'));
+
+  XMLNode = require('./XMLNode');
+
+  NodeType = require('./NodeType');
+
+  // Represents an entity declaration in the DTD
+  module.exports = XMLDTDEntity = (function() {
+    class XMLDTDEntity extends XMLNode {
+      // Initializes a new instance of `XMLDTDEntity`
+
+      // `parent` the parent `XMLDocType` element
+      // `pe` whether this is a parameter entity or a general entity
+      //      defaults to `false` (general entity)
+      // `name` the name of the entity
+      // `value` internal entity value or an object with external entity details
+      // `value.pubID` public identifier
+      // `value.sysID` system identifier
+      // `value.nData` notation declaration
+      constructor(parent, pe, name, value) {
+        super(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));
+          }
+        }
+      }
+
+      // Converts the XML fragment to string
+
+      // `options.pretty` pretty prints the result
+      // `options.indent` indentation for pretty print
+      // `options.offset` how many indentations to add to every line for pretty print
+      // `options.newline` newline sequence for pretty print
+      toString(options) {
+        return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options));
+      }
+
+    };
+
+    // DOM level 1
+    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;
+      }
+    });
+
+    // DOM level 3
+    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;
+      }
+    });
+
+    return XMLDTDEntity;
+
+  }).call(this);
+
+}).call(this);

package/generator/dead-code-review/node_modules/xmlbuilder/lib/XMLDTDNotation.js

@@ -0,0 +1,66 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var NodeType, XMLDTDNotation, XMLNode;
+
+  XMLNode = require('./XMLNode');
+
+  NodeType = require('./NodeType');
+
+  // Represents a NOTATION entry in the DTD
+  module.exports = XMLDTDNotation = (function() {
+    class XMLDTDNotation extends XMLNode {
+      // Initializes a new instance of `XMLDTDNotation`
+
+      // `parent` the parent `XMLDocType` element
+      // `name` the name of the notation
+      // `value` an object with external entity details
+      // `value.pubID` public identifier
+      // `value.sysID` system identifier
+      constructor(parent, name, value) {
+        super(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);
+        }
+      }
+
+      // Converts the XML fragment to string
+
+      // `options.pretty` pretty prints the result
+      // `options.indent` indentation for pretty print
+      // `options.offset` how many indentations to add to every line for pretty print
+      // `options.newline` newline sequence for pretty print
+      toString(options) {
+        return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));
+      }
+
+    };
+
+    // DOM level 1
+    Object.defineProperty(XMLDTDNotation.prototype, 'publicId', {
+      get: function() {
+        return this.pubID;
+      }
+    });
+
+    Object.defineProperty(XMLDTDNotation.prototype, 'systemId', {
+      get: function() {
+        return this.sysID;
+      }
+    });
+
+    return XMLDTDNotation;
+
+  }).call(this);
+
+}).call(this);

package/generator/dead-code-review/node_modules/xmlbuilder/lib/XMLDeclaration.js

@@ -0,0 +1,51 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var NodeType, XMLDeclaration, XMLNode, isObject;
+
+  ({isObject} = require('./Utility'));
+
+  XMLNode = require('./XMLNode');
+
+  NodeType = require('./NodeType');
+
+  // Represents the XML declaration
+  module.exports = XMLDeclaration = class XMLDeclaration extends XMLNode {
+    // Initializes a new instance of `XMLDeclaration`
+
+    // `parent` the document object
+
+    // `version` A version number string, e.g. 1.0
+    // `encoding` Encoding declaration, e.g. UTF-8
+    // `standalone` standalone document declaration: true or false
+    constructor(parent, version, encoding, standalone) {
+      super(parent);
+      // arguments may also be passed as an object
+      if (isObject(version)) {
+        ({version, encoding, standalone} = version);
+      }
+      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);
+      }
+    }
+
+    // Converts to string
+
+    // `options.pretty` pretty prints the result
+    // `options.indent` indentation for pretty print
+    // `options.offset` how many indentations to add to every line for pretty print
+    // `options.newline` newline sequence for pretty print
+    toString(options) {
+      return this.options.writer.declaration(this, this.options.writer.filterOptions(options));
+    }
+
+  };
+
+}).call(this);

package/generator/dead-code-review/node_modules/xmlbuilder/lib/XMLDocType.js

@@ -0,0 +1,235 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var NodeType, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNamedNodeMap, XMLNode, isObject;
+
+  ({isObject} = require('./Utility'));
+
+  XMLNode = require('./XMLNode');
+
+  NodeType = require('./NodeType');
+
+  XMLDTDAttList = require('./XMLDTDAttList');
+
+  XMLDTDEntity = require('./XMLDTDEntity');
+
+  XMLDTDElement = require('./XMLDTDElement');
+
+  XMLDTDNotation = require('./XMLDTDNotation');
+
+  XMLNamedNodeMap = require('./XMLNamedNodeMap');
+
+  // Represents doctype declaration
+  module.exports = XMLDocType = (function() {
+    class XMLDocType extends XMLNode {
+      // Initializes a new instance of `XMLDocType`
+
+      // `parent` the document object
+
+      // `pubID` public identifier of the external subset
+      // `sysID` system identifier of the external subset
+      constructor(parent, pubID, sysID) {
+        var child, i, len, ref;
+        super(parent);
+        this.type = NodeType.DocType;
+        // set DTD name to the name of the root node
+        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;
+        // arguments may also be passed as an object
+        if (isObject(pubID)) {
+          ({pubID, sysID} = pubID);
+        }
+        if (sysID == null) {
+          [sysID, pubID] = [pubID, sysID];
+        }
+        if (pubID != null) {
+          this.pubID = this.stringify.dtdPubID(pubID);
+        }
+        if (sysID != null) {
+          this.sysID = this.stringify.dtdSysID(sysID);
+        }
+      }
+
+      // Creates an element type declaration
+
+      // `name` element name
+      // `value` element content (defaults to #PCDATA)
+      element(name, value) {
+        var child;
+        child = new XMLDTDElement(this, name, value);
+        this.children.push(child);
+        return this;
+      }
+
+      // Creates an attribute declaration
+
+      // `elementName` the name of the element containing this attribute
+      // `attributeName` attribute name
+      // `attributeType` type of the attribute (defaults to CDATA)
+      // `defaultValueType` default value type (either #REQUIRED, #IMPLIED, #FIXED or
+      //                    #DEFAULT) (defaults to #IMPLIED)
+      // `defaultValue` default value of the attribute
+      //                (only used for #FIXED or #DEFAULT)
+      attList(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+        var child;
+        child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
+        this.children.push(child);
+        return this;
+      }
+
+      // Creates a general entity declaration
+
+      // `name` the name of the entity
+      // `value` internal entity value or an object with external entity details
+      // `value.pubID` public identifier
+      // `value.sysID` system identifier
+      // `value.nData` notation declaration
+      entity(name, value) {
+        var child;
+        child = new XMLDTDEntity(this, false, name, value);
+        this.children.push(child);
+        return this;
+      }
+
+      // Creates a parameter entity declaration
+
+      // `name` the name of the entity
+      // `value` internal entity value or an object with external entity details
+      // `value.pubID` public identifier
+      // `value.sysID` system identifier
+      pEntity(name, value) {
+        var child;
+        child = new XMLDTDEntity(this, true, name, value);
+        this.children.push(child);
+        return this;
+      }
+
+      // Creates a NOTATION declaration
+
+      // `name` the name of the notation
+      // `value` an object with external entity details
+      // `value.pubID` public identifier
+      // `value.sysID` system identifier
+      notation(name, value) {
+        var child;
+        child = new XMLDTDNotation(this, name, value);
+        this.children.push(child);
+        return this;
+      }
+
+      // Converts to string
+
+      // `options.pretty` pretty prints the result
+      // `options.indent` indentation for pretty print
+      // `options.offset` how many indentations to add to every line for pretty print
+      // `options.newline` newline sequence for pretty print
+      toString(options) {
+        return this.options.writer.docType(this, this.options.writer.filterOptions(options));
+      }
+
+      // Aliases
+      ele(name, value) {
+        return this.element(name, value);
+      }
+
+      att(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+        return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
+      }
+
+      ent(name, value) {
+        return this.entity(name, value);
+      }
+
+      pent(name, value) {
+        return this.pEntity(name, value);
+      }
+
+      not(name, value) {
+        return this.notation(name, value);
+      }
+
+      up() {
+        return this.root() || this.documentObject;
+      }
+
+      isEqualNode(node) {
+        if (!super.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;
+        }
+        return true;
+      }
+
+    };
+
+    // DOM level 1
+    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);
+      }
+    });
+
+    // DOM level 2
+    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());
+      }
+    });
+
+    return XMLDocType;
+
+  }).call(this);
+
+}).call(this);