vite-plugin-taro-runtime 0.7.0 → 0.7.1-beta.2

package/dist/components/dist/components/taro-radio-group-core.js

@@ -0,0 +1,99 @@
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
+
+var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RadioGroup_value;
+const RadioGroup = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.onChange = createEvent(this, "change", 7);
+    this.uniqueName = Date.now().toString(36);
+    _RadioGroup_value.set(this, void 0);
+    this.name = undefined;
+  }
+  function(e) {
+    e.stopPropagation();
+    if (e.target.tagName !== 'TARO-RADIO-CORE')
+      return;
+    const target = e.target;
+    if (target.checked) {
+      const childList = this.el.querySelectorAll('taro-radio-core');
+      childList.forEach(element => {
+        if (element !== target) {
+          element.checked = false;
+        }
+      });
+      __classPrivateFieldSet(this, _RadioGroup_value, e.detail.value, "f");
+      this.onChange.emit({
+        value: __classPrivateFieldGet(this, _RadioGroup_value, "f")
+      });
+    }
+  }
+  componentDidLoad() {
+    const childList = this.el.querySelectorAll('taro-radio-core');
+    childList.forEach((element) => {
+      element.setAttribute('name', this.name || this.uniqueName);
+    });
+    Object.defineProperty(this.el, 'value', {
+      get: () => {
+        if (!__classPrivateFieldGet(this, _RadioGroup_value, "f")) {
+          const childList = this.el.querySelectorAll('taro-radio-core');
+          __classPrivateFieldSet(this, _RadioGroup_value, this.getValues(childList), "f");
+        }
+        return __classPrivateFieldGet(this, _RadioGroup_value, "f");
+      },
+      configurable: true
+    });
+  }
+  getValues(childList) {
+    let val = '';
+    Array.from(childList)
+      .forEach(element => {
+      const checkbox = element.querySelector('input');
+      if (checkbox === null || checkbox === void 0 ? void 0 : checkbox.checked) {
+        val = checkbox.value || '';
+      }
+    });
+    return val;
+  }
+  render() {
+    return (h(Host, { class: 'weui-cells_radiogroup' }));
+  }
+  get el() { return this; }
+}, [0, "taro-radio-group-core", {
+    "name": [8]
+  }, [[0, "radiochange", "function"]]]);
+_RadioGroup_value = new WeakMap();
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["taro-radio-group-core"];
+  components.forEach(tagName => { switch (tagName) {
+    case "taro-radio-group-core":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, RadioGroup);
+      }
+      break;
+  } });
+}
+
+const TaroRadioGroupCore = RadioGroup;
+const defineCustomElement = defineCustomElement$1;
+
+export { RadioGroup as R, TaroRadioGroupCore, defineCustomElement };

