j-templates 6.1.11 → 7.0.0

package/Node/componentNode.types.d.ts

@@ -1,37 +0,0 @@
-import { BoundNodeFunctionParam, IBoundNodeBase, NodeDefinition } from "./boundNode.types";
-import { Component, ComponentConstructor } from "./component";
-import { NodeRefType } from "./nodeRef";
-import { AllNodeRefTypes } from "./nodeRef.types";
-export type ComponentNodeEvents<E = void> = {
-    [P in keyof E]?: {
-        (data: E[P]): void;
-    };
-};
-export interface ComponentNodeDefinition<D = void, E = void> extends NodeDefinition<D> {
-    on: ComponentNodeEvents<E>;
-    data?: {
-        (): D | Promise<D>;
-    };
-}
-export interface ComponentNodeFunctionParam<D = void, E = void, P = HTMLElement> extends BoundNodeFunctionParam<P> {
-    on?: ComponentNodeEvents<E>;
-    data?: {
-        (): D | Promise<D>;
-    };
-}
-export type ComponentNodeFunction<D = void, T = void, E = void> = (nodeDef: ComponentNodeFunctionParam<D, E>, templates?: T) => IComponentNode<D, T, E>;
-export interface IComponentNodeBase<D, T, E> extends IBoundNodeBase {
-    nodeDef: ComponentNodeFunctionParam<D, E>;
-    constructor: ComponentConstructor<D, T, E>;
-    component: Component<D, T, E>;
-    componentEvents: {
-        [name: string]: {
-            (...args: Array<any>): void;
-        };
-    };
-    templates: T;
-}
-export interface IComponentNode<D, T, E> extends IComponentNodeBase<D, T, E> {
-    type: NodeRefType.ComponentNode;
-    childNodes: AllNodeRefTypes[];
-}

package/Node/elementNode.d.ts

@@ -1,5 +0,0 @@
-import { ElementChildrenFunctionParam, ElementNodeFunctionParam, IElementNode, IElementNodeBase } from "./elementNode.types";
-export declare namespace ElementNode {
-    function Create<T>(type: any, namespace: string, nodeDef: ElementNodeFunctionParam<T>, children: ElementChildrenFunctionParam<T>): IElementNode<T>;
-    function Init<T>(elementNode: IElementNodeBase<T>): void;
-}

