@yuji-min/google-docs-parser 1.0.3 → 1.2.0

package/README.md

@@ -36,16 +36,33 @@ This library solves that complexity by allowing you to define a **Schema** that
 
 ## 📦 Installation
 
+### Node.js / Traditional Environments
+
 ```bash
 npm install @yuji-min/google-docs-parser googleapis google-auth-library
 # or
 yarn add @yuji-min/google-docs-parser googleapis google-auth-library
 ```
 
+### Edge Runtime (Cloudflare Workers, Vercel Edge, etc.)
+
+```bash
+npm install @yuji-min/google-docs-parser
+# or
+yarn add @yuji-min/google-docs-parser
+```
+
+> **Note:** The Edge Runtime version (`/edge`) does **not** require `googleapis` or `google-auth-library` dependencies. It uses native Web APIs (Fetch, Web Crypto) instead.
+
 ---
 
 ## 🔑 Authentication & Setup
 
+This library supports two runtime environments with different authentication approaches:
+
+- **Node.js**: Uses `googleapis` and `google-auth-library` (traditional approach)
+- **Edge Runtime**: Uses native Web APIs with JSON credentials (Cloudflare Workers, Vercel Edge, etc.)
+
 To use this library, you need a Google Cloud Service Account with access to the Google Docs API.
 
 ### 1. Create Google Cloud Credentials
@@ -58,6 +75,8 @@ To use this library, you need a Google Cloud Service Account with access to the
 
 ### 2. Configure Environment Variable
 
+#### Node.js (File Path)
+
 Set the `GOOGLE_APPLICATION_CREDENTIALS` environment variable to the path of your downloaded JSON key file.
 
 **Mac/Linux:**
@@ -74,6 +93,34 @@ $env:GOOGLE_APPLICATION_CREDENTIALS="C:\path\to\your\service-account-key.json"
 
 > **Note:** The library uses `google-auth-library` internally, which automatically looks for credentials at the path defined in this environment variable.
 
+#### Edge Runtime (JSON String)
+
+For Edge Runtime environments, set `GOOGLE_APPLICATION_CREDENTIALS` to the **JSON string** (not a file path):
+
+**Cloudflare Workers (wrangler.toml):**
+
+```toml
+[vars]
+GOOGLE_APPLICATION_CREDENTIALS = '''
+{
+  "type": "service_account",
+  "project_id": "your-project-id",
+  "private_key_id": "key-id",
+  "private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n",
+  "client_email": "your-service-account@project.iam.gserviceaccount.com",
+  "client_id": "123456789",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/..."
+}
+'''
+```
+
+**Vercel Edge Functions:**
+
+Add the JSON as an environment variable in your Vercel project settings, or use `.env.local` during development.
+
 ### 3. Share the Document (Important!)
 
 Google Docs are private by default. You must share the target document with your Service Account's email address (found in your JSON key, e.g., my-bot@my-project.iam.gserviceaccount.com) with Viewer permission.
@@ -191,6 +238,99 @@ Tree nodes always have a consistent `{ title, content }` structure:
 
 ---
 
