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

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

@@ -0,0 +1,51 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  // Represents a node filter
+  var XMLNodeFilter;
+
+  module.exports = XMLNodeFilter = (function() {
+    class XMLNodeFilter {
+      // DOM level 4 functions to be implemented later
+      acceptNode(node) {
+        throw new Error("This DOM method is not implemented.");
+      }
+
+    };
+
+    XMLNodeFilter.prototype.FilterAccept = 1;
+
+    XMLNodeFilter.prototype.FilterReject = 2;
+
+    XMLNodeFilter.prototype.FilterSkip = 3;
+
+    XMLNodeFilter.prototype.ShowAll = 0xffffffff;
+
+    XMLNodeFilter.prototype.ShowElement = 0x1;
+
+    XMLNodeFilter.prototype.ShowAttribute = 0x2;
+
+    XMLNodeFilter.prototype.ShowText = 0x4;
+
+    XMLNodeFilter.prototype.ShowCDataSection = 0x8;
+
+    XMLNodeFilter.prototype.ShowEntityReference = 0x10;
+
+    XMLNodeFilter.prototype.ShowEntity = 0x20;
+
+    XMLNodeFilter.prototype.ShowProcessingInstruction = 0x40;
+
+    XMLNodeFilter.prototype.ShowComment = 0x80;
+
+    XMLNodeFilter.prototype.ShowDocument = 0x100;
+
+    XMLNodeFilter.prototype.ShowDocumentType = 0x200;
+
+    XMLNodeFilter.prototype.ShowDocumentFragment = 0x400;
+
+    XMLNodeFilter.prototype.ShowNotation = 0x800;
+
+    return XMLNodeFilter;
+
+  }).call(this);
+
+}).call(this);

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

@@ -0,0 +1,45 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  // Represents a list of nodes
+  var XMLNodeList;
+
+  module.exports = XMLNodeList = (function() {
+    class XMLNodeList {
+      // Initializes a new instance of `XMLNodeList`
+      // This is just a wrapper around an ordinary
+      // JS array.
+
+      // `nodes` the array containing nodes.
+      constructor(nodes) {
+        this.nodes = nodes;
+      }
+
+      // Creates and returns a deep clone of `this`
+
+      clone() {
+        // this class should not be cloned since it wraps
+        // around a given array. The calling function should check
+        // whether the wrapped array is null and supply a new array
+        // (from the clone).
+        return this.nodes = null;
+      }
+
+      // DOM Level 1
+      item(index) {
+        return this.nodes[index] || null;
+      }
+
+    };
+
+    // DOM level 1
+    Object.defineProperty(XMLNodeList.prototype, 'length', {
+      get: function() {
+        return this.nodes.length || 0;
+      }
+    });
+
+    return XMLNodeList;
+
+  }).call(this);
+
+}).call(this);

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

@@ -0,0 +1,56 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var NodeType, XMLCharacterData, XMLProcessingInstruction;
+
+  NodeType = require('./NodeType');
+
+  XMLCharacterData = require('./XMLCharacterData');
+
+  // Represents a processing instruction
+  module.exports = XMLProcessingInstruction = class XMLProcessingInstruction extends XMLCharacterData {
+    // Initializes a new instance of `XMLProcessingInstruction`
+
+    // `parent` the parent node
+    // `target` instruction target
+    // `value` instruction value
+    constructor(parent, target, value) {
+      super(parent);
+      if (target == null) {
+        throw new Error("Missing instruction target. " + this.debugInfo());
+      }
+      this.type = NodeType.ProcessingInstruction;
+      this.target = this.stringify.insTarget(target);
+      this.name = this.target;
+      if (value) {
+        this.value = this.stringify.insValue(value);
+      }
+    }
+
+    // Creates and returns a deep clone of `this`
+    clone() {
+      return Object.create(this);
+    }
+
+    // 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.processingInstruction(this, this.options.writer.filterOptions(options));
+    }
+
+    isEqualNode(node) {
+      if (!super.isEqualNode(node)) {
+        return false;
+      }
+      if (node.target !== this.target) {
+        return false;
+      }
+      return true;
+    }
+
+  };
+
+}).call(this);

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

@@ -0,0 +1,40 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var NodeType, XMLNode, XMLRaw;
+
+  NodeType = require('./NodeType');
+
+  XMLNode = require('./XMLNode');
+
+  // Represents a  raw node
+  module.exports = XMLRaw = class XMLRaw extends XMLNode {
+    // Initializes a new instance of `XMLRaw`
+
+    // `text` raw text
+    constructor(parent, text) {
+      super(parent);
+      if (text == null) {
+        throw new Error("Missing raw text. " + this.debugInfo());
+      }
+      this.type = NodeType.Raw;
+      this.value = this.stringify.raw(text);
+    }
+
+    // Creates and returns a deep clone of `this`
+    clone() {
+      return Object.create(this);
+    }
+
+    // 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.raw(this, this.options.writer.filterOptions(options));
+    }
+
+  };
+
+}).call(this);

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

