🚑 fix build error

Author: exploitationExplorers

docs/.vitepress/config.mts

@@ -30,6 +30,8 @@ export default defineConfig({
                 { text: '实现Readonly', link: '/challenges/easy/readonly' },
                 { text: '实现Awaited', link: '/challenges/easy/awaited' },
                 { text: '实现Parameters', link: '/challenges/easy/paramEters' },
+                { text: '实现Exclude', link: '/challenges/easy/Exclude' },
+                { text: '第一个元素', link: '/challenges/easy/firstOne' },
               ]
              },
             { text: '中等',
@@ -52,7 +54,6 @@ export default defineConfig({
                 { text: '实现Promise.all', link: '/challenges/medium/Promise.all' },
                 { text: '实现Replace', link: '/challenges/medium/Replace' },
                 { text: '实现KebabCase', link: '/challenges/medium/KebabCase' },
-                { text: '实现Pop', link: '/challenges/medium/Pop' },
                 { text: '最后一个元素', link: '/challenges/medium/lastOne' },
               ]
              },

docs/challenges/easy/Exclude.md

@@ -0,0 +1,67 @@
+---
+title: 实现Exclude
+---
+
+# {{ $frontmatter.title }}
+
+## 🎯 题目描述
+
+实现内置的 Exclude <T, U>类型，但不能直接使用它本身。
+
+> 从联合类型 T 中排除 U 的类型成员，来构造一个新的类型。
+
+例如：
+
+```ts
+type Result = MyExclude<'a' | 'b' | 'c', 'a'>; // 'b' | 'c'
+```
+
+## 🔍 分析
+
+在 `A extends B ? true : false` 中，如果 `A` 是联合类型，那么就会触发 ts 的分发特性。
+
+```ts
+type Example<T> = T extends string ? T : boolean;
+// 1 | '3' | {} | [] extends string 会触发分发特性，会转变成如下逻辑:
+// 需要注意的是 T 在分发后，还是用 T 表示，但是此时的 T 仅仅表示的是联合类型中的那一项，而非整个联合类型
+// 1 extends string ? 1 : boolean | '3' extends string ? '3' : boolean | {} extends string ? {} : boolean | [] extends string ? [] : boolean
+// boolean | '3' | boolean | boolean
+// Case1 = boolean | '3'
+type Case1 = Example<1 | '3' | {} | []>;
+```
+
+要注意的是，只有泛型才会触发分发特性，也就是说，如下的简单类型的判断是不会触发分发特性的：
+
+```ts
+type Example<T> = T extends string ? 1 : 2;
+
+// 简单类型，不会分发，结果为 2
+type Case2 = '1' | 1 extends string ? 1 : 2;
+
+// 泛型，触发分发
+// '1' extends string ? 1 : 2 | 1 extends string ? 1 : 2
+// 1 | 2
+// 结果为 1 | 2
+type Case3 = Example<'1' | 1>;
+```
+
+了解了分发特性后，这题的结果就呼之欲出了，但是在此之前，还有一个特性需要了解，那就是 **任意类型 | never = 任意类型**。
+
+## 🛠️ 题解
+
+解法如下：
+
+```ts
+type MyExclude<T, U> = T extends U ? never : T;
+
+// 触发分发特性
+// 'a' extends 'a' ? never : 'a' | 'b' extends 'a' ? never : 'b' | 'c' extends 'a' ? never : 'c'
+// never | 'b' | 'c'
+// Case = 'b' | 'c';
+type Case = MyExclude<'a' | 'b' | 'c', 'a'>;
+```
+
+## 💡 知识点
+
+1. 泛型下联合的分发特性
+2. `任意类型 | never = 任意类型`

docs/challenges/easy/firstOne.md

@@ -0,0 +1,63 @@
+---
+title: 第一个元素
+---
+
+# {{ $frontmatter.title }}
+
+## 🎯 题目描述
+
+实现一个通用`First<T>`，它接受一个数组`T`并返回它的第一个元素的类型。
+
+例如：
+
+```ts
+type arr1 = ['a', 'b', 'c'];
+type arr2 = [3, 2, 1];
+
+type head1 = First<arr1>; // expected to be 'a'
+type head2 = First<arr2>; // expected to be 3
+```
+
+## 🔍 分析
+
+这一题主要是围绕元组的，要获取元组的第一个，就必须要借助 ts 的 `infer` 了。
+
+这一类题的套路都如下：`T extends [infer F, ...infer R] ? F : never`。
+
+其本质可以说是模式匹配，如果 `T` 能够匹配上 `[infer F, ...infer R]`，那么就取前一个类型，否则走后者，基本逻辑和 js 中的三元表达式一样。
+
+## 🛠️ 题解
+
+了解了 infer 和 extends 用法后，其实答案也非常简单了：
+
+```ts
+type First<T extends any[]> = T extends [infer F, ...infer _] ? F : never;
+```
+
+这里值得一提的就是 `[] extends [infer F, ...infer R]` 的判断，由于有两个变量需要推断，`F` 和 `R`，但是原数组中一个元素都没有，此时就会走 false 的逻辑，返回 never。而如果有一个元素，那么还是会走 true 的逻辑，此时 `R` 会被推断为 `[]`。
+
+## 💡 知识点
+
+1. `xxx extends infer xxx ? A : B`，infer + extends 范式
+2. `[infer F, ...infer R]` 中，如果 1 个元素都没有，那么走 false 的逻辑
+
+## 其他解题思路
+
+上面的解题思路是利用`infer`进行匹配, 还有一种完全不同的思路, 是利用元组的索引特性, 我们通过`T[number]`可以获取任意位置的元素, 还能通过`T['length']`获取元组的长度, 类比于 js 中国呢我们获取第一个元素的方式, 我们可以写出如下伪代码:
+
+```ts
+// 利用isEmpty判断数组是否为空
+Array.isEmpty(arr) ? undefined : arr[0];
+
+// 或者利用length判断数组是否为空
+arr.length === 0 ? undefined : arr[0];
+```
+
+将上述伪代码改写成 typescript 类型版本:
+
+```ts
+type First<T extends any[]> = T['length'] extends 0 ? never : T[0];
+
+// 或者
+type First<T extends any[]> = T extends [] ? never : T[0];
+```

docs/challenges/medium/Diff.md

@@ -24,7 +24,7 @@ type Result2 = Diff<Bar, Foo>; // { b: number, c: boolean }
 
 ## 🔍 分析
 
-这道题目其实就比较宽泛了，获取只存在于 A 或 只存在于 B 中的属性，网上有很多借助 `Omit`, `Exclude`, `&` 的解法，我认为都不太直观，其实借助 `as` 非常好实现。关于 `as` 可以参考 [实现 Omit](/medium/实现Omit.md) 中介绍的部分。
+这道题目其实就比较宽泛了，获取只存在于 A 或 只存在于 B 中的属性，网上有很多借助 `Omit`, `Exclude`, `&` 的解法，我认为都不太直观，其实借助 `as` 非常好实现。关于 `as` 可以参考 [实现 Omit](./Omit.md) 中介绍的部分。
 
 首先通过 `keyof A | keyof B` 可以获取所有的属性，接下来只需要让即存在于 A 中的属性 又存在于 B 中的属性为 never 即可去除该属性，也就是 `P extends keyof A & keyof B ? never : P`。讲到这里题解基本就出来了。
 
@@ -41,4 +41,4 @@ type Diff<O, O1> = {
 
 ## 💡 知识点
 
-1. 同 [实现 Omit](/medium/实现Omit.md)。
+1. 同 [实现 Omit](./Omit.md)。

docs/challenges/medium/Flatten.md

@@ -38,7 +38,7 @@ type Flatten<T> =
 
 这里可以注意下 `[...Flatten<F>, ...Flatten<R>]`，因为既需要递归第一个元素，也需要递归剩余元素，还是有一定的圈圈绕。
 
-同时可以留意下最后的 空元组，不理解的可以查看 [实现 Pop](/medium/实现Pop.md) 中提到的边界条件。
+同时可以留意下最后的 空元组，不理解的可以查看 [实现 Pop](./Pop.md) 中提到的边界条件。
 
 ## 💡 知识点
 

docs/challenges/medium/Merge.md

@@ -38,7 +38,7 @@ type Merge<T, S> = {
 } & S;
 ```
 
-这是一种思路，不借助 Exclude 本身也能实现，就是借助 [实现 Omit](/medium/实现Omit.md) 来完成，代码如下：
+这是一种思路，不借助 Exclude 本身也能实现，就是借助 [实现 Omit](./Omit.md) 来完成，代码如下：
 
 ```ts
 type Merge<T, S> = {
@@ -67,4 +67,4 @@ type Merge<F, S> = {
 
 ## 💡 知识点
 
-1. 同 [实现 Omit](/medium/实现Omit.md)。
+1. 同 [实现 Omit](./Omit.md)。

docs/challenges/medium/Pop.md

@@ -21,7 +21,7 @@ const p = PromiseAll([promise1, promise2, promise3] as const);
 
 ## 🔍 分析
 
-这一题可以遍历整个元组，并将元组中的每一个元素通过之前实现的 [Awaited](/easy/实现Awaited.md) 转换一下即可。
+这一题可以遍历整个元组，并将元组中的每一个元素通过之前实现的 [Awaited](../easy/awaited.md) 转换一下即可。
 
 元组的遍历基本上有三种方式：
 
@@ -100,4 +100,4 @@ declare function PromiseAll<T extends any[]>(
 ## 💡 知识点
 
 1. ts 类型推断时，会尝试计算一个更通用的类型，比如 `[1, 2, 3]` 就会被推断成 `number[]`。这里要注意此处的类型推断是指的 ts 中的隐式类型推断，和 `A extends infer xxx` 还是不一样的。这种隐式类型推断一般发生在 `const a = [1, 2, 3] -> a = number[]` 以及函数的入参中
-2. 同 [Awaited](/easy/实现Awaited.md)
+2. 同 [Awaited](../easy/awaited.md)

docs/challenges/medium/Promise.all.md

@@ -16,7 +16,7 @@ type replaced = ReplaceAll<'t y p e s', ' ', ''>; // 期望是 'types'
 
 ## 🔍 分析
 
-这一题是上一题 [实现 replace](/medium/实现Replace.md) 的升级版，不仅仅需要匹配第一次，还需要匹配剩余字符中的符合条件的字符。不过整体还是非常简单的，只需要通过递归嵌套即可。
+这一题是上一题 [实现 replace](./Replace.md) 的升级版，不仅仅需要匹配第一次，还需要匹配剩余字符中的符合条件的字符。不过整体还是非常简单的，只需要通过递归嵌套即可。
 
 ## 🛠️ 题解
 

docs/challenges/medium/ReplaceAll.md

@@ -48,4 +48,4 @@ type Trim<S extends string> = S extends
 
 ## 💡 知识点
 
-1. 同 [TirmLeft](/medium/实现TrimLeft.md)
+1. 同 [TirmLeft](./TrimLeft.md)