package/Node/elementNode.js

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElementNode = void 0;
-const observableScope_1 = require("../Store/Tree/observableScope");
-const injector_1 = require("../Utils/injector");
-const list_1 = require("../Utils/list");
-const thread_1 = require("../Utils/thread");
-const boundNode_1 = require("./boundNode");
-const nodeConfig_1 = require("./nodeConfig");
-const nodeRef_1 = require("./nodeRef");
-const valueDefault = [];
-var ElementNode;
-(function (ElementNode) {
-    function Create(type, namespace, nodeDef, children) {
-        var elemNode = nodeRef_1.NodeRef.Create(type, namespace, nodeRef_1.NodeRefType.ElementNode);
-        elemNode.nodeDef = nodeDef;
-        if (Array.isArray(children))
-            elemNode.childrenArray = children;
-        else if (children !== undefined)
-            elemNode.children = children;
-        return elemNode;
-    }
-    ElementNode.Create = Create;
-    function CreateValueScopeCallback(dataScope) {
-        return function () {
-            const value = observableScope_1.ObservableScope.Value(dataScope);
-            if (!value)
-                return valueDefault;
-            if (!Array.isArray(value))
-                return [value];
-            return value;
-        };
-    }
-    function CreateNodeScopeCallback(elementNode, valueScope) {
-        let lastNodeList;
-        return function () {
-            const values = observableScope_1.ObservableScope.Value(valueScope);
-            const lastNodeMap = lastNodeList && list_1.List.ToNodeMap(lastNodeList, GetDataValue);
-            const nextNodeList = list_1.List.Create();
-            for (let x = 0; x < values.length; x++) {
-                let curNode = null;
-                if (lastNodeMap !== undefined) {
-                    const nodeArr = lastNodeMap.get(values[x]);
-                    if (nodeArr !== undefined) {
-                        let y = nodeArr.length - 1;
-                        for (; y >= 0 && nodeArr[y] === null; y--) { }
-                        curNode = nodeArr[y];
-                        nodeArr[y] = null;
-                    }
-                }
-                const value = values[x];
-                if (curNode !== null) {
-                    list_1.List.RemoveNode(lastNodeList, curNode);
-                    list_1.List.AddNode(nextNodeList, curNode);
-                    const nextNodes = observableScope_1.ObservableScope.Value(curNode.data.scope);
-                    if (curNode.data.nodes !== nextNodes) {
-                        list_1.List.Add(elementNode.destroyNodeList, {
-                            ...curNode.data,
-                            scope: null
-                        });
-                        curNode.data.init = false;
-                        curNode.data.nodes = nextNodes;
-                    }
-                }
-                else {
-                    const scope = observableScope_1.ObservableScope.Create(function () {
-                        return injector_1.Injector.Scope(elementNode.injector, CreateNodeArray, elementNode.children, value);
-                    });
-                    curNode = list_1.List.Add(nextNodeList, {
-                        value,
-                        init: false,
-                        scope,
-                        nodes: observableScope_1.ObservableScope.Value(scope),
-                    });
-                }
-            }
-            lastNodeList && list_1.List.Append(elementNode.destroyNodeList, lastNodeList);
-            lastNodeList = nextNodeList;
-            return nextNodeList;
-        };
-    }
-    function Init(elementNode) {
-        elementNode.childNodes = new Set();
-        if (elementNode.children !== null) {
-            const dataScope = elementNode.nodeDef.data ? observableScope_1.ObservableScope.Create(elementNode.nodeDef.data) : observableScope_1.ObservableScope.Create(function () {
-                return [true];
-            });
-            const valueScope = observableScope_1.ObservableScope.Create(CreateValueScopeCallback(dataScope));
-            const nodeScope = observableScope_1.ObservableScope.Create(CreateNodeScopeCallback(elementNode, valueScope));
-            elementNode.childNodes = new Set();
-            elementNode.scopes ??= [];
-            elementNode.scopes.push(dataScope, valueScope, nodeScope);
-            observableScope_1.ObservableScope.Watch(nodeScope, function (scope) {
-                ScheduleSetData(elementNode, scope);
-            });
-            UpdateNodes(elementNode, observableScope_1.ObservableScope.Value(nodeScope), true);
-        }
-        else if (elementNode.childrenArray !== null) {
-            SetDefaultData(elementNode);
-        }
-        boundNode_1.BoundNode.Init(elementNode);
-    }
-    ElementNode.Init = Init;
-})(ElementNode || (exports.ElementNode = ElementNode = {}));
-function ScheduleSetData(node, scope) {
-    if (node.setData)
-        return;
-    node.setData = true;
-    nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-        node.setData = false;
-        if (node.destroyed)
-            return;
-        UpdateNodes(node, observableScope_1.ObservableScope.Value(scope));
-    });
-}
-function SetDefaultData(node) {
-    const nodes = node.childrenArray ||
-        injector_1.Injector.Scope(node.injector, CreateNodeArray, node.children, true);
-    node.childrenArray = null;
-    const defaultNodeList = list_1.List.Create();
-    list_1.List.Add(defaultNodeList, {
-        value: null,
-        init: false,
-        scope: null,
-        nodes
-    });
-    UpdateNodes(node, defaultNodeList, true);
-}
-function GetDataValue(data) {
-    return data.value;
-}
-function UpdateNodes(elementNode, nodeList, init = false) {
-    (0, thread_1.Synch)(function () {
-        let data;
-        while (data = list_1.List.Pop(elementNode.destroyNodeList)) {
-            observableScope_1.ObservableScope.Destroy(data.scope);
-            for (let x = 0; x < data.nodes.length; x++)
-                elementNode.childNodes.delete(data.nodes[x]);
-            nodeRef_1.NodeRef.DestroyAll(data.nodes);
-        }
-        for (let node = nodeList.head; node !== null; node = node.next) {
-            if (!node.data.init) {
-                const nodeData = node.data;
-                (0, thread_1.Schedule)(function () {
-                    if (elementNode.destroyed || nodeData.init)
-                        return;
-                    nodeRef_1.NodeRef.InitAll(elementNode, nodeData.nodes);
-                    nodeData.init = true;
-                });
-            }
-        }
-        const startSize = nodeList.size;
-        (0, thread_1.Thread)(function (async) {
-            if (elementNode.destroyed)
-                return;
-            if (init || !async)
-                nodeRef_1.NodeRef.ReconcileChildren(elementNode, nodeList);
-            else
-                nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-                    if (elementNode.destroyed || nodeList.size !== startSize)
-                        return;
-                    nodeRef_1.NodeRef.ReconcileChildren(elementNode, nodeList);
-                });
-        });
-    });
-}
-function CreateNodeArray(childrenFunc, value) {
-    const newNodes = childrenFunc(value);
-    if (typeof newNodes === "string" || !newNodes) {
-        const textNode = nodeRef_1.NodeRef.Create(newNodes, null, nodeRef_1.NodeRefType.TextNode);
-        return [textNode];
-    }
-    if (Array.isArray(newNodes))
-        return newNodes;
-    return [newNodes];
-}