@@ -0,0 +1,209 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var NodeType, WriterState, XMLStreamWriter, XMLWriterBase,
+    hasProp = {}.hasOwnProperty;
+
+  NodeType = require('./NodeType');
+
+  XMLWriterBase = require('./XMLWriterBase');
+
+  WriterState = require('./WriterState');
+
+  // Prints XML nodes to a stream
+  module.exports = XMLStreamWriter = class XMLStreamWriter extends XMLWriterBase {
+    // Initializes a new instance of `XMLStreamWriter`
+
+    // `stream` output stream
+    // `options.pretty` pretty prints the result
+    // `options.indent` indentation string
+    // `options.newline` newline sequence
+    // `options.offset` a fixed number of indentations to add to every line
+    // `options.allowEmpty` do not self close empty element tags
+    // 'options.dontPrettyTextNodes' if any text is present in node, don't indent or LF
+    // `options.spaceBeforeSlash` add a space before the closing slash of empty elements
+    constructor(stream, options) {
+      super(options);
+      this.stream = stream;
+    }
+
+    endline(node, options, level) {
+      if (node.isLastRootNode && options.state === WriterState.CloseTag) {
+        return '';
+      } else {
+        return super.endline(node, options, level);
+      }
+    }
+
+    document(doc, options) {
+      var child, i, j, k, len1, len2, ref, ref1, results;
+      ref = doc.children;
+      // set a flag so that we don't insert a newline after the last root level node 
+      for (i = j = 0, len1 = ref.length; j < len1; i = ++j) {
+        child = ref[i];
+        child.isLastRootNode = i === doc.children.length - 1;
+      }
+      options = this.filterOptions(options);
+      ref1 = doc.children;
+      results = [];
+      for (k = 0, len2 = ref1.length; k < len2; k++) {
+        child = ref1[k];
+        results.push(this.writeChildNode(child, options, 0));
+      }
+      return results;
+    }
+
+    cdata(node, options, level) {
+      return this.stream.write(super.cdata(node, options, level));
+    }
+
+    comment(node, options, level) {
+      return this.stream.write(super.comment(node, options, level));
+    }
+
+    declaration(node, options, level) {
+      return this.stream.write(super.declaration(node, options, level));
+    }
+
+    docType(node, options, level) {
+      var child, j, len1, ref;
+      level || (level = 0);
+      this.openNode(node, options, level);
+      options.state = WriterState.OpenTag;
+      this.stream.write(this.indent(node, options, level));
+      this.stream.write('<!DOCTYPE ' + node.root().name);
+      // external identifier
+      if (node.pubID && node.sysID) {
+        this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
+      } else if (node.sysID) {
+        this.stream.write(' SYSTEM "' + node.sysID + '"');
+      }
+      // internal subset
+      if (node.children.length > 0) {
+        this.stream.write(' [');
+        this.stream.write(this.endline(node, options, level));
+        options.state = WriterState.InsideTag;
+        ref = node.children;
+        for (j = 0, len1 = ref.length; j < len1; j++) {
+          child = ref[j];
+          this.writeChildNode(child, options, level + 1);
+        }
+        options.state = WriterState.CloseTag;
+        this.stream.write(']');
+      }
+      // close tag
+      options.state = WriterState.CloseTag;
+      this.stream.write(options.spaceBeforeSlash + '>');
+      this.stream.write(this.endline(node, options, level));
+      options.state = WriterState.None;
+      return this.closeNode(node, options, level);
+    }
+
+    element(node, options, level) {
+      var att, attLen, child, childNodeCount, firstChildNode, j, len, len1, name, prettySuppressed, r, ratt, ref, ref1, ref2, rline;
+      level || (level = 0);
+      // open tag
+      this.openNode(node, options, level);
+      options.state = WriterState.OpenTag;
+      r = this.indent(node, options, level) + '<' + node.name;
+      // attributes
+      if (options.pretty && options.width > 0) {
+        len = r.length;
+        ref = node.attribs;
+        for (name in ref) {
+          if (!hasProp.call(ref, name)) continue;
+          att = ref[name];
+          ratt = this.attribute(att, options, level);
+          attLen = ratt.length;
+          if (len + attLen > options.width) {
+            rline = this.indent(node, options, level + 1) + ratt;
+            r += this.endline(node, options, level) + rline;
+            len = rline.length;
+          } else {
+            rline = ' ' + ratt;
+            r += rline;
+            len += rline.length;
+          }
+        }
+      } else {
+        ref1 = node.attribs;
+        for (name in ref1) {
+          if (!hasProp.call(ref1, name)) continue;
+          att = ref1[name];
+          r += this.attribute(att, options, level);
+        }
+      }
+      this.stream.write(r);
+      childNodeCount = node.children.length;
+      firstChildNode = childNodeCount === 0 ? null : node.children[0];
+      if (childNodeCount === 0 || node.children.every(function(e) {
+        return (e.type === NodeType.Text || e.type === NodeType.Raw || e.type === NodeType.CData) && e.value === '';
+      })) {
+        // empty element
+        if (options.allowEmpty) {
+          this.stream.write('>');
+          options.state = WriterState.CloseTag;
+          this.stream.write('</' + node.name + '>');
+        } else {
+          options.state = WriterState.CloseTag;
+          this.stream.write(options.spaceBeforeSlash + '/>');
+        }
+      } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw || firstChildNode.type === NodeType.CData) && (firstChildNode.value != null)) {
+        // do not indent text-only nodes
+        this.stream.write('>');
+        options.state = WriterState.InsideTag;
+        options.suppressPrettyCount++;
+        prettySuppressed = true;
+        this.writeChildNode(firstChildNode, options, level + 1);
+        options.suppressPrettyCount--;
+        prettySuppressed = false;
+        options.state = WriterState.CloseTag;
+        this.stream.write('</' + node.name + '>');
+      } else {
+        this.stream.write('>' + this.endline(node, options, level));
+        options.state = WriterState.InsideTag;
+        ref2 = node.children;
+        // inner tags
+        for (j = 0, len1 = ref2.length; j < len1; j++) {
+          child = ref2[j];
+          this.writeChildNode(child, options, level + 1);
+        }
+        // close tag
+        options.state = WriterState.CloseTag;
+        this.stream.write(this.indent(node, options, level) + '</' + node.name + '>');
+      }
+      this.stream.write(this.endline(node, options, level));
+      options.state = WriterState.None;
+      return this.closeNode(node, options, level);
+    }
+
+    processingInstruction(node, options, level) {
+      return this.stream.write(super.processingInstruction(node, options, level));
+    }
+
+    raw(node, options, level) {
+      return this.stream.write(super.raw(node, options, level));
+    }
+
+    text(node, options, level) {
+      return this.stream.write(super.text(node, options, level));
+    }
+
+    dtdAttList(node, options, level) {
+      return this.stream.write(super.dtdAttList(node, options, level));
+    }
+
+    dtdElement(node, options, level) {
+      return this.stream.write(super.dtdElement(node, options, level));
+    }
+
+    dtdEntity(node, options, level) {
+      return this.stream.write(super.dtdEntity(node, options, level));
+    }
+
+    dtdNotation(node, options, level) {
+      return this.stream.write(super.dtdNotation(node, options, level));
+    }
+
+  };
+
+}).call(this);

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

