tldraw_0/public/workbox-ea903bce.js

define('./workbox-ea903bce.js', ['exports'], function (t) {
  'use strict'
  try {
    self['workbox:core:6.1.5'] && _()
  } catch (t) {}
  const e = (t, ...e) => {
    let s = t
    return e.length > 0 && (s += ` :: ${JSON.stringify(e)}`), s
  }
  class s extends Error {
    constructor(t, s) {
      super(e(t, s)), (this.name = t), (this.details = s)
    }
  }
  try {
    self['workbox:routing:6.1.5'] && _()
  } catch (t) {}
  const n = (t) => (t && 'object' == typeof t ? t : { handle: t })
  class i {
    constructor(t, e, s = 'GET') {
      ;(this.handler = n(e)), (this.match = t), (this.method = s)
    }
    setCatchHandler(t) {
      this.catchHandler = n(t)
    }
  }
  class r extends i {
    constructor(t, e, s) {
      super(
        ({ url: e }) => {
          const s = t.exec(e.href)
          if (s && (e.origin === location.origin || 0 === s.index))
            return s.slice(1)
        },
        e,
        s
      )
    }
  }
  class a {
    constructor() {
      ;(this.t = new Map()), (this.i = new Map())
    }
    get routes() {
      return this.t
    }
    addFetchListener() {
      self.addEventListener('fetch', (t) => {
        const { request: e } = t,
          s = this.handleRequest({ request: e, event: t })
        s && t.respondWith(s)
      })
    }
    addCacheListener() {
      self.addEventListener('message', (t) => {
        if (t.data && 'CACHE_URLS' === t.data.type) {
          const { payload: e } = t.data,
            s = Promise.all(
              e.urlsToCache.map((e) => {
                'string' == typeof e && (e = [e])
                const s = new Request(...e)
                return this.handleRequest({ request: s, event: t })
              })
            )
          t.waitUntil(s),
            t.ports && t.ports[0] && s.then(() => t.ports[0].postMessage(!0))
        }
      })
    }
    handleRequest({ request: t, event: e }) {
      const s = new URL(t.url, location.href)
      if (!s.protocol.startsWith('http')) return
      const n = s.origin === location.origin,
        { params: i, route: r } = this.findMatchingRoute({
          event: e,
          request: t,
          sameOrigin: n,
          url: s,
        })
      let a = r && r.handler
      const c = t.method
      if ((!a && this.i.has(c) && (a = this.i.get(c)), !a)) return
      let o
      try {
        o = a.handle({ url: s, request: t, event: e, params: i })
      } catch (t) {
        o = Promise.reject(t)
      }
      const h = r && r.catchHandler
      return (
        o instanceof Promise &&
          (this.o || h) &&
          (o = o.catch(async (n) => {
            if (h)
              try {
                return await h.handle({
                  url: s,
                  request: t,
                  event: e,
                  params: i,
                })
              } catch (t) {
                n = t
              }
            if (this.o) return this.o.handle({ url: s, request: t, event: e })
            throw n
          })),
        o
      )
    }
    findMatchingRoute({ url: t, sameOrigin: e, request: s, event: n }) {
      const i = this.t.get(s.method) || []
      for (const r of i) {
        let i
        const a = r.match({ url: t, sameOrigin: e, request: s, event: n })
        if (a)
          return (
            (i = a),
            ((Array.isArray(a) && 0 === a.length) ||
              (a.constructor === Object && 0 === Object.keys(a).length) ||
              'boolean' == typeof a) &&
              (i = void 0),
            { route: r, params: i }
          )
      }
      return {}
    }
    setDefaultHandler(t, e = 'GET') {
      this.i.set(e, n(t))
    }
    setCatchHandler(t) {
      this.o = n(t)
    }
    registerRoute(t) {
      this.t.has(t.method) || this.t.set(t.method, []),
        this.t.get(t.method).push(t)
    }
    unregisterRoute(t) {
      if (!this.t.has(t.method))
        throw new s('unregister-route-but-not-found-with-method', {
          method: t.method,
        })
      const e = this.t.get(t.method).indexOf(t)
      if (!(e > -1)) throw new s('unregister-route-route-not-registered')
      this.t.get(t.method).splice(e, 1)
    }
  }
  let c
  const o = () => (
    c || ((c = new a()), c.addFetchListener(), c.addCacheListener()), c
  )
  function h(t, e, n) {
    let a
    if ('string' == typeof t) {
      const s = new URL(t, location.href)
      a = new i(({ url: t }) => t.href === s.href, e, n)
    } else if (t instanceof RegExp) a = new r(t, e, n)
    else if ('function' == typeof t) a = new i(t, e, n)
    else {
      if (!(t instanceof i))
        throw new s('unsupported-route-type', {
          moduleName: 'workbox-routing',
          funcName: 'registerRoute',
          paramName: 'capture',
        })
      a = t
    }
    return o().registerRoute(a), a
  }
  try {
    self['workbox:strategies:6.1.5'] && _()
  } catch (t) {}
  const u = {
      cacheWillUpdate: async ({ response: t }) =>
        200 === t.status || 0 === t.status ? t : null,
    },
    l = {
      googleAnalytics: 'googleAnalytics',
      precache: 'precache-v2',
      prefix: 'workbox',
      runtime: 'runtime',
      suffix: 'undefined' != typeof registration ? registration.scope : '',
    },
    f = (t) =>
      [l.prefix, t, l.suffix].filter((t) => t && t.length > 0).join('-'),
    w = (t) => t || f(l.precache),
    d = (t) => t || f(l.runtime)
  function p() {
    return (p =
      Object.assign ||
      function (t) {
        for (var e = 1; e < arguments.length; e++) {
          var s = arguments[e]
          for (var n in s)
            Object.prototype.hasOwnProperty.call(s, n) && (t[n] = s[n])
        }
        return t
      }).apply(this, arguments)
  }
  function y(t, e) {
    const s = new URL(t)
    for (const t of e) s.searchParams.delete(t)
    return s.href
  }
  class m {
    constructor() {
      this.promise = new Promise((t, e) => {
        ;(this.resolve = t), (this.reject = e)
      })
    }
  }
  const g = new Set()
  function R(t) {
    return 'string' == typeof t ? new Request(t) : t
  }
  class v {
    constructor(t, e) {
      ;(this.h = {}),
        Object.assign(this, e),
        (this.event = e.event),
        (this.u = t),
        (this.l = new m()),
        (this.p = []),
        (this.m = [...t.plugins]),
        (this.g = new Map())
      for (const t of this.m) this.g.set(t, {})
      this.event.waitUntil(this.l.promise)
    }
    async fetch(t) {
      const { event: e } = this
      let n = R(t)
      if (
        'navigate' === n.mode &&
        e instanceof FetchEvent &&
        e.preloadResponse
      ) {
        const t = await e.preloadResponse
        if (t) return t
      }
      const i = this.hasCallback('fetchDidFail') ? n.clone() : null
      try {
        for (const t of this.iterateCallbacks('requestWillFetch'))
          n = await t({ request: n.clone(), event: e })
      } catch (t) {
        throw new s('plugin-error-request-will-fetch', { thrownError: t })
      }
      const r = n.clone()
      try {
        let t
        t = await fetch(n, 'navigate' === n.mode ? void 0 : this.u.fetchOptions)
        for (const s of this.iterateCallbacks('fetchDidSucceed'))
          t = await s({ event: e, request: r, response: t })
        return t
      } catch (t) {
        throw (
          (i &&
            (await this.runCallbacks('fetchDidFail', {
              error: t,
              event: e,
              originalRequest: i.clone(),
              request: r.clone(),
            })),
          t)
        )
      }
    }
    async fetchAndCachePut(t) {
      const e = await this.fetch(t),
        s = e.clone()
      return this.waitUntil(this.cachePut(t, s)), e
    }
    async cacheMatch(t) {
      const e = R(t)
      let s
      const { cacheName: n, matchOptions: i } = this.u,
        r = await this.getCacheKey(e, 'read'),
        a = p({}, i, { cacheName: n })
      s = await caches.match(r, a)
      for (const t of this.iterateCallbacks('cachedResponseWillBeUsed'))
        s =
          (await t({
            cacheName: n,
            matchOptions: i,
            cachedResponse: s,
            request: r,
            event: this.event,
          })) || void 0
      return s
    }
    async cachePut(t, e) {
      const n = R(t)
      var i
      await ((i = 0), new Promise((t) => setTimeout(t, i)))
      const r = await this.getCacheKey(n, 'write')
      if (!e)
        throw new s('cache-put-with-no-response', {
          url:
            ((a = r.url),
            new URL(String(a), location.href).href.replace(
              new RegExp(`^${location.origin}`),
              ''
            )),
        })
      var a
      const c = await this.R(e)
      if (!c) return !1
      const { cacheName: o, matchOptions: h } = this.u,
        u = await self.caches.open(o),
        l = this.hasCallback('cacheDidUpdate'),
        f = l
          ? await (async function (t, e, s, n) {
              const i = y(e.url, s)
              if (e.url === i) return t.match(e, n)
              const r = p({}, n, { ignoreSearch: !0 }),
                a = await t.keys(e, r)
              for (const e of a) if (i === y(e.url, s)) return t.match(e, n)
            })(u, r.clone(), ['__WB_REVISION__'], h)
          : null
      try {
        await u.put(r, l ? c.clone() : c)
      } catch (t) {
        throw (
          ('QuotaExceededError' === t.name &&
            (await (async function () {
              for (const t of g) await t()
            })()),
          t)
        )
      }
      for (const t of this.iterateCallbacks('cacheDidUpdate'))
        await t({
          cacheName: o,
          oldResponse: f,
          newResponse: c.clone(),
          request: r,
          event: this.event,
        })
      return !0
    }
    async getCacheKey(t, e) {
      if (!this.h[e]) {
        let s = t
        for (const t of this.iterateCallbacks('cacheKeyWillBeUsed'))
          s = R(
            await t({
              mode: e,
              request: s,
              event: this.event,
              params: this.params,
            })
          )
        this.h[e] = s
      }
      return this.h[e]
    }
    hasCallback(t) {
      for (const e of this.u.plugins) if (t in e) return !0
      return !1
    }
    async runCallbacks(t, e) {
      for (const s of this.iterateCallbacks(t)) await s(e)
    }
    *iterateCallbacks(t) {
      for (const e of this.u.plugins)
        if ('function' == typeof e[t]) {
          const s = this.g.get(e),
            n = (n) => {
              const i = p({}, n, { state: s })
              return e[t](i)
            }
          yield n
        }
    }
    waitUntil(t) {
      return this.p.push(t), t
    }
    async doneWaiting() {
      let t
      for (; (t = this.p.shift()); ) await t
    }
    destroy() {
      this.l.resolve()
    }
    async R(t) {
      let e = t,
        s = !1
      for (const t of this.iterateCallbacks('cacheWillUpdate'))
        if (
          ((e =
            (await t({
              request: this.request,
              response: e,
              event: this.event,
            })) || void 0),
          (s = !0),
          !e)
        )
          break
      return s || (e && 200 !== e.status && (e = void 0)), e
    }
  }
  class q {
    constructor(t = {}) {
      ;(this.cacheName = d(t.cacheName)),
        (this.plugins = t.plugins || []),
        (this.fetchOptions = t.fetchOptions),
        (this.matchOptions = t.matchOptions)
    }
    handle(t) {
      const [e] = this.handleAll(t)
      return e
    }
    handleAll(t) {
      t instanceof FetchEvent && (t = { event: t, request: t.request })
      const e = t.event,
        s = 'string' == typeof t.request ? new Request(t.request) : t.request,
        n = 'params' in t ? t.params : void 0,
        i = new v(this, { event: e, request: s, params: n }),
        r = this.v(i, s, e)
      return [r, this.q(r, i, s, e)]
    }
    async v(t, e, n) {
      let i
      await t.runCallbacks('handlerWillStart', { event: n, request: e })
      try {
        if (((i = await this.U(e, t)), !i || 'error' === i.type))
          throw new s('no-response', { url: e.url })
      } catch (s) {
        for (const r of t.iterateCallbacks('handlerDidError'))
          if (((i = await r({ error: s, event: n, request: e })), i)) break
        if (!i) throw s
      }
      for (const s of t.iterateCallbacks('handlerWillRespond'))
        i = await s({ event: n, request: e, response: i })
      return i
    }
    async q(t, e, s, n) {
      let i, r
      try {
        i = await t
      } catch (r) {}
      try {
        await e.runCallbacks('handlerDidRespond', {
          event: n,
          request: s,
          response: i,
        }),
          await e.doneWaiting()
      } catch (t) {
        r = t
      }
      if (
        (await e.runCallbacks('handlerDidComplete', {
          event: n,
          request: s,
          response: i,
          error: r,
        }),
        e.destroy(),
        r)
      )
        throw r
    }
  }
  function U(t) {
    t.then(() => {})
  }
  class x {
    constructor(t, e, { onupgradeneeded: s, onversionchange: n } = {}) {
      ;(this._ = null),
        (this.L = t),
        (this.N = e),
        (this.C = s),
        (this.D = n || (() => this.close()))
    }
    get db() {
      return this._
    }
    async open() {
      if (!this._)
        return (
          (this._ = await new Promise((t, e) => {
            let s = !1
            setTimeout(() => {
              ;(s = !0),
                e(new Error('The open request was blocked and timed out'))
            }, this.OPEN_TIMEOUT)
            const n = indexedDB.open(this.L, this.N)
            ;(n.onerror = () => e(n.error)),
              (n.onupgradeneeded = (t) => {
                s
                  ? (n.transaction.abort(), n.result.close())
                  : 'function' == typeof this.C && this.C(t)
              }),
              (n.onsuccess = () => {
                const e = n.result
                s ? e.close() : ((e.onversionchange = this.D.bind(this)), t(e))
              })
          })),
          this
        )
    }
    async getKey(t, e) {
      return (await this.getAllKeys(t, e, 1))[0]
    }
    async getAll(t, e, s) {
      return await this.getAllMatching(t, { query: e, count: s })
    }
    async getAllKeys(t, e, s) {
      return (
        await this.getAllMatching(t, { query: e, count: s, includeKeys: !0 })
      ).map((t) => t.key)
    }
    async getAllMatching(
      t,
      {
        index: e,
        query: s = null,
        direction: n = 'next',
        count: i,
        includeKeys: r = !1,
      } = {}
    ) {
      return await this.transaction([t], 'readonly', (a, c) => {
        const o = a.objectStore(t),
          h = e ? o.index(e) : o,
          u = [],
          l = h.openCursor(s, n)
        l.onsuccess = () => {
          const t = l.result
          t
            ? (u.push(r ? t : t.value),
              i && u.length >= i ? c(u) : t.continue())
            : c(u)
        }
      })
    }
    async transaction(t, e, s) {
      return (
        await this.open(),
        await new Promise((n, i) => {
          const r = this._.transaction(t, e)
          ;(r.onabort = () => i(r.error)),
            (r.oncomplete = () => n()),
            s(r, (t) => n(t))
        })
      )
    }
    async T(t, e, s, ...n) {
      return await this.transaction([e], s, (s, i) => {
        const r = s.objectStore(e),
          a = r[t].apply(r, n)
        a.onsuccess = () => i(a.result)
      })
    }
    close() {
      this._ && (this._.close(), (this._ = null))
    }
  }
  x.prototype.OPEN_TIMEOUT = 2e3
  const b = {
    readonly: ['get', 'count', 'getKey', 'getAll', 'getAllKeys'],
    readwrite: ['add', 'put', 'clear', 'delete'],
  }
  for (const [t, e] of Object.entries(b))
    for (const s of e)
      s in IDBObjectStore.prototype &&
        (x.prototype[s] = async function (e, ...n) {
          return await this.T(s, e, t, ...n)
        })
  try {
    self['workbox:expiration:6.1.5'] && _()
  } catch (t) {}
  const L = 'cache-entries',
    N = (t) => {
      const e = new URL(t, location.href)
      return (e.hash = ''), e.href
    }
  class C {
    constructor(t) {
      ;(this.P = t),
        (this._ = new x('workbox-expiration', 1, {
          onupgradeneeded: (t) => this.k(t),
        }))
    }
    k(t) {
      const e = t.target.result.createObjectStore(L, { keyPath: 'id' })
      e.createIndex('cacheName', 'cacheName', { unique: !1 }),
        e.createIndex('timestamp', 'timestamp', { unique: !1 }),
        (async (t) => {
          await new Promise((e, s) => {
            const n = indexedDB.deleteDatabase(t)
            ;(n.onerror = () => {
              s(n.error)
            }),
              (n.onblocked = () => {
                s(new Error('Delete blocked'))
              }),
              (n.onsuccess = () => {
                e()
              })
          })
        })(this.P)
    }
    async setTimestamp(t, e) {
      const s = {
        url: (t = N(t)),
        timestamp: e,
        cacheName: this.P,
        id: this.K(t),
      }
      await this._.put(L, s)
    }
    async getTimestamp(t) {
      return (await this._.get(L, this.K(t))).timestamp
    }
    async expireEntries(t, e) {
      const s = await this._.transaction(L, 'readwrite', (s, n) => {
          const i = s
              .objectStore(L)
              .index('timestamp')
              .openCursor(null, 'prev'),
            r = []
          let a = 0
          i.onsuccess = () => {
            const s = i.result
            if (s) {
              const n = s.value
              n.cacheName === this.P &&
                ((t && n.timestamp < t) || (e && a >= e)
                  ? r.push(s.value)
                  : a++),
                s.continue()
            } else n(r)
          }
        }),
        n = []
      for (const t of s) await this._.delete(L, t.id), n.push(t.url)
      return n
    }
    K(t) {
      return this.P + '|' + N(t)
    }
  }
  class E {
    constructor(t, e = {}) {
      ;(this.O = !1),
        (this.W = !1),
        (this.M = e.maxEntries),
        (this.A = e.maxAgeSeconds),
        (this.S = e.matchOptions),
        (this.P = t),
        (this.I = new C(t))
    }
    async expireEntries() {
      if (this.O) return void (this.W = !0)
      this.O = !0
      const t = this.A ? Date.now() - 1e3 * this.A : 0,
        e = await this.I.expireEntries(t, this.M),
        s = await self.caches.open(this.P)
      for (const t of e) await s.delete(t, this.S)
      ;(this.O = !1), this.W && ((this.W = !1), U(this.expireEntries()))
    }
    async updateTimestamp(t) {
      await this.I.setTimestamp(t, Date.now())
    }
    async isURLExpired(t) {
      if (this.A) {
        return (await this.I.getTimestamp(t)) < Date.now() - 1e3 * this.A
      }
      return !1
    }
    async delete() {
      ;(this.W = !1), await this.I.expireEntries(1 / 0)
    }
  }
  function D(t, e) {
    const s = e()
    return t.waitUntil(s), s
  }
  try {
    self['workbox:precaching:6.1.5'] && _()
  } catch (t) {}
  function T(t) {
    if (!t) throw new s('add-to-cache-list-unexpected-type', { entry: t })
    if ('string' == typeof t) {
      const e = new URL(t, location.href)
      return { cacheKey: e.href, url: e.href }
    }
    const { revision: e, url: n } = t
    if (!n) throw new s('add-to-cache-list-unexpected-type', { entry: t })
    if (!e) {
      const t = new URL(n, location.href)
      return { cacheKey: t.href, url: t.href }
    }
    const i = new URL(n, location.href),
      r = new URL(n, location.href)
    return (
      i.searchParams.set('__WB_REVISION__', e),
      { cacheKey: i.href, url: r.href }
    )
  }
  class P {
    constructor() {
      ;(this.updatedURLs = []),
        (this.notUpdatedURLs = []),
        (this.handlerWillStart = async ({ request: t, state: e }) => {
          e && (e.originalRequest = t)
        }),
        (this.cachedResponseWillBeUsed = async ({
          event: t,
          state: e,
          cachedResponse: s,
        }) => {
          if ('install' === t.type) {
            const t = e.originalRequest.url
            s ? this.notUpdatedURLs.push(t) : this.updatedURLs.push(t)
          }
          return s
        })
    }
  }
  class k {
    constructor({ precacheController: t }) {
      ;(this.cacheKeyWillBeUsed = async ({ request: t, params: e }) => {
        const s = (e && e.cacheKey) || this.j.getCacheKeyForURL(t.url)
        return s ? new Request(s) : t
      }),
        (this.j = t)
    }
  }
  let K, O
  async function W(t, e) {
    let n = null
    if (t.url) {
      n = new URL(t.url).origin
    }
    if (n !== self.location.origin)
      throw new s('cross-origin-copy-response', { origin: n })
    const i = t.clone(),
      r = {
        headers: new Headers(i.headers),
        status: i.status,
        statusText: i.statusText,
      },
      a = e ? e(r) : r,
      c = (function () {
        if (void 0 === K) {
          const t = new Response('')
          if ('body' in t)
            try {
              new Response(t.body), (K = !0)
            } catch (t) {
              K = !1
            }
          K = !1
        }
        return K
      })()
        ? i.body
        : await i.blob()
    return new Response(c, a)
  }
  class M extends q {
    constructor(t = {}) {
      ;(t.cacheName = w(t.cacheName)),
        super(t),
        (this.F = !1 !== t.fallbackToNetwork),
        this.plugins.push(M.copyRedirectedCacheableResponsesPlugin)
    }
    async U(t, e) {
      const s = await e.cacheMatch(t)
      return (
        s ||
        (e.event && 'install' === e.event.type
          ? await this.B(t, e)
          : await this.H(t, e))
      )
    }
    async H(t, e) {
      let n
      if (!this.F)
        throw new s('missing-precache-entry', {
          cacheName: this.cacheName,
          url: t.url,
        })
      return (n = await e.fetch(t)), n
    }
    async B(t, e) {
      this.$()
      const n = await e.fetch(t)
      if (!(await e.cachePut(t, n.clone())))
        throw new s('bad-precaching-response', { url: t.url, status: n.status })
      return n
    }
    $() {
      let t = null,
        e = 0
      for (const [s, n] of this.plugins.entries())
        n !== M.copyRedirectedCacheableResponsesPlugin &&
          (n === M.defaultPrecacheCacheabilityPlugin && (t = s),
          n.cacheWillUpdate && e++)
      0 === e
        ? this.plugins.push(M.defaultPrecacheCacheabilityPlugin)
        : e > 1 && null !== t && this.plugins.splice(t, 1)
    }
  }
  ;(M.defaultPrecacheCacheabilityPlugin = {
    cacheWillUpdate: async ({ response: t }) =>
      !t || t.status >= 400 ? null : t,
  }),
    (M.copyRedirectedCacheableResponsesPlugin = {
      cacheWillUpdate: async ({ response: t }) =>
        t.redirected ? await W(t) : t,
    })
  class A {
    constructor({
      cacheName: t,
      plugins: e = [],
      fallbackToNetwork: s = !0,
    } = {}) {
      ;(this.G = new Map()),
        (this.V = new Map()),
        (this.J = new Map()),
        (this.u = new M({
          cacheName: w(t),
          plugins: [...e, new k({ precacheController: this })],
          fallbackToNetwork: s,
        })),
        (this.install = this.install.bind(this)),
        (this.activate = this.activate.bind(this))
    }
    get strategy() {
      return this.u
    }
    precache(t) {
      this.addToCacheList(t),
        this.X ||
          (self.addEventListener('install', this.install),
          self.addEventListener('activate', this.activate),
          (this.X = !0))
    }
    addToCacheList(t) {
      const e = []
      for (const n of t) {
        'string' == typeof n
          ? e.push(n)
          : n && void 0 === n.revision && e.push(n.url)
        const { cacheKey: t, url: i } = T(n),
          r = 'string' != typeof n && n.revision ? 'reload' : 'default'
        if (this.G.has(i) && this.G.get(i) !== t)
          throw new s('add-to-cache-list-conflicting-entries', {
            firstEntry: this.G.get(i),
            secondEntry: t,
          })
        if ('string' != typeof n && n.integrity) {
          if (this.J.has(t) && this.J.get(t) !== n.integrity)
            throw new s('add-to-cache-list-conflicting-integrities', { url: i })
          this.J.set(t, n.integrity)
        }
        if ((this.G.set(i, t), this.V.set(i, r), e.length > 0)) {
          const t = `Workbox is precaching URLs without revision info: ${e.join(
            ', '
          )}\nThis is generally NOT safe. Learn more at https://bit.ly/wb-precache`
          console.warn(t)
        }
      }
    }
    install(t) {
      return D(t, async () => {
        const e = new P()
        this.strategy.plugins.push(e)
        for (const [e, s] of this.G) {
          const n = this.J.get(s),
            i = this.V.get(e),
            r = new Request(e, {
              integrity: n,
              cache: i,
              credentials: 'same-origin',
            })
          await Promise.all(
            this.strategy.handleAll({
              params: { cacheKey: s },
              request: r,
              event: t,
            })
          )
        }
        const { updatedURLs: s, notUpdatedURLs: n } = e
        return { updatedURLs: s, notUpdatedURLs: n }
      })
    }
    activate(t) {
      return D(t, async () => {
        const t = await self.caches.open(this.strategy.cacheName),
          e = await t.keys(),
          s = new Set(this.G.values()),
          n = []
        for (const i of e) s.has(i.url) || (await t.delete(i), n.push(i.url))
        return { deletedURLs: n }
      })
    }
    getURLsToCacheKeys() {
      return this.G
    }
    getCachedURLs() {
      return [...this.G.keys()]
    }
    getCacheKeyForURL(t) {
      const e = new URL(t, location.href)
      return this.G.get(e.href)
    }
    async matchPrecache(t) {
      const e = t instanceof Request ? t.url : t,
        s = this.getCacheKeyForURL(e)
      if (s) {
        return (await self.caches.open(this.strategy.cacheName)).match(s)
      }
    }
    createHandlerBoundToURL(t) {
      const e = this.getCacheKeyForURL(t)
      if (!e) throw new s('non-precached-url', { url: t })
      return (s) => (
        (s.request = new Request(t)),
        (s.params = p({ cacheKey: e }, s.params)),
        this.strategy.handle(s)
      )
    }
  }
  const S = () => (O || (O = new A()), O)
  class I extends i {
    constructor(t, e) {
      super(({ request: s }) => {
        const n = t.getURLsToCacheKeys()
        for (const t of (function* (
          t,
          {
            ignoreURLParametersMatching: e = [/^utm_/, /^fbclid$/],
            directoryIndex: s = 'index.html',
            cleanURLs: n = !0,
            urlManipulation: i,
          } = {}
        ) {
          const r = new URL(t, location.href)
          ;(r.hash = ''), yield r.href
          const a = (function (t, e = []) {
            for (const s of [...t.searchParams.keys()])
              e.some((t) => t.test(s)) && t.searchParams.delete(s)
            return t
          })(r, e)
          if ((yield a.href, s && a.pathname.endsWith('/'))) {
            const t = new URL(a.href)
            ;(t.pathname += s), yield t.href
          }
          if (n) {
            const t = new URL(a.href)
            ;(t.pathname += '.html'), yield t.href
          }
          if (i) {
            const t = i({ url: r })
            for (const e of t) yield e.href
          }
        })(s.url, e)) {
          const e = n.get(t)
          if (e) return { cacheKey: e }
        }
      }, t.strategy)
    }
  }
  ;(t.CacheFirst = class extends q {
    async U(t, e) {
      let n,
        i = await e.cacheMatch(t)
      if (!i)
        try {
          i = await e.fetchAndCachePut(t)
        } catch (t) {
          n = t
        }
      if (!i) throw new s('no-response', { url: t.url, error: n })
      return i
    }
  }),
    (t.ExpirationPlugin = class {
      constructor(t = {}) {
        var e
        ;(this.cachedResponseWillBeUsed = async ({
          event: t,
          request: e,
          cacheName: s,
          cachedResponse: n,
        }) => {
          if (!n) return null
          const i = this.Y(n),
            r = this.Z(s)
          U(r.expireEntries())
          const a = r.updateTimestamp(e.url)
          if (t)
            try {
              t.waitUntil(a)
            } catch (t) {}
          return i ? n : null
        }),
          (this.cacheDidUpdate = async ({ cacheName: t, request: e }) => {
            const s = this.Z(t)
            await s.updateTimestamp(e.url), await s.expireEntries()
          }),
          (this.tt = t),
          (this.A = t.maxAgeSeconds),
          (this.et = new Map()),
          t.purgeOnQuotaError &&
            ((e = () => this.deleteCacheAndMetadata()), g.add(e))
      }
      Z(t) {
        if (t === d()) throw new s('expire-custom-caches-only')
        let e = this.et.get(t)
        return e || ((e = new E(t, this.tt)), this.et.set(t, e)), e
      }
      Y(t) {
        if (!this.A) return !0
        const e = this.st(t)
        if (null === e) return !0
        return e >= Date.now() - 1e3 * this.A
      }
      st(t) {
        if (!t.headers.has('date')) return null
        const e = t.headers.get('date'),
          s = new Date(e).getTime()
        return isNaN(s) ? null : s
      }
      async deleteCacheAndMetadata() {
        for (const [t, e] of this.et)
          await self.caches.delete(t), await e.delete()
        this.et = new Map()
      }
    }),
    (t.NetworkFirst = class extends q {
      constructor(t = {}) {
        super(t),
          this.plugins.some((t) => 'cacheWillUpdate' in t) ||
            this.plugins.unshift(u),
          (this.nt = t.networkTimeoutSeconds || 0)
      }
      async U(t, e) {
        const n = [],
          i = []
        let r
        if (this.nt) {
          const { id: s, promise: a } = this.it({
            request: t,
            logs: n,
            handler: e,
          })
          ;(r = s), i.push(a)
        }
        const a = this.rt({ timeoutId: r, request: t, logs: n, handler: e })
        i.push(a)
        const c = await e.waitUntil(
          (async () => (await e.waitUntil(Promise.race(i))) || (await a))()
        )
        if (!c) throw new s('no-response', { url: t.url })
        return c
      }
      it({ request: t, logs: e, handler: s }) {
        let n
        return {
          promise: new Promise((e) => {
            n = setTimeout(async () => {
              e(await s.cacheMatch(t))
            }, 1e3 * this.nt)
          }),
          id: n,
        }
      }
      async rt({ timeoutId: t, request: e, logs: s, handler: n }) {
        let i, r
        try {
          r = await n.fetchAndCachePut(e)
        } catch (t) {
          i = t
        }
        return t && clearTimeout(t), (!i && r) || (r = await n.cacheMatch(e)), r
      }
    }),
    (t.StaleWhileRevalidate = class extends q {
      constructor(t) {
        super(t),
          this.plugins.some((t) => 'cacheWillUpdate' in t) ||
            this.plugins.unshift(u)
      }
      async U(t, e) {
        const n = e.fetchAndCachePut(t).catch(() => {})
        let i,
          r = await e.cacheMatch(t)
        if (r);
        else
          try {
            r = await n
          } catch (t) {
            i = t
          }
        if (!r) throw new s('no-response', { url: t.url, error: i })
        return r
      }
    }),
    (t.cleanupOutdatedCaches = function () {
      self.addEventListener('activate', (t) => {
        const e = w()
        t.waitUntil(
          (async (t, e = '-precache-') => {
            const s = (await self.caches.keys()).filter(
              (s) =>
                s.includes(e) && s.includes(self.registration.scope) && s !== t
            )
            return await Promise.all(s.map((t) => self.caches.delete(t))), s
          })(e).then((t) => {})
        )
      })
    }),
    (t.clientsClaim = function () {
      self.addEventListener('activate', () => self.clients.claim())
    }),
    (t.precacheAndRoute = function (t, e) {
      !(function (t) {
        S().precache(t)
      })(t),
        (function (t) {
          const e = S()
          h(new I(e, t))
        })(e)
    }),
    (t.registerRoute = h)
})
//# sourceMappingURL=workbox-ea903bce.js.map