@pierre/words 0.0.0-stage → 0.1.1

package/LICENSE.md

@@ -0,0 +1,189 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction, and
+    distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by the
+    copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all other
+    entities that control, are controlled by, or are under common control with
+    that entity. For the purposes of this definition, "control" means (i) the
+    power, direct or indirect, to cause the direction or management of such
+    entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+    (50%) or more of the outstanding shares, or (iii) beneficial ownership of
+    such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity exercising
+    permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation source, and
+    configuration files.
+
+    "Object" form shall mean any form resulting from mechanical transformation
+    or translation of a Source form, including but not limited to compiled
+    object code, generated documentation, and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or Object form,
+    made available under the License, as indicated by a copyright notice that is
+    included in or attached to the work (an example is provided in the Appendix
+    below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object form,
+    that is based on (or derived from) the Work and for which the editorial
+    revisions, annotations, elaborations, or other modifications represent, as a
+    whole, an original work of authorship. For the purposes of this License,
+    Derivative Works shall not include works that remain separable from, or
+    merely link (or bind by name) to the interfaces of, the Work and Derivative
+    Works thereof.
+
+    "Contribution" shall mean any work of authorship, including the original
+    version of the Work and any modifications or additions to that Work or
+    Derivative Works thereof, that is intentionally submitted to Licensor for
+    inclusion in the Work by the copyright owner or by an individual or Legal
+    Entity authorized to submit on behalf of the copyright owner. For the
+    purposes of this definition, "submitted" means any form of electronic,
+    verbal, or written communication sent to the Licensor or its
+    representatives, including but not limited to communication on electronic
+    mailing lists, source code control systems, and issue tracking systems that
+    are managed by, or on behalf of, the Licensor for the purpose of discussing
+    and improving the Work, but excluding communication that is conspicuously
+    marked or otherwise designated in writing by the copyright owner as "Not a
+    Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity on
+    behalf of whom a Contribution has been received by Licensor and subsequently
+    incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of this
+    License, each Contributor hereby grants to You a perpetual, worldwide,
+    non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+    reproduce, prepare Derivative Works of, publicly display, publicly perform,
+    sublicense, and distribute the Work and such Derivative Works in Source or
+    Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of this
+    License, each Contributor hereby grants to You a perpetual, worldwide,
+    non-exclusive, no-charge, royalty-free, irrevocable (except as stated in
+    this section) patent license to make, have made, use, offer to sell, sell,
+    import, and otherwise transfer the Work, where such license applies only to
+    those patent claims licensable by such Contributor that are necessarily
+    infringed by their Contribution(s) alone or by combination of their
+    Contribution(s) with the Work to which such Contribution(s) was submitted.
+    If You institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+    Contribution incorporated within the Work constitutes direct or contributory
+    patent infringement, then any patent licenses granted to You under this
+    License for that Work shall terminate as of the date such litigation is
+    filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the Work or
+    Derivative Works thereof in any medium, with or without modifications, and
+    in Source or Object form, provided that You meet the following conditions:
+
+    (a) You must give any other recipients of the Work or Derivative Works a
+    copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices stating
+    that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works that You
+    distribute, all copyright, patent, trademark, and attribution notices from
+    the Source form of the Work, excluding those notices that do not pertain to
+    any part of the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its distribution,
+    then any Derivative Works that You distribute must include a readable copy
+    of the attribution notices contained within such NOTICE file, excluding
+    those notices that do not pertain to any part of the Derivative Works, in at
+    least one of the following places: within a NOTICE text file distributed as
+    part of the Derivative Works; within the Source form or documentation, if
+    provided along with the Derivative Works; or, within a display generated by
+    the Derivative Works, if and wherever such third-party notices normally
+    appear. The contents of the NOTICE file are for informational purposes only
+    and do not modify the License. You may add Your own attribution notices
+    within Derivative Works that You distribute, alongside or as an addendum to
+    the NOTICE text from the Work, provided that such additional attribution
+    notices cannot be construed as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and may
+    provide additional or different license terms and conditions for use,
+    reproduction, or distribution of Your modifications, or for any such
+    Derivative Works as a whole, provided Your use, reproduction, and
+    distribution of the Work otherwise complies with the conditions stated in
+    this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise, any
+    Contribution intentionally submitted for inclusion in the Work by You to the
+    Licensor shall be under the terms and conditions of this License, without
+    any additional terms or conditions. Notwithstanding the above, nothing
+    herein shall supersede or modify the terms of any separate license agreement
+    you may have executed with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade names,
+    trademarks, service marks, or product names of the Licensor, except as
+    required for reasonable and customary use in describing the origin of the
+    Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or agreed to in
+    writing, Licensor provides the Work (and each Contributor provides its
+    Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied, including, without limitation, any
+    warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or
+    FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining
+    the appropriateness of using or redistributing the Work and assume any risks
+    associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory, whether in
+    tort (including negligence), contract, or otherwise, unless required by
+    applicable law (such as deliberate and grossly negligent acts) or agreed to
+    in writing, shall any Contributor be liable to You for damages, including
+    any direct, indirect, special, incidental, or consequential damages of any
+    character arising as a result of this License or out of the use or inability
+    to use the Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all other
+    commercial damages or losses), even if such Contributor has been advised of
+    the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing the Work or
+    Derivative Works thereof, You may choose to offer, and charge a fee for,
+    acceptance of support, warranty, indemnity, or other liability obligations
+    and/or rights consistent with this License. However, in accepting such
+    obligations, You may act only on Your own behalf and on Your sole
+    responsibility, not on behalf of any other Contributor, and only if You
+    agree to indemnify, defend, and hold each Contributor harmless for any
+    liability incurred by, or claims asserted against, such Contributor by
+    reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2025 Pierre Computer Company
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/NOTICE.md

@@ -0,0 +1,25 @@
+# Third-party notices
+
+`@pierre/words` is licensed under Apache 2.0. The material below keeps its
+original license.
+
+## Data in the published package
+
+| Data                            | Location                           | Source                                                                         | License                                                   |
+| ------------------------------- | ---------------------------------- | ------------------------------------------------------------------------------ | --------------------------------------------------------- |
+| HTML named character references | `src/entities.txt`, `dist/md.wasm` | [WHATWG HTML `entities.json`](https://html.spec.whatwg.org/entities.json)      | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) |
+| East Asian Width ranges         | `scripts/build.ts`, `dist/md.wasm` | [Unicode `EastAsianWidth.txt`](https://www.unicode.org/Public/UCD/latest/ucd/) | [Unicode License v3](https://www.unicode.org/license.txt) |
+
+## Test and benchmark files, not published
+
+| File                             | Source                                                                                                                          | License                                                         |
+| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
+| `test/spec/commonmark-spec.json` | [CommonMark Spec 0.31.2](https://spec.commonmark.org/0.31.2/) by John MacFarlane                                                | [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+| `test/spec/gfm-spec.json`        | [GitHub Flavored Markdown Spec 0.29](https://github.com/github/cmark-gfm/blob/0.29.0.gfm.13/test/spec.txt), based on CommonMark | [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+| `benchmark/fixtures/gfm-spec.md` | The same GitHub Flavored Markdown Spec, without its front matter                                                                | [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |
+| `benchmark/fixtures/simd.md`     | [WebAssembly SIMD proposal](https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md)                             | See below                                                       |
+
+The
+[WebAssembly SIMD repository notice](https://github.com/WebAssembly/simd/blob/master/LICENSE)
+lists a license for each of its top-level directories, and it does not list
+`proposals/`. `simd.md` is used only as benchmark input.

package/README.md

@@ -1,3 +1,157 @@
-# Temporary Holding Version
+# Words, from Pierre
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@pierre/words` is a Markdown renderer written in WebAssembly Text (WAT). It
+supports CommonMark 0.31.2 and GFM 0.29, and writes HTML or ANSI. The core has
+no runtime dependencies. A React component for streaming text and a code
+highlighting plugin are optional.
+
+Try the [demo](https://diffs.com/words).
+
+## Installation
+
+```bash
+pnpm add @pierre/words
+```
+
+The package runs in Node.js, browsers, and Cloudflare Workers.
+
+## Quick start
+
+```js
+import { renderToAnsi, renderToHtml } from '@pierre/words';
+
+const html = new TextDecoder().decode(renderToHtml('# Hello, **world**!'));
+process.stdout.write(renderToAnsi('# Hello, **world**!', { width: 80 }));
+```
+
+Both functions take a string, `Uint8Array`, or `ArrayBuffer`. They return a
+`Uint8Array` that shares Wasm memory, so decode or copy it before the next
+render.
+
+`renderToHtml()` options:
+
+| Option        | Default | Purpose                                                                                |
+| ------------- | ------- | -------------------------------------------------------------------------------------- |
+| `frontmatter` | `false` | Parse YAML frontmatter and return `[meta, output]`. `meta` is `null` if there is none. |
+| `skipHtml`    | `false` | Omit raw HTML.                                                                         |
+| `incomplete`  | `false` | Complete common unfinished inline syntax.                                              |
+
+`renderToAnsi()` takes `width`, the wrap column. With the default, `0`, the
+terminal wraps the text. Control characters print as U+FFFD, so a document
+cannot send escape sequences.
+
+**Warning:** `renderToHtml()` keeps raw HTML by default. Sanitize the output of
+untrusted Markdown before you add it to a page. `skipHtml` alone is not a
+sanitizer.
+
+## React
+
+```tsx
+import { Markdown } from '@pierre/words/react';
+import '@pierre/words/styles.css';
+
+<Markdown isAnimating={status === 'streaming'} caret="block">
+  {message.text}
+</Markdown>;
+```
+
+Pass the full Markdown string on each update, and keep `isAnimating` true for as
+long as text arrives. While it is true, the component completes unfinished
+emphasis, code, and links, and hides unfinished images. Finished text renders as
+normal Markdown.
+
+| Prop                                    | Purpose                                                                                       |
+| --------------------------------------- | --------------------------------------------------------------------------------------------- |
+| `children`                              | Full Markdown string.                                                                         |
+| `isAnimating`                           | The stream is active. Default: `false`.                                                       |
+| `mode`                                  | `streaming` (default), or `static` for content that never streams.                            |
+| `parseIncompleteMarkdown`               | Complete unfinished syntax while the stream is active. Default: `true`.                       |
+| `animated`                              | Fade in new text. Use `true` or `{ animation: 'fadeIn', duration: 180 }`. Default: `false`.   |
+| `caret`                                 | Show a `block` or `circle` caret while the stream is active.                                  |
+| `components`                            | HTML hooks for generated elements, including `inlineCode`.                                    |
+| `plugins.code`                          | Code highlighter.                                                                             |
+| `plugins.renderers`                     | Custom code block renderers, selected by language.                                            |
+| `controls`                              | Code copy/download buttons. Use a boolean or `{ code: { copy, download } }`. Default: `true`. |
+| `lineNumbers`                           | Show code line numbers. Default: `true`.                                                      |
+| `allowedElements`, `disallowedElements` | Element filters. Use only one of these props.                                                 |
+| `unwrapDisallowed`                      | Keep the children of filtered elements.                                                       |
+| `urlTransform`                          | Change link and image URLs before validation.                                                 |
+| `idPrefix`                              | Prefix for generated ids. Default: a unique React id.                                         |
+| `onAnimationStart`, `onAnimationEnd`    | Called when the stream starts and ends.                                                       |
+
+Fades and the caret need `styles.css`. Fades run only during a stream. Reduced
+motion and a zero duration turn them off.
+
+Hooks take and return HTML strings, not React elements:
+
+```tsx
+const components = {
+  a: (html: string) => html.replace('<a ', '<a class="message-link" '),
+};
+
+<Markdown components={components}>{text}</Markdown>;
+```
+
+The component omits raw HTML and rejects unsafe URL schemes. It allows external
+images, so use `urlTransform` or element filters to block them. Hooks and
+plugins are trusted code: escape any untrusted text they add.
+
+Math, Mermaid, CJK extensions, and remark or rehype plugins are not supported.
+
+### Syntax highlighting
+
+```tsx
+import { createHighlightsPlugin } from '@pierre/words/highlights';
+import pierreLight from '@pierre/highlights/themes/pierre-light';
+
+const plugins = { code: createHighlightsPlugin({ theme: pierreLight }) };
+
+<Markdown plugins={plugins}>{text}</Markdown>;
+```
+
+Create the plugin once, outside the render. Unknown languages render as plain
+text. React and `@pierre/highlights` are optional peer dependencies, and the
+core entry point loads neither.
+
+## HTML sessions
+
+A session renders a growing string to HTML, without React or a browser:
+
+```ts
+import { createHtmlSession } from '@pierre/words';
+
+const session = createHtmlSession();
+const { html, stable, pending } = session.render('First paragraph.\n\nSecond');
+session.render('First paragraph.\n\nSecond paragraph.');
+```
+
+`stable` holds completed blocks, `pending` holds the part that can still change,
+and `html` holds both. Sessions omit raw HTML.
+
+Pass `{ incomplete: true }` as the second argument to complete unfinished
+syntax. A link with no destination yet renders as
+`<a data-markdown-incomplete>`. A session always renders an open code fence as
+`<pre data-markdown-incomplete>`.
+
+Appended text reuses completed blocks. An edit, a changed `incomplete` option,
+or a link or footnote definition can force a full render. A long open paragraph
+is parsed again on each update.
+
+`@pierre/words/html` exports `createHtmlRenderer()` for formatted HTML and
+`createDomRenderer()` for DOM updates without React. See
+[`html/types.ts`](./html/types.ts) for their options.
+
+## Development
+
+```bash
+moonx words:build
+moonx words:test
+moonx words:test-spec
+moonx words:bench --ignore-ci-checks
+```
+
+[Benchmarks](./benchmark/README.md) · [Architecture](./ARCHITECTURE.md)
+
+## License
+
+[Apache-2.0](./LICENSE.md)

package/dist/core.d.ts

@@ -0,0 +1,41 @@
+import { AnsiOptions, Frontmatter, HtmlSessionOptions, HtmlUpdate, RenderOptions } from "./types.js";
+//#region lib/core.d.ts
+type Input = string | Uint8Array | ArrayBuffer;
+/** `boundary` makes Wasm measure the session's safe boundary in UTF-16 units. */
+type Options = AnsiOptions & RenderOptions & {
+  boundary?: boolean;
+};
+declare class Renderer {
+  memory: WebAssembly.Memory;
+  wasmRender: () => void;
+  buffer: Uint8Array<ArrayBuffer>;
+  dv: DataView<ArrayBuffer>;
+  pages: number;
+  constructor(wasmModule: WebAssembly.Module);
+  render(input: Input, mode: number, options?: Options): {
+    output: Uint8Array;
+    meta?: Uint8Array;
+  };
+  grow(len: number): void;
+  bindMemory(): void;
+}
+declare function init(wasmModule: WebAssembly.Module): Renderer;
+declare function renderToHtml(input: Input): Uint8Array;
+declare function renderToHtml<T = Frontmatter>(input: Input, options: RenderOptions & {
+  frontmatter: true;
+}): [T | null, Uint8Array];
+declare function renderToHtml(input: Input, options?: RenderOptions & {
+  frontmatter?: false;
+}): Uint8Array;
+declare function renderToHtml<T = Frontmatter>(input: Input, options: RenderOptions): Uint8Array | [T | null, Uint8Array];
+declare function renderToAnsi(input: Input, options?: AnsiOptions): Uint8Array;
+/**
+ * Render a growing string to HTML. A session keeps completed HTML and reparses
+ * only the unfinished end.
+ */
+declare function createHtmlSession(): {
+  render(input: string, options?: HtmlSessionOptions): HtmlUpdate;
+};
+//#endregion
+export { type AnsiOptions, type Frontmatter, type HtmlSessionOptions, type HtmlUpdate, type RenderOptions, createHtmlSession, init, renderToAnsi, renderToHtml };
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","names":[],"sources":["../lib/core.ts"],"mappings":";;KAgBK,iBAAiB,aAAa;;KAE9B,UAAU,cAAc;EAAkB;;cAUzC;EACJ,QAAQ,YAAY;EACpB;EACA,QAAS,WAAW;EACpB,IAAK,SAAS;EACd;EAEA,YAAY,YAAY,YAAY;EAYpC,OACE,OAAO,OACP,cACA,UAAU;IACP,QAAQ;IAAY,OAAO;;EA8DhC,KAAK;EAQL;;iBAac,KAAK,YAAY,YAAY,SAAS;iBAItC,aAAa,OAAO,QAAQ;iBAC5B,aAAa,IAAI,aAC/B,OAAO,OACP,SAAS;EAAkB;KACzB,UAAU;iBACE,aACd,OAAO,OACP,UAAU;EAAkB;IAC3B;iBACa,aAAa,IAAI,aAC/B,OAAO,OACP,SAAS,gBACR,cAAc,UAAU;iBAUX,aAAa,OAAO,OAAO,UAAU,cAAc;;;;;iBAQnD;EACd,OAAO,eAAe,UAAU,qBAAqB"}

package/dist/core.js

@@ -0,0 +1,147 @@
+//#region lib/core.ts
+const enc = new TextEncoder();
+const dec = new TextDecoder("utf-8", { ignoreBOM: true });
+const pageSize = 65536;
+const maxInput = 2 ** 30 - 2 * pageSize;
+var Renderer = class {
+	memory;
+	wasmRender;
+	buffer;
+	dv;
+	pages;
+	constructor(wasmModule) {
+		const instance = new WebAssembly.Instance(wasmModule, {});
+		this.memory = instance.exports.memory;
+		this.wasmRender = instance.exports.render;
+		instance.exports.seed(Math.random() * 2 ** 32 >>> 0);
+		this.bindMemory();
+	}
+	render(input, mode, options) {
+		if (typeof input !== "string" && !(input instanceof Uint8Array) && !(input instanceof ArrayBuffer)) throw new TypeError("input must be a string, Uint8Array, or ArrayBuffer");
+		let inputLength;
+		if (typeof input === "string") {
+			this.grow(Math.min(input.length * 3, maxInput + 1) + 8192);
+			const { read, written } = enc.encodeInto(input, this.buffer.subarray(pageSize, pageSize + maxInput + 1));
+			if (read < input.length || written > maxInput) throw tooLarge();
+			inputLength = written;
+		} else {
+			if (input instanceof ArrayBuffer) input = new Uint8Array(input);
+			if (input.length > maxInput) throw tooLarge();
+			if (input.buffer === this.memory.buffer) input = input.slice();
+			this.grow(input.length + 8192);
+			this.buffer.set(input, pageSize);
+			inputLength = input.length;
+		}
+		this.dv.setUint8(0, mode);
+		this.dv.setUint8(1, (options?.frontmatter === true ? 1 : 0) | (options?.skipHtml === true ? 2 : 0) | (options?.boundary === true ? 8 : 0) | (mode === 1 && typeof input !== "string" ? 32 : 0) | (options?.incomplete === true ? 64 : 0));
+		this.dv.setUint32(2, inputLength, true);
+		this.dv.setUint32(22, options?.width != null && options.width > 0 ? Math.min(options.width, 4096) : 0, true);
+		this.buffer.fill(0, pageSize + inputLength, pageSize + inputLength + 32);
+		try {
+			this.wasmRender();
+		} finally {
+			this.bindMemory();
+		}
+		const outStart = this.dv.getUint32(6, true);
+		const outLength = this.dv.getUint32(10, true);
+		const metaStart = this.dv.getUint32(14, true);
+		const metaLength = this.dv.getUint32(18, true);
+		const ret = { output: this.buffer.subarray(outStart, outStart + outLength) };
+		if (metaStart !== 0) ret.meta = this.buffer.subarray(metaStart, metaStart + metaLength);
+		return ret;
+	}
+	grow(len) {
+		const needed = 1 + Math.ceil(len / pageSize);
+		if (needed > this.pages) {
+			this.memory.grow(needed - this.pages);
+			this.bindMemory();
+		}
+	}
+	bindMemory() {
+		if (this.buffer?.buffer === this.memory.buffer) return;
+		this.pages = this.memory.buffer.byteLength / pageSize;
+		this.buffer = new Uint8Array(this.memory.buffer);
+		this.dv = new DataView(this.memory.buffer);
+	}
+};
+let shared;
+const tooLarge = () => /* @__PURE__ */ new RangeError(`input exceeds ${maxInput} bytes of UTF-8`);
+function init(wasmModule) {
+	return shared = new Renderer(wasmModule);
+}
+function renderToHtml(input, options) {
+	const { output, meta } = shared.render(input, 0, options);
+	if (options?.frontmatter !== true) return output;
+	return [meta != null ? JSON.parse(dec.decode(meta)) : null, output];
+}
+function renderToAnsi(input, options) {
+	return shared.render(input, 1, { width: options?.width }).output;
+}
+/**
+* Render a growing string to HTML. A session keeps completed HTML and reparses
+* only the unfinished end.
+*/
+function createHtmlSession() {
+	let previous = "";
+	let stable = "";
+	let offset = 0;
+	let definitions = false;
+	let incomplete;
+	let result;
+	let revision = 0;
+	return { render(input, options) {
+		if (typeof input !== "string") throw new TypeError("session input must be a string");
+		const wanted = options?.incomplete === true;
+		if (input === previous && incomplete === wanted && result != null) return result;
+		let reset = input.length < previous.length || input.slice(0, previous.length) !== previous || incomplete !== wanted || definitions;
+		if (offset !== 0 && input.charCodeAt(offset) === 65279) reset = true;
+		let nextStable = reset ? "" : stable;
+		let nextOffset = reset ? 0 : offset;
+		const renderOptions = {
+			skipHtml: true,
+			incomplete: wanted,
+			boundary: true
+		};
+		let tail = input.slice(nextOffset);
+		let rendered = shared.render(tail, 0, renderOptions);
+		if (nextOffset !== 0 && shared.dv.getUint8(30) !== 0) {
+			nextStable = "";
+			nextOffset = 0;
+			reset = true;
+			tail = input;
+			rendered = shared.render(tail, 0, renderOptions);
+		}
+		const html = dec.decode(rendered.output);
+		definitions = shared.dv.getUint8(30) !== 0;
+		const completed = definitions ? 0 : shared.dv.getUint32(36, true);
+		let pending = html;
+		let addition = "";
+		if (completed > 0 && completed <= tail.length) {
+			addition = html.slice(0, shared.dv.getUint32(40, true));
+			nextStable += addition;
+			nextOffset += completed;
+			pending = html.slice(addition.length);
+		}
+		stable = nextStable;
+		offset = nextOffset;
+		previous = input;
+		incomplete = wanted;
+		const completedHtml = stable;
+		let fullHtml;
+		result = {
+			get html() {
+				return fullHtml ??= completedHtml + pending;
+			},
+			stable: completedHtml,
+			addition,
+			pending,
+			reset,
+			revision: ++revision
+		};
+		return result;
+	} };
+}
+//#endregion
+export { createHtmlSession, init, renderToAnsi, renderToHtml };
+
+//# sourceMappingURL=core.js.map

package/dist/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","names":[],"sources":["../lib/core.ts"],"sourcesContent":["import type {\n  AnsiOptions,\n  Frontmatter,\n  HtmlSessionOptions,\n  HtmlUpdate,\n  RenderOptions,\n} from './types';\n\nexport type {\n  AnsiOptions,\n  Frontmatter,\n  HtmlSessionOptions,\n  HtmlUpdate,\n  RenderOptions,\n} from './types';\n\ntype Input = string | Uint8Array | ArrayBuffer;\n/** `boundary` makes Wasm measure the session's safe boundary in UTF-16 units. */\ntype Options = AnsiOptions & RenderOptions & { boundary?: boolean };\n\nconst enc = new TextEncoder();\n// Keep a leading U+FEFF so string lengths match the UTF-16 counts from Wasm.\nconst dec = new TextDecoder('utf-8', { ignoreBOM: true });\nconst pageSize = 65536;\n// Line records keep 30-bit end addresses and the input starts after the first\n// 64 KiB page. Another 64 KiB stays free for the closers completion appends.\nconst maxInput = 2 ** 30 - 2 * pageSize;\n\nclass Renderer {\n  memory: WebAssembly.Memory;\n  wasmRender: () => void;\n  buffer!: Uint8Array<ArrayBuffer>;\n  dv!: DataView<ArrayBuffer>;\n  pages!: number;\n\n  constructor(wasmModule: WebAssembly.Module) {\n    const instance = new WebAssembly.Instance(wasmModule, {});\n    this.memory = instance.exports.memory as WebAssembly.Memory;\n    this.wasmRender = instance.exports.render as () => void;\n    // A random label hash seed, so crafted reference labels cannot share a\n    // slot. Math.random suffices and avoids ~2 MiB of webcrypto setup in Node.\n    (instance.exports.seed as (seed: number) => void)(\n      (Math.random() * 2 ** 32) >>> 0\n    );\n    this.bindMemory();\n  }\n\n  render(\n    input: Input,\n    mode: number,\n    options?: Options\n  ): { output: Uint8Array; meta?: Uint8Array } {\n    if (\n      typeof input !== 'string' &&\n      !(input instanceof Uint8Array) &&\n      !(input instanceof ArrayBuffer)\n    ) {\n      throw new TypeError('input must be a string, Uint8Array, or ArrayBuffer');\n    }\n    let inputLength;\n    if (typeof input === 'string') {\n      this.grow(Math.min(input.length * 3, maxInput + 1) + 8192);\n      const { read, written } = enc.encodeInto(\n        input,\n        this.buffer.subarray(pageSize, pageSize + maxInput + 1)\n      );\n      if (read < input.length || written > maxInput) throw tooLarge();\n      inputLength = written;\n    } else {\n      if (input instanceof ArrayBuffer) input = new Uint8Array(input);\n      if (input.length > maxInput) throw tooLarge();\n      // growing detaches the old buffer, so copy an aliasing input first\n      if (input.buffer === this.memory.buffer) input = input.slice();\n      this.grow(input.length + 8192);\n      this.buffer.set(input, pageSize);\n      inputLength = input.length;\n    }\n    this.dv.setUint8(0, mode);\n    this.dv.setUint8(\n      1,\n      (options?.frontmatter === true ? 1 : 0) |\n        (options?.skipHtml === true ? 2 : 0) |\n        (options?.boundary === true ? 8 : 0) |\n        (mode === 1 && typeof input !== 'string' ? 32 : 0) |\n        (options?.incomplete === true ? 64 : 0)\n    );\n    this.dv.setUint32(2, inputLength, true);\n    this.dv.setUint32(\n      22,\n      options?.width != null && options.width > 0\n        ? Math.min(options.width, 4096)\n        : 0,\n      true\n    );\n    // the NUL sentinel and the slack the SIMD scans read into\n    this.buffer.fill(0, pageSize + inputLength, pageSize + inputLength + 32);\n    try {\n      this.wasmRender();\n    } finally {\n      this.bindMemory();\n    }\n    const outStart = this.dv.getUint32(6, true);\n    const outLength = this.dv.getUint32(10, true);\n    const metaStart = this.dv.getUint32(14, true);\n    const metaLength = this.dv.getUint32(18, true);\n    const ret: { output: Uint8Array; meta?: Uint8Array } = {\n      output: this.buffer.subarray(outStart, outStart + outLength),\n    };\n    if (metaStart !== 0)\n      ret.meta = this.buffer.subarray(metaStart, metaStart + metaLength);\n    return ret;\n  }\n\n  grow(len: number) {\n    const needed = 1 + Math.ceil(len / pageSize);\n    if (needed > this.pages) {\n      this.memory.grow(needed - this.pages);\n      this.bindMemory();\n    }\n  }\n\n  bindMemory() {\n    if (this.buffer?.buffer === this.memory.buffer) return;\n    this.pages = this.memory.buffer.byteLength / pageSize;\n    this.buffer = new Uint8Array(this.memory.buffer);\n    this.dv = new DataView(this.memory.buffer);\n  }\n}\n\nlet shared: Renderer;\n\nconst tooLarge = () =>\n  new RangeError(`input exceeds ${maxInput} bytes of UTF-8`);\n\nexport function init(wasmModule: WebAssembly.Module): Renderer {\n  return (shared = new Renderer(wasmModule));\n}\n\nexport function renderToHtml(input: Input): Uint8Array;\nexport function renderToHtml<T = Frontmatter>(\n  input: Input,\n  options: RenderOptions & { frontmatter: true }\n): [T | null, Uint8Array];\nexport function renderToHtml(\n  input: Input,\n  options?: RenderOptions & { frontmatter?: false }\n): Uint8Array;\nexport function renderToHtml<T = Frontmatter>(\n  input: Input,\n  options: RenderOptions\n): Uint8Array | [T | null, Uint8Array];\nexport function renderToHtml(\n  input: Input,\n  options?: RenderOptions\n): Uint8Array | [unknown, Uint8Array] {\n  const { output, meta } = shared.render(input, 0, options);\n  if (options?.frontmatter !== true) return output;\n  return [meta != null ? JSON.parse(dec.decode(meta)) : null, output];\n}\n\nexport function renderToAnsi(input: Input, options?: AnsiOptions): Uint8Array {\n  return shared.render(input, 1, { width: options?.width }).output;\n}\n\n/**\n * Render a growing string to HTML. A session keeps completed HTML and reparses\n * only the unfinished end.\n */\nexport function createHtmlSession(): {\n  render(input: string, options?: HtmlSessionOptions): HtmlUpdate;\n} {\n  let previous = '';\n  let stable = '';\n  let offset = 0;\n  let definitions = false;\n  let incomplete: boolean | undefined;\n  let result: HtmlUpdate | undefined;\n  let revision = 0;\n  return {\n    render(input, options) {\n      if (typeof input !== 'string')\n        throw new TypeError('session input must be a string');\n      // A missing option and `false` are the same mode.\n      const wanted = options?.incomplete === true;\n      if (input === previous && incomplete === wanted && result != null)\n        return result;\n      // V8 compares slices with memcmp, but its startsWith reads each character.\n      let reset =\n        input.length < previous.length ||\n        input.slice(0, previous.length) !== previous ||\n        incomplete !== wanted ||\n        definitions;\n      if (offset !== 0 && input.charCodeAt(offset) === 0xfeff) reset = true;\n      // A render can throw, so session state changes only after it succeeds.\n      let nextStable = reset ? '' : stable;\n      let nextOffset = reset ? 0 : offset;\n      const renderOptions = {\n        skipHtml: true,\n        incomplete: wanted,\n        boundary: true,\n      };\n      let tail = input.slice(nextOffset);\n      let rendered = shared.render(tail, 0, renderOptions);\n      if (nextOffset !== 0 && shared.dv.getUint8(30) !== 0) {\n        nextStable = '';\n        nextOffset = 0;\n        reset = true;\n        tail = input;\n        rendered = shared.render(tail, 0, renderOptions);\n      }\n      const html = dec.decode(rendered.output);\n      definitions = shared.dv.getUint8(30) !== 0;\n      // Wasm measures the source and HTML before the boundary in UTF-16 units.\n      const completed = definitions ? 0 : shared.dv.getUint32(36, true);\n      let pending = html;\n      let addition = '';\n      if (completed > 0 && completed <= tail.length) {\n        addition = html.slice(0, shared.dv.getUint32(40, true));\n        nextStable += addition;\n        nextOffset += completed;\n        pending = html.slice(addition.length);\n      }\n      stable = nextStable;\n      offset = nextOffset;\n      previous = input;\n      incomplete = wanted;\n      const completedHtml = stable;\n      let fullHtml: string | undefined;\n      result = {\n        // The DOM renderer reads only `addition` and `pending`, so build this on demand.\n        get html() {\n          return (fullHtml ??= completedHtml + pending);\n        },\n        stable: completedHtml,\n        addition,\n        pending,\n        reset,\n        revision: ++revision,\n      };\n      return result;\n    },\n  };\n}\n"],"mappings":"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"}