tsondb 0.7.12 → 0.8.0

package/dist/src/shared/utils/markdown.d.ts

@@ -24,45 +24,83 @@ type AttributedStringMarkdownNode = {
     attributes: Record<string, string | number | boolean>;
     content: InlineMarkdownNode[];
 };
-export type InlineMarkdownNode = BoldMarkdownNode | ItalicMarkdownNode | CodeMarkdownNode | LinkMarkdownNode | AttributedStringMarkdownNode | TextNode;
-type ParagraphBlockNode = {
+type FootnoteRefInlineNode = {
+    kind: "footnoteRef";
+    label: string;
+};
+export type InlineMarkdownNode = BoldMarkdownNode | ItalicMarkdownNode | CodeMarkdownNode | LinkMarkdownNode | AttributedStringMarkdownNode | TextNode | FootnoteRefInlineNode;
+export declare const checkTableRowsAreSections: (rows: TableRowBlockNode[] | TableSectionBlockNode[]) => rows is TableSectionBlockNode[];
+export declare const syntaxNodeToString: (node: BlockSyntaxMarkdownNode) => string;
+export type ParagraphBlockNode = {
     kind: "paragraph";
     content: InlineMarkdownNode[];
 };
-type HeadingBlockNode = {
+export type HeadingBlockNode = {
     kind: "heading";
     level: number;
     content: InlineMarkdownNode[];
 };
-type ListBlockNode = {
+export type ListBlockNode = {
     kind: "list";
     ordered: boolean;
     content: ListItemNode[];
 };
-type ListItemNode = {
-    kind: "listitem";
+export type ListItemNode = {
+    kind: "listItem";
     content: InlineMarkdownNode[];
 };
-type TableBlockNode = {
+export type TableBlockNode = {
     kind: "table";
     caption?: InlineMarkdownNode[];
-    header: InlineMarkdownNode[][];
-    rows: InlineMarkdownNode[][][];
+    header: TableCellBlockNode[];
+    rows: TableRowBlockNode[] | TableSectionBlockNode[];
+};
+export type TableSectionBlockNode = {
+    kind: "tableSection";
+    header?: TableCellBlockNode[];
+    rows: TableRowBlockNode[];
+};
+export type TableRowBlockNode = {
+    kind: "tableRow";
+    cells: TableCellBlockNode[];
+};
+export type TableCellBlockNode = {
+    kind: "tableCell";
+    colSpan?: number;
+    content: InlineMarkdownNode[];
+};
+export type SectionBlockNode = {
+    kind: "section";
+    name?: string;
+    content: BlockMarkdownNode[];
 };
-export type BlockMarkdownNode = ParagraphBlockNode | HeadingBlockNode | ListBlockNode | TableBlockNode;
+export type FootnoteBlockNode = {
+    kind: "footnote";
+    label: string;
+    content: BlockMarkdownNode[];
+};
+export type BlockMarkdownNode = ParagraphBlockNode | HeadingBlockNode | ListBlockNode | TableBlockNode | SectionBlockNode | FootnoteBlockNode;
 type ListItemMarkerSyntaxNode = {
-    kind: "listitemmarker";
+    kind: "listItemMarker";
     content: string;
 };
 type TableMarkerSyntaxNode = {
-    kind: "tablemarker";
+    kind: "tableMarker";
     content: string;
 };
 type HeadingMarkerSyntaxNode = {
-    kind: "headingmarker";
+    kind: "headingMarker";
+    content: string;
+};
+type SectionMarkerSyntaxNode = {
+    kind: "sectionMarker";
+    content: string;
+};
+type FootnoteMarkerSyntaxNode = {
+    kind: "footnoteMarker";
     content: string;
 };
-type SyntaxNode = ListItemMarkerSyntaxNode | TableMarkerSyntaxNode | HeadingMarkerSyntaxNode;
+type SyntaxNode = ListItemMarkerSyntaxNode | TableMarkerSyntaxNode | HeadingMarkerSyntaxNode | SectionMarkerSyntaxNode | FootnoteMarkerSyntaxNode;
 export type BlockSyntaxMarkdownNode = InlineMarkdownNode | SyntaxNode;
 export declare const parseBlockMarkdown: (text: string) => BlockMarkdownNode[];
 export declare const parseBlockMarkdownForSyntaxHighlighting: (text: string) => BlockSyntaxMarkdownNode[];

package/dist/src/shared/utils/markdown.js

@@ -149,6 +149,17 @@ const attributedRule = {
         };
     },
 };
+const footnoteRefRule = {
+    pattern: /(?<!\\)\[\^([a-zA-Z0-9*]+?)\]/,
+    map: ([_match, label = ""]) => ({
+        kind: "footnoteRef",
+        label,
+    }),
+    mapHighlighting: ([match]) => ({
+        kind: "footnoteRef",
+        label: match,
+    }),
+};
 const textNode = (content) => ({
     kind: "text",
     content: content,
@@ -173,6 +184,7 @@ const inlineRules = [
     italicWithBoldRule,
     boldRule,
     italicRule,
+    footnoteRefRule,
     textRule,
 ];
 const parseForInlineRules = (rules, text, forSyntaxHighlighting) => {
@@ -203,19 +215,19 @@ const nodesForTrailingWhitespace = (text) => {
     return trailingWhitespace.length === 0 ? [] : [textNode(trailingWhitespace)];
 };
 const listRule = {
-    pattern: /^((?:(?:\d+\.|[-*]) [^\n]+?)(?:\n(?:\d+\.|[-*]) [^\n]+?)*)(\n{2,}|$)/,
+    pattern: /^((?:(?:\d+\.|[-*]) [^\n]+?)(?:\n(?:\d+\.|[-*]) [^\n]+?)*)(\n{2,}|\s*$)/,
     map: result => ({
         kind: "list",
         ordered: /^\d+\. /.test(result[0]),
         content: (result[1] ?? "").split("\n").map(item => ({
-            kind: "listitem",
+            kind: "listItem",
             content: parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, ""), false),
         })),
     }),
     mapHighlighting: result => [
         ...(result[1] ?? "").split("\n").flatMap((item, index, array) => [
             {
-                kind: "listitemmarker",
+                kind: "listItemMarker",
                 content: /^(\d+\. |[-*] )/.exec(item)?.[1] ?? "",
             },
             ...parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, ""), true),
@@ -243,28 +255,111 @@ const headingRule = {
         content: parseInlineMarkdown(result[3] ?? "", false),
     }),
     mapHighlighting: result => [
-        { kind: "headingmarker", content: (result[1] ?? "") + (result[2] ?? "") },
+        { kind: "headingMarker", content: (result[1] ?? "") + (result[2] ?? "") },
         ...parseInlineMarkdown(result[3] ?? "", true),
         ...nodesForTrailingWhitespace(result[4]),
     ],
 };
-const removeSurroundingPipes = (text) => text.replace(/^\|/, "").replace(/\|$/, "");
 const tableMarker = (text) => ({
-    kind: "tablemarker",
+    kind: "tableMarker",
     content: text,
 });
+const sectionSeparatorPattern = /^\|? *-{3,} *(?:\| *-{3,} *)+\|?$|^\|? *={3,} *(?:\| *={3,} *)+\|?$/;
+const sectionWithHeaderSeparatorPattern = /^\|? *={3,} *(?:\| *={3,} *)+\|?$/;
+export const checkTableRowsAreSections = (rows) => rows.every(row => row.kind === "tableSection");
+const parseContentRow = (row) => row
+    .replace(/^\|/, "")
+    .split(/(\|+)/)
+    .reduce((acc, segment, index, arr) => {
+    if (index % 2 === 0 && segment.trim() !== "") {
+        const colSpan = arr[index + 1]?.length;
+        return [
+            ...acc,
+            omitUndefinedKeys({
+                kind: "tableCell",
+                colSpan: colSpan !== undefined && colSpan > 1 ? colSpan : undefined,
+                content: parseInlineMarkdown(segment.trim(), false),
+            }),
+        ];
+    }
+    return acc;
+}, []);
+const parseContentRowForSyntaxHighlighting = (row) => row.split(/(\|+)/).reduce((acc, segment, index) => {
+    if (index % 2 === 0) {
+        return [...acc, ...parseInlineMarkdown(segment, true)];
+    }
+    else {
+        return [...acc, tableMarker(segment)];
+    }
+}, []);
 const tableRule = {
-    pattern: /^(?:(\|#)(.+?)(#\|)\n)?(\|)?(.+?(?:(?<!\\)\|.+?)+)((?<!\\)\|)?\n((?:\| *)?(?:-{3,}|:-{2,}|-{2,}:|:-+:)(?: *\| *(?:-{3,}|:-{2,}|-{2,}:|:-+:))*(?: *\|)?)((?:\n\|?.+?(?:(?<!\\)\|.+?)*(?<!\\)\|?)+)(\n{2,}|$)/,
+    pattern: /^(?:(\|#)(.+?)(#\|)\n)?(\|)?(.+?(?:(?<!\\)\|.+?)+)((?<!\\)\|)?\n((?:\| *)?(?:-{3,}|:-{2,}|-{2,}:|:-+:)(?: *\| *(?:-{3,}|:-{2,}|-{2,}:|:-+:))*(?: *\|)?)((?:\n\|?.+?(?:(?<!\\)\|+.+?)*(?:(?<!\\)\|+)?)+)(\n{2,}|$)/,
     map: ([_res, _captionMarkerStart, caption, _captionMarkerEnd, _headerMarkerStart, headers, _headerMarkerEnd, _bodySeparators, body, _trailingWhitespace,]) => omitUndefinedKeys({
         kind: "table",
         caption: caption !== undefined ? parseInlineMarkdown(caption.trim(), false) : undefined,
-        header: headers?.split("|").map(th => parseInlineMarkdown(th.trim(), false)) ?? [],
+        header: headers ? parseContentRow(headers) : [],
         rows: body
             ?.split("\n")
-            .slice(1)
-            .map(tr => removeSurroundingPipes(tr)
-            .split("|")
-            .map(tc => parseInlineMarkdown(tc.trim(), false))) ?? [],
+            .slice(1) // leading newline due to regex
+            .reduce((accRows, row) => {
+            if (sectionSeparatorPattern.test(row)) {
+                const hasHeader = sectionWithHeaderSeparatorPattern.test(row);
+                const newSection = omitUndefinedKeys({
+                    kind: "tableSection",
+                    header: hasHeader ? [] : undefined,
+                    rows: [],
+                });
+                if (accRows[0] === undefined) {
+                    return [newSection];
+                }
+                if (checkTableRowsAreSections(accRows)) {
+                    return [...accRows, newSection];
+                }
+                return [{ kind: "tableSection", rows: accRows }, newSection];
+            }
+            const lastRow = accRows[accRows.length - 1];
+            const rowContent = parseContentRow(row);
+            if (lastRow === undefined) {
+                return [
+                    {
+                        kind: "tableRow",
+                        cells: rowContent,
+                    },
+                ];
+            }
+            if (checkTableRowsAreSections(accRows)) {
+                const lastSection = lastRow;
+                if (lastSection.header !== undefined && lastSection.header.length === 0) {
+                    return [
+                        ...accRows.slice(0, -1),
+                        {
+                            ...lastSection,
+                            header: rowContent,
+                        },
+                    ];
+                }
+                return [
+                    ...accRows.slice(0, -1),
+                    {
+                        ...lastSection,
+                        rows: [
+                            ...lastSection.rows,
+                            {
+                                kind: "tableRow",
+                                cells: rowContent,
+                            },
+                        ],
+                    },
+                ];
+            }
+            return [
+                ...accRows,
+                {
+                    kind: "tableRow",
+                    cells: rowContent,
+                },
+            ];
+        }, []) ?? [],
     }),
     mapHighlighting: ([_res, captionMarkerStart, caption, captionMarkerEnd, headerMarkerStart, headers, headerMarkerEnd, bodySeparators, body, trailingWhitespace,]) => [
         ...(caption !== undefined
@@ -281,22 +376,121 @@ const tableRule = {
             .flatMap((th, i) => i === 0
             ? parseInlineMarkdown(th, true)
             : [tableMarker("|"), ...parseInlineMarkdown(th, true)]) ?? []),
-        tableMarker((headerMarkerEnd ?? "") + "\n" + (bodySeparators ?? "")),
+        tableMarker(headerMarkerEnd ?? ""),
+        textNode("\n"),
+        tableMarker(bodySeparators ?? ""),
         ...(body
             ?.split("\n")
             .slice(1)
             .flatMap((tr) => [
             textNode("\n"),
-            ...tr
-                .split("|")
-                .flatMap((tc, i) => i === 0
-                ? parseInlineMarkdown(tc, true)
-                : [tableMarker("|"), ...parseInlineMarkdown(tc, true)]),
+            ...(sectionSeparatorPattern.test(tr)
+                ? [tableMarker(tr)]
+                : parseContentRowForSyntaxHighlighting(tr)),
         ]) ?? []),
         ...nodesForTrailingWhitespace(trailingWhitespace),
     ],
 };
-const blockRules = [headingRule, tableRule, listRule, paragraphRule];
+const sectionRule = {
+    pattern: /^::: (\w+)?(\n+)(.+?)\n:::(\n{2,}|\s*$)/s,
+    map: ([_match, name, _leadingContentWhitespace, content, _trailingWhitespace,]) => ({
+        kind: "section",
+        name: name ?? undefined,
+        content: parseBlockMarkdown(content ?? ""),
+    }),
+    mapHighlighting: ([_match, name, leadingContentWhitespace = "", content, trailingWhitespace,]) => [
+        { kind: "sectionMarker", content: `::: ${name ?? ""}` },
+        textNode(leadingContentWhitespace),
+        ...parseBlockMarkdownForSyntaxHighlighting(content ?? ""),
+        textNode("\n"),
+        { kind: "sectionMarker", content: ":::" },
+        ...nodesForTrailingWhitespace(trailingWhitespace),
+    ],
+};
+const removeIndentation = (text) => text
+    .split("\n")
+    .map(line => line.replace(/^ {2}/, ""))
+    .join("\n");
+export const syntaxNodeToString = (node) => {
+    switch (node.kind) {
+        case "bold":
+        case "italic":
+        case "link":
+        case "attributed":
+            return node.content.map(syntaxNodeToString).join("");
+        case "text":
+        case "code":
+        case "listItemMarker":
+        case "tableMarker":
+        case "headingMarker":
+        case "sectionMarker":
+        case "footnoteMarker":
+            return node.content;
+        case "footnoteRef":
+            return node.label;
+        default:
+            return assertExhaustive(node);
+    }
+};
+const addIndentationToSyntax = (nodes, nextUpperNode) => nodes.reduce((accNodes, currentNode, index) => {
+    switch (currentNode.kind) {
+        case "bold":
+        case "italic":
+        case "link":
+        case "attributed":
+            return [
+                ...accNodes,
+                {
+                    ...currentNode,
+                    content: addIndentationToSyntax(currentNode.content, nodes[index + 1] ?? nextUpperNode),
+                },
+            ];
+        case "text":
+        case "code":
+        case "listItemMarker":
+        case "tableMarker":
+        case "headingMarker":
+        case "sectionMarker":
+        case "footnoteMarker": {
+            const nextNode = nodes[index + 1] ?? nextUpperNode;
+            const currentContent = currentNode.content.endsWith("\n") &&
+                nextNode &&
+                /^[^\n]*?\S+?/.test(syntaxNodeToString(nextNode))
+                ? currentNode.content + "  "
+                : currentNode.content;
+            return [
+                ...accNodes,
+                { ...currentNode, content: currentContent.replace(/\n([^\n]*?\S+?)/g, "\n  $1") },
+            ];
+        }
+        case "footnoteRef":
+            return [...accNodes, currentNode];
+        default:
+            return assertExhaustive(currentNode);
+    }
+}, []);
+const footnoteRule = {
+    pattern: /^\[\^([a-zA-Z0-9*]+?)\]: (.+?(?:\n(?: {2}.+)?)*)(\n{2,}|\s*$)/,
+    map: ([_match, label = "", content = "", _trailingWhitespace]) => ({
+        kind: "footnote",
+        label: label,
+        content: parseBlockMarkdown(removeIndentation(content)),
+    }),
+    mapHighlighting: ([_match, label = "", content = "", trailingWhitespace,]) => [
+        { kind: "footnoteMarker", content: `[^${label}]:` },
+        textNode(" "),
+        ...addIndentationToSyntax(parseBlockMarkdownForSyntaxHighlighting(removeIndentation(content))),
+        ...nodesForTrailingWhitespace(trailingWhitespace),
+    ],
+};
+const blockRules = [
+    sectionRule,
+    headingRule,
+    footnoteRule,
+    tableRule,
+    listRule,
+    paragraphRule,
+];
 const parseActiveBlockRule = (rule, res) => [
     rule.map(res),
 ];
@@ -341,9 +535,12 @@ const reduceSyntaxNode = (node) => {
         case "link":
         case "attributed":
         case "text":
-        case "listitemmarker":
-        case "tablemarker":
-        case "headingmarker":
+        case "listItemMarker":
+        case "tableMarker":
+        case "headingMarker":
+        case "sectionMarker":
+        case "footnoteMarker":
+        case "footnoteRef":
             return node;
         default:
             return assertExhaustive(node);
@@ -354,9 +551,12 @@ const syntaxNodeMergeRules = {
     italic: (a, b) => ({ ...a, content: [...a.content, ...b.content] }),
     code: (a, b) => ({ ...a, content: a.content + b.content }),
     text: (a, b) => ({ ...a, content: a.content + b.content }),
-    listitemmarker: (a, b) => ({ ...a, content: a.content + b.content }),
-    tablemarker: (a, b) => ({ ...a, content: a.content + b.content }),
-    headingmarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    listItemMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    tableMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    headingMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    sectionMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    footnoteMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    footnoteRef: null,
     link: null,
     attributed: null,
 };

package/dist/src/web/utils/BlockMarkdown.d.ts

@@ -1,8 +1,9 @@
 import type { FunctionalComponent } from "preact";
-import type { BlockMarkdownNode } from "../../shared/utils/markdown.ts";
+import { type BlockMarkdownNode } from "../../shared/utils/markdown.ts";
 type Props = {
     node: BlockMarkdownNode;
     outerHeadingLevel?: number;
+    insertBefore?: preact.ComponentChildren;
 };
 export declare const BlockMarkdown: FunctionalComponent<Props>;
 export {};

package/dist/src/web/utils/BlockMarkdown.js

@@ -1,22 +1,34 @@
-import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-runtime";
+import { checkTableRowsAreSections, } from "../../shared/utils/markdown.js";
+import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { InlineMarkdown } from "./InlineMarkdown.js";
-export const BlockMarkdown = ({ node, outerHeadingLevel = 0 }) => {
+export const BlockMarkdown = ({ node, outerHeadingLevel = 0, insertBefore, }) => {
     switch (node.kind) {
         case "paragraph":
-            return (_jsx("p", { children: node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii))) }));
+            return (_jsxs("p", { children: [insertBefore, node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii)))] }));
         case "heading":
             const Tag = `h${(node.level + outerHeadingLevel).toString()}`;
-            return (_jsx(Tag, { children: node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii))) }));
+            return (_jsxs(Tag, { children: [insertBefore, node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii)))] }));
         case "list":
             if (node.ordered) {
-                return (_jsx("ol", { children: node.content.map((item, ii) => (_jsx("li", { children: item.content.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ii))) }));
+                return (_jsxs(_Fragment, { children: [insertBefore, _jsx("ol", { children: node.content.map((item, ii) => (_jsx("li", { children: item.content.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ii))) })] }));
             }
             else {
-                return (_jsx("ul", { children: node.content.map((item, ii) => (_jsx("li", { children: item.content.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ii))) }));
+                return (_jsxs(_Fragment, { children: [insertBefore, _jsx("ul", { children: node.content.map((item, ii) => (_jsx("li", { children: item.content.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ii))) })] }));
             }
         case "table":
-            return (_jsxs("table", { children: [node.caption !== undefined && (_jsx("caption", { children: node.caption.map((inline, ci) => (_jsx(InlineMarkdown, { node: inline }, ci))) })), _jsx("thead", { children: _jsx("tr", { children: node.header.map((th, hi) => (_jsx("th", { children: th.map((inline, hii) => (_jsx(InlineMarkdown, { node: inline }, hii))) }, hi))) }) }), _jsx("tbody", { children: node.rows.map((tr, ri) => (_jsx("tr", { children: tr.map((tc, ci) => (_jsx("td", { children: tc.map((inline, cii) => (_jsx(InlineMarkdown, { node: inline }, cii))) }, ci))) }, ri))) })] }));
+            return (_jsxs(_Fragment, { children: [insertBefore, _jsxs("table", { children: [node.caption !== undefined && (_jsx("caption", { children: node.caption.map((inline, ci) => (_jsx(InlineMarkdown, { node: inline }, ci))) })), _jsx("thead", { children: _jsx(TableRow, { cells: node.header, cellType: "th" }) }), checkTableRowsAreSections(node.rows) ? (node.rows.map((section, si) => (_jsxs("tbody", { children: [section.header && _jsx(TableRow, { cells: section.header, cellType: "th" }), section.rows.map((row, ri) => (_jsx(TableRow, { cells: row.cells }, ri)))] }, si)))) : (_jsx("tbody", { children: node.rows.map((row, ri) => (_jsx(TableRow, { cells: row.cells }, ri))) }))] })] }));
+        case "section":
+            return (_jsxs("div", { class: node.name, children: [insertBefore, node.content.map((childNode, i) => (_jsx(BlockMarkdown, { node: childNode }, i)))] }));
+        case "footnote": {
+            const label = (_jsxs(_Fragment, { children: [_jsxs("span", { class: "footnote-label", children: [node.label, /^\*+$/.test(node.label) ? ")" : ":"] }), " "] }));
+            return (_jsxs("div", { role: "note", children: [insertBefore, node.content.map((n, i) => (_jsx(BlockMarkdown, { node: n, insertBefore: label }, i)))] }));
+        }
         default:
-            return null;
+            return assertExhaustive(node);
     }
 };
+const TableRow = ({ cells, cellType = "td", }) => {
+    const CellTag = cellType;
+    return (_jsx("tr", { children: cells.map((tc, ci) => (_jsx(CellTag, { scope: cellType === "th" && cells.length === 1 ? "colgroup" : undefined, colSpan: tc.colSpan, children: tc.content.map((inline, cii) => (_jsx(InlineMarkdown, { node: inline }, cii))) }, ci))) }));
+};

package/dist/src/web/utils/BlockMarkdownHighlighting.js

@@ -2,12 +2,18 @@ import { jsx as _jsx } from "preact/jsx-runtime";
 import { InlineMarkdown } from "./InlineMarkdown.js";
 export const BlockMarkdownHighlighting = ({ node }) => {
     switch (node.kind) {
-        case "listitemmarker":
+        case "listItemMarker":
             return _jsx("span", { class: "list-item-marker", children: node.content });
-        case "tablemarker":
+        case "tableMarker":
             return _jsx("span", { class: "table-marker", children: node.content });
-        case "headingmarker":
+        case "headingMarker":
             return _jsx("span", { class: "heading-marker", children: node.content });
+        case "sectionMarker":
+            return _jsx("span", { class: "section-marker", children: node.content });
+        case "footnoteMarker":
+            return _jsx("span", { class: "footnote-marker", children: node.content });
+        case "footnoteRef":
+            return _jsx("span", { class: "footnote-marker", children: node.label });
         default:
             return _jsx(InlineMarkdown, { node: node });
     }

package/dist/src/web/utils/InlineMarkdown.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { Fragment } from "preact";
+import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 const emptyNode = { kind: "text", content: "" };
 export const InlineMarkdown = ({ node }) => {
     switch (node.kind) {
@@ -21,7 +22,11 @@ export const InlineMarkdown = ({ node }) => {
             const trailingNodes = node.content.slice(attributesEnd);
             return (_jsxs("span", { class: "attributed", ...Object.fromEntries(Object.entries(node.attributes).map(([k, v]) => [`data-${k}`, v.toString()])), children: [leadingNodes.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))), Array.from({ length: count }, (_, i) => (_jsxs(Fragment, { children: [_jsx("span", { class: "attributed__name", children: _jsx(InlineMarkdown, { node: attributes[i * 4] ?? emptyNode }) }), _jsx("span", { class: "attributed__separator", children: _jsx(InlineMarkdown, { node: attributes[i * 4 + 1] ?? emptyNode }) }), _jsx("span", { class: "attributed__value", children: _jsx(InlineMarkdown, { node: attributes[i * 4 + 2] ?? emptyNode }) }), i < count - 1 && (_jsx("span", { class: "attributed__separator", children: _jsx(InlineMarkdown, { node: attributes[i * 4 + 3] ?? emptyNode }) }))] }, `attr-${(i + 1).toString()}`))), trailingNodes.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i)))] }));
         }
