@kood/claude-code 0.4.1 → 0.5.0

package/templates/.claude/skills/tanstack-start-react-best-practices/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: tanstack-start-react-best-practices
-description: TanStack Start and React performance optimization guide. Ensures optimal performance patterns when writing, reviewing, or refactoring TanStack Start pages and React components. Triggers on tasks involving React components, TanStack Router routes, data fetching, bundle optimization, or performance improvements.
+description: TanStack Start와 React 성능 최적화 가이드. React 컴포넌트, TanStack Start 페이지 작성/리뷰/리팩토링 시 최적 성능 패턴 보장. React 컴포넌트, TanStack Router 라우트, 데이터 페칭, 번들 최적화, 성능 개선 작업에 트리거.
 license: MIT
 metadata:
   author: vercel
@@ -8,41 +8,23 @@ metadata:
   adapted_for: tanstack-start
 ---
 
-# TanStack Start React Best Practices
+# TanStack Start React 베스트 프랙티스
 
-Performance optimization guide for React and TanStack Start applications. Contains 39 rules across 7 categories, prioritized by impact to guide automated refactoring and code generation.
-
----
-
-<communication>
-
-## User Communication
-
-**IMPORTANT: Always communicate with the user in Korean (한국어), even though this document is in English.**
-
-When:
-- Asking questions
-- Providing summaries
-- Explaining decisions
-- Reporting progress
-
-Use Korean for all user-facing communication while applying these English guidelines internally.
-
-</communication>
+React와 TanStack Start 애플리케이션 성능 최적화 가이드. 7개 카테고리, 38개 규칙 포함. 영향도별 우선순위로 자동 리팩토링과 코드 생성 가이드 제공.
 
 ---
 
 <when_to_use>
 
-## When to Apply
+## 사용 시점
 
-| Situation | Description |
-|-----------|-------------|
-| **Writing Components** | Creating new React components or TanStack Start routes |
-| **Data Fetching** | Implementing client-side or server-side data fetching |
-| **Code Review** | Reviewing code for performance issues |
-| **Refactoring** | Improving existing React/TanStack Start code |
-| **Optimization** | Optimizing bundle size or load times |
+| 상황 | 설명 |
+|------|------|
+| **컴포넌트 작성** | React 컴포넌트, TanStack Start 라우트 신규 작성 |
+| **데이터 페칭** | 클라이언트/서버 사이드 데이터 페칭 구현 |
+| **코드 리뷰** | 성능 이슈 검토 |
+| **리팩토링** | 기존 React/TanStack Start 코드 개선 |
+| **최적화** | 번들 크기, 로딩 시간 최적화 |
 
 </when_to_use>
 
@@ -50,17 +32,17 @@ Use Korean for all user-facing communication while applying these English guidel
 
 <categories>
 
-## Rule Categories by Priority
+## 카테고리별 우선순위
 
-| Priority | Category | Impact | Prefix |
-|----------|----------|--------|--------|
-| 1 | Eliminating Waterfalls | **CRITICAL** | `async-` |
-| 2 | Bundle Size Optimization | **CRITICAL** | `bundle-` |
-| 3 | Server-Side Performance | HIGH | `server-` |
-| 4 | Client-Side Data Fetching | MEDIUM-HIGH | `client-` |
-| 5 | Re-render Optimization | MEDIUM | `rerender-` |
-| 6 | Rendering Performance | MEDIUM | `rendering-` |
-| 7 | JavaScript Performance | LOW-MEDIUM | `js-` |
+| 우선순위 | 카테고리 | 영향도 | 접두사 |
+|---------|---------|--------|--------|
+| 1 | Waterfall 제거 | **CRITICAL** | `async-` |
+| 2 | 번들 크기 최적화 | **CRITICAL** | `bundle-` |
+| 3 | 서버 사이드 성능 | HIGH | `server-` |
+| 4 | 클라이언트 데이터 페칭 | MEDIUM-HIGH | `client-` |
+| 5 | Re-render 최적화 | MEDIUM | `rerender-` |
+| 6 | 렌더링 성능 | MEDIUM | `rendering-` |
+| 7 | JavaScript 성능 | LOW-MEDIUM | `js-` |
 
 </categories>
 
@@ -68,81 +50,81 @@ Use Korean for all user-facing communication while applying these English guidel
 
 <rules>
 
