@mx-space/cli 0.14.2 → 0.15.1

package/dist/src/cli/project/list.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const list: Command.Command<"list", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly page: Option.Option<number>;
+    readonly size: Option.Option<number>;
+}>;

package/dist/src/cli/project/list.js

@@ -0,0 +1,19 @@
+import { Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { projectListView } from './view';
+const page = Options.integer('page').pipe(Options.optional);
+const size = Options.integer('size').pipe(Options.optional);
+const unwrap = (value) => Option.getOrUndefined(value);
+export const list = Command.make('list', { page, size }, ({ page, size }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/projects', {
+        query: {
+            page: unwrap(page),
+            size: unwrap(size),
+        },
+    });
+    yield* renderer.emit(projectListView, res);
+})).pipe(Command.withDescription('list projects'));

package/dist/src/cli/project/update.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const update: Command.Command<"update", import("@effect/platform/FileSystem").FileSystem | Api | Renderer | Resolver, import("../../services/Api").ApiError, {
+    readonly name: import("effect/Option").Option<string>;
+    readonly description: import("effect/Option").Option<string>;
+    readonly previewUrl: import("effect/Option").Option<string>;
+    readonly docUrl: import("effect/Option").Option<string>;
+    readonly projectUrl: import("effect/Option").Option<string>;
+    readonly avatar: import("effect/Option").Option<string>;
+    readonly images: import("effect/Option").Option<string>;
+    readonly text: import("effect/Option").Option<string>;
+    readonly file: import("effect/Option").Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+    readonly nameOrId: string;
+}>;

package/dist/src/cli/project/update.js

@@ -0,0 +1,24 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { openAdminEdit } from '../../domain/admin-link';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+import { buildProjectPayload, projectWriteOptions, toProjectFlagInputs, } from './_flags';
+const nameOrId = Args.text({ name: 'nameOrId' });
+export const update = Command.make('update', { nameOrId, ...projectWriteOptions }, ({ nameOrId, ...rest }) => Effect.gen(function* () {
+    const flags = toProjectFlagInputs(rest);
+    const payload = yield* buildProjectPayload(flags);
+    const resolver = yield* Resolver;
+    const id = yield* resolver.resolveProjectId(nameOrId);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(`/projects/${id}`, {
+        method: 'PATCH',
+        body: payload,
+    });
+    yield* resolver.invalidate('project');
+    yield* renderer.emitSuccess(rest.silent ? { ok: true } : res);
+    if (rest.open)
+        yield* openAdminEdit('projects', id);
+})).pipe(Command.withDescription('partially update a project'));

package/dist/src/cli/project/view-cmd.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const viewCmd: Command.Command<"view", Api | Renderer | Resolver, import("../../services/Api").ApiError, {
+    readonly nameOrId: string;
+}>;

package/dist/src/cli/project/view-cmd.js

@@ -0,0 +1,15 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+import { projectView } from './view';
+const nameOrId = Args.text({ name: 'nameOrId' });
+export const viewCmd = Command.make('view', { nameOrId }, ({ nameOrId }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const resolver = yield* Resolver;
+    const id = yield* resolver.resolveProjectId(nameOrId);
+    const res = yield* api.request(`/projects/${id}`);
+    yield* renderer.emit(projectView, res);
+})).pipe(Command.withDescription('show a project (rendered)'));

package/dist/src/cli/project/view.d.ts

@@ -0,0 +1,3 @@
+import type { View } from '../../services/Renderer/view';
+export declare const projectView: View<unknown>;
+export declare const projectListView: View<unknown>;

package/dist/src/cli/project/view.js

