tsondb 0.8.0 → 0.8.1

package/dist/src/node/schema/types/Type.d.ts

@@ -1,7 +1,7 @@
-import { type Decl } from "../index.ts";
+import { type Decl, type EnumDecl, type TypeAliasDecl, type TypeParameter } from "../index.ts";
 import type { BaseNode } from "../Node.ts";
 import type { ArrayType } from "./generic/ArrayType.ts";
-import type { EnumType } from "./generic/EnumType.ts";
+import type { EnumCaseDecl, EnumType } from "./generic/EnumType.ts";
 import type { MemberDecl, ObjectType } from "./generic/ObjectType.ts";
 import type { BooleanType } from "./primitives/BooleanType.ts";
 import type { DateType } from "./primitives/DateType.ts";
@@ -17,9 +17,23 @@ export interface BaseType extends BaseNode {
 }
 export type Type = BooleanType | DateType | FloatType | IntegerType | StringType | ArrayType | ObjectType | TypeArgumentType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType | EnumType | ChildEntitiesType;
 export declare function walkTypeNodeTree(callbackFn: (type: Type, parentTypes: Type[], parentDecl: Decl) => void, type: Type, parentTypes: Type[], parentDecl: Decl): void;
+type EnumCaseTypeAsType<Case extends string, T extends Type | null> = T extends object ? {
+    kind: Case;
+} & {
+    [AV in Case]: AsType<T>;
+} : {
+    kind: Case;
+};
+export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
+    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
+} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer Decl> ? Decl extends TypeAliasDecl<string, infer TA> ? AsType<TA> : Decl extends EnumDecl<string, infer EC> ? AsType<EnumType<EC>> : unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+    [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
+}[keyof EC] : never : never;
 export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
     [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
-} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : never;
+} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+    [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
+}[keyof EC] : never : never;
 export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, unknown> ? ObjectType<{
     [K in keyof T]: T[K] extends MemberDecl ? T[K] : T extends null | undefined ? MemberDecl<AsNode<NonNullable<T[K]>>, false> : MemberDecl<AsNode<T[K]>, true>;
 }> : T extends string ? StringType : T extends number ? FloatType : T extends boolean ? BooleanType : T extends Date ? DateType : never;
