@anvia/core 0.26.0 → 1.0.0-rc.10

package/dist/index-BxSbmOMr.d.ts

@@ -1,257 +0,0 @@
-import { Y as ReasoningContentType, p as ToolCall, h as CompletionSource, o as ProviderToolCall, U as Usage, j as ContextUsage, M as Message, f as CompletionRequest, u as ToolResultContent, g as CompletionResponse, _ as ToolCallArgumentsMode, J as JsonObject, O as CompletionModelCapabilities, r as ToolDefinition, l as JsonValue } from './types-G12i56s2.js';
-import { GuardrailDecisionRecord } from './guardrails/index.js';
-import { g as ToolCallStreamEvent } from './tool-Cohdv5GC.js';
-
-type PromptResponse = {
-    output: string;
-    usage: Usage;
-    contextUsage?: ContextUsage | undefined;
-    messages: Message[];
-    trace?: AgentTraceInfo | undefined;
-    guardrails?: GuardrailDecisionRecord[] | undefined;
-    sources?: CompletionSource[] | undefined;
-    providerToolCalls?: ProviderToolCall[] | undefined;
-};
-type AgentDeltaEvent = {
-    type: "text_delta";
-    delta: string;
-} | {
-    type: "reasoning_delta";
-    delta: string;
-    id?: string;
-    contentType?: ReasoningContentType;
-    signature?: string;
-} | {
-    type: "tool_call";
-    toolCall: ToolCall;
-} | {
-    type: "source";
-    source: CompletionSource;
-} | {
-    type: "provider_tool_call";
-    toolCall: ProviderToolCall;
-};
-type AgentErrorStreamEvent = {
-    type: "error";
-    error: unknown;
-    usage: Usage;
-};
-type AgentStreamOptions = {
-    /** @default true */
-    includeToolCallDeltas?: boolean;
-};
-type AgentToolCallDeltaEvent = {
-    type: "tool_call_delta";
-    turn: number;
-    id: string;
-    callId?: string;
-    name?: string;
-    argumentsDelta?: string;
-    argumentsMode?: ToolCallArgumentsMode;
-    signature?: string;
-};
-type AgentChildStreamEventBase<RawResponse = unknown> = {
-    type: "turn_start";
-    turn: number;
-    prompt: Message;
-    history: Message[];
-} | {
-    type: "generation_start";
-    turn: number;
-    request: CompletionRequest;
-    modelInfo: AgentGenerationModelInfo;
-} | {
-    type: "text_delta";
-    turn: number;
-    delta: string;
-} | {
-    type: "reasoning_delta";
-    turn: number;
-    delta: string;
-    id?: string;
-    contentType?: ReasoningContentType;
-    signature?: string;
-} | {
-    type: "tool_call";
-    turn: number;
-    toolCall: ToolCall;
-} | {
-    type: "source";
-    turn: number;
-    source: CompletionSource;
-} | {
-    type: "provider_tool_call";
-    turn: number;
-    toolCall: ProviderToolCall;
-} | {
-    type: "tool_result";
-    turn: number;
-    toolName: string;
-    toolCallId?: string;
-    internalCallId: string;
-    args: string;
-    result: string;
-    structuredResult?: ToolResultContent[] | undefined;
-} | {
-    type: "turn_end";
-    turn: number;
-    response: CompletionResponse<RawResponse>;
-    firstDeltaMs?: number | undefined;
-} | {
-    type: "guardrail_decision";
-    turn?: number | undefined;
-    decision: GuardrailDecisionRecord;
-} | {
-    type: "final";
-    runId: string;
-    output: string;
-    usage: Usage;
-    contextUsage?: ContextUsage | undefined;
-    messages: Message[];
-    trace?: AgentTraceInfo | undefined;
-    guardrails?: GuardrailDecisionRecord[] | undefined;
-    sources?: CompletionSource[] | undefined;
-    providerToolCalls?: ProviderToolCall[] | undefined;
-} | AgentErrorStreamEvent;
-type AgentChildStreamEventWithoutToolCallDeltas<RawResponse = unknown> = AgentChildStreamEventBase<RawResponse>;
-type AgentChildStreamEvent<RawResponse = unknown> = AgentChildStreamEventBase<RawResponse> | AgentToolCallDeltaEvent;
-type AgentChildStreamEventWithToolCallDeltas<RawResponse = unknown> = AgentChildStreamEvent<RawResponse>;
-type AgentToolStreamEvent<ChildEvent> = {
-    type: "agent_tool_event";
-    turn: number;
-    toolName: string;
-    toolCallId?: string;
-    internalCallId: string;
-    agentId: string;
-    agentName?: string;
-    event: ChildEvent;
-};
-type AgentStreamEventWithoutToolCallDeltas<RawResponse = unknown> = AgentChildStreamEventWithoutToolCallDeltas<RawResponse> | AgentToolStreamEvent<AgentChildStreamEventWithoutToolCallDeltas<RawResponse>>;
-type AgentStreamEvent<RawResponse = unknown> = AgentChildStreamEvent<RawResponse> | AgentToolStreamEvent<AgentChildStreamEvent<RawResponse>>;
-type AgentStreamEventWithToolCallDeltas<RawResponse = unknown> = AgentStreamEvent<RawResponse>;
-
-type AgentTraceInfo = {
-    traceId?: string | undefined;
-    observationId?: string | undefined;
-};
-type AgentTraceOptions = {
-    name?: string | undefined;
-    userId?: string | undefined;
-    sessionId?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
-    tags?: string[] | undefined;
-    version?: string | undefined;
-    traceId?: string | undefined;
-    failOnObserverError?: boolean | undefined;
-    promptRef?: AgentRunPromptRef | undefined;
-};
-type AgentRunPromptRef = {
-    name: string;
-    version?: number | undefined;
-};
-type AgentRunStartArgs = {
-    agentName?: string | undefined;
-    agentDescription?: string | undefined;
-    instructions?: string | undefined;
-    trace?: AgentTraceOptions | undefined;
-    prompt: Message;
-    promptRef?: AgentRunPromptRef | undefined;
-    history: Message[];
-    maxTurns: number;
-};
-type AgentRunEndArgs = {
-    output: string;
-    usage: Usage;
-    messages: Message[];
-    sources?: CompletionSource[] | undefined;
-    providerToolCalls?: ProviderToolCall[] | undefined;
-};
-type AgentRunErrorArgs = {
-    error: unknown;
-    usage: Usage;
-    messages: Message[];
-};
-type AgentGenerationModelInfo = {
-    provider: string;
-    defaultModel: string;
-    capabilities?: CompletionModelCapabilities | undefined;
-};
-type AgentGenerationStartArgs = {
-    turn: number;
-    request: CompletionRequest;
-    providerRequest?: JsonObject | undefined;
-    modelInfo?: AgentGenerationModelInfo | undefined;
-};
-type AgentGenerationEndArgs<RawResponse = unknown> = {
-    turn: number;
-    response: CompletionResponse<RawResponse>;
-    firstDeltaMs?: number | undefined;
-};
-type AgentGenerationErrorArgs = {
-    turn: number;
-    error: unknown;
-};
-type AgentGenerationUpdateArgs = {
-    turn: number;
-    delta: AgentDeltaEvent;
-};
-type AgentRunEventArgs = {
-    name: string;
-    attributes?: Record<string, JsonValue | undefined> | undefined;
-    level?: "DEFAULT" | "WARNING" | "ERROR" | undefined;
-    timestamp?: Date | string | undefined;
-};
-type AgentToolStartArgs = {
-    turn: number;
-    toolCall: ToolCall;
-    toolName: string;
-    args: string;
-    internalCallId: string;
-    toolCallId?: string | undefined;
-    toolDefinition?: ToolDefinition | undefined;
-    toolMetadata?: JsonObject | undefined;
-};
-type AgentToolEndArgs = AgentToolStartArgs & {
-    result: string;
-    structuredResult?: ToolResultContent[] | undefined;
-    skipped: boolean;
-};
-type AgentToolErrorArgs = AgentToolStartArgs & {
-    error: unknown;
-};
-type AgentToolStreamEventArgs = AgentToolStartArgs & {
-    event: ToolCallStreamEvent;
-};
-interface AgentGenerationObserver {
-    end(args: AgentGenerationEndArgs): void | Promise<void>;
-    error?(args: AgentGenerationErrorArgs): void | Promise<void>;
-    update?(args: AgentGenerationUpdateArgs): void | Promise<void>;
-}
-interface AgentToolObserver {
-    streamEvent?(args: AgentToolStreamEventArgs): void | Promise<void>;
-    end(args: AgentToolEndArgs): void | Promise<void>;
-    error?(args: AgentToolErrorArgs): void | Promise<void>;
-}
-interface AgentRunObserver {
-    readonly trace?: AgentTraceInfo | undefined;
-    startGeneration?(args: AgentGenerationStartArgs): AgentGenerationObserver | undefined | Promise<AgentGenerationObserver | undefined>;
-    startTool?(args: AgentToolStartArgs): AgentToolObserver | undefined | Promise<AgentToolObserver | undefined>;
-    end(args: AgentRunEndArgs): void | Promise<void>;
-    error?(args: AgentRunErrorArgs): void | Promise<void>;
-    event?(args: AgentRunEventArgs): void | Promise<void>;
-}
-interface AgentObserver {
-    startRun(args: AgentRunStartArgs): AgentRunObserver | undefined | Promise<AgentRunObserver | undefined>;
-    flush?(): void | Promise<void>;
-    shutdown?(): void | Promise<void>;
-}
-type AgentObserverRegistration = {
-    observer: AgentObserver;
-    failOnObserverError?: boolean | undefined;
-};
-type ObserveOptions = {
-    failOnObserverError?: boolean | undefined;
-};
-declare function createObserver(observer: AgentObserver): AgentObserver;
-
-export { type AgentChildStreamEvent as A, type AgentToolObserver as B, type AgentToolStartArgs as C, type AgentToolStreamEventArgs as D, type AgentTraceInfo as E, createObserver as F, type ObserveOptions as O, type PromptResponse as P, type AgentChildStreamEventWithToolCallDeltas as a, type AgentChildStreamEventWithoutToolCallDeltas as b, type AgentErrorStreamEvent as c, type AgentStreamEvent as d, type AgentStreamEventWithToolCallDeltas as e, type AgentStreamEventWithoutToolCallDeltas as f, type AgentStreamOptions as g, type AgentToolCallDeltaEvent as h, type AgentObserver as i, type AgentTraceOptions as j, type AgentObserverRegistration as k, type AgentDeltaEvent as l, type AgentGenerationEndArgs as m, type AgentGenerationErrorArgs as n, type AgentGenerationModelInfo as o, type AgentGenerationObserver as p, type AgentGenerationStartArgs as q, type AgentGenerationUpdateArgs as r, type AgentRunEndArgs as s, type AgentRunErrorArgs as t, type AgentRunEventArgs as u, type AgentRunObserver as v, type AgentRunPromptRef as w, type AgentRunStartArgs as x, type AgentToolEndArgs as y, type AgentToolErrorArgs as z };