-## Quick Reference
-
-### 1. Eliminating Waterfalls (CRITICAL)
-
-| Rule | Description |
-|------|-------------|
-| `async-defer-await` | Move await into branches where actually used |
-| `async-parallel` | Use Promise.all() for independent operations |
-| `async-dependencies` | Use better-all for partial dependencies |
-| `async-loader` | Parallel data fetching in TanStack Router loader |
-
-### 2. Bundle Size Optimization (CRITICAL)
-
-| Rule | Description |
-|------|-------------|
-| `bundle-barrel-imports` | Import directly, avoid barrel files |
-| `bundle-lazy-routes` | Route-based code splitting |
-| `bundle-defer-third-party` | Load analytics/logging after hydration |
-| `bundle-conditional` | Load modules only when feature is activated |
-| `bundle-preload` | Preload on hover/focus for perceived speed |
-
-### 3. Server-Side Performance (HIGH)
-
-| Rule | Description |
-|------|-------------|
-| `server-cache-lru` | Use LRU cache for cross-request caching |
-| `server-serialization` | Minimize data passed to client components |
-| `server-parallel-fetching` | Parallel data fetching in loader |
-| `server-deferred-data` | Use defer() for non-blocking data loading |
-
-### 4. Client-Side Data Fetching (MEDIUM-HIGH)
-
-| Rule | Description |
-|------|-------------|
-| `client-tanstack-query` | TanStack Query for automatic caching/deduplication |
-| `client-event-listeners` | Deduplicate global event listeners |
-
-### 5. Re-render Optimization (MEDIUM)
-
-| Rule | Description |
-|------|-------------|
-| `rerender-defer-reads` | Don't subscribe to state only used in callbacks |
-| `rerender-memo` | Extract expensive work into memoized components |
-| `rerender-dependencies` | Use primitive dependencies in effects |
-| `rerender-derived-state` | Subscribe to derived booleans, not raw values |
-| `rerender-functional-setstate` | Use functional setState for stable callbacks |
-| `rerender-lazy-state-init` | Pass function to useState for expensive values |
-| `rerender-transitions` | Use startTransition for non-urgent updates |
-
-### 6. Rendering Performance (MEDIUM)
-
-| Rule | Description |
-|------|-------------|
-| `rendering-animate-svg-wrapper` | Animate div wrapper, not SVG element |
-| `rendering-content-visibility` | Use content-visibility for long lists |
-| `rendering-hoist-jsx` | Extract static JSX outside components |
-| `rendering-svg-precision` | Reduce SVG coordinate precision |
-| `rendering-conditional-render` | Use ternary, not && for conditionals |
-
-### 7. JavaScript Performance (LOW-MEDIUM)
-
-| Rule | Description |
-|------|-------------|
-| `js-batch-dom-css` | Group CSS changes via classes or cssText |
-| `js-index-maps` | Build Map for repeated lookups |
-| `js-cache-property-access` | Cache object properties in loops |
-| `js-cache-function-results` | Cache function results in module-level Map |
-| `js-cache-storage` | Cache localStorage/sessionStorage reads |
-| `js-combine-iterations` | Combine multiple filter/map into one loop |
-| `js-length-check-first` | Check array length before expensive comparison |
-| `js-early-exit` | Return early from functions |
-| `js-hoist-regexp` | Hoist RegExp creation outside loops |
-| `js-min-max-loop` | Use loop for min/max instead of sort |
-| `js-set-map-lookups` | Use Set/Map for O(1) lookups |
-| `js-tosorted-immutable` | Use toSorted() for immutability |
+## 빠른 참조
+
+### 1. Waterfall 제거 (CRITICAL)
+
+| 규칙 | 설명 |
+|------|------|
+| `async-defer-await` | await를 실제 사용 지점으로 이동 |
+| `async-parallel` | 독립 작업은 Promise.all() 사용 |
+| `async-dependencies` | 부분 의존성은 better-all 사용 |
+| `async-loader` | TanStack Router loader에서 병렬 데이터 페칭 |
+
+### 2. 번들 크기 최적화 (CRITICAL)
+
+| 규칙 | 설명 |
+|------|------|
+| `bundle-barrel-imports` | 직접 import, barrel 파일 회피 |
+| `bundle-lazy-routes` | 라우트 기반 코드 스플리팅 |
+| `bundle-defer-third-party` | 분석/로깅은 hydration 후 로드 |
+| `bundle-conditional` | 기능 활성화 시에만 모듈 로드 |
+| `bundle-preload` | hover/focus 시 preload로 체감 속도 향상 |
+
+### 3. 서버 사이드 성능 (HIGH)
+
+| 규칙 | 설명 |
+|------|------|
+| `server-cache-lru` | LRU 캐시로 요청 간 캐싱 |
+| `server-serialization` | 클라이언트로 전달 데이터 최소화 |
+| `server-parallel-fetching` | loader에서 병렬 데이터 페칭 |
+| `server-deferred-data` | defer()로 비차단 데이터 로딩 |
+
+### 4. 클라이언트 데이터 페칭 (MEDIUM-HIGH)
+
+| 규칙 | 설명 |
+|------|------|
+| `client-tanstack-query` | TanStack Query로 자동 캐싱/중복 제거 |
+| `client-event-listeners` | 전역 이벤트 리스너 중복 제거 |
+
+### 5. Re-render 최적화 (MEDIUM)
+
+| 규칙 | 설명 |
+|------|------|
+| `rerender-defer-reads` | 콜백 전용 상태는 구독 안 함 |
+| `rerender-memo` | 비싼 작업은 memoized 컴포넌트로 추출 |
+| `rerender-dependencies` | effect에 원시값 의존성 사용 |
+| `rerender-derived-state` | 파생 boolean 구독, raw 값 구독 회피 |
+| `rerender-functional-setstate` | 안정적 콜백용 함수형 setState |
+| `rerender-lazy-state-init` | 비싼 초기값은 함수로 useState에 전달 |
+| `rerender-transitions` | 비긴급 업데이트는 startTransition |
+
+### 6. 렌더링 성능 (MEDIUM)
+
+| 규칙 | 설명 |
+|------|------|
+| `rendering-animate-svg-wrapper` | SVG 대신 wrapper div 애니메이션 |
+| `rendering-content-visibility` | 긴 리스트는 content-visibility 사용 |
+| `rendering-hoist-jsx` | 정적 JSX 컴포넌트 외부로 추출 |
+| `rendering-svg-precision` | SVG 좌표 정밀도 감소 |
+| `rendering-conditional-render` | 조건부 렌더링은 &&가 아닌 삼항 연산자 |
+
+### 7. JavaScript 성능 (LOW-MEDIUM)
+
+| 규칙 | 설명 |
+|------|------|
+| `js-batch-dom-css` | CSS 변경은 클래스나 cssText로 그룹화 |
+| `js-index-maps` | 반복 조회용 Map 빌드 |
+| `js-cache-property-access` | 루프에서 객체 속성 캐싱 |
+| `js-cache-function-results` | 함수 결과를 모듈 레벨 Map에 캐싱 |
+| `js-cache-storage` | localStorage/sessionStorage 읽기 캐싱 |
+| `js-combine-iterations` | 여러 filter/map을 하나의 루프로 결합 |
+| `js-length-check-first` | 비싼 비교 전 배열 길이 먼저 체크 |
+| `js-early-exit` | 함수에서 조기 반환 |
+| `js-hoist-regexp` | RegExp 생성을 루프 밖으로 |
+| `js-min-max-loop` | sort 대신 루프로 min/max |
+| `js-set-map-lookups` | O(1) 조회용 Set/Map 사용 |
+| `js-tosorted-immutable` | 불변성용 toSorted() 사용 |
 
 </rules>
 