+## ☁️ Edge Runtime Usage
+
+The `/edge` export is specifically designed for Edge Runtime environments like Cloudflare Workers and Vercel Edge Functions.
+
+### Cloudflare Workers Example
+
+```typescript
+import { getParsedDocument } from "@yuji-min/google-docs-parser/edge";
+import type { ParseSchema } from "@yuji-min/google-docs-parser/edge";
+
+const schema = {
+  sections: [
+    { title: { name: "Profile", namedStyleType: "HEADING_1" } },
+    {
+      title: { name: "Experience", namedStyleType: "HEADING_1" },
+      content: {
+        kind: "tree",
+        node: {
+          title: {
+            namedStyleType: "HEADING_2",
+            keys: ["company", "role"],
+            delimiter: "|",
+          },
+          content: { kind: "list" },
+        },
+      },
+    },
+  ],
+} as const satisfies ParseSchema;
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    // Set credentials from environment variable
+    process.env.GOOGLE_APPLICATION_CREDENTIALS = env.GOOGLE_CREDENTIALS;
+
+    const docId = "YOUR_GOOGLE_DOC_ID";
+
+    try {
+      const data = await getParsedDocument(docId, schema);
+      return Response.json(data);
+    } catch (error) {
+      return Response.json(
+        { error: error instanceof Error ? error.message : "Unknown error" },
+        { status: 500 }
+      );
+    }
+  },
+};
+```
+
+### Vercel Edge Functions Example
+
+```typescript
+// app/api/docs/route.ts
+import { getParsedDocument } from "@yuji-min/google-docs-parser/edge";
+import type { ParseSchema } from "@yuji-min/google-docs-parser/edge";
+
+export const runtime = "edge";
+
+const schema = {
+  /* your schema */
+} as const satisfies ParseSchema;
+
+export async function GET(request: Request) {
+  // Credentials are automatically loaded from process.env.GOOGLE_APPLICATION_CREDENTIALS
+  const docId = "YOUR_GOOGLE_DOC_ID";
+
+  try {
+    const data = await getParsedDocument(docId, schema);
+    return Response.json(data);
+  } catch (error) {
+    return Response.json(
+      { error: error instanceof Error ? error.message : "Unknown error" },
+      { status: 500 }
+    );
+  }
+}
+```
+
+### Key Differences: Node.js vs Edge Runtime
+
+| Feature                    | Node.js (`/`)                       | Edge Runtime (`/edge`)              |
+| :------------------------- | :---------------------------------- | :---------------------------------- |
+| **Import Path**            | `@yuji-min/google-docs-parser`      | `@yuji-min/google-docs-parser/edge` |
+| **Dependencies**           | Requires `googleapis` + auth lib    | No external dependencies            |
+| **Credentials Format**     | File path or JSON string            | JSON string only                    |
+| **Authentication**         | `google-auth-library`               | Native Web Crypto API               |
+| **HTTP Client**            | `googleapis` client                 | Native `fetch`                      |
+| **Bundle Size**            | Larger (~400KB+)                    | Smaller (~16KB)                     |
+| **Supported Environments** | Node.js 18+                         | Cloudflare, Vercel Edge, Deno, etc. |
+
+---
+
 ## 📚 Parsing Schema Guide
 
 The `ParseSchema` object controls how the parser reads your document. Use `GetParsedType<typeof schema>` to infer the exact TypeScript type from your schema.

package/dist/edge.cjs

