game_dig 0.1.0 → 0.2.0

data/lib/game_dig/node/node_modules/safer-buffer/tests.js

@@ -0,0 +1,406 @@
+/* eslint-disable node/no-deprecated-api */
+
+'use strict'
+
+var test = require('tape')
+
+var buffer = require('buffer')
+
+var index = require('./')
+var safer = require('./safer')
+var dangerous = require('./dangerous')
+
+/* Inheritance tests */
+
+test('Default is Safer', function (t) {
+  t.equal(index, safer)
+  t.notEqual(safer, dangerous)
+  t.notEqual(index, dangerous)
+  t.end()
+})
+
+test('Is not a function', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.equal(typeof impl, 'object')
+    t.equal(typeof impl.Buffer, 'object')
+  });
+  [buffer].forEach(function (impl) {
+    t.equal(typeof impl, 'object')
+    t.equal(typeof impl.Buffer, 'function')
+  })
+  t.end()
+})
+
+test('Constructor throws', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.throws(function () { impl.Buffer() })
+    t.throws(function () { impl.Buffer(0) })
+    t.throws(function () { impl.Buffer('a') })
+    t.throws(function () { impl.Buffer('a', 'utf-8') })
+    t.throws(function () { return new impl.Buffer() })
+    t.throws(function () { return new impl.Buffer(0) })
+    t.throws(function () { return new impl.Buffer('a') })
+    t.throws(function () { return new impl.Buffer('a', 'utf-8') })
+  })
+  t.end()
+})
+
+test('Safe methods exist', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.equal(typeof impl.Buffer.alloc, 'function', 'alloc')
+    t.equal(typeof impl.Buffer.from, 'function', 'from')
+  })
+  t.end()
+})
+
+test('Unsafe methods exist only in Dangerous', function (t) {
+  [index, safer].forEach(function (impl) {
+    t.equal(typeof impl.Buffer.allocUnsafe, 'undefined')
+    t.equal(typeof impl.Buffer.allocUnsafeSlow, 'undefined')
+  });
+  [dangerous].forEach(function (impl) {
+    t.equal(typeof impl.Buffer.allocUnsafe, 'function')
+    t.equal(typeof impl.Buffer.allocUnsafeSlow, 'function')
+  })
+  t.end()
+})
+
+test('Generic methods/properties are defined and equal', function (t) {
+  ['poolSize', 'isBuffer', 'concat', 'byteLength'].forEach(function (method) {
+    [index, safer, dangerous].forEach(function (impl) {
+      t.equal(impl.Buffer[method], buffer.Buffer[method], method)
+      t.notEqual(typeof impl.Buffer[method], 'undefined', method)
+    })
+  })
+  t.end()
+})
+
+test('Built-in buffer static methods/properties are inherited', function (t) {
+  Object.keys(buffer).forEach(function (method) {
+    if (method === 'SlowBuffer' || method === 'Buffer') return;
+    [index, safer, dangerous].forEach(function (impl) {
+      t.equal(impl[method], buffer[method], method)
+      t.notEqual(typeof impl[method], 'undefined', method)
+    })
+  })
+  t.end()
+})
+
+test('Built-in Buffer static methods/properties are inherited', function (t) {
+  Object.keys(buffer.Buffer).forEach(function (method) {
+    if (method === 'allocUnsafe' || method === 'allocUnsafeSlow') return;
+    [index, safer, dangerous].forEach(function (impl) {
+      t.equal(impl.Buffer[method], buffer.Buffer[method], method)
+      t.notEqual(typeof impl.Buffer[method], 'undefined', method)
+    })
+  })
+  t.end()
+})
+
+test('.prototype property of Buffer is inherited', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.equal(impl.Buffer.prototype, buffer.Buffer.prototype, 'prototype')
+    t.notEqual(typeof impl.Buffer.prototype, 'undefined', 'prototype')
+  })
+  t.end()
+})
+
+test('All Safer methods are present in Dangerous', function (t) {
+  Object.keys(safer).forEach(function (method) {
+    if (method === 'Buffer') return;
+    [index, safer, dangerous].forEach(function (impl) {
+      t.equal(impl[method], safer[method], method)
+      if (method !== 'kStringMaxLength') {
+        t.notEqual(typeof impl[method], 'undefined', method)
+      }
+    })
+  })
+  Object.keys(safer.Buffer).forEach(function (method) {
+    [index, safer, dangerous].forEach(function (impl) {
+      t.equal(impl.Buffer[method], safer.Buffer[method], method)
+      t.notEqual(typeof impl.Buffer[method], 'undefined', method)
+    })
+  })
+  t.end()
+})
+
+test('Safe methods from Dangerous methods are present in Safer', function (t) {
+  Object.keys(dangerous).forEach(function (method) {
+    if (method === 'Buffer') return;
+    [index, safer, dangerous].forEach(function (impl) {
+      t.equal(impl[method], dangerous[method], method)
+      if (method !== 'kStringMaxLength') {
+        t.notEqual(typeof impl[method], 'undefined', method)
+      }
+    })
+  })
+  Object.keys(dangerous.Buffer).forEach(function (method) {
+    if (method === 'allocUnsafe' || method === 'allocUnsafeSlow') return;
+    [index, safer, dangerous].forEach(function (impl) {
+      t.equal(impl.Buffer[method], dangerous.Buffer[method], method)
+      t.notEqual(typeof impl.Buffer[method], 'undefined', method)
+    })
+  })
+  t.end()
+})
+
+/* Behaviour tests */
+
+test('Methods return Buffers', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.alloc(0)))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.alloc(0, 10)))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.alloc(0, 'a')))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.alloc(10)))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.alloc(10, 'x')))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.alloc(9, 'ab')))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.from('')))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.from('string')))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.from('string', 'utf-8')))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.from('b25ldHdvdGhyZWU=', 'base64')))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.from([0, 42, 3])))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.from(new Uint8Array([0, 42, 3]))))
+    t.ok(buffer.Buffer.isBuffer(impl.Buffer.from([])))
+  });
+  ['allocUnsafe', 'allocUnsafeSlow'].forEach(function (method) {
+    t.ok(buffer.Buffer.isBuffer(dangerous.Buffer[method](0)))
+    t.ok(buffer.Buffer.isBuffer(dangerous.Buffer[method](10)))
+  })
+  t.end()
+})
+
+test('Constructor is buffer.Buffer', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.equal(impl.Buffer.alloc(0).constructor, buffer.Buffer)
+    t.equal(impl.Buffer.alloc(0, 10).constructor, buffer.Buffer)
+    t.equal(impl.Buffer.alloc(0, 'a').constructor, buffer.Buffer)
+    t.equal(impl.Buffer.alloc(10).constructor, buffer.Buffer)
+    t.equal(impl.Buffer.alloc(10, 'x').constructor, buffer.Buffer)
+    t.equal(impl.Buffer.alloc(9, 'ab').constructor, buffer.Buffer)
+    t.equal(impl.Buffer.from('').constructor, buffer.Buffer)
+    t.equal(impl.Buffer.from('string').constructor, buffer.Buffer)
+    t.equal(impl.Buffer.from('string', 'utf-8').constructor, buffer.Buffer)
+    t.equal(impl.Buffer.from('b25ldHdvdGhyZWU=', 'base64').constructor, buffer.Buffer)
+    t.equal(impl.Buffer.from([0, 42, 3]).constructor, buffer.Buffer)
+    t.equal(impl.Buffer.from(new Uint8Array([0, 42, 3])).constructor, buffer.Buffer)
+    t.equal(impl.Buffer.from([]).constructor, buffer.Buffer)
+  });
+  [0, 10, 100].forEach(function (arg) {
+    t.equal(dangerous.Buffer.allocUnsafe(arg).constructor, buffer.Buffer)
+    t.equal(dangerous.Buffer.allocUnsafeSlow(arg).constructor, buffer.SlowBuffer(0).constructor)
+  })
+  t.end()
+})
+
+test('Invalid calls throw', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.throws(function () { impl.Buffer.from(0) })
+    t.throws(function () { impl.Buffer.from(10) })
+    t.throws(function () { impl.Buffer.from(10, 'utf-8') })
+    t.throws(function () { impl.Buffer.from('string', 'invalid encoding') })
+    t.throws(function () { impl.Buffer.from(-10) })
+    t.throws(function () { impl.Buffer.from(1e90) })
+    t.throws(function () { impl.Buffer.from(Infinity) })
+    t.throws(function () { impl.Buffer.from(-Infinity) })
+    t.throws(function () { impl.Buffer.from(NaN) })
+    t.throws(function () { impl.Buffer.from(null) })
+    t.throws(function () { impl.Buffer.from(undefined) })
+    t.throws(function () { impl.Buffer.from() })
+    t.throws(function () { impl.Buffer.from({}) })
+    t.throws(function () { impl.Buffer.alloc('') })
+    t.throws(function () { impl.Buffer.alloc('string') })
+    t.throws(function () { impl.Buffer.alloc('string', 'utf-8') })
+    t.throws(function () { impl.Buffer.alloc('b25ldHdvdGhyZWU=', 'base64') })
+    t.throws(function () { impl.Buffer.alloc(-10) })
+    t.throws(function () { impl.Buffer.alloc(1e90) })
+    t.throws(function () { impl.Buffer.alloc(2 * (1 << 30)) })
+    t.throws(function () { impl.Buffer.alloc(Infinity) })
+    t.throws(function () { impl.Buffer.alloc(-Infinity) })
+    t.throws(function () { impl.Buffer.alloc(null) })
+    t.throws(function () { impl.Buffer.alloc(undefined) })
+    t.throws(function () { impl.Buffer.alloc() })
+    t.throws(function () { impl.Buffer.alloc([]) })
+    t.throws(function () { impl.Buffer.alloc([0, 42, 3]) })
+    t.throws(function () { impl.Buffer.alloc({}) })
+  });
+  ['allocUnsafe', 'allocUnsafeSlow'].forEach(function (method) {
+    t.throws(function () { dangerous.Buffer[method]('') })
+    t.throws(function () { dangerous.Buffer[method]('string') })
+    t.throws(function () { dangerous.Buffer[method]('string', 'utf-8') })
+    t.throws(function () { dangerous.Buffer[method](2 * (1 << 30)) })
+    t.throws(function () { dangerous.Buffer[method](Infinity) })
+    if (dangerous.Buffer[method] === buffer.Buffer.allocUnsafe) {
+      t.skip('Skipping, older impl of allocUnsafe coerced negative sizes to 0')
+    } else {
+      t.throws(function () { dangerous.Buffer[method](-10) })
+      t.throws(function () { dangerous.Buffer[method](-1e90) })
+      t.throws(function () { dangerous.Buffer[method](-Infinity) })
+    }
+    t.throws(function () { dangerous.Buffer[method](null) })
+    t.throws(function () { dangerous.Buffer[method](undefined) })
+    t.throws(function () { dangerous.Buffer[method]() })
+    t.throws(function () { dangerous.Buffer[method]([]) })
+    t.throws(function () { dangerous.Buffer[method]([0, 42, 3]) })
+    t.throws(function () { dangerous.Buffer[method]({}) })
+  })
+  t.end()
+})
+
+test('Buffers have appropriate lengths', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.equal(impl.Buffer.alloc(0).length, 0)
+    t.equal(impl.Buffer.alloc(10).length, 10)
+    t.equal(impl.Buffer.from('').length, 0)
+    t.equal(impl.Buffer.from('string').length, 6)
+    t.equal(impl.Buffer.from('string', 'utf-8').length, 6)
+    t.equal(impl.Buffer.from('b25ldHdvdGhyZWU=', 'base64').length, 11)
+    t.equal(impl.Buffer.from([0, 42, 3]).length, 3)
+    t.equal(impl.Buffer.from(new Uint8Array([0, 42, 3])).length, 3)
+    t.equal(impl.Buffer.from([]).length, 0)
+  });
+  ['allocUnsafe', 'allocUnsafeSlow'].forEach(function (method) {
+    t.equal(dangerous.Buffer[method](0).length, 0)
+    t.equal(dangerous.Buffer[method](10).length, 10)
+  })
+  t.end()
+})
+
+test('Buffers have appropriate lengths (2)', function (t) {
+  t.equal(index.Buffer.alloc, safer.Buffer.alloc)
+  t.equal(index.Buffer.alloc, dangerous.Buffer.alloc)
+  var ok = true;
+  [ safer.Buffer.alloc,
+    dangerous.Buffer.allocUnsafe,
+    dangerous.Buffer.allocUnsafeSlow
+  ].forEach(function (method) {
+    for (var i = 0; i < 1e2; i++) {
+      var length = Math.round(Math.random() * 1e5)
+      var buf = method(length)
+      if (!buffer.Buffer.isBuffer(buf)) ok = false
+      if (buf.length !== length) ok = false
+    }
+  })
+  t.ok(ok)
+  t.end()
+})
+
+test('.alloc(size) is zero-filled and has correct length', function (t) {
+  t.equal(index.Buffer.alloc, safer.Buffer.alloc)
+  t.equal(index.Buffer.alloc, dangerous.Buffer.alloc)
+  var ok = true
+  for (var i = 0; i < 1e2; i++) {
+    var length = Math.round(Math.random() * 2e6)
+    var buf = index.Buffer.alloc(length)
+    if (!buffer.Buffer.isBuffer(buf)) ok = false
+    if (buf.length !== length) ok = false
+    var j
+    for (j = 0; j < length; j++) {
+      if (buf[j] !== 0) ok = false
+    }
+    buf.fill(1)
+    for (j = 0; j < length; j++) {
+      if (buf[j] !== 1) ok = false
+    }
+  }
+  t.ok(ok)
+  t.end()
+})
+
+test('.allocUnsafe / .allocUnsafeSlow are fillable and have correct lengths', function (t) {
+  ['allocUnsafe', 'allocUnsafeSlow'].forEach(function (method) {
+    var ok = true
+    for (var i = 0; i < 1e2; i++) {
+      var length = Math.round(Math.random() * 2e6)
+      var buf = dangerous.Buffer[method](length)
+      if (!buffer.Buffer.isBuffer(buf)) ok = false
+      if (buf.length !== length) ok = false
+      buf.fill(0, 0, length)
+      var j
+      for (j = 0; j < length; j++) {
+        if (buf[j] !== 0) ok = false
+      }
+      buf.fill(1, 0, length)
+      for (j = 0; j < length; j++) {
+        if (buf[j] !== 1) ok = false
+      }
+    }
+    t.ok(ok, method)
+  })
+  t.end()
+})
+
+test('.alloc(size, fill) is `fill`-filled', function (t) {
+  t.equal(index.Buffer.alloc, safer.Buffer.alloc)
+  t.equal(index.Buffer.alloc, dangerous.Buffer.alloc)
+  var ok = true
+  for (var i = 0; i < 1e2; i++) {
+    var length = Math.round(Math.random() * 2e6)
+    var fill = Math.round(Math.random() * 255)
+    var buf = index.Buffer.alloc(length, fill)
+    if (!buffer.Buffer.isBuffer(buf)) ok = false
+    if (buf.length !== length) ok = false
+    for (var j = 0; j < length; j++) {
+      if (buf[j] !== fill) ok = false
+    }
+  }
+  t.ok(ok)
+  t.end()
+})
+
+test('.alloc(size, fill) is `fill`-filled', function (t) {
+  t.equal(index.Buffer.alloc, safer.Buffer.alloc)
+  t.equal(index.Buffer.alloc, dangerous.Buffer.alloc)
+  var ok = true
+  for (var i = 0; i < 1e2; i++) {
+    var length = Math.round(Math.random() * 2e6)
+    var fill = Math.round(Math.random() * 255)
+    var buf = index.Buffer.alloc(length, fill)
+    if (!buffer.Buffer.isBuffer(buf)) ok = false
+    if (buf.length !== length) ok = false
+    for (var j = 0; j < length; j++) {
+      if (buf[j] !== fill) ok = false
+    }
+  }
+  t.ok(ok)
+  t.deepEqual(index.Buffer.alloc(9, 'a'), index.Buffer.alloc(9, 97))
+  t.notDeepEqual(index.Buffer.alloc(9, 'a'), index.Buffer.alloc(9, 98))
+
+  var tmp = new buffer.Buffer(2)
+  tmp.fill('ok')
+  if (tmp[1] === tmp[0]) {
+    // Outdated Node.js
+    t.deepEqual(index.Buffer.alloc(5, 'ok'), index.Buffer.from('ooooo'))
+  } else {
+    t.deepEqual(index.Buffer.alloc(5, 'ok'), index.Buffer.from('okoko'))
+  }
+  t.notDeepEqual(index.Buffer.alloc(5, 'ok'), index.Buffer.from('kokok'))
+
+  t.end()
+})
+
+test('safer.Buffer.from returns results same as Buffer constructor', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.deepEqual(impl.Buffer.from(''), new buffer.Buffer(''))
+    t.deepEqual(impl.Buffer.from('string'), new buffer.Buffer('string'))
+    t.deepEqual(impl.Buffer.from('string', 'utf-8'), new buffer.Buffer('string', 'utf-8'))
+    t.deepEqual(impl.Buffer.from('b25ldHdvdGhyZWU=', 'base64'), new buffer.Buffer('b25ldHdvdGhyZWU=', 'base64'))
+    t.deepEqual(impl.Buffer.from([0, 42, 3]), new buffer.Buffer([0, 42, 3]))
+    t.deepEqual(impl.Buffer.from(new Uint8Array([0, 42, 3])), new buffer.Buffer(new Uint8Array([0, 42, 3])))
+    t.deepEqual(impl.Buffer.from([]), new buffer.Buffer([]))
+  })
+  t.end()
+})
+
+test('safer.Buffer.from returns consistent results', function (t) {
+  [index, safer, dangerous].forEach(function (impl) {
+    t.deepEqual(impl.Buffer.from(''), impl.Buffer.alloc(0))
+    t.deepEqual(impl.Buffer.from([]), impl.Buffer.alloc(0))
+    t.deepEqual(impl.Buffer.from(new Uint8Array([])), impl.Buffer.alloc(0))
+    t.deepEqual(impl.Buffer.from('string', 'utf-8'), impl.Buffer.from('string'))
+    t.deepEqual(impl.Buffer.from('string'), impl.Buffer.from([115, 116, 114, 105, 110, 103]))
+    t.deepEqual(impl.Buffer.from('string'), impl.Buffer.from(impl.Buffer.from('string')))
+    t.deepEqual(impl.Buffer.from('b25ldHdvdGhyZWU=', 'base64'), impl.Buffer.from('onetwothree'))
+    t.notDeepEqual(impl.Buffer.from('b25ldHdvdGhyZWU='), impl.Buffer.from('onetwothree'))
+  })
+  t.end()
+})

