@bitstillery/mithril 3.0.0-AA

package/htm.ts

@@ -0,0 +1,7 @@
+import htm from 'htm'
+import m from './index.ts'
+
+const html = htm.bind(m)
+
+export {html}
+export {m}

package/hyperscript.ts

@@ -0,0 +1,8 @@
+import hyperscript from './render/hyperscript'
+import trust from './render/trust'
+import fragment from './render/fragment'
+
+hyperscript.trust = trust
+hyperscript.fragment = fragment
+
+export default hyperscript

package/index.ts

@@ -0,0 +1,134 @@
+import hyperscript from './render/hyperscript'
+import mountRedrawFactory from './api/mount-redraw'
+import routerFactory from './api/router'
+import renderFactory from './render/render'
+import parseQueryString from './querystring/parse'
+import buildQueryString from './querystring/build'
+import parsePathname from './pathname/parse'
+import buildPathname from './pathname/build'
+import VnodeFactory, {MithrilComponent} from './render/vnode'
+import censor from './util/censor'
+import next_tick from './util/next_tick'
+import domFor from './render/domFor'
+import {signal, computed, effect, Signal, ComputedSignal, setSignalRedrawCallback, getSignalComponents} from './signal'
+import {state, watch, registerState, getRegisteredStates, copyGlobalStatesToContext} from './state'
+
+import type {Vnode, Children, ComponentType} from './render/vnode'
+import type {Hyperscript} from './render/hyperscript'
+import type {Route, RouteResolver, RedirectObject} from './api/router'
+import type {Render, Redraw, Mount} from './api/mount-redraw'
+
+export interface MithrilStatic {
+    m: Hyperscript
+    trust: (html: string) => Vnode
+    fragment: (attrs: Record<string, any> | null, ...children: Children[]) => Vnode
+    Fragment: string
+    mount: Mount
+    route: Route &
+        ((root: Element, defaultRoute: string, routes: Record<string, ComponentType | RouteResolver>) => void) & {
+            redirect: (path: string) => RedirectObject
+        }
+    render: Render
+    redraw: Redraw
+    parseQueryString: (queryString: string) => Record<string, any>
+    buildQueryString: (values: Record<string, any>) => string
+    parsePathname: (pathname: string) => {path: string; params: Record<string, any>}
+    buildPathname: (template: string, params: Record<string, any>) => string
+    vnode: typeof VnodeFactory
+    censor: (attrs: Record<string, any>, extras?: string[]) => Record<string, any>
+    next_tick: () => Promise<void>
+    domFor: (vnode: Vnode) => Generator<Node, void, unknown>
+}
+
+const mountRedrawInstance = mountRedrawFactory(
+    renderFactory(),
+    typeof requestAnimationFrame !== 'undefined' ? requestAnimationFrame.bind(window) : setTimeout,
+    console,
+)
+
+const router = routerFactory(typeof window !== 'undefined' ? window : null, mountRedrawInstance)
+
+const m: MithrilStatic & Hyperscript = function m(this: any) {
+    return hyperscript.apply(this, arguments as any)
+} as unknown as MithrilStatic & Hyperscript
+
+m.m = hyperscript as Hyperscript
+m.trust = hyperscript.trust
+m.fragment = hyperscript.fragment
+m.Fragment = '['
+m.mount = mountRedrawInstance.mount
+m.route = router as Route & typeof router & {redirect: (path: string) => RedirectObject}
+m.render = renderFactory()
+m.redraw = mountRedrawInstance.redraw
+m.parseQueryString = parseQueryString
+m.buildQueryString = buildQueryString
+m.parsePathname = parsePathname
+m.buildPathname = buildPathname
+m.vnode = VnodeFactory
+m.censor = censor
+m.next_tick = next_tick
+m.domFor = domFor
+
+// Set up signal-to-component redraw integration
+setSignalRedrawCallback((sig: Signal<any>) => {
+    const components = getSignalComponents(sig)
+    if (components) {
+        components.forEach((component) => {
+            // Use the component-level redraw
+            m.redraw(component as any)
+        })
+    }
+})
+
+// Export signals API
+export {signal, computed, effect, Signal, ComputedSignal, state, watch, registerState, getRegisteredStates}
+export type {State, StateOptions} from './state'
+
+// Export Store class
+export {Store} from './store'
+
+// Export SSR utilities
+export {serializeStore, deserializeStore, serializeAllStates, deserializeAllStates} from './render/ssrState'
+
+// Export SSR request context (for per-request store and state registry)
+export {getSSRContext, runWithContext, runWithContextAsync, cleanupWatchers} from './ssrContext'
+export type {SSRAccessContext} from './ssrContext'
+
+// Export isomorphic logger
+export {logger, Logger} from './server/logger'
+export type {LogContext} from './server/logger'
+
+// Export next_tick utility
+export {next_tick} from './util/next_tick'
+
+// Export URI utilities
+export {getCurrentUrl, getPathname, getSearch, getHash, getLocation} from './util/uri'
+export type {IsomorphicLocation} from './util/uri'
+
+// Export component and vnode types
+export type {
+    Vnode,
+    ComponentVnode,
+    Children,
+    Child,
+    VnodeDOM,
+    Component,
+    ComponentFactory,
+    ComponentType,
+    VnodeOf,
+} from './render/vnode'
+export {MithrilComponent}
+export type {Hyperscript} from './render/hyperscript'
+export type {Route, RouteResolver, RedirectObject} from './api/router'
+export type {Render, Redraw, Mount} from './api/mount-redraw'
+
+// Namespace merge: enables m.Vnode<Attrs> and m.Children when using import m from '@bitstillery/mithril'
+// m.Vnode uses ComponentVnode so vnode.attrs is always defined in component lifecycle methods
+declare namespace m {
+    type Vnode<Attrs = Record<string, any>, State = any> = import('./render/vnode').ComponentVnode<Attrs, State>
+    type VnodeDOM<Attrs = Record<string, any>, State = any> = import('./render/vnode').VnodeDOM<Attrs, State>
+    type Children = import('./render/vnode').Children
+    type ChildArray = import('./render/vnode').Child[]
+}
+
+export default m

