Change history for demjson python module.

Version 1.6 released 2011-04-01

 * Bug fix. The jsonlint tool failed to accept a JSON document from
   standard input (stdin).  Also added a --version and --copyright
   option support to jsonlint.  Thanks to Brian Bloniarz for reporting
   this bug.

 * No changes to the core demjson library/module was made, other
   than a version number bump.

Version 1.5 released 2010-10-10

 * Bug fix. When encoding Python strings to JSON, occurances of
   character U+00FF (ASCII 255 or 0xFF) may result in an error.
   Thanks to Tom Kho and Yanxin Shi for reporting this bug.

Version 1.4 released 2008-12-17

 * Changed license to LGPL 3 (GNU Lesser General Public License) or
   later.  Older versions still retain their original licenses.

 * No changes other than relicensing were made.

Version 1.3 released 2008-03-19

 * Change the default value of escape_unicode to False rather than
   True.

 * Parsing JSON strings was not strict enough.  Prohibit multi-line
   string literals in strict mode.  Also prohibit control characters
   U+0000 through U+001F inside string literals unless they are
   \u-escaped.

 * When in non-strict mode where object keys may be JavaScript
   identifiers, allow those identifiers to contain '$' and '_'.  Also
   introduce a method, decode_javascript_identifier(), which converts
   a JavaScript identifier into a Python string type, or can be
   overridden by a subclass to do something different.

 * Use the Python decimal module if available for representing
   numbers that can not fit into a float without loosing precision.
   Also encode decimal numbers into JSON and use them as a source
   for NaN and Infinity values if necessary.

 * Allow Python complex types to be encoded into JSON if their
   imaginary part is zero.

 * When parsing JSON numbers try to keep whole numbers as integers
   rather than floats; e.g., '1e+3' will be 1000 rather than 1000.0.
   Also make sure that overflows and underflows (even for the larger
   Decimal type) always result in Infinity or -Infinity values.

 * Handle more Python collection types when creating JSON; such as
   deque, set, array, and defaultdict.  Also fix a bug where UserDict
   was not properly handled because of it's unusual iter() behavior.


Version 1.2 released 2007-11-08

 * Changed license to GPL 3 or later.  Older versions still retain
   their original licenses.

 * Lint Validator: Added a "jsonlint" command-line utility for
   validating JSON data files, and/or reformatting them.

 * Major performance enhancements.  The most signifant of the many
   changes was to use a new strategy during encoding to use lists and
   fast list operations rather than slow string concatenation.

 * Floating-Point Precision: Fixed a bug which could cause loss of
   precision (e.g., number of significant digits) when encoding
   floating-point numbers into their JSON representation.  Also, the
   bundled test suite now properly tests floating-point encoding
   allowing for slight rounding errors which may naturally occur on
   some platforms.

 * Very Large Hex Numbers: Fixed a bug when decoding very large
   hexadecimal integers which could result in the wrong value for
   numbers larger than 0xffffffff.  Note that the language syntax
   allows such huge numbers, and since Python supports them too this
   module will decode such numbers.  However in practice very few
   other JSON or Javascript implementations support arbitrary-size
   integers.  Also hex numbers are not valid when in strict mode.

 * According to the JSON specification a document must start with
   either an object or an array type.  When in strict mode if the
   first non-whitespace object is any other type it should be
   considered to be an invalid document.  The previous version
   erroneously decoded any JSON value (e.g., it considered the
   document "1" to be valid when it should not have done so.
   Non-strict mode still allows any type, as well as by setting
   the new behavior flag 'allow_any_type_at_start'.

 * Exception Handling: Minor improvements in exception handling by
   removing most cases where unbounded catching was performed (i.e.,
   an "except:" with no specified exception types), excluding during
   module initialization.  This will make the module more
   caller-friendly, for instance by not catching and "hiding"
   KeyboardInterrupt or other asyncrhonous exceptions.

 * Identifier Parsing: The parser allows a more expanded syntax for
   Javascript identifiers which is more compliant with the ECMAscript
   standard.  This will allow, for example, underscores and dollar
   signs to appear in identifiers.  Also, to provide further
   information to the caller, rather than converting identifiers into
   Python strings they are converted to a special string-subclass.
   Thus they will look just like strings (and pass the
   "isinstance(x,basestring)" test), but the caller can do a type test
   to see if the value originated from Javascript identifiers or string literals.
   Note this only affects the non-strict (non-JSON) mode.

 * Fixed a liberal parsing bug which would successfully decode JSON
   ["a" "b"] into Python ['a', 'b'], rather than raising a syntax
   error for the missing comma.

 * Fixed a bug in the encode_default() method which raised the
   wrong kind of error.  Thanks to Nicolas Bonardelle.

 * Added more test cases to the bundled self-test program (see
   test/test_demjson.py).  There are now over 180 individual
   test cases being checked.


Version 1.1 released 2006-11-06

 * Extensive self testing code is now included, conforming to the
   standard Python unittest framework.  See the INSTALL.txt file for
   instructions.

 * Corrected character encoding sanity check which would erroneously
   complain if the input contained a newline or tab character within
   the first two characters.

 * The decode() and encode() top-level functions now allow additional
   keyword arguments to turn specific behaviors on or off that
   previously could only be done using the JSON class directly.  The
   keyword arguments look like 'allow_comments=True'.  Read the
   function docstrings for more information on this enhancement.

 * The decoding of supplementary Unicode character escape sequences
   (such as "\ud801\udc02") was broken on some versions of Python.
   These are now decoded explicitly without relying on Python so they
   always work.

 * Some Unicode encoding and decoding with UCS-4 or UTF-32 were not
   handled correctly.

 * Encoding of pseudo-string types from the UserString module are
   now correctly encoded as if real strings.

 * Improved simulation of nan, inf, and neginf classes used if the
   Python interpreter doesn't support IEEE 754 floating point math.

 * Updated the documentation to describe why this module does not
   permit multi-line string literals.


Version 1.0 released 2006-08-10

 * Initial public release