@draftlab/auth 0.15.0 → 0.16.0

package/dist/types/provider/facebook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facebook.d.ts","sourceRoot":"","sources":["../../../src/provider/facebook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAEnE;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,mBAAmB;IAC1D;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IAEzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAE7B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAA;IAEzB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,cAAc,qEAStD,CAAA"}

package/dist/types/provider/github.d.ts

@@ -0,0 +1,220 @@
+/**
+ * GitHub authentication provider for Draft Auth.
+ * Implements OAuth 2.0 flow for authenticating users with their GitHub accounts.
+ *
+ * ## Quick Setup
+ *
+ * ```ts
+ * import { GithubProvider } from "@draftlab/auth/provider/github"
+ *
+ * export default issuer({
+ *   basePath: "/auth", // Important for callback URL
+ *   providers: {
+ *     github: GithubProvider({
+ *       clientID: process.env.GITHUB_CLIENT_ID,
+ *       clientSecret: process.env.GITHUB_CLIENT_SECRET,
+ *       scopes: ["user:email", "read:user"]
+ *     })
+ *   }
+ * })
+ * ```
+ *
+ * **Callback URL Pattern**: `{baseURL}{basePath}/{provider}/callback`
+ * - Development: `http://localhost:3000/auth/github/callback`
+ * - Production: `https://yourapp.com/auth/github/callback`
+ *
+ * Register this URL in your GitHub App/OAuth App settings.
+ *
+ * ## GitHub App vs OAuth App
+ *
+ * This provider works with both GitHub OAuth Apps and GitHub Apps:
+ *
+ * ### OAuth App (Recommended for user authentication)
+ * ```ts
+ * GithubProvider({
+ *   clientID: "your-oauth-app-client-id",
+ *   clientSecret: "your-oauth-app-client-secret",
+ *   scopes: ["user:email", "read:user"]
+ * })
+ * ```
+ *
+ * ### GitHub App (For organization-level integrations)
+ * ```ts
+ * GithubProvider({
+ *   clientID: "your-github-app-client-id",
+ *   clientSecret: "your-github-app-client-secret",
+ *   scopes: ["user:email", "read:user", "repo"]
+ * })
+ * ```
+ *
+ * ## Common Scopes
+ *
+ * - `user:email` - Access user's email addresses
+ * - `read:user` - Read user profile information
+ * - `repo` - Access public and private repositories
+ * - `public_repo` - Access public repositories only
+ * - `read:org` - Read organization membership
+ * - `gist` - Create and update gists
+ *
+ * ## User Data Access
+ *
+ * ```ts
+ * success: async (ctx, value) => {
+ *   if (value.provider === "github") {
+ *     const accessToken = value.tokenset.access
+ *
+ *     // Fetch user information
+ *     const userResponse = await fetch('https://api.github.com/user', {
+ *       headers: { Authorization: `Bearer ${accessToken}` }
+ *     })
+ *     const user = await userResponse.json()
+ *
+ *     // Fetch user emails (requires user:email scope)
+ *     const emailsResponse = await fetch('https://api.github.com/user/emails', {
+ *       headers: { Authorization: `Bearer ${accessToken}` }
+ *     })
+ *     const emails = await emailsResponse.json()
+ *
+ *     // User info: `${user.login} (${user.name})`
+ *     // Primary email: emails.find(e => e.primary)?.email
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { type Oauth2WrappedConfig } from "./oauth2";
+/**
+ * Configuration options for GitHub OAuth 2.0 provider.
+ * Extends the base OAuth 2.0 configuration with GitHub-specific documentation.
+ */
+export interface GithubConfig extends Oauth2WrappedConfig {
+    /**
+     * GitHub OAuth App client ID or GitHub App client ID.
+     * Found in your GitHub App settings or OAuth App settings.
+     *
+     * @example
+     * ```ts
+     * {
+     *   clientID: "Iv1.a629723000043722" // OAuth App
+     *   // or
+     *   clientID: "Iv23liAG5t7VwMkUsKTi" // GitHub App
+     * }
+     * ```
+     */
+    readonly clientID: string;
+    /**
+     * GitHub OAuth App client secret or GitHub App client secret.
+     * Keep this secure and never expose it to client-side code.
+     *
+     * @example
+     * ```ts
+     * {
+     *   clientSecret: process.env.GITHUB_CLIENT_SECRET
+     * }
+     * ```
+     */
+    readonly clientSecret: string;
+    /**
+     * GitHub OAuth scopes to request access for.
+     * Determines what data and actions your app can access.
+     *
+     * @example
+     * ```ts
+     * {
+     *   scopes: [
+     *     "user:email",    // Access user email addresses
+     *     "read:user",     // Read user profile info
+     *     "public_repo",   // Access public repositories
+     *     "read:org"       // Read organization membership
+     *   ]
+     * }
+     * ```
+     */
+    readonly scopes: string[];
+    /**
+     * Additional query parameters for GitHub OAuth authorization.
+     * Useful for GitHub-specific options like restricting to organizations.
+     *
+     * @example
+     * ```ts
+     * {
+     *   query: {
+     *     allow_signup: "false",      // Disable new account creation
+     *     login: "suggested-username" // Pre-fill username field
+     *   }
+     * }
+     * ```
+     */
+    readonly query?: Record<string, string>;
+}
+/**
+ * Creates a GitHub OAuth 2.0 authentication provider.
+ * Supports both GitHub OAuth Apps and GitHub Apps for user authentication.
+ *
+ * @param config - GitHub OAuth 2.0 configuration
+ * @returns OAuth 2.0 provider configured for GitHub
+ *
+ * @example
+ * ```ts
+ * // Basic GitHub authentication
+ * const basicGithub = GithubProvider({
+ *   clientID: process.env.GITHUB_CLIENT_ID,
+ *   clientSecret: process.env.GITHUB_CLIENT_SECRET
+ * })
+ *
+ * // GitHub with specific scopes
+ * const githubWithScopes = GithubProvider({
+ *   clientID: process.env.GITHUB_CLIENT_ID,
+ *   clientSecret: process.env.GITHUB_CLIENT_SECRET,
+ *   scopes: [
+ *     "user:email",
+ *     "read:user",
+ *     "public_repo",
+ *     "read:org"
+ *   ]
+ * })
+ *
+ * // GitHub with custom authorization options
+ * const restrictedGithub = GithubProvider({
+ *   clientID: process.env.GITHUB_CLIENT_ID,
+ *   clientSecret: process.env.GITHUB_CLIENT_SECRET,
+ *   scopes: ["user:email", "read:user"],
+ *   query: {
+ *     allow_signup: "false" // Don't allow new GitHub account creation
+ *   }
+ * })
+ *
+ * // Using the access token to fetch data
+ * export default issuer({
+ *   providers: { github: githubWithScopes },
+ *   success: async (ctx, value) => {
+ *     if (value.provider === "github") {
+ *       const token = value.tokenset.access
+ *
+ *       // Get user profile
+ *       const userRes = await fetch('https://api.github.com/user', {
+ *         headers: { Authorization: `Bearer ${token}` }
+ *       })
+ *       const user = await userRes.json()
+ *
+ *       // Get user repositories (if repo scope granted)
+ *       const reposRes = await fetch('https://api.github.com/user/repos', {
+ *         headers: { Authorization: `Bearer ${token}` }
+ *       })
+ *       const repos = await reposRes.json()
+ *
+ *       return ctx.subject("user", {
+ *         githubId: user.id,
+ *         username: user.login,
+ *         email: user.email,
+ *         name: user.name,
+ *         repoCount: repos.length
+ *       })
+ *     }
+ *   }
+ * })
+ * ```
+ */
+export declare const GithubProvider: (config: GithubConfig) => import("./provider").Provider<import("./oauth2").Oauth2UserData>;
+//# sourceMappingURL=github.d.ts.map

