solarite 0.5.2 → 0.7.0

package/src/assert.js

@@ -1,10 +1,10 @@
-
-/*@__NO_SIDE_EFFECTS__*/
-export default function assert(val) {
-	//#IFDEV
-	if (!val) {
-		//debugger;
-		throw new Error('Assertion failed: ' + val);
-	}
-	//#ENDIF
-}
+
+/*@__NO_SIDE_EFFECTS__*/
+export default function assert(val) {
+	//#IFDEV
+	if (!val) {
+		//debugger;
+		throw new Error('Assertion failed: ' + val);
+	}
+	//#ENDIF
+}

package/src/assignAttributes.js

@@ -0,0 +1,63 @@
+/*
+┏┓  ┓    •
+┗┓┏┓┃┏┓┏┓┓╋▗▖
+┗┛┗┛┗┗┻╹ ╹╹┗
+JavaScript UI library
+@license MIT
+@copyright Vorticode LLC
+https://vorticode.github.io/solarite/ */
+
+import Util from "./Util.js";
+
+/**
+ * Read an element's html attributes onto fields that already exist on the element.
+ * Typically called from a web component constructor to support plain-html instantiation
+ * like `<my-timer duration="7" auto-start>`.  Tagged-template values are already typed and
+ * arrive in the constructor's argument instead, so assign those directly.
+ *
+ * Attribute names convert from kebab-case to camelCase, so `auto-start` becomes `autoStart`.
+ * An attribute written like `${...}` is JSON-parsed back to its original type and assigned
+ * as-is.  Every other attribute value is a string: if its field is named in `types`, the
+ * string is cast with that converter, otherwise it's assigned as a string.
+ *
+ * `types` maps a field name to a converter: Number, Boolean, String, Date, or any function
+ * taking the string and returning a value.  Boolean is true for any string except 'false'
+ * and '0', so a bare attribute like `<my-timer auto-start>` reads as true.  Date uses
+ * new Date(value).  No type is inferred from the field's existing value.
+ *
+ * Field names listed in `ignore` are skipped.
+ * @param dest {HTMLElement}
+ * @param types {Object<string, Function>}
+ * @param ignore {string[]} */
+export function assignAttributes(dest, types={}, ignore=[]) {
+	for (let attrib of dest.attributes) {
+		let name = Util.dashesToCamel(attrib.name);
+		if (!(name in dest) || ignore.includes(name))
+			continue;
+
+		let value = attrib.value;
+		let type = types[name];
+
+		// 1. A `${...}` attribute holds an already-typed JSON value.
+		if (value.startsWith('${') && value.endsWith('}'))
+			dest[name] = JSON.parse(value.slice(2, -1));
+
+		// 2. Cast the string with the converter named in `types`, if any.
+		else if (type === Date)
+			dest[name] = new Date(value);
+		else if (type === Boolean)
+			dest[name] = !['false', '0'].includes(value);
+		else if (type === Number)
+			dest[name] = Number(value);
+		else if (type === String)
+			dest[name] = String(value);
+		else if (type) // custom string=>value function
+			dest[name] = type(value);
+
+		// 3. No converter named: assign the raw string.  But an empty value over a function/object
+		// field is just the serialization residue of a template expression (functions render as
+		// attribute="") — skip it, or it clobbers the real value the expression already assigned.
+		else if (value !== '' || !(typeof dest[name] === 'function' || (typeof dest[name] === 'object' && dest[name] !== null)))
+			dest[name] = value;
+	}
+}

package/src/delve.js