package/dist/components/dist/components/taro-rich-text-core.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface TaroRichTextCore extends Components.TaroRichTextCore, HTMLElement {}
+export const TaroRichTextCore: {
+  prototype: TaroRichTextCore;
+  new (): TaroRichTextCore;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/dist/components/taro-rich-text-core.js

@@ -0,0 +1,93 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+
+const indexCss = "taro-rich-text-core{user-select:none}taro-rich-text-core[selectable=true],taro-rich-text-core[user-select=true]{user-select:text;display:block}taro-rich-text-core[space]{white-space:pre-wrap}taro-rich-text-core[space=ensp]{word-spacing:.5em}taro-rich-text-core[space=nbsp]{word-spacing:1em}";
+
+const RichText = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.renderNode = (node) => {
+      if ('type' in node && node.type === 'text') {
+        // nonsupport Html Entries
+        const content = (node.text || '').replace(/ /g, '\u00A0');
+        return content;
+      }
+      else if ('name' in node && node.name) {
+        const { name, attrs, children } = node;
+        const attributes = {};
+        let childList = [];
+        if (attrs && typeof attrs === 'object') {
+          for (const key in attrs) {
+            const val = attrs[key];
+            if (key === 'style' && typeof val === 'string') {
+              // stencil JSX style props only support object
+              const styles = val
+                .split(';')
+                .map(item => item.trim())
+                .filter(item => item);
+              const styleObj = {};
+              styles.forEach(item => {
+                if (!item)
+                  return;
+                const res = /(.+): *(.+)/g.exec(item);
+                if (!res)
+                  return;
+                const [, name, value] = res;
+                const styleName = name.replace(/-([a-z])/g, (...args) => args[1].toUpperCase());
+                styleObj[styleName] = value;
+              });
+              if (Object.keys(styleObj).length) {
+                attributes.style = styleObj;
+              }
+              continue;
+            }
+            attributes[key] = val;
+          }
+        }
+        if (children && children.length) {
+          childList = children.map(node => this.renderNode(node));
+        }
+        // @ts-ignore
+        return h(name, attributes, childList);
+      }
+      return null;
+    };
+    this.nodes = undefined;
+    this.selectable = false;
+    this.userSelect = false;
+    this.space = undefined;
+  }
+  render() {
+    const { nodes, renderNode } = this;
+    if (Array.isArray(nodes)) {
+      return (h(Host, null, nodes.map(node => renderNode(node))));
+    }
+    else {
+      return h(Host, { innerHTML: nodes });
+    }
+  }
+  static get style() { return indexCss; }
+}, [0, "taro-rich-text-core", {
+    "nodes": [1],
+    "selectable": [1028],
+    "userSelect": [1028, "user-select"],
+    "space": [1]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["taro-rich-text-core"];
+  components.forEach(tagName => { switch (tagName) {
+    case "taro-rich-text-core":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, RichText);
+      }
+      break;
+  } });
+}
+
+const TaroRichTextCore = RichText;
+const defineCustomElement = defineCustomElement$1;
+
+export { RichText as R, TaroRichTextCore, defineCustomElement };

package/dist/components/dist/components/taro-root-portal-core.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface TaroRootPortalCore extends Components.TaroRootPortalCore, HTMLElement {}
+export const TaroRootPortalCore: {
+  prototype: TaroRootPortalCore;
+  new (): TaroRootPortalCore;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/dist/components/taro-root-portal-core.js

@@ -0,0 +1,33 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { n as notSupport } from './helper.js';
+
+const RootPortal = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+  }
+  componentDidLoad() {
+    notSupport('RootPortal', this);
+  }
+  render() {
+    return (h(Host, null));
+  }
+}, [0, "taro-root-portal-core"]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["taro-root-portal-core"];
+  components.forEach(tagName => { switch (tagName) {
+    case "taro-root-portal-core":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, RootPortal);
+      }
+      break;
+  } });
+}
+
+const TaroRootPortalCore = RootPortal;
+const defineCustomElement = defineCustomElement$1;
+
+export { RootPortal as R, TaroRootPortalCore, defineCustomElement };

package/dist/components/dist/components/taro-rtc-room-core.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface TaroRtcRoomCore extends Components.TaroRtcRoomCore, HTMLElement {}
+export const TaroRtcRoomCore: {
+  prototype: TaroRtcRoomCore;
+  new (): TaroRtcRoomCore;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/dist/components/taro-rtc-room-core.js

@@ -0,0 +1,33 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { n as notSupport } from './helper.js';
+
+const RtcRoom = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+  }
+  componentDidLoad() {
+    notSupport('RtcRoom', this);
+  }
+  render() {
+    return (h(Host, null));
+  }
+}, [0, "taro-rtc-room-core"]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["taro-rtc-room-core"];
+  components.forEach(tagName => { switch (tagName) {
+    case "taro-rtc-room-core":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, RtcRoom);
+      }
+      break;
+  } });
+}
+
+const TaroRtcRoomCore = RtcRoom;
+const defineCustomElement = defineCustomElement$1;
+
+export { RtcRoom as R, TaroRtcRoomCore, defineCustomElement };