package/Node/elementNode.types.d.ts

@@ -1,40 +0,0 @@
-import { IObservableScope } from "../Store/Tree/observableScope";
-import { IList } from "../Utils/list";
-import { NodeDefinition, BoundNodeFunctionParam, IBoundNodeBase } from "./boundNode.types";
-import { NodeRefType } from "./nodeRef";
-import { INodeRefBase, ElementNodeRefTypes, AllNodeRefTypes } from "./nodeRef.types";
-export type ElementChildrenFunction<T> = {
-    (data: T): string | ElementNodeRefTypes | ElementNodeRefTypes[];
-};
-export type ElementChildrenFunctionParam<T> = ElementChildrenFunction<T> | ElementNodeRefTypes[];
-export type ElementNodeFunction<T> = {
-    (nodeDef: ElementNodeFunctionParam<T>, children?: ElementChildrenFunctionParam<T>): INodeRefBase;
-};
-export interface ElementNodeDefinition<T> extends NodeDefinition<T> {
-    data?: {
-        (): T | Array<T> | Promise<Array<T>> | Promise<T>;
-    };
-    children?: ElementChildrenFunction<T>;
-}
-export interface ElementNodeFunctionParam<T, P = HTMLElement, E = HTMLElementEventMap> extends BoundNodeFunctionParam<P, E> {
-    data?: {
-        (): T | Array<T> | Promise<Array<T>> | Promise<T>;
-    };
-}
-export interface IElementDataNode<T> {
-    value: T;
-    init: boolean;
-    scope: IObservableScope<AllNodeRefTypes[] | null>;
-    nodes: AllNodeRefTypes[] | null;
-}
-export interface IElementNodeBase<T> extends IBoundNodeBase {
-    nodeDef: ElementNodeFunctionParam<T>;
-    children: ElementChildrenFunction<T>;
-    childrenArray: ElementNodeRefTypes[];
-    destroyNodeList: IList<IElementDataNode<T>>;
-    setData: boolean;
-}
-export interface IElementNode<T> extends IElementNodeBase<T> {
-    type: NodeRefType.ElementNode;
-    childNodes: Set<AllNodeRefTypes>;
-}

package/Node/elementNode.types.js

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

package/Node/nodeRef.d.ts