+        case "footnoteRef":
+            return /^\*+$/.test(node.label) ? (_jsx("span", { class: "footnote-ref", children: node.label })) : (_jsx("sup", { class: "footnote-ref", children: node.label }));
         case "text":
             return node.content;
+        default:
+            return assertExhaustive(node);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.7.12",
+  "version": "0.8.0",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",

package/public/css/styles.css

@@ -63,6 +63,8 @@
   --color-syntax-table-marker: rgb(237, 58, 118);
   --color-syntax-attributed: rgb(48, 81, 228);
   --color-syntax-heading-marker: rgb(62, 189, 191);
+  --color-syntax-footnote: rgb(48, 126, 228);
+  --color-syntax-section: rgb(172, 147, 3);
 }
 
 @media (prefers-color-scheme: dark) {
@@ -105,6 +107,8 @@
     --color-syntax-table-marker: rgb(244, 135, 171);
     --color-syntax-attributed: rgb(137, 157, 244);
     --color-syntax-heading-marker: rgb(140, 229, 231);
+  --color-syntax-footnote: rgb(157, 199, 255);
+  --color-syntax-section: rgb(247, 231, 135);
   }
 }
 
@@ -704,6 +708,7 @@ form > .field--container {
 .editor--markdown input,
 .editor--markdown .textarea-grow-wrap__mirror {
   font-family: var(--font-mono);
+  line-height: 1.5;
 }
 
 .editor--markdown textarea {
@@ -732,6 +737,14 @@ form > .field--container {
   color: var(--color-syntax-heading-marker);
 }
 
+.editor-highlighting .footnote-marker {
+  color: var(--color-syntax-footnote);
+}
+
+.editor-highlighting .section-marker {
+  color: var(--color-syntax-section);
+}
+
 .preview .attributed {
   text-decoration-line: underline;
   text-decoration-style: dashed;