@floegence/floe-webapp-core 0.86.47 → 0.86.48

package/dist/components/chat/markdown/incremental.d.ts

@@ -0,0 +1,43 @@
+import type { Links, Marked, Token, TokensList } from 'marked';
+export type MarkdownBlock = Readonly<{
+    id: number;
+    start: number;
+    token: Token;
+}>;
+export type MarkdownBlockChange = Readonly<{
+    kind: 'replace';
+    block: MarkdownBlock;
+}> | Readonly<{
+    kind: 'remove';
+    id: number;
+}> | Readonly<{
+    kind: 'append_text';
+    id: number;
+    text: string;
+    code: boolean;
+    inlineIndex?: number;
+}> | Readonly<{
+    kind: 'inline';
+    id: number;
+    from: number;
+    deleteCount: number;
+    tokens: readonly Token[];
+}>;
+export type MarkdownUpdate = Readonly<{
+    changes: readonly MarkdownBlockChange[];
+    links: Links;
+    sourceLength: number;
+}>;
+/** One append-only source, Marked semantics, and explicit changed blocks. */
+export declare function createIncrementalMarkdownParser(markdown: Marked<string, string>): {
+    append: (delta: string) => MarkdownUpdate;
+    reset: (text?: string) => MarkdownUpdate;
+    finish: () => MarkdownUpdate;
+    snapshot: () => TokensList;
+    readonly sourceLength: number;
+    diagnostics: () => {
+        fullParses: number;
+        parsedCharacters: number;
+        blocks: number;
+    };
+};

package/dist/components/chat/markdown/incremental.js

