jupyterlab-markdown-syntax-rendering-fix 0.6.9__tar.gz

jupyterlab_markdown_syntax_rendering_fix-0.6.9/.claude/CLAUDE.md

@@ -0,0 +1,59 @@
+<!-- @import /home/lab/.claude/CLAUDE.md -->
+
+# Project-Specific Configuration
+
+This file imports workspace-level configuration from `/home/lab/.claude/CLAUDE.md` (user home).
+All workspace rules apply. Project-specific rules below strengthen or extend them.
+
+The `/home/lab/.claude/` directory contains additional instruction files and skills referenced
+by that CLAUDE.md. Consult it to discover all applicable standards.
+
+## Mandatory Bans (Reinforced)
+
+The following workspace rules are STRICTLY ENFORCED for this project:
+
+- **No automatic git tags** - only create tags when user explicitly requests
+- **No automatic version changes** - only modify version in package.json/pyproject.toml/etc. when user explicitly requests
+- **No automatic publishing** - never run `make publish`, `npm publish`, `twine upload`, or similar without explicit user request
+- **No manual package installs if Makefile exists** - use `make install` or equivalent Makefile targets, not direct `pip install`/`uv install`/`npm install`
+- **No automatic git commits or pushes** - only when user explicitly requests
+
+## Project Context
+
+JupyterLab 4 frontend extension (`kind: frontend`, copier template `jupyterlab/extension-template` v4.6.2).
+Single TypeScript plugin at `src/index.ts`, no Python server component.
+
+**Purpose**: Fix the intermittent loss of syntax highlighting in rendered Markdown fenced code blocks.
+
+**Root cause** (reconstructed from the shipped JupyterLab 4.6 `jlab_core` bundle): `marked` runs in async
+mode. An async highlighter (`g`) writes a `lang|text` cache by awaiting `registry.highlight(...)`, which lazily
+dynamic-imports the CodeMirror language chunk. The synchronous code renderer reads that cache and, on any miss,
+falls back to a plain uncoloured `<pre><code>`. A miss occurs whenever the async highlight threw - the language
+chunk's lazy `spec.load()` import rejected (chunk-load flake/timeout, often behind the JupyterHub proxy) or the
+language registry was not yet wired when an early render fired. The `catch` swallows the error
+(`console.error("Failed to highlight ...")`), the cache stays empty, and the renderer ships plain text. The
+failure is independent of mermaid - it reproduces on bash/python/json fences with zero mermaid present.
+
+**Implication for the fix**: the durable fix is to retry or re-run the highlight after the language chunk loads;
+the only built-in workaround is re-rendering (reload tab / reopen preview) once chunks are warm.
+
+## Journal Rules (Project-Specific)
+
+- **APPEND ONLY**: New journal entries MUST be appended at the end of the file, never inserted between existing entries
+- Entries maintain strict chronological order by position - the last entry in the file is always the most recent work
+- Never reorder, move, or insert entries out of sequence
+- The Stellars **journal plugin** is the canonical tool for this file: create via `/journal:create`, append via `/journal:update`, archive via `/journal:archive`. The `journal:journal` skill auto-triggers on any mention of "journal" and runs `journal-tools check` after every write
+- Direct edits to `JOURNAL.md` are a last resort - prefer the plugin so modus secundis format, continuous numbering and append-only order are enforced automatically
+
+## Required Workspace Skills
+
+These skills MUST be consulted when working on this project (located at `/home/lab/.claude/skills/`, invocable by name):
+
+- **jupyterlab-extension** (`/home/lab/.claude/skills/jupyterlab-extension/SKILL.md`) - extension development guidelines, testing strategy, jupyter-releaser CI/CD workflows, common caveats, TypeScript compatibility, syntax highlighting
+- **playwright** (`/home/lab/.claude/skills/playwright/SKILL.md`) - browser automation for screenshots and UI verification, serving local files, connecting to authenticated JupyterHub
+
+## Strengthened Rules
+
+- **Install with `make install`** - all package install/build goes through the Makefile (`make install`, `make build`, `make test`). Never run `pip install`, `jlpm install`, `jlpm build`, `npm install` directly while a Makefile target exists
+- **Always track `package.json` and `package-lock.json`** - both files are committed artefacts; never gitignore or omit `package-lock.json`, and stage both whenever dependencies change
+- **Keep the Makefile current** - before any build/release work, compare the version header of the local `Makefile` (line 1, currently `version 1.32`) against the canonical `/home/lab/workspace/private/jupyterlab/@utils/jupyterlab-extensions/Makefile`. As soon as the canonical file is a newer version, replace the local `Makefile` with it

