@brillout/docpress 0.15.10-commit-ef0b9a0 → 0.15.10-commit-e9efbd3

package/dist/components/Note.js

@@ -1,3 +1,14 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 export { Warning };
 export { Advanced };
 export { Construction };
@@ -16,38 +27,39 @@ import React from 'react';
 import { assert } from '../utils/assert';
 import './Note.css';
 function Warning(props) {
-    return React.createElement(NoteGeneric, { type: "warning", ...props });
+    return React.createElement(NoteGeneric, __assign({ type: "warning" }, props));
 }
 function Advanced(props) {
-    return React.createElement(NoteGeneric, { type: "advanced", ...props });
+    return React.createElement(NoteGeneric, __assign({ type: "advanced" }, props));
 }
 function Construction(props) {
-    return React.createElement(NoteGeneric, { type: "construction", ...props });
+    return React.createElement(NoteGeneric, __assign({ type: "construction" }, props));
 }
 function Contribution(props) {
-    return React.createElement(NoteGeneric, { type: "contribution", ...props });
+    return React.createElement(NoteGeneric, __assign({ type: "contribution" }, props));
 }
 function Danger(props) {
-    return React.createElement(NoteGeneric, { type: "danger", ...props });
+    return React.createElement(NoteGeneric, __assign({ type: "danger" }, props));
 }
 function NoteWithoutIcon(props) {
-    return React.createElement(NoteGeneric, { icon: null, ...props });
+    return React.createElement(NoteGeneric, __assign({ icon: null }, props));
 }
 function NoteWithCustomIcon(props) {
-    const { icon } = props;
+    var icon = props.icon;
     if (!icon)
-        throw new Error(`<NoteWithCustomIcon icon={/*...*/}> property 'icon' is \`${icon}\` which is forbidden`);
-    return React.createElement(NoteGeneric, { ...props });
+        throw new Error("<NoteWithCustomIcon icon={/*...*/}> property 'icon' is `".concat(icon, "` which is forbidden"));
+    return React.createElement(NoteGeneric, __assign({}, props));
 }
