fixnow 1.0.1 → 2.0.0

package/dist/fr.d.cts

@@ -0,0 +1,10 @@
+import { CheckOptions, SpellIssue, BoundChecker, IsCorrectOptions } from './index.cjs';
+export { DEFAULT_PROTECTED_PATTERN, Dictionary, LANGUAGES, LanguageInfo, tokenize } from './index.cjs';
+
+declare const checker: BoundChecker;
+declare const check: (text: string, options?: Omit<CheckOptions, "language">) => Promise<SpellIssue[]>;
+declare const suggest: (word: string, max?: number) => Promise<string[]>;
+declare const isCorrect: (word: string, options?: IsCorrectOptions) => Promise<boolean>;
+declare const warmup: () => Promise<void>;
+
+export { BoundChecker, CheckOptions, IsCorrectOptions, SpellIssue, check, checker, isCorrect, suggest, warmup };

package/dist/fr.d.ts

@@ -0,0 +1,10 @@
+import { CheckOptions, SpellIssue, BoundChecker, IsCorrectOptions } from './index.js';
+export { DEFAULT_PROTECTED_PATTERN, Dictionary, LANGUAGES, LanguageInfo, tokenize } from './index.js';
+
+declare const checker: BoundChecker;
+declare const check: (text: string, options?: Omit<CheckOptions, "language">) => Promise<SpellIssue[]>;
+declare const suggest: (word: string, max?: number) => Promise<string[]>;
+declare const isCorrect: (word: string, options?: IsCorrectOptions) => Promise<boolean>;
+declare const warmup: () => Promise<void>;
+
+export { BoundChecker, CheckOptions, IsCorrectOptions, SpellIssue, check, checker, isCorrect, suggest, warmup };

package/dist/fr.js

@@ -0,0 +1,20 @@
+import {
+  DEFAULT_PROTECTED_PATTERN,
+  LANGUAGES,
+  createChecker,
+  tokenize
+} from "./chunk-FX7T7BEL.js";
+
+// src/entries/fr.ts
+var checker = createChecker("fr");
+var { check, suggest, isCorrect, warmup } = checker;
+export {
+  DEFAULT_PROTECTED_PATTERN,
+  LANGUAGES,
+  check,
+  checker,
+  isCorrect,
+  suggest,
+  tokenize,
+  warmup
+};

package/dist/index.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  DEFAULT_PROTECTED_PATTERN: () => DEFAULT_PROTECTED_PATTERN,
   LANGUAGES: () => LANGUAGES,
   SUPPORTED_LANGUAGES: () => SUPPORTED_LANGUAGES,
   checkText: () => checkText,
@@ -4832,11 +4833,11 @@ function consolidate(root) {
     knownMap.set(orig, n);
     return n;
   }