@@ -1,44 +1,56 @@
-/**
- * Follow a path into an object.
- * @param obj {object}
- * @param path {string[]}
- * @param createVal {*}  If set, non-existent paths will be created and value at path will be set to createVal.
- * @return {*} The value, or undefined if it can't be reached. */
-export default function delve(obj, path, createVal = d) {
-	let isCreate = createVal !== d;
-
-	let len = path.length;
-	if (!obj && !isCreate && len)
-		return undefined;
-
-	let i = 0;
-	for (let srcProp of path) {
-
-		// If the path is undefined and we're not to the end yet:
-		if (obj[srcProp] === undefined) {
-
-			// If the next index is an integer or integer string.
-			if (isCreate) {
-				if (i < len - 1) {
-					// If next level path is a number, create as an array
-					let isArray = (path[i + 1] + '').match(/^\d+$/);
-					obj[srcProp] = isArray ? [] : {};
-				}
-			} else
-				return undefined; // can't traverse
-		}
-
-		// If last item in path
-		if (isCreate && i === len - 1)
-			obj[srcProp] = createVal;
-
-		// Traverse deeper along destination object.
-		obj = obj[srcProp];
-		i++;
-	}
-
-	return obj;
-}
-
-// d means "don't create"
+/**
+ * Follow a path into an object.
+ * @param obj {object}
+ * @param path {string[]}
+ * @param createVal {*}  If set, non-existent paths will be created and value at path will be set to createVal.
+ * @return {*} The value, or undefined if it can't be reached. */
+export default function delve(obj, path, createVal = d) {
+	let isCreate = createVal !== d;
+
+	let len = path.length;
+	if (!obj && !isCreate && len)
+		return undefined;
+
+	let i = 0;
+	for (let srcProp of path) {
+
+		// If the path is undefined and we're not to the end yet:
+		if (obj[srcProp] === undefined) {
+
+			// If the next index is an integer or integer string.
+			if (isCreate) {
+				if (i < len - 1) {
+					// If next level path is a number, create as an array
+					let isArray = (path[i + 1] + '').match(/^\d+$/);
+					obj[srcProp] = isArray ? [] : {};
+				}
+			} else
+				return undefined; // can't traverse
+		}
+
+		// If last item in path
+		if (isCreate && i === len - 1)
+			obj[srcProp] = createVal;
+
+		// Traverse deeper along destination object.
+		obj = obj[srcProp];
+		i++;
+	}
+
+	return obj;
+}
+
+
+/**
+ * Is it an array and a path that can be evaluated by delve() ?
+ * We allow the first element to be null/undefined so binding can report errors.
+ * @param arr {Array|*}
+ * @returns {boolean} */
+export function isDelvePath(arr) {
+	return Array.isArray(arr) && arr.length >=2  // An array of at least two elements.
+		&& (typeof arr[0] === 'object' || arr[0] === undefined) // Where the first element is an object, null, or undefined.
+		&& !arr.slice(1).find(p => typeof p !== 'string' && typeof p !== 'number'); // Path 1..x is only numbers and strings.
+}
+
+// d means "don't create"
 let d = {};

package/src/h.js