@@ -1,26 +0,0 @@
-import { INodeRef, ElementNodeRefTypes, AllNodeRefTypes } from "./nodeRef.types";
-import { IBoundNode } from "./boundNode.types";
-import { IElementDataNode, IElementNode } from "./elementNode.types";
-import { IComponentNode } from "./componentNode.types";
-import { IList } from "../Utils/list";
-import { ITextNode } from "./textNode.types";
-export declare enum NodeRefType {
-    NodeRef = 0,
-    BoundNode = 1,
-    ElementNode = 2,
-    ComponentNode = 3,
-    TextNode = 4
-}
-export declare namespace NodeRef {
-    function Wrap(node: any): INodeRef;
-    function Create(nodeType: any, namespace: string, type: NodeRefType): INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any> | ITextNode;
-    function Init(nodeRef: AllNodeRefTypes): void;
-    function InitAll(parentNode: ElementNodeRefTypes, nodeRefs: Array<AllNodeRefTypes>): void;
-    function AddChild(node: ElementNodeRefTypes, child: AllNodeRefTypes): void;
-    function AddChildAfter(node: ElementNodeRefTypes, currentChild: AllNodeRefTypes, newChild: AllNodeRefTypes): void;
-    function AddChildBefore(node: ElementNodeRefTypes, currentChild: AllNodeRefTypes, newChild: AllNodeRefTypes): void;
-    function ReconcileChildren(node: ElementNodeRefTypes, nextChildren: IList<IElementDataNode<unknown>>): void;
-    function DetachChild(node: ElementNodeRefTypes, child: AllNodeRefTypes): void;
-    function Destroy(node: AllNodeRefTypes): void;
-    function DestroyAll(nodes: Array<AllNodeRefTypes>): void;
-}

package/Node/nodeRef.js

