{"version":3,"sources":["../node_modules/valtio/index.js","../../src/index.ts","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js","../node_modules/react-rating/lib/react-rating.esm.js","../node_modules/use-sync-external-store/shim/index.js","../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.min.js","../node_modules/valtio/vanilla.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/slicedToArray.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js"],"names":["Object","defineProperty","exports","value","react","require","proxyCompare","useSyncExternalStoreExports","vanilla","_interopDefaultLegacy","e","useSyncExternalStore","enumerable","get","getVersion","proxy","ref","snapshot","subscribe","getHandler","useSnapshot","proxyObject","options","notifyInSync","sync","lastSnapshot","useRef","lastAffected","inRender","currSnapshot","useCallback","callback","unsub","nextSnapshot","current","isChanged","WeakMap","currAffected","useEffect","proxyCache","useMemo","createProxy","OWN_KEYS_SYMBOL","Symbol","TRACK_MEMO_SYMBOL","GET_ORIGINAL_SYMBOL","getProto","getPrototypeOf","objectsToTrack","isObjectToTrack","obj","has","prototype","Array","isObject","x","createProxyHandler","origObj","frozen","trackObject","recordUsage","h","key","skipWithOwnKeys","used","Set","set","add","handler","f","target","this","delete","getOwnPropertyDescriptor","ownKeys","Reflect","deleteProperty","getOriginalObject","affected","isFrozen","values","getOwnPropertyDescriptors","some","descriptor","writable","proxyHandler","Proxy","isArray","from","descriptors","forEach","desc","configurable","create","isOwnKeysChanged","prevObj","nextObj","prevKeys","nextKeys","length","k","i","cache","is","hit","n","g","changed","o","iterator","unsupportedIterableToArray","F","s","done","_e","TypeError","it","err","normalCompletion","didErr","step","next","_e2","c","trackMemo","getUntracked","markToTrack","mark","affectedToPathList","list","seen","WeakSet","walk","path","push","_typeof","constructor","_classCallCheck","instance","Constructor","_defineProperties","props","_createClass","protoProps","staticProps","_defineProperty","_extends","assign","arguments","source","hasOwnProperty","call","apply","_objectSpread","keys","getOwnPropertySymbols","concat","filter","sym","_inherits","subClass","superClass","_setPrototypeOf","_getPrototypeOf","setPrototypeOf","__proto__","p","_assertThisInitialized","self","ReferenceError","_possibleConstructorReturn","style","display","borderRadius","border","width","height","Style","empty","backgroundColor","full","placeholder","_iconNode","icon","React","isValidElement","createElement","toString","className","RatingSymbol","_React$PureComponent","_iconContainerStyle","_this$props","index","inactiveIcon","activeIcon","percent","direction","readonly","onClick","onMouseMove","backgroundNode","bgIconContainerStyle","visibility","iconNode","iconContainerStyle","position","overflow","top","cursor","handleMouseMove","handleMouseClick","preventDefault","onTouchMove","onTouchEnd","PureComponent","Rating","_this","state","displayValue","interacting","onMouseLeave","bind","symbolMouseMove","symbolClick","nextProps","valueChanged","setState","prevState","prevProps","onHover","symbolIndex","event","calculateDisplayValue","percentage","calculateHoverPercentage","fraction","Math","ceil","fractions","precision","pow","floor","totalSymbols","clientX","nativeEvent","type","indexOf","changedTouches","touches","targetRect","getBoundingClientRect","delta","right","left","renderedValue","quiet","placeholderValue","emptySymbol","fullSymbol","placeholderSymbol","id","tabIndex","_this$state","symbolNodes","shouldDisplayPlaceholder","fullSymbols","noop","_name","RatingAPILayer","initialRating","handleClick","handleHover","_this2","newValue","translateDisplayValueToValue","onChange","undefined","translatedValue","start","stop","calculateTotalSymbols","tranlateValueToDisplayValue","placeholderRating","defaultProps","module","a","b","l","useState","m","useLayoutEffect","useDebugValue","r","getSnapshot","d","u","window","document","inst","VERSION","LISTENERS","SNAPSHOT","HANDLER","PROMISE_RESULT","PROMISE_ERROR","refSet","canProxy","Error","Number","Date","String","RegExp","ArrayBuffer","globalVersion","snapshotCache","initialObject","found","version","listeners","notifyUpdate","op","nextVersion","listener","propListeners","Map","getPropListener","prop","propListener","newOp","popPropListener","baseObject","receiver","Promise","errorOrPromise","freeze","createSnapshot","prevValue","childListeners","deleted","_Object$getOwnPropert","_value","hasPrevValue","nextValue","then","v","catch","promise","ops","splice","resolve","_slicedToArray","arr","_arr","_n","_d","_s","_i"],"mappings":"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","file":"static/js/6.ff835670.chunk.js","sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar react = require('react');\nvar proxyCompare = require('proxy-compare');\nvar useSyncExternalStoreExports = require('use-sync-external-store/shim');\nvar vanilla = require('valtio/vanilla');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\nvar useSyncExternalStoreExports__default = /*#__PURE__*/_interopDefaultLegacy(useSyncExternalStoreExports);\n\nvar useSyncExternalStore = useSyncExternalStoreExports__default[\"default\"].useSyncExternalStore;\n\nvar useAffectedDebugValue = function useAffectedDebugValue(state, affected) {\n  var pathList = react.useRef();\n  react.useEffect(function () {\n    pathList.current = proxyCompare.affectedToPathList(state, affected);\n  });\n  react.useDebugValue(pathList.current);\n};\n\nfunction useSnapshot(proxyObject, options) {\n  var notifyInSync = options == null ? void 0 : options.sync;\n  var lastSnapshot = react.useRef();\n  var lastAffected = react.useRef();\n  var inRender = true;\n  var currSnapshot = useSyncExternalStore(react.useCallback(function (callback) {\n    var unsub = vanilla.subscribe(proxyObject, callback, notifyInSync);\n    callback();\n    return unsub;\n  }, [proxyObject, notifyInSync]), function () {\n    var nextSnapshot = vanilla.snapshot(proxyObject);\n\n    try {\n      if (!inRender && lastSnapshot.current && lastAffected.current && !proxyCompare.isChanged(lastSnapshot.current, nextSnapshot, lastAffected.current, new WeakMap())) {\n        return lastSnapshot.current;\n      }\n    } catch (e) {}\n\n    return nextSnapshot;\n  }, function () {\n    return vanilla.snapshot(proxyObject);\n  });\n  inRender = false;\n  var currAffected = new WeakMap();\n  react.useEffect(function () {\n    lastSnapshot.current = currSnapshot;\n    lastAffected.current = currAffected;\n  });\n\n  if (process.env.NODE_ENV !== \"production\") {\n    useAffectedDebugValue(currSnapshot, currAffected);\n  }\n\n  var proxyCache = react.useMemo(function () {\n    return new WeakMap();\n  }, []);\n  return proxyCompare.createProxy(currSnapshot, currAffected, proxyCache);\n}\n\nObject.defineProperty(exports, 'getVersion', {\n  enumerable: true,\n  get: function () { return vanilla.getVersion; }\n});\nObject.defineProperty(exports, 'proxy', {\n  enumerable: true,\n  get: function () { return vanilla.proxy; }\n});\nObject.defineProperty(exports, 'ref', {\n  enumerable: true,\n  get: function () { return vanilla.ref; }\n});\nObject.defineProperty(exports, 'snapshot', {\n  enumerable: true,\n  get: function () { return vanilla.snapshot; }\n});\nObject.defineProperty(exports, 'subscribe', {\n  enumerable: true,\n  get: function () { return vanilla.subscribe; }\n});\nObject.defineProperty(exports, 'unstable_getHandler', {\n  enumerable: true,\n  get: function () { return vanilla.getHandler; }\n});\nexports.useSnapshot = useSnapshot;\n","// symbols\nconst OWN_KEYS_SYMBOL = Symbol();\nconst TRACK_MEMO_SYMBOL = Symbol();\nconst GET_ORIGINAL_SYMBOL = Symbol();\n\n// properties\nconst AFFECTED_PROPERTY = 'a';\nconst FROZEN_PROPERTY = 'f';\nconst PROXY_PROPERTY = 'p';\nconst PROXY_CACHE_PROPERTY = 'c';\nconst NEXT_OBJECT_PROPERTY = 'n';\nconst CHANGED_PROPERTY = 'g';\n\n// get object prototype\nconst getProto = Object.getPrototypeOf;\n\nconst objectsToTrack = new WeakMap<object, boolean>();\n\n// check if obj is a plain object or an array\nconst isObjectToTrack = <T>(obj: T): obj is T extends object ? T : never => (\n  obj && (objectsToTrack.has(obj as unknown as object)\n    ? objectsToTrack.get(obj as unknown as object) as boolean\n    : (getProto(obj) === Object.prototype || getProto(obj) === Array.prototype)\n  )\n);\n\n// check if it is object\nconst isObject = (x: unknown): x is object => (\n  typeof x === 'object' && x !== null\n);\n\n// check if frozen\nconst isFrozen = (obj: object) => (\n  Object.isFrozen(obj) || (\n    // Object.isFrozen() doesn't detect non-writable properties\n    // See: https://github.com/dai-shi/proxy-compare/pull/8\n    Object.values(Object.getOwnPropertyDescriptors(obj)).some(\n      (descriptor) => !descriptor.writable,\n    )\n  )\n);\n\n// copy frozen object\nconst unfreeze = (obj: object) => {\n  if (Array.isArray(obj)) {\n    // Arrays need a special way to copy\n    return Array.from(obj);\n  }\n  // For non-array objects, we create a new object keeping the prototype\n  // with changing all configurable options (otherwise, proxies will complain)\n  const descriptors = Object.getOwnPropertyDescriptors(obj);\n  Object.values(descriptors).forEach((desc) => { desc.configurable = true; });\n  return Object.create(getProto(obj), descriptors);\n};\n\ntype Affected = WeakMap<object, Set<string | symbol>>;\ntype ProxyCache<T extends object> = WeakMap<object, ProxyHandler<T>>;\ntype ProxyHandler<T extends object> = {\n  [FROZEN_PROPERTY]: boolean;\n  [PROXY_PROPERTY]?: T;\n  [PROXY_CACHE_PROPERTY]?: ProxyCache<object> | undefined;\n  [AFFECTED_PROPERTY]?: Affected;\n  get(target: T, key: string | symbol): unknown;\n  has(target: T, key: string | symbol): boolean;\n  getOwnPropertyDescriptor(target: T, key: string | symbol): PropertyDescriptor | undefined;\n  ownKeys(target: T): (string | symbol)[];\n  set?(target: T, key: string | symbol, value: unknown): boolean;\n  deleteProperty?(target: T, key: string | symbol): boolean;\n};\n\nconst createProxyHandler = <T extends object>(origObj: T, frozen: boolean) => {\n  let trackObject = false; // for trackMemo\n  const recordUsage = (h: ProxyHandler<T>, key: string | symbol, skipWithOwnKeys?: boolean) => {\n    if (!trackObject) {\n      let used = (h[AFFECTED_PROPERTY] as Affected).get(origObj);\n      if (!used) {\n        used = new Set();\n        (h[AFFECTED_PROPERTY] as Affected).set(origObj, used);\n      }\n      if (!skipWithOwnKeys || !used.has(OWN_KEYS_SYMBOL)) {\n        used.add(key);\n      }\n    }\n  };\n  const recordObjectAsUsed = (h: ProxyHandler<T>) => {\n    trackObject = true;\n    (h[AFFECTED_PROPERTY] as Affected).delete(origObj);\n  };\n  const handler: ProxyHandler<T> = {\n    [FROZEN_PROPERTY]: frozen,\n    get(target, key) {\n      if (key === GET_ORIGINAL_SYMBOL) {\n        return origObj;\n      }\n      recordUsage(this, key);\n      return createProxy(\n        (target as any)[key],\n        (this[AFFECTED_PROPERTY] as Affected),\n        this[PROXY_CACHE_PROPERTY],\n      );\n    },\n    has(target, key) {\n      if (key === TRACK_MEMO_SYMBOL) {\n        recordObjectAsUsed(this);\n        return true;\n      }\n      // LIMITATION: We simply record the same as `get`.\n      // This means { a: {} } and { a: {} } is detected as changed,\n      // if `'a' in obj` is handled.\n      recordUsage(this, key);\n      return key in target;\n    },\n    getOwnPropertyDescriptor(target, key) {\n      // LIMITATION: We simply record the same as `get`.\n      // This means { a: {} } and { a: {} } is detected as changed,\n      // if `obj.getOwnPropertyDescriptor('a'))` is handled.\n      recordUsage(this, key, true);\n      return Object.getOwnPropertyDescriptor(target, key);\n    },\n    ownKeys(target) {\n      recordUsage(this, OWN_KEYS_SYMBOL);\n      return Reflect.ownKeys(target);\n    },\n  };\n  if (frozen) {\n    handler.set = handler.deleteProperty = () => false;\n  }\n  return handler;\n};\n\nconst getOriginalObject = <T extends object>(obj: T) => (\n  // unwrap proxy\n  (obj as { [GET_ORIGINAL_SYMBOL]?: typeof obj })[GET_ORIGINAL_SYMBOL]\n  // otherwise\n  || obj\n);\n\n/**\n * Create a proxy.\n *\n * This function will create a proxy at top level and proxy nested objects as you access them,\n * in order to keep track of which properties were accessed via get/has proxy handlers:\n *\n * NOTE: Printing of WeakMap is hard to inspect and not very readable\n * for this purpose you can use the `affectedToPathList` helper.\n *\n * @param {object} obj - Object that will be wrapped on the proxy.\n * @param {WeakMap<object, unknown>} affected -\n * WeakMap that will hold the tracking of which properties in the proxied object were accessed.\n * @param {WeakMap<object, unknown>} [proxyCache] -\n * WeakMap that will help keep referential identity for proxies.\n * @returns {Proxy<object>} - Object wrapped in a proxy.\n *\n * @example\n * import { createProxy } from 'proxy-compare';\n *\n * const original = { a: \"1\", c: \"2\", d: { e: \"3\" } };\n * const affected = new WeakMap();\n * const proxy = createProxy(original, affected);\n *\n * proxy.a // Will mark as used and track its value.\n * // This will update the affected WeakMap with original as key\n * // and a Set with \"a\"\n *\n * proxy.d // Will mark \"d\" as accessed to track and proxy itself ({ e: \"3\" }).\n * // This will update the affected WeakMap with original as key\n * // and a Set with \"d\"\n */\nexport const createProxy = <T>(\n  obj: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache?: WeakMap<object, unknown>,\n): T => {\n  if (!isObjectToTrack(obj)) return obj;\n  const target = getOriginalObject(obj);\n  const frozen = isFrozen(target);\n  let proxyHandler: ProxyHandler<typeof target> | undefined = (\n    proxyCache && (proxyCache as ProxyCache<typeof target>).get(target)\n  );\n  if (!proxyHandler || proxyHandler[FROZEN_PROPERTY] !== frozen) {\n    proxyHandler = createProxyHandler<T extends object ? T : never>(target, frozen);\n    proxyHandler[PROXY_PROPERTY] = new Proxy(\n      frozen ? unfreeze(target) : target,\n      proxyHandler,\n    ) as typeof target;\n    if (proxyCache) {\n      proxyCache.set(target, proxyHandler);\n    }\n  }\n  proxyHandler[AFFECTED_PROPERTY] = affected as Affected;\n  proxyHandler[PROXY_CACHE_PROPERTY] = proxyCache as ProxyCache<object> | undefined;\n  return proxyHandler[PROXY_PROPERTY] as typeof target;\n};\n\nconst isOwnKeysChanged = (prevObj: object, nextObj: object) => {\n  const prevKeys = Reflect.ownKeys(prevObj);\n  const nextKeys = Reflect.ownKeys(nextObj);\n  return prevKeys.length !== nextKeys.length\n    || prevKeys.some((k, i) => k !== nextKeys[i]);\n};\n\ntype ChangedCache = WeakMap<object, {\n  [NEXT_OBJECT_PROPERTY]: object;\n  [CHANGED_PROPERTY]: boolean;\n}>;\n\n/**\n * Compare changes on objects.\n *\n * This will compare the affected properties on tracked objects inside the proxy\n * to check if there were any changes made to it,\n * by default if no property was accessed on the proxy it will attempt to do a\n * reference equality check for the objects provided (Object.is(a, b)). If you access a property\n * on the proxy, then isChanged will only compare the affected properties.\n *\n * @param {object} prevObj - The previous object to compare.\n * @param {object} nextObj - Object to compare with the previous one.\n * @param {WeakMap<object, unknown>} affected -\n * WeakMap that holds the tracking of which properties in the proxied object were accessed.\n * @param {WeakMap<object, unknown>} [cache] -\n * WeakMap that holds a cache of the comparisons for better performance with repetitive comparisons,\n * and to avoid infinite loop with circular structures.\n * @returns {boolean} - Boolean indicating if the affected property on the object has changed.\n *\n * @example\n * import { createProxy, isChanged } from 'proxy-compare';\n *\n * const obj = { a: \"1\", c: \"2\", d: { e: \"3\" } };\n * const affected = new WeakMap();\n *\n * const proxy = createProxy(obj, affected);\n *\n * proxy.a\n *\n * isChanged(obj, { a: \"1\" }, affected) // false\n *\n * proxy.a = \"2\"\n *\n * isChanged(obj, { a: \"1\" }, affected) // true\n */\n\nexport const isChanged = (\n  prevObj: unknown,\n  nextObj: unknown,\n  affected: WeakMap<object, unknown>,\n  cache?: WeakMap<object, unknown>,\n): boolean => {\n  if (Object.is(prevObj, nextObj)) {\n    return false;\n  }\n  if (!isObject(prevObj) || !isObject(nextObj)) return true;\n  const used = (affected as Affected).get(getOriginalObject(prevObj));\n  if (!used) return true;\n  if (cache) {\n    const hit = (cache as ChangedCache).get(prevObj);\n    if (hit && hit[NEXT_OBJECT_PROPERTY] === nextObj) {\n      return hit[CHANGED_PROPERTY];\n    }\n    // for object with cycles\n    (cache as ChangedCache).set(prevObj, {\n      [NEXT_OBJECT_PROPERTY]: nextObj,\n      [CHANGED_PROPERTY]: false,\n    });\n  }\n  let changed: boolean | null = null;\n  // eslint-disable-next-line no-restricted-syntax\n  for (const key of used) {\n    const c = key === OWN_KEYS_SYMBOL ? isOwnKeysChanged(prevObj, nextObj)\n      : isChanged(\n        (prevObj as any)[key],\n        (nextObj as any)[key],\n        affected,\n        cache,\n      );\n    if (c === true || c === false) changed = c;\n    if (changed) break;\n  }\n  if (changed === null) changed = true;\n  if (cache) {\n    cache.set(prevObj, {\n      [NEXT_OBJECT_PROPERTY]: nextObj,\n      [CHANGED_PROPERTY]: changed,\n    });\n  }\n  return changed;\n};\n\n// explicitly track object with memo\nexport const trackMemo = (obj: unknown) => {\n  if (isObjectToTrack(obj)) {\n    return TRACK_MEMO_SYMBOL in obj;\n  }\n  return false;\n};\n\n/**\n * Unwrap proxy to get the original object.\n *\n * Used to retrieve the original object used to create the proxy instance with `createProxy`.\n *\n * @param {Proxy<object>} obj -  The proxy wrapper of the originial object.\n * @returns {object | null} - Return either the unwrapped object if exists.\n *\n * @example\n * import { createProxy, getUntracked } from 'proxy-compare';\n *\n * const original = { a: \"1\", c: \"2\", d: { e: \"3\" } };\n * const affected = new WeakMap();\n *\n * const proxy = createProxy(original, affected);\n * const originalFromProxy = getUntracked(proxy)\n *\n * Object.is(original, originalFromProxy) // true\n * isChanged(original, originalFromProxy, affected) // false\n */\nexport const getUntracked = <T>(obj: T): T | null => {\n  if (isObjectToTrack(obj)) {\n    return (obj as { [GET_ORIGINAL_SYMBOL]?: T })[GET_ORIGINAL_SYMBOL] || null;\n  }\n  return null;\n};\n\n/**\n * Mark object to be tracked.\n *\n * This function marks an object that will be passed into `createProxy`\n * as marked to track or not. By default only Array and Object are marked to track,\n * so this is useful for example to mark a class instance to track or to mark a object\n * to be untracked when creating your proxy.\n *\n * @param obj - Object to mark as tracked or not.\n * @param mark - Boolean indicating whether you want to track this object or not.\n * @returns No return.\n *\n * @example\n * import { createProxy, markToTrack, isChanged } from 'proxy-compare';\n *\n * const nested = { e: \"3\" }\n *\n * markToTrack(nested, false)\n *\n * const original = { a: \"1\", c: \"2\", d: nested };\n * const affected = new WeakMap();\n *\n * const proxy = createProxy(original, affected);\n *\n * proxy.d.e\n *\n * isChanged(original, { d: { e: \"3\" } }, affected) // true\n */\nexport const markToTrack = (obj: object, mark = true) => {\n  objectsToTrack.set(obj, mark);\n};\n\n// convert affected to path list\nexport const affectedToPathList = (\n  obj: unknown,\n  affected: WeakMap<object, unknown>,\n) => {\n  const list: (string | symbol)[][] = [];\n  const seen = new WeakSet();\n  const walk = (x: unknown, path?: (string | symbol)[]) => {\n    if (seen.has(x as object)) {\n      // for object with cycles\n      return;\n    }\n    if (isObject(x)) {\n      seen.add(x);\n    }\n    const used = isObject(x) && (affected as Affected).get(getOriginalObject(x));\n    if (used) {\n      used.forEach((key) => {\n        walk((x as any)[key], path ? [...path, key] : [key]);\n      });\n    } else if (path) {\n      list.push(path);\n    }\n  };\n  walk(obj);\n  return list;\n};\n","import unsupportedIterableToArray from \"./unsupportedIterableToArray\";\nexport default function _createForOfIteratorHelper(o) {\n  if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) {\n    if (Array.isArray(o) || (o = unsupportedIterableToArray(o))) {\n      var i = 0;\n\n      var F = function F() {};\n\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  var it,\n      normalCompletion = true,\n      didErr = false,\n      err;\n  return {\n    s: function s() {\n      it = o[Symbol.iterator]();\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}","import React from 'react';\n\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) _setPrototypeOf(subClass, superClass);\n}\n\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return _assertThisInitialized(self);\n}\n\nvar style = {\n  display: 'inline-block',\n  borderRadius: '50%',\n  border: '5px double white',\n  width: 30,\n  height: 30\n};\nvar Style = {\n  empty: _objectSpread({}, style, {\n    backgroundColor: '#ccc'\n  }),\n  full: _objectSpread({}, style, {\n    backgroundColor: 'black'\n  }),\n  placeholder: _objectSpread({}, style, {\n    backgroundColor: 'red'\n  })\n};\n\n// Return the corresponding React node for an icon.\nvar _iconNode = function _iconNode(icon) {\n  // If it is already a React Element just return it.\n  if (React.isValidElement(icon)) {\n    return icon;\n  } // If it is an object, try to use it as a CSS style object.\n\n\n  if (_typeof(icon) === 'object' && icon !== null) {\n    return React.createElement(\"span\", {\n      style: icon\n    });\n  } // If it is a string, use it as class names.\n\n\n  if (Object.prototype.toString.call(icon) === '[object String]') {\n    return React.createElement(\"span\", {\n      className: icon\n    });\n  }\n};\n\nvar RatingSymbol =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(RatingSymbol, _React$PureComponent);\n\n  function RatingSymbol() {\n    _classCallCheck(this, RatingSymbol);\n\n    return _possibleConstructorReturn(this, _getPrototypeOf(RatingSymbol).apply(this, arguments));\n  }\n\n  _createClass(RatingSymbol, [{\n    key: \"render\",\n    value: function render() {\n      var _iconContainerStyle;\n\n      var _this$props = this.props,\n          index = _this$props.index,\n          inactiveIcon = _this$props.inactiveIcon,\n          activeIcon = _this$props.activeIcon,\n          percent = _this$props.percent,\n          direction = _this$props.direction,\n          readonly = _this$props.readonly,\n          onClick = _this$props.onClick,\n          onMouseMove = _this$props.onMouseMove;\n\n      var backgroundNode = _iconNode(inactiveIcon);\n\n      var showbgIcon = percent < 100;\n      var bgIconContainerStyle = showbgIcon ? {} : {\n        visibility: 'hidden'\n      };\n\n      var iconNode = _iconNode(activeIcon);\n\n      var iconContainerStyle = (_iconContainerStyle = {\n        display: 'inline-block',\n        position: 'absolute',\n        overflow: 'hidden',\n        top: 0\n      }, _defineProperty(_iconContainerStyle, direction === 'rtl' ? 'right' : 'left', 0), _defineProperty(_iconContainerStyle, \"width\", \"\".concat(percent, \"%\")), _iconContainerStyle);\n      var style = {\n        cursor: !readonly ? 'pointer' : 'inherit',\n        display: 'inline-block',\n        position: 'relative'\n      };\n\n      function handleMouseMove(e) {\n        if (onMouseMove) {\n          onMouseMove(index, e);\n        }\n      }\n\n      function handleMouseClick(e) {\n        if (onClick) {\n          // [Supporting both TouchEvent and MouseEvent](https://developer.mozilla.org/en-US/docs/Web/API/Touch_events/Supporting_both_TouchEvent_and_MouseEvent)\n          // We must prevent firing click event twice on touch devices.\n          e.preventDefault();\n          onClick(index, e);\n        }\n      }\n\n      return React.createElement(\"span\", {\n        style: style,\n        onClick: handleMouseClick,\n        onMouseMove: handleMouseMove,\n        onTouchMove: handleMouseMove,\n        onTouchEnd: handleMouseClick\n      }, React.createElement(\"span\", {\n        style: bgIconContainerStyle\n      }, backgroundNode), React.createElement(\"span\", {\n        style: iconContainerStyle\n      }, iconNode));\n    }\n  }]);\n\n  return RatingSymbol;\n}(React.PureComponent); // Define propTypes only in development. They will be void in production.\n\nvar Rating =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(Rating, _React$PureComponent);\n\n  function Rating(props) {\n    var _this;\n\n    _classCallCheck(this, Rating);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Rating).call(this, props));\n    _this.state = {\n      // Indicates the value that is displayed to the user in the form of symbols.\n      // It can be either 0 (for no displayed symbols) or (0, end]\n      displayValue: _this.props.value,\n      // Indicates if the user is currently hovering over the rating element\n      interacting: false\n    };\n    _this.onMouseLeave = _this.onMouseLeave.bind(_assertThisInitialized(_assertThisInitialized(_this)));\n    _this.symbolMouseMove = _this.symbolMouseMove.bind(_assertThisInitialized(_assertThisInitialized(_this)));\n    _this.symbolClick = _this.symbolClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));\n    return _this;\n  }\n\n  _createClass(Rating, [{\n    key: \"UNSAFE_componentWillReceiveProps\",\n    value: function UNSAFE_componentWillReceiveProps(nextProps) {\n      var valueChanged = this.props.value !== nextProps.value;\n      this.setState(function (prevState) {\n        return {\n          displayValue: valueChanged ? nextProps.value : prevState.displayValue\n        };\n      });\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      // Ignore state update due to value changed from props.\n      // Usually originated through an onClick event.\n      if (prevProps.value !== this.props.value) {\n        return;\n      } // When hover ends, call this.props.onHover with no value.\n\n\n      if (prevState.interacting && !this.state.interacting) {\n        return this.props.onHover();\n      } // When hover over.\n\n\n      if (this.state.interacting) {\n        this.props.onHover(this.state.displayValue);\n      }\n    }\n  }, {\n    key: \"symbolClick\",\n    value: function symbolClick(symbolIndex, event) {\n      var value = this.calculateDisplayValue(symbolIndex, event);\n      this.props.onClick(value, event);\n    }\n  }, {\n    key: \"symbolMouseMove\",\n    value: function symbolMouseMove(symbolIndex, event) {\n      var value = this.calculateDisplayValue(symbolIndex, event); // This call should cause an update only if the state changes.\n      // Mainly the first time the mouse enters and whenever the value changes.\n      // So DidComponentUpdate is NOT called for every mouse movement.\n\n      this.setState({\n        interacting: !this.props.readonly,\n        displayValue: value\n      });\n    }\n  }, {\n    key: \"onMouseLeave\",\n    value: function onMouseLeave() {\n      this.setState({\n        displayValue: this.props.value,\n        interacting: false\n      });\n    }\n  }, {\n    key: \"calculateDisplayValue\",\n    value: function calculateDisplayValue(symbolIndex, event) {\n      var percentage = this.calculateHoverPercentage(event); // Get the closest top fraction.\n\n      var fraction = Math.ceil(percentage % 1 * this.props.fractions) / this.props.fractions; // Truncate decimal trying to avoid float precission issues.\n\n      var precision = Math.pow(10, 3);\n      var displayValue = symbolIndex + (Math.floor(percentage) + Math.floor(fraction * precision) / precision); // ensure the returned value is greater than 0 and lower than totalSymbols\n\n      return displayValue > 0 ? displayValue > this.props.totalSymbols ? this.props.totalSymbols : displayValue : 1 / this.props.fractions;\n    }\n  }, {\n    key: \"calculateHoverPercentage\",\n    value: function calculateHoverPercentage(event) {\n      var clientX = event.nativeEvent.type.indexOf(\"touch\") > -1 ? event.nativeEvent.type.indexOf(\"touchend\") > -1 ? event.changedTouches[0].clientX : event.touches[0].clientX : event.clientX;\n      var targetRect = event.target.getBoundingClientRect();\n      var delta = this.props.direction === 'rtl' ? targetRect.right - clientX : clientX - targetRect.left; // Returning 0 if the delta is negative solves the flickering issue\n\n      return delta < 0 ? 0 : delta / targetRect.width;\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props = this.props,\n          readonly = _this$props.readonly,\n          quiet = _this$props.quiet,\n          totalSymbols = _this$props.totalSymbols,\n          value = _this$props.value,\n          placeholderValue = _this$props.placeholderValue,\n          direction = _this$props.direction,\n          emptySymbol = _this$props.emptySymbol,\n          fullSymbol = _this$props.fullSymbol,\n          placeholderSymbol = _this$props.placeholderSymbol,\n          className = _this$props.className,\n          id = _this$props.id,\n          style = _this$props.style,\n          tabIndex = _this$props.tabIndex;\n      var _this$state = this.state,\n          displayValue = _this$state.displayValue,\n          interacting = _this$state.interacting;\n      var symbolNodes = [];\n      var empty = [].concat(emptySymbol);\n      var full = [].concat(fullSymbol);\n      var placeholder = [].concat(placeholderSymbol);\n      var shouldDisplayPlaceholder = placeholderValue !== 0 && value === 0 && !interacting; // The value that will be used as base for calculating how to render the symbols\n\n      var renderedValue;\n\n      if (shouldDisplayPlaceholder) {\n        renderedValue = placeholderValue;\n      } else {\n        renderedValue = quiet ? value : displayValue;\n      } // The amount of full symbols\n\n\n      var fullSymbols = Math.floor(renderedValue);\n\n      for (var i = 0; i < totalSymbols; i++) {\n        var percent = void 0; // Calculate each symbol's fullness percentage\n\n        if (i - fullSymbols < 0) {\n          percent = 100;\n        } else if (i - fullSymbols === 0) {\n          percent = (renderedValue - i) * 100;\n        } else {\n          percent = 0;\n        }\n\n        symbolNodes.push(React.createElement(RatingSymbol, _extends({\n          key: i,\n          index: i,\n          readonly: readonly,\n          inactiveIcon: empty[i % empty.length],\n          activeIcon: shouldDisplayPlaceholder ? placeholder[i % full.length] : full[i % full.length],\n          percent: percent,\n          direction: direction\n        }, !readonly && {\n          onClick: this.symbolClick,\n          onMouseMove: this.symbolMouseMove,\n          onTouchMove: this.symbolMouseMove,\n          onTouchEnd: this.symbolClick\n        })));\n      }\n\n      return React.createElement(\"span\", _extends({\n        id: id,\n        style: _objectSpread({}, style, {\n          display: 'inline-block',\n          direction: direction\n        }),\n        className: className,\n        tabIndex: tabIndex,\n        \"aria-label\": this.props['aria-label']\n      }, !readonly && {\n        onMouseLeave: this.onMouseLeave\n      }), symbolNodes);\n    }\n  }]);\n\n  return Rating;\n}(React.PureComponent); // Define propTypes only in development.\n\nfunction noop() {}\n\nnoop._name = 'react_rating_noop';\n\nvar RatingAPILayer =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(RatingAPILayer, _React$PureComponent);\n\n  function RatingAPILayer(props) {\n    var _this;\n\n    _classCallCheck(this, RatingAPILayer);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(RatingAPILayer).call(this, props));\n    _this.state = {\n      value: props.initialRating\n    };\n    _this.handleClick = _this.handleClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));\n    _this.handleHover = _this.handleHover.bind(_assertThisInitialized(_assertThisInitialized(_this)));\n    return _this;\n  }\n\n  _createClass(RatingAPILayer, [{\n    key: \"UNSAFE_componentWillReceiveProps\",\n    value: function UNSAFE_componentWillReceiveProps(nextProps) {\n      this.setState({\n        value: nextProps.initialRating\n      });\n    }\n  }, {\n    key: \"handleClick\",\n    value: function handleClick(value, e) {\n      var _this2 = this;\n\n      var newValue = this.translateDisplayValueToValue(value);\n      this.props.onClick(newValue); // Avoid calling setState if not necessary. Micro optimisation.\n\n      if (this.state.value !== newValue) {\n        // If we have a new value trigger onChange callback.\n        this.setState({\n          value: newValue\n        }, function () {\n          return _this2.props.onChange(_this2.state.value);\n        });\n      }\n    }\n  }, {\n    key: \"handleHover\",\n    value: function handleHover(displayValue) {\n      var value = displayValue === undefined ? displayValue : this.translateDisplayValueToValue(displayValue);\n      this.props.onHover(value);\n    }\n  }, {\n    key: \"translateDisplayValueToValue\",\n    value: function translateDisplayValueToValue(displayValue) {\n      var translatedValue = displayValue * this.props.step + this.props.start; // minimum value cannot be equal to start, since it's exclusive\n\n      return translatedValue === this.props.start ? translatedValue + 1 / this.props.fractions : translatedValue;\n    }\n  }, {\n    key: \"tranlateValueToDisplayValue\",\n    value: function tranlateValueToDisplayValue(value) {\n      if (value === undefined) {\n        return 0;\n      }\n\n      return (value - this.props.start) / this.props.step;\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props = this.props,\n          step = _this$props.step,\n          emptySymbol = _this$props.emptySymbol,\n          fullSymbol = _this$props.fullSymbol,\n          placeholderSymbol = _this$props.placeholderSymbol,\n          readonly = _this$props.readonly,\n          quiet = _this$props.quiet,\n          fractions = _this$props.fractions,\n          direction = _this$props.direction,\n          start = _this$props.start,\n          stop = _this$props.stop,\n          id = _this$props.id,\n          className = _this$props.className,\n          style = _this$props.style,\n          tabIndex = _this$props.tabIndex;\n\n      function calculateTotalSymbols(start, stop, step) {\n        return Math.floor((stop - start) / step);\n      }\n\n      return React.createElement(Rating, {\n        id: id,\n        style: style,\n        className: className,\n        tabIndex: tabIndex,\n        \"aria-label\": this.props['aria-label'],\n        totalSymbols: calculateTotalSymbols(start, stop, step),\n        value: this.tranlateValueToDisplayValue(this.state.value),\n        placeholderValue: this.tranlateValueToDisplayValue(this.props.placeholderRating),\n        readonly: readonly,\n        quiet: quiet,\n        fractions: fractions,\n        direction: direction,\n        emptySymbol: emptySymbol,\n        fullSymbol: fullSymbol,\n        placeholderSymbol: placeholderSymbol,\n        onClick: this.handleClick,\n        onHover: this.handleHover\n      });\n    }\n  }]);\n\n  return RatingAPILayer;\n}(React.PureComponent);\n\nRatingAPILayer.defaultProps = {\n  start: 0,\n  stop: 5,\n  step: 1,\n  readonly: false,\n  quiet: false,\n  fractions: 1,\n  direction: 'ltr',\n  onHover: noop,\n  onClick: noop,\n  onChange: noop,\n  emptySymbol: Style.empty,\n  fullSymbol: Style.full,\n  placeholderSymbol: Style.placeholder\n}; // Define propTypes only in development.\n\nexport default RatingAPILayer;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('../cjs/use-sync-external-store-shim.production.min.js');\n} else {\n  module.exports = require('../cjs/use-sync-external-store-shim.development.js');\n}\n","/**\n * @license React\n * use-sync-external-store-shim.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var e=require(\"react\");function h(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k=\"function\"===typeof Object.is?Object.is:h,l=e.useState,m=e.useEffect,n=e.useLayoutEffect,p=e.useDebugValue;function q(a,b){var d=b(),f=l({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function(){c.value=d;c.getSnapshot=b;r(c)&&g({inst:c})},[a,d,b]);m(function(){r(c)&&g({inst:c});return a(function(){r(c)&&g({inst:c})})},[a]);p(d);return d}\nfunction r(a){var b=a.getSnapshot;a=a.value;try{var d=b();return!k(a,d)}catch(f){return!0}}function t(a,b){return b()}var u=\"undefined\"===typeof window||\"undefined\"===typeof window.document||\"undefined\"===typeof window.document.createElement?t:q;exports.useSyncExternalStore=void 0!==e.useSyncExternalStore?e.useSyncExternalStore:u;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar proxyCompare = require('proxy-compare');\n\nvar VERSION = process.env.NODE_ENV !== \"production\" ? Symbol('VERSION') : Symbol();\nvar LISTENERS = process.env.NODE_ENV !== \"production\" ? Symbol('LISTENERS') : Symbol();\nvar SNAPSHOT = process.env.NODE_ENV !== \"production\" ? Symbol('SNAPSHOT') : Symbol();\nvar HANDLER = process.env.NODE_ENV !== \"production\" ? Symbol('HANDLER') : Symbol();\nvar PROMISE_RESULT = process.env.NODE_ENV !== \"production\" ? Symbol('PROMISE_RESULT') : Symbol();\nvar PROMISE_ERROR = process.env.NODE_ENV !== \"production\" ? Symbol('PROMISE_ERROR') : Symbol();\nvar refSet = new WeakSet();\nfunction ref(o) {\n  refSet.add(o);\n  return o;\n}\n\nvar isObject = function isObject(x) {\n  return typeof x === 'object' && x !== null;\n};\n\nvar canProxy = function canProxy(x) {\n  return isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer);\n};\n\nvar proxyCache = new WeakMap();\nvar globalVersion = 1;\nvar snapshotCache = new WeakMap();\nfunction proxy(initialObject) {\n  if (initialObject === void 0) {\n    initialObject = {};\n  }\n\n  if (!isObject(initialObject)) {\n    throw new Error('object required');\n  }\n\n  var found = proxyCache.get(initialObject);\n\n  if (found) {\n    return found;\n  }\n\n  var version = globalVersion;\n  var listeners = new Set();\n\n  var notifyUpdate = function notifyUpdate(op, nextVersion) {\n    if (nextVersion === void 0) {\n      nextVersion = ++globalVersion;\n    }\n\n    if (version !== nextVersion) {\n      version = nextVersion;\n      listeners.forEach(function (listener) {\n        return listener(op, nextVersion);\n      });\n    }\n  };\n\n  var propListeners = new Map();\n\n  var getPropListener = function getPropListener(prop) {\n    var propListener = propListeners.get(prop);\n\n    if (!propListener) {\n      propListener = function propListener(op, nextVersion) {\n        var newOp = [].concat(op);\n        newOp[1] = [prop].concat(newOp[1]);\n        notifyUpdate(newOp, nextVersion);\n      };\n\n      propListeners.set(prop, propListener);\n    }\n\n    return propListener;\n  };\n\n  var popPropListener = function popPropListener(prop) {\n    var propListener = propListeners.get(prop);\n    propListeners.delete(prop);\n    return propListener;\n  };\n\n  var createSnapshot = function createSnapshot(target, receiver) {\n    var cache = snapshotCache.get(receiver);\n\n    if ((cache == null ? void 0 : cache[0]) === version) {\n      return cache[1];\n    }\n\n    var snapshot = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));\n    proxyCompare.markToTrack(snapshot, true);\n    snapshotCache.set(receiver, [version, snapshot]);\n    Reflect.ownKeys(target).forEach(function (key) {\n      var value = Reflect.get(target, key, receiver);\n\n      if (refSet.has(value)) {\n        proxyCompare.markToTrack(value, false);\n        snapshot[key] = value;\n      } else if (value instanceof Promise) {\n        if (PROMISE_RESULT in value) {\n          snapshot[key] = value[PROMISE_RESULT];\n        } else {\n          var errorOrPromise = value[PROMISE_ERROR] || value;\n          Object.defineProperty(snapshot, key, {\n            get: function get() {\n              if (PROMISE_RESULT in value) {\n                return value[PROMISE_RESULT];\n              }\n\n              throw errorOrPromise;\n            }\n          });\n        }\n      } else if (value != null && value[LISTENERS]) {\n        snapshot[key] = value[SNAPSHOT];\n      } else {\n        snapshot[key] = value;\n      }\n    });\n    Object.freeze(snapshot);\n    return snapshot;\n  };\n\n  var baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));\n  var handler = {\n    get: function get(target, prop, receiver) {\n      if (prop === VERSION) {\n        return version;\n      }\n\n      if (prop === LISTENERS) {\n        return listeners;\n      }\n\n      if (prop === SNAPSHOT) {\n        return createSnapshot(target, receiver);\n      }\n\n      if (prop === HANDLER) {\n        return handler;\n      }\n\n      return Reflect.get(target, prop, receiver);\n    },\n    deleteProperty: function deleteProperty(target, prop) {\n      var prevValue = Reflect.get(target, prop);\n      var childListeners = prevValue == null ? void 0 : prevValue[LISTENERS];\n\n      if (childListeners) {\n        childListeners.delete(popPropListener(prop));\n      }\n\n      var deleted = Reflect.deleteProperty(target, prop);\n\n      if (deleted) {\n        notifyUpdate(['delete', [prop], prevValue]);\n      }\n\n      return deleted;\n    },\n    is: Object.is,\n    canProxy: canProxy,\n    set: function set(target, prop, value, receiver) {\n      var _Object$getOwnPropert, _value;\n\n      var hasPrevValue = Reflect.has(target, prop);\n      var prevValue = Reflect.get(target, prop, receiver);\n\n      if (hasPrevValue && this.is(prevValue, value)) {\n        return true;\n      }\n\n      var childListeners = prevValue == null ? void 0 : prevValue[LISTENERS];\n\n      if (childListeners) {\n        childListeners.delete(popPropListener(prop));\n      }\n\n      if (isObject(value)) {\n        value = proxyCompare.getUntracked(value) || value;\n      }\n\n      var nextValue;\n\n      if ((_Object$getOwnPropert = Object.getOwnPropertyDescriptor(target, prop)) != null && _Object$getOwnPropert.set) {\n        nextValue = value;\n      } else if (value instanceof Promise) {\n        nextValue = value.then(function (v) {\n          nextValue[PROMISE_RESULT] = v;\n          notifyUpdate(['resolve', [prop], v]);\n          return v;\n        }).catch(function (e) {\n          nextValue[PROMISE_ERROR] = e;\n          notifyUpdate(['reject', [prop], e]);\n        });\n      } else if ((_value = value) != null && _value[LISTENERS]) {\n        nextValue = value;\n        nextValue[LISTENERS].add(getPropListener(prop));\n      } else if (this.canProxy(value)) {\n        nextValue = proxy(value);\n        nextValue[LISTENERS].add(getPropListener(prop));\n      } else {\n        nextValue = value;\n      }\n\n      Reflect.set(target, prop, nextValue, receiver);\n      notifyUpdate(['set', [prop], value, prevValue]);\n      return true;\n    }\n  };\n  var proxyObject = new Proxy(baseObject, handler);\n  proxyCache.set(initialObject, proxyObject);\n  Reflect.ownKeys(initialObject).forEach(function (key) {\n    var desc = Object.getOwnPropertyDescriptor(initialObject, key);\n\n    if (desc.get || desc.set) {\n      Object.defineProperty(baseObject, key, desc);\n    } else {\n      proxyObject[key] = initialObject[key];\n    }\n  });\n  return proxyObject;\n}\nfunction getVersion(proxyObject) {\n  return isObject(proxyObject) ? proxyObject[VERSION] : undefined;\n}\nfunction subscribe(proxyObject, callback, notifyInSync) {\n  if (process.env.NODE_ENV !== \"production\" && !(proxyObject != null && proxyObject[LISTENERS])) {\n    console.warn('Please use proxy object');\n  }\n\n  var promise;\n  var ops = [];\n\n  var listener = function listener(op) {\n    ops.push(op);\n\n    if (notifyInSync) {\n      callback(ops.splice(0));\n      return;\n    }\n\n    if (!promise) {\n      promise = Promise.resolve().then(function () {\n        promise = undefined;\n        callback(ops.splice(0));\n      });\n    }\n  };\n\n  proxyObject[LISTENERS].add(listener);\n  return function () {\n    proxyObject[LISTENERS].delete(listener);\n  };\n}\nfunction snapshot(proxyObject) {\n  if (process.env.NODE_ENV !== \"production\" && !(proxyObject != null && proxyObject[SNAPSHOT])) {\n    console.warn('Please use proxy object');\n  }\n\n  return proxyObject[SNAPSHOT];\n}\nfunction getHandler(proxyObject) {\n  if (process.env.NODE_ENV !== \"production\" && !(proxyObject != null && proxyObject[HANDLER])) {\n    console.warn('Please use proxy object');\n  }\n\n  return proxyObject[HANDLER];\n}\n\nexports.getHandler = getHandler;\nexports.getVersion = getVersion;\nexports.proxy = proxy;\nexports.ref = ref;\nexports.snapshot = snapshot;\nexports.subscribe = subscribe;\n","import arrayWithHoles from \"./arrayWithHoles\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray\";\nimport nonIterableRest from \"./nonIterableRest\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}"],"sourceRoot":""}