@@ -1,138 +1,220 @@
-import Template from "./Template.js";
-import Globals from "./Globals.js";
-import toEl from "./toEl.js";
-import Util from "./Util.js";
-
-/**
- * Convert strings to HTMLNodes.
- * Using h`...` as a tag will always create a Template.
- * Using h() as a function() will always create a DOM element.
- *
- * Features beyond what standard js tagged template strings do:
- * 1. h`` sub-expressions
- * 2. functions, nodes, and arrays of nodes as sub-expressions.
- * 3. html-escape all expressions by default, unless wrapped in h()
- * 4. event binding
- * 5. TODO:  list more
- *
- * General rule:
- * If h() is a function with null or an HTMLElement as its first argument create a Node.
- * Otherwise create a template
- *
- * Currently supported:
- *
- * Create Tempataes
- * 1. h`<b>Hello</b> ${'World'}!`      // Create Template that can later be used to create nodes.
- * 2. h('<b>Hello</b><u>Goodbye</u>'); // Create Template from string, that can later be used to create nodes.
- *
- * Add children to an element.
- * 3. h(el, h`<b>${'Hi'}</b>`, ?options)
- * 4. h(el, ?options)`<b>${'Hi'}</b>`   // typical path used in render(). Create template and render its nodes to el.
- *
- * Create top-level element
- * 5. h()`Hello<b>${'World'}!</b>`
- *
- * 6. h(string, object, ...)           // Used for JSX
- * @param htmlStrings {?HTMLElement|string|string[]|function():Template|{render:function()}}
- * @param exprs {*[]|string|Template|Object}
- * @return {Node|HTMLElement|Template|Function} */
-export default function h(htmlStrings=undefined, ...exprs) {
-
-	// 1. Tagged template: h`<div>...</div>`
-	if (Array.isArray(arguments[0])) {
-		return new Template(arguments[0], exprs);
-	}
-
-	// 2. String to template, or JSX factory form h(tag, props, ...children)
-	else if (typeof arguments[0] === 'string' || arguments[0] instanceof String) {
-		let tagOrHtml = arguments[0];
-
-		// 2a. JSX: h("tag", {props}, ...children)
-		if (exprs.length && (typeof exprs[0] === 'object' || exprs[0] === null)) {
-			let tag = tagOrHtml + '';
-			let props = exprs[0] || {};
-			let children = exprs.slice(1);
-
-			return Template.fromJsx(tag, props, children);
-		}
-
-		// 2b. Plain html string => template: h('<div>...</div>')
-		else {
-			let html = tagOrHtml;
-			// If it starts with whitespace and then a tag, trim it.
-			if (html.match(/^\s^</))
-				html = html.trim();
-			return new Template([html], []);
-		}
-	}
-
-	else if (arguments[0] instanceof HTMLElement || arguments[0] instanceof DocumentFragment) {
-
-		// 3. Render template to element: h(el, template)
-		if (arguments[1] instanceof Template) {
-
-			/** @type Template */
-			let template = arguments[1];
-			let parent = arguments[0];
-			let options = arguments[2];
-			template.render(parent, options);
-		}
-
-		// 4. Render tagged template to element: h(el)`<div>...</div>`
-		else {
-			let parent = arguments[0], options = arguments[1];
-
-			// Remove shadowroot if present.  TODO: This could mess up paths?
-			if (parent.shadowRoot)
-				parent.innerHTML = '';
-
-			// Return a tagged template function that applies the tagged template to parent.
-			let renderTemplate = (htmlStrings, ...exprs) => {
-				Globals.rendered.add(parent)
-				let template = new Template(htmlStrings, exprs);
-				return template.render(parent, options);
-			}
-			return renderTemplate;
-		}
-	}
-
-	// 5. Create a static element: h()`<div></div>`
-	else if (!arguments.length) {
-		return (htmlStrings, ...exprs) => {
-			let template = h(htmlStrings, ...exprs);
-			return toEl(template);
-		}
-	}
-
-	// 6. Help toEl() with objects: h(this)`<div>...</div>` inside an object's render()
-	// Intercepts the main h(this)`...` function call inside render().
-	// TODO: This path doesn't handle embeds like data-id="..."
-	else if (typeof arguments[0] === 'object' && Globals.objToEl.has(arguments[0])) {
-		let obj = arguments[0];
-
-		if (obj.constructor.name !== 'Object')
-			throw new Error(`Solarate Web Component class ${obj.constructor?.name} must extend HTMLElement.`);
-
-		// Jsx with h(this, <jsx>)
-		if (arguments[1] instanceof Template) {
-			let template = arguments[1];
-			let el = template.render();
-			Globals.objToEl.set(obj, el);
-		}
-
-		// h(this)`<div>...</div>`
-		else
-			return function(...args) {
-				let template = h(...args);
-				let el = template.render();
-				Globals.objToEl.set(obj, el);
-			}.bind(obj);
-	}
-	// TODO: Handle other primitive types?
-	else if (Util.isFalsy(arguments[0]))
-		return new Template();
-
-	else
-		throw new Error('h() does not support argument of type: ' + (arguments[0] ? typeof arguments[0] : arguments[0]))
-}
-
+import Template from "./Template.js";
+import Globals from "./Globals.js";
+import toEl from "./toEl.js";
+import Util from "./Util.js";
+import {jsxToTemplate, Fragment} from "./jsx.js";
+
+/**
+ * Convert strings to HTMLNodes.
+ * Using h`...` as a tag will always create a Template.
+ * Using h() as a function() will always create a DOM element.
+ *
+ * Features beyond what standard js tagged template strings do:
+ * 1. h`` sub-expressions
+ * 2. functions, nodes, and arrays of nodes as sub-expressions.
+ * 3. html-escape all expressions by default, unless wrapped in h()
+ * 4. event binding
+ * 5. TODO:  list more
+ *
+ * General rule:
+ * If h() is a function with null or an HTMLElement as its first argument create a Node.
+ * Otherwise create a template
+ *
+ * Currently supported:
+ *
+ * Create Tempataes
+ * 1. h`<b>Hello</b> ${'World'}!`      // Create Template that can later be used to create nodes.
+ * 2. h('<b>Hello</b><u>Goodbye</u>'); // Create Template from string, that can later be used to create nodes.
+ *
+ * Add children to an element.
+ * 3. h(el, h`<b>${'Hi'}</b>`, ?options)
+ * 4. h(el, ?options)`<b>${'Hi'}</b>`   // typical path used in render(). Create template and render its nodes to el.
+ *
+ * Create top-level element
+ * 5. h()`Hello<b>${'World'}!</b>`
+ *
+ * 6. h(string, object, ...)           // Used for JSX
+ * @param htmlStrings {?HTMLElement|string|string[]|function():Template|{render:function()}}
+ * @param exprs {*[]|string|Template|Object}
+ * @return {Node|HTMLElement|Template|Function} */
+/**
+ * Like h`...` but the fragment is parsed in the SVG namespace.
+ * Required for nested SVG fragments, since they're parsed standalone without an <svg> ancestor:
+ * h`<svg>${svg`<circle r="1"/>`}</svg>`
+ * @param htmlStrings {string[]}
+ * @param exprs {*[]}
+ * @return {Template} */
+export function svg(htmlStrings, ...exprs) {
+	let template = new Template(htmlStrings, exprs);
+	template.svgMode = true;
+	return template;
+}
+
+const renderTemplateKey = Symbol('solariteRender');
+
+// Unique default that detects h() called with no arguments.
+// Using `arguments` alongside rest params would force the engine to materialize both per call.
+const noArg = Symbol();
+
+export default function h(htmlStrings=noArg, ...exprs) {
+
+	// 1. Tagged template: h`<div>...</div>`
+	if (Array.isArray(htmlStrings)) {
+		return new Template(htmlStrings, exprs);
+	}
+
+	// 2. String to template, or JSX factory form h(tag, props, ...children)
+	else if (typeof htmlStrings === 'string' || htmlStrings instanceof String) {
+		let tagOrHtml = htmlStrings;
+
+		// 2a. JSX classic factory: h("tag", {props}, ...children)
+		if (exprs.length && (typeof exprs[0] === 'object' || exprs[0] === null)) {
+			let tag = tagOrHtml + '';
+			let props = exprs[0] || {};
+			let children = exprs.slice(1);
+
+			return jsxToTemplate(tag, props, children);
+		}
+
+		// 2b. Plain html string => template: h('<div>...</div>')
+		else {
+			let html = tagOrHtml;
+			// If it starts with whitespace and then a tag, trim it.
+			if (/^\s+</.test(html))
+				html = html.trim();
+			return new Template([html], []);
+		}
+	}
+
+	// 2c. JSX classic factory for a component or Fragment: h(Component, {props}, ...children)
+	// The transform passes the class/function (or the Fragment symbol) as the first argument.
+	else if (typeof htmlStrings === 'function' || htmlStrings === Fragment) {
+		return jsxToTemplate(htmlStrings, exprs[0] || {}, exprs.slice(1));
+	}
+
+	else if (htmlStrings instanceof HTMLElement || htmlStrings instanceof DocumentFragment) {
+
+		// 3. Render template to element: h(el, template)
+		if (exprs[0] instanceof Template) {
+
+			/** @type Template */
+			let template = exprs[0];
+			let parent = htmlStrings;
+			let options = exprs[1];
+			template.render(parent, options);
+		}
+
+		// 4. Render tagged template to element: h(el)`<div>...</div>`
+		else {
+			let parent = htmlStrings, options = exprs[0];
+
+			// The closure is cached on the element so repeated renders don't recreate it.
+			if (options === undefined) {
+				let cached = parent[renderTemplateKey];
+				if (cached)
+					return cached;
+			}
+
+			// Return a tagged template function that applies the tagged template to parent.
+			let renderTemplate = (htmlStrings, ...exprs) => {
+				// Remove shadowroot if present.  TODO: This could mess up paths?
+				if (parent.shadowRoot)
+					parent.innerHTML = '';
+
+				Globals.rendered.add(parent)
+				let template = new Template(htmlStrings, exprs);
+				return template.render(parent, options);
+			}
+			if (options === undefined)
+				parent[renderTemplateKey] = renderTemplate;
+			return renderTemplate;
+		}
+	}
+
+	// 5. Create a static element: h()`<div></div>`
+	else if (htmlStrings === noArg) {
+		return (htmlStrings, ...exprs) => {
+			let template = h(htmlStrings, ...exprs);
+			return toEl(template);
+		}
+	}
+
+	// 6. Help toEl() with objects: h(this)`<div>...</div>` inside an object's render()
+	// Intercepts the main h(this)`...` function call inside render().
+	// TODO: This path doesn't handle embeds like data-id="..."
+	else if (typeof htmlStrings === 'object' && Globals.objToEl.has(htmlStrings)) {
+		let obj = htmlStrings;
+
+		if (obj.constructor.name !== 'Object')
+			throw new Error(`Solarate Web Component class ${obj.constructor?.name} must extend HTMLElement.`);
+
+		// Jsx with h(this, <jsx>)
+		if (exprs[0] instanceof Template) {
+			let template = exprs[0];
+			let el = template.render();
+			Globals.objToEl.set(obj, el);
+		}
+
+		// h(this)`<div>...</div>`
+		else
+			return function(...args) {
+				let template = h(...args);
+				let el = template.render();
+				Globals.objToEl.set(obj, el);
+			}.bind(obj);
+	}
+	// TODO: Handle other primitive types?
+	else if (Util.isFalsy(htmlStrings))
+		return new Template();
+
+	else
+		throw new Error('h() does not support argument of type: ' + (htmlStrings ? typeof htmlStrings : htmlStrings))
+}
+
+// h.map caches each item's Template keyed by the item's identity, so a re-render returns
+// the SAME Template instance for any item whose reference is unchanged.  The reconciler's
+// `ng.template === item` fast path (PathToNodes.applyKeyed/applyDiff) then skips rebuilding
+// and comparing that row.  A WeakMap is used instead of a symbol property so the idiomatic
+// immutable update `{...item, x}` yields a fresh object that ISN'T in the cache and re-renders;
+// a symbol property would be copied by spread and silently reuse the stale Template.
+const mapCache = new WeakMap();
+
+/**
+ * Render a list, reusing each item's DOM for as long as the item is the SAME object.
+ *
+ * Treat items as immutable: to change a row, replace it with a new object rather than
+ * mutating it in place, so its identity changes and it re-renders.  This is the contract
+ * Solid's <For> and React's keyed lists use.  It takes no deps — the object identity IS
+ * the dependency — so the call site stays a plain list with no caching code.
+ *
+ * Each item must be a distinct object, and an object must appear in only one h.map.
+ * Non-object items (strings, numbers) are never cached and rebuild every render.
+ *
+ * h.immutableMap is the same function under a longer, self-documenting name; use whichever
+ * reads better: h.map for brevity, h.immutableMap to flag the immutability contract.
+ *
+ * ${h.map(this.rows, row => h`<tr key=${row.id}>${row.label}</tr>`)}
+ *
+ * @param items {Array} The list to render.
+ * @param fn {function(item:*):Template} Builds an item's Template; called only for new items.
+ * @return {Template[]} */
+h.map = (items, fn) => {
+	let result = new Array(items.length);
+	for (let i=0; i<items.length; i++) {
+		let item = items[i];
+		if (item !== null && typeof item === 'object') {
+			let template = mapCache.get(item);
+			if (template === undefined) {
+				template = fn(item);
+				mapCache.set(item, template);
+			}
+			result[i] = template;
+		}
+		else
+			result[i] = fn(item);
+	}
+	return result;
+}
+
+h.immutableMap = h.map;
+

