fg-tracker-sdk 0.13.0 → 0.15.0

package/dist/scrub.js

@@ -1,30 +1,675 @@
 /**
- * Remoção de dados sensíveis antes do envio (CONTRATO.md §22): valores de chaves
- * conhecidas viram `[Filtered]`, em qualquer profundidade dos `attributes`.
+ * Remoção de dados sensíveis antes de enfileirar (CONTRATO.md §22):
+ * - **por chave**: valores de chaves conhecidas viram `[Filtered]`, em qualquer profundidade;
+ * - **por valor**: JWT, `Bearer`/`Basic`, cartão (Luhn), CPF formatado, chaves privadas e tokens
+ *   de formato conhecido viram `[Filtered]`; `chave=valor` com chave sensível dentro de texto também;
+ *   e-mails viram `<email>` (o mesmo marcador da normalização da API, §16: a fingerprint não muda);
+ * - **URLs**: sem usuário/senha; valores da query (e de parâmetros no fragmento) viram `[Filtered]`,
+ *   as chaves ficam. Com `sendDefaultPii: true` só os valores de chaves sensíveis saem.
+ *
+ * Identificadores (`traceId`, `spanId`, `requestId`, `user.id`…), `user.email`/`user.name` (dados
+ * que a aplicação entregou de propósito) e o SQL já normalizado não passam pela limpeza por valor.
+ * Os padrões são lineares: nada aqui pode travar o event loop com uma string grande.
  */
 export const DEFAULT_SCRUB_FIELDS = [
     'password', 'passwd', 'secret', 'token', 'authorization', 'cookie', 'set-cookie',
     'api_key', 'apikey', 'api-key', 'access_token', 'refresh_token', 'credit_card', 'card_number', 'cvv', 'ssn', 'private_key',
+    'cpf', 'jwt', 'secret_access_key', 'secret_key',
 ];
 export const FILTERED = '[Filtered]';
+export const EMAIL_PLACEHOLDER = '<email>';
 const MAX_DEPTH = 6;