jupyterlab_markdown_syntax_rendering_fix-0.6.9/.claude/JOURNAL.md

@@ -0,0 +1,14 @@
+# Claude Code Journal
+
+This journal tracks substantive work on documents, diagrams, and documentation content.
+
+---
+
+1. **Task - Project initialization** (v0.1.0): Created `jupyterlab_markdown_syntax_rendering_fix` as a new JupyterLab 4 frontend extension and ran `/init-project`<br>
+   **Result**: Scaffolded from the `jupyterlab/extension-template` copier template (v4.6.2, `kind: frontend`) - single TypeScript plugin at `src/index.ts`, no server component. Replaced the inline `.claude/CLAUDE.md` with an `@import` of the user-home workspace config (`/home/lab/.claude/CLAUDE.md`) plus project-specific sections: Mandatory Bans, Project Context (the Markdown highlighting root cause), Journal Rules, a Required Workspace Skills section pointing at `jupyterlab-extension` and `playwright`, and strengthened rules mandating `make install`, tracking both `package.json` and `package-lock.json`, and syncing the local `Makefile` against the canonical `@utils/jupyterlab-extensions/Makefile` (currently v1.32). Rewrote `README.md` with the full KOLOMOLO/PyPI/npm badge set, a brief feature statement, and Install/Uninstall only. Initialized the git repository with `git init -b main` and committed the initial import.
+
+2. **Task [Extended] - Implement Markdown highlight recovery** (v0.1.7): Implemented the actual fix - recover syntax highlighting lost when JupyterLab's async highlighter throws and the markdown renderer ships a plain `pre > code.language-*`<br>
+   **Result**: Confirmed the root cause live via headless Chrome + the Playwright Python API (token from env, never leaked - the MCP path was unusable because its sandbox has no env and it echoes code; noted the working recipe in the `playwright` skill): a highlighted block carries token `<span>`s (`childElementCount > 0`), a failed one is bare text. Split the pure DOM detection (`languageFromClass`, `needsHighlight`, `collectPlainBlocks`) into `src/highlight.ts` and the JupyterLab-coupled plugin into `src/index.ts`, depending on `IEditorLanguageRegistry`. A `MutationObserver` on `app.shell.node` (skipping `.cm-editor` and `code[data-msrf]` subtrees to cut churn) finds plain blocks and `rehighlight()` re-runs `languages.highlight(text, findBest(lang), host)`, committing via `replaceChildren` only when `host.textContent === text` (no truncation). A four-state `data-msrf` marker (`1`/`plain`/`skipped`/`failed`) + a `WeakSet` dedupe make it idempotent; only a thrown highlight is retried, backing off 750/1500/3000 ms - verified against `@jupyterlab/codemirror` source that `getLanguage` caches `spec.support` only on success, so retries genuinely re-import. Build needed `typescript ~5.8` (lib0) and `chalk`/`webpack` pins in both `resolutions` and `overrides` (Node 24 isolated build). Survived five adversarial-review rounds (R1/R2 found single-shot abandonment + over-broad observer; R3 the retry-theatre claim, disproven by source; R4 and R5 returned SHIP with guard-hardening applied). Added jest unit tests (13 pass) and a Galata UI test that injects a plain block and asserts recovery (run on a port-8899 server since 8888 is the live hub); wrote `docs/acc-crit-markdown-syntax-rendering-fix.md` (22 criteria, all met). Lint clean, `labextension list` OK.
+
+3. **Task - Release v0.6.9 to npm + PyPI** (v0.6.9): First public release of the Markdown highlight-recovery extension to both registries via `make publish`<br>
+   **Result**: Greened GitHub Actions first. `check_release` failed because `package.json` still carried the copier placeholder `repository.url` (`.git`) - set `repository.url`/`homepage`/`bugs.url` to the real `stellarshenson/jupyterlab_markdown_syntax_rendering_fix` URLs so `jupyter-releaser check-npm` matches the cloned repo. `Check Links` 404'd on the pre-publish `pepy.tech` download badges - added `ignore_links` (npm/pepy patterns) to the check-links step. All five jobs (build, test_isolated, integration tests, Check Links, check_release) then passed. Added `CHANGELOG.md` (Keep a Changelog) and a README "How it works" section. `make publish` auto-incremented 0.6.8 -> 0.6.9, built the wheel + sdist and pushed to npm (`npm publish --access public`) and PyPI (`twine upload`).