package/src/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export { jsx, jsxs, jsxDEV, Fragment, jsxTemplate, jsxAttr, jsxEscape, JSX } from './jsx-runtime';

package/src/jsx-dev-runtime.js

@@ -0,0 +1,5 @@
+/** Dev entry point used by toolchains configured with the automatic runtime in development mode
+ * (e.g. esbuild/tsc `jsxDEV`).  It re-exports the same runtime; the extra dev source args are
+ * ignored. */
+export { jsx, jsxs, jsxDEV, Fragment, jsxTemplate, jsxAttr, jsxEscape } from './jsx-runtime.js';
+export { jsxDEV as jsxDEVRuntime } from './jsx-runtime.js';

package/src/jsx-runtime.d.ts

@@ -0,0 +1,21 @@
+import { Template } from './Solarite';
+
+export function jsxTemplate(strings: string[], ...exprs: any[]): Template;
+export function jsxAttr(name: string, value: any): any;
+export function jsxEscape(value: any): any;
+export function jsx(tag: any, props: any, key?: any): Template;
+export function jsxs(tag: any, props: any, key?: any): Template;
+export function jsxDEV(tag: any, props: any, key?: any): Template;
+export const Fragment: unique symbol;
+
+/**
+ * Types for `tsconfig` / `deno.json` with `jsx: "react-jsx" | "precompile"` and
+ * `jsxImportSource: "solarite"`.  IntrinsicElements is intentionally permissive for now: any
+ * lowercase tag with any attributes is allowed.  A JSX expression evaluates to a Solarite Template. */
+export namespace JSX {
+	type Element = Template;
+	interface ElementChildrenAttribute { children: {}; }
+	interface IntrinsicElements {
+		[tagName: string]: any;
+	}
+}

