ilib-lint 2.18.2 → 2.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilib-lint",
-  "version": "2.18.2",
+  "version": "2.19.1",
   "type": "module",
   "main": "./src/index.js",
   "module": "./src/index.js",
@@ -62,30 +62,34 @@
     "jest": "^29.7.0",
     "jsdoc": "^4.0.3",
     "jsdoc-to-markdown": "^8.0.3",
-    "typescript": "^5.5.4",
-    "@ilib-mono/e2e-test": "^0.0.0"
+    "typescript": "^5.9.2",
+    "ilib-internal": "^0.0.0"
   },
   "dependencies": {
     "@formatjs/intl": "^2.10.4",
     "ilib-localeinfo": "^1.1.0",
+    "ilib-localematcher": "^1.2.2",
     "intl-messageformat": "^10.5",
     "json5": "^2.2.3",
     "log4js": "^6.9.1",
     "micromatch": "^4.0.7",
     "options-parser": "^0.4.0",
     "xml-js": "^1.6.11",
+    "ilib-casemapper": "^1.0.2",
     "ilib-common": "^1.1.6",
     "ilib-ctype": "^1.3.0",
     "ilib-lint-common": "^3.6.0",
-    "ilib-locale": "^1.2.4",
-    "ilib-tools-common": "^1.19.0"
+    "ilib-scriptinfo": "^1.0.0",
+    "ilib-tools-common": "^1.19.0",
+    "ilib-locale": "^1.2.4"
   },
   "scripts": {
-    "coverage": "pnpm test -- --coverage",
-    "test": "pnpm test:jest",
-    "test:jest": "LANG=en_US.UTF8 node --trace-warnings --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "coverage": "LANG=en_US.UTF8 node --trace-warnings --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
+    "test": "pnpm test:cli",
+    "test:cli": "LANG=en_US.UTF8 node --trace-warnings --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:watch": "pnpm test:jest --watch",
     "test:e2e": "LANG=en_US.UTF8 node --trace-warnings --experimental-vm-modules node_modules/jest/bin/jest.js --config test-e2e/jest.config.cjs",
+    "test:all": "pnpm test:cli test:e2e",
     "debug": "LANG=en_US.UTF8 node --experimental-vm-modules --inspect-brk node_modules/jest/bin/jest.js -i",
     "lint": "node src/index.js",
     "clean": "git clean -f -d src test",

package/src/FileType.js

@@ -51,13 +51,6 @@ class FileType {
      */
     name;
 
-    /**
-     * The list of locales to use with this file type
-     * @type {Array.<String>|undefined}
-     * @readonly
-     */
-    locales;
-
     /**
      * The intermediate representation type of this file type.
      * @type {String}
@@ -114,7 +107,6 @@ class FileType {
      * of this file type as documented above
      * @param {String} options.name the name or glob spec for this file type
      * @param {Project} options.project the Project that this file type is a part of
-     * @param {Array.<String>} [options.locales] list of locales to use with this file type
      * @param {String} [options.template] the path name template for this file type
      * which shows how to extract the locale from the path
      * name if the path includes it. Many file types
@@ -152,7 +144,6 @@ class FileType {
 
         this.name = options.name;
         this.project = options.project;
-        this.locales = options.locales;
         this.template = options.template;
 
         const parserNames = options.parsers;
@@ -243,10 +234,6 @@ class FileType {
         return this.project;
     }
 
-    getLocales() {
-        return this.locales || this.project.getLocales();
-    }
-
     getTemplate() {
         return this.template;
     }

package/src/Project.js

@@ -77,6 +77,42 @@ function isOwnMethod(instance, methodName, parentClass) {
     return typeof instance[methodName] === "function" && instance[methodName] !== parentClass.prototype[methodName];
 }
 
+/**
+ * Default locales for the linter if none are specified on the command line or in the config file. These are the top
+ * 27 locales on the internet by volume as of 2015. (Maybe we should update this list?)
+ * @type {readonly string[]}
+ */
+const defaultLocales = [
+    "en-AU",
+    "en-CA",
+    "en-GB",
+    "en-IN",
+    "en-NG",
+    "en-PH",
+    "en-PK",
+    "en-US",
+    "en-ZA",
+    "de-DE",
+    "fr-CA",
+    "fr-FR",
+    "es-AR",
+    "es-ES",
+    "es-MX",
+    "id-ID",
+    "it-IT",
+    "ja-JP",
+    "ko-KR",
+    "pt-BR",
+    "ru-RU",
+    "tr-TR",
+    "vi-VN",
+    "zxx-XX",
+    "zh-Hans-CN",
+    "zh-Hant-HK",
+    "zh-Hant-TW",
+    "zh-Hans-SG"
+];
+
 /**
  * @class Represent an ilin-lint project.
  *
@@ -124,6 +160,12 @@ class Project extends DirItem {
         }
 
         this.sourceLocale = config?.sourceLocale || options?.opt?.sourceLocale;
+        /**
+         * @readonly
+         * @type {string[]}
+         */
+        this.locales = this.options?.opt?.locales || this.config.locales || [...defaultLocales];
+
         this.config.autofix = options?.opt?.fix === true || config?.autofix === true;
 
         this.pluginMgr = this.options.pluginManager;
@@ -401,14 +443,6 @@ class Project extends DirItem {
         return this.sourceLocale || "en-US";
     }
 
-    /**
-     * Return the list of global locales for this project.
-     * @returns {Array.<String>} the list of global locales for this project
-     */
-    getLocales() {
-        return this.options.locales || this.config.locales;
-    }
-
     /**
      * Return the plugin manager for this project.
      * @returns {PluginManager} the plugin manager for this project
@@ -561,7 +595,17 @@ class Project extends DirItem {
      * @param {Array.<Result>} results the results of the linting process
      */
     applyTransformers(results) {
-        this.get().forEach((file) => file.applyTransformers(results));
+        const files = this.get();
+        for (const file of files) {
+            if (!this.options.opt.quiet && this.options.opt.progressInfo) {
+                logger.info(`Applying transformers to file [${file.filePath}]`);
+            }
+            try {
+                file.applyTransformers(results);
+            } catch (e) {
+                logger.error(`Error applying transformers to file [${file.getFilePath()}]`, e);
+            }
+        }
     }
 
     /**
@@ -569,9 +613,19 @@ class Project extends DirItem {
      * file type of each file.
      */
     serialize() {
-        if (this.options.opt.write) {
-            const files = this.get();
-            files.forEach((file) => {
+        if (!this.options.opt.write) {
+            logger.debug("Skipping serialization because write option is not set");
+            return;
+        }
+        const files = this.get();
+        for (const file of files) {
+            if (!this.options.opt.quiet && this.options.opt.progressInfo) {
+                logger.info(
+                    `Serializing file [${file.filePath}]` +
+                        (this.options.opt.overwrite ? " (overwriting)" : "(as .modified)")
+                );
+            }
+            try {
                 const irs = file.getIRs();
                 const fileType = file.getFileType();
                 const serializer = fileType.getSerializer();
@@ -585,7 +639,9 @@ class Project extends DirItem {
                     }
                     sourceFile.write();
                 }
-            });
+            } catch (e) {
+                logger.error(`Error serializing file [${file.getFilePath()}]`, e);
+            }
         }
     }
 
@@ -627,7 +683,7 @@ class Project extends DirItem {
     run() {
         let startTime = new Date();
 
-        const results = this.findIssues(this.options.opt.locales);
+        const results = this.findIssues(this.locales);
         this.applyTransformers(results);
         this.serialize();
         let endTime = new Date();

package/src/index.js

@@ -79,7 +79,6 @@ const optionConfig = {
     locales: {
         short: "l",
         varName: "LOCALES",
-        "default": "en-AU,en-CA,en-GB,en-IN,en-NG,en-PH,en-PK,en-US,en-ZA,de-DE,fr-CA,fr-FR,es-AR,es-ES,es-MX,id-ID,it-IT,ja-JP,ko-KR,pt-BR,ru-RU,tr-TR,vi-VN,zxx-XX,zh-Hans-CN,zh-Hant-HK,zh-Hant-TW,zh-Hans-SG",
         help: "Locales you want your app to support. Value is a comma-separated list of BCP-47 style locale tags. Default: the top 20 locales on the internet by traffic."
     },
     sourceLocale: {
@@ -188,15 +187,15 @@ if (paths.length === 0) {
 
 if (options.opt.locales) {
     options.opt.locales = options.opt.locales.split(/,/g);
+    // normalize the locale specs
+    options.opt.locales = options.opt.locales.map(spec => {
+        let loc = new Locale(spec);
+        if (!loc.getLanguage()) {
+            loc = new Locale("und", loc.getRegion(), loc.getVariant(), loc.getScript());
+        }
+        return loc.getSpec();
+    });
 }
-// normalize the locale specs
-options.opt.locales = options.opt.locales.map(spec => {
-    let loc = new Locale(spec);
-    if (!loc.getLanguage()) {
-        loc = new Locale("und", loc.getRegion(), loc.getVariant(), loc.getScript());
-    }
-    return loc.getSpec();
-});
 
 if (options.opt.fix || options.opt.overwrite) {
     // The write option indicates that modified files should be written back to disk.

package/src/plugins/BuiltinPlugin.js

@@ -46,6 +46,7 @@ import ResourceXML from '../rules/ResourceXML.js';
 import ResourceCamelCase from '../rules/ResourceCamelCase.js';
 import ResourceSnakeCase from '../rules/ResourceSnakeCase.js';
 import ResourceKebabCase from '../rules/ResourceKebabCase.js';
+import ResourceAllCaps from '../rules/ResourceAllCaps.js';
 import ResourceGNUPrintfMatch from '../rules/ResourceGNUPrintfMatch.js';
 import ResourceReturnChar from '../rules/ResourceReturnChar.js';
 import StringFixer from './string/StringFixer.js';
@@ -542,6 +543,7 @@ class BuiltinPlugin extends Plugin {
             ResourceCamelCase,
             ResourceSnakeCase,
             ResourceKebabCase,
+            ResourceAllCaps,
             ResourceGNUPrintfMatch,
             ResourceReturnChar,
             FileEncodingRule,

package/src/rules/ResourceAllCaps.js

@@ -0,0 +1,215 @@
+/*
+ * ResourceAllCaps.js - rule for checking that ALL CAPS source strings have ALL CAPS targets
+ *
+ * Copyright © 2025 JEDLSoft
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import ResourceRule from './ResourceRule.js';
+import ResourceFixer from '../plugins/resource/ResourceFixer.js';
+
+import {Result} from 'ilib-lint-common';
+import Locale from 'ilib-locale';
+import {isAlpha, isUpper} from 'ilib-ctype';
+import CaseMapper from 'ilib-casemapper';
+import { scriptInfoFactory } from 'ilib-scriptinfo';
+import LocaleMatcher from 'ilib-localematcher';
+
+// type imports
+/** @ignore @typedef {import('ilib-tools-common').Resource} Resource */
+/** @ignore @typedef {import('../plugins/resource/ResourceFix.js').default} ResourceFix */
+
+/**
+ * @classdesc Class representing an ilib-lint programmatic rule for linting ALL CAPS strings.
+ * @class
+ */
+class ResourceAllCaps extends ResourceRule {
+    /**
+     * Create a ResourceAllCaps rule instance.
+     * @param {object} options
+     * @param {string[]} [options.exceptions] An array of strings to exclude from the rule.
+     */
+    constructor(options) {
+        super(options);
+
+        this.name = "resource-all-caps";
+        this.description = "Ensure that when source strings are in ALL CAPS, then the targets are also in ALL CAPS";
+        this.link = "https://github.com/iLib-js/ilib-mono/blob/main/packages/ilib-lint/docs/resource-all-caps.md";
+        this.exceptions = Array.isArray(options?.exceptions) ? options.exceptions : [];
+    }
+
+    /**
+     * Check if a source string is in ALL CAPS and if the target string matches the casing style.
+     * @override
+     * @param {Object} params parameters for the string matching
+     * @param {string} params.source the source string to match against
+     * @param {string} params.target the target string to match against
+     * @param {string} params.file the file path where the resources came from
+     * @param {Resource} params.resource the resource that contains the source and/or target string
+     * @param {number} [params.index] the index of the resource
+     * @param {string} [params.category] the category of the resource
+     * @returns {Result|undefined} A Result with severity 'error' if the source string is in ALL CAPS and target string is not in ALL CAPS, otherwise undefined.
+     */
+    matchString({source, target, file, resource, index, category}) {
+        if (!source || !target) {
+            return;
+        }
+
+        const isException = this.exceptions.includes(source);
+        if (isException) {
+            return;
+        }
+
+        const isAllCaps = ResourceAllCaps.isAllCaps(source);
+        if (!isAllCaps) {
+            return;
+        }
+
+        // Check if the target locale supports capital letters
+        if (!ResourceAllCaps.hasCapitalLetters(resource.targetLocale || 'en-US')) {
+            return;
+        }
+
+        // Check if target matches the ALL CAPS style
+        if (ResourceAllCaps.isAllCaps(target)) {
+            return;
+        }
+
+        const result = new Result({
+            severity: "error",
+            id: resource.getKey(),
+            source,
+            description: "The source string is in ALL CAPS, but the target string is not.",
+            rule: this,
+            locale: resource.targetLocale,
+            pathName: file,
+            fix: this.createFix(resource, target, file, index, category),
+            highlight: `<e0>${target}</e0>`
+        });
+        return result;
+    }
+
+    /**
+     * Get the fix for this rule - converts target to ALL CAPS while preserving the translation
+     * @param {Resource} resource the resource to fix
+     * @param {string} target the current target string
+     * @param {string} file the file path
+     * @param {number} [index] the index for array resources
+     * @param {string} [category] the category for plural resources
+     * @returns {ResourceFix | undefined} the fix for this rule
+     */
+    createFix(resource, target, file, index, category) {
+        const locale = resource.targetLocale || 'en-US';
+        const casemapper = new CaseMapper({
+            locale,
+            direction: "toupper"
+        });
+        const upperCaseTarget = casemapper.map(target);
+        if (!upperCaseTarget) {
+            // if we could not upper-case the target, then we cannot fix it, so don't return a fix
+            return undefined;
+        }
+
+        const command = ResourceFixer.createStringCommand(0, target.length, upperCaseTarget);
+        return ResourceFixer.createFix({
+            resource,
+            target: true,
+            category,
+            index,
+            commands: [command]
+        });
+    }
+
+    /**
+     * Checks if a given string is in ALL CAPS style, i.e. at least 2 letter characters exist and all of them are uppercase.
+     * 
+     * @public
+     * @param {string} string A non-empty string to check.
+     * @returns {boolean} Returns true for a string that is in ALL CAPS (all letter characters are uppercase and at least 2 letter characters exist).
+     * Otherwise, returns false.
+     */
+    static isAllCaps(string) {
+        if (!string || typeof string !== 'string') {
+            return false;
+        }
+
+        const trimmed = string.trim();
+        if (trimmed.length < 2) {
+            return false;
+        }
+
+        let letterCount = 0;
+        let allLettersUpper = true;
+
+        for (let i = 0; i < trimmed.length; i++) {
+            const char = trimmed[i];
+            if (isAlpha(char)) {
+                letterCount++;
+                if (!isUpper(char)) {
+                    allLettersUpper = false;
+                    break;
+                }
+            }
+        }
+
+        return letterCount >= 2 && allLettersUpper;
+    }
+
+    /**
+     * Checks if a locale supports letter upper- and lower-casing.
+     * A language by itself cannot have capitalization; Instead, it's a property of a script.
+     * Therefore, if no script is explicitly specified in the locale, this method will figure out
+     * what the script is. It will use LocaleMatcher to guess the most likely full
+     * locale, which always includes the script tag. This may not be the script that the caller intended
+     * to use with the locale, but it will be a good guess because most locales only use one script. 
+     * Very few locales use multiple scripts, though they do exist. (Kurdish and Serbian for example
+     * are commonly written in multiple scripts.) Once it has the name of the script, it will check whether
+     * that script supports letter casing.
+     * @public
+     * @param {string} locale The locale to check for capital letter support.
+     * @returns {boolean} Returns true if the locale's script supports capital letters, false otherwise.
+     */
+    static hasCapitalLetters(locale) {
+        if (!locale) {
+            return true; // Default to true for unknown locales
+        }
+
+        try {
+            const localeObj = new Locale(locale);
+            let script = localeObj.getScript();
+
+            // If no script is specified, use LocaleMatcher to get the likely locale
+            if (!script) {
+                const localeMatcher = new LocaleMatcher({ locale: locale });
+                const likelyLocale = localeMatcher.getLikelyLocale();
+                if (likelyLocale) {
+                    const likelyLocaleObj = new Locale(likelyLocale);
+                    script = likelyLocaleObj.getScript();
+                }
+            }
+
+            if (script) {
+                const scriptInfo = scriptInfoFactory(script);
+                return scriptInfo?.casing ?? true;
+            }
+
+            return true; // Default to true for unknown scripts
+        } catch (error) {
+            // If there's any error parsing the locale or script, default to true
+            return true;
+        }
+    }
+}
+
+export default ResourceAllCaps; 

package/src/rules/ResourceSentenceEnding.js

@@ -17,12 +17,18 @@
  * limitations under the License.
  */
 
-/**
+/*
  * ResourceSentenceEnding - Checks that sentence-ending punctuation is appropriate for the target locale
  *
  * This rule checks if the source string ends with certain punctuation marks and ensures
  * the target uses the locale-appropriate equivalent.
  *
+ * Features:
+ * - Configurable minimum length threshold to skip short strings (abbreviations)
+ * - Automatic skipping of strings with no spaces (non-sentences)
+ * - Custom punctuation mappings per locale
+ * - Exception lists to skip specific source strings
+ *
  * Examples:
  * - English period (.) should become Japanese maru (。) in Japanese
  * - English question mark (?) should become Japanese question mark (？) in Japanese
@@ -34,14 +40,23 @@
 import { Result } from 'ilib-lint-common';
 import ResourceRule from './ResourceRule.js';
 import Locale from 'ilib-locale';
-import LocaleInfo from 'ilib-localeinfo';
 import ResourceFixer from '../plugins/resource/ResourceFixer.js';
-import { isPunct, isSpace } from 'ilib-ctype';
+import { isSpace, isAlpha, isAlnum } from 'ilib-ctype';
 
-/** @ignore @typedef {import("ilib-tools-common").Resource} Resource */
-/** @ignore @typedef {import("ilib-lint-common").Fix} Fix */
+/**
+ * @ignore
+ * @typedef {import("ilib-tools-common").Resource} Resource
+ */
+/**
+ * @ignore
+ * @typedef {import("ilib-lint-common").Fix} Fix
+ */
+/**
+ * @ignore
+ * @typedef {import("../plugins/resource/ResourceFix.js").default} ResourceFix
+ */
 
-/** @ignore
+/*
  * Default punctuation for each punctuation type
  */
 const defaults = {
@@ -52,7 +67,7 @@ const defaults = {
     'colon': ':'
 };
 
-/** @ignore
+/*
  * Punctuation map for each language, with default punctuation for each punctuation type
  */
 const punctuationMap = {
@@ -72,42 +87,133 @@ const punctuationMap = {
     'bn': { 'period': '।', 'question': '?', 'exclamation': '!', 'ellipsis': '…', 'colon': ':' }
 };
 
+/**
+ * @ignore
+ * @typedef {{period?: string, question?: string, exclamation?: string, ellipsis?: string, colon?: string, exceptions?: string[]}} LocaleOptions
+ * @property {string} [period] - Custom period punctuation for this locale
+ * @property {string} [question] - Custom question mark punctuation for this locale
+ * @property {string} [exclamation] - Custom exclamation mark punctuation for this locale
+ * @property {string} [ellipsis] - Custom ellipsis punctuation for this locale
+ * @property {string} [colon] - Custom colon punctuation for this locale
+ * @property {string[]} [exceptions] - Array of source strings to skip checking for this locale.
+ *   Useful for handling special cases like abbreviations that should not be checked for sentence-ending punctuation.
+ */
+
+/**
+ * @ignore
+ * @typedef {{minimumLength?: number}} ResourceSentenceEndingFixedOptions
+ * @property {number} [minimumLength=10] - Minimum length of source string before the rule is applied.
+ *   Strings shorter than this length will be skipped (useful for avoiding false positives on abbreviations).
+ */
+
+/**
+ * @ignore
+ * @typedef {ResourceSentenceEndingFixedOptions | Record<string, LocaleOptions>} ResourceSentenceEndingOptions
+ */
+
 /**
  * @class ResourceSentenceEnding
  * @extends ResourceRule
  */
 class ResourceSentenceEnding extends ResourceRule {
-    constructor(options) {
+    /**
+     * Constructs a new ResourceSentenceEnding rule instance.
+     *
+     * @param {ResourceSentenceEndingOptions} [options] - Configuration options for the rule
+     *
+     * @example
+     * // Basic usage with default settings
+     * const rule = new ResourceSentenceEnding();
+     *
+     * @example
+     * // Custom minimum length
+     * const rule = new ResourceSentenceEnding({
+     *   minimumLength: 15
+     * });
+     *
+     * @example
+     * // Custom punctuation mappings for Japanese
+     * const rule = new ResourceSentenceEnding({
+     *   'ja-JP': {
+     *     period: '。',
+     *     question: '？',
+     *     exclamation: '！',
+     *     ellipsis: '…',
+     *     colon: '：'
+     *   }
+     * });
+     *
+     * @example
+     * // Exception list for German
+     * const rule = new ResourceSentenceEnding({
+     *   'de-DE': {
+     *     exceptions: [
+     *       'See the Dr.',
+     *       'Visit the Prof.',
+     *       'Check with Mr.'
+     *     ]
+     *   }
+     * });
+     *
+     * @example
+     * // Combined configuration
+     * const rule = new ResourceSentenceEnding({
+     *   minimumLength: 8,
+     *   'ja-JP': {
+     *     period: '。',
+     *     exceptions: ['Loading...', 'Please wait...']
+     *   },
+     *   'de-DE': {
+     *     exceptions: ['See the Dr.', 'Visit the Prof.']
+     *   }
+     * });
+     */
+    constructor(options = {}) {
         super(options);
         this.name = "resource-sentence-ending";
         this.description = "Checks that sentence-ending punctuation is appropriate for the locale of the target string and matches the punctuation in the source string";
         this.link = "https://github.com/iLib-js/ilib-lint/blob/main/docs/resource-sentence-ending.md";
 
+        // Initialize minimum length configuration
+        this.minimumLength = Math.max(0, options?.minimumLength ?? 10);
+
         // Initialize custom punctuation mappings from configuration
         this.customPunctuationMap = {};
+        // Initialize exception lists from configuration
+        this.exceptionsMap = {};
+
         if (options && typeof options === 'object' && !Array.isArray(options)) {
-                    // options is an object with locale codes as keys and punctuation mappings as values
-        // Merge the default punctuation with the custom punctuation so that the custom
-        // punctuation overrides the default and we don't have to specify all punctuation types.
-        // Custom maps are stored by language, not locale, so that they apply to all locales of
-        // that language.
-        for (const locale in options) {
-            const localeObj = new Locale(locale);
-
-            // only process config for valid locales
-            if (localeObj.isValid()) {
-                const language = localeObj.getLanguage();
-                // locale must have a language code
-                if (!language) continue;
-                // Apply locale-specific defaults for any locale that usesthis language
-                const localeDefaults = this.getLocaleDefaults(language);
-                this.customPunctuationMap[language] = {
-                    ...localeDefaults,
-                    ...options[locale]
-                };
+            // options is an object with locale codes as keys and punctuation mappings as values
+            // Merge the default punctuation with the custom punctuation so that the custom
+            // punctuation overrides the default and we don't have to specify all punctuation types.
+            // Custom maps are stored by language, not locale, so that they apply to all locales of
+            // that language.
+            for (const locale in options) {
+                const localeObj = new Locale(locale);
+
+                // only process config for valid locales
+                if (localeObj.isValid()) {
+                    const language = localeObj.getLanguage();
+                    // locale must have a language code
+                    if (!language) continue;
+
+                    // Separate punctuation mappings from exceptions
+                    const { exceptions, ...punctuationMappings } = options[locale];
+
+                    // Apply locale-specific defaults for any locale that usesthis language
+                    const localeDefaults = this.getLocaleDefaults(language);
+                    this.customPunctuationMap[language] = {
+                        ...localeDefaults,
+                        ...punctuationMappings
+                    };
+
+                    // Store exceptions separately
+                    if (exceptions && Array.isArray(exceptions)) {
+                        this.exceptionsMap[language] = exceptions;
+                    }
+                }
             }
         }
-        }
 
         // Build the set of sentence-ending punctuation characters dynamically
         this.sentenceEndingPunctuationSet = this.buildSentenceEndingPunctuationSet();
@@ -251,11 +357,12 @@ class ResourceSentenceEnding extends ResourceRule {
     }
 
     /**
-     * Get a regex that matches all expected punctuation for a given locale
+     * Get a regex that matches all expected punctuation for a given locale, excluding colons
+     * This is used by getLastSentenceFromContent to avoid splitting on colons in the middle of sentences
      * @param {Locale} localeObj locale of the punctuation
-     * @returns {string} regex string that matches all expected punctuation for the locale
+     * @returns {string} regex string that matches all expected punctuation for the locale except colons
      */
-    getExpectedPunctuationRegex(localeObj) {
+    getExpectedPunctuationRegexWithoutColons(localeObj) {
         const language = localeObj.getLanguage();
         let config;
         if (language) {
@@ -266,7 +373,10 @@ class ResourceSentenceEnding extends ResourceRule {
         } else {
             config = defaults;
         }
-        return Object.values(config).join('').replace(/\./g, '\\.').replace(/\?/g, '\\?');
+        // Exclude colons from the punctuation regex
+        const punctuationWithoutColons = { ...config };
+        delete punctuationWithoutColons.colon;
+        return Object.values(punctuationWithoutColons).join('').replace(/\./g, '\\.').replace(/\?/g, '\\?');
     }
 
     /**
@@ -381,11 +491,13 @@ class ResourceSentenceEnding extends ResourceRule {
     getLastSentenceFromContent(content, targetLocaleObj) {
         if (!content) return content;
         // Only treat .!?。？！ as sentence-ending punctuation, not ¿ or ¡
-        const allSentenceEnding = this.getExpectedPunctuationRegex(targetLocaleObj);
+        // Exclude colons from sentence-ending punctuation for this function because
+        // colons in the middle of a sentence should not split the sentence
+        const sentenceEndingWithoutColons = this.getExpectedPunctuationRegexWithoutColons(targetLocaleObj);
         // Fix: Use a regex that finds the last sentence, properly handling trailing whitespace
         // First, trim trailing whitespace to avoid matching spaces instead of sentences
         const trimmedContent = content.trim();
-        const sentenceEndingRegex = new RegExp(`[^${allSentenceEnding}]+\\p{P}?\\w*$`, 'gu');
+        const sentenceEndingRegex = new RegExp(`[^${sentenceEndingWithoutColons}]+\\p{P}?\\w*$`, 'gu');
         const match = sentenceEndingRegex.exec(trimmedContent);
         if (match !== null && match.length > 0) {
             let lastSentence = match[0].trim();
@@ -434,26 +546,106 @@ class ResourceSentenceEnding extends ResourceRule {
     }
 
     /**
-     * Check if Spanish target has the correct inverted punctuation at the beginning of the last sentence
+     * Format punctuation for error messages - replace empty strings with "no punctuation"
+     * @param {string} punctuation - The punctuation string to format
+     * @returns {string} - The formatted punctuation string
+     */
+    static formatPunctuationForMessage(punctuation) {
+        return punctuation === '' ? 'no punctuation' : `"${punctuation}"`;
+    }
+
+    /**
+     * Check if Spanish target has the correct inverted punctuation in the last sentence
      * @param {string} lastSentence - The last sentence of the target string (already stripped of quotes)
      * @param {string} sourceEndingType - The type of ending punctuation in source
-     * @returns {boolean} - True if Spanish target has correct inverted punctuation at start of last sentence
+     * @param {Locale} targetLocaleObj - The target locale object for custom punctuation configuration
+     * @returns {{correct: boolean, position: number}} - position is where inverted punctuation should be
      */
-    hasCorrectSpanishInvertedPunctuation(lastSentence, sourceEndingType) {
-        if (!lastSentence || typeof lastSentence !== 'string') return false;
+    hasCorrectSpanishInvertedPunctuation(lastSentence, sourceEndingType, targetLocaleObj) {
+        if (!lastSentence || typeof lastSentence !== 'string') return { correct: false, position: 0 };
         // Only check for questions and exclamations
         if (sourceEndingType !== 'question' && sourceEndingType !== 'exclamation') {
-            return true; // Not applicable for other punctuation types
+            return { correct: true, position: 0 }; // Not applicable for other punctuation types
         }
         // Strip any leading quote characters before checking for inverted punctuation
         const quoteChars = ResourceSentenceEnding.allQuoteChars;
         let strippedSentence = lastSentence;
+        let strippedOffset = 0;
         while (strippedSentence.length > 0 && (quoteChars.includes(strippedSentence.charAt(0)) || isSpace(strippedSentence.charAt(0)))) {
             strippedSentence = strippedSentence.slice(1);
+            strippedOffset++;
         }
-        // Check for inverted punctuation at the beginning of the stripped last sentence
+
         const expectedInverted = sourceEndingType === 'question' ? '¿' : '¡';
-        return strippedSentence.startsWith(expectedInverted);
+
+        // Search backwards from the end of the sentence
+        // If we find the correct inverted punctuation first, it's correct
+        // If we find sentence-ending punctuation first, it's incorrect
+        for (let i = strippedSentence.length - 1; i >= 0; i--) {
+            const char = strippedSentence.charAt(i);
+
+            // If we find the correct inverted punctuation, it's correct
+            if (char === expectedInverted) {
+                return { correct: true, position: strippedOffset };
+            }
+
+            // If we find sentence-ending punctuation (excluding the final one),
+            // we've reached the start of this sentence without finding inverted punctuation
+            // Use locale-specific punctuation configuration
+            const sentenceEndingChars = this.getExpectedPunctuationRegexWithoutColons(targetLocaleObj);
+            const sentenceEndingRegex = new RegExp(`[${sentenceEndingChars}]`, 'u');
+            if (sentenceEndingRegex.test(char)) {
+                // Skip the final punctuation at the end
+                if (i === strippedSentence.length - 1) {
+                    continue;
+                }
+
+                // Special handling for dots: check if it's part of a letter-dot-letter pattern
+                // (like email addresses, URLs, abbreviations, etc.)
+                if (char === '.') {
+                    // Check if this dot is part of a letter-dot-letter pattern
+                    const beforeDot = i > 0 ? strippedSentence.charAt(i - 1) : '';
+                    const afterDot = i < strippedSentence.length - 1 ? strippedSentence.charAt(i + 1) : '';
+
+                    // If it's letter-dot-letter, it's not sentence-ending punctuation
+                    // But exclude cases where the dot is part of an ellipsis (...)
+                    if (isAlpha(beforeDot) && isAlpha(afterDot)) {
+                        // Check if this is part of an ellipsis (three consecutive dots)
+                        const beforeBeforeDot = i > 1 ? strippedSentence.charAt(i - 2) : '';
+                        const afterAfterDot = i < strippedSentence.length - 2 ? strippedSentence.charAt(i + 2) : '';
+
+                        // If it's part of an ellipsis (...), treat it as sentence-ending punctuation
+                        if (beforeBeforeDot === '.' || afterAfterDot === '.') {
+                            // This is part of an ellipsis, so treat as sentence-ending punctuation
+                        } else {
+                            // This is a letter-dot-letter pattern, skip it
+                            continue;
+                        }
+                    }
+                }
+
+                // Special handling for question marks: check if it's part of a URL query parameter
+                // (like ?param=value in URLs)
+                if (char === '?') {
+                    // Check if this question mark is part of a URL query parameter
+                    const afterQuestion = i < strippedSentence.length - 1 ? strippedSentence.charAt(i + 1) : '';
+                    const beforeQuestion = i > 0 ? strippedSentence.charAt(i - 1) : '';
+
+                    // If it's followed by alphanumeric characters (like ?param=value),
+                    // it's likely part of a URL query parameter, not sentence-ending punctuation
+                    if (isAlnum(afterQuestion)) {
+                        // This is likely a URL query parameter, skip it
+                        continue;
+                    }
+                }
+
+                // Found sentence-ending punctuation before inverted punctuation
+                return { correct: false, position: strippedOffset };
+            }
+        }
+
+        // If we reach the start without finding either, it's incorrect
+        return { correct: false, position: strippedOffset };
     }
 
     /**
@@ -490,7 +682,7 @@ class ResourceSentenceEnding extends ResourceRule {
      * @param {string} target - The target string
      * @param {string} incorrectPunctuation - The incorrect punctuation
      * @param {string} correctPunctuation - The correct punctuation
-     * @returns {Fix|undefined} - The fix object or undefined if no fix can be created
+     * @returns {ResourceFix|undefined} - The fix object or undefined if no fix can be created
      */
     createPunctuationFix(resource, target, incorrectPunctuation, correctPunctuation, index, category, targetLocaleObj) {
         // Get the last sentence to find the position
@@ -547,7 +739,7 @@ class ResourceSentenceEnding extends ResourceRule {
      * @param {string} character - The character to insert
      * @param {number} [index] - Index for array/plural resources
      * @param {string} [category] - Category for plural resources
-     * @returns {Fix|undefined} - The fix object or undefined if no fix can be created
+     * @returns {ResourceFix|undefined} - The fix object or undefined if no fix can be created
      */
     createInsertCharacterFix(resource, target, position, character, index, category) {
         return ResourceFixer.createFix({
@@ -576,7 +768,7 @@ class ResourceSentenceEnding extends ResourceRule {
      * @param {number} [index] - Index for array/plural resources
      * @param {string} [category] - Category for plural resources
      * @param {Locale} [targetLocaleObj] - The target locale object (unused, kept for compatibility)
-     * @returns {Fix|undefined} - The fix object or undefined if no fix can be created
+     * @returns {ResourceFix|undefined} - The fix object or undefined if no fix can be created
      */
     createFixForSpanishInvertedPunctuation(resource, target, lastSentence, correctPunctuation, index, category, targetLocaleObj) {
         const lastSentenceStart = target.lastIndexOf(lastSentence);
@@ -592,7 +784,7 @@ class ResourceSentenceEnding extends ResourceRule {
      * @param {string} nonBreakingSpace - The non-breaking space character to insert
      * @param {number} [index] - Index for array/plural resources
      * @param {string} [category] - Category for plural resources
-     * @returns {Fix|undefined} - The fix object or undefined if no fix can be created
+     * @returns {ResourceFix|undefined} - The fix object or undefined if no fix can be created
      */
     createFixForFrenchNonBreakingSpace(resource, target, position, nonBreakingSpace, index, category) {
         return ResourceFixer.createFix({
@@ -618,7 +810,7 @@ class ResourceSentenceEnding extends ResourceRule {
      * @param {string} currentSpace - The current space character (or empty string if none)
      * @param {number} [index] - Index for array/plural resources
      * @param {string} [category] - Category for plural resources
-     * @returns {Fix|undefined} - The fix object or undefined if no fix is needed
+     * @returns {ResourceFix|undefined} - The fix object or undefined if no fix is needed
      */
     createFrenchSpacingFix(resource, target, spacePosition, needsNonBreakingSpace, currentSpace, index, category) {
         const regularSpace = ' ';
@@ -733,6 +925,29 @@ class ResourceSentenceEnding extends ResourceRule {
         const sourceLanguage = sourceLocaleObj.getLanguage();
         if (!sourceLanguage) return undefined;
 
+        // Exception 1: Check minimum length
+        if (source.length < this.minimumLength) {
+            return undefined;
+        }
+
+        // Exception 2: Check if source has no spaces AND doesn't end with sentence-ending punctuation (not a sentence)
+        if (!source.includes(' ')) {
+            const trimmed = source.trim();
+            const lastChar = trimmed.charAt(trimmed.length - 1);
+            const sentenceEndingChars = ['.', '?', '!', '。', '？', '！', '…', ':'];
+            if (!sentenceEndingChars.includes(lastChar)) {
+                return undefined; // Not a sentence
+            }
+        }
+
+        // Exception 3: Check if source is in exception list
+        const exceptions = this.exceptionsMap[targetLanguage];
+        if (exceptions) {
+            if (exceptions.some(exception => exception.toLowerCase().trim() === source.toLowerCase().trim())) {
+                return undefined;
+            }
+        }
+
         const optionalPunctuationLanguages = ['th', 'lo', 'my', 'km', 'vi', 'id', 'ms', 'tl', 'jv', 'su'];
         const isOptionalPunctuationLanguage = optionalPunctuationLanguages.includes(targetLanguage);
 
@@ -779,7 +994,7 @@ class ResourceSentenceEnding extends ResourceRule {
                 rule: this,
                 severity: "warning",
                 id: resource.getKey(),
-                description: `Sentence ending should be "" for ${targetLocale} locale instead of "${targetEnding.original}" (${unicodeCode})`,
+                description: `Sentence ending should be no punctuation for ${targetLocale} locale instead of "${targetEnding.original}" (${unicodeCode})`,
                 source,
                 highlight,
                 pathName: file,
@@ -819,7 +1034,7 @@ class ResourceSentenceEnding extends ResourceRule {
                 rule: this,
                 severity: "warning",
                 id: resource.getKey(),
-                description: `Sentence ending should be "${insertString}" (${unicodeCode}) for ${targetLocale} locale instead of ""`,
+                description: `Sentence ending should be "${insertString}" (${unicodeCode}) for ${targetLocale} locale instead of ${ResourceSentenceEnding.formatPunctuationForMessage('')}`,
                 source,
                 highlight,
                 pathName: file,
@@ -836,7 +1051,25 @@ class ResourceSentenceEnding extends ResourceRule {
 
             // For Spanish, check for inverted punctuation at the beginning
             if (targetLanguage === 'es' && (sourceEnding.type === 'question' || sourceEnding.type === 'exclamation')) {
-                if (!this.hasCorrectSpanishInvertedPunctuation(lastSentence, sourceEnding.type)) {
+                // For Spanish inverted punctuation, we need to check the appropriate part of the target:
+                // - If source ends with quote, check the quoted content (lastSentence already contains this)
+                // - If source doesn't end with quote, check the full target string
+                // - However, if lastSentence is the result of getLastSentenceFromContent (which extracts
+                //   only the part after the last sentence-ending punctuation), we should check the full target
+                //   because inverted punctuation should be at the beginning of the entire sentence
+                // For Spanish inverted punctuation, we need to check the appropriate part of the target:
+                // - If source ends with quote, check the quoted content (lastSentence already contains this)
+                // - If source doesn't end with quote, check the lastSentence (which contains the relevant part)
+                //   because inverted punctuation should be at the beginning of the sentence being checked
+                // - Special case: if lastSentence is very short (like "com?" from email addresses or "bar?" from URLs),
+                //   use the full target string instead
+                let stringToCheck = lastSentence;
+                if (lastSentence.length < 10 && !lastSentence.startsWith('¿') && !lastSentence.startsWith('¡')) {
+                    // This might be a fragment from an email address, URL, or similar, use the full target
+                    stringToCheck = target;
+                }
+                const invertedPunctuationResult = this.hasCorrectSpanishInvertedPunctuation(stringToCheck, sourceEnding.type, targetLocaleObj);
+                if (!invertedPunctuationResult.correct) {
                     // Spanish target is missing inverted punctuation at the beginning
                     const quoteChars = ResourceSentenceEnding.allQuoteChars;
                     let quotedContentStart = -1;
@@ -852,7 +1085,18 @@ class ResourceSentenceEnding extends ResourceRule {
                         const afterQuote = target.substring(quotedContentStart);
                         highlight = `${beforeQuote}<e0/>${afterQuote}`;
                     } else {
-                        highlight = `<e0/>${target}`;
+                        // For multi-sentence strings, find where the last sentence starts
+                        const lastSentenceStart = target.lastIndexOf(lastSentence);
+                        if (lastSentenceStart !== -1 && stringToCheck === lastSentence) {
+                            // Use the position from hasCorrectSpanishInvertedPunctuation for more precise highlighting
+                            const highlightPosition = lastSentenceStart + invertedPunctuationResult.position;
+                            const beforeHighlight = target.substring(0, highlightPosition);
+                            const afterHighlight = target.substring(highlightPosition);
+                            highlight = `${beforeHighlight}<e0/>${afterHighlight}`;
+                        } else {
+                            // If we're using the full target string (due to URL/email special case), highlight at the beginning
+                            highlight = `<e0/>${target}`;
+                        }
                     }
 
                     // Add prefix for array/plural resources
@@ -952,7 +1196,7 @@ class ResourceSentenceEnding extends ResourceRule {
             const expectedUnicode = ResourceSentenceEnding.getUnicodeCodes(expectedPunctuation);
             const positionInfo = this.findIncorrectPunctuationPosition(target, lastSentence, targetEnding.original);
 
-            description = `Sentence ending should be "${expectedPunctuation}" (${expectedUnicode}) for ${targetLocale} locale instead of "${targetEnding.original}" (${unicodeCode})`;
+            description = `Sentence ending should be ${ResourceSentenceEnding.formatPunctuationForMessage(expectedPunctuation)} (${expectedUnicode}) for ${targetLocale} locale instead of ${ResourceSentenceEnding.formatPunctuationForMessage(targetEnding.original)} (${unicodeCode})`;
 
             if (positionInfo) {
                 const beforePunctuation = target.substring(0, positionInfo.position);
@@ -968,7 +1212,7 @@ class ResourceSentenceEnding extends ResourceRule {
                         const expectedUnicodeWithSpace = ResourceSentenceEnding.getUnicodeCodes(expectedWithSpace);
 
                         highlight = `${beforePunctuation}<e0/>`;
-                        description = `Sentence ending should be "${expectedWithSpace}" (${expectedUnicodeWithSpace}) for ${targetLocale} locale instead of ""`;
+                        description = `Sentence ending should be "${expectedWithSpace}" (${expectedUnicodeWithSpace}) for ${targetLocale} locale instead of no punctuation`;
                         fix = this.createPunctuationFix(resource, target, '', expectedWithSpace, index, category, targetLocaleObj);
                     } else {
                         // Target has some punctuation - check for spacing issues