@elmethis/core 1.0.0-alpha.15 → 1.0.0-alpha.151

package/dist/components/others/ElmColorSample.vue.d.ts

@@ -0,0 +1,8 @@
+export interface ElmColorSampleProps {
+    /**
+     * The color to display.
+     */
+    color: string;
+}
+declare const _default: import('vue').DefineComponent<ElmColorSampleProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ElmColorSampleProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/others/ElmColorSample.vue.mjs

@@ -0,0 +1,10 @@
+import _sfc_main from "./ElmColorSample.vue2.mjs";
+import style0 from "./ElmColorSample.vue3.mjs";
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
+const cssModules = {
+  "$style": style0
+};
+const ElmColorSample = /* @__PURE__ */ _export_sfc(_sfc_main, [["__cssModules", cssModules], ["__scopeId", "data-v-9606dccc"]]);
+export {
+  ElmColorSample as default
+};

package/dist/components/others/ElmColorSample.vue2.mjs

@@ -0,0 +1,72 @@
+import { defineComponent, createElementBlock, openBlock, normalizeStyle, createVNode, withCtx, createElementVNode, unref, normalizeClass, toDisplayString, Transition, createBlock, createCommentVNode } from "vue";
+import { parseToRgb, parseToHsl, rgbToColorString } from "polished";
+import ElmTooltip from "../containments/ElmTooltip.vue.mjs";
+import { useClipboard } from "@vueuse/core";
+import { Icon } from "@iconify/vue";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ElmColorSample",
+  props: {
+    color: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { blue, green, red } = parseToRgb(props.color);
+    const { hue, saturation, lightness } = parseToHsl(props.color);
+    const hex = rgbToColorString(parseToRgb(props.color));
+    const rgb = `rgb(${red}, ${green}, ${blue})`;
+    const hsl = `hsl(${Math.floor(hue)}, ${Math.floor(saturation * 100)}%, ${Math.floor(lightness * 100)}%)`;
+    const { copy, copied } = useClipboard();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        style: normalizeStyle({ "--color": _ctx.color })
+      }, [
+        createVNode(ElmTooltip, null, {
+          original: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass(_ctx.$style["color-bg"]),
+              style: normalizeStyle({
+                "--background-color": _ctx.color
+              }),
+              onClick: _cache[0] || (_cache[0] = ($event) => unref(copy)(unref(hex)))
+            }, [
+              createVNode(Transition, null, {
+                default: withCtx(() => [
+                  unref(copied) ? (openBlock(), createBlock(unref(Icon), {
+                    key: 0,
+                    icon: "heroicons:check",
+                    style: { color: "white" },
+                    width: "16",
+                    height: "16"
+                  })) : createCommentVNode("", true)
+                ]),
+                _: 1
+              })
+            ], 6),
+            createElementVNode("div", {
+              class: normalizeClass(_ctx.$style.text),
+              onClick: _cache[1] || (_cache[1] = ($event) => unref(copy)(unref(hex)))
+            }, toDisplayString(unref(hex)), 3)
+          ]),
+          tooltip: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass(_ctx.$style.text),
+              onClick: _cache[2] || (_cache[2] = ($event) => unref(copy)(unref(hex)))
+            }, toDisplayString(unref(hex)), 3),
+            createElementVNode("div", {
+              class: normalizeClass(_ctx.$style.text),
+              onClick: _cache[3] || (_cache[3] = ($event) => unref(copy)(rgb))
+            }, toDisplayString(rgb), 2),
+            createElementVNode("div", {
+              class: normalizeClass(_ctx.$style.text),
+              onClick: _cache[4] || (_cache[4] = ($event) => unref(copy)(hsl))
+            }, toDisplayString(hsl), 2)
+          ]),
+          _: 1
+        })
+      ], 4);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/others/ElmColorSample.vue3.mjs

@@ -0,0 +1,9 @@
+const text = "_text_819fg_13";
+const style0 = {
+  "color-bg": "_color-bg_819fg_1",
+  text
+};
+export {
+  style0 as default,
+  text
+};