@@ -150,17 +132,17 @@ Use Korean for all user-facing communication while applying these English guidel
 
 <patterns>
 
-## Core Patterns
+## 핵심 패턴
 
-### ✅ Eliminate Waterfalls
+### ✅ Waterfall 제거
 
 ```typescript
-// ❌ Sequential execution, 3 round trips
+// ❌ 순차 실행, 3번 왕복
 const user = await fetchUser()
 const posts = await fetchPosts()
 const comments = await fetchComments()
 
-// ✅ Parallel execution, 1 round trip
+// ✅ 병렬 실행, 1번 왕복
 const [user, posts, comments] = await Promise.all([
   fetchUser(),
   fetchPosts(),
@@ -174,7 +156,7 @@ const [user, posts, comments] = await Promise.all([
 import { createServerFn } from '@tanstack/react-start'
 import { createFileRoute } from '@tanstack/react-router'
 
-// Define Server Functions
+// Server Functions 정의
 const getPost = createServerFn().handler(async (postId: string) => {
   return await db.post.findUnique({ where: { id: postId } })
 })
@@ -183,7 +165,7 @@ const getComments = createServerFn().handler(async (postId: string) => {
   return await db.comment.findMany({ where: { postId } })
 })
 
-// ❌ Sequential loading
+// ❌ 순차 로딩
 export const Route = createFileRoute('/posts/$postId')({
   loader: async ({ params }) => {
     const post = await getPost(params.postId)
@@ -192,7 +174,7 @@ export const Route = createFileRoute('/posts/$postId')({
   }
 })
 
-// ✅ Parallel loading
+// ✅ 병렬 로딩
 export const Route = createFileRoute('/posts/$postId')({
   loader: async ({ params }) => {
     const [post, comments] = await Promise.all([
@@ -204,24 +186,24 @@ export const Route = createFileRoute('/posts/$postId')({
 })
 ```
 