@@ -31,3 +45,4 @@ export declare const findTypeAtPath: (type: Type, path: string[], options?: {
  */
 export type StructureFormatter<T extends Type> = (type: T, value: unknown) => unknown;
 export declare const formatValue: StructureFormatter<Type>;
+export {};

package/dist/src/node/schema/types/Type.js

@@ -1,5 +1,5 @@
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
-import { isTypeAliasDecl } from "../index.js";
+import { isTypeAliasDecl, } from "../index.js";
 import { NodeKind } from "../Node.js";
 import { formatArrayValue, isArrayType } from "./generic/ArrayType.js";
 import { formatEnumType } from "./generic/EnumType.js";

package/dist/src/node/utils/displayName.d.ts

@@ -2,13 +2,13 @@ import type { GetInstanceById } from "../../node/server/index.ts";
 import { type DisplayNameResult } from "../../shared/utils/displayName.ts";
 import type { InstanceContainer } from "../../shared/utils/instances.ts";
 import { type EntityDecl } from "../schema/declarations/EntityDecl.ts";
-import type { AsType, Type } from "../schema/types/Type.ts";
+import type { AsDeepType, Type } from "../schema/types/Type.ts";
 export type GetChildInstancesForInstanceId = (parentEntityName: string, parentId: string, childEntityName: string) => {
     id: string;
     content: unknown;
 }[];
 export type DisplayNameCustomizer<T extends Type> = (params: {
-    instance: AsType<T>;
+    instance: AsDeepType<T>;
     instanceId: string;
     instanceDisplayName: string;
     instanceDisplayNameLocaleId: string | undefined;

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

@@ -22,3 +22,10 @@ export declare const unique: <T>(arr: T[], equalityCheck?: (a: T, b: T) => boole
  * Moves an element from one position to another within the array.
  */
 export declare const reorder: <T>(arr: T[], sourceIndex: number, targetIndex: number) => T[];
+/**
+ * Splits an array into chunks of a specified size.
+ * @param arr The array to be chunked.
+ * @param size The size of each chunk.
+ * @returns An array of chunks, where each chunk is an array of elements. The last chunk may be smaller than the specified size if there are not enough elements left.
+ */
+export declare const chunk: <T>(arr: T[], size: number) => T[][];

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

@@ -59,3 +59,19 @@ export const reorder = (arr, sourceIndex, targetIndex) => {
         ...arr.slice(sourceIndex + 1),
     ];
 };
+/**
+ * Splits an array into chunks of a specified size.
+ * @param arr The array to be chunked.
+ * @param size The size of each chunk.
+ * @returns An array of chunks, where each chunk is an array of elements. The last chunk may be smaller than the specified size if there are not enough elements left.
+ */
+export const chunk = (arr, size) => {
+    if (size <= 0) {
+        throw new RangeError(`size must be a positive integer, got ${size.toString()}`);
+    }
+    return arr.reduce((chunks, item, index) => {
+        const chunkIndex = Math.floor(index / size);
+        (chunks[chunkIndex] ??= []).push(item);
+        return chunks;
+    }, []);
+};

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

@@ -70,7 +70,7 @@ export type TableCellBlockNode = {
     content: InlineMarkdownNode[];
 };
 export type SectionBlockNode = {
-    kind: "section";
+    kind: "container";
     name?: string;
     content: BlockMarkdownNode[];
 };
@@ -79,7 +79,16 @@ export type FootnoteBlockNode = {
     label: string;
     content: BlockMarkdownNode[];
 };
-export type BlockMarkdownNode = ParagraphBlockNode | HeadingBlockNode | ListBlockNode | TableBlockNode | SectionBlockNode | FootnoteBlockNode;
+export type DefinitionListBlockNode = {
+    kind: "definitionList";
+    content: DefinitionListItemBlockNode[];
+};
+export type DefinitionListItemBlockNode = {
+    kind: "definitionListItem";
+    terms: InlineMarkdownNode[][];
+    definitions: BlockMarkdownNode[][];
+};
+export type BlockMarkdownNode = ParagraphBlockNode | HeadingBlockNode | ListBlockNode | TableBlockNode | SectionBlockNode | FootnoteBlockNode | DefinitionListBlockNode;
 type ListItemMarkerSyntaxNode = {
     kind: "listItemMarker";
     content: string;
@@ -100,7 +109,11 @@ type FootnoteMarkerSyntaxNode = {
     kind: "footnoteMarker";
     content: string;
 };
-type SyntaxNode = ListItemMarkerSyntaxNode | TableMarkerSyntaxNode | HeadingMarkerSyntaxNode | SectionMarkerSyntaxNode | FootnoteMarkerSyntaxNode;
+type DefinitionMarkerSyntaxNode = {
+    kind: "definitionMarker";
+    content: string;
+};
+type SyntaxNode = ListItemMarkerSyntaxNode | TableMarkerSyntaxNode | HeadingMarkerSyntaxNode | SectionMarkerSyntaxNode | FootnoteMarkerSyntaxNode | DefinitionMarkerSyntaxNode;
 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

@@ -1,3 +1,4 @@
+import { chunk } from "./array.js";
 import { omitUndefinedKeys } from "./object.js";
 import { assertExhaustive } from "./typeSafety.js";
 const codeRule = {
@@ -12,7 +13,7 @@ const codeRule = {
     }),
 };
 const boldWithItalicRule = {
-    pattern: /(?<!\\)\*\*((.*?[^\\*])?\*(?!\*).*?[^\\*]\*.*?)(?<!\\)\*\*/,
+    pattern: /(?<!\\|\*\*.*)\*\*(([^\\*]*)?\*(?!\*).*?[^\\*]\*.*?)(?<!\\)\*\*/,
     map: (result, parseInside) => ({
         kind: "bold",
         content: parseInside(result[1] ?? ""),
@@ -23,7 +24,7 @@ const boldWithItalicRule = {
     }),
 };
 const italicWithBoldRule = {
-    pattern: /(?<![\\*])\*(?=\*\*|[^*])(.*?\*\*.*?\*\*.*?)(?<=[^\\*]|[^\\]\*\*)\*(?!\*)/,
+    pattern: /(?<![\\*]|[\\*]\*.*)\*(?=\*\*|[^*])([^*]*?\*\*[^*]*?\*\*[^*]*?)(?<=[^\\*]|[^\\]\*\*)\*(?!\*)/,
     map: (result, parseInside) => ({
         kind: "italic",
         content: parseInside(result[1] ?? ""),
@@ -391,10 +392,10 @@ const tableRule = {
         ...nodesForTrailingWhitespace(trailingWhitespace),
     ],
 };
-const sectionRule = {
-    pattern: /^::: (\w+)?(\n+)(.+?)\n:::(\n{2,}|\s*$)/s,
+const containerRule = {
+    pattern: /^::: ([\w-_]+)?(\n+)(.+?)\n:::(\n{2,}|\s*$)/s,
     map: ([_match, name, _leadingContentWhitespace, content, _trailingWhitespace,]) => ({
-        kind: "section",
+        kind: "container",
         name: name ?? undefined,
         content: parseBlockMarkdown(content ?? ""),
     }),
@@ -425,6 +426,7 @@ export const syntaxNodeToString = (node) => {
         case "headingMarker":
         case "sectionMarker":
         case "footnoteMarker":
+        case "definitionMarker":
             return node.content;
         case "footnoteRef":
             return node.label;
@@ -451,7 +453,8 @@ const addIndentationToSyntax = (nodes, nextUpperNode) => nodes.reduce((accNodes,
         case "tableMarker":
         case "headingMarker":
         case "sectionMarker":
-        case "footnoteMarker": {
+        case "footnoteMarker":
+        case "definitionMarker": {
             const nextNode = nodes[index + 1] ?? nextUpperNode;
             const currentContent = currentNode.content.endsWith("\n") &&
                 nextNode &&
@@ -483,12 +486,59 @@ const footnoteRule = {
         ...nodesForTrailingWhitespace(trailingWhitespace),
     ],
 };
+const definitionListItemSeparatorPattern = /(^.+?(?=\n:)|\n\n[^: ].*?(?=\n:))/s;
+const definitionListRule = {
+    pattern: /((?:[^\n]+?(?:\n[^\n]+?)*)(?:\n: .+?(?:\n {2}.+?)*)+(?:\n\n(?:[^\n]+?(?:\n[^\n]+?)*)(?:\n: .+?(?:\n(?=\n)|\n {2}.+?)*))*)(\n{2,}|\s*$)/,
+    map: ([_res, content = "", _trailingWhitespace]) => {
+        const definitionItemPairs = chunk(content.split(definitionListItemSeparatorPattern).slice(1), 2);
+        const items = definitionItemPairs.map(([termsText = "", definitionsText = ""]) => {
+            const terms = termsText
+                .trim()
+                .split("\n")
+                .map(term => parseInlineMarkdown(term.trim(), false));
+            const definitions = definitionsText
+                .split("\n:")
+                .slice(1)
+                .map(definition => parseBlockMarkdown(removeIndentation(definition.trim())));
+            return {
+                kind: "definitionListItem",
+                terms,
+                definitions,
+            };
+        });
+        return {
+            kind: "definitionList",
+            content: items,
+        };
+    },
+    mapHighlighting: ([_res, content = "", trailingWhitespace]) => {
+        const items = chunk(content.split(definitionListItemSeparatorPattern).slice(1), 2).flatMap(([termsText = "", definitionsText = ""]) => {
+            const terms = termsText
+                .split("\n")
+                .flatMap((term, index, termArray) => [
+                ...parseInlineMarkdown(term, true),
+                ...(index < termArray.length - 1 ? [textNode("\n")] : []),
+            ]);
+            const definitions = definitionsText
+                .split("\n:")
+                .slice(1)
+                .flatMap((definition, defIndex, defArray) => [
+                { kind: "definitionMarker", content: ":" },
+                ...addIndentationToSyntax(parseBlockMarkdownForSyntaxHighlighting(removeIndentation(definition))),
+                ...(defIndex < defArray.length - 1 ? [textNode("\n")] : []),
+            ]);
+            return [...terms, textNode("\n"), ...definitions];
+        });
+        return [...items, ...nodesForTrailingWhitespace(trailingWhitespace)];
+    },
+};
 const blockRules = [
-    sectionRule,
+    containerRule,
     headingRule,
     footnoteRule,
     tableRule,
     listRule,
+    definitionListRule,
     paragraphRule,
 ];
 const parseActiveBlockRule = (rule, res) => [
@@ -530,9 +580,9 @@ const reduceSyntaxNode = (node) => {
     switch (node.kind) {
         case "bold":
         case "italic":
+        case "link":
             return { ...node, content: reduceSyntaxNodes(node.content) };
         case "code":
-        case "link":
         case "attributed":
         case "text":
         case "listItemMarker":
@@ -541,6 +591,7 @@ const reduceSyntaxNode = (node) => {
         case "sectionMarker":
         case "footnoteMarker":
         case "footnoteRef":
+        case "definitionMarker":
             return node;
         default:
             return assertExhaustive(node);
@@ -556,6 +607,7 @@ const syntaxNodeMergeRules = {
     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 }),
+    definitionMarker: (a, b) => ({ ...a, content: a.content + b.content }),
     footnoteRef: null,
     link: null,
     attributed: null,

package/dist/src/web/components/InstanceRouteSkeleton.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useLocation, useRoute } from "preact-iso";
-import { useCallback, useContext, useEffect, useState } from "preact/hooks";
+import { useCallback, useContext, useEffect, useMemo, useState } from "preact/hooks";
 import { removeAt } from "../../shared/utils/array.js";
 import { deepEqual } from "../../shared/utils/compare.js";
 import { getSerializedDisplayNameFromEntityInstance } from "../../shared/utils/displayName.js";
@@ -37,17 +37,18 @@ export const InstanceRouteSkeleton = ({ mode, buttons, init, titleBuilder, onSub
     const [customId, setCustomId] = useState("");
     const client = useContext(GitClientContext);
     const { route } = useLocation();
+    const hasUnsavedChanges = useMemo(() => !deepEqual(instanceContent, savedInstanceContent), [instanceContent, savedInstanceContent]);
     useEffect(() => {
-        if (deepEqual(instanceContent, savedInstanceContent)) {
-            window.removeEventListener("beforeunload", onBeforeUnload);
+        if (hasUnsavedChanges) {
+            window.addEventListener("beforeunload", onBeforeUnload);
         }
         else {
-            window.addEventListener("beforeunload", onBeforeUnload);
+            window.removeEventListener("beforeunload", onBeforeUnload);
         }
         return () => {
             window.removeEventListener("beforeunload", onBeforeUnload);
         };
-    }, [instanceContent, savedInstanceContent]);
+    }, [hasUnsavedChanges]);
     useEffect(() => {
         document.title =
             (entity && titleBuilder({ locales, entity, instanceContent, instanceId: id })) ??
@@ -147,5 +148,5 @@ export const InstanceRouteSkeleton = ({ mode, buttons, init, titleBuilder, onSub
                             }
                         }, children: "Delete" }))] }), !id && isLocaleEntity && (_jsxs("div", { class: "field field--id", children: [_jsx("label", { htmlFor: "id", children: "ID" }), _jsx("p", { className: "comment", children: "The instance\u2019s identifier. An IETF language tag (BCP47)." }), _jsx("input", { type: "text", id: "id", value: customId, required: true, pattern: "[a-z]{2,3}(-[A-Z]{2,3})?", placeholder: "en-US, de-DE, \u2026", onInput: event => {
                             setCustomId(event.currentTarget.value);
-                        }, "aria-invalid": idErrors.length > 0 }), _jsx(ValidationErrors, { errors: idErrors })] })), _jsxs("form", { onSubmit: handleSubmit, children: [_jsx(TypeInput, { type: entity.type, value: instanceContent, path: undefined, instanceNamesByEntity: instanceNamesByEntity, childInstances: childInstances, getDeclFromDeclName: getDeclFromDeclName, onChange: setInstanceContent, onChildChange: handleOnChildChange, onChildAdd: handleOnChildAdd, onChildRemove: handleOnChildRemove, checkIsLocaleEntity: checkIsLocaleEntity }), _jsx("div", { class: "form-footer btns", children: buttons.map(button => (_jsx("button", { type: "submit", name: button.name, class: button.primary ? "primary" : undefined, children: button.label }, button.name))) })] })] }));
+                        }, "aria-invalid": idErrors.length > 0 }), _jsx(ValidationErrors, { errors: idErrors })] })), _jsxs("form", { onSubmit: handleSubmit, children: [_jsx(TypeInput, { type: entity.type, value: instanceContent, path: undefined, instanceNamesByEntity: instanceNamesByEntity, childInstances: childInstances, getDeclFromDeclName: getDeclFromDeclName, onChange: setInstanceContent, onChildChange: handleOnChildChange, onChildAdd: handleOnChildAdd, onChildRemove: handleOnChildRemove, checkIsLocaleEntity: checkIsLocaleEntity }), _jsx("div", { class: "form-footer btns", children: buttons.map(button => (_jsx("button", { type: "submit", name: button.name, class: button.primary ? "primary" : undefined, disabled: !hasUnsavedChanges, children: button.label }, button.name))) })] })] }));
 };

