jupyterlab_edit_markdown_at_content_extension 0.4.3

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Stellars Henson
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,33 @@
+# jupyterlab_edit_markdown_at_content_extension
+
+[![GitHub Actions](https://github.com/stellarshenson/jupyterlab_edit_markdown_at_content_extension/actions/workflows/build.yml/badge.svg)](https://github.com/stellarshenson/jupyterlab_edit_markdown_at_content_extension/actions/workflows/build.yml)
+[![npm version](https://img.shields.io/npm/v/jupyterlab_edit_markdown_at_content_extension.svg)](https://www.npmjs.com/package/jupyterlab_edit_markdown_at_content_extension)
+[![PyPI version](https://img.shields.io/pypi/v/jupyterlab-edit-markdown-at-content-extension.svg)](https://pypi.org/project/jupyterlab-edit-markdown-at-content-extension/)
+[![Total PyPI downloads](https://static.pepy.tech/badge/jupyterlab-edit-markdown-at-content-extension)](https://pepy.tech/project/jupyterlab-edit-markdown-at-content-extension)
+[![JupyterLab 4](https://img.shields.io/badge/JupyterLab-4-orange.svg)](https://jupyterlab.readthedocs.io/en/stable/)
+[![Brought To You By KOLOMOLO](https://img.shields.io/badge/Brought%20To%20You%20By-KOLOMOLO-00ffff?style=flat)](https://kolomolo.com)
+[![Donate PayPal](https://img.shields.io/badge/Donate-PayPal-blue?style=flat)](https://www.paypal.com/donate/?hosted_button_id=B4KPBJDLLXTSA)
+
+Jump straight from a rendered markdown file into the editor at the exact line you were reading. No more opening the editor and scrolling to find the content again - this extension opens the editor positioned right where the content is.
+
+## Features
+
+- **Edit at content location** - open the editor scrolled to the line matching the rendered content you are viewing
+- **No-scroll workflow** - skips the manual hunt for the right line after switching from preview to editor
+- **Server-side support** - a Python `jupyter_server` extension backs the frontend with the routes it needs
+
+## Requirements
+
+- JupyterLab >= 4.0.0
+
+## Install
+
+```bash
+pip install jupyterlab_edit_markdown_at_content_extension
+```
+
+## Uninstall
+
+```bash
+pip uninstall jupyterlab_edit_markdown_at_content_extension
+```

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * Initialization data for the jupyterlab_edit_markdown_at_content_extension extension.
+ */
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/index.js

@@ -0,0 +1,178 @@
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { IEditorTracker } from '@jupyterlab/fileeditor';
+import { IMarkdownViewerTracker } from '@jupyterlab/markdownviewer';
+import { buildBlockMap, blockToLine, lineToBlock, headingSlug } from './mapping';
+const PLUGIN_ID = 'jupyterlab_edit_markdown_at_content_extension:plugin';
+const CMD_EDIT_AT = 'editmarkdownatcontent:edit-at-location';
+const CMD_REVEAL_IN = 'editmarkdownatcontent:reveal-in-preview';
+const PREVIEW_SELECTOR = '.jp-MarkdownViewer .jp-RenderedMarkdown';
+const EDITOR_SELECTOR = '.jp-FileEditor';
+const EDITOR_FACTORY = 'Editor';
+const PREVIEW_FACTORY = 'Markdown Preview';
+const LOG = '[edit-markdown-at-content]';
+/**
+ * Initialization data for the jupyterlab_edit_markdown_at_content_extension extension.
+ */
+const plugin = {
+    id: PLUGIN_ID,
+    description: 'Jupyterlab extension to save you the scrolling time from when you are at markdown file location and open editor and need to scroll to the exact place in the file where the content is. This extension opens the editor at the place where the content is',
+    autoStart: true,
+    requires: [IDocumentManager, IEditorTracker, IMarkdownViewerTracker],
+    activate: (app, docManager, editorTracker, markdownTracker) => {
+        console.log('JupyterLab extension jupyterlab_edit_markdown_at_content_extension is activated!');
+        // Lumino commands receive no DOM target, so a single capture-phase
+        // listener stashes the right-clicked node for both directions.
+        let lastPreviewTarget = null;
+        let lastEditorTarget = null;
+        document.addEventListener('contextmenu', (event) => {
+            var _a, _b;
+            const target = event.target;
+            lastPreviewTarget = ((_a = target === null || target === void 0 ? void 0 : target.closest) === null || _a === void 0 ? void 0 : _a.call(target, PREVIEW_SELECTOR)) ? target : null;
+            lastEditorTarget = ((_b = target === null || target === void 0 ? void 0 : target.closest) === null || _b === void 0 ? void 0 : _b.call(target, EDITOR_SELECTOR)) ? target : null;
+        }, true);
+        /** The MarkdownDocument widget whose rendered host contains `target`. */
+        const findPreviewWidget = (target) => {
+            let found = null;
+            markdownTracker.forEach(widget => {
+                if (!found && widget.node.contains(target)) {
+                    found = widget;
+                }
+            });
+            return found;
+        };
+        /** The FileEditor document widget whose node contains `target`. */
+        const findEditorWidget = (target) => {
+            let found = null;
+            editorTracker.forEach(widget => {
+                if (!found && widget.node.contains(target)) {
+                    found = widget;
+                }
+            });
+            return found !== null && found !== void 0 ? found : editorTracker.currentWidget;
+        };
+        /** The `.jp-RenderedMarkdown` host element inside a preview/editor widget. */
+        const renderedHost = (widget) => { var _a, _b; return (_b = (_a = widget === null || widget === void 0 ? void 0 : widget.node) === null || _a === void 0 ? void 0 : _a.querySelector('.jp-RenderedMarkdown')) !== null && _b !== void 0 ? _b : null; };
+        // ---- Preview -> Editor -------------------------------------------------
+        app.commands.addCommand(CMD_EDIT_AT, {
+            label: 'Edit at this location',
+            execute: async () => {
+                const target = lastPreviewTarget;
+                if (!target) {
+                    console.warn(`${LOG} no markdown preview target under the cursor`);
+                    return;
+                }
+                const widget = findPreviewWidget(target);
+                if (!widget) {
+                    console.warn(`${LOG} could not resolve the owning Markdown Preview`);
+                    return;
+                }
+                const host = renderedHost(widget);
+                if (!host) {
+                    console.warn(`${LOG} rendered host not found`);
+                    return;
+                }
+                // Walk up to the top-level block (direct child of the host).
+                let block = target;
+                while (block && block.parentElement !== host) {
+                    block = block.parentElement;
+                }
+                if (!block) {
+                    console.warn(`${LOG} clicked content is not a rendered block`);
+                    return;
+                }
+                const ordinal = Array.from(host.children).indexOf(block);
+                const source = widget.context.model.toString();
+                const line = blockToLine(source, ordinal);
+                if (line < 0) {
+                    console.warn(`${LOG} block ordinal ${ordinal} is not mappable`);
+                    return;
+                }
+                const editorWidget = docManager.openOrReveal(widget.context.path, EDITOR_FACTORY);
+                if (!editorWidget) {
+                    return;
+                }
+                await editorWidget.context.ready;
+                await editorWidget.revealed;
+                const editor = editorWidget.content.editor;
+                const clamped = Math.min(line, editor.lineCount - 1);
+                editor.setCursorPosition({ line: clamped, column: 0 });
+                // Focus so the cursor is live (you asked to edit here) and the active
+                // line is rendered, then scroll it into view.
+                editor.focus();
+                editor.revealPosition({ line: clamped, column: 0 });
+            }
+        });
+        app.contextMenu.addItem({
+            command: CMD_EDIT_AT,
+            selector: PREVIEW_SELECTOR,
+            rank: 0
+        });
+        // ---- Editor -> Preview -------------------------------------------------
+        app.commands.addCommand(CMD_REVEAL_IN, {
+            label: 'Reveal in Markdown Preview',
+            execute: async () => {
+                var _a;
+                const target = lastEditorTarget;
+                if (!target) {
+                    console.warn(`${LOG} no editor target under the cursor`);
+                    return;
+                }
+                const widget = findEditorWidget(target);
+                if (!widget) {
+                    console.warn(`${LOG} could not resolve the owning file editor`);
+                    return;
+                }
+                const editor = widget.content.editor;
+                const line = editor.getCursorPosition().line;
+                const source = widget.context.model.toString();
+                const { ordinal, headingSlug: slug, headingNth } = lineToBlock(source, line);
+                const previewWidget = docManager.openOrReveal(widget.context.path, PREVIEW_FACTORY);
+                if (!previewWidget) {
+                    return;
+                }
+                await previewWidget.context.ready;
+                await previewWidget.revealed;
+                const host = renderedHost(previewWidget);
+                if (!host) {
+                    console.warn(`${LOG} rendered preview host not found`);
+                    return;
+                }
+                const children = Array.from(host.children);
+                const expected = buildBlockMap(source).blocks.length;
+                if (children.length === expected && ordinal >= 0) {
+                    children[ordinal].scrollIntoView({ block: 'start' });
+                    return;
+                }
+                // Fallback (AC #8): ordinal alignment is unreliable (math, sanitizer,
+                // injected nodes). Re-derive heading ids from the live headings and
+                // scroll to the headingNth-th match.
+                if (slug) {
+                    const headings = Array.from(host.querySelectorAll('h1, h2, h3, h4, h5, h6'));
+                    let seen = 0;
+                    for (const h of headings) {
+                        // rendermime stores createHeaderId in `id` (trusted) or
+                        // `data-jupyter-id` (untrusted); the live textContent also contains
+                        // the appended '¶' anchor, so prefer the stored attribute.
+                        const id = h.id ||
+                            h.getAttribute('data-jupyter-id') ||
+                            headingSlug((_a = h.textContent) !== null && _a !== void 0 ? _a : '');
+                        if (id === slug) {
+                            seen += 1;
+                            if (seen === (headingNth !== null && headingNth !== void 0 ? headingNth : 1)) {
+                                h.scrollIntoView({ block: 'start' });
+                                return;
+                            }
+                        }
+                    }
+                }
+                console.warn(`${LOG} could not align preview to line ${line}`);
+            }
+        });
+        app.contextMenu.addItem({
+            command: CMD_REVEAL_IN,
+            selector: EDITOR_SELECTOR,
+            rank: 0
+        });
+    }
+};
+export default plugin;

package/lib/mapping.d.ts

@@ -0,0 +1,53 @@
+/** One rendered top-level block, ordinal-aligned to the rendered host's children. */
+export interface IBlockDescriptor {
+    /** Index into the DOM-correlated block list == rendered host child index. */
+    ordinal: number;
+    /** 0-based first source line of the block. */
+    startLine: number;
+    /** 0-based last source line of the block (inclusive of trailing blanks). */
+    endLine: number;
+    /** marked token type (heading, paragraph, code, list, table, ...). */
+    type: string;
+    /** Normalized block text, for the empty-block guard. */
+    text: string;
+    /** Present only for heading tokens: createHeaderId form of the heading text. */
+    headingSlug?: string;
+}
+export interface IBlockMap {
+    /** Rendered (non-space/def/comment) tokens, in DOM order. */
+    blocks: IBlockDescriptor[];
+    /** Heading blocks, for the nearest-preceding-heading fallback. */
+    headings: {
+        line: number;
+        slug: string;
+        ordinal: number;
+    }[];
+}
+/** Reproduce rendermime `createHeaderId`: spaces -> hyphens on the plain text. */
+export declare function headingSlug(headingText: string): string;
+/**
+ * Re-lex `source` and build the ordinal<->line map.
+ *
+ * Uses `marked.lexer(source, { gfm: true })` to match core's parser config.
+ * The line walk includes EVERY top-level token (space/def advance the
+ * counter); the DOM-aligned block list excludes space, def and comment-only
+ * html tokens.
+ */
+export declare function buildBlockMap(source: string): IBlockMap;
+/**
+ * Preview -> Editor. Returns the 0-based start line for the block at DOM
+ * ordinal `ordinal`, or -1 when the ordinal is out of range or the block has
+ * no textual content (caller no-ops + warns, AC #5).
+ */
+export declare function blockToLine(source: string, ordinal: number): number;
+/**
+ * Editor -> Preview. Returns the DOM ordinal of the block containing `line`
+ * (the last block whose startLine <= line), plus the nearest-preceding
+ * heading slug and its 1-based occurrence index for the fallback.
+ * `ordinal` is -1 when no block precedes the line.
+ */
+export declare function lineToBlock(source: string, line: number): {
+    ordinal: number;
+    headingSlug?: string;
+    headingNth?: number;
+};

package/lib/mapping.js

@@ -0,0 +1,143 @@
+/**
+ * Pure, DOM-free source<->rendered-block mapping for Markdown.
+ *
+ * The Markdown Preview renders with `marked` and emits no source-line
+ * attributes, so we re-lex the source ourselves and correlate rendered
+ * top-level blocks to source lines by ORDINAL INDEX: the nth rendered
+ * top-level child corresponds to the nth non-space/def/comment block token.
+ *
+ * The line accumulator replicates JupyterLab core's `getHeadingTokens`
+ * walk (`@jupyterlab/markedparser-extension`): `currentLine` is a cumulative
+ * newline count advanced by EVERY top-level token, recorded BEFORE advancing.
+ *
+ * This module imports only `marked` - no `@jupyterlab` / `@lumino` / DOM - so
+ * it is unit-testable offline with Jest.
+ */
+import { marked } from 'marked';
+/** marked token types that are NOT rendered as a top-level DOM child. */
+const NON_DOM_TYPES = new Set(['space', 'def']);
+/** True for an html token that renders nothing (HTML comment only). */
+function isCommentOnlyHtml(token) {
+    var _a;
+    if (token.type !== 'html') {
+        return false;
+    }
+    const raw = ((_a = token.raw) !== null && _a !== void 0 ? _a : '').trim();
+    return /^<!--[\s\S]*-->$/.test(raw);
+}
+/** Reproduce rendermime `createHeaderId`: spaces -> hyphens on the plain text. */
+export function headingSlug(headingText) {
+    return plainText(headingText).replace(/ /g, '-');
+}
+/** Best-effort strip of inline markdown so a heading token's text matches the
+ *  rendered element's textContent (used only for the heading fallback). */
+function plainText(text) {
+    return text
+        .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1') // images -> alt
+        .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1') // links -> label
+        .replace(/[*_~`]/g, '') // emphasis / code markers
+        .trim();
+}
+/** Normalized text used for the empty-block guard. */
+function blockText(token) {
+    var _a, _b;
+    if (token.type === 'hr') {
+        return '';
+    }
+    return ((_b = (_a = token.text) !== null && _a !== void 0 ? _a : token.raw) !== null && _b !== void 0 ? _b : '').trim();
+}
+/**
+ * Re-lex `source` and build the ordinal<->line map.
+ *
+ * Uses `marked.lexer(source, { gfm: true })` to match core's parser config.
+ * The line walk includes EVERY top-level token (space/def advance the
+ * counter); the DOM-aligned block list excludes space, def and comment-only
+ * html tokens.
+ */
+export function buildBlockMap(source) {
+    var _a;
+    const tokens = marked.lexer(source, { gfm: true });
+    const blocks = [];
+    const headings = [];
+    let currentLine = 0;
+    for (const token of tokens) {
+        const startLine = currentLine;
+        const spanned = token.raw.split('\n').length - 1;
+        currentLine += spanned;
+        if (NON_DOM_TYPES.has(token.type) || isCommentOnlyHtml(token)) {
+            continue;
+        }
+        const ordinal = blocks.length;
+        const descriptor = {
+            ordinal,
+            startLine,
+            endLine: startLine + Math.max(spanned - 1, 0),
+            type: token.type,
+            text: blockText(token)
+        };
+        if (token.type === 'heading') {
+            descriptor.headingSlug = headingSlug((_a = token.text) !== null && _a !== void 0 ? _a : '');
+            headings.push({
+                line: startLine,
+                slug: descriptor.headingSlug,
+                ordinal
+            });
+        }
+        blocks.push(descriptor);
+    }
+    return { blocks, headings };
+}
+/**
+ * Preview -> Editor. Returns the 0-based start line for the block at DOM
+ * ordinal `ordinal`, or -1 when the ordinal is out of range or the block has
+ * no textual content (caller no-ops + warns, AC #5).
+ */
+export function blockToLine(source, ordinal) {
+    const { blocks } = buildBlockMap(source);
+    if (ordinal < 0 || ordinal >= blocks.length) {
+        return -1;
+    }
+    const block = blocks[ordinal];
+    if (block.text.length === 0) {
+        return -1;
+    }
+    return block.startLine;
+}
+/**
+ * Editor -> Preview. Returns the DOM ordinal of the block containing `line`
+ * (the last block whose startLine <= line), plus the nearest-preceding
+ * heading slug and its 1-based occurrence index for the fallback.
+ * `ordinal` is -1 when no block precedes the line.
+ */
+export function lineToBlock(source, line) {
+    var _a;
+    const { blocks } = buildBlockMap(source);
+    let ordinal = -1;
+    for (const block of blocks) {
+        if (block.startLine <= line) {
+            ordinal = block.ordinal;
+        }
+        else {
+            break;
+        }
+    }
+    // Nearest preceding heading + its occurrence index among same-slug headings.
+    let headingSlugValue;
+    let headingNth;
+    const slugCounts = new Map();
+    for (const block of blocks) {
+        if (block.type !== 'heading' || block.headingSlug === undefined) {
+            continue;
+        }
+        const nth = ((_a = slugCounts.get(block.headingSlug)) !== null && _a !== void 0 ? _a : 0) + 1;
+        slugCounts.set(block.headingSlug, nth);
+        if (block.startLine <= line) {
+            headingSlugValue = block.headingSlug;
+            headingNth = nth;
+        }
+        else {
+            break;
+        }
+    }
+    return { ordinal, headingSlug: headingSlugValue, headingNth };
+}

package/package.json

@@ -0,0 +1,210 @@
+{
+    "name": "jupyterlab_edit_markdown_at_content_extension",
+    "version": "0.4.3",
+    "description": "Jupyterlab extension to save you the scrolling time from when you are at markdown file location and open editor and need to scroll to the exact place in the file where the content is. This extension opens the editor at the place where the content is",
+    "keywords": [
+        "jupyter",
+        "jupyterlab",
+        "jupyterlab-extension"
+    ],
+    "homepage": "https://github.com/stellarshenson/jupyterlab_edit_markdown_at_content_extension",
+    "bugs": {
+        "url": "https://github.com/stellarshenson/jupyterlab_edit_markdown_at_content_extension/issues"
+    },
+    "license": "BSD-3-Clause",
+    "author": {
+        "name": "Stellars Henson",
+        "email": "konrad.jelen+github@gmail.com"
+    },
+    "files": [
+        "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}",
+        "style/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}",
+        "src/**/*.{ts,tsx}"
+    ],
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "style": "style/index.css",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/stellarshenson/jupyterlab_edit_markdown_at_content_extension.git"
+    },
+    "scripts": {
+        "build": "jlpm build:lib && jlpm build:labextension:dev",
+        "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension",
+        "build:labextension": "jupyter labextension build .",
+        "build:labextension:dev": "jupyter labextension build --development True .",
+        "build:lib": "tsc --sourceMap",
+        "build:lib:prod": "tsc",
+        "clean": "jlpm clean:lib",
+        "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
+        "clean:lintcache": "rimraf .eslintcache .stylelintcache",
+        "clean:labextension": "rimraf jupyterlab_edit_markdown_at_content_extension/labextension jupyterlab_edit_markdown_at_content_extension/_version.py",
+        "clean:all": "jlpm clean:lib && jlpm clean:labextension && jlpm clean:lintcache",
+        "eslint": "jlpm eslint:check --fix",
+        "eslint:check": "eslint . --cache --ext .ts,.tsx",
+        "install:extension": "jlpm build",
+        "lint": "jlpm stylelint && jlpm prettier && jlpm eslint",
+        "lint:check": "jlpm stylelint:check && jlpm prettier:check && jlpm eslint:check",
+        "prettier": "jlpm prettier:base --write --list-different",
+        "prettier:base": "prettier \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
+        "prettier:check": "jlpm prettier:base --check",
+        "stylelint": "jlpm stylelint:check --fix",
+        "stylelint:check": "stylelint --cache \"style/**/*.css\"",
+        "test": "jest --coverage",
+        "watch": "run-p watch:src watch:labextension",
+        "watch:src": "tsc -w --sourceMap",
+        "watch:labextension": "jupyter labextension watch ."
+    },
+    "dependencies": {
+        "@jupyterlab/application": "^4.5.0",
+        "@jupyterlab/codeeditor": "^4.5.0",
+        "@jupyterlab/docmanager": "^4.5.0",
+        "@jupyterlab/docregistry": "^4.5.0",
+        "@jupyterlab/fileeditor": "^4.5.0",
+        "@jupyterlab/markdownviewer": "^4.5.0",
+        "marked": "^17.0.0"
+    },
+    "devDependencies": {
+        "@jupyterlab/builder": "^4.0.0",
+        "@jupyterlab/testutils": "^4.0.0",
+        "@types/jest": "^29.2.0",
+        "@types/json-schema": "^7.0.11",
+        "@types/react": "^18.0.26",
+        "@types/react-addons-linked-state-mixin": "^0.14.22",
+        "@typescript-eslint/eslint-plugin": "^6.1.0",
+        "@typescript-eslint/parser": "^6.1.0",
+        "css-loader": "^6.7.1",
+        "eslint": "^8.36.0",
+        "eslint-config-prettier": "^8.8.0",
+        "eslint-plugin-prettier": "^5.0.0",
+        "jest": "^29.2.0",
+        "mkdirp": "^1.0.3",
+        "npm-run-all2": "^7.0.1",
+        "prettier": "^3.0.0",
+        "rimraf": "^5.0.1",
+        "source-map-loader": "^1.0.2",
+        "style-loader": "^3.3.1",
+        "stylelint": "^15.10.1",
+        "stylelint-config-recommended": "^13.0.0",
+        "stylelint-config-standard": "^34.0.0",
+        "stylelint-csstree-validator": "^3.0.0",
+        "stylelint-prettier": "^4.0.0",
+        "typescript": "~5.8.0",
+        "yjs": "^13.5.0"
+    },
+    "resolutions": {
+        "lib0": "0.2.111",
+        "webpack": "5.106.0",
+        "chalk": "4.1.2"
+    },
+    "overrides": {
+        "webpack": "5.106.0",
+        "chalk": "4.1.2"
+    },
+    "sideEffects": [
+        "style/*.css",
+        "style/index.js"
+    ],
+    "styleModule": "style/index.js",
+    "publishConfig": {
+        "access": "public"
+    },
+    "jupyterlab": {
+        "extension": true,
+        "outputDir": "jupyterlab_edit_markdown_at_content_extension/labextension"
+    },
+    "eslintIgnore": [
+        "node_modules",
+        "dist",
+        "coverage",
+        "**/*.d.ts",
+        "tests",
+        "**/__tests__",
+        "ui-tests"
+    ],
+    "eslintConfig": {
+        "extends": [
+            "eslint:recommended",
+            "plugin:@typescript-eslint/eslint-recommended",
+            "plugin:@typescript-eslint/recommended",
+            "plugin:prettier/recommended"
+        ],
+        "parser": "@typescript-eslint/parser",
+        "parserOptions": {
+            "project": "tsconfig.json",
+            "sourceType": "module"
+        },
+        "plugins": [
+            "@typescript-eslint"
+        ],
+        "rules": {
+            "@typescript-eslint/naming-convention": [
+                "error",
+                {
+                    "selector": "interface",
+                    "format": [
+                        "PascalCase"
+                    ],
+                    "custom": {
+                        "regex": "^I[A-Z]",
+                        "match": true
+                    }
+                }
+            ],
+            "@typescript-eslint/no-unused-vars": [
+                "warn",
+                {
+                    "args": "none"
+                }
+            ],
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-namespace": "off",
+            "@typescript-eslint/no-use-before-define": "off",
+            "@typescript-eslint/quotes": [
+                "error",
+                "single",
+                {
+                    "avoidEscape": true,
+                    "allowTemplateLiterals": false
+                }
+            ],
+            "curly": [
+                "error",
+                "all"
+            ],
+            "eqeqeq": "error",
+            "prefer-arrow-callback": "error"
+        }
+    },
+    "prettier": {
+        "singleQuote": true,
+        "trailingComma": "none",
+        "arrowParens": "avoid",
+        "endOfLine": "auto",
+        "overrides": [
+            {
+                "files": "package.json",
+                "options": {
+                    "tabWidth": 4
+                }
+            }
+        ]
+    },
+    "stylelint": {
+        "extends": [
+            "stylelint-config-recommended",
+            "stylelint-config-standard",
+            "stylelint-prettier/recommended"
+        ],
+        "plugins": [
+            "stylelint-csstree-validator"
+        ],
+        "rules": {
+            "csstree/validator": true,
+            "property-no-vendor-prefix": null,
+            "selector-class-pattern": "^([a-z][A-z\\d]*)(-[A-z\\d]+)*$",
+            "selector-no-vendor-prefix": null,
+            "value-no-vendor-prefix": null
+        }
+    }
+}

package/src/__tests__/index.spec.ts

@@ -0,0 +1,32 @@
+declare const require: (module: string) => any;
+declare const __dirname: string;
+
+const fs = require('fs');
+const path = require('path');
+
+/** index.ts source with comments stripped, for static regression checks. */
+function indexSourceNoComments(): string {
+  const source = fs.readFileSync(
+    path.resolve(__dirname, '..', 'index.ts'),
+    'utf-8'
+  );
+  return source.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+}
+
+describe('index - registry hygiene (AC #10)', () => {
+  it('does not call docRegistry.addFileType (must not override icons)', () => {
+    expect(indexSourceNoComments()).not.toMatch(/addFileType\s*\(/);
+  });
+
+  it('does not depend on IDocumentRegistry', () => {
+    expect(indexSourceNoComments()).not.toMatch(/IDocumentRegistry/);
+  });
+});
+
+describe('index - activation message (AC #9)', () => {
+  it('logs the exact activation message the UI test expects', () => {
+    expect(indexSourceNoComments()).toContain(
+      'JupyterLab extension jupyterlab_edit_markdown_at_content_extension is activated!'
+    );
+  });
+});

package/src/__tests__/mapping.spec.ts

@@ -0,0 +1,122 @@
+import {
+  buildBlockMap,
+  blockToLine,
+  lineToBlock,
+  headingSlug
+} from '../mapping';
+
+/** Return the 0-based source line, for content-based assertions. */
+function lineAt(src: string, n: number): string {
+  return src.split('\n')[n];
+}
+
+describe('mapping - buildBlockMap', () => {
+  it('orders blocks and starts the first block at line 0', () => {
+    const src = '# Title\n\nFirst paragraph.\n';
+    const { blocks } = buildBlockMap(src);
+    expect(blocks[0].ordinal).toBe(0);
+    expect(blocks[0].startLine).toBe(0);
+    expect(blocks.map(b => b.ordinal)).toEqual([0, 1]);
+  });
+});
+
+describe('mapping - cumulative line arithmetic across a fenced code block', () => {
+  const src = [
+    '# Title', // 0
+    '', // 1
+    'First paragraph.', // 2
+    '', // 3
+    '## Section', // 4
+    '', // 5
+    '```js', // 6
+    'const a = 1;', // 7
+    'const b = 2;', // 8
+    '```', // 9
+    '', // 10
+    'After code paragraph.' // 11
+  ].join('\n');
+
+  it('lands each block on its true source line (verifies the accumulator)', () => {
+    const { blocks } = buildBlockMap(src);
+    const byType = (t: string) => blocks.filter(b => b.type === t);
+
+    expect(blocks[0].startLine).toBe(0); // heading
+    expect(lineAt(src, blockToLine(src, 1))).toBe('First paragraph.');
+    // The paragraph AFTER the 4-line code fence must resolve to line 11,
+    // not be off-by-N from naive +1-per-token counting.
+    const lastPara = byType('paragraph').slice(-1)[0];
+    expect(blockToLine(src, lastPara.ordinal)).toBe(11);
+    expect(lineAt(src, 11)).toBe('After code paragraph.');
+  });
+
+  it('round-trips line -> block -> line for the trailing paragraph', () => {
+    const { blocks } = buildBlockMap(src);
+    const lastPara = blocks.filter(b => b.type === 'paragraph').slice(-1)[0];
+    const { ordinal } = lineToBlock(src, 11);
+    expect(ordinal).toBe(lastPara.ordinal);
+  });
+
+  it('maps a line inside the code fence to the code block + preceding heading', () => {
+    const { blocks } = buildBlockMap(src);
+    const code = blocks.find(b => b.type === 'code')!;
+    const res = lineToBlock(src, 8); // 'const b = 2;'
+    expect(res.ordinal).toBe(code.ordinal);
+    expect(res.headingSlug).toBe('Section');
+    expect(res.headingNth).toBe(1);
+  });
+});
+
+describe('mapping - duplicate adjacent paragraphs (position, not content)', () => {
+  const src = 'Repeat me.\n\nRepeat me.\n';
+  it('resolves identical paragraphs to distinct ordinals and lines', () => {
+    const { blocks } = buildBlockMap(src);
+    expect(blocks).toHaveLength(2);
+    expect(blockToLine(src, 0)).toBe(0);
+    expect(blockToLine(src, 1)).toBe(2);
+    expect(lineAt(src, 2)).toBe('Repeat me.');
+  });
+});
+
+describe('mapping - empty/marker-only blocks guard (AC #5)', () => {
+  it('returns -1 for a horizontal rule block', () => {
+    const src = 'Text\n\n---\n\nMore\n';
+    const { blocks } = buildBlockMap(src);
+    const hr = blocks.find(b => b.type === 'hr')!;
+    expect(hr).toBeDefined();
+    expect(blockToLine(src, hr.ordinal)).toBe(-1);
+  });
+
+  it('returns -1 for an out-of-range ordinal', () => {
+    expect(blockToLine('# Only\n', 999)).toBe(-1);
+    expect(blockToLine('# Only\n', -1)).toBe(-1);
+  });
+});
+
+describe('mapping - nested list is a single top-level block', () => {
+  const src = '- a\n  - b\n- c\n';
+  it('treats the whole list as one ordinal', () => {
+    const { blocks } = buildBlockMap(src);
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('list');
+    expect(lineToBlock(src, 1).ordinal).toBe(0);
+    expect(blockToLine(src, 0)).toBe(0);
+  });
+});
+
+describe('mapping - GFM table is a single top-level block', () => {
+  const src = '| H | I |\n|---|---|\n| 1 | 2 |\n';
+  it('treats the table as one ordinal at line 0', () => {
+    const { blocks } = buildBlockMap(src);
+    expect(blocks[0].type).toBe('table');
+    expect(blockToLine(src, 0)).toBe(0);
+  });
+});
+
+describe('mapping - headingSlug', () => {
+  it('replaces spaces with hyphens on plain text', () => {
+    expect(headingSlug('Hello World')).toBe('Hello-World');
+  });
+  it('strips inline markdown before slugging', () => {
+    expect(headingSlug('A **bold** title')).toBe('A-bold-title');
+  });
+});

package/src/index.ts

@@ -0,0 +1,232 @@
+import {
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+
+import { IDocumentManager } from '@jupyterlab/docmanager';
+
+import { IEditorTracker } from '@jupyterlab/fileeditor';
+
+import { IMarkdownViewerTracker } from '@jupyterlab/markdownviewer';
+
+import {
+  buildBlockMap,
+  blockToLine,
+  lineToBlock,
+  headingSlug
+} from './mapping';
+
+const PLUGIN_ID = 'jupyterlab_edit_markdown_at_content_extension:plugin';
+const CMD_EDIT_AT = 'editmarkdownatcontent:edit-at-location';
+const CMD_REVEAL_IN = 'editmarkdownatcontent:reveal-in-preview';
+
+const PREVIEW_SELECTOR = '.jp-MarkdownViewer .jp-RenderedMarkdown';
+const EDITOR_SELECTOR = '.jp-FileEditor';
+const EDITOR_FACTORY = 'Editor';
+const PREVIEW_FACTORY = 'Markdown Preview';
+
+const LOG = '[edit-markdown-at-content]';
+
+/**
+ * Initialization data for the jupyterlab_edit_markdown_at_content_extension extension.
+ */
+const plugin: JupyterFrontEndPlugin<void> = {
+  id: PLUGIN_ID,
+  description:
+    'Jupyterlab extension to save you the scrolling time from when you are at markdown file location and open editor and need to scroll to the exact place in the file where the content is. This extension opens the editor at the place where the content is',
+  autoStart: true,
+  requires: [IDocumentManager, IEditorTracker, IMarkdownViewerTracker],
+  activate: (
+    app: JupyterFrontEnd,
+    docManager: IDocumentManager,
+    editorTracker: IEditorTracker,
+    markdownTracker: IMarkdownViewerTracker
+  ) => {
+    console.log(
+      'JupyterLab extension jupyterlab_edit_markdown_at_content_extension is activated!'
+    );
+
+    // Lumino commands receive no DOM target, so a single capture-phase
+    // listener stashes the right-clicked node for both directions.
+    let lastPreviewTarget: Element | null = null;
+    let lastEditorTarget: Element | null = null;
+
+    document.addEventListener(
+      'contextmenu',
+      (event: MouseEvent) => {
+        const target = event.target as Element | null;
+        lastPreviewTarget = target?.closest?.(PREVIEW_SELECTOR) ? target : null;
+        lastEditorTarget = target?.closest?.(EDITOR_SELECTOR) ? target : null;
+      },
+      true
+    );
+
+    /** The MarkdownDocument widget whose rendered host contains `target`. */
+    const findPreviewWidget = (target: Element): any | null => {
+      let found: any | null = null;
+      markdownTracker.forEach(widget => {
+        if (!found && widget.node.contains(target)) {
+          found = widget;
+        }
+      });
+      return found;
+    };
+
+    /** The FileEditor document widget whose node contains `target`. */
+    const findEditorWidget = (target: Element): any | null => {
+      let found: any | null = null;
+      editorTracker.forEach(widget => {
+        if (!found && widget.node.contains(target)) {
+          found = widget;
+        }
+      });
+      return found ?? editorTracker.currentWidget;
+    };
+
+    /** The `.jp-RenderedMarkdown` host element inside a preview/editor widget. */
+    const renderedHost = (widget: any): HTMLElement | null =>
+      widget?.node?.querySelector('.jp-RenderedMarkdown') ?? null;
+
+    // ---- Preview -> Editor -------------------------------------------------
+    app.commands.addCommand(CMD_EDIT_AT, {
+      label: 'Edit at this location',
+      execute: async () => {
+        const target = lastPreviewTarget;
+        if (!target) {
+          console.warn(`${LOG} no markdown preview target under the cursor`);
+          return;
+        }
+        const widget = findPreviewWidget(target);
+        if (!widget) {
+          console.warn(`${LOG} could not resolve the owning Markdown Preview`);
+          return;
+        }
+        const host = renderedHost(widget);
+        if (!host) {
+          console.warn(`${LOG} rendered host not found`);
+          return;
+        }
+
+        // Walk up to the top-level block (direct child of the host).
+        let block: Element | null = target;
+        while (block && block.parentElement !== host) {
+          block = block.parentElement;
+        }
+        if (!block) {
+          console.warn(`${LOG} clicked content is not a rendered block`);
+          return;
+        }
+        const ordinal = Array.from(host.children).indexOf(block);
+        const source: string = widget.context.model.toString();
+        const line = blockToLine(source, ordinal);
+        if (line < 0) {
+          console.warn(`${LOG} block ordinal ${ordinal} is not mappable`);
+          return;
+        }
+
+        const editorWidget: any = docManager.openOrReveal(
+          widget.context.path,
+          EDITOR_FACTORY
+        );
+        if (!editorWidget) {
+          return;
+        }
+        await editorWidget.context.ready;
+        await editorWidget.revealed;
+        const editor = editorWidget.content.editor;
+        const clamped = Math.min(line, editor.lineCount - 1);
+        editor.setCursorPosition({ line: clamped, column: 0 });
+        // Focus so the cursor is live (you asked to edit here) and the active
+        // line is rendered, then scroll it into view.
+        editor.focus();
+        editor.revealPosition({ line: clamped, column: 0 });
+      }
+    });
+    app.contextMenu.addItem({
+      command: CMD_EDIT_AT,
+      selector: PREVIEW_SELECTOR,
+      rank: 0
+    });
+
+    // ---- Editor -> Preview -------------------------------------------------
+    app.commands.addCommand(CMD_REVEAL_IN, {
+      label: 'Reveal in Markdown Preview',
+      execute: async () => {
+        const target = lastEditorTarget;
+        if (!target) {
+          console.warn(`${LOG} no editor target under the cursor`);
+          return;
+        }
+        const widget = findEditorWidget(target);
+        if (!widget) {
+          console.warn(`${LOG} could not resolve the owning file editor`);
+          return;
+        }
+        const editor = widget.content.editor;
+        const line = editor.getCursorPosition().line;
+        const source: string = widget.context.model.toString();
+        const {
+          ordinal,
+          headingSlug: slug,
+          headingNth
+        } = lineToBlock(source, line);
+
+        const previewWidget: any = docManager.openOrReveal(
+          widget.context.path,
+          PREVIEW_FACTORY
+        );
+        if (!previewWidget) {
+          return;
+        }
+        await previewWidget.context.ready;
+        await previewWidget.revealed;
+        const host = renderedHost(previewWidget);
+        if (!host) {
+          console.warn(`${LOG} rendered preview host not found`);
+          return;
+        }
+
+        const children = Array.from(host.children);
+        const expected = buildBlockMap(source).blocks.length;
+        if (children.length === expected && ordinal >= 0) {
+          children[ordinal].scrollIntoView({ block: 'start' });
+          return;
+        }
+
+        // Fallback (AC #8): ordinal alignment is unreliable (math, sanitizer,
+        // injected nodes). Re-derive heading ids from the live headings and
+        // scroll to the headingNth-th match.
+        if (slug) {
+          const headings = Array.from(
+            host.querySelectorAll('h1, h2, h3, h4, h5, h6')
+          );
+          let seen = 0;
+          for (const h of headings) {
+            // rendermime stores createHeaderId in `id` (trusted) or
+            // `data-jupyter-id` (untrusted); the live textContent also contains
+            // the appended '¶' anchor, so prefer the stored attribute.
+            const id =
+              (h as HTMLElement).id ||
+              h.getAttribute('data-jupyter-id') ||
+              headingSlug(h.textContent ?? '');
+            if (id === slug) {
+              seen += 1;
+              if (seen === (headingNth ?? 1)) {
+                h.scrollIntoView({ block: 'start' });
+                return;
+              }
+            }
+          }
+        }
+        console.warn(`${LOG} could not align preview to line ${line}`);
+      }
+    });
+    app.contextMenu.addItem({
+      command: CMD_REVEAL_IN,
+      selector: EDITOR_SELECTOR,
+      rank: 0
+    });
+  }
+};
+
+export default plugin;

package/src/mapping.ts

@@ -0,0 +1,190 @@
+/**
+ * Pure, DOM-free source<->rendered-block mapping for Markdown.
+ *
+ * The Markdown Preview renders with `marked` and emits no source-line
+ * attributes, so we re-lex the source ourselves and correlate rendered
+ * top-level blocks to source lines by ORDINAL INDEX: the nth rendered
+ * top-level child corresponds to the nth non-space/def/comment block token.
+ *
+ * The line accumulator replicates JupyterLab core's `getHeadingTokens`
+ * walk (`@jupyterlab/markedparser-extension`): `currentLine` is a cumulative
+ * newline count advanced by EVERY top-level token, recorded BEFORE advancing.
+ *
+ * This module imports only `marked` - no `@jupyterlab` / `@lumino` / DOM - so
+ * it is unit-testable offline with Jest.
+ */
+import { marked } from 'marked';
+
+/** One rendered top-level block, ordinal-aligned to the rendered host's children. */
+export interface IBlockDescriptor {
+  /** Index into the DOM-correlated block list == rendered host child index. */
+  ordinal: number;
+  /** 0-based first source line of the block. */
+  startLine: number;
+  /** 0-based last source line of the block (inclusive of trailing blanks). */
+  endLine: number;
+  /** marked token type (heading, paragraph, code, list, table, ...). */
+  type: string;
+  /** Normalized block text, for the empty-block guard. */
+  text: string;
+  /** Present only for heading tokens: createHeaderId form of the heading text. */
+  headingSlug?: string;
+}
+
+export interface IBlockMap {
+  /** Rendered (non-space/def/comment) tokens, in DOM order. */
+  blocks: IBlockDescriptor[];
+  /** Heading blocks, for the nearest-preceding-heading fallback. */
+  headings: { line: number; slug: string; ordinal: number }[];
+}
+
+/** marked token types that are NOT rendered as a top-level DOM child. */
+const NON_DOM_TYPES = new Set(['space', 'def']);
+
+/** True for an html token that renders nothing (HTML comment only). */
+function isCommentOnlyHtml(token: { type: string; raw?: string }): boolean {
+  if (token.type !== 'html') {
+    return false;
+  }
+  const raw = (token.raw ?? '').trim();
+  return /^<!--[\s\S]*-->$/.test(raw);
+}
+
+/** Reproduce rendermime `createHeaderId`: spaces -> hyphens on the plain text. */
+export function headingSlug(headingText: string): string {
+  return plainText(headingText).replace(/ /g, '-');
+}
+
+/** Best-effort strip of inline markdown so a heading token's text matches the
+ *  rendered element's textContent (used only for the heading fallback). */
+function plainText(text: string): string {
+  return text
+    .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1') // images -> alt
+    .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1') // links -> label
+    .replace(/[*_~`]/g, '') // emphasis / code markers
+    .trim();
+}
+
+/** Normalized text used for the empty-block guard. */
+function blockText(token: {
+  type: string;
+  text?: string;
+  raw?: string;
+}): string {
+  if (token.type === 'hr') {
+    return '';
+  }
+  return (token.text ?? token.raw ?? '').trim();
+}
+
+/**
+ * Re-lex `source` and build the ordinal<->line map.
+ *
+ * Uses `marked.lexer(source, { gfm: true })` to match core's parser config.
+ * The line walk includes EVERY top-level token (space/def advance the
+ * counter); the DOM-aligned block list excludes space, def and comment-only
+ * html tokens.
+ */
+export function buildBlockMap(source: string): IBlockMap {
+  const tokens = marked.lexer(source, { gfm: true }) as Array<{
+    type: string;
+    raw: string;
+    text?: string;
+    depth?: number;
+  }>;
+
+  const blocks: IBlockDescriptor[] = [];
+  const headings: { line: number; slug: string; ordinal: number }[] = [];
+
+  let currentLine = 0;
+  for (const token of tokens) {
+    const startLine = currentLine;
+    const spanned = token.raw.split('\n').length - 1;
+    currentLine += spanned;
+
+    if (NON_DOM_TYPES.has(token.type) || isCommentOnlyHtml(token)) {
+      continue;
+    }
+
+    const ordinal = blocks.length;
+    const descriptor: IBlockDescriptor = {
+      ordinal,
+      startLine,
+      endLine: startLine + Math.max(spanned - 1, 0),
+      type: token.type,
+      text: blockText(token)
+    };
+
+    if (token.type === 'heading') {
+      descriptor.headingSlug = headingSlug(token.text ?? '');
+      headings.push({
+        line: startLine,
+        slug: descriptor.headingSlug,
+        ordinal
+      });
+    }
+
+    blocks.push(descriptor);
+  }
+
+  return { blocks, headings };
+}
+
+/**
+ * Preview -> Editor. Returns the 0-based start line for the block at DOM
+ * ordinal `ordinal`, or -1 when the ordinal is out of range or the block has
+ * no textual content (caller no-ops + warns, AC #5).
+ */
+export function blockToLine(source: string, ordinal: number): number {
+  const { blocks } = buildBlockMap(source);
+  if (ordinal < 0 || ordinal >= blocks.length) {
+    return -1;
+  }
+  const block = blocks[ordinal];
+  if (block.text.length === 0) {
+    return -1;
+  }
+  return block.startLine;
+}
+
+/**
+ * Editor -> Preview. Returns the DOM ordinal of the block containing `line`
+ * (the last block whose startLine <= line), plus the nearest-preceding
+ * heading slug and its 1-based occurrence index for the fallback.
+ * `ordinal` is -1 when no block precedes the line.
+ */
+export function lineToBlock(
+  source: string,
+  line: number
+): { ordinal: number; headingSlug?: string; headingNth?: number } {
+  const { blocks } = buildBlockMap(source);
+
+  let ordinal = -1;
+  for (const block of blocks) {
+    if (block.startLine <= line) {
+      ordinal = block.ordinal;
+    } else {
+      break;
+    }
+  }
+
+  // Nearest preceding heading + its occurrence index among same-slug headings.
+  let headingSlugValue: string | undefined;
+  let headingNth: number | undefined;
+  const slugCounts = new Map<string, number>();
+  for (const block of blocks) {
+    if (block.type !== 'heading' || block.headingSlug === undefined) {
+      continue;
+    }
+    const nth = (slugCounts.get(block.headingSlug) ?? 0) + 1;
+    slugCounts.set(block.headingSlug, nth);
+    if (block.startLine <= line) {
+      headingSlugValue = block.headingSlug;
+      headingNth = nth;
+    } else {
+      break;
+    }
+  }
+
+  return { ordinal, headingSlug: headingSlugValue, headingNth };
+}

package/style/base.css

@@ -0,0 +1,5 @@
+/*
+    See the JupyterLab Developer Guide for useful CSS Patterns:
+
+    https://jupyterlab.readthedocs.io/en/stable/developer/css.html
+*/

package/style/index.css

@@ -0,0 +1 @@
+@import url('base.css');

package/style/index.js

@@ -0,0 +1 @@
+import './base.css';