@sanity/pkg-utils 1.18.0 → 1.20.0

package/src/node/{_tasks/dts/_dtsWatchTask.ts → tasks/dts/dtsWatchTask.ts}

@@ -1,13 +1,13 @@
 import chalk from 'chalk'
 import {Observable} from 'rxjs'
-import {_printExtractMessages} from '../../_printExtractMessages'
-import {_TaskHandler} from '../_types'
-import {_doExtract} from './_doExtract'
-import {_DtsError} from './_DtsError'
-import {_DtsResult, _DtsWatchTask} from './_types'
+import {printExtractMessages} from '../../printExtractMessages'
+import {TaskHandler} from '../types'
+import {doExtract} from './doExtract'
+import {DtsError} from './DtsError'
+import {DtsResult, DtsWatchTask} from './types'
 
 /** @internal */
-export const _dtsWatchTask: _TaskHandler<_DtsWatchTask, _DtsResult> = {
+export const dtsWatchTask: TaskHandler<DtsWatchTask, DtsResult> = {
   name: (_ctx, task) =>
     [
       `build type definitions`,
@@ -18,7 +18,7 @@ export const _dtsWatchTask: _TaskHandler<_DtsWatchTask, _DtsResult> = {
     ].join('\n'),
   exec: (ctx, task) => {
     return new Observable((observer) => {
-      _doExtract(ctx, task)
+      doExtract(ctx, task)
         .then((result) => {
           observer.next(result)
           observer.complete()
@@ -29,7 +29,7 @@ export const _dtsWatchTask: _TaskHandler<_DtsWatchTask, _DtsResult> = {
   complete: (ctx, _task, result) => {
     const {logger} = ctx
 
-    _printExtractMessages(ctx, result.messages)
+    printExtractMessages(ctx, result.messages)
 
     logger.warn('watching typescript definitions is currently not supported')
     logger.log()
@@ -37,8 +37,8 @@ export const _dtsWatchTask: _TaskHandler<_DtsWatchTask, _DtsResult> = {
   error: (ctx, _task, err) => {
     const {logger} = ctx
 
-    if (err instanceof _DtsError) {
-      _printExtractMessages(ctx, err.messages)
+    if (err instanceof DtsError) {
+      printExtractMessages(ctx, err.messages)
     } else if (err instanceof Error) {
       logger.error(err)
     }

package/src/node/{_tasks/dts/_extractModuleBlocks.ts → tasks/dts/extractModuleBlocks.ts}

@@ -8,7 +8,7 @@ import {Program} from 'typescript'
  * A workaround to find all module blocks in extract TS files.
  * @internal
  * */
-export async function _extractModuleBlocksFromTypes({
+export async function extractModuleBlocksFromTypes({
   tsOutDir,
   extractResult,
 }: {
@@ -26,7 +26,7 @@ export async function _extractModuleBlocksFromTypes({
 
   for (const sourceFile of sourceFiles) {
     if (sourceFile.text.includes('declare module')) {
-      moduleBlocks.push(..._extractModuleBlocks(sourceFile.text))
+      moduleBlocks.push(...extractModuleBlocks(sourceFile.text))
     }
   }
 
@@ -34,7 +34,7 @@ export async function _extractModuleBlocksFromTypes({
 }
 
 /** @internal */
-export function _extractModuleBlocks(fileContent: string): string[] {
+export function extractModuleBlocks(fileContent: string): string[] {
   const ast = parse(fileContent, {
     parser: typeScriptParser,
   }) as File

package/src/node/{_tasks/dts/_extractTypes.ts → tasks/dts/extractTypes.ts}

@@ -8,19 +8,19 @@ import {
 } from '@microsoft/api-extractor'
 import mkdirp from 'mkdirp'
 import prettier from 'prettier'
-import {PkgConfigOptions, _BuildFile} from '../../_core'
-import {_createApiExtractorConfig} from './_createApiExtractorConfig'
-import {_createTSDocConfig} from './_createTSDocConfig'
-import {_extractModuleBlocksFromTypes} from './_extractModuleBlocks'
-import {_getExtractMessagesConfig} from './_getExtractMessagesConfig'
+import {PkgConfigOptions, BuildFile} from '../../core'
+import {createApiExtractorConfig} from './createApiExtractorConfig'
+import {createTSDocConfig} from './createTSDocConfig'
+import {extractModuleBlocksFromTypes} from './extractModuleBlocks'
+import {getExtractMessagesConfig} from './getExtractMessagesConfig'
 
-export async function _extractTypes(options: {
+export async function extractTypes(options: {
   customTags: NonNullable<PkgConfigOptions['extract']>['customTags']
   cwd: string
   distPath: string
   exportPath: string
   filePath: string
-  files: _BuildFile[]
+  files: BuildFile[]
   projectPath: string
   rules?: NonNullable<PkgConfigOptions['extract']>['rules']
   sourceTypesPath: string
@@ -40,16 +40,16 @@ export async function _extractTypes(options: {
     tsconfigPath,
   } = options
 
-  const tsdocConfigFile = await _createTSDocConfig({
+  const tsdocConfigFile = await createTSDocConfig({
     customTags: customTags || [],
   })
 
   const extractorConfig: ExtractorConfig = ExtractorConfig.prepare({
-    configObject: _createApiExtractorConfig({
+    configObject: createApiExtractorConfig({
       distPath,
       exportPath,
       filePath,
-      messages: _getExtractMessagesConfig({rules}),
+      messages: getExtractMessagesConfig({rules}),
       projectFolder: projectPath,
       mainEntryPointFilePath: sourceTypesPath,
       tsconfigPath,
@@ -80,7 +80,7 @@ export async function _extractTypes(options: {
 
   await mkdirp(path.dirname(typesPath))
 
-  const moduleBlocks = await _extractModuleBlocksFromTypes({
+  const moduleBlocks = await extractModuleBlocksFromTypes({
     extractResult: extractorResult,
     tsOutDir: tmpPath,
   })

package/src/node/{_tasks/dts/_getExtractMessagesConfig.ts → tasks/dts/getExtractMessagesConfig.ts}

@@ -1,7 +1,7 @@
 import {ExtractorLogLevel, IExtractorMessagesConfig} from '@microsoft/api-extractor'
-import {PkgRuleLevel, PkgConfigOptions} from '../../_core'
+import {PkgRuleLevel, PkgConfigOptions} from '../../core'
 
-const _LOG_LEVELS: Record<PkgRuleLevel, ExtractorLogLevel> = {
+const LOG_LEVELS: Record<PkgRuleLevel, ExtractorLogLevel> = {
   error: 'error' as ExtractorLogLevel.Error,
   info: 'info' as ExtractorLogLevel.Info,
   off: 'none' as ExtractorLogLevel.None,
@@ -9,18 +9,18 @@ const _LOG_LEVELS: Record<PkgRuleLevel, ExtractorLogLevel> = {
 }
 
 /** @internal */
-export function _getExtractMessagesConfig(options: {
+export function getExtractMessagesConfig(options: {
   rules: NonNullable<PkgConfigOptions['extract']>['rules']
 }): IExtractorMessagesConfig {
   const {rules} = options
 
-  function _ruleToLogLevel(
+  function ruleToLogLevel(
     key: keyof NonNullable<NonNullable<PkgConfigOptions['extract']>['rules']>,
     defaultLevel?: ExtractorLogLevel
   ) {
     const r = rules?.[key]
 
-    return (r ? _LOG_LEVELS[r] : defaultLevel || 'warning') as ExtractorLogLevel
+    return (r ? LOG_LEVELS[r] : defaultLevel || 'warning') as ExtractorLogLevel
   }
 
   return {
@@ -37,22 +37,22 @@ export function _getExtractMessagesConfig(options: {
       },
 
       'ae-forgotten-export': {
-        logLevel: _ruleToLogLevel('ae-forgotten-export', 'error' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('ae-forgotten-export', 'error' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
       'ae-incompatible-release-tags': {
-        logLevel: _ruleToLogLevel('ae-incompatible-release-tags', 'error' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('ae-incompatible-release-tags', 'error' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
       'ae-internal-missing-underscore': {
-        logLevel: _ruleToLogLevel('ae-internal-missing-underscore'),
+        logLevel: ruleToLogLevel('ae-internal-missing-underscore'),
         addToApiReportFile: false,
       },
 
       'ae-missing-release-tag': {
-        logLevel: _ruleToLogLevel('ae-missing-release-tag', 'error' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('ae-missing-release-tag', 'error' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
@@ -69,17 +69,17 @@ export function _getExtractMessagesConfig(options: {
       },
 
       'tsdoc-link-tag-unescaped-text': {
-        logLevel: _ruleToLogLevel('tsdoc-link-tag-unescaped-text', 'warning' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('tsdoc-link-tag-unescaped-text', 'warning' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
       'tsdoc-undefined-tag': {
-        logLevel: _ruleToLogLevel('tsdoc-undefined-tag', 'error' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('tsdoc-undefined-tag', 'error' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
       'tsdoc-unsupported-tag': {
-        logLevel: _ruleToLogLevel('tsdoc-unsupported-tag', 'none' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('tsdoc-unsupported-tag', 'none' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
     },

package/src/node/tasks/dts/index.ts

@@ -0,0 +1,4 @@
+export * from './dtsTask'
+export * from './dtsWatchTask'
+export * from './getExtractMessagesConfig'
+export * from './types'

package/src/node/{_tasks/dts/_types.ts → tasks/dts/types.ts}

@@ -1,7 +1,7 @@
 import {ExtractorMessage} from '@microsoft/api-extractor'
 
 /** @internal */
-export interface _DtsWatchTask {
+export interface DtsWatchTask {
   type: 'watch:dts'
   entries: {
     exportPath: string
@@ -12,7 +12,7 @@ export interface _DtsWatchTask {
 }
 
 /** @internal */
-export interface _DtsTask {
+export interface DtsTask {
   type: 'build:dts'
   entries: {
     exportPath: string
@@ -23,7 +23,7 @@ export interface _DtsTask {
 }
 
 /** @internal */
-export interface _DtsResult {
+export interface DtsResult {
   type: 'dts'
   messages: ExtractorMessage[]
   results: {sourcePath: string; filePath: string}[]

package/src/node/tasks/index.ts

@@ -0,0 +1,19 @@
+import {dtsTask, dtsWatchTask} from './dts'
+import {rollupTask, rollupWatchTask} from './rollup'
+import {BuildTaskHandlers, WatchTaskHandlers} from './types'
+
+export * from './types'
+export * from './dts'
+export * from './rollup'
+
+/** @internal */
+export const buildTaskHandlers: BuildTaskHandlers = {
+  'build:dts': dtsTask,
+  'build:js': rollupTask,
+}
+
+/** @internal */
+export const watchTaskHandlers: WatchTaskHandlers = {
+  'watch:dts': dtsWatchTask,
+  'watch:js': rollupWatchTask,
+}

package/src/node/tasks/rollup/index.ts

@@ -0,0 +1,2 @@
+export * from './rollupTask'
+export * from './rollupWatchTask'

package/src/node/{_tasks/rollup/_resolveRollupConfig.ts → tasks/rollup/resolveRollupConfig.ts}

@@ -8,22 +8,27 @@ import replace from '@rollup/plugin-replace'
 import {InputOptions, OutputOptions, Plugin} from 'rollup'
 import esbuild from 'rollup-plugin-esbuild'
 import {terser} from 'rollup-plugin-terser'
-import {_BuildContext, _DEFAULTS, _MODULE_EXT, _resolveConfigProperty} from '../../_core'
-import {_RollupTask, _RollupWatchTask} from '../_types'
-
-export interface _RollupConfig {
+import {
+  BuildContext,
+  DEFAULT_BROWSERSLIST_QUERY,
+  MODULE_EXT,
+  resolveConfigProperty,
+} from '../../core'
+import {RollupTask, RollupWatchTask} from '../types'
+
+export interface RollupConfig {
   inputOptions: InputOptions
   outputOptions: OutputOptions
 }
 
 /** @internal */
-export function _resolveRollupConfig(
-  ctx: _BuildContext,
-  buildTask: _RollupTask | _RollupWatchTask
-): _RollupConfig {
+export function resolveRollupConfig(
+  ctx: BuildContext,
+  buildTask: RollupTask | RollupWatchTask
+): RollupConfig {
   const {format, runtime, target} = buildTask
   const {config, cwd, exports: _exports, external, distPath, logger, pkg, ts} = ctx
-  const outputExt = _MODULE_EXT[pkg.type][format]
+  const outputExt = MODULE_EXT[pkg.type][format]
   const minify = config?.minify ?? true
   const outDir = path.relative(cwd, distPath)
 
@@ -106,7 +111,7 @@ export function _resolveRollupConfig(
     getBabelOutputPlugin({
       babelrc: false,
       plugins: ['@babel/plugin-proposal-object-rest-spread'],
-      presets: [['@babel/preset-env', {targets: pkg.browserslist || _DEFAULTS.browserslist}]],
+      presets: [['@babel/preset-env', {targets: pkg.browserslist || DEFAULT_BROWSERSLIST_QUERY}]],
     }),
     minify &&
       terser({
@@ -131,7 +136,7 @@ export function _resolveRollupConfig(
 
   const plugins = Array.isArray(userPlugins)
     ? defaultPlugins.concat(userPlugins)
-    : _resolveConfigProperty(config?.rollup?.plugins, defaultPlugins)
+    : resolveConfigProperty(config?.rollup?.plugins, defaultPlugins)
 
   return {
     inputOptions: {

package/src/node/{_tasks/rollup/_rollupTask.ts → tasks/rollup/rollupTask.ts}

@@ -4,12 +4,12 @@ import path from 'path'
 import chalk from 'chalk'
 import {rollup} from 'rollup'
 import {Observable} from 'rxjs'
-import {_BuildContext} from '../../_core'
-import {_RollupTask, _TaskHandler} from '../_types'
-import {_resolveRollupConfig} from './_resolveRollupConfig'
+import {BuildContext} from '../../core'
+import {RollupTask, TaskHandler} from '../types'
+import {resolveRollupConfig} from './resolveRollupConfig'
 
 /** @internal */
-export const _rollupTask: _TaskHandler<_RollupTask> = {
+export const rollupTask: TaskHandler<RollupTask> = {
   name: (ctx, task) =>
     `build javascript files (target ${task.target.join(' + ')}, format ${
       task.format
@@ -18,7 +18,7 @@ export const _rollupTask: _TaskHandler<_RollupTask> = {
       .join('\n       ')}`,
   exec: (ctx, task) => {
     return new Observable((observer) => {
-      _execPromise(ctx, task)
+      execPromise(ctx, task)
         .then((result) => {
           observer.next(result)
           observer.complete()
@@ -36,11 +36,11 @@ export const _rollupTask: _TaskHandler<_RollupTask> = {
   },
 }
 
-async function _execPromise(ctx: _BuildContext, task: _RollupTask) {
+async function execPromise(ctx: BuildContext, task: RollupTask) {
   const {files, distPath} = ctx
   const outDir = path.relative(ctx.cwd, distPath)
 
-  const {inputOptions, outputOptions} = _resolveRollupConfig(ctx, task)
+  const {inputOptions, outputOptions} = resolveRollupConfig(ctx, task)
 
   // Create bundle
   const bundle = await rollup(inputOptions)

package/src/node/{_tasks/rollup/_rollupWatchTask.ts → tasks/rollup/rollupWatchTask.ts}

@@ -2,11 +2,11 @@ import path from 'path'
 import chalk from 'chalk'
 import {RollupWatcherEvent, RollupWatchOptions, watch as rollupWatch} from 'rollup'
 import {Observable} from 'rxjs'
-import {_RollupWatchTask, _TaskHandler} from '../_types'
-import {_resolveRollupConfig} from './_resolveRollupConfig'
+import {RollupWatchTask, TaskHandler} from '../types'
+import {resolveRollupConfig} from './resolveRollupConfig'
 
 /** @internal */
-export const _rollupWatchTask: _TaskHandler<_RollupWatchTask, RollupWatcherEvent> = {
+export const rollupWatchTask: TaskHandler<RollupWatchTask, RollupWatcherEvent> = {
   name: (ctx, task) =>
     `build javascript files (target ${task.target.join(' + ')}, format ${
       task.format
@@ -14,7 +14,7 @@ export const _rollupWatchTask: _TaskHandler<_RollupWatchTask, RollupWatcherEvent
       .map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`)
       .join('\n       ')}`,
   exec: (ctx, task) => {
-    const {inputOptions, outputOptions} = _resolveRollupConfig(ctx, task)
+    const {inputOptions, outputOptions} = resolveRollupConfig(ctx, task)
 
     return new Observable((observer) => {
       const watchOptions: RollupWatchOptions = {

package/src/node/tasks/types.ts

@@ -0,0 +1,57 @@
+import {RollupWatcherEvent} from 'rollup'
+import {Observable} from 'rxjs'
+import {PkgRuntime, BuildContext} from '../core'
+import {DtsResult, DtsTask, DtsWatchTask} from './dts'
+
+/** @internal */
+export interface RollupTaskEntry {
+  path: string
+  source: string
+  output: string
+}
+
+/** @internal */
+export interface RollupTask {
+  type: 'build:js'
+  buildId: string
+  entries: RollupTaskEntry[]
+  runtime: PkgRuntime
+  format: 'commonjs' | 'esm'
+  target: string[]
+}
+
+/** @internal */
+export interface RollupWatchTask {
+  type: 'watch:js'
+  buildId: string
+  entries: RollupTaskEntry[]
+  runtime: PkgRuntime
+  format: 'commonjs' | 'esm'
+  target: string[]
+}
+
+/** @internal */
+export type BuildTask = DtsTask | RollupTask
+
+/** @internal */
+export type WatchTask = DtsWatchTask | RollupWatchTask
+
+/** @internal */
+export type TaskHandler<Task, Result = void> = {
+  name: (ctx: BuildContext, task: Task) => string
+  exec: (ctx: BuildContext, task: Task) => Observable<Result>
+  complete: (ctx: BuildContext, task: Task, result: Result) => void
+  error: (ctx: BuildContext, task: Task, error: unknown) => void
+}
+
+/** @internal */
+export interface BuildTaskHandlers {
+  'build:dts': TaskHandler<DtsTask, DtsResult>
+  'build:js': TaskHandler<RollupTask>
+}
+
+/** @internal */
+export interface WatchTaskHandlers {
+  'watch:dts': TaskHandler<DtsWatchTask, DtsResult>
+  'watch:js': TaskHandler<RollupWatchTask, RollupWatcherEvent>
+}

package/src/node/watch.ts

@@ -1,10 +1,10 @@
 import path from 'path'
 import {switchMap} from 'rxjs'
-import {_loadConfig, _loadPkgWithReporting} from './_core'
-import {_resolveBuildContext} from './_resolveBuildContext'
-import {_resolveWatchTasks} from './_resolveWatchTasks'
-import {_WatchTask, _TaskHandler, _watchTaskHandlers} from './_tasks'
-import {_watchConfigFiles} from './_watchConfigFiles'
+import {loadConfig, loadPkgWithReporting} from './core'
+import {resolveBuildContext} from './resolveBuildContext'
+import {resolveWatchTasks} from './resolveWatchTasks'
+import {WatchTask, TaskHandler, watchTaskHandlers} from './tasks'
+import {watchConfigFiles} from './watchConfigFiles'
 
 /** @public */
 export async function watch(options: {
@@ -14,31 +14,31 @@ export async function watch(options: {
 }): Promise<void> {
   const {cwd, strict = false, tsconfig: tsconfigOption} = options
 
-  const configFiles$ = await _watchConfigFiles({cwd})
+  const configFiles$ = await watchConfigFiles({cwd})
 
   const ctx$ = configFiles$.pipe(
     switchMap(async (configFiles) => {
-      const _files = configFiles.map((f) => path.relative(cwd, f))
+      const files = configFiles.map((f) => path.relative(cwd, f))
 
-      const packageJsonPath = _files.find((f) => f === 'package.json')
+      const packageJsonPath = files.find((f) => f === 'package.json')
 
       if (!packageJsonPath) {
         throw new Error('missing package.json')
       }
 
-      const pkg = await _loadPkgWithReporting({cwd})
-      const config = await _loadConfig({cwd})
+      const pkg = await loadPkgWithReporting({cwd})
+      const config = await loadConfig({cwd})
       const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
 
-      return _resolveBuildContext({config, cwd, pkg, strict, tsconfig})
+      return resolveBuildContext({config, cwd, pkg, strict, tsconfig})
     })
   )
 
   ctx$.subscribe(async (ctx) => {
-    const watchTasks = _resolveWatchTasks(ctx)
+    const watchTasks = resolveWatchTasks(ctx)
 
     for (const task of watchTasks) {
-      const handler = _watchTaskHandlers[task.type] as _TaskHandler<_WatchTask, unknown>
+      const handler = watchTaskHandlers[task.type] as TaskHandler<WatchTask, unknown>
       const result$ = handler.exec(ctx, task)
 
       result$.subscribe({

package/src/node/{_watchConfigFiles.ts → watchConfigFiles.ts}

@@ -2,20 +2,20 @@ import path from 'path'
 import chalk from 'chalk'
 import {Observable} from 'rxjs'
 import {distinctUntilChanged, scan, startWith} from 'rxjs/operators'
-import {_globFiles} from './_globFiles'
-import {_watchFiles} from './_watchFiles'
+import {globFiles} from './globFiles'
+import {watchFiles} from './watchFiles'
 
-export async function _watchConfigFiles(options: {cwd: string}): Promise<Observable<string[]>> {
+export async function watchConfigFiles(options: {cwd: string}): Promise<Observable<string[]>> {
   const {cwd} = options
 
-  const initialFiles = await _globFiles([
+  const initialFiles = await globFiles([
     path.resolve(cwd, 'package.json'),
     path.resolve(cwd, 'package.config.cjs'),
     path.resolve(cwd, 'package.config.js'),
     path.resolve(cwd, 'package.config.ts'),
   ])
 
-  const fileEvent$ = _watchFiles([
+  const fileEvent$ = watchFiles([
     path.resolve(cwd, 'package.json'),
     path.resolve(cwd, 'package.config.cjs'),
     path.resolve(cwd, 'package.config.js'),

package/src/node/{_watchFiles.ts → watchFiles.ts}

@@ -1,28 +1,28 @@
 import chokidar from 'chokidar'
 import {Observable} from 'rxjs'
 
-export interface _FileEvent {
+export interface FileEvent {
   type: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir'
   file: string
 }
 
-export function _watchFiles(patterns: string[]): Observable<_FileEvent> {
+export function watchFiles(patterns: string[]): Observable<FileEvent> {
   return new Observable((observer) => {
     const watcher = chokidar.watch(patterns, {
       ignoreInitial: true,
     })
 
-    function _handleFileEvent(
+    function handleFileEvent(
       type: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir',
       file: string
     ) {
       observer.next({type, file})
     }
 
-    watcher.on('all', _handleFileEvent)
+    watcher.on('all', handleFileEvent)
 
     return () => {
-      watcher.off('all', _handleFileEvent)
+      watcher.off('all', handleFileEvent)
       watcher.close()
     }
   })

package/dist/_chunks/_handleError-869dec25.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_handleError-869dec25.js","sources":["../../src/cli/_handleError.ts"],"sourcesContent":["/* eslint-disable no-console */\n\nimport chalk from 'chalk'\n\nexport function _handleError(err: unknown): void {\n  if (err instanceof Error) {\n    console.error(chalk.red('error'), err.message)\n  }\n\n  process.exit(1)\n}\n"],"names":["_handleError","err","Error","console","error","chalk","red","message","process","exit"],"mappings":";;;;;;;;;AACO,SAASA,YAAY,CAACC,GAAG,EAAE;EAChC,IAAIA,GAAG,YAAYC,KAAK,EAAE;IACxBC,OAAO,CAACC,KAAK,CAACC,yBAAK,CAACC,GAAG,CAAC,OAAO,CAAC,EAAEL,GAAG,CAACM,OAAO,CAAC;EAC/C;EACDC,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC;AACjB;"}