element.'); // 'This is a <div> element.'
+escape('This is a "quote"'); // 'This is a "quote"'
+escape("This is a 'quote'"); // 'This is a 'quote''
+escape('This is a & symbol'); // 'This is a & symbol'
+```
+
+Non-string values are also converted to strings before processing.
+
+```typescript
+import { escape } from 'es-toolkit/compat';
+
+escape(123); // '123'
+escape(null); // ''
+escape(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to escape HTML special characters.
+
+#### Returns
+
+(`string`): Returns the string with HTML special characters converted to entities.
diff --git a/docs/compat/reference/string/escapeRegExp.md b/docs/compat/reference/string/escapeRegExp.md
new file mode 100644
index 000000000..b8b2d4b31
--- /dev/null
+++ b/docs/compat/reference/string/escapeRegExp.md
@@ -0,0 +1,49 @@
+# escapeRegExp (Lodash compatibility)
+
+::: warning Use `escapeRegExp` from `es-toolkit`
+
+This `escapeRegExp` function operates slower due to handling non-string input values.
+
+Instead, use the faster and more modern [escapeRegExp](../../../reference/string/escapeRegExp.md) from `es-toolkit`.
+
+:::
+
+Escapes regular expression special characters in a string.
+
+```typescript
+const result = escapeRegExp(str);
+```
+
+## Usage
+
+### `escapeRegExp(str)`
+
+Escapes regular expression special characters `^`, `$`, `\`, `.`, `*`, `+`, `?`, `(`, `)`, `[`, `]`, `{`, `}`, `|` in a string. This is useful when you want to treat a string literally when dynamically creating regular expressions.
+
+```typescript
+import { escapeRegExp } from 'es-toolkit/compat';
+
+escapeRegExp('[es-toolkit](https://es-toolkit.dev/)');
+// '\\[es-toolkit\\]\\(https://es-toolkit\\.dev/\\)'
+
+escapeRegExp('$^{}.+*?()[]|\\');
+// '\\$\\^\\{\\}\\.\\+\\*\\?\\(\\)\\[\\]\\|\\\\'
+```
+
+Non-string values are also converted to strings before processing.
+
+```typescript
+import { escapeRegExp } from 'es-toolkit/compat';
+
+escapeRegExp(123); // '123'
+escapeRegExp(null); // ''
+escapeRegExp(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to escape regular expression special characters.
+
+#### Returns
+
+(`string`): Returns the string with regular expression special characters escaped.
diff --git a/docs/compat/reference/string/kebabCase.md b/docs/compat/reference/string/kebabCase.md
new file mode 100644
index 000000000..06e0ecc66
--- /dev/null
+++ b/docs/compat/reference/string/kebabCase.md
@@ -0,0 +1,48 @@
+# kebabCase (Lodash compatibility)
+
+::: warning Use `kebabCase` from `es-toolkit`
+
+This `kebabCase` function operates slower due to handling non-string input values and removing contracted apostrophes.
+
+Instead, use the faster and more modern [kebabCase](../../../reference/string/kebabCase.md) from `es-toolkit`.
+
+:::
+
+Converts a string to kebab case.
+
+```typescript
+const result = kebabCase(str);
+```
+
+## Usage
+
+### `kebabCase(str)`
+
+Converts a string to kebab case. Kebab case is a naming convention where each word is written in lowercase and connected with a dash (-) character. It's commonly used in URLs and CSS class names.
+
+```typescript
+import { kebabCase } from 'es-toolkit/compat';
+
+kebabCase('camelCase'); // 'camel-case'
+kebabCase('some whitespace'); // 'some-whitespace'
+kebabCase('hyphen-text'); // 'hyphen-text'
+kebabCase('HTTPRequest'); // 'http-request'
+```
+
+Non-string values are also converted to strings before processing.
+
+```typescript
+import { kebabCase } from 'es-toolkit/compat';
+
+kebabCase(123); // '123'
+kebabCase(null); // ''
+kebabCase(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string | object`, optional): The value to convert to kebab case.
+
+#### Returns
+
+(`string`): Returns the string converted to kebab case.
diff --git a/docs/compat/reference/string/lowerCase.md b/docs/compat/reference/string/lowerCase.md
new file mode 100644
index 000000000..018376013
--- /dev/null
+++ b/docs/compat/reference/string/lowerCase.md
@@ -0,0 +1,48 @@
+# lowerCase (Lodash compatibility)
+
+::: warning Use `lowerCase` from `es-toolkit`
+
+This `lowerCase` function operates slower due to handling non-string input values and removing contracted apostrophes.
+
+Instead, use the faster and more modern [lowerCase](../../../reference/string/lowerCase.md) from `es-toolkit`.
+
+:::
+
+Converts a string to lowercase words separated by spaces.
+
+```typescript
+const result = lowerCase(str);
+```
+
+## Usage
+
+### `lowerCase(str)`
+
+Converts a string to lowercase words separated by spaces. Each word is converted to lowercase and connected with space characters. This is useful for creating human-readable text.
+
+```typescript
+import { lowerCase } from 'es-toolkit/compat';
+
+lowerCase('camelCase'); // 'camel case'
+lowerCase('some whitespace'); // 'some whitespace'
+lowerCase('hyphen-text'); // 'hyphen text'
+lowerCase('HTTPRequest'); // 'http request'
+```
+
+Non-string values are also converted to strings before processing.
+
+```typescript
+import { lowerCase } from 'es-toolkit/compat';
+
+lowerCase(123); // '123'
+lowerCase(null); // ''
+lowerCase(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string | object`, optional): The value to convert to lowercase format.
+
+#### Returns
+
+(`string`): Returns the string with lowercase words separated by spaces.
diff --git a/docs/compat/reference/string/lowerFirst.md b/docs/compat/reference/string/lowerFirst.md
new file mode 100644
index 000000000..4541bd18e
--- /dev/null
+++ b/docs/compat/reference/string/lowerFirst.md
@@ -0,0 +1,48 @@
+# lowerFirst (Lodash compatibility)
+
+::: warning Use `lowerFirst` from `es-toolkit`
+
+This `lowerFirst` function operates slower due to handling non-string input values.
+
+Instead, use the faster and more modern [lowerFirst](../../../reference/string/lowerFirst.md) from `es-toolkit`.
+
+:::
+
+Converts the first character of a string to lowercase.
+
+```typescript
+const result = lowerFirst(str);
+```
+
+## Usage
+
+### `lowerFirst(str)`
+
+Converts the first character of a string to lowercase. The remaining characters are kept as is. This is useful for creating camelCase variable names or when you only want to lowercase the first character.
+
+```typescript
+import { lowerFirst } from 'es-toolkit/compat';
+
+lowerFirst('fred'); // 'fred'
+lowerFirst('Fred'); // 'fred'
+lowerFirst('FRED'); // 'fRED'
+lowerFirst(''); // ''
+```
+
+Non-string values are also converted to strings before processing.
+
+```typescript
+import { lowerFirst } from 'es-toolkit/compat';
+
+lowerFirst(123); // '123'
+lowerFirst(null); // ''
+lowerFirst(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to convert the first character to lowercase.
+
+#### Returns
+
+(`string`): Returns the string with the first character converted to lowercase.
diff --git a/docs/compat/reference/string/pad.md b/docs/compat/reference/string/pad.md
new file mode 100644
index 000000000..4432115ed
--- /dev/null
+++ b/docs/compat/reference/string/pad.md
@@ -0,0 +1,60 @@
+# pad (Lodash compatibility)
+
+::: warning Use `pad` from `es-toolkit`
+
+This `pad` function operates slower due to handling `null` or `undefined`.
+
+Instead, use the faster and more modern [pad](../../../reference/string/pad.md) from `es-toolkit`.
+
+:::
+
+Pads a string on both sides with padding characters to reach the specified length.
+
+```typescript
+const padded = pad(str, length, chars);
+```
+
+## Usage
+
+### `pad(str, length, chars)`
+
+Use `pad` when you want to pad a string on both sides to match a desired length. If the padding characters don't divide evenly, extra characters are placed on the right.
+
+```typescript
+import { pad } from 'es-toolkit/compat';
+
+// Pad with default spaces
+pad('abc', 8);
+// Returns: ' abc '
+
+// Pad with specified characters
+pad('abc', 8, '_-');
+// Returns: '_-abc_-_'
+
+// Return as is if already long enough
+pad('abc', 3);
+// Returns: 'abc'
+
+// Return as is if length is shorter
+pad('abc', 2);
+// Returns: 'abc'
+```
+
+`null` or `undefined` are treated as empty strings.
+
+```typescript
+import { pad } from 'es-toolkit/compat';
+
+pad(null, 5); // ' '
+pad(undefined, 3, '*'); // '***'
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to pad.
+- `length` (`number`, optional): The target length. Defaults to `0`.
+- `chars` (`string`, optional): The characters to use for padding. Defaults to space `' '`.
+
+#### Returns
+
+(`string`): Returns the string padded to the specified length.
diff --git a/docs/reference/compat/string/padEnd.md b/docs/compat/reference/string/padEnd.md
similarity index 100%
rename from docs/reference/compat/string/padEnd.md
rename to docs/compat/reference/string/padEnd.md
diff --git a/docs/reference/compat/string/padStart.md b/docs/compat/reference/string/padStart.md
similarity index 100%
rename from docs/reference/compat/string/padStart.md
rename to docs/compat/reference/string/padStart.md
diff --git a/docs/reference/compat/string/repeat.md b/docs/compat/reference/string/repeat.md
similarity index 100%
rename from docs/reference/compat/string/repeat.md
rename to docs/compat/reference/string/repeat.md
diff --git a/docs/reference/compat/string/replace.md b/docs/compat/reference/string/replace.md
similarity index 100%
rename from docs/reference/compat/string/replace.md
rename to docs/compat/reference/string/replace.md
diff --git a/docs/compat/reference/string/snakeCase.md b/docs/compat/reference/string/snakeCase.md
new file mode 100644
index 000000000..e47c0413e
--- /dev/null
+++ b/docs/compat/reference/string/snakeCase.md
@@ -0,0 +1,58 @@
+# snakeCase (Lodash compatibility)
+
+::: warning Use `snakeCase` from `es-toolkit`
+
+This `snakeCase` function operates slowly due to normalization logic for handling `null` or `undefined`.
+
+Instead, use the faster and more modern [snakeCase](../../../reference/string/snakeCase.md) from `es-toolkit`.
+
+:::
+
+Converts a string to snake case.
+
+```typescript
+const snakeCased = snakeCase(str);
+```
+
+## Usage
+
+### `snakeCase(str)`
+
+Use `snakeCase` when you want to convert a string to snake*case. Snake case is a naming convention where each word is written in lowercase and connected with underscores (*).
+
+```typescript
+import { snakeCase } from 'es-toolkit/compat';
+
+// Convert camel case
+snakeCase('camelCase');
+// Returns: 'camel_case'
+
+// Convert space-separated string
+snakeCase('some whitespace');
+// Returns: 'some_whitespace'
+
+// Convert hyphen-separated string
+snakeCase('hyphen-text');
+// Returns: 'hyphen_text'
+
+// Handle consecutive uppercase letters
+snakeCase('HTTPRequest');
+// Returns: 'http_request'
+```
+
+`null` or `undefined` are treated as empty strings.
+
+```typescript
+import { snakeCase } from 'es-toolkit/compat';
+
+snakeCase(null); // ''
+snakeCase(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to convert to snake case.
+
+#### Returns
+
+(`string`): Returns the converted string in snake case.
diff --git a/docs/reference/compat/string/split.md b/docs/compat/reference/string/split.md
similarity index 100%
rename from docs/reference/compat/string/split.md
rename to docs/compat/reference/string/split.md
diff --git a/docs/compat/reference/string/startCase.md b/docs/compat/reference/string/startCase.md
new file mode 100644
index 000000000..26eb3cf5d
--- /dev/null
+++ b/docs/compat/reference/string/startCase.md
@@ -0,0 +1,58 @@
+# startCase (Lodash compatibility)
+
+::: warning Use `startCase` from `es-toolkit`
+
+This `startCase` function runs slower due to normalization logic for handling `null` or `undefined`.
+
+Instead, use the faster and more modern [startCase](../../../reference/string/startCase.md) from `es-toolkit`.
+
+:::
+
+Converts a string to start case.
+
+```typescript
+const startCased = startCase(str);
+```
+
+## Usage
+
+### `startCase(str)`
+
+Use `startCase` when you want to convert a string to Start Case. Start Case is a naming convention where the first letter of each word is capitalized and separated by spaces.
+
+```typescript
+import { startCase } from 'es-toolkit/compat';
+
+// Convert regular string
+startCase('hello world');
+// Returns: 'Hello World'
+
+// Keep words that are already uppercase
+startCase('HELLO WORLD');
+// Returns: 'HELLO WORLD'
+
+// Convert hyphen-separated string
+startCase('hello-world');
+// Returns: 'Hello World'
+
+// Convert underscore-separated string
+startCase('hello_world');
+// Returns: 'Hello World'
+```
+
+`null` or `undefined` are treated as empty strings.
+
+```typescript
+import { startCase } from 'es-toolkit/compat';
+
+startCase(null); // ''
+startCase(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to convert to start case.
+
+#### Returns
+
+(`string`): Returns the start case converted string.
diff --git a/docs/reference/compat/string/startsWith.md b/docs/compat/reference/string/startsWith.md
similarity index 100%
rename from docs/reference/compat/string/startsWith.md
rename to docs/compat/reference/string/startsWith.md
diff --git a/docs/reference/compat/string/template.md b/docs/compat/reference/string/template.md
similarity index 100%
rename from docs/reference/compat/string/template.md
rename to docs/compat/reference/string/template.md
diff --git a/docs/reference/compat/string/toLower.md b/docs/compat/reference/string/toLower.md
similarity index 100%
rename from docs/reference/compat/string/toLower.md
rename to docs/compat/reference/string/toLower.md
diff --git a/docs/reference/compat/string/toUpper.md b/docs/compat/reference/string/toUpper.md
similarity index 100%
rename from docs/reference/compat/string/toUpper.md
rename to docs/compat/reference/string/toUpper.md
diff --git a/docs/compat/reference/string/trim.md b/docs/compat/reference/string/trim.md
new file mode 100644
index 000000000..5f02a018d
--- /dev/null
+++ b/docs/compat/reference/string/trim.md
@@ -0,0 +1,55 @@
+# trim (Lodash Compatibility)
+
+::: warning Use `trim` from `es-toolkit`
+
+This `trim` function operates slowly due to handling `null` or `undefined` and array-type `chars`.
+
+Use the faster and more modern [trim](../../../reference/string/trim.md) from `es-toolkit` instead.
+
+:::
+
+Removes leading and trailing whitespace or specified characters from a string.
+
+```typescript
+const trimmed = trim(str, chars);
+```
+
+## Usage
+
+### `trim(str, chars)`
+
+Use `trim` when you want to remove whitespace or specific characters from the beginning and end of a string. If `chars` is not specified, only leading and trailing whitespace will be removed.
+
+```typescript
+import { trim } from 'es-toolkit/compat';
+
+// Remove leading and trailing whitespace
+trim(' hello ');
+// Returns: 'hello'
+
+// Remove specified characters
+trim('--hello--', '-');
+// Returns: 'hello'
+
+// Remove multiple characters with an array
+trim('##hello##', ['#', 'o']);
+// Returns: 'hell'
+```
+
+`null` or `undefined` is treated as an empty string.
+
+```typescript
+import { trim } from 'es-toolkit/compat';
+
+trim(null); // ''
+trim(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to trim.
+- `chars` (`string`, optional): The characters to remove. If not specified, whitespace will be removed.
+
+#### Returns
+
+(`string`): Returns the string with specified characters removed from the beginning and end.
diff --git a/docs/compat/reference/string/trimEnd.md b/docs/compat/reference/string/trimEnd.md
new file mode 100644
index 000000000..a25202fb4
--- /dev/null
+++ b/docs/compat/reference/string/trimEnd.md
@@ -0,0 +1,55 @@
+# trimEnd (Lodash Compatibility)
+
+::: warning Use `trimEnd` from `es-toolkit`
+
+This `trimEnd` function operates slowly due to handling `null` or `undefined` and parameter order changes.
+
+Use the faster and more modern [trimEnd](../../../reference/string/trimEnd.md) from `es-toolkit` instead.
+
+:::
+
+Removes trailing whitespace or specified characters from a string.
+
+```typescript
+const trimmed = trimEnd(str, chars);
+```
+
+## Usage
+
+### `trimEnd(str, chars)`
+
+Use `trimEnd` when you want to remove whitespace or specific characters from the end of a string. If `chars` is not specified, only trailing whitespace will be removed.
+
+```typescript
+import { trimEnd } from 'es-toolkit/compat';
+
+// Remove trailing whitespace
+trimEnd(' abc ');
+// Returns: ' abc'
+
+// Remove specified characters
+trimEnd('-_-abc-_-', '_-');
+// Returns: '-_-abc'
+
+// Only applies to the end of the string
+trimEnd('abc', 'a');
+// Returns: 'abc'
+```
+
+`null` or `undefined` is treated as an empty string.
+
+```typescript
+import { trimEnd } from 'es-toolkit/compat';
+
+trimEnd(null); // ''
+trimEnd(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to trim from the end.
+- `chars` (`string`, optional): The characters to remove. If not specified, whitespace will be removed.
+
+#### Returns
+
+(`string`): Returns the string with specified characters removed from the end.
diff --git a/docs/compat/reference/string/trimStart.md b/docs/compat/reference/string/trimStart.md
new file mode 100644
index 000000000..abf2c02e0
--- /dev/null
+++ b/docs/compat/reference/string/trimStart.md
@@ -0,0 +1,55 @@
+# trimStart (Lodash Compatibility)
+
+::: warning Use `trimStart` from `es-toolkit`
+
+This `trimStart` function operates slowly due to handling `null` or `undefined` and parameter order changes.
+
+Use the faster and more modern [trimStart](../../../reference/string/trimStart.md) from `es-toolkit` instead.
+
+:::
+
+Removes leading whitespace or specified characters from a string.
+
+```typescript
+const trimmed = trimStart(str, chars);
+```
+
+## Usage
+
+### `trimStart(str, chars)`
+
+Use `trimStart` when you want to remove whitespace or specific characters from the beginning of a string. If `chars` is not specified, only leading whitespace will be removed.
+
+```typescript
+import { trimStart } from 'es-toolkit/compat';
+
+// Remove leading whitespace
+trimStart(' abc ');
+// Returns: 'abc '
+
+// Remove specified characters
+trimStart('-_-abc-_-', '_-');
+// Returns: 'abc-_-'
+
+// Only applies to the beginning of the string
+trimStart('abc', 'c');
+// Returns: 'abc'
+```
+
+`null` or `undefined` is treated as an empty string.
+
+```typescript
+import { trimStart } from 'es-toolkit/compat';
+
+trimStart(null); // ''
+trimStart(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to trim from the beginning.
+- `chars` (`string`, optional): The characters to remove. If not specified, whitespace will be removed.
+
+#### Returns
+
+(`string`): Returns the string with specified characters removed from the beginning.
diff --git a/docs/reference/compat/string/truncate.md b/docs/compat/reference/string/truncate.md
similarity index 100%
rename from docs/reference/compat/string/truncate.md
rename to docs/compat/reference/string/truncate.md
diff --git a/docs/compat/reference/string/unescape.md b/docs/compat/reference/string/unescape.md
new file mode 100644
index 000000000..b5dc2d264
--- /dev/null
+++ b/docs/compat/reference/string/unescape.md
@@ -0,0 +1,58 @@
+# unescape (Lodash Compatibility)
+
+::: warning Use `unescape` from `es-toolkit`
+
+This `unescape` function operates slowly due to conversion logic for handling `null` or `undefined`.
+
+Use the faster and more modern [unescape](../../../reference/string/unescape.md) from `es-toolkit` instead.
+
+:::
+
+Converts HTML entities to their original characters.
+
+```typescript
+const unescaped = unescape(str);
+```
+
+## Usage
+
+### `unescape(str)`
+
+Use `unescape` when you want to convert HTML entities `&`, `<`, `>`, `"`, `'` back to their original characters. This is the reverse operation of the `escape` function.
+
+```typescript
+import { unescape } from 'es-toolkit/compat';
+
+// Unescape HTML tags
+unescape('This is a <div> element.');
+// Returns: 'This is a
element.'
+
+// Unescape quotes
+unescape('This is a "quote"');
+// Returns: 'This is a "quote"'
+
+// Unescape apostrophes
+unescape('This is a 'quote'');
+// Returns: 'This is a 'quote''
+
+// Unescape ampersands
+unescape('This is a & symbol');
+// Returns: 'This is a & symbol'
+```
+
+`null` or `undefined` is treated as an empty string.
+
+```typescript
+import { unescape } from 'es-toolkit/compat';
+
+unescape(null); // ''
+unescape(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to unescape.
+
+#### Returns
+
+(`string`): Returns the string with HTML entities converted to their original characters.
diff --git a/docs/compat/reference/string/upperCase.md b/docs/compat/reference/string/upperCase.md
new file mode 100644
index 000000000..1f5a40b01
--- /dev/null
+++ b/docs/compat/reference/string/upperCase.md
@@ -0,0 +1,58 @@
+# upperCase (Lodash Compatibility)
+
+::: warning Use `upperCase` from `es-toolkit`
+
+This `upperCase` function operates slowly due to normalization logic for handling `null` or `undefined`.
+
+Use the faster and more modern [upperCase](../../../reference/string/upperCase.md) from `es-toolkit` instead.
+
+:::
+
+Converts a string to upper case.
+
+```typescript
+const upperCased = upperCase(str);
+```
+
+## Usage
+
+### `upperCase(str)`
+
+Use `upperCase` when you want to convert a string to upper case (UPPER CASE). Upper case is a naming convention where each word is written in uppercase and connected with spaces.
+
+```typescript
+import { upperCase } from 'es-toolkit/compat';
+
+// Convert camel case
+upperCase('camelCase');
+// Returns: 'CAMEL CASE'
+
+// Convert space-separated string
+upperCase('some whitespace');
+// Returns: 'SOME WHITESPACE'
+
+// Convert hyphen-separated string
+upperCase('hyphen-text');
+// Returns: 'HYPHEN TEXT'
+
+// When uppercase letters appear consecutively
+upperCase('HTTPRequest');
+// Returns: 'HTTP REQUEST'
+```
+
+`null` or `undefined` is treated as an empty string.
+
+```typescript
+import { upperCase } from 'es-toolkit/compat';
+
+upperCase(null); // ''
+upperCase(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to convert to upper case.
+
+#### Returns
+
+(`string`): Returns the string converted to upper case.
diff --git a/docs/compat/reference/string/upperFirst.md b/docs/compat/reference/string/upperFirst.md
new file mode 100644
index 000000000..52ec9ace8
--- /dev/null
+++ b/docs/compat/reference/string/upperFirst.md
@@ -0,0 +1,54 @@
+# upperFirst (Lodash Compatibility)
+
+::: warning Use `upperFirst` from `es-toolkit`
+
+This `upperFirst` function operates slowly due to conversion logic for handling `null` or `undefined`.
+
+Use the faster and more modern [upperFirst](../../../reference/string/upperFirst.md) from `es-toolkit` instead.
+
+:::
+
+Converts the first character of a string to uppercase.
+
+```typescript
+const upperCased = upperFirst(str);
+```
+
+## Usage
+
+### `upperFirst(str)`
+
+Use `upperFirst` when you want to capitalize only the first character of a string. The remaining characters stay unchanged.
+
+```typescript
+import { upperFirst } from 'es-toolkit/compat';
+
+// String starting with lowercase
+upperFirst('fred');
+// Returns: 'Fred'
+
+// String already starting with uppercase
+upperFirst('Fred');
+// Returns: 'Fred'
+
+// All uppercase string
+upperFirst('FRED');
+// Returns: 'FRED'
+```
+
+`null` or `undefined` is treated as an empty string.
+
+```typescript
+import { upperFirst } from 'es-toolkit/compat';
+
+upperFirst(null); // ''
+upperFirst(undefined); // ''
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to convert the first character to uppercase.
+
+#### Returns
+
+(`string`): Returns the string with the first character converted to uppercase.
diff --git a/docs/compat/reference/string/words.md b/docs/compat/reference/string/words.md
new file mode 100644
index 000000000..1e1d21305
--- /dev/null
+++ b/docs/compat/reference/string/words.md
@@ -0,0 +1,69 @@
+# words (Lodash Compatibility)
+
+::: warning Use `words` from `es-toolkit`
+
+This `words` function operates slowly due to handling `null` or `undefined` and complex Unicode support.
+
+Use the faster and more modern [words](../../../reference/string/words.md) from `es-toolkit` instead.
+
+:::
+
+Splits a string into an array of words.
+
+```typescript
+const wordArray = words(str, pattern);
+```
+
+## Usage
+
+### `words(str, pattern)`
+
+Use `words` when you want to split a string into words. By default, it recognizes English letters, numbers, emojis, etc., to extract words.
+
+```typescript
+import { words } from 'es-toolkit/compat';
+
+// Basic word extraction
+words('fred, barney, & pebbles');
+// Returns: ['fred', 'barney', 'pebbles']
+
+// Extract words from camel case
+words('camelCaseWord');
+// Returns: ['camel', 'Case', 'Word']
+
+// String with numbers
+words('hello123world');
+// Returns: ['hello', '123', 'world']
+```
+
+You can also extract words using a custom pattern.
+
+```typescript
+import { words } from 'es-toolkit/compat';
+
+// Extract words using regex
+words('hello world', /\w+/g);
+// Returns: ['hello', 'world']
+
+// Use string pattern
+words('one-two-three', '-');
+// Returns: ['-']
+```
+
+`null` or `undefined` is treated as an empty array.
+
+```typescript
+import { words } from 'es-toolkit/compat';
+
+words(null); // []
+words(undefined); // []
+```
+
+#### Parameters
+
+- `str` (`string`, optional): The string to split into words.
+- `pattern` (`RegExp | string`, optional): The pattern to match words. Defaults to a built-in Unicode word pattern.
+
+#### Returns
+
+(`string[]`): Returns an array of extracted words.
diff --git a/docs/reference/compat/util/bindAll.md b/docs/compat/reference/util/bindAll.md
similarity index 100%
rename from docs/reference/compat/util/bindAll.md
rename to docs/compat/reference/util/bindAll.md
diff --git a/docs/reference/compat/util/cond.md b/docs/compat/reference/util/cond.md
similarity index 100%
rename from docs/reference/compat/util/cond.md
rename to docs/compat/reference/util/cond.md
diff --git a/docs/reference/compat/util/constant.md b/docs/compat/reference/util/constant.md
similarity index 100%
rename from docs/reference/compat/util/constant.md
rename to docs/compat/reference/util/constant.md
diff --git a/docs/reference/compat/util/defaultTo.md b/docs/compat/reference/util/defaultTo.md
similarity index 100%
rename from docs/reference/compat/util/defaultTo.md
rename to docs/compat/reference/util/defaultTo.md
diff --git a/docs/reference/compat/util/eq.md b/docs/compat/reference/util/eq.md
similarity index 100%
rename from docs/reference/compat/util/eq.md
rename to docs/compat/reference/util/eq.md
diff --git a/docs/reference/compat/util/gt.md b/docs/compat/reference/util/gt.md
similarity index 100%
rename from docs/reference/compat/util/gt.md
rename to docs/compat/reference/util/gt.md
diff --git a/docs/reference/compat/util/gte.md b/docs/compat/reference/util/gte.md
similarity index 100%
rename from docs/reference/compat/util/gte.md
rename to docs/compat/reference/util/gte.md
diff --git a/docs/reference/compat/util/invoke.md b/docs/compat/reference/util/invoke.md
similarity index 100%
rename from docs/reference/compat/util/invoke.md
rename to docs/compat/reference/util/invoke.md
diff --git a/docs/reference/compat/util/iteratee.md b/docs/compat/reference/util/iteratee.md
similarity index 100%
rename from docs/reference/compat/util/iteratee.md
rename to docs/compat/reference/util/iteratee.md
diff --git a/docs/reference/compat/util/lt.md b/docs/compat/reference/util/lt.md
similarity index 100%
rename from docs/reference/compat/util/lt.md
rename to docs/compat/reference/util/lt.md
diff --git a/docs/reference/compat/util/lte.md b/docs/compat/reference/util/lte.md
similarity index 100%
rename from docs/reference/compat/util/lte.md
rename to docs/compat/reference/util/lte.md
diff --git a/docs/reference/compat/util/method.md b/docs/compat/reference/util/method.md
similarity index 100%
rename from docs/reference/compat/util/method.md
rename to docs/compat/reference/util/method.md
diff --git a/docs/reference/compat/util/methodOf.md b/docs/compat/reference/util/methodOf.md
similarity index 100%
rename from docs/reference/compat/util/methodOf.md
rename to docs/compat/reference/util/methodOf.md
diff --git a/docs/reference/compat/util/now.md b/docs/compat/reference/util/now.md
similarity index 100%
rename from docs/reference/compat/util/now.md
rename to docs/compat/reference/util/now.md
diff --git a/docs/reference/compat/util/over.md b/docs/compat/reference/util/over.md
similarity index 100%
rename from docs/reference/compat/util/over.md
rename to docs/compat/reference/util/over.md
diff --git a/docs/reference/compat/util/overEvery.md b/docs/compat/reference/util/overEvery.md
similarity index 100%
rename from docs/reference/compat/util/overEvery.md
rename to docs/compat/reference/util/overEvery.md
diff --git a/docs/reference/compat/util/overSome.md b/docs/compat/reference/util/overSome.md
similarity index 100%
rename from docs/reference/compat/util/overSome.md
rename to docs/compat/reference/util/overSome.md
diff --git a/docs/reference/compat/util/stubArray.md b/docs/compat/reference/util/stubArray.md
similarity index 100%
rename from docs/reference/compat/util/stubArray.md
rename to docs/compat/reference/util/stubArray.md
diff --git a/docs/reference/compat/util/stubFalse.md b/docs/compat/reference/util/stubFalse.md
similarity index 100%
rename from docs/reference/compat/util/stubFalse.md
rename to docs/compat/reference/util/stubFalse.md
diff --git a/docs/reference/compat/util/stubObject.md b/docs/compat/reference/util/stubObject.md
similarity index 100%
rename from docs/reference/compat/util/stubObject.md
rename to docs/compat/reference/util/stubObject.md
diff --git a/docs/reference/compat/util/stubString.md b/docs/compat/reference/util/stubString.md
similarity index 100%
rename from docs/reference/compat/util/stubString.md
rename to docs/compat/reference/util/stubString.md
diff --git a/docs/reference/compat/util/stubTrue.md b/docs/compat/reference/util/stubTrue.md
similarity index 100%
rename from docs/reference/compat/util/stubTrue.md
rename to docs/compat/reference/util/stubTrue.md
diff --git a/docs/reference/compat/util/times.md b/docs/compat/reference/util/times.md
similarity index 100%
rename from docs/reference/compat/util/times.md
rename to docs/compat/reference/util/times.md
diff --git a/docs/reference/compat/util/toArray.md b/docs/compat/reference/util/toArray.md
similarity index 100%
rename from docs/reference/compat/util/toArray.md
rename to docs/compat/reference/util/toArray.md
diff --git a/docs/reference/compat/util/toFinite.md b/docs/compat/reference/util/toFinite.md
similarity index 100%
rename from docs/reference/compat/util/toFinite.md
rename to docs/compat/reference/util/toFinite.md
diff --git a/docs/reference/compat/util/toInteger.md b/docs/compat/reference/util/toInteger.md
similarity index 100%
rename from docs/reference/compat/util/toInteger.md
rename to docs/compat/reference/util/toInteger.md
diff --git a/docs/reference/compat/util/toLength.md b/docs/compat/reference/util/toLength.md
similarity index 100%
rename from docs/reference/compat/util/toLength.md
rename to docs/compat/reference/util/toLength.md
diff --git a/docs/reference/compat/util/toNumber.md b/docs/compat/reference/util/toNumber.md
similarity index 100%
rename from docs/reference/compat/util/toNumber.md
rename to docs/compat/reference/util/toNumber.md
diff --git a/docs/reference/compat/util/toPath.md b/docs/compat/reference/util/toPath.md
similarity index 100%
rename from docs/reference/compat/util/toPath.md
rename to docs/compat/reference/util/toPath.md
diff --git a/docs/reference/compat/util/toPlainObject.md b/docs/compat/reference/util/toPlainObject.md
similarity index 100%
rename from docs/reference/compat/util/toPlainObject.md
rename to docs/compat/reference/util/toPlainObject.md
diff --git a/docs/reference/compat/util/toSafeInteger.md b/docs/compat/reference/util/toSafeInteger.md
similarity index 100%
rename from docs/reference/compat/util/toSafeInteger.md
rename to docs/compat/reference/util/toSafeInteger.md
diff --git a/docs/reference/compat/util/toString.md b/docs/compat/reference/util/toString.md
similarity index 100%
rename from docs/reference/compat/util/toString.md
rename to docs/compat/reference/util/toString.md
diff --git a/docs/reference/compat/util/uniqueId.md b/docs/compat/reference/util/uniqueId.md
similarity index 100%
rename from docs/reference/compat/util/uniqueId.md
rename to docs/compat/reference/util/uniqueId.md
diff --git a/docs/compatibility.md b/docs/compatibility.md
deleted file mode 100644
index 9e6368615..000000000
--- a/docs/compatibility.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# Compatibility with Lodash
-
-::: tip ✅ Starting with version 1.39.3, we ensure 100% compatibility with Lodash
-
-`es-toolkit/compat` functions exactly like all Lodash functions while being lighter and faster.
-
-- It ensures identical behavior with Lodash's actual test code.
-- It has been adopted by popular open-source projects including Storybook, Recharts, and CKEditor, and is recommended by Nuxt.
-
-For detailed documentation of all available compat functions, check out our [Compat Reference](/reference/compat/array/castArray).
-
-:::
-
-```tsx
-// es-toolkit/compat aims to provide 100% feature parity with lodash
-import { chunk } from 'es-toolkit/compat';
-
-chunk([1, 2, 3, 4], 0);
-// Returns [], which is identical to lodash
-```
-
-For maximum compatibility with `lodash`, use `es-toolkit/compat`, a compatibility layer that bridges the gap between the two libraries.
-
-This module is designed to provide an identical API to `lodash`, making it easier to switch between the two libraries.
-
-`es-toolkit/compat` has been thoroughly tested with real test cases from `lodash`.
-
-It's important to note that `es-toolkit/compat` may have a slight performance impact and a larger bundle size compared to the original `es-toolkit`. This module is designed to facilitate a smooth transition and should be replaced with the original `es-toolkit` for optimal performance once the migration is complete.
-
-## Design Principles
-
-::: info
-Design principles are subject to change.
-:::
-
-Our compatibility layer aims to achieve feature parity with 100% accuracy for:
-
-- Features that are written as a test case in lodash.
-- Features that can be inferred from types of `@types/lodash` or `@types/lodash-es`.
-- Feature differences identified while migrating code from lodash to es-toolkit (please report these to our [issues page](https://github.com/toss/es-toolkit/issues)).
-
-However, the following are out of scope for `es-toolkit/compat`:
-
-- Implicit type conversions, such as converting an empty string to zero or false.
-- Functions that have specialized implementations for specific types of arrays, like [sortedUniq](https://lodash.com/docs/4.17.15#sortedUniq).
-- Handling cases where internal object prototypes, like `Array.prototype`, have been modified.
-- Managing cases with JavaScript realms.
-- Method chaining support through "Seq" methods.
-
-## Implementation Status
-
-::: info
-The following emojis indicate the status of each feature:
-
-- ✅: Completed (The function is fully implemented and has passed all tests with lodash test code.)
-- 📝: In Review (The function is implemented but hasn't been tested with lodash test code yet.)
-- ❌: Not Implemented (The function hasn't been implemented.)
-
-Even if a feature is marked "in review," it might already be under review to ensure it matches lodash perfectly, and it could already offer the same functionality.
-:::
-
-
diff --git a/docs/index.md b/docs/index.md
index c29ed8e2d..c456c7c6f 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -29,7 +29,7 @@ features:
details: es-toolkit ships up to 97% less JavaScript code compared to other alternative libraries.
- title: Seamless Lodash replacement
details: es-toolkit offers a complete compatibility layer to seamlessly replace Lodash.
- link: /compatibility
+ link: /compat/intro
- title: Modern implementation
details: es-toolkit fully leverages modern JavaScript APIs for straightforward and error-free implementation.
- title: Robust types
diff --git a/docs/ja/compat/intro.md b/docs/ja/compat/intro.md
new file mode 100644
index 000000000..4e1149675
--- /dev/null
+++ b/docs/ja/compat/intro.md
@@ -0,0 +1,66 @@
+# es-toolkit/compat
+
+`es-toolkit/compat`は、[Lodash](https://lodash.com)と同じインターフェースと動作を提供するモジュールです。Lodashを使っている既存のコードをそのままにしたまま、少しずつ`es-toolkit`へ移行できるように作られています。
+
+既存のプロジェクトでLodashを使っていないなら、[`es-toolkit`](/ja/intro)を使ってください。
+
+::: tip ✅ 1.39.3からLodashと100%の互換性を保証しています
+Lodash自身のテストコードをそのまま通過します。動作は同じまま、より軽く高速です。
+:::
+
+```ts
+// lodashと同じ呼び出しの形を es-toolkit/compat でそのまま使えます
+import { chunk } from 'es-toolkit/compat';
+
+chunk([1, 2, 3, 4], 0);
+// [] を返します。lodashと同じです。
+```
+
+## マイグレーションの流れ
+
+既存のコードからLodashを取り除くときは、次の流れをおすすめします。
+
+1. `lodash` / `lodash-es`のimportパスを`es-toolkit/compat`に変えてください。呼び出し側のコードはそのままで大丈夫です。
+2. 時間をかけて呼び出し側を整理しつつ、importを[`es-toolkit`](/ja/intro)に切り替えてください。すべて移行できれば、バンドルがより小さく、より高速になります。
+
+## `es-toolkit`との違い
+
+- **APIの形**: Lodashと1:1で一致しています。暗黙的な型変換、さまざまな引数の形、非推奨のヘルパーまでそのまま含まれます。[`es-toolkit`](/ja/intro)は型安全で整理された形だけを提供します。
+- **バンドルサイズと速度**: [`es-toolkit`](/ja/intro)より少し大きく、少し遅いです。Lodashと動作を合わせるための追加処理が入っているためです。
+- **非推奨の関数**: Lodashで非推奨になった関数も互換性のために`compat`には残っていますが、[`es-toolkit`](/ja/intro)には含まれません。マイグレーション中に一緒に整理してください。
+
+関数ごとの詳細なドキュメントは[互換性リファレンス](/ja/compat/reference/array/castArray)をご覧ください。
+
+## 設計原則
+
+::: info
+`es-toolkit/compat`の設計原則の方向性は変わる可能性があります。
+:::
+
+`es-toolkit/compat`は、次の機能について`lodash`と100%同じ機能を提供することを目指しています。
+
+- `lodash`のテストケースとして書かれている機能
+- `@types/lodash`または`@types/lodash-es`の型から推測できる機能
+- `lodash`から`es-toolkit`へコードをマイグレーションする際に見つかった機能の違い（[Issuesページ](https://github.com/toss/es-toolkit/issues)に報告してください）
+
+ただし、以下は`es-toolkit/compat`の対象外です。
+
+- 暗黙的な型変換: 空文字列を0またはfalseに変換するような動作
+- 特殊なケースに最適化された実装: [sortedUniq](https://lodash.com/docs/4.17.15#sortedUniq)のように、ソートされた配列だけを受け取る関数
+- `Array.prototype`のような組み込みオブジェクトのプロトタイプが変更されたケースへの対応
+- JavaScript Realmへの対応
+- メソッドチェーン: `_(arr).map(...).filter(...)`のようなメソッドチェーン
+
+## 実装状況
+
+::: info
+以下の絵文字で、各機能の現在の状態を表しています。
+
+- ✅: 完了（実装されており、lodashのテストコードをすべて通過しています）
+- 📝: レビュー中（実装されていますが、lodashのテストコードでテストされていません）
+- ❌: 未実装
+
+「レビュー中」と書かれていても、すでにlodashと100%同じ機能を提供している場合があります。
+:::
+
+
diff --git a/docs/ja/reference/compat/array/castArray.md b/docs/ja/compat/reference/array/castArray.md
similarity index 100%
rename from docs/ja/reference/compat/array/castArray.md
rename to docs/ja/compat/reference/array/castArray.md
diff --git a/docs/ja/compat/reference/array/chunk.md b/docs/ja/compat/reference/array/chunk.md
new file mode 100644
index 000000000..1f4a655aa
--- /dev/null
+++ b/docs/ja/compat/reference/array/chunk.md
@@ -0,0 +1,70 @@
+# chunk（Lodash 互換性）
+
+::: warning `es-toolkit` の [`chunk`](../../../reference/array/chunk.md) を使用してください
+
+この `chunk` 関数は `null`、`undefined` の処理、`size` のデフォルト値処理などにより動作が遅くなります。
+
+より高速でモダンな実装である `es-toolkit` の [chunk](../../../reference/array/chunk.md) を使用してください。
+
+:::
+
+配列を指定されたサイズの小さな配列に分割します。
+
+```typescript
+const chunked = chunk(arr, size);
+```
+
+## 使用法
+
+### `chunk(arr, size?)`
+
+長い配列を同じサイズの複数の小さな配列に分割したい場合は `chunk` を使用します。配列を均等に分割できない場合、最後の配列に残りの要素が含まれます。
+
+```typescript
+import { chunk } from 'es-toolkit/compat';
+
+// 数値配列をサイズ 2 のチャンクに分割します。
+chunk([1, 2, 3, 4], 2);
+// 戻り値: [[1, 2], [3, 4]]
+
+// 文字列配列をサイズ 3 のチャンクに分割します。
+chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+// 戻り値: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+
+// 均等に分割できない場合
+chunk([1, 2, 3, 4, 5], 2);
+// 戻り値: [[1, 2], [3, 4], [5]]
+```
+
+`null` または `undefined` は空の配列として扱われます。
+
+```typescript
+import { chunk } from 'es-toolkit/compat';
+
+chunk(null, 2);
+// 戻り値: []
+
+chunk(undefined, 2);
+// 戻り値: []
+```
+
+サイズが 0 または負の場合、空の配列を返します。
+
+```typescript
+import { chunk } from 'es-toolkit/compat';
+
+chunk([1, 2, 3], 0);
+// 戻り値: []
+
+chunk([1, 2, 3], -1);
+// 戻り値: []
+```
+
+#### パラメータ
+
+- `arr` (`ArrayLike
| null | undefined`): 分割する配列。
+- `size` (`number`, オプション): 各小さな配列のサイズ。デフォルト値は `1`。
+
+#### 戻り値
+
+(`T[][]`): サイズ `size` で分割された二次元配列を返します。
diff --git a/docs/ja/compat/reference/array/compact.md b/docs/ja/compat/reference/array/compact.md
new file mode 100644
index 000000000..4db8918f9
--- /dev/null
+++ b/docs/ja/compat/reference/array/compact.md
@@ -0,0 +1,77 @@
+# compact (Lodash 互換性)
+
+::: warning `es-toolkit`の[`compact`](../../../reference/array/compact.md)を使用してください
+
+この `compact` 関数は、`null` や `undefined` の処理、`size` のデフォルト値処理などにより、動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [compact](../../../reference/array/compact.md) を使用してください。
+
+:::
+
+配列から偽値と評価される値を削除します。
+
+```typescript
+const compacted = compact(arr);
+```
+
+## 使用法
+
+### `compact(arr)`
+
+配列から `false`、`null`、`0`、`""`、`undefined`、`NaN` のような偽値と評価される値を削除したい場合、`compact` を使用してください。
+
+```typescript
+import { compact } from 'es-toolkit/compat';
+
+// 偽値と評価される値を削除
+compact([0, 1, false, 2, '', 3]);
+// Returns: [1, 2, 3]
+
+compact(['a', null, 'b', undefined, 'c', NaN]);
+// Returns: ['a', 'b', 'c']
+
+// BigInt 0も削除
+compact([0n, 1n, false, 2n]);
+// Returns: [1n, 2n]
+
+// 空配列も処理
+compact([]);
+// Returns: []
+
+// すべての値が偽値と評価される場合
+compact([false, null, 0, '', undefined, NaN]);
+// Returns: []
+```
+
+真値と評価される値はそのまま保持されます。
+
+```typescript
+import { compact } from 'es-toolkit/compat';
+
+compact([1, 'hello', true, {}, []]);
+// Returns: [1, 'hello', true, {}, []]
+
+// 0以外の数値
+compact([0, -1, 2, -3]);
+// Returns: [-1, 2, -3]
+```
+
+`null` や `undefined` の配列は空配列として処理されます。
+
+```typescript
+import { compact } from 'es-toolkit/compat';
+
+compact(null);
+// Returns: []
+
+compact(undefined);
+// Returns: []
+```
+
+#### パラメータ
+
+- `arr` (`ArrayLike | null | undefined`): 圧縮する配列です。
+
+#### 戻り値
+
+(`T[]`): 偽値と評価される値が削除された新しい配列を返します。
diff --git a/docs/ja/reference/compat/array/concat.md b/docs/ja/compat/reference/array/concat.md
similarity index 100%
rename from docs/ja/reference/compat/array/concat.md
rename to docs/ja/compat/reference/array/concat.md
diff --git a/docs/ja/compat/reference/array/countBy.md b/docs/ja/compat/reference/array/countBy.md
new file mode 100644
index 000000000..7da6a3949
--- /dev/null
+++ b/docs/ja/compat/reference/array/countBy.md
@@ -0,0 +1,88 @@
+# countBy (Lodash 互換性)
+
+::: warning `es-toolkit`の`countBy`を使用してください
+
+この `countBy` 関数は、複雑な変換関数処理と型変換により、動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [countBy](../../../reference/array/countBy.md) を使用してください。
+
+:::
+
+配列やオブジェクトの要素を条件に従って分類し、各分類の個数を数えます。
+
+```typescript
+const counts = countBy(collection, iteratee);
+```
+
+## 使用法
+
+### `countBy(collection, iteratee?)`
+
+配列やオブジェクトの各要素をある基準でグループ化し、各グループに何個の要素があるかを数えたい場合、`countBy` を使用してください。反復関数が返す値がキーになり、そのキーに該当する要素の個数が値になります。
+
+```typescript
+import { countBy } from 'es-toolkit/compat';
+
+// 数値を小数点以下切り捨てでグループ化
+countBy([6.1, 4.2, 6.3], Math.floor);
+// Returns: { '4': 1, '6': 2 }
+
+// 文字列を長さでグループ化
+countBy(['one', 'two', 'three'], 'length');
+// Returns: { '3': 2, '5': 1 }
+
+// ユーザーを年齢代でグループ化
+const users = [
+ { name: 'Alice', age: 25 },
+ { name: 'Bob', age: 35 },
+ { name: 'Charlie', age: 25 },
+];
+countBy(users, user => Math.floor(user.age / 10) * 10);
+// Returns: { '20': 2, '30': 1 }
+```
+
+オブジェクトも処理できます。
+
+```typescript
+import { countBy } from 'es-toolkit/compat';
+
+// オブジェクトの値を型で分類
+const obj = { a: 1, b: 'string', c: 2, d: 'text' };
+countBy(obj, value => typeof value);
+// Returns: { 'number': 2, 'string': 2 }
+```
+
+反復関数なしで使用すると、値そのものでグループ化されます。
+
+```typescript
+import { countBy } from 'es-toolkit/compat';
+
+// 値そのものでグループ化
+countBy([1, 2, 1, 3, 2, 1]);
+// Returns: { '1': 3, '2': 2, '3': 1 }
+
+// 真偽値でグループ化
+countBy([true, false, true, true]);
+// Returns: { 'true': 3, 'false': 1 }
+```
+
+`null` や `undefined` のコレクションは空のオブジェクトを返します。
+
+```typescript
+import { countBy } from 'es-toolkit/compat';
+
+countBy(null);
+// Returns: {}
+
+countBy(undefined);
+// Returns: {}
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | object | null | undefined`): 処理する配列またはオブジェクトです。
+- `iteratee` (`ValueIteratee`, 選択): 各要素をグループ化する基準を決定する関数です。関数、プロパティ名、または部分オブジェクトを使用できます。
+
+#### 戻り値
+
+(`Record`): 各グループのキーとそのグループの要素数を持つオブジェクトを返します。
diff --git a/docs/ja/compat/reference/array/difference.md b/docs/ja/compat/reference/array/difference.md
new file mode 100644
index 000000000..deafea7a3
--- /dev/null
+++ b/docs/ja/compat/reference/array/difference.md
@@ -0,0 +1,94 @@
+# difference (Lodash 互換性)
+
+::: warning `es-toolkit`の`difference`を使用してください
+
+この `difference` 関数は、`null` や `undefined` の処理、複数の配列引数処理により、複雑に動作します。
+
+代わりに、より高速で現代的な `es-toolkit` の [difference](../../../reference/array/difference.md) を使用してください。
+
+:::
+
+最初の配列から他の配列の値を除いた差集合を求めます。
+
+```typescript
+const result = difference(arr, ...values);
+```
+
+## 使用法
+
+### `difference(arr, ...values)`
+
+最初の配列から残りの配列に含まれる値をすべて削除したい場合、`difference` を使用してください。順序は最初の配列の順序を保持します。
+
+```typescript
+import { difference } from 'es-toolkit/compat';
+
+// 基本的な使用法
+const array1 = [1, 2, 3, 4, 5];
+const array2 = [2, 4];
+const array3 = [5, 6];
+difference(array1, array2, array3);
+// Returns: [1, 3]
+
+// 文字列配列
+difference(['a', 'b', 'c'], ['b'], ['c', 'd']);
+// Returns: ['a']
+
+// 重複する値の処理
+difference([1, 2, 2, 3], [2]);
+// Returns: [1, 3]
+```
+
+空配列や空の差集合も処理します。
+
+```typescript
+import { difference } from 'es-toolkit/compat';
+
+// 空配列との差集合
+difference([1, 2, 3], []);
+// Returns: [1, 2, 3]
+
+// すべての値が除外される場合
+difference([1, 2, 3], [1, 2, 3]);
+// Returns: []
+
+// 重複する値がない場合
+difference([1, 2], [3, 4]);
+// Returns: [1, 2]
+```
+
+`null` や `undefined` の配列は空配列として処理されます。
+
+```typescript
+import { difference } from 'es-toolkit/compat';
+
+difference(null, [1, 2]);
+// Returns: []
+
+difference(undefined, [1, 2]);
+// Returns: []
+
+difference([1, 2, 3], null, undefined);
+// Returns: [1, 2, 3] (nullとundefinedは無視されます)
+```
+
+配列風オブジェクトもサポートします。
+
+```typescript
+import { difference } from 'es-toolkit/compat';
+
+// 配列風オブジェクト
+const arrayLike1 = { 0: 1, 1: 2, 2: 3, length: 3 };
+const arrayLike2 = { 0: 2, 1: 4, length: 2 };
+difference(arrayLike1, arrayLike2);
+// Returns: [1, 3]
+```
+
+#### パラメータ
+
+- `arr` (`ArrayLike | null | undefined`): 差集合を求める基準配列です。
+- `values` (`...ArrayLike[]`): 除外する値を含む配列です。
+
+#### 戻り値
+
+(`T[]`): 最初の配列から他の配列の値を除いた新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/differenceBy.md b/docs/ja/compat/reference/array/differenceBy.md
new file mode 100644
index 000000000..0bf4afa05
--- /dev/null
+++ b/docs/ja/compat/reference/array/differenceBy.md
@@ -0,0 +1,88 @@
+# differenceBy (Lodash 互換性)
+
+::: warning `es-toolkit`の`differenceBy`を使用してください
+
+この `differenceBy` 関数は、複雑な引数処理と反復子変換により、動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [differenceBy](../../../reference/array/differenceBy.md) を使用してください。
+
+:::
+
+反復関数で変換した値を基準に、最初の配列から他の配列の要素を除いた差集合を求めます。
+
+```typescript
+const result = differenceBy(array, ...values, iteratee);
+```
+
+## 使用法
+
+### `differenceBy(array, ...values, iteratee)`
+
+最初の配列の各要素と除外する配列の要素を反復関数で変換した後、同じ値になる要素を削除したい場合、`differenceBy` を使用してください。オブジェクト配列で特定のプロパティ値や変換された値を基準に比較する際に便利です。
+
+```typescript
+import { differenceBy } from 'es-toolkit/compat';
+
+// 小数点以下切り捨てで比較
+differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
+// Returns: [1.2] (Math.floor(2.1) === Math.floor(2.3)のため2.1を除外)
+
+// 文字列の長さで比較
+differenceBy(['one', 'two', 'three'], ['four', 'eight'], 'length');
+// Returns: ['one', 'two'] (threeとeightは長さが同じためthreeを除外)
+
+// オブジェクトのプロパティで比較
+const users1 = [
+ { id: 1, name: 'Alice' },
+ { id: 2, name: 'Bob' },
+];
+const users2 = [{ id: 1, name: 'Different Alice' }];
+differenceBy(users1, users2, 'id');
+// Returns: [{ id: 2, name: 'Bob' }] (idが1のオブジェクトを除外)
+```
+
+複数の配列を一度に除外できます。
+
+```typescript
+import { differenceBy } from 'es-toolkit/compat';
+
+// 複数の配列から除外
+differenceBy([2.1, 1.2, 3.5], [2.3], [1.4], [3.2], Math.floor);
+// Returns: [] (すべての要素が除外されます)
+
+// 文字列配列を長さで比較
+differenceBy(['a', 'bb', 'ccc'], ['x'], ['yy'], ['zzz'], 'length');
+// Returns: [] (長さ1、2、3がすべて除外されます)
+```
+
+反復関数がない場合、通常の `difference` のように動作します。
+
+```typescript
+import { differenceBy } from 'es-toolkit/compat';
+
+// 反復関数なしで使用
+differenceBy([1, 2, 3], [2, 4]);
+// Returns: [1, 3]
+```
+
+`null` や `undefined` の配列は空配列として処理されます。
+
+```typescript
+import { differenceBy } from 'es-toolkit/compat';
+
+differenceBy(null, [1, 2], Math.floor);
+// Returns: []
+
+differenceBy(undefined, [1, 2], x => x);
+// Returns: []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 差集合を求める基準配列です。
+- `values` (`...ArrayLike[]`): 除外する値を含む配列です。
+- `iteratee` (`ValueIteratee`): 各要素を比較する値に変換する関数です。関数、プロパティ名、または部分オブジェクトを使用できます。
+
+#### 戻り値
+
+(`T[]`): 反復関数で変換した値を基準に除外された要素を除いた新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/differenceWith.md b/docs/ja/compat/reference/array/differenceWith.md
new file mode 100644
index 000000000..dc1fa991e
--- /dev/null
+++ b/docs/ja/compat/reference/array/differenceWith.md
@@ -0,0 +1,79 @@
+# differenceWith (Lodash 互換性)
+
+::: warning `es-toolkit`の`differenceWith`を使用してください
+
+この `differenceWith` 関数は、`null` や `undefined` の処理、複数の配列処理、`ArrayLike` 型の処理などにより、動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [differenceWith](../../../reference/array/differenceWith.md) を使用してください。
+
+:::
+
+比較関数を使用して、最初の配列から他の配列に含まれる要素を削除します。
+
+```typescript
+const result = differenceWith(array, ...values, comparator);
+```
+
+## 使用法
+
+### `differenceWith(array, ...values, comparator)`
+
+各要素を比較関数で比較して差を求めたい場合、`differenceWith` を使用してください。最後の引数が比較関数になります。
+
+```typescript
+import { differenceWith } from 'es-toolkit/compat';
+
+// オブジェクトをidで比較します。
+const objects = [{ id: 1 }, { id: 2 }, { id: 3 }];
+const others = [{ id: 2 }];
+const comparator = (a, b) => a.id === b.id;
+
+differenceWith(objects, others, comparator);
+// Returns: [{ id: 1 }, { id: 3 }]
+
+// 複数の配列を一度に除外します。
+const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }];
+const values1 = [{ id: 2 }];
+const values2 = [{ id: 3 }];
+
+differenceWith(array, values1, values2, comparator);
+// Returns: [{ id: 1 }, { id: 4 }]
+```
+
+比較関数を提供しない場合、通常の `difference` のように動作します。
+
+```typescript
+import { differenceWith } from 'es-toolkit/compat';
+
+// 比較関数なしで使用すると通常の比較を行います。
+differenceWith([1, 2, 3], [2], [3]);
+// Returns: [1]
+```
+
+複雑な比較ロジックも使用できます。
+
+```typescript
+import { differenceWith } from 'es-toolkit/compat';
+
+const users = [
+ { name: 'alice', age: 25 },
+ { name: 'bob', age: 30 },
+ { name: 'charlie', age: 35 },
+];
+const excludeUsers = [{ name: 'bob', age: 25 }]; // 異なる年齢
+
+// 名前のみで比較します。
+const compareByName = (a, b) => a.name === b.name;
+differenceWith(users, excludeUsers, compareByName);
+// Returns: [{ name: 'alice', age: 25 }, { name: 'charlie', age: 35 }]
+// bobが除外されます（年齢が違っても名前が同じため）
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 差を求める基準配列です。
+- `...values` (`Array>` + `(a: T, b: T) => boolean`): 除外する要素を含む配列と最後に比較関数です。
+
+#### 戻り値
+
+(`T[]`): 比較関数を使用して最初の配列から残りの配列の要素を削除した新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/drop.md b/docs/ja/compat/reference/array/drop.md
new file mode 100644
index 000000000..d55a67402
--- /dev/null
+++ b/docs/ja/compat/reference/array/drop.md
@@ -0,0 +1,97 @@
+# drop (Lodash 互換性)
+
+::: warning `es-toolkit` の `drop` を使用してください
+
+この `drop` 関数は、`null` や `undefined` の処理、`toInteger` 変換などにより複雑に動作します。
+
+代わりに、より高速で現代的な `es-toolkit` の [`drop`](../../../reference/array/drop.md) を使用してください。
+
+:::
+
+配列の先頭から指定された個数の要素を削除します。
+
+```typescript
+const result = drop(array, n);
+```
+
+## 使用法
+
+### `drop(array, n?)`
+
+配列の先頭からいくつかの要素を削除し、残りを取得したい場合に `drop` を使用します。デフォルトでは、最初の要素を1つ削除します。
+
+```typescript
+import { drop } from 'es-toolkit/compat';
+
+// 基本的な使用法(最初の要素を削除)
+drop([1, 2, 3, 4, 5]);
+// 戻り値: [2, 3, 4, 5]
+
+// 最初の2つの要素を削除
+drop([1, 2, 3, 4, 5], 2);
+// 戻り値: [3, 4, 5]
+
+// 最初の3つの要素を削除
+drop(['a', 'b', 'c', 'd'], 3);
+// 戻り値: ['d']
+```
+
+0または負の数を指定すると、元の配列をそのまま返します。
+
+```typescript
+import { drop } from 'es-toolkit/compat';
+
+// 0個削除
+drop([1, 2, 3], 0);
+// 戻り値: [1, 2, 3]
+
+// 負の数を指定
+drop([1, 2, 3], -1);
+// 戻り値: [1, 2, 3]
+```
+
+配列より大きい数を指定すると、空の配列を返します。
+
+```typescript
+import { drop } from 'es-toolkit/compat';
+
+// 配列のサイズより大きい数を指定
+drop([1, 2, 3], 5);
+// 戻り値: []
+
+// 空の配列から削除
+drop([], 1);
+// 戻り値: []
+```
+
+`null` または `undefined` の配列は空の配列として処理されます。
+
+```typescript
+import { drop } from 'es-toolkit/compat';
+
+drop(null, 1);
+// 戻り値: []
+
+drop(undefined, 2);
+// 戻り値: []
+```
+
+配列風オブジェクトもサポートされています。
+
+```typescript
+import { drop } from 'es-toolkit/compat';
+
+// 配列風オブジェクト
+const arrayLike = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
+drop(arrayLike, 1);
+// 戻り値: ['b', 'c']
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 要素を削除する配列です。
+- `n` (`number`, オプション): 削除する要素の個数です。デフォルトは `1` です。
+
+#### 戻り値
+
+(`T[]`): 先頭から指定された個数の要素が削除された新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/dropRight.md b/docs/ja/compat/reference/array/dropRight.md
new file mode 100644
index 000000000..7c46cb8e2
--- /dev/null
+++ b/docs/ja/compat/reference/array/dropRight.md
@@ -0,0 +1,55 @@
+# dropRight (Lodash 互換性)
+
+::: warning `es-toolkit` の `dropRight` を使用してください
+
+この `dropRight` 関数は、`null` や `undefined` の処理、`guard` パラメータ処理、`toInteger` 変換などにより遅く動作します。
+
+代わりに、より高速で現代的な `es-toolkit` の [`dropRight`](../../../reference/array/dropRight.md) を使用してください。
+
+:::
+
+配列の末尾から指定された個数の要素を削除した新しい配列を返します。
+
+```typescript
+const result = dropRight(array, itemsCount);
+```
+
+## 使用法
+
+### `dropRight(array, itemsCount)`
+
+配列の末尾から特定の個数の要素を削除し、残りの要素で新しい配列を作成したい場合に `dropRight` を使用します。
+
+```typescript
+import { dropRight } from 'es-toolkit/compat';
+
+// 数値配列から末尾の2つの要素を削除します。
+dropRight([1, 2, 3, 4, 5], 2);
+// 戻り値: [1, 2, 3]
+
+// 文字列配列から末尾の1つの要素を削除します。
+dropRight(['a', 'b', 'c'], 1);
+// 戻り値: ['a', 'b']
+
+// 削除する個数を指定しない場合、デフォルト値1が使用されます。
+dropRight([1, 2, 3]);
+// 戻り値: [1, 2]
+```
+
+`null` または `undefined` は空の配列として処理されます。
+
+```typescript
+import { dropRight } from 'es-toolkit/compat';
+
+dropRight(null, 2); // []
+dropRight(undefined, 2); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 要素を削除する配列です。
+- `itemsCount` (`number`, オプション): 配列の末尾から削除する要素の個数です。デフォルトは `1` です。
+
+#### 戻り値
+
+(`T[]`): 末尾から `itemsCount` 個の要素が削除された新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/dropRightWhile.md b/docs/ja/compat/reference/array/dropRightWhile.md
new file mode 100644
index 000000000..3d205a80e
--- /dev/null
+++ b/docs/ja/compat/reference/array/dropRightWhile.md
@@ -0,0 +1,65 @@
+# dropRightWhile (Lodash 互換性)
+
+::: warning `es-toolkit` の `dropRightWhile` を使用してください
+
+この `dropRightWhile` 関数は、`null` や `undefined` の処理、`ArrayLike` 型の処理、様々な条件関数形式のサポートなどにより遅く動作します。
+
+代わりに、より高速で現代的な `es-toolkit` の [`dropRightWhile`](../../../reference/array/dropRightWhile.md) を使用してください。
+
+:::
+
+条件関数に基づいて配列の末尾から要素を削除します。
+
+```typescript
+const result = dropRightWhile(array, predicate);
+```
+
+## 使用法
+
+### `dropRightWhile(array, predicate)`
+
+配列の末尾から特定の条件を満たす要素を連続して削除したい場合に `dropRightWhile` を使用します。条件関数が `false` を返すと削除を中断します。
+
+```typescript
+import { dropRightWhile } from 'es-toolkit/compat';
+
+// 関数を条件として使用します。
+const users = [
+ { user: 'barney', active: true },
+ { user: 'fred', active: false },
+ { user: 'pebbles', active: false },
+];
+
+dropRightWhile(users, user => !user.active);
+// 戻り値: [{ user: 'barney', active: true }]
+
+// オブジェクトパターンでマッチングします。
+dropRightWhile(users, { user: 'pebbles', active: false });
+// 戻り値: [{ user: 'barney', active: true }, { user: 'fred', active: false }]
+
+// 配列形式でプロパティと値を指定します。
+dropRightWhile(users, ['active', false]);
+// 戻り値: [{ user: 'barney', active: true }]
+
+// プロパティ名で条件を確認します。
+dropRightWhile(users, 'active');
+// 戻り値: [{ user: 'barney', active: true }, { user: 'fred', active: false }, { user: 'pebbles', active: false }]
+```
+
+`null` または `undefined` は空の配列として処理されます。
+
+```typescript
+import { dropRightWhile } from 'es-toolkit/compat';
+
+dropRightWhile(null, x => x > 0); // []
+dropRightWhile(undefined, x => x > 0); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 要素を削除する配列です。
+- `predicate` (`ListIteratee`, オプション): 各要素に適用する条件関数です。関数、オブジェクトパターン、配列パターン、またはプロパティ名を受け取ることができます。
+
+#### 戻り値
+
+(`T[]`): 条件を満たさない最初の要素からの新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/dropWhile.md b/docs/ja/compat/reference/array/dropWhile.md
new file mode 100644
index 000000000..5050d70cd
--- /dev/null
+++ b/docs/ja/compat/reference/array/dropWhile.md
@@ -0,0 +1,67 @@
+# dropWhile (Lodash 互換性)
+
+::: warning `es-toolkit` の `dropWhile` を使用してください
+
+この `dropWhile` 関数は、`null` や `undefined` の処理、`ArrayLike` 型の処理、様々な条件関数形式のサポートなどにより遅く動作します。
+
+代わりに、より高速で現代的な `es-toolkit` の [`dropWhile`](../../../reference/array/dropWhile.md) を使用してください。
+
+:::
+
+条件関数に基づいて配列の先頭から要素を削除します。
+
+```typescript
+const result = dropWhile(array, predicate);
+```
+
+## 使用法
+
+### `dropWhile(array, predicate)`
+
+配列の先頭から特定の条件を満たす要素を連続して削除したい場合に `dropWhile` を使用します。条件関数が `false` を返すと削除を中断します。
+
+```typescript
+import { dropWhile } from 'es-toolkit/compat';
+
+// 関数を条件として使用します。
+dropWhile([1, 2, 3, 4, 5], n => n < 3);
+// 戻り値: [3, 4, 5]
+
+// オブジェクトパターンでマッチングします。
+const users = [
+ { name: 'alice', active: false },
+ { name: 'bob', active: false },
+ { name: 'charlie', active: true },
+];
+
+dropWhile(users, { active: false });
+// 戻り値: [{ name: 'charlie', active: true }]
+
+// 配列形式でプロパティと値を指定します。
+dropWhile(users, ['active', false]);
+// 戻り値: [{ name: 'charlie', active: true }]
+
+// プロパティ名で条件を確認します。
+const items = [{ visible: false }, { visible: false }, { visible: true }];
+
+dropWhile(items, 'visible');
+// 戻り値: [{ visible: false }, { visible: false }, { visible: true }]
+```
+
+`null` または `undefined` は空の配列として処理されます。
+
+```typescript
+import { dropWhile } from 'es-toolkit/compat';
+
+dropWhile(null, x => x > 0); // []
+dropWhile(undefined, x => x > 0); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 要素を削除する配列です。
+- `predicate` (`ListIteratee`, オプション): 各要素に適用する条件関数です。関数、オブジェクトパターン、配列パターン、またはプロパティ名を受け取ることができます。デフォルトは `identity` です。
+
+#### 戻り値
+
+(`T[]`): 条件を満たさない最初の要素からの新しい配列を返します。
diff --git a/docs/ja/reference/compat/array/each.md b/docs/ja/compat/reference/array/each.md
similarity index 100%
rename from docs/ja/reference/compat/array/each.md
rename to docs/ja/compat/reference/array/each.md
diff --git a/docs/ja/compat/reference/array/eachRight.md b/docs/ja/compat/reference/array/eachRight.md
new file mode 100644
index 000000000..0a049674d
--- /dev/null
+++ b/docs/ja/compat/reference/array/eachRight.md
@@ -0,0 +1,58 @@
+# eachRight (Lodash 互換性)
+
+::: warning `es-toolkit` の `forEachRight` を使用してください
+
+この `eachRight` 関数は、`null` や `undefined` の処理、`ArrayLike` 型の処理、様々な条件関数形式のサポートなどにより遅く動作します。
+
+代わりに、より高速で現代的な `es-toolkit` の [`forEachRight`](../../../reference/array/forEachRight.md) を使用してください。
+
+:::
+
+配列またはオブジェクトの各要素に対して右から左へ反復操作を実行します。
+
+```typescript
+const result = eachRight(collection, iteratee);
+```
+
+## 使用法
+
+### `eachRight(collection, iteratee)`
+
+配列、オブジェクト、文字列の各要素を右から左へ順回しながら与えられた関数を実行します。配列の場合は最後のインデックスから逆順に、オブジェクトの場合は列挙可能なプロパティを逆順に順回します。
+
+```typescript
+import { eachRight } from 'es-toolkit/compat';
+
+// 配列を逆順に順回
+eachRight([1, 2, 3], (value, index) => console.log(value, index));
+// ログ: 3 2, 2 1, 1 0
+
+// オブジェクトを逆順に順回
+eachRight({ a: 1, b: 2 }, (value, key) => console.log(key, value));
+// ログ: 'b' 2, 'a' 1
+
+// 文字列を逆順に順回
+eachRight('hello', (char, index) => console.log(char, index));
+// ログ: 'o' 4, 'l' 3, 'l' 2, 'e' 1, 'h' 0
+```
+
+関数が `false` を返すと順回を中断します。
+
+```typescript
+import { eachRight } from 'es-toolkit/compat';
+
+eachRight([1, 2, 3, 4], value => {
+ console.log(value);
+ return value !== 2; // 2で中断
+});
+// ログ: 4, 3, 2
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | Record | string | null | undefined`): 順回するコレクションです。
+- `iteratee` (`(item: any, index: any, collection: any) => unknown`, オプション): 各要素に対して実行する関数です。デフォルトは `identity` 関数です。
+
+#### 戻り値
+
+(`ArrayLike | Record | string | null | undefined`): 元のコレクションを返します。
diff --git a/docs/ja/reference/compat/array/every.md b/docs/ja/compat/reference/array/every.md
similarity index 100%
rename from docs/ja/reference/compat/array/every.md
rename to docs/ja/compat/reference/array/every.md
diff --git a/docs/ja/compat/reference/array/fill.md b/docs/ja/compat/reference/array/fill.md
new file mode 100644
index 000000000..a5787b77f
--- /dev/null
+++ b/docs/ja/compat/reference/array/fill.md
@@ -0,0 +1,82 @@
+# fill (Lodash 互換性)
+
+::: warning `es-toolkit` の `fill` を使用してください
+
+この `fill` 関数は、`null` や `undefined` の処理、配列風オブジェクトのサポートなどにより複雑に動作します。
+
+代わりに、より高速で現代的な `es-toolkit` の [`fill`](../../../reference/array/fill.md) を使用してください。
+
+:::
+
+配列の要素を指定された値で埋めます。
+
+```typescript
+const result = fill(array, value, start, end);
+```
+
+## 使用法
+
+### `fill(array, value, start?, end?)`
+
+配列の特定の範囲または全体を同じ値で埋めたい場合に `fill` を使用します。元の配列を直接変更します。
+
+```typescript
+import { fill } from 'es-toolkit/compat';
+
+// 配列全体を埋める
+const arr1 = [1, 2, 3];
+fill(arr1, 'a');
+// 戻り値: ['a', 'a', 'a']
+
+// 特定の範囲を埋める
+const arr2 = [1, 2, 3, 4, 5];
+fill(arr2, '*', 1, 4);
+// 戻り値: [1, '*', '*', '*', 5]
+
+// 負のインデックスを使用
+const arr3 = [1, 2, 3, 4, 5];
+fill(arr3, 'x', -3, -1);
+// 戻り値: [1, 2, 'x', 'x', 5]
+```
+
+配列風オブジェクトもサポートされています。
+
+```typescript
+import { fill } from 'es-toolkit/compat';
+
+const arrayLike = { 0: 1, 1: 2, 2: 3, length: 3 };
+fill(arrayLike, 'a', 1, 2);
+// 戻り値: { 0: 1, 1: 'a', 2: 3, length: 3 }
+```
+
+`null` または `undefined` の配列は空の配列として処理されます。
+
+```typescript
+import { fill } from 'es-toolkit/compat';
+
+fill(null, 'a');
+// 戻り値: []
+
+fill(undefined, 'a');
+// 戻り値: []
+```
+
+文字列は読み取り専用なのでそのまま返します。
+
+```typescript
+import { fill } from 'es-toolkit/compat';
+
+fill('abc', 'x');
+// 戻り値: 'abc' (変更されません)
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 埋める配列です。
+- `value` (`U`): 配列を埋める値です。
+- `start` (`number`, オプション): 開始位置です。デフォルトは `0` です。
+- `end` (`number`, オプション): 終了位置です(含まれません)。デフォルトは `array.length` です。
+
+#### 戻り値
+
+(`ArrayLike`): 値で埋められた配列を返します。
diff --git a/docs/ja/reference/compat/array/filter.md b/docs/ja/compat/reference/array/filter.md
similarity index 100%
rename from docs/ja/reference/compat/array/filter.md
rename to docs/ja/compat/reference/array/filter.md
diff --git a/docs/ja/reference/compat/array/find.md b/docs/ja/compat/reference/array/find.md
similarity index 100%
rename from docs/ja/reference/compat/array/find.md
rename to docs/ja/compat/reference/array/find.md
diff --git a/docs/ja/reference/compat/array/findIndex.md b/docs/ja/compat/reference/array/findIndex.md
similarity index 100%
rename from docs/ja/reference/compat/array/findIndex.md
rename to docs/ja/compat/reference/array/findIndex.md
diff --git a/docs/ja/reference/compat/array/findLast.md b/docs/ja/compat/reference/array/findLast.md
similarity index 100%
rename from docs/ja/reference/compat/array/findLast.md
rename to docs/ja/compat/reference/array/findLast.md
diff --git a/docs/ja/reference/compat/array/findLastIndex.md b/docs/ja/compat/reference/array/findLastIndex.md
similarity index 100%
rename from docs/ja/reference/compat/array/findLastIndex.md
rename to docs/ja/compat/reference/array/findLastIndex.md
diff --git a/docs/ja/compat/reference/array/first.md b/docs/ja/compat/reference/array/first.md
new file mode 100644
index 000000000..912d40293
--- /dev/null
+++ b/docs/ja/compat/reference/array/first.md
@@ -0,0 +1,78 @@
+# first (Lodash 互換性)
+
+::: warning `es-toolkit`の`head`を使用してください
+
+この`first`関数は、`null`や`undefined`の処理と配列のようなオブジェクトの変換により、動作が遅くなります。`es-toolkit`の`head`関数は、これらの追加処理なしで、より高速かつシンプルに動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[head](../../../reference/array/head.md)を使用してください。
+
+:::
+
+配列の最初の要素を返します。
+
+```typescript
+const firstElement = first(array);
+```
+
+## 使用法
+
+### `first(array)`
+
+配列の最初の要素を取得したい場合は`first`を使用してください。配列が空であるか、`null`、`undefined`の場合は`undefined`を返します。
+
+```typescript
+import { first } from 'es-toolkit/compat';
+
+// 通常の配列から最初の要素を取得
+first([1, 2, 3]);
+// Returns: 1
+
+// 文字列配列から最初の要素を取得
+first(['a', 'b', 'c']);
+// Returns: 'a'
+
+// 空の配列
+first([]);
+// Returns: undefined
+```
+
+`null`または`undefined`は`undefined`を返します。
+
+```typescript
+import { first } from 'es-toolkit/compat';
+
+first(null); // undefined
+first(undefined); // undefined
+```
+
+配列のようなオブジェクトでも使用できます。
+
+```typescript
+import { first } from 'es-toolkit/compat';
+
+const arrayLike = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
+first(arrayLike);
+// Returns: 'a'
+
+// 文字列も配列のように処理されます
+first('hello');
+// Returns: 'h'
+```
+
+型が保証されたタプルでは、正確な型を返します。
+
+```typescript
+import { first } from 'es-toolkit/compat';
+
+const tuple = [1, 'two', true] as const;
+first(tuple);
+// Returns: 1 (型は1と推論されます)
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 最初の要素を取得する配列です。
+
+#### 戻り値
+
+(`T | undefined`): 配列の最初の要素を返します。配列が空または無効な場合は`undefined`を返します。
diff --git a/docs/ja/compat/reference/array/flatMap.md b/docs/ja/compat/reference/array/flatMap.md
new file mode 100644
index 000000000..ee6ace74e
--- /dev/null
+++ b/docs/ja/compat/reference/array/flatMap.md
@@ -0,0 +1,77 @@
+# flatMap (Lodash 互換性)
+
+::: warning `es-toolkit`の`flatMap`を使用してください
+
+この`flatMap`関数は、`null`や`undefined`の処理、`ArrayLike`型の処理、様々な条件関数形式のサポートなどにより、動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[flatMap](../../../reference/array/flatMap.md)を使用してください。
+
+:::
+
+各要素に関数を適用した後、結果を平坦化します。
+
+```typescript
+const result = flatMap(collection, iteratee);
+```
+
+## 使用法
+
+### `flatMap(collection, iteratee)`
+
+コレクションの各要素にイテレータ関数を適用した後、1段階平坦化した配列を返します。配列、オブジェクト、文字列をサポートし、様々な形式のイテレータを使用できます。
+
+```typescript
+import { flatMap } from 'es-toolkit/compat';
+
+// 配列に関数を適用
+function duplicate(n) {
+ return [n, n];
+}
+flatMap([1, 2], duplicate);
+// 結果: [1, 1, 2, 2]
+
+// オブジェクトに関数を適用
+const obj = { a: 1, b: 2 };
+flatMap(obj, (value, key) => [key, value]);
+// 結果: ['a', 1, 'b', 2]
+
+// 文字列プロパティでマッピング
+const users = [
+ { user: 'barney', hobbies: ['hiking', 'coding'] },
+ { user: 'fred', hobbies: ['reading'] },
+];
+flatMap(users, 'hobbies');
+// 結果: ['hiking', 'coding', 'reading']
+```
+
+イテレータなしで使用すると、値を1段階平坦化します。
+
+```typescript
+import { flatMap } from 'es-toolkit/compat';
+
+const obj = { a: [1, 2], b: [3, 4] };
+flatMap(obj);
+// 結果: [1, 2, 3, 4]
+```
+
+部分オブジェクトで条件マッピングも可能です。
+
+```typescript
+import { flatMap } from 'es-toolkit/compat';
+
+const users = [
+ { user: 'barney', age: 36, active: true },
+ { user: 'fred', age: 40, active: false },
+];
+flatMap(users, { active: false });
+// 結果: [false, true] (activeがfalseの要素のマッチング結果)
+```
+
+#### パラメータ
+
+- `collection` (`object | null | undefined`): 反復処理するコレクションです。配列、オブジェクト、文字列が可能です。
+- `iteratee` (`ListIterator | ObjectIterator | string | object`, オプション): 各要素に適用するイテレータです。関数、プロパティ名、または部分オブジェクトが可能です。
+
+#### 戻り値
+
+(`any[]`): マッピング後1段階平坦化された新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/flatMapDeep.md b/docs/ja/compat/reference/array/flatMapDeep.md
new file mode 100644
index 000000000..1bd43e23d
--- /dev/null
+++ b/docs/ja/compat/reference/array/flatMapDeep.md
@@ -0,0 +1,77 @@
+# flatMapDeep (Lodash 互換性)
+
+::: warning `es-toolkit`の[`flatMapDeep`](../../../reference/array/flatMapDeep.md)を使用してください
+
+この`flatMapDeep`関数は、複雑なコレクション型の処理と深い平坦化ロジックにより、動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[flatMapDeep](../../../reference/array/flatMapDeep.md)を使用してください。
+
+:::
+
+各要素に関数を適用した後、結果を再帰的に平坦化します。
+
+```typescript
+const result = flatMapDeep(collection, iteratee);
+```
+
+## 使用法
+
+### `flatMapDeep(collection, iteratee)`
+
+コレクションの各要素にイテレータ関数を適用した後、無限の深さまで平坦化した配列を返します。ネストされた配列構造がすべて平坦化されて1次元配列になります。
+
+```typescript
+import { flatMapDeep } from 'es-toolkit/compat';
+
+// 配列に関数を適用して深く平坦化
+function duplicate(n) {
+ return [[[n, n]]];
+}
+flatMapDeep([1, 2], duplicate);
+// 結果: [1, 1, 2, 2]
+
+// オブジェクトに関数を適用して深く平坦化
+const obj = { a: 1, b: 2 };
+flatMapDeep(obj, (value, key) => [[[key, value]]]);
+// 結果: ['a', 1, 'b', 2]
+
+// 文字列プロパティでマッピングして深く平坦化
+const users = [
+ { user: 'barney', hobbies: [['hiking', 'coding']] },
+ { user: 'fred', hobbies: [['reading']] },
+];
+flatMapDeep(users, 'hobbies');
+// 結果: ['hiking', 'coding', 'reading']
+```
+
+イテレータなしで使用すると、値を再帰的に平坦化します。
+
+```typescript
+import { flatMapDeep } from 'es-toolkit/compat';
+
+const obj = { a: [[1, 2]], b: [[[3]]] };
+flatMapDeep(obj);
+// 結果: [1, 2, 3]
+```
+
+部分オブジェクトで条件マッピングも可能です。
+
+```typescript
+import { flatMapDeep } from 'es-toolkit/compat';
+
+const users = [
+ { user: 'barney', active: [true, false] },
+ { user: 'fred', active: [false] },
+];
+flatMapDeep(users, { active: [false] });
+// 結果: [true, true] (active配列に[false]が含まれる要素のマッチング結果)
+```
+
+#### パラメータ
+
+- `collection` (`object | null | undefined`): 反復処理するコレクションです。配列、オブジェクト、文字列が可能です。
+- `iteratee` (`ListIterator | ObjectIterator | string | object`, オプション): 各要素に適用するイテレータです。関数、プロパティ名、または部分オブジェクトが可能です。
+
+#### 戻り値
+
+(`any[]`): マッピング後再帰的に平坦化された新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/flatMapDepth.md b/docs/ja/compat/reference/array/flatMapDepth.md
new file mode 100644
index 000000000..4c13e15a6
--- /dev/null
+++ b/docs/ja/compat/reference/array/flatMapDepth.md
@@ -0,0 +1,79 @@
+# flatMapDepth (Lodash 互換性)
+
+::: warning `es-toolkit`の[flatMap](../../../reference/array/flatMap.md)を使用してください
+
+この`flatMapDepth`関数は、Lodashとの互換性のために様々な形式のイテレータをサポートし、`null`や`undefined`の処理などにより複雑に実装されています。メインライブラリの`flatMap`関数はシンプルな関数イテレータのみをサポートするため、より高速に動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[flatMap](../../../reference/array/flatMap.md)を使用してください。
+
+:::
+
+配列の各要素をイテレータ関数で変換した後、指定された深さまで平坦化します。
+
+```typescript
+const result = flatMapDepth(collection, iteratee, depth);
+```
+
+## 使用法
+
+### `flatMapDepth(collection, iteratee, depth)`
+
+配列またはオブジェクトの各要素を与えられた関数で変換した後、結果を指定された深さまで平坦化して新しい配列として返します。ネストされた配列構造を望む深さまでのみ平坦化したいときに便利です。
+
+```typescript
+import { flatMapDepth } from 'es-toolkit/compat';
+
+// 配列を変換して深さ2まで平坦化
+flatMapDepth([1, 2], n => [[n, n]], 2);
+// => [1, 1, 2, 2]
+
+// 深さ1に制限すると完全に平坦化されません
+flatMapDepth([1, 2], n => [[n, n]], 1);
+// => [[1, 1], [2, 2]]
+
+// オブジェクトから値を抽出して平坦化
+const users = [
+ { user: 'barney', hobbies: [['hiking'], ['coding']] },
+ { user: 'fred', hobbies: [['reading']] },
+];
+flatMapDepth(users, 'hobbies', 2);
+// => ['hiking', 'coding', 'reading']
+```
+
+この関数は様々な形式のイテレータをサポートします。
+
+```typescript
+import { flatMapDepth } from 'es-toolkit/compat';
+
+// 関数を使用した変換
+flatMapDepth([1, 2, 3], n => [[n, n]], 2);
+
+// プロパティ名で値を抽出
+const objects = [{ items: [['a'], ['b']] }, { items: [['c']] }];
+flatMapDepth(objects, 'items', 2);
+// => ['a', 'b', 'c']
+
+// オブジェクトの部分一致
+const users = [{ active: [[true], [false]] }, { active: [[false]] }];
+flatMapDepth(users, { active: [[false]] }, 2);
+// => [true, true]
+```
+
+`null`または`undefined`は空の配列として処理されます。
+
+```typescript
+import { flatMapDepth } from 'es-toolkit/compat';
+
+flatMapDepth(null, n => [n], 1); // => []
+flatMapDepth(undefined, n => [n], 1); // => []
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | Record | Record | object | null | undefined`): 反復処理する配列またはオブジェクトです。
+- `iteratee` (`((value: T, index: number, collection: any) => any) | string | object`, オプション): 各要素に対して実行する変換関数またはプロパティ名です。デフォルトは`identity`です。
+- `depth` (`number`, オプション): 平坦化する最大深さです。デフォルトは`1`です。
+
+#### 戻り値
+
+(`T[]`): イテレータで変換された後、指定された深さまで平坦化された新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/flatten.md b/docs/ja/compat/reference/array/flatten.md
new file mode 100644
index 000000000..334affeee
--- /dev/null
+++ b/docs/ja/compat/reference/array/flatten.md
@@ -0,0 +1,69 @@
+# flatten (Lodash 互換性)
+
+::: warning `es-toolkit`の`flatten`を使用してください
+
+この`flatten`関数は、`null`や`undefined`の処理、`ArrayLike`型の処理、様々な条件関数形式のサポートなどにより、動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[flatten](../../../reference/array/flatten.md)を使用してください。
+
+:::
+
+配列を1段階平坦化します。
+
+```typescript
+const result = flatten(array, depth);
+```
+
+## 使用法
+
+### `flatten(value, depth)`
+
+ネストされた配列を指定された深さだけ平坦化します。デフォルトでは1段階のみ平坦化し、ArgumentsオブジェクトやSymbol.isConcatSpreadableを持つオブジェクトもサポートします。
+
+```typescript
+import { flatten } from 'es-toolkit/compat';
+
+// 基本的な平坦化(1段階)
+flatten([1, [2, [3, [4]], 5]]);
+// 結果: [1, 2, [3, [4]], 5]
+
+// 深さを指定
+flatten([1, [2, [3, [4]], 5]], 2);
+// 結果: [1, 2, 3, [4], 5]
+
+// Argumentsオブジェクトのサポート
+function example() {
+ return flatten(arguments);
+}
+example(1, [2, 3], [[4]]);
+// 結果: [1, 2, 3, [4]]
+```
+
+空の配列やnull、undefinedは空の配列を返します。
+
+```typescript
+import { flatten } from 'es-toolkit/compat';
+
+flatten(null); // []
+flatten(undefined); // []
+flatten([]); // []
+```
+
+Symbol.isConcatSpreadableを持つオブジェクトも配列のように平坦化されます。
+
+```typescript
+import { flatten } from 'es-toolkit/compat';
+
+const spreadable = { 0: 'a', 1: 'b', length: 2, [Symbol.isConcatSpreadable]: true };
+flatten([1, spreadable, 3]);
+// 結果: [1, 'a', 'b', 3]
+```
+
+#### パラメータ
+
+- `value` (`ArrayLike | null | undefined`): 平坦化する配列です。
+- `depth` (`number`, オプション): 平坦化する最大深さです。デフォルトは`1`です。
+
+#### 戻り値
+
+(`T[]`): 平坦化された新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/flattenDeep.md b/docs/ja/compat/reference/array/flattenDeep.md
new file mode 100644
index 000000000..52f4ede73
--- /dev/null
+++ b/docs/ja/compat/reference/array/flattenDeep.md
@@ -0,0 +1,64 @@
+# flattenDeep (Lodash 互換性)
+
+::: warning `es-toolkit`の`flattenDeep`を使用してください
+
+この`flattenDeep`関数は、`null`や`undefined`の処理、`ArrayLike`型の処理、様々な条件関数形式のサポートなどにより、動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[flattenDeep](../../../reference/array/flattenDeep.md)を使用してください。
+
+:::
+
+配列を完全に平坦化します。
+
+```typescript
+const result = flattenDeep(array);
+```
+
+## 使用法
+
+### `flattenDeep(value)`
+
+ネストされた配列をすべての深さで再帰的に平坦化します。すべてのネストレベルが削除され、完全に平坦化された1次元配列を返します。
+
+```typescript
+import { flattenDeep } from 'es-toolkit/compat';
+
+// 深くネストされた配列を完全に平坦化
+flattenDeep([1, [2, [3, [4]], 5]]);
+// 結果: [1, 2, 3, 4, 5]
+
+// 複雑なネスト構造も完全に平坦化
+flattenDeep([1, [2, [3, [[[[4]]]]], 5]]);
+// 結果: [1, 2, 3, 4, 5]
+
+// 混合された型もサポート
+flattenDeep(['a', ['b', ['c', [['d']]]]]);
+// 結果: ['a', 'b', 'c', 'd']
+```
+
+空の配列やnull、undefinedは空の配列を返します。
+
+```typescript
+import { flattenDeep } from 'es-toolkit/compat';
+
+flattenDeep(null); // []
+flattenDeep(undefined); // []
+flattenDeep([]); // []
+```
+
+すでに平坦化された配列はそのままコピーされます。
+
+```typescript
+import { flattenDeep } from 'es-toolkit/compat';
+
+flattenDeep([1, 2, 3, 4, 5]);
+// 結果: [1, 2, 3, 4, 5]
+```
+
+#### パラメータ
+
+- `value` (`ListOfRecursiveArraysOrValues | null | undefined`): 完全に平坦化する配列です。
+
+#### 戻り値
+
+(`Array`): すべてのネストが削除された完全に平坦化された新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/flattenDepth.md b/docs/ja/compat/reference/array/flattenDepth.md
new file mode 100644
index 000000000..bdef86f3a
--- /dev/null
+++ b/docs/ja/compat/reference/array/flattenDepth.md
@@ -0,0 +1,55 @@
+# flattenDepth (Lodash 互換性)
+
+::: warning `es-toolkit`の`flatten`を使用してください
+
+この`flattenDepth`関数は、`null`や`undefined`の処理などにより、動作が遅くなります。`es-toolkit`の`flatten`関数は、これらの追加処理なしで、より高速かつシンプルに動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[flatten](../../../reference/array/flatten.md)を使用してください。
+
+:::
+
+配列を指定した深さまで平坦化します。
+
+```typescript
+const flattened = flattenDepth(array, depth);
+```
+
+## 使用法
+
+### `flattenDepth(array, depth)`
+
+ネストされた配列を望む深さまで平坦化したい場合は`flattenDepth`を使用してください。深さを指定すると、その深さまでのみネストされた配列を平坦化します。
+
+```typescript
+import { flattenDepth } from 'es-toolkit/compat';
+
+// 深さ1まで平坦化します
+flattenDepth([1, [2, [3, [4]], 5]], 1);
+// Returns: [1, 2, [3, [4]], 5]
+
+// 深さ2まで平坦化します
+flattenDepth([1, [2, [3, [4]], 5]], 2);
+// Returns: [1, 2, 3, [4], 5]
+
+// 深さを指定しない場合、デフォルト値1で平坦化します
+flattenDepth([1, [2, [3, [4]], 5]]);
+// Returns: [1, 2, [3, [4]], 5]
+```
+
+`null`または`undefined`は空の配列として処理されます。
+
+```typescript
+import { flattenDepth } from 'es-toolkit/compat';
+
+flattenDepth(null, 2); // []
+flattenDepth(undefined, 2); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 平坦化する配列です。
+- `depth` (`number`, オプション): 平坦化する最大深さです。デフォルトは`1`です。
+
+#### 戻り値
+
+(`T[]`): 指定した深さまで平坦化された新しい配列を返します。
diff --git a/docs/ja/reference/compat/array/forEach.md b/docs/ja/compat/reference/array/forEach.md
similarity index 100%
rename from docs/ja/reference/compat/array/forEach.md
rename to docs/ja/compat/reference/array/forEach.md
diff --git a/docs/ja/compat/reference/array/forEachRight.md b/docs/ja/compat/reference/array/forEachRight.md
new file mode 100644
index 000000000..c6d6baeff
--- /dev/null
+++ b/docs/ja/compat/reference/array/forEachRight.md
@@ -0,0 +1,75 @@
+# forEachRight (Lodash 互換性)
+
+::: warning `es-toolkit`の`forEachRight`を使用してください
+
+この`forEachRight`関数は、`null`や`undefined`の処理、`ArrayLike`タイプの処理、さまざまな条件関数形式のサポートなどにより、動作が遅くなります。
+
+代わりに、より高速でモダンな`es-toolkit`の[forEachRight](../../../reference/array/forEachRight.md)を使用してください。
+
+:::
+
+配列またはオブジェクトの要素を右から左に走査し、各要素に対して関数を実行します。
+
+```typescript
+forEachRight(collection, callback);
+```
+
+## 使用法
+
+### `forEachRight(collection, callback)`
+
+配列、オブジェクト、文字列を右から左の順序で走査し、各要素に対してコールバック関数を実行します。コールバックが`false`を返すと走査を中断します。
+
+```typescript
+import { forEachRight } from 'es-toolkit/compat';
+
+// 配列を逆順で走査します
+forEachRight([1, 2, 3], (value, index) => {
+ console.log(value, index);
+});
+// 出力: 3 2, 2 1, 1 0
+
+// 文字列を逆順で走査します
+forEachRight('abc', (char, index) => {
+ console.log(char, index);
+});
+// 出力: 'c' 2, 'b' 1, 'a' 0
+
+// オブジェクトを逆順で走査します
+forEachRight({ a: 1, b: 2, c: 3 }, (value, key) => {
+ console.log(value, key);
+});
+// 出力: 3 'c', 2 'b', 1 'a'
+```
+
+`null`または`undefined`はそのまま返します。
+
+```typescript
+import { forEachRight } from 'es-toolkit/compat';
+
+forEachRight(null, value => console.log(value)); // null
+forEachRight(undefined, value => console.log(value)); // undefined
+```
+
+コールバックが`false`を返すと走査を中断します。
+
+```typescript
+import { forEachRight } from 'es-toolkit/compat';
+
+forEachRight([1, 2, 3, 4], value => {
+ console.log(value);
+ if (value === 2) {
+ return false; // 走査を中断
+ }
+});
+// 出力: 4, 3, 2
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | Record | string | null | undefined`): 走査するコレクションです。配列、オブジェクト、文字列、またはnull/undefinedを指定できます。
+- `callback` (`(item: any, index: any, arr: any) => unknown`, 選択): 各要素に対して実行する関数です。`false`を返すと走査を中断します。デフォルトは`identity`関数です。
+
+#### 戻り値
+
+(`ArrayLike | Record | string | null | undefined`): 元のコレクションをそのまま返します。
diff --git a/docs/ja/compat/reference/array/groupBy.md b/docs/ja/compat/reference/array/groupBy.md
new file mode 100644
index 000000000..88b8b370c
--- /dev/null
+++ b/docs/ja/compat/reference/array/groupBy.md
@@ -0,0 +1,79 @@
+# groupBy (Lodash 互換性)
+
+::: warning `es-toolkit`の[groupBy](../../../reference/array/groupBy.md)を使用してください
+
+この`groupBy`関数は、`null`や`undefined`の処理、オブジェクトのサポート、複雑な型処理などにより、動作が遅くなります。
+
+代わりに、より高速でモダンな`es-toolkit`の[groupBy](../../../reference/array/groupBy.md)を使用してください。
+
+:::
+
+配列またはオブジェクトの要素を与えられた条件に従ってグループ化します。
+
+```typescript
+const grouped = groupBy(collection, iteratee);
+```
+
+## 使用法
+
+### `groupBy(collection, iteratee)`
+
+配列またはオブジェクトの各要素を与えられた条件関数に従ってグループ化し、グループ別に分類されたオブジェクトを返します。条件は関数、プロパティ名、部分オブジェクトなど、さまざまな形式で提供できます。
+
+```typescript
+import { groupBy } from 'es-toolkit/compat';
+
+// 関数でグループ化
+const array = [6.1, 4.2, 6.3];
+const result = groupBy(array, Math.floor);
+// resultは{ '4': [4.2], '6': [6.1, 6.3] }
+
+// プロパティ名でグループ化
+const users = [
+ { name: 'john', age: 30 },
+ { name: 'jane', age: 25 },
+ { name: 'bob', age: 30 },
+];
+const byAge = groupBy(users, 'age');
+// byAgeは{ '25': [{ name: 'jane', age: 25 }], '30': [{ name: 'john', age: 30 }, { name: 'bob', age: 30 }] }
+
+// オブジェクトからグループ化
+const obj = { a: 6.1, b: 4.2, c: 6.3 };
+const groupedObj = groupBy(obj, Math.floor);
+// groupedObjは{ '4': [4.2], '6': [6.1, 6.3] }
+```
+
+`null`または`undefined`は空のオブジェクトとして扱われます。
+
+```typescript
+import { groupBy } from 'es-toolkit/compat';
+
+groupBy(null, x => x); // {}
+groupBy(undefined, x => x); // {}
+```
+
+部分オブジェクトやプロパティ-値ペアでもグループ化できます。
+
+```typescript
+import { groupBy } from 'es-toolkit/compat';
+
+const products = [
+ { category: 'fruit', name: 'apple' },
+ { category: 'fruit', name: 'banana' },
+ { category: 'vegetable', name: 'carrot' },
+];
+
+// 部分オブジェクトでグループ化
+const byCategory = groupBy(products, { category: 'fruit' });
+// プロパティ-値ペアでグループ化
+const byName = groupBy(products, ['name', 'apple']);
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | Record | null | undefined`): グループ化する配列またはオブジェクトです。
+- `iteratee` (`Function | PropertyKey | Array | Object`, 選択): グループ化する条件です。関数、プロパティ名、プロパティ-値ペア、または部分オブジェクトを指定できます。デフォルトは`identity`関数です。
+
+#### 戻り値
+
+(`Record`): 各キーがグループの条件値で、値がそのグループに属する要素の配列であるオブジェクトを返します。
diff --git a/docs/ja/compat/reference/array/head.md b/docs/ja/compat/reference/array/head.md
new file mode 100644
index 000000000..fb1079114
--- /dev/null
+++ b/docs/ja/compat/reference/array/head.md
@@ -0,0 +1,61 @@
+# head (Lodash 互換性)
+
+::: warning `es-toolkit`の[head](../../../reference/array/head.md)を使用してください
+
+この`head`関数は、`ArrayLike`オブジェクトの処理と配列変換プロセスにより、動作が遅くなります。
+
+代わりに、より高速でモダンな`es-toolkit`の[head](../../../reference/array/head.md)を使用してください。
+
+:::
+
+配列の最初の要素を返します。
+
+```typescript
+const firstElement = head(array);
+```
+
+## 使用法
+
+### `head(array)`
+
+配列または配列のようなオブジェクトの最初の要素を返します。配列が空または無効な場合は`undefined`を返します。
+
+```typescript
+import { head } from 'es-toolkit/compat';
+
+// 数値配列の最初の要素
+const numbers = [1, 2, 3, 4];
+const first = head(numbers);
+// firstは1
+
+// 文字列配列の最初の要素
+const strings = ['a', 'b', 'c'];
+const firstChar = head(strings);
+// firstCharは'a'
+
+// 配列のようなオブジェクト
+const arrayLike = { 0: 'x', 1: 'y', 2: 'z', length: 3 };
+const firstItem = head(arrayLike);
+// firstItemは'x'
+```
+
+空の配列または無効な入力は`undefined`を返します。
+
+```typescript
+import { head } from 'es-toolkit/compat';
+
+const emptyArray: number[] = [];
+const noElement = head(emptyArray);
+// noElementはundefined
+
+head(null); // undefined
+head(undefined); // undefined
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 最初の要素を取得する配列または配列のようなオブジェクトです。
+
+#### 戻り値
+
+(`T | undefined`): 配列の最初の要素を返し、配列が空または無効な場合は`undefined`を返します。
diff --git a/docs/ja/reference/compat/array/includes.md b/docs/ja/compat/reference/array/includes.md
similarity index 100%
rename from docs/ja/reference/compat/array/includes.md
rename to docs/ja/compat/reference/array/includes.md
diff --git a/docs/ja/reference/compat/array/indexOf.md b/docs/ja/compat/reference/array/indexOf.md
similarity index 100%
rename from docs/ja/reference/compat/array/indexOf.md
rename to docs/ja/compat/reference/array/indexOf.md
diff --git a/docs/ja/compat/reference/array/initial.md b/docs/ja/compat/reference/array/initial.md
new file mode 100644
index 000000000..2eeaf9e5a
--- /dev/null
+++ b/docs/ja/compat/reference/array/initial.md
@@ -0,0 +1,65 @@
+# initial (Lodash 互換性)
+
+::: warning `es-toolkit`の[initial](../../../reference/array/initial.md)を使用してください
+
+この`initial`関数は、`ArrayLike`オブジェクトの処理と配列変換プロセスにより、動作が遅くなります。
+
+代わりに、より高速でモダンな`es-toolkit`の[initial](../../../reference/array/initial.md)を使用してください。
+
+:::
+
+配列から最後の要素を除くすべての要素を新しい配列として返します。
+
+```typescript
+const result = initial(array);
+```
+
+## 使用法
+
+### `initial(array)`
+
+配列または配列のようなオブジェクトから最後の要素を除くすべての要素を含む新しい配列を返します。配列が空または要素が1つだけの場合は空の配列を返します。
+
+```typescript
+import { initial } from 'es-toolkit/compat';
+
+// 数値配列から最後の要素を除外
+const numbers = [1, 2, 3, 4];
+const result = initial(numbers);
+// resultは[1, 2, 3]
+
+// 文字列配列から最後の要素を除外
+const strings = ['a', 'b', 'c', 'd'];
+const withoutLast = initial(strings);
+// withoutLastは['a', 'b', 'c']
+
+// 配列のようなオブジェクト
+const arrayLike = { 0: 'x', 1: 'y', 2: 'z', length: 3 };
+const items = initial(arrayLike);
+// itemsは['x', 'y']
+```
+
+空の配列または無効な入力は空の配列を返します。
+
+```typescript
+import { initial } from 'es-toolkit/compat';
+
+const emptyArray: number[] = [];
+const result = initial(emptyArray);
+// resultは[]
+
+const singleItem = [42];
+const onlyOne = initial(singleItem);
+// onlyOneは[]
+
+initial(null); // []
+initial(undefined); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 最後の要素を除外する配列または配列のようなオブジェクトです。
+
+#### 戻り値
+
+(`T[]`): 最後の要素を除外した新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/intersection.md b/docs/ja/compat/reference/array/intersection.md
new file mode 100644
index 000000000..eaacfb857
--- /dev/null
+++ b/docs/ja/compat/reference/array/intersection.md
@@ -0,0 +1,80 @@
+# intersection (Lodash 互換性)
+
+::: warning `es-toolkit`の[intersection](../../../reference/array/intersection.md)を使用してください
+
+この`intersection`関数は、`null`や`undefined`の処理、複数配列のサポート、重複除去プロセスにより、動作が遅くなります。
+
+代わりに、より高速でモダンな`es-toolkit`の[intersection](../../../reference/array/intersection.md)を使用してください。
+
+:::
+
+複数の配列の共通部分を求めます。
+
+```typescript
+const result = intersection(...arrays);
+```
+
+## 使用法
+
+### `intersection(...arrays)`
+
+複数の配列で共通に存在する要素を見つけて新しい配列として返します。結果は重複が除去され、最初の配列の順序を維持します。
+
+```typescript
+import { intersection } from 'es-toolkit/compat';
+
+// 2つの配列の共通部分
+const array1 = [1, 2, 3, 4];
+const array2 = [2, 3, 5, 6];
+const result = intersection(array1, array2);
+// resultは[2, 3]
+
+// 3つの配列の共通部分
+const array3 = [3, 4, 7, 8];
+const multiResult = intersection(array1, array2, array3);
+// multiResultは[3]
+
+// 文字列配列
+const strings1 = ['a', 'b', 'c'];
+const strings2 = ['b', 'c', 'd'];
+const stringResult = intersection(strings1, strings2);
+// stringResultは['b', 'c']
+
+// 配列のようなオブジェクト
+const arrayLike1 = { 0: 1, 1: 2, 2: 3, length: 3 };
+const arrayLike2 = { 0: 2, 1: 3, 2: 4, length: 3 };
+const likeResult = intersection(arrayLike1, arrayLike2);
+// likeResultは[2, 3]
+```
+
+`null`または`undefined`配列は空の配列として扱われます。
+
+```typescript
+import { intersection } from 'es-toolkit/compat';
+
+const array1 = [1, 2, 3];
+const result1 = intersection(array1, null);
+// result1は[]
+
+const result2 = intersection(null, undefined);
+// result2は[]
+```
+
+重複した要素は結果から除去されます。
+
+```typescript
+import { intersection } from 'es-toolkit/compat';
+
+const array1 = [1, 1, 2, 3];
+const array2 = [1, 2, 2, 4];
+const result = intersection(array1, array2);
+// resultは[1, 2]（重複除去されます）
+```
+
+#### パラメータ
+
+- `...arrays` (`Array | null | undefined>`): 共通部分を求める配列です。配列のようなオブジェクトやnull/undefinedも許可されます。
+
+#### 戻り値
+
+(`T[]`): すべての配列で共通に存在する要素の新しい配列を返します。重複は除去され、最初の配列の順序に従います。
diff --git a/docs/ja/compat/reference/array/intersectionBy.md b/docs/ja/compat/reference/array/intersectionBy.md
new file mode 100644
index 000000000..29b6f11f3
--- /dev/null
+++ b/docs/ja/compat/reference/array/intersectionBy.md
@@ -0,0 +1,93 @@
+# intersectionBy (Lodash 互換性)
+
+::: warning `es-toolkit`の[intersectionBy](../../../reference/array/intersectionBy.md)を使用してください
+
+この`intersectionBy`関数は、複雑な条件処理、複数配列のサポート、プロパティパスの解析などにより、動作が遅くなります。
+
+代わりに、より高速でモダンな`es-toolkit`の[intersectionBy](../../../reference/array/intersectionBy.md)を使用してください。
+
+:::
+
+与えられた条件関数を使用して複数の配列の共通部分を求めます。
+
+```typescript
+const result = intersectionBy(...arrays, iteratee);
+```
+
+## 使用法
+
+### `intersectionBy(...arrays, iteratee)`
+
+複数の配列で、各要素を与えられた条件関数で変換した値を基準に共通部分を求めます。条件は関数、プロパティ名、部分オブジェクトなど、さまざまな形式で提供できます。
+
+```typescript
+import { intersectionBy } from 'es-toolkit/compat';
+
+// 関数で共通部分を求める
+const array1 = [2.1, 1.2];
+const array2 = [2.3, 3.4];
+const result = intersectionBy(array1, array2, Math.floor);
+// resultは[2.1]（Math.floor基準で2が共通）
+
+// プロパティで共通部分を求める
+const users1 = [
+ { id: 1, name: 'john' },
+ { id: 2, name: 'jane' },
+];
+const users2 = [
+ { id: 2, name: 'jane' },
+ { id: 3, name: 'bob' },
+];
+const byId = intersectionBy(users1, users2, 'id');
+// byIdは[{ id: 2, name: 'jane' }]
+
+// 3つの配列の共通部分
+const array3 = [2.5, 4.1];
+const multiResult = intersectionBy(array1, array2, array3, Math.floor);
+// multiResultは[2.1]
+
+// 配列のようなオブジェクト
+const arrayLike1 = { 0: { x: 1 }, 1: { x: 2 }, length: 2 };
+const arrayLike2 = { 0: { x: 2 }, 1: { x: 3 }, length: 2 };
+const byProperty = intersectionBy(arrayLike1, arrayLike2, 'x');
+// byPropertyは[{ x: 2 }]
+```
+
+`null`または`undefined`配列は空の配列として扱われます。
+
+```typescript
+import { intersectionBy } from 'es-toolkit/compat';
+
+const array1 = [{ x: 1 }, { x: 2 }];
+const result = intersectionBy(array1, null, 'x');
+// resultは[]
+```
+
+部分オブジェクトやプロパティ-値ペアでも条件を指定できます。
+
+```typescript
+import { intersectionBy } from 'es-toolkit/compat';
+
+const products1 = [
+ { category: 'fruit', name: 'apple' },
+ { category: 'vegetable', name: 'carrot' },
+];
+const products2 = [
+ { category: 'fruit', name: 'banana' },
+ { category: 'meat', name: 'beef' },
+];
+
+// 部分オブジェクトで条件を指定
+const byCategory = intersectionBy(products1, products2, { category: 'fruit' });
+// プロパティ-値ペアで条件を指定
+const byCategoryPair = intersectionBy(products1, products2, ['category', 'fruit']);
+```
+
+#### パラメータ
+
+- `...arrays` (`Array | null | undefined>`): 共通部分を求める配列です。
+- `iteratee` (`Function | PropertyKey | Array | Object`): 各要素を変換する条件です。関数、プロパティ名、プロパティ-値ペア、または部分オブジェクトを指定できます。
+
+#### 戻り値
+
+(`T[]`): 変換された値を基準にすべての配列で共通に存在する要素の新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/intersectionWith.md b/docs/ja/compat/reference/array/intersectionWith.md
new file mode 100644
index 000000000..99e9c5b3e
--- /dev/null
+++ b/docs/ja/compat/reference/array/intersectionWith.md
@@ -0,0 +1,64 @@
+# intersectionWith (Lodash 互換性)
+
+::: warning `es-toolkit`の[intersectionWith](../../../reference/array/intersectionWith.md)を使用してください
+
+この`intersectionWith`関数は、`null`や`undefined`の処理、さまざまなオーバーロードのサポートなどにより、動作が遅くなります。
+
+代わりに、より高速でモダンな`es-toolkit`の[intersectionWith](../../../reference/array/intersectionWith.md)を使用してください。
+
+:::
+
+カスタム比較関数を使用して、すべての配列に含まれる共通要素の配列を作成します。
+
+```typescript
+const result = intersectionWith(array, ...otherArrays, comparator);
+```
+
+## 使用法
+
+### `intersectionWith(array, ...otherArrays, comparator)`
+
+カスタム比較関数を使用して、最初の配列と残りの配列の共通部分を求めます。比較関数で各要素が等しいかを判断し、すべての配列に含まれる要素のみを返します。
+
+```typescript
+import { intersectionWith } from 'es-toolkit/compat';
+
+const objects = [
+ { id: 1, name: 'john' },
+ { id: 2, name: 'jane' },
+];
+const others = [
+ { id: 1, name: 'john' },
+ { id: 3, name: 'joe' },
+];
+
+intersectionWith(objects, others, (a, b) => a.id === b.id);
+// => [{ id: 1, name: 'john' }]
+
+// 複数の配列と比較することもできます
+const array1 = [{ x: 1 }, { x: 2 }];
+const array2 = [{ x: 1 }, { x: 3 }];
+const array3 = [{ x: 1 }, { x: 4 }];
+
+intersectionWith(array1, array2, array3, (a, b) => a.x === b.x);
+// => [{ x: 1 }]
+```
+
+`null`または`undefined`は空の配列として扱われます。
+
+```typescript
+import { intersectionWith } from 'es-toolkit/compat';
+
+intersectionWith(null, [1, 2], (a, b) => a === b); // []
+intersectionWith([1, 2], undefined, (a, b) => a === b); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 比較する最初の配列です。
+- `...otherArrays` (`Array | ((a: T, b: T | U) => boolean)>`): 比較する他の配列と、最後の要素として比較関数です。
+- `comparator` (`(a: T, b: T | U) => boolean`): 2つの要素が等しいかを判断する関数です。
+
+#### 戻り値
+
+(`T[]`): すべての配列で共通に見つかった要素の新しい配列を返します。
diff --git a/docs/ja/reference/compat/array/invokeMap.md b/docs/ja/compat/reference/array/invokeMap.md
similarity index 100%
rename from docs/ja/reference/compat/array/invokeMap.md
rename to docs/ja/compat/reference/array/invokeMap.md
diff --git a/docs/ja/reference/compat/array/join.md b/docs/ja/compat/reference/array/join.md
similarity index 100%
rename from docs/ja/reference/compat/array/join.md
rename to docs/ja/compat/reference/array/join.md
diff --git a/docs/ja/compat/reference/array/keyBy.md b/docs/ja/compat/reference/array/keyBy.md
new file mode 100644
index 000000000..d94b08a8e
--- /dev/null
+++ b/docs/ja/compat/reference/array/keyBy.md
@@ -0,0 +1,64 @@
+# keyBy (Lodash 互換性)
+
+::: warning `es-toolkit` の [keyBy](../../../reference/array/keyBy.md) を使用してください
+
+この `keyBy` 関数は、`null` や `undefined` の処理、さまざまなパラメータ型の処理などにより動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [keyBy](../../../reference/array/keyBy.md) を使用してください。
+
+:::
+
+コレクションの要素を指定されたキーに基づいてオブジェクトに構成します。
+
+```typescript
+const result = keyBy(collection, iteratee);
+```
+
+## 使用法
+
+### `keyBy(collection, iteratee)`
+
+配列またはオブジェクトの各要素を、指定されたキー生成関数またはプロパティ名を使用してオブジェクトに構成します。同じキーを持つ要素が複数ある場合は、最後の要素が使用されます。
+
+```typescript
+import { keyBy } from 'es-toolkit/compat';
+
+// プロパティ名でキーを生成する
+const array = [
+ { dir: 'left', code: 97 },
+ { dir: 'right', code: 100 },
+];
+
+keyBy(array, 'dir');
+// => { left: { dir: 'left', code: 97 }, right: { dir: 'right', code: 100 } }
+
+// 関数でキーを生成する
+keyBy(array, o => String.fromCharCode(o.code));
+// => { a: { dir: 'left', code: 97 }, d: { dir: 'right', code: 100 } }
+
+// オブジェクトでも使用可能
+const obj = {
+ a: { id: 1, name: 'john' },
+ b: { id: 2, name: 'jane' },
+};
+keyBy(obj, 'name');
+// => { john: { id: 1, name: 'john' }, jane: { id: 2, name: 'jane' } }
+```
+
+`null` または `undefined` は空のオブジェクトとして扱われます。
+
+```typescript
+import { keyBy } from 'es-toolkit/compat';
+
+keyBy(null, 'id'); // {}
+keyBy(undefined, 'id'); // {}
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | null | undefined`): キーで構成する配列またはオブジェクトです。
+- `iteratee` (`ValueIterateeCustom`, オプション): キーを生成する関数またはプロパティ名です。省略すると、要素自体がキーとして使用されます。
+
+#### 戻り値
+
+(`Record`): 各要素が生成されたキーにマッピングされた新しいオブジェクトを返します。
diff --git a/docs/ja/compat/reference/array/last.md b/docs/ja/compat/reference/array/last.md
new file mode 100644
index 000000000..a1361df64
--- /dev/null
+++ b/docs/ja/compat/reference/array/last.md
@@ -0,0 +1,79 @@
+# last (Lodash互換性)
+
+::: warning `es-toolkit`の[last](../../../reference/array/last.md)を使用してください
+
+この`last`関数は`null`や`undefined`の処理により複雑に動作します。
+
+代わりに、より高速でモダンな`es-toolkit`の[last](../../../reference/array/last.md)を使用してください。
+
+:::
+
+配列の最後の要素を返します。
+
+```typescript
+const lastElement = last(array);
+```
+
+## 使用法
+
+### `last(array)`
+
+配列の最後の要素を取得したいときに`last`を使用してください。配列が空の場合は`undefined`を返します。
+
+```typescript
+import { last } from 'es-toolkit/compat';
+
+// 数値配列の最後の要素
+last([1, 2, 3, 4, 5]);
+// Returns: 5
+
+// 文字列配列の最後の要素
+last(['a', 'b', 'c']);
+// Returns: 'c'
+
+// オブジェクト配列の最後の要素
+const users = [{ name: 'Alice' }, { name: 'Bob' }];
+last(users);
+// Returns: { name: 'Bob' }
+```
+
+空の配列や`null`、`undefined`は`undefined`を返します。
+
+```typescript
+import { last } from 'es-toolkit/compat';
+
+// 空の配列
+last([]);
+// Returns: undefined
+
+// null配列
+last(null);
+// Returns: undefined
+
+// undefined配列
+last(undefined);
+// Returns: undefined
+```
+
+配列風オブジェクトもサポートしています。
+
+```typescript
+import { last } from 'es-toolkit/compat';
+
+// 配列風オブジェクト
+const arrayLike = { 0: 'first', 1: 'second', length: 2 };
+last(arrayLike);
+// Returns: 'second'
+
+// 文字列も配列風オブジェクト
+last('hello');
+// Returns: 'o'
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 最後の要素を取得する配列です。
+
+#### 戻り値
+
+(`T | undefined`): 配列の最後の要素を返し、配列が空または`null`、`undefined`の場合は`undefined`を返します。
diff --git a/docs/ja/reference/compat/array/lastIndexOf.md b/docs/ja/compat/reference/array/lastIndexOf.md
similarity index 100%
rename from docs/ja/reference/compat/array/lastIndexOf.md
rename to docs/ja/compat/reference/array/lastIndexOf.md
diff --git a/docs/ja/reference/compat/array/map.md b/docs/ja/compat/reference/array/map.md
similarity index 100%
rename from docs/ja/reference/compat/array/map.md
rename to docs/ja/compat/reference/array/map.md
diff --git a/docs/ja/reference/compat/array/nth.md b/docs/ja/compat/reference/array/nth.md
similarity index 100%
rename from docs/ja/reference/compat/array/nth.md
rename to docs/ja/compat/reference/array/nth.md
diff --git a/docs/ja/compat/reference/array/orderBy.md b/docs/ja/compat/reference/array/orderBy.md
new file mode 100644
index 000000000..59dad02a2
--- /dev/null
+++ b/docs/ja/compat/reference/array/orderBy.md
@@ -0,0 +1,82 @@
+# orderBy (Lodash 互換性)
+
+::: warning `es-toolkit` の [orderBy](../../../reference/array/orderBy.md) を使用してください
+
+この `orderBy` 関数は、`null` や `undefined` の処理、複雑なパス探索、様々なソート条件の処理により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [orderBy](../../../reference/array/orderBy.md) を使用してください。
+
+:::
+
+複数の条件でコレクションの要素をソートします。
+
+```typescript
+const result = orderBy(collection, criteria, orders);
+```
+
+## 使用法
+
+### `orderBy(collection, criteria, orders)`
+
+指定された条件とソート順に従って、配列またはオブジェクトの要素をソートします。複数の条件を使用でき、各条件に対して昇順 (`'asc'`) または降順 (`'desc'`) のソートを指定できます。
+
+```typescript
+import { orderBy } from 'es-toolkit/compat';
+
+const users = [
+ { name: 'fred', age: 48 },
+ { name: 'barney', age: 34 },
+ { name: 'fred', age: 40 },
+ { name: 'barney', age: 36 },
+];
+
+// 名前昇順、年齢降順でソート
+orderBy(users, ['name', 'age'], ['asc', 'desc']);
+// => [
+// { name: 'barney', age: 36 },
+// { name: 'barney', age: 34 },
+// { name: 'fred', age: 48 },
+// { name: 'fred', age: 40 }
+// ]
+
+// 関数でソート条件を指定
+orderBy(users, [user => user.name, user => user.age], ['asc', 'desc']);
+// => 上記と同じ結果
+
+// 単一の条件でソート
+orderBy(users, 'age', 'desc');
+// => [{ name: 'fred', age: 48 }, { name: 'fred', age: 40 }, ...]
+```
+
+オブジェクトの場合、値をソートします。
+
+```typescript
+import { orderBy } from 'es-toolkit/compat';
+
+const obj = {
+ a: { name: 'fred', age: 48 },
+ b: { name: 'barney', age: 34 },
+};
+
+orderBy(obj, 'age', 'desc');
+// => [{ name: 'fred', age: 48 }, { name: 'barney', age: 34 }]
+```
+
+`null` または `undefined` は空の配列として扱われます。
+
+```typescript
+import { orderBy } from 'es-toolkit/compat';
+
+orderBy(null, 'name'); // []
+orderBy(undefined, 'age'); // []
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | object | null | undefined`): ソートする配列またはオブジェクトです。
+- `criteria` (`Criterion | Array>`, オプション): ソート条件です。プロパティ名、プロパティパス、関数などを使用できます。デフォルトは `[null]` です。
+- `orders` (`unknown | unknown[]`, オプション): 各条件のソート順です。`'asc'`(昇順)、`'desc'`(降順)、`true`(昇順)、`false`(降順)を使用できます。デフォルトは `[]` です。
+
+#### 戻り値
+
+(`T[]`): 新しくソートされた配列を返します。
diff --git a/docs/ja/compat/reference/array/partition.md b/docs/ja/compat/reference/array/partition.md
new file mode 100644
index 000000000..f2cfecaf0
--- /dev/null
+++ b/docs/ja/compat/reference/array/partition.md
@@ -0,0 +1,89 @@
+# partition (Lodash 互換性)
+
+::: warning `es-toolkit` の [partition](../../../reference/array/partition.md) を使用してください
+
+この `partition` 関数は、`null` や `undefined` の処理、様々な条件タイプにより動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [partition](../../../reference/array/partition.md) を使用してください。
+
+:::
+
+条件に基づいてコレクションの要素を2つのグループに分けます。
+
+```typescript
+const [truthy, falsy] = partition(collection, predicate);
+```
+
+## 使用法
+
+### `partition(collection, predicate)`
+
+与えられた条件関数に基づいて、配列またはオブジェクトの要素を2つのグループに分けます。最初のグループには条件が真である要素が含まれ、2番目のグループには条件が偽である要素が含まれます。
+
+```typescript
+import { partition } from 'es-toolkit/compat';
+
+// 数値配列を偶数と奇数に分ける
+partition([1, 2, 3, 4, 5, 6], n => n % 2 === 0);
+// => [[2, 4, 6], [1, 3, 5]]
+
+// プロパティ名で条件を指定
+const users = [
+ { name: 'john', active: true },
+ { name: 'jane', active: false },
+ { name: 'bob', active: true },
+];
+
+partition(users, 'active');
+// => [
+// [{ name: 'john', active: true }, { name: 'bob', active: true }],
+// [{ name: 'jane', active: false }]
+// ]
+
+// オブジェクト条件でフィルタリング
+partition(users, { active: true });
+// => [
+// [{ name: 'john', active: true }, { name: 'bob', active: true }],
+// [{ name: 'jane', active: false }]
+// ]
+
+// 配列条件でフィルタリング
+partition(users, ['name', 'john']);
+// => [
+// [{ name: 'john', active: true }],
+// [{ name: 'jane', active: false }, { name: 'bob', active: true }]
+// ]
+```
+
+オブジェクトの場合、値を分割します。
+
+```typescript
+import { partition } from 'es-toolkit/compat';
+
+const obj = {
+ a: { score: 90 },
+ b: { score: 40 },
+ c: { score: 80 },
+};
+
+partition(obj, item => item.score >= 80);
+// => [[{ score: 90 }, { score: 80 }], [{ score: 40 }]]
+```
+
+`null` または `undefined` は空の配列として扱われます。
+
+```typescript
+import { partition } from 'es-toolkit/compat';
+
+partition(null, x => x > 0); // [[], []]
+partition(undefined, 'active'); // [[], []]
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | T | null | undefined`): 分割する配列またはオブジェクトです。
+- `predicate` (`((value: T) => unknown) | Partial | [PropertyKey, any] | PropertyKey`, オプション): 各要素をテストする条件です。関数、部分オブジェクト、プロパティ-値配列、またはプロパティ名を使用できます。デフォルトは `identity` です。
+
+#### 戻り値
+
+(`[T[], T[]]`): 条件を満たす要素の配列と満たさない要素の配列を含む配列を返します。
diff --git a/docs/ja/compat/reference/array/pull.md b/docs/ja/compat/reference/array/pull.md
new file mode 100644
index 000000000..119cc5e7a
--- /dev/null
+++ b/docs/ja/compat/reference/array/pull.md
@@ -0,0 +1,44 @@
+# pull (Lodash 互換性)
+
+::: warning `es-toolkit` の [pull](../../../reference/array/pull.md) を使用してください
+
+この `pull` 関数は Lodash 互換性のための関数であり、より複雑な型処理とオーバーロードにより動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [pull](../../../reference/array/pull.md) を使用してください。
+
+:::
+
+配列から指定された値をすべて削除します。
+
+```typescript
+const result = pull(array, ...valuesToRemove);
+```
+
+## 使用法
+
+### `pull(array, ...valuesToRemove)`
+
+配列から指定された値をすべて削除し、元の配列を変更します。配列をコピーせずに元の配列を直接変更することでメモリを節約できます。
+
+```typescript
+import { pull } from 'es-toolkit/compat';
+
+// 数値配列から特定の値を削除
+const numbers = [1, 2, 3, 2, 4, 2, 5];
+pull(numbers, 2, 3);
+console.log(numbers); // [1, 4, 5]
+
+// 文字列配列から特定の値を削除
+const fruits = ['apple', 'banana', 'apple', 'cherry'];
+pull(fruits, 'apple');
+console.log(fruits); // ['banana', 'cherry']
+```
+
+#### パラメータ
+
+- `array` (`T[]`): 変更する配列です。
+- `...valuesToRemove` (`T[]`): 配列から削除する値です。
+
+#### 戻り値
+
+(`T[]`): 変更された元の配列を返します。
diff --git a/docs/ja/reference/compat/array/pullAll.md b/docs/ja/compat/reference/array/pullAll.md
similarity index 100%
rename from docs/ja/reference/compat/array/pullAll.md
rename to docs/ja/compat/reference/array/pullAll.md
diff --git a/docs/ja/reference/compat/array/pullAllBy.md b/docs/ja/compat/reference/array/pullAllBy.md
similarity index 100%
rename from docs/ja/reference/compat/array/pullAllBy.md
rename to docs/ja/compat/reference/array/pullAllBy.md
diff --git a/docs/ja/reference/compat/array/pullAllWith.md b/docs/ja/compat/reference/array/pullAllWith.md
similarity index 100%
rename from docs/ja/reference/compat/array/pullAllWith.md
rename to docs/ja/compat/reference/array/pullAllWith.md
diff --git a/docs/ja/compat/reference/array/pullAt.md b/docs/ja/compat/reference/array/pullAt.md
new file mode 100644
index 000000000..ae338d8a2
--- /dev/null
+++ b/docs/ja/compat/reference/array/pullAt.md
@@ -0,0 +1,57 @@
+# pullAt (Lodash 互換性)
+
+::: warning `es-toolkit` の [pullAt](../../../reference/array/pullAt.md) を使用してください
+
+この `pullAt` 関数は、複雑な型処理とオーバーロードにより動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [pullAt](../../../reference/array/pullAt.md) を使用してください。
+
+:::
+
+指定されたインデックスにある要素を配列から削除し、削除された要素を返します。
+
+```typescript
+const removed = pullAt(array, ...indexes);
+```
+
+## 使用法
+
+### `pullAt(array, ...indexes)`
+
+指定されたインデックスにある要素を配列から削除し、削除された要素の配列を返します。元の配列は変更されます。
+
+```typescript
+import { pullAt } from 'es-toolkit/compat';
+
+// 個別のインデックスで削除
+const array = [1, 2, 3, 4, 5];
+const removed = pullAt(array, 1, 3);
+console.log(array); // [1, 3, 5]
+console.log(removed); // [2, 4]
+
+// インデックスの配列で削除
+const colors = ['red', 'green', 'blue', 'yellow'];
+const removedColors = pullAt(colors, [0, 2]);
+console.log(colors); // ['green', 'yellow']
+console.log(removedColors); // ['red', 'blue']
+```
+
+存在しないインデックスは `undefined` として扱われます。
+
+```typescript
+import { pullAt } from 'es-toolkit/compat';
+
+const numbers = [10, 20, 30];
+const removed = pullAt(numbers, 1, 5);
+console.log(numbers); // [10, 30]
+console.log(removed); // [20, undefined]
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike`): 変更する配列です。
+- `...indexes` (`Array`): 削除する要素のインデックスです。個別の数値または数値の配列として渡すことができます。
+
+#### 戻り値
+
+(`ArrayLike`): 削除された要素の配列を返します。
diff --git a/docs/ja/reference/compat/array/reduce.md b/docs/ja/compat/reference/array/reduce.md
similarity index 100%
rename from docs/ja/reference/compat/array/reduce.md
rename to docs/ja/compat/reference/array/reduce.md
diff --git a/docs/ja/reference/compat/array/reduceRight.md b/docs/ja/compat/reference/array/reduceRight.md
similarity index 100%
rename from docs/ja/reference/compat/array/reduceRight.md
rename to docs/ja/compat/reference/array/reduceRight.md
diff --git a/docs/ja/reference/compat/array/reject.md b/docs/ja/compat/reference/array/reject.md
similarity index 100%
rename from docs/ja/reference/compat/array/reject.md
rename to docs/ja/compat/reference/array/reject.md
diff --git a/docs/ja/compat/reference/array/remove.md b/docs/ja/compat/reference/array/remove.md
new file mode 100644
index 000000000..8d54ff117
--- /dev/null
+++ b/docs/ja/compat/reference/array/remove.md
@@ -0,0 +1,70 @@
+# remove (Lodash 互換性)
+
+::: warning `es-toolkit`の`remove`を使用してください
+
+この`remove`関数は、Lodashとの互換性のために様々な形式の述語をサポートするため、複雑に実装されています。メインライブラリの`remove`関数はシンプルな関数述語のみをサポートするため、より高速に動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[remove](../../../reference/array/remove.md)を使用してください。
+
+:::
+
+配列から条件に一致する要素を削除し、削除された要素を配列として返します。
+
+```typescript
+const removedElements = remove(array, predicate);
+```
+
+## 使用法
+
+### `remove(array, predicate)`
+
+配列を反復処理し、与えられた条件に一致する要素を元の配列から削除し、削除された要素を新しい配列として返します。元の配列が直接変更されることに注意してください。
+
+```typescript
+import { remove } from 'es-toolkit/compat';
+
+// 関数を使用した条件で削除
+const numbers = [1, 2, 3, 4, 5];
+const evens = remove(numbers, n => n % 2 === 0);
+console.log(numbers); // => [1, 3, 5]
+console.log(evens); // => [2, 4]
+
+// 部分オブジェクトのマッチングで削除
+const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+const removed = remove(objects, { a: 1 });
+console.log(objects); // => [{ a: 2 }, { a: 3 }]
+console.log(removed); // => [{ a: 1 }]
+
+// プロパティ-値ペアで削除
+const items = [{ name: 'apple' }, { name: 'banana' }, { name: 'cherry' }];
+const cherries = remove(items, ['name', 'cherry']);
+console.log(items); // => [{ name: 'apple' }, { name: 'banana' }]
+console.log(cherries); // => [{ name: 'cherry' }]
+```
+
+この関数は様々な形式の述語をサポートします。
+
+```typescript
+import { remove } from 'es-toolkit/compat';
+
+// 関数を使用した条件
+remove(users, user => user.active === false);
+
+// 部分オブジェクトのマッチング
+remove(users, { status: 'inactive' });
+
+// プロパティ-値配列
+remove(users, ['type', 'guest']);
+
+// プロパティ名で真値を確認
+remove(users, 'isDeleted');
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike`): 変更する配列です。
+- `predicate` (`((value: T, index: number, array: ArrayLike) => boolean) | Partial | [keyof T, unknown] | keyof T`, オプション): 各要素に対して実行する条件です。デフォルトは`identity`です。
+
+#### 戻り値
+
+(`T[]`): 条件に一致して削除された要素で構成された新しい配列を返します。
diff --git a/docs/ja/reference/compat/array/reverse.md b/docs/ja/compat/reference/array/reverse.md
similarity index 100%
rename from docs/ja/reference/compat/array/reverse.md
rename to docs/ja/compat/reference/array/reverse.md
diff --git a/docs/ja/compat/reference/array/sample.md b/docs/ja/compat/reference/array/sample.md
new file mode 100644
index 000000000..87d880516
--- /dev/null
+++ b/docs/ja/compat/reference/array/sample.md
@@ -0,0 +1,54 @@
+# sample（Lodash 互換性）
+
+::: warning `es-toolkit` の [sample](../../../reference/array/sample.md) を使用してください
+
+この `sample` 関数は、`null` や `undefined` の処理、オブジェクト値の処理などにより、遅く動作します。
+
+より高速でモダンな `es-toolkit` の [sample](../../../reference/array/sample.md) を使用してください。
+
+:::
+
+配列またはオブジェクトからランダムな要素を1つ取得します。
+
+```typescript
+const randomItem = sample(collection);
+```
+
+## 使用法
+
+### `sample(collection)`
+
+配列またはオブジェクトからランダムな要素を1つ選択する場合は `sample` を使用します。配列ではランダムな要素を返し、オブジェクトではランダムな値を返します。
+
+```typescript
+import { sample } from 'es-toolkit/compat';
+
+// 配列からランダムな要素を取得
+sample([1, 2, 3, 4, 5]);
+// 1から5の中からランダムな数値を1つ返します
+
+// オブジェクトからランダムな値を取得
+sample({ a: 1, b: 2, c: 3 });
+// 1、2、3の中からランダムな値を1つ返します
+
+// 文字列も処理します
+sample('hello');
+// 'h'、'e'、'l'、'l'、'o'の中からランダムな文字を1つ返します
+```
+
+`null` や `undefined` は `undefined` を返します。
+
+```typescript
+import { sample } from 'es-toolkit/compat';
+
+sample(null); // undefined
+sample(undefined); // undefined
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | Record | null | undefined`): サンプリングする配列またはオブジェクト。
+
+#### 戻り値
+
+(`T | string | undefined`): 配列またはオブジェクトからランダムに選択された要素を返します。コレクションが空であるか `null`、`undefined` の場合は `undefined` を返します。
diff --git a/docs/ja/compat/reference/array/sampleSize.md b/docs/ja/compat/reference/array/sampleSize.md
new file mode 100644
index 000000000..4dcebd0f7
--- /dev/null
+++ b/docs/ja/compat/reference/array/sampleSize.md
@@ -0,0 +1,54 @@
+# sampleSize（Lodash 互換性）
+
+::: warning `es-toolkit` の [sampleSize](../../../reference/array/sampleSize.md) を使用してください
+
+この `sampleSize` 関数は、`null` や `undefined` の処理、オブジェクトのサポート、デフォルト値の処理などにより、遅く動作します。
+
+より高速でモダンな `es-toolkit` の [sampleSize](../../../reference/array/sampleSize.md) を使用してください。
+
+:::
+
+配列またはオブジェクトから指定された数だけランダムに要素を選択します。
+
+```typescript
+const sampled = sampleSize(collection, size);
+```
+
+## 使用法
+
+### `sampleSize(collection, size?)`
+
+配列またはオブジェクトからランダムに要素を選択する場合は `sampleSize` を使用します。Floyd アルゴリズムを使用して重複なく効率的にサンプリングします。
+
+```typescript
+import { sampleSize } from 'es-toolkit/compat';
+
+// 配列から3個の要素をランダムに選択します。
+sampleSize([1, 2, 3, 4, 5], 3);
+// 戻り値：[2, 4, 5]（実際の結果は異なる場合があります）
+
+// オブジェクトから2個の値をランダムに選択します。
+sampleSize({ a: 1, b: 2, c: 3, d: 4 }, 2);
+// 戻り値：[2, 4]（実際の結果は異なる場合があります）
+```
+
+`null` や `undefined` は空の配列として処理します。
+
+```typescript
+import { sampleSize } from 'es-toolkit/compat';
+
+sampleSize(null, 2);
+// 戻り値：[]
+
+sampleSize(undefined, 2);
+// 戻り値：[]
+```
+
+#### パラメータ
+
+- `collection` (`Record | Record | T | null | undefined`): サンプリングする配列またはオブジェクト。
+- `size` (`number`、オプション): 選択する要素の個数。デフォルトは `1` です。
+
+#### 戻り値
+
+(`T[]`)：ランダムに選択された要素で構成される新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/shuffle.md b/docs/ja/compat/reference/array/shuffle.md
new file mode 100644
index 000000000..1342cc3d5
--- /dev/null
+++ b/docs/ja/compat/reference/array/shuffle.md
@@ -0,0 +1,60 @@
+# shuffle（Lodash 互換性）
+
+::: warning `es-toolkit` の `shuffle` を使用してください
+
+この `shuffle` 関数は、Lodash との互換性のために追加の処理が含まれており、遅く動作します。
+
+より高速でモダンな `es-toolkit` の [shuffle](../../../reference/array/shuffle.md) を使用してください。
+
+:::
+
+配列またはオブジェクトの要素をランダムにシャッフルして新しい配列を返します。
+
+```typescript
+const result = shuffle(collection);
+```
+
+## 使用法
+
+### `shuffle(collection)`
+
+Fisher-Yates アルゴリズムを使用して配列またはオブジェクトの要素をランダムにシャッフルし、新しい配列を返します。元は変更されません。
+
+```typescript
+import { shuffle } from 'es-toolkit/compat';
+
+// 数値配列をシャッフル
+const numbers = [1, 2, 3, 4, 5];
+const shuffled1 = shuffle(numbers);
+// 戻り値：例えば [3, 1, 5, 2, 4]（毎回異なる順序）
+
+// 文字列配列をシャッフル
+const fruits = ['apple', 'banana', 'cherry', 'date'];
+const shuffled2 = shuffle(fruits);
+// 戻り値：例えば ['cherry', 'apple', 'date', 'banana']
+
+// オブジェクトの値をシャッフル
+const obj = { a: 1, b: 2, c: 3, d: 4 };
+const shuffled3 = shuffle(obj);
+// 戻り値：例えば [3, 1, 4, 2]（オブジェクトの値がランダムにシャッフルされる）
+```
+
+`null` や `undefined` は空の配列として処理します。
+
+```typescript
+import { shuffle } from 'es-toolkit/compat';
+
+shuffle(null);
+// 戻り値：[]
+
+shuffle(undefined);
+// 戻り値：[]
+```
+
+#### パラメータ
+
+- `collection` (`ArrayLike | T | null | undefined`): シャッフルする配列またはオブジェクト。
+
+#### 戻り値
+
+(`T[]`)：要素がランダムにシャッフルされた新しい配列を返します。
diff --git a/docs/ja/reference/compat/array/size.md b/docs/ja/compat/reference/array/size.md
similarity index 100%
rename from docs/ja/reference/compat/array/size.md
rename to docs/ja/compat/reference/array/size.md
diff --git a/docs/ja/reference/compat/array/slice.md b/docs/ja/compat/reference/array/slice.md
similarity index 100%
rename from docs/ja/reference/compat/array/slice.md
rename to docs/ja/compat/reference/array/slice.md
diff --git a/docs/ja/reference/compat/array/some.md b/docs/ja/compat/reference/array/some.md
similarity index 100%
rename from docs/ja/reference/compat/array/some.md
rename to docs/ja/compat/reference/array/some.md
diff --git a/docs/ja/reference/compat/array/sortBy.md b/docs/ja/compat/reference/array/sortBy.md
similarity index 100%
rename from docs/ja/reference/compat/array/sortBy.md
rename to docs/ja/compat/reference/array/sortBy.md
diff --git a/docs/ja/reference/compat/array/sortedIndex.md b/docs/ja/compat/reference/array/sortedIndex.md
similarity index 100%
rename from docs/ja/reference/compat/array/sortedIndex.md
rename to docs/ja/compat/reference/array/sortedIndex.md
diff --git a/docs/ja/reference/compat/array/sortedIndexBy.md b/docs/ja/compat/reference/array/sortedIndexBy.md
similarity index 100%
rename from docs/ja/reference/compat/array/sortedIndexBy.md
rename to docs/ja/compat/reference/array/sortedIndexBy.md
diff --git a/docs/ja/reference/compat/array/sortedIndexOf.md b/docs/ja/compat/reference/array/sortedIndexOf.md
similarity index 100%
rename from docs/ja/reference/compat/array/sortedIndexOf.md
rename to docs/ja/compat/reference/array/sortedIndexOf.md
diff --git a/docs/ja/reference/compat/array/sortedLastIndex.md b/docs/ja/compat/reference/array/sortedLastIndex.md
similarity index 100%
rename from docs/ja/reference/compat/array/sortedLastIndex.md
rename to docs/ja/compat/reference/array/sortedLastIndex.md
diff --git a/docs/ja/reference/compat/array/sortedLastIndexBy.md b/docs/ja/compat/reference/array/sortedLastIndexBy.md
similarity index 100%
rename from docs/ja/reference/compat/array/sortedLastIndexBy.md
rename to docs/ja/compat/reference/array/sortedLastIndexBy.md
diff --git a/docs/ja/reference/compat/array/sortedLastIndexOf.md b/docs/ja/compat/reference/array/sortedLastIndexOf.md
similarity index 100%
rename from docs/ja/reference/compat/array/sortedLastIndexOf.md
rename to docs/ja/compat/reference/array/sortedLastIndexOf.md
diff --git a/docs/ja/compat/reference/array/tail.md b/docs/ja/compat/reference/array/tail.md
new file mode 100644
index 000000000..71ede54b1
--- /dev/null
+++ b/docs/ja/compat/reference/array/tail.md
@@ -0,0 +1,58 @@
+# tail (Lodash 互換性)
+
+::: warning `es-toolkit`の[tail](../../../reference/array/tail.md)を使用してください
+
+この`tail`関数は、`null`や`undefined`の処理などにより遅く動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[tail](../../../reference/array/tail.md)を使用してください。
+
+:::
+
+配列の最初の要素を除いた残りの要素を返します。
+
+```typescript
+const result = tail(array);
+```
+
+## 使用法
+
+### `tail(array)`
+
+配列の最初の要素を除いたすべての要素を含む新しい配列を作成したい場合は`tail`を使用してください。入力配列が空または要素が1つだけの場合は空の配列を返します。
+
+```typescript
+import { tail } from 'es-toolkit/compat';
+
+// 数値配列から最初の要素を削除します。
+tail([1, 2, 3]);
+// Returns: [2, 3]
+
+// 文字列配列から最初の要素を削除します。
+tail(['a', 'b', 'c']);
+// Returns: ['b', 'c']
+
+// 要素が1つだけの配列です。
+tail([1]);
+// Returns: []
+
+// 空の配列です。
+tail([]);
+// Returns: []
+```
+
+`null`や`undefined`は空の配列として扱われます。
+
+```typescript
+import { tail } from 'es-toolkit/compat';
+
+tail(null); // []
+tail(undefined); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 最初の要素を削除する配列です。
+
+#### 戻り値
+
+(`T[]`): 最初の要素を除いた残りの要素を含む新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/take.md b/docs/ja/compat/reference/array/take.md
new file mode 100644
index 000000000..40862dcaf
--- /dev/null
+++ b/docs/ja/compat/reference/array/take.md
@@ -0,0 +1,56 @@
+# take (Lodash 互換性)
+
+::: warning `es-toolkit`の[take](../../../reference/array/take.md)を使用してください
+
+この`take`関数は、Lodashとの互換性のための追加処理が含まれているため遅く動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[take](../../../reference/array/take.md)を使用してください。
+
+:::
+
+配列の先頭から指定された個数の要素を取得して新しい配列を作成します。
+
+```typescript
+const result = take([1, 2, 3, 4, 5], 3);
+// resultは[1, 2, 3]になります。
+```
+
+## 使用法
+
+### `take(array, count)`
+
+配列の先頭から指定された個数の要素を取得して新しい配列を返します。`count`が配列の長さより大きい場合は、配列全体を返します。
+
+```typescript
+import { take } from 'es-toolkit/compat';
+
+// 基本的な使用法
+const numbers = [1, 2, 3, 4, 5];
+const result1 = take(numbers, 3);
+// Returns: [1, 2, 3]
+
+// 配列の長さより大きい個数を要求
+const result2 = take(numbers, 10);
+// Returns: [1, 2, 3, 4, 5] (配列全体)
+
+// 0個を要求
+const result3 = take(numbers, 0);
+// Returns: []
+
+// 空の配列を処理
+const result4 = take([], 3);
+// Returns: []
+
+// 負の数を処理
+const result5 = take(numbers, -1);
+// Returns: []
+```
+
+#### パラメータ
+
+- `array` (`T[]`): 要素を取得する配列です。
+- `count` (`number`): 取得する要素の個数です。デフォルト値は1です。
+
+#### 戻り値
+
+(`T[]`): 先頭から指定された個数の要素を含む新しい配列です。
diff --git a/docs/ja/compat/reference/array/takeRight.md b/docs/ja/compat/reference/array/takeRight.md
new file mode 100644
index 000000000..52ea71d85
--- /dev/null
+++ b/docs/ja/compat/reference/array/takeRight.md
@@ -0,0 +1,63 @@
+# takeRight (Lodash 互換性)
+
+::: warning `es-toolkit`の[takeRight](../../../reference/array/takeRight.md)を使用してください
+
+この`takeRight`関数は、`null`や`undefined`の処理などにより遅く動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[takeRight](../../../reference/array/takeRight.md)を使用してください。
+
+:::
+
+配列の末尾から指定された個数の要素を取得します。
+
+```typescript
+const result = takeRight(array, count);
+```
+
+## 使用法
+
+### `takeRight(array, count)`
+
+配列の末尾から指定された個数の要素を取得して新しい配列を作成したい場合は`takeRight`を使用してください。要求された個数が配列の長さより大きい場合は、配列全体を返します。
+
+```typescript
+import { takeRight } from 'es-toolkit/compat';
+
+// 数値配列から末尾の2個の要素を取得します。
+takeRight([1, 2, 3, 4, 5], 2);
+// Returns: [4, 5]
+
+// 文字列配列から末尾の3個の要素を取得します。
+takeRight(['a', 'b', 'c'], 2);
+// Returns: ['b', 'c']
+
+// 要求された個数が配列の長さより大きい場合
+takeRight([1, 2, 3], 5);
+// Returns: [1, 2, 3]
+
+// 0個を要求
+takeRight([1, 2, 3], 0);
+// Returns: []
+
+// 負の数を要求
+takeRight([1, 2, 3], -1);
+// Returns: []
+```
+
+`null`や`undefined`は空の配列として扱われます。
+
+```typescript
+import { takeRight } from 'es-toolkit/compat';
+
+takeRight(null, 2); // []
+takeRight(undefined, 2); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 要素を取得する配列です。
+- `count` (`number`, オプション): 取得する要素の個数です。デフォルト値は`1`です。
+
+#### 戻り値
+
+(`T[]`): 末尾から指定された個数の要素を含む新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/takeRightWhile.md b/docs/ja/compat/reference/array/takeRightWhile.md
new file mode 100644
index 000000000..a2f8831c4
--- /dev/null
+++ b/docs/ja/compat/reference/array/takeRightWhile.md
@@ -0,0 +1,71 @@
+# takeRightWhile (Lodash 互換性)
+
+::: warning `es-toolkit`の[takeRightWhile](../../../reference/array/takeRightWhile.md)を使用してください
+
+この`takeRightWhile`関数は、`null`や`undefined`の処理などにより遅く動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[takeRightWhile](../../../reference/array/takeRightWhile.md)を使用してください。
+
+:::
+
+条件を満たす間、配列の末尾から要素を取得します。
+
+```typescript
+const result = takeRightWhile(array, predicate);
+```
+
+## 使用法
+
+### `takeRightWhile(array, predicate)`
+
+配列の末尾から開始して条件を満たす間、要素を取得して新しい配列を作成したい場合は`takeRightWhile`を使用してください。条件が偽と評価されると停止します。
+
+```typescript
+import { takeRightWhile } from 'es-toolkit/compat';
+
+// 関数条件を使用
+const numbers = [1, 2, 3, 4, 5];
+takeRightWhile(numbers, x => x > 3);
+// Returns: [4, 5]
+
+// オブジェクトプロパティ条件を使用
+const users = [
+ { user: 'barney', active: true },
+ { user: 'fred', active: false },
+ { user: 'pebbles', active: false },
+];
+
+takeRightWhile(users, o => !o.active);
+// Returns: [{ user: 'fred', active: false }, { user: 'pebbles', active: false }]
+
+// 部分オブジェクトで条件マッチング
+takeRightWhile(users, { active: false });
+// Returns: [{ user: 'pebbles', active: false }]
+
+// プロパティ-値配列で条件マッチング
+takeRightWhile(users, ['active', false]);
+// Returns: [{ user: 'fred', active: false }, { user: 'pebbles', active: false }]
+
+// プロパティ名で真と評価される値を確認
+const items = [{ active: false }, { active: true }, { active: true }];
+takeRightWhile(items, 'active');
+// Returns: [{ active: true }, { active: true }]
+```
+
+`null`や`undefined`は空の配列として扱われます。
+
+```typescript
+import { takeRightWhile } from 'es-toolkit/compat';
+
+takeRightWhile(null, x => x > 0); // []
+takeRightWhile(undefined, x => x > 0); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 処理する配列です。
+- `predicate` (`ListIteratee`, オプション): 各要素に対して実行する条件です。関数、部分オブジェクト、プロパティ-値配列、プロパティ名を使用できます。デフォルトは恒等関数です。
+
+#### 戻り値
+
+(`T[]`): 条件を満たす間、配列の末尾から取得した要素の新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/takeWhile.md b/docs/ja/compat/reference/array/takeWhile.md
new file mode 100644
index 000000000..55e96b6c1
--- /dev/null
+++ b/docs/ja/compat/reference/array/takeWhile.md
@@ -0,0 +1,71 @@
+# takeWhile (Lodash 互換性)
+
+::: warning `es-toolkit`の[takeWhile](../../../reference/array/takeWhile.md)を使用してください
+
+この`takeWhile`関数は、`null`や`undefined`の処理などにより遅く動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[takeWhile](../../../reference/array/takeWhile.md)を使用してください。
+
+:::
+
+条件を満たす間、配列の先頭から要素を取得します。
+
+```typescript
+const result = takeWhile(array, predicate);
+```
+
+## 使用法
+
+### `takeWhile(array, predicate)`
+
+配列の開始から条件を満たす間、要素を取得して新しい配列を作成したい場合は`takeWhile`を使用してください。条件が偽と評価されると停止します。
+
+```typescript
+import { takeWhile } from 'es-toolkit/compat';
+
+// 関数条件を使用
+const numbers = [1, 2, 3, 4, 5];
+takeWhile(numbers, x => x < 3);
+// Returns: [1, 2]
+
+// オブジェクトプロパティ条件を使用
+const users = [
+ { user: 'barney', active: false },
+ { user: 'fred', active: false },
+ { user: 'pebbles', active: true },
+];
+
+takeWhile(users, o => !o.active);
+// Returns: [{ user: 'barney', active: false }, { user: 'fred', active: false }]
+
+// 部分オブジェクトで条件マッチング
+takeWhile(users, { active: false });
+// Returns: [{ user: 'barney', active: false }]
+
+// プロパティ-値配列で条件マッチング
+takeWhile(users, ['active', false]);
+// Returns: [{ user: 'barney', active: false }, { user: 'fred', active: false }]
+
+// プロパティ名で真と評価される値を確認
+const items = [{ active: true }, { active: true }, { active: false }];
+takeWhile(items, 'active');
+// Returns: [{ active: true }, { active: true }]
+```
+
+`null`や`undefined`は空の配列として扱われます。
+
+```typescript
+import { takeWhile } from 'es-toolkit/compat';
+
+takeWhile(null, x => x > 0); // []
+takeWhile(undefined, x => x > 0); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 処理する配列です。
+- `predicate` (`ListIteratee`, オプション): 各要素に対して実行する条件です。関数、部分オブジェクト、プロパティ-値配列、プロパティ名を使用できます。デフォルトは恒等関数です。
+
+#### 戻り値
+
+(`T[]`): 条件を満たす間、配列の先頭から取得した要素の新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/union.md b/docs/ja/compat/reference/array/union.md
new file mode 100644
index 000000000..7f00e0da5
--- /dev/null
+++ b/docs/ja/compat/reference/array/union.md
@@ -0,0 +1,62 @@
+# union (Lodash互換)
+
+::: warning `es-toolkit`の[union](../../../reference/array/union.md)を使用してください
+
+この`union`関数は複雑な配列処理により動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[union](../../../reference/array/union.md)を使用してください。
+
+:::
+
+複数の配列からユニークな値のみを集めて新しい配列を作成します。
+
+```typescript
+const result = union(...arrays);
+```
+
+## 使用法
+
+### `union(...arrays)`
+
+複数の配列をマージして重複を削除し、ユニークな値のみを含む新しい配列を作成したい場合は`union`を使用してください。各値が最初に出現する順序を保持します。
+
+```typescript
+import { union } from 'es-toolkit/compat';
+
+// 数値配列をマージ
+union([2], [1, 2]);
+// 戻り値: [2, 1]
+
+// 複数の配列をマージ
+union([2], [1, 2], [2, 3]);
+// 戻り値: [2, 1, 3]
+
+// ネストした配列は平坦化されません
+union([1, 3, 2], [1, [5]], [2, [4]]);
+// 戻り値: [1, 3, 2, [5], [4]]
+
+// 配列でない値は無視されます
+union([0], 3, { '0': 1 }, null, [2, 1]);
+// 戻り値: [0, 2, 1]
+
+// 配列のようなオブジェクトも処理されます
+union([0], { 0: 'a', length: 1 }, [2, 1]);
+// 戻り値: [0, 'a', 2, 1]
+```
+
+`null`または`undefined`は無視されます。
+
+```typescript
+import { union } from 'es-toolkit/compat';
+
+union([1, 2], null, undefined, [3, 4]);
+// 戻り値: [1, 2, 3, 4]
+```
+
+#### パラメータ
+
+- `...arrays` (`Array | null | undefined>`): マージする配列。配列でない値は無視されます。
+
+#### 戻り値
+
+(`T[]`): すべての配列のユニークな値を含む新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/unionBy.md b/docs/ja/compat/reference/array/unionBy.md
new file mode 100644
index 000000000..66e035cce
--- /dev/null
+++ b/docs/ja/compat/reference/array/unionBy.md
@@ -0,0 +1,66 @@
+# unionBy (Lodash互換)
+
+::: warning `es-toolkit`の[unionBy](../../../reference/array/unionBy.md)を使用してください
+
+この`unionBy`関数は複雑な処理により動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[unionBy](../../../reference/array/unionBy.md)を使用してください。
+
+:::
+
+複数の配列をマージし、指定された基準に基づいてユニークな値のみを残します。
+
+```typescript
+const result = unionBy(...arrays, iteratee);
+```
+
+## 使用法
+
+### `unionBy(...arrays, iteratee)`
+
+複数の配列をマージし、与えられた基準関数に基づいて重複を削除してユニークな値のみを含む新しい配列を作成したい場合は`unionBy`を使用してください。各値が最初に出現する順序を保持します。
+
+```typescript
+import { unionBy } from 'es-toolkit/compat';
+
+// 小数を切り捨てて比較
+unionBy([2.1], [1.2, 2.3], Math.floor);
+// 戻り値: [2.1, 1.2]
+
+// オブジェクトのプロパティで比較
+unionBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], 'x');
+// 戻り値: [{ x: 1 }, { x: 2 }]
+
+// 関数で比較
+unionBy(
+ [{ id: 1, name: 'a' }],
+ [
+ { id: 2, name: 'b' },
+ { id: 1, name: 'c' },
+ ],
+ item => item.id
+);
+// 戻り値: [{ id: 1, name: 'a' }, { id: 2, name: 'b' }]
+
+// 部分オブジェクトで比較
+unionBy([{ x: 1, y: 1 }], [{ x: 1, y: 2 }], { x: 1 });
+// 戻り値: [{ x: 1, y: 1 }]
+```
+
+`null`または`undefined`配列は無視されます。
+
+```typescript
+import { unionBy } from 'es-toolkit/compat';
+
+unionBy([1, 2], null, undefined, [3, 4], x => x);
+// 戻り値: [1, 2, 3, 4]
+```
+
+#### パラメータ
+
+- `...arrays` (`Array | null | undefined>`): マージする配列。
+- `iteratee` (`ValueIteratee`): ユニーク性を決定する基準。関数、プロパティ名、部分オブジェクト、またはプロパティ-値配列を使用できます。
+
+#### 戻り値
+
+(`T[]`): 指定された基準に基づいて重複を削除したユニークな値を含む新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/unionWith.md b/docs/ja/compat/reference/array/unionWith.md
new file mode 100644
index 000000000..f2698c9aa
--- /dev/null
+++ b/docs/ja/compat/reference/array/unionWith.md
@@ -0,0 +1,64 @@
+# unionWith (Lodash互換)
+
+::: warning `es-toolkit`の[unionWith](../../../reference/array/unionWith.md)を使用してください
+
+この`unionWith`関数は複雑な処理により動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[unionWith](../../../reference/array/unionWith.md)を使用してください。
+
+:::
+
+複数の配列をマージし、比較関数を使用してユニークな値のみを残します。
+
+```typescript
+const result = unionWith(...arrays, comparator);
+```
+
+## 使用法
+
+### `unionWith(...arrays, comparator)`
+
+複数の配列をマージし、カスタム比較関数を使用して重複を削除し、ユニークな値のみを含む新しい配列を作成したい場合は`unionWith`を使用してください。各値が最初に出現する順序を保持します。
+
+```typescript
+import { unionWith } from 'es-toolkit/compat';
+
+// カスタム比較関数を使用
+const objects = [
+ { x: 1, y: 2 },
+ { x: 2, y: 1 },
+];
+const others = [
+ { x: 1, y: 1 },
+ { x: 1, y: 2 },
+];
+
+unionWith(objects, others, (a, b) => a.x === b.x && a.y === b.y);
+// 戻り値: [{ x: 1, y: 2 }, { x: 2, y: 1 }, { x: 1, y: 1 }]
+
+// 単純な等価比較
+unionWith([1, 2], [2, 3], (a, b) => a === b);
+// 戻り値: [1, 2, 3]
+
+// 文字列の長さで比較
+unionWith(['ab', 'cd'], ['ef', 'gh', 'ab'], (a, b) => a.length === b.length);
+// 戻り値: ['ab']
+```
+
+`null`または`undefined`配列は無視されます。
+
+```typescript
+import { unionWith } from 'es-toolkit/compat';
+
+unionWith([1, 2], null, undefined, [3, 4], (a, b) => a === b);
+// 戻り値: [1, 2, 3, 4]
+```
+
+#### パラメータ
+
+- `...arrays` (`Array | null | undefined>`): マージする配列。
+- `comparator` (`(a: T, b: T) => boolean`): 2つの値が等しいかどうかを判断する比較関数。
+
+#### 戻り値
+
+(`T[]`): 比較関数を使用して重複を削除したユニークな値を含む新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/uniq.md b/docs/ja/compat/reference/array/uniq.md
new file mode 100644
index 000000000..23b7c4bec
--- /dev/null
+++ b/docs/ja/compat/reference/array/uniq.md
@@ -0,0 +1,51 @@
+# uniq (Lodash互換)
+
+::: warning `es-toolkit`の[uniq](../../../reference/array/uniq.md)を使用してください
+
+この`uniq`関数はLodash互換性のための追加処理により動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[uniq](../../../reference/array/uniq.md)を使用してください。
+
+:::
+
+配列から重複する要素を削除してユニークな要素のみを残した新しい配列を作成します。
+
+```typescript
+const result = uniq([1, 2, 2, 3, 3, 4]);
+// resultは[1, 2, 3, 4]になります。
+```
+
+## 使用法
+
+### `uniq(array)`
+
+配列から重複する要素を削除してユニークな要素のみを含む新しい配列を返します。最初に出現する要素のみが保持され、順序は保たれます。
+
+```typescript
+import { uniq } from 'es-toolkit/compat';
+
+// 数値配列から重複を削除
+const numbers = [1, 2, 2, 3, 3, 4, 1];
+const result1 = uniq(numbers);
+// 戻り値: [1, 2, 3, 4]
+
+// 文字列配列から重複を削除
+const strings = ['a', 'b', 'b', 'c', 'a'];
+const result2 = uniq(strings);
+// 戻り値: ['a', 'b', 'c']
+
+// オブジェクト配列から重複を削除（参照値比較）
+const obj1 = { id: 1 };
+const obj2 = { id: 2 };
+const objects = [obj1, obj2, obj1];
+const result3 = uniq(objects);
+// 戻り値: [{ id: 1 }, { id: 2 }]
+```
+
+#### パラメータ
+
+- `array` (`T[]`): 処理する配列。
+
+#### 戻り値
+
+(`T[]`): 重複が削除された新しい配列。
diff --git a/docs/ja/compat/reference/array/uniqBy.md b/docs/ja/compat/reference/array/uniqBy.md
new file mode 100644
index 000000000..59c72a1c4
--- /dev/null
+++ b/docs/ja/compat/reference/array/uniqBy.md
@@ -0,0 +1,55 @@
+# uniqBy (Lodash互換)
+
+::: warning `es-toolkit`の[uniqBy](../../../reference/array/uniqBy.md)を使用してください
+
+この`uniqBy`関数は`null`または`undefined`の処理、複雑な引数タイプ処理などにより動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[uniqBy](../../../reference/array/uniqBy.md)を使用してください。
+
+:::
+
+配列で変換関数が返す値に基づいて重複を削除し、ユニークな要素で構成される新しい配列を作成します。
+
+```typescript
+const result = uniqBy(array, iteratee);
+```
+
+## 使用法
+
+### `uniqBy(array, iteratee)`
+
+配列の各要素に変換関数を適用し、変換結果が同じ要素の中で最初の要素のみを保持します。オブジェクト配列で特定のプロパティを基準に重複を削除したり、数値配列で特定の計算結果を基準に重複を削除するときに便利です。
+
+```typescript
+import { uniqBy } from 'es-toolkit/compat';
+
+// 数値配列でMath.floor結果により重複を削除
+uniqBy([2.1, 1.2, 2.3], Math.floor);
+// 戻り値: [2.1, 1.2]
+
+// オブジェクト配列でプロパティにより重複を削除
+uniqBy([{ x: 1 }, { x: 2 }, { x: 1 }], 'x');
+// 戻り値: [{ x: 1 }, { x: 2 }]
+
+// 関数で重複を削除
+uniqBy([{ name: 'John' }, { name: 'Jane' }, { name: 'John' }], obj => obj.name);
+// 戻り値: [{ name: 'John' }, { name: 'Jane' }]
+```
+
+`null`または`undefined`は空配列として扱われます。
+
+```typescript
+import { uniqBy } from 'es-toolkit/compat';
+
+uniqBy(null, Math.floor); // []
+uniqBy(undefined, 'x'); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 重複を削除する配列。
+- `iteratee` (`ValueIteratee`): 各要素に適用する変換関数。関数、プロパティ名、部分オブジェクトなどを使用できます。
+
+#### 戻り値
+
+(`T[]`): 変換関数の結果を基準に重複が削除された新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/uniqWith.md b/docs/ja/compat/reference/array/uniqWith.md
new file mode 100644
index 000000000..e1aad566b
--- /dev/null
+++ b/docs/ja/compat/reference/array/uniqWith.md
@@ -0,0 +1,60 @@
+# uniqWith (Lodash互換)
+
+::: warning `es-toolkit`の[uniqWith](../../../reference/array/uniqWith.md)を使用してください
+
+この`uniqWith`関数は`null`または`undefined`の処理、複雑な引数タイプ処理などにより動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[uniqWith](../../../reference/array/uniqWith.md)を使用してください。
+
+:::
+
+配列で比較関数を使用して重複を削除し、ユニークな要素で構成される新しい配列を作成します。
+
+```typescript
+const result = uniqWith(array, comparator);
+```
+
+## 使用法
+
+### `uniqWith(array, comparator)`
+
+配列の各要素を比較関数で比較して重複を削除します。比較関数が`true`を返すと2つの要素が同じと判断され、最初に出現する要素のみが保持されます。比較関数を提供しない場合、デフォルトで浅い等価比較を使用します。
+
+```typescript
+import { uniqWith } from 'es-toolkit/compat';
+
+// 比較関数なしで使用（浅い等価比較）
+uniqWith([1, 2, 2, 3]);
+// 戻り値: [1, 2, 3]
+
+// カスタム比較関数で奇数/偶数基準により重複を削除
+uniqWith([1, 2, 3, 4], (a, b) => a % 2 === b % 2);
+// 戻り値: [1, 2]
+
+// オブジェクト配列でプロパティ基準により重複を削除
+const objects = [
+ { x: 1, y: 2 },
+ { x: 2, y: 1 },
+ { x: 1, y: 2 },
+];
+uniqWith(objects, (a, b) => a.x === b.x && a.y === b.y);
+// 戻り値: [{ x: 1, y: 2 }, { x: 2, y: 1 }]
+```
+
+`null`または`undefined`は空配列として扱われます。
+
+```typescript
+import { uniqWith } from 'es-toolkit/compat';
+
+uniqWith(null); // []
+uniqWith(undefined); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 重複を削除する配列。
+- `comparator` (`(a: T, b: T) => boolean`, 選択): 2つの要素が等しいか比較する関数。`true`を返すと同じと判断されます。デフォルトは浅い等価比較です。
+
+#### 戻り値
+
+(`T[]`): 比較関数の結果を基準に重複が削除された新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/unzip.md b/docs/ja/compat/reference/array/unzip.md
new file mode 100644
index 000000000..8113c6690
--- /dev/null
+++ b/docs/ja/compat/reference/array/unzip.md
@@ -0,0 +1,68 @@
+# unzip (Lodash互換)
+
+::: warning `es-toolkit`の[unzip](../../../reference/array/unzip.md)を使用してください
+
+この`unzip`関数は`null`または`undefined`の処理、配列でない値のフィルタリングなどにより動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[unzip](../../../reference/array/unzip.md)を使用してください。
+
+:::
+
+グループ化された配列の同じ位置にある要素を集めて新しい配列を作成します。
+
+```typescript
+const result = unzip(array);
+```
+
+## 使用法
+
+### `unzip(array)`
+
+ネストした配列の同じインデックスにある要素を集めて新しい配列として返します。`zip`関数の逆の操作を実行します。行列を転置したり構造化データを再編成するときに便利です。
+
+```typescript
+import { unzip } from 'es-toolkit/compat';
+
+// 文字列、ブール値、数値が混在した配列をアンジップ
+const zipped = [
+ ['a', true, 1],
+ ['b', false, 2],
+];
+const result = unzip(zipped);
+// 戻り値: [['a', 'b'], [true, false], [1, 2]]
+
+// 数値配列をアンジップ
+const numbers = [
+ [1, 4],
+ [2, 5],
+ [3, 6],
+];
+unzip(numbers);
+// 戻り値: [[1, 2, 3], [4, 5, 6]]
+
+// 長さが異なる配列も処理
+const uneven = [
+ ['a', 1],
+ ['b', 2, true],
+];
+unzip(uneven);
+// 戻り値: [['a', 'b'], [1, 2], [undefined, true]]
+```
+
+`null`、`undefined`、または空配列は空配列として扱われます。
+
+```typescript
+import { unzip } from 'es-toolkit/compat';
+
+unzip(null); // []
+unzip(undefined); // []
+unzip([]); // []
+```
+
+#### パラメータ
+
+- `array` (`T[][] | ArrayLike> | null | undefined`): アンジップするネストした配列。各内部配列の同じ位置の要素が集められます。
+
+#### 戻り値
+
+(`T[][]`): 同じ位置の要素が集められた新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/unzipWith.md b/docs/ja/compat/reference/array/unzipWith.md
new file mode 100644
index 000000000..372f38a83
--- /dev/null
+++ b/docs/ja/compat/reference/array/unzipWith.md
@@ -0,0 +1,84 @@
+# unzipWith (Lodash互換)
+
+::: warning `es-toolkit`の`unzipWith`を使用してください
+
+この`unzipWith`関数は`null`または`undefined`の処理、`ArrayLike`タイプ処理、さまざまな条件関数形式のサポートなどにより動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[unzipWith](../../../reference/array/unzipWith.md)を使用してください。
+
+:::
+
+グループ化された配列の同じ位置にある要素を集めて変換関数を適用した新しい配列を作成します。
+
+```typescript
+const result = unzipWith(array, iteratee);
+```
+
+## 使用法
+
+### `unzipWith(array, iteratee)`
+
+ネストした配列の同じインデックスにある要素を集めて変換関数を適用します。`unzip`関数と似ていますが、各グループに変換関数を適用できます。変換関数を提供しない場合、デフォルトの`unzip`操作を実行します。
+
+```typescript
+import { unzipWith } from 'es-toolkit/compat';
+
+// 同じ位置の要素を足す
+unzipWith(
+ [
+ [1, 10, 100],
+ [2, 20, 200],
+ ],
+ (a, b) => a + b
+);
+// 戻り値: [3, 30, 300]
+
+// 変換関数なしで使用（デフォルトunzip操作）
+unzipWith([
+ [1, 4],
+ [2, 5],
+ [3, 6],
+]);
+// 戻り値: [[1, 2, 3], [4, 5, 6]]
+
+// 文字列連結
+unzipWith(
+ [
+ ['a', 'x'],
+ ['b', 'y'],
+ ['c', 'z'],
+ ],
+ (a, b) => a + b
+);
+// 戻り値: ['abc', 'xyz']
+
+// 最大値を探す
+unzipWith(
+ [
+ [1, 10],
+ [2, 20],
+ [3, 5],
+ ],
+ Math.max
+);
+// 戻り値: [3, 20]
+```
+
+`null`、`undefined`、または空配列は空配列として扱われます。
+
+```typescript
+import { unzipWith } from 'es-toolkit/compat';
+
+unzipWith(null, (a, b) => a + b); // []
+unzipWith(undefined, (a, b) => a + b); // []
+unzipWith([], (a, b) => a + b); // []
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike> | null | undefined`): アンジップするネストした配列。
+- `iteratee` (`(...values: T[]) => R`, 選択): 各グループの要素に適用する変換関数。提供しない場合、デフォルトの`unzip`操作を実行します。
+
+#### 戻り値
+
+(`R[]`または`T[][]`): 変換関数がある場合は変換された結果の配列を、ない場合はアンジップされた配列を返します。
diff --git a/docs/ja/compat/reference/array/without.md b/docs/ja/compat/reference/array/without.md
new file mode 100644
index 000000000..cc1fbbf0e
--- /dev/null
+++ b/docs/ja/compat/reference/array/without.md
@@ -0,0 +1,49 @@
+# without (Lodash互換)
+
+::: warning `es-toolkit`の[without](../../../reference/array/without.md)を使用してください
+
+この`without`関数はLodash互換性のための追加処理により動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[without](../../../reference/array/without.md)を使用してください。
+
+:::
+
+配列から指定された値を除外した新しい配列を作成します。
+
+```typescript
+const result = without([1, 2, 3, 4, 5], 2, 4);
+// resultは[1, 3, 5]になります。
+```
+
+## 使用法
+
+### `without(array, ...values)`
+
+配列から指定された値を削除した新しい配列を返します。元の配列は変更されません。
+
+```typescript
+import { without } from 'es-toolkit/compat';
+
+// 数値配列から複数の値を削除
+const numbers = [1, 2, 3, 4, 5, 2, 4];
+const result1 = without(numbers, 2, 4);
+// 戻り値: [1, 3, 5]
+
+// 文字列配列から値を削除
+const fruits = ['apple', 'banana', 'cherry', 'banana'];
+const result2 = without(fruits, 'banana');
+// 戻り値: ['apple', 'cherry']
+
+// 空配列を処理
+const result3 = without([], 1, 2, 3);
+// 戻り値: []
+```
+
+#### パラメータ
+
+- `array` (`T[]`): 処理する元の配列。
+- `...values` (`T[]`): 削除する値。
+
+#### 戻り値
+
+(`T[]`): 指定された値を削除した新しい配列。
diff --git a/docs/ja/compat/reference/array/xor.md b/docs/ja/compat/reference/array/xor.md
new file mode 100644
index 000000000..3c7a3e6b1
--- /dev/null
+++ b/docs/ja/compat/reference/array/xor.md
@@ -0,0 +1,61 @@
+# xor (Lodash互換)
+
+::: warning `es-toolkit`の[xor](../../../reference/array/xor.md)を使用してください
+
+この`xor`関数は`null`または`undefined`の処理、複雑な重複計算ロジックなどにより動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[xor](../../../reference/array/xor.md)を使用してください。
+
+:::
+
+複数の配列で正確に1つの配列にのみ存在する要素で構成される新しい配列を作成します。
+
+```typescript
+const result = xor(...arrays);
+```
+
+## 使用法
+
+### `xor(...arrays)`
+
+複数の配列の対称差集合を計算します。つまり、与えられた配列の中で正確に1つの配列にのみ存在する要素を返します。2つ以上の配列を比較する際に重複しないユニークな要素を見つけたい場合に便利です。
+
+```typescript
+import { xor } from 'es-toolkit/compat';
+
+// 2つの配列の対称差集合
+xor([1, 2, 3, 4], [3, 4, 5, 6]);
+// 戻り値: [1, 2, 5, 6]
+
+// 3つの配列の対称差集合
+xor([1, 2], [2, 3], [4, 5]);
+// 戻り値: [1, 3, 4, 5]
+
+// 文字列配列
+xor(['a', 'b'], ['b', 'c']);
+// 戻り値: ['a', 'c']
+
+// 1つの配列のみを提供
+xor([1, 2, 3]);
+// 戻り値: [1, 2, 3]
+```
+
+`null`、`undefined`、または空配列は無視され、有効な配列のみが処理されます。
+
+```typescript
+import { xor } from 'es-toolkit/compat';
+
+xor([1, 2], null, [2, 3]);
+// 戻り値: [1, 3]
+
+xor([], [1, 2], [2, 3]);
+// 戻り値: [1, 3]
+```
+
+#### パラメータ
+
+- `...arrays` (`Array | null | undefined>`): 対称差集合を計算する配列。`null`または`undefined`は無視されます。
+
+#### 戻り値
+
+(`T[]`): 正確に1つの配列にのみ存在する要素で構成される新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/xorBy.md b/docs/ja/compat/reference/array/xorBy.md
new file mode 100644
index 000000000..4d32fd9c8
--- /dev/null
+++ b/docs/ja/compat/reference/array/xorBy.md
@@ -0,0 +1,63 @@
+# xorBy (Lodash互換)
+
+::: warning `es-toolkit`の[xorBy](../../../reference/array/xorBy.md)を使用してください
+
+この`xorBy`関数は`null`または`undefined`の処理、複雑な重複計算ロジックなどにより動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[xorBy](../../../reference/array/xorBy.md)を使用してください。
+
+:::
+
+複数の配列で変換関数を基準に正確に1つの配列にのみ存在する要素で構成される新しい配列を作成します。
+
+```typescript
+const result = xorBy(...arrays, iteratee);
+```
+
+## 使用法
+
+### `xorBy(...arrays, iteratee)`
+
+複数の配列の対称差集合を変換関数を基準に計算します。各要素に変換関数を適用した結果が正確に1つの配列にのみ存在する要素を返します。オブジェクト配列で特定のプロパティを基準に比較したり、数値配列で特定の計算結果を基準に比較するときに便利です。
+
+```typescript
+import { xorBy } from 'es-toolkit/compat';
+
+// Math.floor結果により対称差集合を計算
+xorBy([2.1, 1.2], [4.3, 2.4], Math.floor);
+// 戻り値: [1.2, 4.3]
+
+// オブジェクトのプロパティにより対称差集合を計算
+xorBy([{ x: 1 }], [{ x: 2 }, { x: 1 }], 'x');
+// 戻り値: [{ x: 2 }]
+
+// 関数で対称差集合を計算
+const users1 = [{ name: 'John', age: 30 }];
+const users2 = [
+ { name: 'Jane', age: 25 },
+ { name: 'John', age: 30 },
+];
+xorBy(users1, users2, user => user.name);
+// 戻り値: [{ name: 'Jane', age: 25 }]
+
+// 3つの配列の対称差集合
+xorBy([1.2, 2.3], [3.4, 4.5], [5.6, 6.7], Math.floor);
+// 戻り値: [1.2, 2.3, 3.4, 4.5, 5.6, 6.7]
+```
+
+`null`または`undefined`は無視されます。
+
+```typescript
+import { xorBy } from 'es-toolkit/compat';
+
+xorBy([2.1, 1.2], null, [4.3, 2.4], Math.floor);
+// 戻り値: [1.2, 4.3]
+```
+
+#### パラメータ
+
+- `...arrays` (`Array | null | undefined | ValueIteratee>`): 対称差集合を計算する配列と最後の変換関数。関数、プロパティ名、部分オブジェクトなどを使用できます。
+
+#### 戻り値
+
+(`T[]`): 変換関数の結果を基準に正確に1つの配列にのみ存在する要素で構成される新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/xorWith.md b/docs/ja/compat/reference/array/xorWith.md
new file mode 100644
index 000000000..56b7280bf
--- /dev/null
+++ b/docs/ja/compat/reference/array/xorWith.md
@@ -0,0 +1,66 @@
+# xorWith (Lodash互換)
+
+::: warning `es-toolkit`の[xorWith](../../../reference/array/xorWith.md)を使用してください
+
+この`xorWith`関数は`null`または`undefined`の処理、複雑な重複計算ロジックなどにより動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[xorWith](../../../reference/array/xorWith.md)を使用してください。
+
+:::
+
+複数の配列で比較関数を使用して正確に1つの配列にのみ存在する要素で構成される新しい配列を作成します。
+
+```typescript
+const result = xorWith(...arrays, comparator);
+```
+
+## 使用法
+
+### `xorWith(...arrays, comparator)`
+
+複数の配列の対称差集合を比較関数を使用して計算します。比較関数が`true`を返すと2つの要素が同じと判断され、正確に1つの配列にのみ存在する要素を返します。複雑なオブジェクトやカスタム比較ロジックが必要な場合に便利です。
+
+```typescript
+import { xorWith } from 'es-toolkit/compat';
+
+// 単純な数値比較
+xorWith([1, 2], [2, 3], (a, b) => a === b);
+// 戻り値: [1, 3]
+
+// オブジェクトのプロパティを比較
+const objects = [
+ { x: 1, y: 2 },
+ { x: 2, y: 1 },
+];
+const others = [
+ { x: 1, y: 1 },
+ { x: 1, y: 2 },
+];
+xorWith(objects, others, (a, b) => a.x === b.x && a.y === b.y);
+// 戻り値: [{ x: 2, y: 1 }, { x: 1, y: 1 }]
+
+// 3つの配列の対称差集合
+xorWith([1], [2], [3], (a, b) => a === b);
+// 戻り値: [1, 2, 3]
+
+// 文字列の長さで比較
+xorWith(['hello'], ['world', 'hi'], (a, b) => a.length === b.length);
+// 戻り値: ['hi']
+```
+
+比較関数を提供しない場合、デフォルトで浅い等価比較を使用します。
+
+```typescript
+import { xorWith } from 'es-toolkit/compat';
+
+xorWith([1, 2], [2, 3]);
+// 戻り値: [1, 3]
+```
+
+#### パラメータ
+
+- `...arrays` (`Array | null | undefined | ((a: T, b: T) => boolean)>`): 対称差集合を計算する配列と最後の比較関数。比較関数は2つの要素が等しい場合に`true`を返す必要があります。
+
+#### 戻り値
+
+(`T[]`): 比較関数の結果を基準に正確に1つの配列にのみ存在する要素で構成される新しい配列を返します。
diff --git a/docs/ja/compat/reference/array/zip.md b/docs/ja/compat/reference/array/zip.md
new file mode 100644
index 000000000..89ac859d2
--- /dev/null
+++ b/docs/ja/compat/reference/array/zip.md
@@ -0,0 +1,48 @@
+# zip (Lodash互換)
+
+::: warning `es-toolkit`の[zip](../../../reference/array/zip.md)を使用してください
+
+この`zip`関数はLodash互換性のための追加処理により動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[zip](../../../reference/array/zip.md)を使用してください。
+
+:::
+
+複数の配列を1つのタプルの配列に結合します。
+
+```typescript
+const result = zip([1, 2], ['a', 'b']);
+// resultは[[1, 'a'], [2, 'b']]になります。
+```
+
+## 使用法
+
+### `zip(...arrs)`
+
+複数の配列を受け取り、各インデックスの要素を1つのタプルにまとめて新しい配列を作成します。入力配列の長さが異なる場合、結果の配列の長さは最も長い入力配列の長さとなり、欠落した要素は`undefined`で埋められます。
+
+```typescript
+import { zip } from 'es-toolkit/compat';
+
+const arr1 = [1, 2, 3];
+const arr2 = ['a', 'b', 'c'];
+const result = zip(arr1, arr2);
+// 戻り値: [[1, 'a'], [2, 'b'], [3, 'c']]
+
+// 長さが異なる配列
+const arr3 = [true, false];
+const result2 = zip(arr1, arr2, arr3);
+// 戻り値: [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]
+
+// 空配列が含まれる場合
+zip([1, 2], [], ['a', 'b']);
+// 戻り値: [[1, undefined, 'a'], [2, undefined, 'b']]
+```
+
+#### パラメータ
+
+- `...arrs` (`any[][]`): 結合する配列。
+
+#### 戻り値
+
+(`any[][]`): 入力配列の各インデックスの要素を含むタプルの新しい配列。
diff --git a/docs/ja/compat/reference/array/zipObject.md b/docs/ja/compat/reference/array/zipObject.md
new file mode 100644
index 000000000..fe702b914
--- /dev/null
+++ b/docs/ja/compat/reference/array/zipObject.md
@@ -0,0 +1,50 @@
+# zipObject (Lodash互換)
+
+::: warning `es-toolkit`の[zipObject](../../../reference/array/zipObject.md)を使用してください
+
+この`zipObject`関数はLodash互換性のための追加処理により動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[zipObject](../../../reference/array/zipObject.md)を使用してください。
+
+:::
+
+2つの配列を使用してオブジェクトを作成します。最初の配列はプロパティ名として、2番目の配列は対応する値として使用されます。
+
+```typescript
+const result = zipObject(keys, values);
+```
+
+## 使用法
+
+### `zipObject(keys, values)`
+
+キー配列と値配列から1つのオブジェクトを作成したい場合は`zipObject`を使用してください。最初の配列の要素をプロパティ名として、2番目の配列の要素を対応する値として使用してオブジェクトを作成します。APIレスポンスの処理やデータの変換時に特に便利です。
+
+```typescript
+import { zipObject } from 'es-toolkit/compat';
+
+// 基本的な使用法
+const keys = ['a', 'b', 'c'];
+const values = [1, 2, 3];
+const result = zipObject(keys, values);
+// 戻り値: { a: 1, b: 2, c: 3 }
+
+// 長さが異なる配列
+const keys2 = ['x', 'y', 'z'];
+const values2 = [10, 20];
+const result2 = zipObject(keys2, values2);
+// 戻り値: { x: 10, y: 20, z: undefined }
+
+// 空配列が提供された場合
+const result3 = zipObject([], []);
+// 戻り値: {}
+```
+
+#### パラメータ
+
+- `keys` (`PropertyKey[]`): プロパティ名として使用する配列。
+- `values` (`T[]`): プロパティ値として使用する配列。
+
+#### 戻り値
+
+(`Record`): 作成されたオブジェクト。
diff --git a/docs/ja/reference/compat/array/zipObjectDeep.md b/docs/ja/compat/reference/array/zipObjectDeep.md
similarity index 100%
rename from docs/ja/reference/compat/array/zipObjectDeep.md
rename to docs/ja/compat/reference/array/zipObjectDeep.md
diff --git a/docs/ja/compat/reference/array/zipWith.md b/docs/ja/compat/reference/array/zipWith.md
new file mode 100644
index 000000000..108dd66dd
--- /dev/null
+++ b/docs/ja/compat/reference/array/zipWith.md
@@ -0,0 +1,47 @@
+# zipWith (Lodash互換)
+
+::: warning `es-toolkit`の[zipWith](../../../reference/array/zipWith.md)を使用してください
+
+この`zipWith`関数はLodash互換性のための追加処理により動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[zipWith](../../../reference/array/zipWith.md)を使用してください。
+
+:::
+
+複数の配列の要素を結合関数を使用して新しい配列に結合します。
+
+```typescript
+const result = zipWith([1, 2], [3, 4], (a, b) => a + b);
+// resultは[4, 6]になります。
+```
+
+## 使用法
+
+### `zipWith(...arrs, iteratee)`
+
+複数の配列を受け取り、各インデックスの要素を提供された関数で結合して新しい配列を作成します。配列の長さが異なる場合、最も長い配列の長さまで処理し、欠落した値には`undefined`が渡されます。
+
+```typescript
+import { zipWith } from 'es-toolkit/compat';
+
+// 2つの配列の要素を足す
+const result1 = zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b);
+// 戻り値: [5, 7, 9]
+
+// 3つの配列の要素を結合
+const result2 = zipWith([1, 2], [3, 4], [5, 6], (a, b, c) => a + b + c);
+// 戻り値: [9, 12]
+
+// 長さが異なる配列
+const result3 = zipWith([1, 2, 3], [4, 5], (a, b) => (a || 0) + (b || 0));
+// 戻り値: [5, 7, 3]
+```
+
+#### パラメータ
+
+- `...arrs` (`any[][]`): 結合する配列。
+- `iteratee` (`Function`): 各インデックスの要素を結合する関数。
+
+#### 戻り値
+
+(`any[]`): 結合関数を適用した結果からなる新しい配列。
diff --git a/docs/ja/compat/reference/function/after.md b/docs/ja/compat/reference/function/after.md
new file mode 100644
index 000000000..4b8877750
--- /dev/null
+++ b/docs/ja/compat/reference/function/after.md
@@ -0,0 +1,75 @@
+# after (Lodash 互換性)
+
+::: warning `es-toolkit` の [`after`](../../../reference/function/after.md) を使用してください
+
+この `after` 関数は、複雑な型検証と整数変換処理により動作が遅くなります。
+
+代わりに、より高速でモダンな `es-toolkit` の [after](../../../reference/function/after.md) を使用してください。
+
+:::
+
+指定された回数呼び出された後にのみ実行される関数を作成します。
+
+```typescript
+const restrictedFunction = after(n, func);
+```
+
+## 使用法
+
+### `after(n, func)`
+
+関数が特定の回数呼び出された後にのみ実行されるように制限したい場合は、`after` を使用してください。複数の非同期操作が完了した後にコールバックを実行したり、初期化段階を経た後に関数を有効化する際に便利です。
+
+```typescript
+import { after } from 'es-toolkit/compat';
+
+// 基本的な使用法
+const logAfterThree = after(3, () => {
+ console.log('3回目の呼び出しから実行されます!');
+});
+
+logAfterThree(); // 実行されない
+logAfterThree(); // 実行されない
+logAfterThree(); // "3回目の呼び出しから実行されます!" が出力される
+logAfterThree(); // "3回目の呼び出しから実行されます!" が出力される (実行が続く)
+```
+
+複数の非同期操作がすべて完了した後に特定のコールバックを実行する際にも使用できます。
+
+```typescript
+import { after } from 'es-toolkit/compat';
+
+const tasks = ['task1', 'task2', 'task3'];
+const allTasksComplete = after(tasks.length, () => {
+ console.log('すべてのタスクが完了しました!');
+});
+
+// 各タスクが完了するたびに呼び出される
+tasks.forEach(task => {
+ performAsyncTask(task, () => {
+ console.log(`${task} 完了`);
+ allTasksComplete(); // 3回目の呼び出しで "すべてのタスクが完了しました!" が出力される
+ });
+});
+```
+
+0または負の数を渡すと、最初の呼び出しからすぐに実行されます。
+
+```typescript
+import { after } from 'es-toolkit/compat';
+
+const immediate = after(0, () => console.log('すぐに実行'));
+immediate(); // "すぐに実行"
+
+const negative = after(-1, () => console.log('すぐに実行'));
+negative(); // "すぐに実行"
+```
+
+#### パラメータ
+
+- `n` (`number`): 関数が実行される前に必要な呼び出し回数です。
+- `func` (`TFunc`): 制限する関数です。
+
+#### 戻り値
+
+(`TFunc`): n回目の呼び出しから元の関数を実行する新しい制限された関数を返します。
diff --git a/docs/ja/compat/reference/function/ary.md b/docs/ja/compat/reference/function/ary.md
new file mode 100644
index 000000000..a3b9fe38c
--- /dev/null
+++ b/docs/ja/compat/reference/function/ary.md
@@ -0,0 +1,90 @@
+# ary (Lodash 互換性)
+
+::: warning `es-toolkit` の [`ary`](../../../reference/function/ary.md) を使用してください
+
+この `ary` 関数は、複雑なパラメータ検証により動作が遅くなります。
+
+代わりに、より高速でモダンな `es-toolkit` の [ary](../../../reference/function/ary.md) を使用してください。
+
+:::
+
+関数が受け取ることができる引数の数を制限する関数を作成します。
+
+```typescript
+const cappedFunction = ary(func, n);
+```
+
+## 使用法
+
+### `ary(func, n)`
+
+関数が受け取る引数の数を制限したい場合は、`ary` を使用してください。あまりにも多くの引数を受け取る関数を安全に使用したり、コールバック関数で不要な引数を無視する際に便利です。
+
+```typescript
+import { ary } from 'es-toolkit/compat';
+
+// 基本的な使用法
+function greet(name, age, city) {
+ return `こんにちは、${name}さん! ${age}歳、${city}からいらっしゃいました。`;
+}
+
+const limitedGreet = ary(greet, 2);
+console.log(limitedGreet('田中', 30, '東京', '追加引数'));
+// "こんにちは、田中さん! 30歳、undefinedからいらっしゃいました。"
+// 3番目の引数以降は無視される
+```
+
+配列メソッドと一緒に使用する際、コールバック関数に不要な引数が渡されないようにできます。
+
+```typescript
+import { ary } from 'es-toolkit/compat';
+
+// parseIntは第2引数(基数)を受け取るが、mapのコールバックは3つの引数を渡す
+const numbers = ['1', '2', '3', '4', '5'];
+
+// 誤った使用法 - parseIntがインデックスを基数として受け取る
+console.log(numbers.map(parseInt)); // [1, NaN, NaN, NaN, NaN]
+
+// aryを使用して最初の引数のみ渡す
+console.log(numbers.map(ary(parseInt, 1))); // [1, 2, 3, 4, 5]
+```
+
+関数が希望するパラメータ引数の数だけを受け取るように制限できます。
+
+```typescript
+import { ary } from 'es-toolkit/compat';
+
+function sum(...args) {
+ return args.reduce((total, num) => total + num, 0);
+}
+
+const sum0 = ary(sum, 0);
+const sum1 = ary(sum, 1);
+const sum2 = ary(sum, 2);
+const sum3 = ary(sum, 3);
+
+console.log(sum0(1, 2, 3, 4, 5)); // 0 (引数なし)
+console.log(sum1(1, 2, 3, 4, 5)); // 1 (最初の引数のみ)
+console.log(sum2(1, 2, 3, 4, 5)); // 3 (最初の2つの引数のみ)
+console.log(sum3(1, 2, 3, 4, 5)); // 6 (最初の3つの引数のみ)
+```
+
+負の数や `NaN` を渡すと、0として扱われ、すべての引数が無視されます。
+
+```typescript
+import { ary } from 'es-toolkit/compat';
+
+const func = (a, b, c) => [a, b, c];
+
+console.log(ary(func, -1)(1, 2, 3)); // [] (負数は0として扱われる)
+console.log(ary(func, NaN)(1, 2, 3)); // [] (NaNは0として扱われる)
+```
+
+#### パラメータ
+
+- `func` (`Function`): 引数の数を制限する関数です。
+- `n` (`number`, オプション): 許可する最大引数数です。省略した場合、関数の `length` プロパティを使用します。
+
+#### 戻り値
+
+(`Function`): 最大 `n` 個の引数のみを受け取る新しい関数を返します。
diff --git a/docs/ja/compat/reference/function/attempt.md b/docs/ja/compat/reference/function/attempt.md
new file mode 100644
index 000000000..33c3e43af
--- /dev/null
+++ b/docs/ja/compat/reference/function/attempt.md
@@ -0,0 +1,66 @@
+# attempt (Lodash 互換性)
+
+::: warning `es-toolkit` の [`attempt`](../../../reference/util/attempt.md) 関数または try-catch ブロックを使用してください
+
+この `attempt` 関数は、エラーと戻り値を区別せずに返すため、使用時に混乱する可能性があります。
+
+代わりに、より直接的で明確な [`attempt`](../../../reference/util/attempt.md) 関数または try-catch ブロックを使用してください。
+
+:::
+
+関数を実行し、エラーが発生した場合にエラーオブジェクトを返す関数です。
+
+```typescript
+const result = attempt(func, ...args);
+```
+
+## 使用法
+
+### `attempt(func, ...args)`
+
+関数を安全に実行したい場合は `attempt` を使用してください。エラーが発生する可能性のある関数を実行する際に、プログラムがクラッシュするのを防ぎ、エラーを戻り値として処理するのに便利です。
+
+```typescript
+import { attempt } from 'es-toolkit/compat';
+
+// 基本的な使用法 - 成功する場合
+const result = attempt((x, y) => x + y, 2, 3);
+console.log(result); // 5
+
+// エラーが発生する場合
+const errorResult = attempt(() => {
+ throw new Error('何かがうまくいきませんでした');
+});
+console.log(errorResult); // Error: 何かがうまくいきませんでした
+```
+
+try-catch ブロックの使用との違いは次のとおりです。
+
+```typescript
+// attempt を使用
+import { attempt } from 'es-toolkit/compat';
+
+const result = attempt(riskyFunction, arg1, arg2);
+if (result instanceof Error) {
+ console.log('エラーが発生しました:', result.message);
+} else {
+ console.log('結果:', result);
+}
+
+// try-catch を使用 (より直接的)
+try {
+ const result = riskyFunction(arg1, arg2);
+ console.log('結果:', result);
+} catch (error) {
+ console.log('エラーが発生しました:', error.message);
+}
+```
+
+#### パラメータ
+
+- `func` (`Function`): 実行する関数です。
+- `args` (`...any[]`): 関数に渡す引数です。
+
+#### 戻り値
+
+(`ReturnType | Error`): 関数が成功した場合は戻り値を、エラーが発生した場合は Error オブジェクトを返します。
diff --git a/docs/ja/compat/reference/function/before.md b/docs/ja/compat/reference/function/before.md
new file mode 100644
index 000000000..83dd8b5b8
--- /dev/null
+++ b/docs/ja/compat/reference/function/before.md
@@ -0,0 +1,186 @@
+# before (Lodash 互換性)
+
+::: warning `es-toolkit` の [`before`](../../../reference/function/before.md) を使用してください
+
+この `before` 関数は、複雑な型検証と整数変換処理により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [before](../../../reference/function/before.md) を使用してください。
+
+:::
+
+指定された回数まで元の関数を実行し、その後は最後の結果を返す関数を作成します。
+
+```typescript
+const limitedFunction = before(n, func);
+```
+
+## 使用法
+
+### `before(n, func)`
+
+関数を特定の回数まで実行するように制限したい場合は `before` を使用してください。関数呼び出し回数を制限したり、初期設定段階でのみ関数を実行したい場合に便利です。
+
+```typescript
+import { before } from 'es-toolkit/compat';
+
+// 基本的な使い方
+let count = 0;
+const beforeThree = before(3, () => ++count);
+
+console.log(beforeThree()); // 1 (最初の呼び出し)
+console.log(beforeThree()); // 2 (2回目の呼び出し)
+console.log(beforeThree()); // 2 (3回目以降は最後の結果を返す)
+console.log(beforeThree()); // 2 (引き続き最後の結果を返す)
+```
+
+クロージャを使用した代替案：
+
+```typescript
+// before を使用
+const beforeThree = before(3, myFunction);
+
+// クロージャを使用（よりシンプルで高速）
+function createBefore(limit, callback) {
+ let callCount = 0;
+ let lastResult;
+
+ return function (...args) {
+ if (callCount < limit - 1) {
+ lastResult = callback.apply(this, args);
+ callCount++;
+ }
+ return lastResult;
+ };
+}
+
+const beforeThreeAlternative = createBefore(3, myFunction);
+```
+
+初期化関数として活用：
+
+```typescript
+import { before } from 'es-toolkit/compat';
+
+class Database {
+ constructor() {
+ this.isInitialized = false;
+
+ // 初期化は一度だけ実行
+ this.initialize = before(2, () => {
+ console.log('データベースを初期化中...');
+ this.setupConnection();
+ this.isInitialized = true;
+ return '初期化完了';
+ });
+ }
+
+ setupConnection() {
+ // 実際の接続設定ロジック
+ }
+
+ query(sql) {
+ const initResult = this.initialize();
+ console.log(initResult); // 最初の呼び出し: "初期化完了"、以降：同じ結果
+
+ // クエリ実行ロジック
+ return `クエリを実行: ${sql}`;
+ }
+}
+
+const db = new Database();
+db.query('SELECT * FROM users'); // 初期化実行
+db.query('SELECT * FROM products'); // 初期化は実行されない
+```
+
+API 呼び出しの制限：
+
+```typescript
+import { before } from 'es-toolkit/compat';
+
+// API 呼び出しを最大5回まで許可
+const limitedApiCall = before(6, endpoint => {
+ console.log(`API 呼び出し: ${endpoint}`);
+ return fetch(endpoint).then(res => res.json());
+});
+
+// 最初の5回は実際の API 呼び出し
+limitedApiCall('/api/data1'); // 実際の呼び出し
+limitedApiCall('/api/data2'); // 実際の呼び出し
+limitedApiCall('/api/data3'); // 実際の呼び出し
+limitedApiCall('/api/data4'); // 実際の呼び出し
+limitedApiCall('/api/data5'); // 実際の呼び出し
+limitedApiCall('/api/data6'); // 最後の結果を返す（API 呼び出しなし）
+```
+
+イベントリスナーの制限：
+
+```typescript
+import { before } from 'es-toolkit/compat';
+
+// クリックイベントを3回まで処理
+const limitedClickHandler = before(4, event => {
+ console.log('クリック処理:', event.target.id);
+ return `処理完了: ${Date.now()}`;
+});
+
+document.getElementById('button').addEventListener('click', limitedClickHandler);
+// 最初の3回のクリックのみ処理され、その後は最後の結果を返す
+```
+
+パラメータと戻り値の処理：
+
+```typescript
+import { before } from 'es-toolkit/compat';
+
+const limitedCalculator = before(3, (operation, a, b) => {
+ const result = operation === 'add' ? a + b : a - b;
+ console.log(`計算: ${a} ${operation} ${b} = ${result}`);
+ return result;
+});
+
+console.log(limitedCalculator('add', 5, 3)); // "計算: 5 add 3 = 8"、返す: 8
+console.log(limitedCalculator('subtract', 10, 4)); // "計算: 10 subtract 4 = 6"、返す: 6
+console.log(limitedCalculator('multiply', 7, 2)); // 計算しない、返す: 6（最後の結果）
+```
+
+0または1を渡すと関数が実行されません：
+
+```typescript
+import { before } from 'es-toolkit/compat';
+
+const neverCalled = before(0, () => {
+ console.log('この関数は実行されません');
+ return '結果';
+});
+
+const onceOnly = before(1, () => {
+ console.log('この関数も実行されません');
+ return '結果';
+});
+
+console.log(neverCalled()); // undefined
+console.log(onceOnly()); // undefined
+```
+
+リソースクリーンアップの最適化：
+
+```typescript
+import { before } from 'es-toolkit/compat';
+
+// 関数参照が自動的にクリーンアップされてメモリリークを防止
+const limitedProcessor = before(2, data => {
+ // 複雑なデータ処理
+ return processComplexData(data);
+});
+
+// 2回目の呼び出し後、元の関数参照が削除される（ガベージコレクション）
+```
+
+#### パラメータ
+
+- `n` (`number`): 関数を実行する最大回数。n-1回まで実行され、n回目以降は最後の結果を返します。
+- `func` (`Function`): 制限する関数。
+
+#### 戻り値
+
+(`Function`): 指定された回数まで元の関数を実行し、その後は最後の結果を返す新しい関数を返します。
diff --git a/docs/ja/reference/compat/function/bind.md b/docs/ja/compat/reference/function/bind.md
similarity index 100%
rename from docs/ja/reference/compat/function/bind.md
rename to docs/ja/compat/reference/function/bind.md
diff --git a/docs/ja/reference/compat/function/bindKey.md b/docs/ja/compat/reference/function/bindKey.md
similarity index 100%
rename from docs/ja/reference/compat/function/bindKey.md
rename to docs/ja/compat/reference/function/bindKey.md
diff --git a/docs/ja/compat/reference/function/curry.md b/docs/ja/compat/reference/function/curry.md
new file mode 100644
index 000000000..de1c0b327
--- /dev/null
+++ b/docs/ja/compat/reference/function/curry.md
@@ -0,0 +1,222 @@
+# curry (Lodash 互換性)
+
+::: warning `es-toolkit` の `curry` または手動クロージャを使用してください
+この `curry` 関数は、複雑なプレースホルダー処理、引数個数検証、引数合成ロジックにより、動作が遅くなります。
+
+プレースホルダーが必要ない場合は、より高速な `es-toolkit` の [`curry`](../../../reference/function/curry.md) またはシンプルなクロージャを使用してください。
+:::
+
+関数をカリー化して、引数を一つずつ受け取るか、複数個を一度に受け取ることができる関数を作成します。
+
+```typescript
+const curriedFunction = curry(func, arity);
+```
+
+## 使用法
+
+### `curry(func, arity)`
+
+部分適用を容易にするために関数をカリー化したい場合に `curry` を使用します。引数を段階的に提供する場合や、プレースホルダーを使用して特定の位置の引数を後で提供する場合に便利です。
+
+```typescript
+import { curry } from 'es-toolkit/compat';
+
+// 基本的な使用法
+function add(a, b, c) {
+ return a + b + c;
+}
+
+const curriedAdd = curry(add);
+
+// さまざまな方法で呼び出し可能
+console.log(curriedAdd(1)(2)(3)); // 6
+console.log(curriedAdd(1, 2)(3)); // 6
+console.log(curriedAdd(1)(2, 3)); // 6
+console.log(curriedAdd(1, 2, 3)); // 6
+```
+
+メインライブラリの curry との比較:
+
+```typescript
+// compat バージョン (柔軟、ただし遅い)
+import { curry } from 'es-toolkit/compat';
+const curriedCompat = curry(add);
+curriedCompat(1, 2)(3); // サポート
+curriedCompat(1)(curry.placeholder, 3)(2); // プレースホルダーサポート
+
+// メインライブラリバージョン (より速い、ただし一度に一つずつのみ)
+import { curry } from 'es-toolkit';
+const curriedMain = curry(add);
+curriedMain(1)(2)(3); // サポート
+curriedMain(1, 2)(3); // サポートされていない
+```
+
+プレースホルダー機能の使用:
+
+```typescript
+import { curry } from 'es-toolkit/compat';
+
+function greet(greeting, name, punctuation) {
+ return `${greeting}, ${name}${punctuation}`;
+}
+
+const curriedGreet = curry(greet);
+
+// プレースホルダーで中間引数をスキップ
+const greetWithExclamation = curriedGreet(curry.placeholder, curry.placeholder, '!');
+console.log(greetWithExclamation('Hello', 'John')); // "Hello, John!"
+
+const sayHello = curriedGreet('Hello');
+console.log(sayHello(curry.placeholder, '~')('Jane')); // "Hello, Jane~"
+```
+
+関数型プログラミングでの活用:
+
+```typescript
+import { curry } from 'es-toolkit/compat';
+
+// マッピング関数を作成
+const map = curry((fn, array) => array.map(fn));
+const filter = curry((predicate, array) => array.filter(predicate));
+
+const numbers = [1, 2, 3, 4, 5];
+
+// 再利用可能な関数を生成
+const double = x => x * 2;
+const isEven = x => x % 2 === 0;
+
+const mapDouble = map(double);
+const filterEven = filter(isEven);
+
+console.log(mapDouble(numbers)); // [2, 4, 6, 8, 10]
+console.log(filterEven(numbers)); // [2, 4]
+
+// 関数合成
+const processNumbers = nums => mapDouble(filterEven(nums));
+console.log(processNumbers(numbers)); // [4, 8]
+```
+
+API クライアントの構成:
+
+```typescript
+import { curry } from 'es-toolkit/compat';
+
+function apiRequest(method, baseUrl, endpoint, options) {
+ return fetch(`${baseUrl}${endpoint}`, {
+ method,
+ ...options,
+ });
+}
+
+const curriedApiRequest = curry(apiRequest);
+
+// デフォルト設定で特化した関数を生成
+const apiGet = curriedApiRequest('GET', 'https://api.example.com');
+const apiPost = curriedApiRequest('POST', 'https://api.example.com');
+
+// 認証ヘッダーを含む
+const authenticatedPost = apiPost(curry.placeholder, {
+ headers: { Authorization: 'Bearer token123' },
+});
+
+// 使用
+apiGet('/users'); // GET https://api.example.com/users
+authenticatedPost('/users'); // POST with auth headers
+```
+
+数学演算関数:
+
+```typescript
+import { curry } from 'es-toolkit/compat';
+
+const calculate = curry((operation, a, b) => {
+ switch (operation) {
+ case '+':
+ return a + b;
+ case '-':
+ return a - b;
+ case '*':
+ return a * b;
+ case '/':
+ return a / b;
+ default:
+ throw new Error('サポートされていない演算');
+ }
+});
+
+// 特化した演算関数
+const add = calculate('+');
+const subtract = calculate('-');
+const multiply = calculate('*');
+
+console.log(add(5, 3)); // 8
+console.log(subtract(10)(4)); // 6
+console.log(multiply(3, 4)); // 12
+
+// プレースホルダーで第二オペランドを固定
+const addFive = calculate('+', curry.placeholder, 5);
+console.log(addFive(10)); // 15
+```
+
+引数個数の指定:
+
+```typescript
+import { curry } from 'es-toolkit/compat';
+
+function variableArgsFunction(a, b, c, ...rest) {
+ return [a, b, c, rest];
+}
+
+// 引数個数を 3 に制限
+const curriedFixed = curry(variableArgsFunction, 3);
+
+console.log(curriedFixed(1)(2)(3)); // [1, 2, 3, []]
+console.log(curriedFixed(1, 2)(3)); // [1, 2, 3, []]
+
+// 引数個数なしで使用 (デフォルト値: function.length)
+const curriedDefault = curry(variableArgsFunction); // arity = 3
+```
+
+シンプルなカリー化の代替:
+
+```typescript
+// curry を使用
+const curriedAdd = curry((a, b, c) => a + b + c);
+
+// 手動クロージャ (より速い)
+const manualCurry = a => b => c => a + b + c;
+
+// どちらも同じ結果
+console.log(curriedAdd(1)(2)(3)); // 6
+console.log(manualCurry(1)(2)(3)); // 6
+```
+
+コンストラクタ関数もサポート:
+
+```typescript
+import { curry } from 'es-toolkit/compat';
+
+function Person(name, age, city) {
+ this.name = name;
+ this.age = age;
+ this.city = city;
+}
+
+const CurriedPerson = curry(Person);
+const SeoulPerson = CurriedPerson(curry.placeholder, curry.placeholder, 'Seoul');
+
+const person1 = new SeoulPerson('John', 30);
+const person2 = new SeoulPerson('Jane', 25);
+
+console.log(person1.city); // "Seoul"
+console.log(person2.city); // "Seoul"
+```
+
+#### パラメータ
+
+- `func` (`Function`): カリー化する関数。
+- `arity` (`number`, オプション): 関数の引数個数。省略すると `func.length` が使用されます。
+
+#### 戻り値
+
+(`Function & { placeholder: symbol }`): カリー化された関数を返します。`placeholder` プロパティで引数の位置を制御できます。
diff --git a/docs/ja/compat/reference/function/curryRight.md b/docs/ja/compat/reference/function/curryRight.md
new file mode 100644
index 000000000..2d3f255c2
--- /dev/null
+++ b/docs/ja/compat/reference/function/curryRight.md
@@ -0,0 +1,242 @@
+# curryRight (Lodash 互換性)
+
+::: warning `es-toolkit` の [`curryRight`](../../../reference/function/curryRight.md) または手動クロージャを使用してください
+
+この `curryRight` 関数は、複雑なプレースホルダー処理、引数数の検証、引数合成ロジックにより動作が遅くなります。
+
+プレースホルダーが不要な場合は、より高速な `es-toolkit` の [`curryRight`](../../../reference/function/curryRight.md) またはシンプルなクロージャを使用してください。
+
+:::
+
+関数を右からカリー化し、最後の引数から1つずつまたは複数ずつ受け取ることができる関数を作成します。
+
+```typescript
+const curriedFunction = curryRight(func, arity);
+```
+
+## 使用法
+
+### `curryRight(func, arity)`
+
+関数を右からカリー化し、最後の引数から部分適用したい場合は `curryRight` を使用します。通常の `curry` とは異なり、最後の引数から先に処理します。
+
+```typescript
+import { curryRight } from 'es-toolkit/compat';
+
+// 基本的な使用法
+function subtract(a, b, c) {
+ return a - b - c;
+}
+
+const curriedSubtract = curryRight(subtract);
+
+// 右から(最後の引数から)カリー化
+console.log(curriedSubtract(1)(2)(5)); // 5 - 2 - 1 = 2
+console.log(curriedSubtract(1, 2)(5)); // 5 - 2 - 1 = 2
+console.log(curriedSubtract(1)(2, 5)); // 2 - 5 - 1 = -4
+console.log(curriedSubtract(1, 2, 5)); // 1 - 2 - 5 = -6
+```
+
+`curry` と `curryRight` の違い:
+
+```typescript
+import { curry, curryRight } from 'es-toolkit/compat';
+
+function divide(a, b, c) {
+ return a / b / c;
+}
+
+// 通常の curry(左から)
+const leftCurried = curry(divide);
+console.log(leftCurried(12)(3)(2)); // ((12 / 3) / 2) = 2
+
+// curryRight(右から)
+const rightCurried = curryRight(divide);
+console.log(rightCurried(2)(3)(12)); // ((12 / 3) / 2) = 2
+// 最後に渡した 12 が最初の引数(a)になる
+```
+
+メインライブラリとの比較:
+
+```typescript
+// compat バージョン(柔軟だが遅い)
+import { curryRight } from 'es-toolkit/compat';
+const curriedCompat = curryRight(subtract);
+curriedCompat(1, 2)(3); // サポート
+curriedCompat(1)(curryRight.placeholder, 3)(2); // プレースホルダーサポート
+
+// メインライブラリバージョン(より高速だが一度に1つのみ)
+import { curryRight } from 'es-toolkit';
+const curriedMain = curryRight(subtract);
+curriedMain(1)(2)(3); // サポート
+curriedMain(1, 2)(3); // サポートされていない
+```
+
+プレースホルダー機能の使用:
+
+```typescript
+import { curryRight } from 'es-toolkit/compat';
+
+function formatMessage(name, action, time) {
+ return `${name}さんが${action}を${time}に行いました`;
+}
+
+const curriedFormat = curryRight(formatMessage);
+
+// プレースホルダーで特定の位置をスキップ
+const todayAction = curriedFormat('今日');
+const todayLoginAction = todayAction(curryRight.placeholder, 'ログイン');
+
+console.log(todayLoginAction('田中'));
+// "田中さんがログインを今日に行いました"
+
+// 時間を先に固定
+const morningFormat = curriedFormat('朝9時');
+console.log(morningFormat('コメント作成', '佐藤'));
+// "佐藤さんがコメント作成を朝9時に行いました"
+```
+
+配列処理での活用:
+
+```typescript
+import { curryRight } from 'es-toolkit/compat';
+
+// 配列の末尾から特定の数だけ取得
+function takeFromEnd(array, count, separator = ', ') {
+ return array.slice(-count).join(separator);
+}
+
+const curriedTake = curryRight(takeFromEnd);
+
+// カンマ区切りの関数を作成
+const takeWithComma = curriedTake(', ');
+
+// 最後の3つを取得
+const takeLast3 = takeWithComma(3);
+
+const fruits = ['りんご', 'バナナ', 'オレンジ', 'ぶどう', 'キウイ'];
+console.log(takeLast3(fruits)); // "オレンジ, ぶどう, キウイ"
+
+// 異なる区切り文字を使用
+const takeWithDash = curriedTake(' - ');
+console.log(takeWithDash(2, fruits)); // "ぶどう - キウイ"
+```
+
+関数合成での活用:
+
+```typescript
+import { curryRight } from 'es-toolkit/compat';
+
+// ログ出力関数
+function logWithPrefix(message, level, timestamp) {
+ return `[${timestamp}] ${level}: ${message}`;
+}
+
+const curriedLog = curryRight(logWithPrefix);
+
+// 現在時刻で固定
+const currentTimeLog = curriedLog(new Date().toISOString());
+
+// レベル別のロガーを作成
+const errorLog = currentTimeLog('ERROR');
+const infoLog = currentTimeLog('INFO');
+const debugLog = currentTimeLog('DEBUG');
+
+// 使用
+console.log(errorLog('データベース接続失敗'));
+console.log(infoLog('サーバー起動'));
+console.log(debugLog('ユーザーリクエスト処理中'));
+```
+
+関数型プログラミングパイプライン:
+
+```typescript
+import { curryRight } from 'es-toolkit/compat';
+
+// データ変換関数
+const mapWith = curryRight((array, fn) => array.map(fn));
+const filterWith = curryRight((array, predicate) => array.filter(predicate));
+const reduceWith = curryRight((array, reducer, initial) => array.reduce(reducer, initial));
+
+const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+// 変換関数を定義
+const double = x => x * 2;
+const isEven = x => x % 2 === 0;
+const sum = (acc, val) => acc + val;
+
+// パイプラインを構成(右から優先)
+const processNumbers = nums => {
+ return reduceWith(filterWith(mapWith(nums, double), isEven), sum, 0);
+};
+
+console.log(processNumbers(numbers)); // すべての数を2倍にして偶数のみフィルタリングして合計
+```
+
+API リクエストビルダー:
+
+```typescript
+import { curryRight } from 'es-toolkit/compat';
+
+function makeRequest(url, method, headers, body) {
+ return fetch(url, { method, headers, body });
+}
+
+const curriedRequest = curryRight(makeRequest);
+
+// body から設定
+const withJsonBody = curriedRequest(JSON.stringify({ data: 'test' }));
+
+// headers を追加
+const withHeaders = withJsonBody({
+ 'Content-Type': 'application/json',
+ Authorization: 'Bearer token123',
+});
+
+// POST メソッドを設定
+const postRequest = withHeaders('POST');
+
+// 最終的な使用
+postRequest('/api/data')
+ .then(response => response.json())
+ .then(data => console.log(data));
+```
+
+手動カリー化の代替:
+
+```typescript
+// curryRight を使用
+const curriedSubtract = curryRight((a, b, c) => a - b - c);
+
+// 手動クロージャ(より高速、右から)
+const manualCurryRight = c => b => a => a - b - c;
+
+// 両方とも同じ結果
+console.log(curriedSubtract(1)(2)(5)); // 2
+console.log(manualCurryRight(1)(2)(5)); // 2
+```
+
+引数数の指定:
+
+```typescript
+import { curryRight } from 'es-toolkit/compat';
+
+function variableArgsFunction(a, b, c, ...rest) {
+ return { a, b, c, rest };
+}
+
+// 引数数を3に制限(rest は無視)
+const curriedFixed = curryRight(variableArgsFunction, 3);
+
+// 右から c, b, a の順序で受け取る
+console.log(curriedFixed(3)(2)(1)); // { a: 1, b: 2, c: 3, rest: [] }
+```
+
+#### パラメータ
+
+- `func` (`Function`): 右からカリー化する関数です。
+- `arity` (`number`, オプション): 関数の引数数です。省略すると `func.length` が使用されます。
+
+#### 戻り値
+
+(`Function & { placeholder: symbol }`): 右からカリー化された関数を返します。`placeholder` プロパティで引数の位置を制御できます。
diff --git a/docs/ja/compat/reference/function/debounce.md b/docs/ja/compat/reference/function/debounce.md
new file mode 100644
index 000000000..96f5f68c5
--- /dev/null
+++ b/docs/ja/compat/reference/function/debounce.md
@@ -0,0 +1,264 @@
+# debounce (Lodash 互換)
+
+::: warning `es-toolkit` の [`debounce`](../../../reference/function/debounce.md) を使用してください
+
+この `debounce` 関数は、複雑な `maxWait` 処理と Lodash 互換のオプション構造によるオーバーヘッドがあります。
+
+代わりに、より高速で現代的な `es-toolkit` の [`debounce`](../../../reference/function/debounce.md) を使用してください。
+
+:::
+
+関数呼び出しを遅延させ、最後の呼び出しから指定された時間が経過した後にのみ実行されるデバウンス関数を作成します。
+
+```typescript
+const debouncedFunction = debounce(func, wait, options);
+```
+
+## 使用法
+
+### `debounce(func, wait, options)`
+
+関数呼び出しを遅延させたい場合は `debounce` を使用してください。検索入力、スクロールイベント、ボタンクリックなどでの過度な呼び出しを防ぐのに便利です。
+
+```typescript
+import { debounce } from 'es-toolkit/compat';
+
+// 基本的な使用法
+const searchFunction = debounce(query => {
+ console.log('検索:', query);
+}, 300);
+
+// 300ms 以内に再度呼び出されなければ実行される
+searchFunction('React'); // 実行されない
+searchFunction('Vue'); // 実行されない
+searchFunction('Angular'); // 300ms 後に "検索: Angular" と出力
+```
+
+メインライブラリの debounce との比較:
+
+```typescript
+// compat バージョン(Lodash 互換、maxWait などの追加オプション)
+import { debounce } from 'es-toolkit/compat';
+const debouncedCompat = debounce(func, 300, {
+ leading: true,
+ trailing: false,
+ maxWait: 1000
+});
+
+// メインライブラリバージョン(より高速でシンプル)
+import { debounce } from 'es-toolkit';
+const debouncedMain = debounce(func, 300, {
+ edges: ['leading'] // leading/trailing の代わりに edges を使用
+});
+```
+
+leading と trailing オプション:
+
+```typescript
+import { debounce } from 'es-toolkit/compat';
+
+const func = () => console.log('実行されました');
+
+// leading: true - 最初の呼び出し時に即座に実行
+const leadingDebounce = debounce(func, 1000, { leading: true });
+leadingDebounce(); // 即座に "実行されました" と出力
+leadingDebounce(); // 1秒待機
+// 1秒後に追加の実行なし
+
+// trailing: true(デフォルト) - 最後の呼び出し後の遅延時間後に実行
+const trailingDebounce = debounce(func, 1000, { trailing: true });
+trailingDebounce(); // 1秒待機
+trailingDebounce(); // 1秒待機(前のタイマーをキャンセル)
+// 1秒後に "実行されました" と出力
+
+// 両方とも true - 開始時と終了時に実行
+const bothDebounce = debounce(func, 1000, {
+ leading: true,
+ trailing: true,
+});
+bothDebounce(); // 即座に "実行されました" と出力
+bothDebounce(); // 1秒待機
+// 1秒後に "実行されました" と出力(trailing)
+```
+
+maxWait オプション:
+
+```typescript
+import { debounce } from 'es-toolkit/compat';
+
+// 最大2秒ごとには必ず実行
+const debouncedWithMaxWait = debounce(() => console.log('保存されました'), 500, { maxWait: 2000 });
+
+// 高速に連続呼び出しされても、最大2秒ごとに実行される
+setInterval(() => {
+ debouncedWithMaxWait();
+}, 100); // 100ms ごとに呼び出されるが、2秒ごとに "保存されました" と出力
+```
+
+実際の検索例:
+
+```typescript
+import { debounce } from 'es-toolkit/compat';
+
+class SearchComponent {
+ constructor() {
+ this.searchInput = document.getElementById('search');
+
+ // ユーザー入力を 300ms デバウンス
+ this.debouncedSearch = debounce(this.performSearch.bind(this), 300, {
+ leading: false, // 入力開始時に即座に検索しない
+ trailing: true, // 入力停止後に検索
+ });
+
+ this.searchInput.addEventListener('input', e => {
+ this.debouncedSearch(e.target.value);
+ });
+ }
+
+ performSearch(query) {
+ if (query.length < 2) return;
+
+ console.log('API 呼び出し:', query);
+ // fetch(`/api/search?q=${query}`)...
+ }
+}
+```
+
+スクロールイベントの最適化:
+
+```typescript
+import { debounce } from 'es-toolkit/compat';
+
+// スクロールイベントを 100ms デバウンスするが、最大 500ms ごとには実行
+const optimizedScrollHandler = debounce(
+ () => {
+ const scrollTop = window.pageYOffset;
+ console.log('スクロール位置:', scrollTop);
+
+ // ヘッダーの非表示/表示ロジック
+ if (scrollTop > 100) {
+ document.header.classList.add('hidden');
+ } else {
+ document.header.classList.remove('hidden');
+ }
+ },
+ 100,
+ { maxWait: 500 }
+);
+
+window.addEventListener('scroll', optimizedScrollHandler);
+```
+
+API 呼び出しの制限:
+
+```typescript
+import { debounce } from 'es-toolkit/compat';
+
+class AutoSave {
+ constructor() {
+ // 500ms デバウンス、最大5秒ごとには保存
+ this.debouncedSave = debounce(this.saveToServer.bind(this), 500, { maxWait: 5000 });
+ }
+
+ onTextChange(content) {
+ this.pendingContent = content;
+ this.debouncedSave();
+ }
+
+ saveToServer() {
+ if (!this.pendingContent) return;
+
+ console.log('サーバーに保存:', this.pendingContent);
+ // fetch('/api/save', { ... })
+
+ this.pendingContent = null;
+ }
+}
+```
+
+cancel と flush メソッド:
+
+```typescript
+import { debounce } from 'es-toolkit/compat';
+
+const debouncedFunc = debounce(() => {
+ console.log('実行されました');
+}, 1000);
+
+debouncedFunc(); // 1秒待機中
+
+// 待機中の実行をキャンセル
+debouncedFunc.cancel();
+
+// または即座に実行
+debouncedFunc(); // 1秒待機開始
+debouncedFunc.flush(); // 即座に "実行されました" と出力し、タイマーをキャンセル
+```
+
+ボタンクリックの重複防止:
+
+```typescript
+import { debounce } from 'es-toolkit/compat';
+
+const handleSubmit = debounce(
+ async formData => {
+ console.log('フォーム送信中...');
+ try {
+ const response = await fetch('/api/submit', {
+ method: 'POST',
+ body: formData,
+ });
+ console.log('送信完了');
+ } catch (error) {
+ console.error('送信失敗:', error);
+ }
+ },
+ 1000,
+ { leading: true, trailing: false } // 最初のクリックのみ処理
+);
+
+document.getElementById('submit-btn').addEventListener('click', e => {
+ const formData = new FormData(e.target.form);
+ handleSubmit(formData);
+});
+```
+
+リサイズイベント処理:
+
+```typescript
+import { debounce } from 'es-toolkit/compat';
+
+const handleResize = debounce(
+ () => {
+ const width = window.innerWidth;
+ const height = window.innerHeight;
+
+ console.log('ウィンドウサイズ変更:', { width, height });
+
+ // レイアウトの再計算
+ recalculateLayout();
+ },
+ 250,
+ { leading: false, trailing: true }
+);
+
+window.addEventListener('resize', handleResize);
+
+// ページ終了時にクリーンアップ
+window.addEventListener('beforeunload', () => {
+ handleResize.cancel();
+});
+```
+
+#### パラメータ
+
+- `func` (`Function`): デバウンスする関数です。
+- `wait` (`number`, オプション): 遅延するミリ秒数です。デフォルトは `0` です。
+- `options` (`DebounceSettings`, オプション): オプションオブジェクトです。
+ - `leading` (`boolean`): `true` の場合、遅延開始時点で関数を実行します。デフォルトは `false` です。
+ - `trailing` (`boolean`): `true` の場合、遅延終了時点で関数を実行します。デフォルトは `true` です。
+ - `maxWait` (`number`): 関数実行が遅延できる最大時間です。デフォルトは `Infinity` です。
+
+#### 戻り値
+
+(`DebouncedFunc`): デバウンスされた関数を返します。`cancel()` と `flush()` メソッドが含まれています。
diff --git a/docs/ja/reference/compat/function/defer.md b/docs/ja/compat/reference/function/defer.md
similarity index 100%
rename from docs/ja/reference/compat/function/defer.md
rename to docs/ja/compat/reference/function/defer.md
diff --git a/docs/ja/reference/compat/function/delay.md b/docs/ja/compat/reference/function/delay.md
similarity index 100%
rename from docs/ja/reference/compat/function/delay.md
rename to docs/ja/compat/reference/function/delay.md
diff --git a/docs/ja/reference/compat/function/flip.md b/docs/ja/compat/reference/function/flip.md
similarity index 100%
rename from docs/ja/reference/compat/function/flip.md
rename to docs/ja/compat/reference/function/flip.md
diff --git a/docs/ja/compat/reference/function/flow.md b/docs/ja/compat/reference/function/flow.md
new file mode 100644
index 000000000..30e77ebe5
--- /dev/null
+++ b/docs/ja/compat/reference/function/flow.md
@@ -0,0 +1,87 @@
+# flow (Lodash 互換性)
+
+::: warning `es-toolkit` の `flow` を使用してください
+この `flow` 関数は Lodash 互換性のために配列のフラット化処理が追加されており、複雑です。
+
+代わりに、より高速で現代的な `es-toolkit` の [flow](../../../reference/function/flow.md) を使用してください。
+:::
+
+与えられた関数を左から右へ順次実行する新しい関数を作成します。
+
+```typescript
+const combinedFunc = flow(...functions);
+```
+
+## 使用法
+
+### `flow(...functions)`
+
+複数の関数を左から右へ順次実行する1つの合成関数を作成したい場合は `flow` を使用してください。データ変換パイプラインを作成する際に便利です。
+
+```typescript
+import { flow } from 'es-toolkit/compat';
+
+// 基本的な使い方
+function add(x, y) {
+ return x + y;
+}
+
+function square(n) {
+ return n * n;
+}
+
+function double(n) {
+ return n * 2;
+}
+
+// 左から右へ実行: double(square(add(x, y)))
+const calculate = flow(add, square, double);
+console.log(calculate(1, 2)); // double(square(add(1, 2))) = double(square(3)) = double(9) = 18
+
+// 配列で関数を渡す
+const calculate2 = flow([add, square], double);
+console.log(calculate2(2, 3)); // 50
+
+// 現代的な代替案（推奨）
+const modernCalculate = (x, y) => double(square(add(x, y)));
+console.log(modernCalculate(1, 2)); // 18
+
+// パイプ演算子を使用（将来の JavaScript）
+const pipeCalculate = (x, y) => add(x, y) |> square |> double;
+
+// またはチェーンパターン
+class Calculator {
+ constructor(value) {
+ this.value = value;
+ }
+
+ add(n) {
+ this.value += n;
+ return this;
+ }
+
+ square() {
+ this.value *= this.value;
+ return this;
+ }
+
+ double() {
+ this.value *= 2;
+ return this;
+ }
+
+ valueOf() {
+ return this.value;
+ }
+}
+
+const chainedResult = new Calculator(3).square().double().valueOf(); // 18
+```
+
+#### パラメータ
+
+- `...functions` (`Array`): 左から右へ実行する関数です。配列で渡すこともできます。
+
+#### 戻り値
+
+(`Function`): すべての関数を左から右へ順次実行する新しい合成関数を返します。
diff --git a/docs/ja/compat/reference/function/flowRight.md b/docs/ja/compat/reference/function/flowRight.md
new file mode 100644
index 000000000..de0af5fc2
--- /dev/null
+++ b/docs/ja/compat/reference/function/flowRight.md
@@ -0,0 +1,65 @@
+# flowRight (Lodash 互換性)
+
+::: warning `es-toolkit` の `flowRight` を使用してください
+この `flowRight` 関数は Lodash 互換性のために配列のフラット化処理が追加されており、複雑です。
+
+代わりに、より高速で現代的な `es-toolkit` の [flowRight](../../../reference/function/flowRight.md) を使用してください。
+:::
+
+与えられた関数を右から左へ順次実行する新しい関数を作成します。
+
+```typescript
+const combinedFunc = flowRight(...functions);
+```
+
+## 使用法
+
+### `flowRight(...functions)`
+
+複数の関数を右から左へ順次実行する1つの合成関数を作成したい場合は `flowRight` を使用してください。データ変換パイプラインを作成する際に便利です。
+
+```typescript
+import { flowRight } from 'es-toolkit/compat';
+
+// 基本的な使い方
+function add(x, y) {
+ return x + y;
+}
+
+function square(n) {
+ return n * n;
+}
+
+function double(n) {
+ return n * 2;
+}
+
+// 右から左へ実行: double(square(add(x, y)))
+const calculate = flowRight(double, square, add);
+console.log(calculate(1, 2)); // double(square(add(1, 2))) = double(square(3)) = double(9) = 18
+
+// 配列で関数を渡す
+const calculate2 = flowRight([double, square], add);
+console.log(calculate2(2, 3)); // 50
+
+// 現代的な代替案（推奨）
+const modernCalculate = (x, y) => double(square(add(x, y)));
+console.log(modernCalculate(1, 2)); // 18
+
+// または関数チェーンを使用
+const chainedCalculate = (x, y) => [x, y]
+ .reduce((acc, val, idx) => idx === 0 ? val : acc + val)
+ .valueOf()
+ |> (n => n * n)
+ |> (n => n * 2);
+```
+
+一般的に `flow` と反対の順序で動作します。合成関数と似た方式で動作するため直感的です。
+
+#### パラメータ
+
+- `...functions` (`Array`): 右から左へ実行する関数です。配列で渡すこともできます。
+
+#### 戻り値
+
+(`Function`): すべての関数を右から左へ順次実行する新しい合成関数を返します。
diff --git a/docs/ja/compat/reference/function/identity.md b/docs/ja/compat/reference/function/identity.md
new file mode 100644
index 000000000..2f3478d4e
--- /dev/null
+++ b/docs/ja/compat/reference/function/identity.md
@@ -0,0 +1,62 @@
+# identity (Lodash 互換性)
+
+::: warning `es-toolkit` の `identity` を使用してください
+この `identity` 関数は `es-toolkit` のメインライブラリにも同じ機能の関数があります。単に入力値をそのまま返す機能です。
+
+代わりに、より高速で現代的な `es-toolkit` の [identity](../../../reference/function/identity.md) を使用してください。
+:::
+
+受け取った値をそのまま返します。
+
+```typescript
+const result = identity(value);
+```
+
+## 使用法
+
+### `identity(value)`
+
+受け取った値をそのまま返したい場合は `identity` を使用してください。主にデフォルト値やプレースホルダー関数として使用され、関数型プログラミングでよく使われます。
+
+```typescript
+import { identity } from 'es-toolkit/compat';
+
+// 基本的な使い方
+console.log(identity(5)); // 5
+console.log(identity('hello')); // 'hello'
+console.log(identity({ key: 'value' })); // { key: 'value' }
+
+// 配列の map と一緒に使用（値のコピー）
+const numbers = [1, 2, 3, 4, 5];
+const copied = numbers.map(identity);
+console.log(copied); // [1, 2, 3, 4, 5]
+
+// フィルタリングでデフォルト値として使用
+const values = [1, 0, '', 'hello', null, undefined, false, true];
+const filtered = values.filter(identity); // 真と評価される値だけを残す
+console.log(filtered); // [1, 'hello', true]
+
+// デフォルトの変換関数として使用
+function processData(data, transform = identity) {
+ return transform(data);
+}
+
+console.log(processData('hello')); // 'hello'
+console.log(processData('hello', x => x.toUpperCase())); // 'HELLO'
+```
+
+ほとんどの場合、より簡単なアロー関数 `x => x` で置き換えることができます:
+
+```typescript
+// identity の代わりにアロー関数を使用（推奨）
+const copied = numbers.map(x => x);
+const filtered = values.filter(x => x);
+```
+
+#### パラメータ
+
+- `value` (`T`): 返す値です。
+
+#### 戻り値
+
+(`T`): 受け取った値をそのまま返します。
diff --git a/docs/ja/compat/reference/function/memoize.md b/docs/ja/compat/reference/function/memoize.md
new file mode 100644
index 000000000..8b47af5ae
--- /dev/null
+++ b/docs/ja/compat/reference/function/memoize.md
@@ -0,0 +1,66 @@
+# memoize (Lodash 互換性)
+
+::: warning `es-toolkit` の `memoize` を使用してください
+この `memoize` 関数は `resolver` 関数の `null` チェック、`MapCache` インターフェースの複雑な型処理、そして Lodash 互換性のための追加のオーバーヘッドにより遅く動作します。
+
+代わりに、より高速で現代的な `es-toolkit` の [memoize](../../../reference/function/memoize.md) を使用してください。
+:::
+
+関数の結果をキャッシュして、同じ引数で呼び出されたときにパフォーマンスを向上させます。
+
+```typescript
+const memoizedFunc = memoize(func, resolver);
+```
+
+## 使用法
+
+### `memoize(func, resolver)`
+
+関数の結果をメモ化して、同じ引数で呼び出されたときに以前の結果を再利用したい場合は `memoize` を使用してください。コストのかかる計算や API 呼び出しに便利です。
+
+```typescript
+import { memoize } from 'es-toolkit/compat';
+
+// 基本的な使い方
+function expensiveCalculation(n) {
+ console.log('計算中...', n);
+ return n * n;
+}
+
+const memoizedCalc = memoize(expensiveCalculation);
+
+console.log(memoizedCalc(5)); // '計算中... 5', 25
+console.log(memoizedCalc(5)); // 25 (キャッシュされた結果、計算しない)
+console.log(memoizedCalc(10)); // '計算中... 10', 100
+
+// カスタムリゾルバーを使用
+function fetchUserData(userId, includeProfile) {
+ console.log('ユーザーデータを取得中...', userId, includeProfile);
+ return { id: userId, profile: includeProfile ? 'プロフィールデータ' : null };
+}
+
+// すべての引数を考慮したキャッシュキーを生成
+const memoizedFetch = memoize(fetchUserData, (userId, includeProfile) => {
+ return `${userId}_${includeProfile}`;
+});
+
+memoizedFetch(1, true); // 'ユーザーデータを取得中... 1 true'
+memoizedFetch(1, true); // キャッシュされた結果を使用
+memoizedFetch(1, false); // 'ユーザーデータを取得中... 1 false' (異なるキャッシュキー)
+
+// キャッシュへのアクセスと変更
+console.log(memoizedCalc.cache.get(5)); // 25
+memoizedCalc.cache.set(7, 49); // 手動でキャッシュを設定
+console.log(memoizedCalc(7)); // 49 (計算せずにキャッシュされた値を使用)
+```
+
+ほとんどの場合、基本的なハッシュマップを使用しますが、必要に応じてカスタムキャッシュ実装を使用することもできます。
+
+#### パラメータ
+
+- `func` (`Function`): メモ化する関数です。
+- `resolver` (`Function`, オプション): キャッシュキーを決定する関数です。提供されない場合は最初の引数をキーとして使用します。
+
+#### 戻り値
+
+(`Function & { cache: MapCache }`): メモ化された関数を返します。返された関数には `cache` プロパティがあり、キャッシュに直接アクセスできます。
diff --git a/docs/ja/reference/compat/function/negate.md b/docs/ja/compat/reference/function/negate.md
similarity index 100%
rename from docs/ja/reference/compat/function/negate.md
rename to docs/ja/compat/reference/function/negate.md
diff --git a/docs/ja/compat/reference/function/noop.md b/docs/ja/compat/reference/function/noop.md
new file mode 100644
index 000000000..dbd88859f
--- /dev/null
+++ b/docs/ja/compat/reference/function/noop.md
@@ -0,0 +1,60 @@
+# noop (Lodash 互換性)
+
+::: warning `es-toolkit` の `noop` を使用してください
+
+`es-toolkit` にも同じ動作をする [noop](../../../reference/function/noop.md) 関数があります。
+
+:::
+
+何もしない空の関数です。
+
+```typescript
+noop();
+```
+
+## 使用法
+
+### `noop(...args)`
+
+何もしないプレースホルダー関数が必要な場合は `noop` を使用してください。デフォルト値やコールバック関数としてよく使われます。
+
+```typescript
+import { noop } from 'es-toolkit/compat';
+
+// 基本的な使用法
+noop(); // 何もしない
+noop(1, 2, 3); // 引数を受け取るが何もしない
+
+// デフォルトのコールバックとして使用
+function processData(data, callback = noop) {
+ // データ処理
+ console.log('データ処理中...', data);
+
+ // コールバック呼び出し(提供されていなければ noop)
+ callback(data);
+}
+
+processData('テスト'); // コールバックが提供されていなくてもエラーなく動作
+
+// 現代的な代替案(推奨)
+function modernProcessData(data, callback = () => {}) {
+ console.log('データ処理中...', data);
+ callback(data);
+}
+
+// またはオプショナルなコールバックを使用
+function processDataOptional(data, callback) {
+ console.log('データ処理中...', data);
+ callback?.(data); // コールバックが提供された場合のみ呼び出し
+}
+```
+
+デフォルト値やプレースホルダーが必要な状況で便利ですが、現代の JavaScript ではオプショナルチェイニング(`?.`)やデフォルトパラメータを使用する方が一般的です。
+
+#### パラメータ
+
+- `...args` (`any[]`): どんな引数でも受け取れますが、すべて無視されます。
+
+#### 戻り値
+
+(`void`): 何も返しません。
diff --git a/docs/ja/reference/compat/function/nthArg.md b/docs/ja/compat/reference/function/nthArg.md
similarity index 100%
rename from docs/ja/reference/compat/function/nthArg.md
rename to docs/ja/compat/reference/function/nthArg.md
diff --git a/docs/ja/compat/reference/function/once.md b/docs/ja/compat/reference/function/once.md
new file mode 100644
index 000000000..67c0890c2
--- /dev/null
+++ b/docs/ja/compat/reference/function/once.md
@@ -0,0 +1,56 @@
+# once (Lodash 互換性)
+
+::: warning `es-toolkit` の `once` を使用してください
+
+この `once` 関数は、`es-toolkit` のメインライブラリ [once](../../../reference/function/once.md) 関数と同じ機能を持っています。
+
+:::
+
+関数が1回だけ呼び出されるように制限します。
+
+```typescript
+const limitedFunc = once(func);
+```
+
+## 使用法
+
+### `once(func)`
+
+関数を1回だけ呼び出すように制限したい場合は `once` を使用してください。最初の呼び出し後は結果がキャッシュされ、同じ値を返します。
+
+```typescript
+import { once } from 'es-toolkit/compat';
+
+// 基本的な使用法
+let count = 0;
+const increment = once(() => {
+ count++;
+ console.log('カウンター増加:', count);
+ return count;
+});
+
+increment(); // 'カウンター増加: 1' を出力、1 を返す
+increment(); // 何も出力しない、1 を返す
+increment(); // 何も出力しない、1 を返す
+
+// 実用的な例 - 初期化関数
+const initialize = once(() => {
+ console.log('アプリケーション初期化中...');
+ // コストのかかる初期化操作
+ return '初期化完了';
+});
+
+// 複数回呼び出しても、初期化は1回だけ実行される
+initialize(); // 'アプリケーション初期化中...' を出力
+initialize(); // 何も出力しない
+```
+
+コストのかかる初期化操作やセットアップ関数を作成する際に便利です。例えば、データベース接続、APIトークンの初期化などに使用できます。
+
+#### パラメータ
+
+- `func` (`Function`): 1回だけ呼び出すように制限する関数です。
+
+#### 戻り値
+
+(`Function`): 1回だけ呼び出される新しい関数を返します。2回目の呼び出し以降は、最初の呼び出しの結果を返します。
diff --git a/docs/ja/reference/compat/function/overArgs.md b/docs/ja/compat/reference/function/overArgs.md
similarity index 100%
rename from docs/ja/reference/compat/function/overArgs.md
rename to docs/ja/compat/reference/function/overArgs.md
diff --git a/docs/ja/compat/reference/function/partial.md b/docs/ja/compat/reference/function/partial.md
new file mode 100644
index 000000000..d72eb3fa6
--- /dev/null
+++ b/docs/ja/compat/reference/function/partial.md
@@ -0,0 +1,59 @@
+# partial (Lodash 互換性)
+
+::: warning `es-toolkit` の `partial` を使用してください
+
+この `partial` 関数は多くのオーバーロードとユニオン型処理により非効率的です。また、ほとんどの場合、より簡単なアロー関数で代替できます。
+
+代わりに、より高速で現代的な `es-toolkit` の [`partial`](../../../reference/function/partial.md) を使用してください。
+
+:::
+
+関数の引数を事前に埋めて部分適用された関数を作成します。
+
+```typescript
+const partialFunc = partial(func, ...args);
+```
+
+## 使用法
+
+### `partial(func, ...args)`
+
+関数の引数を事前に埋めて部分適用された関数を作成したい場合は `partial` を使用してください。主に引数の順序が重要な関数で最初の引数を固定する際に便利です。
+
+```typescript
+import { partial } from 'es-toolkit/compat';
+
+// 基本的な使用法
+function greet(greeting, name, punctuation) {
+ return `${greeting} ${name}${punctuation}`;
+}
+
+// 最初の引数を事前設定
+const sayHello = partial(greet, 'Hello');
+sayHello('Alice', '!'); // 'Hello Alice!'
+
+// 複数の引数を事前設定
+const greetAlice = partial(greet, 'Hello', 'Alice');
+greetAlice('!'); // 'Hello Alice!'
+
+// placeholder を使用して引数の順序を調整
+const greetWithExclamation = partial(greet, partial.placeholder, 'Alice', '!');
+greetWithExclamation('Hi'); // 'Hi Alice!'
+```
+
+ほとんどの場合、アロー関数で代替できます:
+
+```typescript
+// partial の代わりにアロー関数を使用(推奨)
+const sayHello = (name, punctuation) => greet('Hello', name, punctuation);
+const greetAlice = punctuation => greet('Hello', 'Alice', punctuation);
+```
+
+#### パラメータ
+
+- `func` (`Function`): 部分適用する関数です。
+- `...args` (`any[]`): 事前に埋める引数です。`partial.placeholder` を使用して引数の順序を調整できます。
+
+#### 戻り値
+
+(`Function`): 引数が事前に埋められた新しい関数を返します。
diff --git a/docs/ja/compat/reference/function/partialRight.md b/docs/ja/compat/reference/function/partialRight.md
new file mode 100644
index 000000000..471ba733c
--- /dev/null
+++ b/docs/ja/compat/reference/function/partialRight.md
@@ -0,0 +1,59 @@
+# partialRight (Lodash 互換性)
+
+::: warning `es-toolkit` の `partialRight` を使用してください
+
+この `partialRight` 関数は多くのオーバーロードとユニオン型処理により非効率的です。また、ほとんどの場合、より簡単なアロー関数で代替できます。
+
+代わりに、より高速で現代的な `es-toolkit` の [`partialRight`](../../../reference/function/partialRight.md) を使用してください。
+
+:::
+
+関数の右側から引数を事前に埋めて部分適用された関数を作成します。
+
+```typescript
+const partialFunc = partialRight(func, ...args);
+```
+
+## 使用法
+
+### `partialRight(func, ...args)`
+
+関数の右側から引数を事前に埋めて部分適用された関数を作成したい場合は `partialRight` を使用してください。主に引数の順序が重要な関数で最後の引数を固定する際に便利です。
+
+```typescript
+import { partialRight } from 'es-toolkit/compat';
+
+// 基本的な使用法
+function greet(greeting, name, punctuation) {
+ return `${greeting} ${name}${punctuation}`;
+}
+
+// 最後の引数を事前設定
+const greetWithExclamation = partialRight(greet, '!');
+greetWithExclamation('Hello', 'Alice'); // 'Hello Alice!'
+
+// 複数の引数を事前設定
+const sayHiToAlice = partialRight(greet, 'Alice', '!');
+sayHiToAlice('Hi'); // 'Hi Alice!'
+
+// placeholder を使用して引数の順序を調整
+const greetAliceWithCustom = partialRight(greet, 'Alice', partialRight.placeholder);
+greetAliceWithCustom('Hello', '?'); // 'Hello Alice?'
+```
+
+ほとんどの場合、アロー関数で代替できます:
+
+```typescript
+// partialRight の代わりにアロー関数を使用(推奨)
+const greetWithExclamation = (greeting, name) => greet(greeting, name, '!');
+const sayHiToAlice = greeting => greet(greeting, 'Alice', '!');
+```
+
+#### パラメータ
+
+- `func` (`Function`): 部分適用する関数です。
+- `...args` (`any[]`): 事前に埋める引数です。`partialRight.placeholder` を使用して引数の順序を調整できます。
+
+#### 戻り値
+
+(`Function`): 右側から引数が事前に埋められた新しい関数を返します。
diff --git a/docs/ja/reference/compat/function/rearg.md b/docs/ja/compat/reference/function/rearg.md
similarity index 100%
rename from docs/ja/reference/compat/function/rearg.md
rename to docs/ja/compat/reference/function/rearg.md
diff --git a/docs/ja/compat/reference/function/rest.md b/docs/ja/compat/reference/function/rest.md
new file mode 100644
index 000000000..be8f3d2d8
--- /dev/null
+++ b/docs/ja/compat/reference/function/rest.md
@@ -0,0 +1,54 @@
+# rest (Lodash 互換性)
+
+::: warning `es-toolkit` の `rest` を使用してください
+
+この `rest` 関数は、デフォルト値処理やインデックス検証などの追加ロジックにより、パフォーマンスが低下する可能性があります。
+
+代わりに、より高速で現代的な `es-toolkit` の [rest](../../../reference/function/rest.md) を使用してください。
+
+:::
+
+指定されたインデックスから残りの引数を配列にグループ化する関数を作成します。
+
+```typescript
+const restFunc = rest(func, start);
+```
+
+## 使用法
+
+### `rest(func, start)`
+
+指定されたインデックスから残りの引数を配列にグループ化して関数の引数を変換したい場合は、`rest` を使用してください。可変長引数を受け取る関数を作成するのに便利です。
+
+```typescript
+import { rest } from 'es-toolkit/compat';
+
+// 基本的な使用法 - 最後の引数を配列にグループ化
+function logMessage(level, message, ...details) {
+ console.log(`[${level}] ${message}`, details);
+}
+
+const restLogger = rest(logMessage, 2);
+restLogger('ERROR', 'エラーが発生しました', '詳細情報 1', '詳細情報 2');
+// 内部的に logMessage('ERROR', 'エラーが発生しました', [['詳細情報 1', '詳細情報 2']]) として呼び出されます
+
+// 別のインデックスの例
+function process(action, target, ...args) {
+ return { action, target, args };
+}
+
+const restProcess = rest(process, 1);
+restProcess('update', 'user', 'name', 'John', 'age', 25);
+// { action: 'update', target: ['user', 'name', 'John', 'age', 25], args: [] }
+```
+
+関数の最後の引数を配列として受け取りたい場合に使用します。現代の JavaScript では、残余パラメータ構文(`...args`)を使用するのがより一般的です。
+
+#### パラメータ
+
+- `func` (`Function`): 変換する関数です。
+- `start` (`number`, オプション): 配列へのグループ化を開始するインデックスです。デフォルト値は `func.length - 1` です。
+
+#### 戻り値
+
+(`Function`): 指定されたインデックスから残りの引数を配列にグループ化する新しい関数を返します。
diff --git a/docs/ja/reference/compat/function/spread.md b/docs/ja/compat/reference/function/spread.md
similarity index 100%
rename from docs/ja/reference/compat/function/spread.md
rename to docs/ja/compat/reference/function/spread.md
diff --git a/docs/ja/compat/reference/function/throttle.md b/docs/ja/compat/reference/function/throttle.md
new file mode 100644
index 000000000..b15490e84
--- /dev/null
+++ b/docs/ja/compat/reference/function/throttle.md
@@ -0,0 +1,52 @@
+# throttle (Lodash 互換性)
+
+::: warning `es-toolkit` の `throttle` を使用してください
+
+この `throttle` 関数は、Lodash 互換性のために内部的に debounce 関数を使用しているため、少し複雑になっています。また、デフォルト値やオプションの処理もより複雑です。
+
+代わりに、より高速で現代的な `es-toolkit` の [throttle](../../../reference/function/throttle.md) を使用してください。
+
+:::
+
+関数呼び出しを指定された時間間隔で最大1回実行されるように制限します。
+
+```typescript
+const throttledFunc = throttle(func, wait, options);
+```
+
+## 使用法
+
+### `throttle(func, wait, options)`
+
+関数呼び出しを指定された時間間隔で最大1回実行されるように制限したい場合は、`throttle` を使用してください。イベントハンドラーや API 呼び出しの頻度を制限するのに便利です。
+
+```typescript
+import { throttle } from 'es-toolkit/compat';
+
+// 基本的な使用法 - 1秒に最大1回実行
+const throttledLog = throttle(() => {
+ console.log('イベント発生!');
+}, 1000);
+
+// オプションを使用した例
+const throttledScroll = throttle(handleScroll, 100, {
+ leading: true, // 最初にすぐ実行
+ trailing: false, // 最後に実行しない
+});
+
+window.addEventListener('scroll', throttledScroll);
+```
+
+スクロールイベントやリサイズイベントのように速く発生するイベントを処理する際、パフォーマンスのために必須です。
+
+#### パラメータ
+
+- `func` (`Function`): スロットリングする関数です。
+- `wait` (`number`, オプション): ミリ秒単位の待機時間です。デフォルト値は `0` です。
+- `options` (`ThrottleSettings`, オプション): スロットリングオプションです。
+ - `leading` (`boolean`): 最初の呼び出しですぐに実行するかどうかです。デフォルト値は `true` です。
+ - `trailing` (`boolean`): 最後の呼び出し後に実行するかどうかです。デフォルト値は `true` です。
+
+#### 戻り値
+
+(`DebouncedFunc`): スロットリングされた関数を返します。`cancel()` メソッドで待機中の実行をキャンセルできます。
diff --git a/docs/ja/compat/reference/function/unary.md b/docs/ja/compat/reference/function/unary.md
new file mode 100644
index 000000000..871c4410f
--- /dev/null
+++ b/docs/ja/compat/reference/function/unary.md
@@ -0,0 +1,46 @@
+# unary (Lodash 互換性)
+
+::: warning `es-toolkit` の `ary` を使用してください
+
+この `unary` 関数は `ary` 関数の特殊なケースとして実装されています。より多くの制御が必要な場合は、`es-toolkit` の [ary](../../../reference/function/ary.md) を直接使用する方が効率的です。
+
+代わりに、より高速で現代的な `es-toolkit` の [ary](../../../reference/function/ary.md) を使用してください。
+
+:::
+
+関数が最大1つの引数のみを受け取るように制限します。
+
+```typescript
+const limitedFunc = unary(func);
+```
+
+## 使用法
+
+### `unary(func)`
+
+関数が最大1つの引数のみを受け取るように制限したい場合は、`unary` を使用してください。追加で渡される引数はすべて無視されます。
+
+```typescript
+import { unary } from 'es-toolkit/compat';
+
+function greet(name, greeting, punctuation) {
+ return `${greeting} ${name}${punctuation}`;
+}
+
+// 最初の引数のみを受け取る関数に変換
+const greetOne = unary(greet);
+greetOne('Alice', 'Hello', '!'); // greet('Alice') と同じように動作
+
+// 配列の map 関数と一緒に使用すると便利
+const numbers = ['1', '2', '3'];
+numbers.map(parseInt); // [1, NaN, NaN] - 予期しない結果
+numbers.map(unary(parseInt)); // [1, 2, 3] - 正しい結果
+```
+
+#### パラメータ
+
+- `func` (`(...args: any[]) => any`): 引数を制限する関数です。
+
+#### 戻り値
+
+(`(...args: any[]) => any`): 最大1つの引数のみを受け取る新しい関数を返します。
diff --git a/docs/ja/reference/compat/function/wrap.md b/docs/ja/compat/reference/function/wrap.md
similarity index 100%
rename from docs/ja/reference/compat/function/wrap.md
rename to docs/ja/compat/reference/function/wrap.md
diff --git a/docs/ja/reference/compat/math/add.md b/docs/ja/compat/reference/math/add.md
similarity index 100%
rename from docs/ja/reference/compat/math/add.md
rename to docs/ja/compat/reference/math/add.md
diff --git a/docs/ja/reference/compat/math/ceil.md b/docs/ja/compat/reference/math/ceil.md
similarity index 100%
rename from docs/ja/reference/compat/math/ceil.md
rename to docs/ja/compat/reference/math/ceil.md
diff --git a/docs/ja/compat/reference/math/clamp.md b/docs/ja/compat/reference/math/clamp.md
new file mode 100644
index 000000000..deef4610c
--- /dev/null
+++ b/docs/ja/compat/reference/math/clamp.md
@@ -0,0 +1,82 @@
+# clamp (Lodash 互換性)
+
+::: warning `es-toolkit`の[clamp](../../../reference/math/clamp.md)を使用してください
+
+この `clamp` 関数はNaN検証と処理により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [clamp](../../../reference/math/clamp.md) を使用してください。
+
+:::
+
+数値を指定された範囲内に制限します。
+
+```typescript
+const clamped = clamp(number, lower, upper);
+```
+
+## 使用法
+
+### `clamp(number, lower, upper)`
+
+数値を指定された最小値と最大値の間に制限したい場合は `clamp` を使用してください。
+
+```typescript
+import { clamp } from 'es-toolkit/compat';
+
+// 基本的な使用法
+clamp(3, 2, 4);
+// Returns: 3 (範囲内にある)
+
+clamp(0, 5, 10);
+// Returns: 5 (最小値で制限)
+
+clamp(15, 5, 10);
+// Returns: 10 (最大値で制限)
+
+// 負の数も処理
+clamp(-5, -10, -1);
+// Returns: -5
+
+clamp(-15, -10, -1);
+// Returns: -10 (最小値で制限)
+```
+
+### `clamp(number, upper)`
+
+1つの引数のみを提供すると、その値を最大値として使用します。
+
+```typescript
+import { clamp } from 'es-toolkit/compat';
+
+// 最大値のみ指定
+clamp(5, 3);
+// Returns: 3 (最大値で制限)
+
+clamp(2, 3);
+// Returns: 2 (範囲内にある)
+
+clamp(1, 5);
+// Returns: 1
+```
+
+NaN値は0として処理されます。
+
+```typescript
+import { clamp } from 'es-toolkit/compat';
+
+clamp(5, NaN, 10);
+// Returns: 5 (NaNが0として処理され、範囲は0〜10)
+
+clamp(5, 2, NaN);
+// Returns: 2 (NaNが0として処理され、範囲は0〜2)
+```
+
+#### パラメータ
+
+- `number` (`number`): 制限する数値です。
+- `lower` (`number`): 最小値です。2番目のパラメータのみがある場合は最大値になります。
+- `upper` (`number`, オプション): 最大値です。
+
+#### 戻り値
+
+(`number`): 指定された範囲内に制限された数値を返します。
diff --git a/docs/ja/reference/compat/math/divide.md b/docs/ja/compat/reference/math/divide.md
similarity index 100%
rename from docs/ja/reference/compat/math/divide.md
rename to docs/ja/compat/reference/math/divide.md
diff --git a/docs/ja/reference/compat/math/floor.md b/docs/ja/compat/reference/math/floor.md
similarity index 100%
rename from docs/ja/reference/compat/math/floor.md
rename to docs/ja/compat/reference/math/floor.md
diff --git a/docs/ja/compat/reference/math/inRange.md b/docs/ja/compat/reference/math/inRange.md
new file mode 100644
index 000000000..99a5b2caf
--- /dev/null
+++ b/docs/ja/compat/reference/math/inRange.md
@@ -0,0 +1,101 @@
+# inRange (Lodash 互換性)
+
+::: warning `es-toolkit`の[inRange](../../../reference/math/inRange.md)を使用してください
+
+この `inRange` 関数は複雑な型変換とnull/undefined処理により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [inRange](../../../reference/math/inRange.md) を使用してください。
+
+:::
+
+数値が指定された範囲内にあるかを確認します。
+
+```typescript
+const result = inRange(value, minimum, maximum);
+```
+
+## 使用法
+
+### `inRange(value, minimum, maximum?)`
+
+数値が特定の範囲内にあるかを確認したい場合は `inRange` を使用してください。最小値は含まれ、最大値は含まれません。
+
+```typescript
+import { inRange } from 'es-toolkit/compat';
+
+// 基本的な使用法
+inRange(3, 2, 4);
+// Returns: true (2 ≤ 3 < 4)
+
+inRange(1, 2, 5);
+// Returns: false (1 < 2)
+
+inRange(5, 2, 5);
+// Returns: false (5は含まれない)
+
+// 範囲境界値
+inRange(2, 2, 4);
+// Returns: true (最小値は含まれる)
+
+inRange(4, 2, 4);
+// Returns: false (最大値は含まれない)
+```
+
+### `inRange(value, maximum)`
+
+2つの引数のみを提供すると、0からmaximumまでの範囲として処理されます。
+
+```typescript
+import { inRange } from 'es-toolkit/compat';
+
+inRange(3, 5);
+// Returns: true (0 ≤ 3 < 5)
+
+inRange(-1, 5);
+// Returns: false (-1 < 0)
+
+inRange(0, 5);
+// Returns: true (0 ≤ 0 < 5)
+
+inRange(5, 5);
+// Returns: false (5は含まれない)
+```
+
+最小値が最大値より大きい場合は自動的に交換されます。
+
+```typescript
+import { inRange } from 'es-toolkit/compat';
+
+inRange(3, 5, 2);
+// Returns: true (範囲が2〜5に変更され、2 ≤ 3 < 5)
+
+inRange(1, 5, 2);
+// Returns: false (1 < 2)
+```
+
+不正な値は適切に変換されます。
+
+```typescript
+import { inRange } from 'es-toolkit/compat';
+
+// 文字列数値変換
+inRange(3, '2', '4');
+// Returns: true
+
+// falsy値は0として処理
+inRange(1, null, 5);
+// Returns: true (nullが0として処理され、0〜5の範囲)
+
+inRange(3, false, 5);
+// Returns: true (falseが0として処理)
+```
+
+#### パラメータ
+
+- `value` (`number`): 範囲内にあるかを確認する数値です。
+- `minimum` (`number`): 範囲の最小値です（含まれる）。`maximum`がない場合、この値が最大値になります。
+- `maximum` (`number`, オプション): 範囲の最大値です（含まれない）。
+
+#### 戻り値
+
+(`boolean`): 値が指定された範囲内にある場合は `true`、そうでなければ `false` を返します。
diff --git a/docs/ja/reference/compat/math/max.md b/docs/ja/compat/reference/math/max.md
similarity index 100%
rename from docs/ja/reference/compat/math/max.md
rename to docs/ja/compat/reference/math/max.md
diff --git a/docs/ja/compat/reference/math/maxBy.md b/docs/ja/compat/reference/math/maxBy.md
new file mode 100644
index 000000000..453ff0acd
--- /dev/null
+++ b/docs/ja/compat/reference/math/maxBy.md
@@ -0,0 +1,114 @@
+# maxBy (Lodash 互換性)
+
+::: warning es-toolkitの[maxBy](../../../reference/array/maxBy.md)を使用してください
+
+この `maxBy` 関数はiteratee関数処理と型変換により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [maxBy](../../../reference/array/maxBy.md) を使用してください。
+
+:::
+
+条件に合う値の中から最大値要素を見つけます。
+
+```typescript
+const maxItem = maxBy(array, iteratee);
+```
+
+## 使用法
+
+### `maxBy(array, iteratee)`
+
+配列から関数で計算した値が最も大きい要素を見つけます。
+
+```typescript
+import { maxBy } from 'es-toolkit/compat';
+
+// オブジェクト配列から特定のプロパティが最大の要素
+const people = [
+ { name: '홍길동', age: 25 },
+ { name: '김철수', age: 30 },
+ { name: '이영희', age: 35 },
+];
+
+maxBy(people, person => person.age);
+// Returns: { name: '이영희', age: 35 }
+
+// プロパティ名でも可能
+maxBy(people, 'age');
+// Returns: { name: '이영희', age: 35 }
+```
+
+関数で値を変換して最大値を見つけます。
+
+```typescript
+import { maxBy } from 'es-toolkit/compat';
+
+const items = [{ a: 1 }, { a: 2 }, { a: 3 }];
+maxBy(items, x => x.a);
+// Returns: { a: 3 }
+
+const numbers = [-1, -2, -3];
+maxBy(numbers, x => Math.abs(x));
+// Returns: -3 (絶対値が最も大きい要素)
+```
+
+配列要素でアクセスします。
+
+```typescript
+import { maxBy } from 'es-toolkit/compat';
+
+const arrays = [
+ [1, 2],
+ [3, 4],
+ [0, 5],
+];
+maxBy(arrays, 0); // 最初の要素が最大の配列
+// Returns: [3, 4]
+
+maxBy(arrays, 1); // 2番目の要素が最大の配列
+// Returns: [0, 5]
+```
+
+オブジェクトの特定プロパティと値が一致する場合を見つけます。
+
+```typescript
+import { maxBy } from 'es-toolkit/compat';
+
+const users = [
+ { name: '홍길동', age: 25, active: true },
+ { name: '김철수', age: 30, active: false },
+ { name: '이영희', age: 35, active: true },
+];
+
+// activeがtrueの要素の中から最初のもの
+maxBy(users, ['active', true]);
+// Returns: { name: '홍길동', age: 25, active: true }
+
+// オブジェクトで条件指定
+maxBy(users, { active: true });
+// Returns: { name: '홍길동', age: 25, active: true }
+```
+
+空の配列はundefinedを返します。
+
+```typescript
+import { maxBy } from 'es-toolkit/compat';
+
+maxBy([], x => x.a);
+// Returns: undefined
+
+maxBy(null);
+// Returns: undefined
+
+maxBy(undefined);
+// Returns: undefined
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 検索する配列です。
+- `iteratee` (`ValueIteratee`, オプション): 各要素に適用する関数、プロパティ名、または条件です。
+
+#### 戻り値
+
+(`T | undefined`): 条件に合う値が最も大きい要素を返します。空の配列の場合は `undefined` を返します。
diff --git a/docs/ja/compat/reference/math/mean.md b/docs/ja/compat/reference/math/mean.md
new file mode 100644
index 000000000..a178d99a8
--- /dev/null
+++ b/docs/ja/compat/reference/math/mean.md
@@ -0,0 +1,76 @@
+# mean (Lodash 互換性)
+
+::: warning es-toolkitの[mean](../../../reference/math/mean.md)を使用してください
+
+この `mean` 関数は型変換とnull/undefined処理により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [mean](../../../reference/math/mean.md) を使用してください。
+
+:::
+
+配列の平均値を計算します。
+
+```typescript
+const average = mean(array);
+```
+
+## 使用法
+
+### `mean(array)`
+
+数値配列の平均値を計算します。
+
+```typescript
+import { mean } from 'es-toolkit/compat';
+
+// 数値配列
+mean([1, 2, 3, 4, 5]);
+// Returns: 3
+
+mean([10, 20, 30]);
+// Returns: 20
+
+mean([1.5, 2.5, 3.5]);
+// Returns: 2.5
+```
+
+空の配列はNaNを返します。
+
+```typescript
+import { mean } from 'es-toolkit/compat';
+
+mean([]);
+// Returns: NaN
+
+mean(null);
+// Returns: NaN
+
+mean(undefined);
+// Returns: NaN
+```
+
+無効な値は0として扱われ、計算に含まれます。
+
+```typescript
+import { mean } from 'es-toolkit/compat';
+
+mean([1, undefined, 2, null, 3]);
+// Returns: 1.2 (1 + 2 + 3) / 5 = 1.2
+```
+
+文字列は連結されます。
+
+```typescript
+import { mean } from 'es-toolkit/compat';
+
+mean(['1', '2', '3']);
+// Returns: 41 (123 / 3 = 41)
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 平均を計算する数値が含まれる配列です。
+
+#### 戻り値
+
+(`number`): 配列の平均値を返します。空の配列の場合は `NaN` を返します。
diff --git a/docs/ja/compat/reference/math/meanBy.md b/docs/ja/compat/reference/math/meanBy.md
new file mode 100644
index 000000000..5dc5b4af8
--- /dev/null
+++ b/docs/ja/compat/reference/math/meanBy.md
@@ -0,0 +1,103 @@
+# meanBy (Lodash 互換性)
+
+::: warning es-toolkitの[meanBy](../../../reference/math/meanBy.md)を使用してください
+
+この `meanBy` 関数はiteratee関数処理と型変換により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [meanBy](../../../reference/math/meanBy.md) を使用してください。
+
+:::
+
+条件に合う値の平均を計算します。
+
+```typescript
+const average = meanBy(array, iteratee);
+```
+
+## 使用法
+
+### `meanBy(array, iteratee)`
+
+配列の各要素に関数を適用した結果の平均を計算します。
+
+```typescript
+import { meanBy } from 'es-toolkit/compat';
+
+// オブジェクト配列から特定プロパティの平均
+const people = [
+ { name: '홍길동', age: 25 },
+ { name: '김철수', age: 30 },
+ { name: '이영희', age: 35 },
+];
+
+meanBy(people, person => person.age);
+// Returns: 30
+
+// プロパティ名でも可能
+meanBy(people, 'age');
+// Returns: 30
+```
+
+関数で値を変換して平均を計算します。
+
+```typescript
+import { meanBy } from 'es-toolkit/compat';
+
+const numbers = [1.5, 2.7, 3.2, 4.8];
+meanBy(numbers, x => Math.floor(x));
+// Returns: 2.5 (1 + 2 + 3 + 4) / 4
+
+const items = [{ a: 1 }, { a: 2 }, { a: 3 }];
+meanBy(items, x => x.a);
+// Returns: 2
+```
+
+配列要素でアクセスします。
+
+```typescript
+import { meanBy } from 'es-toolkit/compat';
+
+const arrays = [[2], [3], [1]];
+meanBy(arrays, 0); // 最初の要素の平均
+// Returns: 2
+```
+
+オブジェクトの特定プロパティと値が一致する場合のみ計算します。
+
+```typescript
+import { meanBy } from 'es-toolkit/compat';
+
+const users = [
+ { name: '홍길동', age: 25, active: true },
+ { name: '김철수', age: 30, active: false },
+ { name: '이영희', age: 35, active: true },
+];
+
+// activeがtrueの人のみ
+meanBy(users, { active: true });
+// Returns: 0.6666666 (active が true の人の割合)
+```
+
+空の配列はNaNを返します。
+
+```typescript
+import { meanBy } from 'es-toolkit/compat';
+
+meanBy([], x => x.a);
+// Returns: NaN
+
+meanBy(null);
+// Returns: NaN
+
+meanBy(undefined);
+// Returns: NaN
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 処理する配列です。
+- `iteratee` (`ValueIteratee`, オプション): 各要素に適用する関数、プロパティ名、または条件です。
+
+#### 戻り値
+
+(`number`): 条件に合う値の平均を返します。空の配列の場合は `NaN` を返します。
diff --git a/docs/ja/reference/compat/math/min.md b/docs/ja/compat/reference/math/min.md
similarity index 100%
rename from docs/ja/reference/compat/math/min.md
rename to docs/ja/compat/reference/math/min.md
diff --git a/docs/ja/compat/reference/math/minBy.md b/docs/ja/compat/reference/math/minBy.md
new file mode 100644
index 000000000..cdb65713b
--- /dev/null
+++ b/docs/ja/compat/reference/math/minBy.md
@@ -0,0 +1,114 @@
+# minBy (Lodash 互換性)
+
+::: warning es-toolkitの[minBy](../../../reference/array/minBy.md)を使用してください
+
+この `minBy` 関数はiteratee関数処理と型変換により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [minBy](../../../reference/array/minBy.md) を使用してください。
+
+:::
+
+条件に合致する値の中で最小値要素を見つけます。
+
+```typescript
+const minItem = minBy(array, iteratee);
+```
+
+## 使用法
+
+### `minBy(array, iteratee)`
+
+配列から関数で計算した値が最小の要素を見つけます。
+
+```typescript
+import { minBy } from 'es-toolkit/compat';
+
+// オブジェクト配列から特定のプロパティが最小の要素
+const people = [
+ { name: 'ホンギルドン', age: 25 },
+ { name: 'キムチョルス', age: 30 },
+ { name: 'イヨンヒ', age: 35 },
+];
+
+minBy(people, person => person.age);
+// Returns: { name: 'ホンギルドン', age: 25 }
+
+// プロパティ名でも可能
+minBy(people, 'age');
+// Returns: { name: 'ホンギルドン', age: 25 }
+```
+
+関数で値を変換して最小値を見つけます。
+
+```typescript
+import { minBy } from 'es-toolkit/compat';
+
+const items = [{ a: 1 }, { a: 2 }, { a: 3 }];
+minBy(items, x => x.a);
+// Returns: { a: 1 }
+
+const numbers = [-1, -2, -3];
+minBy(numbers, x => Math.abs(x));
+// Returns: -1 (絶対値が最小の要素)
+```
+
+配列要素でアクセスします。
+
+```typescript
+import { minBy } from 'es-toolkit/compat';
+
+const arrays = [
+ [1, 2],
+ [3, 4],
+ [0, 5],
+];
+minBy(arrays, 0); // 最初の要素が最小の配列
+// Returns: [0, 5]
+
+minBy(arrays, 1); // 2番目の要素が最小の配列
+// Returns: [1, 2]
+```
+
+オブジェクトの特定プロパティと値が一致する場合を見つけます。
+
+```typescript
+import { minBy } from 'es-toolkit/compat';
+
+const users = [
+ { name: 'ホンギルドン', age: 25, active: true },
+ { name: 'キムチョルス', age: 30, active: false },
+ { name: 'イヨンヒ', age: 35, active: true },
+];
+
+// activeがtrueの要素の中で最初ではないものを見つける
+minBy(users, ['active', true]);
+// Returns: { name: 'キムチョルス', age: 30, active: false }
+
+// オブジェクトで条件を指定
+minBy(users, { active: true });
+// Returns: { name: 'キムチョルス', age: 30, active: false }
+```
+
+空の配列はundefinedを返します。
+
+```typescript
+import { minBy } from 'es-toolkit/compat';
+
+minBy([], x => x.a);
+// Returns: undefined
+
+minBy(null);
+// Returns: undefined
+
+minBy(undefined);
+// Returns: undefined
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 検索する配列です。
+- `iteratee` (`ValueIteratee`, オプション): 各要素に適用する関数、プロパティ名、または条件です。
+
+#### 戻り値
+
+(`T | undefined`): 条件に合致する値が最小の要素を返します。空の配列の場合は `undefined` を返します。
diff --git a/docs/ja/reference/compat/math/multiply.md b/docs/ja/compat/reference/math/multiply.md
similarity index 100%
rename from docs/ja/reference/compat/math/multiply.md
rename to docs/ja/compat/reference/math/multiply.md
diff --git a/docs/ja/reference/compat/math/parseInt.md b/docs/ja/compat/reference/math/parseInt.md
similarity index 100%
rename from docs/ja/reference/compat/math/parseInt.md
rename to docs/ja/compat/reference/math/parseInt.md
diff --git a/docs/ja/reference/compat/math/random.md b/docs/ja/compat/reference/math/random.md
similarity index 100%
rename from docs/ja/reference/compat/math/random.md
rename to docs/ja/compat/reference/math/random.md
diff --git a/docs/ja/compat/reference/math/range.md b/docs/ja/compat/reference/math/range.md
new file mode 100644
index 000000000..32a6a4aa3
--- /dev/null
+++ b/docs/ja/compat/reference/math/range.md
@@ -0,0 +1,99 @@
+# range (Lodash 互換性)
+
+::: warning es-toolkitの[range](../../../reference/math/range.md)を使用してください
+
+この `range` 関数は複雑な引数処理と型変換により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [range](../../../reference/math/range.md) を使用してください。
+
+:::
+
+数値範囲の配列を作成します。
+
+```typescript
+const numbers = range(start, end, step);
+```
+
+## 使用法
+
+### `range(end)`
+
+0からendまで1ずつ増加する配列を作成します。
+
+```typescript
+import { range } from 'es-toolkit/compat';
+
+range(4);
+// Returns: [0, 1, 2, 3]
+
+range(0);
+// Returns: []
+
+range(-4);
+// Returns: [0, -1, -2, -3]
+```
+
+### `range(start, end)`
+
+startからendまで1ずつ増加する配列を作成します。
+
+```typescript
+import { range } from 'es-toolkit/compat';
+
+range(1, 5);
+// Returns: [1, 2, 3, 4]
+
+range(5, 1);
+// Returns: [5, 4, 3, 2] (自動的に-1ずつ減少)
+
+range(-2, 3);
+// Returns: [-2, -1, 0, 1, 2]
+```
+
+### `range(start, end, step)`
+
+startからendまでstepずつ増加する配列を作成します。
+
+```typescript
+import { range } from 'es-toolkit/compat';
+
+range(0, 20, 5);
+// Returns: [0, 5, 10, 15]
+
+range(0, -4, -1);
+// Returns: [0, -1, -2, -3]
+
+range(1, 4, 0);
+// Returns: [1, 1, 1]
+```
+
+小数のstepも可能です。
+
+```typescript
+import { range } from 'es-toolkit/compat';
+
+range(0, 1, 0.2);
+// Returns: [0, 0.2, 0.4, 0.6, 0.8]
+
+range(1, 0, -0.25);
+// Returns: [1, 0.75, 0.5, 0.25]
+```
+
+iterateeとして使用する場合はguardオブジェクトで処理されます。
+
+```typescript
+import { range } from 'es-toolkit/compat';
+
+[1, 2, 3].map(range);
+// Returns: [[0], [0, 1], [0, 1, 2]]
+```
+
+#### パラメータ
+
+- `start` (`number`): 範囲の開始値です（含まれます）。`end`がない場合、この値がendになります。
+- `end` (`number`, オプション): 範囲の終了値です（含まれません）。
+- `step` (`number`, オプション): 増加幅です。デフォルトは1または-1です。
+
+#### 戻り値
+
+(`number[]`): 指定された範囲の数値配列を返します。
diff --git a/docs/ja/compat/reference/math/rangeRight.md b/docs/ja/compat/reference/math/rangeRight.md
new file mode 100644
index 000000000..1db217bc1
--- /dev/null
+++ b/docs/ja/compat/reference/math/rangeRight.md
@@ -0,0 +1,99 @@
+# rangeRight (Lodash 互換性)
+
+::: warning es-toolkitの[rangeRight](../../../reference/math/rangeRight.md)を使用してください
+
+この `rangeRight` 関数は複雑な引数処理と型変換により動作が遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [rangeRight](../../../reference/math/rangeRight.md) を使用してください。
+
+:::
+
+数値範囲の配列を逆順で作成します。
+
+```typescript
+const numbers = rangeRight(start, end, step);
+```
+
+## 使用法
+
+### `rangeRight(end)`
+
+0からendまで1ずつ増加させた後、逆順で配列を作成します。
+
+```typescript
+import { rangeRight } from 'es-toolkit/compat';
+
+rangeRight(4);
+// Returns: [3, 2, 1, 0]
+
+rangeRight(0);
+// Returns: []
+
+rangeRight(-4);
+// Returns: [-3, -2, -1, 0]
+```
+
+### `rangeRight(start, end)`
+
+startからendまで1ずつ増加させた後、逆順で配列を作成します。
+
+```typescript
+import { rangeRight } from 'es-toolkit/compat';
+
+rangeRight(1, 5);
+// Returns: [4, 3, 2, 1]
+
+rangeRight(5, 1);
+// Returns: [2, 3, 4, 5] (自動的に-1ずつ減少してから逆順)
+
+rangeRight(-2, 3);
+// Returns: [2, 1, 0, -1, -2]
+```
+
+### `rangeRight(start, end, step)`
+
+startからendまでstepずつ増加させた後、逆順で配列を作成します。
+
+```typescript
+import { rangeRight } from 'es-toolkit/compat';
+
+rangeRight(0, 8, 2);
+// Returns: [6, 4, 2, 0]
+
+rangeRight(0, -4, -1);
+// Returns: [-3, -2, -1, 0]
+
+rangeRight(1, 4, 0);
+// Returns: [1, 1, 1]
+```
+
+小数のstepも可能です。
+
+```typescript
+import { rangeRight } from 'es-toolkit/compat';
+
+rangeRight(0, 1, 0.2);
+// Returns: [0.8, 0.6, 0.4, 0.2, 0]
+
+rangeRight(1, 0, -0.25);
+// Returns: [0.25, 0.5, 0.75, 1]
+```
+
+iterateeとして使用する場合はguardオブジェクトで処理されます。
+
+```typescript
+import { rangeRight } from 'es-toolkit/compat';
+
+[1, 2, 3].map(rangeRight);
+// Returns: [[0], [1, 0], [2, 1, 0]]
+```
+
+#### パラメータ
+
+- `start` (`number`): 範囲の開始値です（含まれます）。`end`がない場合、この値がendになります。
+- `end` (`number`, オプション): 範囲の終了値です（含まれません）。
+- `step` (`number`, オプション): 増加幅です。デフォルトは1または-1です。
+
+#### 戻り値
+
+(`number[]`): 指定された範囲の数値配列を逆順で返します。
diff --git a/docs/ja/reference/compat/math/round.md b/docs/ja/compat/reference/math/round.md
similarity index 100%
rename from docs/ja/reference/compat/math/round.md
rename to docs/ja/compat/reference/math/round.md
diff --git a/docs/ja/reference/compat/math/subtract.md b/docs/ja/compat/reference/math/subtract.md
similarity index 100%
rename from docs/ja/reference/compat/math/subtract.md
rename to docs/ja/compat/reference/math/subtract.md
diff --git a/docs/ja/compat/reference/math/sum.md b/docs/ja/compat/reference/math/sum.md
new file mode 100644
index 000000000..14a9227cb
--- /dev/null
+++ b/docs/ja/compat/reference/math/sum.md
@@ -0,0 +1,73 @@
+# sum (Lodash 互換性)
+
+::: warning es-toolkitの[sum](../../../reference/math/sum.md)を使用してください
+
+この`sum`関数は型変換とnull/undefined処理により動作が遅いです。
+
+代わりにより高速で現代的な`es-toolkit`の[sum](../../../reference/math/sum.md)を使用してください。
+
+:::
+
+配列のすべての値を足します。
+
+```typescript
+const total = sum(array);
+```
+
+## 使用法
+
+### `sum(array)`
+
+配列内のすべての数値を足して合計を求めます。
+
+```typescript
+import { sum } from 'es-toolkit/compat';
+
+// 数値配列
+sum([1, 2, 3]);
+// Returns: 6
+
+sum([1.5, 2.5, 3]);
+// Returns: 7
+
+// 空配列
+sum([]);
+// Returns: 0
+```
+
+BigIntと文字列も処理します。
+
+```typescript
+import { sum } from 'es-toolkit/compat';
+
+// BigInt配列
+sum([1n, 2n, 3n]);
+// Returns: 6n
+
+// 文字列配列（連結される）
+sum(['1', '2']);
+// Returns: '12'
+```
+
+無効な値は無視します。
+
+```typescript
+import { sum } from 'es-toolkit/compat';
+
+sum([1, undefined, 2]);
+// Returns: 3 (undefinedを無視)
+
+sum(null);
+// Returns: 0
+
+sum(undefined);
+// Returns: 0
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 足す値が含まれる配列です。
+
+#### 戻り値
+
+(`number`): すべての値を足した合計を返します。
diff --git a/docs/ja/compat/reference/math/sumBy.md b/docs/ja/compat/reference/math/sumBy.md
new file mode 100644
index 000000000..5e2ac19f2
--- /dev/null
+++ b/docs/ja/compat/reference/math/sumBy.md
@@ -0,0 +1,103 @@
+# sumBy (Lodash 互換性)
+
+::: warning es-toolkitの[sumBy](../../../reference/math/sumBy.md)を使用してください
+
+この`sumBy`関数はiteratee関数処理と型変換により動作が遅いです。
+
+代わりにより高速で現代的な`es-toolkit`の[sumBy](../../../reference/math/sumBy.md)を使用してください。
+
+:::
+
+条件に合う値を足します。
+
+```typescript
+const total = sumBy(array, iteratee);
+```
+
+## 使用法
+
+### `sumBy(array, iteratee)`
+
+配列の各要素に関数を適用した結果を足します。
+
+```typescript
+import { sumBy } from 'es-toolkit/compat';
+
+// 数値配列
+sumBy([1, 2, 3], value => value);
+// Returns: 6
+
+sumBy([1.5, 2.5, 3.5], value => Math.floor(value));
+// Returns: 6 (1 + 2 + 3)
+
+// 空配列
+sumBy([], value => value);
+// Returns: 0
+```
+
+### `sumBy(array)`
+
+関数を渡さない場合、配列の値をそのまま足します。
+
+```typescript
+import { sumBy } from 'es-toolkit/compat';
+
+sumBy([1, 2, 3]);
+// Returns: 6
+
+sumBy([1n, 2n, 3n]);
+// Returns: 6n
+```
+
+オブジェクト配列から特定のプロパティを足します。
+
+```typescript
+import { sumBy } from 'es-toolkit/compat';
+
+const people = [
+ { name: '田中太郎', age: 25 },
+ { name: '佐藤次郎', age: 30 },
+ { name: '鈴木花子', age: 35 },
+];
+
+sumBy(people, person => person.age);
+// Returns: 90
+
+// プロパティ名でも可能
+sumBy(people, 'age');
+// Returns: 90
+```
+
+文字列も連結します。
+
+```typescript
+import { sumBy } from 'es-toolkit/compat';
+
+const items = [{ a: '1' }, { a: '2' }];
+sumBy(items, obj => obj.a);
+// Returns: '12'
+```
+
+無効な値は無視します。
+
+```typescript
+import { sumBy } from 'es-toolkit/compat';
+
+sumBy([1, undefined, 2], value => value);
+// Returns: 3 (undefinedを無視)
+
+sumBy(null);
+// Returns: 0
+
+sumBy(undefined);
+// Returns: 0
+```
+
+#### パラメータ
+
+- `array` (`ArrayLike | null | undefined`): 処理する配列です。
+- `iteratee` (`((value: T) => number) | string`, オプション): 各要素に適用する関数またはプロパティ名です。
+
+#### 戻り値
+
+(`number`): 条件に合う値を足した合計を返します。
diff --git a/docs/ja/reference/compat/object/assign.md b/docs/ja/compat/reference/object/assign.md
similarity index 100%
rename from docs/ja/reference/compat/object/assign.md
rename to docs/ja/compat/reference/object/assign.md
diff --git a/docs/ja/reference/compat/object/assignIn.md b/docs/ja/compat/reference/object/assignIn.md
similarity index 100%
rename from docs/ja/reference/compat/object/assignIn.md
rename to docs/ja/compat/reference/object/assignIn.md
diff --git a/docs/ja/reference/compat/object/assignInWith.md b/docs/ja/compat/reference/object/assignInWith.md
similarity index 100%
rename from docs/ja/reference/compat/object/assignInWith.md
rename to docs/ja/compat/reference/object/assignInWith.md
diff --git a/docs/ja/reference/compat/object/assignWith.md b/docs/ja/compat/reference/object/assignWith.md
similarity index 100%
rename from docs/ja/reference/compat/object/assignWith.md
rename to docs/ja/compat/reference/object/assignWith.md
diff --git a/docs/ja/reference/compat/object/at.md b/docs/ja/compat/reference/object/at.md
similarity index 100%
rename from docs/ja/reference/compat/object/at.md
rename to docs/ja/compat/reference/object/at.md
diff --git a/docs/ja/compat/reference/object/clone.md b/docs/ja/compat/reference/object/clone.md
new file mode 100644
index 000000000..43163cd9a
--- /dev/null
+++ b/docs/ja/compat/reference/object/clone.md
@@ -0,0 +1,89 @@
+# clone (Lodash 互換性)
+
+::: warning `es-toolkit`の`clone`を使用してください
+
+この `clone` 関数は、特殊なオブジェクトタイプを処理する複雑なロジックにより相対的に遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [clone](../../../reference/object/clone.md) を使用してください。
+
+:::
+
+オブジェクトの浅いコピーを作成します。
+
+```typescript
+const cloned = clone(value);
+```
+
+## 使用法
+
+### `clone(value)`
+
+値の浅いコピーを作成したい場合は、`clone`を使用してください。さまざまなタイプのオブジェクトと原始値をコピーできます。
+
+```typescript
+import { clone } from 'es-toolkit/compat';
+
+// 原始値のコピー
+const num = 42;
+const clonedNum = clone(num);
+// Returns: 42 (同じ値)
+
+// 配列のコピー
+const arr = [1, 2, 3];
+const clonedArr = clone(arr);
+// Returns: [1, 2, 3] (新しい配列インスタンス)
+
+// オブジェクトのコピー
+const obj = { a: 1, b: 'hello' };
+const clonedObj = clone(obj);
+// Returns: { a: 1, b: 'hello' } (新しいオブジェクトインスタンス)
+
+// Dateオブジェクトのコピー
+const date = new Date('2023-01-01');
+const clonedDate = clone(date);
+// Returns: new Date('2023-01-01') (新しいDateインスタンス)
+
+// 正規表現のコピー
+const regex = /hello/gi;
+regex.lastIndex = 3;
+const clonedRegex = clone(regex);
+// Returns: /hello/gi with lastIndex = 3
+
+// Mapのコピー
+const map = new Map([
+ ['a', 1],
+ ['b', 2],
+]);
+const clonedMap = clone(map);
+// Returns: new Map([['a', 1], ['b', 2]])
+
+// Setのコピー
+const set = new Set([1, 2, 3]);
+const clonedSet = clone(set);
+// Returns: new Set([1, 2, 3])
+```
+
+ネストされたオブジェクトは浅いコピーのみが行われます。
+
+```typescript
+import { clone } from 'es-toolkit/compat';
+
+const nested = {
+ a: 1,
+ b: {
+ c: 2,
+ },
+};
+const clonedNested = clone(nested);
+
+console.log(clonedNested !== nested); // true (異なるオブジェクト)
+console.log(clonedNested.b === nested.b); // true (ネストされたオブジェクトは同じ参照)
+```
+
+#### パラメータ
+
+- `value` (`T`): コピーする値です。
+
+#### 戻り値
+
+(`T`): コピーされた値を返します。
diff --git a/docs/ja/compat/reference/object/cloneDeep.md b/docs/ja/compat/reference/object/cloneDeep.md
new file mode 100644
index 000000000..19128c31a
--- /dev/null
+++ b/docs/ja/compat/reference/object/cloneDeep.md
@@ -0,0 +1,88 @@
+# cloneDeep (Lodash 互換性)
+
+::: warning `es-toolkit`の`cloneDeep`を使用してください
+
+この `cloneDeep` 関数は、特殊なオブジェクトタイプを処理する複雑なロジックにより相対的に遅くなります。
+
+代わりに、より高速で現代的な `es-toolkit` の [cloneDeep](../../../reference/object/cloneDeep.md) を使用してください。
+
+:::
+
+オブジェクトの深いコピーを作成します。
+
+```typescript
+const cloned = cloneDeep(value);
+```
+
+## 使用法
+
+### `cloneDeep(value)`
+
+値の深いコピーを作成したい場合は、`cloneDeep`を使用してください。ネストされたオブジェクトと配列を完全に新しいインスタンスとしてコピーします。
+
+```typescript
+import { cloneDeep } from 'es-toolkit/compat';
+
+// 原始値のコピー
+const num = 42;
+const clonedNum = cloneDeep(num);
+// Returns: 42 (同じ値)
+
+// 配列の深いコピー
+const arr = [1, [2, 3], { a: 4 }];
+const clonedArr = cloneDeep(arr);
+clonedArr[1][0] = 99;
+console.log(arr[1][0]); // 2 (元の値は変更されない)
+console.log(clonedArr[1][0]); // 99
+
+// オブジェクトの深いコピー
+const obj = {
+ a: 1,
+ b: {
+ c: 2,
+ d: {
+ e: 3,
+ },
+ },
+};
+const clonedObj = cloneDeep(obj);
+clonedObj.b.d.e = 99;
+console.log(obj.b.d.e); // 3 (元の値は変更されない)
+console.log(clonedObj.b.d.e); // 99
+
+// Dateオブジェクトの深いコピー
+const date = new Date('2023-01-01');
+const clonedDate = cloneDeep(date);
+// Returns: new Date('2023-01-01') (新しいDateインスタンス)
+
+// 複雑なネスト構造
+const complex = {
+ arr: [1, { nested: true }],
+ map: new Map([['key', { value: 1 }]]),
+ set: new Set([{ item: 1 }]),
+ date: new Date(),
+};
+const clonedComplex = cloneDeep(complex);
+// すべてのネストされたオブジェクトが完全に新しいインスタンスとしてコピーされる
+```
+
+循環参照も正しく処理されます。
+
+```typescript
+import { cloneDeep } from 'es-toolkit/compat';
+
+const obj = { a: 1 };
+obj.self = obj; // 循環参照
+
+const cloned = cloneDeep(obj);
+console.log(cloned !== obj); // true
+console.log(cloned.self === cloned); // true (循環参照が保持される)
+```
+
+#### パラメータ
+
+- `value` (`T`): 深くコピーする値です。
+
+#### 戻り値
+
+(`T`): 深くコピーされた値を返します。
diff --git a/docs/ja/reference/compat/object/cloneDeepWith.md b/docs/ja/compat/reference/object/cloneDeepWith.md
similarity index 100%
rename from docs/ja/reference/compat/object/cloneDeepWith.md
rename to docs/ja/compat/reference/object/cloneDeepWith.md
diff --git a/docs/ja/reference/compat/object/cloneWith.md b/docs/ja/compat/reference/object/cloneWith.md
similarity index 100%
rename from docs/ja/reference/compat/object/cloneWith.md
rename to docs/ja/compat/reference/object/cloneWith.md
diff --git a/docs/ja/reference/compat/object/create.md b/docs/ja/compat/reference/object/create.md
similarity index 100%
rename from docs/ja/reference/compat/object/create.md
rename to docs/ja/compat/reference/object/create.md
diff --git a/docs/ja/reference/compat/object/defaults.md b/docs/ja/compat/reference/object/defaults.md
similarity index 100%
rename from docs/ja/reference/compat/object/defaults.md
rename to docs/ja/compat/reference/object/defaults.md
diff --git a/docs/ja/reference/compat/object/defaultsDeep.md b/docs/ja/compat/reference/object/defaultsDeep.md
similarity index 100%
rename from docs/ja/reference/compat/object/defaultsDeep.md
rename to docs/ja/compat/reference/object/defaultsDeep.md
diff --git a/docs/ja/reference/compat/object/extend.md b/docs/ja/compat/reference/object/extend.md
similarity index 100%
rename from docs/ja/reference/compat/object/extend.md
rename to docs/ja/compat/reference/object/extend.md
diff --git a/docs/ja/reference/compat/object/extendWith.md b/docs/ja/compat/reference/object/extendWith.md
similarity index 100%
rename from docs/ja/reference/compat/object/extendWith.md
rename to docs/ja/compat/reference/object/extendWith.md
diff --git a/docs/ja/compat/reference/object/findKey.md b/docs/ja/compat/reference/object/findKey.md
new file mode 100644
index 000000000..3d5d009bf
--- /dev/null
+++ b/docs/ja/compat/reference/object/findKey.md
@@ -0,0 +1,61 @@
+# findKey (Lodash 互換性)
+
+::: warning `es-toolkit`の`findKey`を使用してください
+
+この`findKey`関数は、さまざまな条件タイプの処理と互換性ロジックにより、複雑に動作します。
+
+代わりに、より高速で現代的な`es-toolkit`の[findKey](../../../reference/object/findKey.md)を使用してください。
+
+:::
+
+条件に一致する最初の要素のキーを検索します。
+
+```typescript
+const key = findKey(obj, predicate);
+```
+
+## 使用法
+
+### `findKey(obj, predicate)`
+
+オブジェクト内で条件に一致する最初の要素のキーを検索するには`findKey`を使用してください。関数、オブジェクト、配列、文字列など、さまざまな形式の条件を使用できます。
+
+```typescript
+import { findKey } from 'es-toolkit/compat';
+
+// 関数条件でキーを検索
+const users = {
+ alice: { age: 25, active: true },
+ bob: { age: 30, active: false },
+ charlie: { age: 35, active: true },
+};
+
+findKey(users, user => user.age > 30);
+// 戻り値: 'charlie'
+
+// オブジェクト条件でキーを検索
+findKey(users, { active: false });
+// 戻り値: 'bob'
+
+// プロパティパスでキーを検索
+findKey(users, 'active');
+// 戻り値: 'alice'
+```
+
+条件に一致する要素がない場合は`undefined`を返します。
+
+```typescript
+import { findKey } from 'es-toolkit/compat';
+
+findKey({ a: 1, b: 2 }, value => value > 5);
+// 戻り値: undefined
+```
+
+#### パラメータ
+
+- `obj` (`T | null | undefined`): 検索するオブジェクトです。
+- `predicate` (`ObjectIteratee`, オプション): 各要素に適用する条件です。関数、オブジェクト、配列、文字列を指定できます。
+
+#### 戻り値
+
+(`string | undefined`): 条件に一致する最初の要素のキーを返します。一致するものがない場合は`undefined`を返します。
diff --git a/docs/ja/reference/compat/object/findLastKey.md b/docs/ja/compat/reference/object/findLastKey.md
similarity index 100%
rename from docs/ja/reference/compat/object/findLastKey.md
rename to docs/ja/compat/reference/object/findLastKey.md
diff --git a/docs/ja/reference/compat/object/forIn.md b/docs/ja/compat/reference/object/forIn.md
similarity index 100%
rename from docs/ja/reference/compat/object/forIn.md
rename to docs/ja/compat/reference/object/forIn.md
diff --git a/docs/ja/reference/compat/object/forInRight.md b/docs/ja/compat/reference/object/forInRight.md
similarity index 100%
rename from docs/ja/reference/compat/object/forInRight.md
rename to docs/ja/compat/reference/object/forInRight.md
diff --git a/docs/ja/reference/compat/object/forOwn.md b/docs/ja/compat/reference/object/forOwn.md
similarity index 100%
rename from docs/ja/reference/compat/object/forOwn.md
rename to docs/ja/compat/reference/object/forOwn.md
diff --git a/docs/ja/reference/compat/object/forOwnRight.md b/docs/ja/compat/reference/object/forOwnRight.md
similarity index 100%
rename from docs/ja/reference/compat/object/forOwnRight.md
rename to docs/ja/compat/reference/object/forOwnRight.md
diff --git a/docs/ja/reference/compat/object/fromPairs.md b/docs/ja/compat/reference/object/fromPairs.md
similarity index 100%
rename from docs/ja/reference/compat/object/fromPairs.md
rename to docs/ja/compat/reference/object/fromPairs.md
diff --git a/docs/ja/reference/compat/object/functions.md b/docs/ja/compat/reference/object/functions.md
similarity index 100%
rename from docs/ja/reference/compat/object/functions.md
rename to docs/ja/compat/reference/object/functions.md
diff --git a/docs/ja/reference/compat/object/functionsIn.md b/docs/ja/compat/reference/object/functionsIn.md
similarity index 100%
rename from docs/ja/reference/compat/object/functionsIn.md
rename to docs/ja/compat/reference/object/functionsIn.md
diff --git a/docs/ja/reference/compat/object/get.md b/docs/ja/compat/reference/object/get.md
similarity index 100%
rename from docs/ja/reference/compat/object/get.md
rename to docs/ja/compat/reference/object/get.md
diff --git a/docs/ja/reference/compat/object/has.md b/docs/ja/compat/reference/object/has.md
similarity index 100%
rename from docs/ja/reference/compat/object/has.md
rename to docs/ja/compat/reference/object/has.md
diff --git a/docs/ja/reference/compat/object/hasIn.md b/docs/ja/compat/reference/object/hasIn.md
similarity index 100%
rename from docs/ja/reference/compat/object/hasIn.md
rename to docs/ja/compat/reference/object/hasIn.md
diff --git a/docs/ja/compat/reference/object/invert.md b/docs/ja/compat/reference/object/invert.md
new file mode 100644
index 000000000..20733f373
--- /dev/null
+++ b/docs/ja/compat/reference/object/invert.md
@@ -0,0 +1,60 @@
+# invert (Lodash 互換性)
+
+::: warning `es-toolkit`の`invert`を使用してください
+
+この`invert`関数はLodash互換性のための複雑な処理により動作が遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[`invert`](../../../reference/object/invert.md)を使用してください。
+
+:::
+
+オブジェクトのキーと値を入れ替えます。
+
+```typescript
+const inverted = invert(object);
+```
+
+## 使用法
+
+### `invert(object)`
+
+オブジェクトのキーと値を入れ替えたい場合は`invert`を使用してください。元のオブジェクトのキーは新しいオブジェクトの値になり、元のオブジェクトの値は新しいオブジェクトのキーになります。
+
+```typescript
+import { invert } from 'es-toolkit/compat';
+
+// 基本的なキー・値の入れ替え
+const object = { a: 1, b: 2, c: 3 };
+invert(object);
+// => { '1': 'a', '2': 'b', '3': 'c' }
+
+// 文字列値の入れ替え
+const colors = { red: '#ff0000', green: '#00ff00', blue: '#0000ff' };
+invert(colors);
+// => { '#ff0000': 'red', '#00ff00': 'green', '#0000ff': 'blue' }
+
+// 混合キーと値のタイプ
+const mixed = { a: 1, 2: 'b', c: 3, 4: 'd' };
+invert(mixed);
+// => { '1': 'a', 'b': '2', '3': 'c', 'd': '4' }
+```
+
+重複した値がある場合、最後のキーが使用されます。
+
+```typescript
+import { invert } from 'es-toolkit/compat';
+
+// 重複した値がある場合
+const object = { a: 1, b: 1, c: 2 };
+invert(object);
+// => { '1': 'b', '2': 'c' }
+// 'a'は上書きされて失われます
+```
+
+#### パラメータ
+
+- `object` (`object`): 入れ替えるオブジェクトです。
+
+#### 戻り値
+
+(`Record`): キーと値が入れ替わった新しいオブジェクトを返します。
diff --git a/docs/ja/reference/compat/object/invertBy.md b/docs/ja/compat/reference/object/invertBy.md
similarity index 100%
rename from docs/ja/reference/compat/object/invertBy.md
rename to docs/ja/compat/reference/object/invertBy.md
diff --git a/docs/ja/reference/compat/object/keys.md b/docs/ja/compat/reference/object/keys.md
similarity index 100%
rename from docs/ja/reference/compat/object/keys.md
rename to docs/ja/compat/reference/object/keys.md
diff --git a/docs/ja/reference/compat/object/keysIn.md b/docs/ja/compat/reference/object/keysIn.md
similarity index 100%
rename from docs/ja/reference/compat/object/keysIn.md
rename to docs/ja/compat/reference/object/keysIn.md
diff --git a/docs/ja/compat/reference/object/mapKeys.md b/docs/ja/compat/reference/object/mapKeys.md
new file mode 100644
index 000000000..172fc5082
--- /dev/null
+++ b/docs/ja/compat/reference/object/mapKeys.md
@@ -0,0 +1,63 @@
+# mapKeys (Lodash 互換性)
+
+::: warning `es-toolkit`の`mapKeys`を使用してください
+
+この `mapKeys` 関数は、`null`や`undefined`の処理、`iteratee`変換過程により相対的に遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[`mapKeys`](../../../reference/object/mapKeys.md)を使用してください。
+
+:::
+
+値をそのままにしてキーを変換し、新しいオブジェクトを作成します。
+
+```typescript
+const result = mapKeys(obj, iteratee);
+```
+
+## 使用法
+
+### `mapKeys(object, iteratee)`
+
+`iteratee`関数を使用してオブジェクト内の各キーを変換し、新しいオブジェクトを作成します。値は変更されず、キーのみが変更されます。オブジェクトのキーを変換または正規化する際に便利です。
+
+```typescript
+import { mapKeys } from 'es-toolkit/compat';
+
+// キーに接頭辞を追加
+const obj = { a: 1, b: 2, c: 3 };
+const result = mapKeys(obj, (value, key) => 'prefix_' + key);
+// 結果: { prefix_a: 1, prefix_b: 2, prefix_c: 3 }
+
+// キーを大文字に変換
+const data = { name: 'John', age: 30 };
+const uppercased = mapKeys(data, (value, key) => key.toUpperCase());
+// 結果: { NAME: 'John', AGE: 30 }
+
+// 配列のインデックスをキーに変換
+const arr = ['apple', 'banana', 'orange'];
+const indexed = mapKeys(arr, (value, index) => `item_${index}`);
+// 結果: { item_0: 'apple', item_1: 'banana', item_2: 'orange' }
+
+// キーと値を組み合わせて新しいキーを生成
+const scores = { math: 90, science: 85, english: 92 };
+const detailed = mapKeys(scores, (value, key) => `${key}_score_${value}`);
+// 結果: { math_score_90: 90, science_score_85: 85, english_score_92: 92 }
+```
+
+`null`または`undefined`は空のオブジェクトとして処理されます。
+
+```typescript
+import { mapKeys } from 'es-toolkit/compat';
+
+mapKeys(null, iteratee); // {}
+mapKeys(undefined, iteratee); // {}
+```
+
+#### パラメータ
+
+- `object` (`ArrayLike | T | null | undefined`): キーを変換するオブジェクトまたは配列です。
+- `iteratee` (`ListIteratee | ObjectIteratee`, オプション): 各キーを変換する関数です。デフォルトは`identity`関数です。
+
+#### 戻り値
+
+(`Record | Record`): 変換されたキーを持つ新しいオブジェクトを返します。
diff --git a/docs/ja/compat/reference/object/mapValues.md b/docs/ja/compat/reference/object/mapValues.md
new file mode 100644
index 000000000..46b0bd979
--- /dev/null
+++ b/docs/ja/compat/reference/object/mapValues.md
@@ -0,0 +1,71 @@
+# mapValues (Lodash 互換性)
+
+::: warning `es-toolkit`の`mapValues`を使用してください
+
+この `mapValues` 関数は、`null`や`undefined`の処理、`iteratee`変換過程により相対的に遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[`mapValues`](../../../reference/object/mapValues.md)を使用してください。
+
+:::
+
+キーをそのままにして値を変換し、新しいオブジェクトを作成します。
+
+```typescript
+const result = mapValues(obj, iteratee);
+```
+
+## 使用法
+
+### `mapValues(object, iteratee)`
+
+`iteratee`関数を使用してオブジェクト内の各値を変換し、新しいオブジェクトを作成します。キーは変更されず、値のみが変更されます。文字列、配列、オブジェクトすべてを処理できます。データを変換または計算する際に便利です。
+
+```typescript
+import { mapValues } from 'es-toolkit/compat';
+
+// オブジェクトの値を変換
+const obj = { a: 1, b: 2, c: 3 };
+const doubled = mapValues(obj, value => value * 2);
+// 結果: { a: 2, b: 4, c: 6 }
+
+// 文字列を大文字に変換
+const names = { first: 'john', last: 'doe' };
+const uppercased = mapValues(names, value => value.toUpperCase());
+// 結果: { first: 'JOHN', last: 'DOE' }
+
+// 文字列の各文字を変換
+const str = 'abc';
+const charMap = mapValues(str, char => char.toUpperCase());
+// 結果: { '0': 'A', '1': 'B', '2': 'C' }
+
+// 配列をオブジェクトに変換
+const arr = [10, 20, 30];
+const arrMap = mapValues(arr, (value, index) => value + index);
+// 結果: { '0': 10, '1': 21, '2': 32 }
+
+// プロパティパスで値を抽出
+const users = {
+ user1: { profile: { name: 'Alice' } },
+ user2: { profile: { name: 'Bob' } },
+};
+const userNames = mapValues(users, 'profile.name');
+// 結果: { user1: 'Alice', user2: 'Bob' }
+```
+
+`null`または`undefined`は空のオブジェクトとして処理されます。
+
+```typescript
+import { mapValues } from 'es-toolkit/compat';
+
+mapValues(null, iteratee); // {}
+mapValues(undefined, iteratee); // {}
+```
+
+#### パラメータ
+
+- `object` (`string | T[] | T | null | undefined`): 値を変換するオブジェクト、配列、または文字列です。
+- `iteratee` (`ValueIteratee`, オプション): 各値を変換する関数、プロパティパス、またはマッチングオブジェクトです。デフォルトは`identity`関数です。
+
+#### 戻り値
+
+(`Record | { [P in keyof T]: U } | Record | Record | Partial`): 変換された値を持つ新しいオブジェクトを返します。
diff --git a/docs/ja/compat/reference/object/merge.md b/docs/ja/compat/reference/object/merge.md
new file mode 100644
index 000000000..2915f1434
--- /dev/null
+++ b/docs/ja/compat/reference/object/merge.md
@@ -0,0 +1,82 @@
+# merge (Lodash 互換性)
+
+::: warning `es-toolkit`の`merge`を使用してください
+
+この `merge` 関数は、内部的に複雑な `mergeWith` 関数を呼び出すため相対的に遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[`merge`](../../../reference/object/merge.md)を使用してください。
+
+:::
+
+複数のオブジェクトを深くマージして1つのオブジェクトにします。
+
+```typescript
+const result = merge(target, ...sources);
+```
+
+## 使用法
+
+### `merge(object, ...sources)`
+
+ターゲットオブジェクトに1つ以上のソースオブジェクトを深くマージします。ネストされたオブジェクトと配列は再帰的にマージされます。ソースオブジェクトのプロパティが`undefined`の場合、ターゲットオブジェクトの既存の値は上書きされません。オブジェクト設定のマージやデフォルト値の適用に便利です。
+
+```typescript
+import { merge } from 'es-toolkit/compat';
+
+// 基本的なオブジェクトのマージ
+const target = { a: 1, b: { x: 1, y: 2 } };
+const source = { b: { y: 3, z: 4 }, c: 5 };
+const result = merge(target, source);
+// 結果: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+
+// 配列のマージ
+const obj1 = { arr: [1, 2] };
+const obj2 = { arr: [3, 4] };
+const merged = merge(obj1, obj2);
+// 結果: { arr: [3, 4] } (配列は置き換えられる)
+
+// 複数のオブジェクトをマージ
+const base = { a: 1 };
+const ext1 = { b: 2 };
+const ext2 = { c: 3 };
+const ext3 = { d: 4 };
+const combined = merge(base, ext1, ext2, ext3);
+// 結果: { a: 1, b: 2, c: 3, d: 4 }
+
+// ネストされたオブジェクトのマージ
+const config = {
+ api: { url: 'https://api.example.com', timeout: 5000 },
+ features: { auth: true },
+};
+const overrides = {
+ api: { timeout: 10000, retries: 3 },
+ features: { analytics: true },
+};
+const finalConfig = merge(config, overrides);
+// 結果: {
+// api: { url: 'https://api.example.com', timeout: 10000, retries: 3 },
+// features: { auth: true, analytics: true }
+// }
+```
+
+ターゲットオブジェクトは変更されるため、元を保持したい場合は空のオブジェクトを使用してください。
+
+```typescript
+import { merge } from 'es-toolkit/compat';
+
+const original = { a: 1, b: { x: 1 } };
+const source = { b: { y: 2 } };
+
+// 元を保持
+const result = merge({}, original, source);
+// original は変更されない
+```
+
+#### パラメータ
+
+- `object` (`any`): マージ先となるターゲットオブジェクトです。このオブジェクトは変更されます。
+- `...sources` (`any[]`): マージするソースオブジェクトです。
+
+#### 戻り値
+
+(`any`): マージされたターゲットオブジェクトを返します。
diff --git a/docs/ja/compat/reference/object/mergeWith.md b/docs/ja/compat/reference/object/mergeWith.md
new file mode 100644
index 000000000..2aec630e0
--- /dev/null
+++ b/docs/ja/compat/reference/object/mergeWith.md
@@ -0,0 +1,94 @@
+# mergeWith (Lodash 互換性)
+
+::: warning `es-toolkit`の`mergeWith`を使用してください
+
+この `mergeWith` 関数は、複雑な型チェック、循環参照処理、特殊オブジェクト処理により相対的に遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[`mergeWith`](../../../reference/object/mergeWith.md)を使用してください。
+
+:::
+
+カスタマイザー関数でマージ方法を制御しながら、複数のオブジェクトを深くマージします。
+
+```typescript
+const result = mergeWith(target, ...sources, customizer);
+```
+
+## 使用法
+
+### `mergeWith(object, ...sources, customizer)`
+
+ターゲットオブジェクトに1つ以上のソースオブジェクトを深くマージしますが、カスタマイザー関数でマージ方法を制御します。カスタマイザー関数が`undefined`を返す場合、デフォルトのマージロジックが使用されます。配列の連結や特別なマージルールが必要な場合に便利です。
+
+```typescript
+import { mergeWith } from 'es-toolkit/compat';
+
+// 数値を加算
+const obj1 = { a: 1, b: 2 };
+const obj2 = { b: 3, c: 4 };
+const result = mergeWith(obj1, obj2, (objValue, srcValue) => {
+ if (typeof objValue === 'number' && typeof srcValue === 'number') {
+ return objValue + srcValue;
+ }
+});
+// 結果: { a: 1, b: 5, c: 4 }
+
+// 配列を連結
+const arr1 = { items: [1, 2] };
+const arr2 = { items: [3, 4] };
+const merged = mergeWith(arr1, arr2, (objValue, srcValue) => {
+ if (Array.isArray(objValue)) {
+ return objValue.concat(srcValue);
+ }
+});
+// 結果: { items: [1, 2, 3, 4] }
+
+// 文字列を連結
+const str1 = { message: 'Hello' };
+const str2 = { message: 'World' };
+const combined = mergeWith(str1, str2, (objValue, srcValue, key) => {
+ if (key === 'message' && typeof objValue === 'string') {
+ return objValue + ' ' + srcValue;
+ }
+});
+// 結果: { message: 'Hello World' }
+
+// 複数のソースオブジェクトとカスタマイザー
+const base = { scores: [80] };
+const quiz1 = { scores: [90] };
+const quiz2 = { scores: [85] };
+const final = mergeWith(base, quiz1, quiz2, (objValue, srcValue) => {
+ if (Array.isArray(objValue)) {
+ return objValue.concat(srcValue);
+ }
+});
+// 結果: { scores: [80, 90, 85] }
+```
+
+カスタマイザー関数は様々なパラメータを受け取ります。
+
+```typescript
+import { mergeWith } from 'es-toolkit/compat';
+
+const customizer = (objValue, srcValue, key, object, source, stack) => {
+ console.log('マージ中:', key, objValue, '->', srcValue);
+
+ // 特定のキーに対してのみカスタマイズ
+ if (key === 'specialField') {
+ return `${objValue}_${srcValue}`;
+ }
+
+ // undefinedを返すとデフォルトのマージロジックを使用
+ return undefined;
+};
+```
+
+#### パラメータ
+
+- `object` (`any`): マージ先となるターゲットオブジェクトです。このオブジェクトは変更されます。
+- `...sources` (`any[]`): マージするソースオブジェクトです。
+- `customizer` (`MergeWithCustomizer`): 値の割り当てをカスタマイズする関数です。形式: `(objValue, srcValue, key, object, source, stack) => any`。
+
+#### 戻り値
+
+(`any`): マージされたターゲットオブジェクトを返します。
diff --git a/docs/ja/compat/reference/object/omit.md b/docs/ja/compat/reference/object/omit.md
new file mode 100644
index 000000000..33544cf99
--- /dev/null
+++ b/docs/ja/compat/reference/object/omit.md
@@ -0,0 +1,82 @@
+# omit (Lodash 互換性)
+
+::: warning `es-toolkit`の`omit`を使用してください
+
+この `omit` 関数は、深いコピーと `unset` 関数の呼び出しにより相対的に遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[`omit`](../../../reference/object/omit.md)を使用してください。
+
+:::
+
+オブジェクトから指定されたキーを除外した新しいオブジェクトを作成します。
+
+```typescript
+const result = omit(obj, ...keys);
+```
+
+## 使用法
+
+### `omit(object, ...paths)`
+
+オブジェクトから指定されたキーを除外した新しいオブジェクトを作成します。深いキーパスをサポートし、配列を使用して一度に複数のキーを指定することもできます。オブジェクトから機密情報を削除したり、必要なプロパティのみを選択する際に便利です。
+
+```typescript
+import { omit } from 'es-toolkit/compat';
+
+// 基本的なキーの削除
+const user = { id: 1, name: 'John', email: 'john@example.com', password: 'secret' };
+const publicUser = omit(user, 'password', 'email');
+// 結果: { id: 1, name: 'John' }
+
+// 配列で複数のキーを削除
+const data = { a: 1, b: 2, c: 3, d: 4 };
+const filtered = omit(data, ['a', 'c']);
+// 結果: { b: 2, d: 4 }
+
+// 深いキーパスの削除
+const nested = {
+ user: { profile: { name: 'John', age: 30 }, settings: { theme: 'dark' } },
+ admin: true,
+};
+const result = omit(nested, 'user.profile.age', 'admin');
+// 結果: { user: { profile: { name: 'John' }, settings: { theme: 'dark' } } }
+
+// ネストされた配列とキーの組み合わせ
+const complex = { a: 1, b: 2, c: 3, d: { e: 4, f: 5 } };
+const simplified = omit(complex, 'a', ['b', 'c'], 'd.f');
+// 結果: { d: { e: 4 } }
+```
+
+配列、文字列、キーパスを自由に組み合わせることができます。
+
+```typescript
+import { omit } from 'es-toolkit/compat';
+
+const config = {
+ api: { url: 'https://api.example.com', key: 'secret', timeout: 5000 },
+ ui: { theme: 'dark', language: 'en' },
+ debug: true,
+};
+
+// 複数の方法でキーを指定
+const cleaned = omit(config, 'api.key', ['debug'], 'ui.language');
+// 結果: { api: { url: 'https://api.example.com', timeout: 5000 }, ui: { theme: 'dark' } }
+```
+
+`null`または`undefined`は空のオブジェクトとして処理されます。
+
+```typescript
+import { omit } from 'es-toolkit/compat';
+
+omit(null, 'key'); // {}
+omit(undefined, 'key'); // {}
+```
+
+#### パラメータ
+
+- `object` (`T | null | undefined`): キーを削除する元のオブジェクトです。
+- `...paths` (`Array>`): 削除するキーです。単一のキー、キーの配列、または深いキーパスを指定できます。
+
+#### 戻り値
+
+(`Partial`): 指定されたキーが削除された新しいオブジェクトを返します。
diff --git a/docs/ja/compat/reference/object/omitBy.md b/docs/ja/compat/reference/object/omitBy.md
new file mode 100644
index 000000000..6ffc9451a
--- /dev/null
+++ b/docs/ja/compat/reference/object/omitBy.md
@@ -0,0 +1,76 @@
+# omitBy (Lodash 互換性)
+
+::: warning `es-toolkit`の`omitBy`を使用してください
+
+この `omitBy` 関数は、配列様オブジェクトのチェック、`iteratee`変換、キー変換過程により相対的に遅くなります。
+
+代わりに、より高速で現代的な`es-toolkit`の[`omitBy`](../../../reference/object/omitBy.md)を使用してください。
+
+:::
+
+述語関数がtrueを返すプロパティを除外した新しいオブジェクトを作成します。
+
+```typescript
+const result = omitBy(obj, predicate);
+```
+
+## 使用法
+
+### `omitBy(object, predicate)`
+
+オブジェクトの各プロパティに対して述語関数を実行し、述語がtrueを返すプロパティを除外した新しいオブジェクトを作成します。条件に基づいてプロパティを動的にフィルタリングする際に便利です。
+
+```typescript
+import { omitBy } from 'es-toolkit/compat';
+
+// 特定の型の値を削除
+const data = { a: 1, b: 'remove', c: 3, d: 'keep' };
+const numbers = omitBy(data, value => typeof value === 'string');
+// 結果: { a: 1, c: 3 }
+
+// 条件に基づいてプロパティを削除
+const user = { id: 1, name: 'John', age: 0, active: false, email: '' };
+const validData = omitBy(user, value => !value);
+// 結果: { id: 1, name: 'John' } (偽値を削除)
+
+// キー名でフィルタリング
+const settings = { userSetting: true, adminSetting: false, debugMode: true };
+const userOnly = omitBy(settings, (value, key) => key.startsWith('admin'));
+// 結果: { userSetting: true, debugMode: true }
+
+// 数値プロパティのみ削除
+const mixed = { str: 'hello', num1: 42, bool: true, num2: 0, obj: {} };
+const noNumbers = omitBy(mixed, value => typeof value === 'number');
+// 結果: { str: 'hello', bool: true, obj: {} }
+
+// 配列でも使用可能
+const arr = [1, 2, 3, 4, 5];
+const filtered = omitBy(arr, value => value % 2 === 0);
+// 結果: { '0': 1, '2': 3, '4': 5 } (偶数インデックスの奇数値)
+
+// 値、キー、元のオブジェクトをすべて活用
+const scores = { math: 90, science: 75, english: 85, art: 60 };
+const passingGrades = omitBy(scores, (value, key, obj) => {
+ console.log(`${key}: ${value} (平均: ${Object.values(obj).reduce((a, b) => a + b) / Object.keys(obj).length})`);
+ return value < 80;
+});
+// 結果: { math: 90, english: 85 }
+```
+
+`null`または`undefined`は空のオブジェクトとして処理されます。
+
+```typescript
+import { omitBy } from 'es-toolkit/compat';
+
+omitBy(null, () => true); // {}
+omitBy(undefined, () => true); // {}
+```
+
+#### パラメータ
+
+- `object` (`Record | Record | object | null | undefined`): フィルタリングする元のオブジェクトです。
+- `predicate` (`ValueKeyIteratee | ValueKeyIteratee`, オプション): 各プロパティに対して実行する述語関数です。これがtrueを返すプロパティは削除されます。デフォルトは`identity`関数です。
+
+#### 戻り値
+
+(`Record | Record | Partial