Make docs headings consistent with each other.

Before, headings were not consistent across the docs. This standardizes on the Python doc convention: https://devguide.python.org/documenting/#sections

docs/source/developer/components.rst

@@ -1,5 +1,5 @@
 Using JupyterLab components
----------------------------
+===========================
 
 JupyterLab is built with many re-usable components that are
 independently `published on npm <https://www.npmjs.com/search?q=%40jupyterlab>`_.
@@ -36,7 +36,7 @@ the ``examples`` directory and enter:
     python main.py
 
 Dissecting the 'filebrowser' example
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------------
 
 The filebrowser example provides a stand-alone implementation of a
 filebrowser. Here's what the filebrowser's user interface looks like:

docs/source/developer/contributing.rst

@@ -1,5 +1,5 @@
 Contributing to JupyterLab
---------------------------
+==========================
 
 If you're reading this section, you're probably interested in
 contributing to JupyterLab. Welcome and thanks for your interest in
@@ -29,7 +29,7 @@ key <https://raw.githubusercontent.com/jupyter/notebook/master/docs/source/ipyth
     :depth: 1
 
 General Guidelines for Contributing
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------------
 
 For general documentation about contributing to Jupyter projects, see
 the `Project Jupyter Contributor
@@ -57,13 +57,13 @@ configuring it to format your code with a keyboard shortcut or
 automatically on save.
 
 Submitting a Pull Request Contribution
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------------
 
 Generally, an issue should be opened describing a piece of proposed work
 and the issues it solves before a pull request is opened.
 
 Issue Management
-''''''''''''''''
+^^^^^^^^^^^^^^^^
 
 Opening an issue lets community members participate in the design
 discussion, makes others aware of work being done, and sets the stage
@@ -77,7 +77,7 @@ discussion is desired, or if the pull request doesn't fully address the
 locked issue, please open a new issue referencing the locked issue.
 
 Tag Issues with Labels
-''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^
 
 Users without the commit rights to the JupyterLab repository can tag
 issues with labels using the ``@meeseeksdev`` bot. For example: To apply
@@ -85,7 +85,7 @@ the label ``foo`` and ``bar baz`` to an issue, comment
 ``@meeseeksdev tag foo "bar baz"`` on the issue.
 
 Setting Up a Development Environment
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------------
 
 You can launch a binder with the latest JupyterLab master to test
 something (this may take a few minutes to load):
@@ -94,7 +94,7 @@ something (this may take a few minutes to load):
    :target: https://mybinder.org/v2/gh/jupyterlab/jupyterlab/master?urlpath=lab-dev/
 
 Installing Node.js and jlpm
-'''''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Building JupyterLab from its GitHub source code requires Node.js. The
 development version requires Node.js version 10+, as defined in the
@@ -123,7 +123,7 @@ To check which version of Node.js is installed:
    node -v
 
 Installing JupyterLab
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 JupyterLab requires Jupyter Notebook version 4.3 or later.
 
@@ -217,7 +217,7 @@ For installation instructions to write documentation, please see
 `Writing Documentation <#writing-documentation>`__
 
 Run JupyterLab
-''''''''''''''
+^^^^^^^^^^^^^^
 
 Start JupyterLab in development mode:
 
@@ -233,7 +233,7 @@ When running in dev mode, a red stripe will appear at the top of the
 page; this is to indicate running an unreleased version.
 
 Build and Run the Tests
-'''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^
 
 .. code:: bash
 
@@ -256,7 +256,7 @@ scripts in each package accept ``jest`` `cli
 options <https://jestjs.io/docs/en/cli.html>`__.
 
 VSCode Debugging
-^^^^^^^^^^^^^^^^
+""""""""""""""""
 
 To debug in VSCode, open a package folder in VSCode. We provide a launch
 configuration in each package folder. In a terminal, run
@@ -266,14 +266,14 @@ debugging <https://code.visualstudio.com/docs/editor/debugging>`__ for
 more details.
 
 Chrome Debugging
-^^^^^^^^^^^^^^^^
+""""""""""""""""
 
 To debug in Chrome, run ``jlpm test:debug:watch`` in the terminal. Open
 Chrome and go to ``chrome://inspect/``. Select the remote device and
 begin debugging.
 
 Testing Utilities
-^^^^^^^^^^^^^^^^^
+"""""""""""""""""
 
 There are some helper functions in ``testutils`` (which is a public npm
 package called ``@jupyterlab/testutils``) that are used by many of the
@@ -293,7 +293,7 @@ check that the sentinel was set if we need a promise to run without
 blocking.
 
 Performance Testing
-~~~~~~~~~~~~~~~~~~~
+-------------------
 
 If you are making a change that might affect how long it takes to load
 JupyterLab in the browser, we recommend doing some performance testing
@@ -322,7 +322,7 @@ Now run Lighthouse against this local server and show the results:
 .. image:: /images/lighthouse.png
 
 Using throttling
-''''''''''''''''
+^^^^^^^^^^^^^^^^
 
 Lighthouse recommends using the system level
 `comcast <https://github.com/tylertreat/comcast>`__ tool to throttle
@@ -356,7 +356,7 @@ Then disable the throttling after you are done:
    jlpm run lighthouse:throttling:stop
 
 Comparing results
-'''''''''''''''''
+^^^^^^^^^^^^^^^^^
 
 Performance results are usually only useful in comparison to other
 results. For that reason, we have included a comparison script that can
@@ -522,7 +522,7 @@ the two reports:
      more <https://developers.google.com/web/tools/lighthouse/audits/dom-size>`__.
 
 Contributing to the debugger front-end
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------------
 
 To make changes to the debugger extension, a kernel with support for debugging is required.
 
@@ -531,14 +531,14 @@ Check out the user documentation to learn how to install such kernel: :ref:`debu
 Then refresh the page and the debugger sidebar should appear in the right area.
 
 The Debugger Adapter Protocol
-'''''''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The following diagram illustrates the types of messages sent between the JupyterLab extension and the kernel.
 
 .. image:: ./debugger_protocol_diagram.png
 
 Inspecting Debug Messages in VS Code
-''''''''''''''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Inspecting the debug messages in VS Code can be useful to understand when debug requests are made (for example triggered by a UI action), and to compare the behavior of the JupyterLab debugger with the Python debugger in VS Code.
 
@@ -599,7 +599,7 @@ With:
 - Messages follow the `DAP <https://microsoft.github.io/debug-adapter-protocol/specification>`_
 
 References
-''''''''''
+^^^^^^^^^^
 
 - Dump cell and state restoration: https://github.com/jupyterlab/debugger/issues/52
 - Protocol Overview: https://microsoft.github.io/debug-adapter-protocol/overview
@@ -607,7 +607,7 @@ References
 
 
 Build and run the stand-alone examples
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------------
 
 To install and build the examples in the ``examples`` directory:
 