package/jsx.d.ts

@@ -0,0 +1,16 @@
+import type {Vnode} from './render/vnode'
+
+declare global {
+    namespace JSX {
+        /** JSX elements from hyperscript always have attrs set (at least {}). */
+        interface Element extends Omit<Vnode, 'attrs'> {
+            attrs: Record<string, any>
+        }
+        interface IntrinsicElements {
+            [elemName: string]: any
+        }
+        interface ElementAttributesProperty {
+            __tsx_attrs: any
+        }
+    }
+}

package/mount.ts

@@ -0,0 +1,10 @@
+import mountRedrawFactory from './api/mount-redraw'
+import renderFactory from './render/render'
+
+const mountRedraw = mountRedrawFactory(
+    renderFactory(),
+    typeof requestAnimationFrame !== 'undefined' ? requestAnimationFrame.bind(window) : setTimeout,
+    console,
+)
+
+export default mountRedraw.mount

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@bitstillery/mithril",
+    "version": "3.0.0-AA",
+    "description": "Mithril AA (AI Augmented) - Mithril + Signals, Store and SSR",
+    "license": "MIT",
+    "author": "Bitstillery",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/bitstillery/mithril.git"
+    },
+    "files": [
+        "*.ts",
+        "*.d.ts",
+        "ssrContext.ts",
+        "signal.ts",
+        "store.ts",
+        "api/*.ts",
+        "pathname/*.ts",
+        "querystring/*.ts",
+        "render/*.ts",
+        "server/*.ts",
+        "util/*.ts",
+        "LICENSE",
+        "README.md"
+    ],
+    "type": "module",
+    "main": "./index.ts",
+    "module": "./index.ts",
+    "exports": {
+        ".": {
+            "import": "./index.ts",
+            "default": "./index.ts"
+        },
+        "./browser": {
+            "import": "./browser.ts",
+            "default": "./browser.ts"
+        },
+        "./server": {
+            "import": "./server.ts",
+            "default": "./server.ts"
+        },
+        "./htm": {
+            "import": "./htm.ts",
+            "default": "./htm.ts"
+        }
+    },
+    "scripts": {
+        "lint": "bun run lint:ts",
+        "lint:ts": "bun run lint:ts-format && bun run lint:ts-syntax && bun run lint:ts-types",
+        "lint:ts-format": "oxfmt",
+        "lint:ts-syntax": "oxlint -c .oxlintrc.json",
+        "lint:ts-types": "tsgo --noEmit",
+        "test": "bun test",
+        "prepublishOnly": "bun run lint:ts",
+        "pack:dry-run": "npm pack --dry-run"
+    },
+    "dependencies": {
+        "htm": "^3.1.1"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.9",
+        "@typescript/native-preview": "^7.0.0-dev.20260120.1",
+        "oxfmt": "^0.32.0",
+        "oxlint": "^1.30.0"
+    }
+}

