{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/rambda/dist/rambda.esm.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/rxjs/_esm5/internal/util/isFunction.js","webpack:///./node_modules/rxjs/_esm5/internal/config.js","webpack:///./node_modules/rxjs/_esm5/internal/util/hostReportError.js","webpack:///./node_modules/rxjs/_esm5/internal/Observer.js","webpack:///./node_modules/rxjs/_esm5/internal/util/isArray.js","webpack:///./node_modules/rxjs/_esm5/internal/util/isObject.js","webpack:///./node_modules/rxjs/_esm5/internal/util/UnsubscriptionError.js","webpack:///./node_modules/rxjs/_esm5/internal/Subscription.js","webpack:///./node_modules/rxjs/_esm5/internal/symbol/rxSubscriber.js","webpack:///./node_modules/rxjs/_esm5/internal/Subscriber.js","webpack:///./node_modules/rxjs/_esm5/internal/symbol/observable.js","webpack:///./node_modules/rxjs/_esm5/internal/util/noop.js","webpack:///./node_modules/rxjs/_esm5/internal/util/pipe.js","webpack:///./node_modules/rxjs/_esm5/internal/Observable.js","webpack:///./node_modules/rxjs/_esm5/internal/util/toSubscriber.js","webpack:///./node_modules/rxjs/_esm5/internal/util/canReportError.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/map.js","webpack:///./node_modules/rxjs/_esm5/internal/observable/fromEvent.js","webpack:///./node_modules/rxjs/_esm5/internal/util/isScheduler.js","webpack:///./node_modules/rxjs/_esm5/internal/util/subscribeToArray.js","webpack:///./node_modules/rxjs/_esm5/internal/scheduled/scheduleArray.js","webpack:///./node_modules/rxjs/_esm5/internal/observable/fromArray.js","webpack:///./node_modules/rxjs/_esm5/internal/observable/of.js","webpack:///./node_modules/rxjs/_esm5/internal/OuterSubscriber.js","webpack:///./node_modules/rxjs/_esm5/internal/InnerSubscriber.js","webpack:///./node_modules/rxjs/_esm5/internal/symbol/iterator.js","webpack:///./node_modules/rxjs/_esm5/internal/util/isArrayLike.js","webpack:///./node_modules/rxjs/_esm5/internal/util/isPromise.js","webpack:///./node_modules/rxjs/_esm5/internal/util/subscribeTo.js","webpack:///./node_modules/rxjs/_esm5/internal/util/subscribeToObservable.js","webpack:///./node_modules/rxjs/_esm5/internal/util/subscribeToPromise.js","webpack:///./node_modules/rxjs/_esm5/internal/util/subscribeToIterable.js","webpack:///./node_modules/rxjs/_esm5/internal/util/subscribeToResult.js","webpack:///./node_modules/rxjs/_esm5/internal/observable/combineLatest.js","webpack:///./node_modules/rxjs/_esm5/internal/scheduled/scheduled.js","webpack:///./node_modules/rxjs/_esm5/internal/util/isInteropObservable.js","webpack:///./node_modules/rxjs/_esm5/internal/scheduled/scheduleObservable.js","webpack:///./node_modules/rxjs/_esm5/internal/scheduled/schedulePromise.js","webpack:///./node_modules/rxjs/_esm5/internal/util/isIterable.js","webpack:///./node_modules/rxjs/_esm5/internal/scheduled/scheduleIterable.js","webpack:///./node_modules/rxjs/_esm5/internal/observable/from.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/mergeMap.js","webpack:///./node_modules/rxjs/_esm5/internal/util/identity.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/mergeAll.js","webpack:///./node_modules/rxjs/_esm5/internal/observable/concat.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/concatAll.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/startWith.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/filter.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/switchMap.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/switchMapTo.js","webpack:///./node_modules/rxjs/_esm5/internal/operators/distinctUntilChanged.js","webpack:///./src/assets/javascripts/viewport/_/index.ts","webpack:///./src/assets/javascripts/index.ts","webpack:///./src/assets/javascripts/viewport/breakpoint/index.ts","webpack:///./node_modules/rxjs/_esm5/internal/observable/fromEventPattern.js","webpack:///./node_modules/rxjs/_esm5/internal/observable/merge.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","curry","fn","args","_args","rest","length","idx","list","clone","slice","actualIndex","assoc","prop","val","obj","assign","_isInteger","Number","isInteger","_objectIs","a","b","is","assocPathFn","pathArrValue","split","index","nextObj","parseInt","Array","isArray","arr","concat","flagIs","inputArgument","isNaN","defaultTo","defaultArgument","arguments","_inputArgument","limit","holder","len","ready","instance","undefined","type","typeOf","RegExp","asStr","toString","startsWith","equals","_b","aType","aClone","from","bClone","loopArrayFlag","forEach","aCloneInstance","aCloneIndex","aKeys","keys","loopObjectFlag","aKeyInstance","aValue","bValue","defaultValue","path","_obj","willReturn","counter","reduce","acc","multiply","ctor","_val","constructor","extendStatics","setPrototypeOf","__proto__","__extends","__","this","isFunction","x","_enable_super_gross_mode_that_will_cause_bad_things","config","Promise","Error","stack","hostReportError","err","setTimeout","empty","closed","next","error","useDeprecatedSynchronousErrorHandling","complete","isObject","UnsubscriptionError","UnsubscriptionErrorImpl","errors","message","map","join","Subscription","unsubscribe","_parentOrParents","_subscriptions","_unsubscribe","remove","e","flattenUnsubscriptionErrors","sub","push","add","teardown","subscription","EMPTY","tmp","indexOf","subscriptions","subscriptionIndex","splice","errs","rxSubscriber","Math","random","_super","Subscriber","destinationOrNext","_this","syncErrorValue","syncErrorThrown","syncErrorThrowable","isStopped","destination","subscriber","_next","_error","_complete","_unsubscribeAndRecycle","SafeSubscriber","_parentSubscriber","observerOrNext","context","_context","__tryOrSetError","__tryOrUnsub","wrappedComplete","parent","observable","noop","pipeFromArray","fns","input","prev","Observable","subscribe","_isScalar","_subscribe","lift","operator","source","sink","nextOrObserver","toSubscriber","_trySubscribe","observer","_a","closed_1","canReportError","console","warn","promiseCtor","getPromiseCtor","resolve","reject","pipe","operations","_i","toPromise","project","thisArg","TypeError","MapOperator","MapSubscriber","count","result","fromEvent","target","eventName","options","resultSelector","apply","setupSubscription","sourceObj","handler","addEventListener","removeEventListener","isEventTarget","source_1","on","off","isJQueryStyleEventEmitter","source_2","addListener","removeListener","isNodeStyleEventEmitter","source_3","isScheduler","schedule","subscribeToArray","array","scheduleArray","scheduler","fromArray","of","pop","OuterSubscriber","notifyNext","outerValue","innerValue","outerIndex","innerIndex","innerSub","notifyError","notifyComplete","InnerSubscriber","getSymbolIterator","iterator","isArrayLike","isPromise","then","subscribeTo","obs","promise","iterable","item","done","return","subscribeToResult","outerSubscriber","NONE","combineLatest","observables","CombineLatestOperator","CombineLatestSubscriber","active","values","toRespond","unused","oldVal","_tryResultSelector","scheduled","isInteropObservable","scheduleObservable","schedulePromise","isIterable","scheduleIterable","MergeMapOperator","concurrent","POSITIVE_INFINITY","MergeMapSubscriber","hasCompleted","buffer","_tryNext","_innerSub","ish","innerSubscriber","shift","mergeAll","mergeMap","ii","concatAll","startWith","predicate","FilterOperator","FilterSubscriber","switchMap","SwitchMapOperator","SwitchMapSubscriber","innerSubscription","switchMapTo","innerObservable","distinctUntilChanged","compare","keySelector","DistinctUntilChangedOperator","DistinctUntilChangedSubscriber","hasKey","y","scroll$","window","resize$","getViewportOffset","pageXOffset","pageYOffset","getViewportSize","width","innerWidth","height","innerHeight","query","media","matchMedia","fromEventPattern","addHandler","removeHandler","retValue","matches","offset$","last","size$","hash$","document","location","hash","component$","container","querySelector","navigation","header","title","toc","headline","toArray","collection","documentElement","classList","sidebarOffset$","offsetParent","offsetHeight","offset","child","max","offsetTop","parentElement","children","sidebarHeight$","sidebarActive$","dataset","mdState","style","Boolean","shadowActive$","previousElementSibling","headlineOffset$","headlineWidth$","offsetWidth","headlineActive$","app","_x","el","parentNode","HTMLDetailsElement","open"],"mappings":"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","file":"app.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 2);\n","function F() {\n  return false;\n}\n\nfunction T() {\n  return true;\n}\n\nfunction add(a, b) {\n  if (arguments.length === 1) return _b => add(a, _b);\n  return a + b;\n}\n\nfunction curry(fn, args = []) {\n  return (..._args) => (rest => rest.length >= fn.length ? fn(...rest) : curry(fn, rest))([...args, ..._args]);\n}\n\nfunction adjustRaw(fn, idx, list) {\n  const clone = list.slice();\n  const actualIndex = idx < 0 ? clone.length + idx : idx;\n  clone[actualIndex] = fn(clone[actualIndex]);\n  return clone;\n}\n\nconst adjust = curry(adjustRaw);\n\nfunction all(fn, list) {\n  if (arguments.length === 1) return _list => all(fn, _list);\n\n  for (let i = 0; i < list.length; i++) {\n    if (!fn(list[i], i)) return false;\n  }\n\n  return true;\n}\n\nfunction allPass(predicates) {\n  return input => {\n    let counter = 0;\n\n    while (counter < predicates.length) {\n      if (!predicates[counter](input)) {\n        return false;\n      }\n\n      counter++;\n    }\n\n    return true;\n  };\n}\n\nfunction always(val) {\n  return () => val;\n}\n\nfunction any(fn, list) {\n  if (arguments.length === 1) return _list => any(fn, _list);\n  let counter = 0;\n\n  while (counter < list.length) {\n    if (fn(list[counter], counter)) {\n      return true;\n    }\n\n    counter++;\n  }\n\n  return false;\n}\n\nfunction anyPass(predicates) {\n  return input => {\n    let counter = 0;\n\n    while (counter < predicates.length) {\n      if (predicates[counter](input)) {\n        return true;\n      }\n\n      counter++;\n    }\n\n    return false;\n  };\n}\n\nfunction append(el, list) {\n  if (arguments.length === 1) return _list => append(el, _list);\n  if (typeof list === 'string') return `${list}${el}`;\n  const clone = list.concat();\n  clone.push(el);\n  return clone;\n}\n\nfunction assocFn(prop, val, obj) {\n  return Object.assign({}, obj, {\n    [prop]: val\n  });\n}\n\nconst assoc = curry(assocFn);\n\nfunction _isInteger(n) {\n  return n << 0 === n;\n}\nvar _isInteger$1 = Number.isInteger || _isInteger;\n\nfunction _objectIs(a, b) {\n  if (a === b) {\n    return a !== 0 || 1 / a === 1 / b;\n  }\n\n  return a !== a && b !== b;\n}\nvar _objectIs$1 = Object.is || _objectIs;\n\nfunction assocPathFn(list, val, obj) {\n  const pathArrValue = typeof list === 'string' ? list.split('.') : list;\n\n  if (pathArrValue.length === 0) {\n    return obj;\n  }\n\n  const index = pathArrValue[0];\n\n  if (pathArrValue.length > 1) {\n    const nextObj = !(_objectIs(obj) && obj.hasOwnProperty(index)) ? _isInteger(parseInt(pathArrValue[1], 10)) ? [] : {} : obj[index];\n    val = assocPathFn(Array.prototype.slice.call(pathArrValue, 1), val, nextObj);\n  }\n\n  if (_isInteger(parseInt(index, 10)) && Array.isArray(obj)) {\n    const arr = [].concat(obj);\n    arr[index] = val;\n    return arr;\n  } else {\n    return assoc(index, val, obj);\n  }\n}\n\nconst assocPath = curry(assocPathFn);\n\nfunction both(f, g) {\n  if (arguments.length === 1) return _g => both(f, _g);\n  return (...input) => f(...input) && g(...input);\n}\n\nfunction clone(val) {\n  const out = Array.isArray(val) ? Array(val.length) : {};\n\n  for (const key in val) {\n    const v = val[key];\n    out[key] = typeof v === 'object' && v !== null ? v.getTime ? new Date(v.getTime()) : clone(v) : v;\n  }\n\n  return out;\n}\n\nfunction complement(fn) {\n  return input => !fn(input);\n}\n\nfunction compose(...fns) {\n  return (...args) => {\n    const list = fns.slice();\n\n    if (list.length > 0) {\n      const fn = list.pop();\n      let result = fn(...args);\n\n      while (list.length > 0) {\n        result = list.pop()(result);\n      }\n\n      return result;\n    }\n\n    return undefined;\n  };\n}\n\nfunction concat(left, right) {\n  if (arguments.length === 1) return _right => concat(left, _right);\n  return typeof left === 'string' ? `${left}${right}` : [...left, ...right];\n}\n\nconst dec = n => n - 1;\n\nfunction flagIs(inputArgument) {\n  return inputArgument === undefined || inputArgument === null || Number.isNaN(inputArgument) === true;\n}\n\nfunction defaultTo(defaultArgument, ...inputArgument) {\n  if (arguments.length === 1) {\n    return _inputArgument => defaultTo(defaultArgument, _inputArgument);\n  } else if (arguments.length === 2) {\n    return flagIs(inputArgument[0]) ? defaultArgument : inputArgument[0];\n  }\n\n  const limit = inputArgument.length - 1;\n  let len = limit + 1;\n  let ready = false;\n  let holder;\n\n  while (!ready) {\n    const instance = inputArgument[limit - len + 1];\n\n    if (len === 0) {\n      ready = true;\n    } else if (flagIs(instance)) {\n      len -= 1;\n    } else {\n      holder = instance;\n      ready = true;\n    }\n  }\n\n  return holder === undefined ? defaultArgument : holder;\n}\n\nfunction filterObject(fn, obj) {\n  const willReturn = {};\n\n  for (const prop in obj) {\n    if (fn(obj[prop], prop, obj)) {\n      willReturn[prop] = obj[prop];\n    }\n  }\n\n  return willReturn;\n}\n\nfunction filter(fn, list) {\n  if (arguments.length === 1) return _list => filter(fn, _list);\n\n  if (list === undefined) {\n    return [];\n  }\n\n  if (!Array.isArray(list)) {\n    return filterObject(fn, list);\n  }\n\n  let index = -1;\n  let resIndex = 0;\n  const len = list.length;\n  const willReturn = [];\n\n  while (++index < len) {\n    const value = list[index];\n\n    if (fn(value, index)) {\n      willReturn[resIndex++] = value;\n    }\n  }\n\n  return willReturn;\n}\n\nfunction type(val) {\n  const typeOf = typeof val;\n\n  if (val === null) {\n    return 'Null';\n  } else if (val === undefined) {\n    return 'Undefined';\n  } else if (typeOf === 'boolean') {\n    return 'Boolean';\n  } else if (typeOf === 'number') {\n    return Number.isNaN(val) ? 'NaN' : 'Number';\n  } else if (typeOf === 'string') {\n    return 'String';\n  } else if (Array.isArray(val)) {\n    return 'Array';\n  } else if (val instanceof RegExp) {\n    return 'RegExp';\n  }\n\n  const asStr = val.toString();\n\n  if (asStr.startsWith('async')) {\n    return 'Async';\n  } else if (asStr === '[object Promise]') {\n    return 'Promise';\n  } else if (typeOf === 'function') {\n    return 'Function';\n  }\n\n  return 'Object';\n}\n\nfunction equals(a, b) {\n  if (arguments.length === 1) return _b => equals(a, _b);\n\n  if (a === b) {\n    return true;\n  }\n\n  const aType = type(a);\n\n  if (aType !== type(b)) {\n    return false;\n  }\n\n  if (aType === 'Array') {\n    const aClone = Array.from(a);\n    const bClone = Array.from(b);\n\n    if (aClone.toString() !== bClone.toString()) {\n      return false;\n    }\n\n    let loopArrayFlag = true;\n    aClone.forEach((aCloneInstance, aCloneIndex) => {\n      if (loopArrayFlag) {\n        if (aCloneInstance !== bClone[aCloneIndex] && !equals(aCloneInstance, bClone[aCloneIndex])) {\n          loopArrayFlag = false;\n        }\n      }\n    });\n    return loopArrayFlag;\n  }\n\n  if (aType === 'Object') {\n    const aKeys = Object.keys(a);\n\n    if (aKeys.length !== Object.keys(b).length) {\n      return false;\n    }\n\n    let loopObjectFlag = true;\n    aKeys.forEach(aKeyInstance => {\n      if (loopObjectFlag) {\n        const aValue = a[aKeyInstance];\n        const bValue = b[aKeyInstance];\n\n        if (aValue !== bValue && !equals(aValue, bValue)) {\n          loopObjectFlag = false;\n        }\n      }\n    });\n    return loopObjectFlag;\n  }\n\n  return false;\n}\n\nfunction includes(target, list) {\n  if (arguments.length === 1) return _input => includes(target, _input);\n\n  if (typeof list === 'string') {\n    return list.includes(target);\n  }\n\n  if (!Array.isArray(list)) return false;\n  let index = -1;\n\n  while (++index < list.length) {\n    if (equals(list[index], target)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction difference(list1, list2) {\n  if (arguments.length === 1) return _list => difference(list1, _list);\n  return filter(value => !includes(value, list2), list1);\n}\n\nfunction dissoc(prop, obj) {\n  if (arguments.length === 1) return _obj => dissoc(prop, _obj);\n  if (obj === null || obj === undefined) return {};\n  const willReturn = {};\n\n  for (const p in obj) {\n    willReturn[p] = obj[p];\n  }\n\n  delete willReturn[prop];\n  return willReturn;\n}\n\nfunction divide(a, b) {\n  if (arguments.length === 1) return _b => divide(a, _b);\n  return a / b;\n}\n\nfunction drop(n, list) {\n  if (arguments.length === 1) return _list => drop(n, _list);\n  return list.slice(n);\n}\n\nfunction dropLast(n, list) {\n  if (arguments.length === 1) return _list => dropLast(n, _list);\n  return list.slice(0, -n);\n}\n\nfunction either(f, g) {\n  if (arguments.length === 1) return _g => either(f, _g);\n  return (...input) => f(...input) || g(...input);\n}\n\nfunction endsWith(suffix, list) {\n  if (arguments.length === 1) return _list => endsWith(suffix, _list);\n  return list.endsWith(suffix);\n}\n\nfunction find(fn, list) {\n  if (arguments.length === 1) return _list => find(fn, _list);\n  return list.find(fn);\n}\n\nfunction findIndex(fn, list) {\n  if (arguments.length === 1) return _list => findIndex(fn, _list);\n  const len = list.length;\n  let index = -1;\n\n  while (++index < len) {\n    if (fn(list[index], index)) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n\nfunction flatten(list, input) {\n  const willReturn = input === undefined ? [] : input;\n\n  for (let i = 0; i < list.length; i++) {\n    if (Array.isArray(list[i])) {\n      flatten(list[i], willReturn);\n    } else {\n      willReturn.push(list[i]);\n    }\n  }\n\n  return willReturn;\n}\n\nfunction flipExport(fn) {\n  return (...input) => {\n    if (input.length === 1) {\n      return holder => fn(holder, input[0]);\n    } else if (input.length === 2) {\n      return fn(input[1], input[0]);\n    }\n\n    return undefined;\n  };\n}\n\nfunction flip(fn) {\n  return flipExport(fn);\n}\n\nfunction mapObject(fn, obj) {\n  const willReturn = {};\n\n  for (const prop in obj) {\n    willReturn[prop] = fn(obj[prop], prop, obj);\n  }\n\n  return willReturn;\n}\n\nfunction map(fn, list) {\n  if (arguments.length === 1) return _list => map(fn, _list);\n\n  if (list === undefined) {\n    return [];\n  }\n\n  if (!Array.isArray(list)) {\n    return mapObject(fn, list);\n  }\n\n  let index = -1;\n  const len = list.length;\n  const willReturn = Array(len);\n\n  while (++index < len) {\n    willReturn[index] = fn(list[index], index);\n  }\n\n  return willReturn;\n}\n\nfunction forEach(fn, list) {\n  if (arguments.length === 1) return _list => forEach(fn, _list);\n  map(fn, list);\n  return list;\n}\n\nfunction fromPairs(list) {\n  const toReturn = {};\n  list.forEach(([prop, value]) => toReturn[prop] = value);\n  return toReturn;\n}\n\nfunction groupBy(fn, list) {\n  if (arguments.length === 1) return _list => groupBy(fn, _list);\n  const result = {};\n\n  for (let i = 0; i < list.length; i++) {\n    const item = list[i];\n    const key = fn(item);\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n\n    result[key].push(item);\n  }\n\n  return result;\n}\n\nfunction groupWith(predicate, list) {\n  const toReturn = [];\n  let holder = [];\n  list.reduce((prev, current, i) => {\n    if (i > 0 && predicate(prev, current)) {\n      if (holder.length === 0) {\n        holder.push(prev);\n        holder.push(current);\n      } else {\n        holder.push(current);\n      }\n    } else if (i > 0) {\n      if (holder.length === 0) {\n        toReturn.push([prev]);\n        if (i === list.length - 1) holder.push(current);\n      } else {\n        toReturn.push(holder);\n        holder = [];\n      }\n    }\n\n    return current;\n  }, undefined);\n  return holder.length === 0 ? toReturn : [...toReturn, holder];\n}\n\nfunction has(prop, obj) {\n  if (arguments.length === 1) return _obj => has(prop, _obj);\n  return obj[prop] !== undefined;\n}\n\nfunction head(list) {\n  if (typeof list === 'string') return list[0] || '';\n  return list[0];\n}\n\nfunction identical(a, b) {\n  if (arguments.length === 1) return _b => identical(a, _b);\n  return _objectIs$1(a, b);\n}\n\nfunction identity(x) {\n  return x;\n}\n\nfunction ifElse(condition, onTrue, onFalse) {\n  if (onTrue === undefined) {\n    return (_onTrue, _onFalse) => ifElse(condition, _onTrue, _onFalse);\n  } else if (onFalse === undefined) {\n    return _onFalse => ifElse(condition, onTrue, _onFalse);\n  }\n\n  return input => {\n    const conditionResult = typeof condition === 'boolean' ? condition : condition(input);\n\n    if (conditionResult === true) {\n      return onTrue(input);\n    }\n\n    return onFalse(input);\n  };\n}\n\nconst inc = n => n + 1;\n\nfunction indexBy(fn, list) {\n  if (arguments.length === 1) return _list => indexBy(fn, _list);\n  const result = {};\n\n  for (let i = 0; i < list.length; i++) {\n    const item = list[i];\n    result[fn(item)] = item;\n  }\n\n  return result;\n}\n\nfunction indexOf(target, list) {\n  if (arguments.length === 1) return _list => indexOf(target, _list);\n  let index = -1;\n  const {\n    length\n  } = list;\n\n  while (++index < length) {\n    if (list[index] === target) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n\nfunction baseSlice(array, start, end) {\n  let index = -1;\n  let {\n    length\n  } = array;\n  end = end > length ? length : end;\n\n  if (end < 0) {\n    end += length;\n  }\n\n  length = start > end ? 0 : end - start >>> 0;\n  start >>>= 0;\n  const result = Array(length);\n\n  while (++index < length) {\n    result[index] = array[index + start];\n  }\n\n  return result;\n}\n\nfunction init(list) {\n  if (typeof list === 'string') return list.slice(0, -1);\n  return list.length ? baseSlice(list, 0, -1) : [];\n}\n\nfunction intersperse(separator, list) {\n  if (arguments.length === 1) return _list => intersperse(separator, _list);\n  let index = -1;\n  const len = list.length;\n  const willReturn = [];\n\n  while (++index < len) {\n    if (index === len - 1) {\n      willReturn.push(list[index]);\n    } else {\n      willReturn.push(list[index], separator);\n    }\n  }\n\n  return willReturn;\n}\n\nfunction intersection(list1, list2) {\n  if (arguments.length === 1) return _list => intersection(list1, _list);\n  return filter(value => includes(value, list2), list1);\n}\n\nfunction is(ctor, val) {\n  if (arguments.length === 1) return _val => is(ctor, _val);\n  return val != null && val.constructor === ctor || val instanceof ctor;\n}\n\nfunction isEmpty(x) {\n  if (Number.isFinite(x) || !x) {\n    return true;\n  }\n\n  if (Array.isArray(x)) {\n    return x.length === 0;\n  }\n\n  return Object.keys(x).length === 0;\n}\n\nfunction isNil(x) {\n  return x === undefined || x === null;\n}\n\nfunction join(separator, list) {\n  if (arguments.length === 1) return _list => join(separator, _list);\n  return list.join(separator);\n}\n\nfunction keys(obj) {\n  return Object.keys(obj);\n}\n\nfunction last(list) {\n  if (typeof list === 'string') return list[list.length - 1] || '';\n  return list[list.length - 1];\n}\n\nfunction lastIndexOf(target, list) {\n  if (arguments.length === 1) return _list => lastIndexOf(target, _list);\n  let index = list.length;\n\n  while (--index > 0) {\n    if (equals(list[index], target)) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n\nfunction length(list) {\n  return list.length;\n}\n\nfunction match(pattern, str) {\n  if (arguments.length === 1) return _str => match(pattern, _str);\n  const willReturn = str.match(pattern);\n  return willReturn === null ? [] : willReturn;\n}\n\nfunction mathMod(m, p) {\n  if (arguments.length === 1) return p => mathMod(_m, p);\n  if (!_isInteger$1(m) || !_isInteger$1(p) || p < 1) return NaN;\n  return (m % p + p) % p;\n}\n\nfunction max(a, b) {\n  if (arguments.length === 1) return _b => max(a, _b);\n  return b > a ? b : a;\n}\n\nfunction maxBy(fn, a, b) {\n  if (arguments.length === 2) {\n    return _b => maxBy(fn, a, _b);\n  } else if (arguments.length === 1) {\n    return (_a, _b) => maxBy(fn, _a, _b);\n  }\n\n  return fn(b) > fn(a) ? b : a;\n}\n\nfunction sum(list) {\n  return list.reduce((prev, current) => prev + current, 0);\n}\n\nfunction mean(list) {\n  return sum(list) / list.length;\n}\n\nfunction median(list) {\n  const len = list.length;\n  if (len === 0) return NaN;\n  const width = 2 - len % 2;\n  const idx = (len - width) / 2;\n  return mean(Array.prototype.slice.call(list, 0).sort((a, b) => {\n    if (a === b) return 0;\n    return a < b ? -1 : 1;\n  }).slice(idx, idx + width));\n}\n\nfunction merge(obj, props) {\n  if (arguments.length === 1) return _props => merge(obj, _props);\n  return Object.assign({}, obj || {}, props || {});\n}\n\nfunction min(a, b) {\n  if (arguments.length === 1) return _b => min(a, _b);\n  return b < a ? b : a;\n}\n\nfunction minBy(fn, a, b) {\n  if (arguments.length === 2) {\n    return _b => minBy(fn, a, _b);\n  } else if (arguments.length === 1) {\n    return (_a, _b) => minBy(fn, _a, _b);\n  }\n\n  return fn(b) < fn(a) ? b : a;\n}\n\nfunction modulo(a, b) {\n  if (arguments.length === 1) return _b => modulo(a, _b);\n  return a % b;\n}\n\nfunction multiply(a, b) {\n  if (arguments.length === 1) return _b => multiply(a, _b);\n  return a * b;\n}\n\nfunction negate(n) {\n  return -n;\n}\n\nfunction none(fn, list) {\n  if (arguments.length === 1) return _list => none(fn, _list);\n  return list.filter(fn).length === 0;\n}\n\nfunction not(a) {\n  return !a;\n}\n\nfunction nth(offset, list) {\n  if (arguments.length === 1) return _list => nth(offset, _list);\n  const idx = offset < 0 ? list.length + offset : offset;\n  return Object.prototype.toString.call(list) === '[object String]' ? list.charAt(idx) : list[idx];\n}\n\nfunction omit(keys, obj) {\n  if (arguments.length === 1) return _obj => omit(keys, _obj);\n\n  if (obj === null || obj === undefined) {\n    return undefined;\n  }\n\n  const keysValue = typeof keys === 'string' ? keys.split(',') : keys;\n  const willReturn = {};\n\n  for (const key in obj) {\n    if (!keysValue.includes(key)) {\n      willReturn[key] = obj[key];\n    }\n  }\n\n  return willReturn;\n}\n\nfunction partial(fn, ...args) {\n  const len = fn.length;\n  return (...rest) => {\n    if (args.length + rest.length >= len) {\n      return fn(...args, ...rest);\n    }\n\n    return partial(fn, ...[...args, ...rest]);\n  };\n}\n\nfunction partialCurry(fn, args = {}) {\n  return rest => {\n    if (type(fn) === 'Async' || type(fn) === 'Promise') {\n      return new Promise((resolve, reject) => {\n        fn(merge(rest, args)).then(resolve).catch(reject);\n      });\n    }\n\n    return fn(merge(rest, args));\n  };\n}\n\nfunction path(list, obj) {\n  if (arguments.length === 1) return _obj => path(list, _obj);\n\n  if (obj === null || obj === undefined) {\n    return undefined;\n  }\n\n  let willReturn = obj;\n  let counter = 0;\n  const pathArrValue = typeof list === 'string' ? list.split('.') : list;\n\n  while (counter < pathArrValue.length) {\n    if (willReturn === null || willReturn === undefined) {\n      return undefined;\n    }\n\n    willReturn = willReturn[pathArrValue[counter]];\n    counter++;\n  }\n\n  return willReturn;\n}\n\nfunction pathOrRaw(defaultValue, list, obj) {\n  return defaultTo(defaultValue, path(list, obj));\n}\n\nconst pathOr = curry(pathOrRaw);\n\nfunction pick(keys, obj) {\n  if (arguments.length === 1) return _obj => pick(keys, _obj);\n\n  if (obj === null || obj === undefined) {\n    return undefined;\n  }\n\n  const keysValue = typeof keys === 'string' ? keys.split(',') : keys;\n  const willReturn = {};\n  let counter = 0;\n\n  while (counter < keysValue.length) {\n    if (keysValue[counter] in obj) {\n      willReturn[keysValue[counter]] = obj[keysValue[counter]];\n    }\n\n    counter++;\n  }\n\n  return willReturn;\n}\n\nfunction pickAll(keys, obj) {\n  if (arguments.length === 1) return _obj => pickAll(keys, _obj);\n\n  if (obj === null || obj === undefined) {\n    return undefined;\n  }\n\n  const keysValue = typeof keys === 'string' ? keys.split(',') : keys;\n  const willReturn = {};\n  let counter = 0;\n\n  while (counter < keysValue.length) {\n    if (keysValue[counter] in obj) {\n      willReturn[keysValue[counter]] = obj[keysValue[counter]];\n    } else {\n      willReturn[keysValue[counter]] = undefined;\n    }\n\n    counter++;\n  }\n\n  return willReturn;\n}\n\nfunction pipe(...fns) {\n  return compose(...fns.reverse());\n}\n\nfunction pluck(key, list) {\n  if (arguments.length === 1) return _list => pluck(key, _list);\n  const willReturn = [];\n  map(val => {\n    if (val[key] !== undefined) {\n      willReturn.push(val[key]);\n    }\n  }, list);\n  return willReturn;\n}\n\nfunction prepend(el, list) {\n  if (arguments.length === 1) return _list => prepend(el, _list);\n  if (typeof list === 'string') return `${el}${list}`;\n  const clone = [el].concat(list);\n  return clone;\n}\n\nfunction reduceFn(fn, acc, list) {\n  return list.reduce(fn, acc);\n}\n\nconst reduce = curry(reduceFn);\n\nconst product = reduce(multiply, 1);\n\nfunction prop(key, obj) {\n  if (arguments.length === 1) return _obj => prop(key, _obj);\n  if (!obj) return undefined;\n  return obj[key];\n}\n\nfunction propEq(key, val, obj) {\n  if (val === undefined) {\n    return (_val, _obj) => propEq(key, _val, _obj);\n  } else if (obj === undefined) {\n    return _obj => propEq(key, val, _obj);\n  }\n\n  return obj[key] === val;\n}\n\nfunction propIsFn(type, name, obj) {\n  return is(type, obj[name]);\n}\n\nconst propIs = curry(propIsFn);\n\nfunction propOr(defaultValue, p, obj) {\n  if (arguments.length === 2) return _obj => propOr(defaultValue, p, _obj);\n  if (arguments.length === 1) return (_p, _obj) => propOr(defaultValue, _p, _obj);\n  if (!obj) return defaultValue;\n  return defaultTo(defaultValue, obj[p]);\n}\n\nfunction range(from, to) {\n  if (arguments.length === 1) return _to => range(from, _to);\n  const len = to - from;\n  const willReturn = Array(len);\n\n  for (let i = 0; i < len; i++) {\n    willReturn[i] = from + i;\n  }\n\n  return willReturn;\n}\n\nfunction reject(fn, list) {\n  if (arguments.length === 1) return _list => reject(fn, _list);\n  return filter((x, i) => !fn(x, i), list);\n}\n\nfunction repeat(val, n) {\n  if (arguments.length === 1) return _n => repeat(val, _n);\n  const willReturn = Array(n);\n  return willReturn.fill(val);\n}\n\nfunction replace(pattern, replacer, str) {\n  if (replacer === undefined) {\n    return (_replacer, _str) => replace(pattern, _replacer, _str);\n  } else if (str === undefined) {\n    return _str => replace(pattern, replacer, _str);\n  }\n\n  return str.replace(pattern, replacer);\n}\n\nfunction reverse(list) {\n  const clone = list.concat();\n  return clone.reverse();\n}\n\nfunction sort(fn, list) {\n  if (arguments.length === 1) return _list => sort(fn, _list);\n  const arrClone = list.concat();\n  return arrClone.sort(fn);\n}\n\nfunction sortBy(fn, list) {\n  if (arguments.length === 1) return _list => sortBy(fn, _list);\n  const arrClone = list.concat();\n  return arrClone.sort((a, b) => {\n    const fnA = fn(a);\n    const fnB = fn(b);\n    if (fnA === fnB) return 0;\n    return fnA < fnB ? -1 : 1;\n  });\n}\n\nfunction split(separator, str) {\n  if (arguments.length === 1) return _str => split(separator, _str);\n  return str.split(separator);\n}\n\nfunction splitEvery(n, list) {\n  if (arguments.length === 1) return _list => splitEvery(n, _list);\n  const numValue = n > 1 ? n : 1;\n  const willReturn = [];\n  let counter = 0;\n\n  while (counter < list.length) {\n    willReturn.push(list.slice(counter, counter += numValue));\n  }\n\n  return willReturn;\n}\n\nfunction startsWith(prefix, list) {\n  if (arguments.length === 1) return _list => startsWith(prefix, _list);\n  return list.startsWith(prefix);\n}\n\nfunction subtract(a, b) {\n  if (arguments.length === 1) return _b => subtract(a, _b);\n  return a - b;\n}\n\nfunction symmetricDifference(list1, list2) {\n  if (arguments.length === 1) return _list => symmetricDifference(list1, _list);\n  return concat(filter(value => !includes(value, list2), list1), filter(value => !includes(value, list1), list2));\n}\n\nfunction tail(list) {\n  return drop(1, list);\n}\n\nfunction take(n, list) {\n  if (arguments.length === 1) return _list => take(n, _list);\n  if (typeof list === 'string') return list.slice(0, n);\n  return baseSlice(list, 0, n);\n}\n\nfunction takeLast(n, list) {\n  if (arguments.length === 1) return _list => takeLast(n, _list);\n  const len = list.length;\n  let numValue = n > len ? len : n;\n  if (typeof list === 'string') return list.slice(len - numValue);\n  numValue = len - numValue;\n  return baseSlice(list, numValue, len);\n}\n\nfunction tap(fn, x) {\n  if (arguments.length === 1) return _x => tap(fn, _x);\n  fn(x);\n  return x;\n}\n\nfunction test(pattern, str) {\n  if (arguments.length === 1) return _str => test(pattern, _str);\n  return str.search(pattern) !== -1;\n}\n\nfunction times(fn, n) {\n  if (arguments.length === 1) return _n => times(fn, _n);\n  return map(fn, range(0, n));\n}\n\nfunction toLower(str) {\n  return str.toLowerCase();\n}\n\nfunction toPairs(obj) {\n  return Object.entries(obj);\n}\n\nfunction toString(val) {\n  return val.toString();\n}\n\nfunction toUpper(str) {\n  return str.toUpperCase();\n}\n\nfunction trim(str) {\n  return str.trim();\n}\n\nfunction uniq(list) {\n  let index = -1;\n  const willReturn = [];\n\n  while (++index < list.length) {\n    const value = list[index];\n\n    if (!includes(value, willReturn)) {\n      willReturn.push(value);\n    }\n  }\n\n  return willReturn;\n}\n\nfunction uniqWith(fn, list) {\n  if (arguments.length === 1) return _list => uniqWith(fn, _list);\n  let index = -1;\n  const len = list.length;\n  const willReturn = [];\n\n  while (++index < len) {\n    const value = list[index];\n    const flag = any(willReturnInstance => fn(value, willReturnInstance), willReturn);\n\n    if (!flag) {\n      willReturn.push(value);\n    }\n  }\n\n  return willReturn;\n}\n\nfunction update(idx, val, list) {\n  if (val === undefined) {\n    return (_val, _list) => update(idx, _val, _list);\n  } else if (list === undefined) {\n    return _list => update(idx, val, _list);\n  }\n\n  const arrClone = list.concat();\n  return arrClone.fill(val, idx, idx + 1);\n}\n\nfunction values(obj) {\n  return Object.values(obj);\n}\n\nfunction without(left, right) {\n  if (right === undefined) {\n    return _right => without(left, _right);\n  }\n\n  return reduce((accum, item) => includes(item, left) ? accum : accum.concat(item), [], right);\n}\n\nfunction zip(left, right) {\n  if (arguments.length === 1) return _right => zip(left, _right);\n  const result = [];\n  const length = Math.min(left.length, right.length);\n\n  for (let i = 0; i < length; i++) {\n    result[i] = [left[i], right[i]];\n  }\n\n  return result;\n}\n\nfunction zipObj(keys, values) {\n  if (arguments.length === 1) return yHolder => zipObj(keys, yHolder);\n  return keys.reduce((prev, xInstance, i) => {\n    prev[xInstance] = values[i];\n    return prev;\n  }, {});\n}\n\nexport { F, T, add, adjust, all, allPass, always, any, anyPass, append, assoc, assocPath, both, clone, complement, compose, concat, curry, dec, defaultTo, difference, dissoc, divide, drop, dropLast, either, endsWith, equals, filter, find, findIndex, flatten, flip, forEach, fromPairs, groupBy, groupWith, has, head, identical, identity, ifElse, inc, includes, indexBy, indexOf, init, intersection, intersperse, is, isEmpty, isNil, join, keys, last, lastIndexOf, length, map, match, mathMod, max, maxBy, mean, median, merge, min, minBy, modulo, multiply, negate, none, not, nth, omit, partial, partialCurry, path, pathOr, pick, pickAll, pipe, pluck, prepend, product, prop, propEq, propIs, propOr, range, reduce, reject, repeat, replace, reverse, sort, sortBy, split, splitEvery, startsWith, subtract, sum, symmetricDifference, tail, take, takeLast, tap, test, times, toLower, toPairs, toString, toUpper, trim, type, uniq, uniqWith, update, values, without, zip, zipObj };\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport function isFunction(x) {\n    return typeof x === 'function';\n}\n//# sourceMappingURL=isFunction.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nvar _enable_super_gross_mode_that_will_cause_bad_things = false;\nexport var config = {\n    Promise: undefined,\n    set useDeprecatedSynchronousErrorHandling(value) {\n        if (value) {\n            var error = /*@__PURE__*/ new Error();\n            /*@__PURE__*/ console.warn('DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \\n' + error.stack);\n        }\n        else if (_enable_super_gross_mode_that_will_cause_bad_things) {\n            /*@__PURE__*/ console.log('RxJS: Back to a better error behavior. Thank you. <3');\n        }\n        _enable_super_gross_mode_that_will_cause_bad_things = value;\n    },\n    get useDeprecatedSynchronousErrorHandling() {\n        return _enable_super_gross_mode_that_will_cause_bad_things;\n    },\n};\n//# sourceMappingURL=config.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport function hostReportError(err) {\n    setTimeout(function () { throw err; }, 0);\n}\n//# sourceMappingURL=hostReportError.js.map\n","/** PURE_IMPORTS_START _config,_util_hostReportError PURE_IMPORTS_END */\nimport { config } from './config';\nimport { hostReportError } from './util/hostReportError';\nexport var empty = {\n    closed: true,\n    next: function (value) { },\n    error: function (err) {\n        if (config.useDeprecatedSynchronousErrorHandling) {\n            throw err;\n        }\n        else {\n            hostReportError(err);\n        }\n    },\n    complete: function () { }\n};\n//# sourceMappingURL=Observer.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport var isArray = /*@__PURE__*/ (function () { return Array.isArray || (function (x) { return x && typeof x.length === 'number'; }); })();\n//# sourceMappingURL=isArray.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport function isObject(x) {\n    return x !== null && typeof x === 'object';\n}\n//# sourceMappingURL=isObject.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nvar UnsubscriptionErrorImpl = /*@__PURE__*/ (function () {\n    function UnsubscriptionErrorImpl(errors) {\n        Error.call(this);\n        this.message = errors ?\n            errors.length + \" errors occurred during unsubscription:\\n\" + errors.map(function (err, i) { return i + 1 + \") \" + err.toString(); }).join('\\n  ') : '';\n        this.name = 'UnsubscriptionError';\n        this.errors = errors;\n        return this;\n    }\n    UnsubscriptionErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype);\n    return UnsubscriptionErrorImpl;\n})();\nexport var UnsubscriptionError = UnsubscriptionErrorImpl;\n//# sourceMappingURL=UnsubscriptionError.js.map\n","/** PURE_IMPORTS_START _util_isArray,_util_isObject,_util_isFunction,_util_UnsubscriptionError PURE_IMPORTS_END */\nimport { isArray } from './util/isArray';\nimport { isObject } from './util/isObject';\nimport { isFunction } from './util/isFunction';\nimport { UnsubscriptionError } from './util/UnsubscriptionError';\nvar Subscription = /*@__PURE__*/ (function () {\n    function Subscription(unsubscribe) {\n        this.closed = false;\n        this._parentOrParents = null;\n        this._subscriptions = null;\n        if (unsubscribe) {\n            this._unsubscribe = unsubscribe;\n        }\n    }\n    Subscription.prototype.unsubscribe = function () {\n        var errors;\n        if (this.closed) {\n            return;\n        }\n        var _a = this, _parentOrParents = _a._parentOrParents, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;\n        this.closed = true;\n        this._parentOrParents = null;\n        this._subscriptions = null;\n        if (_parentOrParents instanceof Subscription) {\n            _parentOrParents.remove(this);\n        }\n        else if (_parentOrParents !== null) {\n            for (var index = 0; index < _parentOrParents.length; ++index) {\n                var parent_1 = _parentOrParents[index];\n                parent_1.remove(this);\n            }\n        }\n        if (isFunction(_unsubscribe)) {\n            try {\n                _unsubscribe.call(this);\n            }\n            catch (e) {\n                errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];\n            }\n        }\n        if (isArray(_subscriptions)) {\n            var index = -1;\n            var len = _subscriptions.length;\n            while (++index < len) {\n                var sub = _subscriptions[index];\n                if (isObject(sub)) {\n                    try {\n                        sub.unsubscribe();\n                    }\n                    catch (e) {\n                        errors = errors || [];\n                        if (e instanceof UnsubscriptionError) {\n                            errors = errors.concat(flattenUnsubscriptionErrors(e.errors));\n                        }\n                        else {\n                            errors.push(e);\n                        }\n                    }\n                }\n            }\n        }\n        if (errors) {\n            throw new UnsubscriptionError(errors);\n        }\n    };\n    Subscription.prototype.add = function (teardown) {\n        var subscription = teardown;\n        if (!teardown) {\n            return Subscription.EMPTY;\n        }\n        switch (typeof teardown) {\n            case 'function':\n                subscription = new Subscription(teardown);\n            case 'object':\n                if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {\n                    return subscription;\n                }\n                else if (this.closed) {\n                    subscription.unsubscribe();\n                    return subscription;\n                }\n                else if (!(subscription instanceof Subscription)) {\n                    var tmp = subscription;\n                    subscription = new Subscription();\n                    subscription._subscriptions = [tmp];\n                }\n                break;\n            default: {\n                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');\n            }\n        }\n        var _parentOrParents = subscription._parentOrParents;\n        if (_parentOrParents === null) {\n            subscription._parentOrParents = this;\n        }\n        else if (_parentOrParents instanceof Subscription) {\n            if (_parentOrParents === this) {\n                return subscription;\n            }\n            subscription._parentOrParents = [_parentOrParents, this];\n        }\n        else if (_parentOrParents.indexOf(this) === -1) {\n            _parentOrParents.push(this);\n        }\n        else {\n            return subscription;\n        }\n        var subscriptions = this._subscriptions;\n        if (subscriptions === null) {\n            this._subscriptions = [subscription];\n        }\n        else {\n            subscriptions.push(subscription);\n        }\n        return subscription;\n    };\n    Subscription.prototype.remove = function (subscription) {\n        var subscriptions = this._subscriptions;\n        if (subscriptions) {\n            var subscriptionIndex = subscriptions.indexOf(subscription);\n            if (subscriptionIndex !== -1) {\n                subscriptions.splice(subscriptionIndex, 1);\n            }\n        }\n    };\n    Subscription.EMPTY = (function (empty) {\n        empty.closed = true;\n        return empty;\n    }(new Subscription()));\n    return Subscription;\n}());\nexport { Subscription };\nfunction flattenUnsubscriptionErrors(errors) {\n    return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError) ? err.errors : err); }, []);\n}\n//# sourceMappingURL=Subscription.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport var rxSubscriber = /*@__PURE__*/ (function () {\n    return typeof Symbol === 'function'\n        ? /*@__PURE__*/ Symbol('rxSubscriber')\n        : '@@rxSubscriber_' + /*@__PURE__*/ Math.random();\n})();\nexport var $$rxSubscriber = rxSubscriber;\n//# sourceMappingURL=rxSubscriber.js.map\n","/** PURE_IMPORTS_START tslib,_util_isFunction,_Observer,_Subscription,_internal_symbol_rxSubscriber,_config,_util_hostReportError PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { isFunction } from './util/isFunction';\nimport { empty as emptyObserver } from './Observer';\nimport { Subscription } from './Subscription';\nimport { rxSubscriber as rxSubscriberSymbol } from '../internal/symbol/rxSubscriber';\nimport { config } from './config';\nimport { hostReportError } from './util/hostReportError';\nvar Subscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(Subscriber, _super);\n    function Subscriber(destinationOrNext, error, complete) {\n        var _this = _super.call(this) || this;\n        _this.syncErrorValue = null;\n        _this.syncErrorThrown = false;\n        _this.syncErrorThrowable = false;\n        _this.isStopped = false;\n        switch (arguments.length) {\n            case 0:\n                _this.destination = emptyObserver;\n                break;\n            case 1:\n                if (!destinationOrNext) {\n                    _this.destination = emptyObserver;\n                    break;\n                }\n                if (typeof destinationOrNext === 'object') {\n                    if (destinationOrNext instanceof Subscriber) {\n                        _this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;\n                        _this.destination = destinationOrNext;\n                        destinationOrNext.add(_this);\n                    }\n                    else {\n                        _this.syncErrorThrowable = true;\n                        _this.destination = new SafeSubscriber(_this, destinationOrNext);\n                    }\n                    break;\n                }\n            default:\n                _this.syncErrorThrowable = true;\n                _this.destination = new SafeSubscriber(_this, destinationOrNext, error, complete);\n                break;\n        }\n        return _this;\n    }\n    Subscriber.prototype[rxSubscriberSymbol] = function () { return this; };\n    Subscriber.create = function (next, error, complete) {\n        var subscriber = new Subscriber(next, error, complete);\n        subscriber.syncErrorThrowable = false;\n        return subscriber;\n    };\n    Subscriber.prototype.next = function (value) {\n        if (!this.isStopped) {\n            this._next(value);\n        }\n    };\n    Subscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._error(err);\n        }\n    };\n    Subscriber.prototype.complete = function () {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._complete();\n        }\n    };\n    Subscriber.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.isStopped = true;\n        _super.prototype.unsubscribe.call(this);\n    };\n    Subscriber.prototype._next = function (value) {\n        this.destination.next(value);\n    };\n    Subscriber.prototype._error = function (err) {\n        this.destination.error(err);\n        this.unsubscribe();\n    };\n    Subscriber.prototype._complete = function () {\n        this.destination.complete();\n        this.unsubscribe();\n    };\n    Subscriber.prototype._unsubscribeAndRecycle = function () {\n        var _parentOrParents = this._parentOrParents;\n        this._parentOrParents = null;\n        this.unsubscribe();\n        this.closed = false;\n        this.isStopped = false;\n        this._parentOrParents = _parentOrParents;\n        return this;\n    };\n    return Subscriber;\n}(Subscription));\nexport { Subscriber };\nvar SafeSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(SafeSubscriber, _super);\n    function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {\n        var _this = _super.call(this) || this;\n        _this._parentSubscriber = _parentSubscriber;\n        var next;\n        var context = _this;\n        if (isFunction(observerOrNext)) {\n            next = observerOrNext;\n        }\n        else if (observerOrNext) {\n            next = observerOrNext.next;\n            error = observerOrNext.error;\n            complete = observerOrNext.complete;\n            if (observerOrNext !== emptyObserver) {\n                context = Object.create(observerOrNext);\n                if (isFunction(context.unsubscribe)) {\n                    _this.add(context.unsubscribe.bind(context));\n                }\n                context.unsubscribe = _this.unsubscribe.bind(_this);\n            }\n        }\n        _this._context = context;\n        _this._next = next;\n        _this._error = error;\n        _this._complete = complete;\n        return _this;\n    }\n    SafeSubscriber.prototype.next = function (value) {\n        if (!this.isStopped && this._next) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n                this.__tryOrUnsub(this._next, value);\n            }\n            else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            var useDeprecatedSynchronousErrorHandling = config.useDeprecatedSynchronousErrorHandling;\n            if (this._error) {\n                if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(this._error, err);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, this._error, err);\n                    this.unsubscribe();\n                }\n            }\n            else if (!_parentSubscriber.syncErrorThrowable) {\n                this.unsubscribe();\n                if (useDeprecatedSynchronousErrorHandling) {\n                    throw err;\n                }\n                hostReportError(err);\n            }\n            else {\n                if (useDeprecatedSynchronousErrorHandling) {\n                    _parentSubscriber.syncErrorValue = err;\n                    _parentSubscriber.syncErrorThrown = true;\n                }\n                else {\n                    hostReportError(err);\n                }\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.complete = function () {\n        var _this = this;\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._complete) {\n                var wrappedComplete = function () { return _this._complete.call(_this._context); };\n                if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(wrappedComplete);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, wrappedComplete);\n                    this.unsubscribe();\n                }\n            }\n            else {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            this.unsubscribe();\n            if (config.useDeprecatedSynchronousErrorHandling) {\n                throw err;\n            }\n            else {\n                hostReportError(err);\n            }\n        }\n    };\n    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {\n        if (!config.useDeprecatedSynchronousErrorHandling) {\n            throw new Error('bad call');\n        }\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            if (config.useDeprecatedSynchronousErrorHandling) {\n                parent.syncErrorValue = err;\n                parent.syncErrorThrown = true;\n                return true;\n            }\n            else {\n                hostReportError(err);\n                return true;\n            }\n        }\n        return false;\n    };\n    SafeSubscriber.prototype._unsubscribe = function () {\n        var _parentSubscriber = this._parentSubscriber;\n        this._context = null;\n        this._parentSubscriber = null;\n        _parentSubscriber.unsubscribe();\n    };\n    return SafeSubscriber;\n}(Subscriber));\nexport { SafeSubscriber };\n//# sourceMappingURL=Subscriber.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport var observable = /*@__PURE__*/ (function () { return typeof Symbol === 'function' && Symbol.observable || '@@observable'; })();\n//# sourceMappingURL=observable.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport function noop() { }\n//# sourceMappingURL=noop.js.map\n","/** PURE_IMPORTS_START _noop PURE_IMPORTS_END */\nimport { noop } from './noop';\nexport function pipe() {\n    var fns = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        fns[_i] = arguments[_i];\n    }\n    return pipeFromArray(fns);\n}\nexport function pipeFromArray(fns) {\n    if (!fns) {\n        return noop;\n    }\n    if (fns.length === 1) {\n        return fns[0];\n    }\n    return function piped(input) {\n        return fns.reduce(function (prev, fn) { return fn(prev); }, input);\n    };\n}\n//# sourceMappingURL=pipe.js.map\n","/** PURE_IMPORTS_START _util_canReportError,_util_toSubscriber,_symbol_observable,_util_pipe,_config PURE_IMPORTS_END */\nimport { canReportError } from './util/canReportError';\nimport { toSubscriber } from './util/toSubscriber';\nimport { observable as Symbol_observable } from './symbol/observable';\nimport { pipeFromArray } from './util/pipe';\nimport { config } from './config';\nvar Observable = /*@__PURE__*/ (function () {\n    function Observable(subscribe) {\n        this._isScalar = false;\n        if (subscribe) {\n            this._subscribe = subscribe;\n        }\n    }\n    Observable.prototype.lift = function (operator) {\n        var observable = new Observable();\n        observable.source = this;\n        observable.operator = operator;\n        return observable;\n    };\n    Observable.prototype.subscribe = function (observerOrNext, error, complete) {\n        var operator = this.operator;\n        var sink = toSubscriber(observerOrNext, error, complete);\n        if (operator) {\n            sink.add(operator.call(sink, this.source));\n        }\n        else {\n            sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?\n                this._subscribe(sink) :\n                this._trySubscribe(sink));\n        }\n        if (config.useDeprecatedSynchronousErrorHandling) {\n            if (sink.syncErrorThrowable) {\n                sink.syncErrorThrowable = false;\n                if (sink.syncErrorThrown) {\n                    throw sink.syncErrorValue;\n                }\n            }\n        }\n        return sink;\n    };\n    Observable.prototype._trySubscribe = function (sink) {\n        try {\n            return this._subscribe(sink);\n        }\n        catch (err) {\n            if (config.useDeprecatedSynchronousErrorHandling) {\n                sink.syncErrorThrown = true;\n                sink.syncErrorValue = err;\n            }\n            if (canReportError(sink)) {\n                sink.error(err);\n            }\n            else {\n                console.warn(err);\n            }\n        }\n    };\n    Observable.prototype.forEach = function (next, promiseCtor) {\n        var _this = this;\n        promiseCtor = getPromiseCtor(promiseCtor);\n        return new promiseCtor(function (resolve, reject) {\n            var subscription;\n            subscription = _this.subscribe(function (value) {\n                try {\n                    next(value);\n                }\n                catch (err) {\n                    reject(err);\n                    if (subscription) {\n                        subscription.unsubscribe();\n                    }\n                }\n            }, reject, resolve);\n        });\n    };\n    Observable.prototype._subscribe = function (subscriber) {\n        var source = this.source;\n        return source && source.subscribe(subscriber);\n    };\n    Observable.prototype[Symbol_observable] = function () {\n        return this;\n    };\n    Observable.prototype.pipe = function () {\n        var operations = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            operations[_i] = arguments[_i];\n        }\n        if (operations.length === 0) {\n            return this;\n        }\n        return pipeFromArray(operations)(this);\n    };\n    Observable.prototype.toPromise = function (promiseCtor) {\n        var _this = this;\n        promiseCtor = getPromiseCtor(promiseCtor);\n        return new promiseCtor(function (resolve, reject) {\n            var value;\n            _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });\n        });\n    };\n    Observable.create = function (subscribe) {\n        return new Observable(subscribe);\n    };\n    return Observable;\n}());\nexport { Observable };\nfunction getPromiseCtor(promiseCtor) {\n    if (!promiseCtor) {\n        promiseCtor = config.Promise || Promise;\n    }\n    if (!promiseCtor) {\n        throw new Error('no Promise impl found');\n    }\n    return promiseCtor;\n}\n//# sourceMappingURL=Observable.js.map\n","/** PURE_IMPORTS_START _Subscriber,_symbol_rxSubscriber,_Observer PURE_IMPORTS_END */\nimport { Subscriber } from '../Subscriber';\nimport { rxSubscriber as rxSubscriberSymbol } from '../symbol/rxSubscriber';\nimport { empty as emptyObserver } from '../Observer';\nexport function toSubscriber(nextOrObserver, error, complete) {\n    if (nextOrObserver) {\n        if (nextOrObserver instanceof Subscriber) {\n            return nextOrObserver;\n        }\n        if (nextOrObserver[rxSubscriberSymbol]) {\n            return nextOrObserver[rxSubscriberSymbol]();\n        }\n    }\n    if (!nextOrObserver && !error && !complete) {\n        return new Subscriber(emptyObserver);\n    }\n    return new Subscriber(nextOrObserver, error, complete);\n}\n//# sourceMappingURL=toSubscriber.js.map\n","/** PURE_IMPORTS_START _Subscriber PURE_IMPORTS_END */\nimport { Subscriber } from '../Subscriber';\nexport function canReportError(observer) {\n    while (observer) {\n        var _a = observer, closed_1 = _a.closed, destination = _a.destination, isStopped = _a.isStopped;\n        if (closed_1 || isStopped) {\n            return false;\n        }\n        else if (destination && destination instanceof Subscriber) {\n            observer = destination;\n        }\n        else {\n            observer = null;\n        }\n    }\n    return true;\n}\n//# sourceMappingURL=canReportError.js.map\n","/** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { Subscriber } from '../Subscriber';\nexport function map(project, thisArg) {\n    return function mapOperation(source) {\n        if (typeof project !== 'function') {\n            throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');\n        }\n        return source.lift(new MapOperator(project, thisArg));\n    };\n}\nvar MapOperator = /*@__PURE__*/ (function () {\n    function MapOperator(project, thisArg) {\n        this.project = project;\n        this.thisArg = thisArg;\n    }\n    MapOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));\n    };\n    return MapOperator;\n}());\nexport { MapOperator };\nvar MapSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(MapSubscriber, _super);\n    function MapSubscriber(destination, project, thisArg) {\n        var _this = _super.call(this, destination) || this;\n        _this.project = project;\n        _this.count = 0;\n        _this.thisArg = thisArg || _this;\n        return _this;\n    }\n    MapSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.project.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return MapSubscriber;\n}(Subscriber));\n//# sourceMappingURL=map.js.map\n","/** PURE_IMPORTS_START _Observable,_util_isArray,_util_isFunction,_operators_map PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { isArray } from '../util/isArray';\nimport { isFunction } from '../util/isFunction';\nimport { map } from '../operators/map';\nvar toString = /*@__PURE__*/ (function () { return Object.prototype.toString; })();\nexport function fromEvent(target, eventName, options, resultSelector) {\n    if (isFunction(options)) {\n        resultSelector = options;\n        options = undefined;\n    }\n    if (resultSelector) {\n        return fromEvent(target, eventName, options).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); }));\n    }\n    return new Observable(function (subscriber) {\n        function handler(e) {\n            if (arguments.length > 1) {\n                subscriber.next(Array.prototype.slice.call(arguments));\n            }\n            else {\n                subscriber.next(e);\n            }\n        }\n        setupSubscription(target, eventName, handler, subscriber, options);\n    });\n}\nfunction setupSubscription(sourceObj, eventName, handler, subscriber, options) {\n    var unsubscribe;\n    if (isEventTarget(sourceObj)) {\n        var source_1 = sourceObj;\n        sourceObj.addEventListener(eventName, handler, options);\n        unsubscribe = function () { return source_1.removeEventListener(eventName, handler, options); };\n    }\n    else if (isJQueryStyleEventEmitter(sourceObj)) {\n        var source_2 = sourceObj;\n        sourceObj.on(eventName, handler);\n        unsubscribe = function () { return source_2.off(eventName, handler); };\n    }\n    else if (isNodeStyleEventEmitter(sourceObj)) {\n        var source_3 = sourceObj;\n        sourceObj.addListener(eventName, handler);\n        unsubscribe = function () { return source_3.removeListener(eventName, handler); };\n    }\n    else if (sourceObj && sourceObj.length) {\n        for (var i = 0, len = sourceObj.length; i < len; i++) {\n            setupSubscription(sourceObj[i], eventName, handler, subscriber, options);\n        }\n    }\n    else {\n        throw new TypeError('Invalid event target');\n    }\n    subscriber.add(unsubscribe);\n}\nfunction isNodeStyleEventEmitter(sourceObj) {\n    return sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function';\n}\nfunction isJQueryStyleEventEmitter(sourceObj) {\n    return sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function';\n}\nfunction isEventTarget(sourceObj) {\n    return sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function';\n}\n//# sourceMappingURL=fromEvent.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport function isScheduler(value) {\n    return value && typeof value.schedule === 'function';\n}\n//# sourceMappingURL=isScheduler.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport var subscribeToArray = function (array) {\n    return function (subscriber) {\n        for (var i = 0, len = array.length; i < len && !subscriber.closed; i++) {\n            subscriber.next(array[i]);\n        }\n        subscriber.complete();\n    };\n};\n//# sourceMappingURL=subscribeToArray.js.map\n","/** PURE_IMPORTS_START _Observable,_Subscription PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nexport function scheduleArray(input, scheduler) {\n    return new Observable(function (subscriber) {\n        var sub = new Subscription();\n        var i = 0;\n        sub.add(scheduler.schedule(function () {\n            if (i === input.length) {\n                subscriber.complete();\n                return;\n            }\n            subscriber.next(input[i++]);\n            if (!subscriber.closed) {\n                sub.add(this.schedule());\n            }\n        }));\n        return sub;\n    });\n}\n//# sourceMappingURL=scheduleArray.js.map\n","/** PURE_IMPORTS_START _Observable,_util_subscribeToArray,_scheduled_scheduleArray PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { subscribeToArray } from '../util/subscribeToArray';\nimport { scheduleArray } from '../scheduled/scheduleArray';\nexport function fromArray(input, scheduler) {\n    if (!scheduler) {\n        return new Observable(subscribeToArray(input));\n    }\n    else {\n        return scheduleArray(input, scheduler);\n    }\n}\n//# sourceMappingURL=fromArray.js.map\n","/** PURE_IMPORTS_START _util_isScheduler,_fromArray,_scheduled_scheduleArray PURE_IMPORTS_END */\nimport { isScheduler } from '../util/isScheduler';\nimport { fromArray } from './fromArray';\nimport { scheduleArray } from '../scheduled/scheduleArray';\nexport function of() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var scheduler = args[args.length - 1];\n    if (isScheduler(scheduler)) {\n        args.pop();\n        return scheduleArray(args, scheduler);\n    }\n    else {\n        return fromArray(args);\n    }\n}\n//# sourceMappingURL=of.js.map\n","/** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { Subscriber } from './Subscriber';\nvar OuterSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(OuterSubscriber, _super);\n    function OuterSubscriber() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.destination.next(innerValue);\n    };\n    OuterSubscriber.prototype.notifyError = function (error, innerSub) {\n        this.destination.error(error);\n    };\n    OuterSubscriber.prototype.notifyComplete = function (innerSub) {\n        this.destination.complete();\n    };\n    return OuterSubscriber;\n}(Subscriber));\nexport { OuterSubscriber };\n//# sourceMappingURL=OuterSubscriber.js.map\n","/** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { Subscriber } from './Subscriber';\nvar InnerSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(InnerSubscriber, _super);\n    function InnerSubscriber(parent, outerValue, outerIndex) {\n        var _this = _super.call(this) || this;\n        _this.parent = parent;\n        _this.outerValue = outerValue;\n        _this.outerIndex = outerIndex;\n        _this.index = 0;\n        return _this;\n    }\n    InnerSubscriber.prototype._next = function (value) {\n        this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this);\n    };\n    InnerSubscriber.prototype._error = function (error) {\n        this.parent.notifyError(error, this);\n        this.unsubscribe();\n    };\n    InnerSubscriber.prototype._complete = function () {\n        this.parent.notifyComplete(this);\n        this.unsubscribe();\n    };\n    return InnerSubscriber;\n}(Subscriber));\nexport { InnerSubscriber };\n//# sourceMappingURL=InnerSubscriber.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport function getSymbolIterator() {\n    if (typeof Symbol !== 'function' || !Symbol.iterator) {\n        return '@@iterator';\n    }\n    return Symbol.iterator;\n}\nexport var iterator = /*@__PURE__*/ getSymbolIterator();\nexport var $$iterator = iterator;\n//# sourceMappingURL=iterator.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });\n//# sourceMappingURL=isArrayLike.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport function isPromise(value) {\n    return !!value && typeof value.subscribe !== 'function' && typeof value.then === 'function';\n}\n//# sourceMappingURL=isPromise.js.map\n","/** PURE_IMPORTS_START _subscribeToArray,_subscribeToPromise,_subscribeToIterable,_subscribeToObservable,_isArrayLike,_isPromise,_isObject,_symbol_iterator,_symbol_observable PURE_IMPORTS_END */\nimport { subscribeToArray } from './subscribeToArray';\nimport { subscribeToPromise } from './subscribeToPromise';\nimport { subscribeToIterable } from './subscribeToIterable';\nimport { subscribeToObservable } from './subscribeToObservable';\nimport { isArrayLike } from './isArrayLike';\nimport { isPromise } from './isPromise';\nimport { isObject } from './isObject';\nimport { iterator as Symbol_iterator } from '../symbol/iterator';\nimport { observable as Symbol_observable } from '../symbol/observable';\nexport var subscribeTo = function (result) {\n    if (!!result && typeof result[Symbol_observable] === 'function') {\n        return subscribeToObservable(result);\n    }\n    else if (isArrayLike(result)) {\n        return subscribeToArray(result);\n    }\n    else if (isPromise(result)) {\n        return subscribeToPromise(result);\n    }\n    else if (!!result && typeof result[Symbol_iterator] === 'function') {\n        return subscribeToIterable(result);\n    }\n    else {\n        var value = isObject(result) ? 'an invalid object' : \"'\" + result + \"'\";\n        var msg = \"You provided \" + value + \" where a stream was expected.\"\n            + ' You can provide an Observable, Promise, Array, or Iterable.';\n        throw new TypeError(msg);\n    }\n};\n//# sourceMappingURL=subscribeTo.js.map\n","/** PURE_IMPORTS_START _symbol_observable PURE_IMPORTS_END */\nimport { observable as Symbol_observable } from '../symbol/observable';\nexport var subscribeToObservable = function (obj) {\n    return function (subscriber) {\n        var obs = obj[Symbol_observable]();\n        if (typeof obs.subscribe !== 'function') {\n            throw new TypeError('Provided object does not correctly implement Symbol.observable');\n        }\n        else {\n            return obs.subscribe(subscriber);\n        }\n    };\n};\n//# sourceMappingURL=subscribeToObservable.js.map\n","/** PURE_IMPORTS_START _hostReportError PURE_IMPORTS_END */\nimport { hostReportError } from './hostReportError';\nexport var subscribeToPromise = function (promise) {\n    return function (subscriber) {\n        promise.then(function (value) {\n            if (!subscriber.closed) {\n                subscriber.next(value);\n                subscriber.complete();\n            }\n        }, function (err) { return subscriber.error(err); })\n            .then(null, hostReportError);\n        return subscriber;\n    };\n};\n//# sourceMappingURL=subscribeToPromise.js.map\n","/** PURE_IMPORTS_START _symbol_iterator PURE_IMPORTS_END */\nimport { iterator as Symbol_iterator } from '../symbol/iterator';\nexport var subscribeToIterable = function (iterable) {\n    return function (subscriber) {\n        var iterator = iterable[Symbol_iterator]();\n        do {\n            var item = iterator.next();\n            if (item.done) {\n                subscriber.complete();\n                break;\n            }\n            subscriber.next(item.value);\n            if (subscriber.closed) {\n                break;\n            }\n        } while (true);\n        if (typeof iterator.return === 'function') {\n            subscriber.add(function () {\n                if (iterator.return) {\n                    iterator.return();\n                }\n            });\n        }\n        return subscriber;\n    };\n};\n//# sourceMappingURL=subscribeToIterable.js.map\n","/** PURE_IMPORTS_START _InnerSubscriber,_subscribeTo,_Observable PURE_IMPORTS_END */\nimport { InnerSubscriber } from '../InnerSubscriber';\nimport { subscribeTo } from './subscribeTo';\nimport { Observable } from '../Observable';\nexport function subscribeToResult(outerSubscriber, result, outerValue, outerIndex, destination) {\n    if (destination === void 0) {\n        destination = new InnerSubscriber(outerSubscriber, outerValue, outerIndex);\n    }\n    if (destination.closed) {\n        return undefined;\n    }\n    if (result instanceof Observable) {\n        return result.subscribe(destination);\n    }\n    return subscribeTo(result)(destination);\n}\n//# sourceMappingURL=subscribeToResult.js.map\n","/** PURE_IMPORTS_START tslib,_util_isScheduler,_util_isArray,_OuterSubscriber,_util_subscribeToResult,_fromArray PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { isScheduler } from '../util/isScheduler';\nimport { isArray } from '../util/isArray';\nimport { OuterSubscriber } from '../OuterSubscriber';\nimport { subscribeToResult } from '../util/subscribeToResult';\nimport { fromArray } from './fromArray';\nvar NONE = {};\nexport function combineLatest() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i] = arguments[_i];\n    }\n    var resultSelector = null;\n    var scheduler = null;\n    if (isScheduler(observables[observables.length - 1])) {\n        scheduler = observables.pop();\n    }\n    if (typeof observables[observables.length - 1] === 'function') {\n        resultSelector = observables.pop();\n    }\n    if (observables.length === 1 && isArray(observables[0])) {\n        observables = observables[0];\n    }\n    return fromArray(observables, scheduler).lift(new CombineLatestOperator(resultSelector));\n}\nvar CombineLatestOperator = /*@__PURE__*/ (function () {\n    function CombineLatestOperator(resultSelector) {\n        this.resultSelector = resultSelector;\n    }\n    CombineLatestOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new CombineLatestSubscriber(subscriber, this.resultSelector));\n    };\n    return CombineLatestOperator;\n}());\nexport { CombineLatestOperator };\nvar CombineLatestSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(CombineLatestSubscriber, _super);\n    function CombineLatestSubscriber(destination, resultSelector) {\n        var _this = _super.call(this, destination) || this;\n        _this.resultSelector = resultSelector;\n        _this.active = 0;\n        _this.values = [];\n        _this.observables = [];\n        return _this;\n    }\n    CombineLatestSubscriber.prototype._next = function (observable) {\n        this.values.push(NONE);\n        this.observables.push(observable);\n    };\n    CombineLatestSubscriber.prototype._complete = function () {\n        var observables = this.observables;\n        var len = observables.length;\n        if (len === 0) {\n            this.destination.complete();\n        }\n        else {\n            this.active = len;\n            this.toRespond = len;\n            for (var i = 0; i < len; i++) {\n                var observable = observables[i];\n                this.add(subscribeToResult(this, observable, observable, i));\n            }\n        }\n    };\n    CombineLatestSubscriber.prototype.notifyComplete = function (unused) {\n        if ((this.active -= 1) === 0) {\n            this.destination.complete();\n        }\n    };\n    CombineLatestSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        var values = this.values;\n        var oldVal = values[outerIndex];\n        var toRespond = !this.toRespond\n            ? 0\n            : oldVal === NONE ? --this.toRespond : this.toRespond;\n        values[outerIndex] = innerValue;\n        if (toRespond === 0) {\n            if (this.resultSelector) {\n                this._tryResultSelector(values);\n            }\n            else {\n                this.destination.next(values.slice());\n            }\n        }\n    };\n    CombineLatestSubscriber.prototype._tryResultSelector = function (values) {\n        var result;\n        try {\n            result = this.resultSelector.apply(this, values);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.destination.next(result);\n    };\n    return CombineLatestSubscriber;\n}(OuterSubscriber));\nexport { CombineLatestSubscriber };\n//# sourceMappingURL=combineLatest.js.map\n","/** PURE_IMPORTS_START _scheduleObservable,_schedulePromise,_scheduleArray,_scheduleIterable,_util_isInteropObservable,_util_isPromise,_util_isArrayLike,_util_isIterable PURE_IMPORTS_END */\nimport { scheduleObservable } from './scheduleObservable';\nimport { schedulePromise } from './schedulePromise';\nimport { scheduleArray } from './scheduleArray';\nimport { scheduleIterable } from './scheduleIterable';\nimport { isInteropObservable } from '../util/isInteropObservable';\nimport { isPromise } from '../util/isPromise';\nimport { isArrayLike } from '../util/isArrayLike';\nimport { isIterable } from '../util/isIterable';\nexport function scheduled(input, scheduler) {\n    if (input != null) {\n        if (isInteropObservable(input)) {\n            return scheduleObservable(input, scheduler);\n        }\n        else if (isPromise(input)) {\n            return schedulePromise(input, scheduler);\n        }\n        else if (isArrayLike(input)) {\n            return scheduleArray(input, scheduler);\n        }\n        else if (isIterable(input) || typeof input === 'string') {\n            return scheduleIterable(input, scheduler);\n        }\n    }\n    throw new TypeError((input !== null && typeof input || input) + ' is not observable');\n}\n//# sourceMappingURL=scheduled.js.map\n","/** PURE_IMPORTS_START _symbol_observable PURE_IMPORTS_END */\nimport { observable as Symbol_observable } from '../symbol/observable';\nexport function isInteropObservable(input) {\n    return input && typeof input[Symbol_observable] === 'function';\n}\n//# sourceMappingURL=isInteropObservable.js.map\n","/** PURE_IMPORTS_START _Observable,_Subscription,_symbol_observable PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nimport { observable as Symbol_observable } from '../symbol/observable';\nexport function scheduleObservable(input, scheduler) {\n    return new Observable(function (subscriber) {\n        var sub = new Subscription();\n        sub.add(scheduler.schedule(function () {\n            var observable = input[Symbol_observable]();\n            sub.add(observable.subscribe({\n                next: function (value) { sub.add(scheduler.schedule(function () { return subscriber.next(value); })); },\n                error: function (err) { sub.add(scheduler.schedule(function () { return subscriber.error(err); })); },\n                complete: function () { sub.add(scheduler.schedule(function () { return subscriber.complete(); })); },\n            }));\n        }));\n        return sub;\n    });\n}\n//# sourceMappingURL=scheduleObservable.js.map\n","/** PURE_IMPORTS_START _Observable,_Subscription PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nexport function schedulePromise(input, scheduler) {\n    return new Observable(function (subscriber) {\n        var sub = new Subscription();\n        sub.add(scheduler.schedule(function () {\n            return input.then(function (value) {\n                sub.add(scheduler.schedule(function () {\n                    subscriber.next(value);\n                    sub.add(scheduler.schedule(function () { return subscriber.complete(); }));\n                }));\n            }, function (err) {\n                sub.add(scheduler.schedule(function () { return subscriber.error(err); }));\n            });\n        }));\n        return sub;\n    });\n}\n//# sourceMappingURL=schedulePromise.js.map\n","/** PURE_IMPORTS_START _symbol_iterator PURE_IMPORTS_END */\nimport { iterator as Symbol_iterator } from '../symbol/iterator';\nexport function isIterable(input) {\n    return input && typeof input[Symbol_iterator] === 'function';\n}\n//# sourceMappingURL=isIterable.js.map\n","/** PURE_IMPORTS_START _Observable,_Subscription,_symbol_iterator PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nimport { iterator as Symbol_iterator } from '../symbol/iterator';\nexport function scheduleIterable(input, scheduler) {\n    if (!input) {\n        throw new Error('Iterable cannot be null');\n    }\n    return new Observable(function (subscriber) {\n        var sub = new Subscription();\n        var iterator;\n        sub.add(function () {\n            if (iterator && typeof iterator.return === 'function') {\n                iterator.return();\n            }\n        });\n        sub.add(scheduler.schedule(function () {\n            iterator = input[Symbol_iterator]();\n            sub.add(scheduler.schedule(function () {\n                if (subscriber.closed) {\n                    return;\n                }\n                var value;\n                var done;\n                try {\n                    var result = iterator.next();\n                    value = result.value;\n                    done = result.done;\n                }\n                catch (err) {\n                    subscriber.error(err);\n                    return;\n                }\n                if (done) {\n                    subscriber.complete();\n                }\n                else {\n                    subscriber.next(value);\n                    this.schedule();\n                }\n            }));\n        }));\n        return sub;\n    });\n}\n//# sourceMappingURL=scheduleIterable.js.map\n","/** PURE_IMPORTS_START _Observable,_util_subscribeTo,_scheduled_scheduled PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { subscribeTo } from '../util/subscribeTo';\nimport { scheduled } from '../scheduled/scheduled';\nexport function from(input, scheduler) {\n    if (!scheduler) {\n        if (input instanceof Observable) {\n            return input;\n        }\n        return new Observable(subscribeTo(input));\n    }\n    else {\n        return scheduled(input, scheduler);\n    }\n}\n//# sourceMappingURL=from.js.map\n","/** PURE_IMPORTS_START tslib,_util_subscribeToResult,_OuterSubscriber,_InnerSubscriber,_map,_observable_from PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { subscribeToResult } from '../util/subscribeToResult';\nimport { OuterSubscriber } from '../OuterSubscriber';\nimport { InnerSubscriber } from '../InnerSubscriber';\nimport { map } from './map';\nimport { from } from '../observable/from';\nexport function mergeMap(project, resultSelector, concurrent) {\n    if (concurrent === void 0) {\n        concurrent = Number.POSITIVE_INFINITY;\n    }\n    if (typeof resultSelector === 'function') {\n        return function (source) { return source.pipe(mergeMap(function (a, i) { return from(project(a, i)).pipe(map(function (b, ii) { return resultSelector(a, b, i, ii); })); }, concurrent)); };\n    }\n    else if (typeof resultSelector === 'number') {\n        concurrent = resultSelector;\n    }\n    return function (source) { return source.lift(new MergeMapOperator(project, concurrent)); };\n}\nvar MergeMapOperator = /*@__PURE__*/ (function () {\n    function MergeMapOperator(project, concurrent) {\n        if (concurrent === void 0) {\n            concurrent = Number.POSITIVE_INFINITY;\n        }\n        this.project = project;\n        this.concurrent = concurrent;\n    }\n    MergeMapOperator.prototype.call = function (observer, source) {\n        return source.subscribe(new MergeMapSubscriber(observer, this.project, this.concurrent));\n    };\n    return MergeMapOperator;\n}());\nexport { MergeMapOperator };\nvar MergeMapSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(MergeMapSubscriber, _super);\n    function MergeMapSubscriber(destination, project, concurrent) {\n        if (concurrent === void 0) {\n            concurrent = Number.POSITIVE_INFINITY;\n        }\n        var _this = _super.call(this, destination) || this;\n        _this.project = project;\n        _this.concurrent = concurrent;\n        _this.hasCompleted = false;\n        _this.buffer = [];\n        _this.active = 0;\n        _this.index = 0;\n        return _this;\n    }\n    MergeMapSubscriber.prototype._next = function (value) {\n        if (this.active < this.concurrent) {\n            this._tryNext(value);\n        }\n        else {\n            this.buffer.push(value);\n        }\n    };\n    MergeMapSubscriber.prototype._tryNext = function (value) {\n        var result;\n        var index = this.index++;\n        try {\n            result = this.project(value, index);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        this.active++;\n        this._innerSub(result, value, index);\n    };\n    MergeMapSubscriber.prototype._innerSub = function (ish, value, index) {\n        var innerSubscriber = new InnerSubscriber(this, undefined, undefined);\n        var destination = this.destination;\n        destination.add(innerSubscriber);\n        subscribeToResult(this, ish, value, index, innerSubscriber);\n    };\n    MergeMapSubscriber.prototype._complete = function () {\n        this.hasCompleted = true;\n        if (this.active === 0 && this.buffer.length === 0) {\n            this.destination.complete();\n        }\n        this.unsubscribe();\n    };\n    MergeMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.destination.next(innerValue);\n    };\n    MergeMapSubscriber.prototype.notifyComplete = function (innerSub) {\n        var buffer = this.buffer;\n        this.remove(innerSub);\n        this.active--;\n        if (buffer.length > 0) {\n            this._next(buffer.shift());\n        }\n        else if (this.active === 0 && this.hasCompleted) {\n            this.destination.complete();\n        }\n    };\n    return MergeMapSubscriber;\n}(OuterSubscriber));\nexport { MergeMapSubscriber };\n//# sourceMappingURL=mergeMap.js.map\n","/** PURE_IMPORTS_START  PURE_IMPORTS_END */\nexport function identity(x) {\n    return x;\n}\n//# sourceMappingURL=identity.js.map\n","/** PURE_IMPORTS_START _mergeMap,_util_identity PURE_IMPORTS_END */\nimport { mergeMap } from './mergeMap';\nimport { identity } from '../util/identity';\nexport function mergeAll(concurrent) {\n    if (concurrent === void 0) {\n        concurrent = Number.POSITIVE_INFINITY;\n    }\n    return mergeMap(identity, concurrent);\n}\n//# sourceMappingURL=mergeAll.js.map\n","/** PURE_IMPORTS_START _of,_operators_concatAll PURE_IMPORTS_END */\nimport { of } from './of';\nimport { concatAll } from '../operators/concatAll';\nexport function concat() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i] = arguments[_i];\n    }\n    return concatAll()(of.apply(void 0, observables));\n}\n//# sourceMappingURL=concat.js.map\n","/** PURE_IMPORTS_START _mergeAll PURE_IMPORTS_END */\nimport { mergeAll } from './mergeAll';\nexport function concatAll() {\n    return mergeAll(1);\n}\n//# sourceMappingURL=concatAll.js.map\n","/** PURE_IMPORTS_START _observable_concat,_util_isScheduler PURE_IMPORTS_END */\nimport { concat } from '../observable/concat';\nimport { isScheduler } from '../util/isScheduler';\nexport function startWith() {\n    var array = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        array[_i] = arguments[_i];\n    }\n    var scheduler = array[array.length - 1];\n    if (isScheduler(scheduler)) {\n        array.pop();\n        return function (source) { return concat(array, source, scheduler); };\n    }\n    else {\n        return function (source) { return concat(array, source); };\n    }\n}\n//# sourceMappingURL=startWith.js.map\n","/** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { Subscriber } from '../Subscriber';\nexport function filter(predicate, thisArg) {\n    return function filterOperatorFunction(source) {\n        return source.lift(new FilterOperator(predicate, thisArg));\n    };\n}\nvar FilterOperator = /*@__PURE__*/ (function () {\n    function FilterOperator(predicate, thisArg) {\n        this.predicate = predicate;\n        this.thisArg = thisArg;\n    }\n    FilterOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));\n    };\n    return FilterOperator;\n}());\nvar FilterSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(FilterSubscriber, _super);\n    function FilterSubscriber(destination, predicate, thisArg) {\n        var _this = _super.call(this, destination) || this;\n        _this.predicate = predicate;\n        _this.thisArg = thisArg;\n        _this.count = 0;\n        return _this;\n    }\n    FilterSubscriber.prototype._next = function (value) {\n        var result;\n        try {\n            result = this.predicate.call(this.thisArg, value, this.count++);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return;\n        }\n        if (result) {\n            this.destination.next(value);\n        }\n    };\n    return FilterSubscriber;\n}(Subscriber));\n//# sourceMappingURL=filter.js.map\n","/** PURE_IMPORTS_START tslib,_OuterSubscriber,_InnerSubscriber,_util_subscribeToResult,_map,_observable_from PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { OuterSubscriber } from '../OuterSubscriber';\nimport { InnerSubscriber } from '../InnerSubscriber';\nimport { subscribeToResult } from '../util/subscribeToResult';\nimport { map } from './map';\nimport { from } from '../observable/from';\nexport function switchMap(project, resultSelector) {\n    if (typeof resultSelector === 'function') {\n        return function (source) { return source.pipe(switchMap(function (a, i) { return from(project(a, i)).pipe(map(function (b, ii) { return resultSelector(a, b, i, ii); })); })); };\n    }\n    return function (source) { return source.lift(new SwitchMapOperator(project)); };\n}\nvar SwitchMapOperator = /*@__PURE__*/ (function () {\n    function SwitchMapOperator(project) {\n        this.project = project;\n    }\n    SwitchMapOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new SwitchMapSubscriber(subscriber, this.project));\n    };\n    return SwitchMapOperator;\n}());\nvar SwitchMapSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(SwitchMapSubscriber, _super);\n    function SwitchMapSubscriber(destination, project) {\n        var _this = _super.call(this, destination) || this;\n        _this.project = project;\n        _this.index = 0;\n        return _this;\n    }\n    SwitchMapSubscriber.prototype._next = function (value) {\n        var result;\n        var index = this.index++;\n        try {\n            result = this.project(value, index);\n        }\n        catch (error) {\n            this.destination.error(error);\n            return;\n        }\n        this._innerSub(result, value, index);\n    };\n    SwitchMapSubscriber.prototype._innerSub = function (result, value, index) {\n        var innerSubscription = this.innerSubscription;\n        if (innerSubscription) {\n            innerSubscription.unsubscribe();\n        }\n        var innerSubscriber = new InnerSubscriber(this, undefined, undefined);\n        var destination = this.destination;\n        destination.add(innerSubscriber);\n        this.innerSubscription = subscribeToResult(this, result, value, index, innerSubscriber);\n    };\n    SwitchMapSubscriber.prototype._complete = function () {\n        var innerSubscription = this.innerSubscription;\n        if (!innerSubscription || innerSubscription.closed) {\n            _super.prototype._complete.call(this);\n        }\n        this.unsubscribe();\n    };\n    SwitchMapSubscriber.prototype._unsubscribe = function () {\n        this.innerSubscription = null;\n    };\n    SwitchMapSubscriber.prototype.notifyComplete = function (innerSub) {\n        var destination = this.destination;\n        destination.remove(innerSub);\n        this.innerSubscription = null;\n        if (this.isStopped) {\n            _super.prototype._complete.call(this);\n        }\n    };\n    SwitchMapSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.destination.next(innerValue);\n    };\n    return SwitchMapSubscriber;\n}(OuterSubscriber));\n//# sourceMappingURL=switchMap.js.map\n","/** PURE_IMPORTS_START _switchMap PURE_IMPORTS_END */\nimport { switchMap } from './switchMap';\nexport function switchMapTo(innerObservable, resultSelector) {\n    return resultSelector ? switchMap(function () { return innerObservable; }, resultSelector) : switchMap(function () { return innerObservable; });\n}\n//# sourceMappingURL=switchMapTo.js.map\n","/** PURE_IMPORTS_START tslib,_Subscriber PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { Subscriber } from '../Subscriber';\nexport function distinctUntilChanged(compare, keySelector) {\n    return function (source) { return source.lift(new DistinctUntilChangedOperator(compare, keySelector)); };\n}\nvar DistinctUntilChangedOperator = /*@__PURE__*/ (function () {\n    function DistinctUntilChangedOperator(compare, keySelector) {\n        this.compare = compare;\n        this.keySelector = keySelector;\n    }\n    DistinctUntilChangedOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));\n    };\n    return DistinctUntilChangedOperator;\n}());\nvar DistinctUntilChangedSubscriber = /*@__PURE__*/ (function (_super) {\n    tslib_1.__extends(DistinctUntilChangedSubscriber, _super);\n    function DistinctUntilChangedSubscriber(destination, compare, keySelector) {\n        var _this = _super.call(this, destination) || this;\n        _this.keySelector = keySelector;\n        _this.hasKey = false;\n        if (typeof compare === 'function') {\n            _this.compare = compare;\n        }\n        return _this;\n    }\n    DistinctUntilChangedSubscriber.prototype.compare = function (x, y) {\n        return x === y;\n    };\n    DistinctUntilChangedSubscriber.prototype._next = function (value) {\n        var key;\n        try {\n            var keySelector = this.keySelector;\n            key = keySelector ? keySelector(value) : value;\n        }\n        catch (err) {\n            return this.destination.error(err);\n        }\n        var result = false;\n        if (this.hasKey) {\n            try {\n                var compare = this.compare;\n                result = compare(this.key, key);\n            }\n            catch (err) {\n                return this.destination.error(err);\n            }\n        }\n        else {\n            this.hasKey = true;\n        }\n        if (!result) {\n            this.key = key;\n            this.destination.next(value);\n        }\n    };\n    return DistinctUntilChangedSubscriber;\n}(Subscriber));\n//# sourceMappingURL=distinctUntilChanged.js.map\n","/*\n * Copyright (c) 2016-2019 Martin Donath <martin.donath@squidfunk.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { equals } from \"rambda\"\nimport { Observable, fromEvent, merge } from \"rxjs\"\nimport { distinctUntilChanged, map, startWith } from \"rxjs/operators\"\n\n/* ----------------------------------------------------------------------------\n * Data\n * ------------------------------------------------------------------------- */\n\n/**\n * Observable for window scroll events\n */\nconst scroll$ = fromEvent<UIEvent>(window, \"scroll\")\n\n/**\n * Observable for window resize events\n */\nconst resize$ = fromEvent<UIEvent>(window, \"resize\")\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Viewport offset\n */\nexport interface ViewportOffset {\n  x: number                            /* Horizontal offset */\n  y: number                            /* Vertical offset */\n}\n\n/**\n * Viewport size\n */\nexport interface ViewportSize {\n  width: number                        /* Viewport width */\n  height: number                       /* Viewport height */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Retrieve the viewport offset\n *\n * @return Viewport offset\n */\nexport function getViewportOffset(): ViewportOffset {\n  return {\n    x: window.pageXOffset,\n    y: window.pageYOffset\n  }\n}\n\n/**\n * Retrieve the viewport size\n *\n * @return Viewport size\n */\nexport function getViewportSize(): ViewportSize {\n  return {\n    width:  window.innerWidth,\n    height: window.innerHeight\n  }\n}\n\n/* ------------------------------------------------------------------------- */\n\n/**\n * Create an observable emitting changes in viewport offset\n *\n * @return Viewport offset observable\n */\nexport function watchViewportOffset(): Observable<ViewportOffset> {\n  return merge(scroll$, resize$).pipe(\n    map(getViewportOffset),\n    startWith(getViewportOffset()),\n    distinctUntilChanged<ViewportOffset>(equals)\n  )\n}\n\n/**\n * Create an observable emitting changes in viewport size\n *\n * @return Viewport size observable\n */\nexport function watchViewportSize(): Observable<ViewportSize> {\n  return resize$.pipe(\n    map(getViewportSize),\n    startWith(getViewportSize()),\n    distinctUntilChanged<ViewportSize>(equals)\n  )\n}\n","/*\n * Copyright (c) 2016-2019 Martin Donath <martin.donath@squidfunk.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { equals, reduce } from \"rambda\"\nimport { BehaviorSubject, combineLatest, fromEvent, merge, of } from \"rxjs\"\nimport {\n  distinctUntilChanged,\n  filter,\n  map,\n  mapTo,\n  pluck,\n  startWith,\n  switchMapTo\n} from \"rxjs/operators\"\n\nimport {\n  fromMediaQuery,\n  watchViewportOffset,\n  watchViewportSize\n} from \"./viewport\"\n\n// ----------------------------------------------------------------------------\n\nconst screen$ = fromMediaQuery(\"(min-width: 1220px)\")\nconst offset$ = watchViewportOffset()\nconst size$ = watchViewportSize()\n\nconst hash$ = fromEvent<HashChangeEvent>(window, \"hashchange\").pipe(\n  startWith(document.location.hash),\n  map(() => document.location.hash),\n  filter(hash => hash.length > 0)\n)\n\n// ----------------------------------------------------------------------------\n\nconst component$ = of({\n  container:  document.querySelector(\"[data-md-component=container]\") as HTMLElement,\n  navigation: document.querySelector(\"[data-md-component=navigation]\") as HTMLElement,\n  header:     document.querySelector(\"[data-md-component=header]\") as HTMLElement,\n  title:      document.querySelector(\"[data-md-component=title]\") as HTMLElement,\n  toc:        document.querySelector(\"[data-md-component=toc]\") as HTMLElement, // TODO: !?\n  headline:   document.querySelector(\".md-typeset h1\") as HTMLElement\n})\n\n// ----------------------------------------------------------------------------\n\n// helper function\nfunction toArray(collection: HTMLCollection): HTMLElement[] {\n  return Array.from(collection) as HTMLElement[]\n}\n\ndocument.documentElement.classList.remove(\"no-js\")\ndocument.documentElement.classList.add(\"js\")\n\n// we need TWO observables. first, if it's a resize, we need to set up stuff anew\n// bind size and offset to animationFrame !!!\n// TODO: combine latest with element!? navigation -> el\n\n// ----------------------------------------------------------------------------\n// sidebar lock + height\n// ----------------------------------------------------------------------------\n\n// Sidebar { offset, height, locked }\n\nconst sidebarOffset$ = size$.pipe(\n  switchMapTo(component$),\n  map(({ header, navigation }) => {\n    return -1 * (header.offsetParent === null ? header.offsetHeight : 0) +\n      reduce((offset, child) => {\n        return Math.max(offset, child.offsetTop)\n      }, 0, toArray(navigation.parentElement!.children))\n  }),\n  distinctUntilChanged<number>(equals)\n)\n\nconst sidebarHeight$ = combineLatest(offset$, size$, component$, sidebarOffset$).pipe(\n  map(([{ y }, { height }, { header, navigation }, offset]) => {\n    const parent = navigation.parentElement as HTMLElement\n    return height - (\n      header.offsetParent === null ? header.offsetHeight : 0\n    ) - Math.max(0, offset - y)\n      - Math.max(0, y + height - parent.offsetTop - parent.offsetHeight)\n  })\n)\n\nconst sidebarActive$ = combineLatest(offset$, sidebarOffset$).pipe(\n  map(([{ y }, threshold]) => y >= threshold),\n  distinctUntilChanged<boolean>(equals)\n)\n\n// ----------------------------------------------------------------------------\n\ncombineLatest(component$, sidebarActive$)\n  .subscribe(([{ navigation }, active]) => {\n    navigation.dataset.mdState = active ? \"lock\" : \"\"\n  })\n\ncombineLatest(component$, sidebarHeight$)\n  .subscribe(([{ navigation }, height]) => {\n    navigation.style.height = `${height}px`\n  })\n\n// ----------------------------------------------------------------------------\n\n// re-use calculation for toc, if present!\ncombineLatest(component$, sidebarActive$).pipe(\n  filter(([{ toc }]) => Boolean(toc))\n)\n  .subscribe(([{ toc }, active]) => {\n    toc.dataset.mdState = active ? \"lock\" : \"\"\n  })\n\ncombineLatest(component$, sidebarHeight$).pipe(\n  filter(([{ toc }]) => Boolean(toc))\n)\n  .subscribe(([{ toc }, height]) => {\n    toc.style.height = `${height}px`\n  })\n\n// ----------------------------------------------------------------------------\n// header shadow\n// ----------------------------------------------------------------------------\n\n// Shadow { offset, locked }\n\nconst shadowOffset$ = size$.pipe(\n  switchMapTo(component$),\n  map(({ container }) => {\n    let parent = container.parentElement as HTMLElement\n    let height = 0\n    do {\n      parent  = parent.previousElementSibling as HTMLElement                     // toElement -> throw if not!\n      height += parent.offsetHeight\n    } while (parent.previousElementSibling)\n    return height\n  })\n)\n\nconst shadowActive$ = combineLatest(offset$, shadowOffset$).pipe(\n  map(([{ y }, threshold]) => y >= threshold),\n  distinctUntilChanged<boolean>(equals)\n)\n\n// ----------------------------------------------------------------------------\n\ncombineLatest(component$, shadowActive$)\n  .subscribe(([{ header }, active]) => {\n    header.dataset.mdState = active ? \"shadow\" : \"\"\n  })\n\n// ----------------------------------------------------------------------------\n// header title swap\n// ----------------------------------------------------------------------------\n\nconst headlineOffset$ = size$.pipe(\n  switchMapTo(component$),\n  map(({ headline }) => headline.offsetTop),\n  distinctUntilChanged<number>(equals)\n)\n\nconst headlineWidth$ = size$.pipe(\n  switchMapTo(component$),\n  map(({ title }) => title.offsetWidth - 20),\n  distinctUntilChanged<number>(equals)\n)\n\nconst headlineActive$ = combineLatest(offset$, headlineOffset$).pipe(\n  map(([{ y }, threshold]) => y >= threshold),\n  distinctUntilChanged<boolean>(equals)\n)\n\n// ----------------------------------------------------------------------------\n\ncombineLatest(component$, headlineActive$)\n  .subscribe(([{ title }, active]) => {\n    title.dataset.mdState = active ? \"active\" : \"\"\n  })\n\ncombineLatest(component$, headlineWidth$)\n  .subscribe(([{ title }, width]) => {\n    for (const child of toArray(title.children))\n      child.style.width = `${width}px`\n  })\n\n// ----------------------------------------------------------------------------\n// open details on hashchange\n// ----------------------------------------------------------------------------\n\nhash$.pipe(\n  map(hash => document.querySelector(hash) as HTMLElement),                     // TODO: write a getElement function...\n  filter<HTMLElement>(Boolean)\n)\n  .subscribe(el => {\n    let parent = el.parentNode\n    while (parent && !(parent instanceof HTMLDetailsElement))\n      parent = parent.parentNode\n\n    /* If there's a details tag, open it */\n    if (parent && !parent.open) {\n      parent.open = true\n\n      /* Force reload, so the viewport repositions */\n      const hash = location.hash\n      location.hash = \" \"\n      location.hash = hash // tslint:disable-line\n    }\n  })\n\n// size$.pipe(\n//   switchMapTo(component$),\n//   map(({ title }) => {\n//     title.children\n//   }\n\n// just combine all header observables into one!\n\n// headerLock$.subscribe(console.log)\n// headerHeight$.subscribe(console.log)\n// TODO just tap both? toc and nav?\n\n// // first, calculate top offset\n// size$.subscribe(size => {\n//   const children = Array.from(navigation.parentElement!.children) as HTMLElement[] // TODO\n\n//   const top = children.reduce((offset, child) => Math.max(offset, child.offsetTop), 0)\n\n//   const offset = top - (adjust ? header.offsetHeight : 0)\n\n// })\n\n// const top = Array.from(navigation.parentElement!.children)\n//   .reduce()\n\n// this.parent_.children, (offset, child) => {\n//   return Math.max(offset, child.offsetTop)\n// }, 0)\n\n/* Set lock offset for element with largest top offset */\n// this.offset_ = top - (this.pad_ ? this.header_.offsetHeight : 0)\n\n// offset$.subscribe(offset => {\n//   console.log(offset)\n// })\n\nexport function app(_x: any) {\n\n}\n","/*\n * Copyright (c) 2016-2019 Martin Donath <martin.donath@squidfunk.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { Observable, fromEventPattern } from \"rxjs\"\nimport { startWith } from \"rxjs/operators\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Create an observable for a media query\n *\n * @param query - Media query\n *\n * @return Media query observable\n */\nexport function fromMediaQuery(query: string): Observable<boolean> {\n  const media  = window.matchMedia(query)\n  return fromEventPattern<boolean>(next =>\n    media.addListener(() => next(media.matches))\n  ).pipe(\n    startWith(media.matches)\n  )\n}\n","/** PURE_IMPORTS_START _Observable,_util_isArray,_util_isFunction,_operators_map PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { isArray } from '../util/isArray';\nimport { isFunction } from '../util/isFunction';\nimport { map } from '../operators/map';\nexport function fromEventPattern(addHandler, removeHandler, resultSelector) {\n    if (resultSelector) {\n        return fromEventPattern(addHandler, removeHandler).pipe(map(function (args) { return isArray(args) ? resultSelector.apply(void 0, args) : resultSelector(args); }));\n    }\n    return new Observable(function (subscriber) {\n        var handler = function () {\n            var e = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                e[_i] = arguments[_i];\n            }\n            return subscriber.next(e.length === 1 ? e[0] : e);\n        };\n        var retValue;\n        try {\n            retValue = addHandler(handler);\n        }\n        catch (err) {\n            subscriber.error(err);\n            return undefined;\n        }\n        if (!isFunction(removeHandler)) {\n            return undefined;\n        }\n        return function () { return removeHandler(handler, retValue); };\n    });\n}\n//# sourceMappingURL=fromEventPattern.js.map\n","/** PURE_IMPORTS_START _Observable,_util_isScheduler,_operators_mergeAll,_fromArray PURE_IMPORTS_END */\nimport { Observable } from '../Observable';\nimport { isScheduler } from '../util/isScheduler';\nimport { mergeAll } from '../operators/mergeAll';\nimport { fromArray } from './fromArray';\nexport function merge() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i] = arguments[_i];\n    }\n    var concurrent = Number.POSITIVE_INFINITY;\n    var scheduler = null;\n    var last = observables[observables.length - 1];\n    if (isScheduler(last)) {\n        scheduler = observables.pop();\n        if (observables.length > 1 && typeof observables[observables.length - 1] === 'number') {\n            concurrent = observables.pop();\n        }\n    }\n    else if (typeof last === 'number') {\n        concurrent = observables.pop();\n    }\n    if (scheduler === null && observables.length === 1 && observables[0] instanceof Observable) {\n        return observables[0];\n    }\n    return mergeAll(concurrent)(fromArray(observables, scheduler));\n}\n//# sourceMappingURL=merge.js.map\n"],"sourceRoot":""}