Externalized the standard server library.
Updated the external std library.
Update of the std lib
Worked mostly on the grammar, with a notable change due to the update of PEG.js.

package.json:

- updated PEG.js to the version on GitHub: adding a lot of features

OOP:

- added the possibility to make instances callable: a new property is available when defining the class, giving a method (an actual function) to call in this case
- added the possibility to call generated constructor without the `new` keyword
- fixed processProperties to actually make first argument optional
- exported applyProperties function

STD library:

To fix a problem in registering modes as RPC modules.

- fixed route: now you need to explicitly define the name of a RPC module (the OOP system behind changed indeed)
- added some error messages in rpc

Node:

- changed the interface of the constructor, to use a more object oriented approach (using the oop library). Implied defining some (sub)models
- updated logging methods to use the end offset
- added a development feature to check if a graph covers the entire source code (every character)
- updated the documentation accordingly

Mode:

- fixed highlighting method to properly use the end offset

Grammar:

- added the use of the $ syntax/function: removing library helpers
- updated line, column and offset occurrences to use functions
- added use of the text function
- reduced the initializer because the node instancier is now callable (no need for a wrapper function)

AT Grammar:

- fixed the nonbraced rule: syntax error, `=` was missing
- replaced the helper library references for braces by their unicode representations

HTML Grammar:

- completed coverage of the entire source code, splitting lots of rules, building more nodes (see documentation IN AT MODULE for procedure)

Node instancier (in PEG.js helpers):

- updated to take into account the input source and compute the end offset
- updated to conform to the new Node interface

Tests:

- added the graph coverage test in parsers test
- changed the way to pass data input for test: directly instead of giving a path to compute and read

Parsers (HTML & AT):

- changed the way to build grammars: using an options.json file
- updated the way to use the test utility, reading the data before calling the test
Created a client-side application to visualize a graph generated from parsing.

Application:

- added a public folder at application level to be served
- added routes to serve this application
- updated server options to serve proper static locations

STD library:

- fixed static path resolutions in the server library: to take into account the current working directory instead of the server library directory (which made no sense)

Mode:

- added methods to compute models for graph visualization: libraries-specific
Many changes (see full description).

- Cleaned the external STD module: removed unused elements and began translating LS to JS
- Moved the graph visualizer a level up (public) folder for more consistency
- Aligned the graph vizualizer application to the latest changes of the backend
- Updated core code: dop, oop, ...
- Updated core business code: mode, node, highlighting, ...
Big work on the documentation. Some fixes too, and some additions.

Documentation:

- added a global roadmap to priorize items to be done for the project
- introduced some links (relative) between documentation files: might be broken! (didn't test yet if they were properly written)
- Eclipse Plugin
	- removed done items for Outline
	- added documentation to help aligning the plugin with latest changes of the backend regarding the communication protocol
	- completed the documentation about what has to be done to make highlighting work properly
	- completed the documentation about what has to be done to synchronize document changes between the plugin and the backend
- global minor updates/improvements

Graph visualizer:

- little fix for the display of the number of nodes in the tree

Package definition:

- updated the urls of the repo: official Aria Templates instead of my own fork
- changed some properties about installation/deployment

Editor/Mode manager:

- fixed the 'exec' method, not accepting something else than the propery 'svc' for the service specification
- improved the error management of the 'exec' method
- improved error management of several methods (for null inputs essentially)
- added the 'configuration' method, to get the general configuration of an editor (mode agnostic)
- added a class to handle document IDs

DOP:

- now the 'applyProperties' method is able to handle free properties of input spec objects and to copy them (without duplicating standard properties that would have been passed with aliases)
- this introduced a new feature which is: an optional object can be passed to several methods to gather information about what has been done, how the spec object has been processed, which computations occurred, etc.

OOP:

- added common property names to be used to defined the parent class (extends, extend)
- used the Object.create native function where possible, for a better quality of the code

Code:

- added some documentation about the class

New classes:

- Error: to have a wrapper around native Error, to be used for exceptions

STD:

- converted the server index file from LiveScript to JavaScript

JS Mode:

- removed the old sessions management code
Fixed the documentation and completed it a little. Small improvements on the backend code.

Documentation:

- fixed wrong relative links
- added missing relative links (hope these ones are good)
- cleaned and improved a little, added or moved some content

Standard Error:

- renamed the module file containing our own standard error from 'error' to 'stderror'

Editor / Mode manager:

- changed the name of the GUID class to DocumentID
- fix what broke everything: the properties definitions in the schema of the DocumentID class

Code:

- added some descriptions in the schema
- began preparing the class to use a schema at construction

Color:

- added some descriptions
- added serialize and parse methods
- prepared the schema to accept HSV & co. models

Graph visualizer:

- added actions to test standard routes of the backend: GUID identification and shutdown
Lots of changes, the main one being the end (almost) of the implementation of highlighting, along with a lot of improvements in the Web application used for testing.

- updated documentation, fixed some typos
- added instructions for how to launch the backend server
- added the `statics` folder containing cleanup and formatting rules for Java code
- added the dependency to the escape-html library, used for highlighting preview in HTML (in the Web application)

Web application:

- updated to Bootstrap 3: big changes in HTML structure (index.html)
- started using Require.js
- refactored a lot thanks to Require.js notably
	- index.js: main file, entry point, building the GUI and initializing stuff
	- actions.js: handler functions reacting to user interaction
	- backend.js: backend services abstraction
	- graphs.js: functions building graph visualizations from different libraries
	- gui.js: utilities to build the GUI
	- templates.js: a collections of templates compiled with hogan.js, working with bootstrap and designed for the application
	- added a stylesheet: main.css
- added tabs to view highlighting and folding data

OOP:

- fixed the API to define descriptors for instance properties: now it really accepts different property names

STD:

- network.js: removed some code by using a feature of the DOP library
- logger.ls: removed (temporarily) the step of cleaning the object, which was buggy

# Modes

Mode manager:

- improved error handling for the `exec` service

Code:

- fixed the source code update: there was a wrong offset calculation
- added some documentation

Mode:

- used more features of the DOP library
- began using the custom STDError class
- changed the way highlighted nodes are specified: every style defined in the given stylesheet will be used for the highlighting process, and some explicit node types that should use default style can be specified
- finished implementation of highlighting: now at the end of the process every leaf get styled so that a proper set of ranges can be extracted (no overlapping, no hole, ...), and also consecutive ranges of same style are collapsed
- added two methods for HTML rendering of highlithing: `html`, which gives a HTML snippet of code with tokens surrounded by styled elements, and `css`for actual styling of those elements
- implemented folding
- cleaned the parse service: now it returns a smaller but still comprehensive AST

Node:

- fixed the confusion between `_index` and `_parentIndex`, but also `_parentId`: now `_key` is the key used in the parent's children index, `_index` the position in parent's children list, and `_listIndex` the position in the list of nodes added with `addList` (so it's optional)
- fixed and enhanced the missing end position computation
- added more flexibility in the API by adding more input property names
- added a system of flags: specific boolean properties that can be easily set on or off. Flags are copied when copying a graph.
- added a unique id for each node
- added an object globally shared among all the nodes of a graph: the hard part has been made to keep it consistent and up to date while merging graphs (adding a graph to another)
- updated the internal `_pushChild` method to handle the shared object: this is expensive if the added child is the root of a big subgraph, as the latter is traversed twice for proper updates
- added various dynamic instance properties, some of them replacing some methods. This adds two new properties:
	- path: this returns the list of nodes from the root leading to the current node
	- branches: this returns the list of paths for all leaves (that's what are branches)
- added back the `put` utility, to add various things like childrens, properties, flags, ... everything through the same method. Has some edge cases that require specific methods to be used instead.
- added the ability to specify a context for the callback method used when traversing
- added some collection methods: map, pluck
- changed some debugging/introspection methods: `getId` now returns a string built from indexes' keys
- updated the `simplify` method to take flags into account
- added a feature to the `pick` method, using flags: if a string is specified instead of a function, it will pick up nodes matching the given flag

Highlight:

- added css serialization for all models
- made a few API enhancements

PEG.js Parser:

- extracted the Node instancier class to put it in its own file
- added a system of hooks for the Node instancier: post-processing functions applied for each new node, aimed at computing properties or doing whatever you want

# Specific modes & Parsers

HTML:

- updated the mode to specify properly nodes with default style
- updated the stylesheet: now it gives a real-life highlighting
- updated the grammar
	- used hooks to flag nodes which are blocks
	- fixed some stuff, mostly handling of optional elements
	- added quick and dirty changes concerning node typing to make highlighting works
Big refactoring and small documentation improvements.

Refactoring:

- DOP
- OOP
- Error

Documentation:

- backend application
- standard server library
- suggestion for pairs matching feature
Last refactoring before project externalisation.

Imported from ymeine/editors-tools (https://github.com/ymeine/editors-tools/tree/59c05b4205feec0f6ca660b8347e4fb135536862/ultimate-poc/resources/app/node_modules/std/server).