package/pathname/build.ts

@@ -0,0 +1,40 @@
+import buildQueryString from '../querystring/build'
+
+// Returns `path` from `template` + `params`
+export default function buildPathname(template: string, params: Record<string, any>): string {
+    if (/:([^/.-]+)(\.{3})?:/.test(template)) {
+        throw new SyntaxError("Template parameter names must be separated by either a '/', '-', or '.'.")
+    }
+    if (params == null) return template
+    const queryIndex = template.indexOf('?')
+    const hashIndex = template.indexOf('#')
+    const queryEnd = hashIndex < 0 ? template.length : hashIndex
+    const pathEnd = queryIndex < 0 ? queryEnd : queryIndex
+    const path = template.slice(0, pathEnd)
+    const query: Record<string, any> = {}
+
+    Object.assign(query, params)
+
+    const resolved = path.replace(/:([^/.-]+)(\.{3})?/g, function (m, key, variadic) {
+        delete query[key]
+        // If no such parameter exists, don't interpolate it.
+        if (params[key] == null) return m
+        // Escape normal parameters, but not variadic ones.
+        return variadic ? params[key] : encodeURIComponent(String(params[key]))
+    })
+
+    // In case the template substitution adds new query/hash parameters.
+    const newQueryIndex = resolved.indexOf('?')
+    const newHashIndex = resolved.indexOf('#')
+    const newQueryEnd = newHashIndex < 0 ? resolved.length : newHashIndex
+    const newPathEnd = newQueryIndex < 0 ? newQueryEnd : newQueryIndex
+    let result = resolved.slice(0, newPathEnd)
+
+    if (queryIndex >= 0) result += template.slice(queryIndex, queryEnd)
+    if (newQueryIndex >= 0) result += (queryIndex < 0 ? '?' : '&') + resolved.slice(newQueryIndex, newQueryEnd)
+    const querystring = buildQueryString(query)
+    if (querystring) result += (queryIndex < 0 && newQueryIndex < 0 ? '?' : '&') + querystring
+    if (hashIndex >= 0) result += template.slice(hashIndex)
+    if (newHashIndex >= 0) result += (hashIndex < 0 ? '' : '&') + resolved.slice(newHashIndex)
+    return result
+}

package/pathname/compileTemplate.ts

@@ -0,0 +1,49 @@
+import parsePathname from './parse'
+
+interface CompiledTemplate {
+    (data: {path: string; params: Record<string, any>}): boolean
+}
+
+// Compiles a template into a function that takes a resolved path (without query
+// strings) and returns an object containing the template parameters with their
+// parsed values. This expects the input of the compiled template to be the
+// output of `parsePathname`. Note that it does *not* remove query parameters
+// specified in the template.
+export default function compileTemplate(template: string): CompiledTemplate {
+    const templateData = parsePathname(template)
+    const templateKeys = Object.keys(templateData.params)
+    const keys: Array<{k: string; r: boolean}> = []
+    const regexp = new RegExp(
+        '^' +
+            templateData.path.replace(
+                // I escape literal text so people can use things like `:file.:ext` or
+                // `:lang-:locale` in routes. This is all merged into one pass so I
+                // don't also accidentally escape `-` and make it harder to detect it to
+                // ban it from template parameters.
+                /:([^/.-]+)(\.{3}|\.(?!\.)|-)?|[\\^$*+.()|[\]{}]/g,
+                function (m, key, extra) {
+                    if (key == null) return '\\' + m
+                    keys.push({k: key, r: extra === '...'})
+                    if (extra === '...') return '(.*)'
+                    if (extra === '.') return '([^/]+)\\.'
+                    return '([^/]+)' + (extra || '')
+                },
+            ) +
+            '\\/?$',
+    )
+    return function (data: {path: string; params: Record<string, any>}): boolean {
+        // First, check the params. Usually, there isn't any, and it's just
+        // checking a static set.
+        for (let i = 0; i < templateKeys.length; i++) {
+            if (templateData.params[templateKeys[i]] !== data.params[templateKeys[i]]) return false
+        }
+        // If no interpolations exist, let's skip all the ceremony
+        if (!keys.length) return regexp.test(data.path)
+        const values = regexp.exec(data.path)
+        if (values == null) return false
+        for (let i = 0; i < keys.length; i++) {
+            data.params[keys[i].k] = keys[i].r ? values[i + 1] : decodeURIComponent(values[i + 1])
+        }
+        return true
+    }
+}