-### ✅ Bundle Optimization
+### ✅ 번들 최적화
 
 ```tsx
-// ❌ Import entire library (1583 modules, ~2.8s)
+// ❌ 전체 라이브러리 import (1583개 모듈, ~2.8초)
 import { Check, X, Menu } from 'lucide-react'
 
-// ✅ Direct imports (3 modules only)
+// ✅ 직접 import (3개 모듈만)
 import Check from 'lucide-react/dist/esm/icons/check'
 import X from 'lucide-react/dist/esm/icons/x'
 import Menu from 'lucide-react/dist/esm/icons/menu'
 ```
 
-### ✅ TanStack Query for Caching
+### ✅ TanStack Query로 캐싱
 
 ```typescript
 import { useQuery } from '@tanstack/react-query'
 
-// ❌ No deduplication, each instance fetches
+// ❌ 중복 제거 없음, 각 인스턴스가 fetch
 function UserList() {
   const [users, setUsers] = useState([])
   useEffect(() => {
@@ -231,7 +213,7 @@ function UserList() {
   }, [])
 }
 
-// ✅ Multiple instances share one request
+// ✅ 여러 인스턴스가 하나의 요청 공유
 function UserList() {
   const { data: users } = useQuery({
     queryKey: ['users'],
@@ -240,15 +222,15 @@ function UserList() {
 }
 ```
 
-### ✅ Re-render Optimization
+### ✅ Re-render 최적화
 
 ```tsx
-// ❌ items as dependency, recreated every time
+// ❌ items가 의존성, 매번 재생성
 const addItems = useCallback((newItems: Item[]) => {
   setItems([...items, ...newItems])
 }, [items])
 
-// ✅ Stable callback, never recreated
+// ✅ 안정적 콜백, 재생성 없음
 const addItems = useCallback((newItems: Item[]) => {
   setItems(curr => [...curr, ...newItems])
 }, [])
@@ -260,17 +242,17 @@ const addItems = useCallback((newItems: Item[]) => {
 
 <tanstack_specific>
 
-## TanStack Start Specific Patterns
+## TanStack Start 특화 패턴
 
-### createServerFn for Server Functions
+### createServerFn으로 Server Functions
 
 ```typescript
 import { createServerFn } from '@tanstack/react-start'
 import { z } from 'zod'
 
-// ✅ Basic Server Function
+// ✅ 기본 Server Function
 const getUser = createServerFn().handler(async () => {
-  // Only runs on server
+  // 서버에서만 실행
   return await db.user.findMany()
 })
 
