@handlewithcare/react-prosemirror 2.8.0 → 2.9.0-tiptap.24

package/dist/cjs/StaticEditorView.js

@@ -27,6 +27,9 @@ let StaticEditorView = class StaticEditorView {
     get state() {
         return this.props.state;
     }
+    get isDestroyed() {
+        return false;
+    }
     setProps(props) {
         return this.update({
             ...this.props,

package/dist/cjs/commands/reorderSiblings.js

@@ -1,57 +1,72 @@
-"use strict";
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "reorderSiblings", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    reorderSiblings: function() {
         return reorderSiblings;
+    },
+    reorderSiblingsOnTransaction: function() {
+        return reorderSiblingsOnTransaction;
     }
 });
 const _reactKeys = require("../plugins/reactKeys.js");
 function reorderSiblings(pos, order) {
     return function reorderSiblingsCommand(state, dispatch) {
-        const $pos = state.doc.resolve(pos);
-        if ($pos.start() !== pos) {
-            return false;
-        }
-        if (!dispatch) return true;
-        const nodes = $pos.parent.children;
-        const reordered = nodes.map((node, i)=>[
-                node,
-                i
-            ]).sort((param, param1)=>{
-            let [, a] = param, [, b] = param1;
-            return order[a] - order[b];
-        }).map((param)=>{
-            let [node] = param;
-            return node;
-        });
         const tr = state.tr;
-        tr.replaceWith(pos, $pos.parent.content.size + pos, reordered);
-        const meta = {
-            overrides: {}
-        };
-        const oldPositions = [];
-        let start = pos;
-        for (const node of nodes){
-            oldPositions.push(start);
-            start += node.nodeSize;
-        }
-        start = pos;
-        const newPositions = [];
-        for(let i = 0; i < reordered.length; i++){
-            const node = reordered[i];
-            newPositions[order[i]] = start;
-            start += node.nodeSize;
-        }
-        for(let i = 0; i < oldPositions.length; i++){
-            const oldPosition = oldPositions[i];
-            const newPosition = newPositions[i];
-            meta.overrides[oldPosition] = newPosition;
-        }
-        tr.setMeta(_reactKeys.reactKeysPluginKey, meta);
-        dispatch(tr);
-        return true;
+        return reorderSiblingsOnTransaction(pos, order, tr, state, dispatch);
+    };
+}
+function reorderSiblingsOnTransaction(pos, order, tr, state, dispatch) {
+    const orderLookup = order.reduce((acc, oldIndex, newIndex)=>{
+        acc[oldIndex] = newIndex;
+        return acc;
+    }, []);
+    const $pos = state.doc.resolve(pos);
+    if ($pos.start() !== pos) {
+        return false;
+    }
+    if (!dispatch) return true;
+    const nodes = $pos.parent.children;
+    const reordered = nodes.map((node, i)=>[
+            node,
+            i
+        ]).sort((param, param1)=>{
+        let [, a] = param, [, b] = param1;
+        return orderLookup[a] - orderLookup[b];
+    }).map((param)=>{
+        let [node] = param;
+        return node;
+    });
+    tr.replaceWith(pos, $pos.parent.content.size + pos, reordered);
+    const meta = {
+        overrides: {}
     };
+    const oldPositions = [];
+    let start = pos;
+    for (const node of nodes){
+        oldPositions.push(start);
+        start += node.nodeSize;
+    }
+    start = pos;
+    const newPositions = [];
+    for(let i = 0; i < reordered.length; i++){
+        const node = reordered[i];
+        newPositions[order[i]] = start;
+        start += node.nodeSize;
+    }
+    for(let i = 0; i < oldPositions.length; i++){
+        const oldPosition = oldPositions[i];
+        const newPosition = newPositions[i];
+        meta.overrides[oldPosition] = newPosition;
+    }
+    tr.setMeta(_reactKeys.reactKeysPluginKey, meta);
+    dispatch(tr);
+    return true;
 }

package/dist/cjs/components/CustomNodeView.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CustomNodeView", {
+    enumerable: true,
+    get: function() {
+        return CustomNodeView;
+    }
+});
+const _prosemirrormodel = require("prosemirror-model");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
+const _useNodeViewDescriptor = require("../hooks/useNodeViewDescriptor.js");
+const _ChildNodeViews = require("./ChildNodeViews.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const CustomNodeView = /*#__PURE__*/ (0, _react.memo)(function CustomNodeView(param) {
+    let { constructor, node, getPos, innerDeco, outerDeco } = param;
+    const ref = (0, _react.useRef)(null);
+    const innerRef = (0, _react.useRef)(null);
+    const nodeProps = (0, _react.useMemo)(()=>({
+            node,
+            getPos,
+            decorations: outerDeco,
+            innerDecorations: innerDeco
+        }), [
+        node,
+        getPos,
+        outerDeco,
+        innerDeco
+    ]);
+    const createNodeView = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const nodeView = constructor(...args);
+        if (!nodeView || !nodeView.dom) {
+            const spec = node.type.spec.toDOM?.(node);
+            if (!spec) {
+                throw new Error(`Node spec for ${node.type.name} is missing toDOM`);
+            }
+            return _prosemirrormodel.DOMSerializer.renderSpec(document, spec, null);
+        }
+        return nodeView;
+    };
+    const { childContextValue, contentDOM } = (0, _useNodeViewDescriptor.useNodeViewDescriptor)(ref, function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const nodeView = createNodeView(...args);
+        const contentDOM = nodeView.contentDOM;
+        const nodeDOM = nodeView.dom;
+        const wrapperDOM = innerRef.current ?? ref.current;
+        wrapperDOM.appendChild(nodeDOM);
+        if (!contentDOM && nodeDOM instanceof HTMLElement && nodeDOM.tagName !== "BR") {
+            if (!nodeDOM.hasAttribute("contenteditable")) {
+                nodeDOM.contentEditable = "false";
+            }
+            if (node.type.spec.draggable) {
+                nodeDOM.draggable = true;
+            }
+        }
+        return {
+            ...nodeView,
+            destroy () {
+                if (nodeView.destroy) {
+                    nodeView.destroy();
+                }
+                wrapperDOM.removeChild(nodeDOM);
+            },
+            selectNode: nodeView.selectNode?.bind(nodeView),
+            deselectNode: nodeView.deselectNode?.bind(nodeView),
+            stopEvent: nodeView.stopEvent?.bind(nodeView),
+            ignoreMutation: nodeView.ignoreMutation?.bind(nodeView)
+        };
+    }, nodeProps);
+    const Component = node.isInline ? "span" : "div";
+    const props = {
+        ref: innerRef
+    };
+    const children = !node.isLeaf && contentDOM ? /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    })), contentDOM) : null;
+    return /*#__PURE__*/ (0, _react.cloneElement)(outerDeco.reduce(_ChildNodeViews.wrapInDeco, /*#__PURE__*/ _react.default.createElement(Component, props, children)), {
+        ref
+    });
+});