package/pathname/parse.ts

@@ -0,0 +1,19 @@
+import parseQueryString from '../querystring/parse'
+
+// Returns `{path, params}` from `url`
+export default function parsePathname(url: string): {path: string; params: Record<string, any>} {
+    const queryIndex = url.indexOf('?')
+    const hashIndex = url.indexOf('#')
+    const queryEnd = hashIndex < 0 ? url.length : hashIndex
+    const pathEnd = queryIndex < 0 ? queryEnd : queryIndex
+    let path = url.slice(0, pathEnd).replace(/\/{2,}/g, '/')
+
+    if (!path) path = '/'
+    else {
+        if (path[0] !== '/') path = '/' + path
+    }
+    return {
+        path: path,
+        params: queryIndex < 0 ? {} : parseQueryString(url.slice(queryIndex + 1, queryEnd)),
+    }
+}

package/querystring/build.ts

@@ -0,0 +1,22 @@
+export default function buildQueryString(object: Record<string, any>): string {
+    if (Object.prototype.toString.call(object) !== '[object Object]') return ''
+
+    const args: string[] = []
+    function destructure(key: string, value: any) {
+        if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                destructure(key + '[' + i + ']', value[i])
+            }
+        } else if (Object.prototype.toString.call(value) === '[object Object]') {
+            for (const i in value) {
+                destructure(key + '[' + i + ']', value[i])
+            }
+        } else args.push(encodeURIComponent(key) + (value != null && value !== '' ? '=' + encodeURIComponent(value) : ''))
+    }
+
+    for (const key in object) {
+        destructure(key, object[key])
+    }
+
+    return args.join('&')
+}

package/querystring/parse.ts

@@ -0,0 +1,50 @@
+import decodeURIComponentSafe from '../util/decodeURIComponentSafe'
+
+export default function parseQueryString(string: string | null | undefined): Record<string, any> {
+    if (string === '' || string == null) return {}
+    if (string.charAt(0) === '?') string = string.slice(1)
+
+    const entries = string.split('&')
+    const counters: Record<string, number> = {}
+    const data: Record<string, any> = {}
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i].split('=')
+        const key = decodeURIComponentSafe(entry[0])
+        let value: any = entry.length === 2 ? decodeURIComponentSafe(entry[1]) : ''
+
+        if (value === 'true') value = true
+        else if (value === 'false') value = false
+
+        const levels = key.split(/\]\[?|\[/)
+        let cursor: any = data
+        if (key.indexOf('[') > -1) levels.pop()
+        for (let j = 0; j < levels.length; j++) {
+            const level = levels[j]
+            const nextLevel = levels[j + 1]
+            const isNumber = nextLevel == '' || !isNaN(parseInt(nextLevel, 10))
+            let finalLevel: string | number
+            if (level === '') {
+                const key = levels.slice(0, j).join()
+                if (counters[key] == null) {
+                    counters[key] = Array.isArray(cursor) ? cursor.length : 0
+                }
+                finalLevel = counters[key]++
+            }
+            // Disallow direct prototype pollution
+            else if (level === '__proto__') break
+            else {
+                finalLevel = level
+            }
+            if (j === levels.length - 1) cursor[finalLevel] = value
+            else {
+                // Read own properties exclusively to disallow indirect
+                // prototype pollution
+                const desc = Object.getOwnPropertyDescriptor(cursor, finalLevel)
+                let descValue = desc != null ? desc.value : undefined
+                if (descValue == null) cursor[finalLevel] = descValue = isNumber ? [] : {}
+                cursor = descValue
+            }
+        }
+    }
+    return data
+}

package/redraw.ts

