docs(config): improve formatting and add note about library entry points in output.md

Author: skipjack

src/content/configuration/output.md

@@ -295,14 +295,16 @@ If using the [`output.library`](#output-library) option, the library name is aut
 
 How the value of the `output.library` is used depends on the value of the [`output.libraryTarget`](#output-librarytarget) option; please refer to that section for the complete details. Note that the default option for `output.libraryTarget` is `var`, so if the following configuration option is used:
 
-```javascript
+``` js
 output: {
   library: "MyLibrary"
 }
 ```
 
 The variable `MyLibrary` will be bound with the return value of your entry file, if the resulting output is included as a script tag in an HTML page.
 
+W> Note that if an `array` is provided as an `entry` point, only the last module in the array will be exposed. If an `object` is provided, it can exposed using an `array` syntax (see [this example](https://github.com/webpack/webpack/tree/master/examples/multi-part-library) for details).
+
 T> Read the [authoring libraries guide](/guides/author-libraries) guide for more information on `output.library` as well as `output.libraryTarget`.
 
 
@@ -312,41 +314,38 @@ T> Read the [authoring libraries guide](/guides/author-libraries) guide for more
 
 > Default: `_entry_return_`
 
-Configure which module or modules will be exposed via the `libraryTarget`.
-
-The default value `_entry_return_` is the namespace or default module returned by your entry file.
-
-The examples below demonstrate the effect of this config when using `libraryTarget: "var"`, but any target may be used.
+Configure which module or modules will be exposed via the `libraryTarget`. The default `_entry_return_` value is the namespace or default module returned by your entry file. The examples below demonstrate the effect of this config when using `libraryTarget: "var"`, but any target may be used.
 
 The following configurations are supported:
 
 `libraryExport: "default"` - The **default export of your entry point** will be assigned to the library target:
 
-```javascript
+``` js
 // if your entry has a default export of `MyDefaultModule`
 var MyDefaultModule = _entry_return_.default;
 ```
 
 `libraryExport: "MyModule"` - The **specified module** will be assigned to the library target:
 
-```javascript
+``` js
 var MyModule = _entry_return_.MyModule;
 ```
 
 `libraryExport: ["MyModule", "MySubModule"]` - The array is interpreted as a **path to a module** to be assigned to the library target:
 
-```javascript
+``` js
 var MySubModule = _entry_return_.MyModule.MySubModule;
 ```
 
-As the examples have shown that the return values of the entry points are bounded to those named variables, the usage of the resulting library is simply like so:
+With the `libraryExport` configurations specified above, the resulting libraries could be utilized as such:
 
-```javascript
+``` js
 MyDefaultModule.doSomething();
 MyModule.doSomething();
 MySubModule.doSomething();
 ```
 
+
 ## `output.libraryTarget`
 
 `string`
@@ -363,7 +362,7 @@ These options assign the return value of the entry point (e.g. whatever the entr
 
 `libraryTarget: "var"` - (default) When your library is loaded, the **return value of your entry point** will be assigned to a variable:
 
-```javascript
+``` js
 var MyLibrary = _entry_return_;
 
 // In a separate script...
@@ -375,7 +374,7 @@ W> When using this option, an empty `output.library` will result in no assignmen
 
 `libraryTarget: "assign"` - This will generate an implied global which has the potential to reassign an existing value (use with caution).
 
-``` javascript
+``` js
 MyLibrary = _entry_return_;
 ```
 
@@ -390,15 +389,15 @@ These options assign the return value of the entry point (e.g. whatever the entr
 
 If `output.library` is not assigned a non-empty string, the default behavior is that all properties returned by the entry point will be assigned to the object as defined for the particular `output.libraryTarget`, via the following code fragment:
 
-```javascript
+``` js
 (function(e, a) { for(var i in a) e[i] = a[i]; }(${output.libraryTarget}, _entry_return_)
 ```
 
 W> Note that not setting a `output.library` will cause all properties returned by the entry point to be assigned to the given object; there are no checks against existing property names.
 
 `libraryTarget: "this"` - The **return value of your entry point** will be assigned to this under the property named by `output.library`. The meaning of `this` is up to you:
 
-```javascript
+``` js
 this["MyLibrary"] = _entry_return_;
 
 // In a separate script...
@@ -408,7 +407,7 @@ MyLibrary.doSomething(); // if this is window
 
 `libraryTarget: "window"` - The **return value of your entry point** will be assigned to the `window` object using the `output.library` value.
 
-```javascript
+``` js
 window["MyLibrary"] = _entry_return_;
 
 window.MyLibrary.doSomething();
@@ -417,7 +416,7 @@ window.MyLibrary.doSomething();
 
 `libraryTarget: "global"` - The **return value of your entry point** will be assigned to the `global` object using the `output.library` value.
 
-```javascript
+``` js
 global["MyLibrary"] = _entry_return_;
 
 global.MyLibrary.doSomething();
@@ -426,7 +425,7 @@ global.MyLibrary.doSomething();
 
 `libraryTarget: "commonjs"` - The **return value of your entry point** will be assigned to the `exports` object using the `output.library` value. As the name implies, this is used in CommonJS environments.
 
-```javascript
+``` js
 exports["MyLibrary"] = _entry_return_;
 
 require("MyLibrary").doSomething();
@@ -439,7 +438,7 @@ These options will result in a bundle that comes with a more complete header to
 
 `libraryTarget: "commonjs2"` - The **return value of your entry point** will be assigned to the `module.exports`. As the name implies, this is used in CommonJS environments:
 
-```javascript
+``` js
 module.exports = _entry_return_;
 
 require("MyLibrary").doSomething();
@@ -456,7 +455,7 @@ AMD modules require that the entry chunk (e.g. the first script loaded by the `<
 
 So, with the following configuration...
 
-```javascript
+``` js
 output: {
   library: "MyLibrary",
   libraryTarget: "amd"
@@ -465,23 +464,23 @@ output: {
 
 The generated output will be defined with the name "MyLibrary", i.e.
 
-```javascript
+``` js
 define("MyLibrary", [], function() {
   // This module return value is what your entry chunk returns
 });
 ```
 
 The bundle can be included as part of a script tag, and the bundle can be invoked like so:
 
-```javascript
+``` js
 require(['MyLibrary'], function(MyLibrary) {
   // Do something with the library...
 });
 ```
 
 If `output.library` is undefined, the following is generated instead.
 
-```javascript
+``` js
 define([], function() {
   // This module returns is what your entry chunk returns
 });
@@ -494,7 +493,7 @@ This bundle will not work as expected, or not work at all (in the case of the al
 
 In this case, you need the `library` property to name your module:
 
-```javascript
+``` js
 output: {
   library: "MyLibrary",
   libraryTarget: "umd"
@@ -503,7 +502,7 @@ output: {
 
 And finally the output is:
 
-```javascript
+``` js
 (function webpackUniversalModuleDefinition(root, factory) {
   if(typeof exports === 'object' && typeof module === 'object')
     module.exports = factory();
@@ -520,15 +519,15 @@ And finally the output is:
 
 Note that omitting `library` will result in the assignment of all properties returned by the entry point be assigned directly to the root object, as documented under the [object assignment section](#exposing-the-library-via-object-assignment). Example:
 
-```javascript
+``` js
 output: {
   libraryTarget: "umd"
 }
 ```
 
 The output will be:
 
-```javascript
+``` js
 (function webpackUniversalModuleDefinition(root, factory) {
   if(typeof exports === 'object' && typeof module === 'object')
     module.exports = factory();
@@ -545,7 +544,7 @@ The output will be:
 
 Since webpack 3.1.0, you may specify an object for `library` for differing names per targets:
 
-```javascript
+``` js
 output: {
   library: {
     root: "MyLibrary",
@@ -653,7 +652,7 @@ publicPath: "", // relative to HTML page (same directory)
 
 In cases where the `publicPath` of output files can't be known at compile time, it can be left blank and set dynamically at runtime in the entry file using the [free variable](http://stackoverflow.com/questions/12934929/what-are-free-variables) `__webpack_public_path__`.
 
-```javascript
+``` js
  __webpack_public_path__ = myRuntimePublicPath
 
 // rest of your application entry