@@ -1,252 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeRef = exports.NodeRefType = void 0;
-const nodeConfig_1 = require("./nodeConfig");
-const injector_1 = require("../Utils/injector");
-const boundNode_1 = require("./boundNode");
-const elementNode_1 = require("./elementNode");
-const componentNode_1 = require("./componentNode");
-const list_1 = require("../Utils/list");
-const Store_1 = require("../Store");
-var NodeRefType;
-(function (NodeRefType) {
-    NodeRefType[NodeRefType["NodeRef"] = 0] = "NodeRef";
-    NodeRefType[NodeRefType["BoundNode"] = 1] = "BoundNode";
-    NodeRefType[NodeRefType["ElementNode"] = 2] = "ElementNode";
-    NodeRefType[NodeRefType["ComponentNode"] = 3] = "ComponentNode";
-    NodeRefType[NodeRefType["TextNode"] = 4] = "TextNode";
-})(NodeRefType || (exports.NodeRefType = NodeRefType = {}));
-var NodeRef;
-(function (NodeRef) {
-    function Wrap(node) {
-        const nodeRef = Create(null, null, NodeRefType.BoundNode);
-        nodeRef.node = node;
-        nodeRef.childNodes = [];
-        return nodeRef;
-    }
-    NodeRef.Wrap = Wrap;
-    function Create(nodeType, namespace, type) {
-        switch (type) {
-            case NodeRefType.TextNode:
-                return {
-                    type: NodeRefType.TextNode,
-                    parent: null,
-                    node: null,
-                    value: nodeType
-                };
-            case NodeRefType.NodeRef:
-                return {
-                    node: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.NodeRef,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false
-                };
-            case NodeRefType.BoundNode:
-                return {
-                    node: null,
-                    nodeDef: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.BoundNode,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    lastEvents: null,
-                    setProperties: false,
-                    assignProperties: null,
-                    assignEvents: null,
-                    assignText: null,
-                    setAttributes: false,
-                    setEvents: false,
-                    setText: false,
-                    scopes: null
-                };
-            case NodeRefType.ElementNode:
-                return {
-                    node: null,
-                    nodeDef: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.ElementNode,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    lastEvents: null,
-                    setProperties: false,
-                    assignProperties: null,
-                    assignEvents: null,
-                    assignText: null,
-                    setAttributes: false,
-                    setEvents: false,
-                    children: null,
-                    childrenArray: null,
-                    nodeList: null,
-                    setData: false,
-                    setText: false,
-                    scopes: null,
-                    destroyNodeList: list_1.List.Create()
-                };
-            case NodeRefType.ComponentNode:
-                return {
-                    node: null,
-                    nodeDef: null,
-                    nodeType: nodeType,
-                    nodeNamespace: namespace,
-                    type: NodeRefType.ComponentNode,
-                    injector: injector_1.Injector.Current() || new injector_1.Injector(),
-                    parent: null,
-                    childNodes: null,
-                    destroyed: false,
-                    setProperties: false,
-                    assignProperties: null,
-                    assignEvents: null,
-                    setAttributes: false,
-                    setEvents: false,
-                    component: null,
-                    componentEvents: null,
-                    scopes: null
-                };
-        }
-    }
-    NodeRef.Create = Create;
-    function Init(nodeRef) {
-        if (nodeRef.node || nodeRef.type === NodeRefType.TextNode)
-            return;
-        nodeRef.node = nodeRef.nodeType === 'text' ? nodeConfig_1.NodeConfig.createTextNode() : nodeConfig_1.NodeConfig.createNode(nodeRef.nodeType, nodeRef.nodeNamespace);
-        nodeRef.childNodes = nodeRef.nodeType !== 'text' ? [] : null;
-        switch (nodeRef.type) {
-            case NodeRefType.BoundNode:
-                boundNode_1.BoundNode.Init(nodeRef);
-                break;
-            case NodeRefType.ElementNode:
-                elementNode_1.ElementNode.Init(nodeRef);
-                break;
-            case NodeRefType.ComponentNode:
-                componentNode_1.ComponentNode.Init(nodeRef);
-                break;
-        }
-    }
-    NodeRef.Init = Init;
-    function AddChildToNode(parentNode, child) {
-        switch (parentNode.type) {
-            case NodeRefType.ElementNode:
-                parentNode.childNodes.add(child);
-                break;
-            case NodeRefType.ComponentNode:
-            case NodeRefType.BoundNode:
-                parentNode.childNodes.push(child);
-                break;
-            default:
-                throw "Unable to add child node to node";
-        }
-    }
-    function InitAll(parentNode, nodeRefs) {
-        for (var x = 0; x < nodeRefs.length; x++) {
-            nodeRefs[x].parent = parentNode;
-            AddChildToNode(parentNode, nodeRefs[x]);
-            Init(nodeRefs[x]);
-        }
-    }
-    NodeRef.InitAll = InitAll;
-    function AddChild(node, child) {
-        child.parent = node;
-        AddChildToNode(node, child);
-        nodeConfig_1.NodeConfig.addChild(node.node, child.node);
-    }
-    NodeRef.AddChild = AddChild;
-    function AddChildAfter(node, currentChild, newChild) {
-        if (currentChild && currentChild.parent !== node)
-            throw "currentChild is not valid";
-        newChild.parent = node;
-        AddChildToNode(node, newChild);
-        nodeConfig_1.NodeConfig.addChildAfter(node.node, currentChild && currentChild.node, newChild.node);
-    }
-    NodeRef.AddChildAfter = AddChildAfter;
-    function AddChildBefore(node, currentChild, newChild) {
-        if (currentChild && currentChild.parent !== node)
-            throw "currentChild is not valid";
-        newChild.parent = node;
-        AddChildToNode(node, newChild);
-        nodeConfig_1.NodeConfig.addChildBefore(node.node, currentChild && currentChild.node, newChild.node);
-    }
-    NodeRef.AddChildBefore = AddChildBefore;
-    function ReconcileChildren(node, nextChildren) {
-        const rootNode = node.node;
-        if (nextChildren.size === 0) {
-            nodeConfig_1.NodeConfig.replaceChildren(rootNode, []);
-            return;
-        }
-        let priorNode;
-        let insert = false;
-        let remove = false;
-        for (let curDataNode = nextChildren.head; curDataNode !== null; curDataNode = curDataNode.next) {
-            for (let x = 0; x < curDataNode.data.nodes.length; x++) {
-                const virtualNode = curDataNode.data.nodes[x];
-                const actualNode = priorNode ? nodeConfig_1.NodeConfig.getNextSibling(priorNode) : nodeConfig_1.NodeConfig.getFirstChild(rootNode);
-                let expectedNode;
-                if (virtualNode.type === NodeRefType.TextNode && actualNode !== null && nodeConfig_1.NodeConfig.isTextNode(actualNode)) {
-                    nodeConfig_1.NodeConfig.setText(actualNode, virtualNode.value);
-                    virtualNode.node = expectedNode = actualNode;
-                }
-                else if (virtualNode.type === NodeRefType.TextNode)
-                    expectedNode = nodeConfig_1.NodeConfig.createTextNode(virtualNode.value);
-                else
-                    expectedNode = virtualNode.node;
-                if (actualNode !== expectedNode) {
-                    nodeConfig_1.NodeConfig.addChildBefore(rootNode, actualNode, expectedNode);
-                    !remove && insert && actualNode && nodeConfig_1.NodeConfig.removeChild(rootNode, actualNode);
-                    remove = insert;
-                    insert = true;
-                }
-                else {
-                    insert = false;
-                    remove = false;
-                }
-                priorNode = expectedNode;
-            }
-        }
-        let lastChild = nodeConfig_1.NodeConfig.getLastChild(rootNode);
-        while (priorNode && priorNode !== lastChild) {
-            nodeConfig_1.NodeConfig.removeChild(rootNode, lastChild);
-            lastChild = nodeConfig_1.NodeConfig.getLastChild(rootNode);
-        }
-    }
-    NodeRef.ReconcileChildren = ReconcileChildren;
-    function DetachChild(node, child) {
-        if (node.type === NodeRefType.ElementNode && node.childNodes.delete(child))
-            child.parent = null;
-    }
-    NodeRef.DetachChild = DetachChild;
-    function Destroy(node) {
-        if (node.type === NodeRefType.TextNode || node.destroyed)
-            return;
-        node.destroyed = true;
-        if (Array.isArray(node.childNodes))
-            for (let x = 0; x < node.childNodes.length; x++)
-                Destroy(node.childNodes[x]);
-        else
-            node.childNodes?.forEach(Destroy);
-        switch (node.type) {
-            case NodeRefType.ComponentNode:
-                node.component?.Destroy();
-            case NodeRefType.BoundNode:
-                node.assignEvents?.(null);
-            case NodeRefType.ElementNode:
-                for (let x = 0; node.scopes && x < node.scopes.length; x++)
-                    Store_1.ObservableScope.Destroy(node.scopes[x]);
-        }
-        node.node = null;
-    }
-    NodeRef.Destroy = Destroy;
-    function DestroyAll(nodes) {
-        for (let x = 0; x < nodes.length; x++)
-            Destroy(nodes[x]);
-    }
-    NodeRef.DestroyAll = DestroyAll;
-})(NodeRef || (exports.NodeRef = NodeRef = {}));