@@ -0,0 +1,10 @@
+import mountRedrawFactory from './api/mount-redraw'
+import renderFactory from './render/render'
+
+const mountRedraw = mountRedrawFactory(
+    renderFactory(),
+    typeof requestAnimationFrame !== 'undefined' ? requestAnimationFrame.bind(window) : setTimeout,
+    console,
+)
+
+export default mountRedraw.redraw

package/render/cachedAttrsIsStaticMap.ts

@@ -0,0 +1,10 @@
+import emptyAttrs from './emptyAttrs'
+
+// This Map manages the following:
+// - Whether an attrs is cached attrs generated by compileSelector().
+// - Whether the cached attrs is "static", i.e., does not contain any form attributes.
+// These information will be useful to skip updating attrs in render().
+//
+// Since the attrs used as keys in this map are not released from the selectorCache object,
+// there is no risk of memory leaks. Therefore, Map is used here instead of WeakMap.
+export default new Map([[emptyAttrs, true]])

package/render/delayedRemoval.ts

@@ -0,0 +1 @@
+export default new WeakMap<Node, number>()

package/render/domFor.ts

@@ -0,0 +1,23 @@
+import delayedRemoval from './delayedRemoval'
+
+import type {Vnode} from './vnode'
+
+function* domFor(vnode: Vnode): Generator<Node, void, unknown> {
+    // To avoid unintended mangling of the internal bundler,
+    // parameter destructuring is not used here.
+    let dom = vnode.dom
+    let domSize = vnode.domSize
+    const generation = delayedRemoval.get(dom!)
+    do {
+        const nextSibling = dom!.nextSibling
+
+        if (delayedRemoval.get(dom!) === generation) {
+            yield dom!
+            domSize!--
+        }
+
+        dom = nextSibling as Node | null
+    } while (domSize)
+}
+
+export default domFor

package/render/emptyAttrs.ts

@@ -0,0 +1,2 @@
+// This is an attrs object that is used by default when attrs is undefined or null.
+export default {}

package/render/fragment.ts

@@ -0,0 +1,11 @@
+import Vnode from './vnode'
+import hyperscriptVnode from './hyperscriptVnode'
+
+export default function fragment(attrs: any, ...children: any[]): any {
+    const vnode = hyperscriptVnode(attrs, children)
+
+    if (vnode.attrs == null) vnode.attrs = {}
+    vnode.tag = '['
+    vnode.children = Vnode.normalizeChildren(vnode.children)
+    return vnode
+}

package/render/hyperscript.ts

