@youversion/platform-core 0.4.1

package/dist/index.js

@@ -0,0 +1,1286 @@
+// src/client.ts
+var ApiClient = class {
+  baseURL;
+  timeout;
+  defaultHeaders;
+  config;
+  /**
+   * Creates an instance of ApiClient.
+   *
+   * @param config - The API configuration object containing baseUrl, timeout, and appId.
+   */
+  constructor(config) {
+    this.config = {
+      version: config.version || "v1",
+      ...config
+    };
+    this.baseURL = config.baseUrl || "https://api-dev.youversion.com";
+    this.timeout = config.timeout || 1e4;
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      "X-YVP-App-Key": this.config.appId,
+      "X-YVP-Installation-Id": this.config.installationId || "web-sdk-default"
+    };
+  }
+  /**
+   * Builds the query string from parameters
+   */
+  buildQueryString(params) {
+    if (!params) return "";
+    const queryString = new URLSearchParams(
+      Object.entries(params).map(([key, value]) => [key, String(value)])
+    ).toString();
+    return queryString ? `?${queryString}` : "";
+  }
+  /**
+   * Makes an HTTP request with timeout support
+   */
+  async request(url, options = {}) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+        headers: {
+          ...this.defaultHeaders,
+          ...options.headers
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const isDevelopment = process.env.NODE_ENV === "development";
+        let errorMessage = `HTTP error! status: ${response.status}`;
+        try {
+          const errorBody = await response.text();
+          if (errorBody) {
+            try {
+              const errorJson = JSON.parse(errorBody);
+              const detailedMessage = errorJson.message || errorJson.error || errorBody;
+              if (isDevelopment) {
+                errorMessage = detailedMessage;
+              } else {
+                errorMessage = `Request failed with status ${response.status}`;
+              }
+            } catch {
+              if (isDevelopment) {
+                errorMessage = errorBody;
+              }
+            }
+          }
+        } catch (error2) {
+          if (isDevelopment && error2 instanceof Error) {
+            console.error("Failed to read error response:", error2.message);
+          }
+        }
+        const error = Object.assign(new Error(errorMessage), {
+          status: response.status,
+          statusText: response.statusText
+        });
+        throw error;
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        const data = await response.json();
+        return data;
+      } else {
+        const text = await response.text();
+        return text;
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Sends a GET request to the specified API path with optional query parameters.
+   *
+   * @typeParam T - The expected response type.
+   * @param path - The API endpoint path (relative to baseURL).
+   * @param params - Optional query parameters to include in the request.
+   * @returns A promise resolving to the response data of type T.
+   */
+  async get(path, params, headers) {
+    const url = `${this.baseURL}${path}${this.buildQueryString(params)}`;
+    return this.request(url, {
+      method: "GET",
+      headers
+    });
+  }
+  /**
+   * Sends a POST request to the specified API path with optional data and query parameters.
+   *
+   * @typeParam T - The expected response type.
+   * @param path - The API endpoint path (relative to baseURL).
+   * @param data - Optional request body data to send.
+   * @param params - Optional query parameters to include in the request.
+   * @returns A promise resolving to the response data of type T.
+   */
+  async post(path, data, params) {
+    const url = `${this.baseURL}${path}${this.buildQueryString(params)}`;
+    return this.request(url, {
+      method: "POST",
+      body: data ? JSON.stringify(data) : void 0
+    });
+  }
+  /**
+   * Sends a DELETE request to the specified API path with optional query parameters.
+   *
+   * @typeParam T - The expected response type.
+   * @param path - The API endpoint path (relative to baseURL).
+   * @param params - Optional query parameters to include in the request.
+   * @returns A promise resolving to the response data of type T (may be empty for 204 responses).
+   */
+  async delete(path, params) {
+    const url = `${this.baseURL}${path}${this.buildQueryString(params)}`;
+    return this.request(url, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/bible.ts
+import { z } from "zod";
+var BibleClient = class {
+  client;
+  // Validation schemas
+  versionIdSchema = z.number().int().positive("Version ID must be a positive integer");
+  bookSchema = z.string().trim().min(3, "Book ID must be exactly 3 characters").max(3, "Book ID must be exactly 3 characters");
+  chapterSchema = z.number().int("Chapter must be an integer").positive("Chapter must be a positive integer");
+  verseSchema = z.number().int("Verse must be an integer").positive("Verse must be a positive integer");
+  languageRangesSchema = z.string().trim().min(1, "Language ranges must be a non-empty string");
+  booleanSchema = z.boolean();
+  /**
+   * Creates a new BibleClient instance.
+   * @param client The API client to use for requests.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  get rootPath() {
+    return `/${this.client.config.version}`;
+  }
+  /**
+   * Fetches a collection of Bible versions filtered by language ranges.
+   *
+   * @param language_ranges - A comma-separated list of language codes or ranges to filter the versions (required).
+   * @param license_id - Optional license ID to filter versions by license.
+   * @returns A promise that resolves to a collection of BibleVersion objects.
+   */
+  async getVersions(language_ranges, license_id) {
+    this.languageRangesSchema.parse(language_ranges);
+    const params = {
+      "language_ranges[]": language_ranges
+    };
+    if (license_id !== void 0) {
+      params.license_id = license_id;
+    }
+    return this.client.get(`${this.rootPath}/bibles`, params);
+  }
+  /**
+   * Fetches a Bible version by its ID.
+   * @param id The version ID.
+   * @returns The requested BibleVersion object.
+   */
+  async getVersion(id) {
+    this.versionIdSchema.parse(id);
+    return this.client.get(`${this.rootPath}/bibles/${id}`);
+  }
+  /**
+   * Fetches all books for a given Bible version.
+   * @param versionId The version ID.
+   * @param canon Optional canon filter ('ot', 'nt', 'deuterocanon').
+   * @returns An array of BibleBook objects.
+   */
+  async getBooks(versionId, canon) {
+    this.versionIdSchema.parse(versionId);
+    return this.client.get(`${this.rootPath}/bibles/${versionId}/books`, {
+      ...canon && { canon }
+    });
+  }
+  /**
+   * Fetches a specific book by USFM code for a given version.
+   * @param versionId The version ID.
+   * @param book The Book Identifier code of the book.
+   * @returns The requested BibleBook object.
+   */
+  async getBook(versionId, book) {
+    this.versionIdSchema.parse(versionId);
+    this.bookSchema.parse(book);
+    return this.client.get(`${this.rootPath}/bibles/${versionId}/books/${book}`);
+  }
+  /**
+   * Fetches all chapters for a specific book in a version.
+   * @param versionId The version ID.
+   * @param book The Book Identifier code of the book.
+   * @returns An array of BibleChapter objects.
+   */
+  async getChapters(versionId, book) {
+    this.versionIdSchema.parse(versionId);
+    this.bookSchema.parse(book);
+    return this.client.get(
+      `${this.rootPath}/bibles/${versionId}/books/${book}/chapters`
+    );
+  }
+  /**
+   * Fetches a specific chapter for a book in a version.
+   * @param versionId The version ID.
+   * @param book The Book Identifier code of the book (3 characters, e.g., "MAT").
+   * @param chapter The chapter number
+   * @returns The requested BibleChapter object.
+   */
+  async getChapter(versionId, book, chapter) {
+    this.versionIdSchema.parse(versionId);
+    this.bookSchema.parse(book);
+    this.chapterSchema.parse(chapter);
+    return this.client.get(
+      `${this.rootPath}/bibles/${versionId}/books/${book}/chapters/${chapter}`
+    );
+  }
+  /**
+   * Fetches all verses for a specific chapter in a book and version.
+   * @param versionId The version ID.
+   * @param book The Book Identifier code of the book (3 characters, e.g., "MAT").
+   * @param chapter The chapter number.
+   * @returns An array of BibleVerse objects.
+   */
+  async getVerses(versionId, book, chapter) {
+    this.versionIdSchema.parse(versionId);
+    this.bookSchema.parse(book);
+    this.chapterSchema.parse(chapter);
+    return this.client.get(
+      `${this.rootPath}/bibles/${versionId}/books/${book}/chapters/${chapter}/verses`
+    );
+  }
+  /**
+   * Fetches a specific verse from a chapter, book, and version.
+   * @param versionId The version ID.
+   * @param book The Book Identifier code of the book (3 characters, e.g., "MAT").
+   * @param chapter The chapter number.
+   * @param verse The verse number.
+   * @returns The requested BibleVerse object.
+   */
+  async getVerse(versionId, book, chapter, verse) {
+    this.versionIdSchema.parse(versionId);
+    this.bookSchema.parse(book);
+    this.chapterSchema.parse(chapter);
+    this.verseSchema.parse(verse);
+    return this.client.get(
+      `${this.rootPath}/bibles/${versionId}/books/${book}/chapters/${chapter}/verses/${verse}`
+    );
+  }
+  /**
+   * Fetches a passage (range of verses) from the Bible using the passages endpoint.
+   * This is the new API format that returns HTML-formatted content.
+   * @param versionId The version ID.
+   * @param usfm The USFM reference (e.g., "JHN.3.1-2", "GEN.1", "JHN.3.16").
+   * @param format The format to return ("html" or "text", default: "html").
+   * @param include_headings Whether to include headings in the content.
+   * @param include_notes Whether to include notes in the content.
+   * @returns The requested BiblePassage object with HTML content.
+   * @example
+   * ```ts
+   * // Get a single verse
+   * const verse = await bibleClient.getPassage(111, "JHN.3.16");
+   *
+   * // Get a range of verses
+   * const verses = await bibleClient.getPassage(111, "JHN.3.1-5");
+   *
+   * // Get an entire chapter
+   * const chapter = await bibleClient.getPassage(111, "GEN.1");
+   * ```
+   */
+  async getPassage(versionId, usfm, format = "html", include_headings, include_notes) {
+    this.versionIdSchema.parse(versionId);
+    if (include_headings !== void 0) {
+      this.booleanSchema.parse(include_headings);
+    }
+    if (include_notes !== void 0) {
+      this.booleanSchema.parse(include_notes);
+    }
+    const params = {
+      format
+    };
+    if (include_headings !== void 0) {
+      params.include_headings = include_headings;
+    }
+    if (include_notes !== void 0) {
+      params.include_notes = include_notes;
+    }
+    return this.client.get(
+      `${this.rootPath}/bibles/${versionId}/passages/${usfm}`,
+      params
+    );
+  }
+  /**
+   * Fetches the indexing structure for a Bible version.
+   * @param versionId The version ID.
+   * @returns The BibleIndex object containing full hierarchy of books, chapters, and verses.
+   */
+  async getIndex(versionId) {
+    this.versionIdSchema.parse(versionId);
+    return this.client.get(`${this.rootPath}/bibles/${versionId}/index`);
+  }
+  /**
+   * Fetches the verse of the day calendar for an entire year.
+   * @returns A collection of VOTD objects for all days of the year.
+   */
+  async getAllVOTDs() {
+    return this.client.get(`${this.rootPath}/verse_of_the_days`);
+  }
+  /**
+   * Fetches the passage_id for the Verse Of The Day.
+   * @param day The day of the year (1-366).
+   * @returns The day of the year and the passage_id for that day of the year
+   * @example
+   * ```ts
+   * // Get the passageId for the verse of the first day of the year.
+   * const passageId = await bibleClient.getVOTD(1);
+   *
+   * // Get the passageId for the verse of the 100th day of the year.
+   * const passageId = await bibleClient.getVOTD(100);
+   * ```
+   */
+  async getVOTD(day) {
+    const daySchema = z.number().int().min(1).max(366);
+    daySchema.parse(day);
+    return this.client.get(`${this.rootPath}/verse_of_the_days/${day}`);
+  }
+};
+
+// src/languages.ts
+import { z as z2 } from "zod";
+var LanguagesClient = class {
+  client;
+  languageIdSchema = z2.string().trim().min(1, "Language ID must be a non-empty string").regex(
+    /^[a-z]{2,3}(?:-[A-Z][a-z]{3})?$/,
+    "Language ID must match BCP 47 format (language or language+script)"
+  );
+  countrySchema = z2.string().trim().length(2, "Country code must be a 2-character ISO 3166-1 alpha-2 code").toUpperCase();
+  /**
+   * Creates a new LanguagesClient instance.
+   * @param client The API client to use for requests.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  get rootPath() {
+    return `/${this.client.config.version}`;
+  }
+  /**
+   * Fetches a collection of languages supported in the Platform.
+   * @param options Query parameters for pagination and filtering (country is required).
+   * @returns A collection of Language objects.
+   */
+  async getLanguages(options) {
+    const params = {};
+    const country = this.countrySchema.parse(options.country);
+    params.country = country;
+    if (options.page_size !== void 0) {
+      const pageSizeSchema = z2.number().int().positive();
+      pageSizeSchema.parse(options.page_size);
+      params.page_size = options.page_size;
+    }
+    if (options.page_token !== void 0) {
+      params.page_token = options.page_token;
+    }
+    return this.client.get(`${this.rootPath}/languages`, params);
+  }
+  /**
+   * Fetches details about a specific language in the Platform.
+   * @param languageId The BCP 47 language code (optionally including script, e.g., "en" or "sr-Latn").
+   * @returns The requested Language object.
+   */
+  async getLanguage(languageId) {
+    this.languageIdSchema.parse(languageId);
+    return this.client.get(`${this.rootPath}/languages/${languageId}`);
+  }
+};
+
+// src/highlights.ts
+import { z as z3 } from "zod";
+
+// src/YouVersionPlatformConfiguration.ts
+var YouVersionPlatformConfiguration = class {
+  static _appId = null;
+  static _installationId = null;
+  static _accessToken = null;
+  static _apiHost = "api-dev.youversion.com";
+  static _isPreviewMode = false;
+  static _previewUserInfo = null;
+  static getOrSetInstallationId() {
+    if (typeof window === "undefined") {
+      return "";
+    }
+    const existingId = localStorage.getItem("x-yvp-installation-id");
+    if (existingId) {
+      return existingId;
+    }
+    const newId = crypto.randomUUID();
+    localStorage.setItem("x-yvp-installation-id", newId);
+    return newId;
+  }
+  static get appId() {
+    return this._appId;
+  }
+  static set appId(value) {
+    this._appId = value;
+  }
+  static get installationId() {
+    if (!this._installationId) {
+      this._installationId = this.getOrSetInstallationId();
+    }
+    return this._installationId;
+  }
+  static set installationId(value) {
+    this._installationId = value || this.getOrSetInstallationId();
+  }
+  static setAccessToken(token) {
+    if (token !== null && (typeof token !== "string" || token.trim().length === 0)) {
+      throw new Error("Access token must be a non-empty string or null");
+    }
+    this._accessToken = token;
+  }
+  static get accessToken() {
+    return this._accessToken;
+  }
+  static get apiHost() {
+    return this._apiHost;
+  }
+  static set apiHost(value) {
+    this._apiHost = value;
+  }
+  static get isPreviewMode() {
+    return this._isPreviewMode;
+  }
+  static set isPreviewMode(value) {
+    this._isPreviewMode = value;
+  }
+  static get previewUserInfo() {
+    return this._previewUserInfo;
+  }
+  static set previewUserInfo(value) {
+    this._previewUserInfo = value;
+  }
+};
+
+// src/highlights.ts
+var HighlightsClient = class {
+  client;
+  versionIdSchema = z3.number().int().positive("Version ID must be a positive integer");
+  passageIdSchema = z3.string().trim().min(1, "Passage ID must be a non-empty string");
+  colorSchema = z3.string().regex(/^[0-9a-f]{6}$/i, "Color must be a 6-character hex string without #");
+  /**
+   * Creates a new HighlightsClient instance.
+   * @param client The API client to use for requests.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  get rootPath() {
+    return `/${this.client.config.version}`;
+  }
+  /**
+   * Gets the authentication token, either from the provided parameter or from the platform configuration.
+   * @param lat Optional explicit long access token. If not provided, retrieves from YouVersionPlatformConfiguration.
+   * @returns The authentication token.
+   * @throws Error if no token is available.
+   */
+  getAuthToken(lat) {
+    if (lat) {
+      return lat;
+    }
+    const token = YouVersionPlatformConfiguration.accessToken;
+    if (!token) {
+      throw new Error(
+        "Authentication required. Please provide a token or sign in before accessing highlights."
+      );
+    }
+    return token;
+  }
+  validateVersionId(value) {
+    try {
+      this.versionIdSchema.parse(value);
+    } catch (error) {
+      if (error instanceof z3.ZodError) {
+        throw new Error("Version ID must be a positive integer");
+      }
+      throw error;
+    }
+  }
+  validatePassageId(value) {
+    try {
+      this.passageIdSchema.parse(value);
+    } catch (error) {
+      if (error instanceof z3.ZodError) {
+        throw new Error("Passage ID must be a non-empty string");
+      }
+      throw error;
+    }
+  }
+  validateColor(value) {
+    try {
+      this.colorSchema.parse(value);
+    } catch (error) {
+      if (error instanceof z3.ZodError) {
+        throw new Error("Color must be a 6-character hex string without #");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Fetches a collection of highlights for a user.
+   * The response will return a color per verse without ranges.
+   * Requires OAuth with read_highlights scope.
+   * @param options Query parameters for filtering highlights.
+   * @param lat Optional long access token. If not provided, retrieves from YouVersionPlatformConfiguration.
+   * @returns A collection of Highlight objects.
+   */
+  async getHighlights(options, lat) {
+    const token = this.getAuthToken(lat);
+    const params = {
+      lat: token
+    };
+    if (options?.version_id !== void 0) {
+      this.validateVersionId(options.version_id);
+      params.version_id = options.version_id;
+    }
+    if (options?.passage_id !== void 0) {
+      this.validatePassageId(options.passage_id);
+      params.passage_id = options.passage_id;
+    }
+    return this.client.get(`${this.rootPath}/highlights`, params);
+  }
+  /**
+   * Creates or updates a highlight on a passage.
+   * Verse ranges may be used in the passage_id attribute.
+   * Requires OAuth with write_highlights scope.
+   * @param data The highlight data to create or update.
+   * @param lat Optional long access token. If not provided, retrieves from YouVersionPlatformConfiguration.
+   * @returns The created or updated Highlight object.
+   */
+  async createHighlight(data, lat) {
+    this.validateVersionId(data.version_id);
+    this.validatePassageId(data.passage_id);
+    this.validateColor(data.color);
+    const token = this.getAuthToken(lat);
+    return this.client.post(`${this.rootPath}/highlights`, data, { lat: token });
+  }
+  /**
+   * Clears highlights for a passage.
+   * Requires OAuth with write_highlights scope.
+   * @param passageId The passage identifier (USFM format, e.g., "MAT.1.1" or "MAT.1.1-5").
+   * @param options Optional query parameters including bible_id.
+   * @param lat Optional long access token. If not provided, retrieves from YouVersionPlatformConfiguration.
+   * @returns Promise that resolves when highlights are deleted (204 response).
+   */
+  async deleteHighlight(passageId, options, lat) {
+    this.validatePassageId(passageId);
+    const token = this.getAuthToken(lat);
+    const params = {
+      lat: token
+    };
+    if (options?.version_id !== void 0) {
+      this.validateVersionId(options.version_id);
+      params.version_id = options.version_id;
+    }
+    await this.client.delete(`${this.rootPath}/highlights/${passageId}`, params);
+  }
+};
+
+// src/authentication.ts
+var AuthClient = class {
+  client;
+  /**
+   * Creates an instance of AuthClient.
+   * @param client - The ApiClient instance to use for requests.
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Retrieves the current authenticated user.
+   *
+   * @param lat - The long access token (LAT) used for authentication.
+   * @returns A promise that resolves to the authenticated User.
+   */
+  async getUser(lat) {
+    return this.client.get(`/auth/me`, { lat });
+  }
+};
+
+// src/AuthenticationStrategy.ts
+var AuthenticationStrategyRegistry = class {
+  static strategy = null;
+  /**
+   * Registers a platform-specific authentication strategy
+   *
+   * @param strategy - The authentication strategy to register
+   * @throws Error if strategy is null, undefined, or missing required methods
+   */
+  static register(strategy) {
+    if (!strategy) {
+      throw new Error("Authentication strategy cannot be null or undefined");
+    }
+    if (typeof strategy.authenticate !== "function") {
+      throw new Error("Authentication strategy must implement authenticate method");
+    }
+    this.strategy = strategy;
+  }
+  /**
+   * Gets the currently registered authentication strategy
+   *
+   * @returns The registered authentication strategy
+   * @throws Error if no strategy has been registered
+   */
+  static get() {
+    if (!this.strategy) {
+      throw new Error(
+        "No authentication strategy registered. Please register a platform-specific strategy using AuthenticationStrategyRegistry.register()"
+      );
+    }
+    return this.strategy;
+  }
+  /**
+   * Checks if a strategy is currently registered
+   *
+   * @returns true if a strategy is registered, false otherwise
+   */
+  static isRegistered() {
+    return this.strategy !== null;
+  }
+  /**
+   * Resets the registry by removing the current strategy
+   *
+   * This method is primarily intended for testing scenarios
+   * where you need to clean up between test cases.
+   */
+  static reset() {
+    this.strategy = null;
+  }
+};
+
+// src/StorageStrategy.ts
+var SessionStorageStrategy = class {
+  setItem(key, value) {
+    if (typeof sessionStorage === "undefined") {
+      console.warn("SessionStorage is not available in this environment");
+      return;
+    }
+    sessionStorage.setItem(key, value);
+  }
+  getItem(key) {
+    if (typeof sessionStorage === "undefined") {
+      return null;
+    }
+    return sessionStorage.getItem(key);
+  }
+  removeItem(key) {
+    if (typeof sessionStorage === "undefined") {
+      return;
+    }
+    sessionStorage.removeItem(key);
+  }
+  clear() {
+    if (typeof sessionStorage === "undefined") {
+      return;
+    }
+    sessionStorage.clear();
+  }
+};
+var MemoryStorageStrategy = class {
+  store = /* @__PURE__ */ new Map();
+  setItem(key, value) {
+    this.store.set(key, value);
+  }
+  getItem(key) {
+    return this.store.get(key) ?? null;
+  }
+  removeItem(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/WebAuthenticationStrategy.ts
+var WebAuthenticationStrategy = class _WebAuthenticationStrategy {
+  redirectUri;
+  callbackPath;
+  timeout;
+  storage;
+  static pendingAuthResolve = null;
+  static pendingAuthReject = null;
+  static timeoutId = null;
+  constructor(options) {
+    this.callbackPath = options?.callbackPath ?? "/auth/callback";
+    this.redirectUri = options?.redirectUri ?? window.location.origin + this.callbackPath;
+    this.timeout = options?.timeout ?? 3e5;
+    this.storage = options?.storage ?? new SessionStorageStrategy();
+  }
+  async authenticate(authUrl) {
+    authUrl.searchParams.set("redirect_uri", this.redirectUri);
+    return this.authenticateWithRedirect(authUrl);
+  }
+  /**
+   * Call this method when your app loads to handle the redirect callback
+   */
+  static handleCallback(callbackPath = "/auth/callback") {
+    const currentUrl = new URL(window.location.href);
+    if (currentUrl.pathname === callbackPath && currentUrl.searchParams.has("status")) {
+      const callbackUrl = new URL(currentUrl.toString());
+      if (_WebAuthenticationStrategy.pendingAuthResolve) {
+        _WebAuthenticationStrategy.pendingAuthResolve(callbackUrl);
+        _WebAuthenticationStrategy.cleanup();
+      } else {
+        const storageStrategy2 = new SessionStorageStrategy();
+        storageStrategy2.setItem("youversion-auth-callback", callbackUrl.toString());
+      }
+      const storageStrategy = new SessionStorageStrategy();
+      const returnUrl = storageStrategy.getItem("youversion-auth-return") ?? "/";
+      storageStrategy.removeItem("youversion-auth-return");
+      window.history.replaceState({}, "", returnUrl);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Clean up pending authentication state
+   */
+  static cleanup() {
+    if (_WebAuthenticationStrategy.timeoutId) {
+      clearTimeout(_WebAuthenticationStrategy.timeoutId);
+      _WebAuthenticationStrategy.timeoutId = null;
+    }
+    _WebAuthenticationStrategy.pendingAuthResolve = null;
+    _WebAuthenticationStrategy.pendingAuthReject = null;
+  }
+  /**
+   * Retrieve stored callback result if available
+   */
+  static getStoredCallback() {
+    const storageStrategy = new SessionStorageStrategy();
+    const stored = storageStrategy.getItem("youversion-auth-callback");
+    if (stored) {
+      storageStrategy.removeItem("youversion-auth-callback");
+      try {
+        return new URL(stored);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  authenticateWithRedirect(authUrl) {
+    _WebAuthenticationStrategy.cleanup();
+    this.storage.setItem("youversion-auth-return", window.location.href);
+    return new Promise((resolve, reject) => {
+      _WebAuthenticationStrategy.pendingAuthResolve = resolve;
+      _WebAuthenticationStrategy.pendingAuthReject = reject;
+      _WebAuthenticationStrategy.timeoutId = setTimeout(() => {
+        _WebAuthenticationStrategy.cleanup();
+        reject(new Error("Authentication timeout"));
+      }, this.timeout);
+      try {
+        window.location.href = authUrl.toString();
+      } catch (error) {
+        _WebAuthenticationStrategy.cleanup();
+        reject(
+          new Error(
+            `Failed to navigate to auth URL: ${error instanceof Error ? error.message : "Unknown error"}`
+          )
+        );
+      }
+    });
+  }
+};
+
+// src/SignInWithYouVersionResult.ts
+var SignInWithYouVersionPermission = {
+  bibles: "bibles",
+  highlights: "highlights",
+  votd: "votd",
+  demographics: "demographics",
+  bibleActivity: "bible_activity"
+};
+var SignInWithYouVersionResult = class {
+  accessToken;
+  permissions;
+  errorMsg;
+  yvpUserId;
+  constructor(url) {
+    const queryParams = new URLSearchParams(url.search);
+    const status = queryParams.get("status");
+    const userId = queryParams.get("yvp_user_id");
+    const latValue = queryParams.get("lat");
+    const grants = queryParams.get("grants");
+    const perms = grants?.split(",").map((grant) => grant.trim()).filter(
+      (grant) => Object.values(SignInWithYouVersionPermission).includes(
+        grant
+      )
+    ).map((grant) => grant) ?? [];
+    if (status === "success" && latValue && userId) {
+      this.accessToken = latValue;
+      this.permissions = perms;
+      this.errorMsg = null;
+      this.yvpUserId = userId;
+    } else if (status === "canceled") {
+      this.accessToken = null;
+      this.permissions = [];
+      this.errorMsg = null;
+      this.yvpUserId = null;
+    } else {
+      this.accessToken = null;
+      this.permissions = [];
+      this.errorMsg = "Authentication failed";
+      this.yvpUserId = null;
+    }
+  }
+};
+
+// src/YouVersionUserInfo.ts
+var YouVersionUserInfo = class {
+  firstName;
+  lastName;
+  userId;
+  avatarUrlFormat;
+  constructor(data) {
+    if (!data || typeof data !== "object") {
+      throw new Error("Invalid user data provided");
+    }
+    this.firstName = data.first_name;
+    this.lastName = data.last_name;
+    this.userId = data.id;
+    this.avatarUrlFormat = data.avatar_url;
+  }
+  getAvatarUrl(width = 200, height = 200) {
+    if (!this.avatarUrlFormat) {
+      return null;
+    }
+    let urlString = this.avatarUrlFormat;
+    if (urlString.startsWith("//")) {
+      urlString = "https:" + urlString;
+    }
+    urlString = urlString.replace("{width}", width.toString());
+    urlString = urlString.replace("{height}", height.toString());
+    try {
+      return new URL(urlString);
+    } catch {
+      return null;
+    }
+  }
+  get avatarUrl() {
+    return this.getAvatarUrl();
+  }
+};
+
+// src/YouVersionAPI.ts
+var YouVersionAPI = class {
+  static addStandardHeaders(url) {
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    };
+    const appId = YouVersionPlatformConfiguration.appId;
+    if (appId) {
+      headers["X-App-Id"] = appId;
+    }
+    const installationId = YouVersionPlatformConfiguration.installationId;
+    if (installationId) {
+      headers["x-yvp-installation-id"] = installationId;
+    }
+    const request = new Request(url.toString(), {
+      headers
+    });
+    return request;
+  }
+};
+
+// src/URLBuilder.ts
+var URLBuilder = class {
+  static get baseURL() {
+    return new URL(`https://${YouVersionPlatformConfiguration.apiHost}`);
+  }
+  static authURL(appId, requiredPermissions = /* @__PURE__ */ new Set(), optionalPermissions = /* @__PURE__ */ new Set()) {
+    if (typeof appId !== "string" || appId.trim().length === 0) {
+      throw new Error("appId must be a non-empty string");
+    }
+    try {
+      const url = new URL(this.baseURL);
+      url.pathname = "/auth/login";
+      const searchParams = new URLSearchParams();
+      searchParams.append("app_id", appId);
+      searchParams.append("language", "en");
+      if (requiredPermissions.size > 0) {
+        const requiredList = Array.from(requiredPermissions).map((p) => p.toString());
+        searchParams.append("required_perms", requiredList.join(","));
+      }
+      if (optionalPermissions.size > 0) {
+        const optionalList = Array.from(optionalPermissions).map((p) => p.toString());
+        searchParams.append("opt_perms", optionalList.join(","));
+      }
+      const installationId = YouVersionPlatformConfiguration.installationId;
+      if (installationId) {
+        searchParams.append("x-yvp-installation-id", installationId);
+      }
+      url.search = searchParams.toString();
+      return url;
+    } catch (error) {
+      throw new Error(
+        `Failed to construct auth URL: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  static userURL(accessToken) {
+    if (typeof accessToken !== "string" || accessToken.trim().length === 0) {
+      throw new Error("accessToken must be a non-empty string");
+    }
+    try {
+      const url = new URL(this.baseURL);
+      url.pathname = "/auth/me";
+      const searchParams = new URLSearchParams();
+      searchParams.append("lat", accessToken);
+      url.search = searchParams.toString();
+      return url;
+    } catch (error) {
+      throw new Error(
+        `Failed to construct user URL: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+};
+
+// src/Users.ts
+var MAX_RETRY_ATTEMPTS = 3;
+var RETRY_DELAY_MS = 1e3;
+var YouVersionAPIUsers = class {
+  /**
+   * Presents the YouVersion login flow to the user and returns the login result upon completion.
+   *
+   * This function authenticates the user with YouVersion, requesting the specified required and optional permissions.
+   * The function returns a promise that resolves when the user completes or cancels the login flow,
+   * returning the login result containing the authorization code and granted permissions.
+   *
+   * @param requiredPermissions - The set of permissions that must be granted by the user for successful login.
+   * @param optionalPermissions - The set of permissions that will be requested from the user but are not required for successful login.
+   * @returns A Promise resolving to a SignInWithYouVersionResult containing the authorization code and granted permissions upon successful login.
+   * @throws An error if authentication fails or is cancelled by the user.
+   */
+  static async signIn(requiredPermissions, optionalPermissions) {
+    if (!requiredPermissions || !(requiredPermissions instanceof Set)) {
+      throw new Error("Invalid requiredPermissions: must be a Set");
+    }
+    if (!optionalPermissions || !(optionalPermissions instanceof Set)) {
+      throw new Error("Invalid optionalPermissions: must be a Set");
+    }
+    const appId = YouVersionPlatformConfiguration.appId;
+    if (!appId) {
+      throw new Error("YouVersionPlatformConfiguration.appId must be set before calling signIn");
+    }
+    const url = URLBuilder.authURL(appId, requiredPermissions, optionalPermissions);
+    const strategy = AuthenticationStrategyRegistry.get();
+    const callbackUrl = await strategy.authenticate(url);
+    const result = new SignInWithYouVersionResult(callbackUrl);
+    if (result.accessToken) {
+      YouVersionPlatformConfiguration.setAccessToken(result.accessToken);
+    }
+    return result;
+  }
+  static signOut() {
+    YouVersionPlatformConfiguration.setAccessToken(null);
+  }
+  /**
+   * Retrieves user information for the authenticated user using the provided access token.
+   *
+   * This function fetches the user's profile information from the YouVersion API, decoding it into a YouVersionUserInfo model.
+   *
+   * @param accessToken - The access token obtained from the login process.
+   * @returns A Promise resolving to a YouVersionUserInfo object containing the user's profile information.
+   * @throws An error if the URL is invalid, the network request fails, or the response cannot be decoded.
+   */
+  static async userInfo(accessToken) {
+    if (!accessToken || typeof accessToken !== "string") {
+      throw new Error("Invalid access token: must be a non-empty string");
+    }
+    if (YouVersionPlatformConfiguration.isPreviewMode && accessToken === "preview") {
+      return YouVersionPlatformConfiguration.previewUserInfo || new YouVersionUserInfo({
+        first_name: "Preview",
+        last_name: "User",
+        id: "preview-user",
+        avatar_url: void 0
+      });
+    }
+    const url = URLBuilder.userURL(accessToken);
+    const request = YouVersionAPI.addStandardHeaders(url);
+    let lastError = null;
+    for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
+      try {
+        const response = await fetch(request);
+        if (response.status === 401) {
+          throw new Error(
+            "Authentication failed: Invalid or expired access token. Please sign in again."
+          );
+        }
+        if (response.status === 403) {
+          throw new Error("Access denied: Insufficient permissions to retrieve user information");
+        }
+        if (response.status !== 200) {
+          throw new Error(
+            `Failed to retrieve user information: Server responded with status ${response.status}`
+          );
+        }
+        const data = await response.json();
+        return data;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error("Failed to parse server response");
+        if (error instanceof Error && (error.message.includes("401") || error.message.includes("403"))) {
+          throw error;
+        }
+        if (attempt < MAX_RETRY_ATTEMPTS) {
+          await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS * attempt));
+          continue;
+        }
+      }
+    }
+    throw lastError || new Error("Failed to retrieve user information after multiple attempts");
+  }
+};
+
+// src/utils/constants.ts
+var BOOK_IDS = [
+  "GEN",
+  "EXO",
+  "LEV",
+  "NUM",
+  "DEU",
+  "JOS",
+  "JDG",
+  "RUT",
+  "1SA",
+  "2SA",
+  "1KI",
+  "2KI",
+  "1CH",
+  "2CH",
+  "EZR",
+  "NEH",
+  "EST",
+  "JOB",
+  "PSA",
+  "PRO",
+  "ECC",
+  "SNG",
+  "ISA",
+  "JER",
+  "LAM",
+  "EZK",
+  "DAN",
+  "HOS",
+  "JOL",
+  "AMO",
+  "OBA",
+  "JON",
+  "MIC",
+  "NAM",
+  "HAB",
+  "ZEP",
+  "HAG",
+  "ZEC",
+  "MAL",
+  "MAT",
+  "MRK",
+  "LUK",
+  "JHN",
+  "ACT",
+  "ROM",
+  "1CO",
+  "2CO",
+  "GAL",
+  "EPH",
+  "PHP",
+  "COL",
+  "1TH",
+  "2TH",
+  "1TI",
+  "2TI",
+  "TIT",
+  "PHM",
+  "HEB",
+  "JAS",
+  "1PE",
+  "2PE",
+  "1JN",
+  "2JN",
+  "3JN",
+  "JUD",
+  "REV",
+  // dc (Apocrypha) books
+  "TOB",
+  "JDT",
+  "ESG",
+  "WIS",
+  "SIR",
+  "BAR",
+  "LJE",
+  "S3Y",
+  "SUS",
+  "BEL",
+  "1MA",
+  "2MA",
+  "3MA",
+  "4MA",
+  "1ES",
+  "2ES",
+  "MAN",
+  "PS2",
+  "ODA",
+  "PSS",
+  "3ES",
+  "EZA",
+  "5EZ",
+  "6EZ",
+  "DAG",
+  "PS3",
+  "2BA",
+  "LBA",
+  "JUB",
+  "ENO",
+  "1MQ",
+  "2MQ",
+  "3MQ",
+  "REP",
+  "4BA",
+  "LAO",
+  // Luke-Acts combo, treated canonically as New Testament
+  "LKA"
+];
+var BOOK_CANON = {
+  GEN: "ot",
+  EXO: "ot",
+  LEV: "ot",
+  NUM: "ot",
+  DEU: "ot",
+  JOS: "ot",
+  JDG: "ot",
+  RUT: "ot",
+  "1SA": "ot",
+  "2SA": "ot",
+  "1KI": "ot",
+  "2KI": "ot",
+  "1CH": "ot",
+  "2CH": "ot",
+  EZR: "ot",
+  NEH: "ot",
+  EST: "ot",
+  JOB: "ot",
+  PSA: "ot",
+  PRO: "ot",
+  ECC: "ot",
+  SNG: "ot",
+  ISA: "ot",
+  JER: "ot",
+  LAM: "ot",
+  EZK: "ot",
+  DAN: "ot",
+  HOS: "ot",
+  JOL: "ot",
+  AMO: "ot",
+  OBA: "ot",
+  JON: "ot",
+  MIC: "ot",
+  NAM: "ot",
+  HAB: "ot",
+  ZEP: "ot",
+  HAG: "ot",
+  ZEC: "ot",
+  MAL: "ot",
+  MAT: "nt",
+  MRK: "nt",
+  LUK: "nt",
+  JHN: "nt",
+  ACT: "nt",
+  ROM: "nt",
+  "1CO": "nt",
+  "2CO": "nt",
+  GAL: "nt",
+  EPH: "nt",
+  PHP: "nt",
+  COL: "nt",
+  "1TH": "nt",
+  "2TH": "nt",
+  "1TI": "nt",
+  "2TI": "nt",
+  TIT: "nt",
+  PHM: "nt",
+  HEB: "nt",
+  JAS: "nt",
+  "1PE": "nt",
+  "2PE": "nt",
+  "1JN": "nt",
+  "2JN": "nt",
+  "3JN": "nt",
+  JUD: "nt",
+  REV: "nt",
+  TOB: "dc",
+  JDT: "dc",
+  ESG: "dc",
+  WIS: "dc",
+  SIR: "dc",
+  BAR: "dc",
+  LJE: "dc",
+  S3Y: "dc",
+  SUS: "dc",
+  BEL: "dc",
+  "1MA": "dc",
+  "2MA": "dc",
+  "3MA": "dc",
+  "4MA": "dc",
+  "1ES": "dc",
+  "2ES": "dc",
+  MAN: "dc",
+  PS2: "dc",
+  ODA: "dc",
+  PSS: "dc",
+  "3ES": "dc",
+  EZA: "dc",
+  "5EZ": "dc",
+  "6EZ": "dc",
+  DAG: "dc",
+  PS3: "dc",
+  "2BA": "dc",
+  LBA: "dc",
+  JUB: "dc",
+  ENO: "dc",
+  "1MQ": "dc",
+  "2MQ": "dc",
+  "3MQ": "dc",
+  REP: "dc",
+  "4BA": "dc",
+  LAO: "dc",
+  LKA: "nt"
+  // Luke-Acts combo, treated canonically as New Testament
+};
+export {
+  ApiClient,
+  AuthClient,
+  AuthenticationStrategyRegistry,
+  BOOK_CANON,
+  BOOK_IDS,
+  BibleClient,
+  HighlightsClient,
+  LanguagesClient,
+  MemoryStorageStrategy,
+  SessionStorageStrategy,
+  SignInWithYouVersionPermission,
+  SignInWithYouVersionResult,
+  URLBuilder,
+  WebAuthenticationStrategy,
+  YouVersionAPI,
+  YouVersionAPIUsers,
+  YouVersionPlatformConfiguration,
+  YouVersionUserInfo
+};