@uiw/react-md-editor 4.0.0 → 4.0.2

package/dist/mdeditor.js

@@ -266,7 +266,7 @@ var TYPE_DECLARATION = 'declaration';
  * @throws {TypeError}
  * @throws {Error}
  */
-module.exports = function(style, options) {
+module.exports = function (style, options) {
   if (typeof style !== 'string') {
     throw new TypeError('First argument must be a string');
   }
@@ -300,7 +300,7 @@ module.exports = function(style, options) {
    */
   function position() {
     var start = { line: lineno, column: column };
-    return function(node) {
+    return function (node) {
       node.position = new Position(start);
       whitespace();
       return node;
@@ -573,53 +573,54 @@ if (true) {
 
 /***/ }),
 
-/***/ 862:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+/***/ 209:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-var parse = __webpack_require__(812);
+"use strict";
 
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var inline_style_parser_1 = __importDefault(__webpack_require__(812));
 /**
  * Parses inline style to object.
  *
- * @example
- * // returns { 'line-height': '42' }
- * StyleToObject('line-height: 42;');
+ * @param style - Inline style.
+ * @param iterator - Iterator.
+ * @returns - Style object or null.
  *
- * @param  {String}      style      - The inline style.
- * @param  {Function}    [iterator] - The iterator function.
- * @return {null|Object}
+ * @example Parsing inline style to object:
+ *
+ * ```js
+ * import parse from 'style-to-object';
+ * parse('line-height: 42;'); // { 'line-height': '42' }
+ * ```
  */
 function StyleToObject(style, iterator) {
-  var output = null;
-  if (!style || typeof style !== 'string') {
-    return output;
-  }
-
-  var declaration;
-  var declarations = parse(style);
-  var hasIterator = typeof iterator === 'function';
-  var property;
-  var value;
-
-  for (var i = 0, len = declarations.length; i < len; i++) {
-    declaration = declarations[i];
-    property = declaration.property;
-    value = declaration.value;
-
-    if (hasIterator) {
-      iterator(property, value, declaration);
-    } else if (value) {
-      output || (output = {});
-      output[property] = value;
-    }
-  }
-
-  return output;
+    var styleObject = null;
+    if (!style || typeof style !== 'string') {
+        return styleObject;
+    }
+    var declarations = (0, inline_style_parser_1.default)(style);
+    var hasIterator = typeof iterator === 'function';
+    declarations.forEach(function (declaration) {
+        if (declaration.type !== 'declaration') {
+            return;
+        }
+        var property = declaration.property, value = declaration.value;
+        if (hasIterator) {
+            iterator(property, value, declaration);
+        }
+        else if (value) {
+            styleObject = styleObject || {};
+            styleObject[property] = value;
+        }
+    });
+    return styleObject;
 }
-
-module.exports = StyleToObject;
-module.exports["default"] = StyleToObject; // ESM support
-
+exports["default"] = StyleToObject;
+//# sourceMappingURL=index.js.map
 
 /***/ }),
 
@@ -850,27 +851,27 @@ function _typeof(o) {
 }
 ;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
 
-function _toPrimitive(input, hint) {
-  if (_typeof(input) !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (_typeof(res) !== "object") return res;
+function toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != _typeof(i)) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return (hint === "string" ? String : Number)(input);
+  return ("string" === r ? String : Number)(t);
 }
 ;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
 
 
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return _typeof(key) === "symbol" ? key : String(key);
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : String(i);
 }
 ;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/defineProperty.js
 
 function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
+  key = toPropertyKey(key);
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -1101,6 +1102,69 @@ function stringify(values, options) {
     .trim()
 }
 
+;// CONCATENATED MODULE: ../node_modules/estree-util-is-identifier-name/lib/index.js
+/**
+ * @typedef Options
+ *   Configuration.
+ * @property {boolean | null | undefined} [jsx=false]
+ *   Support JSX identifiers (default: `false`).
+ */
+
+const startRe = /[$_\p{ID_Start}]/u
+const contRe = /[$_\u{200C}\u{200D}\p{ID_Continue}]/u
+const contReJsx = /[-$_\u{200C}\u{200D}\p{ID_Continue}]/u
+const nameRe = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u
+const nameReJsx = /^[$_\p{ID_Start}][-$_\u{200C}\u{200D}\p{ID_Continue}]*$/u
+
+/** @type {Options} */
+const emptyOptions = {}
+
+/**
+ * Checks if the given code point can start an identifier.
+ *
+ * @param {number | undefined} code
+ *   Code point to check.
+ * @returns {boolean}
+ *   Whether `code` can start an identifier.
+ */
+// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.
+function start(code) {
+  return code ? startRe.test(String.fromCodePoint(code)) : false
+}
+
+/**
+ * Checks if the given code point can continue an identifier.
+ *
+ * @param {number | undefined} code
+ *   Code point to check.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {boolean}
+ *   Whether `code` can continue an identifier.
+ */
+// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.
+function cont(code, options) {
+  const settings = options || emptyOptions
+  const re = settings.jsx ? contReJsx : contRe
+  return code ? re.test(String.fromCodePoint(code)) : false
+}
+
+/**
+ * Checks if the given value is a valid identifier name.
+ *
+ * @param {string} name
+ *   Identifier to check.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {boolean}
+ *   Whether `name` can be an identifier.
+ */
+function lib_name(name, options) {
+  const settings = options || emptyOptions
+  const re = settings.jsx ? nameReJsx : nameRe
+  return re.test(name)
+}
+
 ;// CONCATENATED MODULE: ../node_modules/hast-util-whitespace/lib/index.js
 /**
  * @typedef {import('hast').Nodes} Nodes
@@ -2500,12 +2564,13 @@ function space_separated_tokens_stringify(values) {
   return values.join(' ').trim()
 }
 
-// EXTERNAL MODULE: ../node_modules/style-to-object/index.js
-var style_to_object = __webpack_require__(862);
-;// CONCATENATED MODULE: ../node_modules/style-to-object/index.mjs
+// EXTERNAL MODULE: ../node_modules/style-to-object/cjs/index.js
+var cjs = __webpack_require__(209);
+;// CONCATENATED MODULE: ../node_modules/style-to-object/esm/index.mjs
 
 
-/* harmony default export */ const node_modules_style_to_object = (style_to_object);
+// ensure compatibility with rollup umd build
+/* harmony default export */ const esm = (cjs["default"] || cjs);
 
 ;// CONCATENATED MODULE: ../node_modules/unist-util-position/lib/index.js
 /**
@@ -3011,13 +3076,36 @@ VFileMessage.prototype.ruleId = undefined
 VFileMessage.prototype.source = undefined
 
 ;// CONCATENATED MODULE: ../node_modules/hast-util-to-jsx-runtime/lib/index.js
+// Register MDX nodes in mdast:
+/// <reference types="mdast-util-mdx-expression" />
+/// <reference types="mdast-util-mdx-jsx" />
+/// <reference types="mdast-util-mdxjs-esm" />
+
 /**
+ * @typedef {import('estree').Identifier} Identifier
+ * @typedef {import('estree').Literal} Literal
+ * @typedef {import('estree').MemberExpression} MemberExpression
+ * @typedef {import('estree').Expression} Expression
+ * @typedef {import('estree').Program} Program
+ *
  * @typedef {import('hast').Element} Element
  * @typedef {import('hast').Nodes} Nodes
  * @typedef {import('hast').Parents} Parents
+ * @typedef {import('hast').Root} Root
+ * @typedef {import('hast').Text} Text
+ *
+ * @typedef {import('mdast-util-mdx-expression').MdxFlowExpressionHast} MdxFlowExpression
+ * @typedef {import('mdast-util-mdx-expression').MdxTextExpressionHast} MdxTextExpression
+ *
+ * @typedef {import('mdast-util-mdx-jsx').MdxJsxFlowElementHast} MdxJsxFlowElement
+ * @typedef {import('mdast-util-mdx-jsx').MdxJsxTextElementHast} MdxJsxTextElement
+ *
+ * @typedef {import('mdast-util-mdxjs-esm').MdxjsEsmHast} MdxjsEsm
  *
  * @typedef {import('property-information').Schema} Schema
  *
+ * @typedef {import('unist').Position} Position
+ *
  * @typedef {import('./components.js').Components} Components
  */
 
@@ -3038,12 +3126,40 @@ VFileMessage.prototype.source = undefined
  * @returns {JSX.Element}
  *   Result.
  *
+ * @callback CreateEvaluater
+ *   Create an evaluator that turns ESTree ASTs from embedded MDX into values.
+ * @returns {Evaluater}
+ *   Evaluater.
+ *
  * @typedef {'html' | 'react'} ElementAttributeNameCase
  *   Casing to use for attribute names.
  *
  *   HTML casing is for example `class`, `stroke-linecap`, `xml:lang`.
  *   React casing is for example `className`, `strokeLinecap`, `xmlLang`.
  *
+ * @callback EvaluateExpression
+ *   Turn an MDX expression into a value.
+ * @param {Expression} expression
+ *   ESTree expression.
+ * @returns {unknown}
+ *   Result of expression.
+ *
+ * @callback EvaluateProgram
+ *   Turn an MDX program (export/import statements) into a value.
+ * @param {Program} expression
+ *   ESTree program.
+ * @returns {unknown}
+ *   Result of program;
+ *   should likely be `undefined` as ESM changes the scope but doesn’t yield
+ *   something.
+ *
+ * @typedef Evaluater
+ *   Evaluator that turns ESTree ASTs from embedded MDX into values.
+ * @property {EvaluateExpression} evaluateExpression
+ *   Evaluate an expression.
+ * @property {EvaluateProgram} evaluateProgram
+ *   Evaluate a program.
+ *
  * @typedef {[string, Value]} Field
  *   Property field.
  *
@@ -3059,7 +3175,7 @@ VFileMessage.prototype.source = undefined
  * @param {string | undefined} [key]
  *   Dynamicly generated key to use.
  * @returns {JSX.Element}
- *   An element from your framework.
+ *   Element from your framework.
  *
  * @callback JsxDev
  *   Create a development element.
@@ -3077,15 +3193,17 @@ VFileMessage.prototype.source = undefined
  * @param {undefined} self
  *   Nothing (this is used by frameworks that have components, we don’t).
  * @returns {JSX.Element}
- *   An element from your framework.
+ *   Element from your framework.
  *
- * @typedef {{children?: Array<Child> | Child, node?: Element | undefined, [prop: string]: Array<Child> | Child | Element | Value | undefined}} Props
+ * @typedef {{children?: Array<Child> | Child, node?: Element | MdxJsxFlowElement | MdxJsxTextElement | undefined, [prop: string]: Array<Child> | Child | Element | MdxJsxFlowElement | MdxJsxTextElement | Value | undefined}} Props
  *   Properties and children.
  *
  * @typedef RegularFields
  *   Configuration.
  * @property {Partial<Components> | null | undefined} [components]
  *   Components to use (optional).
+ * @property {CreateEvaluater | null | undefined} [createEvaluater]
+ *   Create an evaluator that turns ESTree ASTs into values (optional).
  * @property {ElementAttributeNameCase | null | undefined} [elementAttributeNameCase='react']
  *   Specify casing to use for attribute names (default: `'react'`).
  * @property {string | null | undefined} [filePath]
@@ -3184,6 +3302,8 @@ VFileMessage.prototype.source = undefined
  *   Create something in development or production.
  * @property {ElementAttributeNameCase} elementAttributeNameCase
  *   Casing to use for attribute names.
+ * @property {Evaluater | undefined} evaluater
+ *   Evaluator that turns ESTree ASTs into values.
  * @property {string | undefined} filePath
  *   File path.
  * @property {boolean} ignoreInvalidStyle
@@ -3231,6 +3351,8 @@ VFileMessage.prototype.source = undefined
 
 
 
+
+
 const lib_own = {}.hasOwnProperty
 
 /** @type {Map<string, number>} */
@@ -3254,6 +3376,8 @@ const tableElements = new Set(['table', 'tbody', 'thead', 'tfoot', 'tr'])
 
 const tableCellElement = new Set(['td', 'th'])
 
+const docs = 'https://github.com/syntax-tree/hast-util-to-jsx-runtime'
+
 /**
  * Transform a hast tree to preact, react, solid, svelte, vue, etc.,
  * with an automatic JSX runtime.
@@ -3302,6 +3426,7 @@ function toJsxRuntime(tree, options) {
     components: options.components || {},
     create,
     elementAttributeNameCase: options.elementAttributeNameCase || 'react',
+    evaluater: options.createEvaluater ? options.createEvaluater() : undefined,
     filePath,
     ignoreInvalidStyle: options.ignoreInvalidStyle || false,
     passKeys: options.passKeys !== false,
@@ -3340,67 +3465,233 @@ function toJsxRuntime(tree, options) {
  *   Child, optional.
  */
 function one(state, node, key) {
-  if (node.type === 'element' || node.type === 'root') {
-    const parentSchema = state.schema
-    let schema = parentSchema
+  if (node.type === 'element') {
+    return lib_element(state, node, key)
+  }
 
-    if (
-      node.type === 'element' &&
-      node.tagName.toLowerCase() === 'svg' &&
-      parentSchema.space === 'html'
-    ) {
-      schema = property_information_svg
-      state.schema = schema
-    }
+  if (node.type === 'mdxFlowExpression' || node.type === 'mdxTextExpression') {
+    return mdxExpression(state, node)
+  }
 
-    state.ancestors.push(node)
+  if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+    return mdxJsxElement(state, node, key)
+  }
 
-    let children = createChildren(state, node)
-    const props = createProperties(state, state.ancestors)
-    let type = state.Fragment
+  if (node.type === 'mdxjsEsm') {
+    return mdxEsm(state, node)
+  }
 
-    state.ancestors.pop()
+  if (node.type === 'root') {
+    return root(state, node, key)
+  }
 
-    if (node.type === 'element') {
-      if (children && tableElements.has(node.tagName)) {
-        children = children.filter(function (child) {
-          return typeof child === 'string' ? !whitespace(child) : true
-        })
-      }
+  if (node.type === 'text') {
+    return lib_text(state, node)
+  }
+}
 
-      if (lib_own.call(state.components, node.tagName)) {
-        const key = /** @type {keyof JSX.IntrinsicElements} */ (node.tagName)
-        type = state.components[key]
+/**
+ * Handle element.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Element} node
+ *   Current node.
+ * @param {string | undefined} key
+ *   Key.
+ * @returns {Child | undefined}
+ *   Child, optional.
+ */
+function lib_element(state, node, key) {
+  const parentSchema = state.schema
+  let schema = parentSchema
 
-        // If this is swapped out for a component:
-        if (
-          typeof type !== 'string' &&
-          type !== state.Fragment &&
-          state.passNode
-        ) {
-          props.node = node
-        }
-      } else {
-        type = node.tagName
-      }
-    }
+  if (node.tagName.toLowerCase() === 'svg' && parentSchema.space === 'html') {
+    schema = property_information_svg
+    state.schema = schema
+  }
 
-    if (children.length > 0) {
-      const value = children.length > 1 ? children : children[0]
+  state.ancestors.push(node)
 
-      if (value) {
-        props.children = value
-      }
-    }
+  const type = findComponentFromName(state, node.tagName, false)
+  const props = createElementProps(state, node)
+  let children = createChildren(state, node)
+
+  if (tableElements.has(node.tagName)) {
+    children = children.filter(function (child) {
+      return typeof child === 'string' ? !whitespace(child) : true
+    })
+  }
+
+  addNode(state, props, type, node)
+  addChildren(props, children)
 
-    // Restore parent schema.
-    state.schema = parentSchema
+  // Restore.
+  state.ancestors.pop()
+  state.schema = parentSchema
 
-    return state.create(node, type, props, key)
+  return state.create(node, type, props, key)
+}
+
+/**
+ * Handle MDX expression.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdxFlowExpression | MdxTextExpression} node
+ *   Current node.
+ * @returns {Child | undefined}
+ *   Child, optional.
+ */
+function mdxExpression(state, node) {
+  if (node.data && node.data.estree && state.evaluater) {
+    const program = node.data.estree
+    const expression = program.body[0]
+    ok(expression.type === 'ExpressionStatement')
+
+    // Assume result is a child.
+    return /** @type {Child | undefined} */ (
+      state.evaluater.evaluateExpression(expression.expression)
+    )
   }
 
-  if (node.type === 'text') {
-    return node.value
+  crashEstree(state, node.position)
+}
+
+/**
+ * Handle MDX ESM.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdxjsEsm} node
+ *   Current node.
+ * @returns {Child | undefined}
+ *   Child, optional.
+ */
+function mdxEsm(state, node) {
+  if (node.data && node.data.estree && state.evaluater) {
+    // Assume result is a child.
+    return /** @type {Child | undefined} */ (
+      state.evaluater.evaluateProgram(node.data.estree)
+    )
+  }
+
+  crashEstree(state, node.position)
+}
+
+/**
+ * Handle MDX JSX.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdxJsxFlowElement | MdxJsxTextElement} node
+ *   Current node.
+ * @param {string | undefined} key
+ *   Key.
+ * @returns {Child | undefined}
+ *   Child, optional.
+ */
+function mdxJsxElement(state, node, key) {
+  const parentSchema = state.schema
+  let schema = parentSchema
+
+  if (node.name === 'svg' && parentSchema.space === 'html') {
+    schema = property_information_svg
+    state.schema = schema
+  }
+
+  state.ancestors.push(node)
+
+  const type =
+    node.name === null
+      ? state.Fragment
+      : findComponentFromName(state, node.name, true)
+  const props = createJsxElementProps(state, node)
+  const children = createChildren(state, node)
+
+  addNode(state, props, type, node)
+  addChildren(props, children)
+
+  // Restore.
+  state.ancestors.pop()
+  state.schema = parentSchema
+
+  return state.create(node, type, props, key)
+}
+
+/**
+ * Handle root.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Root} node
+ *   Current node.
+ * @param {string | undefined} key
+ *   Key.
+ * @returns {Child | undefined}
+ *   Child, optional.
+ */
+function root(state, node, key) {
+  /** @type {Props} */
+  const props = {}
+
+  addChildren(props, createChildren(state, node))
+
+  return state.create(node, state.Fragment, props, key)
+}
+
+/**
+ * Handle text.
+ *
+ * @param {State} _
+ *   Info passed around.
+ * @param {Text} node
+ *   Current node.
+ * @returns {Child | undefined}
+ *   Child, optional.
+ */
+function lib_text(_, node) {
+  return node.value
+}
+
+/**
+ * Add `node` to props.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Props} props
+ *   Props.
+ * @param {unknown} type
+ *   Type.
+ * @param {Element | MdxJsxFlowElement | MdxJsxTextElement} node
+ *   Node.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function addNode(state, props, type, node) {
+  // If this is swapped out for a component:
+  if (typeof type !== 'string' && type !== state.Fragment && state.passNode) {
+    props.node = node
+  }
+}
+
+/**
+ * Add children to props.
+ *
+ * @param {Props} props
+ *   Props.
+ * @param {Array<Child>} children
+ *   Children.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function addChildren(props, children) {
+  if (children.length > 0) {
+    const value = children.length > 1 ? children : children[0]
+
+    if (value) {
+      props.children = value
+    }
   }
 }
 
@@ -3456,108 +3747,169 @@ function developmentCreate(filePath, jsxDEV) {
 }
 
 /**
- * Create children.
+ * Create props from an element.
  *
  * @param {State} state
  *   Info passed around.
- * @param {Parents} node
+ * @param {Element} node
  *   Current element.
- * @returns {Array<Child>}
- *   Children.
+ * @returns {Props}
+ *   Props.
  */
-function createChildren(state, node) {
-  /** @type {Array<Child>} */
-  const children = []
-  let index = -1
-  /** @type {Map<string, number>} */
-  // Note: test this when Solid doesn’t want to merge my upcoming PR.
-  /* c8 ignore next */
-  const countsByTagName = state.passKeys ? new Map() : emptyMap
+function createElementProps(state, node) {
+  /** @type {Props} */
+  const props = {}
+  /** @type {string | undefined} */
+  let alignValue
+  /** @type {string} */
+  let prop
 
-  while (++index < node.children.length) {
-    const child = node.children[index]
-    /** @type {string | undefined} */
-    let key
+  for (prop in node.properties) {
+    if (prop !== 'children' && lib_own.call(node.properties, prop)) {
+      const result = createProperty(state, prop, node.properties[prop])
+
+      if (result) {
+        const [key, value] = result
 
-    if (state.passKeys && child.type === 'element') {
-      const count = countsByTagName.get(child.tagName) || 0
-      key = child.tagName + '-' + count
-      countsByTagName.set(child.tagName, count + 1)
+        if (
+          state.tableCellAlignToStyle &&
+          key === 'align' &&
+          typeof value === 'string' &&
+          tableCellElement.has(node.tagName)
+        ) {
+          alignValue = value
+        } else {
+          props[key] = value
+        }
+      }
     }
+  }
 
-    const result = one(state, child, key)
-    if (result !== undefined) children.push(result)
+  if (alignValue) {
+    // Assume style is an object.
+    const style = /** @type {Style} */ (props.style || (props.style = {}))
+    style[state.stylePropertyNameCase === 'css' ? 'text-align' : 'textAlign'] =
+      alignValue
   }
 
-  return children
+  return props
 }
 
 /**
- * Handle properties.
+ * Create props from a JSX element.
  *
  * @param {State} state
  *   Info passed around.
- * @param {Array<Parents>} ancestors
- *   Stack of parents.
+ * @param {MdxJsxFlowElement | MdxJsxTextElement} node
+ *   Current JSX element.
  * @returns {Props}
- *   Props for runtime.
+ *   Props.
  */
-function createProperties(state, ancestors) {
-  const node = ancestors[ancestors.length - 1]
+function createJsxElementProps(state, node) {
   /** @type {Props} */
   const props = {}
-  /** @type {string} */
-  let prop
-
-  if ('properties' in node && node.properties) {
-    /** @type {string | undefined} */
-    let alignValue
 
-    for (prop in node.properties) {
-      if (prop !== 'children' && lib_own.call(node.properties, prop)) {
-        const result = createProperty(
-          state,
-          ancestors,
-          prop,
-          node.properties[prop]
+  for (const attribute of node.attributes) {
+    if (attribute.type === 'mdxJsxExpressionAttribute') {
+      if (attribute.data && attribute.data.estree && state.evaluater) {
+        const program = attribute.data.estree
+        const expression = program.body[0]
+        ok(expression.type === 'ExpressionStatement')
+        const objectExpression = expression.expression
+        ok(objectExpression.type === 'ObjectExpression')
+        const property = objectExpression.properties[0]
+        ok(property.type === 'SpreadElement')
+
+        Object.assign(
+          props,
+          state.evaluater.evaluateExpression(property.argument)
         )
+      } else {
+        crashEstree(state, node.position)
+      }
+    } else {
+      // For JSX, the author is responsible of passing in the correct values.
+      const name = attribute.name
+      /** @type {unknown} */
+      let value
 
-        if (result) {
-          const [key, value] = result
-
-          if (
-            state.tableCellAlignToStyle &&
-            key === 'align' &&
-            typeof value === 'string' &&
-            tableCellElement.has(node.tagName)
-          ) {
-            alignValue = value
-          } else {
-            props[key] = value
-          }
+      if (attribute.value && typeof attribute.value === 'object') {
+        if (
+          attribute.value.data &&
+          attribute.value.data.estree &&
+          state.evaluater
+        ) {
+          const program = attribute.value.data.estree
+          const expression = program.body[0]
+          ok(expression.type === 'ExpressionStatement')
+          value = state.evaluater.evaluateExpression(expression.expression)
+        } else {
+          crashEstree(state, node.position)
         }
+      } else {
+        value = attribute.value === null ? true : attribute.value
       }
-    }
 
-    if (alignValue) {
-      // Assume style is an object.
-      const style = /** @type {Style} */ (props.style || (props.style = {}))
-      style[
-        state.stylePropertyNameCase === 'css' ? 'text-align' : 'textAlign'
-      ] = alignValue
+      // Assume a prop.
+      props[name] = /** @type {Props[keyof Props]} */ (value)
     }
   }
 
   return props
 }
 
+/**
+ * Create children.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Parents} node
+ *   Current element.
+ * @returns {Array<Child>}
+ *   Children.
+ */
+function createChildren(state, node) {
+  /** @type {Array<Child>} */
+  const children = []
+  let index = -1
+  /** @type {Map<string, number>} */
+  // Note: test this when Solid doesn’t want to merge my upcoming PR.
+  /* c8 ignore next */
+  const countsByName = state.passKeys ? new Map() : emptyMap
+
+  while (++index < node.children.length) {
+    const child = node.children[index]
+    /** @type {string | undefined} */
+    let key
+
+    if (state.passKeys) {
+      const name =
+        child.type === 'element'
+          ? child.tagName
+          : child.type === 'mdxJsxFlowElement' ||
+              child.type === 'mdxJsxTextElement'
+            ? child.name
+            : undefined
+
+      if (name) {
+        const count = countsByName.get(name) || 0
+        key = name + '-' + count
+        countsByName.set(name, count + 1)
+      }
+    }
+
+    const result = one(state, child, key)
+    if (result !== undefined) children.push(result)
+  }
+
+  return children
+}
+
 /**
  * Handle a property.
  *
  * @param {State} state
  *   Info passed around.
- * @param {Array<Parents>} ancestors
- *   Stack of parents.
  * @param {string} prop
  *   Key.
  * @param {Array<number | string> | boolean | number | string | null | undefined} value
@@ -3565,7 +3917,7 @@ function createProperties(state, ancestors) {
  * @returns {Field | undefined}
  *   Field for runtime, optional.
  */
-function createProperty(state, ancestors, prop, value) {
+function createProperty(state, prop, value) {
   const info = find(state.schema, prop)
 
   // Ignore nullish and `NaN` values.
@@ -3586,9 +3938,7 @@ function createProperty(state, ancestors, prop, value) {
   // React only accepts `style` as object.
   if (info.property === 'style') {
     let styleObject =
-      typeof value === 'object'
-        ? value
-        : parseStyle(state, ancestors, String(value))
+      typeof value === 'object' ? value : parseStyle(state, String(value))
 
     if (state.stylePropertyNameCase === 'css') {
       styleObject = transformStylesToCssCasing(styleObject)
@@ -3610,8 +3960,6 @@ function createProperty(state, ancestors, prop, value) {
  *
  * @param {State} state
  *   Info passed around.
- * @param {Array<Nodes>} ancestors
- *   Stack of nodes.
  * @param {string} value
  *   CSS declarations.
  * @returns {Style}
@@ -3619,24 +3967,24 @@ function createProperty(state, ancestors, prop, value) {
  * @throws
  *   Throws `VFileMessage` when CSS cannot be parsed.
  */
-function parseStyle(state, ancestors, value) {
+function parseStyle(state, value) {
   /** @type {Style} */
   const result = {}
 
   try {
-    node_modules_style_to_object(value, replacer)
+    // @ts-expect-error: `style-to-object` types are broken.
+    esm(value, replacer)
   } catch (error) {
     if (!state.ignoreInvalidStyle) {
       const cause = /** @type {Error} */ (error)
       const message = new VFileMessage('Cannot parse `style` attribute', {
-        ancestors,
+        ancestors: state.ancestors,
         cause,
-        source: 'hast-util-to-jsx-runtime',
-        ruleId: 'style'
+        ruleId: 'style',
+        source: 'hast-util-to-jsx-runtime'
       })
       message.file = state.filePath || undefined
-      message.url =
-        'https://github.com/syntax-tree/hast-util-to-jsx-runtime#cannot-parse-style-attribute'
+      message.url = docs + '#cannot-parse-style-attribute'
 
       throw message
     }
@@ -3667,6 +4015,92 @@ function parseStyle(state, ancestors, value) {
   }
 }
 
+/**
+ * Create a JSX name from a string.
+ *
+ * @param {State} state
+ *   To do.
+ * @param {string} name
+ *   Name.
+ * @param {boolean} allowExpression
+ *   Allow member expressions and identifiers.
+ * @returns {unknown}
+ *   To do.
+ */
+function findComponentFromName(state, name, allowExpression) {
+  /** @type {Identifier | Literal | MemberExpression} */
+  let result
+
+  if (!allowExpression) {
+    result = {type: 'Literal', value: name}
+  } else if (name.includes('.')) {
+    const identifiers = name.split('.')
+    let index = -1
+    /** @type {Identifier | Literal | MemberExpression | undefined} */
+    let node
+
+    while (++index < identifiers.length) {
+      /** @type {Identifier | Literal} */
+      const prop = lib_name(identifiers[index])
+        ? {type: 'Identifier', name: identifiers[index]}
+        : {type: 'Literal', value: identifiers[index]}
+      node = node
+        ? {
+            type: 'MemberExpression',
+            object: node,
+            property: prop,
+            computed: Boolean(index && prop.type === 'Literal'),
+            optional: false
+          }
+        : prop
+    }
+
+    ok(node, 'always a result')
+    result = node
+  } else {
+    result =
+      lib_name(name) && !/^[a-z]/.test(name)
+        ? {type: 'Identifier', name}
+        : {type: 'Literal', value: name}
+  }
+
+  // Only literals can be passed in `components` currently.
+  // No identifiers / member expressions.
+  if (result.type === 'Literal') {
+    const name = /** @type {keyof JSX.IntrinsicElements} */ (result.value)
+
+    return lib_own.call(state.components, name) ? state.components[name] : name
+  }
+
+  // Assume component.
+  if (state.evaluater) {
+    return state.evaluater.evaluateExpression(result)
+  }
+
+  crashEstree(state)
+}
+
+/**
+ * @param {State} state
+ * @param {Position | undefined} [place]
+ * @returns {never}
+ */
+function crashEstree(state, place) {
+  const message = new VFileMessage(
+    'Cannot handle MDX estrees without `createEvaluater`',
+    {
+      ancestors: state.ancestors,
+      place,
+      ruleId: 'mdx-estree',
+      source: 'hast-util-to-jsx-runtime'
+    }
+  )
+  message.file = state.filePath || undefined
+  message.url = docs + '#cannot-handle-mdx-estrees-without-createevaluater'
+
+  throw message
+}
+
 /**
  * Transform a DOM casing style object to a CSS casing style object.
  *
@@ -3775,7 +4209,7 @@ var jsx_runtime = __webpack_require__(246);
  */
 
 /** @type {Options} */
-const emptyOptions = {}
+const lib_emptyOptions = {}
 
 /**
  * Get the text content of a node or list of nodes.
@@ -3791,7 +4225,7 @@ const emptyOptions = {}
  *   Serialized `value`.
  */
 function lib_toString(value, options) {
-  const settings = options || emptyOptions
+  const settings = options || lib_emptyOptions
   const includeImageAlt =
     typeof settings.includeImageAlt === 'boolean'
       ? settings.includeImageAlt
@@ -14430,7 +14864,7 @@ const serializer = (strict, json, $, _) => {
  * fallback to the polyfill if present.
  * @returns {Record[]}
  */
-/* harmony default export */ const esm = (typeof structuredClone === "function" ?
+/* harmony default export */ const structured_clone_esm = (typeof structuredClone === "function" ?
   /* c8 ignore start */
   (any, options) => (
     options && ('json' in options || 'lossy' in options) ?
@@ -15042,7 +15476,7 @@ function footer(state) {
         type: 'element',
         tagName: footnoteLabelTagName,
         properties: {
-          ...esm(footnoteLabelProperties),
+          ...structured_clone_esm(footnoteLabelProperties),
           id: 'footnote-label'
         },
         children: [{type: 'text', value: footnoteLabel}]
@@ -16889,7 +17323,7 @@ function paragraph(state, node) {
  * @returns {HastParents}
  *   hast node.
  */
-function root(state, node) {
+function root_root(state, node) {
   /** @type {HastRoot} */
   const result = {type: 'root', children: state.wrap(state.all(node))}
   state.patch(node, result)
@@ -17274,7 +17708,7 @@ const handlers_handlers = {
   list: list_list,
   paragraph: paragraph,
   // @ts-expect-error: root is different, but hard to type.
-  root: root,
+  root: root_root,
   strong: strong,
   table: table,
   tableCell: tableCell,
@@ -17548,7 +17982,7 @@ function createState(tree, options) {
     if (state.options.passThrough && state.options.passThrough.includes(type)) {
       if ('children' in node) {
         const {children, ...shallow} = node
-        const result = esm(shallow)
+        const result = structured_clone_esm(shallow)
         // @ts-expect-error: TS doesn’t understand…
         result.children = state.all(node)
         // @ts-expect-error: TS doesn’t understand…
@@ -17556,7 +17990,7 @@ function createState(tree, options) {
       }
 
       // @ts-expect-error: it’s custom.
-      return esm(node)
+      return structured_clone_esm(node)
     }
 
     const unknown = state.options.unknownHandler || defaultUnknownHandler
@@ -17666,7 +18100,7 @@ function applyData(from, to) {
     }
 
     if (result.type === 'element' && hProperties) {
-      Object.assign(result.properties, esm(hProperties))
+      Object.assign(result.properties, structured_clone_esm(hProperties))
     }
 
     if (
@@ -23200,7 +23634,7 @@ function emphasisPeek(_, _1, state) {
  */
 
 /** @type {Options} */
-const lib_emptyOptions = {}
+const mdast_util_to_string_lib_emptyOptions = {}
 
 /**
  * Get the text content of a node or list of nodes.
@@ -23216,7 +23650,7 @@ const lib_emptyOptions = {}
  *   Serialized `value`.
  */
 function mdast_util_to_string_lib_toString(value, options) {
-  const settings = options || lib_emptyOptions
+  const settings = options || mdast_util_to_string_lib_emptyOptions
   const includeImageAlt =
     typeof settings.includeImageAlt === 'boolean'
       ? settings.includeImageAlt
@@ -24276,7 +24710,7 @@ const phrasing =
  * @param {Info} info
  * @returns {string}
  */
-function root_root(node, _, state, info) {
+function handle_root_root(node, _, state, info) {
   // Note: `html` nodes are ambiguous.
   const hasPhrasing = node.children.some(function (d) {
     return phrasing(d)
@@ -24467,7 +24901,7 @@ const handle = {
   list: handle_list_list,
   listItem: list_item_listItem,
   paragraph: paragraph_paragraph,
-  root: root_root,
+  root: handle_root_root,
   strong: strong_strong,
   text: handle_text_text,
   thematicBreak: handle_thematic_break_thematicBreak
@@ -30810,7 +31244,7 @@ function hast_util_from_parse5_lib_one(state, node) {
     // Element.
     default: {
       const reference = /** @type {P5Element} */ (node)
-      result = lib_element(state, reference)
+      result = hast_util_from_parse5_lib_element(state, reference)
       return result
     }
   }
@@ -30850,7 +31284,7 @@ function hast_util_from_parse5_lib_all(state, nodes) {
  * @returns {Element}
  *   hast node.
  */
-function lib_element(state, node) {
+function hast_util_from_parse5_lib_element(state, node) {
   const schema = state.schema
 
   state.schema = node.namespaceURI === webNamespaces.svg ? property_information_svg : property_information_html
@@ -31187,7 +31621,7 @@ const hast_util_to_parse5_lib_emptyOptions = {}
 
 const hast_util_to_parse5_lib_own = {}.hasOwnProperty
 
-const hast_util_to_parse5_lib_one = zwitch('type', {handlers: {root: lib_root, element: hast_util_to_parse5_lib_element, text: lib_text, comment, doctype}})
+const hast_util_to_parse5_lib_one = zwitch('type', {handlers: {root: lib_root, element: hast_util_to_parse5_lib_element, text: hast_util_to_parse5_lib_text, comment, doctype}})
 
 /**
  * Transform a hast tree to a `parse5` AST.
@@ -31268,7 +31702,7 @@ function doctype(node) {
  * @returns {Parse5Text}
  *   Parse5 node.
  */
-function lib_text(node) {
+function hast_util_to_parse5_lib_text(node) {
   /** @type {Parse5Text} */
   const result = {
     nodeName: '#text',
@@ -41029,8 +41463,8 @@ function createParse5Location(node) {
  */
 function cloneWithoutChildren(node) {
   return 'children' in node
-    ? esm({...node, children: []})
-    : esm(node)
+    ? structured_clone_esm({...node, children: []})
+    : structured_clone_esm(node)
 }
 
 ;// CONCATENATED MODULE: ../node_modules/rehype-raw/lib/index.js
@@ -41116,7 +41550,7 @@ function useCopied(container) {
 ;// CONCATENATED MODULE: ../node_modules/@uiw/react-markdown-preview/esm/preview.js
 
 
-var _excluded = ["prefixCls", "className", "source", "style", "disableCopy", "skipHtml", "onScroll", "onMouseOver", "pluginsFilter", "rehypeRewrite", "wrapperElement", "warpperElement"];
+var _excluded = ["prefixCls", "className", "source", "style", "disableCopy", "skipHtml", "onScroll", "onMouseOver", "pluginsFilter", "rehypeRewrite", "wrapperElement", "warpperElement", "urlTransform"];
 
 
 
@@ -41124,7 +41558,11 @@ var _excluded = ["prefixCls", "className", "source", "style", "disableCopy", "sk
 
 
 
+/**
+ * https://github.com/uiwjs/react-md-editor/issues/607
+ */
 
+var preview_defaultUrlTransform = url => url;
 /* harmony default export */ const preview = (/*#__PURE__*/external_root_React_commonjs2_react_commonjs_react_amd_react_default().forwardRef((props, ref) => {
   var {
       prefixCls = 'wmde-markdown wmde-markdown-color',
@@ -41137,7 +41575,8 @@ var _excluded = ["prefixCls", "className", "source", "style", "disableCopy", "sk
       onMouseOver,
       pluginsFilter,
       wrapperElement = {},
-      warpperElement = {}
+      warpperElement = {},
+      urlTransform
     } = props,
     other = _objectWithoutPropertiesLoose(props, _excluded);
   var mdp = external_root_React_commonjs2_react_commonjs_react_amd_react_default().useRef(null);
@@ -41169,6 +41608,7 @@ var _excluded = ["prefixCls", "className", "source", "style", "disableCopy", "sk
     style: style,
     children: /*#__PURE__*/(0,jsx_runtime.jsx)(Markdown, _extends({}, customProps, other, {
       skipHtml: skipHtml,
+      urlTransform: urlTransform || preview_defaultUrlTransform,
       rehypePlugins: pluginsFilter ? pluginsFilter('rehype', rehypePlugins) : rehypePlugins,
       remarkPlugins: pluginsFilter ? pluginsFilter('remark', remarkPlugins) : remarkPlugins,
       children: source || ''
@@ -70096,15 +70536,20 @@ var cssSyntaxDefinitions = {
 
 ;// CONCATENATED MODULE: ../node_modules/css-selector-parser/dist/mjs/utils.js
 function isIdentStart(c) {
-    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '-' || c === '_' || c === '\\';
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '-' || c === '_' || c === '\\' || c >= '\u00a0';
 }
 function isIdent(c) {
-    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '-' || c === '_';
+    return ((c >= 'a' && c <= 'z') ||
+        (c >= 'A' && c <= 'Z') ||
+        (c >= '0' && c <= '9') ||
+        c === '-' ||
+        c === '_' ||
+        c >= '\u00a0');
 }
 function isHex(c) {
     return (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') || (c >= '0' && c <= '9');
 }
-var identSpecialChars = {
+var identEscapeChars = {
     '!': true,
     '"': true,
     '#': true,
@@ -70135,19 +70580,12 @@ var identSpecialChars = {
     '}': true,
     '~': true
 };
-var strReplacementsRev = {
-    '\n': '\\n',
-    '\r': '\\r',
-    '\t': '\\t',
-    '\f': '\\f',
-    '\v': '\\v'
-};
-var stringEscapeChars = {
-    n: '\n',
-    r: '\r',
-    t: '\t',
-    f: '\f',
-    '\\': '\\'
+var stringRenderEscapeChars = {
+    '\n': true,
+    '\r': true,
+    '\t': true,
+    '\f': true,
+    '\v': true
 };
 var whitespaceChars = {
     ' ': true,
@@ -70172,21 +70610,25 @@ var digitsChars = {
     8: true,
     9: true
 };
+var maxHexLength = 6;
 function utils_escapeIdentifier(s) {
     var len = s.length;
     var result = '';
     var i = 0;
     while (i < len) {
         var chr = s.charAt(i);
-        if (identSpecialChars[chr]) {
+        if (identEscapeChars[chr] || (chr === '-' && i === 1 && s.charAt(0) === '-')) {
             result += '\\' + chr;
         }
         else {
-            if (!(chr === '_' ||
-                chr === '-' ||
+            if (chr === '-' ||
+                chr === '_' ||
                 (chr >= 'A' && chr <= 'Z') ||
                 (chr >= 'a' && chr <= 'z') ||
-                (i !== 0 && chr >= '0' && chr <= '9'))) {
+                (chr >= '0' && chr <= '9' && i !== 0 && !(i === 1 && s.charAt(0) === '-'))) {
+                result += chr;
+            }
+            else {
                 var charCode = chr.charCodeAt(0);
                 if ((charCode & 0xf800) === 0xd800) {
                     var extraCharCode = s.charCodeAt(i++);
@@ -70197,19 +70639,15 @@ function utils_escapeIdentifier(s) {
                 }
                 result += '\\' + charCode.toString(16) + ' ';
             }
-            else {
-                result += chr;
-            }
         }
         i++;
     }
     return result.trim();
 }
-function utils_escapeStr(s) {
+function utils_escapeString(s) {
     var len = s.length;
     var result = '';
     var i = 0;
-    var replacement;
     while (i < len) {
         var chr = s.charAt(i);
         if (chr === '"') {
@@ -70218,8 +70656,8 @@ function utils_escapeStr(s) {
         else if (chr === '\\') {
             chr = '\\\\';
         }
-        else if ((replacement = strReplacementsRev[chr]) !== undefined) {
-            chr = replacement;
+        else if (stringRenderEscapeChars[chr]) {
+            chr = '\\' + chr.charCodeAt(0).toString(16) + (i === len - 1 ? '' : ' ');
         }
         result += chr;
         i++;
@@ -70360,16 +70798,22 @@ function createParser(options) {
             }
         }
     }
+    /**
+     * @see https://www.w3.org/TR/css-syntax/#hex-digit-diagram
+     */
     function parseHex() {
         var hex = readAndNext();
-        while (isHex(chr)) {
+        var count = 1;
+        while (isHex(chr) && count < maxHexLength) {
             hex += readAndNext();
+            count++;
         }
-        if (is(' ')) {
-            next();
-        }
+        skipSingleWhitespace();
         return String.fromCharCode(parseInt(hex, 16));
     }
+    /**
+     * @see https://www.w3.org/TR/css-syntax/#string-token-diagram
+     */
     function parseString(quote) {
         var result = '';
         pass(quote);
@@ -70380,33 +70824,53 @@ function createParser(options) {
             }
             else if (is('\\')) {
                 next();
-                var esc = void 0;
                 if (is(quote)) {
                     result += quote;
+                    next();
+                }
+                else if (chr === '\n' || chr === '\f') {
+                    next();
                 }
-                else if ((esc = stringEscapeChars[chr]) !== undefined) {
-                    result += esc;
+                else if (chr === '\r') {
+                    next();
+                    if (is('\n')) {
+                        next();
+                    }
                 }
                 else if (isHex(chr)) {
                     result += parseHex();
-                    continue;
                 }
                 else {
                     result += chr;
+                    next();
                 }
             }
             else {
                 result += chr;
+                next();
             }
-            next();
         }
         return result;
     }
+    /**
+     * @see https://www.w3.org/TR/css-syntax/#ident-token-diagram
+     */
     function parseIdentifier() {
         if (!isIdentStart(chr)) {
             return null;
         }
         var result = '';
+        while (is('-')) {
+            result += chr;
+            next();
+        }
+        if (strict && result.length >= 2) {
+            // Checking this only for strict mode since browsers work fine with these identifiers.
+            fail('Identifiers cannot start with two hyphens with strict mode on.');
+        }
+        if (digitsChars[chr]) {
+            fail('Identifiers cannot start with hyphens followed by digits.');
+        }
         while (pos < l) {
             if (isIdent(chr)) {
                 result += readAndNext();
@@ -70422,7 +70886,7 @@ function createParser(options) {
                 }
             }
             else {
-                return result;
+                break;
             }
         }
         return result;
@@ -70452,6 +70916,18 @@ function createParser(options) {
         }
         return result.trim();
     }
+    function skipSingleWhitespace() {
+        if (chr === ' ' || chr === '\t' || chr === '\f' || chr === '\n') {
+            next();
+            return;
+        }
+        if (chr === '\r') {
+            next();
+        }
+        if (chr === '\n') {
+            next();
+        }
+    }
     function skipWhitespace() {
         while (whitespaceChars[chr]) {
             next();
@@ -71012,7 +71488,7 @@ function render(entity) {
         if (operator && value) {
             result += operator;
             if (value.type === 'String') {
-                result += escapeStr(value.value);
+                result += escapeString(value.value);
             }
             else if (value.type === 'Substitution') {
                 result += renderSubstitution(value);
@@ -74247,7 +74723,7 @@ function rehypeAutolinkHeadings(options) {
  */
 function clone(thing) {
   // Cast because it’s mutable now.
-  return /** @type {Cloneable<T>} */ (esm(thing))
+  return /** @type {Cloneable<T>} */ (structured_clone_esm(thing))
 }
 
 /**
@@ -76788,7 +77264,7 @@ function raw_raw(node, index, parent, state) {
  * @returns {string}
  *   Serialized node.
  */
-function handle_root_root(node, _1, _2, state) {
+function lib_handle_root_root(node, _1, _2, state) {
   return state.all(node)
 }
 
@@ -76814,7 +77290,7 @@ function handle_root_root(node, _1, _2, state) {
 const handle_handle = zwitch('type', {
   invalid,
   unknown: handle_unknown,
-  handlers: {comment: comment_comment, doctype: doctype_doctype, element: element_element, raw: raw_raw, root: handle_root_root, text: lib_handle_text_text}
+  handlers: {comment: comment_comment, doctype: doctype_doctype, element: element_element, raw: raw_raw, root: lib_handle_root_root, text: lib_handle_text_text}
 })
 
 /**
@@ -77197,7 +77673,7 @@ function _defineProperties(target, props) {
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);
   }
 }
 function _createClass(Constructor, protoProps, staticProps) {