editable_components 0.1.0

data/app/assets/stylesheets/editable_components/medium-editor/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of MediumEditor, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/app/assets/stylesheets/editable_components/medium-editor/CONTRIBUTING.md

@@ -0,0 +1,56 @@
+# Contributing
+
+## To contribute and end up in this [list](https://github.com/yabwe/medium-editor/graphs/contributors):
+
+[Kill some bugs :)](https://github.com/yabwe/medium-editor/issues?q=is%3Aopen+is%3Aissue+label%3Abug)
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Test your changes to the best of your ability.
+4. Update the documentation to reflect your changes if they add or changes current functionality.
+5. Commit your changes (`git commit -am 'Added some feature'`) **without files from the _dist_ directory**.
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create new Pull Request
+
+## Code Consitency
+
+To help create consistent looking code throughout the project, we use a few tools to help us. They have plugins for most popular editors/IDEs to make coding for our project, but you should use them in your project as well!
+
+#### JSHint
+
+We use [JSHint](http://jshint.com/) on each build to find easy-to-catch errors and potential problems in our js.  You can find our JSHint settings in the `.jshintrc` file in the root of the project.
+
+#### jscs
+
+We use [jscs](http://jscs.info/) on each build to enforce some code style rules we have for our project.  You can find our jscs settings in the `.jscsrc` file in the root of the project.
+
+#### EditorConfig
+
+We use [EditorConfig](http://EditorConfig.org) to maintain consistent coding styles between various editors and IDEs.  You can find our settings in the `.editorconfig` file in the root of the project.
+
+## Easy First Bugs
+
+Looking for something simple for a first contribution? Try fixing an [easy first bug](https://github.com/yabwe/medium-editor/issues?q=is%3Aopen+is%3Aissue+label%3A%22easy+first+bug%22)!
+
+## Development
+
+MediumEditor development tasks are managed by Grunt. To install all the necessary packages, just invoke:
+
+```bash
+npm install
+```
+
+To run all the test and build the dist files for testing on demo pages, just invoke:
+```bash
+grunt
+```
+
+These are the other available grunt tasks:
+
+* __js__: runs jslint and jasmine tests and creates minified and concatenated versions of the script;
+* __css__: runs autoprefixer and csslint
+* __test__: runs jasmine tests, jslint and csslint
+* __watch__: watch for modifications on script/scss files
+* __spec__: runs a task against a specified file
+
+The source files are located inside the __src__ directory.  Be sure to make changes to these files and not files in the dist directory.

data/app/assets/stylesheets/editable_components/medium-editor/CUSTOM-EVENTS.md

@@ -0,0 +1,223 @@
+# MediumEditor Custom Events (v5.0.0)
+
+MediumEditor exposes a variety of custom events for convenience when using the editor with your web application.  You can attach and detach listeners to these custom events, as well as manually trigger any custom events including your own custom events.
+
+**NOTE:**
+
+Custom event listeners are triggered in the order that they were 'subscribed' to.  Most functionality within medium-editor uses these custom events to trigger updates, so in general, it can be assumed that most of the built-in functionality has already been completed before any of your custom event listeners will be called.
+
+If you need to override the editor's built-in behavior, try overriding the built-in extensions with your own [custom extension](src/js/extensions).
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+- [API Methods](#api-methods)
+  - [`MediumEditor.subscribe(name, listener)`](#mediumeditorsubscribename-listener)
+  - [`MediumEditor.unsubscribe(name, listener)`](#mediumeditorunsubscribename-listener)
+  - [`MediumEditor.trigger(name, data, editable)`](#mediumeditortriggername-data-editable)
+- [Custom Events](#custom-events)
+  - [`addElement`](#addelement)
+  - [`blur`](#blur)
+  - [`editableInput`](#editableinput)
+  - [`externalInteraction`](#externalinteraction)
+  - [`focus`](#focus)
+  - [`removeElement`](#removeelement)
+- [Toolbar Custom Events](#toolbar-custom-events)
+  - [`hideToolbar`](#hidetoolbar)
+  - [`positionToolbar`](#positiontoolbar)
+  - [`positionedToolbar`](#positionedtoolbar)
+  - [`showToolbar`](#showtoolbar)
+- [Proxied Custom Events](#proxied-custom-events)
+      - [`editableClick`](#editableclick)
+      - [`editableBlur`](#editableblur)
+      - [`editableKeypress`](#editablekeypress)
+      - [`editableKeyup`](#editablekeyup)
+      - [`editableKeydown`](#editablekeydown)
+      - [`editableKeydownEnter`](#editablekeydownenter)
+      - [`editableKeydownTab`](#editablekeydowntab)
+      - [`editableKeydownDelete`](#editablekeydowndelete)
+      - [`editableKeydownSpace`](#editablekeydownspace)
+      - [`editableMouseover`](#editablemouseover)
+      - [`editableDrag`](#editabledrag)
+      - [`editableDrop`](#editabledrop)
+      - [`editablePaste`](#editablepaste)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## API Methods
+
+Use the following methods of [MediumEditor](API.md) for custom event interaction:
+
+### `MediumEditor.subscribe(name, listener)`
+
+Attaches a listener for the specified custom event name.
+
+**Arguments**
+
+1. _**name** (`String`)_:
+
+  * Name of the event to listen to.  See the list of built-in [Custom Events](#custom-events) below.
+
+2. _**listener(data, editable)** (`function`)_:
+
+  * Listener method that will be called whenever the custom event is triggered.
+
+**Arguments to listener**
+
+  1. _**data** (`Event` | `object`)_
+    * For most custom events, this will be the browser's native `Event` object for the event that triggered the custom event to fire.
+    * For some custom events, this will be an object containing information describing the event (depending on which custom event it is)
+  2. _**editable** (`HTMLElement`)_
+    * A reference to the contenteditable container element that this custom event corresponds to.  This is especially useful for instances where one instance of MediumEditor contains multiple elements, or there are multiple instances of MediumEditor on the page.
+    * For example, when `blur` fires, this argument will be the `<div contenteditable=true></div>` element that is about to receive focus.
+
+***
+### `MediumEditor.unsubscribe(name, listener)`
+
+Detaches a custom event listener for the specified custom event name.
+
+**Arguments**
+
+1. _**name** (`String`)_:
+
+  * Name of the event to detach the listener for.
+
+2. _**listener** (`function`)_:
+
+  * A reference to the listener to detach.  This must be a match by-reference and not a copy.
+
+**NOTE**
+
+  * Calling [destroy()](API.md#destroy) on the MediumEditor object will automatically remove all custom event listeners.
+
+***
+### `MediumEditor.trigger(name, data, editable)`
+
+Manually triggers a custom event.
+
+1. _**name** (`String`)_:
+
+  * Name of the custom event to trigger.
+
+2. _**data** (`Event` | `object`)_:
+
+  * Native `Event` object or custom data object to pass to all the listeners to this custom event.
+
+3. _**editable** (`HTMLElement`)_:
+
+  * The `<div contenteditable=true></div>` element to pass to all of the listeners to this custom event.
+
+## Custom Events
+
+These events are custom to MediumEditor so there may be one or more native events that can trigger them.
+
+### `addElement`
+
+`addElement` is triggered whenever an element is added to the editor after the editor has been instantiated.  This custom event will be triggered **after** the element has already been initialized by the editor and added to the internal array of **elements**.  If the element being added was a `<textarea>`, the element passed to the listener will be the created `<div contenteditable=true>` element and not the root `<textarea>`.
+
+**Arguments to listener**
+
+1. _**data** (`object`)_
+  * Properties of data object
+    * `target`: element which was added to the editor
+    * `currentTarget`: element which was added to the editor
+2. _**editable** (`HTMLElement`)_
+  * element which was added to the editor
+
+***
+### `blur`
+
+`blur` is triggered whenever a `contenteditable` element within an editor has lost focus to an element other than an editor maintained element (ie Toolbar, Anchor Preview, etc).
+
+Example:
+
+1. User selects text within an editor element, causing the toolbar to appear
+2. User clicks on a toolbar button
+  * Technically focus may have been lost on the editor element, but since the user is interacting with the toolbar, `blur` is NOT fired.
+3. User hovers over a link, anchor-preview is displayed
+4. User clicks link to edit it, and the toolbar now displays a textbox to edit the url
+  * Focus will have lost here since focus is now in the url editing textbox, but again since it's within the toolbar, `blur` is NOT fired.
+5. User clicks on another part of the page which hides the toolbar and focus is no longer in the `contenteditable`
+6. `blur` is triggered
+
+***
+### `editableInput`
+
+`editableInput` is triggered whenever the content of a `contenteditable` changes, including keypresses, toolbar actions, or any other user interaction that changes the html within the element.  For non-IE browsers, this is just a proxied version of the native `input` event.  However, Internet Explorer and has never supported the `input` event on `contenteditable` elements, and Edge has some support for `input` on `contenteditable` (which may be fixed in upcoming release of Edge) so for these browsers the `editableInput` event is triggered through a combination of:
+* native `keypress` event on the element
+* native `selectionchange` event on the document
+* monitoring calls the `document.execCommand()`
+
+***
+### `externalInteraction`
+
+`externalInteraction` is triggered whenever the user interact with any element outside of the `contenteditable` element or the other elements maintained by the editor (ie Toolbar, Anchor Preview, etc.).  This event trigger regardless of whether an existing `contenteditable` element had focus or not.
+
+***
+### `focus`
+
+`focus` is triggered whenever a `contenteditable` element within an editor receives focus. If the user interacts with any editor maintained elements (ie toolbar), `blur` is NOT triggered because focus has not been lost.  Thus, `focus` will only be triggered when an `contenteditable` element (or the editor that contains it) is first interacted with.
+
+***
+### `removeElement`
+
+`removeElement` is triggered whenever an element is removed from the editor after the editor has been instantiated.  This custom event will be triggered **after** the element has already been removed from the editor and any events attached to it have already been removed.  If the element being removed was a `<div>` created to correspond to a `<textarea>`, the element will already have been removed from the DOM.
+
+**Arguments to listener**
+
+1. _**data** (`object`)_
+  * Properties of data object
+    * `target`: element which was removed from the editor
+    * `currentTarget`: element which was removed from the editor
+2. _**editable** (`HTMLElement`)_
+  * element which was removed from the editor
+
+## Toolbar Custom Events
+
+These events are triggered by the toolbar when the toolbar extension has not been disabled.
+
+### `hideToolbar`
+
+`hideToolbar` is triggered whenever the toolbar was visible and has just been hidden.
+
+### `positionToolbar`
+`positionToolbar` is triggered each time the current selection is checked and the toolbar's position is about to be updated. This event is triggered after all of the buttons have had their state updated, but before the toolbar is moved to the correct location.  This event will be triggered even if nothing will be changed about the toolbar's appearance.
+
+### `positionedToolbar`
+`positionedToolbar` is triggered each time the current selection is checked, the toolbar is displayed, and the toolbar's position was updated. This differs from the `positionToolbar` event in that the visibility and location of the toolbar has already been changed (as opposed to the event triggering before those changes occur). This event will be triggered even if nothing was changed about the toolbar's appearance.
+
+### `showToolbar`
+`showToolbar` is triggered whenever the toolbar was hidden and has just been displayed.
+
+## Proxied Custom Events
+
+These events are triggered whenever a native browser event is triggered for any of the `contenteditable` elements monitored by this instance of MediumEditor.
+
+For example, the `editableClick` custom event will be triggered when a native `click` event is fired on any of the `contenteditable` elements. This provides a single event listener that can get fired for all elements, and also allows for the `contenteditable` element that triggered the event to be passed to the listener.
+
+##### `editableClick`
+native `click` event for each element
+##### `editableBlur`
+native `blur` event for each element.
+##### `editableKeypress`
+native `keypress` event for each element.
+##### `editableKeyup`
+native `keyup` event for each element.
+##### `editableKeydown`
+native `keydown` event for each element.
+##### `editableKeydownEnter`
+native `keydown` event for each element, but only triggered if the key is `ENTER` (keycode 13).
+##### `editableKeydownTab`
+native `keydown` event for each element, but only triggered if the key is `TAB` (keycode 9).
+##### `editableKeydownDelete`
+native `keydown` event for each element, but only triggered if the key is `DELETE` (keycode 46).
+##### `editableKeydownSpace`
+native `keydown` event for each element, but only triggered if the key is `SPACE` (keycode 32).
+##### `editableMouseover`
+native `mouseover` event for each element.
+##### `editableDrag`
+native `drag` event for each element.
+##### `editableDrop`
+native `drop` event for each element.
+##### `editablePaste`
+native `paste` event for each element.

data/app/assets/stylesheets/editable_components/medium-editor/LICENSE

@@ -0,0 +1,36 @@
+Copyright Davi Ferreira, http://www.daviferreira.com/
+
+This software consists of voluntary contributions made by many
+individuals. For exact contribution history, see the revision history
+available at https://github.com/yabwe/medium-editor
+
+The following license applies to all parts of this software except as
+documented below:
+
+====
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+====
+
+All files located in the node_modules directory are
+externally maintained libraries used by this software which have their
+own licenses; we recommend you read them, as their terms may differ from
+the terms above.

data/app/assets/stylesheets/editable_components/medium-editor/MAINTAINERS.md

@@ -0,0 +1,33 @@
+## STEPS TO RELEASE:
+
+1. Find the last release commit in log history. Look through all the commits or PR history and see all the stuff that has happened since the last release.
+2. Add a row describing each high-level change into `CHANGES.md`. Looking at `CHANGES.md` would be a good stepping off point.
+3. Depending upon the changes, decide if it is a major/minor/patch release. _Read more about [semantic versioning](http://semver.org/)_.
+4. Depending upon the type of release, run `grunt major`, `grunt minor`, `grunt patch` to update the version number and generate all the dist files.
+5. Commit all your changes (**including `CHANGES.md`**) into your commit. Add the new release number into your commit message. And push it up to the remote master branch.
+6. Go [here](https://github.com/yabwe/medium-editor/releases) and ‘Draft a new release’. Title the release as the new release number (ex: `5.11.0`). Copy/paste the entries you made in `CHANGES.md` into the release summary. **Make sure the release is against the master branch.**
+7. Once the release is created, go back to your git and run `npm publish`.
+
+
+## RUNNING TESTS FOR FORK BRANCHES IN SAUCELABS:
+
+For pull requests submitted from a forked version of the repo, the test suite won't run in Saucelabs so we haven't been able to know if tests fail in various browsers until after the PR is merged into master.  This is deliberate by Saucelabs as a security measure to prevent external forks from doing malicious things to the repo.
+
+There is a workaround however, so when a PR is submitted from an external fork, follow these steps to verify the tests don't fail in Saucelabs before merging the PR into master.
+
+For this example, let's assume there's a new pull request (#123) from a branch of an external user's fork (external-user/new-branch)
+
+1. Create a new local branch for the pull request
+  * ```git checkout -b integration-123```
+2. Add a remote that points to the external fork
+  * ```git remote add external-user git@github.com:external-user/medium-editor.git```
+3. Fetch the remote repo
+  * ```git fetch external-user```
+4. Merge the external branch into your local branch
+  * ```git merge external-user/new-branch```
+5. Push your local branch up to the main repo
+  * ```git push```
+
+That's it.  Pushing the branch up should kick off a travis build, which will cause the tests to run in Saucelabs.  Github is smart enough to link the existing pull request to that build and reflect the status of the build (including the results from Saucelabs) on the PR summary page!
+
+

data/app/assets/stylesheets/editable_components/medium-editor/OPTIONS.md

@@ -0,0 +1,663 @@
+# MediumEditor Options (v5.0.0)
+
+Options to customize medium-editor are passed as the second argument to the [MediumEditor constructor](API.md#mediumeditorelements-options).  Example:
+
+```js
+var editor = new MediumEditor('.editor', {
+    // options go here
+});
+```
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+
+- [Core Options](#core-options)
+    - [`activeButtonClass`](#activebuttonclass)
+    - [`buttonLabels`](#buttonlabels)
+    - [`contentWindow`](#contentwindow)
+    - [`delay`](#delay)
+    - [`disableReturn`](#disablereturn)
+    - [`disableDoubleReturn`](#disabledoublereturn)
+    - [`disableExtraSpaces`](#disableextraspaces)
+    - [`disableEditing`](#disableediting)
+    - [`elementsContainer`](#elementscontainer)
+    - [`extensions`](#extensions)
+    - [`ownerDocument`](#ownerdocument)
+    - [`spellcheck`](#spellcheck)
+    - [`targetBlank`](#targetblank)
+- [Toolbar options](#toolbar-options)
+    - [`allowMultiParagraphSelection`](#allowmultiparagraphselection)
+    - [`buttons`](#buttons)
+    - [`diffLeft`](#diffleft)
+    - [`diffTop`](#difftop)
+    - [`firstButtonClass`](#firstbuttonclass)
+    - [`lastButtonClass`](#lastbuttonclass)
+    - [`relativeContainer`](#relativecontainer)
+    - [`standardizeSelectionStart`](#standardizeselectionstart)
+    - [`static`](#static)
+  - ['static' Toolbar Options](#static-toolbar-options)
+    - [`align`](#align)
+    - [`sticky`](#sticky)
+    - [`stickyTopOffset`](#stickytopoffset)
+    - [`updateOnEmptySelection`](#updateonemptyselection)
+  - [Disabling Toolbar](#disabling-toolbar)
+- [Anchor Preview options](#anchor-preview-options)
+    - [`hideDelay`](#hidedelay)
+    - [`previewValueSelector`](#previewvalueselector)
+    - [`showOnEmptyLinks`](#showonemptylinks)
+    - [`showWhenToolbarIsVisible`](#showwhentoolbarisvisible)
+  - [Disabling Anchor Preview](#disabling-anchor-preview)
+- [Placeholder Options](#placeholder-options)
+    - [`text`](#text)
+    - [`hideOnClick`](#hideonclick)
+  - [Disabling Placeholders](#disabling-placeholders)
+- [Anchor Form options](#anchor-form-options)
+    - [`customClassOption`](#customclassoption)
+    - [`customClassOptionText`](#customclassoptiontext)
+    - [`linkValidation`](#linkvalidation)
+    - [`placeholderText`](#placeholdertext)
+    - [`targetCheckbox`](#targetcheckbox)
+    - [`targetCheckboxText`](#targetcheckboxtext)
+- [Paste Options](#paste-options)
+    - [`forcePlainText`](#forceplaintext)
+    - [`cleanPastedHTML`](#cleanpastedhtml)
+    - [`cleanReplacements`](#cleanreplacements)
+    - [`cleanAttrs`](#cleanattrs)
+    - [`cleanTags`](#cleantags)
+    - [`unwrapTags`](#unwraptags)
+  - [Disabling Paste Handling](#disabling-paste-handling)
+- [KeyboardCommands Options](#keyboardcommands-options)
+    - [`commands`](#commands)
+  - [Disabling Keyboard Commands](#disabling-keyboard-commands)
+- [Auto Link Options](#auto-link-options)
+    - [`autoLink`](#autolink)
+  - [Enabling Auto Link](#enabling-auto-link)
+- [Image Dragging Options](#image-dragging-options)
+    - [`imageDragging`](#imagedragging)
+  - [Disabling Image Dragging](#disabling-image-dragging)
+- [Options Example:](#options-example)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Core Options
+
+These are global options that apply to the entire editor. Example:
+
+```js
+var editor = new MediumEditor('.editable', {
+    /* These are the default options for the editor,
+        if nothing is passed this is what is used */
+    activeButtonClass: 'medium-editor-button-active',
+    allowMultiParagraphSelection: true,
+    buttonLabels: false,
+    contentWindow: window,
+    delay: 0,
+    disableReturn: false,
+    disableDoubleReturn: false,
+    disableExtraSpaces: false,
+    disableEditing: false,
+    elementsContainer: false,
+    extensions: {},
+    ownerDocument: document,
+    spellcheck: true,
+    targetBlank: false
+});
+```
+
+#### `activeButtonClass`
+**Default:** `'medium-editor-button-active'`
+
+CSS class added to active buttons in the toolbar.
+
+***
+#### `buttonLabels`
+**Default:** `false`
+
+Custom content for the toolbar buttons.
+
+**Valid Values:**
+* `false`
+  * Use default button labels
+* `'fontawesome'`
+  * Uses fontawesome icon set for all toolbar icons
+
+**NOTE**:
+
+Using `'fontawesome'` as the buttonLabels requires version 4.1.0 of the fontawesome css to be on the page to ensure all icons will be displayed correctly.
+
+***
+#### `contentWindow`
+**Default:** `window`
+
+The contentWindow object that contains the contenteditable element. MediumEditor will use this for attaching events, getting selection, etc.
+
+***
+#### `delay`
+**Default:** `0`
+
+Time in milliseconds to show the toolbar or anchor tag preview.
+
+***
+#### `disableReturn`
+**Default:** `false`
+
+Enables/disables the use of the return-key. You can also set specific element behavior by using setting a data-disable-return attribute.
+
+***
+#### `disableDoubleReturn`
+**Default:** `false`
+
+Allows/disallows two (or more) empty new lines. You can also set specific element behavior by using setting a data-disable-double-return attribute.
+
+***
+#### `disableExtraSpaces`
+**Default:** `false`
+
+When set to true, it disallows spaces at the beginning and end of the element. Also it disallows entering 2 consecutive spaces between 2 words.
+
+***
+#### `disableEditing`
+**Default:** `false`
+
+Enables/disables adding the contenteditable behavior. Useful for using the toolbar with customized buttons/actions. You can also set specific element behavior by using setting a data-disable-editing attribute.
+
+***
+#### `elementsContainer`
+**Default:** `ownerDocument.body`
+
+Specifies a DOM node to contain MediumEditor's toolbar and anchor preview elements.
+
+***
+#### `extensions`
+**Default:** `{}`
+
+Custom extensions to use. See [Custom Buttons and Extensions](src/js/extensions) for more details on extensions.
+
+***
+#### `ownerDocument`
+**Default:** `window.document`
+
+The ownerDocument object for the contenteditable element.  MediumEditor will use this for creating elements, getting selection, attaching events, etc.
+
+***
+#### `spellcheck`
+**Default:** `true`
+
+Enable/disable native contentEditable automatic spellcheck.
+
+***
+#### `targetBlank`
+**Default:** `false`
+
+Enables/disables automatically adding the `target="_blank"` attribute to anchor tags.
+
+## Toolbar options
+
+The toolbar for MediumEditor is implemented as a built-in extension which automatically displays whenever the user selects some text.  The toolbar can hold any set of defined built-in buttons, but can also hold any custom buttons passed in as extensions.
+
+Options for the toolbar are passed as an object that is a member of the outer options object. Example:
+```js
+var editor = new MediumEditor('.editable', {
+    toolbar: {
+        /* These are the default options for the toolbar,
+           if nothing is passed this is what is used */
+        allowMultiParagraphSelection: true,
+        buttons: ['bold', 'italic', 'underline', 'anchor', 'h2', 'h3', 'quote'],
+        diffLeft: 0,
+        diffTop: -10,
+        firstButtonClass: 'medium-editor-button-first',
+        lastButtonClass: 'medium-editor-button-last',
+        relativeContainer: null,
+        standardizeSelectionStart: false,
+        static: false,
+
+        /* options which only apply when static is true */
+        align: 'center',
+        sticky: false,
+        updateOnEmptySelection: false
+    }
+});
+```
+
+***
+#### `allowMultiParagraphSelection`
+**Default:** `true`
+
+enables/disables whether the toolbar should be displayed when selecting multiple paragraphs/block elements.
+
+***
+#### `buttons`
+**Default:** `['bold', 'italic', 'underline', 'anchor', 'h2', 'h3', 'quote']`
+
+The set of buttons to display on the toolbar.
+
+***
+#### `diffLeft`
+**Default:** `0`
+
+Value in pixels to be added to the X axis positioning of the toolbar.
+
+***
+#### `diffTop`
+**Default:** `-10`
+
+Value in pixels to be added to the Y axis positioning of the toolbar.
+
+***
+#### `firstButtonClass`
+**Default:** `'medium-editor-button-first'`
+
+CSS class added to the first button in the toolbar.
+
+***
+#### `lastButtonClass`
+**Default:** `'medium-editor-button-last'`
+
+CSS class added to the last button in the toolbar.
+
+***
+#### `relativeContainer`
+**Default:** `null`
+
+DOMElement to append the toolbar to instead of the body.  When an element is passed the toolbar will also be positioned `relative` instead of `absolute`, which means the editor will not attempt to manually position the toolbar automatically.
+
+**NOTE:**
+* Using this in combination with the `static` option for toolbar is not explicitly supported and the behavior in this case is not defined.
+
+***
+#### `standardizeSelectionStart`
+**Default:** `false`
+
+Enables/disables standardizing how the beginning of a range is decided between browsers whenever the selected text is analyzed for updating toolbar buttons status.
+
+***
+#### `static`
+**Default:** `false`
+
+Enable/disable the toolbar always displaying in the same location relative to the medium-editor element.
+
+
+### 'static' Toolbar Options
+
+These options only apply when the `static` option is being used.
+
+***
+#### `align`
+**Default:** `center`
+
+When the __static__ option is `true`, this aligns the static toolbar relative to the medium-editor element.
+
+**Valid Values**
+
+`'left'` | `'center'` | `'right'`
+
+***
+#### `sticky`
+**Default:** `false`
+
+When the __static__ option is `true`, this enables/disables the toolbar "sticking" to the viewport and staying visible on the screen while the page scrolls.
+
+***
+#### `stickyTopOffset`
+**Default:** `0`
+
+When the __sticky__ option is `true`, this set in pixel a top offset above the toolbar.
+
+***
+#### `updateOnEmptySelection`
+**Default:** `false`
+
+When the __static__ option is `true`, this enables/disables updating the state of the toolbar buttons even when the selection is collapsed (there is no selection, just a cursor).
+
+### Disabling Toolbar
+
+To disable the toolbar (which also disables the anchor-preview extension), set the value of the `toolbar` option to `false`:
+```javascript
+var editor = new MediumEditor('.editable', {
+    toolbar: false
+});
+```
+
+
+## Anchor Preview options
+
+The anchor preview is a built-in extension which automatically displays a 'tooltip' when the user is hovering over a link in the editor.  The tooltip will display the `href` of the link, and when click, will open the anchor editing form in the toolbar.
+
+Options for the anchor preview 'tooltip' are passed as an object that is a member of the outer options object. Example:
+```javascript
+var editor = new MediumEditor('.editable', {
+    anchorPreview: {
+        /* These are the default options for anchor preview,
+           if nothing is passed this is what it used */
+        hideDelay: 500,
+        previewValueSelector: 'a'
+    }
+}
+});
+```
+
+
+***
+#### `hideDelay`
+**Default:** `500`
+
+Time in milliseconds to show the anchor tag preview after the mouse has left the anchor tag.
+
+***
+#### `previewValueSelector`
+**Default:** `'a'`
+
+The default selector to locate where to put the activeAnchor value in the preview. You should only need to override this if you've modified the way in which the anchor-preview extension renders.
+
+***
+#### `showOnEmptyLinks`
+**Default:** `true`
+
+Determines whether the anchor tag preview shows up on link with href as "" or "#something". You should set this value to false if you do not want the preview to show up in such use cases.
+
+***
+#### `showWhenToolbarIsVisible`
+**Default:** `false`
+
+Determines whether the anchor tag preview shows up when the toolbar is visible. You should set this value to true if the static option for the toolbar is true and you want the preview to show at the same time.
+
+### Disabling Anchor Preview
+
+To disable the anchor preview, set the value of the `anchorPreview` option to `false`:
+```javascript
+var editor = new MediumEditor('.editable', {
+    anchorPreview: false
+});
+```
+
+**NOTE:**
+
+* If the toolbar is disabled (via `toolbar: false` option or `data-disable-toolbar` attribute) the anchor-preview is automatically disabled.
+* If the anchor editing form is not enabled, clicking on the anchor-preview will not allow the href of the link to be edited
+
+## Placeholder Options
+
+The placeholder handler is a built-in extension which displays placeholder text when the editor is empty.
+
+Options for placeholder are passed as an object that is a member of the outer options object. Example:
+```javascript
+var editor = new MediumEditor('.editable', {
+    placeholder: {
+        /* This example includes the default options for placeholder,
+           if nothing is passed this is what it used */
+        text: 'Type your text',
+        hideOnClick: true
+    }
+});
+```
+
+
+***
+#### `text`
+**Default:** `'Type your text'`
+
+Defines the default placeholder for empty contenteditables when __placeholder__ is not set to false. You can overwrite it by setting a `data-placeholder` attribute on the editor elements.
+
+***
+#### `hideOnClick`
+**Default:** `true`
+
+Causes the placeholder to disappear as soon as the field gains focus. To hide the placeholder only after starting to type, and to show it again as soon as field is empty, set this option to `false`.
+
+
+### Disabling Placeholders
+
+To disable the placeholder, set the value of the `placeholder` option to `false`:
+```javascript
+var editor = new MediumEditor('.editable', {
+    placeholder: false
+});
+```
+
+## Anchor Form options
+
+The anchor form is a built-in button extension which allows the user to add/edit/remove links from within the editor.  When 'anchor' is passed in as a button in the list of buttons, this extension will be enabled and can be triggered by clicking the corresponding button in the toolbar.
+
+Options for the anchor form are passed as an object that is a member of the outer options object. Example:
+```javascript
+var editor = new MediumEditor('.editable', {
+    toolbar: {
+        buttons: ['bold', 'italic', 'underline', 'anchor']
+    },
+    anchor: {
+        /* These are the default options for anchor form,
+           if nothing is passed this is what it used */
+        customClassOption: null,
+        customClassOptionText: 'Button',
+        linkValidation: false,
+        placeholderText: 'Paste or type a link',
+        targetCheckbox: false,
+        targetCheckboxText: 'Open in new window'
+    }
+}
+});
+```
+
+
+***
+#### `customClassOption`
+**Default:** `null`
+
+Custom class name the user can optionally have added to their created links (ie 'button').  If passed as a non-empty string, a checkbox will be displayed allowing the user to choose whether to have the class added to the created link or not.
+
+***
+#### `customClassOptionText`
+**Default:** `'Button'`
+
+Text to be shown in the checkbox when the __customClassOption__ is being used.
+
+***
+#### `linkValidation`
+**Default:** `false`
+
+Enables/disables check for common URL protocols on anchor links. Converts invalid url characters (ie spaces) to valid characters using `encodeURI`
+
+***
+#### `placeholderText`
+**Default:** `'Paste or type a link'`
+
+Text to be shown as placeholder of the anchor input.
+
+***
+#### `targetCheckbox`
+**Default:** `false`
+
+Enables/disables displaying a "Open in new window" checkbox, which when checked changes the `target` attribute of the created link.
+
+***
+#### `targetCheckboxText`
+**Default:** `'Open in new window'`
+
+Text to be shown in the checkbox enabled via the __targetCheckbox__ option.
+
+## Paste Options
+
+The paste handler is a built-in extension which attempts to filter the content when the user pastes.  How the paste handler filters is configurable via specific options.
+
+Options for paste handling are passed as an object that is a member of the outer options object. Example:
+```javascript
+var editor = new MediumEditor('.editable', {
+    paste: {
+        /* This example includes the default options for paste,
+           if nothing is passed this is what it used */
+        forcePlainText: true,
+        cleanPastedHTML: false,
+        cleanReplacements: [],
+        cleanAttrs: ['class', 'style', 'dir'],
+        cleanTags: ['meta']
+    }
+});
+```
+
+
+***
+#### `forcePlainText`
+**Default:** `true`
+
+Forces pasting as plain text.
+
+***
+#### `cleanPastedHTML`
+**Default:** `false`
+
+Cleans pasted content from different sources, like google docs etc.
+
+***
+#### `cleanReplacements`
+**Default:** `[]`
+
+Custom pairs (2 element arrays) of RegExp and replacement text to use during paste when __forcePlainText__ or __cleanPastedHTML__ are `true` OR when calling `cleanPaste(text)` helper method.
+
+***
+#### `cleanAttrs`
+**Default:** `['class', 'style', 'dir']`
+
+List of element attributes to remove during paste when __cleanPastedHTML__ is `true` or when calling `cleanPaste(text)` or `pasteHTML(html,options)` helper methods.
+
+***
+#### `cleanTags`
+**Default:** `['meta']`
+
+List of element tag names to remove during paste when __cleanPastedHTML__ is `true` or when calling `cleanPaste(text)` or `pasteHTML(html,options)` helper methods.
+
+***
+#### `unwrapTags`
+**Default:** `[]`
+
+List of element tag names to unwrap (remove the element tag but retain its child elements) during paste when __cleanPastedHTML__ is `true` or when calling `cleanPaste(text)` or `pasteHTML(html,options)` helper methods.
+
+***
+### Disabling Paste Handling
+
+To disable MediumEditor manipulating pasted content, set the both the `forcePlainText` and `cleanPastedHTML` options to `false`:
+```javascript
+var editor = new MediumEditor('.editable', {
+    paste: {
+        forcePlainText: false,
+        cleanPastedHTML: false
+    }
+});
+```
+
+## KeyboardCommands Options
+
+The keyboard commands handler is a built-in extension for mapping key-combinations to actions to execute in the editor.
+
+Options for KeyboardCommands are passed as an object that is a member of the outer options object. Example:
+```javascript
+var editor = new MediumEditor('.editable', {
+    keyboardCommands: {
+        /* This example includes the default options for keyboardCommands,
+           if nothing is passed this is what it used */
+        commands: [
+            {
+                command: 'bold',
+                key: 'b',
+                meta: true,
+                shift: false
+            },
+            {
+                command: 'italic',
+                key: 'i',
+                meta: true,
+                shift: false
+            },
+            {
+                command: 'underline',
+                key: 'u',
+                meta: true,
+                shift: false
+            }
+        ],
+    }
+});
+```
+
+
+***
+#### `commands`
+**Default:** shortcuts for `bold`, `italic`, and `underline` (See above example)
+
+Array of objects describing each command and the combination of keys that will trigger it.  Required for each object:
+  * _command_: argument passed to `editor.execAction()` when key-combination is used
+  * _key_: keyboard character that triggers this command
+  * _meta_: whether the ctrl/meta key has to be active or inactive
+  * _shift_: whether the shift key has to be active or inactive
+
+### Disabling Keyboard Commands
+
+To disable the keyboard commands, set the value of the `keyboardCommands` option to `false`:
+```javascript
+var editor = new MediumEditor('.editable', {
+    keyboardCommands: false
+});
+```
+
+## Auto Link Options
+
+#### `autoLink`
+**Default:** `false`
+
+The auto-link handler is a built-in extension which automatically turns URLs entered into the text field into HTML anchor tags (similar to the functionality of Markdown).  This feature is OFF by default.
+
+### Enabling Auto Link
+
+To enable built-in auto-link support, set the value of the `autoLink` option to `true`:
+
+```javascript
+var editor = new MediumEditor('.editable', {
+    autoLink: true
+});
+```
+
+## Image Dragging Options
+
+#### `imageDragging`
+**Default:** `true`
+
+The image dragging handler is a built-in extension for handling dragging & dropping images into the contenteditable.  This feature is ON by default.
+
+### Disabling Image Dragging
+
+To disable built-in image dragging, set the value of the `imageDragging` option to `false`:
+```javascript
+var editor = new MediumEditor('.editable', {
+    imageDragging: false
+});
+```
+
+## Options Example:
+
+```javascript
+var editor = new MediumEditor('.editable', {
+    delay: 1000,
+    targetBlank: true,
+    toolbar: {
+        buttons: ['bold', 'italic', 'quote'],
+        diffLeft: 25,
+        diffTop: 10,
+    },
+    anchor: {
+        placeholderText: 'Type a link',
+        customClassOption: 'btn',
+        customClassOptionText: 'Create Button'
+    },
+    paste: {
+        cleanPastedHTML: true,
+        cleanAttrs: ['style', 'dir'],
+        cleanTags: ['label', 'meta']
+    },
+    anchorPreview: {
+        hideDelay: 300
+    },
+    placeholder: {
+        text: 'Click to edit'
+    }
+});
+```