@jupyter-notebook/application-extension 7.0.0-alpha.1

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * Export the plugins as default.
+ */
+declare const plugins: JupyterFrontEndPlugin<any>[];
+export default plugins;

package/lib/index.js

@@ -0,0 +1,604 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+import { ILabStatus, IRouter, ITreePathUpdater, JupyterFrontEnd, Router } from '@jupyterlab/application';
+import { sessionContextDialogs, ISessionContextDialogs, DOMUtils, ICommandPalette } from '@jupyterlab/apputils';
+import { ConsolePanel } from '@jupyterlab/console';
+import { PageConfig, PathExt, URLExt } from '@jupyterlab/coreutils';
+import { IDocumentManager, renameDialog } from '@jupyterlab/docmanager';
+import { DocumentWidget } from '@jupyterlab/docregistry';
+import { IMainMenu } from '@jupyterlab/mainmenu';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITranslator } from '@jupyterlab/translation';
+import { NotebookApp, NotebookShell, INotebookShell } from '@jupyter-notebook/application';
+import { jupyterIcon } from '@jupyter-notebook/ui-components';
+import { PromiseDelegate } from '@lumino/coreutils';
+import { DisposableDelegate, DisposableSet } from '@lumino/disposable';
+import { Widget } from '@lumino/widgets';
+/**
+ * The default notebook factory.
+ */
+const NOTEBOOK_FACTORY = 'Notebook';
+/**
+ * The editor factory.
+ */
+const EDITOR_FACTORY = 'Editor';
+/**
+ * A regular expression to match path to notebooks and documents
+ */
+const TREE_PATTERN = new RegExp('/(notebooks|edit)/(.*)');
+/**
+ * A regular expression to suppress the file extension from display for .ipynb files.
+ */
+const STRIP_IPYNB = /\.ipynb$/;
+/**
+ * The command IDs used by the application plugin.
+ */
+var CommandIDs;
+(function (CommandIDs) {
+    /**
+     * Toggle Top Bar visibility
+     */
+    CommandIDs.toggleTop = 'application:toggle-top';
+    /**
+     * Toggle the Zen mode
+     */
+    CommandIDs.toggleZen = 'application:toggle-zen';
+    /**
+     * Open JupyterLab
+     */
+    CommandIDs.openLab = 'application:open-lab';
+    /**
+     * Open the tree page.
+     */
+    CommandIDs.openTree = 'application:open-tree';
+    /**
+     * Rename the current document
+     */
+    CommandIDs.rename = 'application:rename';
+    /**
+     * Resolve tree path
+     */
+    CommandIDs.resolveTree = 'application:resolve-tree';
+})(CommandIDs || (CommandIDs = {}));
+/**
+ * Check if the application is dirty before closing the browser tab.
+ */
+const dirty = {
+    id: '@jupyter-notebook/application-extension:dirty',
+    autoStart: true,
+    requires: [ILabStatus, ITranslator],
+    activate: (app, status, translator) => {
+        if (!(app instanceof NotebookApp)) {
+            throw new Error(`${dirty.id} must be activated in Jupyter Notebook.`);
+        }
+        const trans = translator.load('notebook');
+        const message = trans.__('Are you sure you want to exit Jupyter Notebook?\n\nAny unsaved changes will be lost.');
+        window.addEventListener('beforeunload', event => {
+            if (app.status.isDirty) {
+                return (event.returnValue = message);
+            }
+        });
+    }
+};
+/**
+ * The logo plugin.
+ */
+const logo = {
+    id: '@jupyter-notebook/application-extension:logo',
+    autoStart: true,
+    activate: (app) => {
+        const baseUrl = PageConfig.getBaseUrl();
+        const node = document.createElement('a');
+        node.href = `${baseUrl}tree`;
+        node.target = '_blank';
+        node.rel = 'noopener noreferrer';
+        const logo = new Widget({ node });
+        jupyterIcon.element({
+            container: node,
+            elementPosition: 'center',
+            padding: '2px 2px 2px 8px',
+            height: '28px',
+            width: 'auto'
+        });
+        logo.id = 'jp-NotebookLogo';
+        app.shell.add(logo, 'top', { rank: 0 });
+    }
+};
+/**
+ * A plugin to open documents in the main area.
+ */
+const opener = {
+    id: '@jupyter-notebook/application-extension:opener',
+    autoStart: true,
+    requires: [IRouter, IDocumentManager],
+    activate: (app, router, docManager) => {
+        const { commands } = app;
+        const command = 'router:tree';
+        commands.addCommand(command, {
+            execute: (args) => {
+                var _a;
+                const parsed = args;
+                const matches = (_a = parsed.path.match(TREE_PATTERN)) !== null && _a !== void 0 ? _a : [];
+                const [, , path] = matches;
+                if (!path) {
+                    return;
+                }
+                const file = decodeURIComponent(path);
+                const ext = PathExt.extname(file);
+                app.restored.then(async () => {
+                    // TODO: get factory from file type instead?
+                    if (ext === '.ipynb') {
+                        docManager.open(file, NOTEBOOK_FACTORY, undefined, {
+                            ref: '_noref'
+                        });
+                    }
+                    else {
+                        docManager.open(file, EDITOR_FACTORY, undefined, {
+                            ref: '_noref'
+                        });
+                    }
+                });
+            }
+        });
+        router.register({ command, pattern: TREE_PATTERN });
+    }
+};
+/**
+ * A plugin to customize menus
+ *
+ * TODO: use this plugin to customize the menu items and their order
+ */
+const menus = {
+    id: '@jupyter-notebook/application-extension:menus',
+    requires: [IMainMenu],
+    autoStart: true,
+    activate: (app, menu) => {
+        // always disable the Tabs menu
+        menu.tabsMenu.dispose();
+        const page = PageConfig.getOption('notebookPage');
+        switch (page) {
+            case 'consoles':
+            case 'terminals':
+            case 'tree':
+                menu.editMenu.dispose();
+                menu.kernelMenu.dispose();
+                menu.runMenu.dispose();
+                break;
+            case 'edit':
+                menu.kernelMenu.dispose();
+                menu.runMenu.dispose();
+                break;
+            default:
+                break;
+        }
+    }
+};
+/**
+ * Add commands to open the tree and running pages.
+ */
+const pages = {
+    id: '@jupyter-notebook/application-extension:pages',
+    autoStart: true,
+    requires: [ITranslator],
+    optional: [ICommandPalette, IMainMenu],
+    activate: (app, translator, palette, menu) => {
+        const trans = translator.load('notebook');
+        const baseUrl = PageConfig.getBaseUrl();
+        app.commands.addCommand(CommandIDs.openLab, {
+            label: trans.__('Open JupyterLab'),
+            execute: () => {
+                window.open(`${baseUrl}lab`);
+            }
+        });
+        app.commands.addCommand(CommandIDs.openTree, {
+            label: trans.__('Open Files'),
+            execute: () => {
+                window.open(`${baseUrl}tree`);
+            }
+        });
+        if (palette) {
+            [CommandIDs.openLab, CommandIDs.openTree].forEach(command => {
+                palette.addItem({ command, category: 'View' });
+            });
+        }
+        if (menu) {
+            menu.viewMenu.addGroup([{ command: CommandIDs.openLab }, { command: CommandIDs.openTree }], 0);
+        }
+    }
+};
+/**
+ * The default paths for a Jupyter Notebook app.
+ */
+const paths = {
+    id: '@jupyter-notebook/application-extension:paths',
+    autoStart: true,
+    provides: JupyterFrontEnd.IPaths,
+    activate: (app) => {
+        if (!(app instanceof NotebookApp)) {
+            throw new Error(`${paths.id} must be activated in Jupyter Notebook.`);
+        }
+        return app.paths;
+    }
+};
+/**
+ * The default URL router provider.
+ */
+const router = {
+    id: '@jupyter-notebook/application-extension:router',
+    autoStart: true,
+    provides: IRouter,
+    requires: [JupyterFrontEnd.IPaths],
+    activate: (app, paths) => {
+        const { commands } = app;
+        const base = paths.urls.base;
+        const router = new Router({ base, commands });
+        void app.started.then(() => {
+            // Route the very first request on load.
+            void router.route();
+            // Route all pop state events.
+            window.addEventListener('popstate', () => {
+                void router.route();
+            });
+        });
+        return router;
+    }
+};
+/**
+ * The default session dialogs plugin
+ */
+const sessionDialogs = {
+    id: '@jupyter-notebook/application-extension:session-dialogs',
+    provides: ISessionContextDialogs,
+    autoStart: true,
+    activate: () => sessionContextDialogs
+};
+/**
+ * The default Jupyter Notebook application shell.
+ */
+const shell = {
+    id: '@jupyter-notebook/application-extension:shell',
+    activate: (app) => {
+        if (!(app.shell instanceof NotebookShell)) {
+            throw new Error(`${shell.id} did not find a NotebookShell instance.`);
+        }
+        return app.shell;
+    },
+    autoStart: true,
+    provides: INotebookShell
+};
+/**
+ * A plugin to provide a spacer at rank 900 for flex panels
+ * TODO: reuse upstream @jupyterlab/application-extension:top-spacer plugin when fixed
+ * in https://github.com/jupyterlab/jupyterlab/pull/11900
+ */
+const spacer = {
+    id: '@jupyter-notebook/application-extension:spacer',
+    autoStart: true,
+    activate: (app) => {
+        const top = new Widget();
+        top.id = DOMUtils.createDomID();
+        top.addClass('jp-NotebookSpacer');
+        app.shell.add(top, 'top', { rank: 900 });
+        const menu = new Widget();
+        menu.id = DOMUtils.createDomID();
+        menu.addClass('jp-NotebookSpacer');
+        app.shell.add(menu, 'menu', { rank: 900 });
+    }
+};
+/**
+ * The default JupyterLab application status provider.
+ */
+const status = {
+    id: '@jupyter-notebook/application-extension:status',
+    autoStart: true,
+    provides: ILabStatus,
+    activate: (app) => {
+        if (!(app instanceof NotebookApp)) {
+            throw new Error(`${status.id} must be activated in Jupyter Notebook.`);
+        }
+        return app.status;
+    }
+};
+/**
+ * A plugin to display the document title in the browser tab title
+ */
+const tabTitle = {
+    id: '@jupyter-notebook/application-extension:tab-title',
+    autoStart: true,
+    requires: [INotebookShell],
+    activate: (app, shell) => {
+        const setTabTitle = () => {
+            const current = shell.currentWidget;
+            if (current instanceof ConsolePanel) {
+                const update = () => {
+                    const title = current.sessionContext.path || current.sessionContext.name;
+                    const basename = PathExt.basename(title);
+                    // Strip the ".ipynb" suffix from filenames for display in tab titles.
+                    document.title = basename.replace(STRIP_IPYNB, '');
+                };
+                current.sessionContext.sessionChanged.connect(update);
+                update();
+                return;
+            }
+            else if (current instanceof DocumentWidget) {
+                const update = () => {
+                    const basename = PathExt.basename(current.context.path);
+                    document.title = basename.replace(STRIP_IPYNB, '');
+                };
+                current.context.pathChanged.connect(update);
+                update();
+            }
+        };
+        shell.currentChanged.connect(setTabTitle);
+        setTabTitle();
+    }
+};
+/**
+ * A plugin to display and rename the title of a file
+ */
+const title = {
+    id: '@jupyter-notebook/application-extension:title',
+    autoStart: true,
+    requires: [INotebookShell, ITranslator],
+    optional: [IDocumentManager, IRouter],
+    activate: (app, shell, translator, docManager, router) => {
+        const { commands } = app;
+        const trans = translator.load('notebook');
+        const widget = new Widget();
+        widget.id = 'jp-title';
+        app.shell.add(widget, 'top', { rank: 10 });
+        const addTitle = async () => {
+            const current = shell.currentWidget;
+            if (!current || !(current instanceof DocumentWidget)) {
+                return;
+            }
+            if (widget.node.children.length > 0) {
+                return;
+            }
+            const h = document.createElement('h1');
+            h.textContent = current.title.label.replace(STRIP_IPYNB, '');
+            widget.node.appendChild(h);
+            widget.node.style.marginLeft = '10px';
+            if (!docManager) {
+                return;
+            }
+            const isEnabled = () => {
+                const { currentWidget } = shell;
+                return !!(currentWidget && docManager.contextForWidget(currentWidget));
+            };
+            commands.addCommand(CommandIDs.rename, {
+                label: () => trans.__('Rename…'),
+                isEnabled,
+                execute: async () => {
+                    var _a, _b;
+                    if (!isEnabled()) {
+                        return;
+                    }
+                    const result = await renameDialog(docManager, current.context.path);
+                    // activate the current widget to bring the focus
+                    if (current) {
+                        current.activate();
+                    }
+                    if (result === null) {
+                        return;
+                    }
+                    const newPath = (_a = current.context.path) !== null && _a !== void 0 ? _a : result.path;
+                    const basename = PathExt.basename(newPath);
+                    h.textContent = basename.replace(STRIP_IPYNB, '');
+                    if (!router) {
+                        return;
+                    }
+                    const matches = (_b = router.current.path.match(TREE_PATTERN)) !== null && _b !== void 0 ? _b : [];
+                    const [, route, path] = matches;
+                    if (!route || !path) {
+                        return;
+                    }
+                    const encoded = encodeURIComponent(newPath);
+                    router.navigate(`/${route}/${encoded}`, {
+                        skipRouting: true
+                    });
+                }
+            });
+            widget.node.onclick = async () => {
+                void commands.execute(CommandIDs.rename);
+            };
+        };
+        shell.currentChanged.connect(addTitle);
+        void addTitle();
+    }
+};
+/**
+ * Plugin to toggle the top header visibility.
+ */
+const topVisibility = {
+    id: '@jupyter-notebook/application-extension:top',
+    requires: [INotebookShell, ITranslator],
+    optional: [IMainMenu, ISettingRegistry],
+    activate: (app, notebookShell, translator, menu, settingRegistry) => {
+        const trans = translator.load('notebook');
+        const top = notebookShell.top;
+        const pluginId = topVisibility.id;
+        app.commands.addCommand(CommandIDs.toggleTop, {
+            label: trans.__('Show Header'),
+            execute: () => {
+                top.setHidden(top.isVisible);
+                if (settingRegistry) {
+                    void settingRegistry.set(pluginId, 'visible', top.isVisible);
+                }
+            },
+            isToggled: () => top.isVisible
+        });
+        if (menu) {
+            menu.viewMenu.addGroup([{ command: CommandIDs.toggleTop }], 2);
+        }
+        let settingsOverride = false;
+        if (settingRegistry) {
+            const loadSettings = settingRegistry.load(pluginId);
+            const updateSettings = (settings) => {
+                const visible = settings.get('visible').composite;
+                if (settings.user.visible !== undefined) {
+                    settingsOverride = true;
+                    top.setHidden(!visible);
+                }
+            };
+            Promise.all([loadSettings, app.restored])
+                .then(([settings]) => {
+                updateSettings(settings);
+                settings.changed.connect(settings => {
+                    updateSettings(settings);
+                });
+            })
+                .catch((reason) => {
+                console.error(reason.message);
+            });
+        }
+        const onChanged = () => {
+            if (settingsOverride) {
+                return;
+            }
+            if (app.format === 'desktop') {
+                notebookShell.expandTop();
+            }
+            else {
+                notebookShell.collapseTop();
+            }
+        };
+        // listen on format change (mobile and desktop) to make the view more compact
+        app.formatChanged.connect(onChanged);
+    },
+    autoStart: true
+};
+/**
+ * The default tree route resolver plugin.
+ */
+const tree = {
+    id: '@jupyter-notebook/application-extension:tree-resolver',
+    autoStart: true,
+    requires: [IRouter],
+    provides: JupyterFrontEnd.ITreeResolver,
+    activate: (app, router) => {
+        const { commands } = app;
+        const set = new DisposableSet();
+        const delegate = new PromiseDelegate();
+        const treePattern = new RegExp('/(/tree/.*)?');
+        set.add(commands.addCommand(CommandIDs.resolveTree, {
+            execute: (async (args) => {
+                var _a;
+                if (set.isDisposed) {
+                    return;
+                }
+                const query = URLExt.queryStringToObject((_a = args.search) !== null && _a !== void 0 ? _a : '');
+                const browser = query['file-browser-path'] || '';
+                // Remove the file browser path from the query string.
+                delete query['file-browser-path'];
+                // Clean up artifacts immediately upon routing.
+                set.dispose();
+                delegate.resolve({ browser, file: PageConfig.getOption('treePath') });
+            })
+        }));
+        set.add(router.register({ command: CommandIDs.resolveTree, pattern: treePattern }));
+        // If a route is handled by the router without the tree command being
+        // invoked, resolve to `null` and clean up artifacts.
+        const listener = () => {
+            if (set.isDisposed) {
+                return;
+            }
+            set.dispose();
+            delegate.resolve(null);
+        };
+        router.routed.connect(listener);
+        set.add(new DisposableDelegate(() => {
+            router.routed.disconnect(listener);
+        }));
+        return { paths: delegate.promise };
+    }
+};
+const treePathUpdater = {
+    id: '@jupyter-notebook/application-extension:tree-updater',
+    requires: [IRouter],
+    provides: ITreePathUpdater,
+    activate: (app, router) => {
+        function updateTreePath(treePath) {
+            if (treePath !== PageConfig.getOption('treePath')) {
+                const path = URLExt.join(PageConfig.getOption('baseUrl') || '/', 'tree', URLExt.encodeParts(treePath));
+                router.navigate(path, { skipRouting: true });
+                // Persist the new tree path to PageConfig as it is used elsewhere at runtime.
+                PageConfig.setOption('treePath', treePath);
+            }
+        }
+        return updateTreePath;
+    },
+    autoStart: true
+};
+/**
+ * Zen mode plugin
+ */
+const zen = {
+    id: '@jupyter-notebook/application-extension:zen',
+    autoStart: true,
+    requires: [ITranslator],
+    optional: [ICommandPalette, INotebookShell, IMainMenu],
+    activate: (app, translator, palette, notebookShell, menu) => {
+        const { commands } = app;
+        const elem = document.documentElement;
+        const trans = translator.load('notebook');
+        const toggleOn = () => {
+            notebookShell === null || notebookShell === void 0 ? void 0 : notebookShell.collapseTop();
+            notebookShell === null || notebookShell === void 0 ? void 0 : notebookShell.menu.setHidden(true);
+            zenModeEnabled = true;
+        };
+        const toggleOff = () => {
+            notebookShell === null || notebookShell === void 0 ? void 0 : notebookShell.expandTop();
+            notebookShell === null || notebookShell === void 0 ? void 0 : notebookShell.menu.setHidden(false);
+            zenModeEnabled = false;
+        };
+        let zenModeEnabled = false;
+        commands.addCommand(CommandIDs.toggleZen, {
+            label: trans.__('Toggle Zen Mode'),
+            execute: () => {
+                if (!zenModeEnabled) {
+                    elem.requestFullscreen();
+                    toggleOn();
+                }
+                else {
+                    document.exitFullscreen();
+                    toggleOff();
+                }
+            }
+        });
+        document.addEventListener('fullscreenchange', () => {
+            if (!document.fullscreenElement) {
+                toggleOff();
+            }
+        });
+        if (palette) {
+            palette.addItem({ command: CommandIDs.toggleZen, category: 'Mode' });
+        }
+        if (menu) {
+            menu.viewMenu.addGroup([{ command: CommandIDs.toggleZen }], 3);
+        }
+    }
+};
+/**
+ * Export the plugins as default.
+ */
+const plugins = [
+    dirty,
+    logo,
+    menus,
+    opener,
+    pages,
+    paths,
+    router,
+    sessionDialogs,
+    shell,
+    spacer,
+    status,
+    tabTitle,
+    title,
+    topVisibility,
+    tree,
+    treePathUpdater,
+    zen
+];
+export default plugins;

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@jupyter-notebook/application-extension",
+  "version": "7.0.0-alpha.1",
+  "description": "Jupyter Notebook - Application Extension",
+  "homepage": "https://github.com/jupyter/notebook",
+  "bugs": {
+    "url": "https://github.com/jupyter/notebook/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jupyter/notebook.git"
+  },
+  "license": "BSD-3-Clause",
+  "author": "Project Jupyter",
+  "sideEffects": [
+    "style/**/*.css",
+    "style/index.js"
+  ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "style": "style/index.css",
+  "directories": {
+    "lib": "lib/"
+  },
+  "files": [
+    "lib/*.d.ts",
+    "lib/*.js.map",
+    "lib/*.js",
+    "schema/*.json",
+    "style/**/*.css",
+    "style/index.js"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "build:prod": "tsc -b",
+    "clean": "rimraf lib && rimraf tsconfig.tsbuildinfo",
+    "docs": "typedoc src",
+    "prepublishOnly": "npm run build",
+    "watch": "tsc -b --watch"
+  },
+  "dependencies": {
+    "@jupyter-notebook/application": "^7.0.0-alpha.1",
+    "@jupyter-notebook/ui-components": "^7.0.0-alpha.1",
+    "@jupyterlab/application": "^4.0.0-alpha.5",
+    "@jupyterlab/apputils": "^4.0.0-alpha.5",
+    "@jupyterlab/celltags": "^4.0.0-alpha.5",
+    "@jupyterlab/codeeditor": "^4.0.0-alpha.5",
+    "@jupyterlab/codemirror": "^4.0.0-alpha.5",
+    "@jupyterlab/console": "^4.0.0-alpha.5",
+    "@jupyterlab/coreutils": "^6.0.0-alpha.5",
+    "@jupyterlab/docmanager": "^4.0.0-alpha.5",
+    "@jupyterlab/docregistry": "^4.0.0-alpha.5",
+    "@jupyterlab/mainmenu": "^4.0.0-alpha.5",
+    "@jupyterlab/settingregistry": "^4.0.0-alpha.5",
+    "@jupyterlab/translation": "^4.0.0-alpha.4",
+    "@lumino/coreutils": "^1.12.0",
+    "@lumino/disposable": "^1.10.1",
+    "@lumino/widgets": "^1.31.1"
+  },
+  "devDependencies": {
+    "rimraf": "~3.0.0",
+    "typescript": "~4.1.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "jupyterlab": {
+    "extension": true,
+    "schemaDir": "schema"
+  },
+  "styleModule": "style/index.js"
+}

