dsh-plugin-onenote 0.0.0-stage → 0.2.1

package/src/graph-client.js

@@ -0,0 +1,274 @@
+/**
+ * Microsoft Graph client for OneNote.
+ *
+ * Three rules keep this thin and predictable:
+ *   - every call re-resolves the access token, so a refresh reaches the next call;
+ *   - a 401 becomes one actionable sign-in message instead of a bare status;
+ *   - pagination follows `@odata.nextLink` but stops at a cap, so one huge
+ *     notebook cannot stall a turn.
+ */
+import { OneNoteAuthError, requireAccessToken } from './auth.js';
+
+const GRAPH_ORIGIN = 'https://graph.microsoft.com/v1.0';
+const REQUEST_TIMEOUT_MS = 30_000;
+const MAX_PAGES = 5;
+
+/** A Graph failure carrying the status and Graph's own error code. */
+export class GraphError extends Error {
+  constructor(message, { status, code } = {}) {
+    super(message);
+    this.name = 'GraphError';
+    this.status = status;
+    this.code = code;
+  }
+}
+
+function buildUrl(path, params) {
+  const url = new URL(`${GRAPH_ORIGIN}${path}`);
+  for (const [key, value] of Object.entries(params ?? {})) {
+    if (value === undefined || value === null || value === '') continue;
+    url.searchParams.set(key, String(value));
+  }
+  return url;
+}
+
+async function request(url, config, { accept = 'application/json', signal } = {}) {
+  const token = await requireAccessToken(config);
+  const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+  const combined = signal === undefined ? timeout : AbortSignal.any([signal, timeout]);
+
+  let response;
+  try {
+    response = await fetch(url, {
+      method: 'GET',
+      headers: { authorization: `Bearer ${token}`, accept },
+      signal: combined,
+    });
+  } catch (error) {
+    if (error instanceof OneNoteAuthError) throw error;
+    if (signal?.aborted === true) throw new GraphError('The OneNote request was cancelled.', { code: 'CANCELLED' });
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new GraphError(`Could not reach Microsoft Graph (${detail}). Check the network and try again.`, { code: 'NETWORK' });
+  }
+
+  if (response.status === 401) {
+    throw new OneNoteAuthError(
+      'Microsoft Graph rejected the OneNote token. Open Settings → Plugins → OneNote and sign in again.',
+      'SIGN_IN_REQUIRED',
+    );
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => '');
+    let code;
+    let detail = body;
+    try {
+      const parsed = JSON.parse(body);
+      code = parsed?.error?.code;
+      detail = parsed?.error?.message ?? body;
+    } catch {
+      /* a non-JSON error body is still worth showing, trimmed below */
+    }
+    // Graph's own message already ends with a period; the templates below add
+    // one, so trim it first. A doubled period ("expression..") read as a
+    // different kind of failure and hid the real cause from the user.
+    const reason = typeof detail === 'string'
+      ? detail.split('\n')[0].trim().replace(/\.+$/, '').slice(0, 400)
+      : '';
+    // A rejected OData expression is a defect in the query this plugin built,
+    // never a permission or network problem. Saying so stops the next reader
+    // from re-authenticating, which cannot help.
+    if (response.status === 400 && /Parsing OData Select and Expand/i.test(reason)) {
+      throw new GraphError(
+        `Microsoft Graph rejected the query this plugin generated: ${reason}. This is a defect in the plugin, not a permission or network problem: update the plugin, then restart DeepSeek Harness.`,
+        { status: 400, code: code ?? 'BAD_REQUEST' },
+      );
+    }
+    if (response.status === 403) {
+      throw new GraphError(
+        `Microsoft Graph denied access${reason.length > 0 ? `: ${reason}` : ''}. The signed-in account may lack permission for this notebook.`,
+        { status: 403, code: code ?? 'FORBIDDEN' },
+      );
+    }
+    if (response.status === 404) {
+      throw new GraphError('That OneNote item no longer exists. List the notebooks again to get current ids.', { status: 404, code: code ?? 'NOT_FOUND' });
+    }
+    if (response.status === 429) {
+      const retry = response.headers.get('retry-after');
+      throw new GraphError(
+        `Microsoft Graph rate-limited the request${retry === null ? '' : `; retry after ${retry}s`}. Wait and try again.`,
+        { status: 429, code: code ?? 'TOO_MANY_REQUESTS' },
+      );
+    }
+    throw new GraphError(
+      `Microsoft Graph request failed (${response.status})${reason.length > 0 ? `: ${reason}` : ''}.`,
+      { status: response.status, code: code ?? 'GRAPH_ERROR' },
+    );
+  }
+
+  if (accept === 'text/html') return response.text();
+  return response.json();
+}
+
+async function requestCollection(path, params, config, signal) {
+  const items = [];
+  let next = buildUrl(path, params);
+  for (let page = 0; page < MAX_PAGES; page += 1) {
+    const payload = await request(next, config, { signal });
+    if (Array.isArray(payload?.value)) items.push(...payload.value);
+    const nextLink = payload?.['@odata.nextLink'];
+    if (typeof nextLink !== 'string' || nextLink.length === 0) return items;
+    next = new URL(nextLink);
+  }
+  return items;
+}
+
+/**
+ * The expanded parent selectors shared by every page query.
+ *
+ * OneNote implements only a subset of OData: a nested `select` inside `$expand`
+ * is rejected with `Parsing OData Select and Expand failed`, which failed every
+ * page and section read. Expanding the navigation property bare is accepted and
+ * still returns the parent's `id` and `displayName`, which is all the consent
+ * check needs. Verified against Graph v1.0; do not reintroduce `(select=...)`.
+ */
+const PAGE_EXPAND = 'parentSection,parentNotebook';
+const PAGE_SELECT = 'id,title,createdDateTime,lastModifiedDateTime,links';
+
+function toNotebook(raw) {
+  const notebook = {
+    id: typeof raw?.id === 'string' ? raw.id : '',
+    name: typeof raw?.displayName === 'string' && raw.displayName.length > 0 ? raw.displayName : String(raw?.id ?? ''),
+    isDefault: raw?.isDefault === true,
+    isShared: raw?.isShared === true,
+  };
+  const modified = raw?.lastModifiedDateTime ?? raw?.createdDateTime;
+  if (typeof modified === 'string') notebook.lastModified = modified;
+  return notebook;
+}
+
+function toSection(raw) {
+  const section = {
+    id: typeof raw?.id === 'string' ? raw.id : '',
+    name: typeof raw?.displayName === 'string' && raw.displayName.length > 0 ? raw.displayName : String(raw?.id ?? ''),
+  };
+  if (typeof raw?.parentNotebook?.id === 'string') section.notebookId = raw.parentNotebook.id;
+  return section;
+}
+
+function toPage(raw) {
+  const page = {
+    id: typeof raw?.id === 'string' ? raw.id : '',
+    title: typeof raw?.title === 'string' && raw.title.trim().length > 0 ? raw.title.trim() : '(untitled page)',
+  };
+  if (typeof raw?.lastModifiedDateTime === 'string') page.lastModified = raw.lastModifiedDateTime;
+  if (typeof raw?.parentSection?.displayName === 'string' && raw.parentSection.displayName.length > 0) {
+    page.sectionName = raw.parentSection.displayName;
+  }
+  if (typeof raw?.parentNotebook?.displayName === 'string' && raw.parentNotebook.displayName.length > 0) {
+    page.notebookName = raw.parentNotebook.displayName;
+  }
+  if (typeof raw?.parentNotebook?.id === 'string' && raw.parentNotebook.id.length > 0) {
+    page.notebookId = raw.parentNotebook.id;
+  }
+  const webUrl = raw?.links?.oneNoteWebUrl?.href;
+  if (typeof webUrl === 'string' && webUrl.length > 0) page.webUrl = webUrl;
+  return page;
+}
+
+/** The signed-in user, used to name the account in sign-in reports. */
+export async function getMe(config, signal) {
+  const raw = await request(buildUrl('/me', { $select: 'id,displayName,userPrincipalName,mail' }), config, { signal });
+  const me = {};
+  for (const key of ['id', 'displayName', 'userPrincipalName', 'mail']) {
+    if (typeof raw?.[key] === 'string' && raw[key].length > 0) me[key] = raw[key];
+  }
+  return me;
+}
+
+/** Every notebook the account can see, including shared ones. */
+export async function listNotebooks(config, signal) {
+  const raw = await requestCollection(
+    '/me/onenote/notebooks',
+    { $select: 'id,displayName,isDefault,isShared,lastModifiedDateTime,createdDateTime', $top: 100 },
+    config,
+    signal,
+  );
+  return raw.map(toNotebook);
+}
+
+/** Sections directly inside one notebook. */
+export async function listSections(config, notebookId, signal) {
+  const raw = await requestCollection(
+    `/me/onenote/notebooks/${encodeURIComponent(notebookId)}/sections`,
+    { $select: 'id,displayName,lastModifiedDateTime', $top: 100 },
+    config,
+    signal,
+  );
+  return raw.map(toSection);
+}
+
+/**
+ * Pages inside one notebook.
+ *
+ * `$filter=parentNotebook/id eq …` is the only server-side notebook filter
+ * OneNote offers, and it needs the expanded parent in the same request, so the
+ * page projection is pinned rather than left to the service default.
+ */
+export async function listPagesInNotebook(config, notebookId, signal, limit = 200) {
+  const raw = await requestCollection(
+    '/me/onenote/pages',
+    {
+      $filter: `parentNotebook/id eq '${notebookId}'`,
+      $select: PAGE_SELECT,
+      $expand: PAGE_EXPAND,
+      $top: Math.min(100, limit),
+    },
+    config,
+    signal,
+  );
+  return raw.slice(0, limit).map(toPage);
+}
+
+/** Pages inside one section. */
+export async function listPagesInSection(config, sectionId, signal, limit = 200) {
+  const raw = await requestCollection(
+    `/me/onenote/sections/${encodeURIComponent(sectionId)}/pages`,
+    { $select: PAGE_SELECT, $expand: PAGE_EXPAND, $top: Math.min(100, limit) },
+    config,
+    signal,
+  );
+  return raw.slice(0, limit).map(toPage);
+}
+
+/** One section's metadata, including the notebook that owns it. */
+export async function getSectionMeta(config, sectionId, signal) {
+  const raw = await request(
+    buildUrl(`/me/onenote/sections/${encodeURIComponent(sectionId)}`, {
+      $select: 'id,displayName',
+      $expand: 'parentNotebook',
+    }),
+    config,
+    { signal },
+  );
+  return toSection(raw);
+}
+
+/** One page's metadata, including the notebook that owns it. */
+export async function getPageMeta(config, pageId, signal) {
+  const raw = await request(
+    buildUrl(`/me/onenote/pages/${encodeURIComponent(pageId)}`, { $select: PAGE_SELECT, $expand: PAGE_EXPAND }),
+    config,
+    { signal },
+  );
+  return toPage(raw);
+}
+
+/** One page's HTML content. */
+export async function getPageContent(config, pageId, signal) {
+  const html = await request(buildUrl(`/me/onenote/pages/${encodeURIComponent(pageId)}/content`), config, {
+    accept: 'text/html',
+    signal,
+  });
+  return typeof html === 'string' ? html : '';
+}

