@sophonz/redaction 0.0.2

package/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2024-2025 INOBS Inc. All rights reserved.
+
+This software and associated documentation files (the "Software") are the proprietary property of INOBS Inc. and are protected by copyright and other intellectual property laws.
+
+Permission is hereby granted, on a limited basis, to use, copy, modify, or distribute the Software only within the scope of a separate written license agreement with INOBS Inc.
+
+Unless otherwise agreed to in writing, the Software shall not be used, reproduced, distributed, sublicensed, or disclosed, in whole or in part, to any third party.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+For license inquiries, please contact:
+
+INOBS Inc.  
+Email: [contact@sophonz.ai]  
+Website: https://inobs.io

package/README-ko.md

@@ -0,0 +1,191 @@
+# @sophonz/redaction
+
+[English](./README.md)
+
+Sophonz 브라우저 SDK를 위한 마스킹 기본기. **URL 새니타이징**과 **속성 스크러빙** 두 부분으로 구성됩니다.
+
+URL 쪽은 URL이 스팬, 로그 레코드, 내보내기 속성에 기록되기 전에 `user:password@` 자격 증명과 널리 알려진 민감 쿼리 파라미터의 값을 제거합니다.
+
+OpenTelemetry 브라우저 navigation instrumentation의 `defaultSanitizeUrl`을 이식하고, 여기에 Embrace의 `additionalQueryParamsToScrub` 사용성을 더했습니다.
+
+런타임 의존성이 없습니다.
+
+Sophonz OpenTelemetry 제품군의 일부입니다.
+
+## 설치
+
+```bash
+bun add @sophonz/redaction
+# 또는
+pnpm add @sophonz/redaction
+# 또는
+npm install @sophonz/redaction
+```
+
+## 사용법
+
+```ts
+import { defaultSanitizeUrl } from '@sophonz/redaction';
+
+defaultSanitizeUrl('https://api.example.com/v1/me?token=abc&page=2');
+// 'https://api.example.com/v1/me?token=REDACTED&page=2'
+
+defaultSanitizeUrl('https://alice:hunter2@api.example.com/v1/me');
+// 'https://REDACTED:REDACTED@api.example.com/v1/me'
+```
+
+기본 목록 위에 파라미터를 추가하려면:
+
+```ts
+import { createSanitizeUrl } from '@sophonz/redaction';
+
+const sanitizeUrl = createSanitizeUrl({
+  additionalQueryParamsToScrub: ['x-api-key', 'sig'],
+});
+
+sanitizeUrl('https://api.example.com/v1?x-api-key=abc&password=p&page=2');
+// 'https://api.example.com/v1?x-api-key=REDACTED&password=REDACTED&page=2'
+```
+
+## API
+
+### `defaultSanitizeUrl(url: string): string`
+
+자격 증명과 기본 19개 파라미터를 마스킹합니다. 예외를 던지지 않습니다.
+
+### `createSanitizeUrl(options?: SanitizeUrlOptions): SanitizeUrl`
+
+sanitizer를 생성합니다. 옵션 없이 호출하면 `defaultSanitizeUrl`과 동일합니다.
+
+| 옵션 | 타입 | 기본값 | 의미 |
+|---|---|---|---|
+| `additionalQueryParamsToScrub` | `readonly string[]` | `[]` | 기본 목록에 *더해서* 마스킹할 이름 |
+| `queryParamsToScrub` | `readonly string[]` | 기본 19개 | 기본 목록을 통째로 교체. 위 옵션을 우선 사용 |
+| `redactCredentials` | `boolean` | `true` | authority의 `user:password@` 마스킹 |
+| `scrubFragment` | `boolean` | `true` | 프래그먼트의 파라미터도 검사 |
+
+### `DEFAULT_QUERY_PARAMS_TO_SCRUB: readonly string[]`
+
+동결된 기본 19개 이름: `password`, `passwd`, `secret`, `api_key`, `apikey`, `auth`, `authorization`, `token`, `access_token`, `refresh_token`, `jwt`, `session`, `sessionid`, `key`, `private_key`, `client_secret`, `client_id`, `signature`, `hash`.
+
+### `REDACTED: 'REDACTED'`
+
+마스킹된 값을 대체하는 표식입니다.
+
+### `type SanitizeUrl = (url: string) => string`
+
+instrumentation이 받는 훅 시그니처입니다.
+
+## 동작
+
+**키가 아니라 값을 대체합니다.** `?token=abc`는 `?token=REDACTED`가 됩니다. 키를 지우면 비밀 값이 있었다는 사실 자체가 사라지는데, 이는 텔레메트리를 보는 운영자가 가장 알아야 할 정보입니다. OpenTelemetry `url.query` 가이드도 마스킹된 키를 유지하도록 권고합니다.
+
+**파라미터 이름은 대소문자를 구분하지 않고 정확히 일치할 때만 매칭합니다.** `?Token=`과 `?TOKEN=`은 마스킹되지만 `?tokenizer=`, `?keyword=`, `?monkey=`는 그대로 둡니다. 여기서 부분 문자열 매칭은 치명적입니다. 기본 목록에는 `key`, `auth`, `hash`, `session` 같은 짧고 일반적인 단어가 있어 수많은 무해한 파라미터 이름 안에 등장하며, 과잉 마스킹은 되돌릴 수단이 없습니다. `api-key` 같은 변형은 `additionalQueryParamsToScrub`로 처리합니다.
+
+이름은 `+`를 공백으로 바꾸고 퍼센트 이스케이프를 해석한 뒤 앞뒤 공백을 제거해서 비교하므로 `?%74oken=`과 `?%20token=` 모두 마스킹됩니다.
+
+**같은 이름이 여러 번 나오면 각각 마스킹합니다.** `?token=a&token=b`는 하나로 합쳐지지 않고 `?token=REDACTED&token=REDACTED`가 됩니다. 반복을 잃으면 실제 요청의 모습이 왜곡됩니다.
+
+**프래그먼트도 검사합니다.** OAuth 2.0 implicit grant는 `access_token`이 서버에 도달하지 않도록 일부러 프래그먼트로 전달하므로, 프래그먼트는 실제로 비밀 값이 존재하는 자리입니다. `#access_token=…`과 `#/checkout?token=…` 형태의 해시 라우트를 모두 처리합니다. 파라미터 목록이 아닌 프래그먼트(`#installation`, `#/orders/42`)는 `name=value` 쌍이 없으므로 그대로 통과합니다. `scrubFragment: false`로 끌 수 있습니다.
+
+**그 밖에는 아무것도 바꾸지 않습니다.** 구현은 문자열 기반이며 `URL`이나 `URLSearchParams`를 거치지 않으므로 경로, 인코딩, 파라미터 순서, 호스트 대소문자, 기본 포트, 마지막 슬래시 유무가 바이트 단위로 보존됩니다. `URL` 왕복은 마스킹 여부와 무관하게 `http://x.test`를 `http://x.test/`로 바꾸고 `:80`을 지우고 호스트를 소문자로 만들고 쿼리 전체를 재인코딩(`%20` → `+`)하는데, 이는 애플리케이션이 실제로 요청한 URL과 대조하기 어렵게 만듭니다.
+
+**예외를 던지지 않으며, 파싱 불가 입력이라는 개념이 없습니다.** 파싱을 하지 않으므로 파싱에 실패할 수 없습니다. 상대 URL(`/api?token=…`), 프로토콜 상대 URL, `data:`/`blob:` URI, 잘못된 문자열이 모두 같은 경로로 처리되며 그래도 마스킹됩니다. 두 가지 경계는 명시적으로 정의했습니다.
+
+- **문자열이 아닌 인자**는 `''`를 반환합니다. 이는 마스킹 실패가 아니라 호출자의 타입 오류입니다. `undefined`에는 비밀 값이 없음이 자명하고, 임의 객체를 문자열로 강제 변환하면 검사하지 않은 `toString`을 호출하게 됩니다.
+- **내부 실패**는 구조상 도달할 수 없지만 방어해 두었으며, 문자열 `REDACTED`를 반환합니다. 입력을 그대로 돌려주는 것은 안전하지 않습니다. 그 입력이 바로 마스킹에 실패한 대상이기 때문입니다. `url.full` 속성값이 정확히 `REDACTED`라면 sanitizer가 해당 URL을 포기했다는 뜻입니다.
+
+## 상위 OpenTelemetry 구현과의 차이
+
+의도적으로 바로잡은 세 가지이며 모두 테스트로 덮여 있습니다.
+
+| 상위 구현 | 이 패키지 |
+|---|---|
+| `searchParams.has(param)`이 대소문자를 구분해 `URL` 경로에서는 `?Token=`이 살아남음 (정규식 폴백은 구분하지 않아 입력에 따라 동작이 달라짐) | 모든 입력에서 대소문자 무시 |
+| `searchParams.set(param, …)`이 중복 파라미터를 합쳐 `?token=a&token=b`가 `?token=REDACTED`가 됨 | 각 항목을 제자리에서 마스킹 |
+| `new URL(url)`이 상대 URL에서 예외를 던져 호출마다 19개의 `RegExp`를 만드는 폴백으로 감; `URL` 경로는 URL 전체를 재인코딩·정규화 | 문자열 1회 순회, 호출당 `RegExp` 생성 없음, 정규화 없음 |
+
+## 속성 스크러빙 (attribute scrubbing)
+
+위의 URL 새니타이저는 URL을 다룹니다. `createAttributeScrubber`는 **속성**을 다룹니다 — Embrace의 `attributeScrubbers`에 해당하며, 모든 스팬과 모든 로그 레코드에 키 단위로 적용되므로 URL이 아니라 속성에 담긴 비밀 값도 잡아냅니다.
+
+`SophonzSpanAttributeScrubbingProcessor`(`@sophonz/span-processors`)와 `SophonzLogAttributeScrubbingProcessor`(`@sophonz/log-processors`)가 이 함수를 사용하며, SDK의 `attributeScrubbers` 옵션으로 설정합니다.
+
+```ts
+import { createAttributeScrubber } from '@sophonz/redaction';
+
+const scrub = createAttributeScrubber([
+  { keys: ['app.user.email'] },                    // -> 'REDACTED'
+  { keyPattern: /^http\.request\.header\./ },       // -> 'REDACTED'
+  {
+    keys: ['app.query'],                           // 값 변환 (마스킹 아님)
+    scrub: (_key, value) =>
+      typeof value === 'string' ? value.slice(0, 64) : value,
+  },
+  { keys: ['app.internal'], scrub: () => undefined }, // 속성 제거
+]);
+
+const attributes = { 'app.user.email': 'a@b.test', 'app.span.type': 'route' };
+scrub(attributes); // true
+// attributes === { 'app.user.email': 'REDACTED', 'app.span.type': 'route' }
+```
+
+### `createAttributeScrubber(scrubbers?, options?): ScrubAttributes`
+
+규칙 목록을 하나의 함수로 컴파일합니다. 이 함수는 속성 객체를 **제자리에서** 수정하고 변경 여부를 반환하며, 예외를 던지지 않습니다.
+
+빈 목록·미지정·전부 유효하지 않은 목록은 공유 no-op으로 컴파일됩니다 — 매번 **동일한 함수 객체**이므로, 설정하지 않은 고객은 클로저·순회·복사 비용을 전혀 지불하지 않습니다.
+
+`options.onError(message, error?)`로 설정 오류와 스크러버 실패를 보고합니다. 이 패키지는 `@opentelemetry/api`에 의존하지 않아 `diag`에 직접 접근할 수 없으므로, 이를 감싸는 프로세서가 주입합니다. 기본값은 no-op입니다 — 편집기(redactor)가 요청받지 않은 채 고객 콘솔에 쓰는 일은 없어야 합니다.
+
+### 스크러버의 형태, 그리고 `(key, value) => value | undefined`가 아닌 이유
+
+스크러버는 **매처 + 변환**입니다.
+
+| 필드 | 용도 |
+|---|---|
+| `keys?: readonly string[]` | 정확히 일치하는 속성 키 (대소문자 구분) |
+| `keyPattern?: RegExp \| readonly RegExp[]` | 키에 대해 테스트할 패턴 |
+| `shouldScrub?: (key) => boolean` | 임의 술어(predicate). 탈출구 |
+| `scrub?: (key, value) => value \| undefined` | 치환할 값. 생략하면 `'REDACTED'`, `undefined`를 반환하면 속성 제거 |
+
+매처는 최소 하나가 필요합니다. 매처가 없는 규칙은 아무것도 매칭하지 않으므로, 조용히 동작하는 척하지 않고 생성 시점에 `onError`로 보고한 뒤 폐기합니다.
+
+단일 함수 형태를 택하지 않은 이유는 두 가지입니다.
+
+**"내 담당이 아님"을 표현할 수 없습니다.** `(key, value) => value | undefined` 스크러버는 모든 속성에 대해 호출되므로 세 가지 결과(그대로 두기·치환·삭제)가 필요한데, `undefined` 하나로는 그중 하나만 표현할 수 있습니다. 어느 쪽 의미를 부여하든 나머지는 표현 불가능해지며, 실수했을 때의 결과는 "받은 값을 되돌려주는 것을 잊은 스크러버가 모든 스팬을 조용히 비우는 것"입니다. 분리된 형태에는 잘못될 상태 자체가 없습니다.
+
+**저렴하게 만들 수 없습니다.** 이 코드는 모든 스팬과 모든 로그 레코드의 모든 속성마다 실행됩니다. 매처가 *데이터*이면 모든 규칙의 정확한 키를 하나의 공유 `Set`으로, 모든 패턴을 미리 컴파일한 하나의 `RegExp` 목록으로 합칠 수 있어, 아무도 관심 없는 속성은 규칙 개수와 무관하게 `Set` 조회 한 번으로 끝납니다 — 클로저도, 할당도, `try`/`catch` 진입도 없습니다. 매처가 함수이면 모든 속성마다 모든 규칙을 호출해야 합니다. (`shouldScrub`을 선언하면 그 규칙은 빠른 경로에서 빠지므로, 선언적 매처를 기본으로 문서화합니다.)
+
+패턴은 한 번만 컴파일합니다. 호출자의 `RegExp` 사본에서 `g`·`y` 플래그를 제거하는데, `RegExp.prototype.test`가 전역/스티키 패턴에서 `lastIndex`를 전진시켜 두 개 중 하나만 매칭하는 문제를 막기 위해서입니다. 호출자의 객체는 절대 변경하지 않습니다.
+
+매칭되는 모든 규칙이 선언 순서대로 값을 이어받아 실행되므로, 잘라내는 규칙 뒤에 해시하는 규칙을 두면 읽는 순서대로 합성됩니다.
+
+### 기본 스크러버는 의도적으로 없습니다
+
+URL 쪽은 19개 파라미터 이름과 함께 기본 보안 설정으로 출시됩니다. 속성 쪽은 비어 있습니다. 이 비대칭은 의도된 것입니다.
+
+**속성 키는 구조화된 네임스페이스이고, 쿼리 파라미터 이름은 아닙니다.** `?token=`은 작성자가 자유롭게 정하는 텍스트이고 거기서 `token`은 정말로 토큰을 뜻합니다. 반면 속성 키는 `http.request.header.authorization`, `app.screen.name`, `user.journey.id`입니다. 이 SDK가 내보내는 속성 중 이름이 그냥 `key`, `hash`, `auth`, `session`인 것은 없으므로, 같은 19개 이름을 그대로 옮겨와도 거의 아무것도 매칭하지 않고 보안 이득도 거의 없습니다.
+
+**이를 보완하려고 매칭을 느슨하게 하는 순간 위험해집니다.** `key`는 `service.key`의 부분 문자열이고, `session`은 `session.id`의 부분 문자열입니다 — 이 SDK에서 가장 핵심적인 속성이며, 모든 대시보드가 조인하고 ClickHouse의 명명 컬럼으로 승격되는 값입니다. 부분 문자열 기반 기본값은 이들을 조용히 0으로 만듭니다.
+
+**과잉 편집은 조용하고 되돌릴 수 없습니다.** 마스킹된 속성은 컬렉터에 아무 흔적도 남기지 않고, 복원 수단도 없으며, 그런 일이 있었다는 신호조차 없습니다. 반대로 편집 누락은 최소한 데이터에서 보입니다. 외부에서 감사할 수 없는 기본값이라면, 요청받지 않은 것은 편집하지 않는 쪽이 안전합니다.
+
+**정말 위험한 기본 표면은 이미 덮여 있습니다.** URL은 기본으로 편집됩니다. 실제로 비밀 값을 담는 속성은 고객이 직접 넣은 것들(`globalAttributes`, 콘솔 계측의 객체 전개, `data-sophonz-*`)이고, 그 키 이름을 아는 사람은 정확히 고객입니다. Embrace가 `attributeScrubbers`를 비운 채 출시하는 이유도 같습니다.
+
+즉, 아무것도 설정하지 않으면 이 프로세서를 설치한 적 없는 것과 바이트 단위로 동일한 텔레메트리가 전송됩니다.
+
+### 고객의 스크러버가 예외를 던졌을 때
+
+스크러버는 고객 페이지의 핫 패스에서 실행되는 임의 코드입니다. 모든 호출을 감싸며, 두 가지 실패를 의도적으로 다르게 다룹니다.
+
+| 예외 위치 | 결과 | 이유 |
+|---|---|---|
+| `scrub(key, value)` | 값이 `'REDACTED'`가 됩니다. 규칙은 계속 활성 상태입니다. 1회 보고. | **닫힌 실패(fail closed).** 매처가 매칭됐다는 것은 고객이 이 키에 비밀 값이 있을 수 있다고 알려준 것입니다. 변환 실패는 값의 안전 여부에 대해 아무것도 말해주지 않습니다. `'REDACTED'`는 키 삭제와 정확히 동일한 수준으로 유출을 막으면서, 삭제와 달리 "값이 있었고 억제되었다"는 흔적을 남깁니다 — 조용히 사라진 키는 애초에 설정된 적 없는 키와 구분되지 않고, 그 이름을 그대로 매칭하는 대시보드를 0으로 만들 수 있습니다. |
+| `shouldScrub(key)` | 속성을 그대로 둡니다. 해당 규칙은 페이지 수명 동안 **비활성화**됩니다. 1회 보고. | 예외를 던진 술어는 이 키에 대해 아무것도 알려주지 않았습니다. 예외를 매칭으로 취급하면 모든 스팬의 모든 속성을 끌 방법 없이 편집하게 되고, 비매칭으로 취급하면 편집이 누락되지만 그 대상은 명백히 고장 난 규칙 하나뿐이며 보고도 됩니다. 계속 호출하면 속성마다 예외 비용을 영원히 지불하게 됩니다. |
+
+보고는 규칙당 1회만 발생하므로, 모든 스팬의 모든 속성에서 실패하는 규칙이 콘솔을 도배할 수 없습니다. 고장 난 규칙이 다른 규칙을 비활성화하지도 않습니다.
+
+## 범위
+
+이 패키지는 전송·SDK에 중립적입니다. `@opentelemetry/api`에 의존하지 않으며 스팬이나 로그 레코드에 대해 아무것도 모릅니다. 파이프라인 배선 — 프로세서 체인의 어느 지점에서 실행되는지, 그 시점에 무엇을 변경할 수 있는지 — 은 `@sophonz/span-processors`와 `@sophonz/log-processors`에 있습니다.

