tsondb 0.5.18 → 0.6.0

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

@@ -29,3 +29,33 @@ export const difference = (oldArr, newArr) => newArr.reduce((acc, item) => {
     return acc;
 }, { removed: oldArr, added: newArr });
 export const unique = (arr, equalityCheck = (a, b) => a === b) => arr.filter((item, index) => arr.findIndex(other => equalityCheck(item, other)) === index);
+/**
+ * Moves an element from one position to another within the array.
+ */
+export const reorder = (arr, sourceIndex, targetIndex) => {
+    if (sourceIndex < 0 || sourceIndex >= arr.length) {
+        throw new RangeError(`source index ${sourceIndex.toString()} is out of bounds for array of length ${arr.length.toString()}`);
+    }
+    if (targetIndex < 0 || targetIndex >= arr.length) {
+        throw new RangeError(`target index ${targetIndex.toString()} is out of bounds for array of length ${arr.length.toString()}`);
+    }
+    if (sourceIndex === targetIndex) {
+        return arr;
+    }
+    if (sourceIndex < targetIndex) {
+        return [
+            ...arr.slice(0, sourceIndex),
+            ...arr.slice(sourceIndex + 1, targetIndex + 1),
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            arr[sourceIndex],
+            ...arr.slice(targetIndex + 1),
+        ];
+    }
+    return [
+        ...arr.slice(0, targetIndex),
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        arr[sourceIndex],
+        ...arr.slice(targetIndex, sourceIndex),
+        ...arr.slice(sourceIndex + 1),
+    ];
+};

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

@@ -0,0 +1,8 @@
+/**
+ * A simple async map to process tasks with a concurrency limit.
+ * @param tasks The list of tasks to process.
+ * @param worker The async function to process each task.
+ * @param concurrency The maximum number of concurrent tasks.
+ * @returns A promise that resolves to the list of results.
+ */
+export declare const mapAsync: <T, R>(tasks: readonly T[], worker: (task: T) => Promise<R>, concurrency: number) => Promise<R[]>;

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

@@ -0,0 +1,35 @@
+/**
+ * A simple async map to process tasks with a concurrency limit.
+ * @param tasks The list of tasks to process.
+ * @param worker The async function to process each task.
+ * @param concurrency The maximum number of concurrent tasks.
+ * @returns A promise that resolves to the list of results.
+ */
+export const mapAsync = (tasks, worker, concurrency) => new Promise((resolve, reject) => {
+    const results = [];
+    let activeIndex = 0;
+    let activeCount = 0;
+    let resolvedCount = 0;
+    const totalCount = tasks.length;
+    const runNext = () => {
+        if (resolvedCount === totalCount) {
+            resolve(results);
+        }
+        else {
+            while (activeCount < concurrency && activeIndex < totalCount) {
+                const currentIndex = activeIndex++;
+                const task = tasks[currentIndex];
+                activeCount++;
+                worker(task)
+                    .then(result => {
+                    results[currentIndex] = result;
+                    resolvedCount++;
+                    activeCount--;
+                    runNext();
+                })
+                    .catch(reject);
+            }
+        }
+    };
+    runNext();
+});

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

@@ -2,15 +2,15 @@ export const lt = (a, b) => a < b;
 export const lte = (a, b) => a <= b;
 export const gt = (a, b) => a > b;
 export const gte = (a, b) => a >= b;