@@ -623,7 +623,7 @@ To run a specific example, change to the examples directory (i.e.
    python main.py
 
 Debugging in the Browser
-~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------
 
 All methods of building JupyterLab produce source maps. The source maps
 should be available in the source files view of your browser's
@@ -646,7 +646,7 @@ test folder while debugging test options. See
 --------------
 
 High level Architecture
-~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------
 
 The JupyterLab application is made up of two major parts:
 
@@ -658,14 +658,14 @@ documentation <developer-guide>`
 provides additional architecture information.
 
 The NPM Packages
-~~~~~~~~~~~~~~~~
+----------------
 
 The repository consists of many npm packages that are managed using the
 lerna build tool. The npm package source files are in the ``packages/``
 subdirectory.
 
 Build the NPM Packages from Source
-''''''''''''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 .. code:: bash
 
@@ -683,7 +683,7 @@ Build the NPM Packages from Source
    jlpm run build:packages
 
 Writing Documentation
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 Documentation is written in Markdown and reStructuredText. In
 particular, the documentation on our Read the Docs page is written in
@@ -715,7 +715,7 @@ Or with ``jlpm``:
    jlpm run docs
 
 Writing Style
-'''''''''''''
+^^^^^^^^^^^^^
 
 -  The documentation should be written in the second person, referring
    to the reader as "you" and not using the first person plural "we."
@@ -734,10 +734,10 @@ Writing Style
    permission, whereas "enable" connotes empowerment.
 
 User Interface Naming Conventions
-'''''''''''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Documents, Files, and Activities
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""""""""""
 
 Files are referrred to as either files or documents, depending on the
 context.
@@ -757,7 +757,7 @@ or file is an activity in that it is represented by a panel that you can
 interact with.
 
 Element Names
-^^^^^^^^^^^^^
+"""""""""""""
 
 -  The generic content area of a tabbed UI is a panel, but prefer to
    refer to the more specific name, such as “File browser.” Tab bars
@@ -800,14 +800,14 @@ tool, such as “file browser” or “command palette”.
 See :ref:`interface` for descriptions of elements in the UI.
 
 The Jupyter Server Extension
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+----------------------------
 
 The Jupyter server extension source files are in the jupyterlab/
 subdirectory. To use this extension, make sure the Jupyter Notebook
 server version 4.3 or later is installed.
 
 Build the JupyterLab server extension
-'''''''''''''''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 When you make a change to JupyterLab npm package source files, run:
 
@@ -824,7 +824,7 @@ To have the system build after each source file change, run:
    jupyter lab --dev-mode --watch
 
 Build Utilities
-~~~~~~~~~~~~~~~
+---------------
 
 There is a range of build utilities for maintaining the repository. To
 get a suggested version for a library use
@@ -857,10 +857,10 @@ metadata are considered to be a core dependency unless they are
 explicitly marked otherwise.
 
 Testing Changes to External Packages
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------------
 
 Linking/Unlinking Packages to JupyterLab
-''''''''''''''''''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 If you want to make changes to one of JupyterLab's external packages
 (for example, `Lumino <https://github.com/jupyterlab/lumino>`__ and test
@@ -896,7 +896,7 @@ You can then (re)build JupyterLab and everything should be back to
 default.
 
 Possible Linking Pitfalls
-'''''''''''''''''''''''''
+^^^^^^^^^^^^^^^^^^^^^^^^^
 
 If you're working on an external project with more than one package,
 you'll probably have to link in your copies of every package in the
@@ -910,7 +910,7 @@ potential duplication of objects contained in the ``MessageLoop``
 namespace provided by the ``messaging`` package.
 
 Keyboard Shortcuts
-~~~~~~~~~~~~~~~~~~
+------------------
 
 Typeset keyboard shortcuts as follows:
 
@@ -923,7 +923,7 @@ Typeset keyboard shortcuts as follows:
    difficult to display in a platform specific way on Sphinx/RTD.
 
 Screenshots and Animations
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------
 
 Our documentation should contain screenshots and animations that
 illustrate and demonstrate the software. Here are some guidelines for
@@ -980,7 +980,7 @@ This will help us to keep track of the images as documentation content
 evolves.
 
 Notes
-~~~~~
+-----
 
 -  By default, the application will load from the JupyterLab staging
    directory (default is ``<sys-prefix>/share/jupyter/lab/build``. If

docs/source/developer/css.rst

@@ -1,7 +1,7 @@
 .. _css:
 
 CSS Patterns
-------------
+============
 
 This document describes the patterns we are using to organize and write
 CSS for JupyterLab. JupyterLab is developed using a set of npm packages
@@ -9,7 +9,7 @@ that are located in ``packages``. Each of these packages has its own
 style, but depend on CSS variables defined in a main theme package.
 
 CSS checklist
-~~~~~~~~~~~~~
+-------------
 
 -  CSS classnames are defined inline in the code. We used to put them as
    all caps file-level ``const``\ s, but we are moving away from that.
@@ -23,7 +23,7 @@ CSS checklist
    sparingly and in accordance with the conventions described below.
 
 CSS variables
-~~~~~~~~~~~~~
+-------------
 
 We are using native CSS variables in JupyterLab. This is to enable
 dynamic theming of built-in and third party plugins. As of December
@@ -85,7 +85,7 @@ Again, we consider the names of the public CSS variables in this package
 to be our public API for CSS.
 
 File organization
-~~~~~~~~~~~~~~~~~
+-----------------
 
 We are organizing our CSS files in the following manner:
 
@@ -104,7 +104,7 @@ We are organizing our CSS files in the following manner:
 
 
 CSS class names
-~~~~~~~~~~~~~~~
+---------------
 
 CSS class naming conventions
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

docs/source/developer/documents.rst

@@ -1,7 +1,7 @@
 .. _documents:
 
 Documents
----------
+=========
 
 JupyterLab can be extended in several ways:
 
@@ -16,7 +16,7 @@ For this section, the term 'document' refers to any visual thing that
 is backed by a file stored on disk (i.e. uses Contents API).
 
 Overview of document architecture
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------------
 
 A 'document' in JupyterLab is represented by a model instance implementing the `IModel <https://jupyterlab.github.io/jupyterlab/interfaces/_docregistry_src_index_.documentregistry.imodel.html>`__ interface. The model interface is intentionally fairly small, and concentrates on representing the data in the document and signaling changes to that data. Each model has an associated `context <https://jupyterlab.github.io/jupyterlab/interfaces/_docregistry_src_index_.documentregistry.icontext.html>`__ instance as well. The context for a model is the bridge between the internal data of the document, stored in the model, and the file metadata and operations possible on the file, such as save and revert. Since many objects will need both the context and the model, the context contains a reference to the model as its `.model` attribute.
 
@@ -37,7 +37,7 @@ uses the Document Registry to create models and widgets for documents.
 The Document Manager handles the lifecycle of documents for the application.
 
 Document Registry
-~~~~~~~~~~~~~~~~~
+-----------------
 
 *Document widget extensions* in the JupyterLab application can register:
 
@@ -105,7 +105,7 @@ re-implemented. Instead, the contexts are intended to be the glue
 between the document model and the wider application.
 
 Document Manager
-~~~~~~~~~~~~~~~~
+----------------
 
 The *Document Manager* handles:
 

docs/source/developer/extension_dev.rst

@@ -1,7 +1,8 @@
 .. _developer_extensions:
 
 Extension Developer Guide
--------------------------
+=========================
+
 JupyterLab can be extended in four ways via:
 
 -  **application plugins (top level):** Application plugins extend the
@@ -30,7 +31,7 @@ to any GitHub extension repository.
 
 
 Goals of the Federated Extension System
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------------------
 - Users should be able to install and use extensions without requiring ``node`` or a build step
 - Extension authors should be able to easily build and distribute extensions
 - The existing capabilities of built-in extensions should still work
@@ -39,7 +40,7 @@ Goals of the Federated Extension System
 - Extensions should be discoverable
 
 Implementation
-~~~~~~~~~~~~~~
+--------------
 - We provide a ``jupyter labextension build`` script that is used to build federated bundles
    - The command produces a set of static assets that are shipped along with a package (notionally on ``pip``/``conda``)
    - It is a Python cli so that it can use the dependency metadata from the active JupyterLab
@@ -58,14 +59,14 @@ Implementation
 - We update the ``extension-manager`` to target metadata on ``pypi``/``conda`` and consume those packages.
 
 Tools
-~~~~~
+-----
 - ``jupyter labexension build`` python command line tool
 - ``jupyter labextension develop`` python command line tool
 - ``python -m jupyterlab.upgrade_extension`` python command line tool
 - ``cookiecutter`` for extension authors
 
 Workflow for extension authors
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------
 - Use the ``cookiecutter`` to create the extension
 - Run ``jupyter labextension develop`` to build and symlink the files
 - Run ``jlpm run watch`` to start watching
@@ -80,7 +81,7 @@ Workflow for extension authors
 
 
 Tutorials
-~~~~~~~~~
+---------
 
 We provide a set of guides to get started writing third-party extensions for JupyterLab:
 
@@ -90,7 +91,7 @@ We provide a set of guides to get started writing third-party extensions for Jup
 - :ref:`developer-extension-points`: A list of the most common JupyterLab extension points.
 
 Cookiecutters
-~~~~~~~~~~~~~
+-------------
 
 We provide several cookiecutters to create JupyterLab plugin extensions:
 
@@ -100,7 +101,7 @@ We provide several cookiecutters to create JupyterLab plugin extensions:
 - `theme-cookiecutter <https://github.com/jupyterlab/theme-cookiecutter>`_: Create a new theme for JupyterLab
 
 API Documentation
-~~~~~~~~~~~~~~~~~
+-----------------
 
 If you are looking for lower level details on the JupyterLab and Lumino API:
 
@@ -108,7 +109,7 @@ If you are looking for lower level details on the JupyterLab and Lumino API:
 - `Lumino API Documentation <https://jupyterlab.github.io/lumino/>`_
 
 Plugins
-~~~~~~~
+-------
 
 A plugin adds a core functionality to the application:
 
@@ -154,7 +155,7 @@ Here is a dependency graph for the core JupyterLab components: |dependencies|
 
 
 Application Object
-~~~~~~~~~~~~~~~~~~
+------------------
 
 A Jupyter front-end application object is given to each plugin in its
 ``activate()`` function. The application object has:
@@ -167,7 +168,7 @@ A Jupyter front-end application object is given to each plugin in its
 -  ``shell`` - a generic Jupyter front-end shell instance, which holds the user interface for the application.
 
 Jupyter Front-End Shell
-~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------
 
 The Jupyter front-end
 `shell <https://jupyterlab.github.io/jupyterlab/interfaces/_application_src_index_.jupyterfrontend.ishell.html>`__
@@ -182,7 +183,7 @@ In JupyterLab, the application shell consists of:
 -  A ``header`` area for custom elements.
 
 Lumino
-~~~~~~~~
+------
 
 The Lumino library is used as the underlying architecture of
 JupyterLab and provides many of the low level primitives and widget
@@ -198,7 +199,7 @@ interaction that enable listeners to react to changes in an observed
 object.
 
 Extension Authoring
-~~~~~~~~~~~~~~~~~~~
+-------------------
 
 An Extension is a valid `npm
 package <https://docs.npmjs.com/getting-started/what-is-npm>`__ that
@@ -391,7 +392,7 @@ Finally, you will need to configure babel with a ``babel.config.js`` file contai
 .. _rendermime:
 
 Mime Renderer Extensions
-~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------
 
 Mime Renderer extensions are a convenience for creating an extension
 that can render mime data and potentially render files of a given type.
@@ -433,7 +434,7 @@ calling ``.setData()`` with updated data for the rendered MIME type. The
 document can then be saved by the user in the usual manner.
 
 Themes
-~~~~~~
+------
 
 A theme is a JupyterLab extension that uses a ``ThemeManager`` and can
 be loaded and unloaded dynamically. The package must include all static
@@ -456,7 +457,7 @@ It is also possible to create a new theme using the
 `TypeScript theme cookiecutter <https://github.com/jupyterlab/theme-cookiecutter>`__.
 
 Standard (General-Purpose) Extensions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------------------
 
 JupyterLab's modular architecture is based around the idea
 that all extensions are on equal footing, and that they interact
@@ -592,7 +593,7 @@ In addition to the file system that is accessed by using the
 system that can be used to provide default setting values and user overrides.
 
 Extension Settings
-``````````````````
+""""""""""""""""""
 
 An extension can specify user settings using a JSON Schema. The schema
 definition should be in a file that resides in the ``schemaDir``
@@ -635,7 +636,7 @@ added in the application settings directory (by default this is the
   }
 
 State Database
-``````````````
+""""""""""""""
 
 The state database can be accessed by importing ``IStateDB`` from
 ``@jupyterlab/statedb`` and adding it to the list of ``requires`` for

docs/source/developer/extension_migration.rst

@@ -1,7 +1,7 @@
 .. _extension_migration:
 
 JupyterLab 1.x to 2.x Extension Migration Guide
-------------------------------------------------
+===============================================
 
 This is a migration guide for updating extensions that support JupyterLab 1.x
 to work in JupyterLab 2.x. We will look at two examples of extensions that
@@ -14,7 +14,7 @@ cover most of the APIs that extension authors might be using:
   https://github.com/jupyterlab/jupyterlab-shortcutui/pull/53/files
 
 Upgrading library versions
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------
 
 The ``@phosphor/*`` libraries that JupyterLab 1.x uses have been renamed to
 ``@lumino/*``. Updating your ``package.json`` is straightforward. The easiest
@@ -44,7 +44,7 @@ there.
   ``package.json`` should depend on version ``^2.0.0`` of these packages.
 
 Migrating from ``@phosphor`` to ``@lumino``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------------------------
 
 The foundational packages used by JupyterLab are now all prefixed with the NPM
 namespace ``@lumino`` instead of ``@phosphor``. The APIs for these packages
@@ -99,7 +99,7 @@ the new ``@lumino`` namespaced packages:
     e.g. ``lm-dragenter``
 
 Updating former ``@jupyterlab/coreutils`` imports
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------------------------------
 
 JupyterLab 2.0 introduces several new packages with classes and tokens that
 have been moved out of ``@jupyterlab/coreutils`` into their own packages. These
@@ -135,7 +135,7 @@ exports have been moved.
 ============================  =================================
 
 Using ``Session`` and ``SessionContext`` to manage kernel sessions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------------------------------------------
 .. note::
 
   For full API documentation and examples of how to use
@@ -170,7 +170,7 @@ For example, consider how the ``@jupyterlab/debugger`` extension's
   from a new kernel connection), you can do ``await kernel.info``.
 
 Using the new icon system and ``LabIcon``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------------------------
 .. note::
 
   For full API documentation and examples of how to use

docs/source/developer/extension_migration_2_3.rst

@@ -1,12 +1,12 @@
 .. _extension_migration_2_3:
 
 JupyterLab 2.x to 3.x Extension Migration Guide
-------------------------------------------------
+===============================================
 
 This is a migration guide for updating extensions that support JupyterLab 2.x to work in JupyterLab 3.x.
 
 Upgrading library versions manually
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------------------
 
 To update the extensions so it is compatible with the 3.0 release, update the compatibility
 range of the ``@jupyterlab`` dependencies in the ``package.json``. The diff should be similar to:
@@ -21,7 +21,7 @@ range of the ``@jupyterlab`` dependencies in the ``package.json``. The diff shou
    +    "@jupyterlab/application": "^3.0.0",
 
 Upgrading library versions using the upgrade script
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------------------------------
 
 JupyterLab 3.0 provides a script to upgrade an existing extension to use the new extension system and packaging.
 
@@ -110,7 +110,7 @@ Extension developers do not need to interact with ``@jupyterlab/builder`` direct
 For more details about the new file structure and packaging of the extension, check out the extension tutorial: :ref:`extension_tutorial`
 
 Publishing the extension to PyPI and conda-forge
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------------------------
 
 Starting from JupyterLab 3.0, extensions can be distributed as a Python package.
 

docs/source/developer/extension_points.rst

@@ -1,7 +1,7 @@
 .. _developer-extension-points:
 
 Common Extension Points
------------------------
+=======================
 
 Most of the component parts of JupyterLab are designed to be extensible,
 and they provide public APIs that can be requested in extensions via tokens.
@@ -19,7 +19,7 @@ and more detailed descriptions of their public APIs may be found in the
 
 
 Commands
-~~~~~~~~
+--------
 
 Add a Command to the Command Registry
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -103,7 +103,7 @@ This can be useful to make a single command flexible enough to work in multiple
 
 
 Context Menu
-~~~~~~~~~~~~
+------------
 
 The application context menu is shown when the user right-clicks,
 and is populated with menu items that are most relevant to the thing that the user clicked.
@@ -147,7 +147,7 @@ For example, if you are building a custom React element, it would look like this
 .. _copy_shareable_link:
 
 Copy Shareable Link
-~~~~~~~~~~~~~~~~~~~
+-------------------
 
 The file browser provides a context menu item "Copy Shareable Link". The
 desired behavior will vary by deployment and the users it serves. The file
@@ -204,13 +204,13 @@ default plugin provided by the built-in file browser.
 
 
 Icons
-~~~~~
+-----
 
 See :ref:`ui_components`
 
 
 Keyboard Shortcuts
-~~~~~~~~~~~~~~~~~~
+------------------
 
 There are two ways of adding keyboard shortcuts in JupyterLab.
 If you don't want the shortcuts to be user-configurable,
@@ -255,7 +255,7 @@ Shortcuts added to the settings system will be editable by users.
 
 
 Launcher
-~~~~~~~~
+--------
 
 As with menus, keyboard shortcuts, and the command palette, new items can be added
 to the application launcher via commands.
@@ -273,7 +273,7 @@ In addition to providing a command ID, you also provide a category in which to p
 (e.g. 'Notebook', or 'Other'), as well as a rank to determine its position among other items.
 
 Left/Right Areas
-~~~~~~~~~~~~~~~~
+----------------
 
 The left and right areas of JupyterLab are intended to host more persistent user interface
 elements than the main area. That being said, extension authors are free to add whatever
@@ -305,7 +305,7 @@ The recommended ranges for this rank are:
 * 1000: The JupyterLab extension manager.
 
 Main Menu
-~~~~~~~~~
+---------
 
 There are three main ways to extend JupyterLab's main menu.
 
@@ -414,7 +414,7 @@ The available semantic menu items are:
 
 
 Status Bar
-~~~~~~~~~~
+----------
 
 JupyterLab's status bar is intended to show small pieces of contextual information.
 Like the left and right areas, it only expects a Lumino ``Widget``,
@@ -442,7 +442,7 @@ When the ``labStatus`` busy state changes, we update the text content of the
 .. _widget-tracker:
 
 Widget Tracker
-~~~~~~~~~~~~~~
+--------------
 
 Often extensions will want to interact with documents and activities created by other extensions.
 For instance, an extension may want to inject some text into a notebook cell,

docs/source/developer/extension_tutorial.rst

@@ -1,7 +1,7 @@
 .. _extension_tutorial:
 
 Let's Make an Astronomy Picture of the Day JupyterLab Extension
-----------------------------------------------------------------
+===============================================================
 
 JupyterLab extensions add features to the user experience. This page
 describes how to create one type of extension, an *application plugin*,
@@ -32,7 +32,7 @@ By working through this tutorial, you'll learn:
 Sound like fun? Excellent. Here we go!
 
 Set up a development environment
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------
 
 Install conda using miniconda
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ Now we can install the latest version of JupyterLab.
     pip install jupyterlab --pre
 
 Create a repository
-~~~~~~~~~~~~~~~~~~~
+-------------------
 
 Create a new repository for your extension (see, for example, the
 `GitHub instructions <https://help.github.com/articles/create-a-repo/>`__. This is an
@@ -91,7 +91,7 @@ optional step, but highly recommended if you want to share your
 extension.
 
 Create an extension project
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------
 
 Initialize the project from a cookiecutter
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -206,7 +206,7 @@ JupyterLab to see the effects of changes below.
 
 
 Add an Astronomy Picture of the Day widget
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------------------
 
 Show an empty panel
 ^^^^^^^^^^^^^^^^^^^
@@ -474,7 +474,7 @@ in the reference project. When it's working, make another git commit.
     git commit -m 'Show a picture in the panel'
 
 Improve the widget behavior
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------
 
 Center the image, add attribution, and error messaging
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -888,7 +888,7 @@ of this tutorial.
 .. _packaging your extension:
 
 Packaging your extension
-~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------
 
 JupyterLab extensions for JupyterLab 3.0 can be distributed as Python
 packages. The cookiecutter template we used contains all of the Python
@@ -938,7 +938,7 @@ works.
 .. _extension_tutorial_publish:
 
 Publishing your extension
-~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------
 
 You can publish your Python package to the `PyPI <https://pypi.org>`_ or
 `conda-forge <https://conda-forge.org>`_ repositories so users can easily
@@ -963,7 +963,7 @@ You may want to also publish your extension as a JavaScript package to the
    definition.
 
 Learn more
-~~~~~~~~~~
+----------
 
 You've completed the tutorial. Nicely done! If you want to keep
 learning, here are some suggestions about what to try next:

docs/source/developer/notebook.rst

@@ -1,8 +1,8 @@
 Notebook
---------
+========
 
 Background
-~~~~~~~~~~
+----------
 
 .. _architecture-walkthrough:
 
@@ -25,7 +25,7 @@ constructs a new
 from a model and populates the toolbar with default widgets.
 
 Structure of the Notebook plugin
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------
 
 The Notebook plugin provides a model and widgets for dealing with
 notebook files.
@@ -49,7 +49,7 @@ A code cell contains a list of **output models**. The list of cells and
 the list of outputs can be observed for changes.
 
 Cell operations
-'''''''''''''''
+"""""""""""""""
 
 The NotebookModel cell list supports single-step operations such as
 moving, adding, or deleting cells. Compound cell list operations, such
@@ -61,7 +61,7 @@ undo feature. (Note: CodeMirror editor's undo does not cover cell
 metadata changes.)
 
 Metadata
-''''''''''''''''''''
+""""""""
 
 The notebook model and the cell model (i.e. notebook cells) support
 getting and setting metadata through an
@@ -93,7 +93,7 @@ The NotebookModel cell list provides ways to do fine-grained changes to
 the cell list.
 
 Higher level actions using NotebookActions
-''''''''''''''''''''''''''''''''''''''''''
+""""""""""""""""""""""""""""""""""""""""""
 
 Higher-level actions are contained in the
 `NotebookActions <https://jupyterlab.github.io/jupyterlab/classes/_notebook_src_index_.notebookactions.html>`__
@@ -102,7 +102,7 @@ cell and select the next cell, merge or split cells at the cursor,
 delete selected cells, etc.
 
 Widget hierarchy
-''''''''''''''''
+""""""""""""""""
 
 A Notebook widget contains a list of `cell
 widgets <https://jupyterlab.github.io/jupyterlab/classes/_cells_src_index_.cell.html>`__,
@@ -127,7 +127,7 @@ list. An OutputArea uses a notebook-specific
 object to render ``display_data`` output messages.
 
 Rendering output messages
-'''''''''''''''''''''''''
+"""""""""""""""""""""""""
 
 A **Rendermime plugin** provides a pluggable system for rendering output
 messages. Default renderers are provided for markdown, html, images,
@@ -142,7 +142,7 @@ notebook-specific widget state.
 .. _extend-notebook-plugin:
 
 How to extend the Notebook plugin
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------------
 
 We'll walk through two notebook extensions:
 

docs/source/developer/patterns.rst

@@ -1,12 +1,12 @@
 Design Patterns
----------------
+===============
 
 There are several design patterns that are repeated throughout the
 repository. This guide is meant to supplement the `TypeScript Style
 Guide <https://github.com/jupyterlab/jupyterlab/wiki/TypeScript-Style-Guide>`__.
 
 TypeScript
-~~~~~~~~~~
+----------
 
 TypeScript is used in all of the source code. TypeScript is used because
 it provides features from the most recent EMCAScript 6 standards, while
@@ -14,14 +14,14 @@ providing type safety. The TypeScript compiler eliminates an entire
 class of bugs, while making it much easier to refactor code.
 
 Initialization Options
-~~~~~~~~~~~~~~~~~~~~~~
+----------------------
 
 Objects will typically have an ``IOptions`` interface for initializing
 the widget. The use of this interface enables options to be later added
 while preserving backward compatibility.
 
 ContentFactory Option
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 | A common option for a widget is a ``IContentFactory``, which is used
   to customize the child content in the widget.
@@ -31,14 +31,14 @@ ContentFactory Option
   nested content.
 
 Static Namespace
-~~~~~~~~~~~~~~~~
+----------------
 
 An object class will typically have an exported static namespace sharing
 the same name as the object. The namespace is used to declutter the
 class definition.
 
 Private Module Namespace
-~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------
 
 The "Private" module namespace is used to group variables and functions
 that are not intended to be exported and may have otherwise existed as
@@ -48,7 +48,7 @@ module itself. Finally, the namespace enables the entire section to be
 collapsed in an editor if desired.
 
 Disposables
-~~~~~~~~~~~
+-----------
 
 | JavaScript does not support "destructors", so the ``IDisposable``
   pattern is used to ensure resources are freed and can be claimed by
@@ -67,7 +67,7 @@ Disposables
   until the base class ``dispose()`` method is called.
 
 Messages
-~~~~~~~~
+--------
 
 Messages are intended for many-to-one communication where outside
 objects influence another object. Messages can be conflated and
@@ -75,7 +75,7 @@ processed as a single message. They can be posted and handled on the
 next animation frame.
 
 Signals
-~~~~~~~
+-------
 
 Signals are intended for one-to-many communication where outside objects
 react to changes on another object. Signals are always emitted with the
@@ -90,7 +90,7 @@ the connection to be properly cleared by ``clearSignalData(this)``.
 Using a private method avoids allocating a closure for each connection.
 
 Models
-~~~~~~
+------
 
 Some of the more advanced widgets have a model associated with them. The
 common pattern used is that the model is settable and must be set
@@ -108,14 +108,14 @@ constructor has finished evaluating, resulting in undefined state.
 .. _getters-vs-methods:
 
 Getters vs. Methods
-~~~~~~~~~~~~~~~~~~~
+-------------------
 
 Prefer a method when the return value must be computed each time. Prefer
 a getter for simple attribute lookup. A getter should yield the same
 value every time.
 
 Data Structures
-~~~~~~~~~~~~~~~
+---------------
 
 For public API, we have three options: JavaScript ``Array``,
 ``IIterator``, and ``ReadonlyArray`` (an interface defined by
@@ -140,7 +140,7 @@ Prefer an ``IIterator`` for:
 -  A set of return values that can be computed lazily.
 
 DOM Events
-~~~~~~~~~~
+----------
 
 If an object instance should respond to DOM events, create a
 ``handleEvent`` method for the class and register the object instance as
@@ -158,7 +158,7 @@ see the
 API.
 
 Promises
-~~~~~~~~
+--------
 
 We use Promises for asynchronous function calls, and a shim for browsers
 that do not support them. When handling a resolved or rejected Promise,
@@ -166,7 +166,7 @@ make sure to check for the current state (typically by checking an
 ``.isDisposed`` property) before proceeding.
 
 Command Names
-~~~~~~~~~~~~~
+-------------
 
 Commands used in the application command registry should be formatted as
 follows: ``package-name:verb-noun``. They are typically grouped into a

docs/source/developer/repo.rst

@@ -1,7 +1,7 @@
 .. _developer-guide:
 
 General Codebase Orientation
-----------------------------
+============================
 
 The ``jupyterlab`` repository is a monorepo: it contains code for many
 packages that are versioned and published independently.
@@ -14,7 +14,7 @@ See the `Contributing Guidelines <https://github.com/jupyterlab/jupyterlab/blob/
 for detailed developer installation instructions.
 
 Directories
-~~~~~~~~~~~
+-----------
 
 The repository contains a number of top-level directories, the contents of which
 are described here.

docs/source/developer/terminology.rst

@@ -1,12 +1,12 @@
 Terminology
------------
+===========
 
 Learning to use a new technology and its architecture can be complicated
 by the jargon used to describe components. We provide this terminology
 guide to help smooth the learning the components.
 
 Terms
-~~~~~
+-----
 
 -  *Application* - The main application object that hold the application
    shell, command registry, and keymap registry. It is provided to all

docs/source/developer/ui_components.rst

@@ -32,7 +32,7 @@ current JupyterLab theme.
 icon system introduced in JupyterLab v2.0.
 
 How JupyterLab handles icons
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The @jupyterlab/ui-components package provides icons to the rest of
 JupyterLab, in the form of a set of ``LabIcon`` instances (currently
@@ -40,7 +40,7 @@ about 80). All of the icons in the core JupyterLab packages are rendered
 using one of these ``LabIcon`` instances.
 
 Using the icons in your own code
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 You can use any of JupyterLab icons in your own code via an ``import``
 statement. For example, to use ``jupyterIcon`` you would first do:
@@ -50,7 +50,7 @@ statement. For example, to use ``jupyterIcon`` you would first do:
    import { jupyterIcon } from '@jupyterlab/ui-components';
 
 How to render an icon into a DOM node
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Icons can be added as children to any ``div`` or ``span`` nodes using
 the ``icon.element(...)`` method (where ``icon`` is any instance of
@@ -72,7 +72,7 @@ parameters into ``.element(...)``. Any valid CSS parameter can be used
 instead of ``foo-bar: '8px'``, you’d need to use ``fooBar: '8px'``.
 
 How to render an icon as a React component
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Icons can also be rendered using React. The ``icon.react`` parameter
 holds a standard React component that will display the icon on render.
@@ -115,7 +115,7 @@ can result in a `memory
 leak <https://stackoverflow.com/a/48198011/425458>`__.
 
 How to create your own custom ``LabIcon``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 You can create your own custom icon by constructing a new instance of
 ``LabIcon``:
@@ -131,7 +131,7 @@ where ``name`` should be of the form “your-pkg:icon-name”, and
 ``svgstr`` is the raw contents of your icon’s svg file.
 
 How to create a new ``LabIcon`` from an external svg file
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Although you can copy-and-paste an svg directly into the ``LabIcon``
 constructor, the best practice is to keep the svg for each of your icons
@@ -159,7 +159,7 @@ You can then ``import`` the contents of an svg file:
    });
 
 Sync icon color to JupyterLab theme
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 .. raw:: html
 
@@ -171,7 +171,7 @@ Sync icon color to JupyterLab theme
 | In other words, each element of your svg that a ``fill="..."`` or a ``stroke="..."`` property should also have a ``class="jp-icon<whatever>"`` property.
 
 Available icon classes
-^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""
 
 .. raw:: html
 
@@ -218,7 +218,7 @@ lighest/darkest background color, while ``jp-icon-accent1`` is somewhat
 darker/lighter, and so forth.
 
 Adding classes to a one-color icon
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""""""""""""
 
 For most simple, one-color icons, it is desirable for the icon's color
 to strongly constrast with that of the application's background. You can
@@ -243,7 +243,7 @@ acheive this using one of the ``jp-iconX`` classes.
    </svg>
 
 Adding classes to a multi-colored icon
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""""""""""""""""
 
 For more complex icons, each element that needs to match the background
 should be annotated with a ``jp-icon-accentX`` class, while each element
@@ -273,10 +273,10 @@ that needs to contrast with the background should be annotated with a
    </svg>
 
 Background
-~~~~~~~~~~
+^^^^^^^^^^
 
 Icon handling in Jupyterlab
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
+"""""""""""""""""""""""""""
 
 Pre JupyterLab 2.0, most icons were created using the icons-as-css-background
 pattern:
@@ -336,7 +336,7 @@ What you end up with is a DOM node (by default a ‘div’) that has an
 inline svg node as a child.
 
 ``background-image`` vs inline svg
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""""""""""""
 
 The big limitation of the old icon-as-css-background pattern is that svg
 images rendered as ``background-image`` are invisible to CSS. On the

docs/source/developer/ui_helpers.rst

@@ -1,14 +1,14 @@
 User Interface Helpers
-----------------------
+======================
 
 JupyterLab comes with helpers to show or request simple information from a user.
 Those speed up development and ensure a common look and feel.
 
 Dialogs
-~~~~~~~
+-------
 
 Message Dialogs
-'''''''''''''''
+^^^^^^^^^^^^^^^
 
 Helper functions to show a message to the user are available in the ``apputils`` package.
 These dialogs return a ``Promise`` resolving when the user dismisses the dialog.
@@ -19,7 +19,7 @@ There is one helper:
 
 
 Input Dialogs
-'''''''''''''
+^^^^^^^^^^^^^
 
 Helper functions to request a single input from the user are available in the ``apputils``
 package within the ``InputDialog`` namespace. There are four helpers:
@@ -74,7 +74,7 @@ a ``Promise`` resolving in a ``Dialog.IResult`` object.
 
 
 File Dialogs
-''''''''''''
+^^^^^^^^^^^^
 
 Two helper functions to ask a user to open a file or a directory are
 available in the ``filebrowser`` package under the namespace ``FileDialog``.

docs/source/developer/virtualdom.rst

@@ -1,7 +1,7 @@
 .. _react:
 
 React
------
+=====
 
 
 Many JupyterLab APIs require `Lumino`

docs/source/developer/xkcd_extension_tutorial.rst

@@ -1,6 +1,6 @@
 :orphan:
 
 The extension tutorial has moved!
-----------------------------------
+=================================
 
 With the release of JupyterLab 1.0, we've also created a brand-new extension tutorial! This old tutorial is now out-of-date and has been retired, but `you can find the new tutorial here <https://jupyterlab.readthedocs.io/en/stable/developer/extension_tutorial.html>`__.

docs/source/getting_started/changelog.rst

@@ -14,35 +14,35 @@ User-facing changes
 ^^^^^^^^^^^^^^^^^^^
 
 Extensions can be installed without building JupyterLab with NodeJS
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 
 In JupyterLab 3.0, a new recommended way of distributing and installing extensions as Python pip or conda packages is available. Installing such extensions does not require rebuilding JupyterLab and does not require having NodeJS installed. The previous way of distributing extensions as npm packages requiring rebuilding JupyterLab is still available as well. See the `documentation <https://jupyterlab.readthedocs.io/en/latest/user/extensions.html#extensions>`__ for more details.
 
 The JupyterLab interface supports multiple languages
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+""""""""""""""""""""""""""""""""""""""""""""""""""""
 JupyterLab now provides the ability to set the display language of the user interface.
 See the `documentation <https://jupyterlab.readthedocs.io/en/latest/user/language.html>`__ for more details.
 
 
 A new visual debugger
-~~~~~~~~~~~~~~~~~~~~~
+"""""""""""""""""""""
 
 JupyterLab now ships with a debugger front-end by default, available for kernels that support the new debugging protocol.  See the `documentation <https://jupyterlab.readthedocs.io/en/latest/user/debugger.html>`__ for more details.
 
 
 Improvements to Single Document Mode and Mobile 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""""""""""""""""""""""""""""""""""""""""""""""
 The single-document user interface is now more streamlined. JupyterLab now supports showing the current file in use in the browser URL bar, similar to the classic Jupyter Notebook.
 
 
 Table of Contents is now in core
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+""""""""""""""""""""""""""""""""
 
 The popular Table of Contents extension is now part of core JupyterLab. This core extension makes it easy to see an outline view of notebooks and other documents.
 
 
 Visual filter in file browser 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""""""""""""""""""""""""""""
 
 The file browser now has a filter input which filters the list of files using the same fuzzy matching as the command palette.
 
@@ -50,7 +50,7 @@ For Developers
 ^^^^^^^^^^^^^^
 
 Federated Extensions
-~~~~~~~~~~~~~~~~~~~~
+""""""""""""""""""""
 
 Users will typically consume federated extensions, which are Python packages with static assets built using ``JupyterLab``.
 See the updated APOD tutorial for the workflow of creating a federated extension from scratch.
@@ -98,7 +98,7 @@ which used this script heavily.  There are two highlighted commits that demonstr
 * Experiment with module federation (`#8385 <https://github.com/jupyterlab/jupyterlab/pull/8385>`__)
 
 Jupyter Server
-~~~~~~~~~~~~~~
+""""""""""""""
 JupyterLab 3.0 uses Jupyter Server instead of the classic Notebook server.  Existing server extensions will be shimmed, but it 
 is advised to update extensions to use `jupyter_server <https://github.com/jupyter/jupyter_server>`__.
 
@@ -110,7 +110,7 @@ is advised to update extensions to use `jupyter_server <https://github.com/jupyt
 * Jupyterlab as server extension (`#7416 <https://github.com/jupyterlab/jupyterlab/pull/7416>`__)
 
 Internationalization
-~~~~~~~~~~~~~~~~~~~~
+""""""""""""""""""""
 The JupyterLab UI now supports translation.
 
 * Add options to add prefix to strings (`#8946 <https://github.com/jupyterlab/jupyterlab/pull/8946>`__)
@@ -122,13 +122,13 @@ The JupyterLab UI now supports translation.
 * Add translation package (`#8681 <https://github.com/jupyterlab/jupyterlab/pull/8681>`__)
 
 Visual Debugger
-~~~~~~~~~~~~~~~
+"""""""""""""""
 * Fix invisible breakpoint in debugger (`#8908 <https://github.com/jupyterlab/jupyterlab/pull/8908>`__)
 * Port ``jupyterlab/debugger`` PR #527 to JupyterLab (`#8878 <https://github.com/jupyterlab/jupyterlab/pull/8878>`__)
 * Add jupyterlab debugger to core (`#8747 <https://github.com/jupyterlab/jupyterlab/pull/8747>`__, `#75 <https://github.com/jupyterlab/team-compass/issues/75>`__)
 
 Table of Contents
-~~~~~~~~~~~~~~~~~
+"""""""""""""""""
 * Add tests for the toc (`#8757 <https://github.com/jupyterlab/jupyterlab/pull/8757>`__, `#8558 <https://github.com/jupyterlab/jupyterlab/issues/8558>`__)
 * Change toc to use labicon (`#8692 <https://github.com/jupyterlab/jupyterlab/pull/8692>`__, `#8557 <https://github.com/jupyterlab/jupyterlab/issues/8557>`__)
 * Switch from using settings registry to a signal for notebook collapsing behavior in toc (`#8601 <https://github.com/jupyterlab/jupyterlab/pull/8601>`__)
@@ -136,7 +136,7 @@ Table of Contents
 * Merge toc extension into core (`#8538 <https://github.com/jupyterlab/jupyterlab/pull/8538>`__)
 
 Other
-~~~~~
+"""""
 * Upgrade to TypeScript 4 (`#8883 <https://github.com/jupyterlab/jupyterlab/pull/8883>`__)
 * File browser filter (`#8615 <https://github.com/jupyterlab/jupyterlab/pull/8615>`__)
 * Allow to substitute the default completer renderer (`#8930 <https://github.com/jupyterlab/jupyterlab/pull/8930>`__, `#8926 <https://github.com/jupyterlab/jupyterlab/issues/8926>`__)
@@ -175,7 +175,7 @@ Other
 * Add a debugger section to the user docs and contributing guide (`#8977 <https://github.com/jupyterlab/jupyterlab/pull/8977>`__)
 
 Single Document Mode and Mobile Enhancements
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+""""""""""""""""""""""""""""""""""""""""""""
 * Improved url scheme, state, interactions for single document mode (`#8715 <https://github.com/jupyterlab/jupyterlab/pull/8715>`__)
 * Add workspace mime handler and loading/saving workspaces manually (`#8691 <https://github.com/jupyterlab/jupyterlab/pull/8691>`__)
 * Modify ansi color fix (`#8555 <https://github.com/jupyterlab/jupyterlab/pull/8555>`__, `#8554 <https://github.com/jupyterlab/jupyterlab/issues/8554>`__)
@@ -183,7 +183,7 @@ Single Document Mode and Mobile Enhancements
 * Incrementally improve jupyterlab mobile ux (`#8456 <https://github.com/jupyterlab/jupyterlab/pull/8456>`__)
 
 Benchmarks (now a separate repository)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+""""""""""""""""""""""""""""""""""""""
 * Move benchmarks to seperate repo (`#8795 <https://github.com/jupyterlab/jupyterlab/pull/8795>`__)
 * Fix off by one error in benchmark samples (`#8785 <https://github.com/jupyterlab/jupyterlab/pull/8785>`__)
 * Benchmark params configurable and increase timeout (`#8786 <https://github.com/jupyterlab/jupyterlab/pull/8786>`__)
@@ -493,7 +493,7 @@ For developers
 See :ref:`extension_migration` for help in migrating extensions to JupyterLab 2.0.
 
 Backward incompatible changes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""""""""""""""""""""""""""""
 
 * Switch from ``@phosphor`` to ``@lumino`` dependencies. (`#7582 <https://github.com/jupyterlab/jupyterlab/pull/7582>`__, `#7534 <https://github.com/jupyterlab/jupyterlab/issues/7534>`__, `#7763 <https://github.com/jupyterlab/jupyterlab/pull/7763>`__, `#7762 <https://github.com/jupyterlab/jupyterlab/issues/7762>`__, `#7595 <https://github.com/jupyterlab/jupyterlab/pull/7595>`__)
 * Factor out the ``settingsregistry`` and ``statedb`` packages from coreutils (`#7681 <https://github.com/jupyterlab/jupyterlab/pull/7681>`__, `#7615 <https://github.com/jupyterlab/jupyterlab/issues/7615>`__)
@@ -510,7 +510,7 @@ Backward incompatible changes
 
 
 Other changes
-~~~~~~~~~~~~~
+"""""""""""""
 * New property inspector used to display the properties of the currently selected main area widget (`#7665 <https://github.com/jupyterlab/jupyterlab/pull/7665>`__, `#7664 <https://github.com/jupyterlab/jupyterlab/issues/7664>`__, `#7718 <https://github.com/jupyterlab/jupyterlab/pull/7718>`__, `#7686 <https://github.com/jupyterlab/jupyterlab/issues/7686>`__)
 * Allow metadata for launcher items (`#7654 <https://github.com/jupyterlab/jupyterlab/pull/7654>`__, `#7652 <https://github.com/jupyterlab/jupyterlab/issues/7652>`__)
 * Allow default file browser to restore manually. (`#7695 <https://github.com/jupyterlab/jupyterlab/pull/7695>`__, `#4009 <https://github.com/jupyterlab/jupyterlab/issues/4009>`__)

docs/source/getting_started/installation.rst

@@ -1,12 +1,12 @@
 .. _installation:
 
 Installation
-------------
+============
 
 JupyterLab can be installed using ``conda``, ``pip``, ``pipenv`` or ``docker``.
 
 conda
-~~~~~
+-----
 
 If you use ``conda``, you can install it with:
 
@@ -15,7 +15,7 @@ If you use ``conda``, you can install it with:
     conda install -c conda-forge jupyterlab
 
 pip
-~~~
+---
 
 If you use ``pip``, you can install it with:
 
@@ -30,7 +30,7 @@ If installing using ``pip install --user``, you must add the user-level
 OS X), you can achieve this by using ``export PATH="$HOME/.local/bin:$PATH"`` command.
 
 pipenv
-~~~~~~
+------
 
 If you use ``pipenv``, you can install it as:
 
@@ -61,7 +61,7 @@ Alternatively, you can run ``jupyter lab`` inside the virtualenv with
     pipenv run jupyter lab
 
 Docker
-~~~~~~
+------
 
 If you have `Docker installed <https://docs.docker.com/install/>`__, you can install and use JupyterLab by selecting one
 of the many `ready-to-run Docker images <https://jupyter-docker-stacks.readthedocs.io/en/latest/using/selecting.html>`__
@@ -72,7 +72,7 @@ JupyterLab is enabled in your container.
 
 
 Installing with Previous Versions of Notebook
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------------------------
 
 If you are using a version of Jupyter Notebook earlier than 5.3, then you must also run the following command to enable the JupyterLab
 server extension:
@@ -83,7 +83,7 @@ server extension:
 
 
 Prerequisites
-~~~~~~~~~~~~~
+-------------
 
 JupyterLab requires the Jupyter Notebook version 4.3 or later. To check
 the version of the ``notebook`` package that you have installed:
@@ -94,13 +94,13 @@ the version of the ``notebook`` package that you have installed:
 
 
 Usage with JupyterHub
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 Read the details on our :ref:`JupyterLab on JupyterHub documentation page <jupyterhub>`.
 
 
 Supported browsers
-~~~~~~~~~~~~~~~~~~
+------------------
 
 The latest versions of the following browsers are currently known to work:
 
@@ -117,7 +117,7 @@ A tool like `postcss <https://postcss.org/>`__ can be used to convert the CSS fi
 ``jupyterlab/build`` directory manually if desired.
 
 Usage with private NPM registry
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------------
 
 To install extensions, you will need access to a NPM packages registry. Some companies do not allow
 reaching directly public registry and have a private registry. To use it, you need to configure ``npm``
@@ -137,7 +137,7 @@ JupyterLab will pick up that registry automatically.
       python -c "from jupyterlab.commands import AppOptions; print(AppOptions().registry)"
 
 Installation problems
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 If your computer is behind corporate proxy or firewall,
 you may encounter HTTP and SSL errors due to custom security profiles managed by corporate IT departments.
@@ -230,7 +230,7 @@ on connectivity problems to HTTPS servers, you can disable using SSL for ``npm``
     npm set strict-ssl False
 
 Problems with Extensions and Settings
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------------------
 
 Jupyterlab saves settings via `PUT` requests to the server with a JSON5-compatible payload, even though it claims the PUT request is valid JSON. `JSON5 <https://json5.org/>`__ is a superset of JSON that allows comments, etc. There may be deployment problems, manifest as 400 error return codes when saving settings, if these `PUT` requests are rejected by a routing layer that tries to validate the payload as JSON instead of JSON5.
 

docs/source/getting_started/issue.rst

@@ -1,12 +1,12 @@
 .. _issue:
 
 Reporting an issue
-------------------
+==================
 
 Thank you for providing feedback about JupyterLab.
 
 Diagnosing an Issue
-~~~~~~~~~~~~~~~~~~~
+-------------------
 
 If you find a problem in JupyterLab, please follow the steps below to diagnose and report the issue. Following these steps helps you diagnose if the problem is likely from JupyterLab or from a different project.
 
@@ -50,7 +50,7 @@ You might also check your system for:
 .. _create-issue:
 
 Creating an issue
-~~~~~~~~~~~~~~~~~
+-----------------
 
 Before creating an issue, search in the issue tracker for relevant issues. If you find an issue describing your problem, comment there with the following information instead of creating a new issue. If you find a relevant resolved issue (closed and locked for discussion), create a new issue and reference the resolved issue.
 

docs/source/getting_started/overview.rst

@@ -1,7 +1,7 @@
 .. _overview:
 
 Overview
---------
+========
 
 JupyterLab is a next-generation web-based user interface for Project Jupyter.
 
@@ -58,7 +58,7 @@ classic Jupyter Notebook.
 .. _releases:
 
 JupyterLab Releases
-~~~~~~~~~~~~~~~~~~~
+-------------------
 
 Since JupyterLab 0.32 (February 2018), the releases of JupyterLab are suitable
 for general daily use by both Jupyter novices and users experienced with the

docs/source/getting_started/starting.rst

@@ -1,7 +1,7 @@
 .. _starting:
 
 Starting JupyterLab
--------------------
+===================
 
 Start JupyterLab using:
 

docs/source/index.rst

@@ -3,8 +3,9 @@
    You can adapt this file completely to your liking, but it should at least
    contain the root `toctree` directive.
 
+########################
 JupyterLab Documentation
-========================
+########################
 
 JupyterLab is the next-generation web-based user interface for Project Jupyter. `Try it on Binder <https://mybinder.org/v2/gh/jupyterlab/jupyterlab-demo/master?urlpath=lab/tree/demo>`__.  JupyterLab follows the Jupyter `Community Guides <https://jupyter.readthedocs.io/en/latest/community/content-community.html>`__.
 

docs/source/user/code_console.rst

@@ -1,7 +1,7 @@
 .. _code-console:
 
 Code Consoles
--------------
+=============
 
 Code consoles enable you to run code interactively in a kernel. The cells
 of a code console show the order in which code was executed in the

docs/source/user/commands.rst

@@ -1,7 +1,7 @@
 .. _commands:
 
 Command Palette
----------------
+===============
 
 All user actions in JupyterLab are processed through a centralized
 command system. These commands are shared and used throughout JupyterLab

docs/source/user/debugger.rst

@@ -1,14 +1,14 @@
 .. _debugger:
 
 Debugger
---------
+========
 
 JupyterLab 3.0 now ships with a Debugger front-end by default.
 
 This means that notebooks, code consoles and files can now be debugged from JupyterLab directly!
 
 Requirements
-~~~~~~~~~~~~
+------------
 
 For the debugger to be enabled and visible, a kernel with support for debugging is required.
 
@@ -24,7 +24,7 @@ To install ``xeus-python`` in a new ``conda`` environment:
    conda activate jupyterlab-debugger
 
 Usage
-~~~~~
+-----
 
 ``xeus-python`` can be selected from the JupyterLab launcher:
 
@@ -39,7 +39,7 @@ Enable the debugger, set breakpoints and step into the code:
 .. image:: ./images/debugger/step.gif
 
 Tutorial Notebook
-~~~~~~~~~~~~~~~~~
+-----------------
 
 There is also a tutorial notebook to try the debugger that is available on the `jupyter-ide-demo repo <https://github.com/blink1073/jupyter-ide-demo>`_.
 and can be run on Binder `here <https://mybinder.org/v2/gh/blink1073/jupyter-ide-demo/stable?urlpath=/lab/tree/index.ipynb>`_.

docs/source/user/documents_kernels.rst

@@ -1,7 +1,7 @@
 .. _kernel-backed-documents:
 
 Documents and Kernels
----------------------
+=====================
 
 In the Jupyter architecture, kernels are separate processes started by
 the server that run your code in different programming languages and

docs/source/user/export.rst

@@ -1,7 +1,7 @@
 .. _user_export:
 
 Exporting Notebooks
--------------------
+===================
 
 JupyterLab allows you to export your jupyter notebook files (``.ipynb``)
 into other file formats such as:
@@ -28,7 +28,8 @@ information visit the
 .. _user_export_revealjs:
 
 Reveal.js Slides
-~~~~~~~~~~~~~~~~
+----------------
+
 In order to export your notebooks as `Reveal.js <https://github.com/hakimel/reveal.js>`__
 slides, follow these steps:
 

docs/source/user/extensions.rst

@@ -1,7 +1,7 @@
 .. _user_extensions:
 
 Extensions
-----------
+==========
 
 Fundamentally, JupyterLab is designed as an extensible environment. JupyterLab
 extensions can customize or enhance any part of JupyterLab. They can provide
@@ -21,7 +21,7 @@ documentation <developer_extensions>`.
     :depth: 1
 
 Installing Extensions
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 A JupyterLab extension is a JavaScript package that runs in the browser. An
 extension's JavaScript can be distributed as a single JavaScript package
@@ -71,7 +71,7 @@ and install it directly.
 .. _install_command:
 
 Managing Extensions with ``jupyter labextension``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------------------------------
 
 The ``jupyter labextension`` command enables you to install or uninstall
 extensions from `npm
@@ -163,7 +163,7 @@ You can enable a disabled extension with:
 
 
 Managing Extensions Using the Extension Manager
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------------------------------
 
 You can use the Extension Manager in JupyterLab to manage extensions that are
 distributed as single JavaScript packages on npm.
@@ -472,7 +472,7 @@ all jupyterlab organization extensions.
 
 
 Advanced Usage
-~~~~~~~~~~~~~~
+--------------
 
 Any information that JupyterLab persists is stored in its application directory,
 including settings and built assets.
@@ -525,7 +525,7 @@ switch back to the default yarn registry, you will need to clean your
 
 
 Disabling Rebuild Checks
-''''''''''''''''''''''''
+""""""""""""""""""""""""
 
 JupyterLab automatically checks to see if it needs to rebuild on startup. In
 some cases, such as automated testing, you may wish to disable the startup
@@ -572,7 +572,7 @@ we can ensure better isolation between conda or other virtual environments.
 .. _extensions-1:
 
 extensions
-''''''''''
+""""""""""
 
 The ``extensions`` directory has the packed tarballs for each of the
 installed extensions for the app. If the application directory is not
@@ -586,7 +586,7 @@ again. If the ``sys-prefix`` version cannot be uninstalled, its plugins
 can still be ignored using ``ignoredPackages`` metadata in ``settings``.
 
 schemas
-'''''''
+"""""""
 
 The ``schemas`` directory contains `JSON
 Schemas <http://json-schema.org/>`__ that describe the settings used by
@@ -594,7 +594,7 @@ individual extensions. Users may edit these settings using the
 JupyterLab Settings Editor.
 
 settings
-''''''''
+""""""""
 
 The ``settings`` directory may contain ``page_config.json``, ``overrides.json``, and/or
 ``build_config.json`` files, depending on which configurations are
@@ -602,9 +602,7 @@ set on your system.
 
 .. _page_configjson:
 
-**page_config.json**
-
-
+*page_config.json*
 
 The ``page_config.json`` data is used to provide configuration data to the
 application environment.
@@ -654,7 +652,7 @@ An example of a ``page_config.json`` file is:
 
 .. _overridesjson:
 
-**overrides.json**
+*overrides.json*
 
 You can override default values of the extension settings by
 defining new default values in an ``overrides.json`` file.
@@ -674,7 +672,7 @@ added in the application settings directory (by default this is the
 
 .. _build_configjson:
 
-**build_config.json**
+*build_config.json*
 
 
 The ``build_config.json`` file is used to track the local directories
@@ -696,7 +694,7 @@ that have been explicitly uninstalled. An example of a
 
 
 staging and static
-''''''''''''''''''
+""""""""""""""""""
 
 The ``static`` directory contains the assets that will be loaded by the
 JupyterLab application. The ``staging`` directory is used to create the
@@ -708,7 +706,7 @@ application directory if they exist. You can run
 (i.e., the application without any extensions) instead.
 
 themes
-''''''
+""""""
 
 The ``themes`` directory contains assets (such as CSS and icons) for
 JupyterLab theme extensions.
@@ -717,7 +715,7 @@ JupyterLab theme extensions.
 JupyterLab User Settings Directory
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 The user settings directory contains the user-level settings for Jupyter extensions.
-By default, the location is ``~/.jupyter/lab/user-settings/``, where ``~`` is the user's home directory. This folder is not in the JupyterLab application directory,
+By default, the location is ``-/.jupyter/lab/user-settings/``, where ``-`` is the user's home directory. This folder is not in the JupyterLab application directory,
 because these settings are typically shared across Python environments.
 The location can be modified using the ``JUPYTERLAB_SETTINGS_DIR`` environment variable. Files are automatically created in this folder as modifications are made
 to settings from the JupyterLab UI. They can also be manually created.  The files
@@ -733,7 +731,7 @@ JupyterLab Workspaces Directory
 JupyterLab sessions always reside in a workspace. Workspaces contain the state
 of JupyterLab: the files that are currently open, the layout of the application
 areas and tabs, etc. When the page is refreshed, the workspace is restored.
-By default, the location is ``~/.jupyter/lab/workspaces/``, where ``~`` is the user's home directory. This folder is not in the JupyterLab application directory,
+By default, the location is ``-/.jupyter/lab/workspaces/``, where ``-`` is the user's home directory. This folder is not in the JupyterLab application directory,
 because these files are typically shared across Python environments.
 The location can be modified using the ``JUPYTERLAB_WORKSPACES_DIR`` environment variable. These files can be imported and exported to create default "profiles",
 using the :ref:`workspace command line tool <url-workspaces-cli>`.

docs/source/user/file_editor.rst

@@ -1,7 +1,7 @@
 .. _file-editor:
 
 Text Editor
------------
+===========
 
 The text editor in JupyterLab enables you to edit text files in
 JupyterLab:

docs/source/user/file_formats.rst

@@ -1,7 +1,7 @@
 .. _file-and-output-formats:
 
 File and Output Formats
------------------------
+=======================
 
 JupyterLab provides a unified architecture for viewing and editing data
 in a wide variety of formats. This model applies whether the data is in
@@ -54,7 +54,7 @@ other file formats.
 .. _markdown:
 
 Markdown
-~~~~~~~~
+--------
 
 -  File extension: ``.md``
 -  MIME type: ``text/markdown``
@@ -78,7 +78,7 @@ animation, edits to the Markdown source are immediately reflected in the
 rendered version.
 
 Images
-~~~~~~
+------
 
 -  File extensions: ``.bmp``, ``.gif``, ``.jpeg``, ``.jpg``, ``.png``,
    ``.svg``
@@ -106,7 +106,7 @@ submenu:
 .. _csv:
 
 Delimiter-separated Values
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------
 
 -  File extension: ``.csv``
 -  MIME type: None
@@ -154,7 +154,7 @@ Below is a table that shows the sizes of the largest test files we successfully
 The actual maximum size of files that can be successfully loaded will vary depending on the browser version and file content.
 
 JSON
-~~~~
+----
 
 -  File extension: ``.json``
 -  MIME type: ``application/json``
@@ -183,7 +183,7 @@ browser and select the “Editor” item in the “Open With” submenu:
   </div>
 
 HTML
-~~~~
+----
 
 -  File extension: ``.html``
 -  MIME type: ``text/html``
@@ -192,7 +192,7 @@ JupyterLab supports rendering HTML in cell output and editing HTML files
 as text in the file editor.
 
 LaTeX
-~~~~~
+-----
 
 -  File extension: ``.tex``
 -  MIME type: ``text/latex``
@@ -201,7 +201,7 @@ JupyterLab supports rendering LaTeX equations in cell output and editing
 LaTeX files as text in the file editor.
 
 PDF
-~~~
+---
 
 -  File extension: ``.pdf``
 -  MIME type: ``application/pdf``
@@ -220,7 +220,7 @@ in JupyterLab, double-click on the file in the file browser:
 .. _vega-lite:
 
 Vega/Vega-Lite
-~~~~~~~~~~~~~~
+--------------
 
 Vega:
 
@@ -287,7 +287,7 @@ A JupyterLab extension that supports Vega 3.x and Vega-Lite 2.x can be
 found `here <https://github.com/jupyterlab/jupyter-renderers>`__.
 
 Virtual DOM
-~~~~~~~~~~~
+-----------
 
 -  File extensions: ``.vdom``, ``.json``
 -  MIME type: ``application/vdom.v1+json``

docs/source/user/files.rst

@@ -1,10 +1,10 @@
 .. _working-with-files:
 
 Working with Files
-------------------
+==================
 
 Opening Files
-~~~~~~~~~~~~~
+-------------
 
 The file browser and File menu enable you to work with files and
 directories on your system. This includes opening, creating, deleting,
@@ -95,7 +95,7 @@ filesystem relative path. This can be used for passing arguments to open
 files in functions called in various kernels.
 
 Creating Files and Activities
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------------
 
 .. _file-create-plus:
 
@@ -142,7 +142,7 @@ from the context menu:
   </div>
 
 Uploading and Downloading
-~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------
 
 .. _file-upload:
 

docs/source/user/interface.rst

@@ -1,7 +1,7 @@
 .. _interface:
 
 The JupyterLab Interface
-------------------------
+========================
 
 JupyterLab provides flexible building blocks for interactive,
 exploratory computing. While JupyterLab has many features found in
@@ -30,7 +30,7 @@ To learn more about URLs in Jupyterlab, visit :ref:`urls`.
 .. _menu-bar:
 
 Menu Bar
-~~~~~~~~
+--------
 
 The menu bar at the top of JupyterLab has top-level menus that expose
 actions available in JupyterLab with their keyboard shortcuts. The
@@ -53,7 +53,7 @@ bar.
 .. _left-sidebar:
 
 Left Sidebar
-~~~~~~~~~~~~
+------------
 
 The left sidebar contains a number of commonly-used tabs, such as a file
 browser, a list of running kernels and terminals, the command palette,
@@ -80,7 +80,7 @@ JupyterLab extensions can add additional panels to the left sidebar.
 .. _main-area:
 
 Main Work Area
-~~~~~~~~~~~~~~
+--------------
 
 .. _main-area-vid:
 
@@ -102,7 +102,7 @@ marked with a colored top border (blue by default).
 .. _tabs:
 
 Tabs and Single-Document Mode
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------------
 
 The Tabs panel in the left sidebar lists the open documents or
 activities in the main work area:
@@ -134,7 +134,7 @@ When you leave single-document mode, the original layout of the main
 area is restored.
 
 Context Menus
-~~~~~~~~~~~~~
+-------------
 
 .. _context-menus-rightclick:
 
@@ -162,7 +162,7 @@ The browser’s native context menu can be accessed by holding down
 .. _shortcuts:
 
 Keyboard Shortcuts
-~~~~~~~~~~~~~~~~~~
+------------------
 
 .. _shortcuts-settings:
 

docs/source/user/jupyterhub.rst

@@ -1,7 +1,7 @@
 .. _jupyterhub:
 
 JupyterLab on JupyterHub
-------------------------
+========================
 
 JupyterLab works out of the box with JupyterHub 1.0+, and can even run side by side
 with the classic Notebook.
@@ -11,7 +11,7 @@ items in the File menu that allow the user to log out or go to the JupyterHub
 control panel.
 
 Use JupyterLab by Default
-~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------
 
 If you install JupyterLab on a system running JupyterHub, it will immediately be
 available at the ``/lab`` URL, but users will still be directed to the classic
@@ -26,7 +26,7 @@ by either typing that URL into the browser, or by using the "Launch Classic
 Notebook" item in JupyterLab's Help menu.
 
 Example Configuration
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 For a fully-configured example of using JupyterLab with JupyterHub, see
 the `jupyterhub-deploy-teaching

docs/source/user/language.rst

@@ -1,13 +1,13 @@
 .. _language:
 
 Localization and language
--------------------------
+=========================
 
 Staring with version 3.0, JupyterLab provides the ability to set
 the display language of the user interface.
 
 Language packs
-~~~~~~~~~~~~~~
+--------------
 
 To be able to provide a new display language, you will need to 
 install a language pack.
@@ -16,7 +16,7 @@ Visit the `language packs repository <https://github.com/jupyterlab/language-pac
 for a list of available packs.
 
 Installing
-''''''''''
+""""""""""
 
 Language packs are identified by the four letter code of the language and
 variant they provide. For example, for Simplified Chinese the language
@@ -35,7 +35,7 @@ If you use Pip:
    pip install jupyterlab-language-pack-zh-CN
 
 Changing the display language
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------------
 
 To change the interface language, select the Settings menu and then
 select the desired language in the Language submenu.

docs/source/user/notebook.rst

@@ -1,7 +1,7 @@
 .. _notebook:
 
 Notebooks
----------
+=========
 
 Jupyter notebooks are documents that combine live runnable code with
 narrative text (Markdown), equations (LaTeX), images, interactive

docs/source/user/running.rst

@@ -1,7 +1,7 @@
 .. _running:
 
 Managing Kernels and Terminals
-------------------------------
+==============================
 
 The Running panel in the left sidebar shows a list of all the kernels and
 terminals currently running across all notebooks, code consoles, and

docs/source/user/terminal.rst

@@ -1,6 +1,5 @@
 .. _terminal:
 
-==========
 Terminals
 ==========
 
@@ -43,9 +42,9 @@ re-open it using the Running tab in the left sidebar:
 
 
 
-~~~~~~~~~~~~
+
 Copy/Paste
-~~~~~~~~~~~~
+----------
 
 For macOS users,  ``Cmd+C`` and ``Cmd+V`` work as usual.
 

docs/source/user/urls.rst

@@ -1,7 +1,7 @@
 .. _urls:
 
 JupyterLab URLs
----------------
+===============
 
 Like the classic notebook, JupyterLab provides a way for users to copy URLs that
 open a specific notebook or file. Additionally, JupyterLab URLs are an advanced
@@ -12,7 +12,7 @@ specific file in a specific workspace <url-combine>`.
 .. _url-tree:
 
 File Navigation with ``/tree``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------------
 
 JupyterLab's file navigation URLs adopts
 the nomenclature of the classic notebook; these URLs are ``/tree`` URLs:
@@ -38,7 +38,7 @@ directory in the file browser.
 .. _url-workspaces-ui:
 
 Managing Workspaces (UI)
-~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------
 
 JupyterLab sessions always reside in a workspace. Workspaces contain the state
 of JupyterLab: the files that are currently open, the layout of the application
@@ -68,7 +68,7 @@ tabs simultaneously is also not supported.
 .. _url-clone:
 
 Cloning Workspaces
-~~~~~~~~~~~~~~~~~~
+------------------
 
 You can copy the contents of a workspace into another workspace with the ``clone`` url parameter.
 
@@ -93,7 +93,7 @@ To copy the contents of the workspace ``foo`` into the default workspace:
 .. _url-reset:
 
 Resetting a Workspace
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 Use the ``reset`` url parameter to clear a workspace of its contents.
 
@@ -112,7 +112,7 @@ To reset the contents of the default workspace:
 .. _url-combine:
 
 Combining URL Functions
-~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------
 
 These URL functions can be used separately, as above, or in combination.
 
@@ -138,7 +138,7 @@ To reset the contents of the default workspace and load a notebook:
 .. _url-workspaces-cli:
 
 Managing Workspaces (CLI)
-~~~~~~~~~~~~~~~~~~~~~~~~~
+-------------------------
 
 JupyterLab provides a command-line interface for workspace ``import`` and
 ``export``:
@@ -171,7 +171,7 @@ default workspace.
 
 
 Workspace File Format
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 A workspace file in a JSON file with a specific spec.
 

packages/ui-components/docs/source/labicon.rst

@@ -144,7 +144,7 @@ Sync icon color to JupyterLab theme
 | In other words, each element of your svg that a ``fill="..."`` or a ``stroke="..."`` property should also have a ``class="jp-icon<whatever>"`` property.
 
 Available icon classes
-~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^
 
 .. raw:: html
 
@@ -154,7 +154,7 @@ Available icon classes
 | All colors shown are for the standard light/dark theme, mouse over for hex values.
 
 ``jp-iconX``: contrast to theme background
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""""""""""""""""""""
 
 .. raw:: html
 
@@ -174,7 +174,7 @@ background color, while ``jp-icon1`` is somewhat lighter/darker, and so
 forth.
 
 ``jp-icon-accentX``: match to theme background
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+""""""""""""""""""""""""""""""""""""""""""""""
 
 .. raw:: html
 
@@ -191,7 +191,7 @@ lighest/darkest background color, while ``jp-icon-accent1`` is somewhat
 darker/lighter, and so forth.
 
 Adding classes to a one-color icon
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 For most simple, one-color icons, it is desirable for the icon's color
 to strongly constrast with that of the application's background. You can
@@ -216,7 +216,7 @@ acheive this using one of the ``jp-iconX`` classes.
    </svg>
 
 Adding classes to a multi-colored icon
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 For more complex icons, each element that needs to match the background
 should be annotated with a ``jp-icon-accentX`` class, while each element
@@ -249,7 +249,7 @@ Background
 ----------
 
 Icon handling in Jupyterlab
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Pre JupyterLab 2.0, most icons were created using the icons-as-css-background
 pattern:
@@ -309,7 +309,7 @@ What you end up with is a DOM node (by default a ‘div’) that has an
 inline svg node as a child.
 
 ``background-image`` vs inline svg
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The big limitation of the old icon-as-css-background pattern is that svg
 images rendered as ``background-image`` are invisible to CSS. On the

packages/ui-components/docs/source/ui_components.rst

@@ -1,7 +1,8 @@
 .. _ui_components:
 
+#####################
 Reusing JupyterLab UI
-=====================
+#####################
 
 .. include:: intro.rst