package/dist/src/web/routes/CreateInstance.js

@@ -24,6 +24,7 @@ const onSubmit = async ({ locales, entity, buttonName, instanceContent, isLocale
             switch (buttonName) {
                 case "saveandcontinue": {
                     route(`/entities/${entity.name}/instances/${createdInstance.instance.id}`);
+                    setInstanceContent(createdInstance.instance.content);
                     break;
                 }
                 case "saveandaddanother": {

package/dist/src/web/routes/Instance.js

@@ -21,7 +21,7 @@ const titleBuilder = ({ locales, entity, instanceId, instanceContent, }) => {
     }
     return undefined;
 };
-const onSubmit = async ({ locales, entity, instanceId, instanceContent, buttonName, childInstances, route, updateLocalGitState, }) => {
+const onSubmit = async ({ locales, entity, instanceId, instanceContent, buttonName, childInstances, route, updateLocalGitState, setInstanceContent, }) => {
     try {
         if (instanceId && buttonName) {
             await updateInstanceByEntityNameAndId(locales, entity.name, instanceId, {
@@ -33,6 +33,7 @@ const onSubmit = async ({ locales, entity, instanceId, instanceContent, buttonNa
             await updateLocalGitState?.();
             switch (buttonName) {
                 case "saveandcontinue": {
+                    setInstanceContent(instanceContent);
                     break;
                 }
                 case "save": {

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

@@ -18,12 +18,14 @@ export const BlockMarkdown = ({ node, outerHeadingLevel = 0, insertBefore, }) =>
             }
         case "table":
             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 "container":
+            return (_jsxs("div", { class: node.name, children: [insertBefore, node.content.map((childNode, i) => (_jsx(BlockMarkdown, { node: childNode, outerHeadingLevel: outerHeadingLevel }, 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)))] }));
+            return (_jsxs("div", { role: "note", children: [insertBefore, node.content.map((n, i) => (_jsx(BlockMarkdown, { node: n, outerHeadingLevel: outerHeadingLevel, insertBefore: label }, i)))] }));
         }
+        case "definitionList":
+            return (_jsxs(_Fragment, { children: [insertBefore, _jsx("dl", { children: node.content.map((item, ii) => (_jsxs("div", { children: [item.terms.map((term, ti) => (_jsx("dt", { children: term.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ti))), item.definitions.map((definition, di) => (_jsx("dd", { children: definition.map((n, i) => (_jsx(BlockMarkdown, { node: n, outerHeadingLevel: outerHeadingLevel }, i))) }, di)))] }, ii))) })] }));
         default:
             return assertExhaustive(node);
     }

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

@@ -14,6 +14,8 @@ export const BlockMarkdownHighlighting = ({ node }) => {
             return _jsx("span", { class: "footnote-marker", children: node.content });
         case "footnoteRef":
             return _jsx("span", { class: "footnote-marker", children: node.label });
+        case "definitionMarker":
+            return _jsx("span", { class: "definition-description-marker", children: node.content });
         default:
             return _jsx(InlineMarkdown, { node: node });
     }

package/package.json

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

package/public/css/styles.css

@@ -725,7 +725,7 @@ form > .field--container {
   color: var(--color-syntax-italic);
 }
 
-.editor-highlighting .list-item-marker {
+.editor-highlighting :is(.list-item-marker, .definition-description-marker) {
   color: var(--color-syntax-list-item-marker);
 }