@north-light/crouter 0.3.192 → 0.3.194

package/dist/core/human/markdown-html.js

@@ -0,0 +1,581 @@
+// Markdown → HTML for md-dialect page prose. Hand-rolled and dependency-free:
+// crtr ships no markdown-to-HTML dependency, and the only markdown machinery it
+// has (`core/termrender`) renders ANSI terminal lines through a managed Python
+// venv — the wrong thing to invoke inside a daemon HTTP handler.
+//
+// The supported subset is a deliberate CommonMark slice, pinned here because
+// page authors and page hosts both read it as the contract:
+//
+//   Blocks — ATX headings (`#`…`######`), setext headings (`===`/`---`
+//     underlines), fenced code (``` and ~~~, info string → `class="language-x"`),
+//     blockquotes, thematic breaks, bullet lists (`-`, `*`, `+`), ordered lists
+//     (`1.`, `1)`), GFM pipe tables (with `:---:` alignment), raw HTML blocks,
+//     and paragraphs. Lists nest by indentation and render tight or loose.
+//   Inline — backslash escapes, code spans, `**strong**`, `*em*`, `***both***`
+//     (and the `_` forms, intraword-safe), links, images, autolinks
+//     (`<https://…>`, `<a@b.c>`), raw inline HTML, character entities, and
+//     two-space hard breaks.
+//
+// NOT supported (authors get the literal text): reference links and
+// definitions, footnotes, indented (four-space) code blocks, task-list
+// checkboxes, strikethrough, and HTML comments as block separators.
+//
+// Raw HTML passes through verbatim. A page document is authored by the agent
+// that owns the ticket, and the html dialect is whole-document passthrough by
+// design — md prose is not a less-trusted channel than the document carrying it.
+const ENTITY = /^&(?:[a-zA-Z][a-zA-Z0-9]{1,31}|#\d{1,7}|#[xX][0-9a-fA-F]{1,6});/;
+const ASCII_PUNCTUATION = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/;
+const AUTOLINK_URI = /^<([a-zA-Z][a-zA-Z0-9+.-]{1,31}:[^<>\u0000-\u0020]*)>/;
+const AUTOLINK_EMAIL = /^<([^\s@<>]+@[^\s@<>]+\.[^\s@<>]+)>/;
+const RAW_INLINE_TAG = /^<\/?[A-Za-z][A-Za-z0-9-]*(?:\s[^<>]*?)?\/?>/;
+const HTML_COMMENT = /^<!--[\s\S]*?-->/;
+const LIST_ITEM = /^( {0,3})([-*+]|\d{1,9}[.)])( +|$)(.*)$/;
+const THEMATIC_BREAK = /^ {0,3}([-*_])(?: *\1){2,} *$/;
+/** Escape text for an HTML text node. */
+export function escapeHtmlText(raw) {
+    return raw.replace(/[&<>]/g, (character) => (character === '&' ? '&amp;' : character === '<' ? '&lt;' : '&gt;'));
+}
+/** Escape a value for a double-quoted HTML attribute. */
+export function escapeHtmlAttribute(raw) {
+    return escapeHtmlText(raw).replace(/"/g, '&quot;');
+}
+/** Render one markdown document fragment as HTML. */
+export function renderMarkdownToHtml(markdown) {
+    return renderBlocks(markdown.replace(/\r\n?/g, '\n').split('\n'), false);
+}
+// ---------------------------------------------------------------------------
+// Blocks
+// ---------------------------------------------------------------------------
+/** `unwrapParagraphs` renders a tight list item: its paragraphs emit inline
+ *  content with no `<p>` wrapper, exactly as CommonMark specifies. */
+function renderBlocks(lines, unwrapParagraphs) {
+    const blocks = [];
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line.trim() === '') {
+            index++;
+            continue;
+        }
+        const fence = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+        if (fence !== null) {
+            index = pushFencedCode(blocks, lines, index, fence[1], fence[2]);
+            continue;
+        }
+        const heading = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?[ \t]*$/.exec(line);
+        if (heading !== null) {
+            const level = heading[1].length;
+            blocks.push(`<h${level}>${renderInline((heading[2] ?? '').replace(/[ \t]+#+[ \t]*$/, ''))}</h${level}>`);
+            index++;
+            continue;
+        }
+        if (THEMATIC_BREAK.test(line)) {
+            blocks.push('<hr />');
+            index++;
+            continue;
+        }
+        if (/^ {0,3}>/.test(line)) {
+            index = pushBlockquote(blocks, lines, index);
+            continue;
+        }
+        if (LIST_ITEM.test(line) && !THEMATIC_BREAK.test(line)) {
+            index = pushList(blocks, lines, index);
+            continue;
+        }
+        if (isHtmlBlockStart(line)) {
+            index = pushHtmlBlock(blocks, lines, index);
+            continue;
+        }
+        const tableEnd = pushTable(blocks, lines, index);
+        if (tableEnd !== null) {
+            index = tableEnd;
+            continue;
+        }
+        index = pushParagraph(blocks, lines, index, unwrapParagraphs);
+    }
+    return blocks.join('\n');
+}
+function closesFence(text, opener) {
+    const trimmed = text.trim();
+    return trimmed.length >= opener.length && trimmed.split('').every((character) => character === opener[0]);
+}
+function pushFencedCode(blocks, lines, start, opener, info) {
+    let end = start + 1;
+    while (end < lines.length && !closesFence(lines[end], opener))
+        end++;
+    const body = lines.slice(start + 1, end);
+    const language = info.trim().split(/\s+/)[0] ?? '';
+    const attribute = language === '' ? '' : ` class="language-${escapeHtmlAttribute(language)}"`;
+    blocks.push(`<pre><code${attribute}>${escapeHtmlText(body.join('\n'))}${body.length === 0 ? '' : '\n'}</code></pre>`);
+    return end < lines.length ? end + 1 : end;
+}
+function pushBlockquote(blocks, lines, start) {
+    const quoted = [];
+    let index = start;
+    while (index < lines.length && /^ {0,3}>/.test(lines[index])) {
+        quoted.push(lines[index].replace(/^ {0,3}> ?/, ''));
+        index++;
+        // A lazy continuation line belongs to the quoted paragraph.
+        while (index < lines.length && lines[index].trim() !== '' && !/^ {0,3}>/.test(lines[index]) && !startsNewBlock(lines[index])) {
+            quoted.push(lines[index]);
+            index++;
+        }
+    }
+    blocks.push(`<blockquote>\n${renderBlocks(quoted, false)}\n</blockquote>`);
+    return index;
+}
+function startsNewBlock(line) {
+    return /^ {0,3}(`{3,}|~{3,})/.test(line)
+        || /^ {0,3}#{1,6}(\s|$)/.test(line)
+        || THEMATIC_BREAK.test(line)
+        || /^ {0,3}>/.test(line)
+        || LIST_ITEM.test(line)
+        || isHtmlBlockStart(line);
+}
+function isHtmlBlockStart(line) {
+    return /^ {0,3}<(?:[A-Za-z][A-Za-z0-9-]*|\/[A-Za-z][A-Za-z0-9-]*|!--)/.test(line);
+}
+function pushHtmlBlock(blocks, lines, start) {
+    let end = start;
+    while (end < lines.length && lines[end].trim() !== '')
+        end++;
+    blocks.push(lines.slice(start, end).join('\n'));
+    return end;
+}
+// ---------------------------------------------------------------------------
+// Lists
+// ---------------------------------------------------------------------------
+function markerType(marker) {
+    return /^\d/.test(marker) ? 'ordered' : 'bullet';
+}
+function pushList(blocks, lines, start) {
+    const first = LIST_ITEM.exec(lines[start]);
+    const type = markerType(first[2]);
+    const items = [];
+    let current = null;
+    let contentIndent = 0;
+    let loose = false;
+    let pendingBlank = false;
+    let index = start;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line.trim() === '') {
+            pendingBlank = true;
+            index++;
+            continue;
+        }
+        const item = LIST_ITEM.exec(line);
+        const itemIndent = item === null ? 0 : item[1].length;
+        if (item !== null && !THEMATIC_BREAK.test(line) && markerType(item[2]) === type && (current === null || itemIndent < contentIndent)) {
+            if (current !== null && pendingBlank)
+                loose = true;
+            contentIndent = itemIndent + item[2].length + (item[3] === '' ? 1 : item[3].length);
+            current = [item[4]];
+            items.push(current);
+            pendingBlank = false;
+            index++;
+            continue;
+        }
+        if (current === null)
+            break;
+        const indented = /^ +/.exec(line)?.[0]?.length ?? 0;
+        if (indented >= contentIndent) {
+            if (pendingBlank) {
+                current.push('');
+                loose = true;
+            }
+            current.push(line.slice(contentIndent));
+            pendingBlank = false;
+            index++;
+            continue;
+        }
+        // A lazy continuation of the item's paragraph — but only before a blank line.
+        if (!pendingBlank && !startsNewBlock(line)) {
+            current.push(line);
+            index++;
+            continue;
+        }
+        break;
+    }
+    const rendered = items.map((item) => `<li>${wrapListItem(renderBlocks(item, !loose))}</li>`);
+    const tag = type === 'ordered' ? 'ol' : 'ul';
+    const startNumber = type === 'ordered' ? Number.parseInt(first[2], 10) : 1;
+    const startAttribute = type === 'ordered' && startNumber !== 1 ? ` start="${startNumber}"` : '';
+    blocks.push(`<${tag}${startAttribute}>\n${rendered.join('\n')}\n</${tag}>`);
+    return index;
+}
+function wrapListItem(html) {
+    return html.includes('\n') ? `\n${html}\n` : html;
+}
+// ---------------------------------------------------------------------------
+// GFM tables
+// ---------------------------------------------------------------------------
+function splitRow(line) {
+    const trimmed = line.trim().replace(/^\|/, '').replace(/\|$/, '');
+    const cells = [];
+    let cell = '';
+    for (let index = 0; index < trimmed.length; index++) {
+        const character = trimmed[index];
+        if (character === '\\' && trimmed[index + 1] === '|') {
+            cell += '|';
+            index++;
+            continue;
+        }
+        if (character === '|') {
+            cells.push(cell.trim());
+            cell = '';
+            continue;
+        }
+        cell += character;
+    }
+    cells.push(cell.trim());
+    return cells;
+}
+/** Render a GFM pipe table at `start`, or return null when there is none. */
+function pushTable(blocks, lines, start) {
+    const header = lines[start];
+    const delimiter = lines[start + 1];
+    if (!header.includes('|') || delimiter === undefined)
+        return null;
+    if (!/^ {0,3}\|?(?: *:?-+:? *\|)+ *:?-*:? *\|? *$/.test(delimiter) && !/^ {0,3}:?-+:? *$/.test(delimiter))
+        return null;
+    const alignments = splitRow(delimiter).map((cell) => {
+        if (!/^:?-+:?$/.test(cell))
+            return null;
+        if (cell.startsWith(':') && cell.endsWith(':'))
+            return 'center';
+        if (cell.endsWith(':'))
+            return 'right';
+        if (cell.startsWith(':'))
+            return 'left';
+        return '';
+    });
+    if (alignments.some((alignment) => alignment === null))
+        return null;
+    const headerCells = splitRow(header);
+    if (headerCells.length !== alignments.length)
+        return null;
+    const align = (column) => {
+        const alignment = alignments[column];
+        return alignment === undefined || alignment === '' ? '' : ` style="text-align:${alignment}"`;
+    };
+    const rows = [];
+    let index = start + 2;
+    while (index < lines.length && lines[index].trim() !== '' && lines[index].includes('|') && !startsNewBlock(lines[index])) {
+        const cells = splitRow(lines[index]);
+        const padded = alignments.map((_, column) => cells[column] ?? '');
+        rows.push(`<tr>${padded.map((cell, column) => `<td${align(column)}>${renderInline(cell)}</td>`).join('')}</tr>`);
+        index++;
+    }
+    const head = `<thead>\n<tr>${headerCells.map((cell, column) => `<th${align(column)}>${renderInline(cell)}</th>`).join('')}</tr>\n</thead>`;
+    const body = rows.length === 0 ? '' : `\n<tbody>\n${rows.join('\n')}\n</tbody>`;
+    blocks.push(`<table>\n${head}${body}\n</table>`);
+    return index;
+}
+// ---------------------------------------------------------------------------
+// Paragraphs
+// ---------------------------------------------------------------------------
+function pushParagraph(blocks, lines, start, unwrap) {
+    const collected = [lines[start].trim()];
+    let index = start + 1;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line.trim() === '')
+            break;
+        if (/^ {0,3}=+ *$/.test(line)) {
+            blocks.push(`<h1>${renderInline(collected.join('\n'))}</h1>`);
+            return index + 1;
+        }
+        if (/^ {0,3}-+ *$/.test(line)) {
+            blocks.push(`<h2>${renderInline(collected.join('\n'))}</h2>`);
+            return index + 1;
+        }
+        if (startsNewBlock(line))
+            break;
+        collected.push(line.replace(/^ {0,3}/, ''));
+        index++;
+    }
+    const inline = renderInline(collected.join('\n'));
+    blocks.push(unwrap ? inline : `<p>${inline}</p>`);
+    return index;
+}
+// ---------------------------------------------------------------------------
+// Inline
+// ---------------------------------------------------------------------------
+/** Render inline markdown. Exported for callers rendering a single line. */
+export function renderInline(source) {
+    let out = '';
+    let index = 0;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === '\\') {
+            const next = source[index + 1];
+            if (next === '\n') {
+                out += '<br />\n';
+                index += 2;
+                continue;
+            }
+            if (next !== undefined && ASCII_PUNCTUATION.test(next)) {
+                out += escapeHtmlText(next);
+                index += 2;
+                continue;
+            }
+            out += '\\';
+            index++;
+            continue;
+        }
+        if (character === ' ') {
+            const run = /^( +)(\n|$)/.exec(source.slice(index));
+            if (run !== null) {
+                out += run[1].length >= 2 && run[2] === '\n' ? '<br />\n' : run[2] === '\n' ? '\n' : '';
+                index += run[1].length + run[2].length;
+                continue;
+            }
+            out += ' ';
+            index++;
+            continue;
+        }
+        if (character === '`') {
+            const span = codeSpanAt(source, index);
+            if (span !== null) {
+                out += span.html;
+                index = span.end;
+                continue;
+            }
+            out += '`';
+            index++;
+            continue;
+        }
+        if (character === '<') {
+            const raw = rawInlineAt(source, index);
+            if (raw !== null) {
+                out += raw.html;
+                index = raw.end;
+                continue;
+            }
+            out += '&lt;';
+            index++;
+            continue;
+        }
+        if (character === '&') {
+            const entity = ENTITY.exec(source.slice(index));
+            if (entity !== null) {
+                out += entity[0];
+                index += entity[0].length;
+                continue;
+            }
+            out += '&amp;';
+            index++;
+            continue;
+        }
+        if (character === '>') {
+            out += '&gt;';
+            index++;
+            continue;
+        }
+        if (character === '!' && source[index + 1] === '[') {
+            const image = linkAt(source, index + 1);
+            if (image !== null) {
+                out += `<img src="${escapeHtmlAttribute(image.destination)}" alt="${escapeHtmlAttribute(stripInlineMarkup(image.text))}"${image.title === undefined ? '' : ` title="${escapeHtmlAttribute(image.title)}"`} />`;
+                index = image.end;
+                continue;
+            }
+        }
+        if (character === '[') {
+            const link = linkAt(source, index);
+            if (link !== null) {
+                out += `<a href="${escapeHtmlAttribute(link.destination)}"${link.title === undefined ? '' : ` title="${escapeHtmlAttribute(link.title)}"`}>${renderInline(link.text)}</a>`;
+                index = link.end;
+                continue;
+            }
+        }
+        if (character === '*' || character === '_') {
+            const emphasis = emphasisAt(source, index);
+            if (emphasis !== null) {
+                out += emphasis.html;
+                index = emphasis.end;
+                continue;
+            }
+            out += character;
+            index++;
+            continue;
+        }
+        out += character;
+        index++;
+    }
+    return out;
+}
+/** Plain text for an image `alt`, which carries no markup. */
+function stripInlineMarkup(source) {
+    return source.replace(/[*_`]/g, '');
+}
+function backtickRun(source, at) {
+    let run = 0;
+    while (source[at + run] === '`')
+        run++;
+    return run;
+}
+function codeSpanAt(source, start) {
+    const run = backtickRun(source, start);
+    let index = start + run;
+    while (index < source.length) {
+        if (source[index] !== '`') {
+            index++;
+            continue;
+        }
+        const closing = backtickRun(source, index);
+        if (closing === run) {
+            let content = source.slice(start + run, index).replace(/\n/g, ' ');
+            if (content.length > 2 && content.startsWith(' ') && content.endsWith(' ') && content.trim() !== '')
+                content = content.slice(1, -1);
+            return { html: `<code>${escapeHtmlText(content)}</code>`, end: index + closing };
+        }
+        index += closing;
+    }
+    return null;
+}
+function rawInlineAt(source, start) {
+    const rest = source.slice(start);
+    const uri = AUTOLINK_URI.exec(rest);
+    if (uri !== null)
+        return { html: `<a href="${escapeHtmlAttribute(uri[1])}">${escapeHtmlText(uri[1])}</a>`, end: start + uri[0].length };
+    const email = AUTOLINK_EMAIL.exec(rest);
+    if (email !== null)
+        return { html: `<a href="mailto:${escapeHtmlAttribute(email[1])}">${escapeHtmlText(email[1])}</a>`, end: start + email[0].length };
+    const comment = HTML_COMMENT.exec(rest);
+    if (comment !== null)
+        return { html: comment[0], end: start + comment[0].length };
+    const tag = RAW_INLINE_TAG.exec(rest);
+    if (tag !== null)
+        return { html: tag[0], end: start + tag[0].length };
+    return null;
+}
+function linkAt(source, start) {
+    let depth = 0;
+    let index = start;
+    let textEnd = -1;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === '\\') {
+            index += 2;
+            continue;
+        }
+        if (character === '`') {
+            const span = codeSpanAt(source, index);
+            index = span === null ? index + 1 : span.end;
+            continue;
+        }
+        if (character === '[')
+            depth++;
+        else if (character === ']') {
+            depth--;
+            if (depth === 0) {
+                textEnd = index;
+                break;
+            }
+        }
+        index++;
+    }
+    if (textEnd === -1 || source[textEnd + 1] !== '(')
+        return null;
+    let cursor = textEnd + 2;
+    while (source[cursor] === ' ' || source[cursor] === '\n')
+        cursor++;
+    let destination = '';
+    if (source[cursor] === '<') {
+        const close = source.indexOf('>', cursor + 1);
+        if (close === -1)
+            return null;
+        destination = source.slice(cursor + 1, close);
+        cursor = close + 1;
+    }
+    else {
+        let parens = 0;
+        while (cursor < source.length) {
+            const character = source[cursor];
+            if (character === '\\' && source[cursor + 1] !== undefined) {
+                destination += source[cursor + 1];
+                cursor += 2;
+                continue;
+            }
+            if (/\s/.test(character))
+                break;
+            if (character === '(')
+                parens++;
+            if (character === ')') {
+                if (parens === 0)
+                    break;
+                parens--;
+            }
+            destination += character;
+            cursor++;
+        }
+    }
+    while (source[cursor] === ' ' || source[cursor] === '\n')
+        cursor++;
+    let title;
+    const quote = source[cursor];
+    if (quote === '"' || quote === "'") {
+        const close = source.indexOf(quote, cursor + 1);
+        if (close === -1)
+            return null;
+        title = source.slice(cursor + 1, close);
+        cursor = close + 1;
+        while (source[cursor] === ' ' || source[cursor] === '\n')
+            cursor++;
+    }
+    if (source[cursor] !== ')')
+        return null;
+    return { text: source.slice(start + 1, textEnd), destination, ...(title === undefined ? {} : { title }), end: cursor + 1 };
+}
+function emphasisAt(source, start) {
+    const marker = source[start];
+    let run = 0;
+    while (source[start + run] === marker)
+        run++;
+    const need = Math.min(run, 3);
+    const opened = source[start + need];
+    if (opened === undefined || /\s/.test(opened))
+        return null;
+    if (marker === '_') {
+        const before = source[start - 1];
+        if (before !== undefined && /[A-Za-z0-9]/.test(before))
+            return null;
+    }
+    const closer = findEmphasisCloser(source, start + need, marker, need);
+    if (closer === null)
+        return null;
+    const inner = renderInline(source.slice(start + need, closer));
+    const html = need === 1 ? `<em>${inner}</em>` : need === 2 ? `<strong>${inner}</strong>` : `<strong><em>${inner}</em></strong>`;
+    return { html, end: closer + need };
+}
+function findEmphasisCloser(source, from, marker, need) {
+    let index = from;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === '\\') {
+            index += 2;
+            continue;
+        }
+        if (character === '`') {
+            const span = codeSpanAt(source, index);
+            index = span === null ? index + 1 : span.end;
+            continue;
+        }
+        if (character !== marker) {
+            index++;
+            continue;
+        }
+        let run = 0;
+        while (source[index + run] === marker)
+            run++;
+        const before = source[index - 1];
+        const after = source[index + run];
+        const closes = run >= need && before !== undefined && !/\s/.test(before)
+            && !(marker === '_' && after !== undefined && /[A-Za-z0-9]/.test(after));
+        if (closes && index > from)
+            return index;
+        index += run;
+    }
+    return null;
+}