-export const eq = (a, b) => a === b;
-export const neq = (a, b) => a !== b;
+export const eq = (a, b) => Object.is(a, b);
+export const neq = (a, b) => !Object.is(a, b);
 /**
  * Checks two values for value equality. This is a deep equality check that
  * works for all types, including objects and arrays. For objects, it only
  * compares all enumerable keys, no other properties or the prototype chain.
  */
 export const deepEqual = (a, b) => {
-    if (a === b) {
+    if (Object.is(a, b)) {
         return true;
     }
     if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {

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

@@ -1,2 +1,6 @@
-import type { SerializedEntityDecl } from "../../node/schema/index.ts";
-export declare const getSerializedDisplayNameFromEntityInstance: (entity: SerializedEntityDecl, instance: unknown, defaultName: string, locales?: string[]) => string;
+import type { SerializedEntityDecl } from "../schema/declarations/EntityDecl.ts";
+export type DisplayNameResult = {
+    name: string;
+    localeId?: string;
+};
+export declare const getSerializedDisplayNameFromEntityInstance: (entity: SerializedEntityDecl, instance: unknown, defaultName: string, locales: string[]) => DisplayNameResult;

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

@@ -11,13 +11,16 @@ const getValueAtPath = (value, path) => {
     }
     return current;
 };
-export const getSerializedDisplayNameFromEntityInstance = (entity, instance, defaultName, locales = []) => {
+export const getSerializedDisplayNameFromEntityInstance = (entity, instance, defaultName, locales) => {
     if (entity.displayName === null) {
-        return defaultName;
+        return { name: defaultName, localeId: locales[0] };
     }
     const displayNamePath = entity.displayName ?? "name";
     if (typeof displayNamePath === "string") {
-        return getValueAtPath(instance, displayNamePath) ?? defaultName;
+        return {
+            name: getValueAtPath(instance, displayNamePath) ?? defaultName,
+            localeId: locales[0],
+        };
     }
     else {
         const localeMapPath = displayNamePath.pathToLocaleMap ?? "translations";
@@ -25,12 +28,22 @@ export const getSerializedDisplayNameFromEntityInstance = (entity, instance, def
         const pathInLocaleMap = displayNamePath.pathInLocaleMap ?? "name";
         const availableLocales = Object.keys(localeMap ?? {});
         return availableLocales.length === 0
-            ? defaultName
-            : (locales.reduce((name, locale) => name ??
+            ? { name: defaultName }
+            : (locales.reduce((name, locale) => {
+                if (name)
+                    return name;
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                getValueAtPath(localeMap[locale], pathInLocaleMap), undefined) ??
+                const possibleName = getValueAtPath(localeMap[locale], pathInLocaleMap);
+                if (possibleName) {
+                    return { name: possibleName, localeId: locale };
+                }
+                else {
+                    return undefined;
+                }
+            }, undefined) ?? {
+                name: 
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                getValueAtPath(localeMap[availableLocales[0]], pathInLocaleMap) ??
-                defaultName);
+                getValueAtPath(localeMap[availableLocales[0]], pathInLocaleMap) ?? defaultName,
+            });
     }
 };

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

@@ -2,16 +2,15 @@ import type { EntityDecl } from "../../node/schema/index.ts";
 import type { GetInstanceById } from "../../node/server/index.ts";
 import type { GitFileStatus } from "./git.ts";
 export interface InstanceContainer {
-    fileName: string;
     id: string;
     content: unknown;
     gitStatus?: GitFileStatus;
 }
 export interface InstanceContainerOverview {
-    fileName: string;
     id: string;
     gitStatus?: GitFileStatus;
     displayName: string;
+    displayNameLocaleId?: string;
 }
-export declare const getInstanceContainerOverview: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: GetInstanceById, locales?: string[]) => InstanceContainerOverview;
+export declare const getInstanceContainerOverview: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: GetInstanceById, locales: string[]) => InstanceContainerOverview;
 export type InstancesByEntityName = Record<string, InstanceContainer[]>;

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

@@ -1,8 +1,10 @@
 import { getDisplayNameFromEntityInstance } from "../../node/utils/displayName.js";
 export const getInstanceContainerOverview = (entity, instanceContainer, getInstanceById, locales) => {
     const { content: _, ...rest } = instanceContainer;
+    const { name: displayName, localeId: displayNameLocaleId } = getDisplayNameFromEntityInstance(entity, instanceContainer.content, getInstanceById, locales);
     return {
         ...rest,
-        displayName: getDisplayNameFromEntityInstance(entity, instanceContainer.content, getInstanceById, locales),
+        displayName,
+        displayNameLocaleId,
     };
 };

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

@@ -12,6 +12,10 @@ export type InlineMarkdownNode = {
     kind: "link";
     href: string;
     content: InlineMarkdownNode[];
+} | {
+    kind: "attributed";
+    attributes: Record<string, string | number | boolean>;
+    content: InlineMarkdownNode[];
 } | TextNode;
 export type BlockMarkdownNode = {
     kind: "paragraph";

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

@@ -1,92 +1,184 @@
 const codeRule = {
     pattern: /`(.*?)`/,
-    map: (result, _parseInside, forSyntaxHighlighting) => ({
+    map: result => ({
+        kind: "code",
+        content: result[1] ?? "",
+    }),
+    mapHighlighting: result => ({
         kind: "code",
-        content: forSyntaxHighlighting ? `\`${result[1] ?? ""}\`` : (result[1] ?? ""),
+        content: `\`${result[1] ?? ""}\``,
     }),
 };
 const boldWithItalicRule = {
     pattern: /(?<!\\)\*\*((.*?[^\\*])?\*(?!\*).*?[^\\*]\*.*?)(?<!\\)\*\*/,
-    map: (result, parseInside, forSyntaxHighlighting) => ({
+    map: (result, parseInside) => ({
         kind: "bold",
-        content: forSyntaxHighlighting
-            ? [
-                { kind: "text", content: "**" },
-                ...parseInside(result[1] ?? ""),
-                { kind: "text", content: "**" },
-            ]
-            : parseInside(result[1] ?? ""),
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
+        kind: "bold",
+        content: [textNode("**"), ...parseInside(result[1] ?? ""), textNode("**")],
     }),
 };
 const italicWithBoldRule = {
     pattern: /(?<![\\*])\*(?=\*\*|[^*])(.*?\*\*.*?\*\*.*?)(?<=[^\\*]|[^\\]\*\*)\*(?!\*)/,
-    map: (result, parseInside, forSyntaxHighlighting) => ({
+    map: (result, parseInside) => ({
         kind: "italic",
-        content: forSyntaxHighlighting
-            ? [
-                { kind: "text", content: "*" },
-                ...parseInside(result[1] ?? ""),
-                { kind: "text", content: "*" },
-            ]
-            : parseInside(result[1] ?? ""),
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
+        kind: "italic",
+        content: [textNode("*"), ...parseInside(result[1] ?? ""), textNode("*")],
     }),
 };
 const boldRule = {
     pattern: /(?<!\\)\*\*(.*?[^\\*])\*\*/,
-    map: (result, parseInside, forSyntaxHighlighting) => ({
+    map: (result, parseInside) => ({
         kind: "bold",
-        content: forSyntaxHighlighting
-            ? [
-                { kind: "text", content: "**" },
-                ...parseInside(result[1] ?? ""),
-                { kind: "text", content: "**" },
-            ]
-            : parseInside(result[1] ?? ""),
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
+        kind: "bold",
+        content: [textNode("**"), ...parseInside(result[1] ?? ""), textNode("**")],
     }),
 };
 const italicRule = {
     pattern: /(?<!\\)\*(.*?[^\\*])\*/,
-    map: (result, parseInside, forSyntaxHighlighting) => ({
+    map: (result, parseInside) => ({
         kind: "italic",
-        content: forSyntaxHighlighting
-            ? [
-                { kind: "text", content: "*" },
-                ...parseInside(result[1] ?? ""),
-                { kind: "text", content: "*" },
-            ]
-            : parseInside(result[1] ?? ""),
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
+        kind: "italic",
+        content: [textNode("*"), ...parseInside(result[1] ?? ""), textNode("*")],
     }),
 };
 const linkRule = {
-    pattern: /(?<!\\)\[(.*?[^\\])\]\((.*?[^\\])\)/,
-    map: (result, parseInside, forSyntaxHighlighting) => ({
+    pattern: /(?<![\\^])\[(.*?[^\\])\]\((.*?[^\\])\)/,
+    map: (result, parseInside) => ({
+        kind: "link",
+        href: result[2] ?? "",
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
         kind: "link",
         href: result[2] ?? "",
-        content: forSyntaxHighlighting
-            ? [
-                { kind: "text", content: "[" },
+        content: [textNode("["), ...parseInside(result[1] ?? ""), textNode(`](${result[2] ?? ""})`)],
+    }),
+};
+const booleanAttributePattern = /^(true|false)/;
+const numberAttributePattern = /^(-?\d+(\.\d+)?)/;
+const stringAttributePattern = /^("(.*?)(?<!\\)"|'(.*?)(?<!\\)')/;
+const parseAttributeValue = (text) => {
+    const booleanResult = booleanAttributePattern.exec(text);
+    if (booleanResult !== null) {
+        return [booleanResult[1] === "true", booleanResult[0]];
+    }
+    const numberResult = numberAttributePattern.exec(text);
+    if (numberResult !== null) {
+        return [Number.parseFloat(numberResult[1] ?? "0"), numberResult[0]];
+    }
+    const stringResult = stringAttributePattern.exec(text);
+    if (stringResult !== null) {
+        return [stringResult[2] ?? stringResult[3] ?? "", stringResult[0]];
+    }
+    return null;
+};
+const attributeNamePattern = /^(\w+)(: *)/;
+const attributeSeparatorPattern = /^,( *)/;
+const parseNextAttributes = (text) => {
+    const separatorResult = attributeSeparatorPattern.exec(text);
+    if (separatorResult === null) {
+        return [];
+    }
+    const remainingText = text.slice(separatorResult[0].length);
+    return [separatorResult[0], ...parseAttributes(remainingText)];
+};
+const parseAttributes = (text) => {
+    const nameResult = attributeNamePattern.exec(text);
+    if (nameResult === null) {
+        return [];
+    }
+    const name = nameResult[1] ?? "";
+    const separator = nameResult[2] ?? "";
+    const remainingText = text.slice(nameResult[0].length);
+    const valueResult = parseAttributeValue(remainingText);
+    if (valueResult === null) {
+        return [];
+    }
+    const [value, rawValue] = valueResult;
+    return [
+        { name, separator, value, rawValue },
+        ...parseNextAttributes(remainingText.slice(rawValue.length)),
+    ];
+};
+const mapAttributesToObject = (rawAttributes) => Object.fromEntries(rawAttributes.filter(attr => typeof attr !== "string").map(attr => [attr.name, attr.value]));
+const mapAttributesToNodes = (rawAttributes) => rawAttributes.flatMap(attr => typeof attr === "string"
+    ? [textNode(attr)]
+    : [textNode(attr.name), textNode(attr.separator), textNode(attr.rawValue)]);
+const parsedAttributesLength = (rawAttributes) => rawAttributes.reduce((sum, attr) => sum +
+    (typeof attr === "string"
+        ? attr.length
+        : attr.name.length + attr.separator.length + attr.rawValue.length), 0);
+const attributedRule = {
+    pattern: /(?<!\\)\^\[(.*?[^\\])\]\(((?:\w+: *(?:true|false|\d+(?:\.\d+)?|"(.*?)(?<!\\)"|'(.*?)(?<!\\)'))(?:, *\w+: *(?:true|false|\d+(?:\.\d+)?|"(.*?)(?<!\\)"|'(.*?)(?<!\\)'))*)\)/,
+    map: (result, parseInside) => ({
+        kind: "attributed",
+        attributes: mapAttributesToObject(parseAttributes(result[2] ?? "")),
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => {
+        const attributesText = result[2] ?? "";
+        const attributes = parseAttributes(attributesText);
+        const length = parsedAttributesLength(attributes);
+        const unparsedText = attributesText.length > length
+            ? [{ kind: "text", content: attributesText.slice(length) }]
+            : [];
+        return {
+            kind: "attributed",
+            attributes: mapAttributesToObject(attributes),
+            content: [
+                textNode("^["),
                 ...parseInside(result[1] ?? ""),
-                { kind: "text", content: `](${result[2] ?? ""})` },
-            ]
-            : parseInside(result[1] ?? ""),
+                textNode("]("),
+                ...mapAttributesToNodes(attributes),
+                ...unparsedText,
+                textNode(")"),
+            ],
+        };
+    },
+};
+const textNode = (content) => ({
+    kind: "text",
+    content: content,
+});
+const parseEscapedCharacters = (text) => text.replace(/\\([*_`[\]()\\])/g, "$1");
+const textRule = {
+    pattern: /.+/,
+    map: result => ({
+        kind: "text",
+        content: parseEscapedCharacters(result[0]),
+    }),
+    mapHighlighting: result => ({
+        kind: "text",
+        content: result[0],
     }),
 };
 const inlineRules = [
     codeRule,
     linkRule,
+    attributedRule,
     boldWithItalicRule,
     italicWithBoldRule,
     boldRule,
     italicRule,
+    textRule,
 ];
 const parseForInlineRules = (rules, text, forSyntaxHighlighting) => {
-    if (text.length === 0) {
+    if (text.length === 0 || rules[0] === undefined) {
         return [];
     }
     const activeRule = rules[0];
-    if (activeRule === undefined) {
-        return [{ kind: "text", content: text }];
-    }
     const res = activeRule.pattern.exec(text);
     if (res && (activeRule.predicate?.(res) ?? true)) {
         const { index } = res;
@@ -96,7 +188,7 @@ const parseForInlineRules = (rules, text, forSyntaxHighlighting) => {
             ...(before.length > 0
                 ? parseForInlineRules(rules.slice(1), before, forSyntaxHighlighting)
                 : []),
-            activeRule.map(res, text => parseForInlineRules(rules.slice(1), text, forSyntaxHighlighting), forSyntaxHighlighting),
+            (forSyntaxHighlighting ? activeRule.mapHighlighting : activeRule.map)(res, text => parseForInlineRules(rules.slice(1), text, forSyntaxHighlighting)),
             ...(after.length > 0 ? parseForInlineRules(rules, after, forSyntaxHighlighting) : []),
         ];
     }
@@ -105,6 +197,10 @@ const parseForInlineRules = (rules, text, forSyntaxHighlighting) => {
     }
 };
 const parseInlineMarkdown = (text, forSyntaxHighlighting) => parseForInlineRules(inlineRules, text, forSyntaxHighlighting);
+const nodesForTrailingWhitespace = (text) => {
+    const trailingWhitespace = text ?? "";
+    return trailingWhitespace.length === 0 ? [] : [textNode(trailingWhitespace)];
+};
 const listRule = {
     pattern: /^((?:(?:\d+\.|[-*]) [^\n]+?)(?:\n(?:\d+\.|[-*]) [^\n]+?)*)(\n{2,}|$)/,
     map: result => ({
@@ -122,9 +218,9 @@ const listRule = {
                 content: /^(\d+\. |[-*] )/.exec(item)?.[1] ?? "",
             },
             ...parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, ""), true),
-            ...(index < array.length - 1 ? [{ kind: "text", content: "\n" }] : []),
+            ...(index < array.length - 1 ? [textNode("\n")] : []),
         ]),
-        { kind: "text", content: result[2] ?? "" },
+        ...nodesForTrailingWhitespace(result[2]),
     ],
 };
 const paragraphRule = {
@@ -135,10 +231,14 @@ const paragraphRule = {
     }),
     mapHighlighting: result => [
         ...parseInlineMarkdown(result[1] ?? "", true),
-        { kind: "text", content: result[2] ?? "" },
+        ...nodesForTrailingWhitespace(result[2]),
     ],
 };
 const removeSurroundingPipes = (text) => text.replace(/^\|/, "").replace(/\|$/, "");
+const tableMarker = (text) => ({
+    kind: "tablemarker",
+    content: text,
+});
 const tableRule = {
     pattern: /^(\| *)?(.+?(?: *(?<!\\)\| *.+?)+)( *\|)?\n((?:\| *)?(?:-{3,}|:-{2,}|-{2,}:|:-+:)(?: *\| *(?:-{3,}|:-{2,}|-{2,}:|:-+:))*(?: *\|)?)((?:\n\|? *.+?(?: *(?<!\\)\| *.+?)* *(?<!\\)\|?)+)(\n{2,}|$)/,
     map: result => ({
@@ -152,86 +252,49 @@ const tableRule = {
             .map(tc => parseInlineMarkdown(tc.trim(), false))) ?? [],
     }),
     mapHighlighting: result => [
-        {
-            kind: "tablemarker",
-            content: result[1] ?? "",
-        },
-        ...(result[2]?.split("|").flatMap((th, i) => i === 0
+        tableMarker(result[1] ?? ""),
+        ...(result[2]
+            ?.split("|")
+            .flatMap((th, i) => i === 0
             ? parseInlineMarkdown(th, true)
-            : [
-                {
-                    kind: "tablemarker",
-                    content: "|",
-                },
-                ...parseInlineMarkdown(th, true),
-            ]) ?? []),
-        {
-            kind: "tablemarker",
-            content: (result[3] ?? "") + "\n" + (result[4] ?? ""),
-        },
+            : [tableMarker("|"), ...parseInlineMarkdown(th, true)]) ?? []),
+        tableMarker((result[3] ?? "") + "\n" + (result[4] ?? "")),
         ...(result[5]
             ?.split("\n")
             .slice(1)
             .flatMap((tr) => [
-            {
-                kind: "text",
-                content: "\n",
-            },
-            ...tr.split("|").flatMap((tc, i) => i === 0
+            textNode("\n"),
+            ...tr
+                .split("|")
+                .flatMap((tc, i) => i === 0
                 ? parseInlineMarkdown(tc, true)
-                : [
-                    {
-                        kind: "tablemarker",
-                        content: "|",
-                    },
-                    ...parseInlineMarkdown(tc, true),
-                ]),
+                : [tableMarker("|"), ...parseInlineMarkdown(tc, true)]),
         ]) ?? []),
-        {
-            kind: "text",
-            content: result[6] ?? "",
-        },
+        ...nodesForTrailingWhitespace(result[6]),
     ],
 };
 const blockRules = [tableRule, listRule, paragraphRule];
-const parseForBlockRules = (rules, text, remainingRules = rules) => {
-    if (text.length === 0) {
-        return [];
-    }
-    const activeRule = remainingRules[0];
-    if (activeRule === undefined) {
-        return [{ kind: "paragraph", content: [{ kind: "text", content: text }] }];
-    }
-    const res = activeRule.pattern.exec(text);
-    if (res && (activeRule.predicate?.(res) ?? true)) {
-        const { index } = res;
-        const after = text.slice(index + res[0].length);
-        return [activeRule.map(res), ...(after.length > 0 ? parseForBlockRules(rules, after) : [])];
-    }
-    else {
-        return parseForBlockRules(rules, text, remainingRules.slice(1));
-    }
-};
-const parseForBlockRulesSyntaxHighlighting = (rules, text, remainingRules = rules) => {
-    if (text.length === 0) {
+const parseActiveBlockRule = (rule, res) => [
+    rule.map(res),
+];
+const parseActiveBlockSyntaxRule = (rule, res) => rule.mapHighlighting(res);
+const parseForBlockRules = (rules, text, ruleParser, remainingRules = rules) => {
+    if (text.length === 0 || remainingRules[0] === undefined) {
         return [];
     }
     const activeRule = remainingRules[0];
-    if (activeRule === undefined) {
-        return [{ kind: "text", content: text }];
-    }
     const res = activeRule.pattern.exec(text);
     if (res && (activeRule.predicate?.(res) ?? true)) {
         const { index } = res;
         const after = text.slice(index + res[0].length);
         return [
-            ...activeRule.mapHighlighting(res),
-            ...(after.length > 0 ? parseForBlockRulesSyntaxHighlighting(rules, after) : []),
+            ...ruleParser(activeRule, res),
+            ...(after.length > 0 ? parseForBlockRules(rules, after, ruleParser) : []),
         ];
     }
     else {
-        return parseForBlockRulesSyntaxHighlighting(rules, text, remainingRules.slice(1));
+        return parseForBlockRules(rules, text, ruleParser, remainingRules.slice(1));
     }
 };
-export const parseBlockMarkdown = (text) => parseForBlockRules(blockRules, text);
-export const parseBlockMarkdownForSyntaxHighlighting = (text) => parseForBlockRulesSyntaxHighlighting(blockRules, text);
+export const parseBlockMarkdown = (text) => parseForBlockRules(blockRules, text, parseActiveBlockRule);
+export const parseBlockMarkdownForSyntaxHighlighting = (text) => parseForBlockRules(blockRules, text, parseActiveBlockSyntaxRule);

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

@@ -4,3 +4,5 @@ export declare const mergeObjects: <T>(obj1: Record<string, T>, obj2: Record<str
 export type Leaves<T> = T extends object ? {
     [K in keyof T]: T[K] extends unknown[] ? never : `${Exclude<K, symbol>}${Leaves<T[K]> extends never ? "" : `.${Leaves<T[K]>}`}`;
 }[keyof T] : never;
+export declare const onlyKeys: <T extends object, K extends keyof T>(obj: T, ...keys: K[]) => Pick<T, K>;
+export declare const hasKey: <T extends object, K extends PropertyKey>(obj: T, key: K) => obj is T & { [k in K]: unknown; };

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

@@ -8,3 +8,5 @@ export const mergeObjects = (obj1, obj2, solveConflict) => Object.entries(obj2).
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     [key]: Object.hasOwn(acc, key) ? solveConflict(acc[key], value) : value,
 }), obj1);
+export const onlyKeys = (obj, ...keys) => Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)));
+export const hasKey = (obj, key) => Object.hasOwn(obj, key);

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

@@ -19,7 +19,10 @@ export interface Error<E> {
 /**
  * Creates a result that contains a value.
  */
-export declare const ok: <T>(value: T) => Result<T, never>;
+export declare const ok: {
+    (): Result<void, never>;
+    <T>(value: T): Result<T, never>;
+};
 /**
  * Checks if a result contains a value.
  */
@@ -46,7 +49,10 @@ export declare const map: <T, U, E>(result: Result<T, E>, f: (value: T) => U) =>
 export declare const mapError: <T, E, F>(result: Result<T, E>, f: (value: E) => F) => Result<T, F>;
 export declare const combine: <T1, T2, TR, E1, E2, ER>(result1: Result<T1, E1>, result2: Result<T2, E2>, fok: (value1: T1, value2: T2) => TR, ferror: (error1: E1, error2: E2) => ER) => Result<TR, E1 | E2 | ER>;
 export declare const Result: Readonly<{
-    ok: <T>(value: T) => Result<T, never>;
+    ok: {
+        (): Result<void, never>;
+        <T>(value: T): Result<T, never>;
+    };
     isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
     error: <E>(error: E) => Result<never, E>;
     isError: <T, E>(result: Result<T, E>) => result is Error<E>;

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

@@ -1,7 +1,7 @@
 /**
  * Creates a result that contains a value.
  */
-export const ok = (value) => ({ tag: "Ok", value });
+export const ok = (value) => ({ tag: "Ok", value: value });
 /**
  * Checks if a result contains a value.
  */