@@ -0,0 +1,102 @@
+import { asRecord, first, firstString, formatScalar, unwrapDocument, } from '../../services/Renderer/content';
+import { tryFormatTimestamp } from '../../services/Renderer/datetime';
+import { frontmatter, renderMetadataBlock } from '../render';
+const normalize = (data) => asRecord(unwrapDocument(data));
+const collectFields = (doc) => {
+    const images = first(doc, 'images');
+    const imagesField = Array.isArray(images)
+        ? images.length === 0
+            ? undefined
+            : images.length <= 3
+                ? images.join(', ')
+                : `${images.slice(0, 3).join(', ')} (+${images.length - 3} more)`
+        : undefined;
+    return [
+        ['id', first(doc, 'id')],
+        ['name', first(doc, 'name')],
+        ['preview_url', first(doc, 'preview_url', 'previewUrl')],
+        ['project_url', first(doc, 'project_url', 'projectUrl')],
+        ['doc_url', first(doc, 'doc_url', 'docUrl')],
+        ['avatar', first(doc, 'avatar')],
+        ['images', imagesField],
+        ['created_at', first(doc, 'created_at', 'createdAt')],
+    ].filter(([, value]) => value !== undefined && value !== null && value !== '');
+};
+const pickDescription = (doc) => {
+    const desc = firstString(doc, 'description');
+    return desc || undefined;
+};
+const pickText = (doc) => {
+    const text = firstString(doc, 'text');
+    return text ? { body: text, format: 'text' } : undefined;
+};
+export const projectView = {
+    kind: 'project',
+    modes: new Set(['readable', 'llm']),
+    readable: (data, ctx) => {
+        const doc = normalize(data);
+        const body = pickText(doc);
+        const name = firstString(doc, 'name');
+        return renderMetadataBlock({
+            title: name || undefined,
+            kind: 'project',
+            fields: collectFields(doc),
+            summary: pickDescription(doc),
+            body: body?.body,
+            bodyFormat: body?.format,
+        }, ctx);
+    },
+    llm: (data) => {
+        const doc = normalize(data);
+        const body = pickText(doc);
+        const name = firstString(doc, 'name');
+        const fm = frontmatter({
+            title: name || undefined,
+            fields: collectFields(doc),
+            summary: pickDescription(doc),
+        });
+        return body?.body ? `${fm}\n\n${body.body}` : fm;
+    },
+};
+const collectListItemFields = (doc) => [
+    ['id', first(doc, 'id')],
+    ['name', first(doc, 'name')],
+    ['description', first(doc, 'description')],
+    ['created_at', first(doc, 'created_at', 'createdAt')],
+];
+const renderProjectListReadable = (data) => {
+    const payload = asRecord(data);
+    const rows = Array.isArray(payload.data)
+        ? payload.data
+        : Array.isArray(data)
+            ? data
+            : [];
+    const meta = asRecord(first(payload, 'meta'));
+    const pagination = asRecord(first(meta, 'pagination'));
+    const lines = ['projects', `count: ${rows.length}`];
+    const page = first(pagination, 'page', 'currentPage');
+    const size = first(pagination, 'size', 'pageSize');
+    const total = first(pagination, 'total', 'totalCount', 'total_count');
+    if (page !== undefined)
+        lines.push(`page: ${formatScalar(page)}`);
+    if (size !== undefined)
+        lines.push(`size: ${formatScalar(size)}`);
+    if (total !== undefined)
+        lines.push(`total: ${formatScalar(total)}`);
+    rows.forEach((row, index) => {
+        const doc = asRecord(row);
+        lines.push('', `project ${index + 1}:`);
+        for (const [key, value] of collectListItemFields(doc)) {
+            if (value === undefined || value === null || value === '')
+                continue;
+            const rendered = tryFormatTimestamp(value, { style: 'rel' }) ?? formatScalar(value);
+            lines.push(`${key}: ${rendered}`);
+        }
+    });
+    return lines.join('\n');
+};
+export const projectListView = {
+    kind: 'project-list',
+    modes: new Set(['readable', 'llm']),
+    readable: (data) => renderProjectListReadable(data),
+};

package/dist/src/cli/render/codehighlight.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Highlight a multi-line code block. `lang` is matched case-insensitively;
+ * unknown values fall through to a conservative default ruleset.
+ *
+ * When `color` is false (NO_COLOR / non-TTY), the input is returned verbatim
+ * so callers don't have to short-circuit themselves.
+ */
+export declare const highlightCode: (code: string, lang: string | undefined, color: boolean) => string;