package/dist/types/provider/github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../../src/provider/github.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AAEH,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAEnE;;;GAGG;AACH,MAAM,WAAW,YAAa,SAAQ,mBAAmB;IACxD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IAEzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAE7B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAA;IAEzB;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,YAAY,qEASlD,CAAA"}

package/dist/types/provider/gitlab.d.ts

@@ -0,0 +1,180 @@
+/**
+ * GitLab authentication provider for Draft Auth.
+ * Implements OAuth 2.0 flow for authenticating users with their GitLab accounts.
+ *
+ * ## Quick Setup
+ *
+ * ```ts
+ * import { GitlabProvider } from "@draftlab/auth/provider/gitlab"
+ *
+ * export default issuer({
+ *   basePath: "/auth", // Important for callback URL
+ *   providers: {
+ *     gitlab: GitlabProvider({
+ *       clientID: process.env.GITLAB_CLIENT_ID,
+ *       clientSecret: process.env.GITLAB_CLIENT_SECRET,
+ *       scopes: ["read_user", "read_api"]
+ *     })
+ *   }
+ * })
+ * ```
+ *
+ * **Callback URL Pattern**: `{baseURL}{basePath}/{provider}/callback`
+ * - Development: `http://localhost:3000/auth/gitlab/callback`
+ * - Production: `https://yourapp.com/auth/gitlab/callback`
+ *
+ * Register this URL in your GitLab Application settings.
+ *
+ * ## Common Scopes
+ *
+ * - `read_user` - Access user profile
+ * - `read_api` - Read-access to the API
+ * - `read_repository` - Access to project repositories
+ * - `write_repository` - Write access to repositories
+ * - `api` - Full API access
+ * - `read_user_email` - Access user email
+ *
+ * ## Self-Hosted GitLab
+ *
+ * For self-hosted GitLab instances, you can override the endpoint URLs:
+ *
+ * ```ts
+ * const selfHostedGitlab = Oauth2Provider({
+ *   clientID: process.env.GITLAB_CLIENT_ID,
+ *   clientSecret: process.env.GITLAB_CLIENT_SECRET,
+ *   scopes: ["read_user"],
+ *   type: "gitlab",
+ *   endpoint: {
+ *     authorization: "https://your-gitlab.com/oauth/authorize",
+ *     token: "https://your-gitlab.com/oauth/token"
+ *   }
+ * })
+ * ```
+ *
+ * **Callback URL Pattern**: `{baseURL}{basePath}/{provider}/callback`
+ * - Development: `http://localhost:3000/auth/gitlab/callback`
+ * - Production: `https://yourapp.com/auth/gitlab/callback`
+ *
+ * Register this URL in your GitLab Application settings.
+ *
+ * ## User Data Access
+ *
+ * ```ts
+ * success: async (ctx, value) => {
+ *   if (value.provider === "gitlab") {
+ *     const accessToken = value.tokenset.access
+ *
+ *     // Fetch user information
+ *     const userResponse = await fetch('https://gitlab.com/api/v4/user', {
+ *       headers: { Authorization: `Bearer ${accessToken}` }
+ *     })
+ *     const user = await userResponse.json()
+ *
+ *     // User info: id, username, email, name, avatar_url
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { type Oauth2WrappedConfig } from "./oauth2";
+/**
+ * Configuration options for GitLab OAuth 2.0 provider.
+ * Extends the base OAuth 2.0 configuration with GitLab-specific documentation.
+ */
+export interface GitlabConfig extends Oauth2WrappedConfig {
+    /**
+     * GitLab application client ID.
+     * Get this from your GitLab application settings.
+     *
+     * @example
+     * ```ts
+     * {
+     *   clientID: "abcdef123456"
+     * }
+     * ```
+     */
+    readonly clientID: string;
+    /**
+     * GitLab application client secret.
+     * Keep this secure and never expose it to client-side code.
+     *
+     * @example
+     * ```ts
+     * {
+     *   clientSecret: process.env.GITLAB_CLIENT_SECRET
+     * }
+     * ```
+     */
+    readonly clientSecret: string;
+    /**
+     * GitLab OAuth scopes to request access for.
+     * Determines what data and actions your app can access.
+     *
+     * @example
+     * ```ts
+     * {
+     *   scopes: [
+     *     "read_user",        // Access user profile
+     *     "read_api",         // Read-access to API
+     *     "read_repository"   // Access repositories
+     *   ]
+     * }
+     * ```
+     */
+    readonly scopes: string[];
+}
+/**
+ * Creates a GitLab OAuth 2.0 authentication provider.
+ * Allows users to authenticate using their GitLab accounts (gitlab.com or self-hosted).
+ *
+ * @param config - GitLab OAuth 2.0 configuration
+ * @returns OAuth 2.0 provider configured for GitLab
+ *
+ * @example
+ * ```ts
+ * // Basic GitLab.com authentication
+ * const basicGitlab = GitlabProvider({
+ *   clientID: process.env.GITLAB_CLIENT_ID,
+ *   clientSecret: process.env.GITLAB_CLIENT_SECRET
+ * })
+ *
+ * // GitLab with read access
+ * const gitlabWithRead = GitlabProvider({
+ *   clientID: process.env.GITLAB_CLIENT_ID,
+ *   clientSecret: process.env.GITLAB_CLIENT_SECRET,
+ *   scopes: ["read_user", "read_api"]
+ * })
+ *
+ * // Using the access token to fetch user data
+ * export default issuer({
+ *   providers: { gitlab: gitlabWithRead },
+ *   success: async (ctx, value) => {
+ *     if (value.provider === "gitlab") {
+ *       const token = value.tokenset.access
+ *
+ *       const userRes = await fetch('https://gitlab.com/api/v4/user', {
+ *         headers: { Authorization: `Bearer ${token}` }
+ *       })
+ *       const user = await userRes.json()
+ *
+ *       return ctx.subject("user", {
+ *         gitlabId: user.id,
+ *         username: user.username,
+ *         email: user.email,
+ *         name: user.name,
+ *         avatar: user.avatar_url
+ *       })
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * **Callback URL Pattern**: `{baseURL}{basePath}/{provider}/callback`
+ * - Development: `http://localhost:3000/auth/gitlab/callback`
+ * - Production: `https://yourapp.com/auth/gitlab/callback`
+ *
+ * Register this URL in your GitLab Application settings.
+ */
+export declare const GitlabProvider: (config: GitlabConfig) => import("./provider").Provider<import("./oauth2").Oauth2UserData>;
+//# sourceMappingURL=gitlab.d.ts.map

