Add files using upload-large-folder tool

.local/share/jupyter/nbextensions/code_prettify/README_2to3.md

@@ -0,0 +1,139 @@
+A 2to3 converter
+================
+
+This nbextension converts python2 code in notebook code cells to python3 code.
+
+Under the hood, it uses a call to the current notebook kernel to reformat the
+code.
+The conversion run by the kernel uses Python's standard-library [lib2to3]
+module.
+
+The nbextension provides
+
+- a toolbar button (configurable to be added or not)
+
+- a keyboard shortcut for reformatting the current code-cell (default shortcut
+  is `Ctrl-M`, can also be configured not to add the keyboard shortcut).
+
+- a keyboard shortcut for reformatting the whole notebook (default shortcut
+  is `Ctrl-Shift-M`, can also be configured not to add the keyboard shortcut).
+
+Syntax needs to be correct, but the nbextension may be able to point out basic
+syntax errors.
+
+![](demo_2to3.gif)
+
+
+Options
+-------
+
+All options are provided by the [KerneExecOnCells library] - see the
+[internals] section below for details.
+There are a few nbextension-wide options, configurable using the
+[jupyter_nbextensions_configurator] or by editing the `notebook` section config
+file directly.
+The options are as follows:
+
+- `2to3.add_toolbar_button`:
+  Whether to add a toolbar button to transform the selected cell(s).
+  Defaults to `true`.
+
+- `2to3.button_icon`:
+  A font-awesome class defining the icon used for the toolbar button and
+  actions. See [fontawesome] for available icon classes.
+  Defaults to `fa-legal`.
+
+- `2to3.button_label`:
+  Toolbar button label text. Also used in the actions' help text.
+  Defaults to `Convert Python 2 to 3`.
+
+- `2to3.register_hotkey`:
+  Whether to register hotkeys to transform the selected cell(s)/whole notebook.
+  Defaults to `true`.
+
+- `2to3.hotkeys.process_all`:
+  Hotkey to use to transform all the code cells in the notebook.
+  Defaults to `Ctrl-Shift-L`.
+
+- `2to3.hotkeys.process_selected`:
+  Hotkey to use to transform the selected cell(s).
+  Defaults to `Ctrl-L`.
+
+- `2to3.show_alerts_for_not_supported_kernel`:
+  Whether to show alerts if the kernel is not supported.
+  Defaults to `false`.
+
+- `2to3.show_alerts_for_errors`:
+  Whether to show alerts for errors in the kernel calls.
+  Defaults to `true`.
+
+- `2to3.kernel_config_map_json`:
+  The value of this key is a string which can be parsed into a json object
+  giving the config for each kernel language.
+
+  The following give the per-kernel options of the parsed json, using the
+  language key `python `:
+
+  * `2to3.kernel_config_map_json.python.library`:
+    String to execute in the kernel in order to load any necessary kernel
+    libraries.
+
+  * `2to3.kernel_config_map_json.python.replacements_json_to_kernel`:
+    a list of pairs of strings, used as arguments to javascript's
+    `String.replace(from, to)` to translate from a json string into a valid
+    representation of the same string in the kernel language. Since json
+    strings are particularly simple, this can often (as with the python
+    language) be left as the default, an empty list.
+
+  * `2to3.kernel_config_map_json.python.prefix` and
+    `2to3.kernel_config_map_json.python.postfix`:
+    Strings added as bookends to the kernel string (translated from the json
+    string using the replacements above) to make up the kernel prettifier call
+    kernel's prettifier libraries.
+
+  * `2to3.kernel_config_map_json.python.trim_formatted_text`:
+    Whether to trim whitespace from the transformed cell text. Since jupyter
+    cells don't usually have leading or trailing whitespace, the default
+    behaviour is to trim the transformed text, in order to prevent the
+    transform adding extra newlines at the end (a common behaviour for source
+    files, where having a trailing newline is often considered good practice).
+
+
+Internals
+---------
+
+Under the hood, this nbextension uses the [KerneExecOnCells library], a shared
+library for creating Jupyter nbextensions which transform code cell text using
+calls to the active kernel.
+
+See the [shared README] for the internal model used by the nbextension.
+
+History
+-------
+
+The project was forked by [@EWouters] from [@jfbercher]'s [code_prettify],
+retaining most of the code.
+
+It has since been altered to use the [KerneExecOnCells library], a shared
+library for creating Jupyter nbextensions which transform code cell text using
+calls to the active kernel.
+
+The 2to3 conversion's kernel-side python code is based on [2to3_nb.py] by
+[@takluyver] and [@fperez].
+
+It could be extended to use the [futurize] functions so it can convert both
+ways.
+
+[2to3_nb.py]: https://gist.github.com/takluyver/c8839593c615bb2f6e80
+[@EWouters]: https://github.com/EWouters
+[@fperez]: https://github.com/fperez
+[@jfbercher]: https://github.com/jfbercher
+[@takluyver]: https://github.com/takluyver
+[code_prettify]: https://github.com/jfbercher/code_prettify
+[futurize]: http://python-future.org/automatic_conversion.html
+[fontawesome]: https://fontawesome.com/icons
+[internals]: #Internals
+[jupyter_nbextensions_configurator]: https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator
+[KerneExecOnCells library]: README.md
+[lib2to3]: https://docs.python.org/3/library/2to3.html#module-lib2to3
+[shared README]: README.md

.local/share/jupyter/nbextensions/code_prettify/README_code_prettify.md

@@ -0,0 +1,300 @@
+A Code Prettifier
+=================
+
+This nbextension reformats/prettifies code in notebook code cells.
+
+Under the hood, it uses a call to the current notebook kernel to reformat the
+code.
+Thus the actual prettifier package has to be callable from the current kernel
+language.
+
+With an appropriately-configured prettifier for the kernel in use, the
+nbextension provides
+
+- a toolbar button (configurable to be added or not)
+
+- a keyboard shortcut for reformatting the current code-cell (default shortcut
+  is `Ctrl-L`, can also be configured not to add the keyboard shortcut).
+
+- a keyboard shortcut for reformatting the whole notebook (default shortcut
+  is `Ctrl-Shift-L`, can also be configured not to add the keyboard shortcut).
+
+Syntax shall be correct. The nbextension may also point out basic syntax errors.
+
+![](demo-py.gif)
+![](demo-R.gif)
+![](demo-jv.gif)
+
+
+Compatible Kernels
+------------------
+
+Example implementations are provided for prettifiers for ipython, ir and
+ijavascript kernels which should work out of the box (assuming availability of
+the relevant kernel-specific [prerequisites] mentioned below), but the
+kernel-specific prettifier calls are configurable, so the model is applicable
+to essentially any kernel language and prettifier library.
+
+Other languages may be added as defaults in the future, but given that there
+are more than 50 [kernels] available for Jupyter, it is not easily possible to
+support all of them out of the box, unless people with experience in the
+relevant kernels have the time to contribute code. For information on how the
+reformatting takes place, and how to adapt it for your particular
+kernel/prettifier, see the [options] and [internals] sections below.
+If you implement a language that isn't yet provided by default, please submit a
+PR or let us know to add it to the repo :)
+
+Under the hood, this nbextension's functionality is provided by the
+[KerneExecOnCells library], a shared library for creating Jupyter nbextensions
+which transform code cell text using calls to the active kernel.
+
+
+Prerequisites
+-------------
+
+Of course, you must have the necessary kernel-specific packages installed for
+the prettifier call to work:
+
+- for the default python implementation, the [yapf] module is required:
+
+        pip install yapf
+
+  Others you might consider using include [autopep8] - see [README_autopep8.md].
+
+- for R, the default implementation uses the [formatR] and [jsonlite] packages:
+
+  ```r
+  install.packages(c("formatR", "jsonlite"), repos="http://cran.rstudio.com")
+  ```
+
+- for [ijavascript], the [js-beautify] package is used:
+  (*Under linux, in the root of your user tree = ~*)
+
+      npm install js-beautify
+
+  Under Windows, you may then need to set the `NODE_PATH` environment variable
+  (see [this question on stackoverflow]) to it to `%AppData%\npm\node_modules`
+  (Windows 7/8/10).
+  To be done with it once and for all, add this as a System variable in the
+  Advanced tab of the System Properties dialog.
+
+
+Options
+-------
+
+All options are provided by the [KerneExecOnCells library]. - see the
+[internals] section below for details.
+There are a few nbextension-wide options, configurable using the
+[jupyter_nbextensions_configurator] or by editing the `notebook` section config
+file directly.
+The options are as follows:
+
+- `code_prettify.add_toolbar_button`:
+  Whether to add a toolbar button to transform the selected cell(s).
+  Defaults to `true`.
+
+- `code_prettify.button_icon`:
+  A font-awesome class defining the icon used for the toolbar button and
+  actions. See [fontawesome] for available icon classes.
+  Defaults to `fa-legal`.
+
+- `code_prettify.button_label`:
+  Toolbar button label text. Also used in the actions' help text.
+  Defaults to `Code prettify`.
+
+- `code_prettify.register_hotkey`:
+  Whether to register hotkeys to transform the selected cell(s)/whole notebook.
+  Defaults to `true`.
+
+- `code_prettify.hotkeys.process_all`:
+  Hotkey to use to transform all the code cells in the notebook.
+  Defaults to `Ctrl-Shift-L`.
+
+- `code_prettify.hotkeys.process_selected`:
+  Hotkey to use to transform the selected cell(s).
+  Defaults to `Ctrl-L`.
+
+- `code_prettify.show_alerts_for_not_supported_kernel`:
+  Whether to show alerts if the kernel is not supported.
+  Defaults to `false`.
+
+- `code_prettify.show_alerts_for_errors`:
+  Whether to show alerts for errors in the kernel calls.
+  Defaults to `true`.
+
+- `code_prettify.kernel_config_map_json`:
+  The value of this key is a string which can be parsed into a json object
+  giving the config for each kernel language.
+
+  The following give the per-kernel options of the parsed json, using the
+  language key `python `:
+
+  * `code_prettify.kernel_config_map_json.python.library`:
+    String to execute in the kernel in order to load any necessary kernel
+    libraries.
+
+  * `code_prettify.kernel_config_map_json.python.replacements_json_to_kernel`:
+    a list of pairs of strings, used as arguments to javascript's
+    `String.replace(from, to)` to translate from a json string into a valid
+    representation of the same string in the kernel language. Since json
+    strings are particularly simple, this can often (as with the python
+    language) be left as the default, an empty list.
+
+  * `code_prettify.kernel_config_map_json.python.prefix` and
+    `code_prettify.kernel_config_map_json.python.postfix`:
+    Strings added as bookends to the kernel string (translated from the json
+    string using the replacements above) to make up the kernel prettifier call
+    kernel's prettifier libraries.
+
+  * `code_prettify.kernel_config_map_json.python.trim_formatted_text`:
+    Whether to trim whitespace from the transformed cell text. Since jupyter
+    cells don't usually have leading or trailing whitespace, the default
+    behaviour is to trim the transformed text, in order to prevent the
+    transform adding extra newlines at the end (a common behaviour for source
+    files, where having a trailing newline is often considered good practice).
+
+
+Internals
+---------
+
+Under the hood, this nbextension uses the [KerneExecOnCells library], a shared
+library for creating Jupyter nbextensions which transform code cell text using
+calls to the active kernel.
+
+The model is essentially:
+
+1.  The cell text is grabbed by client-side javascript, then turned into a json
+    string using javascript `JSON.stringify`. Since json-compatible strings are
+    a particularly simple string format, which is compatible with many other
+    programming languages without much modification (e.g. a valid json string
+    is also a valid string in python 3, and also in python 2 when prefixed with
+    a `u`), and easily converted for use in others (because of its simplicity).
+
+2.  Optional regex replacements are used to translate the json-format string
+    into a valid kernel string. Python, R and javascript don't require this
+    step, but other  languages may do, so it's implemented for flexibility
+    using the per-kernel config key `replacements_json_to_kernel`, which is a
+    list of pairs of arguments to javascript `String.replace`.
+
+3.  The kernel-specific prettifier call is then composed from
+    `kernel_config.prefix` + `kernel_text_string` + `kernel_config.postfix` and
+    sent to the kernel for execution. This kernel call is expected to get the
+    formatted cell text _printed_ as a json-compatible string. Since most
+    kernel languages have json packages, this should hopefully be easy to
+    arrange. The reason for the printing text rather than simply displaying it,
+    is that it prevents us having to translate from a kernel string
+    representing a json string.
+
+4.  The callback for the kernel execution in client-side javascript parses the
+    printed json-format string, optionally trims trailing whitespace according
+    to the `trim_formatted_text` key (which defaults to `true`) in the
+    per-kernel config, and then sets the cell text using the result.
+
+The process is probably best illustrated using an example for the python
+implementation:
+
+1.  **At nbextension load**, the `code_prettify.kernel_config_map_json` config
+    option is parsed to give the json object
+
+    ```json
+    {
+      "python": {
+        "library": "import json\nimport yapf.yapflib.yapf_api",
+        "prefix": "print(json.dumps(yapf.yapflib.yapf_api.FormatCode(u",
+        "postfix": ")[0]))"
+      }
+    }
+    ```
+
+    (other kernel languages are omitted for clarity).
+
+2.  **On kernel becoming ready**, the nbextension looks up the config for the
+    kernel's language (in our example, this is the `python` key of the kernel
+    config json object above). It then sends the kernel config's `library`
+    string to the kernel for execution. Thus the python implementation above
+    executes
+
+    ```python
+    import json
+    import yapf.yapflib.yapf_api
+    ```
+
+3.  **On requesting a cell be prettified** which can happen by clicking the
+    toolbar, or with a (configurable) hotkey, the following happens:
+
+    Say the cell to be formatted contains the following ugly python code:
+
+    ```python
+    msg= 'hello '+"world"
+    print  (
+                        msg    )
+    ```
+
+    Then the result of the `JSON.stringify` call will be a string containing
+
+    ```json
+    "msg= 'hello '+\"world\"\nprint  (\n                    msg    )"
+    ```
+
+    (note the opening and closing quotes). Concatenating this with the prefix &
+    postfix strings from the python kernel config above, gives us the kernel
+    code to execute. The call sent to the python kernel is therefore
+
+    ```python
+    print(json.dumps(yapf.yapflib.yapf_api.FormatCode(u"msg= 'hello '+\"world\"\nprint  (\n                    msg    )")[0]))
+    ```
+
+4.  What gets 'printed' by the kernel (i.e. returned to the javascript stream
+    callback) is the following json-format string:
+
+    ```json
+    "msg = 'hello ' + \"world\"\nprint(msg)\n"
+    ```
+
+    The default is to trim whitepace from the returned prettified text, which
+    results in the final prettified python code for the cell:
+
+    ```python
+    msg = 'hello ' + "world"
+    print(msg)
+    ```
+
+
+History
+-------
+
+- [@jfbercher], august 14, 2016, first version, named `yapf_ext`
+- [@jfbercher], august 19, 2016, second version `code_prettify`
+  - introduced support for R and javascript.
+  - changed extension name from `yapf_ext` to `code_prettify`
+- [@jcb91], december 2016
+  - made addition of toolbar button & hotkey configurable
+  - reworked to avoid regex replacements for conversion to/from kernel string
+    formats, in favour of json-string interchange
+  - made kernel-specific prettifier calls configurable, allowing support for
+    different prettifiers & arbitrary kernels
+  - improved documentation
+- [@jfbercher], december 2016-january 2017
+  - added a configurable shortkey to reflow the whole notebook
+  - extracted most of the code to build a general library of functions,
+    `kernel_exec_on_cell.js`, which can be used for all nbextensions which
+    needs to exec some code (via the current kernel) on the text from cells.
+
+
+[@jcb91]: https://github.com/jcb91
+[@jfbercher]: https://github.com/jfbercher
+[autopep8]: https://github.com/hhatto/autopep8
+[formatR]: https://yihui.name/formatr
+[fontawesome]: https://fontawesome.com/icons
+[ijavascript]: https://n-riesco.github.io/ijavascript
+[internals]: #Internals
+[js-beautify]: https://github.com/beautify-web/js-beautify
+[jsonlite]: https://github.com/jeroen/jsonlite
+[jupyter_nbextensions_configurator]: https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator
+[KerneExecOnCells library]: README.md
+[kernels]: https://github.com/ipython/ipython/wiki/IPython-kernels-for-other-languages
+[options]: #Options
+[prerequisites]: #Prerequisites
+[README_autopep8.md]: README_autopep8.md
+[this question on stackoverflow]: https://stackoverflow.com/questions/9587665/nodejs-cannot-find-installed-module-on-windows
+[yapf]: https://github.com/google/yapf

.local/share/jupyter/nbextensions/codefolding/edit.js

@@ -0,0 +1,4 @@
+define(['./main'], function (codefolding) {
+    "use strict";
+    return codefolding;
+});

.local/share/jupyter/nbextensions/codefolding/foldgutter.css

@@ -0,0 +1,5 @@
+.CodeMirror-foldgutter {
+  width: .9em;
+}
+
+

.local/share/jupyter/nbextensions/codemirror_mode_extensions/codemirror_mode_extensions.yaml

@@ -0,0 +1,7 @@
+Type: Jupyter Notebook Extension
+Name: CodeMirror mode extensions
+Description: |
+  Extends some CodeMirror modes with extra features. Currently just adds
+  support for comment/uncomment and folding for octave/MATLAB mode.
+Main: main.js
+Compatibility: 4.x

.local/share/jupyter/nbextensions/collapsible_headings/main.css

@@ -0,0 +1,130 @@
+.collapsible_headings_toggle .h1 {
+  font-size: 185.7%;
+  margin: 0.538em 0 0 0;
+  line-height: 1.0;
+}
+.collapsible_headings_toggle .h2 {
+  font-size: 157.1%;
+  margin: 0.636em 0 0 0;
+  line-height: 1.0;
+}
+.collapsible_headings_toggle .h3 {
+  font-size: 128.6%;
+  margin: 0.777em 0 0 0;
+  line-height: 1.0;
+}
+.collapsible_headings_toggle .h4,
+.collapsible_headings_toggle .h5,
+.collapsible_headings_toggle .h6 {
+  font-size: 100%;
+  margin: 1em 0 0 0;
+  line-height: 1.0;
+}
+
+.collapsible_headings_toggle.btn .h1,
+.collapsible_headings_toggle.btn .h2,
+.collapsible_headings_toggle.btn .h3,
+.collapsible_headings_toggle.btn .h4,
+.collapsible_headings_toggle.btn .h5,
+.collapsible_headings_toggle.btn .h6 {
+  margin-top: 0;
+}
+
+.collapsible_headings_toggle .fa {
+	transition: transform 400ms;
+
+  /* don't support IE filter, since can't rotate 360 */
+	-webkit-transform: rotate(360deg);
+	-moz-transform: rotate(360deg);
+	-ms-transform: rotate(360deg);
+	-o-transform: rotate(360deg);
+	transform: rotate(360deg);
+}
+
+.collapsible_headings_collapsed .fa {
+	-webkit-transform: none;
+	-moz-transform: none;
+	-ms-transform: none;
+	-o-transform: none;
+	transform: none;
+}
+
+/* bracket rules */
+
+div.cell {
+  position: relative;
+}
+
+.chb {
+  position: absolute;
+  top: -1px;
+  bottom: -1px;
+  left: calc(100% + 3px);
+  display: flex;
+  flex-direction: row-reverse;
+  justify-content: flex-start;
+  align-items: stretch;
+}
+
+.chb div {
+  margin-left: 2px;
+  width: 5px;
+  border-color: #aaa;
+  border-left-color: transparent;
+  border-style: solid;
+  border-width: 0 2px 0 2px;
+}
+
+.collapsible_headings_collapsed .chb .chb-start {
+  border-width: 5px 2px 2px 4px;
+}
+
+.chb div:hover, 
+.chb .chb-hover, 
+.jupyter-soft-selected .chb div{
+    border-color:  #42A5F5;
+    border-left-color: transparent;
+	  border-width: 0 3px 0 0;
+}
+
+.chb .chb-start {
+  border-top-width: 1px;
+  margin-top: 2px;
+}
+
+.chb .chb-end {
+  border-bottom-width: 1px;
+  margin-bottom: 2px;
+}
+
+.chb-start div:hover, .chb .chb-start.chb-hover, .jupyter-soft-selected .chb .chb-start {
+  border-top-width: 2px;
+}
+
+.chb-end div:hover, .chb .chb-end.chb-hover, .jupyter-soft-selected .chb .chb-end {
+  border-bottom-width: 2px;
+}
+
+/* ellipsis rules */
+.collapsible_headings_ellipsis .rendered_html h1,
+.collapsible_headings_ellipsis .rendered_html h2,
+.collapsible_headings_ellipsis .rendered_html h3,
+.collapsible_headings_ellipsis .rendered_html h4,
+.collapsible_headings_ellipsis .rendered_html h5,
+.collapsible_headings_ellipsis .rendered_html h6 {
+  position: relative;
+  padding-right: 2em;
+}
+
+.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h1:after,
+.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h2:after,
+.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h3:after,
+.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h4:after,
+.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h5:after,
+.collapsible_headings_collapsed.collapsible_headings_ellipsis .rendered_html h6:after {
+  position: absolute;
+  right: 0;
+  bottom: 0;
+  content: "[\002026]";
+  color: #aaa;
+}

.local/share/jupyter/nbextensions/collapsible_headings/main.js

