@oscharko-dev/keiko-local-knowledge 0.2.0

package/dist/parsers/pdf-parser.d.ts

@@ -0,0 +1,43 @@
+import type { PageRecord, ParsedUnit, ParserDiagnostic } from "@oscharko-dev/keiko-contracts";
+import type { AsyncParserAdapter, ParserOptions, ParserSelectionInput } from "./types.js";
+export interface PdfTextItem {
+    readonly str?: string;
+}
+export interface PdfTextContentChunk {
+    readonly items: readonly PdfTextItem[];
+}
+export interface PdfPageLike {
+    readonly streamTextContent: () => ReadableStream<PdfTextContentChunk>;
+}
+export interface PdfDocumentLike {
+    readonly numPages: number;
+    readonly getPage: (pageNumber: number) => Promise<PdfPageLike>;
+}
+export interface PdfDocumentSource {
+    readonly totalBytes: number;
+    readonly loadFullBuffer?: () => Promise<Uint8Array>;
+    readonly readWindow?: (startByte: number, length: number) => Promise<Uint8Array>;
+}
+export declare function loadPdfDocument(bytes: Uint8Array): Promise<PdfDocumentLike>;
+export declare function loadPdfDocumentFromSource(source: PdfDocumentSource): Promise<PdfDocumentLike>;
+export interface PageTextReadState {
+    readonly input: ParserSelectionInput;
+    readonly options: ParserOptions;
+    readonly startedAt: number;
+    readonly emittedUnits: number;
+    readonly scannedObjects: number;
+}
+export interface PageTextReadResult {
+    readonly text: string;
+    readonly scannedObjects: number;
+    readonly diagnostic?: ParserDiagnostic;
+}
+export declare function readPageText(page: PdfPageLike, state: PageTextReadState): Promise<PageTextReadResult>;
+export declare function extractPages(doc: PdfDocumentLike, input: ParserSelectionInput, options: ParserOptions, startedAt: number): Promise<{
+    readonly diagnostics: readonly ParserDiagnostic[];
+    readonly pages: readonly PageRecord[];
+    readonly units: readonly ParsedUnit[];
+    readonly pageTexts: readonly string[];
+}>;
+export declare const pdfParser: AsyncParserAdapter;
+//# sourceMappingURL=pdf-parser.d.ts.map

package/dist/parsers/pdf-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-parser.d.ts","sourceRoot":"","sources":["../../src/parsers/pdf-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,gBAAgB,EAEjB,MAAM,+BAA+B,CAAC;AAUvC,OAAO,KAAK,EACV,kBAAkB,EAIlB,aAAa,EACb,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAUpB,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,cAAc,CAAC,mBAAmB,CAAC,CAAC;CACvE;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CAChE;AAMD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;IACpD,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CAClF;AAmND,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,CAWjF;AAyBD,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,eAAe,CAAC,CAqB1B;AA4BD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAC;CACxC;AA0CD,wBAAsB,YAAY,CAChC,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,kBAAkB,CAAC,CAgC7B;AAkDD,wBAAsB,YAAY,CAChC,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,oBAAoB,EAC3B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IACT,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC,CAAC,CAsCD;AA8DD,eAAO,MAAM,SAAS,EAAE,kBAKtB,CAAC"}

package/dist/parsers/pdf-parser.js