package/dist/components/others/ElmColorTable.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/vue3';
+import { default as ElmColorTable } from './ElmColorTable.vue';
+declare const meta: Meta<typeof ElmColorTable>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Primary: Story;

package/dist/components/others/ElmColorTable.vue.d.ts

@@ -0,0 +1,11 @@
+export interface ElmColorTableProps {
+    /**
+     * The colors to display.
+     */
+    colors: {
+        name: string;
+        code: string;
+    }[];
+}
+declare const _default: import('vue').DefineComponent<ElmColorTableProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ElmColorTableProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/others/ElmColorTable.vue.mjs

@@ -0,0 +1,10 @@
+import _sfc_main from "./ElmColorTable.vue2.mjs";
+import style0 from "./ElmColorTable.vue3.mjs";
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
+const cssModules = {
+  "$style": style0
+};
+const ElmColorTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__cssModules", cssModules]]);
+export {
+  ElmColorTable as default
+};

package/dist/components/others/ElmColorTable.vue2.mjs

@@ -0,0 +1,45 @@
+import { defineComponent, createElementBlock, openBlock, normalizeClass, Fragment, renderList, createElementVNode, normalizeStyle, toDisplayString, createVNode, unref } from "vue";
+import { darken } from "polished";
+import ElmColorSample from "./ElmColorSample.vue.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ElmColorTable",
+  props: {
+    colors: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(_ctx.$style.container)
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.colors, (color) => {
+          return openBlock(), createElementBlock("div", {
+            class: normalizeClass(_ctx.$style["row-container"])
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(_ctx.$style["color-name"]),
+              style: normalizeStyle({ "--color": color.code })
+            }, toDisplayString(color.name), 7),
+            (openBlock(), createElementBlock(Fragment, null, renderList([
+              -0.2,
+              -0.15,
+              -0.1,
+              -0.05,
+              0,
+              0.05,
+              0.1,
+              0.15,
+              0.2
+            ], (darkness) => {
+              return createVNode(ElmColorSample, {
+                color: unref(darken)(darkness, color.code)
+              }, null, 8, ["color"]);
+            }), 64))
+          ], 2);
+        }), 256))
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/others/ElmColorTable.vue3.mjs

@@ -0,0 +1,10 @@
+const container = "_container_2ivef_1";
+const style0 = {
+  container,
+  "row-container": "_row-container_2ivef_8",
+  "color-name": "_color-name_2ivef_15"
+};
+export {
+  container,
+  style0 as default
+};

package/dist/components/others/ElmTemplate.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/vue3';
+import { default as ElmTyping } from './ElmTyping.vue';
+declare const meta: Meta<typeof ElmTyping>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Primary: Story;

package/dist/components/others/ElmTyping.vue.d.ts

@@ -0,0 +1,4 @@
+export interface ElmTypingProps {
+}
+declare const _default: import('vue').DefineComponent<ElmTypingProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ElmTypingProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/renderer/ElmJsonRenderer.vue.d.ts

@@ -1,5 +1,4 @@
 import { ElmInlineTextProps } from '../inline/ElmInlineText.vue';
-import { ElmInlineCodeProps } from '../inline/ElmInlineCode.vue';
 import { ElmInlineLinkProps } from '../inline/ElmInlineLink.vue';
 import { ElmCalloutProps } from '../typography/ElmCallout.vue';
 import { ElmBulletedListProps } from '../typography/ElmBulletedList.vue';
@@ -28,134 +27,160 @@ import { ElmCheckboxProps } from '../form/ElmCheckbox.vue';
 import { ElmFileProps } from '../media/ElmFile.vue';
 import { ElmColumnProps } from '../containments/ElmColumn.vue';
 import { ElmColumnListProps } from '../containments/ElmColumnList.vue';
