maquette 3.5.3 → 4.0.0

package/dist/cache.d.ts

@@ -1,9 +1,9 @@
-import { CalculationCache } from "./interfaces";
-/**
- * Creates a [[CalculationCache]] object, useful for caching [[VNode]] trees.
- * In practice, caching of [[VNode]] trees is not needed, because achieving 60 frames per second is almost never a problem.
- * For more information, see [[CalculationCache]].
- *
- * @param <Result> The type of the value that is cached.
- */
-export declare let createCache: <Result>() => CalculationCache<Result>;
+import { CalculationCache } from "./interfaces";
+/**
+ * Creates a [[CalculationCache]] object, useful for caching [[VNode]] trees.
+ * In practice, caching of [[VNode]] trees is not needed, because achieving 60 frames per second is almost never a problem.
+ * For more information, see [[CalculationCache]].
+ *
+ * @param <Result> The type of the value that is cached.
+ */
+export declare let createCache: <Result>() => CalculationCache<Result>;

package/dist/cache.js

@@ -1,32 +1,32 @@
-/**
- * Creates a [[CalculationCache]] object, useful for caching [[VNode]] trees.
- * In practice, caching of [[VNode]] trees is not needed, because achieving 60 frames per second is almost never a problem.
- * For more information, see [[CalculationCache]].
- *
- * @param <Result> The type of the value that is cached.
- */
-export var createCache = function () {
-    var cachedInputs;
-    var cachedOutcome;
-    return {
-        invalidate: function () {
-            cachedOutcome = undefined;
-            cachedInputs = undefined;
-        },
-        result: function (inputs, calculation) {
-            if (cachedInputs) {
-                for (var i = 0; i < inputs.length; i++) {
-                    if (cachedInputs[i] !== inputs[i]) {
-                        cachedOutcome = undefined;
-                    }
-                }
-            }
-            if (!cachedOutcome) {
-                cachedOutcome = calculation();
-                cachedInputs = inputs;
-            }
-            return cachedOutcome;
-        },
-    };
-};
+/**
+ * Creates a [[CalculationCache]] object, useful for caching [[VNode]] trees.
+ * In practice, caching of [[VNode]] trees is not needed, because achieving 60 frames per second is almost never a problem.
+ * For more information, see [[CalculationCache]].
+ *
+ * @param <Result> The type of the value that is cached.
+ */
+export var createCache = function () {
+    var cachedInputs;
+    var cachedOutcome;
+    return {
+        invalidate: function () {
+            cachedOutcome = undefined;
+            cachedInputs = undefined;
+        },
+        result: function (inputs, calculation) {
+            if (cachedInputs) {
+                for (var i = 0; i < inputs.length; i++) {
+                    if (cachedInputs[i] !== inputs[i]) {
+                        cachedOutcome = undefined;
+                    }
+                }
+            }
+            if (!cachedOutcome) {
+                cachedOutcome = calculation();
+                cachedInputs = inputs;
+            }
+            return cachedOutcome;
+        },
+    };
+};
 //# sourceMappingURL=cache.js.map