package/dist/types/provider/gitlab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitlab.d.ts","sourceRoot":"","sources":["../../../src/provider/gitlab.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAEH,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAEnE;;;GAGG;AACH,MAAM,WAAW,YAAa,SAAQ,mBAAmB;IACxD;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IAEzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAE7B;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,YAAY,qEASlD,CAAA"}

package/dist/types/provider/google.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Google OAuth 2.0 authentication provider for Draft Auth.
+ * Provides access tokens for calling Google APIs on behalf of users.
+ *
+ * ## Quick Setup
+ *
+ * ```ts
+ * import { GoogleProvider } from "@draftlab/auth/provider/google"
+ *
+ * export default issuer({
+ *   basePath: "/auth", // Important for callback URL
+ *   providers: {
+ *     google: GoogleProvider({
+ *       clientID: process.env.GOOGLE_CLIENT_ID,
+ *       clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+ *       scopes: ["profile", "email", "https://www.googleapis.com/auth/calendar.readonly"]
+ *     })
+ *   }
+ * })
+ * ```
+ *
+ * **Callback URL Pattern**: `{baseURL}{basePath}/{provider}/callback`
+ * - Development: `http://localhost:3000/auth/google/callback`
+ * - Production: `https://yourapp.com/auth/google/callback`
+ *
+ * Register this URL in your Google Cloud Console OAuth 2.0 credentials.
+ *
+ * ## Configuration Options
+ *
+ * - Access tokens for Google API calls
+ * - Refresh tokens for long-lived access
+ * - Support for offline access
+ * - Custom scopes for specific Google services
+ *
+ * ## User Data Access
+ *
+ * ```ts
+ * success: async (ctx, value) => {
+ *   if (value.provider === "google") {
+ *     // Access token for API calls: value.tokenset.access
+ *     // Refresh token (if requested): value.tokenset.refresh
+ *     // Use the access token to call Google APIs
+ *     const response = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
+ *       headers: { Authorization: `Bearer ${value.tokenset.access}` }
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { type Oauth2WrappedConfig } from "./oauth2";
+/**
+ * Configuration options for Google OAuth 2.0 provider.
+ * Extends the base OAuth 2.0 configuration with Google-specific defaults.
+ */
+export interface GoogleConfig extends Oauth2WrappedConfig {
+    /**
+     * Google OAuth 2.0 client ID from Google Cloud Console.
+     *
+     * @example
+     * ```ts
+     * {
+     *   clientID: "123456789-abc123.apps.googleusercontent.com"
+     * }
+     * ```
+     */
+    readonly clientID: string;
+    /**
+     * Google OAuth 2.0 client secret from Google Cloud Console.
+     * Required for server-side OAuth 2.0 flows.
+     *
+     * @example
+     * ```ts
+     * {
+     *   clientSecret: process.env.GOOGLE_CLIENT_SECRET
+     * }
+     * ```
+     */
+    readonly clientSecret: string;
+    /**
+     * Google OAuth 2.0 scopes to request.
+     * Common scopes include 'profile', 'email', and specific Google API scopes.
+     *
+     * @example
+     * ```ts
+     * {
+     *   scopes: [
+     *     "profile",
+     *     "email",
+     *     "https://www.googleapis.com/auth/calendar.readonly",
+     *     "https://www.googleapis.com/auth/drive.file"
+     *   ]
+     * }
+     * ```
+     */
+    readonly scopes: string[];
+    /**
+     * Additional query parameters for Google OAuth 2.0.
+     * Useful for Google-specific options like hosted domain restrictions.
+     *
+     * @example
+     * ```ts
+     * {
+     *   query: {
+     *     hd: "mycompany.com",        // Restrict to Google Workspace domain
+     *     access_type: "offline",     // Request refresh token
+     *     prompt: "consent",          // Force consent screen
+     *     include_granted_scopes: "true" // Incremental authorization
+     *   }
+     * }
+     * ```
+     */
+    readonly query?: Record<string, string>;
+}
+/**
+ * Creates a Google OAuth 2.0 authentication provider.
+ * Use this when you need access tokens to call Google APIs on behalf of the user.
+ *
+ * @param config - Google OAuth 2.0 configuration
+ * @returns OAuth 2.0 provider configured for Google
+ *
+ * @example
+ * ```ts
+ * // Basic setup for user authentication
+ * const basicGoogle = GoogleProvider({
+ *   clientID: process.env.GOOGLE_CLIENT_ID,
+ *   clientSecret: process.env.GOOGLE_CLIENT_SECRET
+ * })
+ *
+ * // Advanced setup with API access
+ * const advancedGoogle = GoogleProvider({
+ *   clientID: process.env.GOOGLE_CLIENT_ID,
+ *   clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+ *   scopes: [
+ *     "profile",
+ *     "email",
+ *     "https://www.googleapis.com/auth/calendar.readonly",
+ *     "https://www.googleapis.com/auth/drive.file"
+ *   ],
+ *   query: {
+ *     access_type: "offline",    // Get refresh token
+ *     prompt: "consent",         // Force consent for refresh token
+ *     hd: "mycompany.com"       // Restrict to company domain
+ *   }
+ * })
+ *
+ * // Use the access token for API calls
+ * success: async (ctx, value) => {
+ *   const accessToken = value.tokenset.access
+ *   const response = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events', {
+ *     headers: { Authorization: `Bearer ${accessToken}` }
+ *   })
+ * }
+ * ```
+ */
+export declare const GoogleProvider: (config: GoogleConfig) => import("./provider").Provider<import("./oauth2").Oauth2UserData>;
+//# sourceMappingURL=google.d.ts.map

package/dist/types/provider/google.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/provider/google.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAEnE;;;GAGG;AACH,MAAM,WAAW,YAAa,SAAQ,mBAAmB;IACxD;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IAEzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAE7B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAA;IAEzB;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,YAAY,qEAUlD,CAAA"}