@brillout/docpress 0.15.10 → 0.15.11-commit-e615832

package/css/button.css

@@ -5,3 +5,26 @@ button,
   border-radius: 5px;
   cursor: pointer;
 }
+
+/* Raised button */
+.raised {
+  cursor: pointer;
+  border-radius: 5px;
+  border-style: solid;
+  border-width: 1px 2px 2px 1px;
+  border-color: hsl(0, 0%, 75%) hsl(0, 0%, 72%) hsl(0, 0%, 72%) hsl(0, 0%, 75%);
+
+  &:hover {
+    border-color: hsl(0, 0%, 72%) hsl(0, 0%, 66%) hsl(0, 0%, 66%) hsl(0, 0%, 72%);
+  }
+
+  &:active {
+    border-width: 2px 1px 1px 2px;
+    border-color: hsl(0, 0%, 66%) hsl(0, 0%, 72%) hsl(0, 0%, 72%) hsl(0, 0%, 66%);
+  }
+
+  &:disabled {
+    border-width: 1px;
+    border-color: hsl(0, 0%, 72%);
+  }
+}

package/css/code.css

@@ -2,29 +2,11 @@
 @import './code/block.css';
 @import './code/diff.css';
 
-code {
-  border-radius: 4px;
-}
-pre {
-  background: none !important;
-}
+/* For code blocks, see Pre.css instead */
 
-/* Inline */
+/* Inline <code> */
 code {
+  border-radius: 4px;
   background: rgba(0, 0, 0, 0.063137255);
   font-size: 1.1em;
 }
-
-/* Block */
-pre > code {
-  /*
-  background-color: #f4f4f4;
-  0.043137255 = 1 - (#f4 / #ff)
-  */
-  background: rgba(0, 0, 0, 0.043137255);
-  font-size: 1em;
-}
-/* Workaround for shiki regression */
-pre > code:not([data-language]) {
-  padding: 16px !important;
-}

package/css/tooltip.css

@@ -17,10 +17,8 @@
     font-size: 12px;
     content: attr(aria-label);
     position: absolute;
-    top: 100%;
     left: 50%;
     transform: translate(-50%, 0);
-    margin-top: 5px;
     background: #fdfdfd;
     padding: 3px 10px;
     box-shadow: rgb(0 0 0 / 8%) 2px 4px 7px 0px;
@@ -34,4 +32,14 @@
     */
     white-space: nowrap;
   }
+  /* Show below */
+  [aria-label]:not([data-label-position])::before {
+    top: 100%;
+    margin-top: 5px;
+  }
+  /* Show above */
+  [aria-label][data-label-position='top']::before {
+    bottom: 100%;
+    margin-bottom: 7px;
+  }
 }

package/dist/+config.js

@@ -1,6 +1,6 @@
 export { config as default };
 import { viteConfig } from './vite.config.js';