package/dist/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAC,IAAI,WAAW,GAAG;IACvB,IAAI,YAAmC,CAAC;IACxC,IAAI,aAAiC,CAAC;IAEtC,OAAO;QACL,UAAU,EAAE;YACV,aAAa,GAAG,SAAS,CAAC;YAC1B,YAAY,GAAG,SAAS,CAAC;QAC3B,CAAC;QAED,MAAM,EAAE,UAAC,MAAiB,EAAE,WAAyB;YACnD,IAAI,YAAY,EAAE;gBAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACtC,IAAI,YAAY,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE;wBACjC,aAAa,GAAG,SAAS,CAAC;qBAC3B;iBACF;aACF;YACD,IAAI,CAAC,aAAa,EAAE;gBAClB,aAAa,GAAG,WAAW,EAAE,CAAC;gBAC9B,YAAY,GAAG,MAAM,CAAC;aACvB;YACD,OAAO,aAAa,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC,CAAC","sourcesContent":["import { CalculationCache } from \"./interfaces\";\n\n/**\n * Creates a [[CalculationCache]] object, useful for caching [[VNode]] trees.\n * In practice, caching of [[VNode]] trees is not needed, because achieving 60 frames per second is almost never a problem.\n * For more information, see [[CalculationCache]].\n *\n * @param <Result> The type of the value that is cached.\n */\nexport let createCache = <Result>(): CalculationCache<Result> => {\n  let cachedInputs: unknown[] | undefined;\n  let cachedOutcome: Result | undefined;\n\n  return {\n    invalidate: () => {\n      cachedOutcome = undefined;\n      cachedInputs = undefined;\n    },\n\n    result: (inputs: unknown[], calculation: () => Result) => {\n      if (cachedInputs) {\n        for (let i = 0; i < inputs.length; i++) {\n          if (cachedInputs[i] !== inputs[i]) {\n            cachedOutcome = undefined;\n          }\n        }\n      }\n      if (!cachedOutcome) {\n        cachedOutcome = calculation();\n        cachedInputs = inputs;\n      }\n      return cachedOutcome;\n    },\n  };\n};\n"]}
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAC,IAAI,WAAW,GAAG;IACvB,IAAI,YAAmC,CAAC;IACxC,IAAI,aAAiC,CAAC;IAEtC,OAAO;QACL,UAAU,EAAE;YACV,aAAa,GAAG,SAAS,CAAC;YAC1B,YAAY,GAAG,SAAS,CAAC;QAC3B,CAAC;QAED,MAAM,EAAE,UAAC,MAAiB,EAAE,WAAyB;YACnD,IAAI,YAAY,EAAE,CAAC;gBACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACvC,IAAI,YAAY,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;wBAClC,aAAa,GAAG,SAAS,CAAC;oBAC5B,CAAC;gBACH,CAAC;YACH,CAAC;YACD,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,aAAa,GAAG,WAAW,EAAE,CAAC;gBAC9B,YAAY,GAAG,MAAM,CAAC;YACxB,CAAC;YACD,OAAO,aAAa,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC,CAAC","sourcesContent":["import { CalculationCache } from \"./interfaces\";\n\n/**\n * Creates a [[CalculationCache]] object, useful for caching [[VNode]] trees.\n * In practice, caching of [[VNode]] trees is not needed, because achieving 60 frames per second is almost never a problem.\n * For more information, see [[CalculationCache]].\n *\n * @param <Result> The type of the value that is cached.\n */\nexport let createCache = <Result,>(): CalculationCache<Result> => {\n  let cachedInputs: unknown[] | undefined;\n  let cachedOutcome: Result | undefined;\n\n  return {\n    invalidate: () => {\n      cachedOutcome = undefined;\n      cachedInputs = undefined;\n    },\n\n    result: (inputs: unknown[], calculation: () => Result) => {\n      if (cachedInputs) {\n        for (let i = 0; i < inputs.length; i++) {\n          if (cachedInputs[i] !== inputs[i]) {\n            cachedOutcome = undefined;\n          }\n        }\n      }\n      if (!cachedOutcome) {\n        cachedOutcome = calculation();\n        cachedInputs = inputs;\n      }\n      return cachedOutcome;\n    },\n  };\n};\n"]}

package/dist/dom.d.ts