-type ComponentType = 'ElmInlineText' | 'ElmInlineCode' | 'ElmInlineLink' | 'ElmCallout' | 'ElmBulletedList' | 'ElmNumberedList' | 'ElmListItem' | 'ElmBlockQuote' | 'ElmDivider' | 'ElmHeading1' | 'ElmHeading2' | 'ElmHeading3' | 'ElmHeading4' | 'ElmHeading5' | 'ElmHeading6' | 'ElmCodeBlock' | 'ElmParagraph' | 'ElmTable' | 'ElmTableHeader' | 'ElmTableBody' | 'ElmTableRow' | 'ElmTableCell' | 'ElmKatex' | 'ElmImage' | 'ElmBookmark' | 'ElmToggle' | 'ElmCheckbox' | 'ElmFile' | 'ElmColumn' | 'ElmColumnList';
-type ComponentProps = ElmInlineTextProps | ElmInlineCodeProps | ElmInlineLinkProps | ElmCalloutProps | ElmBulletedListProps | ElmNumberedListProps | ElmListItemProps | ElmBlockQuoteProps | ElmDividerProps | ElmHeading1Props | ElmHeading2Props | ElmHeading3Props | ElmHeading4Props | ElmHeading5Props | ElmHeading6Props | ElmCodeBlockProps | ElmParagraphProps | ElmTableProps | ElmTableHeaderProps | ElmTableBodyProps | ElmTableRowProps | ElmTableCellProps | ElmKatexProps | ElmImageProps | ElmBookmarkProps | ElmToggleProps | ElmCheckboxProps | ElmFileProps | ElmColumnProps | ElmColumnListProps;
+type ComponentType = 'ElmInlineText' | 'ElmInlineLink' | 'ElmCallout' | 'ElmBulletedList' | 'ElmNumberedList' | 'ElmListItem' | 'ElmBlockQuote' | 'ElmDivider' | 'ElmHeading1' | 'ElmHeading2' | 'ElmHeading3' | 'ElmHeading4' | 'ElmHeading5' | 'ElmHeading6' | 'ElmCodeBlock' | 'ElmParagraph' | 'ElmTable' | 'ElmTableHeader' | 'ElmTableBody' | 'ElmTableRow' | 'ElmTableCell' | 'ElmKatex' | 'ElmImage' | 'ElmBookmark' | 'ElmToggle' | 'ElmCheckbox' | 'ElmFile' | 'ElmColumn' | 'ElmColumnList';
+type ComponentProps = ElmInlineTextProps | ElmInlineLinkProps | ElmCalloutProps | ElmBulletedListProps | ElmNumberedListProps | ElmListItemProps | ElmBlockQuoteProps | ElmDividerProps | ElmHeading1Props | ElmHeading2Props | ElmHeading3Props | ElmHeading4Props | ElmHeading5Props | ElmHeading6Props | ElmCodeBlockProps | ElmParagraphProps | ElmTableProps | ElmTableHeaderProps | ElmTableBodyProps | ElmTableRowProps | ElmTableCellProps | ElmKatexProps | ElmImageProps | ElmBookmarkProps | ElmToggleProps | ElmCheckboxProps | ElmFileProps | ElmColumnProps | ElmColumnListProps;
 interface JsonComponentBase {
     type: ComponentType;
+    id?: string;
     props?: ComponentProps;
     children?: JsonComponent[];
 }
 interface ElmInlineTextJsonComponent extends JsonComponentBase {
     type: 'ElmInlineText';
+    id?: string;
     props?: ElmInlineTextProps;
 }