package/README.md

@@ -0,0 +1,191 @@
+# @sophonz/redaction
+
+[한국어](./README-ko.md)
+
+Redaction primitives for the Sophonz browser SDK, in two halves: **URL sanitizing** and **attribute scrubbing**.
+
+The URL half strips `user:password@` credentials and the values of well-known sensitive query parameters before a URL is written to a span, a log record or an exported attribute.
+
+Ported from the OpenTelemetry browser navigation instrumentation's `defaultSanitizeUrl`, with Embrace's `additionalQueryParamsToScrub` ergonomic layered on top.
+
+No runtime dependencies.
+
+Part of the Sophonz OpenTelemetry suite.
+
+## Install
+
+```bash
+bun add @sophonz/redaction
+# or
+pnpm add @sophonz/redaction
+# or
+npm install @sophonz/redaction
+```
+
+## Usage
+
+```ts
+import { defaultSanitizeUrl } from '@sophonz/redaction';
+
+defaultSanitizeUrl('https://api.example.com/v1/me?token=abc&page=2');
+// 'https://api.example.com/v1/me?token=REDACTED&page=2'
+
+defaultSanitizeUrl('https://alice:hunter2@api.example.com/v1/me');
+// 'https://REDACTED:REDACTED@api.example.com/v1/me'
+```
+
+To redact your own parameters on top of the defaults:
+
+```ts
+import { createSanitizeUrl } from '@sophonz/redaction';
+
+const sanitizeUrl = createSanitizeUrl({
+  additionalQueryParamsToScrub: ['x-api-key', 'sig'],
+});
+
+sanitizeUrl('https://api.example.com/v1?x-api-key=abc&password=p&page=2');
+// 'https://api.example.com/v1?x-api-key=REDACTED&password=REDACTED&page=2'
+```
+
+## API
+
+### `defaultSanitizeUrl(url: string): string`
+
+Redacts credentials and the 19 default parameters. Never throws.
+
+### `createSanitizeUrl(options?: SanitizeUrlOptions): SanitizeUrl`
+
+Builds a sanitizer. `createSanitizeUrl()` with no options is equivalent to `defaultSanitizeUrl`.
+
+| Option | Type | Default | Meaning |
+|---|---|---|---|
+| `additionalQueryParamsToScrub` | `readonly string[]` | `[]` | Names redacted *in addition to* the defaults |
+| `queryParamsToScrub` | `readonly string[]` | the 19 defaults | Replaces the default list outright. Prefer the option above |
+| `redactCredentials` | `boolean` | `true` | Redact `user:password@` in the authority |
+| `scrubFragment` | `boolean` | `true` | Also scan the fragment for parameters |
+
+### `DEFAULT_QUERY_PARAMS_TO_SCRUB: readonly string[]`
+
+The 19 default names, frozen: `password`, `passwd`, `secret`, `api_key`, `apikey`, `auth`, `authorization`, `token`, `access_token`, `refresh_token`, `jwt`, `session`, `sessionid`, `key`, `private_key`, `client_secret`, `client_id`, `signature`, `hash`.
+
+### `REDACTED: 'REDACTED'`
+
+The marker substituted for every redacted value.
+
+### `type SanitizeUrl = (url: string) => string`
+
+The hook signature instrumentations accept.
+
+## Behaviour
+
+**The value is replaced, never the key.** `?token=abc` becomes `?token=REDACTED`. Deleting the key would hide that a secret was ever present, which is the thing an operator reading the telemetry most needs to know. This follows the OpenTelemetry `url.query` guidance that a redacted key SHOULD be preserved.
+
+**Parameter names match exactly, case-insensitively.** `?Token=` and `?TOKEN=` are redacted; `?tokenizer=`, `?keyword=` and `?monkey=` are not. Substring matching would be catastrophic here — the default list contains short generic words (`key`, `auth`, `hash`, `session`) that appear inside a great many innocent parameter names, and over-redaction has no off switch. `additionalQueryParamsToScrub` is the supported way to cover variants such as `api-key`.
+
+Names are compared after decoding `+` to a space and resolving percent escapes, and after trimming surrounding whitespace, so `?%74oken=` and `?%20token=` are both redacted.
+
+**Every occurrence is redacted independently.** `?token=a&token=b` becomes `?token=REDACTED&token=REDACTED` rather than collapsing to one pair; losing the repetition would misrepresent the request.
+
+**The fragment is scanned.** The OAuth 2.0 implicit grant delivers `access_token` in the fragment precisely so it never reaches a server, which makes the fragment a place real secrets live. Both `#access_token=…` and hash routes carrying `#/checkout?token=…` are covered. A fragment that is not a parameter list (`#installation`, `#/orders/42`) contains no `name=value` pair and passes through untouched. Set `scrubFragment: false` to opt out.
+
+**Nothing else changes.** The implementation is string-based and does not round-trip through `URL` or `URLSearchParams`, so the path, encoding, parameter order, host case, default port and trailing-slash-or-not all come back byte-for-byte identical. A `URL` round-trip would rewrite `http://x.test` to `http://x.test/`, drop `:80`, lower-case the host, and re-encode the whole query string (`%20` to `+`) whether or not anything was redacted — differences that make a URL harder to match against what the application actually requested.
+
+**It never throws, and there is no unparseable input.** Nothing is parsed, so nothing can fail to parse: relative URLs (`/api?token=…`), protocol-relative URLs, `data:` and `blob:` URIs, and malformed strings are all handled by the same code path and are still redacted. Two edge cases are defined explicitly:
+
+- A **non-string** argument returns `''`. This is a caller type error, not a redaction failure; there is provably no secret in `undefined`, and coercing an arbitrary object would mean invoking a `toString` we have not inspected.
+- An **internal failure** — unreachable by construction, but guarded — returns the bare string `REDACTED`. Returning the input unchanged would be unsafe, because the input is exactly what we failed to redact. A `url.full` attribute equal to exactly `REDACTED` means the sanitizer bailed on that URL.
+
+## Differences from the upstream OpenTelemetry implementation
+
+Three deliberate corrections, all covered by tests:
+
+| Upstream | Here |
+|---|---|
+| `searchParams.has(param)` is case-**sensitive**, so `?Token=` survives on the `URL` path (the regex fallback is case-insensitive, so behaviour differs by input) | Case-insensitive on every input |
+| `searchParams.set(param, …)` collapses repeated parameters, so `?token=a&token=b` becomes `?token=REDACTED` | Each occurrence redacted in place |
+| `new URL(url)` throws on relative URLs, falling back to building 19 `RegExp` objects per call; the `URL` path also re-encodes and normalises the whole URL | One string pass, no `RegExp` construction per call, no normalisation |
+
+## Attribute scrubbing
+
+The URL sanitizer above covers URLs. `createAttributeScrubber` covers **attributes** — Embrace's `attributeScrubbers`, per-key redaction applied to every span and every log record, so a secret that lands in an attribute rather than a URL is caught too.
+
+It is consumed by `SophonzSpanAttributeScrubbingProcessor` (`@sophonz/span-processors`) and `SophonzLogAttributeScrubbingProcessor` (`@sophonz/log-processors`), and configured through the SDK's `attributeScrubbers` option.
+
+```ts
+import { createAttributeScrubber } from '@sophonz/redaction';
+
+const scrub = createAttributeScrubber([
+  { keys: ['app.user.email'] },                    // -> 'REDACTED'
+  { keyPattern: /^http\.request\.header\./ },       // -> 'REDACTED'
+  {
+    keys: ['app.query'],                           // transform, not blank
+    scrub: (_key, value) =>
+      typeof value === 'string' ? value.slice(0, 64) : value,
+  },
+  { keys: ['app.internal'], scrub: () => undefined }, // remove the attribute
+]);
+
+const attributes = { 'app.user.email': 'a@b.test', 'app.span.type': 'route' };
+scrub(attributes); // true
+// attributes === { 'app.user.email': 'REDACTED', 'app.span.type': 'route' }
+```
+
+### `createAttributeScrubber(scrubbers?, options?): ScrubAttributes`
+
+Compiles a list of rules into one function that edits an attribute bag **in place** and returns whether anything changed. Never throws.
+
+An empty, absent or entirely invalid list compiles to a shared no-op — literally the same function object every time, so an unconfigured SDK is not paying for a closure, an iteration or a copy.
+
+`options.onError(message, error?)` receives misconfiguration and scrubber failures. This package has no dependency on `@opentelemetry/api`, so it cannot reach `diag` itself; the processors that wrap it pass one in. It defaults to a no-op — a redactor must never write to a customer's console uninvited.
+
+### The scrubber shape, and why it is not `(key, value) => value | undefined`
+
+A scrubber is a **matcher plus a transform**:
+
+| Field | Purpose |
+|---|---|
+| `keys?: readonly string[]` | Exact attribute keys, case-sensitive |
+| `keyPattern?: RegExp \| readonly RegExp[]` | Patterns tested against the key |
+| `shouldScrub?: (key) => boolean` | Arbitrary predicate; the escape hatch |
+| `scrub?: (key, value) => value \| undefined` | Replacement value. Omit for `'REDACTED'`; return `undefined` to remove the attribute |
+
+At least one matcher is required. A rule with none matches nothing and is dropped at construction with an `onError` report, rather than silently pretending to work.
+
+The single-function alternative was rejected for two reasons.
+
+**It has no way to say "not mine".** A `(key, value) => value | undefined` scrubber is called for every attribute, so it needs three outcomes — leave it, replace it, delete it — and `undefined` can only encode one. Whichever meaning it is given, the other becomes inexpressible; and the failure mode of getting it wrong is a scrubber that forgets to return the value it was handed, which silently empties every span. The split has no such state to get wrong.
+
+**It cannot be made cheap.** This runs on every attribute of every span and every log record. With the matcher as *data*, all rules' exact keys compile into one shared `Set` and all their patterns into one shared, pre-compiled `RegExp` list, so an attribute nobody cares about costs one set lookup regardless of how many rules are configured — no closure, no allocation, no `try`/`catch` entered. With the matcher as a function, every rule must be invoked for every attribute. (Declaring a `shouldScrub` opts that rule out of the fast path, which is why the declarative matchers are the documented default.)
+
+Patterns are compiled once. A `g` or `y` flag is stripped from a copy of the caller's `RegExp`, because `RegExp.prototype.test` advances `lastIndex` on a global or sticky pattern and would otherwise match only every other attribute. The caller's object is never mutated.
+
+Every matching rule runs, in declaration order, threading the value through — so a truncating rule followed by a hashing rule composes the way it reads.
+
+### There are no default scrubbers, deliberately
+
+The URL half ships secure-by-default with 19 parameter names. The attribute half ships empty. That asymmetry is intentional.
+
+**Attribute keys are a structured namespace; query parameter names are not.** `?token=` is free-form, author-chosen text where `token` really does mean a token. Attribute keys are `http.request.header.authorization`, `app.screen.name`, `user.journey.id`. Nothing in this SDK emits an attribute literally named `key`, `hash`, `auth` or `session`, so the same 19 names transplanted here would match almost nothing and buy almost no security.
+
+**Loosening the match to compensate is where it turns dangerous.** `key` is a substring of `service.key`; `session` is a substring of `session.id` — the single most load-bearing attribute in this SDK, joined on by every dashboard and promoted to a named ClickHouse column. A substring default would silently zero them.
+
+**Over-redaction is silent and has no off switch.** A blanked attribute leaves no trace at the collector, there is no un-redact, and nothing signals that it happened. Under-redaction is at least visible in the data. Given a default that cannot be audited from the outside, the safe direction is to redact nothing you were not asked to.
+
+**The dangerous default surface is already covered.** URLs redact by default. The attributes that carry secrets in practice are ones the customer put there — `globalAttributes`, the console instrumentation's object spread, `data-sophonz-*` — and the customer is exactly who knows those key names. Embrace ships its `attributeScrubbers` empty for the same reason.
+
+So: configure nothing and your telemetry is byte-identical to having never installed the processor.
+
+### What happens when a customer's scrubber throws
+
+A scrubber is arbitrary code on the hot path of someone's page. Every invocation is wrapped, and the two failures are treated differently on purpose:
+
+| Throws in | Outcome | Why |
+|---|---|---|
+| `scrub(key, value)` | Value becomes `'REDACTED'`. The rule stays active. Reported once. | **Fail closed.** The matcher fired, so the customer has told us this key may carry a secret; the transform failing says nothing about whether the value is safe. `'REDACTED'` is exactly as leak-proof as deleting the key, and unlike deleting it, leaves visible evidence that a value was there and was suppressed — a silently vanished key is indistinguishable from one that was never set, and can zero a dashboard that matches it by literal name. |
+| `shouldScrub(key)` | Attribute left alone. The rule is **disabled** for the rest of the page's life. Reported once. | A predicate that throws has told us nothing about this key. Treating the throw as a match would redact every attribute of every span with no way to switch it off; treating it as a non-match under-redacts, but only for a rule that is provably broken, and it is reported. Continuing to call it would burn CPU on a throw per attribute forever. |
+
+Reports are emitted once per rule so a rule that fails on every attribute of every span cannot turn the console into a firehose. A broken rule never disables its siblings.
+
+## Scope
+
+This package is transport- and SDK-agnostic: it has no dependency on `@opentelemetry/api` and knows nothing about spans or log records. Wiring it into the pipeline — where in the processor chain it runs, and what may be mutated at that point — lives in `@sophonz/span-processors` and `@sophonz/log-processors`.

