primocode 8.42.1 → 9.0.0

package/studio/web/js/analise.js

@@ -1,510 +0,0 @@
-/* Onde estão as pausas — a conta que permite cortá-las.
- *
- * "Ele vai cortar as pausas demoradas no vídeo."
- *
- * Cortar pausa é escolher trechos, e escolher trechos exige saber onde a fala
- * para. Ninguém no PrimoCode sabe ler o áudio de um .mp4: o projeto não tem
- * dependência nenhuma, e o Python da máquina lê WAV e mais nada. O navegador
- * sabe, desde sempre, em qualquer sistema, sem instalar coisa alguma. Então a
- * conta acontece aqui e o resultado volta para o agente pelo servidor.
- *
- * O método é o de sempre em edição: envelope de energia, limiar relativo ao
- * que o próprio arquivo tem, e histerese para não picotar a fala.
- */
-(function () {
-  "use strict";
-
-  var painel = document.getElementById("painel");
-  var barra = document.getElementById("barra");
-
-  function conta(texto) {
-    var p = document.createElement("p");
-    p.textContent = texto;
-    painel.appendChild(p);
-    painel.scrollTop = painel.scrollHeight;
-  }
-
-  function andar(fracao, rotulo) {
-    barra.style.width = Math.round(Math.max(0, Math.min(1, fracao)) * 100) + "%";
-    barra.setAttribute("data-rotulo", rotulo || "");
-  }
-
-  function mmss(s) {
-    s = Math.max(0, s || 0);
-    var m = Math.floor(s / 60);
-    return m + ":" + String(Math.floor(s % 60)).padStart(2, "0");
-  }
-
-  /* ── o envelope ─────────────────────────────────────────────────────────
-     RMS em janelas de 20ms. Pico não serve: um estalo de teclado tem pico de
-     fala e energia de nada, e cortaria a pausa ao meio. */
-  var JANELA = 0.02;
-
-  function envelope(buffer) {
-    var canais = buffer.numberOfChannels;
-    var passo = Math.max(1, Math.round(buffer.sampleRate * JANELA));
-    var quantas = Math.floor(buffer.length / passo);
-    var fora = new Float32Array(quantas);
-    var dados = [];
-    for (var c = 0; c < canais; c++) dados.push(buffer.getChannelData(c));
-
-    for (var j = 0; j < quantas; j++) {
-      var soma = 0;
-      var base = j * passo;
-      for (var c2 = 0; c2 < canais; c2++) {
-        var d = dados[c2];
-        for (var i = 0; i < passo; i++) { var v = d[base + i]; soma += v * v; }
-      }
-      fora[j] = Math.sqrt(soma / (passo * canais));
-    }
-    return fora;
-  }
-
-  /* O limiar sai do PRÓPRIO arquivo. Um número fixo (-40 dB, digamos) trata
-     igual uma gravação de estúdio e um celular num café — e no café ele
-     acharia que não há pausa nenhuma, porque o chão de ruído já passa do
-     limiar. Aqui o chão é a mediana das janelas mais quietas, e a fala é o
-     percentil alto; o corte fica entre os dois, mais perto do chão. */
-  function limiarDe(env) {
-    var ordenado = Float32Array.from(env).sort();
-    var q = function (p) { return ordenado[Math.min(ordenado.length - 1, Math.floor(ordenado.length * p))]; };
-    var chao = q(0.10);
-    var fala = q(0.90);
-    if (!(fala > 0)) return { corte: 0, chao: chao, fala: fala };
-    // Um sexto do caminho entre o silêncio e a fala. Baixo de propósito: é
-    // melhor deixar uma pausa passar do que cortar a última sílaba de uma
-    // frase, que é o defeito que se ouve.
-    return { corte: Math.max(chao * 2.2, chao + (fala - chao) * 0.16), chao: chao, fala: fala };
-  }
-
-  /* Junta as janelas quietas em pausas, com histerese: uma janela alta no meio
-     do silêncio não reabre a fala, e vice-versa. `minimo` é o que conta como
-     "pausa demorada" — abaixo disso é respiração, e cortar respiração deixa a
-     fala robótica. */
-  function acharPausas(env, minimo, corte) {
-    var pausas = [];
-    var inicio = -1;
-    var seguidas = 0;
-    var TOLERA = 3;                    // ~60ms de estalo não encerram a pausa
-    for (var j = 0; j < env.length; j++) {
-      if (env[j] < corte) {
-        if (inicio < 0) inicio = j;
-        seguidas = 0;
-      } else if (inicio >= 0) {
-        seguidas++;
-        if (seguidas > TOLERA) {
-          var fim = j - seguidas;
-          if ((fim - inicio) * JANELA >= minimo) pausas.push([inicio * JANELA, fim * JANELA]);
-          inicio = -1; seguidas = 0;
-        }
-      }
-    }
-    if (inicio >= 0 && (env.length - inicio) * JANELA >= minimo) {
-      pausas.push([inicio * JANELA, env.length * JANELA]);
-    }
-    return pausas;
-  }
-
-  /* ── O ERRO DE FALA, E A REPETIÇÃO ────────────────────────────────────
-   *
-   *   "O sistema não identifica quando o usuário erra uma fala ou repete
-   *    algo — deveria cortar esses trechos, mas não corta."
-   *
-   * Não identificava porque não havia nada aqui: a análise só sabia achar
-   * silêncio. Isto é a parte nova.
-   *
-   * ── COMO DÁ PARA SABER SEM ENTENDER O QUE FOI DITO ──────────────────
-   * Não há transcrição. Mas errar e repetir tem uma marca ACÚSTICA que não
-   * depende de entender: quando alguém tropeça, ele volta e diz a MESMA
-   * COISA logo em seguida — "o Primo— o PrimoCode é um agente". As duas
-   * tentativas ficam coladas e soam parecidas, porque são as mesmas palavras
-   * na mesma voz, dita do mesmo jeito.
-   *
-   * Então o que se mede é a semelhança entre um trecho e o COMEÇO do
-   * seguinte. Alta semelhança + o primeiro sendo mais curto = tentativa
-   * abortada, e quem vale é a segunda.
-   *
-   * ── POR QUE FORMA DO ESPECTRO, E NÃO O ENVELOPE ─────────────────────
-   * O envelope (a energia) já existe aqui e seria de graça — mas ele só diz
-   * QUANTO som há, não QUAL. Duas frases diferentes ditas no mesmo ritmo têm
-   * envelopes quase idênticos, e cortar por isso apagaria fala boa: o
-   * defeito mais caro possível, porque some conteúdo sem ninguém ver.
-   *
-   * A forma do espectro diz o que está soando. Oito faixas por janela, cada
-   * janela normalizada — assim o que se compara é o TIMBRE, não o volume, e
-   * a pessoa falando mais alto na segunda vez continua sendo a mesma frase.
-   */
-
-  /* FFT radix-2, no lugar. Trinta linhas e nenhuma dependência: o estúdio
-     inteiro roda sem `node_modules`, e uma biblioteca de áudio aqui seria a
-     primeira. */
-  function fft(re, im) {
-    var n = re.length;
-    for (var i = 1, j = 0; i < n; i++) {
-      var bit = n >> 1;
-      for (; j & bit; bit >>= 1) j ^= bit;
-      j ^= bit;
-      if (i < j) {
-        var tr = re[i]; re[i] = re[j]; re[j] = tr;
-        var ti = im[i]; im[i] = im[j]; im[j] = ti;
-      }
-    }
-    for (var tam = 2; tam <= n; tam <<= 1) {
-      var ang = -2 * Math.PI / tam;
-      var wr = Math.cos(ang), wi = Math.sin(ang);
-      for (var k = 0; k < n; k += tam) {
-        var cr = 1, ci = 0;
-        for (var m = 0; m < tam / 2; m++) {
-          var ar = re[k + m], ai = im[k + m];
-          var br = re[k + m + tam / 2] * cr - im[k + m + tam / 2] * ci;
-          var bi = re[k + m + tam / 2] * ci + im[k + m + tam / 2] * cr;
-          re[k + m] = ar + br; im[k + m] = ai + bi;
-          re[k + m + tam / 2] = ar - br; im[k + m + tam / 2] = ai - bi;
-          var ncr = cr * wr - ci * wi;
-          ci = cr * wi + ci * wr; cr = ncr;
-        }
-      }
-    }
-  }
-
-  var JANELA_FFT = 1024;         // ~23ms a 44,1kHz: uma sílaba tem várias
-  var FAIXAS = 8;
-
-  var PASSO_S = 0.02;                             // uma linha a cada 20ms
-
-  /**
-   * A "cara" de um pedaço do áudio: uma linha de 8 números por janela, mais a
-   * FORÇA de cada linha antes de normalizar.
-   *
-   * A força não é enfeite: depois de normalizada, uma janela de silêncio vira
-   * um vetor unitário apontando para o ruído — e dois ruídos podem "casar" tão
-   * bem quanto duas falas iguais. É por ela que `aparar` sabe onde a fala
-   * começa de verdade.
-   */
-  function impressao(dados, taxa, de, ate) {
-    var passo = Math.round(taxa * PASSO_S);
-    var i0 = Math.max(0, Math.round(de * taxa));
-    var i1 = Math.min(dados.length, Math.round(ate * taxa));
-    var linhas = [];
-    var forca = [];
-    var re = new Float64Array(JANELA_FFT);
-    var im = new Float64Array(JANELA_FFT);
-
-    for (var p = i0; p + JANELA_FFT <= i1; p += passo) {
-      for (var k = 0; k < JANELA_FFT; k++) {
-        // Hann: sem janela, o corte do bloco vira um clique que aparece em
-        // todas as faixas e embaralha a comparação.
-        var w = 0.5 * (1 - Math.cos(2 * Math.PI * k / (JANELA_FFT - 1)));
-        re[k] = dados[p + k] * w;
-        im[k] = 0;
-      }
-      fft(re, im);
-
-      var faixa = new Float64Array(FAIXAS);
-      // Faixas em escala logarítmica: o ouvido separa grave de agudo assim, e
-      // a fala vive quase toda embaixo de 4kHz.
-      for (var b = 0; b < FAIXAS; b++) {
-        var de2 = Math.floor(Math.pow(2, b) * 2);
-        var ate2 = Math.min(JANELA_FFT / 2, Math.floor(Math.pow(2, b + 1) * 2));
-        var soma = 0;
-        for (var q = de2; q < ate2; q++) soma += re[q] * re[q] + im[q] * im[q];
-        faixa[b] = Math.log(1 + soma);
-      }
-      // Normaliza a linha: o que importa é a FORMA, não o volume. Sem isto,
-      // falar mais alto na segunda tentativa faria as duas parecerem
-      // diferentes — justamente quando são a mesma frase.
-      var norma = 0;
-      for (var b2 = 0; b2 < FAIXAS; b2++) norma += faixa[b2] * faixa[b2];
-      norma = Math.sqrt(norma) || 1;
-      for (var b3 = 0; b3 < FAIXAS; b3++) faixa[b3] /= norma;
-      linhas.push(faixa);
-      forca.push(norma);
-    }
-    return { linhas: linhas, forca: forca };
-  }
-
-  /**
-   * Tira o silêncio das pontas.
-   *
-   * Sem isto a comparação é entre coisas desalinhadas e o detector não acha
-   * nada: o trecho guarda meia pausa em cada ponta (é o conserto do vídeo
-   * cansativo, logo abaixo), então o primeiro trecho começa na fala e o
-   * segundo começa em 0,35s de ar — um deslocamento de dezessete janelas, que
-   * é mais que uma sílaba inteira. Alinhar pelo COMEÇO DA FALA é o que faz as
-   * duas tentativas ficarem uma em cima da outra.
-   */
-  function aparar(imp) {
-    var f = imp.forca;
-    if (!f.length) return [];
-    var pico = 0;
-    for (var i = 0; i < f.length; i++) if (f[i] > pico) pico = f[i];
-    var corte = pico * 0.35;
-    var de = 0, ate = f.length - 1;
-    while (de < f.length && f[de] < corte) de++;
-    while (ate > de && f[ate] < corte) ate--;
-    return imp.linhas.slice(de, ate + 1);
-  }
-
-  /* Quanto se admite de folga no alinhamento: 6 janelas, ~120ms. Ninguém
-     recomeça uma frase no mesmo milissegundo, e sem esta busca uma diferença
-     de meia sílaba já derruba a semelhança abaixo de qualquer limiar. */
-  var FOLGA = 6;
-
-  /** Quanto duas impressões se parecem, 0 a 1, no melhor alinhamento. */
-  function semelhanca(a, b) {
-    var melhor = 0;
-    for (var d = 0; d <= FOLGA; d++) {
-      melhor = Math.max(melhor, umAlinhamento(a, b, d), umAlinhamento(b, a, d));
-    }
-    return melhor;
-  }
-
-  function umAlinhamento(a, b, desloca) {
-    var n = Math.min(a.length, b.length - desloca);
-    if (n < 8) return 0;                 // curto demais para significar algo
-    var soma = 0;
-    for (var i = 0; i < n; i++) {
-      var s = 0;
-      for (var k = 0; k < FAIXAS; k++) s += a[i][k] * b[i + desloca][k];
-      soma += s;
-    }
-    return soma / n;
-  }
-
-  /* ── AS DUAS FORMAS DE ERRAR UMA FALA ─────────────────────────────────
-   *
-   * Elas não se parecem, e uma regra só não pega as duas:
-   *
-   *   · O TROPEÇO. "O Primo— o PrimoCode é um agente de IA." A primeira
-   *     tentativa morre no meio, é CURTA, e o que vem depois começa igual e
-   *     segue em frente. O sinal é o PEDAÇO: o primeiro trecho é um começo do
-   *     segundo.
-   *
-   *   · A REGRAVAÇÃO. A pessoa diz a frase inteira, não gosta, e diz de novo
-   *     inteira. Os dois trechos têm o MESMO tamanho e o mesmo conteúdo do
-   *     começo ao fim.
-   *
-   * ── O QUE SEGURA A MÃO ───────────────────────────────────────────────
-   * Nenhuma das duas pode confundir com FALA BOA que por acaso se parece. Duas
-   * frases seguidas da mesma pessoa, no mesmo microfone, sobre o mesmo assunto
-   * já se parecem bastante — e apagar uma delas é o defeito mais caro deste
-   * arquivo, porque some conteúdo e o vídeo continua parecendo certo. Por isso
-   * cada regra pede DUAS coisas ao mesmo tempo: semelhança alta E uma relação
-   * de tamanho que só existe no erro.
-   *
-   * Fala boa repetida de propósito ("e eu repito: não vale a pena") não é
-   * cortada, e isso é decisão: quem repete de propósito repete com outras
-   * palavras em volta, e o pedaço igual é curto demais para passar no mínimo
-   * de janelas da `semelhanca`.
-   */
-
-  /* Acima disto, duas falas são a MESMA fala. Alto de propósito: errar para o
-     lado de não cortar deixa um tropeço no vídeo, que se vê e se conserta;
-     errar para o outro apaga fala boa, que ninguém vê faltar até alguém
-     assistir inteiro. */
-  var IGUAIS = 0.985;
-  /* A regravação inteira pede mais, porque ali se joga fora um trecho INTEIRO
-     de fala e não um pedaço de um segundo. */
-  var IGUAIS_INTEIRA = 0.992;
-  /* Uma tentativa abortada é curta — quem tropeça volta rápido. */
-  var ABORTADA_MAXIMA = 3.5;
-  /* E ela é um PEDAÇO do que vem depois. Sem esta conta, dois trechos de fala
-     de verdade com o mesmo tamanho e o mesmo assunto viram "repetição". */
-  var FRAGMENTO_ATE = 0.7;
-  /* Regravação: os dois duram quase o mesmo. */
-  var MESMO_TAMANHO = 0.15;
-
-  /**
-   * Quais trechos são tropeço, e por quê.
-   *
-   * Devolve os índices a descartar e a razão de cada um — a razão é o que
-   * permite CONTAR na tela o que foi tirado, em vez de o vídeo simplesmente
-   * sair menor sem explicação. Vídeo que encurta sozinho e não diz por quê é
-   * indistinguível de vídeo quebrado.
-   */
-  function acharRepeticoes(trechos, dados, taxa) {
-    var fora = [];
-    for (var i = 0; i < trechos.length - 1; i++) {
-      var a = trechos[i], b = trechos[i + 1];
-      var da = a[1] - a[0], db = b[1] - b[0];
-      if (da > ABORTADA_MAXIMA && Math.abs(da - db) / Math.max(da, db) > MESMO_TAMANHO) continue;
-
-      var ia = aparar(impressao(dados, taxa, a[0], a[1]));
-      if (ia.length < 8) continue;
-
-      if (da <= ABORTADA_MAXIMA && da < db * FRAGMENTO_ATE) {
-        // Tropeço: compara a tentativa com o COMEÇO do que vem depois, que é
-        // onde a fala recomeça igual. A janela de b é o tamanho de a mais uma
-        // folga — nela cabe o ar da ponta que `aparar` vai tirar.
-        var ib = aparar(impressao(dados, taxa, b[0], Math.min(b[1], b[0] + da + 1.2)));
-        var s = semelhanca(ia, ib);
-        if (s >= IGUAIS) {
-          fora.push({ indice: i, semelhanca: +s.toFixed(3), motivo: "tentativa abortada" });
-        }
-        continue;
-      }
-
-      if (Math.abs(da - db) / Math.max(da, db) <= MESMO_TAMANHO) {
-        // Regravação: aqui a comparação é do começo ao FIM dos dois. Comparar
-        // só o começo diria "igual" para duas frases que começam com as mesmas
-        // três palavras e terminam dizendo coisas opostas.
-        var ib2 = aparar(impressao(dados, taxa, b[0], b[1]));
-        var s2 = semelhanca(ia, ib2);
-        if (s2 >= IGUAIS_INTEIRA && Math.abs(ia.length - ib2.length) <= FOLGA * 3) {
-          fora.push({ indice: i, semelhanca: +s2.toFixed(3), motivo: "fala regravada" });
-        }
-      }
-    }
-    return fora;
-  }
-
-  /* ── O CORTE QUE NÃO COME A PAUSA ──────────────────────────────────────
-   *
-   *   "O sistema corta todas as pausas, inclusive as propositais, deixando o
-   *    vídeo cansativo."
-   *
-   * Estava certo. A versão anterior pulava a pausa INTEIRA: o trecho terminava
-   * onde o silêncio começava e o próximo começava onde ele acabava. Toda
-   * respiração sumia, e falar sem respirar cansa quem ouve — o vídeo ficava
-   * correndo sem parar, do primeiro segundo ao último.
-   *
-   * O que cansa não é a pausa: é o ar parado. Então a pausa não é removida,
-   * é ENCURTADA — e o corte sai do MEIO dela, deixando metade do que fica de
-   * cada lado. Assim a fala continua com a queda natural no fim da frase e o
-   * ataque limpo na frase seguinte, que é o que soa humano.
-   *
-   * Quanto fica depende do tamanho, porque pausa curta e pausa longa querem
-   * dizer coisas diferentes:
-   *
-   *   · até 1,5s — é respiração. Fica quase inteira (até 0,5s), porque foi
-   *     assim que a pessoa falou.
-   *   · acima disso — ou é ar parado, ou é uma pausa DE PROPÓSITO antes de
-   *     uma frase importante. Fica 0,7s: o suficiente para a intenção
-   *     sobreviver, sem o vazio.
-   *
-   * Quem quiser o corte seco de antes passa `manter: 0`.
-   */
-  var MANTER_CURTA = 0.5;
-  var MANTER_LONGA = 0.7;
-  var LIMITE_LONGA = 1.5;
-
-  function quantoManter(duracaoDaPausa, pedido) {
-    if (pedido != null) return Math.max(0, Math.min(pedido, duracaoDaPausa));
-    var teto = duracaoDaPausa > LIMITE_LONGA ? MANTER_LONGA : MANTER_CURTA;
-    return Math.min(teto, duracaoDaPausa);
-  }
-
-  function trechosUteis(pausas, duracao, manterPedido) {
-    var trechos = [];
-    var cursor = 0;
-    pausas.forEach(function (p) {
-      var tamanho = p[1] - p[0];
-      var manter = quantoManter(tamanho, manterPedido);
-      if (tamanho - manter <= 0.05) return;      // nada a ganhar: deixa inteira
-      var metade = manter / 2;
-      var ate = Math.min(duracao, p[0] + metade);
-      if (ate - cursor > 0.35) trechos.push([+cursor.toFixed(2), +ate.toFixed(2)]);
-      cursor = Math.max(0, p[1] - metade);
-    });
-    if (duracao - cursor > 0.35) trechos.push([+cursor.toFixed(2), +duracao.toFixed(2)]);
-    return trechos;
-  }
-
-  /* ── a tarefa ──────────────────────────────────────────────────────────── */
-
-  function responder(id, corpo) {
-    return fetch("/api/analise/" + id, {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(corpo),
-    });
-  }
-
-  function rodar(id) {
-    var tarefa;
-    andar(0.05, "buscando o pedido");
-
-    fetch("/api/analise/" + id).then(function (r) {
-      if (!r.ok) throw new Error("este pedido de análise não existe mais");
-      return r.json();
-    }).then(function (t) {
-      tarefa = t;
-      document.getElementById("qual").textContent = t.arquivo;
-      conta("Lendo " + t.arquivo + "…");
-      andar(0.15, "baixando o áudio");
-      return fetch(t.arquivo);
-    }).then(function (r) {
-      if (!r.ok) throw new Error("não consegui abrir o arquivo");
-      return r.arrayBuffer();
-    }).then(function (bruto) {
-      conta((bruto.byteLength / 1048576).toFixed(1) + " MB lidos. Decodificando o áudio…");
-      andar(0.35, "decodificando");
-      var Ctx = window.AudioContext || window.webkitAudioContext;
-      return new Ctx().decodeAudioData(bruto);
-    }).then(function (buffer) {
-      conta("Áudio de " + mmss(buffer.duration) + " a " + buffer.sampleRate + " Hz.");
-      andar(0.6, "medindo a energia");
-
-      var env = envelope(buffer);
-      var lim = limiarDe(env);
-      andar(0.85, "achando as pausas");
-
-      var pausas = acharPausas(env, tarefa.pausa || 0.6, lim.corte);
-      var todos = trechosUteis(pausas, buffer.duration, tarefa.manter);
-      conta(pausas.length + " pausa(s) de mais de " + (tarefa.pausa || 0.6) + "s.");
-
-      /* O erro de fala se procura DEPOIS das pausas, e não antes: é a pausa
-         que separa a tentativa que morreu da que vale. Quem pedir
-         `repetida: false` fica só com o corte de pausa — o comportamento
-         antigo, para quem quer editar à mão. */
-      andar(0.92, "ouvindo se algo foi dito duas vezes");
-      var repetidos = tarefa.repetida === false ? []
-        : acharRepeticoes(todos, buffer.getChannelData(0), buffer.sampleRate);
-      var descartar = {};
-      repetidos.forEach(function (r) { descartar[r.indice] = r; });
-      var trechos = todos.filter(function (t, i) { return !descartar[i]; });
-      repetidos.forEach(function (r) {
-        var t = todos[r.indice];
-        conta("Fora " + mmss(t[0]) + "–" + mmss(t[1]) + ": " + r.motivo +
-          " (semelhança " + r.semelhanca + ").");
-      });
-
-      var somaTrechos = trechos.reduce(function (s, t) { return s + (t[1] - t[0]); }, 0);
-      conta("Sobram " + trechos.length + " trecho(s), somando " + mmss(somaTrechos) +
-        " de " + mmss(buffer.duration) + ".");
-      andar(1, "pronto");
-
-      return responder(id, {
-        duracao: +buffer.duration.toFixed(2),
-        pausas: pausas.map(function (p) { return [+p[0].toFixed(2), +p[1].toFixed(2)]; }),
-        trechos: trechos,
-        // O que foi tirado por repetição vai NOMEADO: o agente precisa poder
-        // contar para a pessoa o que sumiu do vídeo dela.
-        repetidos: repetidos.map(function (r) {
-          return { de: todos[r.indice][0], ate: todos[r.indice][1],
-            motivo: r.motivo, semelhanca: r.semelhanca };
-        }),
-        cortado: +(buffer.duration - somaTrechos).toFixed(2),
-      }).then(function () {
-        conta("Resultado entregue ao PrimoCode. Pode fechar esta aba.");
-        document.body.setAttribute("data-estado", "pronto");
-        // Fecha sozinha quando foi o CLI que abriu: ninguém pediu uma aba,
-        // pediram um vídeo editado.
-        setTimeout(function () { try { window.close(); } catch (e) {} }, 2500);
-      });
-    }).catch(function (e) {
-      conta("Não deu: " + e.message);
-      document.body.setAttribute("data-estado", "erro");
-      andar(1, "erro");
-      responder(id, { erro: e.message }).catch(function () {});
-    });
-  }
-
-  var id = (location.hash || "").replace(/^#/, "").trim();
-  if (!/^[a-z0-9]+$/.test(id)) {
-    conta("Esta página é aberta pelo PrimoCode quando ele precisa ouvir um vídeo seu.");
-    document.body.setAttribute("data-estado", "erro");
-  } else {
-    rodar(id);
-  }
-})();