Adds properties to class definitions

Classes can be defined using a specific syntax which allows for a
property to be defined with associated getters and setters. Both
functions are optional and can be replaced with a boolean to indicate
either a simple getter/setter (true) or no getter/setter (false).

Access control can be controlled to allow for any combination of
private/protected/public access to either the underlying property or
the getter/setter.
Adds autoloading of classes and scripts

Classes can now 'require' one or many scripts and/or classes which will
be included when the class is declared and can be guaranteed to load
before any class method (including the constructor) is run.

Mapping can also be set up for autoloading classes and files. That is,
the system can be told to find class x.y.z at the path a/b/c.js or any
other pattern.

Classes can also be registered as loaded. This is so that they can be
compiled into production files and there will be no further attempt to
load them.
Adds events to class definitions

Classes can now declare a list of events which they are able to trigger.
Client objects can bind a nominated method of their own to any of these
events to be called when the event is triggered. Data can be passed
from the triggering class to the target method.

Nominated methods must be accessible to the class which owns the event,
according to existing rules of method access. Classes related by
inheritance can therefore call methods which are protected.

Client classes can also unbind themselves from previously bound events.
Extends abstract functionality

Abstract classes can now list abstract methods that should be
implemented by inheriting classes. All methods must be implemented
unless the child class is also declared abstract in which case the next
child class must implement all abstract methods in both parents.
Adds type hinting to class methods

Class methods can now be defined with return and/or argument type
hinting. Each method can declare that arguments or return values must
be of one of the following types; null, undefined, string, number,
boolean, object, specific class, array or an array of one of the other
types.

A relevant fatal will be thrown at run time when a method or calling
function does not obey type safety.
Changes default behaviour of toString method

Now when a class which does not override the toString method is
converted to a string, it will be rendered as '[object Name.Of.Class]'.
Moves instanceOf function to object prototype

This is so that all non-null and non-undefined objects in the system can
have instanceOf called against them meaning we do not have to check
for the method before we can validate a certain class or interface.

Specifically, we can call instanceOf on strings, numbers, objects,
arrays and booleans without error. All except objects are guaranteed to
return false as they cannot be instances of Class, user defined classes
or interfaces.
Changes default class member access to private

Unless a specific access level is specified at property or method
declaration, they will now be declared private instead of public.

This is in order to encourage encapsulation which is one of the main
aims of this project.
Reformats fatal objects

Fatals now show up in the console as errors of type Fatal with full
stack trace and well formatted messages.
Updates format of fatals to match master
Updates format of fatals to match master
Updates format of fatals to match master
Updates format of fatals to match master
Removes accidental globals
Merge pull request #2 from peteonline/feat-auto-include

Adds autoloading of classes and scripts
Merge branch 'master' into feat-type-safety

Conflicts:
	Class.js
	ClassTest.js
	Test/Test.html
Merge pull request #6 from peteonline/feat-type-safety

Adds type hinting to class methods
Merge branch 'master' into feat-properties

Conflicts:
	ClassTest.js
	Test/Test.html
Adds type hinting to class properties
Merge pull request #1 from peteonline/feat-properties

Adds properties to class definitions