@lightningtv/solid 0.0.9 → 0.0.11

package/dist/esm/index.js

@@ -1,1013 +0,0 @@
-import { createSignal, mergeProps as mergeProps$1, createRoot, createRenderEffect, createMemo, createComponent as createComponent$1, untrack, splitProps, createEffect, on, createResource, createComputed, batch } from 'solid-js';
-export { ErrorBoundary, For, Index, Match, Show, Suspense, SuspenseList, Switch } from 'solid-js';
-import { Config, isInteger, ElementNode, NodeType, log, startLightningRenderer } from '@lightningtv/core';
-export * from '@lightningtv/core';
-import { createElement as createElement$1, spread as spread$1, isArray, activeElement as activeElement$1, isFunc, renderer as renderer$1, setActiveElement as setActiveElement$1, rootNode as rootNode$1, Config as Config$1, ElementNode as ElementNode$1, createComponent as createComponent$2, View as View$1 } from '@lightningtv/solid';
-import { useKeyDownEvent } from '@solid-primitives/keyboard';
-import { debounce, throttle, createScheduled } from '@solid-primitives/scheduled';
-import { makeEventListener } from '@solid-primitives/event-listener';
-import { useMousePosition } from '@solid-primitives/mouse';
-
-const [activeElement, setActiveElement] = createSignal(undefined);
-Config.setActiveElement = setActiveElement;
-
-const View = props => (() => {
-  var _el$ = createElement$1("node");
-  spread$1(_el$, props, false);
-  return _el$;
-})();
-
-const Text = props => (() => {
-  var _el$ = createElement$1("text");
-  spread$1(_el$, props, false);
-  return _el$;
-})();
-
-/**
- * Converts a color string to a color number value.
- */
-function hexColor(color = '') {
-  if (isInteger(color)) {
-    return color;
-  }
-  if (typeof color === 'string') {
-    // Renderer expects RGBA values
-    if (color.startsWith('#')) {
-      return Number(color.replace('#', '0x') + (color.length === 7 ? 'ff' : ''));
-    }
-    if (color.startsWith('0x')) {
-      return Number(color);
-    }
-    return Number('0x' + (color.length === 6 ? color + 'ff' : color));
-  }
-  return 0x00000000;
-}
-
-/**
- * Converts degrees to radians
- */
-function deg2rad(deg) {
-  return deg * Math.PI / 180;
-}
-
-function createRenderer$1({
-  createElement,
-  createTextNode,
-  isTextNode,
-  replaceText,
-  insertNode,
-  removeNode,
-  setProperty,
-  getParentNode,
-  getFirstChild,
-  getNextSibling
-}) {
-  function insert(parent, accessor, marker, initial) {
-    if (marker !== undefined && !initial) initial = [];
-    if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
-    createRenderEffect(current => insertExpression(parent, accessor(), current, marker), initial);
-  }
-  function insertExpression(parent, value, current, marker, unwrapArray) {
-    while (typeof current === "function") current = current();
-    if (value === current) return current;
-    const t = typeof value,
-      multi = marker !== undefined;
-    if (t === "string" || t === "number") {
-      if (t === "number") value = value.toString();
-      if (multi) {
-        let node = current[0];
-        if (node && isTextNode(node)) {
-          replaceText(node, value);
-        } else node = createTextNode(value);
-        current = cleanChildren(parent, current, marker, node);
-      } else {
-        if (current !== "" && typeof current === "string") {
-          replaceText(getFirstChild(parent), current = value);
-        } else {
-          cleanChildren(parent, current, marker, createTextNode(value));
-          current = value;
-        }
-      }
-    } else if (value == null || t === "boolean") {
-      current = cleanChildren(parent, current, marker);
-    } else if (t === "function") {
-      createRenderEffect(() => {
-        let v = value();
-        while (typeof v === "function") v = v();
-        current = insertExpression(parent, v, current, marker);
-      });
-      return () => current;
-    } else if (Array.isArray(value)) {
-      const array = [];
-      if (normalizeIncomingArray(array, value, unwrapArray)) {
-        createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
-        return () => current;
-      }
-      if (array.length === 0) {
-        const replacement = cleanChildren(parent, current, marker);
-        if (multi) return current = replacement;
-      } else {
-        if (Array.isArray(current)) {
-          if (current.length === 0) {
-            appendNodes(parent, array, marker);
-          } else reconcileArrays(parent, current, array);
-        } else if (current == null || current === "") {
-          appendNodes(parent, array);
-        } else {
-          reconcileArrays(parent, multi && current || [getFirstChild(parent)], array);
-        }
-      }
-      current = array;
-    } else {
-      if (Array.isArray(current)) {
-        if (multi) return current = cleanChildren(parent, current, marker, value);
-        cleanChildren(parent, current, null, value);
-      } else if (current == null || current === "" || !getFirstChild(parent)) {
-        insertNode(parent, value);
-      } else replaceNode(parent, value, getFirstChild(parent));
-      current = value;
-    }
-    return current;
-  }
-  function normalizeIncomingArray(normalized, array, unwrap) {
-    let dynamic = false;
-    for (let i = 0, len = array.length; i < len; i++) {
-      let item = array[i],
-        t;
-      if (item == null || item === true || item === false) ;else if (Array.isArray(item)) {
-        dynamic = normalizeIncomingArray(normalized, item) || dynamic;
-      } else if ((t = typeof item) === "string" || t === "number") {
-        normalized.push(createTextNode(item));
-      } else if (t === "function") {
-        if (unwrap) {
-          while (typeof item === "function") item = item();
-          dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic;
-        } else {
-          normalized.push(item);
-          dynamic = true;
-        }
-      } else normalized.push(item);
-    }
-    return dynamic;
-  }
-  function reconcileArrays(parentNode, a, b) {
-    let bLength = b.length,
-      aEnd = a.length,
-      bEnd = bLength,
-      aStart = 0,
-      bStart = 0,
-      after = getNextSibling(a[aEnd - 1]),
-      map = null;
-    while (aStart < aEnd || bStart < bEnd) {
-      if (a[aStart] === b[bStart]) {
-        aStart++;
-        bStart++;
-        continue;
-      }
-      while (a[aEnd - 1] === b[bEnd - 1]) {
-        aEnd--;
-        bEnd--;
-      }
-      if (aEnd === aStart) {
-        const node = bEnd < bLength ? bStart ? getNextSibling(b[bStart - 1]) : b[bEnd - bStart] : after;
-        while (bStart < bEnd) insertNode(parentNode, b[bStart++], node);
-      } else if (bEnd === bStart) {
-        while (aStart < aEnd) {
-          if (!map || !map.has(a[aStart])) removeNode(parentNode, a[aStart]);
-          aStart++;
-        }
-      } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
-        const node = getNextSibling(a[--aEnd]);
-        insertNode(parentNode, b[bStart++], getNextSibling(a[aStart++]));
-        insertNode(parentNode, b[--bEnd], node);
-        a[aEnd] = b[bEnd];
-      } else {
-        if (!map) {
-          map = new Map();
-          let i = bStart;
-          while (i < bEnd) map.set(b[i], i++);
-        }
-        const index = map.get(a[aStart]);
-        if (index != null) {
-          if (bStart < index && index < bEnd) {
-            let i = aStart,
-              sequence = 1,
-              t;
-            while (++i < aEnd && i < bEnd) {
-              if ((t = map.get(a[i])) == null || t !== index + sequence) break;
-              sequence++;
-            }
-            if (sequence > index - bStart) {
-              const node = a[aStart];
-              while (bStart < index) insertNode(parentNode, b[bStart++], node);
-            } else replaceNode(parentNode, b[bStart++], a[aStart++]);
-          } else aStart++;
-        } else removeNode(parentNode, a[aStart++]);
-      }
-    }
-  }
-  function cleanChildren(parent, current, marker, replacement) {
-    if (marker === undefined) {
-      let removed;
-      while (removed = getFirstChild(parent)) removeNode(parent, removed);
-      replacement && insertNode(parent, replacement);
-      return "";
-    }
-    const node = replacement || createTextNode("");
-    if (current.length) {
-      let inserted = false;
-      for (let i = current.length - 1; i >= 0; i--) {
-        const el = current[i];
-        if (node !== el) {
-          const isParent = getParentNode(el) === parent;
-          if (!inserted && !i) isParent ? replaceNode(parent, node, el) : insertNode(parent, node, marker);else isParent && removeNode(parent, el);
-        } else inserted = true;
-      }
-    } else insertNode(parent, node, marker);
-    return [node];
-  }
-  function appendNodes(parent, array, marker) {
-    for (let i = 0, len = array.length; i < len; i++) insertNode(parent, array[i], marker);
-  }
-  function replaceNode(parent, newNode, oldNode) {
-    insertNode(parent, newNode, oldNode);
-    removeNode(parent, oldNode);
-  }
-  function spreadExpression(node, props, prevProps = {}, skipChildren) {
-    props || (props = {});
-    if (!skipChildren) {
-      createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
-    }
-    createRenderEffect(() => props.ref && props.ref(node));
-    createRenderEffect(() => {
-      for (const prop in props) {
-        if (prop === "children" || prop === "ref") continue;
-        const value = props[prop];
-        if (value === prevProps[prop]) continue;
-        setProperty(node, prop, value, prevProps[prop]);
-        prevProps[prop] = value;
-      }
-    });
-    return prevProps;
-  }
-  return {
-    render(code, element) {
-      let disposer;
-      createRoot(dispose => {
-        disposer = dispose;
-        insert(element, code());
-      });
-      return disposer;
-    },
-    insert,
-    spread(node, accessor, skipChildren) {
-      if (typeof accessor === "function") {
-        createRenderEffect(current => spreadExpression(node, accessor(), current, skipChildren));
-      } else spreadExpression(node, accessor, undefined, skipChildren);
-    },
-    createElement,
-    createTextNode,
-    insertNode,
-    setProp(node, name, value, prev) {
-      setProperty(node, name, value, prev);
-      return value;
-    },
-    mergeProps: mergeProps$1,
-    effect: createRenderEffect,
-    memo: createMemo,
-    createComponent: createComponent$1,
-    use(fn, element, arg) {
-      return untrack(() => fn(element, arg));
-    }
-  };
-}
-function createRenderer(options) {
-  const renderer = createRenderer$1(options);
-  renderer.mergeProps = mergeProps$1;
-  return renderer;
-}
-
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * Copyright 2023 Comcast Cable Communications Management, LLC.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Asserts a condition is truthy, otherwise throws an error
- *
- * @remarks
- * Useful at the top of functions to ensure certain conditions, arguments and
- * properties are set/met before continuing. When using this function,
- * TypeScript will narrow away falsy types from the condition.
- *
- * @param condition
- * @param message
- * @returns
- */
-function assertTruthy(condition, message) {
-  if (isProductionEnvironment()) return;
-  if (!condition) {
-    throw new Error('Assertion failed');
-  }
-}
-/**
- * Checks import.meta if env is production
- *
- * @returns
- */
-function isProductionEnvironment() {
-  return import.meta.env && import.meta.env.PROD;
-}
-
-var nodeOpts = {
-  createElement(name) {
-    return new ElementNode(name);
-  },
-  createTextNode(text) {
-    // A text node is just a string - not the <text> node
-    return {
-      type: NodeType.Text,
-      text,
-      parent: undefined
-    };
-  },
-  replaceText(node, value) {
-    log('Replace Text: ', node, value);
-    node.text = value;
-    const parent = node.parent;
-    assertTruthy(parent);
-    parent.text = parent.getText();
-  },
-  setProperty(node, name, value = true) {
-    node[name] = value;
-  },
-  insertNode(parent, node, anchor) {
-    log('INSERT: ', parent, node, anchor);
-    parent.children.insert(node, anchor);
-    node._queueDelete = false;
-    if (node instanceof ElementNode) {
-      parent.rendered && node.render();
-    } else if (parent.isTextNode()) {
-      // TextNodes can be placed outside of <text> nodes when <Show> is used as placeholder
-      parent.text = parent.getText();
-    }
-  },
-  isTextNode(node) {
-    return node.isTextNode();
-  },
-  removeNode(parent, node) {
-    log('REMOVE: ', parent, node);
-    parent.children.remove(node);
-    node._queueDelete = true;
-    if (node instanceof ElementNode) {
-      // Solid replacesNodes to move them (via insert and remove),
-      // so we need to wait for the next microtask to destroy the node
-      // in the event it gets a new parent.
-      queueMicrotask(() => node.destroy());
-    }
-  },
-  getParentNode(node) {
-    return node.parent;
-  },
-  getFirstChild(node) {
-    return node.children[0];
-  },
-  getNextSibling(node) {
-    const children = node.parent.children || [];
-    const index = children.indexOf(node) + 1;
-    if (index < children.length) {
-      return children[index];
-    }
-    return undefined;
-  }
-};
-
-/* eslint-disable @typescript-eslint/unbound-method */
-const solidRenderer = createRenderer(nodeOpts);
-let renderer;
-const rootNode = nodeOpts.createElement('App');
-async function startLightning(options, rootId) {
-  renderer = startLightningRenderer(options || Config.rendererOptions, rootId || 'app');
-  return await renderer.init();
-}
-const render = async function (code, node) {
-  await startLightning(undefined, node);
-  rootNode.lng = renderer.root;
-  rootNode.rendered = true;
-  // @ts-expect-error - code is jsx element and not SolidElement yet
-  const dispose = solidRenderer.render(code, rootNode);
-  return {
-    dispose,
-    rootNode,
-    renderer
-  };
-};
-
-// used for playground - must be sync so user must await startLightning
-const renderSync = function (code) {
-  rootNode.lng = renderer.root;
-  // @ts-expect-error - code is jsx element and not SolidElement yet
-  return solidRenderer.render(code, rootNode);
-};
-const {
-  effect,
-  memo,
-  createComponent,
-  createElement,
-  createTextNode,
-  insertNode,
-  insert,
-  spread,
-  setProp,
-  mergeProps,
-  use
-} = solidRenderer;
-
-/**
- * renders an arbitrary custom or native component and passes the other props
- * ```typescript
- * <Dynamic component={multiline() ? 'textarea' : 'input'} value={value()} />
- * ```
- * @description https://www.solidjs.com/docs/latest/api#dynamic
- */
-function Dynamic(props) {
-  const [p, others] = splitProps(props, ['component']);
-  const cached = createMemo(() => p.component);
-  return createMemo(() => {
-    const component = cached();
-    switch (typeof component) {
-      case 'function':
-        return untrack(() => component(others));
-      case 'string':
-        {
-          const el = createElement(component);
-          spread(el, others);
-          return el;
-        }
-    }
-  });
-}
-
-/**
- * Generates a map of event handlers for each key in the KeyMap
- */
-
-const keyMapEntries = {
-  ArrowLeft: 'Left',
-  ArrowRight: 'Right',
-  ArrowUp: 'Up',
-  ArrowDown: 'Down',
-  Enter: 'Enter',
-  l: 'Last',
-  ' ': 'Space',
-  Backspace: 'Back',
-  Escape: 'Escape'
-};
-const [focusPath, setFocusPath] = createSignal([]);
-const useFocusManager = userKeyMap => {
-  const keypressEvent = useKeyDownEvent();
-  if (userKeyMap) {
-    // Flatten the userKeyMap to a hash
-    for (const [key, value] of Object.entries(userKeyMap)) {
-      if (isArray(value)) {
-        value.forEach(v => {
-          keyMapEntries[v] = key;
-        });
-      } else {
-        keyMapEntries[value] = key;
-      }
-    }
-  }
-  createEffect(on(activeElement$1, (currentFocusedElm, prevFocusedElm, prevFocusPath = []) => {
-    let current = currentFocusedElm;
-    const fp = [];
-    while (current) {
-      if (!current.states.has('focus')) {
-        current.states.add('focus');
-        isFunc(current.onFocus) && current.onFocus.call(current, currentFocusedElm, prevFocusedElm);
-      }
-      fp.push(current);
-      current = current.parent;
-    }
-    prevFocusPath.forEach(elm => {
-      if (!fp.includes(elm)) {
-        elm.states.remove('focus');
-        isFunc(elm.onBlur) && elm.onBlur.call(elm, currentFocusedElm, prevFocusedElm);
-      }
-    });
-    setFocusPath(fp);
-    return fp;
-  }, {
-    defer: true
-  }));
-  createEffect(() => {
-    const e = keypressEvent();
-    if (e) {
-      // Search keyMap for the value of the pressed key or keyCode if value undefined
-      const mappedKeyEvent = keyMapEntries[e.key] || keyMapEntries[e.keyCode];
-      untrack(() => {
-        const fp = focusPath();
-        let finalFocusElm = undefined;
-        for (const elm of fp) {
-          finalFocusElm = finalFocusElm || elm;
-          if (mappedKeyEvent) {
-            const onKeyHandler = elm[`on${mappedKeyEvent}`];
-            if (isFunc(onKeyHandler)) {
-              if (onKeyHandler.call(elm, e, elm, finalFocusElm) === true) {
-                break;
-              }
-            }
-          } else {
-            console.log(`Unhandled key event: ${e.key || e.keyCode}`);
-          }
-          if (isFunc(elm.onKeyPress)) {
-            if (elm.onKeyPress.call(elm, e, mappedKeyEvent, elm, finalFocusElm) === true) {
-              break;
-            }
-          }
-        }
-        return false;
-      });
-    }
-  });
-  return focusPath;
-};
-
-// To use with TS import withPadding and then put withPadding; on the next line to prevent tree shaking
-function withPadding(el, padding) {
-  const pad = padding();
-  let top, left, right, bottom;
-  if (Array.isArray(pad)) {
-    // top right bottom left
-    if (pad.length === 2) {
-      top = bottom = pad[0];
-      left = right = pad[1];
-    } else if (pad.length === 3) {
-      top = pad[0];
-      left = right = pad[1];
-      bottom = pad[2];
-    } else {
-      [top, right, bottom, left] = pad;
-    }
-  } else {
-    top = right = bottom = left = pad;
-  }
-  el.onBeforeLayout = (node, size) => {
-    if (size) {
-      el.width = el.children.reduce((acc, child) => {
-        const c = child;
-        return acc + (c.width || 0);
-      }, 0) + left + right;
-      const firstChild = el.children[0];
-      if (firstChild) {
-        // set padding or marginLeft for flex
-        firstChild.x = left;
-        firstChild.marginLeft = left;
-      }
-      let maxHeight = 0;
-      el.children.forEach(child => {
-        const c = child;
-        c.y = top;
-        c.marginTop = top;
-        maxHeight = Math.max(maxHeight, c.height || 0);
-      });
-      el.height = maxHeight + top + bottom;
-      // let flex know we need to re-layout
-      return true;
-    }
-  };
-}
-
-/* global SpeechSynthesisErrorEvent */
-function flattenStrings(series = []) {
-  const flattenedSeries = [];
-  let i;
-  for (i = 0; i < series.length; i++) {
-    const s = series[i];
-    if (typeof s === 'string' && !s.includes('PAUSE-')) {
-      flattenedSeries.push(series[i]);
-    } else {
-      break;
-    }
-  }
-  // add a "word boundary" to ensure the Announcer doesn't automatically try to
-  // interpret strings that look like dates but are not actually dates
-  // for example, if "Rising Sun" and "1993" are meant to be two separate lines,
-  // when read together, "Sun 1993" is interpretted as "Sunday 1993"
-  return [flattenedSeries.join(',\b ')].concat(series.slice(i));
-}
-function delay(pause) {
-  return new Promise(resolve => {
-    setTimeout(resolve, pause);
-  });
-}
-
-/**
- * Speak a string
- *
- * @param phrase Phrase to speak
- * @param utterances An array which the new SpeechSynthesisUtterance instance representing this utterance will be appended
- * @param lang Language to speak in
- * @return {Promise<void>} Promise resolved when the utterance has finished speaking, and rejected if there's an error
- */
-function speak(phrase, utterances, lang = 'en-US') {
-  const synth = window.speechSynthesis;
-  return new Promise((resolve, reject) => {
-    const utterance = new SpeechSynthesisUtterance(phrase);
-    utterance.lang = lang;
-    utterance.onend = () => {
-      resolve();
-    };
-    utterance.onerror = e => {
-      reject(e);
-    };
-    utterances.push(utterance);
-    synth.speak(utterance);
-  });
-}
-function speakSeries(series, lang, root = true) {
-  const synth = window.speechSynthesis;
-  const remainingPhrases = flattenStrings(Array.isArray(series) ? series : [series]);
-  const nestedSeriesResults = [];
-  /*
-    We hold this array of SpeechSynthesisUtterances in order to prevent them from being
-    garbage collected prematurely on STB hardware which can cause the 'onend' events of
-    utterances to not fire consistently.
-  */
-  const utterances = [];
-  let active = true;
-  const seriesChain = (async () => {
-    try {
-      while (active && remainingPhrases.length) {
-        const phrase = await Promise.resolve(remainingPhrases.shift());
-        if (!active) {
-          // Exit
-          // Need to check this after the await in case it was cancelled in between
-          break;
-        } else if (typeof phrase === 'string' && phrase.includes('PAUSE-')) {
-          // Pause it
-          let pause = Number(phrase.split('PAUSE-')[1]) * 1000;
-          if (isNaN(pause)) {
-            pause = 0;
-          }
-          await delay(pause);
-        } else if (typeof phrase === 'string' && phrase.length) {
-          // Speak it
-          const totalRetries = 3;
-          let retriesLeft = totalRetries;
-          while (active && retriesLeft > 0) {
-            try {
-              await speak(phrase, utterances, lang);
-              retriesLeft = 0;
-            } catch (e) {
-              // eslint-disable-next-line no-undef
-              if (e instanceof SpeechSynthesisErrorEvent) {
-                if (e.error === 'network') {
-                  retriesLeft--;
-                  console.warn(`Speech synthesis network error. Retries left: ${retriesLeft}`);
-                  await delay(500 * (totalRetries - retriesLeft));
-                } else if (e.error === 'canceled' || e.error === 'interrupted') {
-                  // Cancel or interrupt error (ignore)
-                  retriesLeft = 0;
-                } else {
-                  throw new Error(`SpeechSynthesisErrorEvent: ${e.error}`);
-                }
-              } else {
-                throw e;
-              }
-            }
-          }
-        } else if (typeof phrase === 'function') {
-          const seriesResult = speakSeries(phrase(), lang, false);
-          nestedSeriesResults.push(seriesResult);
-          await seriesResult.series;
-        } else if (Array.isArray(phrase)) {
-          // Speak it (recursively)
-          const seriesResult = speakSeries(phrase, lang, false);
-          nestedSeriesResults.push(seriesResult);
-          await seriesResult.series;
-        }
-      }
-    } finally {
-      active = false;
-    }
-  })();
-  return {
-    series: seriesChain,
-    get active() {
-      return active;
-    },
-    append: toSpeak => {
-      remainingPhrases.push(toSpeak);
-    },
-    cancel: () => {
-      if (!active) {
-        return;
-      }
-      if (root) {
-        synth.cancel();
-      }
-      nestedSeriesResults.forEach(nestedSeriesResults => {
-        nestedSeriesResults.cancel();
-      });
-      active = false;
-    }
-  };
-}
-let currentSeries;
-function SpeechEngine (toSpeak, lang = 'en-US') {
-  currentSeries && currentSeries.cancel();
-  currentSeries = speakSeries(toSpeak, lang);
-  return currentSeries;
-}
-
-let resetFocusPathTimer;
-let prevFocusPath = [];
-let currentlySpeaking;
-let voiceOutDisabled = false;
-const fiveMinutes = 300000;
-function debounceWithFlush(callback, time) {
-  const trigger = debounce(callback, time);
-  let scopedValue;
-  const debounced = newValue => {
-    scopedValue = newValue;
-    trigger(newValue);
-  };
-  debounced.flush = () => {
-    trigger.clear();
-    callback(scopedValue);
-  };
-  debounced.clear = trigger.clear;
-  return debounced;
-}
-function getElmName(elm) {
-  return elm.id || elm.name;
-}
-function onFocusChangeCore(focusPath = []) {
-  if (!Announcer.onFocusChange || !Announcer.enabled) {
-    return;
-  }
-  const loaded = focusPath.every(elm => !elm.loading);
-  const focusDiff = focusPath.filter(elm => !prevFocusPath.includes(elm));
-  resetFocusPathTimer();
-  if (!loaded && Announcer.onFocusChange) {
-    Announcer.onFocusChange([]);
-    return;
-  }
-  prevFocusPath = focusPath.slice(0);
-  const toAnnounceText = [];
-  const toAnnounce = focusDiff.reduce((acc, elm) => {
-    if (elm.announce) {
-      acc.push([getElmName(elm), 'Announce', elm.announce]);
-      toAnnounceText.push(elm.announce);
-    } else if (elm.title) {
-      acc.push([getElmName(elm), 'Title', elm.title]);
-      toAnnounceText.push(elm.title);
-    } else {
-      acc.push([getElmName(elm), 'No Announce', '']);
-    }
-    return acc;
-  }, []);
-  focusDiff.reverse().reduce((acc, elm) => {
-    if (elm.announceContext) {
-      acc.push([getElmName(elm), 'Context', elm.announceContext]);
-      toAnnounceText.push(elm.announceContext);
-    } else {
-      acc.push([getElmName(elm), 'No Context', '']);
-    }
-    return acc;
-  }, toAnnounce);
-  if (Announcer.debug) {
-    console.table(toAnnounce);
-  }
-  if (toAnnounceText.length) {
-    return Announcer.speak(toAnnounceText.reduce((acc, val) => acc.concat(val), []));
-  }
-}
-function textToSpeech(toSpeak) {
-  if (voiceOutDisabled) {
-    return;
-  }
-  return currentlySpeaking = SpeechEngine(toSpeak);
-}
-const Announcer = {
-  debug: false,
-  enabled: true,
-  cancel: function () {
-    currentlySpeaking && currentlySpeaking.cancel();
-  },
-  clearPrevFocus: function (depth = 0) {
-    prevFocusPath = prevFocusPath.slice(0, depth);
-    resetFocusPathTimer();
-  },
-  speak: function (text, {
-    append = false,
-    notification = false
-  } = {}) {
-    if (Announcer.onFocusChange && Announcer.enabled) {
-      Announcer.onFocusChange.flush();
-      if (append && currentlySpeaking && currentlySpeaking.active) {
-        currentlySpeaking.append(text);
-      } else {
-        Announcer.cancel();
-        textToSpeech(text);
-      }
-      if (notification) {
-        voiceOutDisabled = true;
-        currentlySpeaking?.series.finally(() => {
-          voiceOutDisabled = false;
-          Announcer.refresh();
-        }).catch(console.error);
-      }
-    }
-    return currentlySpeaking;
-  },
-  refresh: function (depth = 0) {
-    Announcer.clearPrevFocus(depth);
-    Announcer.onFocusChange && Announcer.onFocusChange(untrack(() => focusPath()));
-  },
-  setupTimers: function ({
-    focusDebounce = 400,
-    focusChangeTimeout = fiveMinutes
-  } = {}) {
-    Announcer.onFocusChange = debounceWithFlush(onFocusChangeCore, focusDebounce);
-    resetFocusPathTimer = debounceWithFlush(() => {
-      // Reset focus path for full announce
-      prevFocusPath = [];
-    }, focusChangeTimeout);
-  }
-};
-
-const useAnnouncer = () => {
-  Announcer.setupTimers();
-  createEffect(on(focusPath, Announcer.onFocusChange, {
-    defer: true
-  }));
-  return Announcer;
-};
-
-// Adopted from https://github.com/solidjs-community/solid-primitives/blob/main/packages/pagination/src/index.ts
-// As we don't have intersection observer in Lightning, we can't use the original implementation
-
-/**
- * Provides an easy way to implement infinite items.
- *
- * ```ts
- * const [items, loader, { item, setItem, setItems, end, setEnd }] = createInfiniteScroll(fetcher);
- * ```
- * @param fetcher `(item: number) => Promise<T[]>`
- * @return `items()` is an accessor contains array of contents
- * @property `items.loading` is a boolean indicator for the loading state
- * @property `items.error` contains any error encountered
- * @method `page` is an accessor that contains page number
- * @method `setPage` allows to manually change the page number
- * @method `setItems` allows to manually change the contents of the item
- * @method `end` is a boolean indicator for end of the item
- * @method `setEnd` allows to manually change the end
- */
-function createInfiniteItems(fetcher) {
-  const [items, setItems] = createSignal([]);
-  const [page, setPage] = createSignal(0);
-  const [end, setEnd] = createSignal(false);
-  const [contents] = createResource(page, fetcher);
-  createComputed(() => {
-    const content = contents();
-    if (!content) return;
-    batch(() => {
-      if (content.length === 0) setEnd(true);
-      setItems(p => [...p, ...content]);
-    });
-  });
-  return [items, {
-    page,
-    setPage,
-    setItems,
-    end,
-    setEnd
-  }];
-}
-
-function createSpriteMap(src, subTextures) {
-  const spriteMapTexture = renderer$1.createTexture('ImageTexture', {
-    src
-  });
-  return subTextures.reduce((acc, t) => {
-    const {
-      x,
-      y,
-      width,
-      height
-    } = t;
-    acc[t.name] = renderer$1.createTexture('SubTexture', {
-      texture: spriteMapTexture,
-      x,
-      y,
-      width,
-      height
-    });
-    return acc;
-  }, {});
-}
-
-function createKeyboardEvent(key, keyCode) {
-  return new KeyboardEvent('keydown', {
-    key,
-    keyCode,
-    which: keyCode,
-    ctrlKey: false,
-    altKey: false,
-    shiftKey: false,
-    metaKey: false,
-    bubbles: true
-  });
-}
-const handleScroll = throttle(e => {
-  const deltaY = e.deltaY;
-  if (deltaY < 0) {
-    document.dispatchEvent(createKeyboardEvent('ArrowUp', 38));
-  } else if (deltaY > 0) {
-    document.dispatchEvent(createKeyboardEvent('ArrowDown', 40));
-  }
-}, 250);
-const handleClick = e => {
-  const active = activeElement$1();
-  const precision = Config$1.rendererOptions?.deviceLogicalPixelRatio || 1;
-  if (active && testCollision(e.clientX, e.clientY, active.lng.coreNode.absX * precision, active.lng.coreNode.absY * precision, active.width * precision, active.height * precision)) {
-    document.dispatchEvent(createKeyboardEvent('Enter', 13));
-  }
-};
-function testCollision(px, py, cx, cy, cw = 0, ch = 0) {
-  return px >= cx && px <= cx + cw && py >= cy && py <= cy + ch;
-}
-function getChildrenByPosition(node, x, y) {
-  let result = [node];
-  const precision = Config$1.rendererOptions?.deviceLogicalPixelRatio || 1;
-  for (let i = 0; i < node.children.length; i++) {
-    const child = node.children[i];
-    if (child instanceof ElementNode$1) {
-      if (child.alpha !== 0 && testCollision(x, y, child.lng.coreNode.absX * precision, child.lng.coreNode.absY * precision, child.width * precision, child.height * precision)) {
-        // continue searching tree
-        result = [...result, ...getChildrenByPosition(child, x, y)];
-      }
-    }
-  }
-  return result;
-}
-function useMouse(myApp = rootNode$1) {
-  const pos = useMousePosition();
-  const scheduled = createScheduled(fn => throttle(fn, 100));
-  makeEventListener(window, 'wheel', handleScroll);
-  makeEventListener(window, 'click', handleClick);
-  createEffect(() => {
-    if (scheduled()) {
-      const result = getChildrenByPosition(myApp, pos.x, pos.y).filter(el => (el.focus || el.onFocus || el.onEnter) && !el.skipFocus).sort((a, b) => (a.zIndex || 0) - (b.zIndex || 0));
-      if (result.length) {
-        let activeElm = result[result.length - 1];
-        while (activeElm) {
-          const elmParent = activeElm.parent;
-          if (elmParent?.forwardStates) {
-            activeElm = activeElm.parent;
-          } else {
-            break;
-          }
-        }
-        const activeElmParent = activeElm?.parent;
-        if (activeElm && activeElmParent?.selected !== undefined) {
-          activeElmParent.selected = activeElmParent.children.indexOf(activeElm);
-        }
-        setActiveElement$1(activeElm);
-      }
-    }
-  });
-}
-
-function Portal(props) {
-  function getMount(mount) {
-    if (!mount) return rootNode$1;
-    return rootNode$1.searchChildrenById(mount) || rootNode$1;
-  }
-  return createComponent$2(View$1, {
-    get parent() {
-      return getMount(props.mount);
-    },
-    get children() {
-      return props.children;
-    }
-  });
-}
-
-export { Dynamic, Portal, Text, View, activeElement, createComponent, createElement, createInfiniteItems, createSpriteMap, createTextNode, deg2rad, effect, focusPath, hexColor, insert, insertNode, memo, mergeProps, render, renderSync, rootNode, setActiveElement, setProp, spread, startLightning, use, useAnnouncer, useFocusManager, useMouse, withPadding };
-//# sourceMappingURL=index.js.map