package/dist/components/dist/components/taro-rtc-room-item-core.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface TaroRtcRoomItemCore extends Components.TaroRtcRoomItemCore, HTMLElement {}
+export const TaroRtcRoomItemCore: {
+  prototype: TaroRtcRoomItemCore;
+  new (): TaroRtcRoomItemCore;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/dist/components/taro-rtc-room-item-core.js

@@ -0,0 +1,33 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { n as notSupport } from './helper.js';
+
+const RtcRoomItem = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+  }
+  componentDidLoad() {
+    notSupport('RtcRoomItem', this);
+  }
+  render() {
+    return (h(Host, null));
+  }
+}, [0, "taro-rtc-room-item-core"]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["taro-rtc-room-item-core"];
+  components.forEach(tagName => { switch (tagName) {
+    case "taro-rtc-room-item-core":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, RtcRoomItem);
+      }
+      break;
+  } });
+}
+
+const TaroRtcRoomItemCore = RtcRoomItem;
+const defineCustomElement = defineCustomElement$1;
+
+export { RtcRoomItem as R, TaroRtcRoomItemCore, defineCustomElement };

package/dist/components/dist/components/taro-scale-gesture-handler-core.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface TaroScaleGestureHandlerCore extends Components.TaroScaleGestureHandlerCore, HTMLElement {}
+export const TaroScaleGestureHandlerCore: {
+  prototype: TaroScaleGestureHandlerCore;
+  new (): TaroScaleGestureHandlerCore;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/dist/components/taro-scale-gesture-handler-core.js

@@ -0,0 +1,33 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { n as notSupport } from './helper.js';
+
+const ScaleGestureHandler = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+  }
+  componentDidLoad() {
+    notSupport('ScaleGestureHandler', this);
+  }
+  render() {
+    return (h(Host, null));
+  }
+}, [0, "taro-scale-gesture-handler-core"]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["taro-scale-gesture-handler-core"];
+  components.forEach(tagName => { switch (tagName) {
+    case "taro-scale-gesture-handler-core":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, ScaleGestureHandler);
+      }
+      break;
+  } });
+}
+
+const TaroScaleGestureHandlerCore = ScaleGestureHandler;
+const defineCustomElement = defineCustomElement$1;
+
+export { ScaleGestureHandler as S, TaroScaleGestureHandlerCore, defineCustomElement };

package/dist/components/dist/components/taro-script-core.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface TaroScriptCore extends Components.TaroScriptCore, HTMLElement {}
+export const TaroScriptCore: {
+  prototype: TaroScriptCore;
+  new (): TaroScriptCore;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/dist/components/taro-script-core.js

@@ -0,0 +1,33 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { n as notSupport } from './helper.js';
+
+const Script = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+  }
+  componentDidLoad() {
+    notSupport('Script', this);
+  }
+  render() {
+    return (h(Host, null));
+  }
+}, [0, "taro-script-core"]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["taro-script-core"];
+  components.forEach(tagName => { switch (tagName) {
+    case "taro-script-core":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, Script);
+      }
+      break;
+  } });
+}
+
+const TaroScriptCore = Script;
+const defineCustomElement = defineCustomElement$1;
+
+export { Script as S, TaroScriptCore, defineCustomElement };