@@ -1,59 +1,59 @@
-/**
- * Contains simple low-level utility functions to manipulate the real DOM.
- */
-import { Projection, ProjectionOptions, VNode } from "./interfaces";
-export declare let applyDefaultProjectionOptions: (projectorOptions?: ProjectionOptions) => ProjectionOptions;
-export declare let dom: {
-    /**
-     * Creates a real DOM tree from `vnode`. The [[Projection]] object returned will contain the resulting DOM Node in
-     * its [[Projection.domNode|domNode]] property.
-     * This is a low-level method. Users will typically use a [[Projector]] instead.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
-     * objects may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the projection.
-     * @returns The [[Projection]] which also contains the DOM Node that was created.
-     */
-    create: (vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
-    /**
-     * Appends a new child node to the DOM which is generated from a [[VNode]].
-     * This is a low-level method. Users will typically use a [[Projector]] instead.
-     * @param parentNode - The parent node for the new child node.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
-     * objects may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the [[Projection]].
-     * @returns The [[Projection]] that was created.
-     */
-    append: (parentNode: Element, vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
-    /**
-     * Inserts a new DOM node which is generated from a [[VNode]].
-     * This is a low-level method. Users wil typically use a [[Projector]] instead.
-     * @param beforeNode - The node that the DOM Node is inserted before.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function.
-     * NOTE: [[VNode]] objects may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
-     * @returns The [[Projection]] that was created.
-     */
-    insertBefore: (beforeNode: Element, vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
-    /**
-     * Merges a new DOM node which is generated from a [[VNode]] with an existing DOM Node.
-     * This means that the virtual DOM and the real DOM will have one overlapping element.
-     * Therefore the selector for the root [[VNode]] will be ignored, but its properties and children will be applied to the Element provided.
-     * This is a low-level method. Users wil typically use a [[Projector]] instead.
-     * @param element - The existing element to adopt as the root of the new virtual DOM. Existing attributes and child nodes are preserved.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]] objects
-     * may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
-     * @returns The [[Projection]] that was created.
-     */
-    merge: (element: Element, vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
-    /**
-     * Replaces an existing DOM node with a node generated from a [[VNode]].
-     * This is a low-level method. Users will typically use a [[Projector]] instead.
-     * @param element - The node for the [[VNode]] to replace.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
-     * objects may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the [[Projection]].
-     * @returns The [[Projection]] that was created.
-     */
-    replace: (element: Element, vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
-};
+/**
+ * Contains simple low-level utility functions to manipulate the real DOM.
+ */
+import { Projection, ProjectionOptions, VNode } from "./interfaces";
+export declare let applyDefaultProjectionOptions: (projectorOptions?: ProjectionOptions) => ProjectionOptions;
+export declare let dom: {
+    /**
+     * Creates a real DOM tree from `vnode`. The [[Projection]] object returned will contain the resulting DOM Node in
+     * its [[Projection.domNode|domNode]] property.
+     * This is a low-level method. Users will typically use a [[Projector]] instead.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
+     * objects may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the projection.
+     * @returns The [[Projection]] which also contains the DOM Node that was created.
+     */
+    create: (vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
+    /**
+     * Appends a new child node to the DOM which is generated from a [[VNode]].
+     * This is a low-level method. Users will typically use a [[Projector]] instead.
+     * @param parentNode - The parent node for the new child node.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
+     * objects may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the [[Projection]].
+     * @returns The [[Projection]] that was created.
+     */
+    append: (parentNode: Element, vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
+    /**
+     * Inserts a new DOM node which is generated from a [[VNode]].
+     * This is a low-level method. Users wil typically use a [[Projector]] instead.
+     * @param beforeNode - The node that the DOM Node is inserted before.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function.
+     * NOTE: [[VNode]] objects may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
+     * @returns The [[Projection]] that was created.
+     */
+    insertBefore: (beforeNode: Element, vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
+    /**
+     * Merges a new DOM node which is generated from a [[VNode]] with an existing DOM Node.
+     * This means that the virtual DOM and the real DOM will have one overlapping element.
+     * Therefore the selector for the root [[VNode]] will be ignored, but its properties and children will be applied to the Element provided.
+     * This is a low-level method. Users wil typically use a [[Projector]] instead.
+     * @param element - The existing element to adopt as the root of the new virtual DOM. Existing attributes and child nodes are preserved.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]] objects
+     * may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
+     * @returns The [[Projection]] that was created.
+     */
+    merge: (element: Element, vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
+    /**
+     * Replaces an existing DOM node with a node generated from a [[VNode]].
+     * This is a low-level method. Users will typically use a [[Projector]] instead.
+     * @param element - The node for the [[VNode]] to replace.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
+     * objects may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the [[Projection]].
+     * @returns The [[Projection]] that was created.
+     */
+    replace: (element: Element, vnode: VNode, projectionOptions?: ProjectionOptions) => Projection;
+};

package/dist/dom.js

@@ -1,96 +1,96 @@
-import { createDom, createProjection, extend, initPropertiesAndChildren } from "./projection";
-var DEFAULT_PROJECTION_OPTIONS = {
-    namespace: undefined,
-    performanceLogger: function () { return undefined; },
-    eventHandlerInterceptor: undefined,
-    styleApplyer: function (domNode, styleName, value) {
-        if (styleName.charAt(0) === "-") {
-            // CSS variables must be set using setProperty
-            domNode.style.setProperty(styleName, value);
-        }
-        else {
-            // properties like 'backgroundColor' must be set as a js-property
-            domNode.style[styleName] = value;
-        }
-    },
-};
-export var applyDefaultProjectionOptions = function (projectorOptions) {
-    return extend(DEFAULT_PROJECTION_OPTIONS, projectorOptions);
-};
-export var dom = {
-    /**
-     * Creates a real DOM tree from `vnode`. The [[Projection]] object returned will contain the resulting DOM Node in
-     * its [[Projection.domNode|domNode]] property.
-     * This is a low-level method. Users will typically use a [[Projector]] instead.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
-     * objects may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the projection.
-     * @returns The [[Projection]] which also contains the DOM Node that was created.
-     */
-    create: function (vnode, projectionOptions) {
-        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
-        createDom(vnode, document.createElement("div"), undefined, projectionOptions);
-        return createProjection(vnode, projectionOptions);
-    },
-    /**
-     * Appends a new child node to the DOM which is generated from a [[VNode]].
-     * This is a low-level method. Users will typically use a [[Projector]] instead.
-     * @param parentNode - The parent node for the new child node.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
-     * objects may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the [[Projection]].
-     * @returns The [[Projection]] that was created.
-     */
-    append: function (parentNode, vnode, projectionOptions) {
-        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
-        createDom(vnode, parentNode, undefined, projectionOptions);
-        return createProjection(vnode, projectionOptions);
-    },
-    /**
-     * Inserts a new DOM node which is generated from a [[VNode]].
-     * This is a low-level method. Users wil typically use a [[Projector]] instead.
-     * @param beforeNode - The node that the DOM Node is inserted before.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function.
-     * NOTE: [[VNode]] objects may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
-     * @returns The [[Projection]] that was created.
-     */
-    insertBefore: function (beforeNode, vnode, projectionOptions) {
-        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
-        createDom(vnode, beforeNode.parentNode, beforeNode, projectionOptions);
-        return createProjection(vnode, projectionOptions);
-    },
-    /**
-     * Merges a new DOM node which is generated from a [[VNode]] with an existing DOM Node.
-     * This means that the virtual DOM and the real DOM will have one overlapping element.
-     * Therefore the selector for the root [[VNode]] will be ignored, but its properties and children will be applied to the Element provided.
-     * This is a low-level method. Users wil typically use a [[Projector]] instead.
-     * @param element - The existing element to adopt as the root of the new virtual DOM. Existing attributes and child nodes are preserved.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]] objects
-     * may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
-     * @returns The [[Projection]] that was created.
-     */
-    merge: function (element, vnode, projectionOptions) {
-        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
-        vnode.domNode = element;
-        initPropertiesAndChildren(element, vnode, projectionOptions);
-        return createProjection(vnode, projectionOptions);
-    },
-    /**
-     * Replaces an existing DOM node with a node generated from a [[VNode]].
-     * This is a low-level method. Users will typically use a [[Projector]] instead.
-     * @param element - The node for the [[VNode]] to replace.
-     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
-     * objects may only be rendered once.
-     * @param projectionOptions - Options to be used to create and update the [[Projection]].
-     * @returns The [[Projection]] that was created.
-     */
-    replace: function (element, vnode, projectionOptions) {
-        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
-        createDom(vnode, element.parentNode, element, projectionOptions);
-        element.parentNode.removeChild(element);
-        return createProjection(vnode, projectionOptions);
-    },
-};
+import { createDom, createProjection, extend, initPropertiesAndChildren } from "./projection";
+var DEFAULT_PROJECTION_OPTIONS = {
+    namespace: undefined,
+    performanceLogger: function () { return undefined; },
+    eventHandlerInterceptor: undefined,
+    styleApplyer: function (domNode, styleName, value) {
+        if (styleName.charAt(0) === "-") {
+            // CSS variables must be set using setProperty
+            domNode.style.setProperty(styleName, value);
+        }
+        else {
+            // properties like 'backgroundColor' must be set as a js-property
+            domNode.style[styleName] = value;
+        }
+    },
+};
+export var applyDefaultProjectionOptions = function (projectorOptions) {
+    return extend(DEFAULT_PROJECTION_OPTIONS, projectorOptions);
+};
+export var dom = {
+    /**
+     * Creates a real DOM tree from `vnode`. The [[Projection]] object returned will contain the resulting DOM Node in
+     * its [[Projection.domNode|domNode]] property.
+     * This is a low-level method. Users will typically use a [[Projector]] instead.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
+     * objects may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the projection.
+     * @returns The [[Projection]] which also contains the DOM Node that was created.
+     */
+    create: function (vnode, projectionOptions) {
+        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
+        createDom(vnode, document.createElement("div"), undefined, projectionOptions);
+        return createProjection(vnode, projectionOptions);
+    },
+    /**
+     * Appends a new child node to the DOM which is generated from a [[VNode]].
+     * This is a low-level method. Users will typically use a [[Projector]] instead.
+     * @param parentNode - The parent node for the new child node.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
+     * objects may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the [[Projection]].
+     * @returns The [[Projection]] that was created.
+     */
+    append: function (parentNode, vnode, projectionOptions) {
+        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
+        createDom(vnode, parentNode, undefined, projectionOptions);
+        return createProjection(vnode, projectionOptions);
+    },
+    /**
+     * Inserts a new DOM node which is generated from a [[VNode]].
+     * This is a low-level method. Users wil typically use a [[Projector]] instead.
+     * @param beforeNode - The node that the DOM Node is inserted before.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function.
+     * NOTE: [[VNode]] objects may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
+     * @returns The [[Projection]] that was created.
+     */
+    insertBefore: function (beforeNode, vnode, projectionOptions) {
+        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
+        createDom(vnode, beforeNode.parentNode, beforeNode, projectionOptions);
+        return createProjection(vnode, projectionOptions);
+    },
+    /**
+     * Merges a new DOM node which is generated from a [[VNode]] with an existing DOM Node.
+     * This means that the virtual DOM and the real DOM will have one overlapping element.
+     * Therefore the selector for the root [[VNode]] will be ignored, but its properties and children will be applied to the Element provided.
+     * This is a low-level method. Users wil typically use a [[Projector]] instead.
+     * @param element - The existing element to adopt as the root of the new virtual DOM. Existing attributes and child nodes are preserved.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]] objects
+     * may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].
+     * @returns The [[Projection]] that was created.
+     */
+    merge: function (element, vnode, projectionOptions) {
+        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
+        vnode.domNode = element;
+        initPropertiesAndChildren(element, vnode, projectionOptions);
+        return createProjection(vnode, projectionOptions);
+    },
+    /**
+     * Replaces an existing DOM node with a node generated from a [[VNode]].
+     * This is a low-level method. Users will typically use a [[Projector]] instead.
+     * @param element - The node for the [[VNode]] to replace.
+     * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]
+     * objects may only be rendered once.
+     * @param projectionOptions - Options to be used to create and update the [[Projection]].
+     * @returns The [[Projection]] that was created.
+     */
+    replace: function (element, vnode, projectionOptions) {
+        projectionOptions = applyDefaultProjectionOptions(projectionOptions);
+        createDom(vnode, element.parentNode, element, projectionOptions);
+        element.parentNode.removeChild(element);
+        return createProjection(vnode, projectionOptions);
+    },
+};
 //# sourceMappingURL=dom.js.map

package/dist/dom.js.map

@@ -1 +1 @@
-{"version":3,"file":"dom.js","sourceRoot":"","sources":["../src/dom.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAE9F,IAAM,0BAA0B,GAAsB;IACpD,SAAS,EAAE,SAAS;IACpB,iBAAiB,EAAE,cAAM,OAAA,SAAS,EAAT,CAAS;IAClC,uBAAuB,EAAE,SAAS;IAClC,YAAY,EAAE,UAAC,OAAoB,EAAE,SAAiB,EAAE,KAAa;QACnE,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;YAC/B,8CAA8C;YAC9C,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;SAC7C;aAAM;YACL,iEAAiE;YAChE,OAAO,CAAC,KAAa,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;SAC3C;IACH,CAAC;CACF,CAAC;AAEF,MAAM,CAAC,IAAI,6BAA6B,GAAG,UACzC,gBAAoC;IAEpC,OAAO,MAAM,CAAC,0BAA0B,EAAE,gBAAgB,CAAC,CAAC;AAC9D,CAAC,CAAC;AAEF,MAAM,CAAC,IAAI,GAAG,GAAG;IACf;;;;;;;;OAQG;IACH,MAAM,EAAE,UAAC,KAAY,EAAE,iBAAqC;QAC1D,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC;QAC9E,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,EAAE,UACN,UAAmB,EACnB,KAAY,EACZ,iBAAqC;QAErC,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC;QAC3D,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;OAQG;IACH,YAAY,EAAE,UACZ,UAAmB,EACnB,KAAY,EACZ,iBAAqC;QAErC,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC,UAAW,EAAE,UAAU,EAAE,iBAAiB,CAAC,CAAC;QACxE,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,EAAE,UAAC,OAAgB,EAAE,KAAY,EAAE,iBAAqC;QAC3E,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;QACxB,yBAAyB,CAAC,OAAO,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC;QAC7D,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;OAQG;IACH,OAAO,EAAE,UAAC,OAAgB,EAAE,KAAY,EAAE,iBAAqC;QAC7E,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,UAAW,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC;QAClE,OAAO,CAAC,UAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACzC,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;CACF,CAAC","sourcesContent":["/**\n * Contains simple low-level utility functions to manipulate the real DOM.\n */\nimport { Projection, ProjectionOptions, VNode } from \"./interfaces\";\nimport { createDom, createProjection, extend, initPropertiesAndChildren } from \"./projection\";\n\nconst DEFAULT_PROJECTION_OPTIONS: ProjectionOptions = {\n  namespace: undefined,\n  performanceLogger: () => undefined,\n  eventHandlerInterceptor: undefined,\n  styleApplyer: (domNode: HTMLElement, styleName: string, value: string) => {\n    if (styleName.charAt(0) === \"-\") {\n      // CSS variables must be set using setProperty\n      domNode.style.setProperty(styleName, value);\n    } else {\n      // properties like 'backgroundColor' must be set as a js-property\n      (domNode.style as any)[styleName] = value;\n    }\n  },\n};\n\nexport let applyDefaultProjectionOptions = (\n  projectorOptions?: ProjectionOptions\n): ProjectionOptions => {\n  return extend(DEFAULT_PROJECTION_OPTIONS, projectorOptions);\n};\n\nexport let dom = {\n  /**\n   * Creates a real DOM tree from `vnode`. The [[Projection]] object returned will contain the resulting DOM Node in\n   * its [[Projection.domNode|domNode]] property.\n   * This is a low-level method. Users will typically use a [[Projector]] instead.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]\n   * objects may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the projection.\n   * @returns The [[Projection]] which also contains the DOM Node that was created.\n   */\n  create: (vnode: VNode, projectionOptions?: ProjectionOptions): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    createDom(vnode, document.createElement(\"div\"), undefined, projectionOptions);\n    return createProjection(vnode, projectionOptions);\n  },\n\n  /**\n   * Appends a new child node to the DOM which is generated from a [[VNode]].\n   * This is a low-level method. Users will typically use a [[Projector]] instead.\n   * @param parentNode - The parent node for the new child node.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]\n   * objects may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the [[Projection]].\n   * @returns The [[Projection]] that was created.\n   */\n  append: (\n    parentNode: Element,\n    vnode: VNode,\n    projectionOptions?: ProjectionOptions\n  ): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    createDom(vnode, parentNode, undefined, projectionOptions);\n    return createProjection(vnode, projectionOptions);\n  },\n\n  /**\n   * Inserts a new DOM node which is generated from a [[VNode]].\n   * This is a low-level method. Users wil typically use a [[Projector]] instead.\n   * @param beforeNode - The node that the DOM Node is inserted before.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function.\n   * NOTE: [[VNode]] objects may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].\n   * @returns The [[Projection]] that was created.\n   */\n  insertBefore: (\n    beforeNode: Element,\n    vnode: VNode,\n    projectionOptions?: ProjectionOptions\n  ): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    createDom(vnode, beforeNode.parentNode!, beforeNode, projectionOptions);\n    return createProjection(vnode, projectionOptions);\n  },\n\n  /**\n   * Merges a new DOM node which is generated from a [[VNode]] with an existing DOM Node.\n   * This means that the virtual DOM and the real DOM will have one overlapping element.\n   * Therefore the selector for the root [[VNode]] will be ignored, but its properties and children will be applied to the Element provided.\n   * This is a low-level method. Users wil typically use a [[Projector]] instead.\n   * @param element - The existing element to adopt as the root of the new virtual DOM. Existing attributes and child nodes are preserved.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]] objects\n   * may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].\n   * @returns The [[Projection]] that was created.\n   */\n  merge: (element: Element, vnode: VNode, projectionOptions?: ProjectionOptions): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    vnode.domNode = element;\n    initPropertiesAndChildren(element, vnode, projectionOptions);\n    return createProjection(vnode, projectionOptions);\n  },\n\n  /**\n   * Replaces an existing DOM node with a node generated from a [[VNode]].\n   * This is a low-level method. Users will typically use a [[Projector]] instead.\n   * @param element - The node for the [[VNode]] to replace.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]\n   * objects may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the [[Projection]].\n   * @returns The [[Projection]] that was created.\n   */\n  replace: (element: Element, vnode: VNode, projectionOptions?: ProjectionOptions): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    createDom(vnode, element.parentNode!, element, projectionOptions);\n    element.parentNode!.removeChild(element);\n    return createProjection(vnode, projectionOptions);\n  },\n};\n"]}
+{"version":3,"file":"dom.js","sourceRoot":"","sources":["../src/dom.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAE9F,IAAM,0BAA0B,GAAsB;IACpD,SAAS,EAAE,SAAS;IACpB,iBAAiB,EAAE,cAAM,OAAA,SAAS,EAAT,CAAS;IAClC,uBAAuB,EAAE,SAAS;IAClC,YAAY,EAAE,UAAC,OAAoB,EAAE,SAAiB,EAAE,KAAa;QACnE,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YAChC,8CAA8C;YAC9C,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAC9C,CAAC;aAAM,CAAC;YACN,iEAAiE;YAChE,OAAO,CAAC,KAAa,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;QAC5C,CAAC;IACH,CAAC;CACF,CAAC;AAEF,MAAM,CAAC,IAAI,6BAA6B,GAAG,UACzC,gBAAoC;IAEpC,OAAO,MAAM,CAAC,0BAA0B,EAAE,gBAAgB,CAAC,CAAC;AAC9D,CAAC,CAAC;AAEF,MAAM,CAAC,IAAI,GAAG,GAAG;IACf;;;;;;;;OAQG;IACH,MAAM,EAAE,UAAC,KAAY,EAAE,iBAAqC;QAC1D,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC;QAC9E,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,EAAE,UACN,UAAmB,EACnB,KAAY,EACZ,iBAAqC;QAErC,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC;QAC3D,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;OAQG;IACH,YAAY,EAAE,UACZ,UAAmB,EACnB,KAAY,EACZ,iBAAqC;QAErC,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC,UAAW,EAAE,UAAU,EAAE,iBAAiB,CAAC,CAAC;QACxE,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,EAAE,UAAC,OAAgB,EAAE,KAAY,EAAE,iBAAqC;QAC3E,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;QACxB,yBAAyB,CAAC,OAAO,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC;QAC7D,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;OAQG;IACH,OAAO,EAAE,UAAC,OAAgB,EAAE,KAAY,EAAE,iBAAqC;QAC7E,iBAAiB,GAAG,6BAA6B,CAAC,iBAAiB,CAAC,CAAC;QACrE,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,UAAW,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC;QAClE,OAAO,CAAC,UAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACzC,OAAO,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACpD,CAAC;CACF,CAAC","sourcesContent":["/**\n * Contains simple low-level utility functions to manipulate the real DOM.\n */\nimport { Projection, ProjectionOptions, VNode } from \"./interfaces\";\nimport { createDom, createProjection, extend, initPropertiesAndChildren } from \"./projection\";\n\nconst DEFAULT_PROJECTION_OPTIONS: ProjectionOptions = {\n  namespace: undefined,\n  performanceLogger: () => undefined,\n  eventHandlerInterceptor: undefined,\n  styleApplyer: (domNode: HTMLElement, styleName: string, value: string) => {\n    if (styleName.charAt(0) === \"-\") {\n      // CSS variables must be set using setProperty\n      domNode.style.setProperty(styleName, value);\n    } else {\n      // properties like 'backgroundColor' must be set as a js-property\n      (domNode.style as any)[styleName] = value;\n    }\n  },\n};\n\nexport let applyDefaultProjectionOptions = (\n  projectorOptions?: ProjectionOptions\n): ProjectionOptions => {\n  return extend(DEFAULT_PROJECTION_OPTIONS, projectorOptions);\n};\n\nexport let dom = {\n  /**\n   * Creates a real DOM tree from `vnode`. The [[Projection]] object returned will contain the resulting DOM Node in\n   * its [[Projection.domNode|domNode]] property.\n   * This is a low-level method. Users will typically use a [[Projector]] instead.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]\n   * objects may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the projection.\n   * @returns The [[Projection]] which also contains the DOM Node that was created.\n   */\n  create: (vnode: VNode, projectionOptions?: ProjectionOptions): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    createDom(vnode, document.createElement(\"div\"), undefined, projectionOptions);\n    return createProjection(vnode, projectionOptions);\n  },\n\n  /**\n   * Appends a new child node to the DOM which is generated from a [[VNode]].\n   * This is a low-level method. Users will typically use a [[Projector]] instead.\n   * @param parentNode - The parent node for the new child node.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]\n   * objects may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the [[Projection]].\n   * @returns The [[Projection]] that was created.\n   */\n  append: (\n    parentNode: Element,\n    vnode: VNode,\n    projectionOptions?: ProjectionOptions\n  ): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    createDom(vnode, parentNode, undefined, projectionOptions);\n    return createProjection(vnode, projectionOptions);\n  },\n\n  /**\n   * Inserts a new DOM node which is generated from a [[VNode]].\n   * This is a low-level method. Users wil typically use a [[Projector]] instead.\n   * @param beforeNode - The node that the DOM Node is inserted before.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function.\n   * NOTE: [[VNode]] objects may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].\n   * @returns The [[Projection]] that was created.\n   */\n  insertBefore: (\n    beforeNode: Element,\n    vnode: VNode,\n    projectionOptions?: ProjectionOptions\n  ): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    createDom(vnode, beforeNode.parentNode!, beforeNode, projectionOptions);\n    return createProjection(vnode, projectionOptions);\n  },\n\n  /**\n   * Merges a new DOM node which is generated from a [[VNode]] with an existing DOM Node.\n   * This means that the virtual DOM and the real DOM will have one overlapping element.\n   * Therefore the selector for the root [[VNode]] will be ignored, but its properties and children will be applied to the Element provided.\n   * This is a low-level method. Users wil typically use a [[Projector]] instead.\n   * @param element - The existing element to adopt as the root of the new virtual DOM. Existing attributes and child nodes are preserved.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]] objects\n   * may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the projection, see [[createProjector]].\n   * @returns The [[Projection]] that was created.\n   */\n  merge: (element: Element, vnode: VNode, projectionOptions?: ProjectionOptions): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    vnode.domNode = element;\n    initPropertiesAndChildren(element, vnode, projectionOptions);\n    return createProjection(vnode, projectionOptions);\n  },\n\n  /**\n   * Replaces an existing DOM node with a node generated from a [[VNode]].\n   * This is a low-level method. Users will typically use a [[Projector]] instead.\n   * @param element - The node for the [[VNode]] to replace.\n   * @param vnode - The root of the virtual DOM tree that was created using the [[h]] function. NOTE: [[VNode]]\n   * objects may only be rendered once.\n   * @param projectionOptions - Options to be used to create and update the [[Projection]].\n   * @returns The [[Projection]] that was created.\n   */\n  replace: (element: Element, vnode: VNode, projectionOptions?: ProjectionOptions): Projection => {\n    projectionOptions = applyDefaultProjectionOptions(projectionOptions);\n    createDom(vnode, element.parentNode!, element, projectionOptions);\n    element.parentNode!.removeChild(element);\n    return createProjection(vnode, projectionOptions);\n  },\n};\n"]}

package/dist/h.d.ts

@@ -1,34 +1,34 @@
-import { VNode, VNodeChild, VNodeProperties } from "./interfaces";
-/**
- * The `h` function is used to create a virtual DOM node.
- * This function is largely inspired by the mercuryjs and mithril frameworks.
- * The `h` stands for (virtual) hyperscript.
- *
- * @param selector    Contains the tagName, id and fixed css classnames in CSS selector format.
- *                    It is formatted as follows: `tagname.cssclass1.cssclass2#id`.
- * @param properties  An object literal containing properties that will be placed on the DOM node.
- * @param children    Virtual DOM nodes and strings to add as child nodes.
- *                    `children` may contain [[VNode]]s, `string`s, nested arrays, `null` and `undefined`.
- *                    Nested arrays are flattened, `null` and `undefined` are removed.
- *
- * @returns           A VNode object, used to render a real DOM later.
- *
- * NOTE: There are {@link http://maquettejs.org/docs/rules.html|two basic rules} you should be aware of when updating the virtual DOM.
- */
-export declare function h(selector: string, properties?: VNodeProperties, children?: VNodeChild[] | null): VNode;
-/**
- * The `h` function is used to create a virtual DOM node.
- * This function is largely inspired by the mercuryjs and mithril frameworks.
- * The `h` stands for (virtual) hyperscript.
- *
- * @param selector    Contains the tagName, id and fixed css classnames in CSS selector format.
- *                    It is formatted as follows: `tagname.cssclass1.cssclass2#id`.
- * @param children    Virtual DOM nodes and strings to add as child nodes.
- *                    `children` may contain [[VNode]]s, `string`s, nested arrays, `null` and `undefined`.
- *                    Nested arrays are flattened, `null` and `undefined` are removed.
- *
- * @returns           A VNode object, used to render a real DOM later.
- *
- * NOTE: There are {@link http://maquettejs.org/docs/rules.html|two basic rules} you should be aware of when updating the virtual DOM.
- */
-export declare function h(selector: string, children: VNodeChild[]): VNode;
+import { VNode, VNodeChild, VNodeProperties } from "./interfaces";
+/**
+ * The `h` function is used to create a virtual DOM node.
+ * This function is largely inspired by the mercuryjs and mithril frameworks.
+ * The `h` stands for (virtual) hyperscript.
+ *
+ * @param selector    Contains the tagName, id and fixed css classnames in CSS selector format.
+ *                    It is formatted as follows: `tagname.cssclass1.cssclass2#id`.
+ * @param properties  An object literal containing properties that will be placed on the DOM node.
+ * @param children    Virtual DOM nodes and strings to add as child nodes.
+ *                    `children` may contain [[VNode]]s, `string`s, nested arrays, `null` and `undefined`.
+ *                    Nested arrays are flattened, `null` and `undefined` are removed.
+ *
+ * @returns           A VNode object, used to render a real DOM later.
+ *
+ * NOTE: There are {@link http://maquettejs.org/docs/rules.html two basic rules} you should be aware of when updating the virtual DOM.
+ */
+export declare function h(selector: string, properties?: VNodeProperties, children?: VNodeChild[] | null): VNode;
+/**
+ * The `h` function is used to create a virtual DOM node.
+ * This function is largely inspired by the mercuryjs and mithril frameworks.
+ * The `h` stands for (virtual) hyperscript.
+ *
+ * @param selector    Contains the tagName, id and fixed css classnames in CSS selector format.
+ *                    It is formatted as follows: `tagname.cssclass1.cssclass2#id`.
+ * @param children    Virtual DOM nodes and strings to add as child nodes.
+ *                    `children` may contain [[VNode]]s, `string`s, nested arrays, `null` and `undefined`.
+ *                    Nested arrays are flattened, `null` and `undefined` are removed.
+ *
+ * @returns           A VNode object, used to render a real DOM later.
+ *
+ * NOTE: There are {@link http://maquettejs.org/docs/rules.html two basic rules} you should be aware of when updating the virtual DOM.
+ */
+export declare function h(selector: string, children: VNodeChild[]): VNode;

package/dist/h.js

@@ -1,56 +1,56 @@
-var toTextVNode = function (data) {
-    return {
-        vnodeSelector: "",
-        properties: undefined,
-        children: undefined,
-        text: data.toString(),
-        domNode: null,
-    };
-};
-var appendChildren = function (parentSelector, insertions, main) {
-    for (var i = 0, length_1 = insertions.length; i < length_1; i++) {
-        var item = insertions[i];
-        if (Array.isArray(item)) {
-            appendChildren(parentSelector, item, main);
-        }
-        else {
-            if (item !== null && item !== undefined && item !== false) {
-                if (typeof item === "string") {
-                    item = toTextVNode(item);
-                }
-                main.push(item);
-            }
-        }
-    }
-};
-export function h(selector, properties, children) {
-    if (Array.isArray(properties)) {
-        children = properties;
-        properties = undefined;
-    }
-    else if ((properties && (typeof properties === "string" || properties.vnodeSelector)) ||
-        (children && (typeof children === "string" || children.vnodeSelector))) {
-        throw new Error("h called with invalid arguments");
-    }
-    var text;
-    var flattenedChildren;
-    // Recognize a common special case where there is only a single text node
-    if (children && children.length === 1 && typeof children[0] === "string") {
-        text = children[0];
-    }
-    else if (children) {
-        flattenedChildren = [];
-        appendChildren(selector, children, flattenedChildren);
-        if (flattenedChildren.length === 0) {
-            flattenedChildren = undefined;
-        }
-    }
-    return {
-        vnodeSelector: selector,
-        properties: properties,
-        children: flattenedChildren,
-        text: text === "" ? undefined : text,
-        domNode: null,
-    };
-}
+var toTextVNode = function (data) {
+    return {
+        vnodeSelector: "",
+        properties: undefined,
+        children: undefined,
+        text: data.toString(),
+        domNode: null,
+    };
+};
+var appendChildren = function (parentSelector, insertions, main) {
+    for (var i = 0, length_1 = insertions.length; i < length_1; i++) {
+        var item = insertions[i];
+        if (Array.isArray(item)) {
+            appendChildren(parentSelector, item, main);
+        }
+        else {
+            if (item !== null && item !== undefined && item !== false) {
+                if (typeof item === "string") {
+                    item = toTextVNode(item);
+                }
+                main.push(item);
+            }
+        }
+    }
+};
+export function h(selector, properties, children) {
+    if (Array.isArray(properties)) {
+        children = properties;
+        properties = undefined;
+    }
+    else if ((properties && (typeof properties === "string" || properties.vnodeSelector)) ||
+        (children && (typeof children === "string" || children.vnodeSelector))) {
+        throw new Error("h called with invalid arguments");
+    }
+    var text;
+    var flattenedChildren;
+    // Recognize a common special case where there is only a single text node
+    if (children && children.length === 1 && typeof children[0] === "string") {
+        text = children[0];
+    }
+    else if (children) {
+        flattenedChildren = [];
+        appendChildren(selector, children, flattenedChildren);
+        if (flattenedChildren.length === 0) {
+            flattenedChildren = undefined;
+        }
+    }
+    return {
+        vnodeSelector: selector,
+        properties: properties,
+        children: flattenedChildren,
+        text: text === "" ? undefined : text,
+        domNode: null,
+    };
+}
 //# sourceMappingURL=h.js.map