package/src/parser.js

@@ -0,0 +1,393 @@
+/**
+ * Convert the HTML Microsoft Graph returns for a OneNote page into compact Markdown.
+ *
+ * OneNote emits deeply nested `div`/`span` soup with `data-*` attributes. This
+ * module is a small, dependency-free tokenizer plus a block writer: it keeps the
+ * document structure a reader cares about (headings, paragraphs, lists, tables,
+ * emphasis, links, code) and drops everything else. Media is never fetched, so
+ * an image contributes only its alt text.
+ */
+
+const BLOCK_TAGS = new Set(['p', 'div', 'section', 'article', 'header', 'footer', 'main', 'body', 'html', 'li', 'tr', 'table', 'ul', 'ol', 'pre', 'blockquote']);
+const SKIP_TAGS = new Set(['script', 'style', 'head', 'title', 'meta', 'link', 'noscript']);
+/**
+ * HTML void elements: they never emit a closing tag, so opening one must never
+ * raise the skip depth. OneNote wraps every page in a `<head>` containing
+ * `<meta … />`, and treating that as an unclosed skip scope discarded the whole
+ * page body — every page rendered as empty text.
+ */
+const VOID_TAGS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+const INLINE_MARKS = {
+  strong: ['**', '**'],
+  b: ['**', '**'],
+  em: ['_', '_'],
+  i: ['_', '_'],
+  del: ['~~', '~~'],
+  s: ['~~', '~~'],
+  strike: ['~~', '~~'],
+  code: ['`', '`'],
+  u: ['', ''],
+  sub: ['', ''],
+  sup: ['', ''],
+  span: ['', ''],
+  font: ['', ''],
+  small: ['', ''],
+  mark: ['', ''],
+};
+
+const NAMED_ENTITIES = {
+  amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ',
+  ndash: '–', mdash: '—', hellip: '…', copy: '©', reg: '®', trade: '™',
+  lsquo: '‘', rsquo: '’', ldquo: '“', rdquo: '”', middot: '·', bull: '•',
+  times: '×', divide: '÷', deg: '°', plusmn: '±', frac12: '½',
+};
+
+/** Decode the character references that actually appear in OneNote content. */
+export function decodeEntities(text) {
+  if (!text.includes('&')) return text;
+  return text.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z][a-zA-Z0-9]*);/g, (match, body) => {
+    if (body.startsWith('#')) {
+      const hex = body[1] === 'x' || body[1] === 'X';
+      const code = Number.parseInt(hex ? body.slice(2) : body.slice(1), hex ? 16 : 10);
+      if (Number.isFinite(code) && code > 0 && code <= 0x10ffff) return String.fromCodePoint(code);
+      return '';
+    }
+    const named = NAMED_ENTITIES[body.toLowerCase()];
+    return named === undefined ? match : named;
+  });
+}
+
+const TAG_PATTERN = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<![^>]*>|<\s*(\/?)\s*([a-zA-Z][a-zA-Z0-9:-]*)((?:"[^"]*"|'[^']*'|[^'">])*)>/g;
+const ATTR_PATTERN = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/g;
+
+function parseAttributes(raw) {
+  const attrs = {};
+  if (!raw) return attrs;
+  ATTR_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = ATTR_PATTERN.exec(raw)) !== null) {
+    const value = match[2] ?? match[3] ?? match[4] ?? '';
+    attrs[match[1].toLowerCase()] = decodeEntities(value);
+  }
+  return attrs;
+}
+
+/** Collapse runs of whitespace the way a rendered paragraph would. */
+function collapse(text) {
+  return text.replace(/[\t\r\n ]+/g, ' ').trim();
+}
+
+/**
+ * Render one page's HTML as Markdown.
+ * @param {string} html - the page content from Graph.
+ * @param {number} maxChars - a hard ceiling on the produced text.
+ * @returns {string} Markdown text, ending with a truncation note when clipped.
+ */
+export function parseOneNoteHtml(html, maxChars = 60000) {
+  return renderPage(html, maxChars).content;
+}
+
+/**
+ * Render one page and report whether the ceiling clipped it.
+ * @param {string} html - the page content from Graph.
+ * @param {number} maxChars - a hard ceiling on the produced text.
+ * @returns {{ content: string, truncated: boolean }} Markdown plus the clip flag.
+ */
+export function renderPage(html, maxChars = 60000) {
+  if (typeof html !== 'string' || html.length === 0) return { content: '', truncated: false };
+
+  const lines = [];
+  let used = 0;
+  let truncated = false;
+  let buffer = '';
+  /** The list marker for the item being collected, kept out of the collapsed text. */
+  let pendingPrefix = '';
+  let headingLevel = 0;
+  let preDepth = 0;
+  let preBuffer = '';
+  let skipDepth = 0;
+  let table = null;
+  const frames = [];
+  const lists = [];
+
+  const emit = (line) => {
+    if (truncated) return;
+    const text = line.replace(/[ \t]+$/u, '');
+    if (text.length === 0) {
+      if (lines.length === 0 || lines[lines.length - 1] === '') return;
+      lines.push('');
+      used += 1;
+      return;
+    }
+    if (used + text.length > maxChars) {
+      const room = maxChars - used;
+      if (room > 80) lines.push(text.slice(0, room));
+      truncated = true;
+      return;
+    }
+    lines.push(text);
+    used += text.length + 1;
+  };
+
+  const flush = () => {
+    const text = collapse(buffer);
+    buffer = '';
+    if (text.length === 0) return;
+    // The list marker is kept out of `buffer` so collapsing text cannot eat its indent.
+    const prefix = pendingPrefix;
+    pendingPrefix = '';
+    if (headingLevel > 0) emit(`${'#'.repeat(headingLevel)} ${text}`);
+    else emit(prefix + text);
+  };
+
+  const listPrefix = () => {
+    const depth = Math.max(0, lists.length - 1);
+    const indent = '  '.repeat(depth);
+    const current = lists[lists.length - 1];
+    if (current === undefined) return '';
+    if (current.ordered) {
+      current.index += 1;
+      return `${indent}${current.index}. `;
+    }
+    return `${indent}- `;
+  };
+
+  const renderTable = () => {
+    if (table === null || table.rows.length === 0) {
+      table = null;
+      return;
+    }
+    const rows = table.rows;
+    const width = Math.max(...rows.map((row) => row.length));
+    const padded = rows.map((row) => [...row, ...Array(width - row.length).fill('')]);
+    const header = padded[0];
+    const body = padded.slice(1);
+    emit(`| ${header.join(' | ')} |`);
+    emit(`| ${header.map(() => '---').join(' | ')} |`);
+    for (const row of body) emit(`| ${row.join(' | ')} |`);
+    emit('');
+    table = null;
+  };
+
+  const closeFrame = (name) => {
+    for (let index = frames.length - 1; index >= 0; index -= 1) {
+      if (frames[index].name !== name) continue;
+      const frame = frames.splice(index, 1)[0];
+      const inner = buffer.slice(frame.start);
+      buffer = buffer.slice(0, frame.start) + frame.wrap(inner);
+      return;
+    }
+  };
+
+  const openInline = (name, attrs) => {
+    if (name === 'a') {
+      const href = attrs.href ?? '';
+      const start = buffer.length;
+      frames.push({
+        name,
+        start,
+        wrap: (inner) => {
+          const text = collapse(inner);
+          if (text.length === 0) return '';
+          if (href.length === 0 || href.startsWith('javascript:')) return text;
+          return `[${text}](${href})`;
+        },
+      });
+      return;
+    }
+    const mark = INLINE_MARKS[name];
+    if (mark === undefined) return;
+    if (mark[0].length === 0) {
+      frames.push({ name, start: buffer.length, wrap: (inner) => inner });
+      return;
+    }
+    const start = buffer.length;
+    frames.push({ name, start, wrap: (inner) => (collapse(inner).length === 0 ? inner : `${mark[0]}${inner}${mark[1]}`) });
+  };
+
+  const handleOpen = (name, attrs) => {
+    if (SKIP_TAGS.has(name)) {
+      // A void element inside a skipped scope (OneNote's `<meta>` inside
+      // `<head>`) has no closing tag, so it must not increment the depth.
+      if (!VOID_TAGS.has(name)) skipDepth += 1;
+      return;
+    }
+    if (skipDepth > 0) return;
+
+    if (name === 'pre') {
+      flush();
+      preDepth += 1;
+      preBuffer = '';
+      return;
+    }
+    if (preDepth > 0) return;
+
+    if (table !== null) {
+      if (name === 'tr') table.row = [];
+      else if (name === 'td' || name === 'th') table.cell = '';
+      else if (name === 'br' && table.cell !== null) table.cell += ' ';
+      return;
+    }
+
+    if (name === 'table') {
+      flush();
+      table = { rows: [], row: null, cell: null };
+      return;
+    }
+
+    if (name === 'br') {
+      flush();
+      return;
+    }
+    if (name === 'hr') {
+      flush();
+      emit('---');
+      emit('');
+      return;
+    }
+    if (name === 'img') {
+      const alt = collapse(attrs.alt ?? attrs.title ?? '');
+      if (alt.length > 0) buffer += `🖼️ ${alt} `;
+      return;
+    }
+    if (/^h[1-6]$/u.test(name)) {
+      flush();
+      headingLevel = Number(name.slice(1));
+      return;
+    }
+    if (name === 'ul' || name === 'ol') {
+      flush();
+      lists.push({ ordered: name === 'ol', index: 0 });
+      return;
+    }
+    if (name === 'li') {
+      flush();
+      pendingPrefix = listPrefix();
+      return;
+    }
+    if (BLOCK_TAGS.has(name)) {
+      flush();
+      return;
+    }
+    openInline(name, attrs);
+  };
+
+  const handleClose = (name) => {
+    if (SKIP_TAGS.has(name)) {
+      if (skipDepth > 0) skipDepth -= 1;
+      return;
+    }
+    if (skipDepth > 0) return;
+
+    if (name === 'pre') {
+      if (preDepth > 0) preDepth -= 1;
+      if (preDepth === 0) {
+        const body = preBuffer.replace(/\r\n?/gu, '\n').replace(/^\n+|\n+$/gu, '');
+        preBuffer = '';
+        if (body.length > 0) {
+          emit('```');
+          for (const line of body.split('\n').slice(0, 60)) emit(line);
+          emit('```');
+          emit('');
+        }
+      }
+      return;
+    }
+    if (preDepth > 0) return;
+
+    if (table !== null) {
+      if (name === 'td' || name === 'th') {
+        if (table.row !== null) table.row.push(collapse(table.cell ?? ''));
+        table.cell = null;
+      } else if (name === 'tr') {
+        if (table.row !== null && table.row.length > 0) table.rows.push(table.row);
+        table.row = null;
+      } else if (name === 'table') {
+        renderTable();
+      }
+      return;
+    }
+
+    if (name === 'ul' || name === 'ol') {
+      flush();
+      lists.pop();
+      emit('');
+      return;
+    }
+    if (name === 'li') {
+      flush();
+      return;
+    }
+    if (/^h[1-6]$/u.test(name)) {
+      flush();
+      headingLevel = 0;
+      emit('');
+      return;
+    }
+    if (name === 'p' || name === 'div' || name === 'blockquote' || BLOCK_TAGS.has(name)) {
+      flush();
+      return;
+    }
+    closeFrame(name);
+  };
+
+  TAG_PATTERN.lastIndex = 0;
+  let cursor = 0;
+  let match;
+  while ((match = TAG_PATTERN.exec(html)) !== null) {
+    const text = html.slice(cursor, match.index);
+    cursor = match.index + match[0].length;
+    if (text.length > 0) {
+      const decoded = decodeEntities(text);
+      if (preDepth > 0) preBuffer += decoded;
+      else if (skipDepth === 0) {
+        if (table !== null && table.cell !== null) table.cell += decoded;
+        else buffer += decoded;
+      }
+    }
+    if (match[2] === undefined) continue; // comment, doctype, or CDATA
+    const name = match[2].toLowerCase();
+    if (match[1] === '/') handleClose(name);
+    else handleOpen(name, parseAttributes(match[3]));
+  }
+  if (cursor < html.length) buffer += decodeEntities(html.slice(cursor));
+
+  flush();
+  if (table !== null) renderTable();
+
+  const content = lines
+    .join('\n')
+    .replace(/\n{3,}/gu, '\n\n')
+    .trim();
+  return { content, truncated };
+}
+
+/**
+ * Reduce HTML to one whitespace-collapsed string, for keyword scanning.
+ * @param {string} html - page HTML.
+ * @param {number} maxChars - ceiling on the returned text.
+ * @returns {string} plain text.
+ */
+export function htmlToPlainText(html, maxChars = 20000) {
+  if (typeof html !== 'string' || html.length === 0) return '';
+  let skipDepth = 0;
+  let out = '';
+  TAG_PATTERN.lastIndex = 0;
+  let cursor = 0;
+  let match;
+  while ((match = TAG_PATTERN.exec(html)) !== null && out.length < maxChars) {
+    const text = html.slice(cursor, match.index);
+    cursor = match.index + match[0].length;
+    if (text.length > 0 && skipDepth === 0) out += decodeEntities(text);
+    if (match[2] === undefined) continue;
+    const name = match[2].toLowerCase();
+    if (SKIP_TAGS.has(name)) {
+      if (match[1] === '/') skipDepth = Math.max(0, skipDepth - 1);
+      else if (!VOID_TAGS.has(name)) skipDepth += 1;
+    } else if (skipDepth === 0) {
+      out += ' ';
+    }
+  }
+  if (cursor < html.length && skipDepth === 0) out += decodeEntities(html.slice(cursor));
+  return collapse(out).slice(0, maxChars);
+}