rapier-math 1.1.0 → 1.1.1

package/src/math/examples/worker.mjs

@@ -1,7 +0,0 @@
-// SPDX-License-Identifier: MIT
-import {render} from '../index.mjs';
-self.onmessage = ({data: {id, source}}) => {
-  try { self.postMessage({id, source, result: render(source)}); }
-  catch (error) { self.postMessage({id, source, error: {code: error.code, message: error.message}}); }
-};
-// Keep a request id per message; install a reply only if it is still current.

package/src/math/index.d.ts

@@ -1,43 +0,0 @@
-// SPDX-License-Identifier: MIT
-export interface MathError {
-  code: string;
-  message: string;
-  /** Zero-based UTF-16 offset in the formula. */
-  offset: number;
-  command?: string;
-  messageTruncated?: boolean;
-  commandTruncated?: boolean;
-  /** True only when refused oversized source is not embedded in diagnostic SVG. */
-  sourceOmitted?: boolean;
-}
-export interface RenderOptions {
-  displayMode?: boolean;
-  maxWidth?: number;
-  screen?: {fontSize: number; pixelRatio: number; dark: boolean};
-}
-export interface RenderResult {
-  svg: string;
-  width: number;
-  height: number;
-  depth: number;
-  lines: number;
-  fitted: boolean;
-  errors: MathError[];
-}
-/** Parser nodes are inspectable; the internal node vocabulary can grow. */
-export interface MathNode {type: string; [field: string]: unknown}
-/** Browser nodes (including Element, Document and DocumentFragment) satisfy this
- * structural type without requiring the DOM type library in server projects. */
-export interface MathContainer {readonly nodeType: number}
-export const version: string;
-/** Oversized source returns a bounded resource-limit diagnostic with sourceOmitted. */
-export function render(source: unknown, options?: RenderOptions): RenderResult;
-export function renderToString(source: unknown, options?: RenderOptions): string;
-export function parse(source: string): MathNode;
-export function fit(container: MathContainer): number;
-export function observe(container: MathContainer): () => void;
-declare const RapierMath: Readonly<{
-  version: typeof version; render: typeof render; renderToString: typeof renderToString;
-  parse: typeof parse; fit: typeof fit; observe: typeof observe;
-}>;
-export default RapierMath;

package/src/math/integration.d.ts

@@ -1,9 +0,0 @@
-// SPDX-License-Identifier: MIT
-import type {RenderOptions} from './index.js';
-export interface IntegrationOptions {
-  renderOptions?: RenderOptions;
-  /** Per document. Default 1024. Exhaustion leaves subsequent math as source. */
-  maxFormulas?: number;
-  /** Combined successful SVG code units per document. Default 16 * 1024 * 1024. */
-  maxOutputLength?: number;
-}

package/src/math/integration.mjs

