@scalar/code-highlight 0.4.5 → 0.4.6

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @scalar/code-highlight
 
+## 0.4.6
+
+### Patch Changes
+
+- [#10074](https://github.com/scalar/scalar/pull/10074): perf(code-highlight): reuse the markdown processor and skip the pipeline for plain paragraphs
+
+  `htmlFromMarkdown` rebuilt its twelve-plugin unified chain on every call, and each of those rebuilds ran `createLowlight(standardLanguages)`, re-registering all 57 syntax grammars before rendering. Rendering a single API description paid for a whole highlighter. Profiling an API reference schema put 34-44% of the time in markdown, roughly 70% of it in construction rather than parsing.
+
+  Two changes. One lazily created lowlight instance is now shared through `rehypeHighlight`'s `lowlight` option, and the processor is frozen and cached per option set (sorted `removeTags`, sorted `allowTags`, transform type). Calls that pass a `transform` callback still build per call, because the callback receives the AST. Separately, a description that is a single plain line with no markdown, HTML or collapsible whitespace now returns the paragraph the pipeline would have produced, without running it.
+
+  Output is unchanged. Every unique description in the Stripe OpenAPI document (5,167 of them), plus targeted probes across seven option sets and 40,000 random strings drawn from an alphabet of the excluded metacharacters, render byte-identically before and after.
+
+  Two caches now live for the process lifetime: the grammar registry and the processor map. Both are immutable once built, and the registry is only mutated through an `aliases` option this package never passes.
+
 ## 0.4.5
 
 ### Patch Changes

package/dist/chunks/code.js

@@ -1,4 +1,4 @@
-import { i as lowlightLanguageMappings, t as rehypeHighlight } from "./rehype-highlight.js";
+import { a as lowlightLanguageMappings, t as rehypeHighlight } from "./rehype-highlight.js";
 import { n as rehypeStringify, s as rehypeParse, t as unified } from "./lib.js";
 import { t as visit } from "./lib2.js";
 //#region src/code/line-numbers.ts

package/dist/chunks/lib.js

@@ -1,4 +1,4 @@
-import { c as __toESM, o as __commonJSMin, s as __exportAll } from "./rehype-highlight.js";
+import { c as __exportAll, l as __toESM, s as __commonJSMin } from "./rehype-highlight.js";
 //#region ../../node_modules/.pnpm/property-information@7.1.0/node_modules/property-information/lib/util/schema.js
 /**
 * @import {Schema as SchemaType, Space} from 'property-information'

package/dist/chunks/markdown.js

@@ -1,4 +1,4 @@
-import { n as convertElement, r as isElement, s as __exportAll, t as rehypeHighlight } from "./rehype-highlight.js";
+import { c as __exportAll, i as isElement, n as createLowlight, r as convertElement, t as rehypeHighlight } from "./rehype-highlight.js";
 import { _ as stringify, a as zwitch, b as find, c as stringifyPosition, d as getTagID, f as TokenType, g as stringify$1, h as parse$1, i as ccount, l as Parser, m as webNamespaces, n as rehypeStringify, o as htmlVoidElements, p as fromParse5, r as whitespace, s as rehypeParse, t as unified, u as TokenizerMode, v as html$2, y as svg } from "./lib.js";
 import { i as convert, n as SKIP, r as visitParents, t as visit } from "./lib2.js";
 import { t as standardLanguages } from "./languages.js";
@@ -20829,35 +20829,100 @@ var transformInlineMarkdownInRawHtml = () => (tree) => {
 	});
 };
 /**
+* One lowlight instance shared by every markdown pipeline.
+*
+* Registering the standard grammars is the most expensive part of building a
+* pipeline, and the registry is read-only once built (nothing here passes
+* `aliases`, the only option that mutates a given instance), so it is created
+* on first use and reused from then on.
+*/
+var sharedLowlight;
+var getLowlight = () => {
+	sharedLowlight ??= createLowlight(standardLanguages);
+	return sharedLowlight;
+};
+/**
+* Build the markdown to HTML pipeline.
+*/
+var createProcessor = (tagNames, transform, transformType) => unified().use(remarkParse).use(remarkGfm).use(transformNodes, {
+	transform,
+	type: transformType
+}).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeAlert).use(transformInlineMarkdownInRawHtml).use(rehypeRaw).use(rehypeSanitize, {
+	...defaultSchema,
+	clobberPrefix: "",
+	tagNames,
+	attributes: {
+		...defaultSchema.attributes,
+		abbr: ["title"],
+		"*": [...defaultSchema.attributes?.["*"] ?? [], "className"]
+	},
+	strip: [
+		"script",
+		"style",
+		"object",
+		"embed",
+		"form"
+	]
+}).use(rehypeHighlight, {
+	lowlight: getLowlight(),
+	detect: true,
+	className: "custom-scroll"
+}).use(rehypeExternalLinks, { target: "_blank" }).use(rehypeFormat).use(rehypeStringify);
+/**
+* Frozen pipelines keyed by the options that shape them.
+*
+* Every plugin in the chain is stateless once attached, so a pipeline can be
+* frozen and reused for every call that shares the same options. This matters
+* because API references render one description per schema row, and building
+* the pipeline used to cost far more than running it. Calls with a `transform`
+* callback are not cached, because that closure belongs to the caller.
+*/
+var processorCache = /* @__PURE__ */ new Map();
+/**
+* Matches strings that CommonMark, GFM and this pipeline all render as a single plain paragraph.
+*
+* The point is to skip the whole markdown pipeline for the many short, plain
+* descriptions an API reference renders (property summaries such as "Integer
+* numbers."), where parsing, sanitising, highlighting and formatting cost far
+* more than the one paragraph they produce.
+*
+* The whitelist is deliberately conservative: a single line, no leading or
+* trailing whitespace, no run of two spaces, no character that markdown or the
+* serializer treats specially, and no block marker at the start. Every
+* CommonMark block construct needs a leading space, `#`, `>`, a bullet, an
+* ordered marker, `<`, a fence, a thematic break or a second line; every inline
+* construct needs `\`, a backtick, `*`, `_`, `[`, `]`, `<`, `&`, `~`, a hard
+* break or a GFM autolink literal (`www.`, `:/`, `mailto:`, `xmpp:`, `@`).
+* `rehype-stringify` escapes only `<` and `&` in text, and `rehype-format`
+* only collapses whitespace runs and trims block edges, both of which are
+* excluded here, so the fast path returns exactly what the pipeline returns.
+*
+* The `i` flag is load bearing: GFM matches the `www.`, `mailto:` and `xmpp:`
+* autolink prefixes case-insensitively, so the lookahead has to as well.
+* Unicode whitespace is written as escapes because a literal U+2028 or U+2029
+* inside a regular expression literal is a syntax error.
+*/
+var PLAIN_PARAGRAPH = /^(?![-+=]|\d{1,9}[.)](?:\s|$))(?!.*(?: {2}|:\/|www\.|mailto:|xmpp:))[^\s\\`*_\[\]<>&#~|@\x00-\x1f\x7f\u00a0\u1680\u2000-\u200b\u2028\u2029\u202f\u205f\u3000\ufeff](?:[^\\`*_\[\]<>&#~|@\t\n\v\f\r\x00-\x1f\x7f\u00a0\u1680\u2000-\u200b\u2028\u2029\u202f\u205f\u3000\ufeff]*[^\s\\`*_\[\]<>&#~|@\x00-\x1f\x7f\u00a0\u1680\u2000-\u200b\u2028\u2029\u202f\u205f\u3000\ufeff])?$/i;
+/**
 * Take a Markdown string and generate HTML from it
 */
 function htmlFromMarkdown(markdown, options) {
 	const removeTags = options?.removeTags ?? [];
-	const tagNames = [...defaultSchema.tagNames ?? [], ...options?.allowTags ?? []].filter((t) => !removeTags.includes(t));
-	return unified().use(remarkParse).use(remarkGfm).use(transformNodes, {
-		transform: options?.transform,
-		type: options?.transformType
-	}).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeAlert).use(transformInlineMarkdownInRawHtml).use(rehypeRaw).use(rehypeSanitize, {
-		...defaultSchema,
-		clobberPrefix: "",
-		tagNames,
-		attributes: {
-			...defaultSchema.attributes,
-			abbr: ["title"],
-			"*": [...defaultSchema.attributes?.["*"] ?? [], "className"]
-		},
-		strip: [
-			"script",
-			"style",
-			"object",
-			"embed",
-			"form"
-		]
-	}).use(rehypeHighlight, {
-		languages: standardLanguages,
-		detect: true,
-		className: "custom-scroll"
-	}).use(rehypeExternalLinks, { target: "_blank" }).use(rehypeFormat).use(rehypeStringify).processSync(markdown).toString();
+	if (!options?.transform && !removeTags.includes("p") && PLAIN_PARAGRAPH.test(markdown)) return `\n<p>${markdown}</p>\n`;
+	const allowTags = options?.allowTags ?? [];
+	const tagNames = [...defaultSchema.tagNames ?? [], ...allowTags].filter((t) => !removeTags.includes(t));
+	if (options?.transform) return createProcessor(tagNames, options.transform, options.transformType).processSync(markdown).toString();
+	const key = [
+		[...removeTags].sort().join(","),
+		[...allowTags].sort().join(","),
+		options?.transformType ?? ""
+	].join("|");
+	let processor = processorCache.get(key);
+	if (!processor) {
+		processor = createProcessor(tagNames, void 0, options?.transformType).freeze();
+		processorCache.set(key, processor);
+	}
+	return processor.processSync(markdown).toString();
 }
 /**
 * Create a Markdown AST from a string.