package/dist/json-BVPssigK.d.ts

@@ -1,39 +0,0 @@
-import { Z as ZodSchema } from './zod-schema-C7F4clpm.js';
-import { M as Message, D as Document, i as CompletionTool, L as ToolChoice, J as JsonObject, l as JsonValue, A as AssistantContent, U as Usage, g as CompletionResponse, C as CompletionModel, Z as StreamingCompletionModel, Q as CompletionStreamEvent } from './types-G12i56s2.js';
-
-type CreateCompletionInput = string | Message | Message[];
-type CreateCompletionBaseOptions = {
-    input?: CreateCompletionInput | undefined;
-    messages?: Message[] | undefined;
-    instructions?: string | undefined;
-    documents?: Document[] | undefined;
-    tools?: CompletionTool[] | undefined;
-    temperature?: number | undefined;
-    maxTokens?: number | undefined;
-    toolChoice?: ToolChoice | undefined;
-    outputSchema?: JsonObject | undefined;
-    params?: JsonValue | undefined;
-};
-type CreateCompletionOptions = CreateCompletionBaseOptions;
-type CreateCompletionStreamOptions = CreateCompletionBaseOptions;
-type CreateParsedCompletionOptions<T> = Omit<CreateCompletionBaseOptions, "outputSchema"> & {
-    schema: ZodSchema<T>;
-};
-type CreateCompletionResult<RawResponse = unknown> = {
-    text: string;
-    content: AssistantContent[];
-    usage: Usage;
-    response: CompletionResponse<RawResponse>;
-};
-type CreateParsedCompletionResult<T, RawResponse = unknown> = CreateCompletionResult<RawResponse> & {
-    data: T;
-};
-type RawResponseOf<Model> = Model extends CompletionModel<infer RawResponse, infer _ModelName> ? RawResponse : unknown;
-declare function createCompletion<Model extends CompletionModel>(model: Model, options: CreateCompletionOptions): Promise<CreateCompletionResult<RawResponseOf<Model>>>;
-declare function createCompletionStream<Model extends StreamingCompletionModel>(model: Model, options: CreateCompletionStreamOptions): AsyncIterable<CompletionStreamEvent<RawResponseOf<Model>>>;
-declare function createParsedCompletion<T, Model extends CompletionModel>(model: Model, options: CreateParsedCompletionOptions<T>): Promise<CreateParsedCompletionResult<T, RawResponseOf<Model>>>;
-declare function isStreamingCompletionModel(model: CompletionModel): model is StreamingCompletionModel;
-
-declare function isJsonValue(value: unknown): value is JsonValue;
-
-export { type CreateCompletionBaseOptions as C, type CreateCompletionInput as a, type CreateCompletionOptions as b, type CreateCompletionResult as c, type CreateCompletionStreamOptions as d, type CreateParsedCompletionOptions as e, type CreateParsedCompletionResult as f, createCompletion as g, createCompletionStream as h, createParsedCompletion as i, isJsonValue as j, isStreamingCompletionModel as k };