package/dist/cjs/components/DefaultNodeView.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DefaultNodeView", {
+    enumerable: true,
+    get: function() {
+        return DefaultNodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _OutputSpec = require("./OutputSpec.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const DefaultNodeView = /*#__PURE__*/ (0, _react.forwardRef)(function DefaultNodeView(param, ref) {
+    let { nodeProps: { node }, children, ...props } = param;
+    const spec = (0, _react.useMemo)(()=>node.type.spec.toDOM?.(node), [
+        node
+    ]);
+    if (!spec) {
+        throw new Error(`Node spec for ${node.type.name} is missing toDOM`);
+    }
+    return /*#__PURE__*/ _react.default.createElement(_OutputSpec.OutputSpec, {
+        ...props,
+        outputSpec: spec,
+        ref: ref
+    }, children);
+});

package/dist/cjs/components/DocNodeView.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DocNodeView", {
+    enumerable: true,
+    get: function() {
+        return DocNodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
+const _useNodeViewDescriptor = require("../hooks/useNodeViewDescriptor.js");
+const _ChildNodeViews = require("./ChildNodeViews.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const DocNodeView = /*#__PURE__*/ (0, _react.memo)(/*#__PURE__*/ (0, _react.forwardRef)(function DocNodeView(param, ref) {
+    let { as, node, getPos, decorations, innerDecorations, setMount, ...elementProps } = param;
+    const innerRef = (0, _react.useRef)(null);
+    (0, _react.useImperativeHandle)(ref, ()=>innerRef.current);
+    (0, _react.useImperativeHandle)(setMount, ()=>innerRef.current);
+    const nodeProps = (0, _react.useMemo)(()=>({
+            node,
+            getPos,
+            decorations,
+            innerDecorations
+        }), [
+        node,
+        getPos,
+        decorations,
+        innerDecorations
+    ]);
+    const { childContextValue } = (0, _useNodeViewDescriptor.useNodeViewDescriptor)(innerRef, ()=>{
+        const dom = innerRef.current;
+        return {
+            dom,
+            contentDOM: dom,
+            update () {
+                return true;
+            }
+        };
+    }, nodeProps);
+    const children = /*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDecorations
+    }));
+    const props = {
+        ...elementProps,
+        suppressContentEditableWarning: true,
+        ref: innerRef
+    };
+    const element = as ? /*#__PURE__*/ (0, _react.cloneElement)(as, props, children) : /*#__PURE__*/ (0, _react.createElement)("div", props, children);
+    return nodeProps.decorations.reduce(_ChildNodeViews.wrapInDeco, element);
+}));

