/* Riot v10.1.6, @license MIT */

(function (global, factory) {

typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :

typeof define === 'function' && define.amd ? define(['exports'], factory) :

(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.riot = {}));

})(this, (function (exports) { 'use strict';

const EACH = 0;

const IF = 1;

const SIMPLE = 2;

const TAG = 3;

const SLOT = 4;

const bindingTypes = {

EACH,

IF,

SIMPLE,

TAG,

SLOT,

};

// Riot.js constants that can be used across more modules

const COMPONENTS_IMPLEMENTATION_MAP = new Map(),

DOM_COMPONENT_INSTANCE_PROPERTY = Symbol('riot-component'),

PLUGINS_SET = new Set(),

IS_DIRECTIVE = 'is',

VALUE_ATTRIBUTE = 'value',

REF_ATTRIBUTE = 'ref',

EVENT_ATTRIBUTE_RE = /^on/,

MOUNT_METHOD_KEY = 'mount',

UPDATE_METHOD_KEY = 'update',

UNMOUNT_METHOD_KEY = 'unmount',

SHOULD_UPDATE_KEY = 'shouldUpdate',

ON_BEFORE_MOUNT_KEY = 'onBeforeMount',

ON_MOUNTED_KEY = 'onMounted',

ON_BEFORE_UPDATE_KEY = 'onBeforeUpdate',

ON_UPDATED_KEY = 'onUpdated',

ON_BEFORE_UNMOUNT_KEY = 'onBeforeUnmount',

ON_UNMOUNTED_KEY = 'onUnmounted',

PROPS_KEY = 'props',

STATE_KEY = 'state',

SLOTS_KEY = 'slots',

ROOT_KEY = 'root',

IS_PURE_SYMBOL = Symbol('pure'),

IS_COMPONENT_UPDATING = Symbol('is_updating'),

PARENT_KEY_SYMBOL = Symbol('parent'),

TEMPLATE_KEY_SYMBOL = Symbol('template'),

ROOT_ATTRIBUTES_KEY_SYMBOL = Symbol('root-attributes');

/**

* Quick type checking

* @param {*} element - anything

* @param {string} type - type definition

* @returns {boolean} true if the type corresponds

*/

function checkType(element, type) {

return typeof element === type

}

/**

* Check if an element is part of an svg

* @param {HTMLElement} el - element to check

* @returns {boolean} true if we are in an svg context

*/

function isSvg(el) {

const owner = el.ownerSVGElement;

return !!owner || owner === null

}

/**

* Check if an element is a template tag

* @param {HTMLElement} el - element to check

* @returns {boolean} true if it's a <template>

*/

function isTemplate(el) {

return el.tagName.toLowerCase() === 'template'

}

/**

* Check that will be passed if its argument is a function

* @param {*} value - value to check

* @returns {boolean} - true if the value is a function

*/

function isFunction(value) {

return checkType(value, 'function')

}

/**

* Check if a value is a Boolean

* @param {*} value - anything

* @returns {boolean} true only for the value is a boolean

*/

function isBoolean(value) {

return checkType(value, 'boolean')

}

/**

* Check if a value is an Object

* @param {*} value - anything

* @returns {boolean} true only for the value is an object

*/

function isObject(value) {

return !isNil(value) && value.constructor === Object

}

/**

* Check if a value is null or undefined

* @param {*} value - anything

* @returns {boolean} true only for the 'undefined' and 'null' types

*/

function isNil(value) {

return value === null || value === undefined

}

/**

* Check if an attribute is a DOM handler

* @param {string} attribute - attribute string

* @returns {boolean} true only for dom listener attribute nodes

*/

function isEventAttribute(attribute) {

return EVENT_ATTRIBUTE_RE.test(attribute)

}

/**

* Convert a string from camel case to dash-case

* @param {string} string - probably a component tag name

* @returns {string} component name normalized

*/

function camelToDashCase(string) {

return string.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()

}

/**

* Convert a string containing dashes to camel case

* @param {string} string - input string

* @returns {string} my-string -> myString

*/

function dashToCamelCase(string) {

return string.replace(/-(\w)/g, (_, c) => c.toUpperCase())

}

/**

* Get all the element attributes as object

* @param {HTMLElement} element - DOM node we want to parse

* @returns {object} all the attributes found as a key value pairs

*/

function DOMattributesToObject(element) {

return Array.from(element.attributes).reduce((acc, attribute) => {

acc[dashToCamelCase(attribute.name)] = attribute.value;

return acc

}, {})

}

/**

* Move all the child nodes from a source tag to another

* @param {HTMLElement} source - source node

* @param {HTMLElement} target - target node

* @returns {undefined} it's a void method ¯\_(ツ)_/¯

*/

// Ignore this helper because it's needed only for svg tags

function moveChildren(source, target) {

// eslint-disable-next-line fp/no-loops

while (source.firstChild) target.appendChild(source.firstChild);

}

/**

* Remove the child nodes from any DOM node

* @param {HTMLElement} node - target node

* @returns {undefined}

*/

function cleanNode(node) {

// eslint-disable-next-line fp/no-loops

while (node.firstChild) node.removeChild(node.firstChild);

}

/**

* Clear multiple children in a node

* @param {HTMLElement[]} children - direct children nodes

* @returns {undefined}

*/

function clearChildren(children) {

// eslint-disable-next-line fp/no-loops,fp/no-let

for (let i = 0; i < children.length; i++) removeChild(children[i]);

}

/**

* Remove a node

* @param {HTMLElement}node - node to remove

* @returns {undefined}

*/

const removeChild = (node) => node.remove();

/**

* Insert before a node

* @param {HTMLElement} newNode - node to insert

* @param {HTMLElement} refNode - ref child

* @returns {undefined}

*/

const insertBefore = (newNode, refNode) =>

refNode?.parentNode?.insertBefore(newNode, refNode);

/**

* Move a node into its new position. Use the moveBefore method if it's available

* @param {HTMLElement} existingNode - node to move

* @param {HTMLElement} refNode - ref child

* @returns {undefined}

*/

const moveBefore = ((hasMoveBefore) => (existingNode, refNode) =>

hasMoveBefore

? refNode?.parentNode?.moveBefore(existingNode, refNode)

: insertBefore(existingNode, refNode))(

// Rely on the new moveBefore method to move nodes if it's available https://developer.mozilla.org/en-US/docs/Web/API/Element/moveBefore

// cache the value of the check into a boolean variable

typeof Element !== 'undefined' && Element.prototype.moveBefore,

);

/**

* Replace a node

* @param {HTMLElement} newNode - new node to add to the DOM

* @param {HTMLElement} replaced - node to replace

* @returns {undefined}

*/

const replaceChild = (newNode, replaced) =>

replaced?.parentNode?.replaceChild(newNode, replaced);

const ATTRIBUTE = 0;

const EVENT = 1;

const TEXT = 2;

const VALUE = 3;

const REF = 4;

const expressionTypes = {

ATTRIBUTE,

EVENT,

TEXT,

VALUE,

REF,

};

// does simply nothing

function noop() {

return this

}

/**

* Autobind the methods of a source object to itself

* @param {object} source - probably a riot tag instance

* @param {Array<string>} methods - list of the methods to autobind

* @returns {object} the original object received

*/

function autobindMethods(source, methods) {

methods.forEach((method) => {

source[method] = source[method].bind(source);

});

return source

}

/**

* Call the first argument received only if it's a function otherwise return it as it is

* @param {*} source - anything

* @returns {*} anything

*/

function callOrAssign(source) {

return isFunction(source)

? source.prototype && source.prototype.constructor

? new source()

: source()

: source

}

/**

* Throw an error with a descriptive message

* @param { string } message - error message

* @param { string } cause - optional error cause object

* @returns { undefined } hoppla... at this point the program should stop working

*/

function panic(message, cause) {

throw new Error(message, { cause })

}

/**

* Returns the memoized (cached) function.

* // borrowed from https://www.30secondsofcode.org/js/s/memoize

* @param {Function} fn - function to memoize

* @returns {Function} memoize function

*/

function memoize(fn) {

const cache = new Map();

const cached = (val) => {

return cache.has(val)

? cache.get(val)

: cache.set(val, fn.call(this, val)) && cache.get(val)

};

cached.cache = cache;

return cached

}

/**

* Generate key-value pairs from a list of attributes

* @param {Array} attributes - list of attributes generated by the riot compiler, each containing type, name, and evaluate function

* @param {object} scope - the scope in which the attribute values will be evaluated

* @returns {object} An object containing key-value pairs representing the computed attribute values

*/

function generatePropsFromAttributes(attributes, scope) {

return attributes.reduce((acc, { type, name, evaluate }) => {

const value = evaluate(scope);

switch (true) {

// spread attribute

case !name && type === ATTRIBUTE:

return {

...acc,

...value,

}

// ref attribute

case type === REF:

acc.ref = value;

break

// value attribute

case type === VALUE:

acc.value = value;

break

// normal attributes

default:

acc[dashToCamelCase(name)] = value;

}

return acc

}, {})

}

/**

* Helper function to set an immutable property

* @param {object} source - object where the new property will be set

* @param {string} key - object key where the new property will be stored

* @param {*} value - value of the new property

* @param {object} options - set the property overriding the default options

* @returns {object} - the original object modified

*/

function defineProperty(source, key, value, options = {}) {

Object.defineProperty(source, key, {

value,

enumerable: false,

writable: false,

configurable: true,

...options,

});

return source

}

/**

* Define multiple properties on a target object

* @param {object} source - object where the new properties will be set

* @param {object} properties - object containing as key pair the key + value properties

* @param {object} options - set the property overriding the default options

* @returns {object} the original object modified

*/

function defineProperties(source, properties, options) {

Object.entries(properties).forEach(([key, value]) => {

defineProperty(source, key, value, options);

});

return source

}

/**

* Define default properties if they don't exist on the source object

* @param {object} source - object that will receive the default properties

* @param {object} defaults - object containing additional optional keys

* @returns {object} the original object received enhanced

*/

function defineDefaults(source, defaults) {

Object.entries(defaults).forEach(([key, value]) => {

if (!source[key]) source[key] = value;

});

return source

}

// Components without template use a mocked template interface with some basic functionalities to

// guarantee consistent rendering behaviour see https://github.com/riot/riot/issues/2984

const MOCKED_TEMPLATE_INTERFACE = {

[MOUNT_METHOD_KEY](el) {

this.el = el;

},

[UPDATE_METHOD_KEY]: noop,

[UNMOUNT_METHOD_KEY](_, __, mustRemoveRoot = false) {

if (mustRemoveRoot) removeChild(this.el);

else if (!mustRemoveRoot) cleanNode(this.el);

},

clone() {

return { ...this }

},

createDOM: noop,

};

const HEAD_SYMBOL = Symbol();

const TAIL_SYMBOL = Symbol();

/**

* Create the <template> fragments text nodes

* @returns {object} {{head: Text, tail: Text}}

*/

function createHeadTailPlaceholders() {

const head = document.createTextNode('');

const tail = document.createTextNode('');

head[HEAD_SYMBOL] = true;

tail[TAIL_SYMBOL] = true;

return { head, tail }

}

/**

* Create the template meta object in case of <template> fragments

* @param {TemplateChunk} componentTemplate - template chunk object

* @returns {object} the meta property that will be passed to the mount function of the TemplateChunk

*/

function createTemplateMeta(componentTemplate) {

const fragment = componentTemplate.dom.cloneNode(true);

const { head, tail } = createHeadTailPlaceholders();

return {

avoidDOMInjection: true,

fragment,

head,

tail,

children: [head, ...Array.from(fragment.childNodes), tail],

}

}

/* c8 ignore start */

/**

* ISC License

*

* Copyright (c) 2020, Andrea Giammarchi, @WebReflection

*

* Permission to use, copy, modify, and/or distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

* copyright notice and this permission notice appear in all copies.

*

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH

* REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY

* AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,

* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM

* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE

* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

* PERFORMANCE OF THIS SOFTWARE.

*/

// fork of https://github.com/WebReflection/udomdiff version 1.1.0

// due to https://github.com/WebReflection/udomdiff/pull/2

/* eslint-disable */

/**

* @param {Node[]} a The list of current/live children

* @param {Node[]} b The list of future children

* @param {(entry: Node, action: number) => Node} get

* The callback invoked per each entry related DOM operation.

* @param {Node} [before] The optional node used as anchor to insert before.

* @returns {Node[]} The same list of future children.

*/

const udomdiff = (a, b, get, before) => {

const bLength = b.length;

let aEnd = a.length;

let bEnd = bLength;

let aStart = 0;

let bStart = 0;

let map = null;

while (aStart < aEnd || bStart < bEnd) {

// append head, tail, or nodes in between: fast path

if (aEnd === aStart) {

// we could be in a situation where the rest of nodes that

// need to be added are not at the end, and in such case

// the node to `insertBefore`, if the index is more than 0

// must be retrieved, otherwise it's gonna be the first item.

const node =

bEnd < bLength

? bStart

? get(b[bStart - 1], -0).nextSibling

: get(b[bEnd - bStart], 0)

: before;

while (bStart < bEnd) insertBefore(get(b[bStart++], 1), node);

}

// remove head or tail: fast path

else if (bEnd === bStart) {

while (aStart < aEnd) {

// remove the node only if it's unknown or not live

if (!map || !map.has(a[aStart])) removeChild(get(a[aStart], -1));

aStart++;

}

}

// same node: fast path

else if (a[aStart] === b[bStart]) {

aStart++;

bStart++;

}

// same tail: fast path

else if (a[aEnd - 1] === b[bEnd - 1]) {

aEnd--;

bEnd--;

}

// The once here single last swap "fast path" has been removed in v1.1.0

// https://github.com/WebReflection/udomdiff/blob/single-final-swap/esm/index.js#L69-L85

// reverse swap: also fast path

else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {

// this is a "shrink" operation that could happen in these cases:

// [1, 2, 3, 4, 5]

// [1, 4, 3, 2, 5]

// or asymmetric too

// [1, 2, 3, 4, 5]

// [1, 2, 3, 5, 6, 4]

const node = get(a[--aEnd], -1).nextSibling;

moveBefore(get(b[bStart++], 1), get(a[aStart++], -1).nextSibling);

moveBefore(get(b[--bEnd], 1), node);

// mark the future index as identical (yeah, it's dirty, but cheap 👍)

// The main reason to do this, is that when a[aEnd] will be reached,

// the loop will likely be on the fast path, as identical to b[bEnd].

// In the best case scenario, the next loop will skip the tail,

// but in the worst one, this node will be considered as already

// processed, bailing out pretty quickly from the map index check

a[aEnd] = b[bEnd];

}

// map based fallback, "slow" path

else {

// the map requires an O(bEnd - bStart) operation once

// to store all future nodes indexes for later purposes.

// In the worst case scenario, this is a full O(N) cost,

// and such scenario happens at least when all nodes are different,

// but also if both first and last items of the lists are different

if (!map) {

map = new Map();

let i = bStart;

while (i < bEnd) map.set(b[i], i++);

}

// if it's a future node, hence it needs some handling

if (map.has(a[aStart])) {

// grab the index of such node, 'cause it might have been processed

const index = map.get(a[aStart]);

// if it's not already processed, look on demand for the next LCS

if (bStart < index && index < bEnd) {

let i = aStart;

// counts the amount of nodes that are the same in the future

let sequence = 1;

while (++i < aEnd && i < bEnd && map.get(a[i]) === index + sequence)

sequence++;

// effort decision here: if the sequence is longer than replaces

// needed to reach such sequence, which would brings again this loop

// to the fast path, prepend the difference before a sequence,

// and move only the future list index forward, so that aStart

// and bStart will be aligned again, hence on the fast path.

// An example considering aStart and bStart are both 0:

// a: [1, 2, 3, 4]

// b: [7, 1, 2, 3, 6]

// this would place 7 before 1 and, from that time on, 1, 2, and 3

// will be processed at zero cost

if (sequence > index - bStart) {

const node = get(a[aStart], 0);

while (bStart < index) {

// if the node is already in the DOM, move it

// to preserve its state (focus, animations, iframes, etc.)

// otherwise insert it as a new node

const newNode = get(b[bStart++], 1);

if (newNode.parentNode) moveBefore(newNode, node);

else insertBefore(newNode, node);

}

}

// if the effort wasn't good enough, fallback to a replace,

// moving both source and target indexes forward, hoping that some

// similar node will be found later on, to go back to the fast path

else {

replaceChild(get(b[bStart++], 1), get(a[aStart++], -1));

}

}

// otherwise move the source forward, 'cause there's nothing to do

else aStart++;

}

// this node has no meaning in the future list, so it's more than safe

// to remove it, and check the next live node out instead, meaning

// that only the live list index should be forwarded

else removeChild(get(a[aStart++], -1));

}

}

return b

};

const UNMOUNT_SCOPE = Symbol('unmount');

const EachBinding = {

// dynamic binding properties

// childrenMap: null,

// node: null,

// root: null,

// condition: null,

// evaluate: null,

// template: null,

// isTemplateTag: false,

nodes: [],

// getKey: null,

// indexName: null,

// itemName: null,

// afterPlaceholder: null,

// placeholder: null,

// API methods

mount(scope, parentScope) {

return this.update(scope, parentScope)

},

update(scope, parentScope) {

const { placeholder, nodes, childrenMap } = this;

const collection = scope === UNMOUNT_SCOPE ? null : this.evaluate(scope);

const items = collection ? Array.from(collection) : [];

// prepare the diffing

const { newChildrenMap, batches, futureNodes } = createPatch(

items,

scope,

parentScope,

this,

);

// patch the DOM only if there are new nodes

udomdiff(

nodes,

futureNodes,

patch(Array.from(childrenMap.values()), parentScope),

placeholder,

);

// trigger the mounts and the updates

batches.forEach((fn) => fn());

// update the children map

this.childrenMap = newChildrenMap;

this.nodes = futureNodes;

return this

},

unmount(scope, parentScope) {

this.update(UNMOUNT_SCOPE, parentScope);

return this

},

};

/**

* Patch the DOM while diffing

* @param {any[]} redundant - list of all the children (template, nodes, context) added via each

* @param {*} parentScope - scope of the parent template

* @returns {Function} patch function used by domdiff

*/

function patch(redundant, parentScope) {

return (item, info) => {

if (info < 0) {

// get the last element added to the childrenMap saved previously

const element = redundant[redundant.length - 1];

if (element) {

// get the nodes and the template in stored in the last child of the childrenMap

const { template, nodes, context } = element;

// remove the last node (notice <template> tags might have more children nodes)

nodes.pop();

// notice that we pass null as last argument because

// the root node and its children will be removed by domdiff

if (!nodes.length) {

// we have cleared all the children nodes and we can unmount this template

redundant.pop();

template.unmount(context, parentScope, null);

}

}

}

return item

}

}

/**

* Check whether a template must be filtered from a loop

* @param {Function} condition - filter function

* @param {object} context - argument passed to the filter function

* @returns {boolean} true if this item should be skipped

*/

function mustFilterItem(condition, context) {

return condition ? !condition(context) : false

}

/**

* Extend the scope of the looped template

* @param {object} scope - current template scope

* @param {object} options - options

* @param {string} options.itemName - key to identify the looped item in the new context

* @param {string} options.indexName - key to identify the index of the looped item

* @param {number} options.index - current index

* @param {*} options.item - collection item looped

* @returns {object} enhanced scope object

*/

function extendScope(scope, { itemName, indexName, index, item }) {

defineProperty(scope, itemName, item);

if (indexName) defineProperty(scope, indexName, index);

return scope

}

/**

* Loop the current template items

* @param {Array} items - expression collection value

* @param {*} scope - template scope

* @param {*} parentScope - scope of the parent template

* @param {EachBinding} binding - each binding object instance

* @returns {object} data - An object containing:

* @property {Map} newChildrenMap - a Map containing the new children template structure

* @property {Array} batches - array containing the template lifecycle functions to trigger

* @property {Array} futureNodes - array containing the nodes we need to diff

*/

function createPatch(items, scope, parentScope, binding) {

const {

condition,

template,

childrenMap,

itemName,

getKey,

indexName,

root,

isTemplateTag,

} = binding;

const newChildrenMap = new Map();

const batches = [];

const futureNodes = [];

items.forEach((item, index) => {

const context = extendScope(Object.create(scope), {

itemName,

indexName,

index,

item,

});

const key = getKey ? getKey(context) : index;

const oldItem = childrenMap.get(key);

const nodes = [];

if (mustFilterItem(condition, context)) {

return

}

const mustMount = !oldItem;

const componentTemplate = oldItem ? oldItem.template : template.clone();

const el = componentTemplate.el || root.cloneNode();

const meta =

isTemplateTag && mustMount

? createTemplateMeta(componentTemplate)

: componentTemplate.meta;

if (mustMount) {

batches.push(() =>

componentTemplate.mount(el, context, parentScope, meta),

);

} else {

batches.push(() => componentTemplate.update(context, parentScope));

}

// create the collection of nodes to update or to add

// in case of template tags we need to add all its children nodes

if (isTemplateTag) {

nodes.push(...meta.children);

} else {

nodes.push(el);

}

// delete the old item from the children map

childrenMap.delete(key);

futureNodes.push(...nodes);

// update the children map

newChildrenMap.set(key, {

nodes,

template: componentTemplate,

context,

index,

});

});

return {

newChildrenMap,

batches,

futureNodes,

}

}

function create$6(

node,

{ evaluate, condition, itemName, indexName, getKey, template },

) {

const placeholder = document.createTextNode('');

const root = node.cloneNode();

insertBefore(placeholder, node);

removeChild(node);

return {

...EachBinding,

childrenMap: new Map(),

node,

root,

condition,

evaluate,

isTemplateTag: isTemplate(root),

template: template.createDOM(node),

getKey,

indexName,

itemName,

placeholder,

}

}

/**

* Binding responsible for the `if` directive

*/

const IfBinding = {

// dynamic binding properties

// node: null,

// evaluate: null,

// isTemplateTag: false,

// placeholder: null,

// template: null,

// API methods

mount(scope, parentScope) {

return this.update(scope, parentScope)

},

update(scope, parentScope) {

const value = !!this.evaluate(scope);

const mustMount = !this.value && value;

const mustUnmount = this.value && !value;

const mount = () => {

const pristine = this.node.cloneNode();

insertBefore(pristine, this.placeholder);

this.template = this.template.clone();

this.template.mount(pristine, scope, parentScope);

};

switch (true) {

case mustMount:

mount();

break

case mustUnmount:

this.unmount(scope);

break

default:

if (value) this.template.update(scope, parentScope);

}

this.value = value;

return this

},

unmount(scope, parentScope) {

this.template.unmount(scope, parentScope, true);

return this

},

};

function create$5(node, { evaluate, template }) {

const placeholder = document.createTextNode('');

insertBefore(placeholder, node);

removeChild(node);

return {

...IfBinding,

node,

evaluate,

placeholder,

template: template.createDOM(node),

}

}

/**

* This method handles the REF attribute expressions

* @param {object} expression - expression data

* @param {HTMLElement} expression.node - target node

* @param {*} expression.value - the old expression cached value

* @param {*} value - new expression value

* @returns {undefined}

*/

function refExpression({ node, value: oldValue }, value) {

// called on mount and update

if (value) value(node);

// called on unmount

// in this case the node value is null

else oldValue(null);

}

/**

* Normalize the user value in order to render a empty string in case of falsy values

* @param {*} value - user input value

* @returns {string} hopefully a string

*/

function normalizeStringValue(value) {

return isNil(value) ? '' : value

}

/**

* This methods handles the input fields value updates

* @param {object} expression - expression data

* @param {HTMLElement} expression.node - target node

* @param {*} value - new expression value

* @returns {undefined}

*/

function valueExpression({ node }, value) {

node.value = normalizeStringValue(value);

}

const RE_EVENTS_PREFIX = /^on/;

const getCallbackAndOptions = (value) =>

Array.isArray(value) ? value : [value, false];

// see also https://medium.com/@WebReflection/dom-handleevent-a-cross-platform-standard-since-year-2000-5bf17287fd38

const EventListener = {

handleEvent(event) {

this[event.type](event);

},

};

const ListenersWeakMap = new WeakMap();

const createListener = (node) => {

const listener = Object.create(EventListener);

ListenersWeakMap.set(node, listener);

return listener

};

/**

* Set a new event listener

* @param {object} expression - event expression data

* @param {HTMLElement} expression.node - target node

* @param {string} expression.name - event name

* @param {*} value - new expression value

* @returns {undefined}

*/

function eventExpression({ node, name }, value) {

const normalizedEventName = name.replace(RE_EVENTS_PREFIX, '');

const eventListener = ListenersWeakMap.get(node) || createListener(node);

const [callback, options] = getCallbackAndOptions(value);

const handler = eventListener[normalizedEventName];

const mustRemoveEvent = handler && !callback;

const mustAddEvent = callback && !handler;

if (mustRemoveEvent) {

node.removeEventListener(normalizedEventName, eventListener);

}

if (mustAddEvent) {

node.addEventListener(normalizedEventName, eventListener, options);

}

eventListener[normalizedEventName] = callback;

}

/* c8 ignore next */

const ElementProto = typeof Element === 'undefined' ? {} : Element.prototype;

const isNativeHtmlProperty = memoize(

(name) => ElementProto.hasOwnProperty(name), // eslint-disable-line

);

/**

* Add all the attributes provided

* @param {HTMLElement} node - target node

* @param {object} attributes - object containing the attributes names and values

* @param {*} oldAttributes - the old expression cached value

* @returns {undefined} sorry it's a void function :(

*/

function setAllAttributes(node, attributes, oldAttributes) {

Object.entries(attributes)

// filter out the attributes that didn't change their value

.filter(([name, value]) => value !== oldAttributes?.[name])

.forEach(([name, value]) => {

switch (true) {

case name === REF_ATTRIBUTE:

return refExpression({ node }, value)

case name === VALUE_ATTRIBUTE:

return valueExpression({ node }, value)

case isEventAttribute(name):

return eventExpression({ node, name }, value)

default:

return attributeExpression({ node, name }, value)

}

});

}

/**

* Remove all the attributes provided

* @param {HTMLElement} node - target node

* @param {object} newAttributes - object containing all the new attribute names