jaxs 0.2.0

package/cypress/jaxs-apps/dist/add-remove-root-children.3bb9b3f5.js

@@ -0,0 +1,1682 @@
+// modules are defined as an array
+// [ module function, map of requires ]
+//
+// map of requires is short require name -> numeric require
+//
+// anything defined in a previous bundle is accessed via the
+// orig method which is the require for previous bundles
+
+(function (modules, entry, mainEntry, parcelRequireName, globalName) {
+  /* eslint-disable no-undef */
+  var globalObject =
+    typeof globalThis !== 'undefined'
+      ? globalThis
+      : typeof self !== 'undefined'
+      ? self
+      : typeof window !== 'undefined'
+      ? window
+      : typeof global !== 'undefined'
+      ? global
+      : {};
+  /* eslint-enable no-undef */
+
+  // Save the require from previous bundle to this closure if any
+  var previousRequire =
+    typeof globalObject[parcelRequireName] === 'function' &&
+    globalObject[parcelRequireName];
+
+  var cache = previousRequire.cache || {};
+  // Do not use `require` to prevent Webpack from trying to bundle this call
+  var nodeRequire =
+    typeof module !== 'undefined' &&
+    typeof module.require === 'function' &&
+    module.require.bind(module);
+
+  function newRequire(name, jumped) {
+    if (!cache[name]) {
+      if (!modules[name]) {
+        // if we cannot find the module within our internal map or
+        // cache jump to the current global require ie. the last bundle
+        // that was added to the page.
+        var currentRequire =
+          typeof globalObject[parcelRequireName] === 'function' &&
+          globalObject[parcelRequireName];
+        if (!jumped && currentRequire) {
+          return currentRequire(name, true);
+        }
+
+        // If there are other bundles on this page the require from the
+        // previous one is saved to 'previousRequire'. Repeat this as
+        // many times as there are bundles until the module is found or
+        // we exhaust the require chain.
+        if (previousRequire) {
+          return previousRequire(name, true);
+        }
+
+        // Try the node require function if it exists.
+        if (nodeRequire && typeof name === 'string') {
+          return nodeRequire(name);
+        }
+
+        var err = new Error("Cannot find module '" + name + "'");
+        err.code = 'MODULE_NOT_FOUND';
+        throw err;
+      }
+
+      localRequire.resolve = resolve;
+      localRequire.cache = {};
+
+      var module = (cache[name] = new newRequire.Module(name));
+
+      modules[name][0].call(
+        module.exports,
+        localRequire,
+        module,
+        module.exports,
+        this
+      );
+    }
+
+    return cache[name].exports;
+
+    function localRequire(x) {
+      var res = localRequire.resolve(x);
+      return res === false ? {} : newRequire(res);
+    }
+
+    function resolve(x) {
+      var id = modules[name][1][x];
+      return id != null ? id : x;
+    }
+  }
+
+  function Module(moduleName) {
+    this.id = moduleName;
+    this.bundle = newRequire;
+    this.exports = {};
+  }
+
+  newRequire.isParcelRequire = true;
+  newRequire.Module = Module;
+  newRequire.modules = modules;
+  newRequire.cache = cache;
+  newRequire.parent = previousRequire;
+  newRequire.register = function (id, exports) {
+    modules[id] = [
+      function (require, module) {
+        module.exports = exports;
+      },
+      {},
+    ];
+  };
+
+  Object.defineProperty(newRequire, 'root', {
+    get: function () {
+      return globalObject[parcelRequireName];
+    },
+  });
+
+  globalObject[parcelRequireName] = newRequire;
+
+  for (var i = 0; i < entry.length; i++) {
+    newRequire(entry[i]);
+  }
+
+  if (mainEntry) {
+    // Expose entry point to Node, AMD or browser globals
+    // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
+    var mainExports = newRequire(mainEntry);
+
+    // CommonJS
+    if (typeof exports === 'object' && typeof module !== 'undefined') {
+      module.exports = mainExports;
+
+      // RequireJS
+    } else if (typeof define === 'function' && define.amd) {
+      define(function () {
+        return mainExports;
+      });
+
+      // <script>
+    } else if (globalName) {
+      this[globalName] = mainExports;
+    }
+  }
+})({"gAaC1":[function(require,module,exports) {
+var global = arguments[3];
+var HMR_HOST = null;
+var HMR_PORT = null;
+var HMR_SECURE = false;
+var HMR_ENV_HASH = "d6ea1d42532a7575";
+module.bundle.HMR_BUNDLE_ID = "64a677193bb9b3f5";
+"use strict";
+/* global HMR_HOST, HMR_PORT, HMR_ENV_HASH, HMR_SECURE, chrome, browser, __parcel__import__, __parcel__importScripts__, ServiceWorkerGlobalScope */ /*::
+import type {
+  HMRAsset,
+  HMRMessage,
+} from '@parcel/reporter-dev-server/src/HMRServer.js';
+interface ParcelRequire {
+  (string): mixed;
+  cache: {|[string]: ParcelModule|};
+  hotData: {|[string]: mixed|};
+  Module: any;
+  parent: ?ParcelRequire;
+  isParcelRequire: true;
+  modules: {|[string]: [Function, {|[string]: string|}]|};
+  HMR_BUNDLE_ID: string;
+  root: ParcelRequire;
+}
+interface ParcelModule {
+  hot: {|
+    data: mixed,
+    accept(cb: (Function) => void): void,
+    dispose(cb: (mixed) => void): void,
+    // accept(deps: Array<string> | string, cb: (Function) => void): void,
+    // decline(): void,
+    _acceptCallbacks: Array<(Function) => void>,
+    _disposeCallbacks: Array<(mixed) => void>,
+  |};
+}
+interface ExtensionContext {
+  runtime: {|
+    reload(): void,
+    getURL(url: string): string;
+    getManifest(): {manifest_version: number, ...};
+  |};
+}
+declare var module: {bundle: ParcelRequire, ...};
+declare var HMR_HOST: string;
+declare var HMR_PORT: string;
+declare var HMR_ENV_HASH: string;
+declare var HMR_SECURE: boolean;
+declare var chrome: ExtensionContext;
+declare var browser: ExtensionContext;
+declare var __parcel__import__: (string) => Promise<void>;
+declare var __parcel__importScripts__: (string) => Promise<void>;
+declare var globalThis: typeof self;
+declare var ServiceWorkerGlobalScope: Object;
+*/ var OVERLAY_ID = "__parcel__error__overlay__";
+var OldModule = module.bundle.Module;
+function Module(moduleName) {
+    OldModule.call(this, moduleName);
+    this.hot = {
+        data: module.bundle.hotData[moduleName],
+        _acceptCallbacks: [],
+        _disposeCallbacks: [],
+        accept: function(fn) {
+            this._acceptCallbacks.push(fn || function() {});
+        },
+        dispose: function(fn) {
+            this._disposeCallbacks.push(fn);
+        }
+    };
+    module.bundle.hotData[moduleName] = undefined;
+}
+module.bundle.Module = Module;
+module.bundle.hotData = {};
+var checkedAssets /*: {|[string]: boolean|} */ , assetsToDispose /*: Array<[ParcelRequire, string]> */ , assetsToAccept /*: Array<[ParcelRequire, string]> */ ;
+function getHostname() {
+    return HMR_HOST || (location.protocol.indexOf("http") === 0 ? location.hostname : "localhost");
+}
+function getPort() {
+    return HMR_PORT || location.port;
+}
+// eslint-disable-next-line no-redeclare
+var parent = module.bundle.parent;
+if ((!parent || !parent.isParcelRequire) && typeof WebSocket !== "undefined") {
+    var hostname = getHostname();
+    var port = getPort();
+    var protocol = HMR_SECURE || location.protocol == "https:" && ![
+        "localhost",
+        "127.0.0.1",
+        "0.0.0.0"
+    ].includes(hostname) ? "wss" : "ws";
+    var ws;
+    try {
+        ws = new WebSocket(protocol + "://" + hostname + (port ? ":" + port : "") + "/");
+    } catch (err) {
+        if (err.message) console.error(err.message);
+        ws = {};
+    }
+    // Web extension context
+    var extCtx = typeof browser === "undefined" ? typeof chrome === "undefined" ? null : chrome : browser;
+    // Safari doesn't support sourceURL in error stacks.
+    // eval may also be disabled via CSP, so do a quick check.
+    var supportsSourceURL = false;
+    try {
+        (0, eval)('throw new Error("test"); //# sourceURL=test.js');
+    } catch (err) {
+        supportsSourceURL = err.stack.includes("test.js");
+    }
+    // $FlowFixMe
+    ws.onmessage = async function(event /*: {data: string, ...} */ ) {
+        checkedAssets = {} /*: {|[string]: boolean|} */ ;
+        assetsToAccept = [];
+        assetsToDispose = [];
+        var data /*: HMRMessage */  = JSON.parse(event.data);
+        if (data.type === "update") {
+            // Remove error overlay if there is one
+            if (typeof document !== "undefined") removeErrorOverlay();
+            let assets = data.assets.filter((asset)=>asset.envHash === HMR_ENV_HASH);
+            // Handle HMR Update
+            let handled = assets.every((asset)=>{
+                return asset.type === "css" || asset.type === "js" && hmrAcceptCheck(module.bundle.root, asset.id, asset.depsByBundle);
+            });
+            if (handled) {
+                console.clear();
+                // Dispatch custom event so other runtimes (e.g React Refresh) are aware.
+                if (typeof window !== "undefined" && typeof CustomEvent !== "undefined") window.dispatchEvent(new CustomEvent("parcelhmraccept"));
+                await hmrApplyUpdates(assets);
+                // Dispose all old assets.
+                let processedAssets = {} /*: {|[string]: boolean|} */ ;
+                for(let i = 0; i < assetsToDispose.length; i++){
+                    let id = assetsToDispose[i][1];
+                    if (!processedAssets[id]) {
+                        hmrDispose(assetsToDispose[i][0], id);
+                        processedAssets[id] = true;
+                    }
+                }
+                // Run accept callbacks. This will also re-execute other disposed assets in topological order.
+                processedAssets = {};
+                for(let i = 0; i < assetsToAccept.length; i++){
+                    let id = assetsToAccept[i][1];
+                    if (!processedAssets[id]) {
+                        hmrAccept(assetsToAccept[i][0], id);
+                        processedAssets[id] = true;
+                    }
+                }
+            } else fullReload();
+        }
+        if (data.type === "error") {
+            // Log parcel errors to console
+            for (let ansiDiagnostic of data.diagnostics.ansi){
+                let stack = ansiDiagnostic.codeframe ? ansiDiagnostic.codeframe : ansiDiagnostic.stack;
+                console.error("\uD83D\uDEA8 [parcel]: " + ansiDiagnostic.message + "\n" + stack + "\n\n" + ansiDiagnostic.hints.join("\n"));
+            }
+            if (typeof document !== "undefined") {
+                // Render the fancy html overlay
+                removeErrorOverlay();
+                var overlay = createErrorOverlay(data.diagnostics.html);
+                // $FlowFixMe
+                document.body.appendChild(overlay);
+            }
+        }
+    };
+    ws.onerror = function(e) {
+        if (e.message) console.error(e.message);
+    };
+    ws.onclose = function() {
+        console.warn("[parcel] \uD83D\uDEA8 Connection to the HMR server was lost");
+    };
+}
+function removeErrorOverlay() {
+    var overlay = document.getElementById(OVERLAY_ID);
+    if (overlay) {
+        overlay.remove();
+        console.log("[parcel] \u2728 Error resolved");
+    }
+}
+function createErrorOverlay(diagnostics) {
+    var overlay = document.createElement("div");
+    overlay.id = OVERLAY_ID;
+    let errorHTML = '<div style="background: black; opacity: 0.85; font-size: 16px; color: white; position: fixed; height: 100%; width: 100%; top: 0px; left: 0px; padding: 30px; font-family: Menlo, Consolas, monospace; z-index: 9999;">';
+    for (let diagnostic of diagnostics){
+        let stack = diagnostic.frames.length ? diagnostic.frames.reduce((p, frame)=>{
+            return `${p}
+<a href="/__parcel_launch_editor?file=${encodeURIComponent(frame.location)}" style="text-decoration: underline; color: #888" onclick="fetch(this.href); return false">${frame.location}</a>
+${frame.code}`;
+        }, "") : diagnostic.stack;
+        errorHTML += `
+      <div>
+        <div style="font-size: 18px; font-weight: bold; margin-top: 20px;">
+          \u{1F6A8} ${diagnostic.message}
+        </div>
+        <pre>${stack}</pre>
+        <div>
+          ${diagnostic.hints.map((hint)=>"<div>\uD83D\uDCA1 " + hint + "</div>").join("")}
+        </div>
+        ${diagnostic.documentation ? `<div>\u{1F4DD} <a style="color: violet" href="${diagnostic.documentation}" target="_blank">Learn more</a></div>` : ""}
+      </div>
+    `;
+    }
+    errorHTML += "</div>";
+    overlay.innerHTML = errorHTML;
+    return overlay;
+}
+function fullReload() {
+    if ("reload" in location) location.reload();
+    else if (extCtx && extCtx.runtime && extCtx.runtime.reload) extCtx.runtime.reload();
+}
+function getParents(bundle, id) /*: Array<[ParcelRequire, string]> */ {
+    var modules = bundle.modules;
+    if (!modules) return [];
+    var parents = [];
+    var k, d, dep;
+    for(k in modules)for(d in modules[k][1]){
+        dep = modules[k][1][d];
+        if (dep === id || Array.isArray(dep) && dep[dep.length - 1] === id) parents.push([
+            bundle,
+            k
+        ]);
+    }
+    if (bundle.parent) parents = parents.concat(getParents(bundle.parent, id));
+    return parents;
+}
+function updateLink(link) {
+    var href = link.getAttribute("href");
+    if (!href) return;
+    var newLink = link.cloneNode();
+    newLink.onload = function() {
+        if (link.parentNode !== null) // $FlowFixMe
+        link.parentNode.removeChild(link);
+    };
+    newLink.setAttribute("href", // $FlowFixMe
+    href.split("?")[0] + "?" + Date.now());
+    // $FlowFixMe
+    link.parentNode.insertBefore(newLink, link.nextSibling);
+}
+var cssTimeout = null;
+function reloadCSS() {
+    if (cssTimeout) return;
+    cssTimeout = setTimeout(function() {
+        var links = document.querySelectorAll('link[rel="stylesheet"]');
+        for(var i = 0; i < links.length; i++){
+            // $FlowFixMe[incompatible-type]
+            var href /*: string */  = links[i].getAttribute("href");
+            var hostname = getHostname();
+            var servedFromHMRServer = hostname === "localhost" ? new RegExp("^(https?:\\/\\/(0.0.0.0|127.0.0.1)|localhost):" + getPort()).test(href) : href.indexOf(hostname + ":" + getPort());
+            var absolute = /^https?:\/\//i.test(href) && href.indexOf(location.origin) !== 0 && !servedFromHMRServer;
+            if (!absolute) updateLink(links[i]);
+        }
+        cssTimeout = null;
+    }, 50);
+}
+function hmrDownload(asset) {
+    if (asset.type === "js") {
+        if (typeof document !== "undefined") {
+            let script = document.createElement("script");
+            script.src = asset.url + "?t=" + Date.now();
+            if (asset.outputFormat === "esmodule") script.type = "module";
+            return new Promise((resolve, reject)=>{
+                var _document$head;
+                script.onload = ()=>resolve(script);
+                script.onerror = reject;
+                (_document$head = document.head) === null || _document$head === void 0 || _document$head.appendChild(script);
+            });
+        } else if (typeof importScripts === "function") {
+            // Worker scripts
+            if (asset.outputFormat === "esmodule") return import(asset.url + "?t=" + Date.now());
+            else return new Promise((resolve, reject)=>{
+                try {
+                    importScripts(asset.url + "?t=" + Date.now());
+                    resolve();
+                } catch (err) {
+                    reject(err);
+                }
+            });
+        }
+    }
+}
+async function hmrApplyUpdates(assets) {
+    global.parcelHotUpdate = Object.create(null);
+    let scriptsToRemove;
+    try {
+        // If sourceURL comments aren't supported in eval, we need to load
+        // the update from the dev server over HTTP so that stack traces
+        // are correct in errors/logs. This is much slower than eval, so
+        // we only do it if needed (currently just Safari).
+        // https://bugs.webkit.org/show_bug.cgi?id=137297
+        // This path is also taken if a CSP disallows eval.
+        if (!supportsSourceURL) {
+            let promises = assets.map((asset)=>{
+                var _hmrDownload;
+                return (_hmrDownload = hmrDownload(asset)) === null || _hmrDownload === void 0 ? void 0 : _hmrDownload.catch((err)=>{
+                    // Web extension fix
+                    if (extCtx && extCtx.runtime && extCtx.runtime.getManifest().manifest_version == 3 && typeof ServiceWorkerGlobalScope != "undefined" && global instanceof ServiceWorkerGlobalScope) {
+                        extCtx.runtime.reload();
+                        return;
+                    }
+                    throw err;
+                });
+            });
+            scriptsToRemove = await Promise.all(promises);
+        }
+        assets.forEach(function(asset) {
+            hmrApply(module.bundle.root, asset);
+        });
+    } finally{
+        delete global.parcelHotUpdate;
+        if (scriptsToRemove) scriptsToRemove.forEach((script)=>{
+            if (script) {
+                var _document$head2;
+                (_document$head2 = document.head) === null || _document$head2 === void 0 || _document$head2.removeChild(script);
+            }
+        });
+    }
+}
+function hmrApply(bundle /*: ParcelRequire */ , asset /*:  HMRAsset */ ) {
+    var modules = bundle.modules;
+    if (!modules) return;
+    if (asset.type === "css") reloadCSS();
+    else if (asset.type === "js") {
+        let deps = asset.depsByBundle[bundle.HMR_BUNDLE_ID];
+        if (deps) {
+            if (modules[asset.id]) {
+                // Remove dependencies that are removed and will become orphaned.
+                // This is necessary so that if the asset is added back again, the cache is gone, and we prevent a full page reload.
+                let oldDeps = modules[asset.id][1];
+                for(let dep in oldDeps)if (!deps[dep] || deps[dep] !== oldDeps[dep]) {
+                    let id = oldDeps[dep];
+                    let parents = getParents(module.bundle.root, id);
+                    if (parents.length === 1) hmrDelete(module.bundle.root, id);
+                }
+            }
+            if (supportsSourceURL) // Global eval. We would use `new Function` here but browser
+            // support for source maps is better with eval.
+            (0, eval)(asset.output);
+            // $FlowFixMe
+            let fn = global.parcelHotUpdate[asset.id];
+            modules[asset.id] = [
+                fn,
+                deps
+            ];
+        } else if (bundle.parent) hmrApply(bundle.parent, asset);
+    }
+}
+function hmrDelete(bundle, id) {
+    let modules = bundle.modules;
+    if (!modules) return;
+    if (modules[id]) {
+        // Collect dependencies that will become orphaned when this module is deleted.
+        let deps = modules[id][1];
+        let orphans = [];
+        for(let dep in deps){
+            let parents = getParents(module.bundle.root, deps[dep]);
+            if (parents.length === 1) orphans.push(deps[dep]);
+        }
+        // Delete the module. This must be done before deleting dependencies in case of circular dependencies.
+        delete modules[id];
+        delete bundle.cache[id];
+        // Now delete the orphans.
+        orphans.forEach((id)=>{
+            hmrDelete(module.bundle.root, id);
+        });
+    } else if (bundle.parent) hmrDelete(bundle.parent, id);
+}
+function hmrAcceptCheck(bundle /*: ParcelRequire */ , id /*: string */ , depsByBundle /*: ?{ [string]: { [string]: string } }*/ ) {
+    if (hmrAcceptCheckOne(bundle, id, depsByBundle)) return true;
+    // Traverse parents breadth first. All possible ancestries must accept the HMR update, or we'll reload.
+    let parents = getParents(module.bundle.root, id);
+    let accepted = false;
+    while(parents.length > 0){
+        let v = parents.shift();
+        let a = hmrAcceptCheckOne(v[0], v[1], null);
+        if (a) // If this parent accepts, stop traversing upward, but still consider siblings.
+        accepted = true;
+        else {
+            // Otherwise, queue the parents in the next level upward.
+            let p = getParents(module.bundle.root, v[1]);
+            if (p.length === 0) {
+                // If there are no parents, then we've reached an entry without accepting. Reload.
+                accepted = false;
+                break;
+            }
+            parents.push(...p);
+        }
+    }
+    return accepted;
+}
+function hmrAcceptCheckOne(bundle /*: ParcelRequire */ , id /*: string */ , depsByBundle /*: ?{ [string]: { [string]: string } }*/ ) {
+    var modules = bundle.modules;
+    if (!modules) return;
+    if (depsByBundle && !depsByBundle[bundle.HMR_BUNDLE_ID]) {
+        // If we reached the root bundle without finding where the asset should go,
+        // there's nothing to do. Mark as "accepted" so we don't reload the page.
+        if (!bundle.parent) return true;
+        return hmrAcceptCheck(bundle.parent, id, depsByBundle);
+    }
+    if (checkedAssets[id]) return true;
+    checkedAssets[id] = true;
+    var cached = bundle.cache[id];
+    assetsToDispose.push([
+        bundle,
+        id
+    ]);
+    if (!cached || cached.hot && cached.hot._acceptCallbacks.length) {
+        assetsToAccept.push([
+            bundle,
+            id
+        ]);
+        return true;
+    }
+}
+function hmrDispose(bundle /*: ParcelRequire */ , id /*: string */ ) {
+    var cached = bundle.cache[id];
+    bundle.hotData[id] = {};
+    if (cached && cached.hot) cached.hot.data = bundle.hotData[id];
+    if (cached && cached.hot && cached.hot._disposeCallbacks.length) cached.hot._disposeCallbacks.forEach(function(cb) {
+        cb(bundle.hotData[id]);
+    });
+    delete bundle.cache[id];
+}
+function hmrAccept(bundle /*: ParcelRequire */ , id /*: string */ ) {
+    // Execute the module.
+    bundle(id);
+    // Run the accept callbacks in the new version of the module.
+    var cached = bundle.cache[id];
+    if (cached && cached.hot && cached.hot._acceptCallbacks.length) cached.hot._acceptCallbacks.forEach(function(cb) {
+        var assetsToAlsoAccept = cb(function() {
+            return getParents(module.bundle.root, id);
+        });
+        if (assetsToAlsoAccept && assetsToAccept.length) {
+            assetsToAlsoAccept.forEach(function(a) {
+                hmrDispose(a[0], a[1]);
+            });
+            // $FlowFixMe[method-unbinding]
+            assetsToAccept.push.apply(assetsToAccept, assetsToAlsoAccept);
+        }
+    });
+}
+
+},{}],"bAfYR":[function(require,module,exports) {
+var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
+parcelHelpers.defineInteropFlag(exports);
+parcelHelpers.export(exports, "views", ()=>views);
+parcelHelpers.export(exports, "render", ()=>render);
+parcelHelpers.export(exports, "navigation", ()=>exports_navigation);
+parcelHelpers.export(exports, "jsx", ()=>jsx_default);
+parcelHelpers.export(exports, "createBus", ()=>createBus);
+parcelHelpers.export(exports, "createApp", ()=>createApp);
+parcelHelpers.export(exports, "bind", ()=>bind);
+parcelHelpers.export(exports, "State", ()=>State);
+var __defProp = Object.defineProperty;
+var __export = (target, all)=>{
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true,
+        configurable: true,
+        set: (newValue)=>all[name] = ()=>newValue
+    });
+};
+// src/rendering/dom/create.ts
+var setAttributesOnElement = (element, attributes)=>{
+    for(const key in attributes){
+        if (key === "__self") continue;
+        if (key === "value") element.value = attributes[key];
+        else element.setAttribute(key, attributes[key]);
+    }
+};
+var setEventsOnElement = (element, events, publish)=>{
+    const eventMaps = {};
+    for(const domEvent in events){
+        const eventName = events[domEvent];
+        const listener = (event)=>publish(eventName, event);
+        element.addEventListener(domEvent, listener);
+        eventMaps[domEvent] = {
+            domEvent,
+            busEvent: eventName,
+            listener
+        };
+    }
+    element.eventMaps = eventMaps;
+};
+var createNode = (type, document)=>{
+    document = document || window.document;
+    return document.createElement(type);
+};
+var createTextNode = (value, document)=>{
+    document = document || window.document;
+    return document.createTextNode(value);
+};
+var createDecoratedNode = (type, attributes, events, renderKit)=>{
+    const dom = createNode(type, renderKit.document);
+    setAttributesOnElement(dom, attributes);
+    setEventsOnElement(dom, events, renderKit.publish);
+    return dom;
+};
+// src/rendering/dom/attributesAndEvents.ts
+var separateAttrsAndEvents = (combined, defaultValue = "")=>{
+    const attributes = {};
+    const events = {};
+    for(const key in combined){
+        const value = combined[key];
+        if (key.match(/^on.+/i)) {
+            const eventKey = key.slice(2).toLowerCase();
+            events[eventKey] = value;
+        } else attributes[key] = normalizeValueForKey(combined, key, defaultValue);
+    }
+    return {
+        attributes,
+        events
+    };
+};
+var normalizeValueForKey = (object, key, defaultValue = "")=>{
+    if (object[key] === undefined) return defaultValue;
+    return object[key];
+};
+// src/rendering/templates/text.ts
+class TextTemplate {
+    value;
+    constructor(content){
+        this.value = content.toString();
+    }
+    render(renderKit) {
+        const textNode = createTextNode(this.value, renderKit.document);
+        if (!textNode) return [];
+        textNode.__jsx = "TextNode";
+        return [
+            textNode
+        ];
+    }
+}
+// src/rendering/templates/children.ts
+var ensureArray = (children)=>{
+    if (Array.isArray(children)) return children.flat();
+    if (!children) return [];
+    return [
+        children
+    ];
+};
+var recursiveRender = (children, renderKit, rendered = [])=>children.reduce(renderReducer(renderKit), rendered).flat();
+var renderReducer = (renderKit)=>(aggregate, view)=>{
+        if (!view) return aggregate;
+        if (Array.isArray(view)) {
+            const dom = recursiveRender(view, renderKit, aggregate);
+            return dom;
+        }
+        view.render(renderKit).forEach((template)=>aggregate.push(template));
+        return aggregate;
+    };
+var replaceTextNodes = (child)=>{
+    if (isTextNode(child)) return textNode(child);
+    return child;
+};
+var isTextNode = (child)=>{
+    return typeof child === "string" || typeof child === "number";
+};
+var textNode = (content)=>{
+    return new TextTemplate(content);
+};
+class Children {
+    collection;
+    parentElement;
+    constructor(jsxChildren){
+        this.collection = ensureArray(jsxChildren);
+        this.collection = this.collection.map(replaceTextNodes);
+        this.collection = this.collection.flat();
+    }
+    render(renderKit, parentElement) {
+        this.parentElement = parentElement;
+        const dom = this.generateDom(renderKit);
+        this.attachToParent(dom);
+        return dom;
+    }
+    generateDom(renderKit) {
+        return recursiveRender(this.collection, renderKit);
+    }
+    attachToParent(dom) {
+        if (this.parentElement === undefined) return;
+        const parent = this.parentElement;
+        dom.forEach((node)=>parent.appendChild(node));
+    }
+}
+// src/rendering/templates/tag.ts
+class Tag {
+    type;
+    events;
+    attributes;
+    children;
+    constructor(tagType, combinedAttributes, children2){
+        this.type = tagType;
+        const { events, attributes } = separateAttrsAndEvents(combinedAttributes);
+        this.events = events;
+        this.attributes = attributes;
+        this.children = new Children(children2);
+    }
+    render(renderKit) {
+        const dom = this.generateDom(renderKit);
+        if (!dom) return [];
+        this.children.render(renderKit, dom);
+        return [
+            dom
+        ];
+    }
+    generateDom(renderKit) {
+        const node = createDecoratedNode(this.type, this.attributes, this.events, renderKit);
+        node.__jsx = this.key();
+        return node;
+    }
+    key() {
+        return this.attributes.key || this.source() || this.createKey();
+    }
+    source() {
+        if (this.attributes.__source) {
+            const { fileName, lineNumber, columnNumber } = this.attributes.__source;
+            return `${fileName}:${lineNumber}:${columnNumber}`;
+        }
+    }
+    createKey() {
+        const id = this.attributes.id ? `#${this.attributes.id}` : "";
+        const type = this.attributes.type ? `[type=${this.attributes.type}]` : "";
+        const name = this.attributes.name ? `[name=${this.attributes.name}]` : "";
+        return `${this.type}${id}${type}${name}`;
+    }
+}
+// src/jsx.js
+var ensureChildrenArray = (maybeChildren, attributes)=>maybeChildren || attributes.children || [];
+var packageAttributes = (maybeAttributes, maybeChildren)=>{
+    const attributes = maybeAttributes || {};
+    const children3 = ensureChildrenArray(maybeChildren, attributes);
+    attributes.children = attributes.children || children3;
+    return attributes;
+};
+var jsx = (type, attributes, ...children3)=>{
+    if (typeof type === "string") return new Tag(type, attributes, children3);
+    return type(packageAttributes(attributes, children3));
+};
+jsx.fragment = (attributes, maybeChildren)=>{
+    const children3 = ensureChildrenArray(maybeChildren, attributes);
+    return new Children(children3);
+};
+var jsx_default = jsx;
+// src/rendering/templates/root.ts
+class Root {
+    template;
+    selector;
+    renderKit;
+    dom;
+    parentElement;
+    constructor(template, selector, renderKit){
+        this.template = template;
+        this.selector = selector;
+        this.renderKit = renderKit;
+        this.dom = [];
+        this.parentElement = null;
+    }
+    renderAndAttach(renderKit) {
+        this.parentElement = this.getParentElement();
+        this.dom = this.render({
+            ...renderKit,
+            parent: this.parentElement
+        });
+        if (this.parentElement) this.attach();
+    }
+    render(renderKit) {
+        return this.template.render(renderKit);
+    }
+    attach() {
+        this.parentElement && (this.parentElement.innerHTML = "");
+        this.dom.forEach((element)=>{
+            this.parentElement && this.parentElement.appendChild(element);
+        });
+    }
+    getParentElement() {
+        return this.renderKit.document.querySelector(this.selector);
+    }
+}
+var render = (template, selector, renderKit)=>{
+    const root = new Root(template, selector, renderKit);
+    root.renderAndAttach(renderKit);
+    return root;
+};
+// src/state/testingTypes.js
+var isBoolean = (value)=>typeof value === "boolean";
+var isNumber = (value)=>typeof value === "number";
+var isString = (value)=>typeof value === "string";
+var isArray = (value)=>Array.isArray(value);
+var isObject = (value)=>value !== null && !isArray(value) && typeof value === "object";
+// src/state/equality.js
+var areElementEqual = (oldValue, newValue)=>oldValue === newValue;
+var keyLengthSame = (oldValue, newValue)=>Object.keys(oldValue).length === Object.keys(newValue).length;
+var areObjectsEqual = (oldValue, newValue)=>{
+    if (!(isObject(oldValue) && isObject(newValue))) return false;
+    if (!keyLengthSame(oldValue, newValue)) return false;
+    Object.keys(oldValue).every((key)=>{
+        const oldInnerValue = oldValue[key];
+        const newInnerValue = newValue[key];
+        return areEqual(oldInnerValue, newInnerValue);
+    });
+};
+var areArraysEqual = (oldValue, newValue)=>{
+    if (!(isArray(oldValue) && isArray(newValue))) return false;
+    if (oldValue.length !== newValue.length) return false;
+    oldValue.every((oldInnerValue, index)=>{
+        const newInnerValue = newValue[index];
+        return areEqual(oldInnerValue, newInnerValue);
+    });
+};
+var areEqual = (oldValue, newValue)=>{
+    if (isObject(oldValue)) return areObjectsEqual(oldValue, newValue);
+    if (isArray(oldValue)) return areArraysEqual(oldValue, newValue);
+    return areElementEqual(oldValue, newValue);
+};
+// src/state/stores.js
+class GeneralStore {
+    nullEvent = {};
+    constructor({ name, value, parent }){
+        this.name = name;
+        this.value = value;
+        this.parent = parent;
+        this.initialState = value;
+    }
+    update(newValue) {
+        if (this.isEqual(newValue)) return;
+        this.value = newValue;
+        return this.parent.publish(this.event());
+    }
+    reset() {
+        this.update(this.initialState);
+    }
+    isEqual(newValue) {
+        return areElementEqual(this.value, newValue);
+    }
+    event() {
+        return {
+            name: this.name,
+            value: this.value
+        };
+    }
+}
+class BooleanStore extends GeneralStore {
+    toggle() {
+        this.update(!this.value);
+    }
+}
+class NumericStore extends GeneralStore {
+}
+class StringStore extends GeneralStore {
+}
+class ListStore extends GeneralStore {
+    isEqual(newValue) {
+        return areArraysEqual(this.value, newValue);
+    }
+    push(newValue) {
+        const value = [
+            ...this.value,
+            newValue
+        ];
+        this.update(value);
+    }
+}
+class RecordStore extends GeneralStore {
+    isEqual(newValue) {
+        return areObjectsEqual(this.value, newValue);
+    }
+}
+// src/state.js
+var eventPrefix = "state-change";
+var eventName = (name)=>`${eventPrefix}:${name}`;
+class State {
+    constructor(publish){
+        this.publisher = publish;
+        this.stores = {};
+        this.events = [];
+        this.transacting = false;
+    }
+    create(name, value) {
+        const StoreClass = this.storeTypeFor(value);
+        const store = new StoreClass({
+            name,
+            value,
+            parent: this
+        });
+        this.addStore(name, store);
+    }
+    add(store) {
+        const name = store.name;
+        this.addStore(name, store);
+    }
+    getStore(name) {
+        return this.stores[name];
+    }
+    addStore(name, store) {
+        this.stores[name] = store;
+        this[name] = store;
+    }
+    storeTypeFor(value) {
+        if (isArray(value)) return ListStore;
+        if (isObject(value)) return RecordStore;
+        if (isNumber(value)) return NumericStore;
+        if (isBoolean(value)) return BooleanStore;
+        if (isString(value)) return StringStore;
+        return GeneralStore;
+    }
+    publish(event) {
+        this.events.push(event);
+        if (!this.transacting) this.publishAll();
+    }
+    publishAll() {
+        const publishedStores = [];
+        this.events.reverse().forEach((event)=>{
+            const { name, value } = event;
+            if (!publishedStores.includes(name)) {
+                publishedStores.push(name);
+                this.publisher(`${eventPrefix}:${name}`, value);
+            }
+        });
+        this.events = [];
+    }
+    transaction(setter) {
+        this.transacting = true;
+        setter(this);
+        this.transacting = false;
+        this.publishAll();
+    }
+    value() {
+        return Object.keys(this.stores).reduce((valueObject, key)=>{
+            valueObject[key] = this.stores[key].value;
+            return valueObject;
+        }, {});
+    }
+}
+// src/types.ts
+var ChangeInstructions;
+(function(ChangeInstructions2) {
+    ChangeInstructions2[ChangeInstructions2["removeNode"] = 0] = "removeNode";
+    ChangeInstructions2[ChangeInstructions2["insertNode"] = 1] = "insertNode";
+    ChangeInstructions2[ChangeInstructions2["replaceNode"] = 2] = "replaceNode";
+    ChangeInstructions2[ChangeInstructions2["removeAttribute"] = 3] = "removeAttribute";
+    ChangeInstructions2[ChangeInstructions2["addAttribute"] = 4] = "addAttribute";
+    ChangeInstructions2[ChangeInstructions2["updateAttribute"] = 5] = "updateAttribute";
+    ChangeInstructions2[ChangeInstructions2["removeEvent"] = 6] = "removeEvent";
+    ChangeInstructions2[ChangeInstructions2["addEvent"] = 7] = "addEvent";
+    ChangeInstructions2[ChangeInstructions2["updateEvent"] = 8] = "updateEvent";
+    ChangeInstructions2[ChangeInstructions2["changeValue"] = 9] = "changeValue";
+    ChangeInstructions2[ChangeInstructions2["changeText"] = 10] = "changeText";
+})(ChangeInstructions || (ChangeInstructions = {}));
+// src/rendering/change/instructions/generate.ts
+var changeText = (source, target)=>({
+        source,
+        target,
+        type: ChangeInstructions.changeText,
+        data: {}
+    });
+var replaceNode = (source, target)=>({
+        source,
+        target,
+        type: ChangeInstructions.replaceNode,
+        data: {}
+    });
+var removeAttribute = (source, target, data)=>({
+        source,
+        target,
+        data,
+        type: ChangeInstructions.removeAttribute
+    });
+var addAttribute = (source, target, data)=>({
+        source,
+        target,
+        data,
+        type: ChangeInstructions.addAttribute
+    });
+var updateAttribute = (source, target, data)=>({
+        source,
+        target,
+        data,
+        type: ChangeInstructions.updateAttribute
+    });
+var removeEvent = (source, target, data)=>({
+        source,
+        target,
+        data,
+        type: ChangeInstructions.removeEvent
+    });
+var addEvent = (source, target, data)=>({
+        source,
+        target,
+        data,
+        type: ChangeInstructions.addEvent
+    });
+var updateEvent = (source, target, data)=>({
+        source,
+        target,
+        data,
+        type: ChangeInstructions.updateEvent
+    });
+var removeNode = (source)=>({
+        source,
+        target: source,
+        type: ChangeInstructions.removeNode,
+        data: {}
+    });
+var insertNode = (target, data)=>({
+        target,
+        source: target,
+        type: ChangeInstructions.insertNode,
+        data
+    });
+var changeValue = (source, target, data)=>({
+        source,
+        target,
+        type: ChangeInstructions.changeValue,
+        data
+    });
+// src/rendering/change/instructions/idMap.js
+var nullMatch = {
+    index: -1
+};
+class IdMap {
+    constructor(){
+        this.map = {};
+    }
+    populate(list) {
+        list.forEach((element, i)=>{
+            const id = element.__jsx;
+            if (id) {
+                this.map[id] = this.map[id] || [];
+                this.map[id].push({
+                    element,
+                    index: i
+                });
+            }
+        });
+    }
+    pullMatch(element) {
+        const id = element && element.__jsx;
+        if (!id) return nullMatch;
+        if (!(this.map[id] && this.map[id].length)) return nullMatch;
+        return this.map[id].shift();
+    }
+    clear(element) {
+        const id = element && element.__jsx;
+        if (!(id && this.map[id] && this.map[id].length)) return;
+        const matches = this.map[id];
+        this.map[id] = matches.reduce((collection, possibleMatch)=>{
+            if (possibleMatch.element !== element) collection.push(possibleMatch);
+            return collection;
+        }, []);
+    }
+    check(element) {
+        const id = element && element.__jsx;
+        if (!(id && this.map[id])) return false;
+        return this.map[id].length > 0;
+    }
+    remaining() {
+        return Object.values(this.map).flat();
+    }
+}
+var createIdMap = (list)=>{
+    const map = new IdMap;
+    map.populate(list);
+    return map;
+};
+// src/rendering/change/instructions/attributes.ts
+var compileForAttributes = (source, target)=>{
+    const instructions = [];
+    const sourceAttributes = source.attributes;
+    const sourceLength = sourceAttributes.length;
+    const targetAttributes = target.attributes;
+    const targetLength = targetAttributes.length;
+    let index;
+    let innerIndex;
+    let matchingAttribute;
+    for(index = 0; index < sourceLength; index++){
+        matchingAttribute = null;
+        const sourceAttribute = sourceAttributes.item(index);
+        if (!sourceAttribute) continue;
+        for(innerIndex = 0; innerIndex < targetLength; innerIndex++){
+            const targetAttribute = targetAttributes.item(innerIndex);
+            if (!targetAttribute) continue;
+            if (sourceAttribute.name == targetAttribute.name) {
+                matchingAttribute = targetAttribute;
+                break;
+            }
+        }
+        if (!matchingAttribute) instructions.push(removeAttribute(source, target, {
+            name: sourceAttribute.name
+        }));
+        else if (sourceAttribute.value !== matchingAttribute.value) instructions.push(updateAttribute(source, target, {
+            name: sourceAttribute.name,
+            value: matchingAttribute.value
+        }));
+    }
+    for(index = 0; index < targetLength; index++){
+        matchingAttribute = null;
+        const targetAttribute = targetAttributes.item(index);
+        if (!targetAttribute) continue;
+        for(innerIndex = 0; innerIndex < sourceLength; innerIndex++){
+            const sourceAttribute = sourceAttributes.item(innerIndex);
+            if (!sourceAttribute) continue;
+            if (sourceAttribute.name == targetAttribute.name) {
+                matchingAttribute = sourceAttribute;
+                break;
+            }
+        }
+        if (!matchingAttribute) instructions.push(addAttribute(source, target, {
+            name: targetAttribute.name,
+            value: targetAttribute.value
+        }));
+    }
+    return instructions;
+};
+// src/rendering/change/instructions/events.ts
+var compileForEvents = (source, target)=>{
+    const instructions = [];
+    const sourceEventMaps = source.eventMaps;
+    const targetEventMaps = target.eventMaps;
+    const sourceDomEvents = Object.keys(sourceEventMaps);
+    const targetDomEvents = Object.keys(targetEventMaps);
+    sourceDomEvents.forEach((domEvent)=>{
+        const sourceEventMap = sourceEventMaps[domEvent];
+        const targetEventMap = targetEventMaps[domEvent];
+        if (!targetEventMap) instructions.push(removeEvent(source, target, {
+            name: sourceEventMap.domEvent,
+            value: sourceEventMap.listener
+        }));
+        else if (targetEventMap.busEvent !== sourceEventMap.busEvent) instructions.push(updateEvent(source, target, {
+            name: domEvent,
+            targetValue: targetEventMap.listener,
+            sourceValue: sourceEventMap.listener
+        }));
+    });
+    targetDomEvents.forEach((domEvent)=>{
+        const sourceEventMap = sourceEventMaps[domEvent];
+        const targetEventMap = targetEventMaps[domEvent];
+        if (!sourceEventMap) instructions.push(addEvent(source, target, {
+            name: targetEventMap.domEvent,
+            value: targetEventMap.listener
+        }));
+    });
+    return instructions;
+};
+// src/rendering/change/instructions/element.ts
+var compileForElement = (source, target)=>{
+    const attributeInstructions = compileForAttributes(source, target);
+    const eventInstructions = compileForEvents(source, target);
+    const valueInstructions = compileForInputValue(source, target);
+    return attributeInstructions.concat(eventInstructions).concat(valueInstructions);
+};
+var compileForInputValue = (sourceElement, targetElement)=>{
+    const instructions = [];
+    if (sourceElement.tagName !== "INPUT") return instructions;
+    const source = sourceElement;
+    const target = targetElement;
+    if (source.value !== target.value) instructions.push(changeValue(source, target, {
+        name: "value",
+        value: target.value
+    }));
+    return instructions;
+};
+// src/rendering/change/instructions/text.ts
+var compileForText = (source, target)=>{
+    if (source.textContent !== target.textContent) return [
+        changeText(source, target)
+    ];
+    return [];
+};
+// src/rendering/change/instructions/node.ts
+var NodeTypes;
+(function(NodeTypes2) {
+    NodeTypes2[NodeTypes2["ElementNode"] = 1] = "ElementNode";
+    NodeTypes2[NodeTypes2["TextNode"] = 3] = "TextNode";
+})(NodeTypes || (NodeTypes = {}));
+var compileForNodeGenerator = (compileForCollection)=>(source, target)=>{
+        let instructions = [];
+        if (source.nodeType === NodeTypes.ElementNode) {
+            const sourceElement = source;
+            const targetElement = target;
+            const baseInstructions = compileForElement(sourceElement, targetElement);
+            const childrenInstructions = compileForCollection(sourceElement.childNodes, targetElement.childNodes, sourceElement);
+            instructions = baseInstructions.concat(childrenInstructions);
+        } else if (source.nodeType === NodeTypes.TextNode) instructions = compileForText(source, target);
+        return instructions;
+    };
+// src/debugging.js
+var debug = (...message)=>{};
+// src/rendering/change/instructions/children.ts
+var compileChildren = (sourceList, targetList, parent)=>{
+    const baseInstructions = [];
+    const length = largerLength(sourceList, targetList);
+    const sourceMap = createIdMap(sourceList);
+    const targetMap = createIdMap(targetList);
+    const nodesPairsToDiff = [];
+    let index = 0;
+    for(; index < length; index++){
+        const source = sourceList[index];
+        const target = targetList[index];
+        debug("\n", "loop index", index, source && source.__jsx, target && target.__jsx);
+        if (target && targetMap.check(target)) {
+            debug("target", target.__jsx, "index", index);
+            const matchingSource = sourceMap.pullMatch(target);
+            targetMap.clear(target);
+            if (matchingSource.element) {
+                debug("matching source found for target");
+                if (matchingSource.index !== index) {
+                    debug("moving source", matchingSource.element.__jsx, index);
+                    baseInstructions.push(insertNode(matchingSource.element, {
+                        parent,
+                        index
+                    }));
+                }
+                debug("updating to match target", matchingSource.element.__jsx, matchingSource.element.classList, target.__jsx, target.classList);
+                nodesPairsToDiff.push({
+                    source: matchingSource.element,
+                    target
+                });
+            } else if (source) {
+                debug("NO matching source for target but source in slot", source.__jsx);
+                if (targetMap.check(source)) {
+                    debug("adding", target.__jsx, "at", index);
+                    baseInstructions.push(insertNode(target, {
+                        parent,
+                        index
+                    }));
+                } else {
+                    debug("replacing", source.__jsx, target.__jsx, "at", index);
+                    sourceMap.clear(source);
+                    baseInstructions.push(replaceNode(source, target));
+                }
+            } else {
+                debug("adding target to end", target.__jsx);
+                baseInstructions.push(insertNode(target, {
+                    parent,
+                    index
+                }));
+            }
+        } else if (source) {
+            const matchingSource = sourceMap.pullMatch(source);
+            if (matchingSource.element) {
+                debug("removing", source.__jsx);
+                baseInstructions.push(removeNode(source));
+            }
+        }
+    }
+    sourceMap.remaining().forEach(({ element: element2 })=>{
+        debug("removing", element2.__jsx);
+        baseInstructions.push(removeNode(element2));
+    });
+    const nodeInstructions = nodesPairsToDiff.reduce((collection, { source, target })=>{
+        return collection.concat(compileForNode(source, target));
+    }, []);
+    return baseInstructions.concat(nodeInstructions).sort(instructionsSorter);
+};
+var instructionsSorter = (left, right)=>{
+    if (left.type > right.type) return 1;
+    if (left.type < right.type) return -1;
+    return 0;
+};
+var largerLength = (sourceList, targetList)=>{
+    const sourceLength = Array.from(sourceList).length;
+    const targetLength = Array.from(targetList).length;
+    return sourceLength > targetLength ? sourceLength : targetLength;
+};
+var compileForNode = compileForNodeGenerator(compileChildren);
+// src/rendering/change.ts
+var change = (source, target, parent)=>{
+    const instructions = compileChildren(source, target, parent);
+    debug("instructions", instructions.map((instruction)=>instruction.type));
+    instructions.forEach((instruction)=>{
+        performInstruction(instruction);
+    });
+};
+var performInstruction = (instruction)=>{
+    const performer = performers[instruction.type] || noop;
+    performer(instruction);
+};
+var noop = (_instruction)=>{};
+var changeText2 = (instruction)=>{
+    const { source, target } = instruction;
+    source.nodeValue = target.textContent;
+};
+var removeNode2 = (instruction)=>{
+    const { source } = instruction;
+    source.remove();
+    debug("removeNode called on", source.nodeName);
+};
+var insertNode2 = (instruction)=>{
+    const { target, data } = instruction;
+    const { parent, index } = data;
+    const sibling = parent.childNodes[index];
+    if (!sibling) parent.appendChild(target);
+    else if (sibling && sibling !== target) parent.insertBefore(target, sibling);
+};
+var replaceNode2 = (instruction)=>{
+    const { source, target } = instruction;
+    source.replaceWith(target);
+    debug("replaceNode called on", source.nodeName, "with", target.nodeName);
+    debug("parent", source.parentElement);
+};
+var removeAttribute2 = (instruction)=>{
+    const { source, data } = instruction;
+    const { name } = data;
+    source.removeAttribute(name);
+};
+var addAttribute2 = (instruction)=>{
+    const { source, data } = instruction;
+    const { name, value } = data;
+    source.setAttribute(name, value);
+};
+var updateAttribute2 = (instruction)=>{
+    addAttribute2(instruction);
+};
+var removeEvent2 = (instruction)=>{
+    const data = instruction.data;
+    const source = instruction.source;
+    const { name, value } = data;
+    source.removeEventListener(name, value);
+};
+var addEvent2 = (instruction)=>{
+    const data = instruction.data;
+    const source = instruction.source;
+    const { name, value } = data;
+    source.addEventListener(name, value);
+};
+var updateEvent2 = (instruction)=>{
+    const data = instruction.data;
+    const source = instruction.source;
+    const { name, sourceValue, targetValue } = data;
+    source.removeEventListener(name, sourceValue);
+    source.addEventListener(name, targetValue);
+};
+var changeValue2 = (instruction)=>{
+    const data = instruction.data;
+    const source = instruction.source;
+    const { value } = data;
+    source.value = value;
+};
+var performers = {
+    [ChangeInstructions.changeText]: changeText2,
+    [ChangeInstructions.removeNode]: removeNode2,
+    [ChangeInstructions.insertNode]: insertNode2,
+    [ChangeInstructions.replaceNode]: replaceNode2,
+    [ChangeInstructions.removeAttribute]: removeAttribute2,
+    [ChangeInstructions.addAttribute]: addAttribute2,
+    [ChangeInstructions.updateAttribute]: updateAttribute2,
+    [ChangeInstructions.removeEvent]: removeEvent2,
+    [ChangeInstructions.addEvent]: addEvent2,
+    [ChangeInstructions.updateEvent]: updateEvent2,
+    [ChangeInstructions.changeValue]: changeValue2
+};
+// src/rendering/templates/bound.js
+class Bound {
+    constructor(TemplateClass, viewModel, subscriptions, attributes2){
+        this.TemplateClass = TemplateClass;
+        this.viewModel = viewModel;
+        this.attributes = attributes2 || {};
+        this.subscriptions = subscriptions;
+        this.dom = [];
+    }
+    render(renderKit) {
+        this.parentElement = renderKit.parent;
+        this.renderKit = renderKit;
+        this.subscribeForRerender();
+        this.dom = this._render(renderKit);
+        return this.dom;
+    }
+    _render(renderKit) {
+        const props = {
+            ...this.attributes,
+            ...this.viewModel(renderKit.state.value())
+        };
+        const template = this.TemplateClass(props);
+        const dom = !template ? [] : template.render(renderKit);
+        return dom;
+    }
+    rerender() {
+        if (!this.parentElement) this.parentElement = this.dom[0] && this.dom[0].parentElement;
+        const newDom = this._render(this.renderKit);
+        change(this.dom, newDom, this.parentElement);
+        if (this.parentElement) this.dom = Array.from(this.parentElement.childNodes);
+    }
+    subscribeForRerender() {
+        this.subscriptions.forEach((storeName)=>{
+            this.renderKit.subscribe(eventName(storeName), ()=>this.rerender());
+        });
+    }
+}
+var bind = ({ Template, viewModel, subscriptions })=>{
+    subscriptions = subscriptions || [];
+    return (attributes2)=>new Bound(Template, viewModel, subscriptions, attributes2);
+};
+// src/messageBus.ts
+class MessageBus {
+    listeners;
+    options;
+    constructor(){
+        this.options = {};
+        this.listeners = {};
+    }
+    subscribe(eventName2, listener) {
+        this.ensureListenerCollection(eventName2);
+        this.listeners[eventName2].push(listener);
+    }
+    publish(eventName2, payload) {
+        const listeners = this.listeners[eventName2];
+        if (!listeners) return false;
+        listeners.forEach((listener)=>{
+            listener(payload, this.buildListenerKit(eventName2));
+        });
+        return true;
+    }
+    ensureListenerCollection(eventName2) {
+        if (this.listeners[eventName2]) return;
+        this.listeners[eventName2] = [];
+    }
+    buildListenerKit(eventName2) {
+        return {
+            eventName: eventName2,
+            publish: this.publish.bind(this),
+            ...this.options
+        };
+    }
+    addListenerOptions(options) {
+        this.options = {
+            ...this.options,
+            ...options
+        };
+    }
+}
+var createBus = ()=>{
+    const bus = new MessageBus;
+    const publish = bus.publish.bind(bus);
+    const subscribe = bus.subscribe.bind(bus);
+    return {
+        bus,
+        publish,
+        subscribe
+    };
+};
+// src/navigation/routeState.js
+var createRouteState = (state2)=>{
+    const store = new RecordStore({
+        name: "route",
+        value: {
+            host: "",
+            path: "",
+            query: ""
+        },
+        parent: state2
+    });
+    state2.add(store);
+};
+// src/navigation/setupHistory.js
+var locationChangeEvent = "locationChange";
+var routeChangeEvent = "routeChange";
+var extractQueryParams = (queryString)=>{
+    return queryString.replace(/^\?/, "").split("&").reduce((aggregate, pairString)=>{
+        if (!pairString) return aggregate;
+        const pair = pairString.split("=");
+        aggregate[pair[0]] = pair[1];
+        return aggregate;
+    }, {});
+};
+var onLocationChange = (_payload, { publish, state: state2 })=>{
+    const { host, pathname, search } = window.location;
+    const path = pathname;
+    const query = extractQueryParams(search);
+    state2.route.update({
+        host,
+        path,
+        query
+    });
+    publish(routeChangeEvent, {
+        host,
+        path,
+        query
+    });
+};
+var setupHistory = (app)=>{
+    const { publish, subscribe, state: state2 } = app;
+    createRouteState(state2);
+    window.addEventListener("popstate", ()=>publish(locationChangeEvent));
+    subscribe(locationChangeEvent, onLocationChange);
+};
+// src/navigation/findHref.js
+var findHref = (node2)=>{
+    if (!node2 || !node2.getAttribute) return "";
+    while(!node2.getAttribute("href")){
+        node2 = node2.parentNode;
+        if (!node2 || !node2.getAttribute) return "";
+    }
+    return node2.getAttribute("href");
+};
+// src/navigation/setupNavigation.js
+var linkNavigationEvent = "goToHref";
+var programmaticNavigationEvent = "navigate";
+var navigate = (path, { publish })=>{
+    window.history.pushState(null, "", path);
+    publish(locationChangeEvent);
+};
+var onLinkClick = (domEvent, { publish })=>{
+    if (!domEvent || !domEvent.target) return;
+    domEvent.preventDefault();
+    const href = findHref(domEvent.target);
+    navigate(href, {
+        publish
+    });
+};
+var setupNavigation = (app)=>{
+    const { subscribe } = app;
+    subscribe(linkNavigationEvent, onLinkClick);
+    subscribe(programmaticNavigationEvent, navigate);
+};
+// src/app.ts
+var setupBus = (app)=>{
+    const { publish, subscribe, bus } = createBus();
+    app.publish = publish;
+    app.subscribe = subscribe;
+    app.bus = bus;
+};
+var setupState = (app)=>{
+    const state3 = new State(app.publish);
+    app.state = state3;
+};
+var connectBusToState = (app)=>{
+    const { bus } = app;
+    bus.addListenerOptions({
+        state: app.state
+    });
+};
+var setupRenderKit = (app, document)=>{
+    app.renderKit = {
+        publish: app.publish,
+        subscribe: app.subscribe,
+        state: app.state,
+        document
+    };
+};
+var triggerRoute = (app)=>{
+    const publish = app.publish;
+    setTimeout(()=>{
+        publish(locationChangeEvent, null);
+    }, 0);
+};
+var addRender = (app)=>{
+    app.render = (template, selector)=>{
+        return render(template, selector, app.renderKit);
+    };
+};
+var createApp = (document = window.document)=>{
+    const app = {};
+    setupBus(app);
+    setupState(app);
+    connectBusToState(app);
+    setupRenderKit(app, document);
+    setupHistory(app);
+    setupNavigation(app);
+    triggerRoute(app);
+    addRender(app);
+    return app;
+};
+// src/navigation.ts
+var exports_navigation = {};
+__export(exports_navigation, {
+    setupNavigation: ()=>{
+        return setupNavigation;
+    },
+    setupHistory: ()=>{
+        return setupHistory;
+    }
+});
+// src/views/conditionals.jsx
+var exports_conditionals = {};
+__export(exports_conditionals, {
+    Unless: ()=>{
+        return Unless;
+    },
+    IfElse: ()=>{
+        return IfElse;
+    },
+    If: ()=>{
+        return If;
+    }
+});
+var If = ({ condition, children: children3 })=>{
+    if (!condition) return;
+    return jsx_default(jsx_default.fragment, null, children3);
+};
+var Unless = ({ condition, children: children3 })=>{
+    if (condition) return;
+    return jsx_default(jsx_default.fragment, null, children3);
+};
+var IfElse = ({ condition, children: children3 })=>{
+    const [first, ...rest] = children3;
+    if (condition) return jsx_default(jsx_default.fragment, null, first);
+    return jsx_default(jsx_default.fragment, null, rest);
+};
+// src/views/link.jsx
+var Link = ({ children: children3, ...props })=>{
+    return jsx_default("a", {
+        ...props,
+        onClick: "goToHref"
+    }, children3);
+};
+// src/views.js
+var views = {
+    ...exports_conditionals,
+    Link
+};
+
+},{"@parcel/transformer-js/src/esmodule-helpers.js":"gkKU3"}],"gkKU3":[function(require,module,exports) {
+exports.interopDefault = function(a) {
+    return a && a.__esModule ? a : {
+        default: a
+    };
+};
+exports.defineInteropFlag = function(a) {
+    Object.defineProperty(a, "__esModule", {
+        value: true
+    });
+};
+exports.exportAll = function(source, dest) {
+    Object.keys(source).forEach(function(key) {
+        if (key === "default" || key === "__esModule" || Object.prototype.hasOwnProperty.call(dest, key)) return;
+        Object.defineProperty(dest, key, {
+            enumerable: true,
+            get: function() {
+                return source[key];
+            }
+        });
+    });
+    return dest;
+};
+exports.export = function(dest, destName, get) {
+    Object.defineProperty(dest, destName, {
+        enumerable: true,
+        get: get
+    });
+};
+
+},{}]},["gAaC1"], null, "parcelRequireee15")
+
+//# sourceMappingURL=add-remove-root-children.3bb9b3f5.js.map