package/dist/loaders/index.d.ts

@@ -1,91 +0,0 @@
-import { D as Document } from '../types-G12i56s2.js';
-
-type LoaderResult<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    error: unknown;
-};
-type LoaderValue$1<T> = T extends {
-    ok: true;
-    value: infer Value;
-} ? Value : never;
-type UnwrapLoaderResult$1<T> = [LoaderValue$1<T>] extends [never] ? T : LoaderValue$1<T>;
-type FileSource = {
-    path: string;
-} | {
-    path: "<memory>";
-    bytes: Uint8Array;
-};
-type FileReadWithPath = {
-    path: string;
-    text: string;
-};
-type FileMode = "source" | "read" | "readWithPath";
-type PdfSource = {
-    path: string;
-} | {
-    path: "<memory>";
-    bytes: Uint8Array;
-};
-type PdfReadWithPath = {
-    path: string;
-    text: string;
-};
-type PdfPage = {
-    pageNumber: number;
-    text: string;
-};
-type PdfPageWithPath = {
-    path: string;
-    pageNumber: number;
-    text: string;
-};
-
-declare function fileToDocument(file: FileReadWithPath): Document;
-declare function fileLoaderToDocuments(loader: AsyncIterable<FileReadWithPath>): Promise<Document[]>;
-declare function pdfToDocument(pdf: PdfReadWithPath): Document;
-declare function pdfLoaderToDocuments(loader: AsyncIterable<PdfReadWithPath>): Promise<Document[]>;
-declare function pdfPageToDocument(page: PdfPageWithPath): Document;
-declare function pdfPageLoaderToDocuments(loader: AsyncIterable<PdfPageWithPath>): Promise<Document[]>;
-
-declare class FileLoader<T = LoaderResult<FileSource>> implements AsyncIterable<T> {
-    private readonly source;
-    private readonly mode;
-    private readonly skipErrors;
-    private constructor();
-    static withGlob(pattern: string): FileLoader<LoaderResult<FileSource>>;
-    static withDir(directory: string): FileLoader<LoaderResult<FileSource>>;
-    static fromBytes(bytes: Uint8Array | ArrayBuffer): FileLoader<LoaderResult<FileSource>>;
-    static fromBytesMany(bytes: Array<Uint8Array | ArrayBuffer>): FileLoader<LoaderResult<FileSource>>;
-    read(): FileLoader<LoaderResult<string>>;
-    readWithPath(): FileLoader<LoaderResult<FileReadWithPath>>;
-    ignoreErrors(): FileLoader<UnwrapLoaderResult$1<T>>;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}
-
-type LoaderValue<T> = T extends {
-    ok: true;
-    value: infer Value;
-} ? Value : never;
-type UnwrapLoaderResult<T> = [LoaderValue<T>] extends [never] ? T : LoaderValue<T>;
-declare class PdfFileLoader<T = LoaderResult<PdfSource>> implements AsyncIterable<T> {
-    private readonly source;
-    private readonly mode;
-    private readonly skipErrors;
-    private constructor();
-    static withGlob(pattern: string): PdfFileLoader<LoaderResult<PdfSource>>;
-    static withDir(directory: string): PdfFileLoader<LoaderResult<PdfSource>>;
-    static fromBytes(bytes: Uint8Array | ArrayBuffer): PdfFileLoader<LoaderResult<PdfSource>>;
-    static fromBytesMany(bytes: Array<Uint8Array | ArrayBuffer>): PdfFileLoader<LoaderResult<PdfSource>>;
-    read(): PdfFileLoader<LoaderResult<string>>;
-    readWithPath(): PdfFileLoader<LoaderResult<PdfReadWithPath>>;
-    byPage(this: PdfFileLoader<LoaderResult<PdfReadWithPath>>): PdfFileLoader<LoaderResult<PdfPageWithPath>>;
-    byPage(this: PdfFileLoader<PdfReadWithPath>): PdfFileLoader<PdfPageWithPath>;
-    byPage(): PdfFileLoader<LoaderResult<PdfPage>>;
-    ignoreErrors(): PdfFileLoader<UnwrapLoaderResult<T>>;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}
-
-export { FileLoader, type FileMode, type FileReadWithPath, type FileSource, type LoaderResult, type LoaderValue$1 as LoaderValue, PdfFileLoader, type PdfPage, type PdfPageWithPath, type PdfReadWithPath, type PdfSource, type UnwrapLoaderResult$1 as UnwrapLoaderResult, fileLoaderToDocuments, fileToDocument, pdfLoaderToDocuments, pdfPageLoaderToDocuments, pdfPageToDocument, pdfToDocument };