jupyterlab_markdown_syntax_rendering_fix-0.6.9/.copier-answers.yml

@@ -0,0 +1,18 @@
+# Changes here will be overwritten by Copier; NEVER EDIT MANUALLY
+_commit: v4.6.2
+_src_path: https://github.com/jupyterlab/extension-template
+advanced: false
+author_email: konrad.jelen+github@gmail.com
+author_name: Stellars Henson
+has_ai_rules: false
+has_binder: false
+has_settings: false
+kind: frontend
+labextension_name: jupyterlab_markdown_syntax_rendering_fix
+project_short_description: Jupyterlab extension to fix a common issue with Markdown
+    renderer where some race condition causes for the fenced code block to not have
+    proper syntax highlighting
+python_name: jupyterlab_markdown_syntax_rendering_fix
+repository: ''
+test: true
+

jupyterlab_markdown_syntax_rendering_fix-0.6.9/.gitignore

@@ -0,0 +1,133 @@
+*.bundle.*
+lib/
+node_modules/
+*.log
+.eslintcache
+.stylelintcache
+*.egg-info/
+.ipynb_checkpoints
+*.tsbuildinfo
+jupyterlab_markdown_syntax_rendering_fix/labextension
+# Version file is handled by hatchling
+jupyterlab_markdown_syntax_rendering_fix/_version.py
+
+# Integration tests
+ui-tests/test-results/
+ui-tests/playwright-report/
+
+# Local dev build artifacts
+.nodeenv/
+.playwright-mcp/
+junit.xml
+
+# Created by https://www.gitignore.io/api/python
+# Edit at https://www.gitignore.io/?templates=python
+
+### Python ###
+# Virtual environments
+.venv
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage/
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# End of https://www.gitignore.io/api/python
+
+# OSX files
+.DS_Store
+
+# Yarn cache
+.yarn/

jupyterlab_markdown_syntax_rendering_fix-0.6.9/.prettierignore

@@ -0,0 +1,8 @@
+node_modules
+**/node_modules
+**/lib
+**/package.json
+!/package.json
+jupyterlab_markdown_syntax_rendering_fix
+eslint.config.mjs
+.venv

jupyterlab_markdown_syntax_rendering_fix-0.6.9/.yarnrc.yml

@@ -0,0 +1,2 @@
+nodeLinker: node-modules
+enableScripts: false

jupyterlab_markdown_syntax_rendering_fix-0.6.9/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project are documented here, following the Keep a Changelog format and semantic versioning.
+
+<!-- <START NEW CHANGELOG ENTRY> -->
+
+## [0.6.9] - 2026-06-23
+
+### Added
+
+- Recover syntax highlighting on rendered Markdown fenced code blocks that render plain when JupyterLab's async highlighter fails - a cold or flaky CodeMirror language-chunk import, or a language registry not yet wired when an early render fires
+- `MutationObserver`-based detection over the application shell, re-running the highlight through `IEditorLanguageRegistry` with a bounded, backed-off retry; idempotent per block and content-safe (spans are swapped in only when the highlighted text round-trips exactly, so it never truncates)
+- jest unit tests for the detection helpers and a Galata integration test covering activation and recovery
+
+<!-- <END NEW CHANGELOG ENTRY> -->

jupyterlab_markdown_syntax_rendering_fix-0.6.9/CONTRIBUTING.md