package/dist/cjs/components/MarkView.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MarkView", {
+    enumerable: true,
+    get: function() {
+        return MarkView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
+const _useClientLayoutEffect = require("../hooks/useClientLayoutEffect.js");
+const _viewdesc = require("../viewdesc.js");
+const _OutputSpec = require("./OutputSpec.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const MarkView = /*#__PURE__*/ (0, _react.memo)(/*#__PURE__*/ (0, _react.forwardRef)(function MarkView(param, ref) {
+    let { mark, getPos, children } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptorsContext.ChildDescriptorsContext);
+    const viewDescRef = (0, _react.useRef)(undefined);
+    const childDescriptors = (0, _react.useRef)([]);
+    const domRef = (0, _react.useRef)(null);
+    (0, _react.useImperativeHandle)(ref, ()=>{
+        return domRef.current;
+    }, []);
+    const outputSpec = (0, _react.useMemo)(()=>mark.type.spec.toDOM?.(mark, true), [
+        mark
+    ]);
+    if (!outputSpec) throw new Error(`Mark spec for ${mark.type.name} is missing toDOM`);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        const siblings = siblingsRef.current;
+        return ()=>{
+            if (!viewDescRef.current) return;
+            if (siblings.includes(viewDescRef.current)) {
+                const index = siblings.indexOf(viewDescRef.current);
+                siblings.splice(index, 1);
+            }
+        };
+    }, [
+        siblingsRef
+    ]);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        if (!domRef.current) return;
+        const firstChildDesc = childDescriptors.current[0];
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.MarkViewDesc(parentRef.current, childDescriptors.current, getPos, mark, domRef.current, firstChildDesc?.dom.parentElement ?? domRef.current, {
+                dom: domRef.current,
+                contentDOM: firstChildDesc?.dom.parentElement ?? domRef.current
+            });
+        } else {
+            viewDescRef.current.parent = parentRef.current;
+            viewDescRef.current.spec.dom = viewDescRef.current.dom = domRef.current;
+            viewDescRef.current.children = childDescriptors.current;
+            viewDescRef.current.spec.contentDOM = viewDescRef.current.contentDOM = firstChildDesc?.dom.parentElement ?? domRef.current;
+            viewDescRef.current.mark = mark;
+        }
+        if (!siblingsRef.current.includes(viewDescRef.current)) {
+            siblingsRef.current.push(viewDescRef.current);
+        }
+        siblingsRef.current.sort(_viewdesc.sortViewDescs);
+        for (const childDesc of childDescriptors.current){
+            childDesc.parent = viewDescRef.current;
+        }
+    });
+    const childContextValue = (0, _react.useMemo)(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childDescriptors
+        }), [
+        childDescriptors,
+        viewDescRef
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_OutputSpec.OutputSpec, {
+        ref: domRef,
+        outputSpec: outputSpec,
+        isMark: true
+    }, /*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, children));
+}));

package/dist/cjs/components/NodeView.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NodeView", {
+    enumerable: true,
+    get: function() {
+        return NodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _NodeViewContext = require("../contexts/NodeViewContext.js");
+const _CustomNodeView = require("./CustomNodeView.js");
+const _DefaultNodeView = require("./DefaultNodeView.js");
+const _ReactNodeView = require("./ReactNodeView.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const NodeView = /*#__PURE__*/ (0, _react.memo)(function NodeView(props) {
+    const { components, constructors } = (0, _react.useContext)(_NodeViewContext.NodeViewContext);
+    const component = components[props.node.type.name] ?? _DefaultNodeView.DefaultNodeView;
+    const constructor = constructors[props.node.type.name];
+    // Construct a wrapper component so that the node view remounts when either
+    // its component or constructor changes. A React node view would remount if
+    // its underlying component changed without this wrapper, but a custom node
+    // view otherwise uses the same React components for all custom node views.
+    const Component = (0, _react.useMemo)(()=>{
+        if (constructor) {
+            return function NodeView(props) {
+                return /*#__PURE__*/ _react.default.createElement(_CustomNodeView.CustomNodeView, {
+                    constructor: constructor,
+                    ...props
+                });
+            };
+        } else {
+            return function NodeView(props) {
+                return /*#__PURE__*/ _react.default.createElement(_ReactNodeView.ReactNodeView, {
+                    component: component,
+                    ...props
+                });
+            };
+        }
+    }, [
+        constructor,
+        component
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(Component, props);
+});

package/dist/cjs/components/NodeViewComponentProps.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});