termcast 1.3.9 → 1.3.16

package/src/release.tsx

@@ -0,0 +1,159 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { execSync, exec } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execAsync = promisify(exec)
+import {
+  compileExtension,
+  ALL_TARGETS,
+  targetToFileSuffix,
+  getArchiveExtension,
+  type CompileTarget,
+} from './compile'
+
+export interface ReleaseOptions {
+  extensionPath: string
+  single?: boolean
+}
+
+export interface ReleaseResult {
+  success: boolean
+  version: string
+  uploadedFiles: string[]
+}
+
+export async function releaseExtension({
+  extensionPath,
+  single = false,
+}: ReleaseOptions): Promise<ReleaseResult> {
+  const resolvedPath = path.resolve(extensionPath)
+
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Extension path does not exist: ${resolvedPath}`)
+  }
+
+  const packageJsonPath = path.join(resolvedPath, 'package.json')
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error(`No package.json found at: ${packageJsonPath}`)
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
+  const name = packageJson.name
+  const version = packageJson.version
+
+  if (!name) {
+    throw new Error('package.json must have a name field')
+  }
+  if (!version) {
+    throw new Error('package.json must have a version field')
+  }
+
+  const tag = `${name}@${version}`
+  console.log(`Preparing release ${tag}...`)
+
+  // Check if release already exists
+  try {
+    const checkResult = execSync(`gh release view "${tag}" --json tagName`, {
+      cwd: resolvedPath,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+    if (checkResult.includes(tag)) {
+      throw new Error(`Release ${tag} already exists. Bump the version in package.json first.`)
+    }
+  } catch (error: any) {
+    if (error.message?.includes('already exists')) {
+      throw error
+    }
+  }
+
+  // Install dependencies for all platforms
+  console.log('Installing dependencies for all platforms...')
+  execSync('bun install --os="*" --cpu="*"', {
+    cwd: resolvedPath,
+    stdio: 'inherit',
+  })
+
+  const targets: CompileTarget[] = single
+    ? ALL_TARGETS.filter((t) => t.os === process.platform && t.arch === process.arch)
+    : ALL_TARGETS
+
+  if (targets.length === 0) {
+    throw new Error(`No targets found for current platform: ${process.platform}-${process.arch}`)
+  }
+
+  const outputDir = path.join(resolvedPath, 'dist')
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true })
+  }
+
+  // Compile for all targets in parallel
+  console.log(`Compiling for ${targets.length} targets in parallel...`)
+  const compileResults = await Promise.all(
+    targets.map(async (target) => {
+      const suffix = targetToFileSuffix(target)
+      const binaryName = `${name}-${suffix}`
+      const outfile = path.join(outputDir, binaryName)
+
+      const result = await compileExtension({
+        extensionPath: resolvedPath,
+        outfile,
+        minify: true,
+        target,
+      })
+
+      console.log(`  ✓ ${path.basename(result.outfile)}`)
+
+      const archiveExt = getArchiveExtension(target)
+      const archiveName = `${name}-${suffix}${archiveExt}`
+      const archivePath = path.join(outputDir, archiveName)
+
+      if (archiveExt === '.tar.gz') {
+        await execAsync(`tar -czvf "${archiveName}" "${binaryName}"`, { cwd: outputDir })
+      } else {
+        await execAsync(`zip "${archiveName}" "${binaryName}"`, { cwd: outputDir })
+      }
+
+      fs.unlinkSync(result.outfile)
+      console.log(`  ✓ ${archiveName}`)
+
+      return archivePath
+    }),
+  )
+
+  // Create GitHub release
+  console.log(`\nCreating GitHub release ${tag}...`)
+  try {
+    execSync(`gh release create "${tag}" --title "${tag}" --notes "Release ${version}"`, {
+      cwd: resolvedPath,
+      stdio: 'inherit',
+    })
+  } catch (error: any) {
+    throw new Error(`Failed to create release: ${error.message}`)
+  }
+
+  // Upload all binaries in parallel
+  console.log('\nUploading binaries in parallel...')
+  await Promise.all(
+    compileResults.map(async (file) => {
+      const fileName = path.basename(file)
+      await execAsync(`gh release upload "${tag}" "${file}" --clobber`, {
+        cwd: resolvedPath,
+      })
+      console.log(`  ✓ ${fileName}`)
+    }),
+  )
+
+
+
+  console.log(`\n✅ Release ${tag} published successfully!`)
+  console.log(`   ${compileResults.length} binaries uploaded`)
+
+
+  return {
+    success: true,
+    version,
+    uploadedFiles: compileResults,
+  }
+}

package/src/state.tsx

@@ -26,6 +26,7 @@ interface AppState {
   extensionPath: string | null
   extensionPackageJson: RaycastPackageJson | null
   currentCommandName: string | null
+  currentCommandArguments: Record<string, string> | null
   // OAuth state
   googleAccessToken?: string
   googleIdToken?: string
@@ -43,6 +44,7 @@ export const useStore = create<AppState>(() => ({
   extensionPath: null,
   extensionPackageJson: null,
   currentCommandName: null,
+  currentCommandArguments: null,
   // OAuth state
   googleAccessToken: undefined,
   googleIdToken: undefined,

package/src/store-api/search.test.tsx

@@ -4,26 +4,17 @@ import { searchStoreListings } from './search'
 describe('searchStoreListings', () => {
   test('searches for extensions in the store', async () => {
     const results = await searchStoreListings({
-      query: 'database',
+      query: 'spiceblow-database',
       perPage: 5,
     })
 
     // Check we got results
     expect(results.data).toBeDefined()
     expect(results.data.length).toBeGreaterThan(0)
-    expect(results.data.length).toBeLessThanOrEqual(5)
 
-    // Snapshot the extension names
-    const extensionNames = results.data.map((d) => d.name).sort()
-    expect(extensionNames).toMatchInlineSnapshot(`
-          [
-            "discogs",
-            "notion",
-            "spiceblow-database",
-            "tmdb",
-            "turso",
-          ]
-        `)
+    // Verify the specific extension is found
+    const extensionNames = results.data.map((d) => d.name)
+    expect(extensionNames).toContain('spiceblow-database')
   }, 10000)
 
   test.skip('returns results when searching without a query', async () => {

package/src/theme.tsx

@@ -1,3 +1,5 @@
+import { SyntaxStyle, RGBA } from '@opentui/core'
+
 export const Theme = {
   // Text colors
   text: '#FFFFFF',
@@ -8,24 +10,47 @@ export const Theme = {
   backgroundPanel: '#1E1E1E', // Dark gray panel background
 
   // Primary/accent colors
-  primary: '#0080FF', // Blue
-  accent: '#00FF80', // Light green (was using this for dates)
+  primary: '#FFC000', // Bright golden orange
+  accent: '#FFC000', // Bright golden orange
 
   // Accessory colors (from List component)
-  info: '#0080FF', // Blue for text accessories
-  success: '#00FF80', // Green for date accessories
-  warning: '#FF8000', // Orange for tag accessories
+  info: '#FFC000', // Orange for text accessories
+  success: '#FFC000', // Orange for date accessories
+  warning: '#FFC000', // Orange for tag accessories
   error: '#FF0000', // Red for errors
 
   // Additional UI colors
   border: '#333333',
-  highlight: '#0080FF',
-  selected: '#0080FF',
+  selectedMuted: '#AA8000', // Dimmer orange for selected values when not focused
+  highlight: '#FFC000',
+  selected: '#FFC000',
   yellow: '#FFFF00', // Yellow for icons
-  link: '#0080FF', // Blue for links
+  link: '#FFC000', // Orange for links
 
   // Transparent
   transparent: undefined, // Use undefined for no background color
 } as const
 
+export const markdownSyntaxStyle = SyntaxStyle.fromStyles({
+  default: { fg: RGBA.fromHex(Theme.text) },
+  'markup.heading.1': { fg: RGBA.fromHex(Theme.primary), bold: true },
+  'markup.heading.2': { fg: RGBA.fromHex(Theme.primary), bold: true },
+  'markup.heading.3': { fg: RGBA.fromHex(Theme.primary), bold: true },
+  'markup.heading.4': { fg: RGBA.fromHex(Theme.primary), bold: true },
+  'markup.heading.5': { fg: RGBA.fromHex(Theme.primary), bold: true },
+  'markup.heading.6': { fg: RGBA.fromHex(Theme.primary), bold: true },
+  'markup.heading': { fg: RGBA.fromHex(Theme.primary), bold: true },
+  'markup.raw.block': { fg: RGBA.fromHex(Theme.accent) },
+  'markup.link.url': { fg: RGBA.fromHex(Theme.link) },
+  'markup.link.label': { fg: RGBA.fromHex(Theme.link) },
+  'markup.list': { fg: RGBA.fromHex(Theme.warning) },
+  'markup.list.checked': { fg: RGBA.fromHex(Theme.success) },
+  'markup.list.unchecked': { fg: RGBA.fromHex(Theme.textMuted) },
+  'markup.quote': { fg: RGBA.fromHex(Theme.textMuted), italic: true },
+  'punctuation.special': { fg: RGBA.fromHex(Theme.textMuted) },
+  'punctuation.delimiter': { fg: RGBA.fromHex(Theme.textMuted) },
+  'string.escape': { fg: RGBA.fromHex(Theme.warning) },
+  label: { fg: RGBA.fromHex(Theme.accent) },
+})
+
 export default Theme

package/src/utils/run-command.tsx

@@ -0,0 +1,204 @@
+import React from 'react'
+import { useStore } from 'termcast/src/state'
+import { showToast, Toast } from 'termcast/src/apis/toast'
+import { LocalStorage } from 'termcast/src/apis/localstorage'
+import { CommandArguments } from 'termcast/src/components/command-arguments'
+import { ExtensionPreferences } from 'termcast/src/components/extension-preferences'
+import type { RaycastArgument, RaycastPackageJson } from 'termcast/src/package-json'
+import type { LaunchProps } from 'termcast/src/apis/environment'
+
+export interface RunnableCommand {
+  name: string
+  title: string
+  mode: 'view' | 'no-view' | 'menu-bar'
+  arguments?: RaycastArgument[]
+  preferences?: any[]
+}
+
+export interface RunCommandOptions {
+  command: RunnableCommand
+  extensionName: string
+  packageJson?: RaycastPackageJson
+  bundledPath?: string
+  Component?: (props: LaunchProps) => any
+  push: (element: React.ReactNode) => void
+  // For dev mode, adds cache busting query param
+  cacheBustParam?: string
+}
+
+export async function runCommand(options: RunCommandOptions): Promise<void> {
+  const {
+    command,
+    extensionName,
+    packageJson,
+    bundledPath,
+    Component: BuiltInComponent,
+    push,
+    cacheBustParam,
+  } = options
+
+  // Check if command has required preferences that are missing
+  const prefsCheck = await checkRequiredPreferences({
+    command,
+    extensionName,
+    packageJson,
+    hasBuiltInComponent: !!BuiltInComponent,
+  })
+
+  if (!prefsCheck.hasRequiredPreferences) {
+    // TODO: Use replace instead of push to avoid stacking navigation
+    // Redirect to preferences with onSubmit to run command after
+    push(
+      <ExtensionPreferences
+        extensionName={extensionName}
+        commandName={
+          prefsCheck.requiredPreferences === 'command'
+            ? command.name
+            : undefined
+        }
+        onSubmit={() => {
+          runCommand(options)
+        }}
+      />,
+    )
+    return
+  }
+
+  // Check if command has arguments that need to be collected
+  const commandArgs = command.arguments || []
+  const currentArgs = useStore.getState().currentCommandArguments
+  const needsArguments = commandArgs.length > 0 && !currentArgs
+
+  if (needsArguments) {
+    push(
+      <CommandArguments
+        arguments={commandArgs}
+        commandTitle={command.title}
+        onSubmit={(args) => {
+          useStore.setState({ currentCommandArguments: args })
+          runCommand(options)
+        }}
+      />,
+    )
+    return
+  }
+
+  // Set the current command in state
+  useStore.setState({ currentCommandName: command.name })
+
+  // Get the component/function to run
+  let CommandComponent: ((props: LaunchProps) => any) | undefined
+
+  if (BuiltInComponent) {
+    CommandComponent = BuiltInComponent
+  } else if (bundledPath) {
+    const importPath = cacheBustParam
+      ? `${bundledPath}?rebuild=${cacheBustParam}`
+      : bundledPath
+    const module = await import(importPath)
+    CommandComponent = module.default
+
+    if (!CommandComponent) {
+      await showToast({
+        style: Toast.Style.Failure,
+        title: 'No default export',
+        message: `Command file ${command.name} has no default export`,
+      })
+      return
+    }
+  } else {
+    await showToast({
+      style: Toast.Style.Failure,
+      title: 'Command not available',
+      message: `Command ${command.name} has no implementation`,
+    })
+    return
+  }
+
+  // Build LaunchProps
+  const launchProps: LaunchProps = {
+    arguments: useStore.getState().currentCommandArguments || {},
+    fallbackText: undefined,
+    launchContext: undefined,
+  }
+
+  // Handle no-view commands (they export an async function, not a component)
+  if (command.mode === 'no-view') {
+    if (typeof CommandComponent === 'function') {
+      await CommandComponent(launchProps)
+    }
+    return
+  }
+
+  // For view commands, push the component
+  push(<CommandComponent {...launchProps} />)
+}
+
+async function checkRequiredPreferences({
+  command,
+  extensionName,
+  packageJson,
+  hasBuiltInComponent,
+}: {
+  command: RunnableCommand
+  extensionName: string
+  packageJson?: RaycastPackageJson
+  hasBuiltInComponent: boolean
+}): Promise<{
+  hasRequiredPreferences: boolean
+  requiredPreferences?: 'command' | 'extension'
+}> {
+  // Built-in commands or commands without packageJson don't have preferences
+  if (hasBuiltInComponent || !packageJson) {
+    return { hasRequiredPreferences: true }
+  }
+
+  // Check command-specific preferences
+  const commandDef = packageJson.commands?.find(
+    (cmd) => cmd.name === command.name,
+  )
+  const commandPrefs = commandDef?.preferences || []
+
+  // Check extension-wide preferences
+  const extensionPrefs = packageJson.preferences || []
+
+  // Get saved preferences
+  const commandPrefsKey = `preferences.${extensionName}.${command.name}`
+  const extensionPrefsKey = `preferences.${extensionName}`
+
+  const savedCommandPrefs = await LocalStorage.getItem(commandPrefsKey)
+  const savedExtensionPrefs = await LocalStorage.getItem(extensionPrefsKey)
+
+  const parsedCommandPrefs = savedCommandPrefs
+    ? JSON.parse(savedCommandPrefs as string)
+    : {}
+  const parsedExtensionPrefs = savedExtensionPrefs
+    ? JSON.parse(savedExtensionPrefs as string)
+    : {}
+
+  // Check if all required command preferences are set
+  for (const pref of commandPrefs) {
+    if (pref.required && parsedCommandPrefs[pref.name] == null) {
+      return {
+        hasRequiredPreferences: false,
+        requiredPreferences: 'command',
+      }
+    }
+  }
+
+  // Check if all required extension preferences are set
+  for (const pref of extensionPrefs) {
+    if (pref.required && parsedExtensionPrefs[pref.name] == null) {
+      return {
+        hasRequiredPreferences: false,
+        requiredPreferences: 'extension',
+      }
+    }
+  }
+
+  return { hasRequiredPreferences: true }
+}
+
+export function clearCommandArguments(): void {
+  useStore.setState({ currentCommandArguments: null })
+}

package/src/utils.tsx

@@ -1,6 +1,7 @@
 import React, { type ReactNode } from 'react'
-import { render } from '@opentui/react'
-import { Providers } from 'termcast/src/internal/providers'
+import { createRoot } from '@opentui/react'
+import { createCliRenderer } from '@opentui/core'
+import { TermcastProvider } from 'termcast/src/internal/providers'
 import path from 'node:path'
 import fs from 'node:fs'
 import os from 'node:os'
@@ -12,8 +13,9 @@ import {
 } from './package-json'
 import { logger } from './logger'
 
-export function renderWithProviders(element: ReactNode): void {
-  render(<Providers>{element}</Providers>)
+export async function renderWithProviders(element: ReactNode): Promise<void> {
+  const renderer = await createCliRenderer()
+  createRoot(renderer).render(<TermcastProvider>{element}</TermcastProvider>)
 }
 
 export type CommonProps = {

package/dist/ai.d.ts

@@ -1,104 +0,0 @@
-/**
- * AI API - Interface for AI model interactions
- *
- * Raycast Docs: https://developers.raycast.com/api-reference/ai
- *
- * The AI namespace provides methods to interact with various AI models for
- * generating text completions. It supports streaming responses and multiple
- * model providers including OpenAI, Anthropic, Google, and others.
- *
- * Key features:
- * - Stream text completions with AI.ask()
- * - Support for multiple AI models via Model enum
- * - Configurable creativity levels
- * - Abort signal support for cancellation
- * - Event-based streaming with "data" events
- *
- * Usage:
- * const stream = AI.ask("Explain quantum computing")
- * stream.on("data", (chunk) => console.log(chunk))
- * const result = await stream
- *
- * Models include GPT-4, Claude, Gemini, Llama, Mistral, and many others.
- * Creativity can be set from "none" to "maximum" or as a number 0-2.
- */
-export declare namespace AI {
-    export type Creativity = 'none' | 'low' | 'medium' | 'high' | 'maximum' | number;
-    export enum Model {
-        OpenAI_GPT4 = "openai-gpt-4",
-        'OpenAI_GPT4-turbo' = "openai-gpt-4-turbo",
-        'OpenAI_GPT4.1' = "openai-gpt-4.1",
-        'OpenAI_GPT4.1-nano' = "openai-gpt-4.1-nano",
-        'OpenAI_GPT4.1-mini' = "openai-gpt-4.1-mini",
-        OpenAI_GPT4o = "openai-gpt-4o",
-        'OpenAI_GPT4o-mini' = "openai-gpt-4o-mini",
-        'OpenAI_o3-mini' = "openai_o1-o3-mini",
-        'OpenAI_o4-mini' = "openai_o1-o4-mini",
-        OpenAI_o1 = "openai_o1-o1",
-        OpenAI_o3 = "openai_o1-o3",
-        Anthropic_Claude_Haiku = "anthropic-claude-haiku",
-        Anthropic_Claude_Opus = "anthropic-claude-opus",
-        Anthropic_Claude_Sonnet = "anthropic-claude-sonnet",
-        'Anthropic_Claude_Sonnet_3.7' = "anthropic-claude-3-7-sonnet-latest",
-        Anthropic_Claude_4_Sonnet = "anthropic-claude-sonnet-4",
-        Anthropic_Claude_4_Opus = "anthropic-claude-opus-4",
-        Mistral_Nemo = "mistral-nemo",
-        Mistral_Large = "mistral-large",
-        Mistral_Medium = "mistral-mistral-medium-latest",
-        Mistral_Small = "mistral-small",
-        Mistral_Codestral = "mistral-codestral",
-        'Llama3.3_70B' = "groq-llama-3.3-70b-versatile",
-        'Llama3.1_8B' = "llama3.1-8b",
-        'Llama3.1_405B' = "llama3.1-405b",
-        'Llama4_Scout' = "groq-meta-llama/llama-4-scout-17b-16e-instruct",
-        Perplexity_Sonar = "perplexity-sonar",
-        Perplexity_Sonar_Pro = "perplexity-sonar-pro",
-        Perplexity_Sonar_Reasoning = "perplexity-sonar-reasoning",
-        Perplexity_Sonar_Reasoning_Pro = "perplexity-sonar-reasoning-pro",
-        DeepSeek_R1 = "together-deepseek-ai/DeepSeek-R1",
-        DeepSeek_V3 = "together-deepseek-ai/DeepSeek-V3",
-        'DeepSeek_R1_Distill_Llama_3.3_70B' = "groq-deepseek-r1-distill-llama-70b",
-        'Google_Gemini_2.0_Flash' = "google-gemini-2.0-flash",
-        'Google_Gemini_2.0_Flash_Thinking' = "google-gemini-2.0-flash-thinking",
-        'Google_Gemini_2.5_Flash' = "google-gemini-2.5-flash",
-        'Google_Gemini_2.5_Pro' = "google-gemini-2.5-pro",
-        xAI_Grok_2 = "xai-grok-2-latest",
-        xAI_Grok_3 = "xai-grok-3",
-        xAI_Grok_3_Mini = "xai-grok-3-mini",
-        'OpenAI_GPT3.5-turbo-instruct' = "openai-gpt-4o-mini",
-        Llama2_70B = "llama2-70b",
-        Perplexity_Sonar_Medium_Online = "perplexity-sonar",
-        Perplexity_Sonar_Small_Online = "perplexity-sonar",
-        Codellama_70B_instruct = "codellama-70b-instruct",
-        Perplexity_Llama3_Sonar_Large = "perplexity-sonar",
-        Perplexity_Llama3_Sonar_Small = "perplexity-sonar",
-        'OpenAI_GPT3.5-turbo' = "openai-gpt-4o-mini",
-        'Llama3.1_70B' = "groq-llama-3.3-70b-versatile",
-        'Perplexity_Llama3.1_Sonar_Huge' = "perplexity-sonar-pro",
-        'Perplexity_Llama3.1_Sonar_Large' = "perplexity-sonar",
-        'Perplexity_Llama3.1_Sonar_Small' = "perplexity-sonar",
-        'Mistral_Large2' = "mistral-large",
-        'Groq_DeepSeek_R1_Distill_Llama_3.3_70B' = "groq-deepseek-r1-distill-llama-70b",
-        'Together_DeepSeek_R1' = "together-deepseek-ai/DeepSeek-R1",
-        'MixtraL_8x7B' = "mistral-nemo",
-        'Google_Gemini_1.5_Flash' = "google-gemini-1.5-flash",
-        'Google_Gemini_1.5_Pro' = "google-gemini-2.0-flash",
-        Mixtral_8x7B = "mistral-nemo",
-        'Qwen_2.5_32B' = "openai-gpt-4o-mini",
-        'OpenAI_o1-preview' = "openai_o1-o1",
-        'OpenAI_o1-mini' = "openai_o1-o1-mini",
-        Llama3_70B = "llama3-70b"
-    }
-    export type __DeprecatedModelUnion = 'openai-gpt-3.5-turbo-instruct' | 'openai-gpt-3.5-turbo' | 'openai-gpt-4' | 'openai-gpt-4-turbo' | 'anthropic-claude-haiku' | 'anthropic-claude-opus' | 'anthropic-claude-sonnet' | 'perplexity-sonar-medium-online' | 'perplexity-sonar-small-online' | 'llama2-70b' | 'mixtral-8x7b' | 'codellama-70b-instruct' | 'gpt-3.5-turbo' | 'gpt-3.5-turbo-instruct' | 'gpt-4' | 'text-davinci-003';
-    export type AskOptions = {
-        creativity?: Creativity;
-        model?: Model | __DeprecatedModelUnion;
-        signal?: AbortSignal;
-    };
-    interface AskStream extends Promise<string> {
-        on(event: 'data', listener: (chunk: string) => void): void;
-    }
-    export function ask(prompt: string, options?: AskOptions): AskStream;
-    export {};
-}
-//# sourceMappingURL=ai.d.ts.map

package/dist/ai.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../src/ai.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAKH,yBAAiB,EAAE,CAAC;IAClB,MAAM,MAAM,UAAU,GAClB,MAAM,GACN,KAAK,GACL,QAAQ,GACR,MAAM,GACN,SAAS,GACT,MAAM,CAAA;IAEV,MAAM,MAAM,KAAK;QACf,WAAW,iBAAiB;QAC5B,mBAAmB,uBAAuB;QAC1C,eAAe,mBAAmB;QAClC,oBAAoB,wBAAwB;QAC5C,oBAAoB,wBAAwB;QAC5C,YAAY,kBAAkB;QAC9B,mBAAmB,uBAAuB;QAC1C,gBAAgB,sBAAsB;QACtC,gBAAgB,sBAAsB;QACtC,SAAS,iBAAiB;QAC1B,SAAS,iBAAiB;QAC1B,sBAAsB,2BAA2B;QACjD,qBAAqB,0BAA0B;QAC/C,uBAAuB,4BAA4B;QACnD,6BAA6B,uCAAuC;QACpE,yBAAyB,8BAA8B;QACvD,uBAAuB,4BAA4B;QACnD,YAAY,iBAAiB;QAC7B,aAAa,kBAAkB;QAC/B,cAAc,kCAAkC;QAChD,aAAa,kBAAkB;QAC/B,iBAAiB,sBAAsB;QACvC,cAAc,iCAAiC;QAC/C,aAAa,gBAAgB;QAC7B,eAAe,kBAAkB;QACjC,cAAc,mDAAmD;QACjE,gBAAgB,qBAAqB;QACrC,oBAAoB,yBAAyB;QAC7C,0BAA0B,+BAA+B;QACzD,8BAA8B,mCAAmC;QACjE,WAAW,qCAAqC;QAChD,WAAW,qCAAqC;QAChD,mCAAmC,uCAAuC;QAC1E,yBAAyB,4BAA4B;QACrD,kCAAkC,qCAAqC;QACvE,yBAAyB,4BAA4B;QACrD,uBAAuB,0BAA0B;QACjD,UAAU,sBAAsB;QAChC,UAAU,eAAe;QACzB,eAAe,oBAAoB;QAEnC,8BAA8B,uBAAuB;QACrD,UAAU,eAAe;QACzB,8BAA8B,qBAAqB;QACnD,6BAA6B,qBAAqB;QAClD,sBAAsB,2BAA2B;QACjD,6BAA6B,qBAAqB;QAClD,6BAA6B,qBAAqB;QAClD,qBAAqB,uBAAuB;QAC5C,cAAc,iCAAiC;QAC/C,gCAAgC,yBAAyB;QACzD,iCAAiC,qBAAqB;QACtD,iCAAiC,qBAAqB;QACtD,gBAAgB,kBAAkB;QAClC,wCAAwC,uCAAuC;QAC/E,sBAAsB,qCAAqC;QAC3D,cAAc,iBAAiB;QAC/B,yBAAyB,4BAA4B;QACrD,uBAAuB,4BAA4B;QACnD,YAAY,iBAAiB;QAC7B,cAAc,uBAAuB;QACrC,mBAAmB,iBAAiB;QACpC,gBAAgB,sBAAsB;QACtC,UAAU,eAAe;KAC1B;IAED,MAAM,MAAM,sBAAsB,GAC9B,+BAA+B,GAC/B,sBAAsB,GACtB,cAAc,GACd,oBAAoB,GACpB,wBAAwB,GACxB,uBAAuB,GACvB,yBAAyB,GACzB,gCAAgC,GAChC,+BAA+B,GAC/B,YAAY,GACZ,cAAc,GACd,wBAAwB,GACxB,eAAe,GACf,wBAAwB,GACxB,OAAO,GACP,kBAAkB,CAAA;IAEtB,MAAM,MAAM,UAAU,GAAG;QACvB,UAAU,CAAC,EAAE,UAAU,CAAA;QACvB,KAAK,CAAC,EAAE,KAAK,GAAG,sBAAsB,CAAA;QACtC,MAAM,CAAC,EAAE,WAAW,CAAA;KACrB,CAAA;IAED,UAAU,SAAU,SAAQ,OAAO,CAAC,MAAM,CAAC;QACzC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAA;KAC3D;IAED,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,SAAS,CA2CnE;;CACF"}