@pratikw/detect 0.1.1

package/dist/engine.d.ts

@@ -0,0 +1,16 @@
+import type { CloakResult, CustomPattern, DataCloakConfig, Detection, RestoreResult } from './types.js';
+import { Vault } from './vault.js';
+export declare class DataCloakEngine {
+    readonly vault: Vault;
+    private config;
+    constructor(config?: Partial<DataCloakConfig>);
+    detect(text: string): Detection[];
+    cloak(text: string): CloakResult;
+    private makeSynthetic;
+    private synthEnvValue;
+    private cloakInner;
+    private vaultImport;
+    private vaultAbsorb;
+    restore(text: string): RestoreResult;
+}
+export type { CustomPattern };

package/dist/engine.js

@@ -0,0 +1,108 @@
+import { faker } from '@faker-js/faker';
+import { defaultConfig } from './types.js';
+import { detectPass1 } from './patterns/index.js';
+import { scanEntropy } from './entropy.js';
+import { synthesize } from './synthesizers/index.js';
+import { synthesizeDsn } from './synthesizers/credentials.js';
+import { opaqueToken } from './tokens.js';
+import { Vault } from './vault.js';
+export class DataCloakEngine {
+    vault;
+    config;
+    constructor(config = {}) {
+        this.config = { ...defaultConfig, ...config, detection: { ...defaultConfig.detection, ...config.detection }, vault: { ...defaultConfig.vault, ...config.vault } };
+        // Validate custom patterns loudly at construction (DET-08)
+        for (const c of this.config.customPatterns ?? []) {
+            try {
+                new RegExp(c.pattern);
+            }
+            catch {
+                throw new Error(`datacloak: invalid custom pattern "${c.name}"`);
+            }
+        }
+        this.vault = new Vault(this.config.vault.maxEntries);
+    }
+    detect(text) {
+        const d = this.config.detection;
+        const pass1 = detectPass1(text, { secrets: d.secrets, envVars: d.envVars, pii: d.pii }, this.config.customPatterns ?? []);
+        const out = [...pass1];
+        if (d.entropy) {
+            for (const h of scanEntropy(text, d.entropyThreshold)) {
+                if (out.some((x) => h.start < x.end && x.start < h.end))
+                    continue;
+                out.push({ value: h.value, category: 'HIGH_ENTROPY_STRING', type: 'secret', start: h.start, end: h.end, confidence: 'medium' });
+            }
+        }
+        out.sort((a, b) => a.start - b.start || b.end - a.end);
+        return out;
+    }
+    cloak(text) {
+        const detections = this.detect(text);
+        const substitutions = [];
+        let result = text;
+        for (let i = detections.length - 1; i >= 0; i--) {
+            const det = detections[i];
+            const existing = this.vault.getByOriginal(det.value);
+            let synthetic = existing;
+            if (!synthetic) {
+                synthetic = this.makeSynthetic(det, text);
+                this.vault.set({ original: det.value, synthetic, category: det.category, type: det.type, synthesizedAt: Date.now(), confidence: det.confidence });
+            }
+            result = result.slice(0, det.start) + synthetic + result.slice(det.end);
+            substitutions.unshift({ original: det.value, synthetic, category: det.category });
+        }
+        return { text: result, substitutions };
+    }
+    makeSynthetic(det, fullText) {
+        if (det.category === 'ENV_VAR')
+            return this.synthEnvValue(det.value);
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const s = synthesize(det.category, det.value) ?? opaqueToken(det.category);
+            if (!fullText.includes(s))
+                return s;
+        }
+        return opaqueToken(det.category);
+    }
+    synthEnvValue(value) {
+        const trimmed = value.replace(/^["']|["']$/g, '');
+        const quote = value.startsWith('"') || value.startsWith("'") ? value[0] : '';
+        const inner = this.cloakInner(trimmed);
+        return `${quote}${inner}${quote}`;
+    }
+    cloakInner(value) {
+        // DSN-aware: synthesize whole DSN so protocol/port survive
+        const dsnCats = ['DSN_POSTGRES', 'DSN_MONGO', 'DSN_REDIS', 'DSN_MYSQL', 'DSN_AMQP'];
+        const asDsn = detectPass1(value, { secrets: false, envVars: true, pii: false }).find((x) => dsnCats.includes(x.category));
+        if (asDsn && asDsn.value === value) {
+            const existing = this.vault.getByOriginal(value);
+            if (existing)
+                return existing;
+            const s = synthesizeDsn(value);
+            this.vault.set({ original: value, synthetic: s, category: asDsn.category, type: 'credential', synthesizedAt: Date.now(), confidence: 'high' });
+            return s;
+        }
+        // Otherwise cloak secrets/pii/entropy inside the value, offset by quote (handled by caller via full-string replace below)
+        const inner = new DataCloakEngine({ detection: { secrets: true, envVars: false, pii: true, entropy: true, entropyThreshold: this.config.detection.entropyThreshold }, vault: { maxEntries: this.config.vault.maxEntries } });
+        inner.vaultImport(this.vault);
+        const r = inner.cloak(value);
+        this.vaultAbsorb(inner.vault);
+        return r.text === value ? `SYNTH${faker.string.alphanumeric(16)}` : r.text;
+    }
+    vaultImport(_other) { }
+    vaultAbsorb(other) {
+        for (const e of other.list())
+            this.vault.set(e);
+    }
+    restore(text) {
+        const entries = this.vault.list().sort((a, b) => b.synthetic.length - a.synthetic.length);
+        let result = text;
+        let restored = 0;
+        for (const e of entries) {
+            if (!result.includes(e.synthetic))
+                continue;
+            result = result.split(e.synthetic).join(e.original);
+            restored++;
+        }
+        return { text: result, restored };
+    }
+}

package/dist/entropy.d.ts

@@ -0,0 +1,6 @@
+export declare function shannon(s: string): number;
+export declare function scanEntropy(text: string, threshold: number): {
+    value: string;
+    start: number;
+    end: number;
+}[];

package/dist/entropy.js

@@ -0,0 +1,29 @@
+export function shannon(s) {
+    if (s.length === 0)
+        return 0;
+    const freq = new Map();
+    for (const ch of s)
+        freq.set(ch, (freq.get(ch) ?? 0) + 1);
+    let h = 0;
+    for (const count of freq.values()) {
+        const p = count / s.length;
+        h -= p * Math.log2(p);
+    }
+    return h;
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function scanEntropy(text, threshold) {
+    const out = [];
+    const re = /[^\s"'`,;()]+/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const value = m[0];
+        if (value.length < 20 || UUID.test(value))
+            continue;
+        if (value.startsWith('data:image'))
+            continue;
+        if (shannon(value) >= threshold)
+            out.push({ value, start: m.index, end: m.index + value.length });
+    }
+    return out;
+}

package/dist/patterns/credentials.d.ts

@@ -0,0 +1,4 @@
+import type { PatternEntry } from './secrets.js';
+export declare const CREDENTIAL_KEY_NAMES: string[];
+export declare const isCredentialKey: (key: string) => boolean;
+export declare const credentialPatterns: PatternEntry[];

package/dist/patterns/credentials.js

@@ -0,0 +1,18 @@
+export const CREDENTIAL_KEY_NAMES = ['PASSWORD', 'PASSWD', 'SECRET', 'API_KEY', 'APIKEY', 'API_SECRET', 'ACCESS_KEY', 'ACCESS_TOKEN', 'AUTH_TOKEN', 'PRIVATE_KEY', 'CLIENT_SECRET', 'DB_PASSWORD', 'DATABASE_URL', 'CONNECTION_STRING', 'AWS_SECRET_ACCESS_KEY', 'GITHUB_TOKEN', 'STRIPE_SECRET_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'SLACK_TOKEN', 'SENDGRID_API_KEY', 'TWILIO_AUTH_TOKEN', 'SUPABASE_KEY', 'VERCEL_TOKEN', 'SHOPIFY_TOKEN', 'GITLAB_TOKEN', 'HUGGINGFACE_TOKEN', 'JWT_SECRET', 'SESSION_SECRET', 'ENCRYPTION_KEY'];
+export const isCredentialKey = (key) => {
+    const k = key.toUpperCase();
+    if (CREDENTIAL_KEY_NAMES.includes(k))
+        return true;
+    return /(PASSWORD|PASSWD|SECRET|TOKEN|PRIVATE[_-]?KEY|ACCESS[_-]?KEY|API[_-]?KEY|CONNECTION|DATABASE[_-]?URL|DSN)/.test(k);
+};
+export const credentialPatterns = [
+    // Contextual matches first: on identical spans de-overlap keeps the earliest,
+    // so ENV_VAR wins over the bare DSN inside its value (test: env value span).
+    { name: 'env-var', category: 'ENV_VAR', type: 'credential', regex: /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*("[^"\n]*"|'[^'\n]*'|[^\s"'`#;]+)/gm, confidence: 'high', valueGroup: 2 },
+    { name: 'inline-config', category: 'INLINE_CONFIG', type: 'credential', regex: /["']?(?:api[_-]?key|secret|password|token|access[_-]?key)["']?\s*[:=]\s*["']([^"'`\s]+)["']?/gi, confidence: 'high', valueGroup: 1 },
+    { name: 'dsn-postgres', category: 'DSN_POSTGRES', type: 'credential', regex: /postgres(?:ql)?:\/\/[^\s"'`]+/g, confidence: 'high' },
+    { name: 'dsn-mongo', category: 'DSN_MONGO', type: 'credential', regex: /mongodb(?:\+srv)?:\/\/[^\s"'`]+/g, confidence: 'high' },
+    { name: 'dsn-redis', category: 'DSN_REDIS', type: 'credential', regex: /redis:\/\/(?::[^\s@]+@)?[^\s"'`]+/g, confidence: 'high' },
+    { name: 'dsn-mysql', category: 'DSN_MYSQL', type: 'credential', regex: /mysql:\/\/[^\s"'`]+/g, confidence: 'high' },
+    { name: 'dsn-amqp', category: 'DSN_AMQP', type: 'credential', regex: /amqp:\/\/(?:[^:\s@]+(?::[^\s@]*)?@)?[^\s"'`]+/g, confidence: 'high' },
+];

package/dist/patterns/index.d.ts

@@ -0,0 +1,7 @@
+import type { CustomPattern, Detection } from '../types.js';
+export interface Pass1Opts {
+    secrets: boolean;
+    envVars: boolean;
+    pii: boolean;
+}
+export declare function detectPass1(text: string, opts: Pass1Opts, custom?: CustomPattern[]): Detection[];

package/dist/patterns/index.js

@@ -0,0 +1,56 @@
+import { secretPatterns } from './secrets.js';
+import { credentialPatterns, isCredentialKey } from './credentials.js';
+import { piiPatterns } from './pii.js';
+export function detectPass1(text, opts, custom = []) {
+    const entries = [];
+    // Contextual credential patterns first: exact-tie de-overlap keeps the
+    // earliest, so ENV_VAR/INLINE_CONFIG win over the bare secret in their value.
+    if (opts.envVars)
+        entries.push(...credentialPatterns);
+    if (opts.secrets)
+        entries.push(...secretPatterns);
+    if (opts.pii)
+        entries.push(...piiPatterns);
+    for (const c of custom) {
+        let regex;
+        try {
+            regex = new RegExp(c.pattern, 'g');
+        }
+        catch {
+            throw new Error(`datacloak: invalid custom pattern "${c.name}"`);
+        }
+        entries.push({ name: c.name, category: c.category, type: c.type, regex, confidence: 'medium' });
+    }
+    const out = [];
+    for (const e of entries) {
+        e.regex.lastIndex = 0;
+        let m;
+        while ((m = e.regex.exec(text)) !== null) {
+            if (m[0].length === 0) {
+                e.regex.lastIndex++;
+                continue;
+            }
+            let value = m[0], start = m.index;
+            if (e.valueGroup !== undefined && m[e.valueGroup] !== undefined) {
+                value = m[e.valueGroup];
+                start = m.index + m[0].indexOf(value);
+            }
+            if (e.name === 'env-var') {
+                const key = m[1];
+                if (!isCredentialKey(key))
+                    continue;
+            }
+            out.push({ value, category: e.category, type: e.type, start, end: start + value.length, confidence: e.confidence });
+            if (m[0].length === 0)
+                e.regex.lastIndex++;
+        }
+    }
+    out.sort((a, b) => a.start - b.start || b.end - a.end);
+    const kept = [];
+    for (const d of out) {
+        if (kept.length > 0 && d.start < kept[kept.length - 1].end)
+            continue;
+        kept.push(d);
+    }
+    return kept;
+}

package/dist/patterns/pii.d.ts

@@ -0,0 +1,2 @@
+import type { PatternEntry } from './secrets.js';
+export declare const piiPatterns: PatternEntry[];

package/dist/patterns/pii.js

@@ -0,0 +1,7 @@
+const p = (name, category, regex) => ({ name, category, type: 'pii', regex, confidence: 'high' });
+export const piiPatterns = [
+    p('email', 'EMAIL', /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g),
+    p('phone-e164', 'PHONE_E164', /\+[1-9]\d{7,14}/g),
+    p('ipv4', 'IPV4', /\b(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\b/g),
+    p('phone-us', 'PHONE_US', /\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g),
+];

package/dist/patterns/secrets.d.ts

@@ -0,0 +1,10 @@
+import type { EntryType, Confidence } from '../types.js';
+export interface PatternEntry {
+    name: string;
+    category: string;
+    type: EntryType;
+    regex: RegExp;
+    confidence: Confidence;
+    valueGroup?: number;
+}
+export declare const secretPatterns: PatternEntry[];

package/dist/patterns/secrets.js

@@ -0,0 +1,12 @@
+const s = (name, category, regex) => ({ name, category, type: 'secret', regex, confidence: 'high' });
+export const secretPatterns = [
+    s('anthropic', 'API_KEY_ANTHROPIC', /sk-ant-api03-[A-Za-z0-9\-_]{20,}/g),
+    s('openai', 'API_KEY_OPENAI', /sk-[A-Za-z0-9]{20,}/g),
+    s('aws', 'AWS_ACCESS_KEY', /AKIA[0-9A-Z]{16}/g),
+    s('github-classic', 'GITHUB_PAT', /ghp_[A-Za-z0-9]{36}/g),
+    s('github-fine', 'GITHUB_PAT', /github_pat_[A-Za-z0-9_]{22,}/g),
+    s('stripe-sk', 'STRIPE_KEY', /sk_live_[A-Za-z0-9]{16,}/g),
+    s('stripe-rk', 'STRIPE_KEY', /rk_live_[A-Za-z0-9]{16,}/g),
+    s('jwt', 'JWT', /eyJ[A-Za-z0-9\-_]+\.eyJ[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_=.]+/g),
+    s('pem', 'PEM_KEY', /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g),
+];

package/dist/synthesizers/credentials.d.ts

@@ -0,0 +1 @@
+export declare function synthesizeDsn(original: string): string;

package/dist/synthesizers/credentials.js

@@ -0,0 +1,12 @@
+import { faker } from '@faker-js/faker';
+const DSN = /^([a-z+]+:\/\/)(?:([^:@/\s]+)(?::([^@/\s]*))?@)?([^:/\s]+)(?::(\d+))?(\/[^?\s]*)?(\?[^\s]*)?$/i;
+export function synthesizeDsn(original) {
+    const m = DSN.exec(original);
+    if (!m)
+        return original;
+    const [, proto, , , , port, path, query] = m;
+    const user = faker.internet.username().replace(/[^A-Za-z0-9_]/g, '_');
+    const pass = `SYNTHpw${faker.number.int({ min: 10, max: 99 })}`;
+    const host = `${faker.internet.domainWord()}.${faker.internet.domainSuffix()}`;
+    return `${proto}${user}:${pass}@${host}${port ? `:${port}` : ''}${path ?? ''}${query ?? ''}`;
+}

package/dist/synthesizers/index.d.ts

@@ -0,0 +1 @@
+export declare function synthesize(category: string, original: string): string | null;

package/dist/synthesizers/index.js

@@ -0,0 +1,24 @@
+import { synthEmail, synthIpv4, synthPhoneE164, synthPhoneUS } from './pii.js';
+import { synthAnthropic, synthAws, synthGithub, synthJwt, synthOpenAI, synthPem, synthStripe } from './secrets.js';
+import { synthesizeDsn } from './credentials.js';
+export function synthesize(category, original) {
+    switch (category) {
+        case 'EMAIL': return synthEmail();
+        case 'PHONE_US': return synthPhoneUS();
+        case 'PHONE_E164': return synthPhoneE164();
+        case 'IPV4': return synthIpv4();
+        case 'API_KEY_OPENAI': return synthOpenAI();
+        case 'API_KEY_ANTHROPIC': return synthAnthropic();
+        case 'AWS_ACCESS_KEY': return synthAws();
+        case 'GITHUB_PAT': return synthGithub();
+        case 'STRIPE_KEY': return synthStripe(original.startsWith('rk_live_') ? 'rk_live_' : 'sk_live_');
+        case 'JWT': return synthJwt();
+        case 'PEM_KEY': return synthPem();
+        case 'DSN_POSTGRES':
+        case 'DSN_MONGO':
+        case 'DSN_REDIS':
+        case 'DSN_MYSQL':
+        case 'DSN_AMQP': return synthesizeDsn(original);
+        default: return null;
+    }
+}

package/dist/synthesizers/pii.d.ts

@@ -0,0 +1,4 @@
+export declare function synthEmail(): string;
+export declare function synthPhoneUS(): string;
+export declare function synthPhoneE164(): string;
+export declare function synthIpv4(): string;

package/dist/synthesizers/pii.js

@@ -0,0 +1,5 @@
+import { faker } from '@faker-js/faker';
+export function synthEmail() { return faker.internet.email(); }
+export function synthPhoneUS() { return `(${faker.string.numeric(3)}) 555-01${faker.string.numeric(2)}`; }
+export function synthPhoneE164() { return `+44770090${faker.string.numeric(4)}`; }
+export function synthIpv4() { return faker.internet.ipv4(); }

package/dist/synthesizers/secrets.d.ts

@@ -0,0 +1,7 @@
+export declare function synthOpenAI(): string;
+export declare function synthAnthropic(): string;
+export declare function synthAws(): string;
+export declare function synthGithub(): string;
+export declare function synthStripe(prefix: string): string;
+export declare function synthJwt(overrides?: Record<string, unknown>): string;
+export declare function synthPem(): string;

package/dist/synthesizers/secrets.js

@@ -0,0 +1,29 @@
+import { faker } from '@faker-js/faker';
+const alnum = (n) => faker.string.alphanumeric(n);
+export function synthOpenAI() { return `sk-SYNTH${alnum(20)}`; }
+export function synthAnthropic() { return `sk-ant-api03-SYNTH${alnum(20)}`; }
+export function synthAws() { return `AKIA${faker.string.alphanumeric({ length: 16, casing: 'upper' })}`; }
+export function synthGithub() { return `ghp_SYNTH${alnum(31)}`; }
+export function synthStripe(prefix) { return `${prefix}SYNTH${alnum(20)}`; }
+export function synthJwt(overrides = {}) {
+    const b64 = (o) => {
+        const s = JSON.stringify(o);
+        const G = globalThis;
+        if (G.Buffer)
+            return G.Buffer.from(s, 'utf8').toString('base64url');
+        const bytes = new TextEncoder().encode(s);
+        let bin = '';
+        for (const b of bytes)
+            bin += String.fromCharCode(b);
+        return btoa(bin).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    };
+    const header = b64({ alg: 'HS256', typ: 'JWT' });
+    const now = Math.floor(Date.now() / 1000);
+    const body = b64({ sub: `synth-${faker.string.uuid()}`, iat: now, exp: now + 3600, ...overrides });
+    return `${header}.${body}.SYNTH${alnum(32)}`;
+}
+// ponytail: static throwaway PEM template; real @noble/curves keypair gen deferred to follow-up
+export function synthPem() {
+    const b64body = faker.string.alphanumeric(64);
+    return `-----BEGIN RSA PRIVATE KEY-----\nSYNTH${b64body}\n-----END RSA PRIVATE KEY-----`;
+}

package/dist/tokens.d.ts

@@ -0,0 +1 @@
+export declare function opaqueToken(category: string): string;

package/dist/tokens.js

@@ -0,0 +1,4 @@
+import { faker } from '@faker-js/faker';
+export function opaqueToken(category) {
+    return `[${category.toUpperCase()}_${faker.string.alphanumeric({ length: 6, casing: 'upper' })}]`;
+}

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+export type Confidence = 'high' | 'medium';
+export type EntryType = 'pii' | 'secret' | 'credential';
+export interface Detection {
+    value: string;
+    category: string;
+    type: EntryType;
+    start: number;
+    end: number;
+    confidence: Confidence;
+}
+export interface Substitution {
+    original: string;
+    synthetic: string;
+    category: string;
+}
+export interface CloakResult {
+    text: string;
+    substitutions: Substitution[];
+}
+export interface RestoreResult {
+    text: string;
+    restored: number;
+}
+export interface VaultEntry {
+    original: string;
+    synthetic: string;
+    category: string;
+    type: EntryType;
+    synthesizedAt: number;
+    confidence: Confidence;
+}
+export interface CustomPattern {
+    name: string;
+    pattern: string;
+    category: string;
+    type: EntryType;
+}
+export interface DataCloakConfig {
+    detection: {
+        secrets: boolean;
+        envVars: boolean;
+        pii: boolean;
+        entropy: boolean;
+        entropyThreshold: number;
+    };
+    vault: {
+        maxEntries: number;
+    };
+    customPatterns?: CustomPattern[];
+}
+export declare const defaultConfig: DataCloakConfig;

package/dist/types.js

@@ -0,0 +1,4 @@
+export const defaultConfig = {
+    detection: { secrets: true, envVars: true, pii: true, entropy: true, entropyThreshold: 4.5 },
+    vault: { maxEntries: 2000 },
+};

package/dist/vault.d.ts

@@ -0,0 +1,13 @@
+import type { VaultEntry } from './types.js';
+export declare class Vault {
+    private maxEntries;
+    private bySynthetic;
+    private origToSynth;
+    constructor(maxEntries?: number);
+    get size(): number;
+    set(entry: VaultEntry): void;
+    getBySynthetic(s: string): VaultEntry | undefined;
+    getByOriginal(o: string): string | undefined;
+    list(): VaultEntry[];
+    clear(): void;
+}

package/dist/vault.js

@@ -0,0 +1,29 @@
+export class Vault {
+    maxEntries;
+    bySynthetic = new Map();
+    origToSynth = new Map();
+    constructor(maxEntries = 2000) {
+        this.maxEntries = maxEntries;
+    }
+    get size() { return this.bySynthetic.size; }
+    set(entry) {
+        if (this.bySynthetic.has(entry.synthetic))
+            return;
+        const prev = this.origToSynth.get(entry.original);
+        if (prev !== undefined && prev !== entry.synthetic)
+            this.bySynthetic.delete(prev);
+        this.bySynthetic.set(entry.synthetic, entry);
+        this.origToSynth.set(entry.original, entry.synthetic);
+        while (this.bySynthetic.size > this.maxEntries) {
+            const oldest = this.bySynthetic.keys().next().value;
+            const evicted = this.bySynthetic.get(oldest);
+            this.bySynthetic.delete(oldest);
+            if (evicted && this.origToSynth.get(evicted.original) === oldest)
+                this.origToSynth.delete(evicted.original);
+        }
+    }
+    getBySynthetic(s) { return this.bySynthetic.get(s); }
+    getByOriginal(o) { return this.origToSynth.get(o); }
+    list() { return [...this.bySynthetic.values()]; }
+    clear() { this.bySynthetic.clear(); this.origToSynth.clear(); }
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@pratikw/detect",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "dist/engine.js",
+  "types": "dist/engine.d.ts",
+  "files": ["dist"],
+  "publishConfig": { "access": "public" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pratikwayal01/datacloak.git",
+    "directory": "packages/detect"
+  },
+  "scripts": { "build": "tsc", "test": "vitest run", "prepublishOnly": "npm run build && npm test" },
+  "dependencies": { "@faker-js/faker": "^10.6.0" },
+  "devDependencies": { "typescript": "~5.6.3", "vitest": "^3.0.0" }
+}