@@ -0,0 +1,80 @@
+# Contributing
+
+## Development install
+
+Note: You will need Node.js to build the extension package.
+You may install it from [nodejs.org](https://nodejs.org/en/download). We
+recommend using the latest LTS version of Node.js.
+
+The `jlpm` command is JupyterLab's pinned version of
+[yarn](https://yarnpkg.com/) that is installed with JupyterLab. You may use
+`yarn` or `npm` in lieu of `jlpm` below.
+
+```bash
+# Clone the repo to your local environment
+# Change directory to the jupyterlab_markdown_syntax_rendering_fix directory
+
+# Set up a virtual environment and install package in development mode
+python -m venv .venv
+source .venv/bin/activate
+pip install --editable "."
+
+# Link your development version of the extension with JupyterLab
+jupyter-builder develop . --overwrite
+
+# Rebuild extension Typescript source after making changes
+# IMPORTANT: Unlike the steps above which are performed only once, do this step
+# every time you make a change.
+jlpm build
+```
+
+You can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.
+
+```bash
+# Watch the source directory in one terminal, automatically rebuilding when needed
+jlpm watch
+# Run JupyterLab in another terminal
+jupyter lab
+```
+
+With the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).
+
+By default, the `jlpm build` command generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:
+
+```bash
+jupyter lab build --minimize=False
+```
+
+## Development uninstall
+
+```bash
+pip uninstall jupyterlab_markdown_syntax_rendering_fix
+```
+
+In development mode, you will also need to remove the symlink created by `jupyter-builder develop`
+command. To find its location, you can run `jupyter labextension list` to figure out where the `labextensions`
+folder is located. Then you can remove the symlink named `jupyterlab_markdown_syntax_rendering_fix` within that folder.
+
+## Testing the extension
+
+#### Frontend tests
+
+This extension is using [Jest](https://jestjs.io/) for JavaScript code testing.
+
+To execute them, execute:
+
+```sh
+jlpm
+jlpm test
+```
+
+### Integration tests
+
+This extension uses [Playwright](https://playwright.dev/docs/intro) for the integration tests (aka user level tests).
+More precisely, the JupyterLab helper [Galata](https://github.com/jupyterlab/jupyterlab/tree/master/galata) is used to handle testing the extension in JupyterLab.
+
+More information is provided within the [ui-tests](./ui-tests/README.md) README.
+
+## Packaging the extension
+
+See [RELEASE](RELEASE.md)

jupyterlab_markdown_syntax_rendering_fix-0.6.9/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.

jupyterlab_markdown_syntax_rendering_fix-0.6.9/Makefile

@@ -0,0 +1,155 @@
+# Makefile for Jupyterlab extensions version 1.32
+# changelog:
+#   1.32 - use a project-local nodeenv at .nodeenv/ instead of overwriting the python
+#          prefix via `nodeenv -p` (which used to fail with "Text file busy" when the
+#          existing node binary was held open). PATH=.nodeenv/bin:$PATH is exported so
+#          every target transparently picks up the pinned local node + npm + yarn.
+#          install_dependencies now guards each install step - only what's missing
+#          gets installed. mrproper removes .nodeenv too.
+#   1.31 - mrproper now removes ui-tests/node_modules (Playwright browser binaries)
+#   1.30 - check twine in check_dependencies, ensure publish doesn't fail on missing twine
+#   1.29 - replace yarn with jlpm, add prettier format, auto-commit and push after publish
+#   1.28 - initial versioned Makefile
+# author: Stellars Henson <konrad.jelen@gmail.com>
+# License: MIT Open Source License
+
+.PHONY: build install clean uninstall publish dependencies mrproper increment_version install_dependencies check_dependencies upgrade help test
+.DEFAULT_GOAL := help
+
+# Project-local node environment - keeps node/npm/yarn pinned per project and out of
+# the python prefix. Created by `install_dependencies` and torn down by `mrproper`.
+NODEENV := $(CURDIR)/.nodeenv
+export PATH := $(NODEENV)/bin:$(PATH)
+
+# Read current version from package.json (only if node is available)
+VERSION := $(shell command -v node >/dev/null 2>&1 && node -p "require('./package.json').version" || echo "0.0.0")
+
+## increment project version
+increment_version:
+	@echo "Current version: $(VERSION)"
+	@bash -c 'CURRENT_VERSION=$(VERSION); \
+	IFS="." read -r major minor patch <<< "$$CURRENT_VERSION"; \
+	NEW_PATCH=$$((patch + 1)); \
+	NEW_VERSION="$$major.$$minor.$$NEW_PATCH"; \
+	echo "New version: $$NEW_VERSION"; \
+	sed -i "s/\"version\": \"$$CURRENT_VERSION\"/\"version\": \"$$NEW_VERSION\"/" package.json; '
+
+## build packages
+build: clean increment_version check_dependencies
+	npm install
+	jlpm install
+	npx prettier --write package-lock.json package.json
+	python -m build
+
+## install package
+install: build
+	pip install dist/*.whl --force-reinstall
+
+## run tests
+test: check_dependencies
+	jlpm test
+
+## clean builds and installables
+clean: uninstall  check_dependencies
+	@command -v npm >/dev/null 2>&1 && npm run clean || true
+	@command -v npm >/dev/null 2>&1 && npm run clean:labextension || true
+	rm -rf dist lib || true
+
+## uninstall package
+uninstall:  check_dependencies
+	pip uninstall -y dist/*.whl 2>/dev/null || true
+
+## check if required dependencies are installed in the project-local nodeenv
+check_dependencies:
+	@echo "Checking dependencies..."
+	@MISSING=""; \
+	[ -x "$(NODEENV)/bin/node" ] || MISSING="$$MISSING node"; \
+	[ -x "$(NODEENV)/bin/npm" ] || MISSING="$$MISSING npm"; \
+	[ -x "$(NODEENV)/bin/yarn" ] || MISSING="$$MISSING yarn"; \
+	python -m twine --version >/dev/null 2>&1 || MISSING="$$MISSING twine"; \
+	if [ -n "$$MISSING" ]; then \
+		echo "Missing dependencies:$$MISSING"; \
+		echo "Installing missing dependencies..."; \
+		$(MAKE) install_dependencies; \
+	else \
+		echo "All dependencies are installed."; \
+	fi
+
+## publish package to public repository
+publish: check_dependencies install
+	npm publish --access public
+	python -m twine upload dist/*
+	git add package.json package-lock.json
+	git commit -m "chore: post-publish $$(node -p "require('./package.json').version") package metadata"
+	git push
+
+## install required build dependencies into the project-local nodeenv (only what's missing)
+install_dependencies:
+	@if ! python -m twine --version >/dev/null 2>&1; then \
+		echo "Installing twine..."; \
+		pip install twine; \
+	fi
+	@if [ ! -x "$(NODEENV)/bin/node" ] || [ ! -x "$(NODEENV)/bin/npm" ]; then \
+		echo "Creating project-local node environment at $(NODEENV)..."; \
+		python -c "import nodeenv" >/dev/null 2>&1 || pip install nodeenv; \
+		nodeenv --node=lts --prebuilt "$(NODEENV)"; \
+	fi
+	@if [ ! -x "$(NODEENV)/bin/yarn" ]; then \
+		echo "Installing yarn + rimraf into $(NODEENV)..."; \
+		"$(NODEENV)/bin/npm" install -g yarn rimraf; \
+	fi
+	@echo "node:  $$($(NODEENV)/bin/node --version 2>/dev/null) ($(NODEENV)/bin/node)"
+	@echo "npm:   $$($(NODEENV)/bin/npm --version 2>/dev/null)"
+	@echo "yarn:  $$($(NODEENV)/bin/yarn --version 2>/dev/null)"
+
+## upgrade all npm and yarn dependencies
+upgrade: check_dependencies
+	jlpm up
+
+## cleanup all build and metabuild artefacts (including the project-local nodeenv)
+mrproper: clean uninstall
+	rm -rf node_modules .yarn ui-tests/node_modules .nodeenv || true
+
+## prints the list of available commands
+help:
+	@echo ""
+	@echo "$$(tput bold)Available rules:$$(tput sgr0)"
+	@sed -n -e "/^## / { \
+		h; \
+		s/.*//; \
+		:doc" \
+		-e "H; \
+		n; \
+		s/^## //; \
+		t doc" \
+		-e "s/:.*//; \
+		G; \
+		s/\\n## /---/; \
+		s/\\n/ /g; \
+		p; \
+	}" ${MAKEFILE_LIST} \
+	| LC_ALL='C' sort --ignore-case \
+	| awk -F '---' \
+		-v ncol=$$(tput cols) \
+		-v indent=19 \
+		-v col_on="$$(tput setaf 6)" \
+		-v col_off="$$(tput sgr0)" \
+	'{ \
+		printf "%s%*s%s ", col_on, -indent, $$1, col_off; \
+		n = split($$2, words, " "); \
+		line_length = ncol - indent; \
+		for (i = 1; i <= n; i++) { \
+			line_length -= length(words[i]) + 1; \
+			if (line_length <= 0) { \
+				line_length = ncol - indent - length(words[i]) - 1; \
+				printf "\n%*s ", -indent, " "; \
+			} \
+			printf "%s ", words[i]; \
+		} \
+		printf "\n"; \
+	}' 
+	@echo ""
+
+
+# EOF
+

jupyterlab_markdown_syntax_rendering_fix-0.6.9/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: jupyterlab_markdown_syntax_rendering_fix
+Version: 0.6.9
+Summary: Jupyterlab extension to fix a common issue with Markdown renderer where some race condition causes for the fenced code block to not have proper syntax highlighting
+Project-URL: Homepage, https://github.com/stellarshenson/jupyterlab_markdown_syntax_rendering_fix
+Project-URL: Bug Tracker, https://github.com/stellarshenson/jupyterlab_markdown_syntax_rendering_fix/issues
+Project-URL: Repository, https://github.com/stellarshenson/jupyterlab_markdown_syntax_rendering_fix.git
+Author-email: Stellars Henson <konrad.jelen+github@gmail.com>
+License: 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.
+License-File: LICENSE
+Keywords: jupyter,jupyterlab,jupyterlab-extension
+Classifier: Framework :: Jupyter
+Classifier: Framework :: Jupyter :: JupyterLab
+Classifier: Framework :: Jupyter :: JupyterLab :: 4
+Classifier: Framework :: Jupyter :: JupyterLab :: Extensions
+Classifier: Framework :: Jupyter :: JupyterLab :: Extensions :: Prebuilt
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: jupyter-builder>=1.0.0; extra == 'dev'
+Requires-Dist: jupyterlab>=4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# jupyterlab_markdown_syntax_rendering_fix
+
+[![GitHub Actions](https://github.com/stellarshenson/jupyterlab_markdown_syntax_rendering_fix/actions/workflows/build.yml/badge.svg)](https://github.com/stellarshenson/jupyterlab_markdown_syntax_rendering_fix/actions/workflows/build.yml)
+[![npm version](https://img.shields.io/npm/v/jupyterlab_markdown_syntax_rendering_fix.svg)](https://www.npmjs.com/package/jupyterlab_markdown_syntax_rendering_fix)
+[![PyPI version](https://img.shields.io/pypi/v/jupyterlab-markdown-syntax-rendering-fix.svg)](https://pypi.org/project/jupyterlab-markdown-syntax-rendering-fix/)
+[![Total PyPI downloads](https://static.pepy.tech/badge/jupyterlab-markdown-syntax-rendering-fix)](https://pepy.tech/project/jupyterlab-markdown-syntax-rendering-fix)
+[![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)
+
+Fenced code blocks in rendered Markdown sometimes appear plain and uncoloured - the highlighting silently fails when a CodeMirror language chunk loads late or the language registry is not yet ready, and JupyterLab falls back to plain text. This extension restores the highlighting that was lost to that race.
+
+## Features
+
+- **Recovers lost highlighting** - re-applies syntax highlighting to fenced code blocks that rendered plain because the async highlighter missed the cache
+- **Language agnostic** - works for any fenced language (bash, python, json, ...), independent of mermaid
+- **Targets the cold-load race** - handles the case where a language chunk imports late or the registry is wired after an early render
+- **Frontend only** - pure TypeScript labextension, no server component
+
+## How it works
+
+JupyterLab highlights fenced code in rendered Markdown with an async pass that fills a cache and a synchronous renderer that reads it. When the async highlight throws - a CodeMirror language-chunk import that rejects, or a registry that is not yet wired when an early render fires - the cache misses and the renderer emits a plain `<pre><code>`. This extension watches the application shell for those plain blocks and re-runs the highlight once the language is available.
+
+- **Detect** - a `MutationObserver` flags any rendered `pre > code` that has a `language-*` class and text but no token `<span>` children
+- **Recover** - re-runs the highlight through `IEditorLanguageRegistry` and swaps in the token spans, only when the highlighted text matches the source exactly so it never truncates content
+- **Resilient** - retries a thrown highlight a few times with backoff while the language chunk finishes loading, then gives up cleanly and leaves the original plain text untouched
+- **Unobtrusive** - each block is handled at most once, and editor and overlay churn is skipped to keep the observer cheap
+
+## Requirements
+
+- JupyterLab >= 4.0.0
+
+## Install
+
+To install the extension, execute:
+
+```bash
+pip install jupyterlab_markdown_syntax_rendering_fix
+```
+
+## Uninstall
+
+To remove the extension, execute:
+
+```bash
+pip uninstall jupyterlab_markdown_syntax_rendering_fix
+```