@@ -0,0 +1,40 @@
+// Generated by CoffeeScript 2.4.1
+(function() {
+  var XMLStringWriter, XMLWriterBase;
+
+  XMLWriterBase = require('./XMLWriterBase');
+
+  // Prints XML nodes as plain text
+  module.exports = XMLStringWriter = class XMLStringWriter extends XMLWriterBase {
+    // Initializes a new instance of `XMLStringWriter`
+
+    // `options.pretty` pretty prints the result
+    // `options.indent` indentation string
+    // `options.newline` newline sequence
+    // `options.offset` a fixed number of indentations to add to every line
+    // `options.allowEmpty` do not self close empty element tags
+    // 'options.dontPrettyTextNodes' if any text is present in node, don't indent or LF
+    // `options.spaceBeforeSlash` add a space before the closing slash of empty elements
+    constructor(options) {
+      super(options);
+    }
+
+    document(doc, options) {
+      var child, i, len, r, ref;
+      options = this.filterOptions(options);
+      r = '';
+      ref = doc.children;
+      for (i = 0, len = ref.length; i < len; i++) {
+        child = ref[i];
+        r += this.writeChildNode(child, options, 0);
+      }
+      // remove trailing newline
+      if (options.pretty && r.slice(-options.newline.length) === options.newline) {
+        r = r.slice(0, -options.newline.length);
+      }
+      return r;
+    }
+
+  };
+
+}).call(this);