@@ -0,0 +1,1092 @@
+(requirejs.specified('base/js/namespace') ? define : function (deps, callback) {
+	// if here, the Jupyter namespace hasn't been specified to be loaded.
+	// This means that we're probably embedded in a page, so we need to make
+	// our definition with a specific module name
+	"use strict";
+	return define('nbextensions/collapsible_headings/main', deps, callback);
+})(['jquery', 'require'], function ($, requirejs) {
+	"use strict";
+
+	var mod_name = 'collapsible_headings';
+	var log_prefix = '[' + mod_name + ']';
+	var action_names = { // set on registration
+		insert_above: '',
+		insert_below: '',
+		collapse: '',
+		uncollapse: '',
+		select: ''
+	};
+	var select_reveals = true; // used as a flag to prevent selecting a heading section from also opening it
+
+	// define default values for config parameters
+	var params = {
+		add_button : false,
+		add_all_cells_button: false,
+		add_insert_header_buttons: false,
+		use_toggle_controls : true,
+		make_toggle_controls_buttons : false,
+		size_toggle_controls_by_level : true,
+		toggle_open_icon : 'fa-caret-down',
+		toggle_closed_icon : 'fa-caret-right',
+		toggle_color : '#aaaaaa',
+		use_shortcuts : true,
+		shortcuts: {
+			collapse: 'left',
+			collapse_all: 'ctrl-shift-left',
+			uncollapse: 'right',
+			uncollapse_all: 'ctrl-shift-right',
+			select: 'shift-right',
+			insert_above: 'shift-a',
+			insert_below: 'shift-b',
+		},
+		show_section_brackets : false,
+		section_bracket_width : 10,
+		show_ellipsis : true,
+		select_reveals : true,
+		collapse_to_match_toc: false,
+		indent_px: 8,
+	};
+
+	// ------------------------------------------------------------------------
+	// Jupyter is used when we're in a live notebook, but in non-live notebook
+	// settings, it remains undefined.
+	// It is declared here to allow us to keep logic for live/nonlive functions
+	// together.
+	var Jupyter;
+	// similarly, in a live notebook, events is the Jupyter global events
+	// object, but in a non-live notebook, we must construct our own version
+	var events;
+	try {
+		events = requirejs('base/js/events');
+	}
+	catch (err) {
+		// in non-live notebook, there's no events structure, so we make our own
+		if (window.events === undefined) {
+			var Events = function () {};
+			window.events = $([new Events()]);
+		}
+		events = window.events;
+	}
+
+	// global flag denoting whether we're in a live notebook or exported html.
+	// In a live notebook we operate on Cell instances, in exported html we
+	// operate on jQuery collections of '.cell' elements
+	var live_notebook = false;
+
+
+	//  Some functions providing things akin to Jupyter.notebook methods, but
+	//  which can work using jQuery collections in place of Cell instances.
+
+	/**
+	 *  Return all cells in the notebook (or cell elements if notebook not live)
+	 */
+	function _get_cells () {
+		return live_notebook ? Jupyter.notebook.get_cells() : $('#notebook-container > .cell');
+	}
+
+	/**
+	 *  Return cell at index index (or cell element if notebook not live)
+	 */
+	function _get_cell_at_index (index) {
+		return live_notebook ? Jupyter.notebook.get_cell(index) : $('.cell').eq(index);
+	}
+
+	/**
+	 *  Return the index of the given cell (or cell element if notebook not live)
+	 */
+	function _find_cell_index (cell) {
+		return live_notebook ? Jupyter.notebook.find_cell_index(cell) : $(cell).index();
+	}
+
+	// ------------------------------------------------------------------------
+
+	/**
+	 * Return the level of nbcell.
+	 * The cell level is an integer in the range 1-7 inclusive
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {Integer} cell level
+	 */
+	function get_cell_level (cell) {
+		// headings can have a level up to 6, so 7 is used for a non-heading
+		var level = 7;
+		if (cell === undefined) {
+			return level;
+		}
+		if (live_notebook) {
+			if ((typeof(cell) === 'object')  && (cell.cell_type === 'markdown')) {
+			level = cell.get_text().match(/^#*/)[0].length || level;
+			}
+		}
+		else {
+			// the jQuery pseudo-selector :header is useful for us, but is
+			// implemented in javascript rather than standard css selectors,
+			// which get implemented in native browser code.
+			// So we get best performance by using css-native first, then filtering
+			var only_child_header = $(cell).find(
+				'.inner_cell > .rendered_html > :only-child'
+			).filter(':header');
+			if (only_child_header.length > 0) {
+				level = Number(only_child_header[0].tagName.substring(1));
+			}
+		}
+		return Math.min(level, 7); // we rely on 7 being max
+	}
+
+	/**
+	 * Check if a cell is a heading cell.
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {Boolean}
+	 */
+	function is_heading (cell) {
+		return get_cell_level(cell) < 7;
+	}
+
+	/**
+	 *  Check if a heading cell is collapsed.
+	 *
+	 *  Should in general return false on non-heading cells, but this is
+	 *  dependent on metadata/css classes, so don't rely on it.
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {Boolean}
+	 */
+	function _is_collapsed (heading_cell) {
+		if (live_notebook) {
+			return heading_cell.metadata.heading_collapsed === true;
+		}
+		return $(heading_cell).hasClass('collapsible_headings_collapsed');
+	}
+
+	/**
+	 *  Alter cell so that _is_collapsed called on it will return set_collapsed
+	 */
+	function _set_collapsed (heading_cell, set_collapsed) {
+		set_collapsed = set_collapsed !== undefined ? set_collapsed : true;
+		if (live_notebook) {
+			if (set_collapsed) {
+				heading_cell.metadata.heading_collapsed = true;
+			}
+			else {
+				delete heading_cell.metadata.heading_collapsed;
+			}
+		}
+		else {
+			$(heading_cell).toggleClass('collapsible_headings_collapsed', set_collapsed);
+		}
+		return set_collapsed;
+	}
+
+	/**
+	 * Check if a cell is a collapsed heading cell.
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {Boolean}
+	 */
+	function is_collapsed_heading (cell) {
+		return is_heading(cell) && _is_collapsed(cell);
+	}
+
+	/**
+	 * Uncollapse any headings which are hiding the cell at index
+	 *
+	 * @param {Integer} index - index of cell to reveal
+	 */
+	function reveal_cell_by_index (index) {
+		// Restrict the search to cells that are of the same level and lower
+		// than the currently selected cell by index.
+		var ref_cell = _get_cell_at_index(index);
+		// ref_cell may be null, if we've attempted to extend selection beyond
+		// the existing cells
+		if (!ref_cell) {
+			return;
+		}
+		var pivot_level = get_cell_level(ref_cell);
+		var cells = _get_cells();
+		while (index > 0 && pivot_level > 1) {
+			index--;
+			var cell = cells[index];
+			var cell_level = get_cell_level(cell);
+			if (cell_level < pivot_level) {
+				if (is_collapsed_heading(cell)) {
+					toggle_heading(cell);
+				}
+				pivot_level = cell_level;
+			}
+		}
+	}
+
+	/**
+	 * Add or remove collapsed/uncollapsed classes & metadata to match the
+	 * cell's status as a non-heading or collapsed/uncollapsed heading
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {undefined}
+	 */
+	function update_heading_cell_status (cell) {
+		var level = get_cell_level(cell);
+		var cell_is_heading = level < 7;
+		var cell_elt = live_notebook ? cell.element : $(cell);
+		var cht = cell_elt.find('.input_prompt > .collapsible_headings_toggle');
+		if (cell_is_heading) {
+			var collapsed = _is_collapsed(cell);
+			cell_elt.toggleClass('collapsible_headings_collapsed', collapsed);
+			cell_elt.toggleClass('collapsible_headings_ellipsis', params.show_ellipsis);
+			if (params.use_toggle_controls) {
+				if (cht.length < 1) {
+					cht = $('<div/>')
+						.addClass('collapsible_headings_toggle')
+						.css('color', params.toggle_color)
+						.append('<div><i class="fa fa-fw"></i></div>')
+						.appendTo(cell_elt.find('.input_prompt'));
+					var clickable = cht.find('i');
+					if (params.make_toggle_controls_buttons) {
+						cht.addClass('btn btn-default');
+						clickable = cht;
+					}
+					if (live_notebook) {
+						clickable.on('click', function () { toggle_heading(cell); });
+					}
+					else {
+						// in non-live notebook, cell isn;t editable, so make it clickable also
+						var only_child_header = cell_elt.find(
+							'.inner_cell > .rendered_html > :only-child'
+						).filter(':header');
+						clickable.add(only_child_header)
+							.css('cursor', 'pointer')
+							.on('click', function (evt) {
+								// evt.target is what was clicked, not what the handler was attached to
+								if (!$(evt.target).hasClass('anchor-link')) {
+									toggle_heading(cell);
+								}
+							});
+					}
+				}
+				// Update the cell's toggle control classes
+				var hwrap = cht.children();
+				hwrap.find('.fa')
+					.toggleClass(params.toggle_closed_icon, collapsed)
+					.toggleClass(params.toggle_open_icon, !collapsed);
+				if (params.size_toggle_controls_by_level) {
+					for (var hh = 1; hh < 7; hh++) {
+						hwrap.toggleClass('h' + hh, hh == level);
+					}
+				}
+			}
+		}
+		else {
+			_set_collapsed(cell, false);
+			cell_elt.removeClass('collapsible_headings_collapsed');
+			cht.remove();
+		}
+	}
+
+	/**
+	 * find the closest header cell to input cell
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @param {Function} a function to filter which header cells can be
+	 *                   returned. Should take a notebook cell/jquer element as
+	 *                   input (depending on whether we're in a live notebook),
+	 *                   and return true if the given cell is acceptable.
+	 * @return {Object | undefined}
+	 */
+	function find_header_cell (cell, test_func) {
+		var index = _find_cell_index(cell);
+		for (; index >= 0; index--) {
+			cell = _get_cell_at_index(index);
+			if (is_heading(cell) && (test_func === undefined || test_func(cell))) {
+				return cell;
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 *  Select the section enclosed by the given heading cell.
+	 *
+	 *  Only callable from a live notebook, so require no special cell handling
+	 *
+	 *  @param {Object} head_cell Cell instance or jQuery collection of '.cell' elements
+	 *  @return {undefined}
+	 */
+	function select_heading_section(head_cell, extend) {
+		var head_lvl = get_cell_level(head_cell);
+		var ncells = Jupyter.notebook.ncells();
+		var head_ind = _find_cell_index(head_cell);
+		var tail_ind;
+		for (tail_ind = head_ind; tail_ind + 1 < ncells; tail_ind++) {
+			if (get_cell_level(_get_cell_at_index(tail_ind + 1)) <= head_lvl) {
+				break;
+			}
+		}
+		select_reveals = params.select_reveals;
+		if (extend) {
+			var ank_ind = Jupyter.notebook.get_anchor_index();
+			if (ank_ind <= head_ind) {
+				// keep current anchor, extend to head
+				Jupyter.notebook.select(tail_ind, false);
+				select_reveals = true;
+				return;
+			}
+			else if (ank_ind >= tail_ind) {
+				// keep current anchor, extend to tail
+				Jupyter.notebook.select(head_ind, false);
+				select_reveals = true;
+				return;
+			}
+			// head_ind < ank_ind < tail_ind i.e. anchor is inside section
+		}
+		// move_anchor to header cell
+		Jupyter.notebook.select(head_ind, true);
+		// don't move anchor, i.e. extend, to tail cell
+		Jupyter.notebook.select(tail_ind, false);
+		select_reveals = true;
+	}
+
+	/**
+	 *  Return all of the cell _elements _which are part of the section headed by
+	 *  the given cell
+	 *
+	 *  @param {Object} head_cell Cell instance or jQuery collection of '.cell' elements
+	 */
+	function get_jquery_bracket_section (head_cell) {
+		var head_lvl = get_cell_level(head_cell);
+		var cells = _get_cells();
+		var cell_elements = $(live_notebook ? head_cell.element : head_cell);
+		for (var ii = _find_cell_index(head_cell); ii < cells.length; ii++) {
+			var cell = live_notebook ? cells[ii] : cells.eq(ii);
+
+			if (get_cell_level(cell) <= head_lvl) {
+				break;
+			}
+			cell_elements = cell_elements.add(live_notebook ? cell.element : cell);
+		}
+		return cell_elements;
+	}
+
+	/**
+	 * Callback function attached to the bracket-containing div, should toggle
+	 * the relevant heading
+	 */
+	var bracket_callback_timeout_id;
+	function bracket_callback (evt) {
+		// prevent bubbling, otherwise when closing a section, the cell gets
+		// selected & re-revealed after being hidden
+		evt.preventDefault();
+		evt.stopPropagation();
+		// evt.target is what was clicked, not what the handler was attached to
+		var bracket = $(evt.target);
+		var bracket_level = Number(bracket.attr('data-bracket-level'));
+		if (bracket_level) {
+			var bracket_cell = live_notebook ? bracket.closest('.cell').data('cell') : bracket.closest('.cell');
+			var header_cell = find_header_cell(bracket_cell, function (cell) {
+				return get_cell_level(cell) == bracket_level;
+			});
+			switch (evt.type) {
+				case 'dblclick':
+					clearTimeout(bracket_callback_timeout_id);
+					bracket_callback_timeout_id = undefined;
+					toggle_heading(header_cell);
+					break;
+				case 'click':
+					if (live_notebook && (bracket_callback_timeout_id === undefined)) {
+						bracket_callback_timeout_id = setTimeout(function () {
+							select_heading_section(header_cell, evt.shiftKey);
+							bracket_callback_timeout_id = undefined;
+						}, 300);
+					}
+					break;
+				case 'mouseenter':
+				case 'mouseleave':
+					var in_section = get_jquery_bracket_section(header_cell)
+						.find('.chb div[data-bracket-level=' + bracket_level + ']');
+					$('.chb div').not(in_section).removeClass('chb-hover');
+					in_section.toggleClass('chb-hover', evt.type === 'mouseenter');
+					break;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Update the hidden/collapsed status of all the cells under
+	 * - the notebook, if param cell === undefined
+	 * - the heading which contains the specified cell (if cell !== undefined,
+	 *   but is also not a heading)
+	 * - the specified heading cell (if specified cell is a heading)
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 * @return {undefined}
+	 */
+	function update_collapsed_headings (cell) {
+		var index = 0;
+		var section_level = 0;
+		var show = true;
+		if (cell !== undefined && (cell = find_header_cell(cell)) !== undefined) {
+			index = _find_cell_index(cell) + 1;
+			section_level = get_cell_level(cell);
+			show = !_is_collapsed(cell);
+		}
+		var hide_above = 7;
+		var brackets_open = {};
+		var max_open = 0; // count max number open at one time to calc padding
+		for (var cells = _get_cells(); index < cells.length; index++) {
+			cell = cells[index];
+			var cell_elt = live_notebook ? cell.element : $(cell);
+			var level = get_cell_level(cell);
+			if (level <= section_level) {
+				break;
+			}
+			if (show && level <= hide_above) {
+				cell_elt.slideDown('fast');
+				hide_above = is_collapsed_heading(cell) ? level : 7;
+				if (live_notebook) {
+					delete cell.metadata.hidden;
+				}
+			}
+			else {
+				cell_elt.slideUp('fast');
+				if (live_notebook) {
+					cell.metadata.hidden = true;
+				}
+				continue;
+			}
+
+			if (params.show_section_brackets) {
+				var chb = cell_elt.find('.chb').empty();
+				if (chb.length < 1) {
+					chb = $('<div/>')
+						.addClass('chb')
+						.on('click dblclick', bracket_callback)
+						.appendTo(cell_elt);
+				}
+				var num_open = 0; // count number of brackets currently open
+				for (var jj = 1; jj < 7; jj++) {
+					if (brackets_open[jj] && level <= jj) {
+						brackets_open[jj].addClass('chb-end'); // closing, add class
+						delete brackets_open[jj]; // closed
+					}
+					var opening = level == jj;
+					if (brackets_open[jj] || opening) {
+						num_open++;
+						brackets_open[jj] = $('<div/>')
+							.on('mouseenter mouseleave', bracket_callback)
+							.attr('data-bracket-level', jj)
+							.appendTo(chb); // add bracket element
+						if (opening) { // opening, add class
+							brackets_open[jj].addClass('chb-start');
+						}
+					}
+				}
+				max_open = Math.max(num_open, max_open);
+			}
+		}
+		if (params.show_section_brackets) {
+			// close any remaining
+			for (var ii in brackets_open) {
+				brackets_open[ii].addClass('chb-end');
+			}
+			// adjust padding to fit in brackets
+			var bwidth = params.section_bracket_width;
+			var dwidth = max_open * (2 + bwidth);
+			$('#notebook-container').css('padding-right', (16 + dwidth) + 'px');
+			$('.chb')
+				.css('right', '-' + (3 + dwidth) + 'px')
+				.find('div')
+					.css('width', bwidth);
+		}
+	}
+
+	/**
+	 * Hide/reveal all cells in the section headed by cell.
+	 *
+	 * @param {Object} cell Cell instance or jQuery collection of '.cell' elements
+	 */
+	function toggle_heading (cell, set_collapsed, trigger_event) {
+		if (is_heading(cell)) {
+			if (set_collapsed === undefined) {
+				set_collapsed = !_is_collapsed(cell);
+			}
+			_set_collapsed(cell, set_collapsed);
+			update_heading_cell_status(cell);
+			update_collapsed_headings(params.show_section_brackets ? undefined : cell);
+			console.log(log_prefix, set_collapsed ? 'collapsed' : 'expanded', 'cell', _find_cell_index(cell));
+			if (trigger_event !== false) {
+				events.trigger((set_collapsed ? '' : 'un') + 'collapse.CollapsibleHeading', {cell: cell});
+			}
+		}
+	}
+
+	/**
+	 *  Return a promise which resolves when the Notebook class methods have
+	 *  been appropriately patched.
+	 *  Patches methods
+	 *   - Notebook.select
+	 *   - Notebook.undelete
+	 *
+	 *  @return {Promise}
+	 */
+	function patch_Notebook () {
+		return new Promise(function (resolve, reject) {
+			requirejs(['notebook/js/notebook'], function on_success (notebook) {
+				console.debug(log_prefix, 'patching Notebook.protoype');
+
+				// we have to patch select, since the select.Cell event is only fired
+				// by cell click events, not by the notebook select method
+				var orig_notebook_select = notebook.Notebook.prototype.select;
+				notebook.Notebook.prototype.select = function (index, moveanchor) {
+					if (select_reveals) {
+						reveal_cell_by_index(index);
+					}
+					return orig_notebook_select.apply(this, arguments);
+				};
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error patching Notebook.protoype:', reason);
+		});
+	}
+
+	/**
+	 *  Return a promise which resolves when the TextCell class methods have
+	 *  been appropriately patched.
+	 *
+	 *  Patches TextCell.set_text to update headings.
+	 *  This is useful for undelete and copy/paste of cells, which don't fire
+	 *  markdown.
+	 *
+	 *  @return {Promise}
+	 */
+	function patch_TextCell () {
+		return new Promise(function (resolve, reject) {
+			requirejs(['notebook/js/textcell'], function on_success (textcell) {
+				console.debug(log_prefix, 'patching TextCell.protoype');
+				var orig_set_text = textcell.TextCell.prototype.set_text;
+				textcell.TextCell.prototype.set_text = function (text) {
+					var ret = orig_set_text.apply(this, arguments);
+					if (Jupyter.notebook._fully_loaded) {
+						update_heading_cell_status(this);
+						update_collapsed_headings();
+					}
+					return ret;
+				};
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error patching TextCell.protoype:', reason);
+		});
+	}
+
+	/**
+	 *  Return a promise which resolves when the Tooltip class methods have
+	 *  been appropriately patched.
+	 *
+	 *  For notebook 4.x, cells had css position:static, and changing them to
+	 *  relative to get heading brackets working broke the tooltip position
+	 *  calculation. In order to fix this, we patch the 4.x Tooltip._show
+	 *  method to temporarily reapply position:static while the tooltip
+	 *  position is calculated & the animation queued, before revertign to the
+	 *  css-appled position:relative.
+	 *	For notebook 5.x, cells are already position:relative, so the patch is
+	 *  unecessary.
+	 *
+	 *  @return {Promise}
+	 */
+	function patch_Tooltip () {
+		if (Number(Jupyter.version[0]) >= 5) {
+			return Promise.resolve();
+		}
+		return new Promise(function (resolve, reject) {
+			requirejs(['notebook/js/tooltip'], function on_success (tooltip) {
+				console.debug(log_prefix, 'patching Tooltip.prototype');
+
+				var orig_tooltip__show = tooltip.Tooltip.prototype._show;
+				tooltip.Tooltip.prototype._show = function (reply) {
+					var $cell = $(this.code_mirror.getWrapperElement()).closest('.cell');
+					$cell.css('position', 'static');
+					var ret = orig_tooltip__show.apply(this, arguments);
+					$cell.css('position', '');
+					return ret;
+				};
+
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error patching Tooltip.prototype:', reason);
+		});
+	}
+
+	/**
+	 *  Return a promise which resolves when the appropriate Jupyter actions
+	 *  have been patched correctly.
+	 *
+	 *  We patch the up/down arrow actions to skip selecting cells which are
+	 *  hidden by a collapsed heading
+	 *
+	 *  @return {Promise}
+	 */
+	function patch_actions () {
+		return new Promise(function (resolve, reject) {
+			requirejs(['notebook/js/tooltip'], function on_success (tooltip) {
+				console.debug(log_prefix, 'patching Jupyter up/down actions');
+
+				var kbm = Jupyter.keyboard_manager;
+
+				var action_up = kbm.actions.get("jupyter-notebook:select-previous-cell");
+				var orig_up_handler = action_up.handler;
+				action_up.handler = function (env) {
+					for (var index = env.notebook.get_selected_index() - 1; (index !== null) && (index >= 0); index--) {
+						if (env.notebook.get_cell(index).element.is(':visible')) {
+							env.notebook.select(index);
+							env.notebook.focus_cell();
+							return;
+						}
+					}
+					return orig_up_handler.apply(this, arguments);
+				};
+
+				var action_down = kbm.actions.get("jupyter-notebook:select-next-cell");
+				var orig_down_handler = action_down.handler;
+				action_down.handler = function (env) {
+					var ncells = env.notebook.ncells();
+					for (var index = env.notebook.get_selected_index() + 1; (index !== null) && (index < ncells); index++) {
+						if (env.notebook.get_cell(index).element.is(':visible')) {
+							env.notebook.select(index);
+							env.notebook.focus_cell();
+							return;
+						}
+					}
+					return orig_down_handler.apply(this, arguments);
+				};
+
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error patching Jupyter up/down actions:', reason);
+		});
+	}
+
+	/**
+	 * register actions to collapse and uncollapse the selected heading cell
+	 */
+	function register_new_actions () {
+		action_names.collapse = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					var cell = env.notebook.get_selected_cell();
+					var is_h = is_heading(cell);
+					if (is_h && !_is_collapsed(cell)) {
+						toggle_heading(cell, true);
+						return;
+					}
+					var filter_func;
+					if (is_h) {
+						var lvl = get_cell_level(cell);
+						filter_func = function (c) { return get_cell_level(c) < lvl; };
+					}
+					cell = find_header_cell(cell, filter_func);
+					if (cell !== undefined) {
+						Jupyter.notebook.select(Jupyter.notebook.find_cell_index(cell));
+						cell.focus_cell();
+					}
+				},
+				help : "Collapse the selected heading cell's section",
+				icon : params.toggle_closed_icon,
+				help_index: 'c1'
+			},
+			'collapse_heading', mod_name
+		);
+
+		action_names.collapse_all = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					env.notebook.get_cells().forEach(function (c, idx, arr) {
+						toggle_heading(c, true);
+					});
+					var cell = env.notebook.get_selected_cell();
+					if (cell.element.is(':hidden')) {
+						cell = find_header_cell(cell, function (c) { return c.element.is(':visible'); });
+						if (cell !== undefined) {
+							Jupyter.notebook.select(Jupyter.notebook.find_cell_index(cell));
+							cell.focus_cell();
+						}
+					}
+				},
+				help : "Collapse all heading cells' sections",
+				icon : params.toggle_closed_icon,
+				help_index: 'c2'
+			},
+			'collapse_all_headings', mod_name
+		);
+
+		action_names.uncollapse = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					var cell = env.notebook.get_selected_cell();
+					if (is_heading(cell)) {
+						toggle_heading(cell, false);
+					}
+					else {
+						var ncells = env.notebook.ncells();
+						for (var ii = env.notebook.find_cell_index(cell); ii < ncells; ii++) {
+							cell = env.notebook.get_cell(ii);
+							if (is_heading(cell)) {
+								env.notebook.select(ii);
+								cell.focus_cell();
+								break;
+							}
+						}
+					}
+				},
+				help : "Un-collapse (expand) the selected heading cell's section",
+				icon : params.toggle_open_icon,
+				help_index: 'c3'
+			},
+			'uncollapse_heading', mod_name
+		);
+
+		action_names.uncollapse_all = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					env.notebook.get_cells().forEach(function (c, idx, arr) {
+						toggle_heading(c, false);
+					});
+					env.notebook.get_selected_cell().focus_cell();
+				},
+				help : "Un-collapse (expand) all heading cells' sections",
+				icon : params.toggle_open_icon,
+				help_index: 'c4'
+			},
+			'uncollapse_all_headings', mod_name
+		);
+
+		action_names.toggle = Jupyter.keyboard_manager.actions.register ({
+				handler: function () {
+					var heading_cell = find_header_cell(Jupyter.notebook.get_selected_cell(), function (cell) {
+						return cell.element.is(':visible') && !_is_collapsed(cell);
+					});
+					if (is_heading(heading_cell)) {
+						toggle_heading(heading_cell, true);
+						Jupyter.notebook.select(Jupyter.notebook.find_cell_index(heading_cell));
+					}
+				},
+				help   : "Toggle closest heading's collapsed status",
+				icon   : 'fa-angle-double-up',
+			},
+			'toggle_collapse_heading', mod_name
+		);
+
+		action_names.toggle_all = Jupyter.keyboard_manager.actions.register ({
+				handler: function () {
+					var cells = Jupyter.notebook.get_cells();
+					for (var ii = 0; ii < cells.length; ii++) {
+						if (is_heading(cells[ii])) {
+							Jupyter.keyboard_manager.actions.call(action_names[
+								is_collapsed_heading(cells[ii]) ? 'uncollapse_all' : 'collapse_all']);
+							return;
+						}
+					}
+				},
+				help   : 'Collapse/uncollapse all headings based on the status of the first',
+				icon   : 'fa-angle-double-up',
+			},
+			'toggle_collapse_all_headings', mod_name
+		);
+
+		action_names.select = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) {
+					var cell = env.notebook.get_selected_cell();
+					if (is_heading(cell)) {
+						select_heading_section(cell, true);
+					}
+				},
+				help : "Select all cells in the selected heading cell's section",
+				help_index: 'c3'
+			},
+			'select_heading_section', mod_name
+		);
+
+		action_names.insert_above = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) { insert_heading_cell(true); },
+				help : "Insert a heading cell above the selected cell",
+				help_index: 'c4',
+				icon: 'fa-caret-up'
+			},
+			'insert_heading_above', mod_name
+		);
+
+		action_names.insert_below = Jupyter.keyboard_manager.actions.register({
+				handler : function (env) { insert_heading_cell(false); },
+				help : "Insert a heading cell below the selected cell's section",
+				help_index: 'c5',
+				icon: 'fa-caret-down'
+			},
+			'insert_heading_below', mod_name
+		);
+	}
+
+	function imitate_hash_click ($element) {
+		var site = $('#site');
+		var adjust = $element.offset().top - site.offset().top;
+		site.animate({scrollTop: site.scrollTop() + adjust});
+	}
+
+	/**
+	 * Insert a new heading cell either above or below the current section.
+	 * only works in a live notebook.
+	 */
+	function insert_heading_cell (above) {
+		var selected_cell = Jupyter.notebook.get_selected_cell();
+		var ref_cell = find_header_cell(selected_cell) || selected_cell;
+		var level = get_cell_level(ref_cell);
+		level = (level == 7) ? 1 : level; // default to biggest level (1)
+		if (above) {
+			// if above, insert just above selected cell, but keep ref_cell's level
+			ref_cell = selected_cell;
+		}
+		var index = ref_cell.element.index();
+		if (!above) {
+			// below requires special handling, as we really want to put it
+			// below the currently selected heading's *content*
+			var cells = _get_cells();
+			for (index=index + 1; index < cells.length; index++) {
+				if (get_cell_level(cells[index]) <= level) {
+					break;
+				}
+			}
+			// if we make it here, index will be == cells.length, which is ok
+			// as it gets the new cell inserted at the bottom of the notebook
+		}
+		// we don't want our newly-inserted cell to trigger opening of headings
+		var cached_select_reveals = select_reveals;
+		select_reveals = false;
+		var new_cell = Jupyter.notebook.insert_cell_above('markdown', index);
+		var new_text = 'New heading';
+		new_cell.set_text(new_text);
+		new_cell.set_heading_level(level);
+		new_cell.code_mirror.setSelection({line:0, ch: level + 1}, {line:0, ch: level + 1 + new_text.length});
+		Jupyter.notebook.select(index, true);
+		// restore cached setting
+		select_reveals = cached_select_reveals;
+		Jupyter.notebook.focus_cell();
+		Jupyter.notebook.edit_mode();
+	}
+
+	function refresh_all_headings () {
+		var cells = _get_cells();
+		for (var ii=0; ii < cells.length; ii++) {
+			update_heading_cell_status(cells[ii]);
+		}
+		update_collapsed_headings();
+	}
+
+	function set_collapsible_headings_options (options) {
+		// options may be undefined here, but it's still handled ok by $.extend
+		$.extend(true, params, options);
+		// bind/unbind toc-collapse handler
+		events[params.collapse_to_match_toc ? 'on' : 'off']('collapse.Toc uncollapse.Toc', callback_toc_collapse);
+		// add css for indents
+		if (params.indent_px !== 0) {
+			var lines = [];
+			for (var hh = 1; hh <= 6; hh++) {
+				lines.push(
+					'.collapsible_headings_toggle .h' + hh +
+					' { margin-right: ' + ((6 - hh) * params.indent_px) + 'px; }'
+				);
+			}
+			$('<style id="collapsible_headings_indent_css"/>')
+				.html(lines.join('\n'))
+				.appendTo('head');
+		}
+		return params;
+	}
+
+	function add_buttons_and_shortcuts () {
+		// (Maybe) add buttons to the toolbar
+		if (params.add_button) {
+			Jupyter.toolbar.add_buttons_group([action_names.toggle]);
+		}
+		if (params.add_all_cells_button) {
+			Jupyter.toolbar.add_buttons_group([action_names.toggle_all]);
+		}
+		if (params.add_insert_header_buttons) {
+			Jupyter.toolbar.add_buttons_group([
+				action_names.insert_above, action_names.insert_below
+			],'insert_heading_cell_btns');
+		}
+		// add hashes
+		$('#insert_heading_cell_btns .btn').prepend('# ');
+
+		// (Maybe) register keyboard shortcuts
+		if (params.use_shortcuts) {
+			var cmd_shrts = Jupyter.keyboard_manager.command_shortcuts;
+			for (var act in action_names) {
+				if (action_names.hasOwnProperty(act) && params.shortcuts[act]) {
+					cmd_shrts.add_shortcut(params.shortcuts[act], action_names[act]);
+				}
+			}
+		}
+	}
+
+	var callback_toc_collapse = function (evt, data) {
+		// use trigger_event false to avoid re-triggering toc2
+		toggle_heading(data.cell, evt.type.indexOf('un') < 0, false);
+	}
+
+	/**
+	 *  Return a promise which resolves once event handlers have been bound
+	 *
+	 *  @return {Promise}
+	 */
+	function bind_events () {
+
+		// Callbacks bound to the create.Cell event can execute before the cell
+		// data has been loaded from JSON.
+		// So, we rely on rendered.MarkdownCell event to catch headings from
+		// JSON, and the only reason we use create.Cell is to update brackets
+		function callback_create_cell (evt, data) {
+			if (params.show_section_brackets) {
+				update_collapsed_headings();
+			}
+		}
+
+		function callback_delete_cell(evt, data) {
+			update_collapsed_headings();
+		}
+
+		function callback_markdown_rendered (evt, data) {
+			update_heading_cell_status(data.cell);
+			// we update all headings to avoid pasted headings ending up hidden
+			// by other pre-existing collapsed headings - see
+			//     https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/1082
+			// for details
+			update_collapsed_headings();
+		}
+
+		return new Promise (function (resolve, reject) {
+			requirejs(['base/js/events'], function on_success (events) {
+
+				// ensure events are detached while notebook loads, in order to
+				// speed up loading (otherwise headings are updated for every
+				// new cell in the notebook), then reattached when load is
+				// complete
+				function events_attach () {
+					refresh_all_headings();
+					events.on('create.Cell', callback_create_cell);
+					events.on('delete.Cell', callback_delete_cell);
+					events.on('rendered.MarkdownCell', callback_markdown_rendered);
+				}
+				function events_detach () {
+					events.off('create.Cell', callback_create_cell);
+					events.off('delete.Cell', callback_delete_cell);
+					events.off('rendered.MarkdownCell', callback_markdown_rendered);
+				}
+
+				if (Jupyter.notebook._fully_loaded) {
+					events_attach();
+				}
+				events.on('notebook_loaded.Notebook', events_attach);
+				events.on('notebook_loading.Notebook', events_detach);
+
+				resolve();
+			}, reject);
+		}).catch(function on_reject (reason) {
+			console.warn(log_prefix, 'error binding events:', reason);
+		});
+	}
+
+	/**
+	 *  Return a menu list item with a link that calls the specified action
+	 *  name.
+	 *
+	 *  @param {String} action_name the name of the action which the menu item
+	 *                  should call
+	 *  @param {String} menu_item_html the html to use as the link's content
+	 *  @return {jQuery}
+	 */
+	function make_action_menu_item (action_name, menu_item_html) {
+		var act = Jupyter.menubar.actions.get(action_name);
+		var menu_item = $('<li/>');
+		$('<a/>')
+			.html(menu_item_html)
+			.attr({'title' : act.help, 'href' : '#'})
+			.on('click', function (evt) {
+				Jupyter.menubar.actions.call(action_name, evt);
+			})
+			.appendTo(menu_item);
+		return menu_item;
+	}
+
+	/**
+	 * Add any new items to the notebook menu
+	 */
+	function insert_menu_items () {
+		$('#insert_menu')
+			.append('<li class="divider"/>')
+			.append(make_action_menu_item(action_names.insert_above, 'Insert Heading Above'))
+			.append(make_action_menu_item(action_names.insert_below, 'Insert Heading Below'));
+	}
+
+	/**
+	 * Initialize the extension.
+	 */
+	function load_jupyter_extension () {
+		// Load css first
+		$('<link/>')
+			.attr({
+				id: 'collapsible_headings_css',
+				rel: 'stylesheet',
+				type: 'text/css',
+				href: requirejs.toUrl('./main.css')
+			})
+			.appendTo('head');
+
+		// ensure Jupyter module is defined before proceeding further
+		new Promise(function (resolve, reject) {
+			requirejs(['base/js/namespace'], function (Jupyter_mod) {
+				live_notebook = true;
+				Jupyter = Jupyter_mod;
+				resolve(Jupyter);
+			}, reject);
+		})
+
+		// load config & update params
+		.then(function (Jupyter) {
+			return Jupyter.notebook.config.loaded.catch(function on_err (reason) {
+				console.warn(log_prefix, 'error loading config:', reason);
+			}).then(function () {
+				// may be undefined, but that's ok.
+				return Jupyter.notebook.config.data.collapsible_headings;
+			});
+		})
+		// set values using resolution val of previous .then
+		.then(set_collapsible_headings_options)
+
+		// apply all promisory things in arbitrary order
+		.then(patch_actions)
+		.then(patch_Notebook)
+		.then(patch_TextCell)
+		.then(patch_Tooltip)
+		.then(bind_events)
+		// finally add user-interaction stuff
+		.then(function () {
+			register_new_actions();
+			insert_menu_items();
+			add_buttons_and_shortcuts();
+		})
+		.catch(function on_reject (reason) {
+			console.error(log_prefix, 'error:', reason);
+		});
+	}
+
+	/**
+	 * Export things
+	 */
+	return {
+		get_cell_level : get_cell_level,
+		reveal_cell_by_index : reveal_cell_by_index,
+		update_collapsed_headings : update_collapsed_headings,
+		set_collapsible_headings_options : set_collapsible_headings_options,
+		refresh_all_headings: refresh_all_headings,
+		load_jupyter_extension : load_jupyter_extension,
+		load_ipython_extension : load_jupyter_extension
+	};
+});