-interface ElmInlineCodeJsonComponent extends JsonComponentBase {
-    type: 'ElmInlineCode';
-    props?: ElmInlineCodeProps;
-}
 interface ElmInlineLinkJsonComponent extends JsonComponentBase {
     type: 'ElmInlineLink';
+    id?: string;
     props?: ElmInlineLinkProps;
 }
 interface ElmCalloutJsonComponent extends JsonComponentBase {
     type: 'ElmCallout';
+    id?: string;
     props?: ElmCalloutProps;
 }
 interface ElmBulletedListJsonComponent extends JsonComponentBase {
     type: 'ElmBulletedList';
+    id?: string;
     props?: ElmBulletedListProps;
 }
 interface ElmNumberedListJsonComponent extends JsonComponentBase {
     type: 'ElmNumberedList';
+    id?: string;
     props?: ElmNumberedListProps;
 }
 interface ElmListItemJsonComponent extends JsonComponentBase {
     type: 'ElmListItem';
+    id?: string;
     props?: ElmListItemProps;
 }
 interface ElmBlockQuoteJsonComponent extends JsonComponentBase {
     type: 'ElmBlockQuote';
+    id?: string;
     props?: ElmBlockQuoteProps;
 }
 interface ElmDividerJsonComponent extends JsonComponentBase {
     type: 'ElmDivider';
+    id?: string;
     props?: ElmDividerProps;
 }
 interface ElmHeading1JsonComponent extends JsonComponentBase {
     type: 'ElmHeading1';
+    id?: string;
     props?: ElmHeading1Props;
 }
 interface ElmHeading2JsonComponent extends JsonComponentBase {
     type: 'ElmHeading2';
+    id?: string;
     props?: ElmHeading2Props;
 }
 interface ElmHeading3JsonComponent extends JsonComponentBase {
     type: 'ElmHeading3';
+    id?: string;
     props?: ElmHeading3Props;
 }
 interface ElmHeading4JsonComponent extends JsonComponentBase {
     type: 'ElmHeading4';
+    id?: string;
     props?: ElmHeading4Props;
 }
 interface ElmHeading5JsonComponent extends JsonComponentBase {
     type: 'ElmHeading5';
+    id?: string;
     props?: ElmHeading5Props;
 }
 interface ElmHeading6JsonComponent extends JsonComponentBase {
     type: 'ElmHeading6';
+    id?: string;
     props?: ElmHeading6Props;
 }
 interface ElmCodeBlockJsonComponent extends JsonComponentBase {
     type: 'ElmCodeBlock';
+    id?: string;
     props?: ElmCodeBlockProps;
 }
 interface ElmParagraphJsonComponent extends JsonComponentBase {
     type: 'ElmParagraph';
+    id?: string;
     props?: ElmParagraphProps;
 }
 interface ElmTableJsonComponent extends JsonComponentBase {
     type: 'ElmTable';
+    id?: string;
     props?: ElmTableProps;
 }
 interface ElmTableHeaderJsonComponent extends JsonComponentBase {
     type: 'ElmTableHeader';
+    id?: string;
     props?: ElmTableHeaderProps;
 }
 interface ElmTableBodyJsonComponent extends JsonComponentBase {
     type: 'ElmTableBody';
+    id?: string;
     props?: ElmTableBodyProps;
 }
 interface ElmTableRowJsonComponent extends JsonComponentBase {
     type: 'ElmTableRow';
+    id?: string;
     props?: ElmTableRowProps;
 }
 interface ElmTableCellJsonComponent extends JsonComponentBase {
     type: 'ElmTableCell';
+    id?: string;
     props?: ElmTableCellProps;
 }
 interface ElmKatexJsonComponent extends JsonComponentBase {
     type: 'ElmKatex';
+    id?: string;
     props?: ElmKatexProps;
 }
 interface ElmImageJsonComponent extends JsonComponentBase {
     type: 'ElmImage';
+    id?: string;
     props?: ElmImageProps;
 }
 interface ElmBookmarkJsonComponent extends JsonComponentBase {
     type: 'ElmBookmark';
+    id?: string;
     props?: ElmBookmarkProps;
 }
 interface ElmToggleJsonComponent extends JsonComponentBase {
     type: 'ElmToggle';
+    id?: string;
     props?: ElmToggleProps;
 }
 interface ElmCheckboxJsonComponent extends JsonComponentBase {
     type: 'ElmCheckbox';
+    id?: string;
     props?: ElmCheckboxProps;
 }
 interface ElmFileJsonComponent extends JsonComponentBase {
     type: 'ElmFile';
+    id?: string;
     props?: ElmFileProps;
 }
 interface ElmColumnJsonComponent extends JsonComponentBase {
     type: 'ElmColumn';
+    id?: string;
     props?: ElmColumnProps;
 }
 interface ElmColumnListJsonComponent extends JsonComponentBase {
     type: 'ElmColumnList';
+    id?: string;
     props?: ElmColumnListProps;
 }