package/dist/core/human/page-catalog.d.ts

@@ -0,0 +1,6 @@
+/** The page slot kinds crtr validates and renders itself. */
+export declare const BUILTIN_PAGE_KINDS: readonly ["options", "text", "table", "cards", "chart"];
+/** Normalize the product-registered page slot catalog from raw config. */
+export declare function normalizePageComponents(raw: unknown): string[];
+/** Whether crtr or the product catalog registers a page slot kind. */
+export declare function isRegisteredPageKind(kind: string, productKinds: string[]): boolean;

package/dist/core/human/page-catalog.js

@@ -0,0 +1,43 @@
+/** The page slot kinds crtr validates and renders itself. */
+export const BUILTIN_PAGE_KINDS = ['options', 'text', 'table', 'cards', 'chart'];
+const PAGE_KIND_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
+const BUILTIN_PAGE_KIND_SET = new Set(BUILTIN_PAGE_KINDS);
+function describeEntry(entry) {
+    try {
+        const json = JSON.stringify(entry);
+        return json === undefined ? String(entry) : json;
+    }
+    catch {
+        return String(entry);
+    }
+}
+/** Normalize the product-registered page slot catalog from raw config. */
+export function normalizePageComponents(raw) {
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw)) {
+        throw new Error(`page_components must be an array; received ${describeEntry(raw)}`);
+    }
+    const seen = new Set();
+    return raw.map((entry, index) => {
+        if (typeof entry !== 'string') {
+            throw new Error(`page_components[${index}] must be a string; offending entry: ${describeEntry(entry)}`);
+        }
+        const kind = entry.trim();
+        if (!PAGE_KIND_PATTERN.test(kind)) {
+            throw new Error(`page_components[${index}] has invalid page kind ${describeEntry(entry)} after trimming; expected /^[a-z][a-z0-9-]{0,63}$/`);
+        }
+        if (BUILTIN_PAGE_KIND_SET.has(kind)) {
+            throw new Error(`page_components[${index}] ${describeEntry(entry)} collides with built-in page kind "${kind}"`);
+        }
+        if (seen.has(kind)) {
+            throw new Error(`page_components[${index}] ${describeEntry(entry)} duplicates page kind "${kind}"`);
+        }
+        seen.add(kind);
+        return kind;
+    });
+}
+/** Whether crtr or the product catalog registers a page slot kind. */
+export function isRegisteredPageKind(kind, productKinds) {
+    return BUILTIN_PAGE_KIND_SET.has(kind) || productKinds.includes(kind);
+}

package/dist/core/human/page-render.d.ts

@@ -0,0 +1,3 @@
+import { type PageManifest } from './page-schema.js';
+/** Render one page ticket's authored document as the runtime's HTML payload. */
+export declare function renderPageHtml(manifest: PageManifest, document: string, productKinds?: string[]): string;