i18n-smell-detector 0.1.0 → 0.2.0

package/README.md

@@ -1,17 +1,20 @@
 # i18n-smell-detector
 
-`i18n-smell-detector` identifies potential "stale" translations in your localization files. It flags keys where the translated value is identical to the base locale, which often indicates that a string was never actually translated.
+[![npm version](https://img.shields.io/npm/v/i18n-smell-detector.svg)](https://www.npmjs.com/package/i18n-smell-detector)
+[![CI](https://github.com/xue-moe/i18n-smell-detector/actions/workflows/ci.yml/badge.svg)](https://github.com/xue-moe/i18n-smell-detector/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 
-## Features
-
-- Smart Detection: Categorizes identical translations based on length and content (words vs. phrases).
+Find locale values copied from the base locale.
 
-- Flexible Whitelisting: Exclude brand names, protocol codes, or common UI labels via configuration.
+`i18n-smell-detector` checks localization files for keys whose translated value is identical to the base locale. This can help catch entries that were copied as placeholders and never translated.
 
-- CI Integration: Configurable failure thresholds (`fail-on`) for build pipelines.
-
-- Multiple Output Formats: Supports console, JSON, and Markdown.
+## Features
 
+- Detect values that are identical to the base locale
+- Ignore expected matches by key or value
+- Classify findings as `high`, `medium`, `low`, or `ignored`
+- Output results as console text, JSON, or Markdown
+- Fail CI based on a configurable severity level
 
 ## Install
 
@@ -19,14 +22,6 @@
 npm install -D i18n-smell-detector
 ```
 
-For local development:
-
-```bash
-npm install
-npm test
-npm run check
-```
-
 ## Usage
 
 Run the check:
@@ -35,26 +30,31 @@ Run the check:
 npx i18n-smell-detector check-identical --config i18n-smell.config.mjs
 ```
 
-Output Options:
+Output formats:
 
 ```bash
-# Default output is console
 npx i18n-smell-detector check-identical --format console
 npx i18n-smell-detector check-identical --format json
 npx i18n-smell-detector check-identical --format markdown
 ```
 
-### CI/CD Integration
+## CI usage
+
+Use `--fail-on` to choose the lowest severity that should make the command exit with code `1`.
 
-Set the severity level that causes the process to exit with an error:
+```bash
+npx i18n-smell-detector check-identical --config i18n-smell.config.mjs --fail-on high
+```
+
+For a new project, it is often easier to start in reporting mode while tuning allowlists:
 
 ```bash
-npx i18n-smell-detector check-identical --fail-on high
-npx i18n-smell-detector check-identical --fail-on medium
-npx i18n-smell-detector check-identical --fail-on none
+npx i18n-smell-detector check-identical --config i18n-smell.config.mjs --fail-on none
 ```
 
-## Configuration(`i18n-smell.config.mjs`)
+## Configuration
+
+Create `i18n-smell.config.mjs`:
 
 ```js
 export default {
@@ -62,36 +62,58 @@ export default {
   locales: {
     en: './src/locales/en.json',
     zh: './src/locales/zh.json',
-    ja: './src/locales/ja.json',
-    ko: './src/locales/ko.json',
-    fr: './src/locales/fr.json',
-    // ...
+    ja: './src/locales/ja.json'
   },
 
-  // Whitelist specific keys
   allowIdenticalKeys: [
     'brand.*',
-    'protocol.*',
+    /^protocol\./,
     'common.ok',
     'common.id'
   ],
-  
-  // Whitelist specific values
+
   allowIdenticalValues: [
     'OK',
     'ID',
-    'HTTP',
+    /^HTTP\/\d(\.\d)?$/,
     'API',
     'GET',
     'POST'
   ],
 
-  ignoreSameLanguageFamily: true, // Ignore en -> en-GB
-  trimWhitespace: true, // Trim and compare
+  placeholderPatterns: [
+    '\\{[^}]+\\}',
+    '\\{\\{[^}]+\\}\\}',
+    '%[sdif]',
+    '%\\([^)]+\\)[sdif]',
+    '\\$\\d+'
+  ],
+
+  ignoreCodeLike: true,
+  ignoreSameLanguageFamily: true,
+  trimWhitespace: true,
+  ignoreCase: false,
+  includeIgnored: false,
   failOn: 'high'
 };
 ```
 
+### Configuration reference
+
+| Option | Type | Default | Description |
+|---|---|---:|---|
+| `baseLocale` | `string` | `'en'` | Locale used as the comparison source. It must also be listed in `locales`. |
+| `locales` | `Record<string, string>` | `{}` | Map of locale codes to JSON locale file paths. Relative paths are resolved from the config file directory. |
+| `allowIdenticalKeys` | `(string \| RegExp)[]` | `[]` | Key rules that are allowed to match the base locale. String rules support `*` wildcards, for example `brand.*`. `RegExp` rules are tested against the flattened key. |
+| `allowIdenticalValues` | `(string \| RegExp)[]` | `[]` | Value rules that are allowed to match the base locale. String rules are exact matches, for example `OK`, `API`, or `GET`. `RegExp` rules are tested against the full value. |
+| `placeholderPatterns` | `(string \| RegExp)[]` | `{...}` and `{{...}}` patterns | Placeholder patterns ignored when the whole value is only placeholders and whitespace. String entries must be valid regular expression sources. |
+| `ignoreCodeLike` | `boolean` | `true` | Ignore built-in code-like values such as paths, colors, acronyms, and identifiers. Set to `false` to report them. |
+| `failOn` | `'high' \| 'medium' \| 'low' \| 'none'` | `'high'` | Lowest severity that makes the CLI exit with code `1`. Use `none` to report without failing. |
+| `trimWhitespace` | `boolean` | `true` | Trim leading and trailing whitespace before comparing values. |
+| `ignoreCase` | `boolean` | `false` | Compare values case-insensitively when set to `true`. |
+| `ignoreSameLanguageFamily` | `boolean` | `true` | Ignore regional variants that share the same language family, such as `en` and `en-GB`. Set to `false` to check regional variants too. |
+| `includeIgnored` | `boolean` | `false` | Include ignored findings in reports. Can also be enabled with `--include-ignored`. |
+
 ## Example output
 
 ```txt
@@ -111,21 +133,124 @@ MEDIUM ja.form.search
   reason: copied English word
 ```
 
-## Detection Rules
+## JSON output
+
+`--format json` prints an object with a `summary` and an `issues` array:
+
+```json
+{
+  "summary": {
+    "high": 1,
+    "medium": 0,
+    "low": 0,
+    "ignored": 16
+  },
+  "issues": [
+    {
+      "key": "home.welcome",
+      "baseLocale": "en",
+      "targetLocale": "zh",
+      "value": "Welcome back",
+      "severity": "high",
+      "reason": "copied English phrase"
+    }
+  ]
+}
+```
+
+Fields:
+
+Summary counts include all findings, including ignored findings that may be omitted from the visible `issues` array.
+
+| Field | Type | Description |
+|---|---|---|
+| `key` | `string` | Flattened locale key, such as `settings.profile.title`. |
+| `baseLocale` | `string` | Locale being compared from. |
+| `targetLocale` | `string` | Locale being checked. |
+| `value` | `string` | Identical target value. |
+| `severity` | `'high' \| 'medium' \| 'low' \| 'ignored'` | Classification assigned by the detection rules. |
+| `reason` | `string` | Short explanation for the classification. |
+
+Ignored issues are omitted by default. Pass `--include-ignored` to include them in JSON, console, or Markdown output.
+
+## Exit codes
+
+| Code | Meaning |
+|---:|---|
+| `0` | Completed successfully and no visible issue reached the configured `failOn` threshold. |
+| `1` | Completed successfully, but at least one visible issue reached the configured `failOn` threshold. |
+| `2` | Runtime or configuration error, such as a missing config file, missing locale file, invalid JSON, or unsupported CLI option. |
+
+## Detection rules
 
 | Case | Level |
 |---|---|
 | Key matches `allowIdenticalKeys` | ignored |
 | Value matches `allowIdenticalValues` | ignored |
-| Same language family (e.g., en, en-GB) | ignored |
-| URLs, path, color, or code-like value | ignored |
-| Placeholder-only value (e.g., `{count}`) | ignored |
+| Same language family, such as `en` and `en-GB` | ignored |
+| Placeholder-only value, such as `{count}` | ignored |
+| URL, path, color, or code-like value | ignored by default |
 | Short common label | low |
 | Single English word | medium |
 | English phrase | high |
 
+## False positive tuning
+
+Identical text is sometimes intentional. Start by running the detector in reporting mode, then allow known names, protocol terms, short labels, and other strings that should stay the same across languages.
+
+```js
+export default {
+  baseLocale: 'en',
+  locales: {
+    en: './src/locales/en.json',
+    zh: './src/locales/zh.json'
+  },
+  allowIdenticalKeys: [
+    'brand.*',
+    'legal.name',
+    /^protocol\./
+  ],
+  allowIdenticalValues: [
+    'OK',
+    'ID',
+    'API',
+    /^HTTP\/\d(\.\d)?$/
+  ],
+  placeholderPatterns: [
+    '\\{[^}]+\\}',
+    '\\{\\{[^}]+\\}\\}',
+    '%[sdif]',
+    '%\\([^)]+\\)[sdif]'
+  ],
+  failOn: 'high'
+};
+```
+
+Useful tuning patterns:
+
+- Use `allowIdenticalKeys` for groups of expected identical values, such as names, legal labels, and protocol keys.
+- Use string `allowIdenticalKeys` entries for exact or wildcard key matches, and `RegExp` entries for broader key families.
+- Use string `allowIdenticalValues` entries for exact shared labels, and `RegExp` entries for structured values such as `HTTP/2`.
+- Add `placeholderPatterns` for framework-specific placeholders such as `%s`, `%(name)s`, or `$1`. Mixed content such as `Total: {count}` is still reported.
+- Set `ignoreCodeLike: false` if paths, colors, acronyms, or identifiers should be shown as findings.
+- Set `ignoreSameLanguageFamily: false` if you want to check regional variants such as `en-GB`, `en-AU`, or `pt-BR`.
+- Set `failOn: 'none'` while tuning a new project, then raise it to `high` or `medium` once the allowlist is stable.
+- Pass `--include-ignored` when reviewing why a value was ignored.
+
 ## Notes
 
-- ***Not a coverage checker***: This tool only reports keys that exist in both files but have identical values; it does not check for missing keys.
+- This is not a coverage checker. It only reports keys that exist in both files and have identical values.
+- The rules are conservative. Tune `allowIdenticalKeys` and `allowIdenticalValues` before making this a required CI step.
+- Only string values are checked. Non-string locale values are ignored.
+
+## Development
+
+```bash
+npm install
+npm test
+npm run check
+```
+
+## License
 
-- ***Conservative by design***: The rules are conservative. Tune `allowIdenticalKeys` and `allowIdenticalValues` before making this a mandatory step in your CI pipeline.
+MIT

package/package.json

@@ -1,11 +1,19 @@
 {
   "name": "i18n-smell-detector",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Find locale values copied from the base locale.",
   "type": "module",
   "bin": {
     "i18n-smell-detector": "./bin/i18n-smell-detector.js"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xue-moe/i18n-smell-detector.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xue-moe/i18n-smell-detector/issues"
+  },
+  "homepage": "https://github.com/xue-moe/i18n-smell-detector#readme",
   "files": [
     "bin",
     "src",
@@ -13,7 +21,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "check": "node ./bin/i18n-smell-detector.js check-identical --config ./examples/vue-vite/i18n-smell.config.mjs",
+    "check": "node ./bin/i18n-smell-detector.js check-identical --config ./examples/vue-vite/i18n-smell.config.mjs --fail-on none",
     "test": "node --test"
   },
   "keywords": [

package/src/cli.js

@@ -6,7 +6,7 @@ import { renderReport } from './reporters/index.js';
 import { failRank, severityRank } from './severity.js';
 
 const HELP = `
-i18n-smell-detector v0.1
+i18n-smell-detector v0.1.1
 
 Usage:
   i18n-smell-detector check-identical [options]

package/src/config.js

@@ -12,6 +12,11 @@ const CONFIG_FILES = [
   'i18n-smell.config.json',
 ];
 
+const DEFAULT_PLACEHOLDER_PATTERNS = [
+  String.raw`\{\{[^}]+\}\}`,
+  String.raw`\{[^}]+\}`,
+];
+
 async function exists(filePath) {
   try {
     await access(filePath);
@@ -56,24 +61,33 @@ function validateConfig(config) {
   }
 
   const candidate = /** @type {Record<string, unknown>} */ (config);
-  if (typeof candidate.baseLocale !== 'string' || !candidate.baseLocale) {
-    throw new Error('Config must include baseLocale');
+  if ('baseLocale' in candidate && (typeof candidate.baseLocale !== 'string' || !candidate.baseLocale)) {
+    throw new Error('Config baseLocale must be a non-empty string');
   }
 
-  if (!candidate.locales || typeof candidate.locales !== 'object' || Array.isArray(candidate.locales)) {
-    throw new Error('Config must include locales as an object');
+  if ('locales' in candidate && (!candidate.locales || typeof candidate.locales !== 'object' || Array.isArray(candidate.locales))) {
+    throw new Error('Config locales must be an object');
   }
 
-  for (const [locale, value] of Object.entries(candidate.locales)) {
+  for (const [locale, value] of Object.entries(candidate.locales || {})) {
     if (typeof value !== 'string' || !value) {
       throw new Error(`Config locales.${locale} must be a file path string`);
     }
   }
+
+  validateRuleList(candidate.allowIdenticalKeys, 'allowIdenticalKeys');
+  validateRuleList(candidate.allowIdenticalValues, 'allowIdenticalValues');
+
+  if ('placeholderPatterns' in candidate && !Array.isArray(candidate.placeholderPatterns)) {
+    throw new Error('Config placeholderPatterns must be an array of strings or RegExp objects');
+  }
 }
 
 /** @param {import('./types.js').DetectorConfig} config */
 function withDefaults(config) {
   return {
+    baseLocale: 'en',
+    locales: {},
     allowIdenticalKeys: [],
     allowIdenticalValues: [],
     ignoreSameLanguageFamily: true,
@@ -82,5 +96,39 @@ function withDefaults(config) {
     includeIgnored: false,
     failOn: 'high',
     ...config,
+    placeholderPatterns: normalizePlaceholderPatterns(config.placeholderPatterns || DEFAULT_PLACEHOLDER_PATTERNS),
+    ignoreCodeLike: config.ignoreCodeLike ?? true,
   };
 }
+
+function validateRuleList(rules, name) {
+  if (rules === undefined) return;
+  if (!Array.isArray(rules)) throw new Error(`Config ${name} must be an array`);
+
+  for (const rule of rules) {
+    if (typeof rule !== 'string' && !(rule instanceof RegExp)) {
+      throw new Error(`Config ${name} entries must be strings or RegExp objects`);
+    }
+  }
+}
+
+function normalizePlaceholderPatterns(patterns) {
+  return patterns.map((pattern) => {
+    if (pattern instanceof RegExp) return withGlobalFlag(pattern);
+
+    if (typeof pattern !== 'string') {
+      throw new Error('Config placeholderPatterns entries must be strings or RegExp objects');
+    }
+
+    try {
+      return new RegExp(pattern, 'g');
+    } catch (error) {
+      throw new Error(`Invalid placeholder pattern "${pattern}": ${error.message}`);
+    }
+  });
+}
+
+function withGlobalFlag(pattern) {
+  const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+  return new RegExp(pattern.source, flags);
+}

package/src/locale/load-locales.js

@@ -2,13 +2,28 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { flattenLocale } from './flatten-locale.js';
 
-async function readJson(filePath) {
-  const text = await readFile(filePath, 'utf8');
+function readErrorReason(error) {
+  if (error && typeof error === 'object' && 'code' in error) {
+    if (error.code === 'ENOENT') return 'file not found';
+    if (error.code === 'EACCES') return 'permission denied';
+  }
+
+  return error instanceof Error ? error.message : String(error);
+}
+
+async function readJson(filePath, displayPath = filePath) {
+  let text;
+  try {
+    text = await readFile(filePath, 'utf8');
+  } catch (error) {
+    throw new Error(`Failed to read locale file: ${displayPath}\nReason: ${readErrorReason(error)}`);
+  }
+
   try {
     return JSON.parse(text);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse ${filePath}: ${message}`);
+    throw new Error(`Failed to parse locale file: ${displayPath}\nReason: ${message}`);
   }
 }
 
@@ -21,7 +36,7 @@ export async function loadFlattenedLocales(config, cwd) {
 
   for (const [locale, localePath] of Object.entries(config.locales || {})) {
     const absolutePath = path.isAbsolute(localePath) ? localePath : path.resolve(cwd, localePath);
-    locales[locale] = flattenLocale(await readJson(absolutePath));
+    locales[locale] = flattenLocale(await readJson(absolutePath, localePath));
   }
 
   if (!locales[config.baseLocale]) {

package/src/reporters/console.js

@@ -1,3 +1,5 @@
+import { summarizeIssues } from './summary.js';
+
 function color(code, text) {
   if (process.env.NO_COLOR) return text;
   return `\u001b[${code}m${text}\u001b[0m`;
@@ -17,7 +19,7 @@ function preview(value) {
 
 export function renderConsoleReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
-  const counts = countBySeverity(issues);
+  const counts = summarizeIssues(issues);
   const lines = [
     color('1', 'i18n-smell-detector: identical translations'),
     `high=${counts.high} medium=${counts.medium} low=${counts.low} ignored=${counts.ignored}`,
@@ -37,13 +39,3 @@ export function renderConsoleReport(issues, options) {
 
   return lines.join('\n');
 }
-
-function countBySeverity(issues) {
-  return issues.reduce(
-    (acc, issue) => {
-      acc[issue.severity] += 1;
-      return acc;
-    },
-    { high: 0, medium: 0, low: 0, ignored: 0 }
-  );
-}

package/src/reporters/json.js

@@ -1,4 +1,6 @@
+import { summarizeIssues } from './summary.js';
+
 export function renderJsonReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
-  return `${JSON.stringify({ issues: visible }, null, 2)}\n`;
+  return `${JSON.stringify({ summary: summarizeIssues(issues), issues: visible }, null, 2)}\n`;
 }

package/src/reporters/markdown.js

@@ -1,10 +1,18 @@
+import { summarizeIssues } from './summary.js';
+
 function escapeCell(value) {
   return String(value).replace(/\|/g, '\\|').replace(/\n/g, '<br>');
 }
 
 export function renderMarkdownReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
-  const lines = ['# Identical translations', ''];
+  const summary = summarizeIssues(issues);
+  const lines = [
+    '# Identical translations',
+    '',
+    `high=${summary.high} medium=${summary.medium} low=${summary.low} ignored=${summary.ignored}`,
+    '',
+  ];
 
   if (visible.length === 0) {
     lines.push('No copied base-locale values found.');

package/src/reporters/summary.js

@@ -0,0 +1,9 @@
+export function summarizeIssues(issues) {
+  return issues.reduce(
+    (summary, issue) => {
+      summary[issue.severity] += 1;
+      return summary;
+    },
+    { high: 0, medium: 0, low: 0, ignored: 0 }
+  );
+}

package/src/rules/classify-identical.js

@@ -1,4 +1,4 @@
-import { matchesAnyPattern } from './match-pattern.js';
+import { matchesAnyRule } from './match-rule.js';
 
 function isBlank(value) {
   return value.trim().length === 0;
@@ -18,12 +18,17 @@ function isCodeLike(value) {
     || (/^[a-z0-9_.:-]+$/.test(text) && !/\s/.test(text) && !/[A-Z]/.test(text));
 }
 
-function isPlaceholderOnly(value) {
-  const text = value
-    .replace(/\{\{\s*[^}]+\s*\}\}/g, '')
-    .replace(/\{\s*[^}]+\s*\}/g, '')
-    .replace(/[\s\p{P}\p{S}]/gu, '');
-  return text.length === 0;
+function isPlaceholderOnly(value, patterns) {
+  let text = value.trim();
+
+  const orderedPatterns = [...(patterns || [])].sort((a, b) => b.source.length - a.source.length);
+
+  for (const pattern of orderedPatterns) {
+    pattern.lastIndex = 0;
+    text = text.replace(pattern, '');
+  }
+
+  return text.trim() === '';
 }
 
 function getLatinWords(value) {
@@ -49,22 +54,22 @@ function isShortCommonLabel(value) {
  * @returns {{ severity: import('../types.js').Severity, reason: string }}
  */
 export function classifyIdentical({ key, value, baseLocale, targetLocale, config }) {
-  if ((config.ignoreSameLanguageFamily ?? true) && languageFamily(baseLocale) === languageFamily(targetLocale)) {
-    return { severity: 'ignored', reason: 'same language family' };
-  }
-
-  if (matchesAnyPattern(key, config.allowIdenticalKeys || [])) {
+  if (matchesAnyRule(key, config.allowIdenticalKeys || [], { wildcard: true })) {
     return { severity: 'ignored', reason: 'allowed key' };
   }
 
-  if ((config.allowIdenticalValues || []).includes(value)) {
+  if (matchesAnyRule(value, config.allowIdenticalValues || [])) {
     return { severity: 'ignored', reason: 'allowed value' };
   }
 
+  if ((config.ignoreSameLanguageFamily ?? true) && languageFamily(baseLocale) === languageFamily(targetLocale)) {
+    return { severity: 'ignored', reason: 'same language family' };
+  }
+
   if (isBlank(value)) return { severity: 'ignored', reason: 'blank value' };
+  if (isPlaceholderOnly(value, config.placeholderPatterns || [])) return { severity: 'ignored', reason: 'placeholder only' };
   if (isExternalReference(value)) return { severity: 'ignored', reason: 'external reference' };
-  if (isPlaceholderOnly(value)) return { severity: 'ignored', reason: 'placeholder only' };
-  if (isCodeLike(value)) return { severity: 'ignored', reason: 'code-like value' };
+  if ((config.ignoreCodeLike ?? true) && isCodeLike(value)) return { severity: 'ignored', reason: 'code-like value' };
   if (isShortCommonLabel(value)) return { severity: 'low', reason: 'short common label' };
 
   const words = getLatinWords(value);

package/src/rules/match-pattern.js

@@ -1,8 +1,5 @@
-function patternToRegExp(pattern) {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-  return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
-}
+import { matchesAnyRule } from './match-rule.js';
 
 export function matchesAnyPattern(value, patterns = []) {
-  return patterns.some((pattern) => patternToRegExp(pattern).test(value));
+  return matchesAnyRule(value, patterns, { wildcard: true });
 }

package/src/rules/match-rule.js

@@ -0,0 +1,21 @@
+function wildcardToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
+}
+
+function testRegExp(value, pattern) {
+  pattern.lastIndex = 0;
+  return pattern.test(value);
+}
+
+export function matchesRule(value, rule, options = {}) {
+  if (rule instanceof RegExp) return testRegExp(value, rule);
+  if (typeof rule !== 'string') return false;
+
+  if (options.wildcard) return wildcardToRegExp(rule).test(value);
+  return value === rule;
+}
+
+export function matchesAnyRule(value, rules = [], options = {}) {
+  return rules.some((rule) => matchesRule(value, rule, options));
+}

package/src/types.js

@@ -5,8 +5,10 @@
  * @typedef {Object} DetectorConfig
  * @property {string} baseLocale
  * @property {Record<string, string>} locales
- * @property {string[]=} allowIdenticalKeys
- * @property {string[]=} allowIdenticalValues
+ * @property {(string | RegExp)[]=} allowIdenticalKeys
+ * @property {(string | RegExp)[]=} allowIdenticalValues
+ * @property {(string | RegExp)[]=} placeholderPatterns
+ * @property {boolean=} ignoreCodeLike
  * @property {boolean=} ignoreSameLanguageFamily
  * @property {boolean=} trimWhitespace
  * @property {boolean=} ignoreCase