@@ -0,0 +1,245 @@
+function V(O) {
+  let L = 0, b = [], C = 0, I = !1, l = [], d = /* @__PURE__ */ Object.create(null), y = /* @__PURE__ */ Object.create(null), D = 1, o = 0, g, v, M = !1, S = 0, W = 0;
+  const x = /* @__PURE__ */ new Map();
+  function R(e) {
+    let t = 0, n = b.length;
+    for (; t < n; ) {
+      const s = t + n >>> 1;
+      b[s].start <= e ? t = s + 1 : n = s;
+    }
+    const r = Math.max(0, t - 1);
+    return b.slice(r).map((s, a) => a === 0 ? s.text.slice(e - s.start) : s.text).join("");
+  }
+  function F(e, t) {
+    W += e.length;
+    const n = new O.Lexer({ ...O.defaults });
+    return n.tokens.links = { ...t }, n.lex(e);
+  }
+  function m(e) {
+    return { changes: e, links: d, sourceLength: C };
+  }
+  function $(e) {
+    return { id: e.id, start: e.start, token: structuredClone(e.token) };
+  }
+  function U(e) {
+    for (const t of e.token.raw.matchAll(/\[((?:\\[^\n]|[^\]\n\\])+)\]/g)) {
+      const n = t[1].toLowerCase().replace(/\s+/g, " ");
+      e.references.add(n);
+      let r = x.get(n);
+      r || x.set(n, r = /* @__PURE__ */ new Set()), r.add(e);
+    }
+  }
+  function q(e) {
+    for (const t of e.references) {
+      const n = x.get(t);
+      n?.delete(e), n?.size || x.delete(t);
+    }
+  }
+  function E(e, t) {
+    for (const n of e)
+      if (n === `
+`) {
+        if (t.candidate && t.count >= t.minimum) return !0;
+        t.count = 0, t.indent = 0, t.candidate = !0;
+      } else t.candidate && (n === t.mark && t.indent <= 3 ? t.count++ : n === " " && t.count === 0 && t.indent < 3 ? t.indent++ : (n !== " " && n !== "	" || t.count === 0) && (t.candidate = !1));
+    return t.candidate && t.count >= t.minimum;
+  }
+  function z(e, t = 0) {
+    const n = e.tokens;
+    let r = -1;
+    for (let f = t; f < n.length; f++) {
+      const u = n[f];
+      if (u.type === "text" && /[\\\x60*_[<~]/u.test(u.raw)) {
+        r = f;
+        break;
+      }
+    }
+    let s = r >= 0 ? r : Math.max(t, n.length - 1);
+    s > t && n[s]?.type === "text" && !/\s/u.test(n[s].raw) && n[s - 1]?.type === "link" && s--;
+    const a = n[s];
+    if (r < 0 && a?.type === "text" && a.raw === a.text) {
+      const f = a.raw.lastIndexOf(" ");
+      if (f > 0) {
+        const u = a;
+        n.splice(
+          s,
+          1,
+          { ...u, raw: u.raw.slice(0, f), text: u.text.slice(0, f) },
+          { ...u, raw: u.raw.slice(f), text: u.text.slice(f) }
+        ), s++;
+      }
+    }
+    const p = n.slice(s).map((f) => f.raw).join("");
+    v = {
+      from: s,
+      source: p,
+      unresolved: r >= 0,
+      lastChar: p.slice(-1)
+    };
+  }
+  function B() {
+    g = void 0, v = void 0, M = !1;
+    const e = l.at(-1)?.token;
+    if (e?.type === "paragraph") {
+      z(e);
+      const a = e.raw.lastIndexOf(`
+`) + 1, p = e.raw.slice(a, a + 32);
+      M = !e.raw.endsWith(`
+`) && !/^(?: {0,3}(?:[-+*_]+|[0-9]{1,9}[.)]?)[ \t]*$| {0,3}[[<\x60~#|=])/u.test(p);
+    }
+    if (e?.type !== "code") return;
+    const t = /^(\x60{3,}|~{3,})[^\n]*\n/.exec(e.raw);
+    if (!t) return;
+    const n = t[1], r = e.raw.slice(t[0].length), s = {
+      mark: n[0],
+      minimum: n.length,
+      count: 0,
+      indent: 0,
+      candidate: !0,
+      pendingNewline: r.endsWith(`
+`)
+    };
+    E(r, s) || (g = s);
+  }
+  function _(e = !1) {
+    const t = l[o]?.start ?? 0, n = l.splice(o);
+    for (const i of n) q(i);
+    const r = F(R(t), y), s = d;
+    d = Object.freeze(
+      Object.fromEntries(
+        Object.entries(r.links).map(([i, c]) => [i, Object.freeze({ ...c })])
+      )
+    );
+    const a = [];
+    let p = t;
+    for (let i = 0; i < r.length; i++) {
+      const c = r[i], h = n[i], k = {
+        id: h?.start === p ? h.id : D++,
+        start: p,
+        token: c,
+        references: /* @__PURE__ */ new Set()
+      };
+      l.push(k), U(k), i === r.length - 1 && c.type === "paragraph" && z(c), (!e || !h || JSON.stringify(h.token) !== JSON.stringify(c)) && a.push({ kind: "replace", block: $(k) }), p += c.raw.length;
+    }
+    const f = new Set(l.slice(o).map((i) => i.id));
+    for (const i of n)
+      f.has(i.id) || a.push({ kind: "remove", id: i.id });
+    const u = /* @__PURE__ */ new Set();
+    for (const i of /* @__PURE__ */ new Set([...Object.keys(s), ...Object.keys(d)]))
+      if (!(s[i]?.href === d[i]?.href && s[i]?.title === d[i]?.title))
+        for (const c of x.get(i) ?? [])
+          c.start < t && u.add(c);
+    for (const i of u) {
+      const c = F(i.token.raw, d);
+      c.length === 1 && (i.token = c[0], a.push({ kind: "replace", block: $(i) }));
+    }
+    const N = o;
+    o = Math.max(0, l.length - 1), l[o]?.token.type === "space" ? o = Math.max(0, o - 1) : o > 0 && !l[o - 1].token.raw.endsWith(`
+
+`) && (l[o - 1]?.token.type !== "space" ? o-- : /\n[ \t]*\n/u.test(l[o - 1].token.raw) || (o = Math.max(0, o - 2)));
+    const w = l.at(-1)?.token;
+    o > 1 && l[o - 1]?.token.type === "space" && l[o - 2]?.token.type === "list" && (w?.type === "list" || w?.type === "paragraph" && /^ {0,3}(?:[0-9]{1,9}[.)]?|[-+*])[ \t]*$/u.test(w.raw)) && (o -= 2);
+    for (let i = N; i < o; i++) {
+      const c = l[i].token;
+      c.type === "def" && !y[c.tag] && (y[c.tag] = { href: c.href, title: c.title });
+    }
+    return B(), m(a);
+  }
+  function J(e) {
+    const t = I && e.startsWith(`
+`);
+    return I = e.endsWith("\r"), (t ? e.slice(1) : e).replace(/\r\n?/g, `
+`);
+  }
+  function G(e) {
+    if (!e) return m([]);
+    if (C += e.length, e = J(e), !e) return m([]);
+    b.push({ start: L, text: e }), L += e.length;
+    const t = l.at(-1), n = t?.token;
+    if (t && o === l.length - 1 && n?.type === "code" && g && !e.includes("\r") && !E(e, g)) {
+      const s = (g.pendingNewline ? `
+` : "") + (e.endsWith(`
+`) ? e.slice(0, -1) : e);
+      return g.pendingNewline = e.endsWith(`
+`), n.raw += e, n.text += s, m(s ? [{ kind: "append_text", id: t.id, text: s, code: !0 }] : []);
+    }
+    const r = n?.type === "paragraph" ? n : void 0;
+    if (t && o === l.length - 1 && r && v && M && !/[\n\r]/u.test(e)) {
+      const s = v, a = r.tokens.at(-1), p = a?.type === "text" && s.from === r.tokens.length - 1 && !/[\\\x60*_[\]<>~&:/.@;|="'()-]/u.test(e) && !/[\\\x60*_[\]<>~&:/.@;|="'()-]$/u.test(s.lastChar);
+      if (r.raw += e, r.text += e, p) {
+        const c = a, h = s.unresolved ? -1 : e.lastIndexOf(" "), k = h > 0 ? e.slice(0, h) : h === 0 ? "" : e, T = [], A = r.tokens.length - 1;
+        if (k && (c.raw += k, c.text += k, T.push({
+          kind: "append_text",
+          id: t.id,
+          text: k,
+          code: !1,
+          inlineIndex: A
+        })), h >= 0) {
+          const j = e.slice(h), P = { type: "text", raw: j, text: j };
+          r.tokens.push(P), T.push({
+            kind: "inline",
+            id: t.id,
+            from: A + 1,
+            deleteCount: 0,
+            tokens: [structuredClone(P)]
+          }), v = {
+            from: A + 1,
+            source: j,
+            unresolved: !1,
+            lastChar: j.slice(-1)
+          };
+        } else
+          s.source += e, s.lastChar = e.slice(-1);
+        return m(T);
+      }
+      const f = new O.Lexer({ ...O.defaults });
+      f.tokens.links = d;
+      const u = s.source + e;
+      W += u.length;
+      const N = f.inlineTokens(u), w = r.tokens.length - s.from;
+      r.tokens.splice(s.from, w, ...N), z(r, s.from);
+      const i = r.tokens.slice(s.from);
+      return m([
+        {
+          kind: "inline",
+          id: t.id,
+          from: s.from,
+          deleteCount: w,
+          tokens: structuredClone(i)
+        }
+      ]);
+    }
+    return _();
+  }
+  function H(e = "") {
+    const t = l.map((s) => ({
+      kind: "remove",
+      id: s.id
+    }));
+    C = e.length, I = !1;
+    const n = J(e);
+    L = n.length, b = n ? [{ start: 0, text: n }] : [], l = [], d = /* @__PURE__ */ Object.create(null), y = /* @__PURE__ */ Object.create(null), x.clear(), o = 0, g = void 0, S++;
+    const r = _();
+    return { ...r, changes: [...t, ...r.changes] };
+  }
+  function K() {
+    const e = l.map((t) => structuredClone(t.token));
+    return e.links = { ...d }, e;
+  }
+  function Q() {
+    return S++, o = 0, y = /* @__PURE__ */ Object.create(null), _(!0);
+  }
+  return {
+    append: G,
+    reset: H,
+    finish: Q,
+    snapshot: K,
+    get sourceLength() {
+      return C;
+    },
+    diagnostics: () => ({ fullParses: S, parsedCharacters: W, blocks: l.length })
+  };
+}
+export {
+  V as createIncrementalMarkdownParser
+};

package/dist/markdown.d.ts

@@ -1 +1,3 @@
 export { createMarkdownParser } from './components/chat/markdown/parser';
+export { createIncrementalMarkdownParser } from './components/chat/markdown/incremental';
+export type { MarkdownBlock, MarkdownBlockChange, MarkdownUpdate, } from './components/chat/markdown/incremental';

package/dist/markdown.js

@@ -1,4 +1,6 @@
 import { createMarkdownParser as a } from "./components/chat/markdown/parser.js";
+import { createIncrementalMarkdownParser as t } from "./components/chat/markdown/incremental.js";
 export {
+  t as createIncrementalMarkdownParser,
   a as createMarkdownParser
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/floe-webapp-core",
-  "version": "0.86.47",
+  "version": "0.86.48",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",