@pellux/goodvibes-sdk 0.25.21 → 0.26.0

package/dist/_internal/platform/knowledge/browser-history/ingest.js

@@ -0,0 +1,275 @@
+import { createHash } from 'node:crypto';
+import { emitKnowledgeIngestCompleted, emitKnowledgeIngestFailed, emitKnowledgeIngestStarted, } from '../../runtime/emitters/index.js';
+import { summarizeError } from '../../utils/error-display.js';
+import { compileKnowledgeSource } from '../ingest-compile.js';
+import { canonicalizeUri, estimateTokens, isHttpUri, mergeTags, slugify } from '../internal.js';
+import { discoverBrowserKnowledgeProfiles } from './discover.js';
+import { readBrowserKnowledgeProfile } from './readers.js';
+function timestampForEntry(entry) {
+    return entry.sourceKind === 'history' ? entry.visitedAtMs : entry.addedAtMs;
+}
+function hashAggregate(aggregate) {
+    return createHash('sha256')
+        .update(JSON.stringify(aggregate.entries.map((entry) => ({
+        sourceKind: entry.sourceKind,
+        url: entry.url,
+        browser: entry.browser,
+        profilePath: entry.profilePath,
+        rawId: entry.rawId,
+        recordedAt: timestampForEntry(entry),
+    }))))
+        .digest('hex');
+}
+function sourceTypeForAggregate(aggregate) {
+    return aggregate.sourceKinds.includes('bookmark') ? 'bookmark' : 'history';
+}
+function titleForAggregate(aggregate) {
+    return aggregate.entries.find((entry) => entry.title)?.title
+        ?? aggregate.entries[0]?.url
+        ?? aggregate.canonicalUri;
+}
+function folderForAggregate(aggregate) {
+    return aggregate.folders[0] ?? `/browser/${aggregate.browsers[0] ?? 'local'}`;
+}
+function tagsForAggregate(aggregate) {
+    return mergeTags([
+        'browser',
+        ...aggregate.browsers,
+        ...aggregate.sourceKinds.map((kind) => kind === 'history' ? 'browser-history' : 'browser-bookmark'),
+    ]);
+}
+function metadataForAggregate(aggregate) {
+    return {
+        browserKnowledge: true,
+        browserSourceKinds: [...aggregate.sourceKinds],
+        browserKinds: [...aggregate.browsers],
+        browserProfiles: [...aggregate.profileKeys],
+        browserFolders: [...aggregate.folders],
+        browserObservationCount: aggregate.entries.length,
+        browserVisitCount: aggregate.visitCount,
+        ...(typeof aggregate.firstRecordedAt === 'number' ? { browserFirstRecordedAt: aggregate.firstRecordedAt } : {}),
+        ...(typeof aggregate.lastRecordedAt === 'number' ? { browserLastRecordedAt: aggregate.lastRecordedAt } : {}),
+        browserObservations: aggregate.entries.slice(0, 32).map((entry) => ({
+            sourceKind: entry.sourceKind,
+            browser: entry.browser,
+            browserFamily: entry.family,
+            profileName: entry.profileName,
+            profilePath: entry.profilePath,
+            title: entry.title,
+            rawId: entry.rawId,
+            recordedAt: timestampForEntry(entry),
+            ...(entry.sourceKind === 'history' ? {
+                visitCount: entry.visitCount,
+                transition: entry.transition,
+            } : {
+                folderPath: entry.folderPath,
+            }),
+        })),
+    };
+}
+function describeAggregate(aggregate) {
+    const parts = [
+        aggregate.sourceKinds.includes('bookmark') && aggregate.sourceKinds.includes('history')
+            ? 'Browser-local page observed in bookmarks and history.'
+            : aggregate.sourceKinds.includes('bookmark')
+                ? 'Browser-local page observed in bookmarks.'
+                : 'Browser-local page observed in browsing history.',
+        `Browsers: ${aggregate.browsers.join(', ')}.`,
+        `Profiles: ${aggregate.profileKeys.join(', ')}.`,
+        aggregate.visitCount > 0 ? `Visit count: ${aggregate.visitCount}.` : '',
+        typeof aggregate.lastRecordedAt === 'number' ? `Last recorded: ${new Date(aggregate.lastRecordedAt).toISOString()}.` : '',
+        aggregate.folders.length ? `Folders: ${aggregate.folders.slice(0, 4).join(', ')}.` : '',
+        `URL: ${aggregate.canonicalUri}`,
+    ].filter(Boolean);
+    return parts.join(' ');
+}
+function extractionForAggregate(aggregate, source) {
+    const summary = describeAggregate(aggregate);
+    return {
+        extractorId: 'browser-history',
+        format: 'text',
+        title: titleForAggregate(aggregate),
+        summary,
+        excerpt: summary,
+        sections: mergeTags([
+            ...aggregate.sourceKinds.map((kind) => `browser ${kind}`),
+            ...aggregate.browsers,
+            ...aggregate.folders,
+        ]).slice(0, 24),
+        links: [aggregate.canonicalUri],
+        estimatedTokens: estimateTokens(summary, aggregate.canonicalUri, titleForAggregate(aggregate)),
+        structure: {
+            sourceKinds: [...aggregate.sourceKinds],
+            browsers: [...aggregate.browsers],
+            profiles: [...aggregate.profileKeys],
+            canonicalUri: source.canonicalUri,
+        },
+        metadata: metadataForAggregate(aggregate),
+    };
+}
+function aggregateBrowserEntries(entries) {
+    const buckets = new Map();
+    for (const entry of entries) {
+        if (!isHttpUri(entry.url))
+            continue;
+        const canonicalUri = canonicalizeUri(entry.url) ?? entry.url;
+        const bucket = buckets.get(canonicalUri) ?? [];
+        bucket.push(entry);
+        buckets.set(canonicalUri, bucket);
+    }
+    return [...buckets.entries()].map(([canonicalUri, bucket]) => {
+        const sorted = [...bucket].sort((a, b) => (timestampForEntry(b) ?? 0) - (timestampForEntry(a) ?? 0));
+        const timestamps = sorted.map(timestampForEntry).filter((value) => typeof value === 'number');
+        const kinds = new Set(sorted.map((entry) => entry.sourceKind));
+        const sourceKinds = ['history', 'bookmark'].filter((kind) => kinds.has(kind));
+        const browsers = mergeTags(sorted.map((entry) => entry.browser));
+        const profileKeys = mergeTags(sorted.map((entry) => `${entry.browser}:${entry.profileName}`));
+        const folders = mergeTags(sorted.flatMap((entry) => entry.sourceKind === 'bookmark' && entry.folderPath ? [entry.folderPath] : []));
+        const visitCount = sorted.reduce((sum, entry) => (entry.sourceKind === 'history' ? sum + Math.max(1, entry.visitCount ?? 1) : sum), 0);
+        return {
+            canonicalUri,
+            entries: sorted,
+            sourceKinds,
+            browsers,
+            profileKeys,
+            folders,
+            ...(timestamps.length ? { firstRecordedAt: Math.min(...timestamps), lastRecordedAt: Math.max(...timestamps) } : {}),
+            visitCount,
+        };
+    }).sort((a, b) => (b.lastRecordedAt ?? 0) - (a.lastRecordedAt ?? 0));
+}
+async function upsertAggregate(context, aggregate, options = {}) {
+    const existing = context.store.getSourceByCanonicalUri(aggregate.canonicalUri);
+    const sourceType = existing?.sourceType ?? sourceTypeForAggregate(aggregate);
+    const connectorId = existing?.connectorId ?? options.connectorId ?? 'browser-local';
+    const summary = describeAggregate(aggregate);
+    const source = await context.store.upsertSource({
+        ...(existing ? { id: existing.id } : {}),
+        connectorId,
+        sourceType,
+        title: existing?.title ?? titleForAggregate(aggregate),
+        sourceUri: existing?.sourceUri ?? aggregate.canonicalUri,
+        canonicalUri: aggregate.canonicalUri,
+        summary: existing?.summary ?? summary,
+        description: existing?.description ?? summary,
+        tags: mergeTags(existing?.tags, tagsForAggregate(aggregate)),
+        folderPath: existing?.folderPath ?? folderForAggregate(aggregate),
+        status: 'indexed',
+        artifactId: existing?.artifactId,
+        contentHash: existing?.contentHash ?? hashAggregate(aggregate),
+        lastCrawledAt: existing?.lastCrawledAt ?? Date.now(),
+        sessionId: options.sessionId ?? existing?.sessionId,
+        metadata: {
+            ...(existing?.metadata ?? {}),
+            ...metadataForAggregate(aggregate),
+        },
+    });
+    const existingExtraction = context.store.getExtractionBySourceId(source.id);
+    const extraction = existingExtraction ?? await context.store.upsertExtraction({
+        sourceId: source.id,
+        ...extractionForAggregate(aggregate, source),
+    });
+    for (const entry of aggregate.entries) {
+        const browserNode = await context.store.upsertNode({
+            kind: 'source_group',
+            slug: slugify(`browser-${entry.browser}-${entry.profileName}`),
+            title: `${entry.browser} ${entry.profileName}`,
+            summary: `Local ${entry.browser} browser profile imported from ${entry.profilePath}.`,
+            aliases: [entry.browser, entry.profileName],
+            status: 'active',
+            confidence: 85,
+            metadata: {
+                browser: entry.browser,
+                browserFamily: entry.family,
+                browserProfilePath: entry.profilePath,
+            },
+        });
+        await context.store.upsertEdge({
+            fromKind: 'source',
+            fromId: source.id,
+            toKind: 'node',
+            toId: browserNode.id,
+            relation: entry.sourceKind === 'history' ? 'visited_in_browser_profile' : 'bookmarked_in_browser_profile',
+            weight: timestampForEntry(entry) ? 1.2 : 1,
+            metadata: {
+                sourceKind: entry.sourceKind,
+                recordedAt: timestampForEntry(entry),
+                browser: entry.browser,
+                profileName: entry.profileName,
+                ...(entry.sourceKind === 'bookmark' && entry.folderPath ? { folderPath: entry.folderPath } : {}),
+            },
+        });
+    }
+    await compileKnowledgeSource(context, source, extraction);
+    return source;
+}
+export async function collectBrowserKnowledge(filter = {}) {
+    const profiles = await discoverBrowserKnowledgeProfiles(filter);
+    const entries = [];
+    const errors = [];
+    const perProfileLimit = Math.max(1, Math.ceil((filter.limit ?? 1000) / Math.max(1, profiles.length)));
+    const sourceKinds = filter.sourceKinds ?? ['history', 'bookmark'];
+    for (const profile of profiles) {
+        try {
+            const found = await readBrowserKnowledgeProfile(profile, {
+                limit: perProfileLimit,
+                sinceMs: filter.sinceMs,
+                sourceKinds,
+            });
+            entries.push(...found);
+        }
+        catch (error) {
+            errors.push(`${profile.browser}/${profile.profileName}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    entries.sort((a, b) => (timestampForEntry(b) ?? 0) - (timestampForEntry(a) ?? 0));
+    return {
+        profiles,
+        entries: entries.slice(0, filter.limit ?? entries.length),
+        errors,
+    };
+}
+export async function ingestBrowserKnowledge(context, options = {}) {
+    await context.store.init();
+    const collected = await collectBrowserKnowledge(options);
+    const aggregates = aggregateBrowserEntries(collected.entries);
+    const sources = [];
+    const errors = [...collected.errors];
+    let imported = 0;
+    let failed = 0;
+    for (const aggregate of aggregates) {
+        try {
+            context.emitIfReady((bus, ctx) => emitKnowledgeIngestStarted(bus, ctx, {
+                sourceId: aggregate.canonicalUri,
+                connectorId: options.connectorId ?? 'browser-local',
+                sourceType: sourceTypeForAggregate(aggregate),
+                uri: aggregate.canonicalUri,
+            }), options.sessionId);
+            const source = await upsertAggregate(context, aggregate, options);
+            sources.push(source);
+            imported += 1;
+            context.emitIfReady((bus, ctx) => emitKnowledgeIngestCompleted(bus, ctx, {
+                sourceId: source.id,
+                status: source.status,
+                title: source.title,
+            }), source.sessionId);
+        }
+        catch (error) {
+            failed += 1;
+            errors.push(`${aggregate.canonicalUri}: ${summarizeError(error)}`);
+            context.emitIfReady((bus, ctx) => emitKnowledgeIngestFailed(bus, ctx, {
+                sourceId: aggregate.canonicalUri,
+                error: summarizeError(error),
+            }), options.sessionId);
+        }
+    }
+    await context.syncReviewedMemory();
+    await context.lint();
+    return {
+        imported,
+        failed,
+        sources,
+        errors,
+        profiles: collected.profiles,
+    };
+}

package/dist/_internal/platform/knowledge/browser-history/locked-db.d.ts

@@ -0,0 +1,7 @@
+export interface LockedBrowserDbCopy {
+    readonly copiedDbPath: string;
+    readonly tempDir: string;
+    cleanup(): Promise<void>;
+}
+export declare function copyLockedBrowserSqlite(sourcePath: string): Promise<LockedBrowserDbCopy>;
+//# sourceMappingURL=locked-db.d.ts.map

package/dist/_internal/platform/knowledge/browser-history/locked-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locked-db.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/browser-history/locked-db.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAWD,wBAAsB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA0B9F"}

package/dist/_internal/platform/knowledge/browser-history/locked-db.js

@@ -0,0 +1,38 @@
+import { access, copyFile, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function copyLockedBrowserSqlite(sourcePath) {
+    if (!(await exists(sourcePath))) {
+        throw new Error(`Browser SQLite file does not exist: ${sourcePath}`);
+    }
+    const tempDir = await mkdtemp(join(tmpdir(), 'goodvibes-browser-db-'));
+    const baseName = basename(sourcePath);
+    const copiedDbPath = join(tempDir, baseName);
+    await copyFile(sourcePath, copiedDbPath);
+    for (const suffix of ['-wal', '-shm']) {
+        const source = `${sourcePath}${suffix}`;
+        if (await exists(source)) {
+            await copyFile(source, join(tempDir, `${baseName}${suffix}`));
+        }
+    }
+    let cleaned = false;
+    return {
+        copiedDbPath,
+        tempDir,
+        async cleanup() {
+            if (cleaned)
+                return;
+            cleaned = true;
+            await rm(tempDir, { recursive: true, force: true });
+        },
+    };
+}

package/dist/_internal/platform/knowledge/browser-history/paths.d.ts

@@ -0,0 +1,15 @@
+import type { BrowserKnowledgeFamily, BrowserKnowledgeKind } from './types.js';
+interface BrowserPathEntry {
+    readonly family: BrowserKnowledgeFamily;
+    readonly paths: Partial<Record<'linux' | 'darwin', readonly string[]>>;
+    readonly profileGlob: string;
+    readonly historyFile: string;
+    readonly bookmarksFile: string;
+}
+export declare const BROWSER_PATHS: Record<BrowserKnowledgeKind, BrowserPathEntry>;
+export declare function listBrowserKinds(): BrowserKnowledgeKind[];
+export declare function getBrowserPathEntry(kind: BrowserKnowledgeKind): BrowserPathEntry;
+export declare function expandBrowserRoots(kind: BrowserKnowledgeKind, homeOverride?: string): string[];
+export declare function profileGlobToRegex(kind: BrowserKnowledgeKind): RegExp;
+export {};
+//# sourceMappingURL=paths.d.ts.map

package/dist/_internal/platform/knowledge/browser-history/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/browser-history/paths.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE/E,UAAU,gBAAgB;IACxB,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,GAAG,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;IACvE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAKD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,oBAAoB,EAAE,gBAAgB,CA0GxE,CAAC;AAEF,wBAAgB,gBAAgB,IAAI,oBAAoB,EAAE,CAEzD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,oBAAoB,GAAG,gBAAgB,CAEhF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,oBAAoB,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAI9F;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,oBAAoB,GAAG,MAAM,CAErE"}

package/dist/_internal/platform/knowledge/browser-history/paths.js

@@ -0,0 +1,125 @@
+import { homedir } from 'node:os';
+import { normalize } from 'node:path';
+const CHROMIUM_PROFILES = '(Default|Profile .+|Guest Profile)';
+const GECKO_PROFILES = '(.+\\.default|.+\\.default-release|.+\\.dev-edition-default|[a-z0-9]+\\..+)';
+export const BROWSER_PATHS = {
+    chrome: {
+        family: 'chromium',
+        paths: { linux: ['~/.config/google-chrome', '~/.config/google-chrome-beta'], darwin: ['~/Library/Application Support/Google/Chrome'] },
+        profileGlob: CHROMIUM_PROFILES,
+        historyFile: 'History',
+        bookmarksFile: 'Bookmarks',
+    },
+    chromium: {
+        family: 'chromium',
+        paths: { linux: ['~/.config/chromium'], darwin: ['~/Library/Application Support/Chromium'] },
+        profileGlob: CHROMIUM_PROFILES,
+        historyFile: 'History',
+        bookmarksFile: 'Bookmarks',
+    },
+    brave: {
+        family: 'chromium',
+        paths: { linux: ['~/.config/BraveSoftware/Brave-Browser'], darwin: ['~/Library/Application Support/BraveSoftware/Brave-Browser'] },
+        profileGlob: CHROMIUM_PROFILES,
+        historyFile: 'History',
+        bookmarksFile: 'Bookmarks',
+    },
+    edge: {
+        family: 'chromium',
+        paths: { linux: ['~/.config/microsoft-edge', '~/.config/microsoft-edge-dev'], darwin: ['~/Library/Application Support/Microsoft Edge'] },
+        profileGlob: CHROMIUM_PROFILES,
+        historyFile: 'History',
+        bookmarksFile: 'Bookmarks',
+    },
+    vivaldi: {
+        family: 'chromium',
+        paths: { linux: ['~/.config/vivaldi'], darwin: ['~/Library/Application Support/Vivaldi'] },
+        profileGlob: CHROMIUM_PROFILES,
+        historyFile: 'History',
+        bookmarksFile: 'Bookmarks',
+    },
+    arc: {
+        family: 'chromium',
+        paths: { darwin: ['~/Library/Application Support/Arc/User Data'] },
+        profileGlob: CHROMIUM_PROFILES,
+        historyFile: 'History',
+        bookmarksFile: 'Bookmarks',
+    },
+    opera: {
+        family: 'chromium',
+        paths: { linux: ['~/.config/opera'], darwin: ['~/Library/Application Support/com.operasoftware.Opera'] },
+        profileGlob: CHROMIUM_PROFILES,
+        historyFile: 'History',
+        bookmarksFile: 'Bookmarks',
+    },
+    firefox: {
+        family: 'gecko',
+        paths: { linux: ['~/.mozilla/firefox', '~/snap/firefox/common/.mozilla/firefox', '~/.var/app/org.mozilla.firefox/.mozilla/firefox'], darwin: ['~/Library/Application Support/Firefox/Profiles'] },
+        profileGlob: GECKO_PROFILES,
+        historyFile: 'places.sqlite',
+        bookmarksFile: 'places.sqlite',
+    },
+    zen: {
+        family: 'gecko',
+        paths: { linux: ['~/.zen'], darwin: ['~/Library/Application Support/zen/Profiles'] },
+        profileGlob: '(.+\\.default|.+\\.default-release|[a-z0-9]+\\..+)',
+        historyFile: 'places.sqlite',
+        bookmarksFile: 'places.sqlite',
+    },
+    librewolf: {
+        family: 'gecko',
+        paths: { linux: ['~/.librewolf'], darwin: ['~/Library/Application Support/LibreWolf/Profiles'] },
+        profileGlob: '(.+\\.default|.+\\.default-release|[a-z0-9]+\\..+)',
+        historyFile: 'places.sqlite',
+        bookmarksFile: 'places.sqlite',
+    },
+    waterfox: {
+        family: 'gecko',
+        paths: { linux: ['~/.waterfox'], darwin: ['~/Library/Application Support/Waterfox/Profiles'] },
+        profileGlob: '(.+\\.default|.+\\.default-release|[a-z0-9]+\\..+)',
+        historyFile: 'places.sqlite',
+        bookmarksFile: 'places.sqlite',
+    },
+    floorp: {
+        family: 'gecko',
+        paths: { linux: ['~/.floorp'], darwin: ['~/Library/Application Support/Floorp/Profiles'] },
+        profileGlob: '(.+\\.default|.+\\.default-release|[a-z0-9]+\\..+)',
+        historyFile: 'places.sqlite',
+        bookmarksFile: 'places.sqlite',
+    },
+    safari: {
+        family: 'webkit',
+        paths: { darwin: ['~/Library/Safari'] },
+        profileGlob: '(Default)',
+        historyFile: 'History.db',
+        bookmarksFile: 'Bookmarks.plist',
+    },
+    orion: {
+        family: 'webkit',
+        paths: { darwin: ['~/Library/Application Support/Orion'] },
+        profileGlob: '(Default|Profile .+)',
+        historyFile: 'History.db',
+        bookmarksFile: 'Bookmarks.plist',
+    },
+    epiphany: {
+        family: 'webkit',
+        paths: { linux: ['~/.local/share/epiphany', '~/.var/app/org.gnome.Epiphany/data/epiphany'] },
+        profileGlob: '(Default)',
+        historyFile: 'ephy-history.db',
+        bookmarksFile: 'bookmarks.gvdb',
+    },
+};
+export function listBrowserKinds() {
+    return Object.keys(BROWSER_PATHS);
+}
+export function getBrowserPathEntry(kind) {
+    return BROWSER_PATHS[kind];
+}
+export function expandBrowserRoots(kind, homeOverride) {
+    const platform = process.platform === 'darwin' ? 'darwin' : 'linux';
+    const home = homeOverride ?? homedir();
+    return (BROWSER_PATHS[kind].paths[platform] ?? []).map((entry) => normalize(entry.replace(/^~/, home)));
+}
+export function profileGlobToRegex(kind) {
+    return new RegExp(`^(?:${BROWSER_PATHS[kind].profileGlob})$`);
+}

package/dist/_internal/platform/knowledge/browser-history/readers.d.ts

@@ -0,0 +1,8 @@
+import type { BrowserKnowledgeEntry, BrowserKnowledgeProfile } from './types.js';
+export interface BrowserKnowledgeReadOptions {
+    readonly limit?: number;
+    readonly sinceMs?: number;
+    readonly sourceKinds?: readonly ('history' | 'bookmark')[];
+}
+export declare function readBrowserKnowledgeProfile(profile: BrowserKnowledgeProfile, options?: BrowserKnowledgeReadOptions): Promise<BrowserKnowledgeEntry[]>;
+//# sourceMappingURL=readers.d.ts.map

package/dist/_internal/platform/knowledge/browser-history/readers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readers.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/knowledge/browser-history/readers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAGV,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAMpB,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,CAAC,SAAS,GAAG,UAAU,CAAC,EAAE,CAAC;CAC5D;AA8YD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,uBAAuB,EAChC,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAclC"}