@atproto/api 0.0.0-spaces-alpha-20260818021221

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Dual MIT/Apache-2.0 License
+
+Copyright (c) 2022-2026 Bluesky Social PBC, and Contributors
+
+Except as otherwise noted in individual files, this software is licensed under the MIT license (<http://opensource.org/licenses/MIT>), or the Apache License, Version 2.0 (<http://www.apache.org/licenses/LICENSE-2.0>).
+
+Downstream projects and end users may chose either license individually, or both together, at their discretion. The motivation for this dual-licensing is the additional software patent assurance provided by Apache 2.0.

package/OAUTH.md

@@ -0,0 +1,286 @@
+# OAuth Client Quickstart
+
+This document describes how to implement OAuth based authentication in a
+browser-based Single Page App (SPA), to communicate with
+[atproto](https://atproto.com) API services.
+
+## Prerequisites
+
+- You need a web server - or at the very least a static file server - to host your SPA.
+
+> [!TIP]
+>
+> During development, you can use a local server to host your client metadata.
+> You will need to use a tunneling service like [ngrok](https://ngrok.com/) to
+> make your local server accessible from the internet.
+
+> [!TIP]
+>
+> You can use a service like [GitHub Pages](https://pages.github.com/) to host
+> your client metadata and SPA for free.
+
+- You must be able to build and deploy a SPA to your server.
+
+## Step 1: Create your client metadata
+
+Based on your hosting server endpoint, you will first need to choose a
+`client_id`. That `client_id` will be used to identify your client to
+Authorization Servers. A `client_id` must be a URL pointing to a JSON file
+which contains your client metadata. The client metadata **must** contain a
+`client_id` that is the URL used to access the metadata.
+
+Here is an example client metadata.
+
+```json
+{
+  "client_id": "https://example.com/client-metadata.json",
+  "client_name": "Example atproto Browser App",
+  "client_uri": "https://example.com",
+  "logo_uri": "https://example.com/logo.png",
+  "tos_uri": "https://example.com/tos",
+  "policy_uri": "https://example.com/policy",
+  "redirect_uris": ["https://example.com/callback"],
+  "scope": "atproto",
+  "grant_types": ["authorization_code", "refresh_token"],
+  "response_types": ["code"],
+  "token_endpoint_auth_method": "none",
+  "application_type": "web",
+  "dpop_bound_access_tokens": true
+}
+```
+
+- `redirect_uris`: An array of URLs that will be used as the redirect URIs for
+  the OAuth flow. This should typically contain a single URL that points to a
+  page on your SPA that will handle the OAuth response. This URL must be HTTPS.
+
+- `client_id`: The URL where the client metadata is hosted. This field must be
+  the exact same as the URL used to access the metadata.
+
+- `client_name`: The name of your client. Will be displayed to the user during
+  the authentication process.
+
+- `client_uri`: The URL of your client. Whether or not this value is actually
+  displayed / used is up to the Authorization Server.
+
+- `logo_uri`: The URL of your client's logo. Should be displayed to the user
+  during the authentication process. Whether your logo is actually displayed
+  during the authentication process or not is up to the Authorization Server.
+
+- `tos_uri`: The URL of your client's terms of service. Will be displayed to
+  the user during the authentication process.
+
+- `policy_uri`: The URL of your client's privacy policy. Will be displayed to
+  the user during the authentication process.
+
+- If you don't want or need the user to stay authenticated for long periods
+  (better for security), you can remove `refresh_token` from the `grant_types`.
+
+> [!NOTE]
+>
+> To mitigate phishing attacks, the Authentication Server will typically _not_
+> display the `client_uri` or `logo_uri` to the user. If you don't see your logo
+> or client name during the authentication process, don't worry. This is normal.
+> The `client_name` _is_ generally displayed for all clients.
+
+Upload this JSON file so that it is accessible at the URL you chose for your
+`client_id`.
+
+## Step 2: Setup your SPA
+
+Start by setting up your SPA. You can use any framework you like, or none at
+all. In this example, we will use TypeScript and Parcel, with plain JavaScript.
+
+```bash
+npm init -y
+npm install --save-dev @atproto/oauth-client-browser
+npm install --save-dev @atproto/api
+npm install --save-dev parcel
+npm install --save-dev parcel-reporter-static-files-copy
+mkdir -p src
+mkdir -p static
+```
+
+Create a `.parcelrc` file with the following (exact) content:
+
+```json
+{
+  "extends": ["@parcel/config-default"],
+  "reporters": ["...", "parcel-reporter-static-files-copy"]
+}
+```
+
+Create an `src/index.html` file with the following content:
+
+```html
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>My First OAuth App</title>
+    <script type="module" src="app.ts"></script>
+  </head>
+  <body>
+    Loading...
+  </body>
+</html>
+```
+
+And an `src/app.ts` file, with the following content:
+
+```typescript
+console.log('Hello from atproto OAuth example app!')
+```
+
+Start the app in development mode:
+
+```bash
+npx parcel src/index.html
+```
+
+In another terminal, open a tunnel to your local server:
+
+```bash
+ngrok http 1234
+```
+
+Create a `static/client-metadata.json` file with the client metadata you created
+in [Step 1](#step-1-create-your-client-metadata). Use the hostname provided by
+ngrok as the `client_id`:
+
+```json
+{
+  "client_id": "https://<RANDOM_VALUE>.ngrok.app/client-metadata.json",
+  "client_name": "My First atproto OAuth App",
+  "client_uri": "https://<RANDOM_VALUE>.ngrok.app",
+  "redirect_uris": ["https://<RANDOM_VALUE>.ngrok.app/"],
+  "grant_types": ["authorization_code"],
+  "response_types": ["code"],
+  "token_endpoint_auth_method": "none",
+  "application_type": "web",
+  "dpop_bound_access_tokens": true
+}
+```
+
+## Step 3: Implement the OAuth flow
+
+Replace the content of the `src/app.ts` file, with the following content:
+
+```typescript
+import { Agent } from '@atproto/api'
+import { BrowserOAuthClient } from '@atproto/oauth-client-browser'
+
+async function main() {
+  const oauthClient = await BrowserOAuthClient.load({
+    clientId: '<YOUR_CLIENT_ID>',
+    handleResolver: 'https://bsky.social/',
+  })
+
+  // TO BE CONTINUED
+}
+
+document.addEventListener('DOMContentLoaded', main)
+```
+
+> [!CAUTION]
+>
+> Using Bluesky-hosted services for handle resolution (eg, the `bsky.social`
+> endpoint) will leak both user IP addresses and handle identifier to Bluesky,
+> a third party. While Bluesky has a declared privacy policy, both developers
+> and users of applications need to be informed of and aware of the privacy
+> implications of this arrangement. Application developers are encouraged to
+> improve user privacy by operating their own handle resolution service when
+> possible. If you are a PDS self-hoster, you can use your PDS's URL for
+> `handleResolver`.
+
+The `oauthClient` is now configured to communicate with the user's
+Authorization Service. You can now initialize it in order to detect if the user
+is already authenticated. Replace the `// TO BE CONTINUED` comment with the
+following code:
+
+```typescript
+const result = await oauthClient.init()
+
+if (result) {
+  if ('state' in result) {
+    console.log('The user was just redirected back from the authorization page')
+  }
+
+  console.log(`The user is currently signed in as ${result.session.did}`)
+}
+
+const session = result?.session
+
+// TO BE CONTINUED
+```
+
+At this point you can detect if the user is already authenticated or not (by
+checking if `session` is `undefined`).
+
+Let's initiate an authentication flow if the user is not authenticated. Replace
+the `// TO BE CONTINUED` comment with the following code:
+
+```typescript
+if (!session) {
+  const handle = prompt('Enter your atproto handle to authenticate')
+  if (!handle) throw new Error('Authentication process canceled by the user')
+
+  const url = await oauthClient.authorize(handle)
+
+  // Redirect the user to the authorization page
+  window.open(url, '_self', 'noopener')
+
+  // Protect against browser's back-forward cache
+  await new Promise<never>((resolve, reject) => {
+    setTimeout(
+      reject,
+      10_000,
+      new Error('User navigated back from the authorization page'),
+    )
+  })
+}
+
+// TO BE CONTINUED
+```
+
+At this point in the script, the user **will** be authenticated. Authenticated
+API calls can be made using the `session`. The `session` can be used to instantiate the
+`Agent` class from `@atproto/api`. Let's make a simple call to the API to
+retrieve the user's profile. Replace the `// TO BE CONTINUED` comment with the
+following code:
+
+```typescript
+if (session) {
+  const agent = new Agent(session)
+
+  const fetchProfile = async () => {
+    const profile = await agent.getProfile({ actor: agent.did })
+    return profile.data
+  }
+
+  // Update the user interface
+
+  document.body.textContent = `Authenticated as ${agent.did}`
+
+  const profileBtn = document.createElement('button')
+  document.body.appendChild(profileBtn)
+  profileBtn.textContent = 'Fetch Profile'
+  profileBtn.onclick = async () => {
+    const profile = await fetchProfile()
+    outputPre.textContent = JSON.stringify(profile, null, 2)
+  }
+
+  const logoutBtn = document.createElement('button')
+  document.body.appendChild(logoutBtn)
+  logoutBtn.textContent = 'Logout'
+  logoutBtn.onclick = async () => {
+    await session.signOut()
+    window.location.reload()
+  }
+
+  const outputPre = document.createElement('pre')
+  document.body.appendChild(outputPre)
+}
+```
+
+[API]: ./README.md

package/README.md

@@ -0,0 +1,371 @@
+# ATP API
+
+This API is a client for ATProtocol servers. It communicates using HTTP. It includes:
+
+- ✔️ APIs for ATProto and Bluesky.
+- ✔️ Validation and complete typescript types.
+- ✔️ Session management.
+- ✔️ A RichText library.
+
+> [!Note]
+>
+> We recommend using [lex](https://github.com/bluesky-social/atproto/tree/main/packages/lex/lex), our type-safe SDK with Lexicon code generation, for all new projects.
+
+## Getting started
+
+First install the package:
+
+```sh
+yarn add @atproto/api
+```
+
+Then in your application:
+
+```typescript
+import { Agent, CredentialSession } from '@atproto/api'
+
+const session = new CredentialSession(new URL('https://bsky.social'))
+await session.login(account)
+const agent = new Agent(session)
+```
+
+## Usage
+
+### Session management
+
+You'll need an authenticated session for most API calls. There are two ways to
+manage sessions:
+
+1. [App password based session management](#app-password-based-session-management)
+2. [OAuth based session management](#oauth-based-session-management)
+
+#### App password based session management
+
+Username / password based authentication can be performed using the `Agent`
+class.
+
+> [!CAUTION]
+>
+> This method is deprecated in favor of OAuth based session management. It is
+> recommended to use OAuth based session management (through the
+> `@atproto/oauth-client-*` packages).
+
+```typescript
+import { Agent, CredentialSession, type AtpAgentLoginOpts } from '@atproto/api'
+
+// Configure connection to the server with authentification
+const account: AtpAgentLoginOpts = {
+  identifier: 'your.bsky.social',
+  password: 'xxxx-xxxx-xxxx-xxxx',
+}
+
+async function authenticate(account: AtpAgentLoginOpts): Promise<Agent> {
+  const session = new CredentialSession(new URL('https://example.com'))
+  await session.login(account)
+  const agent = new Agent(session)
+  return agent
+}
+
+;(async () => {
+  console.log('Authenticating...')
+  const agent = await authenticate(account)
+  console.log(`Authenticated as from: ${agent.sessionManager.did}`)
+})()
+```
+
+#### OAuth based session management
+
+Depending on the environment used by your application, different OAuth clients
+are available:
+
+- [@atproto/oauth-client-browser](https://www.npmjs.com/package/@atproto/oauth-client-browser):
+  for the browser.
+- [@atproto/oauth-client-node](https://www.npmjs.com/package/@atproto/oauth-client-node): for
+  Node.js.
+- [@atproto/oauth-client](https://www.npmjs.com/package/@atproto/oauth-client):
+  Lower level; compatible with most JS engines.
+
+Every `@atproto/oauth-client-*` implementation has a different way to obtain an
+`OAuthSession` instance that can be used to instantiate an `Agent` (from
+`@atproto/api`). Here is an example restoring a previously saved session:
+
+```typescript
+import { Agent } from '@atproto/api'
+import { OAuthClient } from '@atproto/oauth-client'
+
+const oauthClient = new OAuthClient({
+  // ...
+})
+
+const oauthSession = await oauthClient.restore('did:plc:123')
+
+// Instantiate the api Agent using an OAuthSession
+const agent = new Agent(oauthSession)
+```
+
+### API calls
+
+The agent includes methods for many common operations, including:
+
+```typescript
+// The DID of the user currently authenticated (or undefined)
+agent.did
+agent.accountDid // Throws if the user is not authenticated
+
+// Feeds and content
+await agent.getTimeline(params, opts)
+await agent.getAuthorFeed(params, opts)
+await agent.getPostThread(params, opts)
+await agent.getPost(params)
+await agent.getPosts(params, opts)
+await agent.getLikes(params, opts)
+await agent.getRepostedBy(params, opts)
+await agent.post(record)
+await agent.deletePost(postUri)
+await agent.like(uri, cid)
+await agent.deleteLike(likeUri)
+await agent.repost(uri, cid)
+await agent.deleteRepost(repostUri)
+await agent.uploadBlob(data, opts)
+
+// Social graph
+await agent.getFollows(params, opts)
+await agent.getFollowers(params, opts)
+await agent.follow(did)
+await agent.deleteFollow(followUri)
+
+// Actors
+await agent.getProfile(params, opts)
+await agent.upsertProfile(updateFn)
+await agent.getProfiles(params, opts)
+await agent.getSuggestions(params, opts)
+await agent.searchActors(params, opts)
+await agent.searchActorsTypeahead(params, opts)
+await agent.mute(did)
+await agent.unmute(did)
+await agent.muteModList(listUri)
+await agent.unmuteModList(listUri)
+await agent.blockModList(listUri)
+await agent.unblockModList(listUri)
+
+// Notifications
+await agent.listNotifications(params, opts)
+await agent.countUnreadNotifications(params, opts)
+await agent.updateSeenNotifications()
+
+// Identity
+await agent.resolveHandle(params, opts)
+await agent.updateHandle(params, opts)
+
+// Legacy: Session management should be performed through the SessionManager
+// rather than the Agent instance.
+if (agent instanceof AtpAgent) {
+  // AtpAgent instances support using different sessions during their lifetime
+  await agent.createAccount({ ... }) // session a
+  await agent.login({ ... }) // session b
+  await agent.resumeSession(savedSession) // session c
+}
+```
+
+### Validation and types
+
+The package includes a complete types system which includes validation and type-guards. For example, to validate a post record:
+
+```typescript
+import { AppBskyFeedPost } from '@atproto/api'
+
+const post = {...}
+if (AppBskyFeedPost.isRecord(post)) {
+  // typescript now recognizes `post` as a AppBskyFeedPost.Record
+  // however -- we still need to validate it
+  const res = AppBskyFeedPost.validateRecord(post)
+  if (res.success) {
+    // a valid record
+  } else {
+    // something is wrong
+    console.log(res.error)
+  }
+}
+```
+
+### Rich text
+
+Some records (ie posts) use the `app.bsky.richtext` lexicon. At the moment richtext is only used for links and mentions, but it will be extended over time to include bold, italic, and so on.
+
+ℹ️ It is **strongly** recommended to use this package's `RichText` library. Javascript encodes strings in utf16 while the protocol (and most other programming environments) use utf8. Converting between the two is challenging, but `RichText` handles that for you.
+
+```typescript
+import { RichText } from '@atproto/api'
+
+// creating richtext
+const rt = new RichText({
+  text: 'Hello @alice.com, check out this link: https://example.com',
+})
+await rt.detectFacets(agent) // automatically detects mentions and links
+const postRecord = {
+  $type: 'app.bsky.feed.post',
+  text: rt.text,
+  facets: rt.facets,
+  createdAt: new Date().toISOString(),
+}
+
+// rendering as markdown
+let markdown = ''
+for (const segment of rt.segments()) {
+  if (segment.isLink()) {
+    markdown += `[${segment.text}](${segment.link?.uri})`
+  } else if (segment.isMention()) {
+    markdown += `[${segment.text}](https://my-bsky-app.com/user/${segment.mention?.did})`
+  } else {
+    markdown += segment.text
+  }
+}
+
+// calculating string lengths
+const rt2 = new RichText({ text: 'Hello' })
+console.log(rt2.length) // => 5
+console.log(rt2.graphemeLength) // => 5
+const rt3 = new RichText({ text: '👨‍👩‍👧‍👧' })
+console.log(rt3.length) // => 25
+console.log(rt3.graphemeLength) // => 1
+```
+
+### Moderation
+
+Applying the moderation system is a challenging task, but we've done our best to simplify it for you. The Moderation API helps handle a wide range of tasks, including:
+
+- Moderator labeling
+- User muting (including mutelists)
+- User blocking
+- Mutewords
+- Hidden posts
+
+For more information, see the [Moderation Documentation](./docs/moderation.md).
+
+```typescript
+import { moderatePost } from '@atproto/api'
+
+// First get the user's moderation prefs and their label definitions
+// =
+
+const prefs = await agent.getPreferences()
+const labelDefs = await agent.getLabelDefinitions(prefs)
+
+// We call the appropriate moderation function for the content
+// =
+
+const postMod = moderatePost(postView, {
+  userDid: agent.session.did,
+  moderationPrefs: prefs.moderationPrefs,
+  labelDefs,
+})
+
+// We then use the output to decide how to affect rendering
+// =
+
+// in feeds
+if (postMod.ui('contentList').filter) {
+  // don't include in feeds
+}
+if (postMod.ui('contentList').blur) {
+  // render the whole object behind a cover (use postMod.ui('contentList').blurs to explain)
+  if (postMod.ui('contentList').noOverride) {
+    // do not allow the cover the be removed
+  }
+}
+if (postMod.ui('contentList').alert || postMod.ui('contentList').inform) {
+  // render warnings on the post
+  // find the warnings in postMod.ui('contentList').alerts and postMod.ui('contentList').informs
+}
+
+// viewed directly
+if (postMod.ui('contentView').filter) {
+  // don't include in feeds
+}
+if (postMod.ui('contentView').blur) {
+  // render the whole object behind a cover (use postMod.ui('contentView').blurs to explain)
+  if (postMod.ui('contentView').noOverride) {
+    // do not allow the cover the be removed
+  }
+}
+if (postMod.ui('contentView').alert || postMod.ui('contentView').inform) {
+  // render warnings on the post
+  // find the warnings in postMod.ui('contentView').alerts and postMod.ui('contentView').informs
+}
+
+// post embeds in all contexts
+if (postMod.ui('contentMedia').blur) {
+  // render the whole object behind a cover (use postMod.ui('contentMedia').blurs to explain)
+  if (postMod.ui('contentMedia').noOverride) {
+    // do not allow the cover the be removed
+  }
+}
+```
+
+## Advanced
+
+### Advanced API calls
+
+The methods above are convenience wrappers. It covers most but not all available methods.
+
+The AT Protocol identifies methods and records with reverse-DNS names. You can use them on the agent as well:
+
+```typescript
+const res1 = await agent.com.atproto.repo.createRecord({
+  did: alice.did,
+  collection: 'app.bsky.feed.post',
+  record: {
+    $type: 'app.bsky.feed.post',
+    text: 'Hello, world!',
+    createdAt: new Date().toISOString(),
+  },
+})
+const res2 = await agent.com.atproto.repo.listRecords({
+  repo: alice.did,
+  collection: 'app.bsky.feed.post',
+})
+
+const res3 = await agent.app.bsky.feed.post.create(
+  { repo: alice.did },
+  {
+    text: 'Hello, world!',
+    createdAt: new Date().toISOString(),
+  },
+)
+const res4 = await agent.app.bsky.feed.post.list({ repo: alice.did })
+```
+
+### Non-browser configuration
+
+If your environment doesn't have a built-in `fetch` implementation, you'll need
+to provide one. This will typically be done through a polyfill.
+
+### Bring your own fetch
+
+If you want to provide your own `fetch` implementation, you can do so by
+instantiating the sessionManager with a custom fetch implementation:
+
+```typescript
+import { AtpAgent } from '@atproto/api'
+
+const myFetch = (input: RequestInfo | URL, init?: RequestInit) => {
+  console.log('requesting', input)
+  const response = await globalThis.fetch(input, init)
+  console.log('got response', response)
+  return response
+}
+
+const agent = new AtpAgent({
+  service: 'https://example.com',
+  fetch: myFetch,
+})
+```
+
+## License
+
+This project is dual-licensed under MIT and Apache 2.0 terms:
+
+- MIT license ([LICENSE-MIT.txt](https://github.com/bluesky-social/atproto/blob/main/LICENSE-MIT.txt) or http://opensource.org/licenses/MIT)
+- Apache License, Version 2.0, ([LICENSE-APACHE.txt](https://github.com/bluesky-social/atproto/blob/main/LICENSE-APACHE.txt) or http://www.apache.org/licenses/LICENSE-2.0)
+
+Downstream projects and end users may chose either license individually, or both together, at their discretion. The motivation for this dual-licensing is the additional software patent assurance provided by Apache 2.0.

package/dist/age-assurance.d.ts

@@ -0,0 +1,33 @@
+import { AppBskyAgeassuranceDefs } from './client/index.js';
+export type AgeAssuranceRuleID = Exclude<AppBskyAgeassuranceDefs.ConfigRegionRuleDefault['$type'] | AppBskyAgeassuranceDefs.ConfigRegionRuleIfDeclaredOverAge['$type'] | AppBskyAgeassuranceDefs.ConfigRegionRuleIfDeclaredUnderAge['$type'] | AppBskyAgeassuranceDefs.ConfigRegionRuleIfAssuredOverAge['$type'] | AppBskyAgeassuranceDefs.ConfigRegionRuleIfAssuredUnderAge['$type'] | AppBskyAgeassuranceDefs.ConfigRegionRuleIfAccountNewerThan['$type'] | AppBskyAgeassuranceDefs.ConfigRegionRuleIfAccountOlderThan['$type'], undefined>;
+export declare const ageAssuranceRuleIDs: Record<string, AgeAssuranceRuleID>;
+/**
+ * Returns the first matched region configuration based on the provided
+ * filters. Region configurations that declare `platforms` only match when the
+ * provided platform is included in that list. If no platform filter is
+ * provided, platform restrictions are ignored.
+ */
+export declare function getAgeAssuranceRegionConfig(config: AppBskyAgeassuranceDefs.Config, filters: {
+    countryCode: string;
+    regionCode?: string;
+    platform?: string;
+}): AppBskyAgeassuranceDefs.ConfigRegion | undefined;
+export declare function computeAgeAssuranceRegionAccess(region: AppBskyAgeassuranceDefs.ConfigRegion, data: {
+    /**
+     * The account creation date in ISO 8601 format. Only checked if we
+     * don't have an assured age, such as on the client.
+     */
+    accountCreatedAt?: string;
+    /**
+     * The user's declared age
+     */
+    declaredAge?: number;
+    /**
+     * The user's minimum age as assured by a trusted third party.
+     */
+    assuredAge?: number;
+} | undefined): {
+    access: AppBskyAgeassuranceDefs.Access;
+    reason: AgeAssuranceRuleID;
+} | undefined;
+//# sourceMappingURL=age-assurance.d.ts.map

package/dist/age-assurance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"age-assurance.d.ts","sourceRoot":"","sources":["../src/age-assurance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAG3D,MAAM,MAAM,kBAAkB,GAAG,OAAO,CACpC,uBAAuB,CAAC,uBAAuB,CAAC,OAAO,CAAC,GACxD,uBAAuB,CAAC,iCAAiC,CAAC,OAAO,CAAC,GAClE,uBAAuB,CAAC,kCAAkC,CAAC,OAAO,CAAC,GACnE,uBAAuB,CAAC,gCAAgC,CAAC,OAAO,CAAC,GACjE,uBAAuB,CAAC,iCAAiC,CAAC,OAAO,CAAC,GAClE,uBAAuB,CAAC,kCAAkC,CAAC,OAAO,CAAC,GACnE,uBAAuB,CAAC,kCAAkC,CAAC,OAAO,CAAC,EACrE,SAAS,CACV,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAQlE,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,uBAAuB,CAAC,MAAM,EACtC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,GACA,uBAAuB,CAAC,YAAY,GAAG,SAAS,CAclD;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,uBAAuB,CAAC,YAAY,EAC5C,IAAI,EACA;IACE;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,GACD,SAAS,GAEX;IACE,MAAM,EAAE,uBAAuB,CAAC,MAAM,CAAA;IACtC,MAAM,EAAE,kBAAkB,CAAA;CAC3B,GACD,SAAS,CAsEZ"}