brookmd 0.22.0

package/dist/vue.js

@@ -0,0 +1,79 @@
+import { defineComponent, h, onMounted, onUnmounted, ref, shallowRef, watch } from "vue";
+import { BrookClient } from "./client.js";
+import {
+  mountBrookMarkdown,
+  tailOpenBlockId
+} from "./dom.js";
+function useBrookMarkdown(getOpts) {
+  const container = ref(null);
+  let handle = null;
+  function mount() {
+    if (!container.value) return;
+    const { client, ...mountOptions } = getOpts();
+    handle = mountBrookMarkdown(client, container.value, mountOptions);
+  }
+  function teardown() {
+    handle?.destroy();
+    handle = null;
+  }
+  onMounted(mount);
+  watch(
+    [
+      () => getOpts().client,
+      () => getOpts().components,
+      () => getOpts().sanitize,
+      () => getOpts().virtualize,
+      () => getOpts().stickToBottom
+    ],
+    () => {
+      teardown();
+      mount();
+    }
+  );
+  onUnmounted(teardown);
+  return { container };
+}
+function useTailBlockId(client) {
+  const tail = shallowRef(tailOpenBlockId(client.getSnapshot()));
+  const unsubscribe = client.subscribe(() => {
+    tail.value = tailOpenBlockId(client.getSnapshot());
+  });
+  onUnmounted(unsubscribe);
+  return tail;
+}
+const BrookMarkdown = defineComponent({
+  name: "BrookMarkdown",
+  props: {
+    client: { type: Object, required: true },
+    components: { type: Object, default: void 0 },
+    sanitize: { type: Function, default: void 0 },
+    virtualize: { type: Boolean, default: void 0 },
+    stickToBottom: { type: Boolean, default: void 0 }
+  },
+  setup(props) {
+    const { container } = useBrookMarkdown(() => ({
+      client: props.client,
+      components: props.components,
+      sanitize: props.sanitize,
+      virtualize: props.virtualize,
+      stickToBottom: props.stickToBottom
+    }));
+    return () => h("div", { ref: container });
+  }
+});
+function useBrookMarkdownString(getContent, getOptions) {
+  const client = new BrookClient({ config: getOptions?.()?.config });
+  const apply = () => {
+    client.setContent(getContent(), { done: getOptions?.()?.streaming === false });
+  };
+  onMounted(apply);
+  watch([getContent, () => getOptions?.()?.streaming], apply);
+  onUnmounted(() => client.destroy());
+  return client;
+}
+export {
+  BrookMarkdown,
+  useBrookMarkdown,
+  useBrookMarkdownString,
+  useTailBlockId
+};

package/dist/wasm/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 siinghd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/wasm/README.md

