@bravophone/webphone 0.1.2 → 0.2.1

package/host/shim/chrome-shim.js

@@ -0,0 +1,287 @@
+/*!
+ * chrome-shim.js — implementa a superfície de `chrome.*` que o bundle do
+ * webphone usa, para que popup.js rode numa página comum, fora da extensão.
+ *
+ * PRECISA carregar ANTES de libwebphone.js e popup.js.
+ *
+ * Superfície coberta (levantada do popup.js / bravophone-route-selector.js /
+ * bravophone-noise-suppressor.js da extensão):
+ *   chrome.storage.sync|local|session .get .set .remove .clear .onChanged
+ *   chrome.runtime .onMessage .sendMessage .lastError .getURL .id
+ *   chrome.tabs .create .sendMessage
+ *   chrome.windows .create .update .get .getCurrent
+ */
+;(function () {
+  'use strict'
+  // Se estivermos dentro da extensão real, não toca em nada.
+  if (window.chrome && window.chrome.storage && window.chrome.runtime && window.chrome.runtime.id) return
+
+  var PREFIX = 'bp.'
+  var listeners = { storage: [], message: [] }
+
+  // Aceita callback OU Promise, como a API MV3 faz.
+  function settle(cb, value) {
+    if (typeof cb === 'function') { cb(value); return Promise.resolve(value) }
+    return Promise.resolve(value)
+  }
+
+  function makeArea(area) {
+    var ns = PREFIX + area + '.'
+
+    function readKey(key) {
+      var raw = localStorage.getItem(ns + key)
+      if (raw === null) return undefined
+      try { return JSON.parse(raw) } catch (_) { return raw }
+    }
+
+    function allKeys() {
+      var out = []
+      for (var i = 0; i < localStorage.length; i++) {
+        var k = localStorage.key(i)
+        if (k && k.indexOf(ns) === 0) out.push(k.slice(ns.length))
+      }
+      return out
+    }
+
+    return {
+      get: function (keys, cb) {
+        if (typeof keys === 'function') { cb = keys; keys = null }
+        var result = {}
+        try {
+          if (keys === null || keys === undefined) {
+            allKeys().forEach(function (k) { result[k] = readKey(k) })
+          } else if (typeof keys === 'string') {
+            var v = readKey(keys)
+            if (v !== undefined) result[keys] = v
+          } else if (Array.isArray(keys)) {
+            keys.forEach(function (k) {
+              var val = readKey(k)
+              if (val !== undefined) result[k] = val
+            })
+          } else if (typeof keys === 'object') {
+            // objeto = mapa de defaults
+            Object.keys(keys).forEach(function (k) {
+              var val = readKey(k)
+              result[k] = val === undefined ? keys[k] : val
+            })
+          }
+        } catch (err) { console.warn('[bp-shim] storage.get:', err) }
+        return settle(cb, result)
+      },
+
+      set: function (items, cb) {
+        var changes = {}
+        try {
+          Object.keys(items || {}).forEach(function (k) {
+            var oldValue = readKey(k)
+            localStorage.setItem(ns + k, JSON.stringify(items[k]))
+            changes[k] = { oldValue: oldValue, newValue: items[k] }
+          })
+        } catch (err) {
+          // Cota estourada é o caso real aqui (localStorage ~5 MB por origem).
+          console.warn('[bp-shim] storage.set:', err)
+        }
+        fireStorage(changes, area)
+        return settle(cb, undefined)
+      },
+
+      remove: function (keys, cb) {
+        var list = Array.isArray(keys) ? keys : [keys]
+        var changes = {}
+        list.forEach(function (k) {
+          changes[k] = { oldValue: readKey(k) }
+          localStorage.removeItem(ns + k)
+        })
+        fireStorage(changes, area)
+        return settle(cb, undefined)
+      },
+
+      clear: function (cb) {
+        var changes = {}
+        allKeys().forEach(function (k) {
+          changes[k] = { oldValue: readKey(k) }
+          localStorage.removeItem(ns + k)
+        })
+        fireStorage(changes, area)
+        return settle(cb, undefined)
+      },
+    }
+  }
+
+  function fireStorage(changes, area) {
+    if (!changes || !Object.keys(changes).length) return
+    listeners.storage.forEach(function (fn) {
+      try { fn(changes, area) } catch (err) { console.error('[bp-shim] onChanged:', err) }
+    })
+  }
+
+  function makeEvent(bucket) {
+    return {
+      addListener: function (fn) { if (bucket.indexOf(fn) === -1) bucket.push(fn) },
+      removeListener: function (fn) {
+        var i = bucket.indexOf(fn)
+        if (i !== -1) bucket.splice(i, 1)
+      },
+      hasListener: function (fn) { return bucket.indexOf(fn) !== -1 },
+      hasListeners: function () { return bucket.length > 0 },
+    }
+  }
+
+  function bridgeEmit(name, payload) {
+    if (window.__bpBridge && typeof window.__bpBridge.emit === 'function') {
+      window.__bpBridge.emit(name, payload)
+    }
+  }
+
+  var chromeShim = {
+    storage: {
+      sync: makeArea('sync'),
+      local: makeArea('local'),
+      session: makeArea('session'),
+      onChanged: makeEvent(listeners.storage),
+    },
+
+    runtime: {
+      id: 'bravophone-embed',
+      // lastError sempre undefined: sem IPC, não há erro assíncrono de canal.
+      lastError: undefined,
+      getURL: function (path) {
+        return new URL(String(path).replace(/^\/+/, ''), document.baseURI).href
+      },
+      onMessage: makeEvent(listeners.message),
+      sendMessage: function (a, b, c) {
+        // Assinaturas: (msg), (msg, cb), (extId, msg), (extId, msg, cb)
+        var msg = typeof a === 'string' && b !== undefined ? b : a
+        var cb = typeof c === 'function' ? c : typeof b === 'function' ? b : undefined
+        var responded = false
+        var reply = function (r) { if (!responded) { responded = true; if (cb) cb(r) } }
+        listeners.message.forEach(function (fn) {
+          try { fn(msg, { id: 'bravophone-embed', url: location.href }, reply) } catch (err) {
+            console.error('[bp-shim] onMessage:', err)
+          }
+        })
+        if (!responded) reply(undefined)
+        return Promise.resolve(undefined)
+      },
+      connect: function () {
+        return {
+          postMessage: function () {},
+          disconnect: function () {},
+          onMessage: makeEvent([]),
+          onDisconnect: makeEvent([]),
+        }
+      },
+      getManifest: function () { return { version: '0.1.0', name: 'Bravophone Embed' } },
+    },
+
+    tabs: {
+      // No embed não há abas: abrir link vira uma nova aba do browser mesmo.
+      create: function (props, cb) {
+        var win = window.open(props && props.url, '_blank', 'noopener,noreferrer')
+        return settle(cb, { id: Date.now(), url: props && props.url, window: win ? 1 : 0 })
+      },
+      query: function (_q, cb) { return settle(cb, []) },
+      sendMessage: function (_tabId, msg, cb) { return chromeShim.runtime.sendMessage(msg, cb) },
+      update: function (_id, _props, cb) { return settle(cb, {}) },
+    },
+
+    windows: {
+      // A "janela" agora é o widget arrastável no host: estes stubs mantêm o
+      // bundle funcionando e delegam ao host o que faz sentido.
+      WINDOW_ID_CURRENT: -2,
+      create: function (props, cb) {
+        bridgeEmit('window:create', props)
+        return settle(cb, Object.assign({ id: 1 }, props))
+      },
+      update: function (id, props, cb) {
+        if (props && (props.width || props.height)) {
+          bridgeEmit('window:resize', { width: props.width, height: props.height })
+        }
+        if (props && props.focused) bridgeEmit('window:focus', {})
+        return settle(cb, Object.assign({ id: id }, props))
+      },
+      get: function (id, info, cb) {
+        var callback = typeof info === 'function' ? info : cb
+        return settle(callback, { id: id, width: window.innerWidth, height: window.innerHeight })
+      },
+      getCurrent: function (info, cb) {
+        var callback = typeof info === 'function' ? info : cb
+        return settle(callback, {
+          id: 1,
+          width: window.innerWidth,
+          height: window.innerHeight,
+          focused: document.hasFocus(),
+        })
+      },
+      remove: function (_id, cb) {
+        bridgeEmit('window:close', {})
+        return settle(cb, undefined)
+      },
+    },
+
+    contextMenus: { create: function () {}, removeAll: function (cb) { return settle(cb, undefined) } },
+    scripting: { executeScript: function (_o, cb) { return settle(cb, []) } },
+    action: {
+      setBadgeText: function (_o, cb) { return settle(cb, undefined) },
+      setIcon: function (_o, cb) { return settle(cb, undefined) },
+    },
+    i18n: {
+      /**
+       * As mensagens vêm de shim/messages.js, gerado do _locales/ da extensão.
+       * O bundle expõe `t(k){ return chrome.i18n.getMessage(k) }` e os
+       * templates usam isso para quase todo label — sem estas mensagens a
+       * interface renderiza sem texto nenhum.
+       */
+      getMessage: function (key, substitutions) {
+        var table = window.__bpMessages
+        if (!table) {
+          if (!chromeShim.i18n._warned) {
+            chromeShim.i18n._warned = true
+            console.error('[bp-shim] __bpMessages ausente: a UI vai aparecer sem textos. ' +
+              'Rode `npm run sync` para gerar shim/messages.js.')
+          }
+          return ''
+        }
+        var entry = table[key]
+        if (!entry) return ''
+        var msg = entry.message || ''
+
+        // Placeholders nomeados do messages.json: "$USER$" -> content "$1".
+        if (entry.placeholders) {
+          Object.keys(entry.placeholders).forEach(function (name) {
+            var ph = entry.placeholders[name]
+            // A string precisa levar DUAS barras: '\\$' em JS produz '\$' na
+            // regex, que é o cifrão literal. Com uma barra só, o $ chega cru à
+            // regex e vira âncora de fim de linha — nada é substituído.
+            var safe = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+            msg = msg.replace(
+              new RegExp('\\$' + safe + '\\$', 'gi'),
+              ph && ph.content != null ? String(ph.content) : ''
+            )
+          })
+        }
+
+        // Substituições posicionais: $1..$9.
+        if (substitutions != null) {
+          var list = Array.isArray(substitutions) ? substitutions : [substitutions]
+          msg = msg.replace(/\$([1-9])/g, function (whole, i) {
+            var v = list[Number(i) - 1]
+            return v == null ? '' : String(v)
+          })
+        }
+
+        // "$$" escapa um cifrão literal.
+        return msg.replace(/\$\$/g, '$')
+      },
+      getUILanguage: function () { return window.__bpLocale || navigator.language || 'pt-BR' },
+      getAcceptLanguages: function (cb) { return settle(cb, [navigator.language || 'pt-BR']) },
+    },
+  }
+
+  window.chrome = window.chrome || {}
+  Object.keys(chromeShim).forEach(function (k) {
+    if (!window.chrome[k]) window.chrome[k] = chromeShim[k]
+  })
+  window.browser = window.browser || window.chrome
+  window.__bpShimActive = true
+})()