.local/share/jupyter/nbextensions/equation-numbering/info.yaml

@@ -0,0 +1,7 @@
+Type: IPython Notebook Extension
+Name: Equation Auto Numbering
+Description: This extension enables equation autonumbering and resetting the equation count.
+Link: readme.md
+Icon: icon.png
+Main: main.js
+Compatibility: 4.x, 5.x

.local/share/jupyter/nbextensions/execute_time/ExecuteTime.js

@@ -0,0 +1,349 @@
+
+//  Copyright (C) 2014  Jean-Christophe Jaskula
+//                2015  [email protected]
+//
+//  Distributed under the terms of the BSD License.
+// ---------------------------------------------------------------------------
+//
+// Execution timings:
+// display when a cell was last executed, and how long it took to run
+// A double click on the timing box makes it disappear
+
+define([
+    'require',
+    'jquery',
+    'moment',
+    'base/js/namespace',
+    'base/js/events',
+    'notebook/js/codecell'
+], function (
+    requirejs,
+    $,
+    moment,
+    Jupyter,
+    events,
+    codecell
+) {
+    'use strict';
+
+    var mod_name = 'ExecuteTime';
+    var log_prefix = '[' + mod_name + ']';
+
+    var CodeCell = codecell.CodeCell;
+
+    // defaults, overridden by server's config
+    var options = {
+        clear_timings_on_clear_output: false,
+        clear_timings_on_kernel_restart: false,
+        default_kernel_to_utc: true,
+        display_absolute_format: 'HH:mm:ss YYYY-MM-DD',
+        display_absolute_timings: true,
+        display_in_utc: false,
+        display_right_aligned: false,
+        highlight: {
+            use: true,
+            color: '#00bb00',
+        },
+        relative_timing_update_period: 10,
+        template: {
+            executed: 'executed in ${duration}, finished ${end_time}',
+            queued: 'execution queued ${start_time}',
+        },
+    };
+
+    function patch_CodeCell_get_callbacks () {
+        console.log(log_prefix, 'patching CodeCell.prototype.get_callbacks');
+        var old_get_callbacks = CodeCell.prototype.get_callbacks;
+        CodeCell.prototype.get_callbacks = function () {
+            var callbacks = old_get_callbacks.apply(this, arguments);
+
+            var cell = this;
+            var prev_reply_callback = callbacks.shell.reply;
+            callbacks.shell.reply = function (msg) {
+                if (msg.msg_type === 'execute_reply') {
+                    $.extend(true, cell.metadata, {
+                        ExecuteTime: {
+                            start_time: add_utc_offset(msg.metadata.started),
+                            end_time: add_utc_offset(msg.header.date),
+                        }
+                    });
+                    var timing_area = update_timing_area(cell);
+                    if ($.ui !== undefined && options.highlight.use) {
+                        timing_area.stop(true, true).show(0).effect('highlight', {color: options.highlight.color});
+                    }
+                }
+                else {
+                    console.log('msg_type', msg.msg_type);
+                }
+                return prev_reply_callback(msg);
+            };
+            return callbacks;
+        };
+    }
+
+    function patch_CodeCell_clear_output () {
+        console.log(log_prefix, 'Patching CodeCell.prototype.clear_output to clear timings also.');
+        var orig_clear_output = CodeCell.prototype.clear_output;
+        CodeCell.prototype.clear_output = function () {
+            var ret = orig_clear_output.apply(this, arguments);
+            clear_timing_data([this]);
+            return ret;
+        };
+    }
+
+    function toggle_timing_display (cells, vis) {
+        for (var i = 0; i < cells.length; i++) {
+            var cell = cells[i];
+            if (cell instanceof CodeCell) {
+                var ce = cell.element;
+                var timing_area = ce.find('.timing_area');
+                if (timing_area.length > 0) {
+                    if (vis === undefined) {
+                        vis = !timing_area.is(':visible');
+                    }
+                    timing_area.toggle(vis);
+                }
+            }
+        }
+        return vis;
+    }
+
+    function clear_timing_data (cells) {
+        cells.forEach(function (cell, idx, arr) {
+            delete cell.metadata.ExecuteTime;
+            cell.element.find('.timing_area').remove();
+        });
+        events.trigger('set_dirty.Notebook', {value: true});
+    }
+
+    function clear_timing_data_all () {
+        console.log(log_prefix, 'Clearing all timing data');
+        clear_timing_data(Jupyter.notebook.get_cells());
+    }
+
+    function create_menu () {
+        var timings_menu_item = $('<li/>')
+            .addClass('dropdown-submenu')
+            .append(
+                $('<a href="#">')
+                    .text('Execution Timings')
+                    .on('click', function (evt) { evt.preventDefault(); })
+            )
+            .appendTo($('#cell_menu'));
+
+        var timings_submenu = $('<ul/>')
+            .addClass('dropdown-menu')
+            .appendTo(timings_menu_item);
+
+        $('<li/>')
+            .attr('title', 'Toggle the timing box for the selected cell(s)')
+            .append(
+                $('<a href="#">')
+                    .text('Toggle visibility (selected)')
+                    .on('click', function (evt) {
+                        evt.preventDefault();
+                        toggle_timing_display(Jupyter.notebook.get_selected_cells());
+                    })
+            )
+            .appendTo(timings_submenu);
+
+        $('<li/>')
+            .attr('title', 'Toggle the timing box for all cells')
+            .append(
+                $('<a href="#">')
+                    .text('Toggle visibility (all)')
+                    .on('click', function (evt) {
+                        evt.preventDefault();
+                        toggle_timing_display(Jupyter.notebook.get_cells());
+                    })
+            )
+            .appendTo(timings_submenu);
+
+        $('<li/>')
+            .attr('title', 'Clear the selected cell(s) timing data')
+            .append(
+                $('<a href="#">')
+                    .text('Clear (selected)')
+                    .on('click', function (evt) {
+                        evt.preventDefault();
+                        clear_timing_data(Jupyter.notebook.get_selected_cells());
+                    })
+            )
+            .appendTo(timings_submenu);
+
+        $('<li/>')
+            .attr('title', 'Clear the timing data from all cells')
+            .append(
+                $('<a href="#">')
+                    .text('Clear (all)')
+                    .on('click', function (evt) {
+                        evt.preventDefault();
+                        clear_timing_data(Jupyter.notebook.get_cells());
+                    })
+            )
+            .appendTo(timings_submenu);
+    }
+
+    function excute_codecell_callback (evt, data) {
+        var cell = data.cell;
+        cell.metadata.ExecuteTime = {start_time: moment().toISOString()};
+
+        update_timing_area(cell);
+    }
+
+    function humanized_duration (duration_ms, item_count) {
+        if (duration_ms < 1000) { // < 1s, show ms directly
+            return Math.round(duration_ms) + 'ms';
+        }
+
+        var humanized = '';
+
+        var days = Math.floor(duration_ms / 86400000);
+        if (days) {
+            humanized += days + 'd ';
+        }
+        duration_ms %= 86400000;
+
+        var hours = Math.floor(duration_ms / 3600000);
+        if (days || hours) {
+            humanized += hours + 'h ';
+        }
+        duration_ms %= 3600000;
+
+        var mins = Math.floor(duration_ms / 60000);
+        if (days || hours || mins) {
+            humanized += mins + 'm';
+        }
+        duration_ms %= 60000;
+
+        var secs = duration_ms / 1000; // don't round!
+        if (!days) {
+            var decimals = (hours || mins > 1) ? 0 : (secs > 10 ? 1 : 2);
+            humanized += (humanized ? ' ' : '') + secs.toFixed(decimals) + 's';
+        }
+
+        return humanized;
+    }
+
+    // ISO8601 UTC offset is in format ±[hh]:[mm], ±[hh][mm], or ±[hh]
+    var rgx_has_timezone = new RegExp('Z|[\\-+\u2212]\\d\\d(?::?\\d\\d)?$');
+    function add_utc_offset (timestamp) {
+        if (options.default_kernel_to_utc && timestamp !== undefined && !rgx_has_timezone.test(timestamp)) {
+            return timestamp + 'Z';
+        }
+        return timestamp;
+    }
+
+    function format_moment (when) {
+        if (options.display_in_utc) {
+            when.utc();
+        }
+        if (options.display_absolute_timings) {
+            return when.format(options.display_absolute_format);
+        }
+        return when.fromNow();
+    }
+
+    function update_timing_area (cell) {
+        if (! (cell instanceof CodeCell) ||
+                 !cell.metadata.ExecuteTime ||
+                 !cell.metadata.ExecuteTime.start_time) {
+            return $();
+        }
+
+        var timing_area = cell.element.find('.timing_area');
+        if (timing_area.length < 1) {
+            timing_area = $('<div/>')
+                .addClass('timing_area' + (options.display_right_aligned ? ' text-right' : ''))
+                .on('dblclick', function (evt) { toggle_timing_display([cell]); })
+                .appendTo(cell.element.find('.input_area'));
+        }
+
+        var start_time = moment(cell.metadata.ExecuteTime.start_time),
+              end_time = cell.metadata.ExecuteTime.end_time;
+        var msg = options.template[end_time ? 'executed' : 'queued'];
+        msg = msg.replace('${start_time}', format_moment(start_time));
+        if (end_time) {
+            end_time = moment(end_time);
+            msg = msg.replace('${end_time}', format_moment(end_time));
+            var exec_time = -start_time.diff(end_time);
+            msg = msg.replace('${duration}', humanized_duration(exec_time));
+        }
+        timing_area.text(msg);
+        return timing_area;
+    }
+
+    function _update_all_timing_areas () {
+        Jupyter.notebook.get_cells().forEach(update_timing_area);
+    }
+
+    function update_all_timing_areas () {
+        console.debug(log_prefix, 'updating all timing areas');
+        _update_all_timing_areas();
+    }
+
+    function add_css(url) {
+        $('<link/>')
+            .attr({
+                rel: 'stylesheet',
+                href: requirejs.toUrl(url),
+                type: 'text/css'
+            })
+            .appendTo('head');
+    }
+
+    function load_jupyter_extension () {
+        // try to load jquery-ui
+        if ($.ui === undefined && options.highlight.use) {
+            requirejs(['jquery-ui'], function ($) {}, function (err) {
+                // try to load using the older, non-standard name (without hyphen)
+                requirejs(['jqueryui'], function ($) {}, function (err) {
+                    console.log(log_prefix, 'couldn\'t find jquery-ui, so no animations');
+                });
+            });
+        }
+
+        add_css('./ExecuteTime.css');
+
+        Jupyter.notebook.config.loaded.then(function on_config_loaded () {
+            $.extend(true, options, Jupyter.notebook.config.data[mod_name]);
+        }, function on_config_load_error (reason) {
+            console.warn(log_prefix, 'Using defaults after error loading config:', reason);
+        }).then(function do_stuff_with_config () {
+
+            patch_CodeCell_get_callbacks();
+            events.on('execute.CodeCell', excute_codecell_callback);
+
+            create_menu();
+
+            // add any existing timing info
+            events.on("notebook_loaded.Notebook", update_all_timing_areas);
+            if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
+                // notebook already loaded, so we missed the event, so update all
+                update_all_timing_areas();
+            }
+
+            // setup optional clear-data calls
+            if (options.clear_timings_on_clear_output) {
+                patch_CodeCell_clear_output();
+            }
+            if (options.clear_timings_on_kernel_restart) {
+                console.log(log_prefix, 'Binding kernel_restarting.Kernel event to clear timings.');
+                events.on('kernel_restarting.Kernel', clear_timing_data_all);
+            }
+
+            // if displaying relative times, update them at intervals
+            if (!options.display_absolute_timings) {
+                var period_ms = 1000 * Math.max(1, options.relative_timing_update_period);
+                setInterval(_update_all_timing_areas, period_ms);
+            }
+        }).catch(function on_error (reason) {
+            console.error(log_prefix, 'Error:', reason);
+        });
+    }
+
+    return {
+        load_jupyter_extension : load_jupyter_extension,
+        load_ipython_extension : load_jupyter_extension
+    };
+});

.local/share/jupyter/nbextensions/execute_time/readme.md