@@ -0,0 +1,125 @@
+import hasOwn from '../util/hasOwn'
+
+import Vnode from './vnode'
+import hyperscriptVnode from './hyperscriptVnode'
+import emptyAttrs from './emptyAttrs'
+import cachedAttrsIsStaticMap from './cachedAttrsIsStaticMap'
+import trust from './trust'
+import fragment from './fragment'
+
+import type {ComponentType, Children, Vnode as VnodeType} from './vnode'
+
+export interface Hyperscript {
+    (selector: string, ...children: Children[]): VnodeType
+    (selector: string, attrs: Record<string, any>, ...children: Children[]): VnodeType
+    <Attrs, State>(component: ComponentType<Attrs, State>, ...children: Children[]): VnodeType<Attrs, State>
+    <Attrs, State>(component: ComponentType<Attrs, State>, attrs: Attrs, ...children: Children[]): VnodeType<Attrs, State>
+    trust(html: string): VnodeType
+    fragment(attrs: Record<string, any> | null, ...children: Children[]): VnodeType
+    Fragment: string
+}
+
+const selectorParser = /(?:(^|#|\.)([^#.[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g
+const selectorCache: Record<string, {tag: string; attrs: Record<string, any>; is?: string}> = Object.create(null)
+
+function isEmpty(object: Record<string, any>): boolean {
+    for (const key in object) if (hasOwn.call(object, key)) return false
+    return true
+}
+
+function isFormAttributeKey(key: string): boolean {
+    return key === 'value' || key === 'checked' || key === 'selectedIndex' || key === 'selected'
+}
+
+function compileSelector(selector: string): {tag: string; attrs: Record<string, any>; is?: string} {
+    let match: RegExpExecArray | null
+    let tag = 'div'
+    const classes: string[] = []
+    let attrs: Record<string, any> = {}
+    let isStatic = true
+    while ((match = selectorParser.exec(selector)) !== null) {
+        const type = match[1]
+        const value = match[2]
+        if (type === '' && value !== '') tag = value
+        else if (type === '#') attrs.id = value
+        else if (type === '.') classes.push(value)
+        else if (match[3][0] === '[') {
+            let attrValue = match[6]
+            if (attrValue) attrValue = attrValue.replace(/\\(["'])/g, '$1').replace(/\\\\/g, '\\')
+            if (match[4] === 'class') classes.push(attrValue)
+            else {
+                attrs[match[4]] = attrValue === '' ? attrValue : attrValue || true
+                if (isFormAttributeKey(match[4])) isStatic = false
+            }
+        }
+    }
+    if (classes.length > 0) attrs.className = classes.join(' ')
+    if (isEmpty(attrs)) attrs = emptyAttrs
+    else cachedAttrsIsStaticMap.set(attrs, isStatic)
+    return (selectorCache[selector] = {tag: tag, attrs: attrs, is: attrs.is})
+}
+
+function execSelector(state: {tag: string; attrs: Record<string, any>; is?: string}, vnode: any): any {
+    vnode.tag = state.tag
+
+    let attrs = vnode.attrs
+    if (attrs == null) {
+        vnode.attrs = state.attrs
+        vnode.is = state.is
+        return vnode
+    }
+
+    if (hasOwn.call(attrs, 'class')) {
+        if (attrs.class != null) attrs.className = attrs.class
+        attrs.class = null
+    }
+
+    if (state.attrs !== emptyAttrs) {
+        const className = attrs.className
+        attrs = Object.assign({}, state.attrs, attrs)
+
+        if (state.attrs.className != null)
+            attrs.className = className != null ? String(state.attrs.className) + ' ' + String(className) : state.attrs.className
+    }
+
+    // workaround for #2622 (reorder keys in attrs to set "type" first)
+    // The DOM does things to inputs based on the "type", so it needs set first.
+    // See: https://github.com/MithrilJS/mithril.js/issues/2622
+    if (state.tag === 'input' && hasOwn.call(attrs, 'type')) {
+        attrs = Object.assign({type: attrs.type}, attrs)
+    }
+
+    // This reduces the complexity of the evaluation of "is" within the render function.
+    vnode.is = attrs.is
+
+    vnode.attrs = attrs
+
+    return vnode
+}
+
+function hyperscript(selector: string | ComponentType, attrs?: Record<string, any> | null, ...children: Children[]): any {
+    if (
+        selector == null ||
+        (typeof selector !== 'string' && typeof selector !== 'function' && typeof (selector as any).view !== 'function')
+    ) {
+        throw Error('The selector must be either a string or a component.')
+    }
+
+    const vnode = hyperscriptVnode(attrs, children)
+
+    if (typeof selector === 'string') {
+        vnode.children = Vnode.normalizeChildren(vnode.children)
+        if (selector !== '[') return execSelector(selectorCache[selector] || compileSelector(selector), vnode)
+    }
+
+    if (vnode.attrs == null) vnode.attrs = {}
+    vnode.tag = selector
+    return vnode
+}
+
+hyperscript.trust = trust
+
+hyperscript.fragment = fragment
+hyperscript.Fragment = '['
+
+export default hyperscript

package/render/hyperscriptVnode.ts

@@ -0,0 +1,21 @@
+import Vnode from './vnode'
+
+// Note: the processing of variadic parameters is perf-sensitive.
+//
+// In native ES6, it might be preferable to define hyperscript and fragment
+// factories with a final ...args parameter and call hyperscriptVnode(...args),
+// since modern engines can optimize spread calls.
+//
+// However, benchmarks showed this was not faster. As a result, spread is used
+// only in the parameter lists of hyperscript and fragment, while an array is
+// passed to hyperscriptVnode.
+export default function hyperscriptVnode(attrs: any, children: any[]): any {
+    if (attrs == null || (typeof attrs === 'object' && attrs.tag == null && !Array.isArray(attrs))) {
+        if (children.length === 1 && Array.isArray(children[0])) children = children[0]
+    } else {
+        children = children.length === 0 && Array.isArray(attrs) ? attrs : [attrs, ...children]
+        attrs = undefined
+    }
+
+    return Vnode('', attrs && attrs.key, attrs, children, null, null)
+}