@@ -1,28 +0,0 @@
-// SPDX-License-Identifier: MIT
-import {render} from './index.mjs';
-
-export const escapeText = text => text.replace(/[&<>"'\r]/g, char =>
-  ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;', '\r': '&#13;'}[char]));
-
-// One budget per document render. Rejection leaves the host's text node intact.
-export function createFormulaRenderer(options = {}) {
-  const maxFormulas = options.maxFormulas ?? 1024, maxOutputLength = options.maxOutputLength ?? 16 * 1024 * 1024;
-  for (const value of [maxFormulas, maxOutputLength])
-    if (!Number.isSafeInteger(value) || value < 0) throw new RangeError('Math integration budgets must be finite nonnegative integers.');
-  let count = 0, length = 0;
-  return (source, displayMode) => {
-    let result;
-    if (count >= maxFormulas || length >= maxOutputLength) return {errors: [{code: 'resource-limit', offset: 0,
-      message: 'The document math budget is exhausted.'}]};
-    count++;
-    try { result = render(source, {...options.renderOptions, displayMode}); }
-    catch (error) { return {errors: [{code: error.code || 'invalid-tex', message: String(error.message), offset: error.offset || 0}]}; }
-    if (result.errors.length) return {errors: result.errors};
-    if (result.svg.length > maxOutputLength - length) {
-      length = maxOutputLength;
-      return {errors: [{code: 'resource-limit', offset: 0, message: 'The document math output budget is exhausted.'}]};
-    }
-    length += result.svg.length;
-    return result;
-  };
-}

package/src/math/markdown-it.d.ts

@@ -1,6 +0,0 @@
-// SPDX-License-Identifier: MIT
-import type MarkdownIt from 'markdown-it';
-import type {DelimiterOptions} from './delimiters.js';
-import type {IntegrationOptions} from './integration.js';
-export interface MarkdownMathOptions extends DelimiterOptions, IntegrationOptions {}
-export default function rapierMath(md: InstanceType<typeof MarkdownIt>, options?: MarkdownMathOptions): void;

package/src/math/markdown-it.mjs

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: MIT
-import {installMathRules} from './markdown-rules.mjs';
-import {createFormulaRenderer, escapeText} from './integration.mjs';
-
-export default function rapierMath(md, options = {}) {
-  installMathRules(md, options);
-  let session;
-  function withSession(renderer, render, tokens, opts, env) {
-    const previous = session, current = {render: createFormulaRenderer(options), children: new WeakSet()};
-    const visit = tokens => {
-      for (const token of tokens) {
-        if (token.children) { current.children.add(token.children); visit(token.children); }
-      }
-    };
-    visit(tokens);
-    session = current;
-    try { return render.call(renderer, tokens, opts, env); }
-    finally { session = previous; }
-  }
-  const render = md.renderer.render, renderInline = md.renderer.renderInline;
-  md.renderer.render = function(tokens, opts, env) {
-    return withSession(this, render, tokens, opts, env);
-  };
-  md.renderer.renderInline = function(tokens, opts, env) {
-    // The block renderer's inline children share its document budget. A separate
-    // inline tree, including a nested host renderInline call, owns a fresh one.
-    if (session?.children.has(tokens)) return renderInline.call(this, tokens, opts, env);
-    return withSession(this, renderInline, tokens, opts, env);
-  };
-  function formula(tokens, index, _options, env) {
-    const token = tokens[index], display = token.type === 'math_block';
-    const result = (session?.render || createFormulaRenderer(options))(token.content, display);
-    if (result.errors.length) {
-      (env.rapierMathErrors ||= []).push({source: token.content, errors: result.errors});
-      return '<code data-math-error="' + escapeText(result.errors[0].code) + '">' +
-        escapeText(token.meta?.mathSource ?? token.content) + '</code>';
-    }
-    return result.svg;
-  }
-  md.renderer.rules.math_inline = formula;
-  md.renderer.rules.math_block = (tokens, index, opts, env) => {
-    const result = formula(tokens, index, opts, env);
-    return tokens[index].block ? '<div class="math-display">' + result + '</div>\n' : result;
-  };
-}

package/src/math/markdown-rules.mjs

@@ -1,65 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Original neutral adapter. The host owns Markdown structure and normalization.
-import {createMathMatcher} from './delimiters.mjs';
-
-export function installMathRules(md, {singleDollar = false, brackets = true, ruleName = 'rapier_math', inLink = false} = {}) {
-  // The host's image-alt renderer ignores unknown token types. Keep math as
-  // literal source in text-only output, while leaving escaping to that host.
-  const renderText = md.renderer.renderInlineAsText;
-  md.renderer.renderInlineAsText = function(tokens, options, env) {
-    return renderText.call(this, tokens.map(token =>
-      token.type === 'math_inline' || token.type === 'math_block'
-        ? {...token, type: 'text', content: token.meta?.mathSource ?? token.content}
-        : token), options, env);
-  };
-  const matchers = new WeakMap();
-  function match(state, at, limit) {
-    let entry = matchers.get(state);
-    if (!entry || entry.source !== state.src) {
-      entry = {source: state.src, match: createMathMatcher(state.src, {singleDollar, brackets})};
-      matchers.set(state, entry);
-    }
-    return entry.match(at, limit);
-  }
-  md.inline.ruler.before('escape', ruleName, (state, silent) => {
-    if (!inLink && state.linkLevel > 0) return false;
-    if (state.src[state.pos] !== '$' && state.src[state.pos] !== '\\') return false;
-    const span = match(state, state.pos, state.posMax);
-    if (!span) return false;
-    if (!silent) {
-      const token = state.push(span.displayMode ? 'math_block' : 'math_inline', '', 0);
-      token.markup = span.open;
-      token.content = state.src.slice(span.bodyStart, span.bodyEnd);
-      token.meta = {mathSource: state.src.slice(span.start, span.end)};
-    }
-    state.pos = span.end;
-    return true;
-  });
-  md.block.ruler.before('fence', ruleName, (state, startLine, endLine, silent) => {
-    // An indented code block belongs to the host even when it begins with dollars.
-    if (state.sCount[startLine] - state.blkIndent >= 4) return false;
-    const start = state.bMarks[startLine] + state.tShift[startLine];
-    if (state.src.slice(start, start + 2) !== '$$' && (!brackets || state.src.slice(start, start + 2) !== '\\[')) return false;
-    const span = match(state, start, state.eMarks[endLine - 1]);
-    if (!span?.displayMode) return false;
-    let last = startLine;
-    while (last < endLine && state.eMarks[last] < span.end) last++;
-    if (last >= endLine || span.bodyEnd < state.bMarks[last] + state.tShift[last] ||
-        state.src.slice(span.end, state.eMarks[last]).trim()) return false;
-    if (silent) return true;
-    const parts = [];
-    for (let line = startLine; line <= last; line++) {
-      const from = line === startLine ? span.bodyStart : state.bMarks[line] + state.tShift[line];
-      const to = line === last ? span.bodyEnd : state.eMarks[line];
-      parts.push(state.src.slice(from, to));
-    }
-    const token = state.push('math_block', 'math', 0);
-    token.block = true;
-    token.markup = span.open;
-    token.content = parts.join('\n');
-    token.meta = {mathSource: span.open + token.content + span.close};
-    token.map = [startLine, last + 1];
-    state.line = last + 1;
-    return true;
-  }, {alt: ['paragraph', 'reference', 'blockquote', 'list']});
-}

package/src/math/package-check.mjs

@@ -1,118 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Package entry, exact authored text and hostile-content boundaries; no appearance assertions.
-import assert from 'node:assert/strict';
-import {readFile} from 'node:fs/promises';
-import {Script, createContext} from 'node:vm';
-import {mathModule} from './src/math/package-build.mjs';
-
-const read = path => readFile(new URL(path, import.meta.url), 'utf8');
-const pkg = JSON.parse(await read('./package.json'));
-const resources = JSON.parse(await read('./src/shell/math-resources.json'));
-const classicSource = await read('./' + resources.bundle);
-assert.equal(pkg.name, 'rapier-math');
-assert.equal(pkg.version, resources.version);
-assert.equal(pkg.type, 'module');
-assert.equal(pkg.license, 'SEE LICENSE IN LICENSE');
-assert.equal(Object.keys(pkg.dependencies || {}).length, 0);
-assert.equal(Object.keys(pkg.scripts || {}).length, 0);
-assert.equal(await read('./index.mjs'), mathModule(classicSource), 'exact generated module');
-const rendererLicense = await read('./LICENSE-MIT'), fontLicense = await read('./math-font-LICENSE.txt');
-for (const name of ['./LICENSE', './index.mjs', './' + resources.bundle]) {
-  const text = await read(name);
-  assert(text.includes(rendererLicense.trim()), name + ': renderer license');
-  assert(text.includes(fontLicense.trim()), name + ': complete font license');
-}
-
-// Initialize Node's lazy Web API globals before observing module purity. This
-// allocates a local Response only; no network request or renderer evaluation.
-new Response();
-const globals = Object.getOwnPropertyDescriptors(globalThis);
-const module = await import('./index.mjs');
-const afterImport = Object.getOwnPropertyDescriptors(globalThis);
-assert.deepEqual(Reflect.ownKeys(afterImport), Reflect.ownKeys(globals), 'module adds no globals');
-for (const key of Reflect.ownKeys(globals)) for (const field of Object.keys(globals[key]))
-  assert(Object.is(afterImport[key][field], globals[key][field]), 'module preserves global ' + String(key));
-assert.deepEqual(Object.keys(module).sort(), ['default', 'fit', 'observe', 'parse', 'render', 'renderToString', 'version']);
-for (const name of Object.keys(module.default)) assert.equal(module[name], module.default[name], 'named/default export ' + name);
-assert.equal(module.version, resources.version);
-assert(Object.isFrozen(module.default));
-
-const context = createContext({atob, URL});
-new Script(classicSource, {filename: resources.bundle}).runInContext(context);
-const classic = context.RapierMath;
-const plain = value => JSON.parse(JSON.stringify(value));
-const unescape = text => text.replace(/&(amp|lt|gt|quot|apos|#\d+|#x[\da-f]+);/gi, (_, entity) =>
-  entity[0] === '#' ? String.fromCodePoint(entity[1] === 'x' ? parseInt(entity.slice(2), 16) : Number(entity.slice(1))) :
-    ({amp: '&', lt: '<', gt: '>', quot: '"', apos: "'"})[entity]);
-function sourceAlternative(result, source) {
-  const label = /\baria-label="([^"]*)"/.exec(result.svg)?.[1];
-  const title = /<title>([^<]*)<\/title>/.exec(result.svg)?.[1];
-  const utf16 = /\bdata-tex-utf16="([0-9a-f]+)"/.exec(result.svg)?.[1];
-  if (utf16) assert.equal(utf16.match(/.{4}/g).map(part => String.fromCharCode(parseInt(part, 16))).join(''), source, 'exact UTF-16 alternative');
-  else { assert.equal(unescape(label), source, 'exact aria alternative'); assert.equal(unescape(title), source, 'exact title alternative'); }
-}
-function inert(svg) {
-  assert(!/<\s*(?:script|foreignObject|iframe|object|embed|image|style|animate|set)\b/i.test(svg), 'no executable or remote SVG element');
-  for (const tag of svg.match(/<[^>]+>/g) || []) {
-    const attributes = [...tag.matchAll(/\s([^\s=]+)="([^"]*)"/g)];
-    for (const [, name, value] of attributes) {
-      assert(!/^on/i.test(name), 'no event attribute');
-      if (/^(?:href|xlink:href)$/i.test(name)) assert(/^https?:\/\//i.test(unescape(value)), 'only HTTP(S) links');
-      if (!/^(?:aria-label|data-tex-utf16)$/.test(name)) assert(!/url\s*\(|javascript:|vbscript:/i.test(unescape(value)), 'no executable attribute');
-    }
-  }
-}
-
-const examples = [
-  [String.raw`\frac{-b\pm\sqrt{b^2-4ac}}{2a}`, {displayMode: true}],
-  [String.raw`\begin{aligned}a&=b+c\\d&=e+f\end{aligned}`, {displayMode: true, maxWidth: 4}],
-  [String.raw`\newcommand{\squareof}[1]{#1^2}\squareof{x}`, {screen: {fontSize: 16, pixelRatio: 2, dark: false}}],
-  [String.raw`\text{A < B & "C" 'D'} + α`, {}],
-  [String.raw`\href{https://example.com/?a=1&b=2}{x}`, {}],
-  [String.raw`\unsupported{content}`, {}],
-  ['x\u0000y\ud800z\udfff', {}],
-];
-for (const [source, options] of examples) {
-  const result = module.render(source, options);
-  assert.deepEqual(plain(result), plain(classic.render(source, options)), 'module/classic result');
-  assert.equal(module.renderToString(source, options), result.svg, 'string export agrees with render');
-  sourceAlternative(result, source); inert(result.svg);
-}
-assert.deepEqual(plain(module.parse(examples[0][0])), plain(classic.parse(examples[0][0])), 'module/classic parse');
-assert.equal(module.render(examples.at(-1)[0]).errors[0].code, 'invalid-source-character');
-assert.equal(module.render(examples.at(-2)[0]).errors[0].code, 'unsupported-command');
-
-const hostile = [
-  String.raw`\text{</title><script>alert(1)</script>}`,
-  String.raw`\href{javascript:alert(1)}{x}`,
-  String.raw`\href{data:text/html,test}{x}`,
-  String.raw`\href{https://example.com/" onload="alert(1)}{x}`,
-  String.raw`\color{url(https://example.com/payload)}x`,
-  String.raw`\def\again{\again}\again`,
-];
-for (const source of hostile) {
-  const result = module.render(source);
-  sourceAlternative(result, source); inert(result.svg);
-  assert.deepEqual(plain(result), plain(classic.render(source)), 'module/classic hostile result');
-}
-for (const source of hostile.slice(1)) assert(module.render(source).errors.length, 'unsafe or exhausted input produces a diagnostic');
-for (const source of ['x'.repeat(1_000_001), '\ud800'.repeat(1_000_001), '&'.repeat(8_000_000)]) {
-  const result = module.render(source);
-  assert.equal(result.errors[0].code, 'resource-limit');
-  assert.equal(result.errors[0].sourceOmitted, true);
-  assert(result.svg.includes('data-math-source-omitted="true"'));
-  assert(!result.svg.includes('data-tex-utf16'), 'refused source never creates a carrier');
-  assert(result.svg.length < 100_000, 'refusal diagnostic is fixed-size');
-  assert.equal(module.renderToString(source), result.svg);
-  assert.deepEqual(plain(result), plain(classic.render(source)), 'module/classic refusal result');
-  inert(result.svg);
-}
-const longCommand = '\\' + 'a'.repeat(10_000), diagnostic = module.render(longCommand);
-assert(diagnostic.errors[0].messageTruncated && diagnostic.errors[0].commandTruncated);
-sourceAlternative(diagnostic, longCommand);
-assert(diagnostic.errors[0].message.length <= 1025 && diagnostic.errors[0].command.length <= 128);
-const unicodeFailure = module.render('\\begin{' + '😀'.repeat(600) + '}x');
-assert(unicodeFailure.errors[0].message.isWellFormed(), 'diagnostic admission cannot split a source surrogate pair');
-assert.equal(module.render('x+1').errors.length, 0, 'refused input cannot poison later rendering');
-console.log(JSON.stringify({name: pkg.name, version: module.version, module: 'native ESM; no global changes',
-  rebuild: 'exact module', classicAgreement: examples.length + hostile.length, sourceAlternatives: 'exact', hostileContent: 'inert', licenses: 'complete'}));

package/src/math/package-verify.mjs

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Verify a standalone package and rebuild its payload from the carried source.
-import assert from 'node:assert/strict';
-import {readFile} from 'node:fs/promises';
-import {createHash} from 'node:crypto';
-import {dirname, resolve} from 'node:path';
-import {fileURLToPath} from 'node:url';
-
-const root = dirname(fileURLToPath(import.meta.url));
-const source = resolve(root, 'src');
-const read = path => readFile(resolve(root, path));
-const hash = (bytes, algorithm = 'sha256', encoding = 'hex') => createHash(algorithm).update(bytes).digest(encoding);
-const resources = JSON.parse(await read('src/shell/math-resources.json'));
-const payload = await read(resources.bundle);
-assert.equal(payload.length, resources.bytes, 'payload length');
-assert.equal(hash(payload), resources.sha256, 'payload SHA-256');
-assert.equal(hash(payload, 'sha384', 'base64'), resources.sha384, 'payload SHA-384');
-for (const input of [...resources.sources, ...resources.recipe, ...resources.adoption]) {
-  const bytes = await read('src/' + input.file);
-  assert.equal(bytes.length, input.bytes, input.file + ': length');
-  assert.equal(hash(bytes), input.sha256, input.file + ': SHA-256');
-  if (input.packageFile) assert.deepEqual(await read(input.packageFile), bytes, input.packageFile + ': exact adoption source');
-}
-const rendererLicense = await read('src/math/LICENSE-MIT');
-for (const file of ['LICENSE-MIT', 'math-LICENSE.txt']) assert.deepEqual(await read(file), rendererLicense, file);
-const fontLicense = await read('src/' + resources.font.licenseFile);
-assert.equal(hash(fontLicense), resources.font.licenseSha256, 'font license SHA-256');
-assert.deepEqual(await read('math-font-LICENSE.txt'), fontLicense, 'font license bytes');
-assert(payload.includes(rendererLicense.toString('utf8').trim()), 'payload renderer license');
-assert(payload.includes(fontLicense.toString('utf8').trim()), 'payload font license');
-const sbom = JSON.parse(await read('math-components.json'));
-const font = sbom.packages.find(item => item.name === resources.font.name);
-assert.equal(font?.copyrightText, resources.font.copyright, 'font copyright');
-assert.equal(font.licenseDeclared, resources.font.license, 'font license identity');
-assert.equal(sbom.hasExtractedLicensingInfos.find(item => item.licenseId === resources.font.license)?.extractedText,
-  fontLicense.toString('utf8'), 'complete extracted font license');
-const {buildMath} = await import('./src/tools/build-math.mjs');
-const {mathReadme} = await import('./src/math/package-readme.mjs');
-assert.equal((await read('README.md')).toString('utf8'), mathReadme(resources), 'generated README source');
-for (const [file, owner] of [['check.mjs', 'package-check.mjs'], ['verify.mjs', 'package-verify.mjs'], ['adoption-check.mjs', 'adoption-verify.mjs']])
-  assert.deepEqual(await read(file), await read('src/math/' + owner), file + ': exact carried owner');
-await buildMath({root: source, updatePins: false});
-assert.deepEqual(await read('src/shell/vendor/' + resources.bundle), payload, 'rebuilt payload bytes');
-console.log(JSON.stringify({file: resources.bundle, bytes: payload.length, sha256: resources.sha256,
-  sources: resources.sources.length + resources.recipe.length, adoptionFiles: resources.adoption.length, rebuild: 'exact', licenses: 'complete'}));

package/src/math/rehype.d.ts

@@ -1,6 +0,0 @@
-// SPDX-License-Identifier: MIT
-import type {Root} from 'hast';
-import type {VFile} from 'vfile';
-import type {IntegrationOptions} from './integration.js';
-/** Install after sanitization. Recognizes remark-rehype math code nodes. */
-export default function rehypeRapierMath(options?: IntegrationOptions): (tree: Root, file: VFile) => void;

package/src/math/rehype.mjs

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: MIT
-import {fromHtml} from 'hast-util-from-html';
-import {createFormulaRenderer} from './integration.mjs';
-
-// Run AFTER the host sanitizer. Only known math code nodes are replaced, using
-// fresh renderer output parsed into HAST. Authored raw nodes never become HTML here.
-export default function rehypeRapierMath(options = {}) {
-  return (tree, file) => {
-    const render = createFormulaRenderer(options);
-    function math(node) {
-      const names = node?.properties?.className;
-      if (node?.type !== 'element' || node.tagName !== 'code' || !Array.isArray(names) ||
-          !names.includes('language-math') || !names.some(name => name === 'math-inline' || name === 'math-display') ||
-          !Array.isArray(node.children) || !node.children.every(child => child.type === 'text' && typeof child.value === 'string')) return null;
-      return {source: node.children.map(child => child.value).join(''), display: names.includes('math-display')};
-    }
-    function visit(parent) {
-      for (let index = 0; index < (parent.children?.length || 0); index++) {
-        const node = parent.children[index];
-        const code = node.type === 'element' && node.tagName === 'pre' && node.children?.length === 1 ? node.children[0] : node;
-        const input = math(code);
-        if (!input) { visit(node); continue; }
-        const result = render(input.source, input.display);
-        if (result.errors.length) {
-          for (const error of result.errors) {
-            const message = file?.message(error.message, {place: code.position, source: 'rapier-math', ruleId: error.code});
-            if (message) { message.mathSource = input.source; message.mathOffset = error.offset; }
-          }
-          continue;
-        }
-        const svg = fromHtml(result.svg, {fragment: true}).children[0];
-        parent.children[index] = input.display ? {type: 'element', tagName: 'div', properties: {className: ['math-display']}, children: [svg]} : svg;
-      }
-    }
-    visit(tree);
-  };
-}

package/src/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "rapier-math-source",
-  "private": true,
-  "version": "1.1.0",
-  "type": "module",
-  "scripts": {
-    "build": "node tools/build-math.mjs"
-  }
-}

package/stream.d.ts

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: MIT
-export interface MarkdownSnapshot {source: string; html: string; revision: number; final: boolean}
-export interface MarkdownStream {
-  /** null means keep the previous preview; the chunk was still accepted. */
-  write(chunk: string): MarkdownSnapshot | null;
-  finish(): MarkdownSnapshot;
-  abort(): void;
-  /** Replace a message by resetting, then writing the replacement source. */
-  reset(): number;
-  readonly revision: number;
-}
-export function createMarkdownStream(renderMarkdown: (source: string) => string, options?: {
-  maxSourceLength?: number; previewEvery?: number;
-}): MarkdownStream;

package/stream.mjs

@@ -1,46 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Full Markdown previews have no append-only promise. Geometric admission bounds
-// the total source passed to a synchronous host, including the final batch pass.
-export function createMarkdownStream(renderMarkdown, {maxSourceLength = 1_000_000, previewEvery = 256} = {}) {
-  if (typeof renderMarkdown !== 'function') throw new TypeError('Supply a synchronous Markdown renderer.');
-  for (const value of [maxSourceLength, previewEvery])
-    if (!Number.isSafeInteger(value) || value < 1) throw new RangeError('Stream limits must be positive finite integers.');
-  let chunks = [], length = 0, threshold = previewEvery, closed = false, revision = 0, rendering = false;
-  function open() {
-    if (closed || rendering) throw new Error(closed ? 'This stream is closed; reset it before writing.' : 'A stream renderer cannot reenter its stream.');
-  }
-  function snapshot(final) {
-    const source = chunks.join('');
-    chunks = source ? [source] : [];
-    // Failed previews consumed work too. Further chunks must still wait for the
-    // next geometric threshold; only an explicit finish retries immediately.
-    threshold = Math.max(previewEvery, length * 2);
-    rendering = true;
-    let html;
-    try {
-      html = renderMarkdown(source);
-      if (typeof html !== 'string') throw new TypeError('The Markdown renderer must return a string synchronously.');
-    } finally { rendering = false; }
-    if (final) { closed = true; chunks = []; length = 0; }
-    return {source, html, revision, final};
-  }
-  return {
-    write(chunk) {
-      open();
-      if (typeof chunk !== 'string') throw new TypeError('Decode transport bytes to strings before writing.');
-      if (chunk.length > maxSourceLength - length)
-        throw Object.assign(new RangeError('The message exceeds its source budget; this chunk was not accepted.'), {code: 'resource-limit'});
-      if (!chunk.length) return null;
-      chunks.push(chunk); length += chunk.length; revision++;
-      return length >= threshold ? snapshot(false) : null;
-    },
-    finish() { open(); revision++; return snapshot(true); },
-    abort() {
-      if (rendering) throw new Error('A stream renderer cannot abort its stream.');
-      if (closed) return;
-      chunks = []; length = 0; closed = true; revision++;
-    },
-    reset() { if (rendering) throw new Error('A stream renderer cannot reset its stream.'); chunks = []; length = 0; threshold = previewEvery; closed = false; return ++revision; },
-    get revision() { return revision; },
-  };
-}

package/verify.mjs

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Verify a standalone package and rebuild its payload from the carried source.
-import assert from 'node:assert/strict';
-import {readFile} from 'node:fs/promises';
-import {createHash} from 'node:crypto';
-import {dirname, resolve} from 'node:path';
-import {fileURLToPath} from 'node:url';
-
-const root = dirname(fileURLToPath(import.meta.url));
-const source = resolve(root, 'src');
-const read = path => readFile(resolve(root, path));
-const hash = (bytes, algorithm = 'sha256', encoding = 'hex') => createHash(algorithm).update(bytes).digest(encoding);
-const resources = JSON.parse(await read('src/shell/math-resources.json'));
-const payload = await read(resources.bundle);
-assert.equal(payload.length, resources.bytes, 'payload length');
-assert.equal(hash(payload), resources.sha256, 'payload SHA-256');
-assert.equal(hash(payload, 'sha384', 'base64'), resources.sha384, 'payload SHA-384');
-for (const input of [...resources.sources, ...resources.recipe, ...resources.adoption]) {
-  const bytes = await read('src/' + input.file);
-  assert.equal(bytes.length, input.bytes, input.file + ': length');
-  assert.equal(hash(bytes), input.sha256, input.file + ': SHA-256');
-  if (input.packageFile) assert.deepEqual(await read(input.packageFile), bytes, input.packageFile + ': exact adoption source');
-}
-const rendererLicense = await read('src/math/LICENSE-MIT');
-for (const file of ['LICENSE-MIT', 'math-LICENSE.txt']) assert.deepEqual(await read(file), rendererLicense, file);
-const fontLicense = await read('src/' + resources.font.licenseFile);
-assert.equal(hash(fontLicense), resources.font.licenseSha256, 'font license SHA-256');
-assert.deepEqual(await read('math-font-LICENSE.txt'), fontLicense, 'font license bytes');
-assert(payload.includes(rendererLicense.toString('utf8').trim()), 'payload renderer license');
-assert(payload.includes(fontLicense.toString('utf8').trim()), 'payload font license');
-const sbom = JSON.parse(await read('math-components.json'));
-const font = sbom.packages.find(item => item.name === resources.font.name);
-assert.equal(font?.copyrightText, resources.font.copyright, 'font copyright');
-assert.equal(font.licenseDeclared, resources.font.license, 'font license identity');
-assert.equal(sbom.hasExtractedLicensingInfos.find(item => item.licenseId === resources.font.license)?.extractedText,
-  fontLicense.toString('utf8'), 'complete extracted font license');
-const {buildMath} = await import('./src/tools/build-math.mjs');
-const {mathReadme} = await import('./src/math/package-readme.mjs');
-assert.equal((await read('README.md')).toString('utf8'), mathReadme(resources), 'generated README source');
-for (const [file, owner] of [['check.mjs', 'package-check.mjs'], ['verify.mjs', 'package-verify.mjs'], ['adoption-check.mjs', 'adoption-verify.mjs']])
-  assert.deepEqual(await read(file), await read('src/math/' + owner), file + ': exact carried owner');
-await buildMath({root: source, updatePins: false});
-assert.deepEqual(await read('src/shell/vendor/' + resources.bundle), payload, 'rebuilt payload bytes');
-console.log(JSON.stringify({file: resources.bundle, bytes: payload.length, sha256: resources.sha256,
-  sources: resources.sources.length + resources.recipe.length, adoptionFiles: resources.adoption.length, rebuild: 'exact', licenses: 'complete'}));