-type JsonComponent = ElmInlineTextJsonComponent | ElmInlineCodeJsonComponent | ElmInlineLinkJsonComponent | ElmCalloutJsonComponent | ElmBulletedListJsonComponent | ElmNumberedListJsonComponent | ElmListItemJsonComponent | ElmBlockQuoteJsonComponent | ElmDividerJsonComponent | ElmHeading1JsonComponent | ElmHeading2JsonComponent | ElmHeading3JsonComponent | ElmHeading4JsonComponent | ElmHeading5JsonComponent | ElmHeading6JsonComponent | ElmCodeBlockJsonComponent | ElmParagraphJsonComponent | ElmTableJsonComponent | ElmTableHeaderJsonComponent | ElmTableBodyJsonComponent | ElmTableRowJsonComponent | ElmTableCellJsonComponent | ElmKatexJsonComponent | ElmImageJsonComponent | ElmBookmarkJsonComponent | ElmToggleJsonComponent | ElmCheckboxJsonComponent | ElmFileJsonComponent | ElmColumnJsonComponent | ElmColumnListJsonComponent;
+type JsonComponent = ElmInlineTextJsonComponent | ElmInlineLinkJsonComponent | ElmCalloutJsonComponent | ElmBulletedListJsonComponent | ElmNumberedListJsonComponent | ElmListItemJsonComponent | ElmBlockQuoteJsonComponent | ElmDividerJsonComponent | ElmHeading1JsonComponent | ElmHeading2JsonComponent | ElmHeading3JsonComponent | ElmHeading4JsonComponent | ElmHeading5JsonComponent | ElmHeading6JsonComponent | ElmCodeBlockJsonComponent | ElmParagraphJsonComponent | ElmTableJsonComponent | ElmTableHeaderJsonComponent | ElmTableBodyJsonComponent | ElmTableRowJsonComponent | ElmTableCellJsonComponent | ElmKatexJsonComponent | ElmImageJsonComponent | ElmBookmarkJsonComponent | ElmToggleJsonComponent | ElmCheckboxJsonComponent | ElmFileJsonComponent | ElmColumnJsonComponent | ElmColumnListJsonComponent;
 export interface ElmJsonRendererProps {
     json: JsonComponent[];
 }

package/dist/components/renderer/ElmJsonRenderer.vue.mjs