@@ -0,0 +1,530 @@
+'use strict';
+
+// src/edge/auth.ts
+function base64UrlEncode(data) {
+  const base64 = btoa(String.fromCharCode(...data));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function stringToUint8Array(str) {
+  return new TextEncoder().encode(str);
+}
+async function importPrivateKey(pemKey) {
+  const pemContents = pemKey.replace(/-----BEGIN PRIVATE KEY-----/, "").replace(/-----END PRIVATE KEY-----/, "").replace(/\s/g, "");
+  const binaryDer = Uint8Array.from(atob(pemContents), (c) => c.charCodeAt(0));
+  return crypto.subtle.importKey(
+    "pkcs8",
+    binaryDer,
+    {
+      name: "RSASSA-PKCS1-v1_5",
+      hash: "SHA-256"
+    },
+    false,
+    ["sign"]
+  );
+}
+async function createSignedJWT(credentials, scope) {
+  const now = Math.floor(Date.now() / 1e3);
+  const expiry = now + 3600;
+  const header = {
+    alg: "RS256",
+    typ: "JWT"
+  };
+  const payload = {
+    iss: credentials.client_email,
+    scope,
+    aud: credentials.token_uri,
+    exp: expiry,
+    iat: now
+  };
+  const encodedHeader = base64UrlEncode(
+    stringToUint8Array(JSON.stringify(header))
+  );
+  const encodedPayload = base64UrlEncode(
+    stringToUint8Array(JSON.stringify(payload))
+  );
+  const unsignedToken = `${encodedHeader}.${encodedPayload}`;
+  const privateKey = await importPrivateKey(credentials.private_key);
+  const dataToSign = stringToUint8Array(unsignedToken);
+  const signature = await crypto.subtle.sign(
+    "RSASSA-PKCS1-v1_5",
+    privateKey,
+    dataToSign
+  );
+  const encodedSignature = base64UrlEncode(new Uint8Array(signature));
+  return `${unsignedToken}.${encodedSignature}`;
+}
+async function getAccessToken(credentials) {
+  const scope = "https://www.googleapis.com/auth/documents.readonly";
+  const jwt = await createSignedJWT(credentials, scope);
+  const response = await fetch(credentials.token_uri, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+      assertion: jwt
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to get access token: ${response.status} ${errorText}`
+    );
+  }
+  const data = await response.json();
+  return data.access_token;
+}
+function loadCredentials() {
+  const credentialsEnv = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+  if (!credentialsEnv) {
+    throw new Error(
+      "GOOGLE_APPLICATION_CREDENTIALS environment variable is not set"
+    );
+  }
+  try {
+    if (credentialsEnv.trim().startsWith("{")) {
+      return JSON.parse(credentialsEnv);
+    }
+    throw new Error(
+      "File path credentials are not supported in Edge Runtime. Use JSON string instead."
+    );
+  } catch (error) {
+    throw new Error(
+      `Failed to parse credentials: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function createAuthenticatedClient() {
+  const credentials = loadCredentials();
+  return getAccessToken(credentials);
+}
+
+// src/edge/client.ts
+async function fetchDocument(documentId, accessToken) {
+  const url = `https://docs.googleapis.com/v1/documents/${documentId}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Google Docs API request failed: ${response.status} ${errorText}`
+    );
+  }
+  const data = await response.json();
+  if (!data.body) {
+    throw new Error("Empty document response from Google Docs API.");
+  }
+  return data;
+}
+async function getDocument(documentId) {
+  const accessToken = await createAuthenticatedClient();
+  return fetchDocument(documentId, accessToken);
+}
+
+// src/constants.ts
+var VALID_NAMED_STYLES = [
+  "HEADING_1",
+  "HEADING_2",
+  "HEADING_3",
+  "HEADING_4",
+  "HEADING_5",
+  "HEADING_6",
+  "TITLE",
+  "SUBTITLE"
+];
+var VALID_NAMED_STYLES_SET = new Set(VALID_NAMED_STYLES);
+
+// src/utils.ts
+function extractParagraphText(paragraph) {
+  const elements = paragraph.elements ?? [];
+  const text = elements.map((el) => el.textRun?.content || "").join("").trim().replace(/\n/g, " ");
+  return text || "";
+}
+function hasNamedStyle(paragraph, namedStyleType) {
+  if (!namedStyleType) return false;
+  const style = paragraph.paragraphStyle?.namedStyleType;
+  return style === namedStyleType;
+}
+function getParagraphNamedStyleType(paragraph) {
+  if (!paragraph.paragraphStyle && !paragraph.elements?.length) {
+    return void 0;
+  }
+  if (!paragraph.paragraphStyle) {
+    return "NORMAL_TEXT";
+  }
+  const namedStyleType = paragraph.paragraphStyle.namedStyleType;
+  if (!namedStyleType) {
+    return "NORMAL_TEXT";
+  }
+  if (VALID_NAMED_STYLES_SET.has(namedStyleType)) {
+    return namedStyleType;
+  }
+  return void 0;
+}
+function isNamedStyleType(style) {
+  if (typeof style !== "string") return false;
+  if (style === "NORMAL_TEXT") return false;
+  return VALID_NAMED_STYLES_SET.has(style);
+}
+function splitAndTrim(text, delimiter, filterEmpty = false) {
+  if (text === "") {
+    return [];
+  }
+  const items = text.split(delimiter).map((t) => t.trim());
+  return filterEmpty ? items.filter((t) => t.length > 0) : items;
+}
+function parseToKeyedList(text, keyDelimiter, listDelimiter) {
+  const delimiterIndex = text.indexOf(keyDelimiter);
+  if (delimiterIndex <= 0) {
+    return text;
+  }
+  const key = text.substring(0, delimiterIndex).trim();
+  const valuePart = text.substring(delimiterIndex + keyDelimiter.length).trim();
+  const value = valuePart ? splitAndTrim(valuePart, listDelimiter, true) : [];
+  return { key, value };
+}
+function parseToFields(text, keys, delimiter) {
+  const values = splitAndTrim(text, delimiter, false);
+  return keys.reduce((acc, key, index) => {
+    const value = values[index];
+    acc[key] = value !== void 0 && value !== "" ? value : "";
+    return acc;
+  }, {});
+}
+function parseDelimitedList(text, delimiter) {
+  const values = text.split(delimiter).map((v) => v.trim()).filter((v) => v.length > 0);
+  return values;
+}
+function parseStructuredText(text, schema) {
+  const delimiter = schema.delimiter || ",";
+  if (schema.keyDelimiter) {
+    return parseToKeyedList(text, schema.keyDelimiter, delimiter);
+  }
+  if (schema.keys && schema.keys.length > 0) {
+    return parseToFields(text, schema.keys, delimiter);
+  }
+  return parseDelimitedList(text, delimiter);
+}
+
+// src/tree.ts
+var CONTENT_KEY = "content";
+function collectNodeStylesRecursive(node, set) {
+  if (node.title.namedStyleType) set.add(node.title.namedStyleType);
+  if (node.content && node.content.kind === "tree") {
+    collectNodeStylesRecursive(node.content.node, set);
+  }
+}
+function createNodeFromTitle(text, titleSchema) {
+  const hasDelimiterSchema = !!titleSchema.keyDelimiter || !!titleSchema.keys && titleSchema.keys.length > 0 || !!titleSchema.delimiter;
+  if (hasDelimiterSchema) {
+    const structuredText = parseStructuredText(text, titleSchema);
+    if (Array.isArray(structuredText)) {
+      return { title: structuredText, content: [] };
+    } else if (typeof structuredText === "object" && structuredText !== null) {
+      return { title: structuredText, content: [] };
+    } else {
+      return { title: text, content: [] };
+    }
+  } else {
+    return { title: text, content: [] };
+  }
+}
+function determineTreeParsingAction(paragraph, cursor, nodeSchema, ancestorNodeList) {
+  const nodeTitleStyle = nodeSchema.title.namedStyleType;
+  const childNode = nodeSchema.content?.kind === "tree" ? nodeSchema.content.node : void 0;
+  const isCurrentNodeTitle = hasNamedStyle(paragraph, nodeTitleStyle);
+  const isChildNodeTitle = !!childNode && hasNamedStyle(paragraph, childNode.title.namedStyleType);
+  const isAncestorNodeTitle = ancestorNodeList.some(
+    (a) => hasNamedStyle(paragraph, a.title.namedStyleType)
+  );
+  const isInThisTree = isCurrentNodeTitle || isChildNodeTitle || isAncestorNodeTitle;
+  const isHeading = cursor.isAtParagraphHeading();
+  const isAtNewSection = cursor.isAtNewSection();
+  const isHeadingOutsideThisTree = isHeading && !isInThisTree;
+  const isHigherLevelHeading = isHeading && isAncestorNodeTitle;
+  const isSameLevelHeading = isHeading && isCurrentNodeTitle;
+  if (isAtNewSection) return { kind: "exitSection" };
+  if (isCurrentNodeTitle) return { kind: "createNode" };
+  if (isChildNodeTitle) return { kind: "startChildNode" };
+  if (isHigherLevelHeading || isSameLevelHeading)
+    return { kind: "finishCurrentNode" };
+  if (isHeadingOutsideThisTree) return { kind: "exitSection" };
+  return { kind: "appendDetail" };
+}
+function parseTreeSection(cursor, section, allNodeTitleStyles) {
+  const treeContent = section.content;
+  const nodeSchema = treeContent?.kind === "tree" ? treeContent.node : void 0;
+  if (!treeContent || !nodeSchema) return [];
+  while (!cursor.isEndOfDocument()) {
+    const info = cursor.getCurrentParagraph();
+    if (!info) {
+      cursor.getNextParagraph();
+      continue;
+    }
+    const { paragraph, style } = info;
+    if (cursor.isAtNewSection()) break;
+    if (cursor.isAtParagraphHeading() && style && !allNodeTitleStyles.has(style)) break;
+    if (hasNamedStyle(paragraph, nodeSchema.title.namedStyleType)) {
+      return parseTreeNode(cursor, nodeSchema, [], allNodeTitleStyles);
+    }
+    cursor.getNextParagraph();
+  }
+  return [];
+}
+function parseTreeNode(cursor, nodeSchema, ancestorNodeList, allNodeTitleStyles) {
+  const result = [];
+  let currentNode = null;
+  const childNodeSchema = nodeSchema.content?.kind === "tree" ? nodeSchema.content.node : void 0;
+  while (!cursor.isEndOfDocument()) {
+    const info = cursor.getCurrentParagraph();
+    if (!info) {
+      cursor.getNextParagraph();
+      continue;
+    }
+    const { text, paragraph, style } = info;
+    if (cursor.isAtNewSection()) {
+      return result;
+    }
+    if (cursor.isAtParagraphHeading() && style && !allNodeTitleStyles.has(style)) {
+      return result;
+    }
+    const decision = determineTreeParsingAction(
+      paragraph,
+      cursor,
+      nodeSchema,
+      ancestorNodeList
+    );
+    switch (decision.kind) {
+      case "exitSection": {
+        return result;
+      }
+      case "createNode": {
+        currentNode = createNodeFromTitle(text, nodeSchema.title);
+        result.push(currentNode);
+        cursor.getNextParagraph();
+        break;
+      }
+      case "startChildNode": {
+        if (!currentNode || !Array.isArray(currentNode[CONTENT_KEY]) || !childNodeSchema) {
+          cursor.getNextParagraph();
+          break;
+        }
+        const children = parseTreeNode(
+          cursor,
+          childNodeSchema,
+          [nodeSchema, ...ancestorNodeList],
+          allNodeTitleStyles
+        );
+        currentNode[CONTENT_KEY].push(...children);
+        break;
+      }
+      case "finishCurrentNode": {
+        if (currentNode) return result;
+        cursor.getNextParagraph();
+        break;
+      }
+      case "appendDetail": {
+        if (nodeSchema.content?.kind === "tree") {
+          cursor.getNextParagraph();
+          break;
+        }
+        if (currentNode && Array.isArray(currentNode[CONTENT_KEY])) {
+          currentNode[CONTENT_KEY].push(text.trim());
+        }
+        cursor.getNextParagraph();
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+// src/list.ts
+function parseListSection(cursor, section) {
+  const result = [];
+  if (!section.content || section.content.kind !== "list") {
+    return [];
+  }
+  const contentSchema = section.content;
+  while (!cursor.isEndOfDocument()) {
+    const info = cursor.getCurrentParagraph();
+    if (!info) {
+      cursor.getNextParagraph();
+      continue;
+    }
+    if (cursor.isAtNewSection()) break;
+    if (cursor.isAtParagraphHeading()) break;
+    const parsed = parseStructuredText(info.text, contentSchema);
+    if (contentSchema.isFlatten && Array.isArray(parsed)) {
+      result.push(...parsed);
+    } else {
+      result.push(parsed);
+    }
+    cursor.getNextParagraph();
+  }
+  return result;
+}
+
+// src/textBlock.ts
+function parseTextBlockSection(cursor) {
+  const textPartList = [];
+  while (!cursor.isEndOfDocument()) {
+    const paragraph = cursor.getCurrentParagraph();
+    if (!paragraph) {
+      cursor.getNextParagraph();
+      continue;
+    }
+    if (cursor.isAtNewSection()) break;
+    if (cursor.isAtParagraphHeading()) break;
+    textPartList.push(paragraph.text);
+    cursor.getNextParagraph();
+  }
+  return textPartList.join(" ");
+}
+
+// src/section.ts
+function getSectionTitle(paragraph, text, parseSchema) {
+  const normalized = text.trim().toLowerCase();
+  const sectionList = parseSchema.sections ?? [];
+  for (const section of sectionList) {
+    const { name, namedStyleType } = section.title;
+    if (name && namedStyleType) {
+      const styleMatches = hasNamedStyle(paragraph, namedStyleType);
+      const textMatches = normalized === name.trim().toLowerCase();
+      if (styleMatches && textMatches) {
+        return name;
+      }
+    }
+  }
+  return null;
+}
+function parseSectionContent(cursor, section) {
+  const content = section.content;
+  if (!content) {
+    return parseTextBlockSection(cursor);
+  }
+  switch (content.kind) {
+    case "tree": {
+      if (!content.node) {
+        return [];
+      }
+      const allNodeTitleStyles = /* @__PURE__ */ new Set();
+      collectNodeStylesRecursive(content.node, allNodeTitleStyles);
+      return parseTreeSection(cursor, section, allNodeTitleStyles);
+    }
+    case "list":
+      return parseListSection(cursor, section);
+    default:
+      return parseTextBlockSection(cursor);
+  }
+}
+
+// src/cursor.ts
+function getParagraph(paragraph) {
+  const text = extractParagraphText(paragraph);
+  if (!text) return null;
+  const style = getParagraphNamedStyleType(paragraph);
+  return { text, style, paragraph };
+}
+var ParagraphCursor = class {
+  constructor(paragraphList, parseSchema) {
+    this.paragraphList = paragraphList;
+    this.parseSchema = parseSchema;
+  }
+  index = 0;
+  /**
+   * Retrieves the paragraph at the current cursor position.
+   *
+   * @returns The current `Paragraph` object, or `null` if the cursor is at the end of the document or the line is empty.
+   */
+  getCurrentParagraph() {
+    if (this.isEndOfDocument()) return null;
+    const paragraph = this.paragraphList[this.index];
+    if (!paragraph) return null;
+    return getParagraph(paragraph);
+  }
+  /**
+   * Advances the cursor to the next position and returns the new paragraph.
+   *
+   * @returns The next `Paragraph` object, or `null` if the end of the document is reached.
+   */
+  getNextParagraph() {
+    if (this.isEndOfDocument()) return null;
+    this.index++;
+    return this.getCurrentParagraph();
+  }
+  /**
+   * Checks if the cursor has reached the end of the paragraph list.
+   */
+  isEndOfDocument() {
+    return this.index >= this.paragraphList.length;
+  }
+  /**
+   * Determines if the current paragraph corresponds to a section title defined in the schema.
+   *
+   * @returns The section name if matched, otherwise `null`.
+   */
+  getCurrentSectionTitle() {
+    const info = this.getCurrentParagraph();
+    if (!info) return null;
+    return getSectionTitle(info.paragraph, info.text, this.parseSchema);
+  }
+  /**
+   * Checks if the current cursor position marks the start of a new section.
+   */
+  isAtNewSection() {
+    return this.getCurrentSectionTitle() !== null;
+  }
+  /**
+   * Checks if the current paragraph has a named heading style (e.g., HEADING_1).
+   */
+  isAtParagraphHeading() {
+    const info = this.getCurrentParagraph();
+    return !!info && isNamedStyleType(info.style);
+  }
+};
+
+// src/edge/index.ts
+function parseDocument(doc, parseSchema) {
+  const content = doc.body?.content || [];
+  const result = {};
+  const validParagraphList = content.map((element) => element.paragraph).filter((paragraph) => !!paragraph);
+  const cursor = new ParagraphCursor(validParagraphList, parseSchema);
+  while (!cursor.isEndOfDocument()) {
+    const currentSectionTitle = cursor.getCurrentSectionTitle();
+    if (currentSectionTitle) {
+      const section = parseSchema.sections.find(
+        (s) => s.title.name === currentSectionTitle
+      );
+      if (section) {
+        cursor.getNextParagraph();
+        const parsedData = parseSectionContent(cursor, section);
+        result[currentSectionTitle] = parsedData;
+        continue;
+      }
+    }
+    cursor.getNextParagraph();
+  }
+  return result;
+}
+async function getParsedDocument(documentId, parseSchema) {
+  try {
+    const doc = await getDocument(documentId);
+    const parsedDocument = parseDocument(doc, parseSchema);
+    return parsedDocument;
+  } catch (e) {
+    throw new Error(
+      `Google Docs API call failed. Check Doc ID and Service Account permissions. Original error: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}
+
+exports.getParsedDocument = getParsedDocument;
+//# sourceMappingURL=edge.cjs.map
+//# sourceMappingURL=edge.cjs.map