data/lib/game_dig/node/node_modules/sax/LICENSE

@@ -0,0 +1,41 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+====
+
+`String.fromCodePoint` by Mathias Bynens used according to terms of MIT
+License, as follows:
+
+    Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/game_dig/node/node_modules/sax/README.md

@@ -0,0 +1,225 @@
+# sax js
+
+A sax-style parser for XML and HTML.
+
+Designed with [node](http://nodejs.org/) in mind, but should work fine in
+the browser or other CommonJS implementations.
+
+## What This Is
+
+* A very simple tool to parse through an XML string.
+* A stepping stone to a streaming HTML parser.
+* A handy way to deal with RSS and other mostly-ok-but-kinda-broken XML
+  docs.
+
+## What This Is (probably) Not
+
+* An HTML Parser - That's a fine goal, but this isn't it.  It's just
+  XML.
+* A DOM Builder - You can use it to build an object model out of XML,
+  but it doesn't do that out of the box.
+* XSLT - No DOM = no querying.
+* 100% Compliant with (some other SAX implementation) - Most SAX
+  implementations are in Java and do a lot more than this does.
+* An XML Validator - It does a little validation when in strict mode, but
+  not much.
+* A Schema-Aware XSD Thing - Schemas are an exercise in fetishistic
+  masochism.
+* A DTD-aware Thing - Fetching DTDs is a much bigger job.
+
+## Regarding `<!DOCTYPE`s and `<!ENTITY`s
+
+The parser will handle the basic XML entities in text nodes and attribute
+values: `&amp; &lt; &gt; &apos; &quot;`. It's possible to define additional
+entities in XML by putting them in the DTD. This parser doesn't do anything
+with that. If you want to listen to the `ondoctype` event, and then fetch
+the doctypes, and read the entities and add them to `parser.ENTITIES`, then
+be my guest.
+
+Unknown entities will fail in strict mode, and in loose mode, will pass
+through unmolested.
+
+## Usage
+
+```javascript
+var sax = require("./lib/sax"),
+  strict = true, // set to false for html-mode
+  parser = sax.parser(strict);
+
+parser.onerror = function (e) {
+  // an error happened.
+};
+parser.ontext = function (t) {
+  // got some text.  t is the string of text.
+};
+parser.onopentag = function (node) {
+  // opened a tag.  node has "name" and "attributes"
+};
+parser.onattribute = function (attr) {
+  // an attribute.  attr has "name" and "value"
+};
+parser.onend = function () {
+  // parser stream is done, and ready to have more stuff written to it.
+};
+
+parser.write('<xml>Hello, <who name="world">world</who>!</xml>').close();
+
+// stream usage
+// takes the same options as the parser
+var saxStream = require("sax").createStream(strict, options)
+saxStream.on("error", function (e) {
+  // unhandled errors will throw, since this is a proper node
+  // event emitter.
+  console.error("error!", e)
+  // clear the error
+  this._parser.error = null
+  this._parser.resume()
+})
+saxStream.on("opentag", function (node) {
+  // same object as above
+})
+// pipe is supported, and it's readable/writable
+// same chunks coming in also go out.
+fs.createReadStream("file.xml")
+  .pipe(saxStream)
+  .pipe(fs.createWriteStream("file-copy.xml"))
+```
+
+
+## Arguments
+
+Pass the following arguments to the parser function.  All are optional.
+
+`strict` - Boolean. Whether or not to be a jerk. Default: `false`.
+
+`opt` - Object bag of settings regarding string formatting.  All default to `false`.
+
+Settings supported:
+
+* `trim` - Boolean. Whether or not to trim text and comment nodes.
+* `normalize` - Boolean. If true, then turn any whitespace into a single
+  space.
+* `lowercase` - Boolean. If true, then lowercase tag names and attribute names
+  in loose mode, rather than uppercasing them.
+* `xmlns` - Boolean. If true, then namespaces are supported.
+* `position` - Boolean. If false, then don't track line/col/position.
+* `strictEntities` - Boolean. If true, only parse [predefined XML
+  entities](http://www.w3.org/TR/REC-xml/#sec-predefined-ent)
+  (`&amp;`, `&apos;`, `&gt;`, `&lt;`, and `&quot;`)
+
+## Methods
+
+`write` - Write bytes onto the stream. You don't have to do this all at
+once. You can keep writing as much as you want.
+
+`close` - Close the stream. Once closed, no more data may be written until
+it is done processing the buffer, which is signaled by the `end` event.
+
+`resume` - To gracefully handle errors, assign a listener to the `error`
+event. Then, when the error is taken care of, you can call `resume` to
+continue parsing. Otherwise, the parser will not continue while in an error
+state.
+
+## Members
+
+At all times, the parser object will have the following members:
+
+`line`, `column`, `position` - Indications of the position in the XML
+document where the parser currently is looking.
+
+`startTagPosition` - Indicates the position where the current tag starts.
+
+`closed` - Boolean indicating whether or not the parser can be written to.
+If it's `true`, then wait for the `ready` event to write again.
+
+`strict` - Boolean indicating whether or not the parser is a jerk.
+
+`opt` - Any options passed into the constructor.
+
+`tag` - The current tag being dealt with.
+
+And a bunch of other stuff that you probably shouldn't touch.
+
+## Events
+
+All events emit with a single argument. To listen to an event, assign a
+function to `on<eventname>`. Functions get executed in the this-context of
+the parser object. The list of supported events are also in the exported
+`EVENTS` array.
+
+When using the stream interface, assign handlers using the EventEmitter
+`on` function in the normal fashion.
+
+`error` - Indication that something bad happened. The error will be hanging
+out on `parser.error`, and must be deleted before parsing can continue. By
+listening to this event, you can keep an eye on that kind of stuff. Note:
+this happens *much* more in strict mode. Argument: instance of `Error`.
+
+`text` - Text node. Argument: string of text.
+
+`doctype` - The `<!DOCTYPE` declaration. Argument: doctype string.
+
+`processinginstruction` - Stuff like `<?xml foo="blerg" ?>`. Argument:
+object with `name` and `body` members. Attributes are not parsed, as
+processing instructions have implementation dependent semantics.
+
+`sgmldeclaration` - Random SGML declarations. Stuff like `<!ENTITY p>`
+would trigger this kind of event. This is a weird thing to support, so it
+might go away at some point. SAX isn't intended to be used to parse SGML,
+after all.
+
+`opentagstart` - Emitted immediately when the tag name is available,
+but before any attributes are encountered.  Argument: object with a
+`name` field and an empty `attributes` set.  Note that this is the
+same object that will later be emitted in the `opentag` event.
+
+`opentag` - An opening tag. Argument: object with `name` and `attributes`.
+In non-strict mode, tag names are uppercased, unless the `lowercase`
+option is set.  If the `xmlns` option is set, then it will contain
+namespace binding information on the `ns` member, and will have a
+`local`, `prefix`, and `uri` member.
+
+`closetag` - A closing tag. In loose mode, tags are auto-closed if their
+parent closes. In strict mode, well-formedness is enforced. Note that
+self-closing tags will have `closeTag` emitted immediately after `openTag`.
+Argument: tag name.
+
+`attribute` - An attribute node.  Argument: object with `name` and `value`.
+In non-strict mode, attribute names are uppercased, unless the `lowercase`
+option is set.  If the `xmlns` option is set, it will also contains namespace
+information.
+
+`comment` - A comment node.  Argument: the string of the comment.
+
+`opencdata` - The opening tag of a `<![CDATA[` block.
+
+`cdata` - The text of a `<![CDATA[` block. Since `<![CDATA[` blocks can get
+quite large, this event may fire multiple times for a single block, if it
+is broken up into multiple `write()`s. Argument: the string of random
+character data.
+
+`closecdata` - The closing tag (`]]>`) of a `<![CDATA[` block.
+
+`opennamespace` - If the `xmlns` option is set, then this event will
+signal the start of a new namespace binding.
+
+`closenamespace` - If the `xmlns` option is set, then this event will
+signal the end of a namespace binding.
+
+`end` - Indication that the closed stream has ended.
+
+`ready` - Indication that the stream has reset, and is ready to be written
+to.
+
+`noscript` - In non-strict mode, `<script>` tags trigger a `"script"`
+event, and their contents are not checked for special xml characters.
+If you pass `noscript: true`, then this behavior is suppressed.
+
+## Reporting Problems
+
+It's best to write a failing test if you find an issue.  I will always
+accept pull requests with failing tests if they demonstrate intended
+behavior, but it is very hard to figure out what issue you're describing
+without a test.  Writing a test is also the best way for you yourself
+to figure out if you really understand the issue you think you have with
+sax-js.