package/dist/src/cli/render/codehighlight.js

@@ -0,0 +1,264 @@
+// ---------------------------------------------------------------------------
+// Minimal terminal syntax highlighter.
+//
+// Same philosophy as `./markdown.ts`: hand-rolled to avoid pulling in
+// `cli-highlight` / `highlight.js` (~270 KB). Covers js/ts, jsx/tsx,
+// bash/sh/zsh, json, css, html/xml, python — the languages most often seen
+// in blog posts. Anything else falls through to a generic ruleset that
+// highlights strings, numbers, and line comments.
+// ---------------------------------------------------------------------------
+import { ANSI, wrap } from './markdown';
+// Common shared rules.
+const STRING_DOUBLE_OR_SINGLE = {
+    pattern: /(["'])(?:\\.|(?!\1)[^\n\\])*\1/g,
+    color: 'green',
+};
+const STRING_TEMPLATE = {
+    pattern: /`(?:\\.|[^\\`])*`/g,
+    color: 'green',
+};
+const LINE_COMMENT_DSLASH = {
+    pattern: /\/\/[^\n]*/g,
+    color: 'dim',
+};
+const LINE_COMMENT_HASH = {
+    pattern: /(^|\s)#[^\n]*/g,
+    color: 'dim',
+};
+const BLOCK_COMMENT_C = {
+    pattern: /\/\*[\s\S]*?\*\//g,
+    color: 'dim',
+};
+const NUMBERS = {
+    pattern: /\b\d+(?:\.\d+)?\b/g,
+    color: 'yellow',
+};
+const kw = (words) => new RegExp(`\\b(?:${words.join('|')})\\b`, 'g');
+const JS_KEYWORDS = [
+    'const',
+    'let',
+    'var',
+    'function',
+    'return',
+    'if',
+    'else',
+    'for',
+    'while',
+    'do',
+    'switch',
+    'case',
+    'break',
+    'continue',
+    'default',
+    'class',
+    'extends',
+    'super',
+    'this',
+    'new',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+    'import',
+    'export',
+    'from',
+    'as',
+    'async',
+    'await',
+    'yield',
+    'try',
+    'catch',
+    'finally',
+    'throw',
+    'void',
+    'delete',
+    'interface',
+    'type',
+    'enum',
+    'implements',
+    'public',
+    'private',
+    'protected',
+    'readonly',
+    'static',
+    'declare',
+    'abstract',
+    'namespace',
+    'module',
+    'require',
+];
+const JS_LITERALS = ['true', 'false', 'null', 'undefined'];
+const JS_SET = {
+    // Strings must extract before comments so `"a // b"` keeps its `//`.
+    literals: [
+        STRING_TEMPLATE,
+        STRING_DOUBLE_OR_SINGLE,
+        BLOCK_COMMENT_C,
+        LINE_COMMENT_DSLASH,
+    ],
+    tokens: [
+        { pattern: kw(JS_KEYWORDS), color: 'magenta' },
+        { pattern: kw(JS_LITERALS), color: 'yellow' },
+        NUMBERS,
+    ],
+};
+const SHELL_KEYWORDS = [
+    'if',
+    'then',
+    'else',
+    'elif',
+    'fi',
+    'case',
+    'esac',
+    'for',
+    'while',
+    'do',
+    'done',
+    'in',
+    'function',
+    'return',
+    'exit',
+    'export',
+    'local',
+    'readonly',
+    'unset',
+    'echo',
+    'printf',
+    'cd',
+    'set',
+    'source',
+];
+const SHELL_SET = {
+    literals: [STRING_DOUBLE_OR_SINGLE, LINE_COMMENT_HASH],
+    tokens: [
+        { pattern: kw(SHELL_KEYWORDS), color: 'magenta' },
+        // Long and short flags (-x, --foo).
+        { pattern: /(?<=\s)-[\w-]+/g, color: 'cyan' },
+        NUMBERS,
+    ],
+};
+const JSON_SET = {
+    literals: [STRING_DOUBLE_OR_SINGLE],
+    tokens: [{ pattern: /\b(?:true|false|null)\b/g, color: 'yellow' }, NUMBERS],
+};
+const CSS_SET = {
+    literals: [STRING_DOUBLE_OR_SINGLE, BLOCK_COMMENT_C],
+    tokens: [
+        { pattern: /@[a-z-]+/g, color: 'magenta' },
+        { pattern: /#[\da-f]{3,8}\b/gi, color: 'yellow' },
+        {
+            pattern: /\b\d+(?:\.\d+)?(?:px|em|rem|%|vh|vw|deg|s|ms)?\b/g,
+            color: 'yellow',
+        },
+        { pattern: /[a-z-]+(?=\s*:)/g, color: 'cyan' },
+    ],
+};
+const HTML_SET = {
+    literals: [
+        { pattern: /<!--[\s\S]*?-->/g, color: 'dim' },
+        STRING_DOUBLE_OR_SINGLE,
+    ],
+    tokens: [
+        { pattern: /<\/?[\w-]+/g, color: 'magenta' },
+        { pattern: /\b[\w-]+(?==)/g, color: 'cyan' },
+    ],
+};
+const PYTHON_KEYWORDS = [
+    'def',
+    'class',
+    'if',
+    'elif',
+    'else',
+    'for',
+    'while',
+    'return',
+    'yield',
+    'import',
+    'from',
+    'as',
+    'try',
+    'except',
+    'finally',
+    'raise',
+    'with',
+    'pass',
+    'break',
+    'continue',
+    'lambda',
+    'global',
+    'nonlocal',
+    'in',
+    'is',
+    'not',
+    'and',
+    'or',
+    'async',
+    'await',
+];
+const PYTHON_SET = {
+    literals: [STRING_DOUBLE_OR_SINGLE, LINE_COMMENT_HASH],
+    tokens: [
+        { pattern: kw(PYTHON_KEYWORDS), color: 'magenta' },
+        { pattern: /\b(?:True|False|None)\b/g, color: 'yellow' },
+        NUMBERS,
+    ],
+};
+const DEFAULT_SET = {
+    literals: [STRING_DOUBLE_OR_SINGLE, LINE_COMMENT_DSLASH, LINE_COMMENT_HASH],
+    tokens: [NUMBERS],
+};
+const LANG_TABLE = {
+    js: JS_SET,
+    jsx: JS_SET,
+    ts: JS_SET,
+    tsx: JS_SET,
+    javascript: JS_SET,
+    typescript: JS_SET,
+    mjs: JS_SET,
+    cjs: JS_SET,
+    bash: SHELL_SET,
+    sh: SHELL_SET,
+    shell: SHELL_SET,
+    zsh: SHELL_SET,
+    console: SHELL_SET,
+    json: JSON_SET,
+    jsonc: JSON_SET,
+    css: CSS_SET,
+    scss: CSS_SET,
+    sass: CSS_SET,
+    less: CSS_SET,
+    html: HTML_SET,
+    xml: HTML_SET,
+    svg: HTML_SET,
+    py: PYTHON_SET,
+    python: PYTHON_SET,
+};
+/**
+ * Highlight a multi-line code block. `lang` is matched case-insensitively;
+ * unknown values fall through to a conservative default ruleset.
+ *
+ * When `color` is false (NO_COLOR / non-TTY), the input is returned verbatim
+ * so callers don't have to short-circuit themselves.
+ */
+export const highlightCode = (code, lang, color) => {
+    if (!color)
+        return code;
+    const key = (lang ?? '').toLowerCase().trim();
+    const set = LANG_TABLE[key] ?? DEFAULT_SET;
+    const stash = [];
+    let work = code;
+    // Placeholder format: `\x00ph<idx>\x00`. The leading `ph` letters break
+    // word-boundary so a later `\b\d+\b` rule can't match the index digits.
+    for (const rule of set.literals) {
+        work = work.replaceAll(rule.pattern, (match) => {
+            const placeholder = `\x00ph${stash.length}\x00`;
+            stash.push(wrap(ANSI[rule.color], match, true));
+            return placeholder;
+        });
+    }
+    for (const rule of set.tokens) {
+        work = work.replaceAll(rule.pattern, (match) => wrap(ANSI[rule.color], match, true));
+    }
+    work = work.replaceAll(/\0ph(\d+)\0/g, (_, idx) => stash[Number(idx)]);
+    return work;
+};

package/dist/src/cli/render/envelope.d.ts

@@ -0,0 +1,7 @@
+export interface EnvelopeInput {
+    /** Root element name, e.g. 'mxpost' / 'mxnote' / 'mxpage'. */
+    readonly root: string;
+    readonly meta: ReadonlyArray<readonly [string, unknown]>;
+    readonly content: string;
+}
+export declare const renderEnvelope: (input: EnvelopeInput) => string;

package/dist/src/cli/render/envelope.js

@@ -0,0 +1,23 @@
+import { escapeXml, formatScalar } from '../../services/Renderer/content';
+const renderEnvelopeMeta = (key, value) => {
+    if (key === 'tags' && Array.isArray(value)) {
+        const tags = value
+            .map((item) => `      <tag>${escapeXml(formatScalar(item))}</tag>`)
+            .join('\n');
+        return `    <tags>\n${tags}\n    </tags>`;
+    }
+    return `    <${key}>${escapeXml(formatScalar(value))}</${key}>`;
+};
+export const renderEnvelope = (input) => {
+    const { root, meta: rawMeta, content } = input;
+    const meta = rawMeta.filter(([, value]) => value !== undefined && value !== null && value !== '');
+    const metaLines = meta.map(([key, value]) => renderEnvelopeMeta(key, value));
+    return `<${root}>
+  <meta>
+${metaLines.join('\n')}
+  </meta>
+  <content>
+${content}
+  </content>
+</${root}>`;
+};

package/dist/src/cli/render/frontmatter.d.ts

@@ -0,0 +1,8 @@
+export declare const yamlScalar: (value: unknown) => string;
+export declare const yamlValue: (value: unknown) => string[];
+export interface FrontmatterInput {
+    readonly title?: string;
+    readonly fields: ReadonlyArray<readonly [string, unknown]>;
+    readonly summary?: string;
+}
+export declare const frontmatter: (input: FrontmatterInput) => string;

package/dist/src/cli/render/frontmatter.js

@@ -0,0 +1,50 @@
+// YAML scalar formatter for markdown-frontmatter output. Quote when the value
+// could otherwise be parsed as a different type, contain delimiters, or start
+// with a YAML indicator.
+const YAML_NEEDS_QUOTING = /^\s|\s$|[\n"#':\\]|^[!%&*,>?@[\]`{|}-]|^(?:true|false|null|yes|no|on|off|~)$/i;
+export const yamlScalar = (value) => {
+    if (value === null || value === undefined)
+        return 'null';
+    if (typeof value === 'boolean' || typeof value === 'number')
+        return String(value);
+    if (value instanceof Date)
+        return value.toISOString();
+    const str = typeof value === 'string' ? value : String(value);
+    if (str === '')
+        return "''";
+    if (YAML_NEEDS_QUOTING.test(str)) {
+        return `"${str.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+    }
+    return str;
+};
+export const yamlValue = (value) => {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return ['[]'];
+        return value.map((item) => `  - ${yamlScalar(item)}`);
+    }
+    return [yamlScalar(value)];
+};
+export const frontmatter = (input) => {
+    const { title, fields: rawFields, summary } = input;
+    const fields = rawFields.filter(([, value]) => value !== undefined && value !== null && value !== '');
+    const lines = ['---'];
+    if (title)
+        lines.push(`title: ${yamlScalar(title)}`);
+    for (const [key, value] of fields) {
+        const parts = yamlValue(value);
+        if (parts.length === 1) {
+            lines.push(`${key}: ${parts[0]}`);
+        }
+        else {
+            lines.push(`${key}:`);
+            for (const item of parts)
+                lines.push(item);
+        }
+    }
+    if (summary) {
+        lines.push(`summary: ${yamlScalar(summary)}`);
+    }
+    lines.push('---');
+    return lines.join('\n');
+};

package/dist/src/cli/render/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const SEPARATOR_WIDTH = 64;
+export declare const formatStateBadge: (raw: unknown, color: boolean) => string | undefined;

package/dist/src/cli/render/helpers.js

@@ -0,0 +1,11 @@
+import { ANSI, wrap } from './markdown';
+export const SEPARATOR_WIDTH = 64;
+export const formatStateBadge = (raw, color) => {
+    if (typeof raw !== 'string')
+        return undefined;
+    if (raw === 'published')
+        return wrap(ANSI.green, raw, color);
+    if (raw === 'draft')
+        return wrap(ANSI.yellow, raw, color);
+    return raw;
+};

package/dist/src/cli/render/index.d.ts

@@ -0,0 +1,7 @@
+export { highlightCode } from './codehighlight';
+export { type DateTimeStyle, formatAbsoluteDateTime, formatDateTime, type FormatDateTimeOptions, formatRelativeTime, looksLikeTimestamp, toDate, tryFormatTimestamp, } from '../../services/Renderer/datetime';
+export { type EnvelopeInput, renderEnvelope } from './envelope';
+export { frontmatter, type FrontmatterInput, yamlScalar, yamlValue, } from './frontmatter';
+export { formatStateBadge, SEPARATOR_WIDTH } from './helpers';
+export { ANSI, isColorEnabled, renderMarkdownToAnsi, type RenderOptions, visibleLen, wrap, } from './markdown';
+export { type MetadataBlockInput, renderMetadataBlock } from './metadata-block';

package/dist/src/cli/render/index.js

@@ -0,0 +1,10 @@
+export { highlightCode } from './codehighlight';
+// Date/time helpers live in services/Renderer (so the generic readable
+// renderer can use them without importing from cli/). Re-export here for
+// view authors who already import from `../render`.
+export { formatAbsoluteDateTime, formatDateTime, formatRelativeTime, looksLikeTimestamp, toDate, tryFormatTimestamp, } from '../../services/Renderer/datetime';
+export { renderEnvelope } from './envelope';
+export { frontmatter, yamlScalar, yamlValue, } from './frontmatter';
+export { formatStateBadge, SEPARATOR_WIDTH } from './helpers';
+export { ANSI, isColorEnabled, renderMarkdownToAnsi, visibleLen, wrap, } from './markdown';
+export { renderMetadataBlock } from './metadata-block';

package/dist/src/cli/render/lexical/blocks.d.ts

@@ -0,0 +1,19 @@
+import type { BlockRenderer } from './walker';
+export declare const paragraphRenderer: BlockRenderer;
+export declare const h1Renderer: BlockRenderer;
+export declare const h2Renderer: BlockRenderer;
+export declare const h3Renderer: BlockRenderer;
+export declare const h4Renderer: BlockRenderer;
+export declare const h5Renderer: BlockRenderer;
+export declare const h6Renderer: BlockRenderer;
+export declare const blockquoteRenderer: BlockRenderer;
+export declare const hrRenderer: BlockRenderer;
+export declare const ulRenderer: BlockRenderer;
+export declare const olRenderer: BlockRenderer;
+export declare const liRenderer: BlockRenderer;
+export declare const tableRenderer: BlockRenderer;
+export declare const alertRenderer: BlockRenderer;
+export declare const bannerRenderer: BlockRenderer;
+export declare const detailsRenderer: BlockRenderer;
+export declare const spoilerRenderer: BlockRenderer;
+export declare const blockRendererEntries: ReadonlyArray<readonly [string, BlockRenderer]>;