@minjun0219/mdwire 0.1.9 → 0.1.11

package/bundler/mdwire_bg.js

@@ -1,5 +1,5 @@
 /**
- * `renderWithReport` 의 결과.
+ * The result of `renderWithReport`.
  */
 export class Rendered {
     static __wrap(ptr) {
@@ -19,7 +19,7 @@ export class Rendered {
         wasm.__wbg_rendered_free(ptr, 0);
     }
     /**
-     * 조각들. 한도를 넘지 않았으면 하나다.
+     * The parts. Just one if the text fit within the limit.
      * @returns {string[]}
      */
     get parts() {
@@ -36,7 +36,7 @@ export class Rendered {
         }
     }
     /**
-     * 정규화가 고친 것.
+     * What normalization repaired.
      * @returns {Repairs}
      */
     get repairs() {
@@ -47,7 +47,7 @@ export class Rendered {
 if (Symbol.dispose) Rendered.prototype[Symbol.dispose] = Rendered.prototype.free;
 
 /**
- * 정규화가 고친 것과 채널에 맞춰 바꾼 것의 개수.
+ * Counts of what normalization repaired and what was changed to fit the channel.
  */
 export class Repairs {
     static __wrap(ptr) {
@@ -67,7 +67,7 @@ export class Repairs {
         wasm.__wbg_repairs_free(ptr, 0);
     }
     /**
-     * 블록이 끝나도록 안 닫혀서 닫아 준 강조.
+     * Emphasis left open at the end of a block, closed for you.
      * @returns {number}
      */
     get closedEmphasis() {
@@ -75,7 +75,7 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 문서 끝까지 안 닫혀서 닫아 준 코드펜스.
+     * Code fences left open at the end of the document, closed for you.
      * @returns {number}
      */
     get closedFence() {
@@ -83,7 +83,7 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 다른 표기로 바꿔 쓴 강조 마커와 `<url|텍스트>` 링크.
+     * Emphasis markers and `<url|text>` links rewritten in a different notation.
      * @returns {number}
      */
     get convertedMarker() {
@@ -91,7 +91,7 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 짝 잃은 채 버린 `**`.
+     * Unmatched `**` markers that were dropped.
      * @returns {number}
      */
     get droppedMarker() {
@@ -99,7 +99,7 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 채널이 구문으로 읽을 글자를 탈출한 수(GitHub 의 `\~`·`\<`·`\*`).
+     * Characters escaped because the channel would read them as syntax (GitHub's `\~`, `\<`, `\*`).
      * @returns {number}
      */
     get escapedChar() {
@@ -107,7 +107,7 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 짝이 없어 글자로 되돌린 백틱 런.
+     * Unmatched backtick runs, turned back into literal text.
      * @returns {number}
      */
     get revertedCodeSpan() {
@@ -115,7 +115,7 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 다른 기호로 바꿔 쓴 목록 불릿.
+     * List bullets rewritten with a different symbol.
      * @returns {number}
      */
     get rewrittenBullet() {
@@ -123,7 +123,7 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 원문과 다른 모양으로 다시 쓴 표.
+     * Tables rewritten in a different shape from the source.
      * @returns {number}
      */
     get rewrittenTable() {
@@ -131,7 +131,7 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 벗긴 원문 HTML(태그·주석·줄바꿈으로 바꾼 `<br>`).
+     * Raw HTML stripped from the source (tags, comments, and `<br>` turned into line breaks).
      * @returns {number}
      */
     get strippedHtml() {
@@ -139,7 +139,7 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 마커 대신 태그로 낸 강조(GitHub 의 `<strong>`).
+     * Emphasis emitted differently because the channel would not read the marker in that position (GitHub's `<strong>`, Slack's U+2060).
      * @returns {number}
      */
     get tagEmphasis() {
@@ -147,70 +147,70 @@ export class Repairs {
         return ret >>> 0;
     }
     /**
-     * 블록이 끝나도록 안 닫혀서 닫아 준 강조.
+     * Emphasis left open at the end of a block, closed for you.
      * @param {number} arg0
      */
     set closedEmphasis(arg0) {
         wasm.__wbg_set_repairs_closedEmphasis(this.__wbg_ptr, arg0);
     }
     /**
-     * 문서 끝까지 안 닫혀서 닫아 준 코드펜스.
+     * Code fences left open at the end of the document, closed for you.
      * @param {number} arg0
      */
     set closedFence(arg0) {
         wasm.__wbg_set_repairs_closedFence(this.__wbg_ptr, arg0);
     }
     /**
-     * 다른 표기로 바꿔 쓴 강조 마커와 `<url|텍스트>` 링크.
+     * Emphasis markers and `<url|text>` links rewritten in a different notation.
      * @param {number} arg0
      */
     set convertedMarker(arg0) {
         wasm.__wbg_set_repairs_convertedMarker(this.__wbg_ptr, arg0);
     }
     /**
-     * 짝 잃은 채 버린 `**`.
+     * Unmatched `**` markers that were dropped.
      * @param {number} arg0
      */
     set droppedMarker(arg0) {
         wasm.__wbg_set_repairs_droppedMarker(this.__wbg_ptr, arg0);
     }
     /**
-     * 채널이 구문으로 읽을 글자를 탈출한 수(GitHub 의 `\~`·`\<`·`\*`).
+     * Characters escaped because the channel would read them as syntax (GitHub's `\~`, `\<`, `\*`).
      * @param {number} arg0
      */
     set escapedChar(arg0) {
         wasm.__wbg_set_repairs_escapedChar(this.__wbg_ptr, arg0);
     }
     /**
-     * 짝이 없어 글자로 되돌린 백틱 런.
+     * Unmatched backtick runs, turned back into literal text.
      * @param {number} arg0
      */
     set revertedCodeSpan(arg0) {
         wasm.__wbg_set_repairs_revertedCodeSpan(this.__wbg_ptr, arg0);
     }
     /**
-     * 다른 기호로 바꿔 쓴 목록 불릿.
+     * List bullets rewritten with a different symbol.
      * @param {number} arg0
      */
     set rewrittenBullet(arg0) {
         wasm.__wbg_set_repairs_rewrittenBullet(this.__wbg_ptr, arg0);
     }
     /**
-     * 원문과 다른 모양으로 다시 쓴 표.
+     * Tables rewritten in a different shape from the source.
      * @param {number} arg0
      */
     set rewrittenTable(arg0) {
         wasm.__wbg_set_repairs_rewrittenTable(this.__wbg_ptr, arg0);
     }
     /**
-     * 벗긴 원문 HTML(태그·주석·줄바꿈으로 바꾼 `<br>`).
+     * Raw HTML stripped from the source (tags, comments, and `<br>` turned into line breaks).
      * @param {number} arg0
      */
     set strippedHtml(arg0) {
         wasm.__wbg_set_repairs_strippedHtml(this.__wbg_ptr, arg0);
     }
     /**
-     * 마커 대신 태그로 낸 강조(GitHub 의 `<strong>`).
+     * Emphasis emitted differently because the channel would not read the marker in that position (GitHub's `<strong>`, Slack's U+2060).
      * @param {number} arg0
      */
     set tagEmphasis(arg0) {
@@ -220,10 +220,11 @@ export class Repairs {
 if (Symbol.dispose) Repairs.prototype[Symbol.dispose] = Repairs.prototype.free;
 
 /**
- * 스트리밍 변환기.
+ * Streaming converter.
  *
- * 조각을 넣으면 지금 안전하게 내보낼 수 있는 만큼만 돌려준다. 경계에 걸린 마크업은
- * 안에 남는다 — 토큰이 흘러들어오는 대로 화면에 붙이는 쪽이 이것 때문에 쓴다.
+ * Push a chunk and it returns only what is safe to emit now. Markup cut off at the
+ * chunk boundary stays inside. This is what you want when appending tokens to the
+ * screen as they arrive.
  */
 export class Streamer {
     __destroy_into_raw() {
@@ -237,14 +238,15 @@ export class Streamer {
         wasm.__wbg_streamer_free(ptr, 0);
     }
     /**
-     * **지금까지 받은 것을 그대로 보내려면 이걸 뒤에 붙인다.**
+     * **To send what you have received so far as is, append this after it.**
      *
-     * 상태는 건드리지 않으므로 붙인 뒤에도 스트리밍은 이어진다. 누적본 자체에는
-     * 넣지 말고, 보내기 직전에만 붙인다. 토큰이 오는 대로 메시지를 편집하는 쪽이 쓴다.
+     * It does not touch the state, so streaming continues afterwards. Do not add it
+     * to the accumulated output itself; append it only right before sending. Use it
+     * when editing a message as tokens arrive.
      *
      * ```js
      * acc += s.push(chunk);
-     * await edit(acc + s.closeOpen());   // 누적본은 그대로 둔다
+     * await edit(acc + s.closeOpen());   // leave acc unchanged
      * ```
      * @returns {string}
      */
@@ -265,7 +267,7 @@ export class Streamer {
         }
     }
     /**
-     * 입력이 끝났다. 남은 것을 내보내고 열린 마크업을 닫는다.
+     * Input has ended. Emits what is left and closes open markup.
      * @returns {string}
      */
     finish() {
@@ -308,15 +310,16 @@ export class Streamer {
         }
     }
     /**
-     * **지금 입력이 끝났다면 확정분 뒤에 붙을 꼬리.** `closeOpen` 과 같은 자리에 들어가지만
-     * 붙들고 있던 것(열린 강조, 표 행, 코드 스팬)까지 그린다. 누적본을 통째로 다시 그리는 쪽의
-     * 기본값이다. 추측이라 뒤 조각이 모양을 바꿀 수 있다 — 끝난 뒤 `revised()` 로 본다.
+     * **The tail that would follow the final output if input ended now.** It goes in the
+     * same place as `closeOpen`, but also draws what is being held back (open emphasis,
+     * table rows, code spans). This is the default when you redraw the whole message.
+     * It is a guess, so later chunks may change the shape. Check `revised()` after the end.
      *
      * ```js
      * acc += s.push(chunk);
-     * await edit(acc + s.preview());      // 화면을 그릴 때만 부른다(열린 블록만큼 든다)
+     * await edit(acc + s.preview());      // call only when drawing (costs as much as the open block)
      * acc += s.finish();
-     * if (s.revised()) await edit(acc);   // 마지막 화면이 곧 완성본이면 건너뛴다
+     * if (s.revised()) await edit(acc);   // skip if the last screen already is the final output
      * ```
      * @returns {string}
      */
@@ -359,7 +362,7 @@ export class Streamer {
         }
     }
     /**
-     * 지금까지 정규화가 고친 것. `finish` 뒤에 보면 문서 전체의 값이다.
+     * What normalization has repaired so far. After `finish`, this covers the whole document.
      * @returns {Repairs}
      */
     repairs() {
@@ -367,7 +370,7 @@ export class Streamer {
         return Repairs.__wrap(ret);
     }
     /**
-     * 완성본이 마지막 `preview()` 와 다른가 — `finish` 뒤에 본다.
+     * Whether the final output differs from the last `preview()`. Check it after `finish`.
      * @returns {boolean}
      */
     revised() {
@@ -378,7 +381,7 @@ export class Streamer {
 if (Symbol.dispose) Streamer.prototype[Symbol.dispose] = Streamer.prototype.free;
 
 /**
- * 채널의 길이 한도(문자 수). 조각을 직접 다루려는 호출자를 위해 열어 둔다.
+ * The channel's length limit (in characters). Exposed for callers that handle parts themselves.
  * @param {string} channel
  * @returns {number}
  */
@@ -401,7 +404,7 @@ export function limit(channel) {
 }
 
 /**
- * 완성된 문서를 변환한다. 한도를 넘으면 조각 배열로 돌아온다.
+ * Converts a complete document. Returns an array of parts; it has more than one when the text exceeds the limit.
  * @param {string} input
  * @param {string} channel
  * @param {RenderOptions | null} [options]
@@ -431,8 +434,8 @@ export function render(input, channel, options) {
 }
 
 /**
- * [`render`] 에 **정규화가 고친 것**을 같이 돌려준다. 모델이 얼마나 자주 서식을 깨는지
- * 로그로 남기려는 쪽이 쓴다.
+ * Like [`render`], but also returns **what normalization repaired**. Use it to log
+ * how often the model breaks formatting.
  * @param {string} input
  * @param {string} channel
  * @param {RenderOptions | null} [options]
@@ -472,37 +475,30 @@ export function __wbg___wbindgen_string_get_92ab86bb19cbc12f(arg0, arg1) {
 export function __wbg___wbindgen_throw_5d9e815e6fdf150f(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_from_6a18a824ab73bfc5(arg0, arg1) {
-    const ret = getObject(arg1).from;
-    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-    var len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-}
-export function __wbg_html_a628fe022a5daeaf(arg0) {
+export function __wbg_html_89b49615556b2850(arg0) {
     const ret = getObject(arg0).html;
     return isLikeNone(ret) ? 0 : addHeapObject(ret);
 }
-export function __wbg_images_ff5cc833afad2dcf(arg0, arg1) {
+export function __wbg_images_fc88426d1f55bdfc(arg0, arg1) {
     const ret = getObject(arg1).images;
     var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
     var len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_limit_cce570f9381001ea(arg0, arg1) {
+export function __wbg_limit_d1453e73fbf788db(arg0, arg1) {
     const ret = getObject(arg1).limit;
     getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 }
-export function __wbg_lineBreaks_aa928a165d0a7659(arg0, arg1) {
+export function __wbg_lineBreaks_8b98689e9716a2c8(arg0, arg1) {
     const ret = getObject(arg1).lineBreaks;
     var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
     var len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_schemes_429ccca2fff29ed9(arg0, arg1) {
+export function __wbg_schemes_8e39175723a07726(arg0, arg1) {
     const ret = getObject(arg1).schemes;
     var ptr1 = isLikeNone(ret) ? 0 : passArrayJsValueToWasm0(ret, wasm.__wbindgen_export);
     var len1 = WASM_VECTOR_LEN;

package/js/events.d.ts

@@ -1,20 +1,20 @@
-/** mdwire html 출력에 나오는 태그. */
+/** Tags that appear in mdwire's html output. */
 export type MdTag =
   | "p" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "ul" | "ol" | "li" | "blockquote" | "pre" | "code"
   | "strong" | "em" | "del" | "a" | "table" | "thead" | "tbody" | "tr" | "th" | "td" | "hr" | "br"
   | "sub" | "sup" | "b" | "i" | "u" | "s" | "strike" | "span" | "small" | "mark" | "kbd" | "ins" | "img";
 
 /**
- * 이벤트 하나. 속성은 코어가 내는 것만 담긴다 —
- * `a` 의 `href`, `code` 의 `class`(`language-…`), `th`·`td` 의 `style`(`text-align:…`), `ol` 의 `start`.
+ * A single event. Attributes hold only what the core emits:
+ * `href` on `a`, `class` on `code` (`language-…`), `style` on `th` and `td` (`text-align:…`), `start` on `ol`.
  */
 export type MdEvent =
   | { type: "open"; tag: MdTag; attrs: Record<string, string> }
   | { type: "close"; tag: MdTag }
   | { type: "void"; tag: "br" | "hr" }
-  /** 이미지는 `html.images: "load"` 일 때만 나온다. `src`·`alt` 를 담는다. */
+  /** Images appear only with `html.images: "load"`. Holds `src` and `alt`. */
   | { type: "void"; tag: "img"; attrs: Record<string, string> }
   | { type: "text"; text: string };
 
-/** html 채널 출력(또는 스트리밍 누적본 + `closeOpen()`)을 이벤트 배열로 푼다. */
+/** Parses html channel output (or the accumulated stream output + `closeOpen()`) into an array of events. */
 export function toEvents(html: string): MdEvent[];

package/js/events.js

@@ -1,6 +1,6 @@
 // mdwire 의 html 채널 출력을 이벤트 열로 푼다.
 //
-// **mdwire 가 낸 HTML 만 읽는다.** 코어가 글자를 전부 escape 하고 태그를 고정된 집합으로만
+// **mdwire 가 낸 HTML 만 읽는다.** 코어가 글자를 전부 이스케이프하고 태그를 고정된 집합으로만
 // 내므로(SPEC 4절) 여기서 필요한 것은 작은 토크나이저 하나다. 남이 쓴 HTML 을 넣으면 모르는
 // 태그는 글자로 돌려준다 — 이 모듈은 새니타이저가 아니다. 안전 판단은 코어 한 곳에 있다.
 
@@ -18,8 +18,8 @@ const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"' };
 const decode = (s) => s.replace(/&(amp|lt|gt|quot);/g, (_, n) => ENTITIES[n]);
 
 /**
- * html 채널 출력을 이벤트 배열로 바꾼다.
- * @param {string} html `render(text, "html")` 의 결과, 또는 스트리밍 누적본 + `closeOpen()`.
+ * Converts html channel output into an array of events.
+ * @param {string} html The result of `render(text, "html")`, or the accumulated stream output + `closeOpen()`.
  * @returns {import("./events.d.ts").MdEvent[]}
  */
 export function toEvents(html) {

package/js/react.d.ts

@@ -2,35 +2,32 @@ import type { ElementType, ReactElement, ReactNode } from "react";
 import type { MdTag } from "./events.js";
 import type { RenderOptions } from "@minjun0219/mdwire";
 
-/** 태그별로 갈아 끼울 컴포넌트 — 예: `{ a: MyLink, code: CodeBlock }`. 받는 props 는 그 태그의 것이다. */
+/** Components that replace individual tags, e.g. `{ a: MyLink, code: CodeBlock }`. Each receives that tag's props. */
 export type MdComponents = Partial<Record<MdTag, ElementType>>;
 
 export interface MarkdownProps {
-  /** 에이전트가 쓴 마크다운(완성된 글). 스트리밍은 `Streamer` + `toElements` 로 — 누적본을 매번 넘기면 처음부터 다시 변환한다. */
+  /** Markdown written by the agent (complete text). For streaming, use `Streamer` + `toElements`; passing the accumulated output each time reconverts it from scratch. */
   text: string;
-  /** 입력 표기. 슬랙 레거시 mrkdwn 이면 "slack-mrkdwn". */
-  from?: "markdown" | "slack-mrkdwn";
   components?: MdComponents;
-  /** 코어에 넘길 옵션 — `html` 정책(줄바꿈·이미지·스킴)이 여기 든다. `from` 은 위 것이 이긴다. */
+  /** Options passed to the core. The `html` policy (line breaks, images, schemes) goes here. */
   options?: RenderOptions;
 }
 
-/** 마크다운을 React 요소로 그린다. innerHTML 을 쓰지 않는다. */
+/** Renders markdown as React elements. Does not use innerHTML. */
 export function Markdown(props: MarkdownProps): ReactElement;
 
 export interface MarkdownStreamOptions {
-  from?: "markdown" | "slack-mrkdwn";
   components?: MdComponents;
   options?: RenderOptions;
-  /** 붙든 것(열린 강조·표 행·코드 스팬)도 먼저 그린다. 기본 `true`. `false` 면 확정된 것만. */
+  /** Also draw what is held back (open emphasis, table rows, code spans) ahead of time. Default `true`. With `false`, only final output is shown. */
   eager?: boolean;
-  /** 끝났을 때. `revised` 는 완성본이 마지막 화면과 다른가 — 거짓이면 훅은 다시 그리지 않는다. */
+  /** Called when done. `revised` tells whether the final output differs from the last screen; if false, the hook does not redraw. */
   onSettled?: (html: string, revised: boolean) => void;
 }
 
 /**
- * 스트리밍용 훅 — 토큰마다 `push`, 끝나면 `finish`. 기본은 붙든 것도 먼저 그린다(`eager`).
- * `onSettled` 말고는 처음 한 번만 읽는다.
+ * Hook for streaming: call `push` for each token and `finish` at the end. By default it also draws what is held back (`eager`).
+ * Options other than `onSettled` are read only once, on first render.
  */
 export function useMarkdownStream(opts?: MarkdownStreamOptions): {
   elements: ReactElement;
@@ -38,6 +35,6 @@ export function useMarkdownStream(opts?: MarkdownStreamOptions): {
   finish(): void;
 };
 
-/** html 채널 출력(스트리밍이면 누적본 + `preview()` 또는 `closeOpen()`)을 React 노드로 바꾼다. */
-/** `schemes` 는 코어에 준 `options.html.schemes` 와 같게 준다. 기본 `["http", "https", "mailto"]`. */
+/** Converts html channel output (when streaming, the accumulated output + `preview()` or `closeOpen()`) into React nodes. */
+/** Pass the same `schemes` you gave the core as `options.html.schemes`. Default `["http", "https", "mailto"]`. */
 export function toElements(html: string, components?: MdComponents, schemes?: string[]): ReactNode[];

package/js/react.js

@@ -40,11 +40,11 @@ function propsOf(tag, attrs, key, schemes) {
 }
 
 /**
- * html 채널 출력을 React 노드 배열로 바꾼다. 스트리밍 누적본을 직접 다루는 쪽이 쓴다 —
- * `toElements(acc + streamer.closeOpen())`.
+ * Converts html channel output into an array of React nodes. Use it when you handle the
+ * accumulated stream output yourself: `toElements(acc + streamer.closeOpen())`.
  * @param {string} html
- * @param {Partial<Record<string, import("react").ElementType>>} [components] 태그별로 갈아 끼울 컴포넌트.
- * @param {string[]} [schemes] 링크·이미지로 받는 스킴. 코어에 준 `options.html.schemes` 와 같게.
+ * @param {Partial<Record<string, import("react").ElementType>>} [components] Components that replace individual tags.
+ * @param {string[]} [schemes] Schemes allowed for links and images. Same as the `options.html.schemes` given to the core.
  */
 export function toElements(html, components = {}, schemes = DEFAULT_SCHEMES) {
   const root = { tag: null, children: [] };
@@ -84,36 +84,41 @@ export function toElements(html, components = {}, schemes = DEFAULT_SCHEMES) {
 }
 
 /**
- * 에이전트 마크다운을 그린다 — 완성된 글용. 스트리밍 중인 누적본을 토큰마다 넘기면 매번
- * 처음부터 다시 변환해 전체 비용이 제곱으로 늘고, 반쪽 마커(`**굵`, 여는 백틱, `##`)가 잠깐 글자로
- * 보였다가 사라진다. 스트리밍은 [`useMarkdownStream`].
+ * Renders agent markdown, for complete text. If you pass the accumulated stream on every token,
+ * it reconverts from scratch each time, so total cost grows quadratically, and half-written markers
+ * (`**bo`, an opening backtick, `##`) briefly show up as text and then vanish. For streaming, use [`useMarkdownStream`].
  * @param {import("./react.d.ts").MarkdownProps} props
  */
-export function Markdown({ text, from, components, options }) {
-  const opts = { ...options, ...(from ? { from } : {}) };
-  const html = render(text, "html", opts).join("");
-  return createElement(Fragment, null, ...toElements(html, components, opts.html?.schemes ?? DEFAULT_SCHEMES));
+export function Markdown({ text, components, options }) {
+  const html = render(text, "html", options).join("");
+  return createElement(Fragment, null, ...toElements(html, components, options?.html?.schemes ?? DEFAULT_SCHEMES));
 }
 
 /**
- * 스트리밍용 훅. 토큰이 오는 대로 `push(chunk)`, 끝나면 `finish()`.
+ * Hook for streaming. Call `push(chunk)` as tokens arrive and `finish()` at the end.
  *
- * 기본(`eager: true`)은 **붙든 것도 먼저 그린다** — 열린 강조는 닫아서, 표는 지금까지 온 행으로,
- * 코드 스팬은 닫아서(`Streamer.preview()`). 추측이라 뒤 토큰이 모양을 바꿀 수 있지만 완성본은
- * 일괄 변환과 같다. `eager: false` 면 확정된 것만 보인다(append-only, SPEC 8.2) — 짝이 안 맞은
- * 강조·판정 전 접두사는 확정될 때 나온다.
+ * By default (`eager: true`) it **also draws what is held back**: open emphasis closed, tables with
+ * the rows received so far, code spans closed (`Streamer.preview()`). This is a guess, so later tokens
+ * may change the shape, but the final output matches a one-shot conversion. With `eager: false`, only
+ * final output is shown (append-only, SPEC 8.2): unmatched emphasis and prefixes not yet decided
+ * appear once they become final.
  *
- * 끝나면 `onSettled(html, revised)` — `revised` 는 완성본이 마지막으로 **화면에 그려진** 것과
- * 다른가다. 같으면 훅은 다시 그리지 않는다.
+ * At the end it calls `onSettled(html, revised)`. `revised` tells whether the final output differs
+ * from what was last **drawn on screen**. If they match, the hook does not redraw.
  * @param {import("./react.d.ts").MarkdownStreamOptions} [opts]
  */
-export function useMarkdownStream({ from, components, options, eager = true, onSettled } = {}) {
+export function useMarkdownStream({ components, options, eager = true, onSettled } = {}) {
   const ref = useRef(null);
   const init = useRef(null);
   const [, rerender] = useReducer((n) => n + 1, 0);
   if (init.current === null) {
-    const o = { ...options, ...(from ? { from } : {}) };
-    init.current = () => ({ streamer: new Streamer("html", o), acc: "", done: false, eager, schemes: o.html?.schemes ?? DEFAULT_SCHEMES });
+    init.current = () => ({
+      streamer: new Streamer("html", options),
+      acc: "",
+      done: false,
+      eager,
+      schemes: options?.html?.schemes ?? DEFAULT_SCHEMES,
+    });
   }
   // 해제됐으면 다시 만든다 — StrictMode 개발 모드는 이펙트를 붙였다 떼었다 다시 붙여서, 정리
   // 함수가 스트리머를 먼저 해제한다(토큰이 오기 전이라 잃는 것은 없다).