/**
                                * The `Matter` module is the top level namespace. It also includes a function for installing plugins on top of the library.
                                *
                                * @class Matter
                                */
                                
                                var Matter = {};
                                
                                module.exports = Matter;
                                
                                var Plugin = require('./Plugin');
                                var Common = require('./Common');
                                
                                (function() {
                                
                                    /**
                                     * The library name.
                                     * @property name
                                     * @readOnly
                                     * @type {String}
                                     */
                                    Matter.name = 'matter-js';
                                
                                    /**
                                     * The library version.
                                     * @property version
                                     * @readOnly
                                     * @type {String}
                                     */
                                    Matter.version = typeof __MATTER_VERSION__ !== 'undefined' ? __MATTER_VERSION__ : '*';
                                
                                    /**
                                     * A list of plugin dependencies to be installed. These are normally set and installed through `Matter.use`.
                                     * Alternatively you may set `Matter.uses` manually and install them by calling `Plugin.use(Matter)`.
                                     * @property uses
                                     * @type {Array}
                                     */
                                    Matter.uses = [];
                                
                                    /**
                                     * The plugins that have been installed through `Matter.Plugin.install`. Read only.
                                     * @property used
                                     * @readOnly
                                     * @type {Array}
                                     */
                                    Matter.used = [];
                                
                                    /**
                                     * Installs the given plugins on the `Matter` namespace.
                                     * This is a short-hand for `Plugin.use`, see it for more information.
                                     * Call this function once at the start of your code, with all of the plugins you wish to install as arguments.
                                     * Avoid calling this function multiple times unless you intend to manually control installation order.
                                     * @method use
                                     * @param ...plugin {Function} The plugin(s) to install on `base` (multi-argument).
                                     */
                                    Matter.use = function() {
                                        Plugin.use(Matter, Array.prototype.slice.call(arguments));
                                    };
                                
                                    /**
                                     * Chains a function to excute before the original function on the given `path` relative to `Matter`.
                                     * See also docs for `Common.chain`.
                                     * @method before
                                     * @param {string} path The path relative to `Matter`
                                     * @param {function} func The function to chain before the original
                                     * @return {function} The chained function that replaced the original
                                     */
                                    Matter.before = function(path, func) {
                                        path = path.replace(/^Matter./, '');
                                        return Common.chainPathBefore(Matter, path, func);
                                    };
                                
                                    /**
                                     * Chains a function to excute after the original function on the given `path` relative to `Matter`.
                                     * See also docs for `Common.chain`.
                                     * @method after
                                     * @param {string} path The path relative to `Matter`
                                     * @param {function} func The function to chain after the original
                                     * @return {function} The chained function that replaced the original
                                     */
                                    Matter.after = function(path, func) {
                                        path = path.replace(/^Matter./, '');
                                        return Common.chainPathAfter(Matter, path, func);
                                    };
                                
                                })();