@@ -0,0 +1,388 @@
+import { diagnostic, emptyResult, objectLimitDiagnostic, oversizeDiagnostic, parserIdentity, shouldStop, } from "./_internal.js";
+const PARSER_ID = "pdf";
+const PARSER_VERSION = "1";
+const DEPENDENCY_VERSIONS = Object.freeze([
+    Object.freeze({ packageName: "pdfjs-dist", version: "6.0.227" }),
+    Object.freeze({ packageName: "@napi-rs/canvas", version: "1.0.0" }),
+]);
+const PDF_MAGIC = [0x25, 0x50, 0x44, 0x46];
+function pdfMatrixValue(init, index, fallback) {
+    return init?.length === 6 ? (init[index] ?? fallback) : fallback;
+}
+class PdfTextDomMatrix {
+    a;
+    b;
+    c;
+    d;
+    e;
+    f;
+    is2D = true;
+    isIdentity;
+    m11;
+    m12 = 0;
+    m13 = 0;
+    m14 = 0;
+    m21 = 0;
+    m22;
+    m23 = 0;
+    m24 = 0;
+    m31 = 0;
+    m32 = 0;
+    m33 = 1;
+    m34 = 0;
+    m41;
+    m42;
+    m43 = 0;
+    m44 = 1;
+    constructor(init) {
+        this.a = pdfMatrixValue(init, 0, 1);
+        this.b = pdfMatrixValue(init, 1, 0);
+        this.c = pdfMatrixValue(init, 2, 0);
+        this.d = pdfMatrixValue(init, 3, 1);
+        this.e = pdfMatrixValue(init, 4, 0);
+        this.f = pdfMatrixValue(init, 5, 0);
+        this.m11 = this.a;
+        this.m22 = this.d;
+        this.m41 = this.e;
+        this.m42 = this.f;
+        this.isIdentity =
+            this.a === 1 && this.b === 0 && this.c === 0 && this.d === 1 && this.e === 0 && this.f === 0;
+    }
+    multiplySelf() {
+        return this;
+    }
+    preMultiplySelf() {
+        return this;
+    }
+    translateSelf() {
+        return this;
+    }
+    scaleSelf() {
+        return this;
+    }
+    rotateSelf() {
+        return this;
+    }
+    invertSelf() {
+        return this;
+    }
+    transformPoint(point = {}) {
+        return { x: point.x ?? 0, y: point.y ?? 0 };
+    }
+    toFloat32Array() {
+        return new Float32Array([
+            this.a,
+            this.b,
+            0,
+            0,
+            this.c,
+            this.d,
+            0,
+            0,
+            0,
+            0,
+            1,
+            0,
+            this.e,
+            this.f,
+            0,
+            1,
+        ]);
+    }
+    toFloat64Array() {
+        return new Float64Array(this.toFloat32Array());
+    }
+}
+class PdfTextImageData {
+    data;
+    width;
+    height;
+    constructor(dataOrWidth, width, height) {
+        if (dataOrWidth instanceof Uint8ClampedArray) {
+            this.data = dataOrWidth;
+            this.width = width ?? 0;
+            this.height = height ?? 0;
+            return;
+        }
+        this.width = dataOrWidth;
+        this.height = width ?? 0;
+        this.data = new Uint8ClampedArray(this.width * this.height * 4);
+    }
+}
+function installPdfTextExtractionDomPolyfills() {
+    const target = globalThis;
+    target.DOMMatrix ??= PdfTextDomMatrix;
+    target.ImageData ??= PdfTextImageData;
+    target.Path2D ??= function PdfTextPath2D() {
+        return undefined;
+    };
+}
+function hasPdfMagic(bytes) {
+    if (bytes.length < PDF_MAGIC.length)
+        return false;
+    for (let i = 0; i < PDF_MAGIC.length; i += 1) {
+        if (bytes[i] !== PDF_MAGIC[i])
+            return false;
+    }
+    return true;
+}
+function isPdf(input) {
+    return (input.extension.toLowerCase() === "pdf" ||
+        input.mediaType.toLowerCase() === "application/pdf" ||
+        hasPdfMagic(input.bytes));
+}
+function cancelled(capability, input, options) {
+    return emptyResult(capability, input.documentId, options, [
+        diagnostic("PARSER_CANCELLED", "caller aborted parser", input.documentId, "info"),
+    ]);
+}
+function isAborted(signal) {
+    return signal?.aborted === true;
+}
+function syncFallback(capability) {
+    return (input, options) => {
+        return emptyResult(capability, input.documentId, options, [
+            diagnostic("UNSUPPORTED_FORMAT", "pdf parser requires async caller; use parseAsync via discovery", input.documentId, "info"),
+        ], [unsupportedMediaUnit(input.documentId, "pdf-async-required")]);
+    };
+}
+export async function loadPdfDocument(bytes) {
+    // pdfjs-dist imports browser geometry constructors even for text-layer extraction.
+    // Keiko does not render PDFs here, so minimal no-op constructors are sufficient.
+    installPdfTextExtractionDomPolyfills();
+    const pdfjs = (await import("pdfjs-dist/legacy/build/pdf.mjs"));
+    const task = pdfjs.getDocument({
+        data: bytes,
+        useWorkerFetch: false,
+        verbosity: 0,
+    });
+    return task.promise;
+}
+const PDF_RANGE_CHUNK_BYTES = 256 * 1024;
+function createRangeTransport(Transport, source) {
+    class WorkspacePdfRangeTransport extends Transport {
+        requestDataRange(begin, end) {
+            const start = Math.max(0, Math.floor(begin));
+            const length = Math.max(0, Math.floor(end) - start);
+            void source
+                .readWindow(start, length)
+                .then((chunk) => {
+                this.onDataRange(start, chunk);
+            })
+                .catch(() => {
+                this.onDataRange(start, new Uint8Array(0));
+            });
+        }
+    }
+    return new WorkspacePdfRangeTransport(source.totalBytes, new Uint8Array(0), false);
+}
+export async function loadPdfDocumentFromSource(source) {
+    if (source.loadFullBuffer !== undefined) {
+        return loadPdfDocument(await source.loadFullBuffer());
+    }
+    if (source.readWindow === undefined) {
+        throw new Error("pdf source does not support range reads");
+    }
+    installPdfTextExtractionDomPolyfills();
+    const pdfjs = (await import("pdfjs-dist/legacy/build/pdf.mjs"));
+    const task = pdfjs.getDocument({
+        range: createRangeTransport(pdfjs.PDFDataRangeTransport, {
+            totalBytes: source.totalBytes,
+            readWindow: source.readWindow,
+        }),
+        rangeChunkSize: PDF_RANGE_CHUNK_BYTES,
+        disableAutoFetch: true,
+        disableStream: true,
+        useWorkerFetch: false,
+        verbosity: 0,
+    });
+    return task.promise;
+}
+function unsupportedMediaUnit(documentId, reason) {
+    return { kind: "unsupported-media", documentId, reason };
+}
+function pageUnit(page) {
+    return page.pageLabel === undefined
+        ? {
+            kind: "page",
+            documentId: page.documentId,
+            pageNumber: page.pageNumber,
+            characterStart: page.characterStart,
+            characterEnd: page.characterEnd,
+        }
+        : {
+            kind: "page",
+            documentId: page.documentId,
+            pageNumber: page.pageNumber,
+            pageLabel: page.pageLabel,
+            characterStart: page.characterStart,
+            characterEnd: page.characterEnd,
+        };
+}
+function limitDiagnostic(input, limit) {
+    if (!limit.stop || limit.code === undefined || limit.message === undefined) {
+        return undefined;
+    }
+    return diagnostic(limit.code, limit.message, input.documentId, "info");
+}
+function pageTextStopDiagnostic(state) {
+    if (state.scannedObjects >= state.options.maxObjectsPerDocument) {
+        return objectLimitDiagnostic(state.input.documentId, state.options.maxObjectsPerDocument);
+    }
+    return limitDiagnostic(state.input, shouldStop(state.startedAt, state.options, state.emittedUnits));
+}
+function appendPdfTextItems(tokens, items, state) {
+    let next = state;
+    for (const item of items) {
+        const stopped = pageTextStopDiagnostic(next);
+        if (stopped !== undefined) {
+            return { state: next, diagnostic: stopped };
+        }
+        next = { ...next, scannedObjects: next.scannedObjects + 1 };
+        const value = item.str?.trim();
+        if (value !== undefined && value.length > 0) {
+            tokens.push(value);
+        }
+    }
+    return { state: next };
+}
+export async function readPageText(page, state) {
+    const reader = page.streamTextContent().getReader();
+    const tokens = [];
+    let next = state;
+    try {
+        for (;;) {
+            const stopped = pageTextStopDiagnostic(next);
+            if (stopped !== undefined) {
+                return {
+                    text: tokens.join(" ").trim(),
+                    scannedObjects: next.scannedObjects,
+                    diagnostic: stopped,
+                };
+            }
+            const read = await reader.read();
+            if (read.done) {
+                return { text: tokens.join(" ").trim(), scannedObjects: next.scannedObjects };
+            }
+            const chunk = read.value;
+            const appended = appendPdfTextItems(tokens, chunk.items, next);
+            next = appended.state;
+            if (appended.diagnostic !== undefined) {
+                return {
+                    text: tokens.join(" ").trim(),
+                    scannedObjects: next.scannedObjects,
+                    diagnostic: appended.diagnostic,
+                };
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function appendPageRecord(pages, units, input, pageNumber, text, cursor) {
+    const pageStart = cursor;
+    const pageEnd = cursor + text.length;
+    const pageLabel = String(pageNumber);
+    const pageRecord = {
+        documentId: input.documentId,
+        pageNumber,
+        pageLabel,
+        characterStart: pageStart,
+        characterEnd: pageEnd,
+    };
+    pages.push(pageRecord);
+    units.push(pageUnit(pageRecord));
+    return pageEnd + 2;
+}
+function noTextResult(capability, input, options, diagnostics = []) {
+    if (diagnostics.length > 0) {
+        return emptyResult(capability, input.documentId, options, diagnostics);
+    }
+    return emptyResult(capability, input.documentId, options, [
+        diagnostic("UNSUPPORTED_FORMAT", "pdf has no extractable text layer", input.documentId, "info"),
+    ], [unsupportedMediaUnit(input.documentId, "pdf-no-text-layer")]);
+}
+export async function extractPages(doc, input, options, startedAt) {
+    const diagnostics = [];
+    const pages = [];
+    const units = [];
+    const pageTexts = [];
+    let cursor = 0;
+    let scannedObjects = 0;
+    for (let pageNumber = 1; pageNumber <= doc.numPages; pageNumber += 1) {
+        const limit = shouldStop(startedAt, options, units.length);
+        if (limit.stop) {
+            if (limit.code !== undefined && limit.message !== undefined) {
+                diagnostics.push(diagnostic(limit.code, limit.message, input.documentId, "info"));
+            }
+            break;
+        }
+        const page = await doc.getPage(pageNumber);
+        const textResult = await readPageText(page, {
+            input,
+            options,
+            startedAt,
+            emittedUnits: units.length,
+            scannedObjects,
+        });
+        scannedObjects = textResult.scannedObjects;
+        if (textResult.diagnostic !== undefined) {
+            diagnostics.push(textResult.diagnostic);
+            break;
+        }
+        if (textResult.text.length === 0) {
+            continue;
+        }
+        pageTexts.push(textResult.text);
+        cursor = appendPageRecord(pages, units, input, pageNumber, textResult.text, cursor);
+    }
+    return { diagnostics, pages, units, pageTexts };
+}
+async function asyncParse(capability, input, options) {
+    if (input.bytes.byteLength > options.maxBytes) {
+        return emptyResult(capability, input.documentId, options, [
+            oversizeDiagnostic(input.documentId, input.bytes.byteLength, options.maxBytes),
+        ]);
+    }
+    if (options.signal?.aborted === true) {
+        return cancelled(capability, input, options);
+    }
+    const startedAt = options.now();
+    try {
+        const doc = await loadPdfDocument(input.bytes);
+        const { diagnostics, pages, units, pageTexts } = await extractPages(doc, input, options, startedAt);
+        if (isAborted(options.signal)) {
+            return cancelled(capability, input, options);
+        }
+        if (pages.length === 0) {
+            return noTextResult(capability, input, options, diagnostics);
+        }
+        return {
+            documentId: input.documentId,
+            parser: parserIdentity(capability),
+            pages,
+            sections: [],
+            units,
+            diagnostics,
+            extractedAt: options.now(),
+            normalizedText: pageTexts.join("\n\n"),
+        };
+    }
+    catch {
+        return emptyResult(capability, input.documentId, options, [
+            diagnostic("MALFORMED_INPUT", "pdf parser rejected malformed or unsupported document", input.documentId, "error"),
+        ]);
+    }
+}
+const capability = Object.freeze({
+    parserId: PARSER_ID,
+    parserVersion: PARSER_VERSION,
+    dependencyVersions: DEPENDENCY_VERSIONS,
+    matches: isPdf,
+});
+export const pdfParser = Object.freeze({
+    capability,
+    parse: syncFallback(capability),
+    parseAsync: (input, options) => asyncParse(capability, input, options),
+});

package/dist/parsers/registry.d.ts

@@ -0,0 +1,8 @@
+import { unsupportedParser } from "./unsupported-parser.js";
+import { type ParserAdapter, type ParserOptions, type ParserRegistry, type ParserResolution, type ParserSelectionInput } from "./types.js";
+export declare function createParserRegistry(): ParserRegistry;
+export declare function registerParser(registry: ParserRegistry, adapter: ParserAdapter): ParserRegistry;
+export declare function resolveParser(registry: ParserRegistry, input: ParserSelectionInput): ParserResolution;
+export declare function buildParserOptions(overrides?: Partial<ParserOptions>): ParserOptions;
+export { unsupportedParser };
+//# sourceMappingURL=registry.d.ts.map

package/dist/parsers/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/parsers/registry.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAMpB,wBAAgB,oBAAoB,IAAI,cAAc,CAOrD;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,GAAG,cAAc,CAS/F;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,gBAAgB,CAElB;AAuBD,wBAAgB,kBAAkB,CAAC,SAAS,GAAE,OAAO,CAAC,aAAa,CAAM,GAAG,aAAa,CAUxF;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/parsers/registry.js

@@ -0,0 +1,57 @@
+// Parser registry (Epic #189, Issue #266). A frozen-after-build map of `ParserAdapter`
+// values. `resolveParser` returns the first registered adapter whose capability matches the
+// input, OR the unsupported sentinel. The registry is intentionally tiny — selection logic
+// lives inside the adapters' `matches` predicates so a new format can land by adding one
+// file plus one register call.
+import { unsupportedParser } from "./unsupported-parser.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_NESTING_DEPTH, DEFAULT_MAX_OBJECTS, DEFAULT_MAX_UNITS, DEFAULT_TIMEOUT_MS, } from "./types.js";
+export function createParserRegistry() {
+    const state = { adapters: [] };
+    return Object.freeze({
+        list: () => Object.freeze([...state.adapters]),
+        resolve: (input) => resolveFromList(state.adapters, input),
+    });
+}
+export function registerParser(registry, adapter) {
+    // We re-emit a brand-new frozen registry rather than mutate. This keeps the registry
+    // value-typed and lets composition layers (#196 indexer) treat it as an immutable
+    // configuration object.
+    const next = [...registry.list(), adapter];
+    return Object.freeze({
+        list: () => Object.freeze([...next]),
+        resolve: (input) => resolveFromList(next, input),
+    });
+}
+export function resolveParser(registry, input) {
+    return registry.resolve(input);
+}
+function resolveFromList(adapters, input) {
+    for (const adapter of adapters) {
+        if (adapter === unsupportedParser)
+            continue;
+        if (adapter.capability.matches(input)) {
+            return { kind: "matched", adapter };
+        }
+    }
+    // Fall through to unsupported. The unsupported adapter's `matches` is a stable predicate
+    // — it returns true for any known-unsupported signal AND for arbitrary unknown formats
+    // (returns true via the magic-byte / extension table OR is explicitly invoked).
+    if (unsupportedParser.capability.matches(input)) {
+        return { kind: "matched", adapter: unsupportedParser };
+    }
+    return { kind: "unsupported", reason: "no-adapter-matched" };
+}
+// Convenience: build a `ParserOptions` value with defaults applied. Callers supply only the
+// fields they want to override.
+export function buildParserOptions(overrides = {}) {
+    const base = {
+        maxBytes: overrides.maxBytes ?? DEFAULT_MAX_BYTES,
+        maxUnitsPerDocument: overrides.maxUnitsPerDocument ?? DEFAULT_MAX_UNITS,
+        maxNestingDepth: overrides.maxNestingDepth ?? DEFAULT_MAX_NESTING_DEPTH,
+        maxObjectsPerDocument: overrides.maxObjectsPerDocument ?? DEFAULT_MAX_OBJECTS,
+        timeoutMs: overrides.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        now: overrides.now ?? (() => Date.now()),
+    };
+    return overrides.signal !== undefined ? { ...base, signal: overrides.signal } : base;
+}
+export { unsupportedParser };

package/dist/parsers/text-parser.d.ts

@@ -0,0 +1,3 @@
+import type { ParserAdapter } from "./types.js";
+export declare const textParser: ParserAdapter;
+//# sourceMappingURL=text-parser.d.ts.map

package/dist/parsers/text-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-parser.d.ts","sourceRoot":"","sources":["../../src/parsers/text-parser.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,aAAa,EAAuC,MAAM,YAAY,CAAC;AAgOrF,eAAO,MAAM,UAAU,EAAE,aAyBvB,CAAC"}