package/host/shim/guest-bridge.js

@@ -0,0 +1,353 @@
+/*!
+ * guest-bridge.js — lado iframe do canal postMessage.
+ *
+ * Carrega DEPOIS de popup.js. Faz duas coisas:
+ *   1. traduz comandos vindos do site (call, hangup, mute...) em ações no
+ *      webphone, usando os mesmos pontos de entrada que a extensão usa;
+ *   2. publica eventos de telefonia de volta para o site.
+ *
+ * Para discar usamos a mesma porta que os content-scripts de CRM usam no
+ * click-to-call: chrome.runtime.onMessage com method 'webphoneDialNow'. Ela
+ * desemboca em 'webphone-dial-from-pad', o funil único de ligações — então
+ * normalização de número, seleção de rota e registro de origem continuam
+ * valendo exatamente como na extensão.
+ */
+;(function () {
+  'use strict'
+
+  var PROTOCOL = 'bravophone/v1'
+  var parentOrigin = null
+
+  // A origem do pai chega de dois jeitos, conforme o modo:
+  //   · hospedado  — query string (?parent=...), pois o iframe navega
+  //   · srcdoc     — variável injetada, pois não há URL própria para carregar
+  // Nos dois casos o servidor ainda valida a origem pela allowlist; isto aqui
+  // sozinho nunca é garantia de nada.
+  try {
+    parentOrigin = window.__bpParentOrigin ||
+      new URLSearchParams(location.search).get('parent')
+  } catch (_) {}
+
+  if (!parentOrigin || window.parent === window) {
+    console.warn('[bp-bridge] sem origem pai; rodando standalone.')
+    return
+  }
+
+  function post(msg) {
+    try {
+      window.parent.postMessage(Object.assign({ protocol: PROTOCOL }, msg), parentOrigin)
+    } catch (err) {
+      console.error('[bp-bridge] postMessage falhou:', err)
+    }
+  }
+
+  var bridge = {
+    emit: function (name, payload) { post({ type: 'event', name: name, payload: payload }) },
+  }
+  window.__bpBridge = bridge
+
+  // --- espera o app Vue montar e expor os handles ---
+  function waitFor(getter, timeout) {
+    return new Promise(function (resolve, reject) {
+      var started = Date.now()
+      ;(function tick() {
+        var v
+        try { v = getter() } catch (_) {}
+        if (v) return resolve(v)
+        if (Date.now() - started > (timeout || 20000)) {
+          return reject(new Error('Bravophone: webphone não inicializou a tempo'))
+        }
+        setTimeout(tick, 120)
+      })()
+    })
+  }
+
+  // --- como se fala com o bundle -------------------------------------------
+  //
+  // O popup.js NÃO expõe nada em window. Há dois caminhos de verdade, ambos
+  // levantados do próprio bundle:
+  //
+  //  1. DISCAR — chrome.runtime.onMessage com method 'webphoneDialNow'. É a
+  //     mesma porta que os content-scripts de CRM usam para click-to-call, e
+  //     por dentro ela emite 'webphone-dial-from-pad', o funil único de
+  //     ligações: normalização de número, seleção de rota e registro de
+  //     origem continuam valendo iguais aos da extensão.
+  //
+  //  2. AÇÕES EM CHAMADA — o emitter (mitt) que o app publica via
+  //     `app.provide(...)`: call-answer, call-hangup, call-toggle-mute,
+  //     call-toggle-hold.
+  //
+  // O emitter é achado pela FORMA (um objeto com on/off/emit), não pelo nome
+  // da chave — o bundle é minificado e a chave muda a cada build.
+
+  function vueApp() {
+    var root = document.getElementById('app')
+    return (root && root.__vue_app__) || null
+  }
+
+  function findEmitter() {
+    var app = vueApp()
+    if (!app) return null
+    var pools = []
+    if (app._context) {
+      if (app._context.provides) pools.push(app._context.provides)
+      if (app._context.config && app._context.config.globalProperties) {
+        pools.push(app._context.config.globalProperties)
+      }
+    }
+    if (app.config && app.config.globalProperties) pools.push(app.config.globalProperties)
+
+    for (var i = 0; i < pools.length; i++) {
+      var pool = pools[i]
+      for (var k in pool) {
+        var v = pool[k]
+        // Assinatura do mitt: { all, on, off, emit }
+        if (v && typeof v.emit === 'function' && typeof v.on === 'function' &&
+            typeof v.off === 'function') return v
+      }
+    }
+    return null
+  }
+
+  function findStore() {
+    var app = vueApp()
+    if (!app) return null
+    var pools = []
+    if (app._context && app._context.provides) pools.push(app._context.provides)
+    if (app.config && app.config.globalProperties) pools.push(app.config.globalProperties)
+    for (var i = 0; i < pools.length; i++) {
+      for (var k in pools[i]) {
+        var v = pools[i][k]
+        if (v && v.state && typeof v.commit === 'function') return v
+      }
+    }
+    return null
+  }
+
+  /** Emite no emitter do app; falha com mensagem clara se ele não aparecer. */
+  function emitApp(event, arg) {
+    return waitFor(findEmitter, 20000).then(function (em) {
+      em.emit(event, arg)
+      return { ok: true }
+    })
+  }
+
+  // --- comandos aceitos do site hospedeiro ---
+  var commands = {
+    auth: function (p) {
+      // Sessão do integrador: grava onde o bundle já procura o token.
+      if (!p || !p.token) throw new Error('token ausente')
+      return new Promise(function (resolve) {
+        chrome.storage.local.set({ vxToken: p.token }, function () {
+          chrome.storage.sync.set({ vxToken: p.token }, function () { resolve({ ok: true }) })
+        })
+      })
+    },
+
+    logout: function () {
+      return new Promise(function (resolve) {
+        chrome.storage.local.remove(['vxToken'], function () {
+          chrome.storage.sync.remove(['vxToken'], function () { resolve({ ok: true }) })
+        })
+      })
+    },
+
+    call: function (p) {
+      if (!p || !p.number) throw new Error('número ausente')
+      var meta = p.meta || {}
+      // Mesmo payload que a API pública da extensão monta para os CRMs.
+      var payload = {
+        phone: String(p.number),
+        name: meta.name || null,
+        crm: meta.crm || null,
+        photo: meta.photo || null,
+        gateway: meta.gateway || meta.source || 'sdk',
+        dealId: meta.dealId || null,
+        pipedriveUrl: meta.url || null,
+      }
+
+      return new Promise(function (resolve, reject) {
+        var answered = false
+        // O listener do popup só existe depois do app montar; se ainda não
+        // houver ninguém escutando, esperamos e reenviamos.
+        var attempts = 0
+        ;(function send() {
+          attempts++
+          if (!chrome.runtime.onMessage.hasListeners() && attempts < 60) {
+            return setTimeout(send, 200)
+          }
+          if (!chrome.runtime.onMessage.hasListeners()) {
+            return reject(new Error('webphone não terminou de carregar'))
+          }
+          chrome.runtime.sendMessage({ method: 'webphoneDialNow', payload: payload }, function () {
+            if (answered) return
+            answered = true
+            resolve({ ok: true, phone: payload.phone })
+          })
+          // sendMessage responde de forma síncrona no shim; este timeout só
+          // cobre o caso de nenhum listener responder.
+          setTimeout(function () {
+            if (!answered) { answered = true; resolve({ ok: true, phone: payload.phone }) }
+          }, 300)
+        })()
+      })
+    },
+
+    hangup: function () { return emitApp('call-hangup') },
+    answer: function () { return emitApp('call-answer') },
+    // mute/hold do bundle são TOGGLE: não aceitam estado alvo.
+    mute: function () { return emitApp('call-toggle-mute') },
+    hold: function () { return emitApp('call-toggle-hold') },
+    dtmf: function (p) {
+      if (!p || p.tone == null) throw new Error('tom ausente')
+      return emitApp('webphone-dial-key', String(p.tone))
+    },
+    transfer: function (p) {
+      if (!p || !p.to) throw new Error('destino ausente')
+      return emitApp('webphone-transfer-initiated', String(p.to))
+    },
+    clearDial: function () { return emitApp('webphone-dial-clear') },
+
+    status: function () {
+      var store = findStore()
+      var st = (store && store.state) || {}
+      return Promise.resolve({
+        ready: !!findEmitter(),
+        inCall: !!(st.callActive || st.callPhase),
+        phase: st.callPhase || null,
+        number: st.callDisplay || null,
+        incoming: !!st.callIsIncoming,
+        muted: !!st.callMuted,
+        held: !!st.callHeld,
+      })
+    },
+
+    ping: function () { return Promise.resolve({ pong: Date.now() }) },
+  }
+
+  function ok() { return { ok: true } }
+
+  window.addEventListener('message', function (ev) {
+    if (ev.origin !== parentOrigin) return
+    if (ev.source !== window.parent) return
+    var msg = ev.data
+    if (!msg || msg.protocol !== PROTOCOL || msg.type !== 'command') return
+
+    var fn = commands[msg.command]
+    if (!fn) {
+      post({ type: 'reply', id: msg.id, error: 'comando desconhecido: ' + msg.command })
+      return
+    }
+    Promise.resolve()
+      .then(function () { return fn(msg.payload || {}) })
+      .then(function (payload) { post({ type: 'reply', id: msg.id, payload: payload }) })
+      .catch(function (err) { post({ type: 'reply', id: msg.id, error: String(err && err.message || err) }) })
+  })
+
+  // --- eventos de telefonia -> site ----------------------------------------
+  //
+  // Não há um `libwebphone` global para escutar. O que existe é o store Vuex,
+  // onde o app mantém o estado da chamada (callActive, callPhase, callDisplay,
+  // callIsIncoming…). Observamos esse estado e traduzimos as TRANSIÇÕES em
+  // eventos — derivar de estado é mais estável que caçar nomes de evento
+  // internos, que mudam a cada build do bundle.
+  ;(function watchCallState() {
+    var prev = null
+
+    function snapshot(st) {
+      return {
+        active: !!(st.callActive || st.callPhase),
+        phase: st.callPhase || null,
+        incoming: !!st.callIsIncoming,
+        number: st.callDisplay || null,
+      }
+    }
+
+    function describe(s) {
+      return { id: null, number: s.number, direction: s.incoming ? 'inbound' : 'outbound' }
+    }
+
+    function tick(store) {
+      var now = snapshot(store.state || {})
+
+      if (!prev) { prev = now; return }
+
+      // Começou uma chamada.
+      if (now.active && !prev.active) {
+        bridge.emit(now.incoming ? 'call:incoming' : 'call:dialing', describe(now))
+      }
+      // Foi atendida: sai de ringing/dialing para um estado de conversa.
+      if (now.active && prev.active && now.phase !== prev.phase &&
+          /answer|establish|active|talking|confirmed/i.test(String(now.phase))) {
+        bridge.emit('call:answered', describe(now))
+      }
+      // Terminou.
+      if (!now.active && prev.active) {
+        bridge.emit('call:ended', describe(prev))
+      }
+      prev = now
+    }
+
+    waitFor(findStore, 30000).then(function (store) {
+      bridge.emit('state', { state: 'ready' })
+      if (typeof store.subscribe === 'function') {
+        // subscribe dispara a cada mutation: reage na hora, sem polling.
+        store.subscribe(function () { tick(store) })
+      }
+      // Rede de segurança: nem toda mudança relevante passa por mutation.
+      setInterval(function () { tick(store) }, 500)
+    }).catch(function (err) {
+      console.warn('[bp-bridge] store não encontrado; eventos de chamada ficam indisponíveis:', err.message)
+      bridge.emit('error', { message: 'estado de chamada indisponível: ' + err.message })
+    })
+  })()
+
+  // --- arraste a partir de DENTRO do iframe ---------------------------------
+  // O host é cross-origin e não pode tocar neste DOM, então a detecção do
+  // arraste tem de acontecer aqui e viajar como delta pela ponte. É isso que
+  // permite arrastar o webphone pela própria UI, sem barra de título externa.
+  ;(function enableInnerDrag() {
+    // Qualquer coisa clicável continua clicável: só o "fundo" arrasta.
+    var INTERACTIVE = 'input,button,a,select,textarea,label,option,[contenteditable],[role="button"],[role="tab"],[role="link"],[draggable="true"]'
+    var dragging = false
+
+    document.addEventListener('pointerdown', function (ev) {
+      if (ev.button !== 0) return
+      if (!ev.target || (ev.target.closest && ev.target.closest(INTERACTIVE))) return
+      // Se o usuário está selecionando texto, não sequestra o gesto.
+      var sel = window.getSelection && window.getSelection()
+      if (sel && String(sel).length) return
+
+      dragging = true
+      // cx/cy: posicao dentro do iframe. O host soma a posicao da janela e
+      // descobre onde o cursor esta na viewport dele — e nao pode calcular
+      // isso sozinho, por ser cross-origin.
+      bridge.emit('drag:start', { x: ev.screenX, y: ev.screenY, cx: ev.clientX, cy: ev.clientY })
+      try { document.documentElement.setPointerCapture(ev.pointerId) } catch (_) {}
+    }, true)
+
+    document.addEventListener('pointermove', function (ev) {
+      if (!dragging) return
+      // screenX/screenY são absolutos na tela: imunes ao próprio iframe se
+      // mover durante o arraste, o que clientX/clientY não seriam.
+      bridge.emit('drag:move', { x: ev.screenX, y: ev.screenY })
+    }, true)
+
+    function stop(ev) {
+      if (!dragging) return
+      dragging = false
+      bridge.emit('drag:end', {})
+      try { document.documentElement.releasePointerCapture(ev.pointerId) } catch (_) {}
+    }
+    document.addEventListener('pointerup', stop, true)
+    document.addEventListener('pointercancel', stop, true)
+  })()
+
+  // Sinaliza pronto assim que o DOM do app existir.
+  function announceReady() {
+    // Identifica o HOST, não o SDK: são artefatos com ciclos separados.
+    post({ type: 'ready', payload: { host: 'bravophone-embed' } })
+  }
+  if (document.readyState === 'complete') announceReady()
+  else window.addEventListener('load', announceReady)
+})()