@@ -0,0 +1,206 @@
+Execute Time
+============
+
+This extension displays when the last execution of a code cell occurred, and
+how long it took.
+
+Every executed code cell is extended with a new area, attached at the bottom of
+the input area, that displays the time at which the user sent the cell to the
+kernel for execution.
+When the kernel finishes executing the cell, the area is updated with the
+duration of the execution.
+The timing information is stored in the cell metadata, and restored on notebook
+load.
+
+![](execution-timings-box.png)
+
+
+Toggling display
+----------------
+
+The timing area can be hidden by double clicking on it, or using the
+`Cell -> Toggle timings -> Selected`
+menu item.
+The menu item
+`Cell -> Toggle timings -> All`
+hides (shows) all the timing areas in the notebook, if the first cell is
+currently shown (hidden).
+
+![](execution-timings-menu.png)
+
+
+Options
+-------
+
+The nbextension offers a few options for how to display and interpret
+timestamps.
+Options are stored in the `notebook` section of the server's nbconfig, under
+the key `ExecuteTime`.
+The easiest way to configure these is using the
+[jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator),
+which if you got this nbextension in the usual way from
+[jupyter_contrib_nbextensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions),
+should also have been installed.
+
+Alternatively, you can also configure them directly with a few lines of python.
+For example, to alter the displayed message, use relative timestamps,
+and set them to update every 5 seconds, we can use the following python
+snippet:
+
+```python
+from notebook.services.config import ConfigManager
+ConfigManager().update('notebook', {'ExecuteTime': {
+   	'display_absolute_timestamps': False,
+    'relative_timing_update_period': 5,
+    'template': {
+    	'executed': 'started ${start_time}, finished in ${duration}',
+    }
+}})
+```
+
+The available options are:
+
+* `ExecuteTime.clear_timings_on_clear_output`: When cells' outputs are cleared,
+  also clear their timing data, e.g. when using the
+  `Kernel > Restart & Clear Output` menu item
+
+* `ExecuteTime.clear_timings_on_kernel_restart`: Clear all cells' execution
+  timing data on any kernel restart event
+
+* `ExecuteTime.display_absolute_timings`: Display absolute timings for the
+  start/end time of execution. Setting this `false` will result in the display
+  of a relative timestamp like 'a few seconds ago' (see the moment.js function
+  [fromNow](https://momentjs.com/docs/#/displaying/fromnow/)
+  for details). Defaults to `true`.
+
+* `ExecuteTime.display_absolute_format`: The format to use when displaying
+  absolute timings (see `ExecuteTime.display_absolute_timings`, above).
+  See the moment.js function
+  [format](https://momentjs.com/docs/#/displaying/format/)
+  for details of the template tokens available.
+  Defaults to `'YYYY-MM-DD HH:mm:ss'`.
+
+* `ExecuteTime.relative_timing_update_period`: Seconds to wait between updating
+  the relative timestamps, if using them (see
+  `ExecuteTime.display_absolute_timings`, above).
+  Defaults to `10`.
+
+* `ExecuteTime.display_in_utc`: Display times in UTC, rather than in the local
+  timezone set by the browser.
+  Defaults to `false`.
+
+* `ExecuteTime.default_kernel_to_utc`: For kernel timestamps which do not
+  specify a timezone, assume UTC.
+  Defaults to `true`.
+
+* `ExecuteTime.display_right_aligned`: Right-align the text in the timing area
+  under each cell.
+  Defaults to `false`.
+
+* `ExecuteTime.highlight.use`: Highlight the displayed execution time on
+  completion of execution.
+  Defaults to `true`.
+
+* `ExecuteTime.highlight.color`: Color to use for highlighting the displayed
+  execution time.
+  Defaults to `'#00BB00'`.
+
+* `ExecuteTime.template.executed`: Template for the timing message for executed
+  cells. See readme for     replacement tokens.
+  Defaults to `'executed in ${duration}, finished ${end_time}'`.
+
+* `ExecuteTime.template.queued`: Template for the timing message for queued
+  cells. The template uses an ES2015-like syntax, but replaces only the exact
+  strings `${start_time}`, plus (if defined) `${end_time}` and `${duration}`.
+  Defaults to `'execution queued ${start_time}'`.
+
+
+
+Limitations
+-----------
+
+
+### timezones
+
+As discussed in
+[ipython-contrib/jupyter_contrib_nbextensions#549](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/549),
+[ipython-contrib/jupyter_contrib_nbextensions#904](https://github.com/ipython-contrib/jupyter_contrib_nbextensions/issues/904),
+and
+[jupyter/jupyter_client#143](https://github.com/jupyter/jupyter_client/issues/143),
+although they are (now) supposed to, Jupyter kernels don't always specify a
+timezone for their timestamps, which can cause problems when the
+[moment.js](https://momentjs.com/)
+library assumes the local timezone, rather than UTC, which is what most kernels
+are actually using.
+To help to address this, see the [options](#Options) above, which can be used
+ to assume UTC for unzoned timestamps.
+
+
+### execution queues
+
+For a reason I don't understand, when multiple cells are queued for execution,
+the kernel doesn't send a reply immediately after finishing executing each
+cell.
+Some replies are delayed, and sent at the same time as later replies, meaning
+that the output of a cell can be updated with its finished value, before the
+notebook recieves the kernel execution reply.
+For the same reason, you can see this in the fact that the star for an
+executing cell can remain next to two cells at once, if several are queued to
+execute together.
+Since this extension uses the times in the kernel message (see internals,
+below), and these remain correct, the timings displayed are still accurate,
+but they may get displayed later due to this kernel issue.
+
+
+Installation
+------------
+
+Install the master version of the jupyter_contrib_nbextensions repository as
+explained in the docs at
+[jupyter-contrib-nbextensions.readthedocs.io](https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/install.html).
+
+Then you can use the
+[jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator)
+to enable/disable this extension for all notebooks.
+
+Internals
+---------
+
+The execution start and end times are stored in the cell metadata as ISO8601
+strings, for example:
+
+```json
+{
+	"ExecuteTime": {
+    	"start_time": "2016-02-11T18:51:18.536796",
+    	"end_time": "2016-02-11T18:51:35.806119"
+	}
+}
+```
+
+The times in the timing areas are formatted using the
+[moment.js](https://momentjs.com/) library (already included as part of
+Jupyter), but the durations use a custom formatting function, as
+I ([@jcb91](https://github.com/jcb91))
+couldn't find an existing one that I liked.
+
+The event `execute.CodeCell` is caught in order to create a start time, and add
+the timing area with its 'Execution queued at' message.
+The extension again uses [moment.js](https://momentjs.com/) for formatting this
+as an ISO string time.
+
+To determine the execution time, the extension patches the Jupyter class
+prototype `CodeCell.prototype.get_callbacks` from `notebook/js/codecell.js`.
+This patch then patches the `callbacks.shell.reply` function returned by the
+original `CodeCell.prototype.get_callbacks`, wrapping it in a function which
+reads the `msg.header.date` value from the kernel message, to provide the
+execution end time.
+This is more accurate than creating a new time, which can be affected by
+client-side variability.
+In addition, for accurate timings, the start time is also revised using
+the `msg.metadata.started` value supplied in the callback, which can be very
+different from the time the cell was queued for execution (as a result of
+other cells already being executed).
+The kernel reply message times are already ISO8601 strings, so no conversion is
+necessary, although again, [moment.js](https://momentjs.com/) is used for
+parsing and diff'ing them.

.local/share/jupyter/nbextensions/exercise/history.md

@@ -0,0 +1,26 @@
+Exercise nbextension history
+----------------------------
+
+Update december 30, 2015:
+(@jfbercher) Updated to jupyter notebook 4.1.x
+
+Update december 22, 2015:
+(@jfbercher)
+  Added the metadata solution_first to mark the beginning of an exercise. It is now possible to have several consecutive exercises. 
+
+October 21-27,2015: 
+(@jfbercher)
+
+1- the extension now works with the multicell API, that is
+  - several cells can be selected either via the rubberband extension 
+  - or via Shift-J (select next) or Shift-K (select previous) keyboard shortcuts
+(probably Shit-up and down will work in a near future) 
+Note: previously, the extension required the selected cells to be marked with a "selected" key in metadata. This is no more necessary with the new API.
+Then clicking on the toolbar button turns these cells into a "solution" which is hidden by default ** Do not forget to keep the Shift key pressed down while clicking on the menu button (otherwise selected cells will be lost)** 
+2- the "state" of solutions, hidden or shown, is saved and restored at reload/restart. We use the "solution" metadata to store the current state.
+3- A small issue (infinite loop when a solution was defined at the bottom edge of the notebook have been corrected)
+4- Added a keyboard shortcut (Alt-S with S for solution]
+
+October-November 2014 (?):
+
+Several versions (@juhasch)

.local/share/jupyter/nbextensions/exercise/main.js

@@ -0,0 +1,169 @@
+// Copyright (c) IPython-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+
+// Hide or display solutions in a notebook
+
+/*
+December  6, 2017 @jcb91: use bootstrap 'hidden' class to play nicely with collapsible_headings
+December 30, 2015: update to 4.1
+Update december 22, 2015:
+  Added the metadata solution_first to mark the beginning of an exercise. It is now possible to have several consecutive exercises.
+Update october 21-27,2015:
+1- the extension now works with the multicell API, that is
+   - several cells can be selected either via the rubberband extension
+   - or via Shift-J (select next) or Shift-K (select previous) keyboard shortcuts
+    (probably Shit-up and down will work in a near future)
+    Note: previously, the extension required the selected cells to be marked with a "selected" key in metadata. This is no more necessary with the new API.
+Then clicking on the toolbar button transforms these cells into a "solution" which is hidden by default
+** Do not forget to keep the Shift key pressed down while clicking on the menu button
+(otherwise selected cells will be lost)**
+2- the "state" of solutions, hidden or shown, is saved and restored at reload/restart. We use the "solution" metadata to store the current state.
+3- A small issue (infinite loop when a solution was defined at the bottom edge of the notebook have been corrected)
+4- Added a keyboard shortcut (Alt-S) [S for solution]
+*/
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'base/js/events',
+], function(IPython, $, requirejs, events) {
+    "use strict";
+
+    var cfg = {
+        add_button: true,
+        use_hotkey: true,
+        hotkey: 'Alt-S',
+    };
+
+    /**
+     * handle click event
+     *
+     * @method click_solution_lock
+     * @param evt {Event} jquery event
+    */
+    function click_solution_lock(evt) {
+        var cell = IPython.notebook.get_selected_cell();
+        var is_locked = cell.metadata.solution === 'hidden';
+        cell.metadata.solution = is_locked ? 'shown' : 'hidden';
+        element_set_locked(cell, !is_locked);
+        cell = IPython.notebook.get_next_cell(cell);
+        while (cell !== null && cell.metadata.solution !== undefined && !cell.metadata.solution_first) {
+            cell.element.toggleClass('hidden', !is_locked);
+            cell.metadata.solution = is_locked ? 'shown' : 'hidden';
+            cell = IPython.notebook.get_next_cell(cell);
+        }
+    }
+
+    /**
+     * Create or Remove an exercise in selected cells
+     *
+     * @method create_remove_exercise
+     *
+     */
+    function create_remove_exercise() {
+        var lcells = IPython.notebook.get_selected_cells();
+        // It is possible that no cell is selected
+        if (lcells.length < 1) {
+            alert("Exercise extension:  \nPlease select some cells...");
+            return;
+        }
+
+        var cell = lcells[0];
+        if (cell.metadata.solution_first) {
+            remove_element(cell);
+            delete cell.metadata.solution_first;
+            while (cell !== null && cell.metadata.solution !== undefined && !cell.metadata.solution_first) {
+                delete cell.metadata.solution;
+                cell.element.removeClass('hidden');
+                cell = IPython.notebook.get_next_cell(cell);
+            }
+        }
+        else {
+            cell.metadata.solution_first = true;
+            cell.metadata.solution = 'hidden';
+            add_element(cell);
+            for (var k = 1; k < lcells.length; k++) {
+                cell = lcells[k];
+                cell.element.addClass('hidden');
+                cell.metadata.solution = 'hidden';
+            }
+        }
+    }
+
+    /**
+     *  Add a lock control to the given cell
+     */
+    function add_element(cell) {
+        var ctrl = cell.element.find('.exercise');
+        if (ctrl.length > 0) return ctrl;
+        var locked = cell.metadata.solution === 'hidden';
+        ctrl = $('<div class="exercise fa">')
+            .prependTo(cell.element)
+            .on('click', click_solution_lock);
+        element_set_locked(cell, locked);
+        return ctrl;
+    }
+
+    function remove_element(cell) {
+        cell.element.find('.exercise').remove();
+    }
+
+    function element_set_locked(cell, locked) {
+        return cell.element.find('.exercise')
+            .toggleClass('fa-plus-square-o', locked)
+            .toggleClass('fa-minus-square-o', !locked);
+    }
+
+    function refresh_exercises() {
+        var in_exercise = false;
+        IPython.notebook.get_cells().forEach(function(cell) {
+            if (in_exercise && cell.metadata.solution !== undefined && !cell.metadata.solution_first) {
+                cell.element.toggleClass('hidden', cell.metadata.solution  === 'hidden');
+            } else {
+                in_exercise = false;
+            }
+            if (!in_exercise && cell.metadata.solution !== undefined) {
+                in_exercise = true;
+                add_element(cell);
+            }
+        });
+    }
+
+    function load_ipython_extension() {
+        // add css
+        $('<link rel="stylesheet" type="text/css">')
+            .attr('href', requirejs.toUrl('./main.css'))
+            .appendTo('head');
+
+        // Hide/display existing solutions at startup
+        events.on('notebook_loaded.Notebook', refresh_exercises);
+        if (IPython.notebook._fully_loaded) refresh_exercises();
+
+        var action_name = IPython.keyboard_manager.actions.register({
+            help    : 'Exercise: Create/Remove exercise',
+            help_index: 'ht',
+            icon    : 'fa-mortar-board',
+            handler : create_remove_exercise
+        }, 'create_remove_exercise', 'exercise');
+
+        IPython.notebook.config.loaded.then(function() {
+            $.extend(true, cfg, IPython.notebook.config.data);
+
+            if (cfg.add_button) {
+                IPython.toolbar.add_buttons_group([action_name]);
+            }
+            if (cfg.use_hotkey && cfg.hotkey) {
+                var cmd_shrts = {};
+                cmd_shrts[cfg.hotkey] = action_name;
+                IPython.keyboard_manager.command_shortcuts.add_shortcuts(cmd_shrts);
+            }
+        }).catch(function(err) {
+            console.warn('[exercise] error:', err);
+        });
+    }
+
+    return {
+        load_ipython_extension: load_ipython_extension,
+    };
+});

.local/share/jupyter/nbextensions/hide_header/hide_header.yaml

@@ -0,0 +1,12 @@
+Type: IPython Notebook Extension
+Name: Hide Header
+Link: README.md
+Description: Toggle visibility of all of header, menubar, toolbar using a hotkey
+Main: main.js
+Compatibility: 4.x, 5.x
+Parameters:
+- name: header_toggle
+  description: keybinding for toggling header visibility
+  input_type: hotkey
+  default: ctrl-H
+

.local/share/jupyter/nbextensions/hide_input_all/hide_input_all.yaml

@@ -0,0 +1,7 @@
+Type: IPython Notebook Extension
+Compatibility: 3.x 4.x 5.x
+Main: main.js
+Name: Hide input all
+Description: "toggle display of all code cells' inputs"
+Icon: icon.png
+Link: readme.md

.local/share/jupyter/nbextensions/hide_input_all/main.js

@@ -0,0 +1,59 @@
+// toggle display of all code cells' inputs
+
+define([
+    'jquery',
+    'base/js/namespace',
+    'base/js/events'
+], function(
+    $,
+    Jupyter,
+    events
+) {
+    "use strict";
+
+    function set_input_visible(show) {
+        Jupyter.notebook.metadata.hide_input = !show;
+
+        if (show) $('div.input').show('slow');
+        else $('div.input').hide('slow');
+
+        var btn = $('#toggle_codecells');
+        btn.toggleClass('active', !show);
+
+        var icon = btn.find('i');
+        icon.toggleClass('fa-eye', show);
+        icon.toggleClass('fa-eye-slash', !show);
+        $('#toggle_codecells').attr(
+            'title', (show ? 'Hide' : 'Show') + ' codecell inputs');
+    }
+
+    function toggle() {
+        set_input_visible($('#toggle_codecells').hasClass('active'));
+    }
+
+    function initialize () {
+        set_input_visible(Jupyter.notebook.metadata.hide_input !== true);
+    }
+
+    var load_ipython_extension = function() {
+        $(Jupyter.toolbar.add_buttons_group([
+            Jupyter.keyboard_manager.actions.register({
+                help   : 'Hide codecell inputs',
+                icon   : 'fa-eye',
+                handler: function() {
+                    toggle();
+                    setTimeout(function() { $('#toggle_codecells').blur(); }, 500);
+                }
+            }, 'hide-codecell-inputs', 'hide_input_all'),
+        ])).find('.btn').attr('id', 'toggle_codecells');
+        if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
+            // notebook_loaded.Notebook event has already happened
+            initialize();
+        }
+        events.on('notebook_loaded.Notebook', initialize);
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

.local/share/jupyter/nbextensions/hide_input_all/readme.md

@@ -0,0 +1,44 @@
+Hide all Input
+==============
+This extension allows hiding all codecells of a notebook. This can be achieved by clicking on the button toolbar:
+
+![](icon.png)
+
+Typically, all codecells are shown with their corresponding output:
+
+![](hide_input_all_show.png)
+
+Clicking on the "Toggle codecell display" toolbar button hides all codecells:
+
+![](hide_input_all_hide.png)
+
+
+Internals
+---------
+
+The codecell hiding state is stored in the metadata `IPython.notebook.metadata.hide_input`.
+If it is set to `true`, all codecells will be hidden on reload.
+
+The `nbextensions.tpl` template is provided in the
+`jupyter_contrib_nbextensions.nbconvert_support` templates directory (see the
+docs mentioned above for how to find it)
+
+To use, add the template to your `nbconvert` call:
+
+    jupyter nbconvert --template=nbextensions --to=html my_notebook.ipynb
+
+The nbextensions template will respect the `nb.metadata.hide_input` flag, and
+filter the cell's output prompt (the bit that looks like `Out[27]:`).
+The filter is only used for html output, not for PDF or LaTeX output.
+
+If you want to _keep_ the cell output prompt, you will have to remove the lines
+
+    {% block output_group -%}
+    {%- if cell.metadata.hide_output or nb.metadata.hide_input -%}
+    {%- else -%}
+        {{ super() }}
+    {%- endif -%}
+    {% endblock output_group %}
+
+in the `nbextensions.tpl` file.
+ 

.local/share/jupyter/nbextensions/highlighter/demo_highlighter.ipynb

@@ -0,0 +1,96 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## The highlighter extension:\n",
+    "\n",
+    "- Firstable, the extension provides <span class=\"mark\">several toolbar buttons</span> for highlighting a selected text _within a markdown cell_. Three different \\`color schemes' are provided, which can be easily customized in the \\textit{stylesheet} `highlighter.css`. The last button enables to remove all highlightings in the current cell. \n",
+    "- This works both <span class=\"burk\">when the cell is _rendered_ and when the cell is in edit mode</span>; \n",
+    "- In both modes, it is possible to highlight formatted portions of text (In rendered mode, since the selected text loose its formatting, an heuristic is applied to find the best alignment with the actual text)\n",
+    "- When no text is selected, the whole cell is highlighted; \n",
+    "- The extension also provides two keyboard shortcuts (Alt-G and Alt-H) which fire the highlighting of the selected text. \n",
+    "- Highlights can be preserved when exporting to html or to LaTeX -- details are provided in [export_highlights](export_highlights.ipynb)\n",
+    "\n",
+    "\n",
+    "![](image.gif)\n",
+    "\n",
+    "## Installation:\n",
+    "\n",
+    "The extension can be installed with the nice UI available on jupyter_contrib_nbextensions website, which also allows to enable/disable the extension. \n",
+    "\n",
+    "You may also install the extension from the original repo: issue\n",
+    "```bash\n",
+    "jupyter nbextension install https://rawgit.com/jfbercher/small_nbextensions/master/highlighter.zip  --user\n",
+    "\n",
+    "```\n",
+    "at the command line.\n",
+    "\n",
+    "### Testing: \n",
+    "\n",
+    "Use a code cell with\n",
+    "```javascript\n",
+    "%%javascript\n",
+    "require(\"base/js/utils\").load_extensions(\"highlighter/highlighter\")\n",
+    "```\n",
+    "\n",
+    "### Automatic load\n",
+    "You may also automatically load the extension for any notebook via\n",
+    "```bash\n",
+    "jupyter nbextension enable highlighter/highlighter\t\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "require(\"base/js/utils\").load_extensions(\"highlighter/highlighter\")"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%javascript\n",
+    "require(\"base/js/utils\").load_extensions(\"highlighter/highlighter\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "interactive_sols": {
+   "cbx_id": 1
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.4.3+"
+  },
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

.local/share/jupyter/nbextensions/highlighter/export_highlights.tex

@@ -0,0 +1,457 @@
+
+% Default to the notebook output style
+
+
+% Inherit from the specified cell style.
+
+
+
+
+
+    
+\documentclass{article}
+
+    
+    
+
+    \usepackage{graphicx} % Used to insert images
+    \usepackage{adjustbox} % Used to constrain images to a maximum size 
+    \usepackage{color} % Allow colors to be defined
+    \usepackage{enumerate} % Needed for markdown enumerations to work
+    \usepackage{geometry} % Used to adjust the document margins
+    \usepackage{amsmath} % Equations
+    \usepackage{amssymb} % Equations
+    \usepackage{eurosym} % defines \euro
+    \usepackage[mathletters]{ucs} % Extended unicode (utf-8) support
+    \usepackage[utf8x]{inputenc} % Allow utf-8 characters in the tex document
+    \usepackage{fancyvrb} % verbatim replacement that allows latex
+    \usepackage{grffile} % extends the file name processing of package graphics 
+                         % to support a larger range 
+    % The hyperref package gives us a pdf with properly built
+    % internal navigation ('pdf bookmarks' for the table of contents,
+    % internal cross-reference links, web links for URLs, etc.)
+    \usepackage{hyperref}
+    \usepackage{longtable} % longtable support required by pandoc >1.10
+    \usepackage{booktabs}  % table support for pandoc > 1.12.2
+    
+\usepackage{color}
+\usepackage{soul}
+\usepackage[framemethod=tikz]{mdframed}
+
+
+    
+    
+    \definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
+    \definecolor{darkorange}{rgb}{.71,0.21,0.01}
+    \definecolor{darkgreen}{rgb}{.12,.54,.11}
+    \definecolor{myteal}{rgb}{.26, .44, .56}
+    \definecolor{gray}{gray}{0.45}
+    \definecolor{lightgray}{gray}{.95}
+    \definecolor{mediumgray}{gray}{.8}
+    \definecolor{inputbackground}{rgb}{.95, .95, .85}
+    \definecolor{outputbackground}{rgb}{.95, .95, .95}
+    \definecolor{traceback}{rgb}{1, .95, .95}
+    % ansi colors
+    \definecolor{red}{rgb}{.6,0,0}
+    \definecolor{green}{rgb}{0,.65,0}
+    \definecolor{brown}{rgb}{0.6,0.6,0}
+    \definecolor{blue}{rgb}{0,.145,.698}
+    \definecolor{purple}{rgb}{.698,.145,.698}
+    \definecolor{cyan}{rgb}{0,.698,.698}
+    \definecolor{lightgray}{gray}{0.5}
+    
+    % bright ansi colors
+    \definecolor{darkgray}{gray}{0.25}
+    \definecolor{lightred}{rgb}{1.0,0.39,0.28}
+    \definecolor{lightgreen}{rgb}{0.48,0.99,0.0}
+    \definecolor{lightblue}{rgb}{0.53,0.81,0.92}
+    \definecolor{lightpurple}{rgb}{0.87,0.63,0.87}
+    \definecolor{lightcyan}{rgb}{0.5,1.0,0.83}
+    
+    % commands and environments needed by pandoc snippets
+    % extracted from the output of `pandoc -s`
+    \providecommand{\tightlist}{%
+      \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
+    \DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}}
+    % Add ',fontsize=\small' for more characters per line
+    \newenvironment{Shaded}{}{}
+    \newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{{#1}}}}
+    \newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.56,0.13,0.00}{{#1}}}
+    \newcommand{\DecValTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}}
+    \newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}}
+    \newcommand{\FloatTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}}
+    \newcommand{\CharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}}
+    \newcommand{\StringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}}
+    \newcommand{\CommentTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textit{{#1}}}}
+    \newcommand{\OtherTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{{#1}}}
+    \newcommand{\AlertTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{{#1}}}}
+    \newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.02,0.16,0.49}{{#1}}}
+    \newcommand{\RegionMarkerTok}[1]{{#1}}
+    \newcommand{\ErrorTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{{#1}}}}
+    \newcommand{\NormalTok}[1]{{#1}}
+    
+    % Define a nice break command that doesn't care if a line doesn't already
+    % exist.
+    \def\br{\hspace*{\fill} \\* }
+    % Math Jax compatability definitions
+    \def\gt{>}
+    \def\lt{<}
+    % Document parameters
+    \title{export\_highlights}
+    
+    
+\author{}
+
+    
+
+    % Pygments definitions
+    
+\makeatletter
+\def\PY@reset{\let\PY@it=\relax \let\PY@bf=\relax%
+    \let\PY@ul=\relax \let\PY@tc=\relax%
+    \let\PY@bc=\relax \let\PY@ff=\relax}
+\def\PY@tok#1{\csname PY@tok@#1\endcsname}
+\def\PY@toks#1+{\ifx\relax#1\empty\else%
+    \PY@tok{#1}\expandafter\PY@toks\fi}
+\def\PY@do#1{\PY@bc{\PY@tc{\PY@ul{%
+    \PY@it{\PY@bf{\PY@ff{#1}}}}}}}
+\def\PY#1#2{\PY@reset\PY@toks#1+\relax+\PY@do{#2}}
+
+\expandafter\def\csname PY@tok@gp\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
+\expandafter\def\csname PY@tok@no\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.53,0.00,0.00}{##1}}}
+\expandafter\def\csname PY@tok@il\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@sx\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@kt\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.69,0.00,0.25}{##1}}}
+\expandafter\def\csname PY@tok@mo\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@sh\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@bp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@gd\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.63,0.00,0.00}{##1}}}
+\expandafter\def\csname PY@tok@sb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@err\endcsname{\def\PY@bc##1{\setlength{\fboxsep}{0pt}\fcolorbox[rgb]{1.00,0.00,0.00}{1,1,1}{\strut ##1}}}
+\expandafter\def\csname PY@tok@nd\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
+\expandafter\def\csname PY@tok@gr\endcsname{\def\PY@tc##1{\textcolor[rgb]{1.00,0.00,0.00}{##1}}}
+\expandafter\def\csname PY@tok@kd\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@s\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@cs\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@sd\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@ss\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@nn\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@w\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.73,0.73}{##1}}}
+\expandafter\def\csname PY@tok@kn\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@sc\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@s1\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@ge\endcsname{\let\PY@it=\textit}
+\expandafter\def\csname PY@tok@cp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.74,0.48,0.00}{##1}}}
+\expandafter\def\csname PY@tok@gh\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
+\expandafter\def\csname PY@tok@gi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.63,0.00}{##1}}}
+\expandafter\def\csname PY@tok@vc\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@si\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.53}{##1}}}
+\expandafter\def\csname PY@tok@ow\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
+\expandafter\def\csname PY@tok@vg\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@sr\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.53}{##1}}}
+\expandafter\def\csname PY@tok@cm\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@c\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@mi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@kc\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@ne\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.82,0.25,0.23}{##1}}}
+\expandafter\def\csname PY@tok@nf\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@go\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
+\expandafter\def\csname PY@tok@m\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@mh\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@nc\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@mb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@se\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.13}{##1}}}
+\expandafter\def\csname PY@tok@gt\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.27,0.87}{##1}}}
+\expandafter\def\csname PY@tok@nv\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@c1\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@kp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@s2\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@nb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@ni\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.60,0.60,0.60}{##1}}}
+\expandafter\def\csname PY@tok@k\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@na\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.49,0.56,0.16}{##1}}}
+\expandafter\def\csname PY@tok@o\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@mf\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@nl\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.63,0.63,0.00}{##1}}}
+\expandafter\def\csname PY@tok@nt\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@gs\endcsname{\let\PY@bf=\textbf}
+\expandafter\def\csname PY@tok@vi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@gu\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.50,0.00,0.50}{##1}}}
+\expandafter\def\csname PY@tok@kr\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+
+\def\PYZbs{\char`\\}
+\def\PYZus{\char`\_}
+\def\PYZob{\char`\{}
+\def\PYZcb{\char`\}}
+\def\PYZca{\char`\^}
+\def\PYZam{\char`\&}
+\def\PYZlt{\char`\<}
+\def\PYZgt{\char`\>}
+\def\PYZsh{\char`\#}
+\def\PYZpc{\char`\%}
+\def\PYZdl{\char`\$}
+\def\PYZhy{\char`\-}
+\def\PYZsq{\char`\'}
+\def\PYZdq{\char`\"}
+\def\PYZti{\char`\~}
+% for compatibility with earlier versions
+\def\PYZat{@}
+\def\PYZlb{[}
+\def\PYZrb{]}
+\makeatother
+
+
+
+    
+
+    
+    % Prevent overflowing lines due to hard-to-break entities
+    \sloppy 
+    % Setup hyperref package
+    \hypersetup{
+      breaklinks=true,  % so long urls are correctly broken across lines
+      colorlinks=true,
+      urlcolor=blue,
+      linkcolor=darkorange,
+      citecolor=darkgreen,
+      }
+    % Slightly bigger margins than the latex defaults
+    
+    \geometry{verbose,tmargin=1in,bmargin=1in,lmargin=1in,rmargin=1in}
+    
+    
+    \newcommand{\highlighta}[1]{{\sethlcolor{yellow} \textcolor{red}{\hl{#1}}}}
+    \newcommand{\highlightb}[1]{{\sethlcolor{red} \textcolor{yellow}{\hl{#1}}}}
+    \newcommand{\highlightc}[1]{{\sethlcolor{green} \textcolor{yellow}{\hl{#1}}}}
+    \newenvironment{highlightA}{\begin{mdframed}[hidealllines=true,backgroundcolor=yellow!20]}{\end{mdframed}}
+    \newenvironment{highlightB}{\begin{mdframed}[hidealllines=true,backgroundcolor=red!20]}{\end{mdframed}}
+    \newenvironment{highlightC}{\begin{mdframed}[hidealllines=true,backgroundcolor=green!20]}{\end{mdframed}}
+
+
+%\usepackage{foo}
+
+    \begin{document}
+    
+    
+    \maketitle
+    
+    
+
+    
+    \section{Exporting the notebook}\label{exporting-the-notebook}
+
+As suggested by @juhasch, it is interesting to keep the highlights when
+exporting the notebook to another format. We give and explain below some
+possibilities:
+
+    \subsection{Short version}\label{short-version}
+
+\begin{itemize}
+\item
+  Html export:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{nbconvert FILE  --config JUPYTER_DATA_DIR/extensions/highlight_html_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+\item
+  LaTeX export:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{nbconvert FILE  --config JUPYTER_DATA_DIR/extensions/highlight_latex_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+
+  where JUPYTER\_DATA\_DIR can be found from the output of
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{--paths}
+\end{Highlighting}
+\end{Shaded}
+
+  eg \texttt{\textasciitilde{}/.local/share/jupyter} in my case. Seems
+  to be
+  \texttt{c:\textbackslash{}users\textbackslash{}NAME\textbackslash{}AppData\textbackslash{}Roaming\textbackslash{}jupyter}
+  under Windows.
+\end{itemize}
+
+Examples can be found here: \href{tst_highlights.ipynb}{initial
+notebook}, \href{tst_highlights.html}{html version},
+\href{tst_highlights.pdf}{pdf version} (after an additional LaTeX
+\(\rightarrow\) pdf compilation).
+
+    \subsection{Html export}\label{html-export}
+
+This is quite easy. Actually, highlight formatting embedded in markdown
+cells is preserved while converting with the standard
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{jupyter} \NormalTok{nbconvert file.ipynb}
+\end{Highlighting}
+\end{Shaded}
+
+However, the css file is missing and must be added. Here we have several
+possibilities
+
+\begin{itemize}
+\item
+  Embed the css \emph{within} the notebook. For that, consider the last
+  cell of the present notebook. This code reads the css file
+  \texttt{highlighter.css} in the extension directory and displays the
+  corresponding style. So doing the
+  \texttt{\textless{}style\textgreater{}\ ...\textless{}/style\textgreater{}}
+  section will be present in the cell output and interpreted by the web
+  browser. Drawbacks of this solution is that user still have to execute
+  this cell and that the this is not language agnostic.
+\item
+  Use a \textbf{template file} to link or include the css file during
+  conversion. Such a file is provided as
+  \texttt{templates/highlighter.tpl}. It was choosen here to
+  \emph{include} the css content in the produced html file rather than
+  linking it. This avoids the necessity to keep the css file with the
+  html files.
+\item
+  This works directly if the css resides in the same directory as the
+  file the user is attempting to convert --thus requires the user to
+  copy \texttt{highlighter.css} in the current directory. Then the
+  conversion is simply
+
+\begin{Shaded}
+\begin{Highlighting}[]
+  \KeywordTok{jupyter} \NormalTok{nbconvert file.ipynb --template highlighter}
+\end{Highlighting}
+\end{Shaded}
+\item
+  It still remains two problems with this approach. First, it can be
+  annoying to have to systematically copy the css file in the current
+  directory. Second, the data within the html tags is not converted (and
+  thus markdown remains unmodified). A solution is to use a pair of
+  preprocessor/postprocessor that modify the html tags and enable the
+  subsequent markdown to html converter to operate on the included data.
+  Also, a config file is provided which redefines the template path to
+  enable direct inclusion of the css file in the extension directory.
+  Unfortunately, \highlighta{it seems that the \emph{full path} to
+  the config file has to be provided}. This file resides in the
+  extensions subdirectory of the jupyter\_data\_dir. The path can be
+  found by looking at the output of
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{--paths}
+\end{Highlighting}
+\end{Shaded}
+
+  Then the command to issue for converting the notebook to html is
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{nbconvert FILE  --config JUPYTER_DATA_DIR/extensions/highlight_html_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+\end{itemize}
+
+For instance
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{jupyter} \NormalTok{nbconvert tst_highlights.ipynb  --config ~/.local/share/jupyter/extensions/highlight_html_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+
+    \subsection{LaTeX export}\label{latex-export}
+
+This is a bit more complicated since the direct conversion removes all
+html formatting present in markdown cells. Thus use again a
+\textbf{preprocessor} which runs before the markdown \(\rightarrow\)
+LaTeX conversion. In turn, it appears that we also need to postprocess
+the result.
+
+Three LaTeX commands, namely \emph{highlighta, highlightb, highlightc},
+and three environments \emph{highlightA, highlightB, highlightC} are
+defined. Highlighting html markup is then transformed into the
+corresponding LaTeX commands and the text for completely highlighted
+cells is put in the adequate LaTeX environment.
+
+Pre and PostProcessor classes are defined in the file
+\texttt{pp\_highlighter.py} located in the \texttt{extensions}
+directory. A LaTeX template, that includes the necessary packages and
+the definitions of commands/environments is provides as
+\texttt{highlighter.tplx} in the template directory. The template
+inherits from \texttt{article.ltx}. For more complex scenarios,
+typically if the latex template file has be customized, the user shall
+modify its template or inherit from his base template rather than from
+article.
+
+Finally, a config file fixes the different options for the conversion.
+Then the command to issue is simply
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{jupyter} \NormalTok{nbconvert FILE  --config JUPYTER_DATA_DIR/extensions/highlight_latex_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+
+e.g.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{jupyter} \NormalTok{nbconvert tst_highlights.ipynb  --config ~/.local/share/jupyter/extensions/highlight_latex_cfg.py }
+\end{Highlighting}
+\end{Shaded}
+
+    \subsection{Configuring paths}\label{configuring-paths}
+
+\highlighta{For those who do not have taken the extension from the
+\texttt{jupyter_contrib_nbextensions} repository or have not configured
+extensions via its \texttt{setup.py} utility,} a file
+\texttt{set\_paths.py} is present in the extension directory (it is
+merely a verbatim copy of the relevant parts in setup.py). This file
+configure the paths to the \texttt{templates} and \texttt{extension}
+directories. It should be executed by something like
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{python3} \NormalTok{set_paths.py}
+\end{Highlighting}
+\end{Shaded}
+
+Additionaly, you may also have to execute \texttt{mv\_paths.py} if you
+installed from the original repo via
+\texttt{jupyter\ nbextension\ install\ ..}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{python3} \NormalTok{mv_paths.py}
+\end{Highlighting}
+\end{Shaded}
+
+    \subsection{Example for embedding the css within the notebook before
+conversion}\label{example-for-embedding-the-css-within-the-notebook-before-conversion}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+>>> \PY{k+kn}{from} \PY{n+nn}{IPython}\PY{n+nn}{.}\PY{n+nn}{core}\PY{n+nn}{.}\PY{n+nn}{display} \PY{k}{import} \PY{n}{display}\PY{p}{,} \PY{n}{HTML}
+... \PY{k+kn}{from} \PY{n+nn}{jupyter\PYZus{}core}\PY{n+nn}{.}\PY{n+nn}{paths} \PY{k}{import} \PY{n}{jupyter\PYZus{}config\PYZus{}dir}\PY{p}{,} \PY{n}{jupyter\PYZus{}data\PYZus{}dir}
+... \PY{k+kn}{import} \PY{n+nn}{os}
+... \PY{n}{csspath}\PY{o}{=}\PY{n}{os}\PY{o}{.}\PY{n}{path}\PY{o}{.}\PY{n}{join}\PY{p}{(}\PY{n}{jupyter\PYZus{}data\PYZus{}dir}\PY{p}{(}\PY{p}{)}\PY{p}{,}\PY{l+s}{\PYZsq{}}\PY{l+s}{nbextensions}\PY{l+s}{\PYZsq{}}\PY{p}{,}
+...                        \PY{l+s}{\PYZsq{}}\PY{l+s}{highlighter}\PY{l+s}{\PYZsq{}}\PY{p}{,}\PY{l+s}{\PYZsq{}}\PY{l+s}{highlighter.css}\PY{l+s}{\PYZsq{}}\PY{p}{)}
+... \PY{n}{HTML}\PY{p}{(}\PY{l+s}{\PYZsq{}}\PY{l+s}{\PYZlt{}style\PYZgt{}}\PY{l+s}{\PYZsq{}}\PY{o}{+}\PY{n+nb}{open}\PY{p}{(}\PY{n}{csspath}\PY{p}{,} \PY{l+s}{\PYZdq{}}\PY{l+s}{r}\PY{l+s}{\PYZdq{}}\PY{p}{)}\PY{o}{.}\PY{n}{read}\PY{p}{(}\PY{p}{)}\PY{o}{+}\PY{l+s}{\PYZsq{}}\PY{l+s}{\PYZlt{}/style\PYZgt{}}\PY{l+s}{\PYZsq{}}\PY{p}{)}
+    \end{Verbatim}
+
+    
+    
+    \begin{verbatim}
+<IPython.core.display.HTML object>
+    \end{verbatim}
+
+    
+
+
+    % Add a bibliography block to the postdoc
+    
+    
+    
+    \end{document}

.local/share/jupyter/nbextensions/highlighter/highlighter.css

@@ -0,0 +1,98 @@
+.mark {
+    background-color: #f2ee97;
+    color: black;
+    display: inline;
+}
+
+.burk {
+    background-color: #ff9292;
+    color: #f9f9f9;
+    display: inline;
+}
+
+.girk {
+    background-color: #afe5ad;
+    color: black;
+    display: inline;
+}
+
+.birk {
+    background-color: #83b8f4;
+    color: #fff;
+    display: inline;
+}
+
+.pirk {
+    background-color: #ecb3d2;
+    color: #000;
+    display: inline;
+}
+
+/**/
+
+button.mark {
+    background-image: url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='iso-8859-1'%3F%3E%3C!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 297 297' style='enable-background:new 0 0 297 297;' xml:space='preserve'%3E%3Cg%3E%3Cg id='XMLID_48_'%3E%3Cg%3E%3Cpath style='fill:%23fff;' d='M63.648,169.162l71.18,71.19l-61.09,12.21c-0.93,0.19-1.78,0.65-2.45,1.32l-9.74,9.74 l-21.17-21.18l9.74-9.73c0.66-0.67,1.12-1.53,1.31-2.45L63.648,169.162z'/%3E%3Cpath style='fill:%23000;' d='M230.278,81.592c2.81,2.81,2.81,7.38,0,10.19l-73.19,73.2c-2.81,2.81-7.38,2.81-10.19,0 l-7.62-7.62c-2.81-2.81-2.81-7.38,0-10.19l73.19-73.2c1.36-1.36,3.17-2.11,5.1-2.11c1.92,0,3.73,0.75,5.09,2.11L230.278,81.592z' /%3E%3Cpolygon style='fill:%23f2ee97;' points='53.918,271.242 45.428,279.732 13.668,269.152 32.748,250.072 '/%3E%3Cpath style='fill:%23f2ee97;' d='M283.918,54.022c4.41,4.41,4.71,11.58,0.68,16.34l-140.34,165.86l-76.48-76.49l165.85-140.34 c4.76-4.02,11.94-3.73,16.34,0.68L283.918,54.022z M241.968,86.682c0-4.3-1.64-8.6-4.91-11.87l-7.61-7.62 c-3.18-3.17-7.39-4.92-11.88-4.92s-8.71,1.75-11.88,4.92l-73.19,73.2c-3.17,3.17-4.92,7.39-4.92,11.87 c0,4.49,1.75,8.71,4.92,11.88l7.62,7.62c3.27,3.27,7.57,4.91,11.87,4.91c4.3,0,8.61-1.64,11.88-4.91l73.19-73.2 C240.328,95.282,241.968,90.982,241.968,86.682z'/%3E%3Cpath d='M290.698,47.242c7.91,7.9,8.44,20.78,1.22,29.31c0,0-143.78,169.92-143.83,169.95c-0.66,0.74-1.55,1.28-2.59,1.49 l-68.46,13.69l-26.92,26.93c-0.92,0.91-2.14,1.4-3.4,1.4c-0.5,0-1.01-0.08-1.51-0.24l-41.93-13.98 c-1.58-0.53-2.77-1.83-3.15-3.45c-0.38-1.61,0.1-3.31,1.28-4.49l40.9-40.9l13.69-68.45c0.22-1.09,0.79-1.99,1.57-2.67 c0.01-0.01,169.87-143.76,169.87-143.76c8.53-7.22,21.41-6.69,29.31,1.22L290.698,47.242z M284.598,70.362 c4.03-4.76,3.73-11.93-0.68-16.34l-33.95-33.95c-4.4-4.41-11.58-4.7-16.34-0.68l-165.85,140.34l76.48,76.49L284.598,70.362z M134.828,240.352l-71.18-71.19l-12.22,61.1c-0.19,0.92-0.65,1.78-1.31,2.45l-9.74,9.73l21.17,21.18l9.74-9.74 c0.67-0.67,1.52-1.13,2.45-1.32L134.828,240.352z M45.428,279.732l8.49-8.49l-21.17-21.17l-19.08,19.08L45.428,279.732z'/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3C/svg%3E%0A");
+    background-repeat: no-repeat;
+}
+
+button.highlighter-btn {
+    height: 24px;
+    width: 29px;
+    background-size: 21px;
+    background-position: center;
+    border: none;
+}
+
+button.burk {
+    background-image: url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='iso-8859-1'%3F%3E%3C!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 297 297' style='enable-background:new 0 0 297 297;' xml:space='preserve'%3E%3Cg%3E%3Cg id='XMLID_48_'%3E%3Cg%3E%3Cpath style='fill:%23fff;' d='M63.648,169.162l71.18,71.19l-61.09,12.21c-0.93,0.19-1.78,0.65-2.45,1.32l-9.74,9.74 l-21.17-21.18l9.74-9.73c0.66-0.67,1.12-1.53,1.31-2.45L63.648,169.162z'/%3E%3Cpath style='fill:%23000;' d='M230.278,81.592c2.81,2.81,2.81,7.38,0,10.19l-73.19,73.2c-2.81,2.81-7.38,2.81-10.19,0 l-7.62-7.62c-2.81-2.81-2.81-7.38,0-10.19l73.19-73.2c1.36-1.36,3.17-2.11,5.1-2.11c1.92,0,3.73,0.75,5.09,2.11L230.278,81.592z' /%3E%3Cpolygon style='fill:%23ff9292;' points='53.918,271.242 45.428,279.732 13.668,269.152 32.748,250.072 '/%3E%3Cpath style='fill:%23ff9292;' d='M283.918,54.022c4.41,4.41,4.71,11.58,0.68,16.34l-140.34,165.86l-76.48-76.49l165.85-140.34 c4.76-4.02,11.94-3.73,16.34,0.68L283.918,54.022z M241.968,86.682c0-4.3-1.64-8.6-4.91-11.87l-7.61-7.62 c-3.18-3.17-7.39-4.92-11.88-4.92s-8.71,1.75-11.88,4.92l-73.19,73.2c-3.17,3.17-4.92,7.39-4.92,11.87 c0,4.49,1.75,8.71,4.92,11.88l7.62,7.62c3.27,3.27,7.57,4.91,11.87,4.91c4.3,0,8.61-1.64,11.88-4.91l73.19-73.2 C240.328,95.282,241.968,90.982,241.968,86.682z'/%3E%3Cpath d='M290.698,47.242c7.91,7.9,8.44,20.78,1.22,29.31c0,0-143.78,169.92-143.83,169.95c-0.66,0.74-1.55,1.28-2.59,1.49 l-68.46,13.69l-26.92,26.93c-0.92,0.91-2.14,1.4-3.4,1.4c-0.5,0-1.01-0.08-1.51-0.24l-41.93-13.98 c-1.58-0.53-2.77-1.83-3.15-3.45c-0.38-1.61,0.1-3.31,1.28-4.49l40.9-40.9l13.69-68.45c0.22-1.09,0.79-1.99,1.57-2.67 c0.01-0.01,169.87-143.76,169.87-143.76c8.53-7.22,21.41-6.69,29.31,1.22L290.698,47.242z M284.598,70.362 c4.03-4.76,3.73-11.93-0.68-16.34l-33.95-33.95c-4.4-4.41-11.58-4.7-16.34-0.68l-165.85,140.34l76.48,76.49L284.598,70.362z M134.828,240.352l-71.18-71.19l-12.22,61.1c-0.19,0.92-0.65,1.78-1.31,2.45l-9.74,9.73l21.17,21.18l9.74-9.74 c0.67-0.67,1.52-1.13,2.45-1.32L134.828,240.352z M45.428,279.732l8.49-8.49l-21.17-21.17l-19.08,19.08L45.428,279.732z'/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3C/svg%3E%0A");
+    background-repeat: no-repeat;
+}
+
+button.girk {
+    background-image: url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='iso-8859-1'%3F%3E%3C!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 297 297' style='enable-background:new 0 0 297 297;' xml:space='preserve'%3E%3Cg%3E%3Cg id='XMLID_48_'%3E%3Cg%3E%3Cpath style='fill:%23fff;' d='M63.648,169.162l71.18,71.19l-61.09,12.21c-0.93,0.19-1.78,0.65-2.45,1.32l-9.74,9.74 l-21.17-21.18l9.74-9.73c0.66-0.67,1.12-1.53,1.31-2.45L63.648,169.162z'/%3E%3Cpath style='fill:%23000;' d='M230.278,81.592c2.81,2.81,2.81,7.38,0,10.19l-73.19,73.2c-2.81,2.81-7.38,2.81-10.19,0 l-7.62-7.62c-2.81-2.81-2.81-7.38,0-10.19l73.19-73.2c1.36-1.36,3.17-2.11,5.1-2.11c1.92,0,3.73,0.75,5.09,2.11L230.278,81.592z' /%3E%3Cpolygon style='fill:%23afe5ad;' points='53.918,271.242 45.428,279.732 13.668,269.152 32.748,250.072 '/%3E%3Cpath style='fill:%23afe5ad;' d='M283.918,54.022c4.41,4.41,4.71,11.58,0.68,16.34l-140.34,165.86l-76.48-76.49l165.85-140.34 c4.76-4.02,11.94-3.73,16.34,0.68L283.918,54.022z M241.968,86.682c0-4.3-1.64-8.6-4.91-11.87l-7.61-7.62 c-3.18-3.17-7.39-4.92-11.88-4.92s-8.71,1.75-11.88,4.92l-73.19,73.2c-3.17,3.17-4.92,7.39-4.92,11.87 c0,4.49,1.75,8.71,4.92,11.88l7.62,7.62c3.27,3.27,7.57,4.91,11.87,4.91c4.3,0,8.61-1.64,11.88-4.91l73.19-73.2 C240.328,95.282,241.968,90.982,241.968,86.682z'/%3E%3Cpath d='M290.698,47.242c7.91,7.9,8.44,20.78,1.22,29.31c0,0-143.78,169.92-143.83,169.95c-0.66,0.74-1.55,1.28-2.59,1.49 l-68.46,13.69l-26.92,26.93c-0.92,0.91-2.14,1.4-3.4,1.4c-0.5,0-1.01-0.08-1.51-0.24l-41.93-13.98 c-1.58-0.53-2.77-1.83-3.15-3.45c-0.38-1.61,0.1-3.31,1.28-4.49l40.9-40.9l13.69-68.45c0.22-1.09,0.79-1.99,1.57-2.67 c0.01-0.01,169.87-143.76,169.87-143.76c8.53-7.22,21.41-6.69,29.31,1.22L290.698,47.242z M284.598,70.362 c4.03-4.76,3.73-11.93-0.68-16.34l-33.95-33.95c-4.4-4.41-11.58-4.7-16.34-0.68l-165.85,140.34l76.48,76.49L284.598,70.362z M134.828,240.352l-71.18-71.19l-12.22,61.1c-0.19,0.92-0.65,1.78-1.31,2.45l-9.74,9.73l21.17,21.18l9.74-9.74 c0.67-0.67,1.52-1.13,2.45-1.32L134.828,240.352z M45.428,279.732l8.49-8.49l-21.17-21.17l-19.08,19.08L45.428,279.732z'/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3C/svg%3E%0A");
+    background-repeat: no-repeat;
+}
+
+button.birk {
+    background-image: url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='iso-8859-1'%3F%3E%3C!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 297 297' style='enable-background:new 0 0 297 297;' xml:space='preserve'%3E%3Cg%3E%3Cg id='XMLID_48_'%3E%3Cg%3E%3Cpath style='fill:%23fff;' d='M63.648,169.162l71.18,71.19l-61.09,12.21c-0.93,0.19-1.78,0.65-2.45,1.32l-9.74,9.74 l-21.17-21.18l9.74-9.73c0.66-0.67,1.12-1.53,1.31-2.45L63.648,169.162z'/%3E%3Cpath style='fill:%23000;' d='M230.278,81.592c2.81,2.81,2.81,7.38,0,10.19l-73.19,73.2c-2.81,2.81-7.38,2.81-10.19,0 l-7.62-7.62c-2.81-2.81-2.81-7.38,0-10.19l73.19-73.2c1.36-1.36,3.17-2.11,5.1-2.11c1.92,0,3.73,0.75,5.09,2.11L230.278,81.592z' /%3E%3Cpolygon style='fill:%2383b8f4;' points='53.918,271.242 45.428,279.732 13.668,269.152 32.748,250.072 '/%3E%3Cpath style='fill:%2383b8f4;' d='M283.918,54.022c4.41,4.41,4.71,11.58,0.68,16.34l-140.34,165.86l-76.48-76.49l165.85-140.34 c4.76-4.02,11.94-3.73,16.34,0.68L283.918,54.022z M241.968,86.682c0-4.3-1.64-8.6-4.91-11.87l-7.61-7.62 c-3.18-3.17-7.39-4.92-11.88-4.92s-8.71,1.75-11.88,4.92l-73.19,73.2c-3.17,3.17-4.92,7.39-4.92,11.87 c0,4.49,1.75,8.71,4.92,11.88l7.62,7.62c3.27,3.27,7.57,4.91,11.87,4.91c4.3,0,8.61-1.64,11.88-4.91l73.19-73.2 C240.328,95.282,241.968,90.982,241.968,86.682z'/%3E%3Cpath d='M290.698,47.242c7.91,7.9,8.44,20.78,1.22,29.31c0,0-143.78,169.92-143.83,169.95c-0.66,0.74-1.55,1.28-2.59,1.49 l-68.46,13.69l-26.92,26.93c-0.92,0.91-2.14,1.4-3.4,1.4c-0.5,0-1.01-0.08-1.51-0.24l-41.93-13.98 c-1.58-0.53-2.77-1.83-3.15-3.45c-0.38-1.61,0.1-3.31,1.28-4.49l40.9-40.9l13.69-68.45c0.22-1.09,0.79-1.99,1.57-2.67 c0.01-0.01,169.87-143.76,169.87-143.76c8.53-7.22,21.41-6.69,29.31,1.22L290.698,47.242z M284.598,70.362 c4.03-4.76,3.73-11.93-0.68-16.34l-33.95-33.95c-4.4-4.41-11.58-4.7-16.34-0.68l-165.85,140.34l76.48,76.49L284.598,70.362z M134.828,240.352l-71.18-71.19l-12.22,61.1c-0.19,0.92-0.65,1.78-1.31,2.45l-9.74,9.73l21.17,21.18l9.74-9.74 c0.67-0.67,1.52-1.13,2.45-1.32L134.828,240.352z M45.428,279.732l8.49-8.49l-21.17-21.17l-19.08,19.08L45.428,279.732z'/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3C/svg%3E%0A");
+    background-repeat: no-repeat;
+}
+
+button.pirk {
+    background-image: url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='iso-8859-1'%3F%3E%3C!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 297 297' style='enable-background:new 0 0 297 297;' xml:space='preserve'%3E%3Cg%3E%3Cg id='XMLID_48_'%3E%3Cg%3E%3Cpath style='fill:%23fff;' d='M63.648,169.162l71.18,71.19l-61.09,12.21c-0.93,0.19-1.78,0.65-2.45,1.32l-9.74,9.74 l-21.17-21.18l9.74-9.73c0.66-0.67,1.12-1.53,1.31-2.45L63.648,169.162z'/%3E%3Cpath style='fill:%23000;' d='M230.278,81.592c2.81,2.81,2.81,7.38,0,10.19l-73.19,73.2c-2.81,2.81-7.38,2.81-10.19,0 l-7.62-7.62c-2.81-2.81-2.81-7.38,0-10.19l73.19-73.2c1.36-1.36,3.17-2.11,5.1-2.11c1.92,0,3.73,0.75,5.09,2.11L230.278,81.592z' /%3E%3Cpolygon style='fill:%23ecb3d2;' points='53.918,271.242 45.428,279.732 13.668,269.152 32.748,250.072 '/%3E%3Cpath style='fill:%23ecb3d2;' d='M283.918,54.022c4.41,4.41,4.71,11.58,0.68,16.34l-140.34,165.86l-76.48-76.49l165.85-140.34 c4.76-4.02,11.94-3.73,16.34,0.68L283.918,54.022z M241.968,86.682c0-4.3-1.64-8.6-4.91-11.87l-7.61-7.62 c-3.18-3.17-7.39-4.92-11.88-4.92s-8.71,1.75-11.88,4.92l-73.19,73.2c-3.17,3.17-4.92,7.39-4.92,11.87 c0,4.49,1.75,8.71,4.92,11.88l7.62,7.62c3.27,3.27,7.57,4.91,11.87,4.91c4.3,0,8.61-1.64,11.88-4.91l73.19-73.2 C240.328,95.282,241.968,90.982,241.968,86.682z'/%3E%3Cpath d='M290.698,47.242c7.91,7.9,8.44,20.78,1.22,29.31c0,0-143.78,169.92-143.83,169.95c-0.66,0.74-1.55,1.28-2.59,1.49 l-68.46,13.69l-26.92,26.93c-0.92,0.91-2.14,1.4-3.4,1.4c-0.5,0-1.01-0.08-1.51-0.24l-41.93-13.98 c-1.58-0.53-2.77-1.83-3.15-3.45c-0.38-1.61,0.1-3.31,1.28-4.49l40.9-40.9l13.69-68.45c0.22-1.09,0.79-1.99,1.57-2.67 c0.01-0.01,169.87-143.76,169.87-143.76c8.53-7.22,21.41-6.69,29.31,1.22L290.698,47.242z M284.598,70.362 c4.03-4.76,3.73-11.93-0.68-16.34l-33.95-33.95c-4.4-4.41-11.58-4.7-16.34-0.68l-165.85,140.34l76.48,76.49L284.598,70.362z M134.828,240.352l-71.18-71.19l-12.22,61.1c-0.19,0.92-0.65,1.78-1.31,2.45l-9.74,9.73l21.17,21.18l9.74-9.74 c0.67-0.67,1.52-1.13,2.45-1.32L134.828,240.352z M45.428,279.732l8.49-8.49l-21.17-21.17l-19.08,19.08L45.428,279.732z'/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3C/svg%3E%0A");
+    background-repeat: no-repeat;
+}
+
+i#menu-hgl, i.highlighter-close {
+    padding-left: 20px;
+}
+
+#higlighter_menu.btn:focus, #higlighter_menu.btn:active:focus, #higlighter_menu.btn.active:focus, #higlighter_menu.btn.focus, #higlighter_menu.btn:active.focus, #higlighter_menu.btn.active.focus :focus {
+    outline: 0 !important;
+}
+
+#higlighter_menu {
+    background-image: url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='iso-8859-1'%3F%3E%3C!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --%3E%3Csvg version='1.1' id='Capa_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 512.001 512.001' style='enable-background:new 0 0 512.001 512.001;' xml:space='preserve'%3E%3Cpolygon style='fill:%23FFABCD;' points='387.375,480.658 383.919,157.034 503.991,157.034 500.535,480.658 '/%3E%3Cpolygon style='fill:%23FF6BA6;' points='382.637,161.05 419.416,90.494 468.484,90.494 505.272,161.05 '/%3E%3Cpolygon style='fill:%23FFABCD;' points='418.626,94.51 418.626,43.148 469.274,30.795 469.274,94.51 '/%3E%3Cg%3E%3Cpolygon style='fill:%23FBDF97;' points='230.672,94.51 230.672,43.148 281.33,30.795 281.33,94.51 '/%3E%3Cpolygon style='fill:%23FBDF97;' points='199.422,480.658 195.965,157.034 316.036,157.034 312.58,480.658 '/%3E%3C/g%3E%3Cpolygon style='fill:%23FBC640;' points='194.683,161.05 231.462,90.494 280.539,90.494 317.318,161.05 '/%3E%3Cg%3E%3Cpolygon style='fill:%2344C973;' points='11.466,480.658 8.011,157.034 128.083,157.034 124.626,480.658 '/%3E%3Cpolygon style='fill:%2344C973;' points='42.728,94.51 42.728,43.148 93.375,30.795 93.375,94.51 '/%3E%3C/g%3E%3Cpolygon style='fill:%23248A48;' points='6.729,161.05 43.518,90.494 92.585,90.494 129.364,161.05 '/%3E%3Cpath d='M443.734,375.969c-12.919,0-12.941,20.078,0,20.078C456.653,396.048,456.675,375.969,443.734,375.969z'/%3E%3Cpath d='M13.453,488.689H122.64c5.502,0,9.98-4.43,10.039-9.932l3.413-319.608c0.004-0.354-0.012-0.705-0.044-1.05 c-0.001-0.014-0.004-0.027-0.006-0.041c-0.037-0.382-0.1-0.758-0.18-1.127c-0.02-0.093-0.045-0.185-0.068-0.277 c-0.074-0.305-0.163-0.604-0.264-0.898c-0.031-0.09-0.061-0.181-0.095-0.27c-0.138-0.361-0.289-0.715-0.466-1.055 c-0.005-0.01-0.008-0.02-0.013-0.029l-0.008-0.015c-0.01-0.02-0.021-0.04-0.031-0.06l-33.51-64.284V33.351 c0-3.081-1.416-5.992-3.838-7.895c-2.423-1.903-5.584-2.588-8.58-1.858L42.357,34.972c-4.497,1.097-7.66,5.125-7.66,9.753v45.316 L1.176,154.325c-0.011,0.02-0.021,0.04-0.031,0.06l-0.008,0.015c-0.005,0.009-0.008,0.019-0.012,0.028 c-0.177,0.34-0.328,0.694-0.466,1.055c-0.034,0.09-0.064,0.181-0.096,0.272c-0.101,0.293-0.19,0.592-0.264,0.898 c-0.023,0.092-0.048,0.184-0.068,0.277c-0.079,0.369-0.143,0.744-0.18,1.126c-0.001,0.014-0.005,0.028-0.006,0.042 c-0.032,0.345-0.048,0.697-0.044,1.051l3.413,319.608C3.473,484.259,7.951,488.689,13.453,488.689z M23.386,468.611l-3.198-299.53 h95.719l-3.198,299.53H23.386z M54.775,52.61l26.554-6.476v36.329H54.775V52.61z M50.823,102.541h34.456l24.22,46.461H26.596 L50.823,102.541z'/%3E%3Cpath d='M68.046,215.121c-5.545,0-10.039,4.495-10.039,10.039v160.366c0,5.545,4.495,10.039,10.039,10.039 s10.039-4.495,10.039-10.039V225.16C78.086,219.615,73.591,215.121,68.046,215.121z'/%3E%3Cpath d='M188.518,155.756c-0.102,0.293-0.19,0.592-0.264,0.898c-0.023,0.092-0.048,0.184-0.068,0.277 c-0.079,0.369-0.143,0.744-0.18,1.127c-0.001,0.014-0.005,0.027-0.006,0.041c-0.032,0.345-0.048,0.696-0.044,1.05l3.413,319.608 c0.059,5.501,4.537,9.932,10.039,9.932h109.187c5.502,0,9.98-4.43,10.039-9.932l3.413-319.608c0.004-0.354-0.012-0.705-0.044-1.05 c-0.001-0.014-0.004-0.027-0.006-0.041c-0.037-0.382-0.1-0.758-0.18-1.127c-0.02-0.093-0.045-0.185-0.068-0.277 c-0.074-0.305-0.163-0.604-0.264-0.898c-0.031-0.09-0.061-0.181-0.095-0.27c-0.138-0.361-0.289-0.715-0.466-1.055 c-0.005-0.01-0.008-0.02-0.013-0.029l-0.008-0.015c-0.01-0.02-0.021-0.04-0.031-0.06l-33.511-64.284V33.351 c0-3.081-1.415-5.991-3.838-7.895c-2.422-1.903-5.585-2.588-8.579-1.858l-46.642,11.374c-4.497,1.096-7.661,5.125-7.661,9.753 v45.317l-33.509,64.283c-0.011,0.02-0.021,0.04-0.031,0.06l-0.008,0.015c-0.005,0.009-0.008,0.02-0.013,0.029 c-0.177,0.34-0.328,0.694-0.466,1.055C188.579,155.575,188.549,155.665,188.518,155.756z M211.34,468.611l-3.198-299.53h95.719 l-3.199,299.53H211.34z M242.719,52.61l26.564-6.478v36.331h-26.564L242.719,52.61L242.719,52.61z M238.768,102.541h34.466 l24.22,46.461H214.55L238.768,102.541z'/%3E%3Cpath d='M256.001,215.121c-5.545,0-10.039,4.495-10.039,10.039v160.366c0,5.545,4.495,10.039,10.039,10.039 c5.545,0,10.039-4.495,10.039-10.039V225.16C266.04,219.615,261.545,215.121,256.001,215.121z'/%3E%3Cpath d='M508.587,478.758l3.413-319.608c0.004-0.355-0.012-0.706-0.044-1.051c-0.001-0.014-0.005-0.028-0.006-0.042 c-0.037-0.382-0.1-0.758-0.18-1.126c-0.02-0.092-0.045-0.185-0.068-0.277c-0.074-0.305-0.163-0.604-0.264-0.898 c-0.031-0.091-0.062-0.182-0.096-0.272c-0.138-0.361-0.289-0.715-0.466-1.055c-0.005-0.009-0.008-0.019-0.012-0.028l-0.008-0.015 c-0.01-0.02-0.02-0.04-0.031-0.06l-33.52-64.283v-56.69c0-3.081-1.416-5.992-3.838-7.895c-2.423-1.903-5.585-2.588-8.579-1.858 l-46.632,11.374c-4.497,1.097-7.66,5.125-7.66,9.753v45.317l-33.51,64.283c-0.011,0.02-0.021,0.04-0.031,0.06l-0.008,0.015 c-0.005,0.009-0.008,0.02-0.013,0.029c-0.177,0.34-0.328,0.694-0.466,1.055c-0.034,0.089-0.064,0.18-0.095,0.27 c-0.102,0.293-0.19,0.592-0.264,0.898c-0.023,0.092-0.048,0.184-0.068,0.277c-0.079,0.369-0.143,0.744-0.18,1.127 c-0.001,0.014-0.005,0.027-0.006,0.041c-0.032,0.345-0.048,0.696-0.044,1.05l3.413,319.608c0.059,5.501,4.537,9.932,10.039,9.932 h109.186C504.051,488.689,508.528,484.259,508.587,478.758z M430.673,52.61l26.554-6.476v36.329h-26.554V52.61z M426.723,102.541 h34.456l24.227,46.461h-82.902L426.723,102.541z M399.293,468.611l-3.198-299.53h95.719l-3.199,299.53H399.293z'/%3E%3Cpath d='M443.955,215.121c-5.545,0-10.039,4.495-10.039,10.039v128.221c0,5.545,4.495,10.039,10.039,10.039 s10.039-4.495,10.039-10.039V225.16C453.994,219.615,449.5,215.121,443.955,215.121z'/%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3C/svg%3E%0A");
+    background-repeat: no-repeat;
+    background-position-x: 6px;
+    padding-right: 2px !important;
+    background-size: 18px;
+    background-position-y: center;
+}
+
+.toolbar .btn-group {
+    margin-top: 3px !important;
+}
+
+div#hgl {
+    padding-top: 2px;
+}
+
+#remove_highlights {
+    background-image: url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='iso-8859-1'%3F%3E%3C!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) --%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 297 297' style='enable-background:new 0 0 297 297;' xml:space='preserve'%3E%3Cg%3E%3Cg id='XMLID_48_'%3E%3Cg%3E%3Cpath style='fill:%23fff;' d='M63.648,169.162l71.18,71.19l-61.09,12.21c-0.93,0.19-1.78,0.65-2.45,1.32l-9.74,9.74 l-21.17-21.18l9.74-9.73c0.66-0.67,1.12-1.53,1.31-2.45L63.648,169.162z'/%3E%3Cpath style='fill:%23000;' d='M230.278,81.592c2.81,2.81,2.81,7.38,0,10.19l-73.19,73.2c-2.81,2.81-7.38,2.81-10.19,0 l-7.62-7.62c-2.81-2.81-2.81-7.38,0-10.19l73.19-73.2c1.36-1.36,3.17-2.11,5.1-2.11c1.92,0,3.73,0.75,5.09,2.11L230.278,81.592z' /%3E%3Cpolygon style='fill:%23fff;' points='53.918,271.242 45.428,279.732 13.668,269.152 32.748,250.072 '/%3E%3Cpath style='fill:%23fff;' d='M283.918,54.022c4.41,4.41,4.71,11.58,0.68,16.34l-140.34,165.86l-76.48-76.49l165.85-140.34 c4.76-4.02,11.94-3.73,16.34,0.68L283.918,54.022z M241.968,86.682c0-4.3-1.64-8.6-4.91-11.87l-7.61-7.62 c-3.18-3.17-7.39-4.92-11.88-4.92s-8.71,1.75-11.88,4.92l-73.19,73.2c-3.17,3.17-4.92,7.39-4.92,11.87 c0,4.49,1.75,8.71,4.92,11.88l7.62,7.62c3.27,3.27,7.57,4.91,11.87,4.91c4.3,0,8.61-1.64,11.88-4.91l73.19-73.2 C240.328,95.282,241.968,90.982,241.968,86.682z'/%3E%3Cpath d='M290.698,47.242c7.91,7.9,8.44,20.78,1.22,29.31c0,0-143.78,169.92-143.83,169.95c-0.66,0.74-1.55,1.28-2.59,1.49 l-68.46,13.69l-26.92,26.93c-0.92,0.91-2.14,1.4-3.4,1.4c-0.5,0-1.01-0.08-1.51-0.24l-41.93-13.98 c-1.58-0.53-2.77-1.83-3.15-3.45c-0.38-1.61,0.1-3.31,1.28-4.49l40.9-40.9l13.69-68.45c0.22-1.09,0.79-1.99,1.57-2.67 c0.01-0.01,169.87-143.76,169.87-143.76c8.53-7.22,21.41-6.69,29.31,1.22L290.698,47.242z M284.598,70.362 c4.03-4.76,3.73-11.93-0.68-16.34l-33.95-33.95c-4.4-4.41-11.58-4.7-16.34-0.68l-165.85,140.34l76.48,76.49L284.598,70.362z M134.828,240.352l-71.18-71.19l-12.22,61.1c-0.19,0.92-0.65,1.78-1.31,2.45l-9.74,9.73l21.17,21.18l9.74-9.74 c0.67-0.67,1.52-1.13,2.45-1.32L134.828,240.352z M45.428,279.732l8.49-8.49l-21.17-21.17l-19.08,19.08L45.428,279.732z'/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3Cg%3E%3C/g%3E%3C/svg%3E%0A");
+    background-repeat: no-repeat;
+    background-position-x: 6px;
+    padding-right: 2px !important;
+    background-size: 18px;
+    background-position-y: center;
+}

.local/share/jupyter/nbextensions/highlighter/highlighter.js

@@ -0,0 +1,378 @@
+/*
+Three different highlighting schemes "mark"|"burk"|"girk"|"birk"|"pirk" are defined in the css highlighter.css
+The following functions highlight the selected text, according to the scheme chosen by a menu button. More precisely, they replace selected text, both in edit or command mode, by 
+a span tag with a given class and the selected text as data.
+if no text is selected, then the whole cell is highlighted (using a div tag and a class corresponding to the chosen scheme). A function to remove all hihlightings is also provided. 
+*/
+
+function removeFullCellHighlight(cell_text) {
+    cell_text = cell_text.replace(/<div class=(?:"mark"|"burk"|"girk"|"birk"|"pirk")>\n([\s\S]*?)<\/div><i class="fa fa-lightbulb-o "><\/i>/g, function (w, g) {
+        return g
+    })
+    return cell_text
+}
+
+function fullCellHighlight(cell_text, scheme) {
+    cell_text = removeFullCellHighlight(cell_text);
+    return '<div class=' + '"' + scheme + '"' + '>\n' + cell_text + '</div><i class="fa fa-lightbulb-o "><\/i>'
+}
+
+function highlight(text, scheme) {
+    var scheme = scheme;
+    // replace by a span, wile preserving leading and trailing spaces
+    var rep = text.replace(/(\S[\S\s]*\S)/, function (w, internal_text) {
+        return '<span class=' + '"' + scheme + '"' + '>' + internal_text + '</span>'
+    })
+    return rep
+    //return '<span class='+'"'+scheme+'"'+'>'+text+'</span>'
+}
+
+
+function add_div(text) {
+    if (text.match(/^<div>([\S\s]*)<\/div>$/) == null) {
+        return '<div>' + text + '</div>'
+    } else {
+        return text
+    }
+}
+
+function rem_div(text) {
+    return text.replace(/^<div>([\S\s]*)<\/div>$/, function (w, g) {
+        return g
+    })
+}
+
+function highlightInCmdMode(event, scheme) {
+    var cell = IPython.notebook.get_selected_cell()
+    var cm = IPython.notebook.get_selected_cell().code_mirror
+    var selectedText = window.getSelection().toString();
+    var cell_text = cell.get_text();
+    if (selectedText.length == 0) {
+        cell_text = fullCellHighlight(cell_text, scheme);
+    } else {
+        var identifiedText = align(selectedText, cell_text);
+        cell_text = cell_text.replace(identifiedText, highlight(identifiedText, scheme));
+    }
+    cell.set_text(cell_text);
+    cell.render();
+    return false;
+}
+
+function highlightInEditMode(event, scheme) {
+    var cell = IPython.notebook.get_selected_cell()
+    var cm = cell.code_mirror
+    var selectedText = cm.getSelection()
+    if (selectedText.length == 0) {
+        var cell_text = cell.get_text();
+        cell_text = fullCellHighlight(cell_text, scheme);
+        cell.set_text(cell_text);
+    } else {
+        cm.replaceSelection(highlight(selectedText, scheme))
+    }
+    return false;
+}
+
+function removeHighlights() {
+    var cell = IPython.notebook.get_selected_cell();
+    var cell_text = removeFullCellHighlight(cell.get_text());
+    cell_text = cell_text.replace(/<span class=(?:"mark"|"burk"|"girk"|"birk"|"pirk")>([\s\S]*?)<\/span>/g,
+        function (w, g) {
+            return g
+        }
+    )
+    cell.set_text(cell_text)
+    cell.render();
+}
+
+//*****************************************************************************************
+// Utilitary functions for finding a candidate corresponding text from an unformatted selection
+
+/* In case of text selection in rendered cells, the returned text retains no formatting 
+therefore, when looking for this text in the actual formatted text, we need to do a 
+kind of "fuzzy" alignment. Though there exists specialized libraries for such task, 
+we have developed here a simple heuristics that should work 90% of the time, 
+but the problem cannot get a perfect solution. 
+A first point is to replace special characters that could be interpreded with 
+a special meaning in regular expressions. Then the idea is to find the exact matches 
+on the longest substring from the beginning of text, then the longest substring 
+from the end of the text. Finally, given the locations of the two substring, 
+we extract the corresponding global match in the original text. 
+*/
+function escapeRegExp(str) {
+    return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "#");
+    // return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+    return str
+}
+
+// Extract the longest matching substring from the beginning of the text
+function exsub_up(sub, text) {
+    for (k = 0; k <= sub.length; k++) {
+        if (text.match(sub.substr(0, k)) == null) {
+            k = k - 2
+            break
+        }
+    }
+    return text.match(sub.substr(0, k + 1))
+}
+
+// Extract the longest matching substring from the end of the text
+function exsub_down(sub, text) {
+    var L = sub.length
+    try {
+        for (k = 0; k <= sub.length; k++) {
+            tst = sub.substr(L - k - 1, L);
+            if (text.match(tst) == null) {
+                // console.log(tst)
+                k = k - 1
+                break
+            }
+        }
+        return text.match(sub.substr(L - k - 1, L))
+    } catch (e) {
+        console.log('Error', e)
+        return ""
+    }
+
+}
+
+// Function that tries to find the best match of the unformatted 
+// text in the formatted one. 
+
+function align(tofind, text) {
+
+    sub = escapeRegExp(tofind)
+    textModified = escapeRegExp(text)
+    //console.log(textModified.match(sub))
+    if (textModified.match(sub) == null) {
+        a = exsub_up(sub, textModified)
+        b = exsub_down(sub, textModified)
+        return text.substr(a.index, b.index + b[0].length - a.index)
+    } else {
+        var tmpMatch = textModified.match(sub)
+        return text.substr(tmpMatch.index, tmpMatch[0].length)
+    }
+}
+
+
+
+// ***************** Keyboard shortcuts ******************************
+
+var add_cmd_shortcuts = {
+    'Alt-g': {
+        help: 'highlight selected text',
+        help_index: 'ht',
+        handler: function (event) {
+            highlightInCmdMode("", mark);
+            return false;
+        }
+    },
+    'Alt-h': {
+        help: 'highlight selected text',
+        help_index: 'ht',
+        handler: function (event) {
+            highlightInCmdMode("", burk);
+            return false;
+        }
+    },
+};
+
+
+var add_edit_shortcuts = {
+    'Alt-g': {
+        help: 'highlight selected text',
+        help_index: 'ht',
+        handler: function (event) {
+            var highlight = mark;
+            highlightInEditMode("", mark);
+            return false;
+        }
+    },
+    'Alt-h': {
+        help: 'highlight selected text',
+        help_index: 'ht',
+        handler: function (event) {
+            var highlight = burk;
+            highlightInEditMode("", burk);
+            return false;
+        }
+    },
+};
+
+
+//******Toolbar buttons *************************************************
+
+function highlightText(scheme) {
+    var cell = IPython.notebook.get_selected_cell();
+    var rendered = cell.rendered;
+    if (rendered) highlightInCmdMode("", scheme);
+    else highlightInEditMode("", scheme);
+}
+
+
+function build_toolbar() {
+    var test = ' <div id="hgl" class="toolbar btn-group" role="toolbar"> \
+<button type="button" class="btn btn-default btn-group" id="higlighter_menu" href="#">\
+ <i id="menu-hgl" class="fa fa-caret-right"></i></button>\
+<div id="submenu" class="btn-group" style="font-weight:bold;margin-left:0" > \
+    <button type="button" class="btn btn-default highlighter-btn burk" style="font-weight:bold;margin-left:0"  href="#" id="b1"></button>\
+    <button type="button" class="btn btn-default highlighter-btn mark" style="font-weight:bold;margin-left:0"  href="#" id="b2"></button>\
+    <button type="button" class="btn btn-default highlighter-btn girk" style="font-weight:bold;margin-left:0"  href="#" id="b3"></button>\
+    <button type="button" class="btn btn-default highlighter-btn birk" style="font-weight:bold;margin-left:0"  href="#" id="b4"></button>\
+    <button type="button" class="btn btn-default highlighter-btn pirk" style="font-weight:bold;margin-left:0"  href="#" id="b5"></button>\
+<button type="button" class="btn btn-default" style="font-weight:bold;margin-left:0"\
+ href="#" id="remove_highlights">\<i class="fa fa-times highlighter-close"></i> </button></div>\
+                 </div>'
+
+
+    $("#maintoolbar-container").append(test);
+    $("#test").css({
+        'padding': '5px'
+    });
+
+    $("#submenu").hide(); // initially hide the submenu
+
+    //buttons initial css -- shall check if this is really necessary
+    // $("#higlighter_menu").css({
+    //     'padding': '2px 8px',
+    //     'display': 'inline-block',
+    //     'border': '1px solid',
+    //     'border-color': '#cccccc',
+    //     'font-weight': 'bold',
+    //     'text-align': 'center',
+    //     'vertical-align': 'middle',
+    //     'margin-left': '0px',
+    //     'margin-right': '0px'
+    // })
+
+
+    //Actions
+
+
+    $("#higlighter_menu")
+        .on('click', function () {
+            $("#submenu").toggle();
+            $("#menu-hgl").toggleClass("fa-caret-right")
+            $("#menu-hgl").toggleClass("fa-caret-left")
+        })
+        .attr('title', 'Highlight Selected Text');
+
+
+    $("#b1")
+        .on('click', function () {
+            highlightText("burk")
+        })
+        .on('mouseover', function () {
+            $("#b1").removeClass("btn btn-default").addClass("btn burk")
+            //.addClass("burk");
+        }) //!!
+        .on('mouseout', function () {
+            $("#b1").addClass("btn btn-default")
+        })
+
+
+    $("#b2")
+        .on('click', function () {
+            highlightText("mark")
+        })
+        .on('mouseover', function () {
+            $("#b2").removeClass("btn btn-default").addClass("btn mark")
+        }) //!!
+        .on('mouseout', function () {
+            $("#b2").addClass("btn btn-default")
+        })
+
+    $("#b3")
+        .on('click', function () {
+            highlightText("girk")
+        })
+        .on('mouseover', function () {
+            $(this).removeClass("btn btn-default").addClass("btn girk")
+        }) //!!
+        .on('mouseout', function () {
+            $(this).addClass("btn btn-default")
+        })
+
+    $("#b4")
+        .on('click', function () {
+            highlightText("birk")
+        })
+        .on('mouseover', function () {
+            $(this).removeClass("btn btn-default").addClass("btn birk")
+        }) //!!
+        .on('mouseout', function () {
+            $(this).addClass("btn btn-default")
+        })
+
+    $("#b5")
+        .on('click', function () {
+            highlightText("pirk")
+        })
+        .on('mouseover', function () {
+            $(this).removeClass("btn btn-default").addClass("btn pirk")
+        }) //!!
+        .on('mouseout', function () {
+            $(this).addClass("btn btn-default")
+        })
+
+
+    $("#remove_highlights")
+        .on('click', function () {
+            removeHighlights()
+        })
+        .attr('title', 'Remove highlightings in selected cell');
+} // end build_toolbar
+
+//******************************* MAIN FUNCTION **************************
+
+define(["require",
+    'base/js/namespace'
+], function (requirejs, Jupyter) {
+
+    var security = requirejs("base/js/security")
+
+    var load_css = function (name) {
+        var link = document.createElement("link");
+        link.type = "text/css";
+        link.rel = "stylesheet";
+        link.href = requirejs.toUrl(name);
+        document.getElementsByTagName("head")[0].appendChild(link);
+
+    };
+
+    //Load_ipython_extension
+    var load_ipython_extension = requirejs(['base/js/namespace'], function (Jupyter) {
+        "use strict";
+        if (Jupyter.version[0] < 3) {
+            console.log("This extension requires Jupyter or IPython >= 3.x")
+            return
+        }
+
+        console.log("[highlighter] Loading highlighter.css");
+        load_css('./highlighter.css')
+
+        IPython.keyboard_manager.edit_shortcuts.add_shortcuts(add_edit_shortcuts);
+        IPython.keyboard_manager.command_shortcuts.add_shortcuts(add_cmd_shortcuts);
+
+        build_toolbar();
+
+        var _on_reload = true; /* make sure cells render on reload */
+
+        //highlighter_init_cells(); /* initialize cells */
+
+
+        /* on reload */
+        $([Jupyter.events]).on('status_started.Kernel', function () {
+
+            //highlighter_init_cells();
+            console.log("[highlighter] reload...");
+            _on_reload = false;
+        })
+
+    }); //end of load_ipython_extension function
+
+    return {
+        load_ipython_extension: load_ipython_extension,
+    };
+}); //End of main function
+
+console.log("Loading ./highlighter.js");

.local/share/jupyter/nbextensions/highlighter/highlighter.yaml

@@ -0,0 +1,7 @@
+Type: IPython Notebook Extension
+Name: highlighter
+Description: Enable to highlight select text in a markdown cell
+Link: readme.md
+Icon: icon.png
+Main: highlighter.js
+Compatibility: 3.x, 4.x, 5.x

.local/share/jupyter/nbextensions/highlighter/readme.md

@@ -0,0 +1,47 @@
+Highlighter
+===========
+
+- Firstable, the extension provides <span class="mark">several toolbar buttons</span> for highlighting a selected text _within a markdown cell_. Three different \`color schemes' are provided, which can be easily customized in the stylesheet `highlighter.css`. The last button enables to remove all highlightings in the current cell. 
+- This works both <span class="burk">when the cell is _rendered_ and when the cell is in edit mode</span>; 
+- In both modes, it is possible to highlight formatted portions of text (In rendered mode, since the selected text loose its formatting, an heuristic is applied to find the best alignment with the actual text)
+- When no text is selected, the whole cell is highlighted; 
+- The extension also provides two keyboard shortcuts (Alt-G and Alt-H) which fire the highlighting of the selected text. 
+- Highlights can be preserved when exporting to html or to LaTeX -- details are provided in [export_highlights](https://rawgit.com/jfbercher/small_nbextensions/master/usability/highlighter/export_highlights.html)
+
+
+![](image.gif)
+
+
+Installation
+------------
+
+The extension can be installed with the nice UI available on jupyter_nbextensions_configurator website, which also allows to enable/disable the extension.
+
+You may also install the extension from the original repo: issue
+
+```bash
+jupyter nbextension install https://rawgit.com/jfbercher/small_nbextensions/master/highlighter.zip  --user
+```
+at the command line.
+
+
+Testing
+-------
+
+Use a code cell with
+
+```python
+%%javascript
+require("base/js/utils").load_extensions("highlighter/highlighter")
+```
+
+
+Automatic load
+--------------
+
+You may also automatically load the extension for any notebook via
+
+```bash
+jupyter nbextension enable highlighter/highlighter
+```
+

.local/share/jupyter/nbextensions/highlighter/tst_highlights.ipynb

@@ -0,0 +1,53 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# First cell\n",
+    "\n",
+    "<span class=\"mark\">In the first cell, we highlight *some words* using the different schemes provided.</span> \n",
+    "\n",
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus id lacus mauris. Etiam in dictum mauris. <span class=\"burk\">Morbi pharetra, **mauris a feugiat consequat**, est purus vulputate mauris, quis feugiat leo metus eu risus. Sed non luctus arcu.</span> Donec eu ipsum justo. Praesent sit amet euismod orci. Nam eu turpis quis enim pulvinar blandit in eu justo. Vivamus nec libero ipsum. Nunc tempus, mi at vestibulum congue, lacus ante faucibus dolor, quis varius elit felis id ipsum. <span class=\"girk\">Vivamus at mi lorem.</span> Integer quam massa, viverra et fermentum et, cursus faucibus nisl. Vestibulum sed est lacus. Morbi sit amet laoreet odio.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div class=\"mark\">\n",
+    "# Second cell\n",
+    "\n",
+    "The second cell is completely highlighted. \n",
+    "\n",
+    "\n",
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus id lacus mauris. Etiam in dictum mauris. Morbi pharetra, mauris a feugiat consequat, <span class=\"burk\">est purus vulputate mauris,</span> quis feugiat leo metus eu risus. Sed non luctus arcu. Donec eu ipsum justo. Praesent sit amet euismod orci. Nam eu turpis quis enim pulvinar blandit in eu justo. Vivamus nec libero ipsum. Nunc tempus, mi at vestibulum congue, <span class=\"girk\">lacus ante faucibus dolor</span>, quis varius elit felis id ipsum. Vivamus at mi lorem. Integer quam massa, viverra et fermentum et, cursus faucibus nisl. Vestibulum sed est lacus. Morbi sit amet laoreet odio.</div><i class=\"fa fa-lightbulb-o \"></i>"
+   ]
+  }
+ ],
+ "metadata": {
+  "interactive_sols": {
+   "cbx_id": 1
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.4.3+"
+  },
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

.local/share/jupyter/nbextensions/hinterland/README.md

@@ -0,0 +1,49 @@
+Hinterland
+==========
+
+Enable code autocompletion menu for every keypress in a code cell, instead of
+only calling it with tab.
+
+The nbextension adds an item to the help menu to turn auto-hinting on and off,
+and offers some options for configuration:
+
+
+Options
+-------
+
+* `hinterland.hint_delay`:
+  delay in milliseconds between keypress & hint request. This is used to help
+  ensure that the character from the keypress is added to the CodeMirror editor
+  *before* the hint request checks the character preceding the cursor against
+  the regexes below.
+
+* `hinterland.enable_at_start`:
+  Whether to enable hinterland's continuous hinting when notebook is first
+  opened, or if false, only when selected from the help-menu item.
+
+* `hinterland.hint_inside_comments`:
+  Whether to request hints while typing code comments. Defaults to false.
+
+* `hinterland.exclude_regexp`:
+  A regular expression tested against the character before the cursor, which,
+  if a match occurs, prevents autocompletion from being triggered. This is
+  useful, for example, to prevent triggering autocomplete on a colon, which is
+  included by the default Completer.reinvoke pattern. If blank, no test is
+  performed. Note that the regex will be created without any flags, making it
+  case sensitive.
+
+* `hinterland.include_regexp`:
+  A regular expression tested against the character before the cursor, which
+  must match in order for autocompletion to be triggered. If left blank, the
+  value of the notebook's `Completer.reinvoke_re` parameter is used, which can
+  be modified by kernels, but defaults to `/[%0-9a-z._/\\:~-]/i`. Note that
+  although the `Completer.reinvoke_re` default is case insensitive by virtue of
+  its `/i` flag, any regex specified by the user will be created without any
+  flags, making it case sensitive.
+
+* `hinterland.tooltip_regexp`:
+  A regular expression tested against the character before the cursor, which if
+  it matches, causes a tooltip to be triggered, instead of regular
+  autocompletion. For python, this is useful for example for function calls, so
+  the default regex matches opening parentheses. Note that the regex will be
+  created without any flags, making it case sensitive.

.local/share/jupyter/nbextensions/hinterland/hinterland.yaml

@@ -0,0 +1,73 @@
+Type: Jupyter Notebook Extension
+Main: hinterland.js
+Name: Hinterland
+Link: README.md
+Description: |
+  Enable code autocompletion menu for every keypress in a code cell, instead of
+  only enabling it with tab
+Compatibility: 4.x, 5.x
+Parameters:
+- name: hinterland.hint_delay
+  description: |
+    delay in milliseconds between keypress & hint request. This is used to help
+    ensure that the character from the keypress is added to the CodeMirror
+    editor *before* the hint request checks the character preceding the cursor
+    against the regexes below.
+  input_type: number
+  min: 1
+  step: 1
+  default: 20
+- name: hinterland.enable_at_start
+  description: |
+    Enable hinterland's continuous hinting when notebook is first opened, or
+    if false, only when selected from the help-menu item.
+  input_type: checkbox
+  default: true
+- name: hinterland.hint_inside_comments
+  description: |
+    Whether to request hints while typing code comments.
+  input_type: checkbox
+  default: false
+- name: hinterland.exclude_regexp
+  description: |
+    exclude_regexp:
+    A regular expression tested against the character before the cursor, which,
+    if a match occurs, prevents autocompletion from being triggered.
+    This is useful, for example, to prevent triggering autocomplete on a colon,
+    which  is included by the default Completer.reinvoke pattern.
+    If blank, no test is performed.
+    Note that the regex will be created without any flags, making it case
+    sensitive.
+  input_type: text
+  # note that the YAML single-quoted string allows us to use the \ character
+  # without escaping it, similar to python's raw string syntax
+  default: ':'
+- name: hinterland.include_regexp
+  description: |
+    include_regexp:
+    A regular expression tested against the character before the cursor, which
+    must match in order for autocompletion to be triggered.
+    If left blank, the value of the notebook's Completer.reinvoke_re parameter
+    is used, which can be modified by kernels, but defaults to
+    /[%0-9a-z._/\\:~-]/i.
+    Note that although the Completer.reinvoke_re default is case insensitive by
+    virtue of its /i flag, any regex specified by the user will be created
+    without any flags, making it case sensitive.
+  input_type: text
+  # note that the YAML single-quoted string allows us to use the \ character
+  # without escaping it, similar to python's raw string syntax
+  default: ''
+- name: hinterland.tooltip_regexp
+  description: |
+    tooltip_regexp:
+    A regular expression tested against the character before the cursor, which
+    if it matches, causes a tooltip to be triggered, instead of regular
+    autocompletion.
+    For python, this is useful for example for function calls, so the default
+    regex matches opening parentheses.
+    Note that the regex will be created without any flags, making it case
+    sensitive.
+  input_type: text
+  # note that the YAML single-quoted string allows us to use the \ character
+  # without escaping it, similar to python's raw string syntax
+  default: '\('

.local/share/jupyter/nbextensions/init_cell/README.md

@@ -0,0 +1,44 @@
+init_cell
+=========
+
+Add a cell toolbar selector to mark cells as 'initialization' cells .
+Such initialization cells are run:
+
+ * on clicking the provided button in the main toolbar
+   ![main toolabr button](icon.png)
+ * by default, on kernel ready notification for trusted notebooks.
+   This is configurable (see options section).
+   In untrusted notebooks, a warning is displayed if the cells would otherwise
+   have been run.
+
+
+Options
+-------
+
+This nbextension provides option configurable using the
+[jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator).
+
+Once the extension is enabled, turn on the cell toolbar within your Notebook using 
+the "View > Cell Toolbar > Initialization Cell" menu
+![Cell Toobar Menu](cell_toolbar_menu.png)
+
+
+The running of initialization cells on kernel ready notification can be
+frustrating if your kernel is attached to multiple frontends, or is persistent
+between frontend reloads (e.g. reloading the notebook browser page without
+killing the kernel).
+As such, the option `init_cell.run_on_kernel_ready` in the notebook config
+section controls whether this behaviour occurs.
+The server's config value can also be overridden on a per-notebook basis by
+setting `notebook.metadata.init_cell.run_on_kernel_ready`.
+
+
+Internals
+---------
+
+Cells are marked as initialization cells in their metadata, as
+
+  cell.metadata.init_cell = true
+
+The running of initialization cells on kernel ready is bound to the Jupyter
+event `kernel_ready.Kernel`.

.local/share/jupyter/nbextensions/init_cell/init_cell.yaml

@@ -0,0 +1,17 @@
+Type: Jupyter Notebook Extension
+Compatibility: 3.x, 4.x, 5.x
+Name: Initialization cells
+Main: main.js
+Icon: icon.png
+Link: README.md
+Description: |
+  Add a cell toolbar selector to mark cells as 'initialization' cells. Such
+  initialization cells can be run by on clicking the provided button in the
+  main toolbar, or configurably, run automatically on notebook load.
+Parameters:
+- name: init_cell.run_on_kernel_ready
+  description: |
+    Run input cells whenever a kernel_ready.Kernel event is fired. See readme
+    for further details.
+  input_type: checkbox
+  default: true

.local/share/jupyter/nbextensions/keyboard_shortcut_editor/README.md

@@ -0,0 +1,130 @@
+Keyboard shortcut editor
+========================
+
+This extension allows you to edit or remove the default notebook keyboard
+shortcuts, or create your own new ones.
+
+Currently, this extension supports the editing of any shortcut provided by
+Jupyter, with the exception of those provided by the CodeMirror editors, since
+they use a different API.
+
+To edit your keyboard shortcuts, open the keyboard shortcuts help dialog,
+either by pressing <kbd>h</kbd> in command mode, or by selecting
+`help > keyboard shortcuts` from the menu:
+
+![keyboard shortcuts menu item](readme_menu_item.png)
+
+When the extension has been loaded, each shortcut in the dialog will show a
+small dropdown menu next to it, with items to remove or edit the shortcut:
+
+![keyboard shortcut edit dropdown](readme_dropdown.png)
+
+Clicking the edit item opens a second modal dialog, with a text input. While
+the input has focus, you can press keys to form your combination. The reset
+button (the curly arrow to the left hand side) allows you to clear any keys you
+may input accidentally.
+
+![the shortcut editor dialog](readme_shortcut_editor_blank.png)
+![the shortcut editor dialog](readme_shortcut_editor_success.png)
+
+If you'd like to disable an existing shortcut, you can click the 'Disable'
+button on the dropdown. This will move the shortcut into a new section on the
+dialog headed 'disabled'. You can click the reset button next to disabled
+shortcuts to re-enable them:
+
+![re-enabling a disabled shortcut](readme_reset_disabled.png)
+
+You can create new custom keyboard shortcuts using the link at the base of the
+shortcut list for each mode:
+
+![add a new keyboard shortcut](readme_add_new_link.png)
+
+This opens a dialog similar to the editor, with the addition of a select box
+from which you can select the action which will be called:
+
+![selecting an action for a new keyboard shortcut](readme_add_new_select_action.png)
+
+
+Limitations: problem shortcuts
+------------------------------
+
+Since this editor uses the same key-identification method as the notebook,
+anything you can get it to recognise should (?!) work as a notebook shortcut,
+even if it gets represented by the editor differently to the letters on your
+actual, physical, keyboard. However, bear in mind that key identification is
+not perfect, (this is a problem on the web in general), so it's possible that
+some combinations may not be identified by Jupyter at all. In such cases, the
+editor should notify you:
+
+![an unrecognised keypress](readme_undefined_key.png)
+
+In addition, the handling of shortcuts including commas is currently
+compromised to the extent that they don't really work properly, so the editor
+also won't accept anything with a comma in it:
+
+![commas don't work properly!](readme_comma.png)
+
+The dialog will also not accept a shortcut that would conflict with one which
+already exists:
+
+![conflicting keyboard shortcuts are not accepted](readme_conflict.png)
+
+If the conflicting shortcut is provided by Jupyter rather than CodeMirror, you
+can of course disable it to prevent the conflict occurring.
+
+
+Internals
+---------
+
+The extension stores a record of the edits in use in the config, as a list
+of objects for each mode. Those without a `to` key denote shortcuts to disable,
+while those without a `from` key denote new shortcuts. For example:
+
+```javascript
+// the config object with section name 'notebook' at the base URL
+{
+  "kse_rebinds": {
+    // command-mode rebindings
+    'command': [
+      { // disable the default 'space' shortcut, which used to scroll the notebook down
+      	from: "space",
+        action_name: "jupyter-notebook:scroll-notebook-down"
+      },
+      { // create a new shortcut 't,t' to trust the notebook
+        action_name: "jupyter-notebook:trust-notebook",
+        to: "t,t"
+      },
+      { // change the default save-notebook shortcut from 's' to 'shift-s'
+        action_name: "jupyter-notebook:save-notebook",
+        to: "shift-s",
+        from: "s"
+      }
+    ],
+    // edit-mode rebindings:
+    "edit": [
+      { // disable the default edit-mode binding which switches to command mode
+        action_name: "jupyter-notebook:enter-command-mode",
+        from: "ctrl-m"
+      }
+    ]
+  },
+  // other config keys may be present in this file!
+}
+```
+
+The extension applies the shortcut edits when it is loaded, and in addition to
+any shortcut registered subsequently, as detailed below.
+
+
+Patches
+-------
+
+The extension applies patches to two Jupyter class prototypes.
+The method `ShortcutManager.prototype.add_shortcut` from `base/js/keyboard`,
+is patched to ensure any appropriate edits are applied to any shortcuts which
+get registered after the extension is loaded, for example by other notebook
+extensions.
+
+The `QuickHelp.prototype.build_command_help` and
+`QuickHelp.prototype.build_edit_help` methods from `notebook/js/quickhelp`, are
+patched to insert the dropdown menus, disabled shortcuts and other links.

.local/share/jupyter/nbextensions/keyboard_shortcut_editor/kse_components.js

@@ -0,0 +1,364 @@
+define([
+	'bootstrap', // for modals
+	'jquery',
+	'base/js/dialog',
+	'base/js/utils',
+	'base/js/keyboard',
+	'notebook/js/quickhelp',
+	'./quickhelp_shim'
+], function(
+	bs,
+	$,
+	dialog,
+	utils,
+	keyboard,
+	quickhelp,
+	quickhelp_shim
+){
+	"use strict";
+
+	function only_modifier_event (event) {
+		// adapted from base/js/keyboard
+		/**
+		 * Return `true` if the event only contains modifiers keys, false
+		 * otherwise
+		 */
+		var key = keyboard.inv_keycodes[event.which];
+		return ((event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) &&
+			(key === 'alt'|| key === 'ctrl'|| key === 'meta'|| key === 'shift'));
+	}
+
+	function editor_build () {
+		var editor = $('#kse-editor');
+		if (editor.length > 0) {
+			return editor;
+		}
+
+		editor = $('<div/>')
+			.addClass('kse-editor')
+			.attr('id', 'kse-editor')
+			.data({
+				'kse_sequence': [],
+				'kse_info': {},
+				'kse_mode': 'command',
+				'kse_undefined_key': false
+			});
+
+		var form = $('<form/>')
+			.addClass('form')
+			.appendTo(editor);
+
+		$('<div/>')
+			.addClass('form-group')
+			.appendTo(form);
+
+		var form_group = $('<div/>')
+			.addClass('form-group has-feedback')
+			.appendTo(form);
+
+		var input_group = $('<div/>')
+			.addClass('input-group')
+			.addClass('kse-input-group')
+			.appendTo(form_group);
+
+		// reset button
+		var btn = $('<a/>')
+			.addClass('btn btn-default')
+			.addClass('kse-input-group-reset')
+			.attr({
+				'title': 'Restart',
+				'type': 'button'
+			})
+			.append(
+				$('<i/>')
+					.addClass('fa fa-repeat')
+			)
+			.on('click', function () {
+				editor.data({
+					'kse_sequence': [],
+					'kse_undefined_key': false
+				});
+				editor_update_input_group(editor);
+				$(this).blur();
+				textcontrol.focus();
+			});
+		$('<div/>')
+			.addClass('input-group-btn')
+			.append(btn)
+			.appendTo(input_group);
+
+		// pretty-displayed shortcut
+		$('<div/>')
+			.addClass('input-group-addon')
+			.addClass('kse-input-group-pretty')
+			.addClass('kse-editor-to')
+			.appendTo(input_group);
+
+		var textcontrol = $('<input/>')
+			.addClass('form-control')
+			.addClass('kse-input-group-input')
+			.attr({
+				'type': 'text',
+				'placeholder': 'click here to edit the shortcut'
+			})
+			.on('keydown', editor_handle_shortcut_keydown)
+			.on('focus', function (evt) {
+				$(this).attr('placeholder', 'press keys to add to the shortcut');
+			})
+			.on('blur', function (evt) {
+				$(this).attr('placeholder', 'click here to edit the shortcut');
+			})
+			.appendTo(input_group);
+
+		// feedback icon
+		var form_fdbck = $('<i/>')
+			.addClass('fa fa-lg');
+		$('<span/>')
+			.addClass('form-control-feedback')
+			.append(form_fdbck)
+			.appendTo(form_group);
+
+		// help for input group
+		$('<span/>')
+			.addClass('help-block')
+			.appendTo(form_group);
+
+		return editor;
+	}
+
+	function editor_update_input_group (editor, seq) {
+		seq = seq || editor.data('kse_sequence');
+		var shortcut = seq.join(',');
+		var mode = editor.data('kse_mode');
+		var have_seq = seq.length > 0;
+		var valid = have_seq;
+
+		// empty help block
+		var feedback = editor.find('.form-group.has-feedback:first');
+		var help_block = feedback.find('.help-block');
+		help_block.empty();
+
+		var ii;
+		var has_comma = false;
+		for (ii = 0; !has_comma && (ii < seq.length); ii++) {
+			has_comma = seq[ii].indexOf(',') >= 0;
+		}
+
+		if (has_comma) {
+			valid = false;
+			// use HTML Unicode escape for a comma, to get it to look right in the pretty version
+			shortcut = $.map(seq, function (elem, idx) {
+				return elem.replace(',', '&#44;');
+			}).join(',');
+
+			$('<p/>')
+				.html(
+					'Unfortunately, Jupyter\'s handling of shortcuts containing ' +
+					'commas (<kbd>,</kbd>) is fundamentally flawed, ' +
+					'as the comma is used as the key-separator character &#9785;. ' +
+					'Please try something else for your rebind!'
+				)
+				.appendTo(help_block);
+		}
+		else if (have_seq) {
+			var conflicts = {};
+			var tree;
+
+			// get existing shortcuts
+			if (Jupyter.keyboard_manager !== undefined) {
+				var startkey = seq.slice(0, 1)[0];
+				if (mode === 'command') {
+					tree = Jupyter.keyboard_manager.command_shortcuts.get_shortcut(startkey);
+				}
+				else {
+					tree = Jupyter.keyboard_manager.edit_shortcuts.get_shortcut(startkey);
+					// deal with codemirror shortcuts specially, since they're not included in kbm
+					for (var jj = 0; jj < quickhelp.cm_shortcuts.length; jj++) {
+						var cm_shrt = quickhelp.cm_shortcuts[jj];
+						if (keyboard.normalize_shortcut(cm_shrt.shortcut) === startkey) {
+							tree = cm_shrt.help;
+							break;
+						}
+					}
+				}
+			}
+
+			// check for conflicting shortcuts.
+			// Start at 1 because we got tree from startkey
+			for (ii = 1; (ii < seq.length) && (tree !== undefined); ii++) {
+				// check for exsiting definitions at current specificity
+				if (typeof(tree) === 'string') {
+					valid = false;
+					conflicts[seq.slice(0, ii).join(',')] = tree;
+					break;
+				}
+				tree = tree[seq[ii]];
+			}
+			
+			// check whether any more-specific shortcuts were defined
+			if ((ii === seq.length) && (tree !== undefined)) {
+				valid = false;
+				var flatten_conflict_tree = function flatten_conflict_tree (obj, key) {
+					if (typeof(obj) === 'string') {
+						conflicts[key] = obj;
+					}
+					else for (var subkey in obj) {
+						if (obj.hasOwnProperty(subkey)) {
+							flatten_conflict_tree(obj[key], [key, subkey].join(','));
+						}
+					}
+				};
+				flatten_conflict_tree(tree, seq.join(','));
+			}
+
+			if (!valid) {
+				var plural = Object.keys(conflicts).length != 1;
+				$('<p/>')
+					.append(quickhelp.humanize_sequence(seq.join(',')))
+					.append(
+						' conflicts with the' + (plural ? ' following' : '') +
+						' existing shortcut' + (plural ? 's' : '') + ':'
+					)
+					.appendTo(help_block);
+
+				for (var conflicting_shortcut in conflicts) {
+					if (conflicts.hasOwnProperty(conflicting_shortcut)) {
+						$('<p/>')
+							.append(quickhelp.humanize_sequence(conflicting_shortcut))
+							.append($('<code/>').text(conflicts[conflicting_shortcut]))
+							.appendTo(help_block);
+					}
+				}
+			}
+		}
+
+		if (editor.data('kse_undefined_key')) {
+			var warning = $('<span/>')
+				.addClass('form-group has-feedback has-warning kse-undefined')
+				.append(
+					$('<span/>')
+						.addClass('help-block')
+						.append(
+							$('<p/>').text('Unrecognised key! (code ' + editor.data('kse_undefined_key' ) + ')')
+						)
+				);
+
+			var existing = editor.find('.kse-undefined');
+			if (existing.length > 0) {
+				existing.replaceWith(warning);
+			}
+			else {
+				warning.insertAfter(feedback);
+			}
+			setTimeout(function () {
+				warning.remove();
+			}, 2000);
+		}
+
+		// disable reset button if no sequence
+		editor.find('.kse-input-group-reset')
+			.toggleClass('disabled', !have_seq);
+
+		editor.find('.kse-input-group-pretty')
+			.html(shortcut ? quickhelp.humanize_sequence(shortcut) : '&lt;new shortcut&gt;');
+
+		feedback
+			.toggleClass('has-error', !valid && have_seq)
+			.toggleClass('has-success', valid && have_seq)
+			.find('.form-control-feedback .fa')
+				.toggleClass('fa-remove', !valid && have_seq)
+				.toggleClass('fa-check', valid && have_seq);
+	}
+
+	function editor_handle_shortcut_keydown (evt) {
+		var elem = $(evt.delegateTarget);
+		if (!only_modifier_event(evt)) {
+			var shortcut = keyboard.normalize_shortcut(keyboard.event_to_shortcut(evt));
+			var editor = elem.closest('#kse-editor');
+			var seq = editor.data('kse_sequence');
+			var has_undefined_key = (shortcut.toLowerCase().indexOf('undefined') !== -1);
+			editor.data('kse_undefined_key', has_undefined_key);
+			if (has_undefined_key) {
+				// deal with things like ~ appearing on apple alt-n, or ¨ on alt-u
+				editor.find('.kse-input-group-input').val('');
+				editor.data('kse_undefined_key', evt.which || true);
+			}
+			else {
+				seq.push(shortcut);
+			}
+			editor_update_input_group(editor, seq);
+		}
+	}
+
+	function modal_build (editor, modal_options) {
+		var modal = $('#kse-editor-modal');
+		if (modal.length > 0) {
+			return modal;
+		}
+
+		var default_modal_options = {
+			'destroy': false,
+			'show': false,
+			'title': 'Edit keyboard shortcut',
+			'body': editor,
+			'buttons': {
+				'OK': {'class': 'btn-primary'},
+				'Cancel': {}
+			},
+			'open': function (evt) {
+				$(this).find('.kse-input-group-input').focus();
+			}
+		};
+		if (Jupyter.notebook !== undefined) {
+			default_modal_options.notebook = Jupyter.notebook;
+		}
+		if (Jupyter.keyboard_manager !== undefined) {
+			default_modal_options.keyboard_manager= Jupyter.keyboard_manager;
+		}
+		modal_options = $.extend({}, default_modal_options, modal_options);
+
+		modal = dialog.modal(modal_options);
+
+		modal
+			.addClass('modal_stretch')
+			.attr('id', 'kse-editor-modal');
+
+		// Add a data-target attribute to ensure buttons only target the editor modal
+		modal.find('.close,.modal-footer button')
+			.attr('data-target', '#kse-editor-modal');
+
+		return modal;
+	}
+
+	/**
+	 * Pass it an option dictionary with any of the bootstrap or base/js/dialog
+	 * modal options, plus the following optional properties:
+	 * - description: html for the form group preceding the editor group,
+	 *   useful as a description
+	 */
+	function KSE_modal (modal_options) {
+		var editor = editor_build();
+		editor.data({'kse_sequence': [], 'kse_undefined_key': false});
+		editor_update_input_group(editor);
+		var modal = modal_build(editor, modal_options);
+
+		editor.on('keydown', '.kse-input-group-input', function (evt) {
+			event.preventDefault();
+			event.stopPropagation();
+			return false;
+		});
+
+		if (modal_options.description) {
+			modal.find('.modal-body .form-group:first').html(modal_options.description);
+		}
+
+		return modal;
+	}
+
+	return {
+		editor_build : editor_build,
+		editor_update_input_group: editor_update_input_group,
+		modal_build : modal_build,
+		KSE_modal : KSE_modal
+	};
+});

.local/share/jupyter/nbextensions/keyboard_shortcut_editor/main.js

@@ -0,0 +1,778 @@
+define([
+	'jquery',
+	'require',
+	'base/js/namespace',
+	'base/js/dialog',
+	'base/js/events',
+	'base/js/keyboard',
+	'notebook/js/quickhelp',
+	'./quickhelp_shim',
+	'./kse_components',
+], function (
+	$,
+	requirejs,
+	Jupyter,
+	dialog,
+	events,
+	keyboard,
+	quickhelp,
+	qh_shim,
+	kse_comp
+) {
+	"use strict";
+
+	var mod_name = 'keyboard_shortcut_editor';
+
+	// define default values for config parameters
+	var params = {
+		'kse_show_rebinds': true,
+		// mode, action name, new combo
+		'kse_rebinds': {
+			// command-mode rebindings
+			'command': [
+				// { // disable the default 'space' shortcut, which used to scroll the notebook down
+				//	from: "space",
+				//	action_name: "jupyter-notebook:scroll-notebook-down"
+				// },
+				// { // create a new shortcut 't,t' to trust the notebook
+				//	action_name: "jupyter-notebook:trust-notebook",
+				//	to: "t,t"
+				// },
+				// { // change the default save-notebook shortcut from 's' to 'shift-s'
+				//	action_name: "jupyter-notebook:save-notebook",
+				//	to: "shift-s",
+				//	from: "s"
+				// }
+			],
+			// edit-mode rebindings:
+			"edit": [
+				// { // disable the default edit-mode binding which switches to command mode
+				//	action_name: "jupyter-notebook:enter-command-mode",
+				//	from: "ctrl-m"
+				// }
+			]
+		}
+	};
+	// function to update params with any specified in the server's config file
+	function update_params () {
+		var config = Jupyter.notebook.config;
+		for (var key in params) {
+			if (config.data.hasOwnProperty(key)) {
+				params[key] = config.data[key];
+			}
+		}
+	}
+
+	function add_css (url) {
+		$('<link/>')
+			.attr({
+				'rel': 'stylesheet',
+				'type': 'text/css',
+				'href': requirejs.toUrl(url)
+			})
+			.appendTo($('head'));
+	}
+
+	var kbm = Jupyter.keyboard_manager;
+	var deleted_shortcuts = {
+		'command': new keyboard.ShortcutManager(undefined, kbm.command_shortcuts.events, kbm.actions, kbm.env),
+		'edit': new keyboard.ShortcutManager(undefined, kbm.edit_shortcuts.events, kbm.actions, kbm.env)
+	};
+	
+	var patched_quickhelp_prototype = false;
+	var patched_shortcut_manager_prototype = false;
+
+	function patch_shortcut_manager_prototype () {
+		if (!patched_shortcut_manager_prototype) {
+			var orig_add_shortcut = keyboard.ShortcutManager.prototype.add_shortcut;
+			keyboard.ShortcutManager.prototype.add_shortcut = function add_shortcut (shortcut, data, suppress_help_update, called_by_rebinder) {
+				if (!called_by_rebinder) {
+					var this_mode;
+					if (this === kbm.edit_shortcuts) {
+						this_mode = 'edit';
+					}
+					else if (this === kbm.command_shortcuts) {
+						this_mode = 'command';
+					}
+					if (this_mode) {
+						var rebind_specs = params.kse_rebinds[this_mode];
+						for (var ii = 0; ii < rebind_specs.length; ii++) {
+							var spec = rebind_specs[ii];
+							if (spec.from === shortcut) {
+								if (!spec.to) {
+									return;
+								}
+								shortcut = spec.to;
+							}
+						}
+					}
+				}
+				return orig_add_shortcut.call(this, shortcut, data, suppress_help_update);
+			};
+			console.log('[' + mod_name + '] patched ShortcutManager.prototype.add_shortcut');
+			patched_shortcut_manager_prototype = true;
+		}
+	}
+
+	function patch_quickhelp_prototype () {
+		if (!patched_quickhelp_prototype) {
+			var orig_build_command_help = quickhelp.QuickHelp.prototype.build_command_help;
+			quickhelp.QuickHelp.prototype.build_command_help = function () {
+				var div = orig_build_command_help.call(this);
+				return quickhelp_div_add_rebind_controls(div, 'command');
+			};
+			console.log('[' + mod_name + '] patched QuickHelp.prototype.build_command_help');
+
+			var orig_build_edit_help = quickhelp.QuickHelp.prototype.build_edit_help;
+			quickhelp.QuickHelp.prototype.build_edit_help = function (cm_shortcuts) {
+				var div = orig_build_edit_help.call(this, cm_shortcuts);
+				return quickhelp_div_add_rebind_controls(div, 'edit');
+			};
+			console.log('[' + mod_name + '] patched QuickHelp.prototype.build_edit_help');
+			
+			patched_quickhelp_prototype = true;
+		}
+	}
+
+	function load_jupyter_extension () {
+		add_css('./main.css');
+		patch_shortcut_manager_prototype();
+		patch_quickhelp_prototype();
+		Jupyter.notebook.config.loaded.then(initialize);
+	}
+
+	function get_mode_shortcuts (mode, deleted) {
+		if (deleted) {
+			return deleted_shortcuts[mode];
+		}
+		else if (mode === 'command') {
+			return kbm.command_shortcuts;
+		}
+		else if (mode === 'edit') {
+			return kbm.edit_shortcuts;
+		}
+		return undefined;
+	}
+
+	function rebind (mode, spec, suppress_help_update) {
+		var shortcuts = get_mode_shortcuts(mode);
+		if (spec.action_name === undefined) {
+			spec.action_name = shortcuts.get_shortcut(spec.from);
+		}
+		if (!shortcuts.actions.exists(spec.action_name)) {
+			console.warn(
+				'[' + mod_name + '] ' +
+				'rebind specified for unrecognised action "' +
+				spec.action_name + '"' +
+				(spec.from ? ' from ' + spec.from : '') +
+				(spec.to ? ' to ' + spec.to : '')
+			);
+		}
+		else {
+			console.log(
+				'[' + mod_name + '] ' +
+				(spec.from ? (spec.to ? 're' : 'un') : '') + 'bound ' +
+				spec.action_name +
+				(spec.from ? ' from ' + spec.from : '') +
+				(spec.to ? ' to ' + spec.to : '')
+			);
+
+			if (spec.from) {
+				if (!spec.to) {
+					deleted_shortcuts[mode].add_shortcut(spec.from, spec.action_name, true, true);
+				}
+				shortcuts.remove_shortcut(spec.from);
+			}
+			if (spec.to) {
+				return shortcuts.add_shortcut(spec.to, spec.action_name, suppress_help_update, true);
+			}
+		}
+	}
+
+	function apply_config_rebinds () {
+		var modes = ['command', 'edit'];
+		for (var mm = 0; mm < modes.length; mm++) {
+			var mode = modes[mm];
+			if (params.kse_rebinds.hasOwnProperty(mode)) {
+				var rebind_specs = params.kse_rebinds[mode];
+				for (var ii = 0; ii < rebind_specs.length; ii++) {
+					rebind(mode, rebind_specs[ii], true);
+				}
+			}
+		}
+		events.trigger('rebuild.QuickHelp');
+	}
+
+	var initialize = function () {
+		update_params();
+		apply_config_rebinds();
+		var title = $('#keyboard_shortcuts').attr('title');
+		$('#keyboard_shortcuts').attr('title',  title + ' & controls to edit them');
+	};
+
+	function reverse_spec (spec) {
+		var new_spec = {action_name: spec.action_name};
+		if (spec.from) {
+			new_spec.to = spec.from;
+		}
+		if (spec.to) {
+			new_spec.from = spec.to;
+		}
+		return new_spec;
+	}
+
+	function find_rebinding (rebinds, partial_spec, index_only) {
+		for (var ii = 0; ii < rebinds.length; ii++) {
+			if (((partial_spec.to === undefined) ||
+					(partial_spec.to === rebinds[ii].to)) &&
+				((partial_spec.from === undefined) ||
+					(partial_spec.from === rebinds[ii].from)) &&
+				((partial_spec.action_name === undefined) ||
+					(partial_spec.action_name === rebinds[ii].action_name))) {
+				return index_only ? ii : rebinds[ii];
+			}
+		}
+		return undefined;
+	}
+
+	function register_rebinding (mode, spec) {
+		var rebinds = params.kse_rebinds[mode];
+		rebinds.push($.extend({}, spec));
+		// write our private copy to the config:
+		Jupyter.notebook.config.update(params);
+		console.log('[' + mod_name + '] rebinding added:', spec);
+	}
+
+	function deregister_rebinding (mode, partial_spec) {
+		var rebinds = params.kse_rebinds[mode];
+		var idx = find_rebinding(rebinds, partial_spec, true);
+		if (idx === undefined) {
+			console.warn('[' + mod_name + '] attempted to delete non-exsitent shortcut:', partial_spec);
+			return undefined;
+		}
+		var deleted = rebinds.splice(idx, 1)[0];
+		// write our private copy to the config:
+		Jupyter.notebook.config.update(params);
+		console.log('[' + mod_name + '] rebinding removed:', deleted);
+		return deleted;
+	}
+
+	function action_selector (default_pair) {
+		var select = $('<select/>')
+			.append(
+				$('<option/>')
+					.attr('value', '')
+					.text('select an action')
+			)
+			.addClass('form-control select-xs');
+
+		var action_names = [];
+		$.each(kbm.actions._actions, function (key, val) {
+			if (key !== 'ignore') {
+				action_names.push(key);
+			}
+		});
+		action_names.sort();
+
+		for (var ii = 0; ii < action_names.length; ii++) {
+			select.append(
+				$('<option/>')
+					.attr('value', action_names[ii])
+					.append(
+						$('<code/>')
+							.text(action_names[ii])
+					)
+					// .text(kbm.actions.get(action_name).help)
+			);
+		}
+		return select;
+	}
+
+	function quickhelp_rebuild_mode_div (div) {
+		if ((div === undefined) || (div.data('kse_mode') === 'command')) {
+			div.replaceWith(Jupyter.quick_help.build_command_help());
+		}
+		if ((div === undefined) || (div.data('kse_mode') === 'edit')) {
+			div.replaceWith(Jupyter.quick_help.build_edit_help(quickhelp.cm_shortcuts));
+		}
+		return div;
+	}
+
+	function modal_update_ok_disable_status (evt) {
+		var editor = $(evt.delegateTarget);
+		if (!editor.is('#kse-editor')) {
+			editor = editor.closest('#kse-editor');
+		}
+		var feedback = editor.find('.has-feedback:first');
+		var valid = feedback.hasClass('has-success');
+		if (valid) {
+			valid = valid && editor.data('kse_sequence').length > 0;
+		}
+		var modal = editor.closest('#kse-editor-modal');
+		if (valid) {
+			var select = modal.find('select');
+			if (select.length > 0) {
+				valid = valid && select.val();
+			}
+		}
+		modal.find('.modal-footer button:first').prop('disabled', !valid);
+	}
+
+
+	function modal_ok_click_callback (evt) {
+		var editor = $('#kse-editor');
+		var new_shortcut = editor.data('kse_sequence').join(',');
+		var info = editor.data('kse_info');
+		var mode = editor.data('kse_mode');
+		var new_spec = {
+			'action_name': info.action_name,
+			'to': new_shortcut
+		};
+		if (info.rebound) {
+			// editing an existing rebinding
+			deregister_rebinding(mode, info.spec);
+			// rebind directly
+			rebind(mode, $.extend({'from': info.spec.to}, new_spec), true);
+			// get registration correct
+			new_spec.from = info.spec.from;
+		}
+		else {
+			if (info.spec.to) {
+				// editing an existing binding, so ensure there's a from
+				new_spec.from = info.spec.to;
+			}
+			rebind(mode, new_spec, true);
+		}
+		if (new_spec.from !== new_spec.to) {
+			register_rebinding(mode, new_spec);
+		}
+		quickhelp_rebuild_mode_div(info.div);
+	}
+
+	var modal_options_for_edit = {
+		backdrop: false,
+		buttons: {
+			OK: {
+				'class':'btn-primary',
+				'click': modal_ok_click_callback
+			},
+			Cancel: {}
+		}
+	};
+
+	function modal_prepare_editor(modal, editor, info) {
+		// ensure events are bound
+		if (!editor.data('kse_modal_events_bound')) {
+			editor.on('keydown', '.kse-input-group-input', function (evt) {
+				evt.preventDefault();
+				evt.stopPropagation();
+				modal_update_ok_disable_status(evt);
+				return false;
+			});
+			editor.on('click', '.kse-input-group-reset', modal_update_ok_disable_status);
+			editor.on('change', 'select', modal_update_ok_disable_status);
+			editor.data('kse_modal_events_bound', true);
+		}
+		// reset data
+		editor.data('kse_sequence', []);
+		editor.data('kse_info', info);
+		editor.data('kse_mode', info.mode);
+		editor.find('.kse-input-group-reset').click();
+
+		// add description
+		var descript_div = editor.find('.form-group:first').empty();
+		if (info.action_name) { // this is a rebind
+			descript_div
+				.append('Rebinding ')
+				.append(
+					$('<code/>')
+						.addClass('kse-action')
+						.text(info.spec.action_name)
+				)
+				.append(' from ')
+				.append(
+					$('<span/>')
+						.addClass('kse-from')
+						.html(quickhelp.humanize_sequence(info.spec.to || ''))
+				)
+				.append(' to:');
+		}
+		else {
+			// this is a nubind
+			var select = action_selector();
+			select.on('change', function (event) {
+				var action_name = $(this).val();
+				$.extend(true, info, {'action_name': action_name, 'spec': {'action_name': action_name}});
+			});
+			descript_div
+				.append('Bind ')
+				.append(select)
+				.append(' to:');
+		}
+		kse_comp.editor_update_input_group(editor);
+	}
+
+	function modal_show_above_quickhelp_modal(modal) {
+		// add a custom backdrop which covers the quickhelp modal.
+		// We do this every time, as bootstrap destroys it every time.
+		var backdrop = modal.data('bs.modal').$backdrop = $('<div/>')
+			.attr('id', 'kse-modal-backdrop')
+			.addClass('kse-modal-backdrop')
+			.addClass('modal-backdrop fade')
+			.appendTo(Jupyter.quick_help.shortcut_dialog.find('.modal-content'));
+
+		// get offsetWidth to force reflow, otherwise animation doesn't show
+		var tmp = backdrop[0].offsetWidth;
+		// now trigger animation by adding class
+		backdrop
+			.addClass('in');
+		// show the modal once the (backdrop) transition is complete
+		backdrop
+			.one('bsTransitionEnd', function () {
+				modal.modal('show');
+			})
+			.emulateTransitionEnd(150);
+	}
+
+	function build_rebind_rep_list (mode) {
+		var rep_list = $('<div/>')
+			.addClass('kse-rep-list');
+
+		var shortcuts = get_mode_shortcuts(mode);
+		var rebind_specs = params.kse_rebinds[mode];
+		
+		for (var ii = 0; ii < rebind_specs.length; ii++) {
+			var spec = rebind_specs[ii];
+			var verb = (spec.from ? (spec.to ? 're' : 'un') : '') + 'bound';
+			var rep = $('<div/>')
+				.append(
+					$('<code/>')
+						.text(spec.action_name)
+				)
+				.append(' ' + verb)
+				.appendTo(rep_list);
+			if (spec.from) {
+				rep.append(' from ' + quickhelp.humanize_sequence(spec.from));
+			}
+			if (spec.to) {
+				rep.append(' to ' + quickhelp.humanize_sequence(spec.to));
+			}
+		}
+
+		return rep_list;
+	}
+
+	function btn_get_info (btn) {
+		/**
+		 * get the shortcut info associated with a quickhelp button element
+		 */
+		var info = {};
+		btn = info.btn = $(btn);
+		var qh_div = info.qh_div = btn.closest('.quickhelp');
+		var div = info.div = qh_div.closest('.kse-div');
+
+		var mode = info.mode = div.data('kse_mode');
+		var unbound = info.unbound = qh_div.hasClass('kse-unbound');
+		var rebound = info.rebound = qh_div.hasClass('kse-rebound');
+		info.nubound = qh_div.hasClass('kse-nubound');
+
+		var shortcuts = info.shortcuts = get_mode_shortcuts(mode, unbound);
+		// Make sure we remove jupyter-notebook:ignore shortcuts.
+		var shortcut_help_arr = info.shortcut_help_arr =  shortcuts.help().filter(
+			function (shortcut) {
+				return (shortcut.help !== 'ignore');
+			}
+		);
+
+		var idx = info.idx = div.find('.quickhelp:not(.kse-links,.kse-codemirror)')[unbound ? 'filter' : 'not']('.kse-unbound').index(qh_div);
+
+		var keycombo = info.keycombo = shortcut_help_arr[idx].shortcut;
+		var action_name = info.action_name = shortcuts.get_shortcut(keycombo);
+		var spec = info.spec = {
+			'to': keycombo,
+			'action_name': action_name
+		};
+		if (rebound) {
+			spec.from = find_rebinding(params.kse_rebinds[mode], spec).from;
+		}
+		return info;
+	}
+
+	function btn_del_callback (evt) {
+		evt.preventDefault(); // ignore #
+
+		var info = btn_get_info(evt.delegateTarget);
+		var spec = info.spec;
+		var rev_spec = reverse_spec(spec);
+		rebind(info.mode, rev_spec, true);
+
+		if (info.nubound) {
+			// don't want deleted new binds to show up in deleted shortcuts
+			deleted_shortcuts[info.mode].remove_shortcut(spec.to);
+			deregister_rebinding(info.mode, spec);
+		}
+		else if (info.rebound) {
+			// get rid of existing rebinding
+			deregister_rebinding(info.mode, spec);
+			// add a new rebinding for the deletion
+			delete spec.to;
+			rebind(info.mode, spec, true);
+			register_rebinding(info.mode, spec);
+		}
+		else {
+			register_rebinding(info.mode, rev_spec);
+		}
+		quickhelp_rebuild_mode_div(info.div);
+	}
+
+	function btn_rst_callback (evt) {
+		evt.preventDefault(); // ignore #
+
+		var info = btn_get_info(evt.delegateTarget);
+		var spec = info.spec;
+		if (info.unbound) {
+			spec = reverse_spec(spec);
+			deleted_shortcuts[info.mode].remove_shortcut(spec.from);
+		}
+		rebind(info.mode, reverse_spec(spec), true);
+		deregister_rebinding(info.mode, spec);
+		
+		quickhelp_rebuild_mode_div(info.div);
+	}
+
+	function btn_edt_callback (evt) {
+		evt.preventDefault(); // ignore #
+
+		var info = btn_get_info(evt.delegateTarget);
+		var spec = reverse_spec(info.spec);
+		// see if the shortcut was already rebound...
+		var rebinds = params.kse_rebinds[info.mode];
+		for (var ii = 0; ii < rebinds.length; ii++) {
+			if (rebinds[ii].to === spec.from) {
+				spec = rebinds[ii];
+				break;
+			}
+		}
+
+		var editor = kse_comp.editor_build();
+		var modal = kse_comp.modal_build(editor, modal_options_for_edit);
+		
+		modal_prepare_editor(modal, editor, info);
+		modal_show_above_quickhelp_modal(modal);
+	}
+
+	function btn_add_callback (evt) {
+		evt.preventDefault(); // don't use #
+
+		var div = $(evt.delegateTarget).closest('.kse-div');
+		var mode = div.data('kse_mode');
+		var info = {
+			'div': div,
+			'spec': {},
+			'shortcuts': get_mode_shortcuts(mode),
+			'keycombo': '',
+			'action_name': '',
+			'mode': mode
+		};
+
+		var editor = kse_comp.editor_build();
+		var modal = kse_comp.modal_build(editor, modal_options_for_edit);
+		
+		modal_prepare_editor(modal, editor, info);
+		modal_show_above_quickhelp_modal(modal, editor, info);
+	}
+
+	function btn_view_callback (evt) {
+		evt.preventDefault(); // don't use #
+
+		var div = $(evt.delegateTarget).closest('.kse-div');
+		var mode = div.data('kse_mode');
+		var modal = dialog.modal({
+			backdrop: false, // a custom one gets added by modal_show_above_quickhelp_modal
+			show: false,
+			title : mode.substring(0, 1).toUpperCase() + mode.substring(1) + '-mode keyboard shortcut edits',
+			body : build_rebind_rep_list(mode),
+			buttons: {'OK': {}},
+			notebook: Jupyter.notebook,
+			keyboard_manager: Jupyter.keyboard_manager
+		});
+
+		modal
+			.addClass('modal_stretch')
+			.attr('id', 'kse-view-modal');
+
+		// Add a data-target attribute to ensure buttons only target this modal
+		modal.find('.close,.modal-footer button')
+			.attr('data-target', '#kse-view-modal');
+		modal_show_above_quickhelp_modal(modal);
+	}
+
+	function build_button_menu (idx, qh_div) {
+		qh_div = $(qh_div);
+
+		var grp = $('<div/>')
+			.addClass('btn-group btn-group-xs')
+			.addClass('kse-dropdown')
+			.addClass('hidden-print')
+			.appendTo(qh_div);
+
+		var btn = $('<button/>')
+			.addClass('btn btn-default')
+			.attr('type', 'button')
+			.appendTo(grp);
+
+		if (qh_div.hasClass('kse-codemirror')) {
+			btn
+				.addClass('disabled')
+				.attr('title', 'Editing Codemirror shortcuts is not supported')
+				.html('<i class="fa">cm</i>');
+		}
+		else if (qh_div.hasClass('kse-unbound')) {
+			btn
+				.on('click', btn_rst_callback)
+				.attr('title', 'Re-enable shortcut')
+				.html('<i class="fa fa-repeat"/>');
+		}
+		else if (qh_div.hasClass('kse-nubound')) {
+			btn
+				.on('click', btn_del_callback)
+				.attr('title', 'Delete custom shortcut')
+				.html('<i class="fa fa-trash"/>');
+		}
+		else {
+			btn
+				.attr({
+					'title': 'Edit',
+					'data-toggle': 'dropdown',
+					'aria-haspopup': 'true',
+					'aria-expanded': 'false'
+				})
+				.addClass('dropdown-toggle')
+				.html('<i class="fa fa-pencil"/> <i class="fa fa-caret-down"/>');
+			
+			var mnu = $('<ul/>')
+				.addClass('dropdown-menu dropdown-menu-right')
+				.appendTo(grp);
+			$('<li/>')
+				.html('<a href="#" title="Edit shortcut"><i class="fa fa-pencil"></i> Edit</a>')
+				.on('click', btn_edt_callback)
+				.appendTo(mnu);
+			if (qh_div.hasClass('kse-rebound')) {
+				$('<li/>')
+					.on('click', btn_rst_callback)
+					.html('<a href="#" title="Reset shortcut to default key(s)"><i class="fa fa-repeat"></i> Reset</a>')
+					.appendTo(mnu);
+			}
+			$('<li/>')
+				.on('click', btn_del_callback)
+				.html('<a href="#" title="Disable shortcut"><i class="fa fa-ban"></i> Disable</a>')
+				.appendTo(mnu);
+		}
+
+		return grp;
+	}
+
+	function quickhelp_div_add_rebind_controls (div, mode) {
+		if (!params.kse_show_rebinds) {
+			return div;
+		}
+
+		div
+			.data('kse_mode', mode)
+			.addClass('kse-div');
+		
+		var nubound_shortcuts = [];
+		var rebound_shortcuts = [];
+		for (var ii = 0; ii < params.kse_rebinds[mode].length; ii++) {
+			var spec = params.kse_rebinds[mode][ii];
+			if (spec.to) {
+				(spec.from ? rebound_shortcuts : nubound_shortcuts).push(spec.to);
+			}
+		}
+
+		var shortcuts = get_mode_shortcuts(mode);
+		var shortcut_help_arr = shortcuts.help();
+		// add codemirror shortcuts in edit mode
+		if (mode === 'edit') {
+			shortcut_help_arr = $.merge($.merge([], quickhelp.cm_shortcuts), shortcut_help_arr);
+		}
+		// Remove jupyter-notebook:ignore shortcuts.
+		shortcut_help_arr = shortcut_help_arr.filter(function(shortcut) {
+			return (shortcut.help !== 'ignore');
+		});
+
+		// label quickhelp divs with classes
+		div.find('.quickhelp').each(function (idx, elem) {
+			var keycombo = shortcut_help_arr[idx].shortcut;
+			var action_name = shortcuts.get_shortcut(keycombo);
+			if (mode === 'edit' && action_name === undefined) {
+				$(elem).addClass('kse-codemirror');
+			}
+			else if (nubound_shortcuts.indexOf(keycombo) >= 0) {
+				$(elem).addClass('kse-nubound');
+			}
+			else if (rebound_shortcuts.indexOf(keycombo) >= 0) {
+				$(elem).addClass('kse-rebound');
+			}
+		});
+
+		// (maybe) add a set of rebinds and deleted shortcuts
+		div.find('.kse-rep-list').remove();
+		var cont = div.find('.container-fluid:first');
+		
+		var del_div = quickhelp.build_div('<h5>Disabled:<h5/>', deleted_shortcuts[mode].help());
+		del_div
+			.addClass('hidden-print')
+			.addClass('text-danger hidden-print');
+		if (del_div.find('.quickhelp').addClass('kse-unbound').length > 0) {
+			del_div
+				.insertAfter(cont);
+		}
+
+		// add button menus
+		div.find('.quickhelp').each(build_button_menu);
+
+		var link_new = $('<a/>')
+			.attr('href', '#')
+			.on('click', btn_add_callback);
+		
+		$('<span/>')
+			.addClass('shortcut_key')
+			.html('<i class="fa fa-plus"></i>')
+			.appendTo(link_new);
+			
+		$('<span/>')
+			.addClass('shortcut_descr')
+			.text(': Add a new ' + mode + '-mode shortcut')
+			.appendTo(link_new);
+
+		$('<div/>')
+			.addClass('col-xs-12 hidden-print quickhelp kse-links')
+			.append(link_new)
+			.appendTo(cont);
+
+		// add the view-rebinds and add-a-new links
+		if (params.kse_rebinds[mode].length > 0) {
+			var link_view = link_new.clone()
+				.off('click')
+				.on('click', btn_view_callback)
+				.appendTo(cont);
+			link_view.find('.shortcut_key')
+				.html('<i class="fa fa-eye"></i>');
+			link_view.find('.shortcut_descr')
+				.text(': View active ' + mode + '-mode shortcut edits');
+			
+			$('<div/>')
+				.addClass('col-xs-12 hidden-print quickhelp kse-links')
+				.append(link_view)
+				.appendTo(cont);
+		}
+
+		return div;
+	}
+
+	return {
+		'load_jupyter_extension': load_jupyter_extension,
+		'load_ipython_extension': load_jupyter_extension
+	};
+});

.local/share/jupyter/nbextensions/keyboard_shortcut_editor/quickhelp_shim.js

@@ -0,0 +1,207 @@
+define([
+	'underscore',
+	'jquery',
+	'base/js/utils',
+	'notebook/js/quickhelp',
+	'codemirror/lib/codemirror'
+], function(
+	_,
+	$,
+	utils,
+	quickhelp,
+	CodeMirror
+){
+	"use strict";
+    // This is essentially a duplicate of the quickhelp module, used to
+    // patch the existing quickhelp with definitions which aren't exported.
+
+	var platform = utils.platform;
+
+	var cmd_ctrl = 'Ctrl-';
+	var platform_specific;
+
+	if (platform === 'MacOS') {
+		// Mac OS X specific
+		cmd_ctrl = 'Cmd-';
+		platform_specific = [
+			{ shortcut: "Cmd-Up",     help:"go to cell start"  },
+			{ shortcut: "Cmd-Down",   help:"go to cell end"  },
+			{ shortcut: "Alt-Left",   help:"go one word left"  },
+			{ shortcut: "Alt-Right",  help:"go one word right"  },
+			{ shortcut: "Alt-Backspace",      help:"delete word before"  },
+			{ shortcut: "Alt-Delete",         help:"delete word after"  },
+		];
+	} else {
+		// PC specific
+		platform_specific = [
+			{ shortcut: "Ctrl-Home",  help:"go to cell start"  },
+			{ shortcut: "Ctrl-Up",    help:"go to cell start"  },
+			{ shortcut: "Ctrl-End",   help:"go to cell end"  },
+			{ shortcut: "Ctrl-Down",  help:"go to cell end"  },
+			{ shortcut: "Ctrl-Left",  help:"go one word left"  },
+			{ shortcut: "Ctrl-Right", help:"go one word right"  },
+			{ shortcut: "Ctrl-Backspace", help:"delete word before"  },
+			{ shortcut: "Ctrl-Delete",	help:"delete word after"  },
+		];
+	}
+
+	var cm_shortcuts = [
+		{ shortcut:"Tab",   help:"code completion or indent" },
+		{ shortcut:"Shift-Tab",   help:"tooltip" },
+		{ shortcut: cmd_ctrl + "]",   help:"indent"  },
+		{ shortcut: cmd_ctrl + "[",   help:"dedent"  },
+		{ shortcut: cmd_ctrl + "a",   help:"select all"  },
+		{ shortcut: cmd_ctrl + "z",   help:"undo"  },
+		{ shortcut: cmd_ctrl + "Shift-z",   help:"redo"  },
+		{ shortcut: cmd_ctrl + "y",   help:"redo"  },
+	].concat( platform_specific );
+	
+	var mac_humanize_map = {
+		// all these are unicode, will probably display badly on anything except macs.
+		// these are the standard symbol that are used in MacOS native menus
+		// cf http://apple.stackexchange.com/questions/55727/
+		// for htmlentities and/or unicode value
+		'cmd':'⌘',
+		'shift':'⇧',
+		'alt':'⌥',
+		'up':'↑',
+		'down':'↓',
+		'left':'←',
+		'right':'→',
+		'eject':'⏏',
+		'tab':'⇥',
+		'backtab':'⇤',
+		'capslock':'⇪',
+		'esc':'esc',
+		'ctrl':'⌃',
+		'enter':'↩',
+		'pageup':'⇞',
+		'pagedown':'⇟',
+		'home':'↖',
+		'end':'↘',
+		'altenter':'⌤',
+		'space':'␣',
+		'delete':'⌦',
+		'backspace':'⌫',
+		'apple':'',
+	};
+
+	var default_humanize_map = {
+		'shift':'Shift',
+		'alt':'Alt',
+		'up':'Up',
+		'down':'Down',
+		'left':'Left',
+		'right':'Right',
+		'tab':'Tab',
+		'capslock':'Caps Lock',
+		'esc':'Esc',
+		'ctrl':'Ctrl',
+		'enter':'Enter',
+		'pageup':'Page Up',
+		'pagedown':'Page Down',
+		'home':'Home',
+		'end':'End',
+		'space':'Space',
+		'backspace':'Backspace',
+		};
+	
+	var humanize_map;
+
+	if (platform === 'MacOS'){
+		humanize_map = mac_humanize_map;
+	} else {
+		humanize_map = default_humanize_map;
+	}
+
+	var special_case = { pageup: "PageUp", pagedown: "Page Down", 'minus': '-' };
+	
+	function humanize_key(key){
+		if (key.length === 1){
+			return key.toUpperCase();
+		}
+
+		key = humanize_map[key.toLowerCase()]||key;
+		
+		if (key.indexOf(',') === -1){
+			return  ( special_case[key] ? special_case[key] : key.charAt(0).toUpperCase() + key.slice(1) );
+		}
+	}
+
+	// return an **html** string of the keyboard shortcut
+	// for human eyes consumption.
+	// the sequence is a string, comma sepparated linkt of shortcut,
+	// where the shortcut is a list of dash-joined keys.
+	// Each shortcut will be wrapped in <kbd> tag, and joined by comma is in a
+	// sequence.
+	//
+	// Depending on the platform each shortcut will be normalized, with or without dashes.
+	// and replace with the corresponding unicode symbol for modifier if necessary.
+	function humanize_sequence(sequence){
+		var joinchar = ',';
+		var hum = _.map(sequence.replace(/meta/g, 'cmd').split(','), humanize_shortcut).join(joinchar);
+		return hum;
+	}
+
+	function humanize_shortcut(shortcut){
+		var joinchar = '-';
+		if (platform === 'MacOS'){
+			joinchar = '';
+		}
+		var sh = _.map(shortcut.split('-'), humanize_key ).join(joinchar);
+		return '<kbd>'+sh+'</kbd>';
+	}
+	
+	var build_one = function (s) {
+		var help = s.help;
+		var shortcut = '';
+		if(s.shortcut){
+			shortcut = humanize_sequence(s.shortcut);
+		}
+		return $('<div>').addClass('quickhelp').
+			append($('<span/>').addClass('shortcut_key').append($(shortcut))).
+			append($('<span/>').addClass('shortcut_descr').text(' : ' + help));
+
+	};
+
+	var build_div = function (title, shortcuts) {
+		
+		// Remove jupyter-notebook:ignore shortcuts.
+		shortcuts = shortcuts.filter(function(shortcut) {
+			if (shortcut.help === 'ignore') {
+				return false;
+			} else {
+				return true;
+			}
+		});
+		
+		var i, half, n;
+		var div = $('<div/>').append($(title));
+		var sub_div = $('<div/>').addClass('container-fluid');
+		var col1 = $('<div/>').addClass('col-md-6');
+		var col2 = $('<div/>').addClass('col-md-6');
+		n = shortcuts.length;
+		half = ~~(n/2);  // Truncate :)
+		for (i=0; i<half; i++) { col1.append( build_one(shortcuts[i]) ); }
+		for (i=half; i<n; i++) { col2.append( build_one(shortcuts[i]) ); }
+		sub_div.append(col1).append(col2);
+		div.append(sub_div);
+		return div;
+	};
+
+    var quickhelp_shiv = {
+        cmd_ctrl : cmd_ctrl,
+        platform_specific : platform_specific,
+        cm_shortcuts : cm_shortcuts,
+        mac_humanize_map : mac_humanize_map,
+        default_humanize_map : default_humanize_map,
+        humanize_map : humanize_map,
+        special_case : special_case,
+        humanize_key : humanize_key,
+        humanize_sequence : humanize_sequence,
+        humanize_shortcut : humanize_shortcut,
+        build_one : build_one,
+        build_div : build_div
+    };
+	_.defaults(quickhelp, quickhelp_shiv);
+});