package/schema/menus.json

@@ -0,0 +1,24 @@
+{
+  "title": "Jupyter Notebook Menu Entries",
+  "description": "Jupyter Notebook Menu Entries",
+  "jupyter.lab.menus": {
+    "main": [
+      {
+        "id": "jp-mainmenu-file",
+        "items": [
+          {
+            "command": "application:rename",
+            "rank": 4
+          },
+          {
+            "command": "notebook:trust",
+            "rank": 20
+          }
+        ]
+      }
+    ]
+  },
+  "properties": {},
+  "additionalProperties": false,
+  "type": "object"
+}

package/schema/top.json

@@ -0,0 +1,16 @@
+{
+  "jupyter.lab.setting-icon": "notebook-ui-components:jupyter",
+  "jupyter.lab.setting-icon-label": "Jupyter Notebook Top Area",
+  "title": "Jupyter Notebook Top Area",
+  "description": "Jupyter Notebook Top Area settings",
+  "properties": {
+    "visible": {
+      "type": "boolean",
+      "title": "Top Bar Visibility",
+      "description": "Whether to show the top bar or not",
+      "default": true
+    }
+  },
+  "additionalProperties": false,
+  "type": "object"
+}

package/style/base.css

@@ -0,0 +1,14 @@
+/*-----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+|
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+
+.jp-NotebookSpacer {
+  flex-grow: 1;
+  flex-shrink: 1;
+}
+
+.jp-MainAreaWidget {
+  height: 100%;
+}

package/style/index.css

@@ -0,0 +1,4 @@
+@import url('~@jupyter-notebook/application/style/index.css');
+@import url('~@lumino/widgets/style/index.css');
+
+@import url('./base.css');

package/style/index.js

@@ -0,0 +1,4 @@
+import '@jupyter-notebook/application/style/index.js';
+import '@lumino/widgets/style/index.js';
+
+import './base.css';