package/Node/nodeRef.types.d.ts

@@ -1,21 +0,0 @@
-import { Injector } from "../Utils/injector";
-import { IBoundNode } from "./boundNode.types";
-import { IComponentNode } from "./componentNode.types";
-import { IElementNode } from "./elementNode.types";
-import { NodeRefType } from "./nodeRef";
-import { ITextNode } from "./textNode.types";
-export interface INodeRefBase {
-    type: NodeRefType;
-    node: any;
-    nodeType: any;
-    nodeNamespace: string;
-    injector: Injector;
-    parent: INodeRefBase;
-    childNodes: AllNodeRefTypes[] | Set<AllNodeRefTypes>;
-    destroyed: boolean;
-}
-export interface INodeRef extends INodeRefBase {
-    type: NodeRefType.NodeRef;
-}
-export type ElementNodeRefTypes = INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any>;
-export type AllNodeRefTypes = ElementNodeRefTypes | ITextNode;

package/Node/nodeRef.types.js

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

package/Node/textNode.types.d.ts

@@ -1,7 +0,0 @@
-import { NodeRefType } from "./nodeRef";
-export interface ITextNode {
-    type: NodeRefType.TextNode;
-    parent: any;
-    node: any;
-    value: string;
-}

package/Node/textNode.types.js

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