-var config = {
+const config = {
     name: '@brillout/docpress',
     require: { vike: '>=0.4.234' },
     vite: viteConfig,

package/dist/NavItemComponent.js

@@ -1,53 +1,39 @@
-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 { NavItemComponent };
 export { getNavItemsWithComputed };
 import React from 'react';
 import { assert, assertWarning, jsxToTextContent } from './utils/server';
 import './NavItemComponent.css';
 import { parseMarkdownMini } from './parseMarkdownMini';
-function NavItemComponent(_a) {
-    var _b;
-    var _c;
-    var navItem = _a.navItem, onClick = _a.onClick;
+function NavItemComponent({ navItem, onClick, }) {
     assert([1, 2, 3, 4].includes(navItem.level), navItem);
-    var titleJsx = parseMarkdownMini(navItem.title);
-    var titleInNavJsx = parseMarkdownMini(navItem.titleInNav);
-    var iconSize = 25;
-    var icon = navItem.titleIcon && (React.createElement("img", { src: navItem.titleIcon, style: __assign({ height: iconSize, width: iconSize, marginRight: 8, marginLeft: 4 }, navItem.titleIconStyle) }));
+    const titleJsx = parseMarkdownMini(navItem.title);
+    const titleInNavJsx = parseMarkdownMini(navItem.titleInNav);
+    const iconSize = 25;
+    const icon = navItem.titleIcon && (React.createElement("img", { src: navItem.titleIcon, style: { height: iconSize, width: iconSize, marginRight: 8, marginLeft: 4, ...navItem.titleIconStyle } }));
     if (navItem.level === 1 || navItem.level === 4) {
         assert(navItem.url === undefined);
     }
     else {
-        var sectionTitle = jsxToTextContent(titleJsx);
+        const sectionTitle = jsxToTextContent(titleJsx);
         assertWarning(navItem.url, [
-            "".concat(jsxToTextContent(titleInNavJsx), " is missing a URL hash."),
-            "Add a URL hash with: `## ".concat(sectionTitle, "{#some-hash}`."),
+            `${jsxToTextContent(titleInNavJsx)} is missing a URL hash.`,
+            `Add a URL hash with: \`## ${sectionTitle}{#some-hash}\`.`,
             /* TO-DO/eventually: not implemented yet.
             `Use \`<h2 id="url-hash">${sectionTitle}</h2>\` instead of \`## ${sectionTitle}\`.`,
             */
         ].join(' '));
     }
-    var children = titleInNavJsx;
+    let children = titleInNavJsx;
     if (navItem.level === 1) {
         children = (React.createElement(React.Fragment, null,
             icon,
             children,
             React.createElement(Chevron, { className: "collapsible-icon", height: 9 })));
     }
-    var props = {
-        href: (_c = navItem.url) !== null && _c !== void 0 ? _c : undefined,
-        children: children,
-        onClick: onClick,
+    const props = {
+        href: navItem.url ?? undefined,
+        children,
+        onClick,
         className: [
             'nav-item',
             'nav-item-level-' + navItem.level,
@@ -59,45 +45,51 @@ function NavItemComponent(_a) {
             .join(' '),
     };
     if (navItem.level === 1) {
-        props.style = (_b = {},
-            _b['--category-color'] = navItem.color,
-            _b);
+        props.style = {
+            ['--category-color']: navItem.color,
+        };
     }
     if (navItem.level === 2 || navItem.level === 3) {
-        return React.createElement("a", __assign({}, props));
+        return React.createElement("a", { ...props });
     }
     else {
-        return React.createElement("span", __assign({}, props));
+        return React.createElement("span", { ...props });
     }
 }
 function getNavItemsWithComputed(navItems, currentUrl) {
-    var navItemIdx;
-    var navItemsWithComputed = navItems.map(function (navItem, i) {
+    let navItemIdx;
+    const navItemsWithComputed = navItems.map((navItem, i) => {
         assert([1, 2, 3, 4].includes(navItem.level), navItem);
-        var navItemPrevious = navItems[i - 1];
-        var navItemNext = navItems[i + 1];
-        var isActive = false;
+        const navItemPrevious = navItems[i - 1];
+        const navItemNext = navItems[i + 1];
+        let isActive = false;
         if (navItem.url === currentUrl) {
-            assert(navItem.level === 2, { currentUrl: currentUrl });
+            assert(navItem.level === 2, { currentUrl });
             assert(navItemIdx === undefined);
             navItemIdx = i;
             isActive = true;
         }
-        var isFirstOfItsKind = navItem.level !== (navItemPrevious === null || navItemPrevious === void 0 ? void 0 : navItemPrevious.level);
-        var isLastOfItsKind = navItem.level !== (navItemNext === null || navItemNext === void 0 ? void 0 : navItemNext.level);
-        var navItemComputed = __assign(__assign({}, navItem), { isActive: isActive, isRelevant: false, isFirstOfItsKind: isFirstOfItsKind, isLastOfItsKind: isLastOfItsKind });
+        const isFirstOfItsKind = navItem.level !== navItemPrevious?.level;
+        const isLastOfItsKind = navItem.level !== navItemNext?.level;
+        const navItemComputed = {
+            ...navItem,
+            isActive,
+            isRelevant: false,
+            isFirstOfItsKind,
+            isLastOfItsKind,
+        };
         return navItemComputed;
     });
     // Set `isRelevant`
     if (navItemIdx !== undefined) {
-        for (var i = navItemIdx; i >= 0; i--) {
-            var navItem = navItemsWithComputed[i];
+        for (let i = navItemIdx; i >= 0; i--) {
+            const navItem = navItemsWithComputed[i];
             navItem.isRelevant = true;
             if (navItem.level === 1)
                 break;
         }
-        for (var i = navItemIdx; i < navItemsWithComputed.length; i++) {
-            var navItem = navItemsWithComputed[i];
+        for (let i = navItemIdx; i < navItemsWithComputed.length; i++) {
+            const navItem = navItemsWithComputed[i];
             if (navItem.level === 1)
                 break;
             navItem.isRelevant = true;
@@ -106,6 +98,6 @@ function getNavItemsWithComputed(navItems, currentUrl) {
     return navItemsWithComputed;
 }
 function Chevron(props) {
-    return (React.createElement("svg", __assign({ viewBox: "0 0 512 292.52", xmlns: "http://www.w3.org/2000/svg" }, props),
+    return (React.createElement("svg", { viewBox: "0 0 512 292.52", xmlns: "http://www.w3.org/2000/svg", ...props },
         React.createElement("path", { fill: "#aaa", d: "M10.725 82.42L230.125 261.82c6.8 6.8 16.2 10.7 25.9 10.7s19.1-3.9 25.9-10.7l219.4-179.4c14.3-14.3 14.3-37.4 0-51.7s-37.4-14.3-51.7 0l-193.6 153.6-193.6-153.6c-14.3-14.3-37.4-14.3-51.7 0s-14.3 37.5 0 51.7z" })));
 }

package/dist/code-blocks/rehypeMetaToProps.d.ts

@@ -0,0 +1,35 @@
+export { rehypeMetaToProps, parseMetaString };
+import type { ElementData, Root } from 'hast';
+/**
+ * Rehype plugin to extract metadata from `<code>` blocks in markdown
+ * and attach them as props to the parent `<pre>` element.
+ *
+ * This allows using those props inside a custom `<Pre>` component.
+ *
+ * Example:
+ * ~~~mdx
+ * ```js foo="bar" hide_copy='true'
+ * export function add(a, b) {
+ *   return a + b
+ * }
+ * ```
+ * ~~~
+ * These props are then added to the `<pre>` element
+ */
+declare function rehypeMetaToProps(): (tree: Root) => void;
+/**
+ * Minimal parser for a metadata string into key-value pairs.
+ *
+ * Supports simple patterns: key or key="value".
+ *
+ * Keys must contain only letters, dashes, or underscores (no digits).
+ * Keys are converted to kebab-case. Values default to "true" if missing.
+ *
+ * Example:
+ *   parseMetaString('foo fooBar="value"')
+ *   => { foo: 'true', foo_bar: 'value' }
+ *
+ * @param metaString - The input metadata string.
+ * @returns A plain object of parsed key-value pairs.
+ */
+declare function parseMetaString(metaString: ElementData['meta']): Record<string, string>;

package/dist/code-blocks/rehypeMetaToProps.js

@@ -0,0 +1,62 @@
+export { rehypeMetaToProps, parseMetaString };
+import { visit } from 'unist-util-visit';
+/**
+ * Rehype plugin to extract metadata from `<code>` blocks in markdown
+ * and attach them as props to the parent `<pre>` element.
+ *
+ * This allows using those props inside a custom `<Pre>` component.
+ *
+ * Example:
+ * ~~~mdx
+ * ```js foo="bar" hide_copy='true'
+ * export function add(a, b) {
+ *   return a + b
+ * }
+ * ```
+ * ~~~
+ * These props are then added to the `<pre>` element
+ */
+function rehypeMetaToProps() {
+    return (tree) => {
+        visit(tree, 'element', (node, _index, parent) => {
+            if (node.tagName === 'code' && parent?.type === 'element' && parent.tagName === 'pre') {
+                const props = parseMetaString(node.data?.meta);
+                parent.properties ??= {};
+                parent.properties = { ...parent.properties, ...props };
+            }
+        });
+    };
+}
+/**
+ * Minimal parser for a metadata string into key-value pairs.
+ *
+ * Supports simple patterns: key or key="value".
+ *
+ * Keys must contain only letters, dashes, or underscores (no digits).
+ * Keys are converted to kebab-case. Values default to "true" if missing.
+ *
+ * Example:
+ *   parseMetaString('foo fooBar="value"')
+ *   => { foo: 'true', foo_bar: 'value' }
+ *
+ * @param metaString - The input metadata string.
+ * @returns A plain object of parsed key-value pairs.
+ */
+function parseMetaString(metaString) {
+    if (!metaString)
+        return {};
+    const props = {};
+    const keyValuePairRE = /([a-zA-Z_-]+)(?:=([^"'\s]+))?(?=\s|$)/g;
+    for (const match of metaString.matchAll(keyValuePairRE)) {
+        let [_, key, value] = match;
+        props[kebabCase(key)] = value || 'true';
+    }
+    return props;
+}
+// Simple function to convert a camelCase or PascalCase string to kebab-case.
+function kebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace('_', '-')
+        .toLowerCase();
+}

package/dist/code-blocks/remarkDetype.d.ts

@@ -0,0 +1,4 @@
+export { remarkDetype };
+import type { Root } from 'mdast';
+import type { VFile } from '@mdx-js/mdx/internal-create-format-aware-processors';
+declare function remarkDetype(): (tree: Root, file: VFile) => Promise<void>;

package/dist/code-blocks/remarkDetype.js

@@ -0,0 +1,164 @@
+export { remarkDetype };
+import { visit } from 'unist-util-visit';
+import { assertUsage } from '../utils/assert.js';
+import { parseMetaString } from './rehypeMetaToProps.js';
+import pc from '@brillout/picocolors';
+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: detype } = module.createRequire(import.meta.url)('detype');
+const prettierOptions = {
+    semi: false,
+    singleQuote: true,
+    trailingComma: 'none',
+};
+function remarkDetype() {
+    return async function transformer(tree, file) {
+        const code_nodes = [];
+        visit(tree, 'code', (node, index, parent) => {
+            if (!parent || typeof index === 'undefined')
+                return;
+            // Skip if `node.lang` is not ts, tsx, vue, or yaml
+            if (!['ts', 'tsx', 'vue', 'yaml'].includes(node.lang || ''))
+                return;
+            // Skip if 'ts-only' meta is present
+            if (node.meta?.includes('ts-only'))
+                return;
+            // Collect this node for post-processing
+            code_nodes.push({ codeBlock: node, index, parent });
+        });
+        for (const node of code_nodes.reverse()) {
+            if (node.codeBlock.lang === 'yaml') {
+                transformYaml(node);
+            }
+            else {
+                await transformTsToJs(node, file);
+            }
+        }
+    };
+}
+function transformYaml(node) {
+    const { codeBlock, index, parent } = node;
+    const codeBlockContentJs = replaceFileNameSuffixes(codeBlock.value);
+    // Skip wrapping if the YAML code block hasn't changed
+    if (codeBlockContentJs === codeBlock.value)
+        return;
+    const { position, ...rest } = codeBlock;
+    // Create a new code node for the JS version based on the modified YAML
+    const yamlJsCode = {
+        ...rest,
+        value: codeBlockContentJs,
+    };
+    // Wrap both the original YAML and `yamlJsCode` with <CodeSnippets>
+    const yamlContainer = {
+        type: 'mdxJsxFlowElement',
+        name: 'CodeSnippets',
+        children: [yamlJsCode, codeBlock],
+        attributes: [
+            {
+                name: 'hideToggle',
+                type: 'mdxJsxAttribute',
+            },
+        ],
+    };
+    parent.children.splice(index, 1, yamlContainer);
+}
+async function transformTsToJs(node, file) {
+    const { codeBlock, index, parent } = node;
+    const maxWidth = Number(parseMetaString(codeBlock.meta)['max-width']);
+    let codeBlockReplacedJs = replaceFileNameSuffixes(codeBlock.value);
+    let codeBlockContentJs = '';
+    // Remove TypeScript from the TS/TSX/Vue code node
+    try {
+        codeBlockContentJs = await detype(codeBlockReplacedJs, `some-dummy-filename.${codeBlock.lang}`, {
+            customizeBabelConfig(config) {
+                // Add `onlyRemoveTypeImports: true` to the internal `@babel/preset-typescript` config
+                // https://github.com/cyco130/detype/blob/46ec867e9efd31d31a312a215ca169bd6bff4726/src/transform.ts#L206
+                assertUsage(config.presets && config.presets.length === 1, 'Unexpected Babel config presets');
+                config.presets = [[config.presets[0], { onlyRemoveTypeImports: true }]];
+            },
+            removeTsComments: true,
+            prettierOptions: {
+                ...prettierOptions,
+                printWidth: maxWidth ? maxWidth : 99,
+            },
+        });
+    }
+    catch (error) {
+        // Log errors and return original content instead of throwing
+        console.error(pc.red(error.message));
+        console.error([
+            `Failed to transform the code block in: ${pc.bold(pc.blue(file.path))}.`,
+            "This likely happened due to invalid TypeScript syntax (see detype's error message above). You can either:",
+            '- Fix the code block syntax',
+            '- Set the code block language to js instead of ts',
+            '- Use custom meta or comments https://github.com/brillout/docpress#detype',
+        ].join('\n') + '\n');
+        return;
+    }
+    // Clean up both JS and TS code contents: correct diff comments (for js only) and apply custom magic comment replacements
+    codeBlockContentJs = cleanUpCode(codeBlockContentJs.trimEnd(), true);
+    codeBlock.value = cleanUpCode(codeBlock.value);
+    // No wrapping needed if JS and TS code are still identical
+    if (codeBlockContentJs === codeBlock.value)
+        return;
+    const { position, lang, ...rest } = codeBlock;
+    const attributes = [];
+    const jsCode = {
+        ...rest,
+        // The jsCode lang should be js|jsx|vue
+        lang: lang.replace('t', 'j'),
+        value: codeBlockContentJs,
+    };
+    // Add `hideToggle` attribute (prop) to `CodeSnippets` if the only change was replacing `.ts` with `.js`
+    if (codeBlockReplacedJs === codeBlockContentJs) {
+        attributes.push({
+            name: 'hideToggle',
+            type: 'mdxJsxAttribute',
+        });
+    }
+    // Wrap both the original `codeBlock` and `jsCode` with <CodeSnippets>
+    const container = {
+        type: 'mdxJsxFlowElement',
+        name: 'CodeSnippets',
+        children: [jsCode, codeBlock],
+        attributes,
+    };
+    parent.children.splice(index, 1, container);
+}
+// Replace all '.ts' extensions with '.js'
+function replaceFileNameSuffixes(codeBlockValue) {
+    return codeBlockValue.replaceAll('.ts', '.js');
+}
+function cleanUpCode(code, isJsCode = false) {
+    if (isJsCode) {
+        code = correctCodeDiffComments(code);
+    }
+    return processMagicComments(code);
+}
+function processMagicComments(code) {
+    // @detype-replace DummyLayout Layout
+    const renameCommentRE = /^\/\/\s@detype-replace\s([^ ]+) ([^ ]+)\n/gm;
+    const matches = Array.from(code.matchAll(renameCommentRE));
+    if (matches.length) {
+        for (let i = matches.length - 1; i >= 0; i--) {
+            const match = matches[i];
+            const [fullMatch, renameFrom, renameTo] = match;
+            code = code.split(fullMatch).join('').replaceAll(renameFrom, renameTo);
+        }
+    }
+    code = code.replaceAll('// @detype-uncomment ', '');
+    return code;
+}
+/**
+ * Correct code diff comments that detype() unexpectedly reformatted (using Prettier and Babel internally)
+ * after removing TypeScript.
+ * See https://github.com/brillout/docpress/pull/47#issuecomment-3263953899
+ * @param code Transformed Javascript code.
+ * @returns The corrected code.
+ */
+function correctCodeDiffComments(code) {
+    // Expected to match the code diff comments: `// [!code ++]` and `// [!code --]` started with newline and optional spaces
+    const codeDiffRE = /\n\s*\/\/\s\[!code.+\]/g;
+    return code.replaceAll(codeDiffRE, (codeDiff) => codeDiff.trimStart());
+}

package/dist/code-blocks/shikiTransformerAutoLinks.d.ts

@@ -0,0 +1,8 @@
+export { shikiTransformerAutoLinks };
+import type { ShikiTransformer } from 'shiki';
+/**
+ * A Shiki transformer that converts plain HTTPS URLs in code blocks into clickable `<a>` links.
+ *
+ * Inspired by `@jcayzac/shiki-transformer-autolinks`, but tailored for a narrower use case.
+ */
+declare function shikiTransformerAutoLinks(): ShikiTransformer;

package/dist/code-blocks/shikiTransformerAutoLinks.js

@@ -0,0 +1,51 @@
+export { shikiTransformerAutoLinks };
+const linkRE = /https:\/\/[^\s]*[^.,\s"'`]/g;
+/**
+ * A Shiki transformer that converts plain HTTPS URLs in code blocks into clickable `<a>` links.
+ *
+ * Inspired by `@jcayzac/shiki-transformer-autolinks`, but tailored for a narrower use case.
+ */
+function shikiTransformerAutoLinks() {
+    return {
+        name: 'docpress-shiki-autolinks',
+        span(span) {
+            if (span.children.length !== 1)
+                return;
+            let child = span.children[0];
+            if (child.type !== 'text')
+                return;
+            const links = [];
+            const matches = Array.from(child.value.matchAll(linkRE));
+            // Filter out URLs that contain `${...}`. e.g. `https://star-wars.brillout.com/api/films/${id}.json`.
+            const filtered = matches.filter(([href]) => !href.includes('${'));
+            if (filtered.length === 0)
+                return;
+            for (const match of filtered) {
+                const [href] = match;
+                links.unshift({ href, index: match.index });
+            }
+            const newChildren = [];
+            for (const { href, index } of links) {
+                const postIndex = index + href.length;
+                const postValue = child.value.slice(postIndex);
+                if (postValue.length > 0) {
+                    newChildren.unshift({ type: 'text', value: postValue });
+                }
+                newChildren.unshift({
+                    type: 'element',
+                    tagName: 'a',
+                    properties: { href },
+                    children: [{ type: 'text', value: href }],
+                });
+                child = {
+                    type: 'text',
+                    value: child.value.slice(0, index),
+                };
+            }
+            if (child.value.length > 0) {
+                newChildren.unshift(child);
+            }
+            span.children = newChildren;
+        },
+    };
+}

package/dist/components/CodeBlockTransformer.js

@@ -2,9 +2,8 @@ export { CodeBlockTransformer };
 import React from 'react';
 import { assert } from '../utils/server';
 import './CodeBlockTransformer.css';
-function CodeBlockTransformer(_a) {
-    var children = _a.children, lineBreak = _a.lineBreak;
+function CodeBlockTransformer({ children, lineBreak }) {
     assert(lineBreak === 'white-space' || lineBreak === 'break-word', '`lineBreak` is currently the only use case for <CodeBlockTransformer>');
-    var className = "with-line-break_".concat(lineBreak);
+    const className = `with-line-break_${lineBreak}`;
     return React.createElement("div", { className: className }, children);
 }

package/dist/components/Comment.js

@@ -1,6 +1,5 @@
 export { Comment };
 import React from 'react';
-function Comment(_a) {
-    var children = _a.children;
+function Comment({ children }) {
     return React.createElement(React.Fragment, null);
 }

package/dist/components/FileRemoved.js

@@ -2,25 +2,23 @@ export { FileRemoved };
 export { FileAdded };
 import React from 'react';
 // Styling defined in src/css/code/diff.css
-var classRemoved = [
+const classRemoved = [
     //
     'diff-entire-file',
     'diff-entire-file-removed',
 ].join(' ');
-var classAdded = [
+const classAdded = [
     //
     'diff-entire-file',
     'diff-entire-file-added',
 ].join(' ');
-function FileRemoved(_a) {
-    var children = _a.children;
+function FileRemoved({ children }) {
     return React.createElement("div", { className: classRemoved },
         " ",
         children,
         " ");
 }
-function FileAdded(_a) {
-    var children = _a.children;
+function FileAdded({ children }) {
     return React.createElement("div", { className: classAdded },
         " ",
         children,

package/dist/components/HorizontalLine.js

@@ -1,8 +1,7 @@
 export { HorizontalLine };
 import React from 'react';
 import { cls } from '../utils/cls';
-function HorizontalLine(_a) {
-    var primary = _a.primary;
+function HorizontalLine({ primary }) {
     return (React.createElement("div", { className: cls(primary && 'primary'), style: { textAlign: 'center' } },
         React.createElement("hr", { style: {
                 display: 'inline-block',

package/dist/components/ImportMeta.js

@@ -1,10 +1,9 @@
 import React from 'react';
 import { assert } from '../utils/server';
 export { ImportMeta };
-function ImportMeta(_a) {
-    var prop = _a.prop;
+function ImportMeta({ prop }) {
     assert(!prop.startsWith('import'));
     assert(!prop.startsWith('.'));
-    var text = 'imp' + 'ort.meta.' + prop;
+    const text = 'imp' + 'ort.meta.' + prop;
     return React.createElement("code", null, text);
 }