package/src/jsx-runtime.js

@@ -0,0 +1,84 @@
+/**
+ * Solarite JSX runtime.  Configure your toolchain with `jsxImportSource: "solarite"` (automatic
+ * runtime) or have Deno's `jsx:"precompile"` / a Solarite build plugin target this module.
+ *
+ * Tier 1 (precompile): jsxTemplate/jsxAttr/jsxEscape map hoisted statics straight onto Template.
+ * Tier 2 (automatic):  jsx/jsxs/jsxDEV build a Template per render via the shape-interning factory.
+ *
+ * See src/jsx.js for the shared core (jsxToTemplate, JsxAttr, Fragment). */
+import Template from "./Template.js";
+import {JsxAttr, jsxToTemplate, Fragment} from "./jsx.js";
+
+export {Fragment};
+
+/**
+ * Tier 1: build a Template from hoisted static strings and expression holes, with the statics'
+ * stable array identity feeding Shell cache / NodeGroup reuse just like a tagged template.
+ * @param strings {string[]} Module-hoisted static html (same array every render).
+ * @param exprs {...*} jsxAttr() pairs, jsxEscape() children, and bare boolean-attr strings.
+ * @return {Template} */
+export function jsxTemplate(strings, ...exprs) {
+	let key;
+	for (let i = 0; i < exprs.length; i++) {
+		let e = exprs[i];
+		// A `key` prop arrives as jsxAttr("key", value) at an attribute hole.  Lift it onto the
+		// Template for keyed diffing and blank the hole so it never renders as an attribute.
+		if (e instanceof JsxAttr && e.name === 'key') {
+			key = e.value;
+			exprs[i] = '';
+		}
+	}
+	let t = new Template(strings, exprs);
+	if (key !== undefined)
+		t.key = key;
+	return t;
+}
+
+/**
+ * Tier 1: a whole-attribute hole, e.g. `<a ` + jsxAttr("href", v) + `>`.  PathToAttribs detects
+ * this and routes the value through normal attribute/event/property application.
+ * @param name {string}
+ * @param value {*}
+ * @return {JsxAttr} */
+export function jsxAttr(name, value) {
+	return new JsxAttr(name, value);
+}
+
+/**
+ * Tier 1: a child hole.  Solarite already html-escapes child expressions (strings render as text,
+ * Templates/arrays as nodes), so this is the identity function.
+ * @param value {*}
+ * @return {*} */
+export function jsxEscape(value) {
+	return value;
+}
+
+/**
+ * Tier 2 automatic runtime: a single-child element.  props.children is one child hole.
+ * @param tag {string|Function|symbol}
+ * @param props {Object}
+ * @param key {*}
+ * @return {Template} */
+export function jsx(tag, props, key) {
+	props = props || {};
+	let children = ('children' in props) ? [props.children] : [];
+	return jsxToTemplate(tag, props, children, key);
+}
+
+/**
+ * Tier 2 automatic runtime: multiple static children.  props.children is the children array.
+ * @param tag {string|Function|symbol}
+ * @param props {Object}
+ * @param key {*}
+ * @return {Template} */
+export function jsxs(tag, props, key) {
+	props = props || {};
+	let children = props.children;
+	children = Array.isArray(children) ? children : (children === undefined ? [] : [children]);
+	return jsxToTemplate(tag, props, children, key);
+}
+
+/** Dev variant (extra source/self args are ignored). */
+export function jsxDEV(tag, props, key) {
+	return jsx(tag, props, key);
+}