-  function process(n) {
+  function process2(n) {
     if (cached.has(n)) return n;
     if (Object.isFrozen(n)) return knownMap.get(n) || deepCopy(n);
     if (n.c) {
-      const children = Object.entries(n.c).sort((a, b) => a[0] < b[0] ? -1 : 1).map(([k, n2]) => [k, process(n2)]);
+      const children = Object.entries(n.c).sort((a, b) => a[0] < b[0] ? -1 : 1).map(([k, n2]) => [k, process2(n2)]);
       n.c = Object.fromEntries(children);
     }
     const sig = signature(n);
@@ -4852,7 +4853,7 @@ function consolidate(root) {
   };
   signatures.set(signature(eow), eow);
   cached.set(eow, count2++);
-  return trieNodeToRoot(process(root), root);
+  return trieNodeToRoot(process2(root), root);
 }
 function decodeBTrie(data) {
   return TrieBlob.decodeBin(data);
@@ -5917,7 +5918,9 @@ var TrieDictionary = class {
     return this.trie.suggest(word, { numSuggestions: max2 });
   }
 };
-var cache = /* @__PURE__ */ new Map();
+var CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("fixnow.dictionaryCache.v2");
+var globalRegistry = globalThis;
+var cache = globalRegistry[CACHE_SYMBOL] ?? (globalRegistry[CACHE_SYMBOL] = /* @__PURE__ */ new Map());
 function loadDictionary(language) {
   if (!isSupportedLanguage(language)) {
     return Promise.reject(
@@ -5973,15 +5976,10 @@ var ENCLITICS = [
 ];
 var ACUTE_ACCENT = {
   a: "\xE1",
-  // á
   e: "\xE9",
-  // é
   i: "\xED",
-  // í
   o: "\xF3",
-  // ó
   u: "\xFA"
-  // ú
 };
 function deaccent(value) {
   return value.normalize("NFD").replace(/[̀-ͯ]/g, "");
@@ -6014,26 +6012,34 @@ function isEncliticVerb(lowerWord, dict) {
   }
   return false;
 }
-function acceptSpanish(word, dict, strict) {
+function acceptSpanish(word, dict, caseSensitive, acceptAccentOmissions) {
   const lower = word.toLowerCase();
-  const inDictionary = strict ? dict.has(word) || dict.has(lower) : dict.has(word) || matchesIgnoringAccents(lower, dict);
+  const inDictionary = caseSensitive ? dict.has(word) || acceptAccentOmissions && word === lower && matchesIgnoringAccents(lower, dict) : acceptAccentOmissions ? dict.has(word) || matchesIgnoringAccents(lower, dict) : dict.has(word) || dict.has(lower);
   return inDictionary || isEncliticVerb(lower, dict);
 }
 
 // src/lang/index.ts
-function isAccepted(word, language, dict, strict) {
-  if (language === "es") return acceptSpanish(word, dict, strict);
-  return dict.has(word) || dict.has(word.toLowerCase());
+function isAccepted(word, language, dict, caseSensitive, acceptAccentOmissions) {
+  if (language === "es") return acceptSpanish(word, dict, caseSensitive, acceptAccentOmissions);
+  if (dict.has(word)) return true;
+  if (!caseSensitive && dict.has(word.toLowerCase())) return true;
+  return false;
 }
 
 // src/tokenize.ts
-var PROTECTED_PATTERN = /\[(?:Image|Code|Text) #\d+[^\]\n]*\]|\[Skills? #[^\]\n]+\]|\/skills #\d+|\/skill\b|```[\s\S]*?```|`[^`\n]+`|https?:\/\/[^\s"'`<>]+|[\w.-]+@[\w.-]+\.\w{2,}|(?:\.{1,2}\/|~\/|\/)[^\s"'`<>]+|[A-Za-z]:\\[^\s"'`<>]+|#[0-9a-fA-F]{3,8}\b|\b[A-Z][A-Z0-9_]{1,}\b|(?<!\S)--?[A-Za-z][\w-]*(?:=[^\s"'`<>]+)?|\b(?:@[\w.-]+\/)?[\w.-]+@[\w.-]+\b|\b[\w.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|html|css|scss|sass|md|mdx|svg|png|jpg|jpeg|gif|webp|yml|yaml|toml|env|lock)\b|\b[$A-Za-z_][\w$]*(?:[._:$][\w$-]+)+\b/g;
+var DEFAULT_PROTECTED_PATTERN = /```[\s\S]*?```|`[^`\n]+`|https?:\/\/[^\s"'`<>]+|[\w.-]+@[\w.-]+\.\w{2,}|(?:\.{1,2}\/|~\/|\/)[^\s"'`<>]+|[A-Za-z]:\\[^\s"'`<>]+|#[0-9a-fA-F]{3,8}\b|\b[A-Z][A-Z0-9_]{1,}\b|(?<!\S)--?[A-Za-z][\w-]*(?:=[^\s"'`<>]+)?|\b(?:@[\w.-]+\/)?[\w.-]+@[\w.-]+\b|\b[\w.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|html|css|scss|sass|md|mdx|svg|png|jpg|jpeg|gif|webp|yml|yaml|toml|env|lock)\b|\b[$A-Za-z_][\w$]*(?:[._:$][\w$-]+)+\b/g;
 var WORD_PATTERN = /[\p{L}\p{M}]+/gu;
-function* tokenize(text) {
+function* tokenize(text, protectedSegments) {
   const protectedRanges = [];
-  for (const match of text.matchAll(PROTECTED_PATTERN)) {
-    const start = match.index ?? 0;
-    protectedRanges.push([start, start + match[0].length]);
+  if (protectedSegments !== false) {
+    const patterns = protectedSegments == null ? [DEFAULT_PROTECTED_PATTERN] : Array.isArray(protectedSegments) ? protectedSegments : [protectedSegments];
+    for (const pattern of patterns) {
+      const re = pattern.flags.includes("g") ? pattern : new RegExp(pattern.source, pattern.flags + "g");
+      for (const match of text.matchAll(re)) {
+        const start = match.index ?? 0;
+        protectedRanges.push([start, start + match[0].length]);
+      }
+    }
   }
   const isProtected = (offset) => protectedRanges.some(([start, end]) => offset >= start && offset < end);
   for (const match of text.matchAll(WORD_PATTERN)) {
@@ -6044,16 +6050,15 @@ function* tokenize(text) {
 }
 
 // src/checker.ts
-var DEFAULT_LANGUAGE = "es";
 var DEFAULT_MIN_WORD_LENGTH = 3;
 var DEFAULT_MAX_SUGGESTIONS = 5;
 var MAX_VERDICT_CACHE = 5e3;
 var verdictCache = /* @__PURE__ */ new Map();
-function acceptedVerdict(word, language, strict, dict) {
-  const key = `${language}:${strict ? 1 : 0}:${word}`;
+function acceptedVerdict(word, language, caseSensitive, acceptAccentOmissions, dict) {
+  const key = `${language}:${caseSensitive ? 1 : 0}:${acceptAccentOmissions ? 1 : 0}:${word}`;
   const cached = verdictCache.get(key);
   if (cached !== void 0) return cached;
-  const accepted = isAccepted(word, language, dict, strict);
+  const accepted = isAccepted(word, language, dict, caseSensitive, acceptAccentOmissions);
   if (verdictCache.size >= MAX_VERDICT_CACHE) {
     const oldest = verdictCache.keys().next().value;
     if (oldest !== void 0) verdictCache.delete(oldest);
@@ -6061,11 +6066,30 @@ function acceptedVerdict(word, language, strict, dict) {
   verdictCache.set(key, accepted);
   return accepted;
 }
-async function checkText(text, options = {}) {
+var strictDeprecationWarned = false;
+function resolveStrictness(options) {
+  let caseSensitive = options.caseSensitive;
+  let acceptAccentOmissions = options.acceptAccentOmissions;
+  if ("strict" in options && options.strict !== void 0) {
+    if (!strictDeprecationWarned && process.env.NODE_ENV !== "production") {
+      console.warn(
+        "[fixnow] `strict` is deprecated; use `caseSensitive` and `acceptAccentOmissions` instead."
+      );
+      strictDeprecationWarned = true;
+    }
+    caseSensitive ??= false;
+    acceptAccentOmissions ??= options.strict === false && options.language === "es";
+  }
+  return {
+    caseSensitive: caseSensitive ?? false,
+    acceptAccentOmissions: acceptAccentOmissions ?? false
+  };
+}
+async function checkText(text, options) {
   if (!text || text.trim().length < 2) return [];
-  const language = options.language ?? DEFAULT_LANGUAGE;
+  const { language } = options;
   const minWordLength = options.minWordLength ?? DEFAULT_MIN_WORD_LENGTH;
-  const strict = options.strict ?? false;
+  const { caseSensitive, acceptAccentOmissions } = resolveStrictness(options);
   const withSuggestions = options.suggestions ?? false;
   const maxSuggestions = options.maxSuggestions ?? DEFAULT_MAX_SUGGESTIONS;
   const ignore = toLowerSet(options.ignoreWords);
@@ -6078,7 +6102,7 @@ async function checkText(text, options = {}) {
     return issue;
   };
   const issues = [];
-  for (const { word, offset } of tokenize(text)) {
+  for (const { word, offset } of tokenize(text, options.protectedSegments)) {
     const lower = word.toLowerCase();
     if (ignore?.has(lower)) continue;
     if (isProtectedWord?.(word)) continue;
@@ -6087,14 +6111,15 @@ async function checkText(text, options = {}) {
       continue;
     }
     if (word.length < minWordLength) continue;
-    if (acceptedVerdict(word, language, strict, dict)) continue;
+    if (acceptedVerdict(word, language, caseSensitive, acceptAccentOmissions, dict)) continue;
     issues.push(makeIssue(word, offset));
   }
   return issues;
 }
-async function isCorrect(word, language = DEFAULT_LANGUAGE, strict = false) {
+async function isCorrect(word, language, options = {}) {
   const dict = await loadDictionary(language);
-  return acceptedVerdict(word, language, strict, dict);
+  const { caseSensitive, acceptAccentOmissions } = resolveStrictness({ ...options, language });
+  return acceptedVerdict(word, language, caseSensitive, acceptAccentOmissions, dict);
 }
 function toLowerSet(words) {
   if (!words) return void 0;
@@ -6109,16 +6134,17 @@ function createChecker(language) {
     language,
     check: (text, options) => checkText(text, { ...options, language }),
     suggest: async (word, max2 = 5) => (await loadDictionary(language)).suggest(word, max2),
-    isCorrect: (word, strict = false) => isCorrect(word, language, strict),
+    isCorrect: (word, options) => isCorrect(word, language, options),
     warmup: () => warmup(language)
   };
 }
-async function suggest(word, options = {}) {
-  const dict = await loadDictionary(options.language ?? "es");
+async function suggest(word, options) {
+  const dict = await loadDictionary(options.language);
   return dict.suggest(word, options.max ?? 5);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_PROTECTED_PATTERN,
   LANGUAGES,
   SUPPORTED_LANGUAGES,
   checkText,

package/dist/index.d.cts

@@ -26,11 +26,19 @@ interface SpellIssue {
     suggestions?: string[];
 }
 interface CheckOptions {
-    /** Dictionary to check against. Defaults to `'es'`. */
-    language?: LanguageCode;
+    /** Dictionary to check against. Required. */
+    language: LanguageCode;
+    /** When true, dictionary lookups are case-sensitive. Default: false. */
+    caseSensitive?: boolean;
     /**
-     * Spanish only: when true, accent omissions (e.g. "codigo" for "código") are
-     * flagged. When false (default) they are accepted as harmless.
+     * Spanish-specific. When true, words missing an acute accent
+     * (e.g. "codigo" for "código") are accepted as correct. Default: false.
+     * No effect for any other language.
+     */
+    acceptAccentOmissions?: boolean;
+    /**
+     * @deprecated Removed in 3.0.0. Use `caseSensitive` and
+     * `acceptAccentOmissions` instead.
      */
     strict?: boolean;
     /** Attach correction suggestions to every issue. Defaults to false. */
@@ -49,6 +57,21 @@ interface CheckOptions {
     flagWords?: Iterable<string>;
     /** Custom predicate to skip a word before it is checked (e.g. protected terms). */
     isProtectedWord?: (word: string) => boolean;
+    /**
+     * Override or disable the protected-segment tokenizer pattern. See
+     * `tokenize` for details. Defaults to the bundled default pattern.
+     */
+    protectedSegments?: RegExp | RegExp[] | false;
+}
+/** Options for `isCorrect` / bound checker `isCorrect`. */
+interface IsCorrectOptions {
+    /** When true, dictionary lookups are case-sensitive. Default: false. */
+    caseSensitive?: boolean;
+    /**
+     * Spanish-specific. When true, words missing an acute accent are accepted
+     * as correct. Default: false. No effect for any other language.
+     */
+    acceptAccentOmissions?: boolean;
 }
 /** A loaded, decoded dictionary. Membership and suggestion lookups are synchronous. */
 interface Dictionary {
@@ -59,9 +82,11 @@ interface Dictionary {
 }
 
 /** Finds misspelled words in `text` for the given language. */
-declare function checkText(text: string, options?: CheckOptions): Promise<SpellIssue[]>;
+declare function checkText(text: string, options: CheckOptions): Promise<SpellIssue[]>;
 /** Whether a single word is correctly spelled in the given language. */
-declare function isCorrect(word: string, language?: LanguageCode, strict?: boolean): Promise<boolean>;
+declare function isCorrect(word: string, language: LanguageCode, options?: IsCorrectOptions & {
+    strict?: boolean;
+}): Promise<boolean>;
 
 /** Loads and decodes a language dictionary, caching the result. */
 declare function loadDictionary(language: LanguageCode): Promise<Dictionary>;
@@ -71,22 +96,32 @@ declare function loadDictionary(language: LanguageCode): Promise<Dictionary>;
  */
 declare function warmup(language?: LanguageCode | LanguageCode[]): Promise<void>;
 
+declare const DEFAULT_PROTECTED_PATTERN: RegExp;
 interface Token {
     word: string;
     offset: number;
 }
 /**
  * Yields candidate words from `text`, skipping anything inside a protected
- * segment (code, URLs, paths, acronyms, …).
+ * segment.
+ *
+ * `protectedSegments` controls what is skipped:
+ * - `undefined` (default) → the bundled {@link DEFAULT_PROTECTED_PATTERN}.
+ * - `RegExp` / `RegExp[]` → use the given patterns instead of the default.
+ *   Pass `[DEFAULT_PROTECTED_PATTERN, myPattern]` to compose.
+ * - `false` → no segment protection at all.
+ *
+ * Non-global regexes are auto-wrapped with the `g` flag; originals are never
+ * mutated.
  */
-declare function tokenize(text: string): Generator<Token>;
+declare function tokenize(text: string, protectedSegments?: RegExp | RegExp[] | false): Generator<Token>;
 
 /** A checker bound to a single language, for convenient repeated use. */
 interface BoundChecker {
     readonly language: LanguageCode;
     check(text: string, options?: Omit<CheckOptions, 'language'>): Promise<SpellIssue[]>;
     suggest(word: string, max?: number): Promise<string[]>;
-    isCorrect(word: string, strict?: boolean): Promise<boolean>;
+    isCorrect(word: string, options?: IsCorrectOptions): Promise<boolean>;
     warmup(): Promise<void>;
 }
 /**
@@ -99,9 +134,9 @@ interface BoundChecker {
  */
 declare function createChecker(language: LanguageCode): BoundChecker;
 /** Correction suggestions for a single word. */
-declare function suggest(word: string, options?: {
-    language?: LanguageCode;
+declare function suggest(word: string, options: {
+    language: LanguageCode;
     max?: number;
 }): Promise<string[]>;
 
-export { type BoundChecker, type CheckOptions, type Dictionary, LANGUAGES, type LanguageCode, type LanguageInfo, SUPPORTED_LANGUAGES, type SpellIssue, checkText, createChecker, isCorrect, isSupportedLanguage, loadDictionary, suggest, tokenize, warmup };
+export { type BoundChecker, type CheckOptions, DEFAULT_PROTECTED_PATTERN, type Dictionary, type IsCorrectOptions, LANGUAGES, type LanguageCode, type LanguageInfo, SUPPORTED_LANGUAGES, type SpellIssue, checkText, createChecker, isCorrect, isSupportedLanguage, loadDictionary, suggest, tokenize, warmup };

package/dist/index.d.ts

@@ -26,11 +26,19 @@ interface SpellIssue {
     suggestions?: string[];
 }
 interface CheckOptions {
-    /** Dictionary to check against. Defaults to `'es'`. */
-    language?: LanguageCode;
+    /** Dictionary to check against. Required. */
+    language: LanguageCode;
+    /** When true, dictionary lookups are case-sensitive. Default: false. */
+    caseSensitive?: boolean;
     /**
-     * Spanish only: when true, accent omissions (e.g. "codigo" for "código") are
-     * flagged. When false (default) they are accepted as harmless.
+     * Spanish-specific. When true, words missing an acute accent
+     * (e.g. "codigo" for "código") are accepted as correct. Default: false.
+     * No effect for any other language.
+     */
+    acceptAccentOmissions?: boolean;
+    /**
+     * @deprecated Removed in 3.0.0. Use `caseSensitive` and
+     * `acceptAccentOmissions` instead.
      */
     strict?: boolean;
     /** Attach correction suggestions to every issue. Defaults to false. */
@@ -49,6 +57,21 @@ interface CheckOptions {
     flagWords?: Iterable<string>;
     /** Custom predicate to skip a word before it is checked (e.g. protected terms). */
     isProtectedWord?: (word: string) => boolean;
+    /**
+     * Override or disable the protected-segment tokenizer pattern. See
+     * `tokenize` for details. Defaults to the bundled default pattern.
+     */
+    protectedSegments?: RegExp | RegExp[] | false;
+}
+/** Options for `isCorrect` / bound checker `isCorrect`. */
+interface IsCorrectOptions {
+    /** When true, dictionary lookups are case-sensitive. Default: false. */
+    caseSensitive?: boolean;
+    /**
+     * Spanish-specific. When true, words missing an acute accent are accepted
+     * as correct. Default: false. No effect for any other language.
+     */
+    acceptAccentOmissions?: boolean;
 }
 /** A loaded, decoded dictionary. Membership and suggestion lookups are synchronous. */
 interface Dictionary {
@@ -59,9 +82,11 @@ interface Dictionary {
 }
 
 /** Finds misspelled words in `text` for the given language. */
-declare function checkText(text: string, options?: CheckOptions): Promise<SpellIssue[]>;
+declare function checkText(text: string, options: CheckOptions): Promise<SpellIssue[]>;
 /** Whether a single word is correctly spelled in the given language. */
-declare function isCorrect(word: string, language?: LanguageCode, strict?: boolean): Promise<boolean>;
+declare function isCorrect(word: string, language: LanguageCode, options?: IsCorrectOptions & {
+    strict?: boolean;
+}): Promise<boolean>;
 
 /** Loads and decodes a language dictionary, caching the result. */
 declare function loadDictionary(language: LanguageCode): Promise<Dictionary>;
@@ -71,22 +96,32 @@ declare function loadDictionary(language: LanguageCode): Promise<Dictionary>;
  */
 declare function warmup(language?: LanguageCode | LanguageCode[]): Promise<void>;
 
+declare const DEFAULT_PROTECTED_PATTERN: RegExp;
 interface Token {
     word: string;
     offset: number;
 }
 /**
  * Yields candidate words from `text`, skipping anything inside a protected
- * segment (code, URLs, paths, acronyms, …).
+ * segment.
+ *
+ * `protectedSegments` controls what is skipped:
+ * - `undefined` (default) → the bundled {@link DEFAULT_PROTECTED_PATTERN}.
+ * - `RegExp` / `RegExp[]` → use the given patterns instead of the default.
+ *   Pass `[DEFAULT_PROTECTED_PATTERN, myPattern]` to compose.
+ * - `false` → no segment protection at all.
+ *
+ * Non-global regexes are auto-wrapped with the `g` flag; originals are never
+ * mutated.
  */
-declare function tokenize(text: string): Generator<Token>;
+declare function tokenize(text: string, protectedSegments?: RegExp | RegExp[] | false): Generator<Token>;
 
 /** A checker bound to a single language, for convenient repeated use. */
 interface BoundChecker {
     readonly language: LanguageCode;
     check(text: string, options?: Omit<CheckOptions, 'language'>): Promise<SpellIssue[]>;
     suggest(word: string, max?: number): Promise<string[]>;
-    isCorrect(word: string, strict?: boolean): Promise<boolean>;
+    isCorrect(word: string, options?: IsCorrectOptions): Promise<boolean>;
     warmup(): Promise<void>;
 }
 /**
@@ -99,9 +134,9 @@ interface BoundChecker {
  */
 declare function createChecker(language: LanguageCode): BoundChecker;
 /** Correction suggestions for a single word. */
-declare function suggest(word: string, options?: {
-    language?: LanguageCode;
+declare function suggest(word: string, options: {
+    language: LanguageCode;
     max?: number;
 }): Promise<string[]>;
 
-export { type BoundChecker, type CheckOptions, type Dictionary, LANGUAGES, type LanguageCode, type LanguageInfo, SUPPORTED_LANGUAGES, type SpellIssue, checkText, createChecker, isCorrect, isSupportedLanguage, loadDictionary, suggest, tokenize, warmup };
+export { type BoundChecker, type CheckOptions, DEFAULT_PROTECTED_PATTERN, type Dictionary, type IsCorrectOptions, LANGUAGES, type LanguageCode, type LanguageInfo, SUPPORTED_LANGUAGES, type SpellIssue, checkText, createChecker, isCorrect, isSupportedLanguage, loadDictionary, suggest, tokenize, warmup };