Allow signed exponent on number literal

The lexer was not considering a positive or negative sign value on a
number literal exponent, which resulted in a split token a dangling
modifer failure. A single sign is now permitted, so long as it is
followed by digits.
Handle a parsing ambiguity for '<'

The existing mismatched operators test was in the wrong directory, and
failed for the wrong reason, because it was parsing '<' and '>' as
generic parameters (and succeeding) before failing at runtime. Now
mismatched operators tests operators for which there is no ambiguity,
and correctly fails to parse.

The opening symbol for a generic request now cannot be spaced from the
previous identifier, but if it is not it can still be parsed as an
operator, but the parser will prefer the generic request if possible.

The actual angle bracket operator tests are now in separated, with one
that ensures the brackets are parsed as operators correctly, and another
that just ensures there's no confusion when they're written backwards.
A final running test has been added which would parse as a generic
parameter but the opening angle is spaced from the preceding identifier,
so is parsed as two separate comparison operators instead.
Return the outer value, not a variable object

When resolving outer, the variable object that contained the outer value
was being returned, rather than the value inside the variable. Now the
correct value is resolved and wrapped in a task.
Add comparison operators to numbers

Comparison is a built-in operation in JavaScript, so the comparison
operators must be built into the Grace numbers as well.
Correctly validate string escape characters

The control errors in string were never actually being raised, and the
continued lexing would not output an appropriate string if an error did
occur. Now backslashes are escaped when outputting strings, and invalid
characters are included as Unicode replacement characters.

Closing quotes in errors were being consumed by the terminal escape
code, so a space is now placed between the end of the output and the
escape code.
Handle number literal bases other than sixteen

The hexadecimal number literal notation now handles any number from 2 to
36 before the 'x', extending the number literal characters that follow
an 'x' to the full alphabet. A number token will verify that the
characters are valid for the given base before continuing. The runtime
definition for creating numbers has been updated to parse different
bases.
Add variables to scope before evaluating them

Variables that were not being hoisted inside of objects were evaluating
their expression before introducing the variable into scope, meaning
that if the expression referred to the variable it would report that it
could not find it rather than reporting that it was not yet defined.
This is tested by provoking the error and catching only the appropriate
packet.
Update package information with correct license

The previous package.json file had the wrong license information in it.
The other fields have also been rearranged into more sensible groups.
Adjust assignment uglify, add missing argument

Uglifying an assignment would produce 'name_:='. The underscore is now
no longer present. The missing node argument when calling 'put' when
scoping variables has been added.
Add method getter and arguments helper to apply

Specialised uses of apply had to reference the receiver of the method
and then separately retrieve the method from the receiver. If the method
took no arguments, apply still had to take a nested array. Now apply
optionally accepts a string instead of a method, in which case it
retrieves the method with that name from the receiver, and the arguments
default to empty.
Parse type literals at start of line as expression

Type literals that began at the start of a line are confused with type
declarations, as they start with the same keyword. The parser for type
declarations had a case to deal with this possibility, but it only
parsed the literal and did not continue on the line. The parser will now
parse a full expression, included method requests, binary operators, and
a new line.
Correct pattern names in runtime definitions

Some definitions in the runtime were wrongly using the abbreviated names
to refer to patterns when asserting that arguments were of the right
type. Now they refer to the full names. The implementation of & and | in
patterns now actually returns the pattern it was creating instead of
undefined.
Make tasks completely asynchronous by default

Allowing task continuations to run synchronously produced a memory leak
that blew the stack out easily in recursive method definitions. Now
calls to 'then' on a task follow the Promises specification by dropping
the call stack before continuing. However, this behaviour can be
overridden by the 'now' function, present on every task, which forces
each subsequent task to run immediately as well. Trying to force a task
in this way fails if the task has truly asynchronous behaviour.

A number of definitions in the runtime have been updated to adjust to
this new interface. Method application still uses setImmediate, but
rather than creating a custom 'now' as it did before, it binds into the
new 'now' interface by setting the memoised function to be run on force.
Ensure method does not continue after return

The return statement was not actually halting the evaluation of a
method, and the actual behaviour was forking onto two paths: one that
continued from where the method was requested, and one that was still
inside the method. The existing test for this case is unable to test
this property correctly because only side-effects are visible from the
second path, and the harness does not take side-effects into account.
Recognise Unicode line separator character

The Unicode line separator character is a valid new line character, and
is now recognised by the lexer as such.
Remove mutation of node when generating inherits

The code that generated the inherits method in the interpreter was
mutating the actual method node by popping off the last statement from
the body. Now the body is cloned before this happens.
Update operator detection when making method name

The function that combined the parts of a method was using the parser to
check if a method part was an operator. Now it just checks the
'isOperator' property.
Use strict mode when parsing var type

If the type of a var was just an identifier, the parser attempted to
parse the assignment operator as part of the type. Types on vars are now
parsed in strict mode, which means they cannot contain assignments.