package/build/attributes.d.ts

@@ -0,0 +1,3 @@
+import type { AttributeScrubber, AttributeScrubberOptions, ScrubAttributes } from './types';
+export declare function createAttributeScrubber(scrubbers: readonly AttributeScrubber[] | null | undefined, options?: AttributeScrubberOptions): ScrubAttributes;
+//# sourceMappingURL=attributes.d.ts.map

package/build/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../src/attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,wBAAwB,EACxB,eAAe,EAEhB,MAAM,SAAS,CAAC;AAyEjB,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,iBAAiB,EAAE,GAAG,IAAI,GAAG,SAAS,EAC1D,OAAO,GAAE,wBAA6B,GACrC,eAAe,CA+MjB"}

package/build/attributes.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAttributeScrubber = createAttributeScrubber;
+const url_1 = require("./url");
+const NOOP_SCRUB = function noopScrubAttributes() {
+    return false;
+};
+function stateless(pattern) {
+    if (pattern.global || pattern.sticky) {
+        return new RegExp(pattern.source, pattern.flags.replace('g', '').replace('y', ''));
+    }
+    return pattern;
+}
+function matchesAnyPattern(patterns, key) {
+    for (let i = 0; i < patterns.length; i++) {
+        if (patterns[i].test(key)) {
+            return true;
+        }
+    }
+    return false;
+}
+function createAttributeScrubber(scrubbers, options = {}) {
+    const onError = options.onError;
+    if (!scrubbers || scrubbers.length === 0) {
+        return NOOP_SCRUB;
+    }
+    const compiled = [];
+    const allKeys = new Set();
+    const allPatterns = [];
+    let hasPredicate = false;
+    for (let i = 0; i < scrubbers.length; i++) {
+        const scrubber = scrubbers[i];
+        if (!scrubber || typeof scrubber !== 'object') {
+            onError === null || onError === void 0 ? void 0 : onError(`attributeScrubbers[${i}] is not an object; ignoring it`);
+            continue;
+        }
+        const entry = { broken: false, reported: false };
+        if (scrubber.keys && scrubber.keys.length > 0) {
+            const keys = new Set();
+            for (let k = 0; k < scrubber.keys.length; k++) {
+                const key = scrubber.keys[k];
+                if (typeof key === 'string' && key !== '') {
+                    keys.add(key);
+                    allKeys.add(key);
+                }
+            }
+            if (keys.size > 0) {
+                entry.keys = keys;
+            }
+        }
+        if (scrubber.keyPattern) {
+            const raw = scrubber.keyPattern instanceof RegExp
+                ? [scrubber.keyPattern]
+                : scrubber.keyPattern;
+            const patterns = [];
+            for (let p = 0; p < raw.length; p++) {
+                if (raw[p] instanceof RegExp) {
+                    const pattern = stateless(raw[p]);
+                    patterns.push(pattern);
+                    allPatterns.push(pattern);
+                }
+            }
+            if (patterns.length > 0) {
+                entry.patterns = patterns;
+            }
+        }
+        if (typeof scrubber.shouldScrub === 'function') {
+            entry.predicate = scrubber.shouldScrub;
+            hasPredicate = true;
+        }
+        if (!entry.keys && !entry.patterns && !entry.predicate) {
+            onError === null || onError === void 0 ? void 0 : onError(`attributeScrubbers[${i}] declares no keys, keyPattern or shouldScrub; ` +
+                'it would match nothing and has been ignored');
+            continue;
+        }
+        if (typeof scrubber.scrub === 'function') {
+            entry.scrub = scrubber.scrub;
+        }
+        compiled.push(entry);
+    }
+    if (compiled.length === 0) {
+        return NOOP_SCRUB;
+    }
+    function report(entry, message, error) {
+        if (entry.reported) {
+            return;
+        }
+        entry.reported = true;
+        onError === null || onError === void 0 ? void 0 : onError(message, error);
+    }
+    function matches(entry, key) {
+        if (entry.keys !== undefined && entry.keys.has(key)) {
+            return true;
+        }
+        if (entry.patterns !== undefined && matchesAnyPattern(entry.patterns, key)) {
+            return true;
+        }
+        if (entry.predicate !== undefined) {
+            try {
+                return entry.predicate(key) === true;
+            }
+            catch (error) {
+                entry.broken = true;
+                report(entry, 'an attribute scrubber\'s shouldScrub() threw; the scrubber has been ' +
+                    'disabled and its attributes will NOT be redacted', error);
+                return false;
+            }
+        }
+        return false;
+    }
+    return function scrubAttributes(attributes) {
+        if (attributes === null || typeof attributes !== 'object') {
+            return false;
+        }
+        let changed = false;
+        let toDelete;
+        for (const key in attributes) {
+            if (!Object.prototype.hasOwnProperty.call(attributes, key)) {
+                continue;
+            }
+            if (!hasPredicate &&
+                !allKeys.has(key) &&
+                !matchesAnyPattern(allPatterns, key)) {
+                continue;
+            }
+            const original = attributes[key];
+            let value = original;
+            let remove = false;
+            for (let i = 0; i < compiled.length; i++) {
+                const entry = compiled[i];
+                if (entry.broken || !matches(entry, key)) {
+                    continue;
+                }
+                let next;
+                if (entry.scrub === undefined) {
+                    next = url_1.REDACTED;
+                }
+                else {
+                    try {
+                        next = entry.scrub(key, value);
+                    }
+                    catch (error) {
+                        report(entry, `an attribute scrubber's scrub() threw for key "${key}"; the ` +
+                            'value has been replaced with REDACTED', error);
+                        next = url_1.REDACTED;
+                    }
+                }
+                if (next === undefined) {
+                    remove = true;
+                    break;
+                }
+                value = next;
+            }
+            if (remove) {
+                (toDelete !== null && toDelete !== void 0 ? toDelete : (toDelete = [])).push(key);
+                changed = true;
+            }
+            else if (!Object.is(value, original)) {
+                attributes[key] = value;
+                changed = true;
+            }
+        }
+        if (toDelete !== undefined) {
+            for (let i = 0; i < toDelete.length; i++) {
+                delete attributes[toDelete[i]];
+            }
+        }
+        return changed;
+    };
+}

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export { createAttributeScrubber } from './attributes';
+export { createSanitizeUrl, DEFAULT_QUERY_PARAMS_TO_SCRUB, defaultSanitizeUrl, REDACTED, } from './url';
+export type { AttributeScrubber, AttributeScrubberOptions, SanitizeUrl, SanitizeUrlOptions, ScrubAttributes, ScrubbableValue, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,EACL,iBAAiB,EACjB,6BAA6B,EAC7B,kBAAkB,EAClB,QAAQ,GACT,MAAM,OAAO,CAAC;AAEf,YAAY,EACV,iBAAiB,EACjB,wBAAwB,EACxB,WAAW,EACX,kBAAkB,EAClB,eAAe,EACf,eAAe,GAChB,MAAM,SAAS,CAAC"}

package/build/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDACTED = exports.defaultSanitizeUrl = exports.DEFAULT_QUERY_PARAMS_TO_SCRUB = exports.createSanitizeUrl = exports.createAttributeScrubber = void 0;
+var attributes_1 = require("./attributes");
+Object.defineProperty(exports, "createAttributeScrubber", { enumerable: true, get: function () { return attributes_1.createAttributeScrubber; } });
+var url_1 = require("./url");
+Object.defineProperty(exports, "createSanitizeUrl", { enumerable: true, get: function () { return url_1.createSanitizeUrl; } });
+Object.defineProperty(exports, "DEFAULT_QUERY_PARAMS_TO_SCRUB", { enumerable: true, get: function () { return url_1.DEFAULT_QUERY_PARAMS_TO_SCRUB; } });
+Object.defineProperty(exports, "defaultSanitizeUrl", { enumerable: true, get: function () { return url_1.defaultSanitizeUrl; } });
+Object.defineProperty(exports, "REDACTED", { enumerable: true, get: function () { return url_1.REDACTED; } });

package/build/types.d.ts

@@ -0,0 +1,21 @@
+export type SanitizeUrl = (url: string) => string;
+export interface SanitizeUrlOptions {
+    additionalQueryParamsToScrub?: readonly string[];
+    queryParamsToScrub?: readonly string[];
+    redactCredentials?: boolean;
+    scrubFragment?: boolean;
+}
+export type ScrubbableValue = string | number | boolean | null | undefined | Uint8Array | ScrubbableValue[] | {
+    [key: string]: ScrubbableValue;
+};
+export interface AttributeScrubber {
+    keys?: readonly string[];
+    keyPattern?: RegExp | readonly RegExp[];
+    shouldScrub?: (key: string) => boolean;
+    scrub?: (key: string, value: ScrubbableValue) => ScrubbableValue | undefined;
+}
+export interface AttributeScrubberOptions {
+    onError?: (message: string, error?: unknown) => void;
+}
+export type ScrubAttributes = (attributes: Record<string, unknown>) => boolean;
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;AAKlD,MAAM,WAAW,kBAAkB;IAWjC,4BAA4B,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAUjD,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAKvC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAW5B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAsBD,MAAM,MAAM,eAAe,GACvB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,UAAU,GACV,eAAe,EAAE,GACjB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAA;CAAE,CAAC;AAyBvC,MAAM,WAAW,iBAAiB;IAQhC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IASzB,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IAgBxC,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAWvC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,KAAK,eAAe,GAAG,SAAS,CAAC;CAC9E;AAKD,MAAM,WAAW,wBAAwB;IAQvC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CACtD;AAYD,MAAM,MAAM,eAAe,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC"}

package/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/url.d.ts

@@ -0,0 +1,6 @@
+import type { SanitizeUrl, SanitizeUrlOptions } from './types';
+export declare const REDACTED = "REDACTED";
+export declare const DEFAULT_QUERY_PARAMS_TO_SCRUB: readonly string[];
+export declare function createSanitizeUrl(options?: SanitizeUrlOptions): SanitizeUrl;
+export declare function defaultSanitizeUrl(url: string): string;
+//# sourceMappingURL=url.d.ts.map

package/build/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../src/url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAY/D,eAAO,MAAM,QAAQ,aAAa,CAAC;AAMnC,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAoBzD,CAAC;AAgMH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,kBAAuB,GAC/B,WAAW,CAsCb;AAgBD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/build/url.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_QUERY_PARAMS_TO_SCRUB = exports.REDACTED = void 0;
+exports.createSanitizeUrl = createSanitizeUrl;
+exports.defaultSanitizeUrl = defaultSanitizeUrl;
+exports.REDACTED = 'REDACTED';
+exports.DEFAULT_QUERY_PARAMS_TO_SCRUB = Object.freeze([
+    'password',
+    'passwd',
+    'secret',
+    'api_key',
+    'apikey',
+    'auth',
+    'authorization',
+    'token',
+    'access_token',
+    'refresh_token',
+    'jwt',
+    'session',
+    'sessionid',
+    'key',
+    'private_key',
+    'client_secret',
+    'client_id',
+    'signature',
+    'hash',
+]);
+const SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+function isSlash(ch) {
+    return ch === '/' || ch === '\\';
+}
+function normalizeParamName(raw) {
+    let name = raw;
+    if (name.indexOf('+') !== -1) {
+        name = name.split('+').join(' ');
+    }
+    if (name.indexOf('%') !== -1) {
+        try {
+            name = decodeURIComponent(name);
+        }
+        catch {
+        }
+    }
+    return name.trim().toLowerCase();
+}
+function scrubParams(params, scrub) {
+    if (params === '' || params.indexOf('=') === -1) {
+        return params;
+    }
+    const pairs = params.split('&');
+    let changed = false;
+    for (let i = 0; i < pairs.length; i++) {
+        const pair = pairs[i];
+        const eq = pair.indexOf('=');
+        if (eq === -1) {
+            continue;
+        }
+        const rawName = pair.slice(0, eq);
+        if (!scrub.has(normalizeParamName(rawName))) {
+            continue;
+        }
+        const redacted = rawName + '=' + exports.REDACTED;
+        if (redacted !== pair) {
+            pairs[i] = redacted;
+            changed = true;
+        }
+    }
+    return changed ? pairs.join('&') : params;
+}
+function scrubFragmentParams(fragment, scrub) {
+    const q = fragment.indexOf('?');
+    if (q !== -1) {
+        return fragment.slice(0, q + 1) + scrubParams(fragment.slice(q + 1), scrub);
+    }
+    return scrubParams(fragment, scrub);
+}
+function redactCredentials(head) {
+    let start = -1;
+    if (head.length >= 2 && isSlash(head[0]) && isSlash(head[1])) {
+        start = 2;
+    }
+    else {
+        const scheme = SCHEME.exec(head);
+        if (scheme !== null) {
+            let i = scheme[0].length;
+            let slashes = 0;
+            while (i < head.length && isSlash(head[i])) {
+                i++;
+                slashes++;
+            }
+            if (slashes >= 2) {
+                start = i;
+            }
+        }
+    }
+    if (start === -1) {
+        return head;
+    }
+    let end = start;
+    while (end < head.length && !isSlash(head[end])) {
+        end++;
+    }
+    const authority = head.slice(start, end);
+    const at = authority.lastIndexOf('@');
+    if (at === -1) {
+        return head;
+    }
+    const userinfo = authority.slice(0, at);
+    const replacement = userinfo.indexOf(':') === -1 ? exports.REDACTED : exports.REDACTED + ':' + exports.REDACTED;
+    if (userinfo === replacement) {
+        return head;
+    }
+    return head.slice(0, start) + replacement + head.slice(start + at);
+}
+function sanitize(url, scrub, credentials, fragment) {
+    const hash = url.indexOf('#');
+    const beforeHash = hash === -1 ? url : url.slice(0, hash);
+    const fragmentText = hash === -1 ? '' : url.slice(hash + 1);
+    const question = beforeHash.indexOf('?');
+    const head = question === -1 ? beforeHash : beforeHash.slice(0, question);
+    const query = question === -1 ? '' : beforeHash.slice(question + 1);
+    let out = credentials ? redactCredentials(head) : head;
+    if (question !== -1) {
+        out += '?' + scrubParams(query, scrub);
+    }
+    if (hash !== -1) {
+        out +=
+            '#' +
+                (fragment ? scrubFragmentParams(fragmentText, scrub) : fragmentText);
+    }
+    return out;
+}
+function createSanitizeUrl(options = {}) {
+    var _a;
+    const scrub = new Set();
+    const base = (_a = options.queryParamsToScrub) !== null && _a !== void 0 ? _a : exports.DEFAULT_QUERY_PARAMS_TO_SCRUB;
+    for (let i = 0; i < base.length; i++) {
+        scrub.add(normalizeParamName(base[i]));
+    }
+    const extra = options.additionalQueryParamsToScrub;
+    if (extra) {
+        for (let i = 0; i < extra.length; i++) {
+            scrub.add(normalizeParamName(extra[i]));
+        }
+    }
+    scrub.delete('');
+    const credentials = options.redactCredentials !== false;
+    const fragment = options.scrubFragment !== false;
+    return function sanitizeUrl(url) {
+        if (typeof url !== 'string' || url === '') {
+            return '';
+        }
+        try {
+            return sanitize(url, scrub, credentials, fragment);
+        }
+        catch {
+            return exports.REDACTED;
+        }
+    };
+}
+const sanitizeWithDefaults = createSanitizeUrl();
+function defaultSanitizeUrl(url) {
+    return sanitizeWithDefaults(url);
+}

package/build/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.0.1";
+//# sourceMappingURL=version.d.ts.map

package/build/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/build/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = '0.0.1';

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@sophonz/redaction",
+  "version": "0.0.2",
+  "description": "Sophonz Redaction",
+  "homepage": "https://sophonz.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sophonz-labs/sophonz-js.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "files": [
+    "build/*",
+    "README-ko.md"
+  ],
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "devDependencies": {
+    "@sophonz/rollup-shared": "*"
+  },
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "require": "./build/index.js",
+      "default": "./build/index.js"
+    }
+  }
+}