{"version":3,"sources":["webpack:///./node_modules/strict-uri-encode/index.js","webpack:///./node_modules/split-on-first/index.js","webpack:///./node_modules/typeit-react/dist/index.es.js","webpack:///./node_modules/react/jsx-runtime.js"],"names":["module","exports","str","encodeURIComponent","replace","x","charCodeAt","toString","toUpperCase","string","separator","TypeError","separatorIndex","indexOf","slice","length","_excluded","_objectWithoutProperties","source","excluded","key","i","target","Object","prototype","hasOwnProperty","call","_objectWithoutPropertiesLoose","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","_slicedToArray","arr","Array","isArray","_arrayWithHoles","r","l","t","Symbol","iterator","e","n","u","a","f","o","next","done","push","value","return","_iterableToArrayLimit","minLen","_arrayLikeToArray","constructor","name","from","test","_unsupportedIterableToArray","_nonIterableRest","len","arr2","ownKeys","keys","filter","getOwnPropertyDescriptor","enumerable","apply","_objectSpread","arguments","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","toPrimitive","String","Number","_toPrimitive","configurable","writable","thing","asArray","toArray","val","createTextNode","content","document","expandTextNodes","element","childNodes","child","nodeValue","c","parentNode","insertBefore","remove","getParsedBody","doc","implementation","createHTMLDocument","body","innerHTML","DATA_ATTRIBUTE","CURSOR_CLASS","DEFAULT_STATUSES","started","completed","frozen","destroyed","DEFAULT_OPTIONS","breakLines","cursor","autoPause","autoPauseDelay","animation","frames","map","opacity","options","iterations","Infinity","easing","fill","cursorChar","cursorSpeed","deleteSpeed","html","lifeLike","loop","loopDelay","nextStringDelay","speed","startDelay","startDelete","strings","waitUntilVisible","beforeString","afterString","beforeStep","afterStep","afterComplete","PLACEHOLDER_CSS","walkElementNodes","nextNode","shouldReverse","undefined","shouldIncludeCursor","querySelector","walker","createTreeWalker","NodeFilter","SHOW_ALL","acceptNode","node","_a","_b","classList","contains","FILTER_ACCEPT","FILTER_REJECT","nodes","originalParent","reverse","maybeChunkStringAsHtml","createElement","el","appendStyleBlock","styles","id","styleBlock","appendChild","head","calculateDelay","delayArg","randomInRange","range2","Math","abs","random","range","isInput","handleFunctionalArg","arg","isNumber","isInteger","select","selector","merge","originalObj","newObj","assign","cursorFontStyles","color","transform","duplicate","times","countStepsToSelector","_ref3","queueItems","cursorPosition","to","isMovingToEnd","RegExp","selectorIndex","findIndex","_ref4","char","parentElement","parentMatches","matches","firstChild","isSameNode","beforePaint","cb","Promise","resolve","requestAnimationFrame","async","getAnimationFromElement","getAnimations","find","dataset","tiAnimationId","setCursorAnimation","_ref5","animate","pause","play","execute","queueItem","func","fireItem","index","_ref7","wait2","wait","cursorOptions","instantQueue","tempIndex","futureItem","shouldBeGrouped","delay","shouldPauseCursor","q","effect","getComputedTiming","cancel","_ref6","oldCurrentTime","currentTime","newAnimation","rebuildCursorAnimation","TypeIt$1","_options$cursor","_this","this","_wait","callback","silent","_statuses","unfreeze","_opts","timeouts","setTimeout","_timeouts","_fireItemWithContext","_cursor","_removeNode","rootElement","nodeParent","removeNode","_element","_elementIsInput","_getPace","calculatePace","_getAllChars","getAllChars","_queueAndReturn","steps","opts","_queue","add","_maybeAppendPause","_getDerivedCursorPosition","_predictedCursorPosit","_predictedCursorPosition","_cursorPosition","_generateTemporaryOptionQueueItems","newOptions","_options","_addSplitPause","items","_attachCursor","_shouldRenderCursor","cursorSelector","computedStyles","getComputedStyle","customProperties","entries","reduce","accumulator","_ref","_ref2","item","setCursorStyles","_id","options2","duration","_generateQueue","type","splitItems","_type","typeable","_delete","getTypeable","_fire","remember","cleanUp","qKey","getQueue","_queueItems$index","queueKey","deletable","newIndex","y","derivedCursorPosition","_move","reset","set","_prepLoop","printedCharacters","step","min","max","allChars","newCursorPosition","nodeToInsertBefore","repositionCursor","originalTarget","character","textContent","tagName","insertIntoElement","_empty","break","actionOpts","delete","numCharacters","bookEndQueueItems","num","instant","typeableQueueItems","rounds","empty","exec","move","movementArg","numberOfSteps","directionalStep","cursorable","milliseconds","charsAsQueueItems","outerHTML","nodeType","Node","TEXT_NODE","itemsToQueue","is","destroy","shouldRemoveCursor","clearTimeout","freeze","rebuild","wipe","property","go","IntersectionObserver","observer2","entry","isIntersecting","unobserve","threshold","observe","fireWhenVisible","bind","flush","then","getOptions","updateOptions","getElement","_cursorOptions$autoPa","_DEFAULT_OPTIONS$curs","defaultFrames","defaultOptions","processCursorOptions","substring","initialItems","_q","innerText","buildQueueItem","Boolean","rawValues","values","Map","get","getItems","Queue","typeitId","className","style","visibility","_setUpCursor","existingMarkup","trim","split","concat","_maybePrependHardcodedStrings","DynamicElementComponent","props","ref","As","as","TypeIt","elementRef","instanceRef","children","getBeforeInit","getAfterInit","remainingProps","_useState2","shouldShowChildren","setShouldShowChildren","_useState4","instanceOptions","setInstanceOptions","optionsClone","current","calculateOptions","defaultProps","instance"],"mappings":"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","file":"js/566-5115922e81f51f417fb1.chunk.js","sourcesContent":["'use strict';\n\nmodule.exports = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);","'use strict';\n\nmodule.exports = (string, separator) => {\n  if (!(typeof string === 'string' && typeof separator === 'string')) {\n    throw new TypeError('Expected the arguments to be of type `string`');\n  }\n  if (separator === '') {\n    return [string];\n  }\n  const separatorIndex = string.indexOf(separator);\n  if (separatorIndex === -1) {\n    return [string];\n  }\n  return [string.slice(0, separatorIndex), string.slice(separatorIndex + separator.length)];\n};","const _excluded = [\"options\", \"children\", \"getBeforeInit\", \"getAfterInit\"];\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } } return target; }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\nimport React, { forwardRef, useRef, useState, useEffect } from \"react\";\nconst isArray = thing => Array.isArray(thing);\nconst asArray = value => {\n  return isArray(value) ? value : [value];\n};\nlet Queue = function (initialItems) {\n  let add = function (steps) {\n    asArray(steps).forEach(step => {\n      var _a;\n      return _q.set(Symbol((_a = step.char) == null ? void 0 : _a.innerText), buildQueueItem(_objectSpread({}, step)));\n    });\n    return this;\n  };\n  let getTypeable = () => rawValues().filter(value => value.typeable);\n  let set = function (index, item) {\n    let keys = [..._q.keys()];\n    _q.set(keys[index], buildQueueItem(item));\n  };\n  let buildQueueItem = queueItem => {\n    queueItem.shouldPauseCursor = function () {\n      return Boolean(this.typeable || this.cursorable || this.deletable);\n    };\n    return queueItem;\n  };\n  let reset = function () {\n    _q.forEach(item => delete item.done);\n  };\n  let wipe = function () {\n    _q = /* @__PURE__ */new Map();\n    add(initialItems);\n  };\n  let getQueue = () => _q;\n  let rawValues = () => Array.from(_q.values());\n  let destroy = key => _q.delete(key);\n  let getItems = function () {\n    let all = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n    return all ? rawValues() : rawValues().filter(i => !i.done);\n  };\n  let done = function (key) {\n    let shouldDestroy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n    return shouldDestroy ? _q.delete(key) : _q.get(key).done = true;\n  };\n  let _q = /* @__PURE__ */new Map();\n  add(initialItems);\n  return {\n    add,\n    set,\n    wipe,\n    reset,\n    destroy,\n    done,\n    getItems,\n    getQueue,\n    getTypeable\n  };\n};\nconst toArray = val => Array.from(val);\nconst createTextNode = content => document.createTextNode(content);\nlet expandTextNodes = element => {\n  [...element.childNodes].forEach(child => {\n    if (child.nodeValue) {\n      [...child.nodeValue].forEach(c => {\n        child.parentNode.insertBefore(createTextNode(c), child);\n      });\n      child.remove();\n      return;\n    }\n    expandTextNodes(child);\n  });\n  return element;\n};\nconst getParsedBody = content => {\n  let doc = document.implementation.createHTMLDocument();\n  doc.body.innerHTML = content;\n  return expandTextNodes(doc.body);\n};\nconst DATA_ATTRIBUTE = \"data-typeit-id\";\nconst CURSOR_CLASS = \"ti-cursor\";\nconst END = \"END\";\nconst DEFAULT_STATUSES = {\n  started: false,\n  completed: false,\n  frozen: false,\n  destroyed: false\n};\nconst DEFAULT_OPTIONS = {\n  breakLines: true,\n  cursor: {\n    autoPause: true,\n    autoPauseDelay: 500,\n    animation: {\n      frames: [0, 0, 1].map(n => {\n        return {\n          opacity: n\n        };\n      }),\n      options: {\n        iterations: Infinity,\n        easing: \"steps(2, start)\",\n        fill: \"forwards\"\n      }\n    }\n  },\n  cursorChar: \"|\",\n  cursorSpeed: 1e3,\n  deleteSpeed: null,\n  html: true,\n  lifeLike: true,\n  loop: false,\n  loopDelay: 750,\n  nextStringDelay: 750,\n  speed: 100,\n  startDelay: 250,\n  startDelete: false,\n  strings: [],\n  waitUntilVisible: false,\n  beforeString: () => {},\n  afterString: () => {},\n  beforeStep: () => {},\n  afterStep: () => {},\n  afterComplete: () => {}\n};\nconst PLACEHOLDER_CSS = `[${DATA_ATTRIBUTE}]:before {content: '.'; display: inline-block; width: 0; visibility: hidden;}`;\nfunction walkElementNodes(element) {\n  let shouldReverse = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  let shouldIncludeCursor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n  let cursor = element.querySelector(`.${CURSOR_CLASS}`);\n  let walker = document.createTreeWalker(element, NodeFilter.SHOW_ALL, {\n    acceptNode: node => {\n      var _a, _b;\n      if (cursor && shouldIncludeCursor) {\n        if ((_a = node.classList) == null ? void 0 : _a.contains(CURSOR_CLASS)) {\n          return NodeFilter.FILTER_ACCEPT;\n        }\n        if (cursor.contains(node)) {\n          return NodeFilter.FILTER_REJECT;\n        }\n      }\n      return ((_b = node.classList) == null ? void 0 : _b.contains(CURSOR_CLASS)) ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT;\n    }\n  });\n  let nextNode;\n  let nodes = [];\n  while (nextNode = walker.nextNode()) {\n    if (!nextNode.originalParent) {\n      nextNode.originalParent = nextNode.parentNode;\n    }\n    nodes.push(nextNode);\n  }\n  return shouldReverse ? nodes.reverse() : nodes;\n}\nfunction chunkStringAsHtml(string) {\n  return walkElementNodes(getParsedBody(string));\n}\nfunction maybeChunkStringAsHtml(str) {\n  let asHtml = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n  return asHtml ? chunkStringAsHtml(str) : toArray(str).map(createTextNode);\n}\nconst createElement = el => document.createElement(el);\nconst appendStyleBlock = function (styles) {\n  let id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"\";\n  let styleBlock = createElement(\"style\");\n  styleBlock.id = id;\n  styleBlock.appendChild(createTextNode(styles));\n  document.head.appendChild(styleBlock);\n};\nconst calculateDelay = delayArg => {\n  if (!isArray(delayArg)) {\n    delayArg = [delayArg / 2, delayArg / 2];\n  }\n  return delayArg;\n};\nconst randomInRange = (value, range2) => {\n  return Math.abs(Math.random() * (value + range2 - (value - range2)) + (value - range2));\n};\nlet range = val => val / 2;\nfunction calculatePace(options) {\n  let speed = options.speed,\n    deleteSpeed = options.deleteSpeed,\n    lifeLike = options.lifeLike;\n  deleteSpeed = deleteSpeed !== null ? deleteSpeed : speed / 3;\n  return lifeLike ? [randomInRange(speed, range(speed)), randomInRange(deleteSpeed, range(deleteSpeed))] : [speed, deleteSpeed];\n}\nconst destroyTimeouts = timeouts => {\n  timeouts.forEach(clearTimeout);\n  return [];\n};\nconst generateHash = () => Math.random().toString().substring(2, 9);\nconst isInput = el => \"value\" in el;\nlet getAllChars = element => {\n  if (isInput(element)) {\n    return toArray(element.value);\n  }\n  return walkElementNodes(element, true).filter(c => !(c.childNodes.length > 0));\n};\nconst fireWhenVisible = (element, func) => {\n  let observer = new IntersectionObserver((entries, observer2) => {\n    entries.forEach(entry => {\n      if (entry.isIntersecting) {\n        func();\n        observer2.unobserve(element);\n      }\n    });\n  }, {\n    threshold: 1\n  });\n  observer.observe(element);\n};\nlet handleFunctionalArg = arg => {\n  return typeof arg === \"function\" ? arg() : arg;\n};\nconst isNumber = value => Number.isInteger(value);\nlet select = function (selector) {\n  let element = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document;\n  let all = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n  return element[`querySelector${all ? \"All\" : \"\"}`](selector);\n};\nlet isBodyElement = node => /body/i.test(node == null ? void 0 : node.tagName);\nlet insertIntoElement = (originalTarget, character) => {\n  if (isInput(originalTarget)) {\n    originalTarget.value = `${originalTarget.value}${character.textContent}`;\n    return;\n  }\n  character.innerHTML = \"\";\n  let target = isBodyElement(character.originalParent) ? originalTarget : character.originalParent || originalTarget;\n  target.insertBefore(character, select(\".\" + CURSOR_CLASS, target) || null);\n};\nlet updateCursorPosition = (steps, cursorPosition, printedCharacters) => {\n  return Math.min(Math.max(cursorPosition + steps, 0), printedCharacters.length);\n};\nconst merge = (originalObj, newObj) => Object.assign({}, originalObj, newObj);\nconst removeNode = (node, rootElement) => {\n  if (!node) return;\n  let nodeParent = node.parentNode;\n  let nodeToRemove = nodeParent.childNodes.length > 1 || nodeParent.isSameNode(rootElement) ? node : nodeParent;\n  nodeToRemove.remove();\n};\nconst repositionCursor = (element, allChars, newCursorPosition) => {\n  let nodeToInsertBefore = allChars[newCursorPosition - 1];\n  let cursor = select(`.${CURSOR_CLASS}`, element);\n  element = (nodeToInsertBefore == null ? void 0 : nodeToInsertBefore.parentNode) || element;\n  element.insertBefore(cursor, nodeToInsertBefore || null);\n};\nfunction selectorToElement(thing) {\n  return typeof thing === \"string\" ? select(thing) : thing;\n}\nconst isNonVoidElement = el => /<(.+)>(.*?)<\\/(.+)>/.test(el.outerHTML);\nlet wait = (callback, delay, timeouts) => {\n  return new Promise(resolve => {\n    let cb = async () => {\n      await callback();\n      resolve();\n    };\n    timeouts.push(setTimeout(cb, delay || 0));\n  });\n};\nlet cursorFontStyles = {\n  \"font-family\": \"\",\n  \"font-weight\": \"\",\n  \"font-size\": \"\",\n  \"font-style\": \"\",\n  \"line-height\": \"\",\n  color: \"\",\n  transform: \"translateX(-.125em)\"\n};\nlet setCursorStyles = (id, element) => {\n  let rootSelector = `[${DATA_ATTRIBUTE}='${id}']`;\n  let cursorSelector = `${rootSelector} .${CURSOR_CLASS}`;\n  let computedStyles = getComputedStyle(element);\n  let customProperties = Object.entries(cursorFontStyles).reduce((accumulator, _ref) => {\n    let _ref2 = _slicedToArray(_ref, 2),\n      item = _ref2[0],\n      value = _ref2[1];\n    return `${accumulator} ${item}: var(--ti-cursor-${item}, ${value || computedStyles[item]});`;\n  }, \"\");\n  appendStyleBlock(`${cursorSelector} { display: inline-block; width: 0; ${customProperties} }`, id);\n};\nconst duplicate = (value, times) => new Array(times).fill(value);\nconst countStepsToSelector = _ref3 => {\n  let queueItems = _ref3.queueItems,\n    selector = _ref3.selector,\n    cursorPosition = _ref3.cursorPosition,\n    to = _ref3.to;\n  if (isNumber(selector)) {\n    return selector * -1;\n  }\n  let isMovingToEnd = new RegExp(END, \"i\").test(to);\n  let selectorIndex = selector ? [...queueItems].reverse().findIndex(_ref4 => {\n    let char = _ref4.char;\n    let parentElement = char.parentElement;\n    let parentMatches = parentElement.matches(selector);\n    if (isMovingToEnd && parentMatches) {\n      return true;\n    }\n    return parentMatches && parentElement.firstChild.isSameNode(char);\n  }) : -1;\n  if (selectorIndex < 0) {\n    selectorIndex = isMovingToEnd ? 0 : queueItems.length - 1;\n  }\n  let offset = isMovingToEnd ? 0 : 1;\n  return selectorIndex - cursorPosition + offset;\n};\nlet beforePaint = cb => {\n  return new Promise(resolve => {\n    requestAnimationFrame(async () => {\n      resolve(await cb());\n    });\n  });\n};\nlet getAnimationFromElement = element => {\n  return element == null ? void 0 : element.getAnimations().find(animation => {\n    return animation.id === element.dataset.tiAnimationId;\n  });\n};\nlet setCursorAnimation = _ref5 => {\n  let cursor = _ref5.cursor,\n    frames = _ref5.frames,\n    options = _ref5.options;\n  let animation = cursor.animate(frames, options);\n  animation.pause();\n  animation.id = cursor.dataset.tiAnimationId;\n  beforePaint(() => {\n    beforePaint(() => {\n      animation.play();\n    });\n  });\n  return animation;\n};\nlet rebuildCursorAnimation = _ref6 => {\n  let cursor = _ref6.cursor,\n    options = _ref6.options,\n    cursorOptions = _ref6.cursorOptions;\n  if (!cursor || !cursorOptions) return;\n  let animation = getAnimationFromElement(cursor);\n  let oldCurrentTime;\n  if (animation) {\n    options.delay = animation.effect.getComputedTiming().delay;\n    oldCurrentTime = animation.currentTime;\n    animation.cancel();\n  }\n  let newAnimation = setCursorAnimation({\n    cursor,\n    frames: cursorOptions.animation.frames,\n    options\n  });\n  if (oldCurrentTime) {\n    newAnimation.currentTime = oldCurrentTime;\n  }\n  return newAnimation;\n};\nlet execute = queueItem => {\n  var _a;\n  return (_a = queueItem.func) == null ? void 0 : _a.call(null);\n};\nlet fireItem = async _ref7 => {\n  let index = _ref7.index,\n    queueItems = _ref7.queueItems,\n    wait2 = _ref7.wait,\n    cursor = _ref7.cursor,\n    cursorOptions = _ref7.cursorOptions;\n  let queueItem = queueItems[index][1];\n  let instantQueue = [];\n  let tempIndex = index;\n  let futureItem = queueItem;\n  let shouldBeGrouped = () => futureItem && !futureItem.delay;\n  let shouldPauseCursor = queueItem.shouldPauseCursor() && cursorOptions.autoPause;\n  while (shouldBeGrouped()) {\n    instantQueue.push(futureItem);\n    shouldBeGrouped() && tempIndex++;\n    futureItem = queueItems[tempIndex] ? queueItems[tempIndex][1] : null;\n  }\n  if (instantQueue.length) {\n    await beforePaint(async () => {\n      for (let q of instantQueue) {\n        await execute(q);\n      }\n    });\n    return tempIndex - 1;\n  }\n  let animation = getAnimationFromElement(cursor);\n  let options;\n  if (animation) {\n    options = _objectSpread(_objectSpread({}, animation.effect.getComputedTiming()), {}, {\n      delay: shouldPauseCursor ? cursorOptions.autoPauseDelay : 0\n    });\n  }\n  await wait2(async () => {\n    if (animation && shouldPauseCursor) {\n      animation.cancel();\n    }\n    await beforePaint(() => {\n      execute(queueItem);\n    });\n  }, queueItem.delay);\n  await rebuildCursorAnimation({\n    cursor,\n    options,\n    cursorOptions\n  });\n  return index;\n};\nlet processCursorOptions = cursorOptions => {\n  var _a, _b;\n  if (typeof cursorOptions === \"object\") {\n    var _cursorOptions$autoPa;\n    let newOptions = {};\n    let _DEFAULT_OPTIONS$curs = DEFAULT_OPTIONS.cursor.animation,\n      defaultFrames = _DEFAULT_OPTIONS$curs.frames,\n      defaultOptions = _DEFAULT_OPTIONS$curs.options;\n    newOptions.animation = cursorOptions.animation || {};\n    newOptions.animation.frames = ((_a = cursorOptions.animation) == null ? void 0 : _a.frames) || defaultFrames;\n    newOptions.animation.options = merge(defaultOptions, ((_b = cursorOptions.animation) == null ? void 0 : _b.options) || {});\n    newOptions.autoPause = (_cursorOptions$autoPa = cursorOptions.autoPause) !== null && _cursorOptions$autoPa !== void 0 ? _cursorOptions$autoPa : DEFAULT_OPTIONS.cursor.autoPause;\n    newOptions.autoPauseDelay = cursorOptions.autoPauseDelay || DEFAULT_OPTIONS.cursor.autoPauseDelay;\n    return newOptions;\n  }\n  if (cursorOptions === true) {\n    return DEFAULT_OPTIONS.cursor;\n  }\n  return cursorOptions;\n};\nconst TypeIt$1 = function (element) {\n  var _this = this,\n    _options$cursor;\n  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  let _wait = async function (callback, delay) {\n    let silent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n    if (_statuses.frozen) {\n      await new Promise(resolve => {\n        _this.unfreeze = () => {\n          _statuses.frozen = false;\n          resolve();\n        };\n      });\n    }\n    silent || (await _opts.beforeStep(_this));\n    await wait(callback, delay, _timeouts);\n    silent || (await _opts.afterStep(_this));\n  };\n  let _fireItemWithContext = (index, queueItems) => {\n    return fireItem({\n      index,\n      queueItems,\n      wait: _wait,\n      cursor: _cursor,\n      cursorOptions: _opts.cursor\n    });\n  };\n  let _removeNode = node => removeNode(node, _element);\n  let _elementIsInput = () => isInput(_element);\n  let _getPace = function () {\n    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n    return calculatePace(_opts)[index];\n  };\n  let _getAllChars = () => getAllChars(_element);\n  let _maybeAppendPause = function () {\n    let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    let delay = opts.delay;\n    delay && _queue.add({\n      delay\n    });\n  };\n  let _queueAndReturn = (steps, opts) => {\n    _queue.add(steps);\n    _maybeAppendPause(opts);\n    return this;\n  };\n  let _getDerivedCursorPosition = () => {\n    var _predictedCursorPosit;\n    return (_predictedCursorPosit = _predictedCursorPosition) !== null && _predictedCursorPosit !== void 0 ? _predictedCursorPosit : _cursorPosition;\n  };\n  let _generateTemporaryOptionQueueItems = function () {\n    let newOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    return [{\n      func: () => _options(newOptions)\n    }, {\n      func: () => _options(_opts)\n    }];\n  };\n  let _addSplitPause = items => {\n    let delay = _opts.nextStringDelay;\n    _queue.add([{\n      delay: delay[0]\n    }, ...items, {\n      delay: delay[1]\n    }]);\n  };\n  let _setUpCursor = () => {\n    if (_elementIsInput()) {\n      return;\n    }\n    let cursor = createElement(\"span\");\n    cursor.className = CURSOR_CLASS;\n    if (!_shouldRenderCursor) {\n      cursor.style.visibility = \"hidden\";\n      return cursor;\n    }\n    cursor.innerHTML = getParsedBody(_opts.cursorChar).innerHTML;\n    return cursor;\n  };\n  let _attachCursor = async () => {\n    !_elementIsInput() && _cursor && _element.appendChild(_cursor);\n    if (_shouldRenderCursor) {\n      setCursorStyles(_id, _element);\n      _cursor.dataset.tiAnimationId = _id;\n      let animation = _opts.cursor.animation;\n      let frames = animation.frames,\n        options2 = animation.options;\n      setCursorAnimation({\n        frames,\n        cursor: _cursor,\n        options: _objectSpread({\n          duration: _opts.cursorSpeed\n        }, options2)\n      });\n    }\n  };\n  let _generateQueue = () => {\n    let strings = _opts.strings.filter(string => !!string);\n    strings.forEach((string, index) => {\n      this.type(string);\n      if (index + 1 === strings.length) {\n        return;\n      }\n      let splitItems = _opts.breakLines ? [{\n        func: () => _type(createElement(\"BR\")),\n        typeable: true\n      }] : duplicate({\n        func: _delete,\n        delay: _getPace(1)\n      }, _queue.getTypeable().length);\n      _addSplitPause(splitItems);\n    });\n  };\n  let _prepLoop = async delay => {\n    let derivedCursorPosition = _getDerivedCursorPosition();\n    derivedCursorPosition && (await _move({\n      value: derivedCursorPosition\n    }));\n    let queueItems = _getAllChars().map(c => {\n      return [Symbol(), {\n        func: _delete,\n        delay: _getPace(1),\n        deletable: true,\n        shouldPauseCursor: () => true\n      }];\n    });\n    for (let index = 0; index < queueItems.length; index++) {\n      await _fireItemWithContext(index, queueItems);\n    }\n    _queue.reset();\n    _queue.set(0, {\n      delay\n    });\n  };\n  let _maybePrependHardcodedStrings = strings => {\n    let existingMarkup = _element.innerHTML;\n    if (!existingMarkup) {\n      return strings;\n    }\n    _element.innerHTML = \"\";\n    if (_opts.startDelete) {\n      _element.innerHTML = existingMarkup;\n      expandTextNodes(_element);\n      _addSplitPause(duplicate({\n        func: _delete,\n        delay: _getPace(1),\n        deletable: true\n      }, _getAllChars().length));\n      return strings;\n    }\n    let hardCodedStrings = existingMarkup.replace(/<!--(.+?)-->/g, \"\").trim().split(/<br(?:\\s*?)(?:\\/)?>/);\n    return hardCodedStrings.concat(strings);\n  };\n  let _fire = async function () {\n    let remember = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n    _statuses.started = true;\n    let cleanUp = qKey => {\n      _queue.done(qKey, !remember);\n    };\n    try {\n      let queueItems = [..._queue.getQueue()];\n      for (let index = 0; index < queueItems.length; index++) {\n        let _queueItems$index = _slicedToArray(queueItems[index], 2),\n          queueKey = _queueItems$index[0],\n          queueItem = _queueItems$index[1];\n        if (queueItem.done) continue;\n        if (!queueItem.deletable || queueItem.deletable && _getAllChars().length) {\n          let newIndex = await _fireItemWithContext(index, queueItems);\n          Array(newIndex - index).fill(index + 1).map((x, y) => x + y).forEach(i => {\n            let _queueItems$i = _slicedToArray(queueItems[i], 1),\n              key = _queueItems$i[0];\n            cleanUp(key);\n          });\n          index = newIndex;\n        }\n        cleanUp(queueKey);\n      }\n      if (!remember) {\n        return _this;\n      }\n      _statuses.completed = true;\n      await _opts.afterComplete(_this);\n      if (!_opts.loop) {\n        throw \"\";\n      }\n      let delay = _opts.loopDelay;\n      _wait(async () => {\n        await _prepLoop(delay[0]);\n        _fire();\n      }, delay[1]);\n    } catch (e) {}\n    return _this;\n  };\n  let _move = async step => {\n    _cursorPosition = updateCursorPosition(step, _cursorPosition, _getAllChars());\n    repositionCursor(_element, _getAllChars(), _cursorPosition);\n  };\n  let _type = char => insertIntoElement(_element, char);\n  let _options = async opts => _opts = merge(_opts, opts);\n  let _empty = async () => {\n    if (_elementIsInput()) {\n      _element.value = \"\";\n      return;\n    }\n    _getAllChars().forEach(_removeNode);\n    return;\n  };\n  let _delete = () => {\n    let allChars = _getAllChars();\n    if (!allChars.length) return;\n    if (_elementIsInput()) {\n      _element.value = _element.value.slice(0, -1);\n    } else {\n      _removeNode(allChars[_cursorPosition]);\n    }\n  };\n  this.break = function (actionOpts) {\n    return _queueAndReturn({\n      func: () => _type(createElement(\"BR\")),\n      typeable: true\n    }, actionOpts);\n  };\n  this.delete = function () {\n    let numCharacters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n    let actionOpts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    numCharacters = handleFunctionalArg(numCharacters);\n    let bookEndQueueItems = _generateTemporaryOptionQueueItems(actionOpts);\n    let num = numCharacters;\n    let instant = actionOpts.instant,\n      to = actionOpts.to;\n    let typeableQueueItems = _queue.getTypeable();\n    let rounds = (() => {\n      if (num === null) {\n        return typeableQueueItems.length;\n      }\n      if (isNumber(num)) {\n        return num;\n      }\n      return countStepsToSelector({\n        queueItems: typeableQueueItems,\n        selector: num,\n        cursorPosition: _getDerivedCursorPosition(),\n        to\n      });\n    })();\n    return _queueAndReturn([bookEndQueueItems[0], ...duplicate({\n      func: _delete,\n      delay: instant ? 0 : _getPace(1),\n      deletable: true\n    }, rounds), bookEndQueueItems[1]], actionOpts);\n  };\n  this.empty = function () {\n    let actionOpts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    return _queueAndReturn({\n      func: _empty\n    }, actionOpts);\n  };\n  this.exec = function (func) {\n    let actionOpts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    let bookEndQueueItems = _generateTemporaryOptionQueueItems(actionOpts);\n    return _queueAndReturn([bookEndQueueItems[0], {\n      func: () => func(this)\n    }, bookEndQueueItems[1]], actionOpts);\n  };\n  this.move = function (movementArg) {\n    let actionOpts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    movementArg = handleFunctionalArg(movementArg);\n    let bookEndQueueItems = _generateTemporaryOptionQueueItems(actionOpts);\n    let instant = actionOpts.instant,\n      to = actionOpts.to;\n    let numberOfSteps = countStepsToSelector({\n      queueItems: _queue.getTypeable(),\n      selector: movementArg === null ? \"\" : movementArg,\n      to,\n      cursorPosition: _getDerivedCursorPosition()\n    });\n    let directionalStep = numberOfSteps < 0 ? -1 : 1;\n    _predictedCursorPosition = _getDerivedCursorPosition() + numberOfSteps;\n    return _queueAndReturn([bookEndQueueItems[0], ...duplicate({\n      func: () => _move(directionalStep),\n      delay: instant ? 0 : _getPace(),\n      cursorable: true\n    }, Math.abs(numberOfSteps)), bookEndQueueItems[1]], actionOpts);\n  };\n  this.options = function (opts) {\n    let actionOpts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    opts = handleFunctionalArg(opts);\n    _options(opts);\n    return _queueAndReturn({}, actionOpts);\n  };\n  this.pause = function (milliseconds) {\n    let actionOpts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    return _queueAndReturn({\n      delay: handleFunctionalArg(milliseconds)\n    }, actionOpts);\n  };\n  this.type = function (string) {\n    let actionOpts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    string = handleFunctionalArg(string);\n    let instant = actionOpts.instant;\n    let bookEndQueueItems = _generateTemporaryOptionQueueItems(actionOpts);\n    let chars = maybeChunkStringAsHtml(string, _opts.html);\n    let charsAsQueueItems = chars.map(char => {\n      return {\n        func: () => _type(char),\n        char,\n        delay: instant || isNonVoidElement(char) ? 0 : _getPace(),\n        typeable: char.nodeType === Node.TEXT_NODE\n      };\n    });\n    let itemsToQueue = [bookEndQueueItems[0], {\n      func: async () => await _opts.beforeString(string, this)\n    }, ...charsAsQueueItems, {\n      func: async () => await _opts.afterString(string, this)\n    }, bookEndQueueItems[1]];\n    return _queueAndReturn(itemsToQueue, actionOpts);\n  };\n  this.is = function (key) {\n    return _statuses[key];\n  };\n  this.destroy = function () {\n    let shouldRemoveCursor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n    _timeouts = destroyTimeouts(_timeouts);\n    handleFunctionalArg(shouldRemoveCursor) && _cursor && _removeNode(_cursor);\n    _statuses.destroyed = true;\n  };\n  this.freeze = function () {\n    _statuses.frozen = true;\n  };\n  this.unfreeze = () => {};\n  this.reset = function (rebuild) {\n    !this.is(\"destroyed\") && this.destroy();\n    if (rebuild) {\n      _queue.wipe();\n      rebuild(this);\n    } else {\n      _queue.reset();\n    }\n    _cursorPosition = 0;\n    for (let property in _statuses) {\n      _statuses[property] = false;\n    }\n    _element[_elementIsInput() ? \"value\" : \"innerHTML\"] = \"\";\n    return this;\n  };\n  this.go = function () {\n    if (_statuses.started) {\n      return this;\n    }\n    _attachCursor();\n    if (!_opts.waitUntilVisible) {\n      _fire();\n      return this;\n    }\n    fireWhenVisible(_element, _fire.bind(this));\n    return this;\n  };\n  this.flush = function () {\n    let cb = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : () => {};\n    _attachCursor();\n    _fire(false).then(cb);\n    return this;\n  };\n  this.getQueue = () => _queue;\n  this.getOptions = () => _opts;\n  this.updateOptions = options2 => _options(options2);\n  this.getElement = () => _element;\n  let _element = selectorToElement(element);\n  let _timeouts = [];\n  let _cursorPosition = 0;\n  let _predictedCursorPosition = null;\n  let _statuses = merge({}, DEFAULT_STATUSES);\n  options.cursor = processCursorOptions((_options$cursor = options.cursor) !== null && _options$cursor !== void 0 ? _options$cursor : DEFAULT_OPTIONS.cursor);\n  let _opts = merge(DEFAULT_OPTIONS, options);\n  _opts = merge(_opts, {\n    html: !_elementIsInput() && _opts.html,\n    nextStringDelay: calculateDelay(_opts.nextStringDelay),\n    loopDelay: calculateDelay(_opts.loopDelay)\n  });\n  let _id = generateHash();\n  let _queue = Queue([{\n    delay: _opts.startDelay\n  }]);\n  _element.dataset.typeitId = _id;\n  appendStyleBlock(PLACEHOLDER_CSS);\n  let _shouldRenderCursor = !!_opts.cursor && !_elementIsInput();\n  let _cursor = _setUpCursor();\n  _opts.strings = _maybePrependHardcodedStrings(asArray(_opts.strings));\n  if (_opts.strings.length) {\n    _generateQueue();\n  }\n};\nconst defaultProps = {\n  as: \"span\",\n  options: {},\n  getBeforeInit: instance => instance,\n  getAfterInit: instance => instance\n};\nconst DynamicElementComponent = forwardRef((props, ref) => {\n  const As = props.as;\n  return /* @__PURE__ */React.createElement(As, _objectSpread({\n    ref\n  }, props));\n});\nconst TypeIt = props => {\n  const elementRef = useRef(null);\n  const instanceRef = useRef(null);\n  const options = props.options,\n    children = props.children,\n    getBeforeInit = props.getBeforeInit,\n    getAfterInit = props.getAfterInit,\n    remainingProps = _objectWithoutProperties(props, _excluded);\n  const _useState = useState(true),\n    _useState2 = _slicedToArray(_useState, 2),\n    shouldShowChildren = _useState2[0],\n    setShouldShowChildren = _useState2[1];\n  const _useState3 = useState(null),\n    _useState4 = _slicedToArray(_useState3, 2),\n    instanceOptions = _useState4[0],\n    setInstanceOptions = _useState4[1];\n  function calculateOptions() {\n    const optionsClone = Object.assign({}, options);\n    if (children && elementRef.current) {\n      optionsClone.strings = elementRef.current.innerHTML;\n    }\n    setInstanceOptions(optionsClone);\n  }\n  function generateNewInstance() {\n    instanceRef.current = new TypeIt$1(elementRef.current, instanceOptions);\n    instanceRef.current = getBeforeInit(instanceRef.current);\n    instanceRef.current.go();\n    instanceRef.current = getAfterInit(instanceRef.current);\n  }\n  useEffect(() => {\n    calculateOptions();\n    setShouldShowChildren(false);\n  }, [options]);\n  useEffect(() => {\n    var _a;\n    if (!instanceOptions) return;\n    ((_a = instanceRef.current) == null ? void 0 : _a.updateOptions(instanceOptions)) || generateNewInstance();\n  }, [instanceOptions]);\n  useEffect(() => {\n    return () => {\n      var _a;\n      return (_a = instanceRef.current) == null ? void 0 : _a.destroy();\n    };\n  }, []);\n  return /* @__PURE__ */React.createElement(DynamicElementComponent, _objectSpread({\n    ref: elementRef,\n    children: shouldShowChildren ? children : null,\n    style: {\n      opacity: shouldShowChildren ? 0 : 1\n    }\n  }, remainingProps));\n};\nTypeIt.defaultProps = defaultProps;\nexport { TypeIt as default };","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\n}"],"sourceRoot":""}