@@ -0,0 +1,71 @@
+# brookmd-core
+
+An incremental, streaming-aware CommonMark + GFM parser core. It is the Rust
+engine behind the [`brookmd`](https://www.npmjs.com/package/brookmd) npm package,
+exposed here as a standalone crate for native Rust consumers.
+
+Feed the document in chunks as they arrive. Each `append` returns a `Patch`
+describing which blocks just became permanent ("committed") and which are still
+being built ("active"). Committed blocks never change again; active blocks may
+flicker as more input arrives. Every block carries a stable, monotonic ID so a UI
+layer can reconcile in place. Block scanning, inline tokenizing, and safe HTML
+rendering are all in-house — there are no other parser dependencies.
+
+## Example
+
+```rust
+use brook_md_core::StreamParser;
+
+fn main() {
+    let mut parser = StreamParser::new();
+
+    // Feed the document in arbitrary chunks, as they arrive off the wire.
+    for chunk in ["# Hello\n\nStreaming ", "markdown ", "core."] {
+        let patch = parser.append(chunk);
+        // `newly_committed` blocks are final; `active` blocks may still change.
+        for block in patch.newly_committed {
+            println!("committed #{}: {}", block.id, block.html);
+        }
+    }
+
+    // Flush any block still open at end of input.
+    let patch = parser.finalize();
+    for block in patch.newly_committed {
+        println!("committed #{}: {}", block.id, block.html);
+    }
+}
+```
+
+Optional extensions (GFM autolinks, alerts, footnotes, math, and more) are
+enabled per parser through builder methods, e.g.
+`StreamParser::new().with_gfm_autolinks(true)`.
+
+## Feature flags
+
+- `wasm` (default) — compiles the wasm-bindgen `BrookParser` glue used by the
+  `brookmd` JS package.
+- `perf_counters` — deterministic work counters used by the complexity-scaling
+  tests. Off by default.
+
+Native Rust consumers who only need the `StreamParser` API can skip wasm-bindgen
+entirely:
+
+```toml
+[dependencies]
+brookmd-core = { version = "0.20", default-features = false }
+```
+
+## Wire format
+
+Blocks and patches serialize to a stable, language-agnostic JSON wire format —
+see [WIRE.md](WIRE.md) (wire contract v1.1.0). Native consumers can produce the
+same bytes as the WASM/JS boundary via `wire::patch_to_json` / `wire::blocks_to_json`.
+
+## Links
+
+- npm package: <https://www.npmjs.com/package/brookmd>
+- Repository: <https://github.com/siinghd/brookmd>
+
+## License
+
+MIT

package/dist/wasm/brook_md_core.d.ts

@@ -0,0 +1,166 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class BrookParser {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * All blocks currently parsed (committed + active), in document order — the
+     * whole rendered document as a **JSON string** of a `Block[]` (parse with
+     * `JSON.parse`). The one-shot / server-side render primitive: feed the full
+     * markdown via `append`, call `finalize`, then read `allBlocks()` (no worker,
+     * no patch accumulation).
+     */
+    allBlocks(): string;
+    /**
+     * Returns the patch as a **JSON string** (parsed with `JSON.parse` on the
+     * main thread), not a live JS object. This is deliberate: serializing once to
+     * a string in Rust avoids serde-wasm-bindgen's per-node boundary calls, and a
+     * string is far cheaper than an object graph to `structuredClone` across the
+     * worker→main `postMessage` (the worker forwards the string verbatim).
+     */
+    append(chunk: string): string;
+    bufferLen(): number;
+    /**
+     * JSON-string patch — see [`BrookParser::append`].
+     */
+    finalize(): string;
+    constructor();
+    /**
+     * Total bytes the parser is retaining: source buffer + all rendered
+     * HTML for committed and active blocks. Use to compare per-parser
+     * memory cost against alternatives.
+     */
+    retainedBytes(): number;
+    /**
+     * Opt-in accessibility markup that deviates from strict GFM byte-output:
+     * `<label>`-wrap a task-list checkbox with its text, and add `scope="col"`
+     * to table header cells. Off by default (conformance output unchanged).
+     */
+    setA11y(on: boolean): void;
+    /**
+     * Opt-in structured `kind.data` channel for Table blocks: a Table then
+     * carries `{ headers, rows, aligns }` (per-cell `{ text, html }`) so a
+     * consumer can build a sort/filter/transpose/chart/CSV toolbar from DATA
+     * without re-parsing the HTML. Off by default — when off, Table serializes
+     * as `{"type":"Table"}` (no `data` key) and output is byte-identical.
+     */
+    setBlockData(on: boolean): void;
+    /**
+     * Set the opt-in component-tag allowlist (e.g. `["Thinking", "Callout"]`).
+     * A `<Tag>…</Tag>` whose name is listed renders as a component whose inner
+     * content is markdown — safely, without unsafe HTML (the tag is allowlisted
+     * and its attributes are sanitized). Empty by default (feature off).
+     */
+    setComponentTags(tags: string[]): void;
+    /**
+     * Emit `dir="auto"` on block-level text elements so the browser detects
+     * each block's direction (LTR/RTL) independently — correct rendering for
+     * documents that mix English with Arabic/Hebrew. Off by default; code
+     * blocks never get it (code is always LTR).
+     */
+    setDirAuto(on: boolean): void;
+    /**
+     * Enable GitHub alerts (`> [!NOTE]` blockquotes render as styled callouts
+     * with GitHub-compatible class names). Off by default.
+     */
+    setGfmAlerts(on: boolean): void;
+    /**
+     * Enable GFM extended autolinks (bare www./http(s)://ftp:// URLs and email
+     * addresses become links). Useful for LLM output, which is full of them.
+     */
+    setGfmAutolinks(on: boolean): void;
+    /**
+     * Enable GFM footnotes (`[^1]` references + `[^1]:` definitions → a
+     * footnote section emitted at finalize). Off by default.
+     */
+    setGfmFootnotes(on: boolean): void;
+    /**
+     * Enable math: `$…$` / `\(…\)` inline and `$$…$$` / `\[…\]` display math.
+     * Off by default (so `$` in prose / currency stays literal). The emitted
+     * HTML carries the LaTeX in `<span class="math math-inline">` /
+     * `<div class="math math-display">` for a KaTeX pass on the JS side.
+     */
+    setGfmMath(on: boolean): void;
+    /**
+     * Enable the GFM "Disallowed Raw HTML" extension (tagfilter): with raw
+     * HTML passing through (`setUnsafeHtml(true)`), the nine disallowed tags
+     * (`<title>`, `<script>`, `<iframe>`, …) get their leading `<` escaped so
+     * they display as text instead of taking effect. Off by default; no
+     * effect while raw HTML is escaped or sanitized (already inert).
+     */
+    setGfmTagfilter(on: boolean): void;
+    /**
+     * Engage the safe raw-HTML sanitizer. When `on`, inline raw HTML renders
+     * sanitized without full unsafe HTML: `allow` empty = allow all tags except
+     * a built-in dangerous set (`script`, `style`, `iframe`, …); `allow`
+     * non-empty = only those render (others escaped); `drop` tags are removed
+     * entirely; HTML comments are dropped; every rendered tag's attributes are
+     * sanitized. Off by default (raw-HTML handling unchanged).
+     */
+    setHtmlSanitize(on: boolean, allow: string[], drop: string[]): void;
+    /**
+     * Set the opt-in INLINE component-tag allowlist (e.g. `["tik", "cite"]`).
+     * An allowlisted inline `<tik>…</tik>` (or self-closing `<tik/>`) renders as
+     * a custom element (markdown inner, sanitized attributes) so a JSX/DOM layer
+     * can dispatch it via `components[tag]` — in paragraphs, headings, table
+     * cells, and list items. Empty by default (inline output unchanged).
+     */
+    setInlineComponentTags(tags: string[]): void;
+    /**
+     * Enable or disable raw-HTML pass-through. Default off. Do not enable
+     * when rendering untrusted input — bypasses XSS protection.
+     */
+    setUnsafeHtml(on: boolean): void;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_brookparser_free: (a: number, b: number) => void;
+    readonly brookparser_allBlocks: (a: number, b: number) => void;
+    readonly brookparser_append: (a: number, b: number, c: number, d: number) => void;
+    readonly brookparser_bufferLen: (a: number) => number;
+    readonly brookparser_finalize: (a: number, b: number) => void;
+    readonly brookparser_new: () => number;
+    readonly brookparser_retainedBytes: (a: number) => number;
+    readonly brookparser_setA11y: (a: number, b: number) => void;
+    readonly brookparser_setBlockData: (a: number, b: number) => void;
+    readonly brookparser_setComponentTags: (a: number, b: number, c: number) => void;
+    readonly brookparser_setDirAuto: (a: number, b: number) => void;
+    readonly brookparser_setGfmAlerts: (a: number, b: number) => void;
+    readonly brookparser_setGfmAutolinks: (a: number, b: number) => void;
+    readonly brookparser_setGfmFootnotes: (a: number, b: number) => void;
+    readonly brookparser_setGfmMath: (a: number, b: number) => void;
+    readonly brookparser_setGfmTagfilter: (a: number, b: number) => void;
+    readonly brookparser_setHtmlSanitize: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly brookparser_setInlineComponentTags: (a: number, b: number, c: number) => void;
+    readonly brookparser_setUnsafeHtml: (a: number, b: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;