package/dist/components/dist/components/taro-scroll-view-core.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface TaroScrollViewCore extends Components.TaroScrollViewCore, HTMLElement {}
+export const TaroScrollViewCore: {
+  prototype: TaroScrollViewCore;
+  new (): TaroScrollViewCore;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/dist/components/taro-scroll-view-core.js

@@ -0,0 +1,199 @@
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
+import { c as classnames } from './index2.js';
+import { d as debounce } from './index3.js';
+import { h as handleStencilNodes } from './helper.js';
+
+const indexCss = "taro-scroll-view-core{-webkit-overflow-scrolling:touch;width:100%;display:block}.taro-scroll-view__scroll-x{overflow:scroll hidden}.taro-scroll-view__scroll-y{overflow:hidden scroll}.taro-scroll--hidebar::-webkit-scrollbar{display:none}";
+
+function easeOutScroll(from, to, duration = 500, callback) {
+  if (from === to || typeof from !== 'number') {
+    return;
+  }
+  const change = to - from;
+  const sTime = Date.now();
+  const isLarger = to >= from;
+  function linear(t, b, c, d) {
+    return c * t / d + b;
+  }
+  function step() {
+    from = linear(Date.now() - sTime, from, change, duration);
+    if ((isLarger && from >= to) || (!isLarger && to >= from)) {
+      callback(to);
+      return;
+    }
+    callback(from);
+    requestAnimationFrame(step);
+  }
+  step();
+}
+const ScrollView = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.onScroll = createEvent(this, "scroll", 3);
+    this.onScrollToUpper = createEvent(this, "scrolltoupper", 3);
+    this.onScrollToLower = createEvent(this, "scrolltolower", 3);
+    this._scrollLeft = 0;
+    this._scrollTop = 0;
+    this.upperAndLower = debounce(() => {
+      const { offsetWidth, offsetHeight, scrollLeft, scrollTop, scrollHeight, scrollWidth } = this.el;
+      const lowerThreshold = Number(this.lowerThreshold);
+      const upperThreshold = Number(this.upperThreshold);
+      if (!isNaN(lowerThreshold) &&
+        ((this.scrollY && offsetHeight + scrollTop + lowerThreshold >= scrollHeight) ||
+          (this.scrollX && offsetWidth + scrollLeft + lowerThreshold >= scrollWidth))) {
+        this.onScrollToLower.emit({
+          direction: this.scrollX ? 'right' : (this.scrollY ? 'bottom' : '')
+        });
+      }
+      if (!isNaN(upperThreshold) &&
+        ((this.scrollY && scrollTop <= upperThreshold) ||
+          (this.scrollX && scrollLeft <= upperThreshold))) {
+        this.onScrollToUpper.emit({
+          direction: this.scrollX ? 'left' : (this.scrollY ? 'top' : '')
+        });
+      }
+    }, 200);
+    this.scrollX = false;
+    this.scrollY = false;
+    this.upperThreshold = 50;
+    this.lowerThreshold = 50;
+    this.mpScrollTop = undefined;
+    this.mpScrollLeft = undefined;
+    this.mpScrollIntoView = undefined;
+    this.mpScrollIntoViewAlignment = undefined;
+    this.animated = false;
+    this.enhanced = false;
+    this.showScrollbar = true;
+  }
+  watchScrollLeft(newVal) {
+    const left = Number(newVal);
+    const { animated } = this;
+    this.mpScrollToMethod({
+      left, animated
+    });
+  }
+  watchScrollTop(newVal) {
+    const top = Number(newVal);
+    const { animated } = this;
+    this.mpScrollToMethod({
+      top, animated
+    });
+  }
+  watchScrollIntoView(newVal) {
+    this.mpScrollIntoViewMethod(newVal);
+  }
+  handleScroll(e) {
+    var _a;
+    if (e instanceof CustomEvent)
+      return;
+    e.stopPropagation();
+    (_a = e.stopImmediatePropagation) === null || _a === void 0 ? void 0 : _a.call(e);
+    const { scrollLeft, scrollTop, scrollHeight, scrollWidth } = this.el;
+    this._scrollLeft = scrollLeft;
+    this._scrollTop = scrollTop;
+    this.upperAndLower();
+    this.onScroll.emit({
+      scrollLeft,
+      scrollTop,
+      scrollHeight,
+      scrollWidth
+    });
+  }
+  handleTouchMove(e) {
+    if (e instanceof CustomEvent)
+      return;
+    e.stopPropagation();
+  }
+  async mpScrollToMethod(object) {
+    let { top, left, duration, animated = false } = object;
+    if (this.scrollY && typeof top === 'number' && !isNaN(top) && top !== this._scrollTop) {
+      if (animated) {
+        easeOutScroll(this._scrollTop, top, duration, pos => (this.el.scrollTop = pos));
+      }
+      else {
+        this.el.scrollTop = top;
+      }
+      this._scrollTop = top;
+    }
+    if (this.scrollX && typeof left === 'number' && !isNaN(left) && left !== this._scrollLeft) {
+      if (animated) {
+        easeOutScroll(this._scrollLeft, left, duration, pos => (this.el.scrollLeft = pos));
+      }
+      else {
+        this.el.scrollLeft = left;
+      }
+      this._scrollLeft = left;
+    }
+  }
+  async mpScrollIntoViewMethod(selector) {
+    var _a;
+    if (typeof selector === 'string' && selector) {
+      (_a = document.querySelector(`#${selector}`)) === null || _a === void 0 ? void 0 : _a.scrollIntoView({
+        behavior: this.animated ? 'smooth' : 'auto',
+        block: this.scrollY ? (this.mpScrollIntoViewAlignment || 'center') : 'center',
+        inline: this.scrollX ? (this.mpScrollIntoViewAlignment || 'start') : 'start'
+      });
+    }
+  }
+  componentDidLoad() {
+    const top = Number(this.mpScrollTop);
+    const left = Number(this.mpScrollLeft);
+    const { animated } = this;
+    this.mpScrollToMethod({
+      top, left, animated
+    });
+  }
+  componentDidRender() {
+    handleStencilNodes(this.el);
+  }
+  render() {
+    const { scrollX, scrollY, enhanced, showScrollbar } = this;
+    const cls = classnames({
+      'taro-scroll-view__scroll-x': scrollX,
+      'taro-scroll-view__scroll-y': scrollY,
+      'taro-scroll--hidebar': enhanced === true && showScrollbar === false,
+      'taro-scroll--enhanced': enhanced === true
+    });
+    return (h(Host, { class: cls }, h("slot", null)));
+  }
+  get el() { return this; }
+  static get watchers() { return {
+    "mpScrollLeft": ["watchScrollLeft"],
+    "mpScrollTop": ["watchScrollTop"],
+    "mpScrollIntoView": ["watchScrollIntoView"]
+  }; }
+  static get style() { return indexCss; }
+}, [4, "taro-scroll-view-core", {
+    "scrollX": [4, "scroll-x"],
+    "scrollY": [4, "scroll-y"],
+    "upperThreshold": [8, "upper-threshold"],
+    "lowerThreshold": [8, "lower-threshold"],
+    "mpScrollTop": [520, "scroll-top"],
+    "mpScrollLeft": [520, "scroll-left"],
+    "mpScrollIntoView": [513, "scroll-into-view"],
+    "mpScrollIntoViewAlignment": [1, "scroll-into-view-alignment"],
+    "animated": [4, "scroll-with-animation"],
+    "enhanced": [4],
+    "showScrollbar": [4, "show-scrollbar"],
+    "mpScrollToMethod": [64],
+    "mpScrollIntoViewMethod": [64]
+  }, [[1, "scroll", "handleScroll"], [1, "touchmove", "handleTouchMove"]]]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["taro-scroll-view-core"];
+  components.forEach(tagName => { switch (tagName) {
+    case "taro-scroll-view-core":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, ScrollView);
+      }
+      break;
+  } });
+}
+
+const TaroScrollViewCore = ScrollView;
+const defineCustomElement = defineCustomElement$1;
+
+export { ScrollView as S, TaroScrollViewCore, defineCustomElement };

package/dist/components/dist/components/taro-share-element-core.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface TaroShareElementCore extends Components.TaroShareElementCore, HTMLElement {}
+export const TaroShareElementCore: {
+  prototype: TaroShareElementCore;
+  new (): TaroShareElementCore;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;