+/** Objeto ou array além de `MAX_DEPTH`: não sai sem passar pela limpeza. */
+export const MAX_DEPTH_MARKER = '[MaxDepth]';
+/** Parâmetros de URL que levam credencial mesmo sem casar com `fields` (assinaturas, `?key=`, OAuth). */
+const SENSITIVE_QUERY_KEYS = new Set([
+    'sig', 'signature', 'x-amz-signature', 'x-amz-credential', 'x-amz-security-token', 'awsaccesskeyid',
+    'x-goog-signature', 'x-goog-credential', 'key', 'code', 'id_token', 'session', 'sessionid', 'auth', 'otp',
+]);
+/** Chaves cujo valor é uma URL: limpas por `scrubUrl`. */
+const URL_KEYS = new Set(['url', 'http.url', 'http.target', 'url.full']);
+/** Chaves com valor que a aplicação entregou de propósito ou que já saem normalizados. */
+const VALUE_EXEMPT_KEYS = new Set([
+    'user.email', 'user.name', 'traceparent', 'tracestate', 'db.query.text', 'db.query.fingerprint',
+    // Dimensões do deploy que a API usa para agrupar (releases, ambientes, serviços): um release com
+    // carimbo de build (`20261017090915`) passa no Luhn ~1 vez em 10 e não pode virar `[Filtered]`.
+    'release', 'serviceName', 'environment', 'deployment.environment.name', 'service.name', 'service.version',
+]);
+/** Identificadores (`id`, `traceId`, `user.id`, `event_id`, `messaging.message.id`): nunca alterados por valor. */
+function isIdentifierKey(key) {
+    return key === 'id' || key === 'ID' || /(?:[._-][iI][dD]|[a-z0-9]Id|ID)$/.test(key);
+}
+/** Formas comparáveis de cada lista de campos, calculadas uma vez por lista (a limpeza roda por chave). */
+const normalizedFields = new WeakMap();
+function normalized(fields) {
+    let list = normalizedFields.get(fields);
+    if (!list || list.length !== fields.length) {
+        list = fields.map((raw) => {
+            const field = raw.toLowerCase();
+            return { field, compact: field.replace(/[_-]/g, '') };
+        });
+        normalizedFields.set(fields, list);
+    }
+    return list;
+}
+/** A chave casa com um campo (sem diferenciar maiúsculas: `scrubFields: ['internalRef']` pega `internalref`). */
 export function shouldScrub(key, fields) {
     const lower = key.toLowerCase();
-    return fields.some((field) => lower === field || lower.endsWith(`_${field}`) || lower.endsWith(`-${field}`) || lower.endsWith(`.${field}`) || lower.endsWith(field.replace(/[_-]/g, '')));
+    return normalized(fields).some(({ field, compact }) => lower === field || lower.endsWith(`_${field}`) || lower.endsWith(`-${field}`) || lower.endsWith(`.${field}`) || lower.endsWith(compact));
+}
+/* ------------------------------------------------------------------ */
+/* Padrões por valor                                                    */
+/* ------------------------------------------------------------------ */
+const PRIVATE_KEY_BLOCK = /-----BEGIN [A-Z0-9 ]{0,40}PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z0-9 ]{0,40}PRIVATE KEY-----|$)/g;
+/** URL com esquema dentro de um texto (`https://…`, `postgres://user:senha@…`). */
+const EMBEDDED_URL = /\b[a-zA-Z][a-zA-Z0-9+.-]{1,15}:\/\/[^\s'"<>`]+/g;
+/** Tokens de formato publicado: FG Tracker (`fgsk_`, `fgt_`), AWS, GitHub, Stripe, Slack, OpenAI/OpenRouter/Anthropic, Google. */
+const KNOWN_TOKENS = [
+    /\b(?:fgsk|fgt)_[A-Za-z0-9_-]{16,256}/g,
+    /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+    /\bgh[pousr]_[A-Za-z0-9]{36,255}\b/g,
+    /\bgithub_pat_[A-Za-z0-9_]{22,255}/g,
+    /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{10,255}/g,
+    /\bwhsec_[A-Za-z0-9+/=]{16,255}/g,
+    /\bxox[abposr]-[A-Za-z0-9-]{10,255}/g,
+    /\bsk-[A-Za-z0-9_-]{32,255}/g,
+    /\bAIza[0-9A-Za-z_-]{35}\b/g,
+];
+/** `Bearer <token>`/`Basic <credencial>`: só com um dígito no token, para não pegar prosa ("Basic authentication"). */
+const AUTH_SCHEME = /\b(Bearer|Basic)(\s+)(?=[A-Za-z0-9._~+/-]*\d)[A-Za-z0-9._~+/-]+=*/gi;
+/** Candidato a cartão: 13–19 dígitos começando pelos prefixos de bandeira (2–6), com espaço ou hífen opcional. */
+const CARD_CANDIDATE = /\b[2-6](?:[ -]?\d){12,18}\b/g;
+const CPF_FORMATTED = /\b\d{3}\.\d{3}\.\d{3}-\d{2}\b/g;
+function luhnValid(digits) {
+    let sum = 0;
+    let double = false;
+    for (let i = digits.length - 1; i >= 0; i -= 1) {
+        let n = digits.charCodeAt(i) - 48;
+        if (double) {
+            n *= 2;
+            if (n > 9)
+                n -= 9;
+        }
+        sum += n;
+        double = !double;
+    }
+    return sum % 10 === 0;
+}
+function cpfValid(formatted) {
+    const digits = formatted.replace(/\D/g, '');
+    if (digits.length !== 11 || /^(\d)\1{10}$/.test(digits))
+        return false;
+    const check = (length) => {
+        let sum = 0;
+        for (let i = 0; i < length; i += 1)
+            sum += (digits.charCodeAt(i) - 48) * (length + 1 - i);
+        const rest = (sum * 10) % 11;
+        return rest === 10 ? 0 : rest;
+    };
+    return check(9) === digits.charCodeAt(9) - 48 && check(10) === digits.charCodeAt(10) - 48;
+}
+const isWordChar = (c) => (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;
+const isLetter = (c) => (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
+/** Caractere de base64url (segmentos de JWT) e de nome de chave (`a.b-c_d`). */
+const isB64UrlChar = (c) => isWordChar(c) || c === 45;
+const isKeyChar = (c) => isWordChar(c) || c === 45 || c === 46;
+/** Fim do valor sem aspas de `chave=valor`: espaço ou um destes delimitadores. */
+/** Caractere de token colado a um valor (`[abc]def`, `"abc"def`): letras, dígitos e `-_.~+/=%`. */
+const isTokenChar = (c) => isB64UrlChar(c) || c === 46 || c === 126 || c === 43 || c === 47 || c === 61 || c === 37;
+const isValueStop = (c) => c <= 32 || c === 38 || c === 59 || c === 44 || c === 39 || c === 34 || c === 60 || c === 62;
+/**
+ * Como `runEnd`, sem engolir a aspa escapada de um texto dentro de string: uma sequência de barras
+ * seguida de aspa com número ímpar de barras (`\"`, `\\\"`) é aspa do texto de fora e fica fora do
+ * valor; um número par (`\\` antes da aspa) são barras literais e fazem parte dele.
+ */
+function valueRunEnd(text, from, accept) {
+    let i = from;
+    while (i < text.length) {
+        const c = text.charCodeAt(i);
+        if (c === 92) {
+            let slashes = 1;
+            while (text.charCodeAt(i + slashes) === 92)
+                slashes += 1;
+            if (text.charCodeAt(i + slashes) === 34 && slashes % 2 === 1)
+                return i;
+            i += slashes;
+            continue;
+        }
+        if (!accept(c))
+            return i;
+        i += 1;
+    }
+    return i;
+}
+function runEnd(text, from, accept) {
+    let i = from;
+    while (i < text.length && accept(text.charCodeAt(i)))
+        i += 1;
+    return i;
+}
+/**
+ * JWT/JWS compacto (`eyJ…` `.` `…` `.` `…`; o cabeçalho em base64url sempre começa com `eyJ`, `{"`)
+ * → `[Filtered]`. Varredura linear: um segmento que não termina em `.` descarta todos os candidatos
+ * dentro dele de uma vez (todos acabariam no mesmo ponto). Com a expressão
+ * `\beyJ[…]{4,}\.[…]{4,}\.[…]*`, cada `eyJ` depois de um hífen relia o resto do texto procurando o
+ * ponto: `'eyJaaaa-'.repeat(16000)` levava 2 s.
+ */
+export function replaceJwts(text) {
+    let at = text.indexOf('eyJ');
+    if (at < 0)
+        return text;
+    let out = '';
+    let last = 0;
+    while (at >= 0) {
+        if (at > 0 && isWordChar(text.charCodeAt(at - 1))) {
+            at = text.indexOf('eyJ', at + 1);
+            continue;
+        }
+        const header = runEnd(text, at, isB64UrlChar);
+        if (header - at < 7 || text.charCodeAt(header) !== 46) {
+            at = text.indexOf('eyJ', header);
+            continue;
+        }
+        const payload = runEnd(text, header + 1, isB64UrlChar);
+        if (payload - header - 1 < 4 || text.charCodeAt(payload) !== 46) {
+            at = text.indexOf('eyJ', payload);
+            continue;
+        }
+        const signature = runEnd(text, payload + 1, isB64UrlChar);
+        out += text.slice(last, at) + FILTERED;
+        last = signature;
+        at = text.indexOf('eyJ', signature);
+    }
+    return out + text.slice(last);
+}
+/** Barras invertidas logo antes da posição `i`. */
+function backslashesBefore(text, i) {
+    let n = 0;
+    while (i - n > 0 && text.charCodeAt(i - n - 1) === 92)
+        n += 1;
+    return n;
+}
+/**
+ * Nível de escape de uma aspa: `r` barras antes dela (0 em JSON, 1 em JSON dentro de string, 3 em
+ * dois níveis…). Uma aspa com `L` barras antes delimita strings do nível `r` quando
+ * `L % (2r + 2) === r`; com mais barras é conteúdo (aspa escapada); com menos, é o fim da string de
+ * fora, onde o valor de dentro termina.
+ */
+function delimitsLevel(slashes, r) {
+    return slashes % (2 * r + 2) === r;
+}
+/**
+ * Fim (exclusivo) do texto entre aspas no nível `r`, a partir de `from` (depois da aspa de
+ * abertura): depois da aspa que fecha, ou na aspa de um nível de fora. -1 numa quebra de linha.
+ */
+function levelQuotedEnd(text, from, quote, r) {
+    for (let i = from; i < text.length; i += 1) {
+        const c = text.charCodeAt(i);
+        if (c === 10)
+            return -1;
+        if (c !== quote && c !== 34)
+            continue;
+        const slashes = backslashesBefore(text, i);
+        if (c === 34 && slashes < r)
+            return i - slashes;
+        if (c === quote && delimitsLevel(slashes, r))
+            return i + 1;
+    }
+    return -1;
+}
+/**
+ * Fim do objeto ou array aberto em `start` (`{`/`[`) no nível de escape `r`, respeitando as strings
+ * desse nível; `text.length` quando não fecha (o resto do texto conta como o valor, escondido
+ * inteiro). Para na aspa de um nível de fora (fim da string que contém o JSON).
+ */
+function balancedEnd(text, start, r = 0) {
+    let depth = 0;
+    let quote = 0;
+    for (let i = start; i < text.length; i += 1) {
+        const c = text.charCodeAt(i);
+        if (c === 34 || (c === 39 && r === 0)) {
+            const slashes = backslashesBefore(text, i);
+            if (c === 34 && slashes < r)
+                return i - slashes;
+            if (!delimitsLevel(slashes, r))
+                continue;
+            if (!quote)
+                quote = c;
+            else if (quote === c)
+                quote = 0;
+            continue;
+        }
+        if (quote)
+            continue;
+        if (c === 123 || c === 91)
+            depth += 1;
+        else if ((c === 125 || c === 93) && --depth === 0)
+            return i + 1;
+    }
+    return text.length;
+}
+const isSpace = (c) => c === 32 || c === 9 || c === 10 || c === 13;
+/** Fim de um valor JSON sem aspas (número, `true`, texto solto): espaço, `,`, `}` ou `]`. */
+const isJsonStop = (c) => c <= 32 || c === 44 || c === 125 || c === 93;
+/**
+ * `"chave": valor` (JSON ou objeto literal dentro de texto) com chave sensível: o valor inteiro vira
+ * `[Filtered]`, seja texto entre aspas, número, objeto ou array. Linear: a partir de cada `:`, a
+ * chave é lida para trás (entre aspas simples, duplas ou escapadas `\"`, de JSON dentro de string)
+ * e só o valor de chave sensível é lido para a frente. O valor de uma chave comum não é pulado: um
+ * par sensível dentro dele (`{"outer":{"password":…}}`) é achado no `:` seguinte.
+ */
+function replaceQuotedKeyValues(text, fields) {
+    let colon = text.indexOf(':');
+    if (colon < 0)
+        return text;
+    let out = '';
+    let last = 0;
+    while (colon >= 0) {
+        let close = colon - 1;
+        while (close >= last && isSpace(text.charCodeAt(close)))
+            close -= 1;
+        const quote = close >= last ? text.charCodeAt(close) : 0;
+        // Nível de escape da chave: 0 (`"k"`), 1 (`\"k\"`), 3 (`\\\"k\\\"`)…; aspas simples só no nível 0.
+        const r = quote === 34 || quote === 39 ? backslashesBefore(text, close) : -1;
+        if (r < 0 || (r & (r + 1)) !== 0 || (quote === 39 && r !== 0)) {
+            colon = text.indexOf(':', colon + 1);
+            continue;
+        }
+        const keyEnd = close - r;
+        let start = keyEnd;
+        while (start > last && keyEnd - start < 64 && isKeyChar(text.charCodeAt(start - 1)))
+            start -= 1;
+        const opened = start > 0 && text.charCodeAt(start - 1) === quote && backslashesBefore(text, start - 1) === r;
+        if (start === keyEnd || !opened || !isLetter(text.charCodeAt(start)) || !shouldScrub(text.slice(start, keyEnd), fields)) {
+            colon = text.indexOf(':', colon + 1);
+            continue;
+        }
+        let value = colon + 1;
+        while (value < text.length && isSpace(text.charCodeAt(value)))
+            value += 1;
+        let slashes = 0;
+        while (text.charCodeAt(value + slashes) === 92)
+            slashes += 1;
+        const open = text.charCodeAt(value + slashes);
+        const level = '\\'.repeat(r);
+        let end;
+        let inner;
+        let replacement = `${level}"${FILTERED}${level}"`;
+        const quotedEnd = slashes === r && (open === 34 || (open === 39 && r === 0)) ? levelQuotedEnd(text, value + r + 1, open, r) : -1;
+        if (quotedEnd >= 0) {
+            end = quotedEnd;
+            const closed = text.charCodeAt(end - 1) === open && end - 1 > value + r;
+            inner = text.slice(value + r + 1, closed ? end - 1 - r : end);
+            replacement = `${level}${text[value + r]}${FILTERED}${level}${text[value + r]}`;
+        }
+        else if (slashes === r && (open === 34 || open === 39)) {
+            // Aspa que não fecha na linha: o resto do valor sem aspas.
+            end = valueRunEnd(text, value + r + 1, (c) => !isJsonStop(c));
+            inner = text.slice(value + r + 1, end);
+        }
+        else if (slashes === 0 && (open === 123 || open === 91)) {
+            end = balancedEnd(text, value, r);
+            inner = text.slice(value, end);
+        }
+        else {
+            end = valueRunEnd(text, value, (c) => !isJsonStop(c) && c !== 34);
+            inner = text.slice(value, end);
+        }
+        // `"k":[a]b` ou `"k":"a"b` (texto que não é JSON válido): o valor vai até o fim do valor sem aspas.
+        if (end < text.length && end > value && isTokenChar(text.charCodeAt(end))) {
+            end = valueRunEnd(text, end, (c) => !isJsonStop(c) && c !== 34 && c !== 41);
+            inner = text.slice(value, end);
+            replacement = `${level}"${FILTERED}${level}"`;
+        }
+        // Valor vazio, `null` ou marcador completo: nada a esconder; segue depois dele (sem reler).
+        if (!inner || inner === 'null' || isPlaceholder(inner)) {
+            colon = text.indexOf(':', Math.max(end, colon + 1));
+            continue;
+        }
+        out += text.slice(last, value) + replacement;
+        last = end;
+        colon = text.indexOf(':', end);
+    }
+    return out + text.slice(last);
+}
+/**
+ * `chave=valor` com chave sensível dentro de texto (query, form, `senha=…` numa mensagem): o valor
+ * inteiro, sem teto de tamanho, vira `[Filtered]` (entre aspas, as aspas ficam). Linear: a partir de
+ * cada `=`, a chave é lida para trás (até 64 caracteres) e só o valor de chave sensível é lido para a
+ * frente; o valor de uma chave comum não esconde o par seguinte (`next=/cb?token=abc`).
+ */
+function replaceKeyEqualsValue(text, fields) {
+    let eq = text.indexOf('=');
+    if (eq < 0)
+        return text;
+    let out = '';
+    let last = 0;
+    while (eq >= 0) {
+        let start = eq;
+        while (start > last && eq - start < 64 && isKeyChar(text.charCodeAt(start - 1)))
+            start -= 1;
+        while (start < eq && !isLetter(text.charCodeAt(start)))
+            start += 1;
+        if (start === eq || !shouldScrub(text.slice(start, eq), fields)) {
+            eq = text.indexOf('=', eq + 1);
+            continue;
+        }
+        // Aspas do valor no nível de escape do texto: `"x"`, `\"x\"` (texto dentro de string JSON)…
+        let slashes = 0;
+        while (text.charCodeAt(eq + 1 + slashes) === 92)
+            slashes += 1;
+        const open = text.charCodeAt(eq + 1 + slashes);
+        const isQuote = (open === 34 || (open === 39 && slashes === 0)) && (slashes & (slashes + 1)) === 0;
+        const quoted = isQuote ? levelQuotedEnd(text, eq + 2 + slashes, open, slashes) : -1;
+        const nested = slashes === 0 && (open === 123 || open === 91);
+        let end = nested ? balancedEnd(text, eq + 1) : quoted >= 0 ? quoted : valueRunEnd(text, isQuote ? eq + 2 + slashes : eq + 1, (c) => !isValueStop(c));
+        // `[abc]def` ou `"abc"def`: o valor vai até o delimitador, nada do que vem colado sobra.
+        const glued = (nested || quoted >= 0) && end < text.length && isTokenChar(text.charCodeAt(end));
+        if (glued)
+            end = valueRunEnd(text, end, (c) => isTokenChar(c) || (!isValueStop(c) && c !== 41));
+        const value = text.slice(eq + 1, end);
+        const level = '\\'.repeat(slashes);
+        const closed = quoted >= 0 && !glued && text.charCodeAt(quoted - 1) === open;
+        const inner = quoted >= 0 && !glued ? text.slice(eq + 2 + slashes, closed ? quoted - 1 - slashes : quoted) : value.replace(/^\\*["']/, '');
+        // Valor vazio ou marcador completo: nada a esconder; segue depois dele (sem reler).
+        if (!inner || isPlaceholder(inner)) {
+            eq = text.indexOf('=', Math.max(end, eq + 1));
+            continue;
+        }
+        const quote = String.fromCharCode(open);
+        out += text.slice(last, eq + 1) + (quoted >= 0 && !glued ? `${level}${quote}${FILTERED}${level}${quote}` : FILTERED);
+        last = end;
+        eq = text.indexOf('=', end);
+    }
+    return out + text.slice(last);
+}
+const isLocalChar = (c) => (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 46 || c === 95 || c === 37 || c === 43 || c === 45;
+const isDomainChar = (c) => (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 46 || c === 45;
+/**
+ * E-mails → `<email>`. Varredura a partir de cada `@` (linear): uma expressão `[\w.]+@` testada
+ * em cada posição de uma string longa sem `@` seria quadrática.
+ */
+export function replaceEmails(text) {
+    let at = text.indexOf('@');
+    if (at < 0)
+        return text;
+    let out = '';
+    let last = 0;
+    while (at >= 0) {
+        let start = at;
+        while (start > last && at - start < 64 && isLocalChar(text.charCodeAt(start - 1)))
+            start -= 1;
+        while (start < at && text[start] === '.')
+            start += 1;
+        let end = at + 1;
+        while (end < text.length && end - at <= 255 && isDomainChar(text.charCodeAt(end)))
+            end += 1;
+        while (end > at + 1 && (text[end - 1] === '.' || text[end - 1] === '-'))
+            end -= 1;
+        const domain = text.slice(at + 1, end);
+        const dot = domain.lastIndexOf('.');
+        if (start < at && dot > 0 && /^[A-Za-z]{2,24}$/.test(domain.slice(dot + 1))) {
+            out += text.slice(last, start) + EMAIL_PLACEHOLDER;
+            last = end;
+            at = text.indexOf('@', end);
+        }
+        else {
+            at = text.indexOf('@', at + 1);
+        }
+    }
+    return out + text.slice(last);
+}
+/** Valor que já é marcador ou placeholder de SQL/URL: nada a limpar. */
+/** Marcador completo (`[Filtered]`, `REDACTED`, placeholder de SQL): só o marcador inteiro, nunca um prefixo. */
+function isPlaceholder(value) {
+    return value === FILTERED || value === 'REDACTED' || value === '?' || value === "'?'" || (value.length < 12 && /^\$\d+$/.test(value));
+}
+const SCRIPT_PATH = /\.(?:[mc]?[jt]sx?|vue|svelte|astro|html?|wasm)$/i;
+/**
+ * Início do `:linha[:coluna][)]` de um frame de stack colado ao fim de uma URL de script com query
+ * (`…/app.js?v=20261017:1:24567)`, `@…/App.tsx?t=1792234743617:12:5`); `url.length` quando não há.
+ * Sem isso o sufixo virava parte do valor da query e saía como `[Filtered]`, e a API perdia linha,
+ * coluna e (no formato do Firefox/Safari) o frame inteiro. Lido do fim, em tempo linear.
+ */
+function frameLocationStart(url) {
+    const cut = url.search(/[?#]/);
+    if (cut < 0 || !SCRIPT_PATH.test(url.slice(0, cut)))
+        return url.length;
+    let i = url.length;
+    if (url.charCodeAt(i - 1) === 41)
+        i -= 1;
+    let start = url.length;
+    for (let groups = 0; groups < 2; groups += 1) {
+        let j = i;
+        while (j > cut && url.charCodeAt(j - 1) >= 48 && url.charCodeAt(j - 1) <= 57)
+            j -= 1;
+        if (j === i || url.charCodeAt(j - 1) !== 58)
+            break;
+        i = j - 1;
+        start = i;
+    }
+    return start;
+}
+/** Limpeza por valor de um texto livre (mensagem de erro, atributo, nome de span, linha de log). */
+export function scrubText(text, options) {
+    if (text.length < 6 || options.fields.length === 0)
+        return text;
+    let out = text;
+    if (out.includes('PRIVATE KEY-----'))
+        out = out.replace(PRIVATE_KEY_BLOCK, FILTERED);
+    if (out.includes('://')) {
+        out = out.replace(EMBEDDED_URL, (url) => {
+            const at = frameLocationStart(url);
+            return scrubUrl(url.slice(0, at), options) + url.slice(at);
+        });
+    }
+    return scrubPatterns(out, options);
+}
+/** Padrões por valor, sem tratar URLs (o `scrubUrl` chama isto no próprio resultado). */
+function scrubPatterns(text, options) {
+    let out = text;
+    out = replaceJwts(out);
+    for (const pattern of KNOWN_TOKENS)
+        out = out.replace(pattern, FILTERED);
+    out = out.replace(AUTH_SCHEME, (_match, scheme, space) => `${scheme}${space}${FILTERED}`);
+    out = replaceKeyEqualsValue(out, options.fields);
+    out = replaceQuotedKeyValues(out, options.fields);
+    out = out.replace(CARD_CANDIDATE, (match) => {
+        const digits = match.replace(/[ -]/g, '');
+        return digits.length >= 13 && digits.length <= 19 && luhnValid(digits) ? FILTERED : match;
+    });
+    if (out.includes('.'))
+        out = out.replace(CPF_FORMATTED, (match) => (cpfValid(match) ? FILTERED : match));
+    return replaceEmails(out);
+}
+function decode(value) {
+    try {
+        return decodeURIComponent(value.replace(/\+/g, ' '));
+    }
+    catch {
+        return value;
+    }
+}
+/** `a=1&token=x&flag` → valores trocados por `[Filtered]` (ou só os sensíveis, com `sendDefaultPii`). */
+function scrubQuery(query, options) {
+    return query
+        .split('&')
+        .map((pair) => {
+        if (!pair)
+            return pair;
+        const eq = pair.indexOf('=');
+        if (eq < 0) {
+            // Parâmetro sem valor: fica se parece um nome curto (`?debug`); senão pode ser o próprio segredo.
+            return /^[A-Za-z][A-Za-z0-9_.-]{0,15}$/.test(pair) ? pair : FILTERED;
+        }
+        const key = pair.slice(0, eq);
+        const value = pair.slice(eq + 1);
+        if (!value || isPlaceholder(value))
+            return pair;
+        const name = decode(key).toLowerCase();
+        if (!options.sendDefaultPii || SENSITIVE_QUERY_KEYS.has(name) || shouldScrub(name, options.fields))
+            return `${key}=${FILTERED}`;
+        const decoded = decode(value);
+        const cleaned = scrubPatterns(decoded, options);
+        return cleaned === decoded ? pair : `${key}=${cleaned}`;
+    })
+        .join('&');
+}
+/**
+ * URL sem usuário/senha e com a query limpa (`/reset?token=[Filtered]&page=[Filtered]`). Vale para
+ * URL absoluta, caminho com query e texto que não é URL válida (a limpeza é textual, sem `new URL`).
+ * Fragmento com parâmetros (`#access_token=…`, `#/cb?code=…`) segue a mesma regra da query.
+ */
+export function scrubUrl(raw, options) {
+    let base = raw;
+    let fragment = null;
+    const hash = raw.indexOf('#');
+    if (hash >= 0) {
+        base = raw.slice(0, hash);
+        fragment = raw.slice(hash + 1);
+    }
+    // Usuário e senha vão até o último `@` da autoridade (o parser de URL aceita `@` na senha).
+    base = base.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)[^/?#\s]*@/, '$1');
+    const q = base.indexOf('?');
+    let out = q >= 0 ? `${base.slice(0, q)}?${scrubQuery(base.slice(q + 1), options)}` : base;
+    if (fragment !== null) {
+        const fq = fragment.indexOf('?');
+        if (fq >= 0)
+            out += `#${fragment.slice(0, fq)}?${scrubQuery(fragment.slice(fq + 1), options)}`;
+        else if (fragment.includes('='))
+            out += `#${scrubQuery(fragment, options)}`;
+        else
+            out += `#${fragment}`;
+    }
+    return options.fields.length > 0 ? scrubPatterns(out, options) : out;
+}
+/* ------------------------------------------------------------------ */
+/* Objetos                                                              */
+/* ------------------------------------------------------------------ */
+function scrubString(key, value, options) {
+    if (key !== null && URL_KEYS.has(key))
+        return scrubUrl(value, options);
+    if (options.fields.length === 0)
+        return value;
+    if (key !== null && (VALUE_EXEMPT_KEYS.has(key) || isIdentifierKey(key)))
+        return value;
+    return scrubText(value, options);
 }
-export function scrubValue(value, fields, depth = 0) {
-    if (depth > MAX_DEPTH || value === null || typeof value !== 'object')
+/**
+ * Cópia limpa até `MAX_DEPTH`. `ancestors` guarda o ramo atual: um ciclo vira `[Circular]` na
+ * primeira repetição (como na serialização), e o mesmo objeto em dois ramos sai inteiro nos dois.
+ */
+export function scrubValue(value, options, depth = 0, key = null, ancestors = [], fromToJSON = false) {
+    if (typeof value === 'string')
+        return scrubString(key, value, options);
+    // Função (também a devolvida por um `toJSON`): o JSON a omite, e nenhum `toJSON` dela pode chegar à cópia.
+    if (typeof value === 'function')
+        return undefined;
+    if (value === null || typeof value !== 'object')
         return value;
-    if (Array.isArray(value))
-        return value.map((item) => scrubValue(item, fields, depth + 1));
+    // String, Number e Boolean em caixa saem como o primitivo (como no JSON.stringify), não como um
+    // objeto de caracteres soltos que a limpeza por valor não reconheceria.
+    const boxed = unboxed(value);
+    if (boxed !== NOT_BOXED)
+        return scrubValue(boxed, options, depth, key, ancestors);
+    if (ancestors.includes(value))
+        return '[Circular]';
+    if (depth > MAX_DEPTH)
+        return MAX_DEPTH_MARKER;
+    // Date, Buffer e afins saem pelo `toJSON`, como sairiam na serialização: a cópia não os achata em `{}`.
+    // Como no JSON.stringify, o `toJSON` do resultado não é chamado de novo: um `toJSON` que devolve
+    // `this` (ou outro objeto) tem as propriedades limpas como qualquer objeto, nunca passa cru.
+    // Um `toJSON` que lança vira o mesmo marcador da serialização, sem perder o evento.
+    if (!fromToJSON && typeof value.toJSON === 'function') {
+        let json;
+        try {
+            json = value.toJSON();
+        }
+        catch {
+            return '[Unserializable]';
+        }
+        return scrubValue(json, options, depth + 1, key, ancestors, true);
+    }
+    // Funções não vão para a cópia (o JSON.stringify também não as serializa): um `toJSON` próprio e
+    // enumerável copiado seria chamado de novo na serialização e poderia devolver o objeto original.
+    // A cópia é sempre um Array ou objeto simples: `map` de uma subclasse de Array (ou um objeto com
+    // protótipo próprio) levaria junto um `toJSON` herdado, chamado de novo na serialização.
+    const branch = [...ancestors, value];
+    if (Array.isArray(value)) {
+        const list = new Array(value.length);
+        for (let i = 0; i < value.length; i += 1) {
+            const item = value[i];
+            list[i] = typeof item === 'function' ? null : scrubValue(item, options, depth + 1, key, branch);
+        }
+        return list;
+    }
     const out = {};
-    for (const [key, item] of Object.entries(value)) {
-        out[key] = shouldScrub(key, fields) && item !== null && item !== undefined ? FILTERED : scrubValue(item, fields, depth + 1);
+    for (const [name, item] of Object.entries(value)) {
+        if (typeof item === 'function')
+            continue;
+        if (name === '__proto__') {
+            // Chave própria vinda de JSON.parse: atribuir trocaria o protótipo da cópia.
+            Object.defineProperty(out, name, { value: scrubValue(item, options, depth + 1, name, branch), enumerable: true, writable: true, configurable: true });
+            continue;
+        }
+        out[name] =
+            options.fields.length > 0 && shouldScrub(name, options.fields) && item !== null && item !== undefined
+                ? FILTERED
+                : scrubValue(item, options, depth + 1, name, branch);
     }
     return out;
 }
-export function scrubAttributes(attributes, fields) {
-    return scrubValue(attributes, fields);
+const NOT_BOXED = Symbol('not-boxed');
+/** Primitivo de um String/Number/Boolean em caixa; `NOT_BOXED` para os demais objetos. */
+function unboxed(value) {
+    try {
+        if (value instanceof String)
+            return String.prototype.valueOf.call(value);
+        if (value instanceof Number)
+            return Number.prototype.valueOf.call(value);
+        if (value instanceof Boolean)
+            return Boolean.prototype.valueOf.call(value);
+    }
+    catch {
+        /* objeto com o protótipo trocado: segue como objeto */
+    }
+    return NOT_BOXED;
+}
+/**
+ * Atributos limpos por chave, por valor e com as URLs limpas. Com `fields` vazio (`scrubFields:
+ * false`), só as URLs passam pela regra da query (que depende de `sendDefaultPii`).
+ */
+export function scrubAttributes(attributes, fields, options = {}) {
+    const resolved = { fields, sendDefaultPii: options.sendDefaultPii ?? false };
+    if (fields.length === 0) {
+        if (resolved.sendDefaultPii)
+            return attributes;
+        let changed = null;
+        for (const key of URL_KEYS) {
+            const value = attributes[key];
+            if (typeof value !== 'string')
+                continue;
+            const cleaned = scrubUrl(value, resolved);
+            if (cleaned !== value)
+                (changed ??= { ...attributes })[key] = cleaned;
+        }
+        return changed ?? attributes;
+    }
+    return scrubValue(attributes, resolved);
+}
+/** Mensagem e stack de um erro limpos por valor (o nome fica: é o tipo do erro). */
+export function scrubError(error, options) {
+    if (options.fields.length === 0)
+        return error;
+    const message = scrubText(String(error.message ?? ''), options);
+    const stack = typeof error.stack === 'string' ? scrubText(error.stack, options) : undefined;
+    if (message === error.message && stack === error.stack)
+        return error;
+    return { ...error, message, ...(stack !== undefined ? { stack } : {}) };
+}
+/** Texto de diagnóstico (console): sempre limpo com a lista padrão, mesmo com `scrubFields: false`. */
+export function scrubDiagnostic(text) {
+    return scrubText(text, { fields: DEFAULT_SCRUB_FIELDS, sendDefaultPii: false });
 }
 export function matchesAny(value, patterns) {
     if (!patterns || patterns.length === 0)