@@ -0,0 +1,96 @@
+import { defineComponent, markRaw, createBlock, openBlock, resolveDynamicComponent, h } from "vue";
+import ElmInlineText from "../inline/ElmInlineText.vue.mjs";
+import ElmInlineLink from "../inline/ElmInlineLink.vue.mjs";
+import ElmCallout from "../typography/ElmCallout.vue.mjs";
+import _sfc_main$5 from "../typography/ElmBulletedList.vue.mjs";
+/* empty css                                  */
+import _sfc_main$4 from "../typography/ElmNumberedList.vue.mjs";
+/* empty css                                  */
+import ElmListItem from "../typography/ElmListItem.vue.mjs";
+import ElmBlockQuote from "../typography/ElmBlockQuote.vue.mjs";
+import ElmDivider from "../typography/ElmDivider.vue.mjs";
+import ElmHeading1 from "../headings/ElmHeading1.vue.mjs";
+import ElmHeading2 from "../headings/ElmHeading2.vue.mjs";
+import ElmHeading3 from "../headings/ElmHeading3.vue.mjs";
+import ElmHeading4 from "../headings/ElmHeading4.vue.mjs";
+import ElmHeading5 from "../headings/ElmHeading5.vue.mjs";
+import ElmHeading6 from "../headings/ElmHeading6.vue.mjs";
+import ElmCodeBlock from "../code/ElmCodeBlock.vue.mjs";
+import ElmParagraph from "../typography/ElmParagraph.vue.mjs";
+import ElmTable from "../table/ElmTable.vue.mjs";
+import _sfc_main$3 from "../table/ElmTableHeader.vue.mjs";
+/* empty css                            */
+import _sfc_main$2 from "../table/ElmTableBody.vue.mjs";
+/* empty css                          */
+import _sfc_main$1 from "../table/ElmTableRow.vue.mjs";
+import ElmTableCell from "../table/ElmTableCell.vue.mjs";
+import ElmKatex from "../code/ElmKatex.vue.mjs";
+import ElmImage from "../media/ElmImage.vue.mjs";
+import ElmBookmark from "../navigation/ElmBookmark.vue.mjs";
+import ElmToggle from "../containments/ElmToggle.vue.mjs";
+import ElmCheckbox from "../form/ElmCheckbox.vue.mjs";
+import ElmFile from "../media/ElmFile.vue.mjs";
+import ElmColumn from "../containments/ElmColumn.vue.mjs";
+import ElmColumnList from "../containments/ElmColumnList.vue.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ElmJsonRenderer",
+  props: {
+    json: {}
+  },
+  setup(__props) {
+    const componentMap = {
+      ElmInlineText: markRaw(ElmInlineText),
+      ElmInlineLink: markRaw(ElmInlineLink),
+      ElmCallout: markRaw(ElmCallout),
+      ElmBulletedList: markRaw(_sfc_main$5),
+      ElmNumberedList: markRaw(_sfc_main$4),
+      ElmListItem: markRaw(ElmListItem),
+      ElmBlockQuote: markRaw(ElmBlockQuote),
+      ElmDivider: markRaw(ElmDivider),
+      ElmHeading1: markRaw(ElmHeading1),
+      ElmHeading2: markRaw(ElmHeading2),
+      ElmHeading3: markRaw(ElmHeading3),
+      ElmHeading4: markRaw(ElmHeading4),
+      ElmHeading5: markRaw(ElmHeading5),
+      ElmHeading6: markRaw(ElmHeading6),
+      ElmCodeBlock: markRaw(ElmCodeBlock),
+      ElmParagraph: markRaw(ElmParagraph),
+      ElmTable: markRaw(ElmTable),
+      ElmTableHeader: markRaw(_sfc_main$3),
+      ElmTableBody: markRaw(_sfc_main$2),
+      ElmTableRow: markRaw(_sfc_main$1),
+      ElmTableCell: markRaw(ElmTableCell),
+      ElmKatex: markRaw(ElmKatex),
+      ElmImage: markRaw(ElmImage),
+      ElmBookmark: markRaw(ElmBookmark),
+      ElmToggle: markRaw(ElmToggle),
+      ElmCheckbox: markRaw(ElmCheckbox),
+      ElmFile: markRaw(ElmFile),
+      ElmColumn: markRaw(ElmColumn),
+      ElmColumnList: markRaw(ElmColumnList)
+    };
+    const render = (json) => {
+      const vnodes = [];
+      for (const component of json) {
+        vnodes.push(
+          h(
+            componentMap[component.type],
+            { ...component.props, key: component.id },
+            () => {
+              if (component.children != null) {
+                return render(component.children);
+              }
+            }
+          )
+        );
+      }
+      return vnodes;
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(() => render(_ctx.json)));
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/renderer/ElmJsonRenderer.vue2.mjs

@@ -0,0 +1,4 @@
+import _sfc_main from "./ElmJsonRenderer.vue.mjs";
+export {
+  _sfc_main as default
+};

package/dist/components/renderer/ElmJsonRendererAsync.vue.d.ts

@@ -0,0 +1,3 @@
+import { ElmJsonRendererProps } from './ElmJsonRenderer.vue';
+declare const _default: import('vue').DefineComponent<ElmJsonRendererProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ElmJsonRendererProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/renderer/ElmJsonRendererAsync.vue.mjs

@@ -0,0 +1,24 @@
+import { defineComponent, ref, onMounted, nextTick, h, createBlock, openBlock, resolveDynamicComponent } from "vue";
+import _sfc_main$1 from "./ElmJsonRenderer.vue.mjs";
+import ElmBlockFallback from "../fallback/ElmBlockFallback.vue.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ElmJsonRendererAsync",
+  props: {
+    json: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const vnode = ref(null);
+    onMounted(() => {
+      nextTick(() => {
+        vnode.value = h(_sfc_main$1, { json: props.json });
+      });
+    });
+    return (_ctx, _cache) => {
+      return vnode.value != null ? (openBlock(), createBlock(resolveDynamicComponent(() => vnode.value), { key: 0 })) : (openBlock(), createBlock(ElmBlockFallback, { key: 1 }));
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/renderer/ElmJsonRendererAsync.vue2.mjs

@@ -0,0 +1,4 @@
+import _sfc_main from "./ElmJsonRendererAsync.vue.mjs";
+export {
+  _sfc_main as default
+};

package/dist/components/table/ElmTable.vue.d.ts

@@ -1,14 +1,20 @@
+import { Property } from 'csstype';
 export interface ElmTableProps {
+    /**
+     * The margin of the table.
+     */
+    margin?: Property.MarginBlock;
 }
 declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: {
         default?(_: {}): any;
     };
     refs: {};
-    attrs: Partial<{}>;
+    rootEl: HTMLTableElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<ElmTableProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ElmTableProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import('vue').DefineComponent<ElmTableProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ElmTableProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLTableElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/components/table/ElmTable.vue.mjs

@@ -0,0 +1,6 @@
+import _sfc_main from "./ElmTable.vue2.mjs";
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
+const ElmTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-6ed1a868"]]);
+export {
+  ElmTable as default
+};

package/dist/components/table/ElmTable.vue2.mjs

@@ -0,0 +1,22 @@
+import { defineComponent, createElementBlock, openBlock, normalizeStyle, renderSlot } from "vue";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ElmTable",
+  props: {
+    margin: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("table", {
+        class: "table",
+        style: normalizeStyle({
+          "--margin-block": _ctx.margin
+        })
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 4);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/table/ElmTableBody.vue.d.ts

@@ -1,14 +1,15 @@
 export interface ElmTableBodyProps {
 }
 declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: {
         default?(_: {}): any;
     };
     refs: {};
-    attrs: Partial<{}>;
+    rootEl: HTMLTableSectionElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<ElmTableBodyProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ElmTableBodyProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import('vue').DefineComponent<ElmTableBodyProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ElmTableBodyProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLTableSectionElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/components/table/ElmTableBody.vue.mjs

@@ -0,0 +1,15 @@
+import { defineComponent, createElementBlock, openBlock, renderSlot } from "vue";
+const _hoisted_1 = { class: "elmethis-table-header-body" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ElmTableBody",
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("tbody", _hoisted_1, [
+        renderSlot(_ctx.$slots, "default")
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/table/ElmTableBody.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./ElmTableBody.vue.mjs";
+/* empty css                   */
+export {
+  _sfc_main as default
+};

package/dist/components/table/ElmTableCell.vue.d.ts

@@ -10,11 +10,12 @@ export interface ElmTableCellProps {
     text?: string;
 }
 declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: {
         default?(_: {}): any;
     };
     refs: {};
-    attrs: Partial<{}>;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<ElmTableCellProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ElmTableCellProps> & Readonly<{}>, {

package/dist/components/table/ElmTableCell.vue.mjs

@@ -0,0 +1,6 @@
+import _sfc_main from "./ElmTableCell.vue2.mjs";
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
+const ElmTableCell = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-7bedd3ac"]]);
+export {
+  ElmTableCell as default
+};