-function NoteGeneric({ type, icon, iconMargin, children, style, }) {
-    assert(icon === null || icon || type, { icon, type });
-    iconMargin ?? (iconMargin = 2);
-    let className = 'custom-icon';
+function NoteGeneric(_a) {
+    var type = _a.type, icon = _a.icon, iconMargin = _a.iconMargin, children = _a.children, style = _a.style;
+    assert(icon === null || icon || type, { icon: icon, type: type });
+    iconMargin !== null && iconMargin !== void 0 ? iconMargin : (iconMargin = 2);
+    var className = 'custom-icon';
     if (type) {
-        className = `${className} type-${type}`;
+        className = "".concat(className, " type-").concat(type);
     }
     if (!icon && type) {
-        let classColor = '';
+        var classColor = '';
         if (type === 'danger') {
             icon = '⛔';
             classColor = 'note-color-red';
@@ -70,13 +82,13 @@ function NoteGeneric({ type, icon, iconMargin, children, style, }) {
         }
         assert(icon);
         assert(classColor);
-        className = `${className} ${classColor}`;
+        className = "".concat(className, " ").concat(classColor);
     }
     return (React.createElement("blockquote", { className: className, style: style },
         React.createElement("div", { style: { marginBottom: 20 } }),
         icon && (React.createElement(React.Fragment, null,
             React.createElement("span", { style: { fontFamily: 'emoji' } }, icon),
-            React.createElement("span", { style: { width: iconMargin ?? undefined, display: 'inline-block' } }),
+            React.createElement("span", { style: { width: iconMargin !== null && iconMargin !== void 0 ? iconMargin : undefined, display: 'inline-block' } }),
             ' ')),
         React.createElement("div", { className: "blockquote-content" }, children),
         React.createElement("div", { style: { marginTop: 20 } })));

package/dist/components/P.js

@@ -1,6 +1,17 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import React from 'react';
 import './P.css';
 export { P };
 function P(props) {
-    return React.createElement("div", { ...props, className: 'paragraph' });
+    return React.createElement("div", __assign({}, props, { className: 'paragraph' }));
 }

package/dist/components/RepoLink.js

@@ -2,19 +2,21 @@ export { RepoLink };
 export { getRepoHref };
 import React from 'react';
 import { usePageContext } from '../renderer/usePageContext';
-function RepoLink({ path, text }) {
+function RepoLink(_a) {
+    var path = _a.path, text = _a.text;
     text = text || path;
-    const href = getRepoHref(path);
+    var href = getRepoHref(path);
     return React.createElement("a", { href: href }, text);
 }
-function getRepoHref(path, editMode = false) {
-    const pageContext = usePageContext();
+function getRepoHref(path, editMode) {
+    if (editMode === void 0) { editMode = false; }
+    var pageContext = usePageContext();
     if (!path.startsWith('/')) {
         path = '/' + path;
     }
-    const viewMode = path.endsWith('/') && !editMode ? 'tree' : 'blob';
-    const { github } = pageContext.globalContext.config.docpress;
-    let href = `${github}/${viewMode}/main${path}`;
+    var viewMode = path.endsWith('/') && !editMode ? 'tree' : 'blob';
+    var github = pageContext.globalContext.config.docpress.github;
+    var href = "".concat(github, "/").concat(viewMode, "/main").concat(path);
     if (editMode)
         href += '?plain=1';
     return href;

package/dist/determineNavItemsColumnLayout.js

@@ -1,26 +1,47 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 export { determineNavItemsColumnLayout };
 import { assert, assertUsage } from './utils/assert';
 function determineNavItemsColumnLayout(navItems) {
-    const columnLayouts = getColumnEntries(navItems);
-    columnLayouts.forEach((columnEntries) => {
-        for (let numberOfColumns = columnEntries.length; numberOfColumns >= 1; numberOfColumns--) {
-            const columnMapping = determineColumnLayout(columnEntries.map((columnEntry) => columnEntry.numberOfEntries), numberOfColumns);
-            columnEntries.forEach((columnEntry, i) => {
+    var columnLayouts = getColumnEntries(navItems);
+    columnLayouts.forEach(function (columnEntries) {
+        var _loop_1 = function (numberOfColumns) {
+            var columnMapping = determineColumnLayout(columnEntries.map(function (columnEntry) { return columnEntry.numberOfEntries; }), numberOfColumns);
+            columnEntries.forEach(function (columnEntry, i) {
                 var _a;
-                (_a = columnEntry.navItemLeader).isColumnEntry ?? (_a.isColumnEntry = {});
+                var _b;
+                (_a = (_b = columnEntry.navItemLeader).isColumnEntry) !== null && _a !== void 0 ? _a : (_b.isColumnEntry = {});
                 columnEntry.navItemLeader.isColumnEntry[numberOfColumns] = columnMapping[i];
             });
+        };
+        for (var numberOfColumns = columnEntries.length; numberOfColumns >= 1; numberOfColumns--) {
+            _loop_1(numberOfColumns);
         }
     });
 }
 function getColumnEntries(navItems) {
-    const navItemsWithLength = navItems.map((navItem) => ({
-        ...navItem,
-        numberOfHeadings: navItem.level === 1 || navItem.level === 4 ? 0 : null,
-    }));
-    let navItemLevel1;
-    let navItemLevel4;
-    navItemsWithLength.forEach((navItem) => {
+    var navItemsWithLength = navItems.map(function (navItem) { return (__assign(__assign({}, navItem), { numberOfHeadings: navItem.level === 1 || navItem.level === 4 ? 0 : null })); });
+    var navItemLevel1;
+    var navItemLevel4;
+    navItemsWithLength.forEach(function (navItem) {
         if (navItem.level === 1) {
             navItemLevel1 = navItem;
             navItemLevel4 = undefined;
@@ -30,7 +51,7 @@ function getColumnEntries(navItems) {
             navItemLevel4 = navItem;
             return;
         }
-        const bumpNavItemLength = (navItem) => {
+        var bumpNavItemLength = function (navItem) {
             assert(navItem.numberOfHeadings !== null);
             navItem.numberOfHeadings++;
         };
@@ -40,13 +61,13 @@ function getColumnEntries(navItems) {
             bumpNavItemLength(navItemLevel4);
         }
     });
-    const columnLayouts = [];
-    let columnEntries = [];
-    let isFullWidthCategory;
-    navItemsWithLength.forEach((navItem, i) => {
-        let isFullWidthCategoryBegin = false;
+    var columnLayouts = [];
+    var columnEntries = [];
+    var isFullWidthCategory;
+    navItemsWithLength.forEach(function (navItem, i) {
+        var isFullWidthCategoryBegin = false;
         if (navItem.level === 1) {
-            const isFullWidthCategoryPrevious = isFullWidthCategory;
+            var isFullWidthCategoryPrevious = isFullWidthCategory;
             isFullWidthCategory = !!navItem.menuModalFullWidth;
             if (isFullWidthCategory)
                 isFullWidthCategoryBegin = true;
@@ -55,8 +76,8 @@ function getColumnEntries(navItems) {
                 columnEntries = [];
             }
         }
-        const navItemPrevious = navItemsWithLength[i - 1];
-        const navItemNext = navItemsWithLength[i + 1];
+        var navItemPrevious = navItemsWithLength[i - 1];
+        var navItemNext = navItemsWithLength[i + 1];
         if (!isFullWidthCategory
             ? navItem.level === 1
             : (navItem.level === 4 && navItemPrevious.level !== 1) || isFullWidthCategoryBegin) {
@@ -66,7 +87,7 @@ function getColumnEntries(navItems) {
             else {
                 assert(navItem.level === 1);
             }
-            let { numberOfHeadings } = navItem;
+            var numberOfHeadings = navItem.numberOfHeadings;
             assert(numberOfHeadings !== null);
             if (isFullWidthCategoryBegin) {
                 assert(navItem.level === 1);
@@ -85,15 +106,15 @@ function getColumnEntries(navItems) {
 }
 function determineColumnLayout(columnsUnmerged, numberOfColumns) {
     assert(numberOfColumns <= columnsUnmerged.length);
-    const columnsMergingInit = columnsUnmerged.map((columnHeight, i) => ({
+    var columnsMergingInit = columnsUnmerged.map(function (columnHeight, i) { return ({
         columnIdsMerged: [i],
         heightTotal: columnHeight,
-    }));
-    const columnsMerged = mergeColumns(columnsMergingInit, numberOfColumns);
-    const columnsIdMap = new Array(columnsUnmerged.length);
+    }); });
+    var columnsMerged = mergeColumns(columnsMergingInit, numberOfColumns);
+    var columnsIdMap = new Array(columnsUnmerged.length);
     assert(columnsMerged.length === numberOfColumns);
-    columnsMerged.forEach((columnMerged, columnMergedId) => {
-        columnMerged.columnIdsMerged.forEach((columnId) => {
+    columnsMerged.forEach(function (columnMerged, columnMergedId) {
+        columnMerged.columnIdsMerged.forEach(function (columnId) {
             columnsIdMap[columnId] = columnMergedId;
         });
     });
@@ -103,32 +124,25 @@ function determineColumnLayout(columnsUnmerged, numberOfColumns) {
 function mergeColumns(columnsMerging, numberOfColumns) {
     if (columnsMerging.length <= numberOfColumns)
         return columnsMerging;
-    let mergeCandidate = null;
-    for (let i = 0; i <= columnsMerging.length - 2; i++) {
-        const column1 = columnsMerging[i + 0];
-        const column2 = columnsMerging[i + 1];
-        const heightTotal = column1.heightTotal + column2.heightTotal;
+    var mergeCandidate = null;
+    for (var i_1 = 0; i_1 <= columnsMerging.length - 2; i_1++) {
+        var column1 = columnsMerging[i_1 + 0];
+        var column2 = columnsMerging[i_1 + 1];
+        var heightTotal = column1.heightTotal + column2.heightTotal;
         if (!mergeCandidate || mergeCandidate.heightTotal > heightTotal) {
             mergeCandidate = {
-                i,
-                columnIdsMerged: [
-                    //
-                    ...column1.columnIdsMerged,
-                    ...column2.columnIdsMerged,
-                ],
-                heightTotal,
+                i: i_1,
+                columnIdsMerged: __spreadArray(__spreadArray([], column1.columnIdsMerged, true), column2.columnIdsMerged, true),
+                heightTotal: heightTotal,
             };
         }
     }
     assert(mergeCandidate);
-    const { i } = mergeCandidate;
+    var i = mergeCandidate.i;
     assert(-1 < i && i < columnsMerging.length - 1);
-    const columnsMergingMod = [
-        //
-        ...columnsMerging.slice(0, i),
-        mergeCandidate,
-        ...columnsMerging.slice(i + 2),
-    ];
+    var columnsMergingMod = __spreadArray(__spreadArray(__spreadArray([], columnsMerging.slice(0, i), true), [
+        mergeCandidate
+    ], false), columnsMerging.slice(i + 2), true);
     assert(columnsMergingMod.length === columnsMerging.length - 1);
     return mergeColumns(columnsMergingMod, numberOfColumns);
 }

package/dist/detypePlugin.js

@@ -1,53 +1,140 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 export { detypePlugin };
 import module from 'node:module';
 // Cannot use `import { transform } from 'detype'` as it results in errors,
 // and the package has no default export. Using `module.createRequire` instead.
-const { transform } = module.createRequire(import.meta.url)('detype');
+var transform = module.createRequire(import.meta.url)('detype').transform;
 function detypePlugin() {
+    var _this = this;
     return {
         name: '@brillout/docpress:detypePlugin',
         enforce: 'pre',
-        transform: async (code, id) => {
-            if (!id.endsWith('+Page.mdx')) {
-                return;
-            }
-            const codeNew = await transformCode(code);
-            return codeNew;
-        },
+        transform: function (code, id) { return __awaiter(_this, void 0, void 0, function () {
+            var codeNew;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!id.endsWith('+Page.mdx')) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, transformCode(code)];
+                    case 1:
+                        codeNew = _a.sent();
+                        return [2 /*return*/, codeNew];
+                }
+            });
+        }); },
     };
 }
-const tsBlockRegex = /```(tsx?|vue)(\s+ts-only)?([\s\S]*?)```/g;
-async function transformCode(code) {
-    let codeNew = `import { CodeSnippets, CodeSnippet } from '@brillout/docpress';\n`;
-    let lastIndex = 0;
-    const matches = [...code.matchAll(tsBlockRegex)];
-    if (matches.length === 0) {
+var codeBlockRE = /^([ \t]{0,3}>?[ \t]?)```(tsx?|vue)[^\n]*\n([\s\S]*?)```/gm;
+var prettierOptions = {
+    semi: false,
+    singleQuote: true,
+    printWidth: 100,
+};
+function transformCode(code) {
+    return __awaiter(this, void 0, void 0, function () {
+        var matches, codeNew, lastIndex, _i, matches_1, match, fullMatch, startsWith, lang, tsCode, tsOpeningCode, blockStart, blockEnd, jsCode, jsLang, jsOpeningCode, closing, jsCodeSnippet, tsCodeSnippet, codeSnippets;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    matches = Array.from(code.matchAll(codeBlockRE));
+                    if (matches.length === 0) {
+                        return [2 /*return*/, code];
+                    }
+                    codeNew = "import { CodeSnippets, CodeSnippet } from '@brillout/docpress';\n\n";
+                    lastIndex = 0;
+                    _i = 0, matches_1 = matches;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < matches_1.length)) return [3 /*break*/, 6];
+                    match = matches_1[_i];
+                    fullMatch = match[0], startsWith = match[1], lang = match[2], tsCode = match[3];
+                    tsOpeningCode = fullMatch.split('\n')[0].slice(startsWith.length);
+                    blockStart = match.index;
+                    blockEnd = blockStart + fullMatch.length;
+                    codeNew += code.slice(lastIndex, blockStart);
+                    if (startsWith.length > 0) {
+                        tsCode = stripStarts(tsCode, startsWith);
+                    }
+                    if (!tsOpeningCode.includes('ts-only')) return [3 /*break*/, 2];
+                    codeNew += "".concat(startsWith, "<CodeSnippet language={'ts'} tsOnly={'true'}>\n").concat(fullMatch, "\n").concat(startsWith, "</CodeSnippet>");
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, transform(tsCode.replaceAll('.ts', '.js'), "tsCode.".concat(lang), {
+                        removeTsComments: true,
+                        prettierOptions: prettierOptions,
+                    })];
+                case 3:
+                    jsCode = _a.sent();
+                    jsLang = lang === 'vue' ? 'vue' : lang.replace('t', 'j') // ts => js | tsx => jsx
+                    ;
+                    jsOpeningCode = tsOpeningCode.replace(lang, jsLang);
+                    closing = "```";
+                    jsCodeSnippet = "<CodeSnippet language={'js'}>\n".concat(jsOpeningCode, "\n").concat(jsCode).concat(closing, "\n</CodeSnippet>");
+                    tsCodeSnippet = "<CodeSnippet language={'ts'}>\n".concat(tsOpeningCode, "\n").concat(tsCode).concat(closing, "\n</CodeSnippet>");
+                    codeSnippets = putBackStarts("<CodeSnippets>\n".concat(tsCodeSnippet, "\n").concat(jsCodeSnippet, "\n</CodeSnippets>"), startsWith);
+                    codeNew += codeSnippets;
+                    _a.label = 4;
+                case 4:
+                    lastIndex = blockEnd;
+                    _a.label = 5;
+                case 5:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 6:
+                    codeNew += code.slice(lastIndex);
+                    return [2 /*return*/, codeNew];
+            }
+        });
+    });
+}
+function stripStarts(code, startsWith) {
+    return code
+        .split('\n')
+        .map(function (line) { return line.slice(startsWith.length); })
+        .join('\n');
+}
+function putBackStarts(code, startsWith) {
+    if (!startsWith.length) {
         return code;
     }
-    for (const match of matches) {
-        const [tsCodeBlock, lang, tsOnly, tsCode] = match; // lang = ts | tsx | vue
-        const type = lang === 'vue' ? 'vue' : lang.replace('t', 'j'); // ts => js | tsx => jsx
-        const blockStart = match.index;
-        const blockEnd = blockStart + tsCodeBlock.length;
-        codeNew += code.slice(lastIndex, blockStart);
-        if (tsOnly) {
-            codeNew += `\n<CodeSnippet language={'ts'} tsOnly={'true'}>\n${tsCodeBlock}\n</CodeSnippet>\n`;
-        }
-        else {
-            const jsCode = await transform(tsCode.trim().replaceAll('.ts', '.js'), `tsCode.${lang}`, {
-                removeTsComments: true,
-                prettierOptions: {
-                    semi: false,
-                    singleQuote: true,
-                },
-            });
-            const jsCodeBlock = `\`\`\`${type}\n${jsCode}\`\`\``;
-            const jsCodeSnippet = `\n<CodeSnippet language={'js'}>\n${jsCodeBlock}\n</CodeSnippet>\n`;
-            const tsCodeSnippet = `\n<CodeSnippet language={'ts'}>\n${tsCodeBlock}\n</CodeSnippet>\n`;
-            codeNew += `<CodeSnippets>${jsCodeSnippet}${tsCodeSnippet}</CodeSnippets>`;
-        }
-        lastIndex = blockEnd;
-    }
-    codeNew += code.slice(lastIndex);
-    return codeNew;
+    return code
+        .split('\n')
+        .map(function (line) { return "".concat(startsWith).concat(line); })
+        .join('\n');
 }

package/dist/parseMarkdownMini.js

@@ -1,11 +1,20 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 export { parseMarkdownMini };
 import React from 'react';
 function parseMarkdownMini(markdown) {
-    const parts = [];
-    let current;
-    markdown.split('').forEach((letter) => {
+    var parts = [];
+    var current;
+    markdown.split('').forEach(function (letter) {
         if (letter === '`') {
-            if (current?.nodeType === 'code') {
+            if ((current === null || current === void 0 ? void 0 : current.nodeType) === 'code') {
                 // </code>
                 parts.push(current);
                 current = undefined;
@@ -28,6 +37,9 @@ function parseMarkdownMini(markdown) {
     if (current) {
         parts.push(current);
     }
-    const parsed = React.createElement(React.Fragment, {}, ...parts.map((part, i) => React.createElement(part.nodeType === 'code' ? 'code' : React.Fragment, { key: i }, part.content)));
+    var parsed = React.createElement.apply(React, __spreadArray([React.Fragment,
+        {}], parts.map(function (part, i) {
+        return React.createElement(part.nodeType === 'code' ? 'code' : React.Fragment, { key: i }, part.content);
+    }), false));
     return parsed;
 }