@minjun0219/mdwire 0.1.4

package/bundler/mdwire_bg.js

@@ -0,0 +1,497 @@
+/**
+ * `renderWithReport` 의 결과.
+ */
+export class Rendered {
+    static __wrap(ptr) {
+        const obj = Object.create(Rendered.prototype);
+        obj.__wbg_ptr = ptr;
+        RenderedFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RenderedFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rendered_free(ptr, 0);
+    }
+    /**
+     * 조각들. 한도를 넘지 않았으면 하나다.
+     * @returns {string[]}
+     */
+    get parts() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendered_parts(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1);
+            wasm.__wbindgen_export3(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * 정규화가 고친 것.
+     * @returns {Repairs}
+     */
+    get repairs() {
+        const ret = wasm.rendered_repairs(this.__wbg_ptr);
+        return Repairs.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Rendered.prototype[Symbol.dispose] = Rendered.prototype.free;
+
+/**
+ * 정규화가 고친 것의 개수.
+ */
+export class Repairs {
+    static __wrap(ptr) {
+        const obj = Object.create(Repairs.prototype);
+        obj.__wbg_ptr = ptr;
+        RepairsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RepairsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_repairs_free(ptr, 0);
+    }
+    /**
+     * 블록이 끝나도록 안 닫혀서 닫아 준 강조.
+     * @returns {number}
+     */
+    get closedEmphasis() {
+        const ret = wasm.__wbg_get_repairs_closedEmphasis(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * 문서 끝까지 안 닫혀서 닫아 준 코드펜스.
+     * @returns {number}
+     */
+    get closedFence() {
+        const ret = wasm.__wbg_get_repairs_closedFence(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * 짝 잃은 채 버린 `**`.
+     * @returns {number}
+     */
+    get droppedMarker() {
+        const ret = wasm.__wbg_get_repairs_droppedMarker(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * 짝이 없어 글자로 되돌린 백틱 런.
+     * @returns {number}
+     */
+    get revertedCodeSpan() {
+        const ret = wasm.__wbg_get_repairs_revertedCodeSpan(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * 블록이 끝나도록 안 닫혀서 닫아 준 강조.
+     * @param {number} arg0
+     */
+    set closedEmphasis(arg0) {
+        wasm.__wbg_set_repairs_closedEmphasis(this.__wbg_ptr, arg0);
+    }
+    /**
+     * 문서 끝까지 안 닫혀서 닫아 준 코드펜스.
+     * @param {number} arg0
+     */
+    set closedFence(arg0) {
+        wasm.__wbg_set_repairs_closedFence(this.__wbg_ptr, arg0);
+    }
+    /**
+     * 짝 잃은 채 버린 `**`.
+     * @param {number} arg0
+     */
+    set droppedMarker(arg0) {
+        wasm.__wbg_set_repairs_droppedMarker(this.__wbg_ptr, arg0);
+    }
+    /**
+     * 짝이 없어 글자로 되돌린 백틱 런.
+     * @param {number} arg0
+     */
+    set revertedCodeSpan(arg0) {
+        wasm.__wbg_set_repairs_revertedCodeSpan(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) Repairs.prototype[Symbol.dispose] = Repairs.prototype.free;
+
+/**
+ * 스트리밍 변환기.
+ *
+ * 조각을 넣으면 지금 안전하게 내보낼 수 있는 만큼만 돌려준다. 경계에 걸린 마크업은
+ * 안에 남는다 — 토큰이 흘러들어오는 대로 화면에 붙이는 쪽이 이것 때문에 쓴다.
+ */
+export class Streamer {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StreamerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_streamer_free(ptr, 0);
+    }
+    /**
+     * **지금까지 받은 것을 그대로 보내려면 이걸 뒤에 붙인다.**
+     *
+     * 상태는 건드리지 않으므로 붙인 뒤에도 스트리밍은 이어진다. 누적본 자체에는
+     * 넣지 말고, 보내기 직전에만 붙인다. 토큰이 오는 대로 메시지를 편집하는 쪽이 쓴다.
+     *
+     * ```js
+     * acc += s.push(chunk);
+     * await edit(acc + s.closeOpen());   // 누적본은 그대로 둔다
+     * ```
+     * @returns {string}
+     */
+    closeOpen() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.streamer_closeOpen(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * 입력이 끝났다. 남은 것을 내보내고 열린 마크업을 닫는다.
+     * @returns {string}
+     */
+    finish() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.streamer_finish(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} channel
+     * @param {RenderOptions | null} [options]
+     */
+    constructor(channel, options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.streamer_new(retptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            StreamerFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {string} chunk
+     * @returns {string}
+     */
+    push(chunk) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(chunk, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.streamer_push(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred2_0 = r0;
+            deferred2_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * 지금까지 정규화가 고친 것. `finish` 뒤에 보면 문서 전체의 값이다.
+     * @returns {Repairs}
+     */
+    repairs() {
+        const ret = wasm.streamer_repairs(this.__wbg_ptr);
+        return Repairs.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Streamer.prototype[Symbol.dispose] = Streamer.prototype.free;
+
+/**
+ * 채널의 길이 한도(문자 수). 조각을 직접 다루려는 호출자를 위해 열어 둔다.
+ * @param {string} channel
+ * @returns {number}
+ */
+export function limit(channel) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.limit(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0 >>> 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * 완성된 문서를 변환한다. 한도를 넘으면 조각 배열로 돌아온다.
+ * @param {string} input
+ * @param {string} channel
+ * @param {RenderOptions | null} [options]
+ * @returns {string[]}
+ */
+export function render(input, channel, options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.render(retptr, ptr0, len0, ptr1, len1, isLikeNone(options) ? 0 : addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayJsValueFromWasm0(r0, r1);
+        wasm.__wbindgen_export3(r0, r1 * 4, 4);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * [`render`] 에 **정규화가 고친 것**을 같이 돌려준다. 모델이 얼마나 자주 서식을 깨는지
+ * 로그로 남기려는 쪽이 쓴다.
+ * @param {string} input
+ * @param {string} channel
+ * @param {RenderOptions | null} [options]
+ * @returns {Rendered}
+ */
+export function renderWithReport(input, channel, options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.renderWithReport(retptr, ptr0, len0, ptr1, len1, isLikeNone(options) ? 0 : addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return Rendered.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+export function __wbg_Error_67e7344beaa85059(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+}
+export function __wbg___wbindgen_throw_5d9e815e6fdf150f(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_from_2d32c1f12e4ec301(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 __wbindgen_generic_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+}
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+}
+const RenderedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rendered_free(ptr, 1));
+const RepairsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_repairs_free(ptr, 1));
+const StreamerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_streamer_free(ptr, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}

package/bundler/mdwire_bg.wasm.d.ts

@@ -0,0 +1,28 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_get_repairs_closedEmphasis: (a: number) => number;
+export const __wbg_get_repairs_closedFence: (a: number) => number;
+export const __wbg_get_repairs_droppedMarker: (a: number) => number;
+export const __wbg_get_repairs_revertedCodeSpan: (a: number) => number;
+export const __wbg_rendered_free: (a: number, b: number) => void;
+export const __wbg_repairs_free: (a: number, b: number) => void;
+export const __wbg_set_repairs_closedEmphasis: (a: number, b: number) => void;
+export const __wbg_set_repairs_closedFence: (a: number, b: number) => void;
+export const __wbg_set_repairs_droppedMarker: (a: number, b: number) => void;
+export const __wbg_set_repairs_revertedCodeSpan: (a: number, b: number) => void;
+export const __wbg_streamer_free: (a: number, b: number) => void;
+export const limit: (a: number, b: number, c: number) => void;
+export const render: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const renderWithReport: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const rendered_parts: (a: number, b: number) => void;
+export const rendered_repairs: (a: number) => number;
+export const streamer_closeOpen: (a: number, b: number) => void;
+export const streamer_finish: (a: number, b: number) => void;
+export const streamer_new: (a: number, b: number, c: number, d: number) => void;
+export const streamer_push: (a: number, b: number, c: number, d: number) => void;
+export const streamer_repairs: (a: number) => number;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number) => void;

package/bundler/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/node/mdwire.d.ts

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/** 변환 옵션. 생략하면 표준 마크다운 입력이다. */
+export interface RenderOptions {
+    /** 입력 표기. 슬랙 레거시 mrkdwn(`*굵게*` `~취소~`)으로 쓴 에이전트 출력이면 "slack-mrkdwn". */
+    from?: "markdown" | "slack-mrkdwn";
+}
+
+
+
+/**
+ * `renderWithReport` 의 결과.
+ */
+export class Rendered {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 조각들. 한도를 넘지 않았으면 하나다.
+     */
+    readonly parts: string[];
+    /**
+     * 정규화가 고친 것.
+     */
+    readonly repairs: Repairs;
+}
+
+/**
+ * 정규화가 고친 것의 개수.
+ */
+export class Repairs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 블록이 끝나도록 안 닫혀서 닫아 준 강조.
+     */
+    closedEmphasis: number;
+    /**
+     * 문서 끝까지 안 닫혀서 닫아 준 코드펜스.
+     */
+    closedFence: number;
+    /**
+     * 짝 잃은 채 버린 `**`.
+     */
+    droppedMarker: number;
+    /**
+     * 짝이 없어 글자로 되돌린 백틱 런.
+     */
+    revertedCodeSpan: number;
+}
+
+/**
+ * 스트리밍 변환기.
+ *
+ * 조각을 넣으면 지금 안전하게 내보낼 수 있는 만큼만 돌려준다. 경계에 걸린 마크업은
+ * 안에 남는다 — 토큰이 흘러들어오는 대로 화면에 붙이는 쪽이 이것 때문에 쓴다.
+ */
+export class Streamer {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * **지금까지 받은 것을 그대로 보내려면 이걸 뒤에 붙인다.**
+     *
+     * 상태는 건드리지 않으므로 붙인 뒤에도 스트리밍은 이어진다. 누적본 자체에는
+     * 넣지 말고, 보내기 직전에만 붙인다. 토큰이 오는 대로 메시지를 편집하는 쪽이 쓴다.
+     *
+     * ```js
+     * acc += s.push(chunk);
+     * await edit(acc + s.closeOpen());   // 누적본은 그대로 둔다
+     * ```
+     */
+    closeOpen(): string;
+    /**
+     * 입력이 끝났다. 남은 것을 내보내고 열린 마크업을 닫는다.
+     */
+    finish(): string;
+    constructor(channel: string, options?: RenderOptions | null);
+    push(chunk: string): string;
+    /**
+     * 지금까지 정규화가 고친 것. `finish` 뒤에 보면 문서 전체의 값이다.
+     */
+    repairs(): Repairs;
+}
+
+/**
+ * 채널의 길이 한도(문자 수). 조각을 직접 다루려는 호출자를 위해 열어 둔다.
+ */
+export function limit(channel: string): number;
+
+/**
+ * 완성된 문서를 변환한다. 한도를 넘으면 조각 배열로 돌아온다.
+ */
+export function render(input: string, channel: string, options?: RenderOptions | null): string[];
+
+/**
+ * [`render`] 에 **정규화가 고친 것**을 같이 돌려준다. 모델이 얼마나 자주 서식을 깨는지
+ * 로그로 남기려는 쪽이 쓴다.
+ */
+export function renderWithReport(input: string, channel: string, options?: RenderOptions | null): Rendered;