@@ -283,12 +265,12 @@ const createUserSchema = z.object({
 const createUser = createServerFn({ method: 'POST' })
   .inputValidator(createUserSchema)
   .handler(async ({ data }) => {
-    // data is fully typed and validated
+    // data는 완전히 타입 검증됨
     return await db.user.create({ data })
   })
 ```
 
-### Loader Optimization
+### Loader 최적화
 
 ```typescript
 import { createServerFn } from '@tanstack/react-start'
@@ -302,7 +284,7 @@ const getStats = createServerFn().handler(async () => {
   return await db.stats.findMany()
 })
 
-// ✅ Parallel data fetching
+// ✅ 병렬 데이터 페칭
 export const Route = createFileRoute('/dashboard')({
   loader: async () => {
     const [user, stats] = await Promise.all([
@@ -314,7 +296,7 @@ export const Route = createFileRoute('/dashboard')({
 })
 ```
 
-### Deferred Data (Automatic Handling)
+### Deferred Data (자동 처리)
 
 ```typescript
 import { createServerFn } from '@tanstack/react-start'
@@ -326,17 +308,17 @@ const getPost = createServerFn().handler(async (postId: string) => {
 })
 
 const getComments = createServerFn().handler(async (postId: string) => {
-  await new Promise(r => setTimeout(r, 3000)) // Slow query simulation
+  await new Promise(r => setTimeout(r, 3000)) // 느린 쿼리 시뮬레이션
   return await db.comment.findMany({ where: { postId } })
 })
 
-// ✅ Await important data, defer non-critical data
+// ✅ 중요 데이터는 await, 비중요 데이터는 Promise 그대로 반환
 export const Route = createFileRoute('/posts/$postId')({
   loader: async ({ params }) => {
-    // Fast data: await
+    // 빠른 데이터는 await
     const post = await getPost(params.postId)
 
-    // Slow data: return Promise (automatically deferred)
+    // 느린 데이터는 Promise 그대로 반환 (자동으로 deferred 처리됨)
     const deferredComments = getComments(params.postId)
 
     return {
@@ -346,7 +328,7 @@ export const Route = createFileRoute('/posts/$postId')({
   }
 })
 
-// Handle with Await in component
+// 컴포넌트에서 Await로 처리
 function PostPage() {
   const { post, deferredComments } = Route.useLoaderData()
 
@@ -363,13 +345,13 @@ function PostPage() {
 }
 ```
 
-### Route-Based Code Splitting
+### 라우트 기반 코드 스플리팅
 
 ```typescript
 import { lazy } from 'react'
 import { createFileRoute } from '@tanstack/react-router'
 
-// ✅ Heavy components lazy loaded
+// ✅ 무거운 컴포넌트는 lazy load
 const HeavyEditor = lazy(() => import('./components/HeavyEditor'))
 
 export const Route = createFileRoute('/editor')({
@@ -387,9 +369,9 @@ export const Route = createFileRoute('/editor')({
 
 <usage>
 
-## Usage
+## 사용법
 
-**Detailed rules and examples:**
+**상세 규칙 및 예시:**
 
 ```
 rules/async-parallel.md
@@ -398,13 +380,13 @@ rules/client-tanstack-query.md
 rules/server-deferred-data.md
 ```
 
-Each rule file contains:
-- Why it matters
-- ❌ Incorrect code example with explanation
-- ✅ Correct code example with explanation
-- Additional context and references
+각 규칙 파일 포함 내용:
+- 중요한 이유 설명
+- ❌ 잘못된 코드 예시 + 설명
+- ✅ 올바른 코드 예시 + 설명
+- 추가 컨텍스트 및 참조
 
-**Full compiled document:** `AGENTS.md`
+**전체 컴파일 문서:** `PARALLEL_AGENTS.md`
 
 </usage>
 
@@ -412,10 +394,10 @@ Each rule file contains:
 
 <references>
 
-## References
+## 참고 자료
 
-### TanStack Official Documentation
-1. [React](https://react.dev)
+### TanStack 공식 문서
+1. [React 공식 문서](https://react.dev)
 2. [TanStack Start Overview](https://tanstack.com/start/latest/docs/framework/react/overview)
 3. [TanStack Start Quick Start](https://tanstack.com/start/latest/docs/framework/react/quick-start)
 4. [TanStack Router](https://tanstack.com/router)
@@ -423,7 +405,7 @@ Each rule file contains:
 6. [TanStack Query](https://tanstack.com/query)
 7. [Server Functions Guide](https://tanstack.com/start/latest/docs/framework/react/guide/server-functions)
 
-### External Resources
+### 외부 자료
 8. [better-all](https://github.com/shuding/better-all)
 9. [node-lru-cache](https://github.com/isaacs/node-lru-cache)
 10. [Using Server Functions and TanStack Query](https://www.brenelz.com/posts/using-server-functions-and-tanstack-query/)

package/templates/.claude/skills/tanstack-start-react-best-practices/rules/async-defer-await.md

@@ -5,76 +5,76 @@ impactDescription: avoids blocking unused code paths
 tags: async, await, conditional, optimization
 ---
 
-## Defer Await Until Needed
+## 필요할 때까지 Await 연기하기
 
-Move `await` operations into the branches where they're actually used to avoid blocking code paths that don't need them.
+실제로 사용되는 분기점에서만 `await` 작업을 수행하여 필요하지 않은 코드 경로가 블로킹되는 것을 방지합니다.
 
-**Incorrect (blocks both branches):**
+**❌ 잘못된 예시 (두 분기 모두 블로킹):**
 
 ```typescript
 async function handleRequest(userId: string, skipProcessing: boolean) {
   const userData = await fetchUserData(userId)
-  
+
   if (skipProcessing) {
-    // Returns immediately but still waited for userData
+    // 즉시 반환하지만 여전히 userData를 기다렸음
     return { skipped: true }
   }
-  
-  // Only this branch uses userData
+
+  // 이 분기에서만 userData를 사용함
   return processUserData(userData)
 }
 ```
 
-**Correct (only blocks when needed):**
+**✅ 올바른 예시 (필요할 때만 블로킹):**
 
 ```typescript
 async function handleRequest(userId: string, skipProcessing: boolean) {
   if (skipProcessing) {
-    // Returns immediately without waiting
+    // 기다리지 않고 즉시 반환
     return { skipped: true }
   }
-  
-  // Fetch only when needed
+
+  // 필요할 때만 가져오기
   const userData = await fetchUserData(userId)
   return processUserData(userData)
 }
 ```
 
-**Another example (early return optimization):**
+**다른 예시 (조기 반환 최적화):**
 
 ```typescript
-// Incorrect: always fetches permissions
+// ❌ 잘못된 예시: 항상 권한을 가져옴
 async function updateResource(resourceId: string, userId: string) {
   const permissions = await fetchPermissions(userId)
   const resource = await getResource(resourceId)
-  
+
   if (!resource) {
     return { error: 'Not found' }
   }
-  
+
   if (!permissions.canEdit) {
     return { error: 'Forbidden' }
   }
-  
+
   return await updateResourceData(resource, permissions)
 }
 
-// Correct: fetches only when needed
+// ✅ 올바른 예시: 필요할 때만 가져오기
 async function updateResource(resourceId: string, userId: string) {
   const resource = await getResource(resourceId)
-  
+
   if (!resource) {
     return { error: 'Not found' }
   }
-  
+
   const permissions = await fetchPermissions(userId)
-  
+
   if (!permissions.canEdit) {
     return { error: 'Forbidden' }
   }
-  
+
   return await updateResourceData(resource, permissions)
 }
 ```
 
-This optimization is especially valuable when the skipped branch is frequently taken, or when the deferred operation is expensive.
+이 최적화는 건너뛴 분기가 자주 실행되거나, 연기된 작업이 비용이 많이 드는 경우 특히 유용합니다.

package/templates/.claude/skills/tanstack-start-react-best-practices/rules/async-dependencies.md

@@ -5,11 +5,11 @@ impactDescription: 2-10× improvement
 tags: async, parallelization, dependencies, better-all
 ---
 
-## Dependency-Based Parallelization
+## 의존성 기반 병렬화
 
-For operations with partial dependencies, use `better-all` to maximize parallelism. It automatically starts each task at the earliest possible moment.
+부분적인 의존성이 있는 작업의 경우 `better-all`을 사용하여 병렬성을 최대화합니다. 각 작업을 가능한 가장 빠른 시점에 자동으로 시작합니다.
 
-**Incorrect (profile waits for config unnecessarily):**
+**❌ 잘못된 예시 (profile이 불필요하게 config을 기다림):**
 
 ```typescript
 const [user, config] = await Promise.all([
@@ -19,7 +19,7 @@ const [user, config] = await Promise.all([
 const profile = await fetchProfile(user.id)
 ```
 
-**Correct (config and profile run in parallel):**
+**✅ 올바른 예시 (config과 profile이 병렬로 실행):**
 
 ```typescript
 import { all } from 'better-all'
@@ -33,4 +33,4 @@ const { user, config, profile } = await all({
 })
 ```
 
-Reference: [https://github.com/shuding/better-all](https://github.com/shuding/better-all)
+참고: [https://github.com/shuding/better-all](https://github.com/shuding/better-all)