package/dist/loaders/index.js

@@ -1,299 +0,0 @@
-// src/loaders/documents.ts
-function fileToDocument(file) {
-  return {
-    id: file.path,
-    text: file.text,
-    additionalProps: {
-      source: file.path,
-      mediaType: "text/plain"
-    }
-  };
-}
-async function fileLoaderToDocuments(loader) {
-  const documents = [];
-  for await (const file of loader) {
-    documents.push(fileToDocument(file));
-  }
-  return documents;
-}
-function pdfToDocument(pdf) {
-  return {
-    id: pdf.path,
-    text: pdf.text,
-    additionalProps: {
-      source: pdf.path,
-      mediaType: "application/pdf"
-    }
-  };
-}
-async function pdfLoaderToDocuments(loader) {
-  const documents = [];
-  for await (const pdf of loader) {
-    documents.push(pdfToDocument(pdf));
-  }
-  return documents;
-}
-function pdfPageToDocument(page) {
-  return {
-    id: `${page.path}#page=${page.pageNumber}`,
-    text: page.text,
-    additionalProps: {
-      source: page.path,
-      mediaType: "application/pdf",
-      pageNumber: String(page.pageNumber)
-    }
-  };
-}
-async function pdfPageLoaderToDocuments(loader) {
-  const documents = [];
-  for await (const page of loader) {
-    documents.push(pdfPageToDocument(page));
-  }
-  return documents;
-}
-
-// src/loaders/file.ts
-import { readdir, readFile } from "fs/promises";
-import { join } from "path";
-
-// src/loaders/shared.ts
-import { isAbsolute } from "path";
-import { glob } from "tinyglobby";
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-async function sortedGlob(pattern) {
-  return (await glob(pattern, { absolute: isAbsolute(pattern), onlyFiles: true })).sort(
-    (left, right) => left.localeCompare(right)
-  );
-}
-function toUint8Array(bytes) {
-  if (bytes instanceof Uint8Array) {
-    return new Uint8Array(
-      bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
-    );
-  }
-  return new Uint8Array(bytes);
-}
-
-// src/loaders/file.ts
-var FileLoader = class _FileLoader {
-  constructor(source, mode, skipErrors) {
-    this.source = source;
-    this.mode = mode;
-    this.skipErrors = skipErrors;
-  }
-  source;
-  mode;
-  skipErrors;
-  static withGlob(pattern) {
-    return new _FileLoader(
-      async function* () {
-        for (const path of await sortedGlob(pattern)) {
-          yield ok({ path });
-        }
-      },
-      "source",
-      false
-    );
-  }
-  static withDir(directory) {
-    return new _FileLoader(
-      async function* () {
-        const entries = await readdir(directory, { withFileTypes: true });
-        const files = entries.filter((entry) => entry.isFile()).map((entry) => join(directory, entry.name)).sort((left, right) => left.localeCompare(right));
-        for (const path of files) {
-          yield ok({ path });
-        }
-      },
-      "source",
-      false
-    );
-  }
-  static fromBytes(bytes) {
-    return _FileLoader.fromBytesMany([bytes]);
-  }
-  static fromBytesMany(bytes) {
-    return new _FileLoader(
-      async function* () {
-        for (const value of bytes) {
-          yield ok({ path: "<memory>", bytes: toUint8Array(value) });
-        }
-      },
-      "source",
-      false
-    );
-  }
-  read() {
-    return new _FileLoader(this.source, "read", this.skipErrors);
-  }
-  readWithPath() {
-    return new _FileLoader(this.source, "readWithPath", this.skipErrors);
-  }
-  ignoreErrors() {
-    return new _FileLoader(this.source, this.mode, true);
-  }
-  async *[Symbol.asyncIterator]() {
-    for await (const item of this.source()) {
-      const result = await mapFileResult(item, this.mode);
-      if (!result.ok && this.skipErrors) {
-        continue;
-      }
-      yield this.skipErrors && result.ok ? result.value : result;
-    }
-  }
-};
-async function mapFileResult(item, mode) {
-  if (!item.ok) {
-    return item;
-  }
-  if (mode === "source") {
-    return item;
-  }
-  try {
-    const text = await readFileSource(item.value);
-    return mode === "read" ? ok(text) : ok({ path: item.value.path, text });
-  } catch (error) {
-    return err(error);
-  }
-}
-async function readFileSource(source) {
-  if ("bytes" in source) {
-    return new TextDecoder().decode(source.bytes);
-  }
-  return readFile(source.path, "utf8");
-}
-
-// src/loaders/pdf.ts
-import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
-var PdfFileLoader = class _PdfFileLoader {
-  constructor(source, mode, skipErrors) {
-    this.source = source;
-    this.mode = mode;
-    this.skipErrors = skipErrors;
-  }
-  source;
-  mode;
-  skipErrors;
-  static withGlob(pattern) {
-    return new _PdfFileLoader(
-      async function* () {
-        for (const path of await sortedGlob(pattern)) {
-          yield ok({ path });
-        }
-      },
-      "source",
-      false
-    );
-  }
-  static withDir(directory) {
-    return new _PdfFileLoader(
-      async function* () {
-        const entries = await readdir2(directory, { withFileTypes: true });
-        const files = entries.filter((entry) => entry.isFile()).map((entry) => join2(directory, entry.name)).sort((left, right) => left.localeCompare(right));
-        for (const path of files) {
-          yield ok({ path });
-        }
-      },
-      "source",
-      false
-    );
-  }
-  static fromBytes(bytes) {
-    return _PdfFileLoader.fromBytesMany([bytes]);
-  }
-  static fromBytesMany(bytes) {
-    return new _PdfFileLoader(
-      async function* () {
-        for (const value of bytes) {
-          yield ok({ path: "<memory>", bytes: toUint8Array(value) });
-        }
-      },
-      "source",
-      false
-    );
-  }
-  read() {
-    return new _PdfFileLoader(this.source, "read", this.skipErrors);
-  }
-  readWithPath() {
-    return new _PdfFileLoader(this.source, "readWithPath", this.skipErrors);
-  }
-  byPage() {
-    const mode = this.mode === "readWithPath" ? "byPageWithPath" : "byPage";
-    return new _PdfFileLoader(this.source, mode, this.skipErrors);
-  }
-  ignoreErrors() {
-    return new _PdfFileLoader(this.source, this.mode, true);
-  }
-  async *[Symbol.asyncIterator]() {
-    for await (const item of this.source()) {
-      const results = await mapPdfResult(item, this.mode);
-      for (const result of results) {
-        if (!result.ok && this.skipErrors) {
-          continue;
-        }
-        yield this.skipErrors && result.ok ? result.value : result;
-      }
-    }
-  }
-};
-async function mapPdfResult(item, mode) {
-  if (!item.ok) {
-    return [item];
-  }
-  if (mode === "source") {
-    return [item];
-  }
-  try {
-    const pages = await readPdfPages(item.value);
-    if (mode === "read") {
-      return [ok(pages.map((page) => page.text).join(""))];
-    }
-    if (mode === "readWithPath") {
-      return [ok({ path: item.value.path, text: pages.map((page) => page.text).join("") })];
-    }
-    if (mode === "byPageWithPath") {
-      return pages.map((page) => ok({ path: item.value.path, ...page }));
-    }
-    return pages.map(ok);
-  } catch (error) {
-    return [err(error)];
-  }
-}
-async function readPdfPages(source) {
-  const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
-  const bytes = "bytes" in source ? source.bytes : toUint8Array(await readFile2(source.path));
-  const loadingTask = pdfjs.getDocument({ data: bytes });
-  const document = await loadingTask.promise;
-  const pages = [];
-  try {
-    for (let index = 1; index <= document.numPages; index += 1) {
-      const page = await document.getPage(index);
-      const content = await page.getTextContent();
-      const text = content.items.flatMap(
-        (item) => typeof item === "object" && item !== null && "str" in item ? [String(item.str)] : []
-      ).join("\n");
-      pages.push({ pageNumber: index - 1, text: text.length > 0 ? `${text}
-` : "" });
-    }
-  } finally {
-    await loadingTask.destroy();
-  }
-  return pages;
-}
-export {
-  FileLoader,
-  PdfFileLoader,
-  fileLoaderToDocuments,
-  fileToDocument,
-  pdfLoaderToDocuments,
-  pdfPageLoaderToDocuments,
-  pdfPageToDocument,
-  pdfToDocument
-};
-//# sourceMappingURL=index.js.map