@cspell/cspell-types 10.3.0 → 10.3.1-alpha.1

package/cspell.schema.json

@@ -1377,6 +1377,18 @@
           "markdownDescription": "Defines a list of patterns that can be used with the  {@link  ignoreRegExpList }  and\n {@link  includeRegExpList }  options.\n\nFor example:\n\n```javascript\n\"ignoreRegExpList\": [\"comments\"],\n\"patterns\": [\n  {\n    \"name\": \"comment-single-line\",\n    \"pattern\": \"/#.*/g\"\n  },\n  {\n    \"name\": \"comment-multi-line\",\n    \"pattern\": \"/(?:\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\/)/g\"\n  },\n  // You can also combine multiple named patterns into one single named pattern\n  {\n    \"name\": \"comments\",\n    \"pattern\": [\"comment-single-line\", \"comment-multi-line\"]\n  }\n]\n```",
           "type": "array"
         },
+        "softWordBreakDefinitions": {
+          "$ref": "#/definitions/SoftWordBreakDefinitions",
+          "description": "Defines a set of word break rules that can be used for text segmentation.\n\nSoft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.\n\nThis allows for word breaks that might not be captured by the camel case detection.\n\nNote: soft-hyphens are removed before checking the word against the dictionaries.\n\nFor example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code` `error|code`, the following words would be checked against the dictionaries: `errorcode`, `error`, and `code`.",
+          "markdownDescription": "Defines a set of word break rules that can be used for text segmentation.\n\nSoft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.\n\nThis allows for word breaks that might not be captured by the camel case detection.\n\nNote: soft-hyphens are removed before checking the word against the dictionaries.\n\nFor example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code`\n`error|code`, the following words would be checked against\nthe dictionaries: `errorcode`, `error`, and `code`.",
+          "since": "10.3.1"
+        },
+        "softWordBreaks": {
+          "$ref": "#/definitions/SoftWordBreaks",
+          "description": "Allows enabling or disabling soft word break rules by name.",
+          "markdownDescription": "Allows enabling or disabling soft word break rules by name.",
+          "since": "10.3.1"
+        },
         "substitutionDefinitions": {
           "$ref": "#/definitions/SubstitutionDefinitions",
           "description": "The set of available substitutions. This is a collection of substitution definitions that can be applied to a document before spell checking.",
@@ -1663,6 +1675,18 @@
           "markdownDescription": "The PnP files to search for. Note: `.mjs` files are not currently supported.",
           "type": "array"
         },
+        "softWordBreakDefinitions": {
+          "$ref": "#/definitions/SoftWordBreakDefinitions",
+          "description": "Defines a set of word break rules that can be used for text segmentation.\n\nSoft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.\n\nThis allows for word breaks that might not be captured by the camel case detection.\n\nNote: soft-hyphens are removed before checking the word against the dictionaries.\n\nFor example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code` `error|code`, the following words would be checked against the dictionaries: `errorcode`, `error`, and `code`.",
+          "markdownDescription": "Defines a set of word break rules that can be used for text segmentation.\n\nSoft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.\n\nThis allows for word breaks that might not be captured by the camel case detection.\n\nNote: soft-hyphens are removed before checking the word against the dictionaries.\n\nFor example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code`\n`error|code`, the following words would be checked against\nthe dictionaries: `errorcode`, `error`, and `code`.",
+          "since": "10.3.1"
+        },
+        "softWordBreaks": {
+          "$ref": "#/definitions/SoftWordBreaks",
+          "description": "Allows enabling or disabling soft word break rules by name.",
+          "markdownDescription": "Allows enabling or disabling soft word break rules by name.",
+          "since": "10.3.1"
+        },
         "substitutionDefinitions": {
           "$ref": "#/definitions/SubstitutionDefinitions",
           "description": "The set of available substitutions. This is a collection of substitution definitions that can be applied to a document before spell checking.",
@@ -1939,6 +1963,60 @@
       "markdownDescription": "Simple Glob string, the root will be globRoot.",
       "type": "string"
     },
+    "SoftWordBreak": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/SoftWordBreakRegExpString"
+        },
+        {
+          "$ref": "#/definitions/SoftWordBreakPattern"
+        }
+      ]
+    },
+    "SoftWordBreakDefinitions": {
+      "additionalProperties": {
+        "$ref": "#/definitions/SoftWordBreakRule",
+        "description": "A named set of soft word break rules.",
+        "markdownDescription": "A named set of soft word break rules."
+      },
+      "description": "Defines a set of word break rules that can be used for text segmentation.\n\nSoft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.\n\nThis allows for word breaks that might not be captured by the camel case detection.\n\nNote: soft-hyphens are removed before checking the word against the dictionaries.\n\nFor example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code` `error|code`, the following words would be checked against the dictionaries: `errorcode`, `error`, and `code`.",
+      "markdownDescription": "Defines a set of word break rules that can be used for text segmentation.\n\nSoft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.\n\nThis allows for word breaks that might not be captured by the camel case detection.\n\nNote: soft-hyphens are removed before checking the word against the dictionaries.\n\nFor example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code`\n`error|code`, the following words would be checked against\nthe dictionaries: `errorcode`, `error`, and `code`.",
+      "since": "10.3.1",
+      "type": "object"
+    },
+    "SoftWordBreakPattern": {
+      "description": "Defines a word break rule based on a string.\n\nFormat:\n- `\"before|after\"` -- Matches a word break between `before` and `after`\n- `\"before|after$\"` -- Matches a word break between `before` and `after` at the end of a word\n- `\"^before|after\"` -- Matches a word break between `before` at the start of a word and `after`\n- `\"^before|after$\"` -- Matches a word break between `before` at the start of a word and `after` at the end of a word\n- `\"before|\"` -- Matches a word break after `before`\n- `\"^before|\"` -- Matches a word break after `before` at the start of a word\n- `\"|after\"` -- Matches a word break before `after`\n- `\"|after$\"` -- Matches a word break before `after` at the end of a word\n\n\nWhere `before` is the text before the word break and `after` is the text after the word break.\n\nSpecial characters like `|`, `^`, and `$` have specific meanings.\n- `|` -- Represents the position of the word break\n- `^` -- Indicates the start of a word\n- `$` -- Indicates the end of a word\n\nFor more complicated word break rules, consider using regular expressions with the  {@link  SoftWordBreakRegExp }  type.\n\nExamples:\n- `\"^ptr|\"` -- Would help with pointer definitions starting with `ptr`, such as `ptrvalue`.\n- `\"^I|\"` -- Would help with interface definitions starting with `I`, such as `IERROR`.",
+      "markdownDescription": "Defines a word break rule based on a string.\n\nFormat:\n- `\"before|after\"` -- Matches a word break between `before` and `after`\n- `\"before|after$\"` -- Matches a word break between `before` and `after` at the end of a word\n- `\"^before|after\"` -- Matches a word break between `before` at the start of a word and `after`\n- `\"^before|after$\"` -- Matches a word break between `before` at the start of a word and `after` at the end of a word\n- `\"before|\"` -- Matches a word break after `before`\n- `\"^before|\"` -- Matches a word break after `before` at the start of a word\n- `\"|after\"` -- Matches a word break before `after`\n- `\"|after$\"` -- Matches a word break before `after` at the end of a word\n\n\nWhere `before` is the text before the word break and `after` is the text after the word break.\n\nSpecial characters like `|`, `^`, and `$` have specific meanings.\n- `|` -- Represents the position of the word break\n- `^` -- Indicates the start of a word\n- `$` -- Indicates the end of a word\n\nFor more complicated word break rules, consider using regular expressions with the  {@link  SoftWordBreakRegExp }  type.\n\nExamples:\n- `\"^ptr|\"` -- Would help with pointer definitions starting with `ptr`, such as `ptrvalue`.\n- `\"^I|\"` -- Would help with interface definitions starting with `I`, such as `IERROR`.",
+      "since": "10.3.1",
+      "type": "string"
+    },
+    "SoftWordBreakRegExpString": {
+      "description": "Represents a regular expression used for word break rules.\n\nThe matching string will be prefixed and suffixed with a soft-hyphen. If the matching string is zero length, only a single soft-hyphen will be inserted. It is best to use lookahead and lookbehind assertions to ensure correct word break positions.\n\nExamples:\n- `\"/(?<=\\\\bptr)/\"` -- The break would occur after the `ptr`, helping with pointer definitions starting with `ptr`, such as `ptrvalue`.\n- `\"/(?<=\\\\bI)(?=[A-Z])/\"` -- The break would occur before an uppercase letter following an `I` at a word boundary, helping with interface definitions like `IError`.",
+      "markdownDescription": "Represents a regular expression used for word break rules.\n\nThe matching string will be prefixed and suffixed with a soft-hyphen.\nIf the matching string is zero length, only a single soft-hyphen will be inserted.\nIt is best to use lookahead and lookbehind assertions to ensure correct word break positions.\n\nExamples:\n- `\"/(?<=\\\\bptr)/\"` -- The break would occur after the `ptr`, helping with pointer definitions starting with `ptr`, such as `ptrvalue`.\n- `\"/(?<=\\\\bI)(?=[A-Z])/\"` -- The break would occur before an uppercase letter following an `I` at a word boundary, helping with interface definitions like `IError`.",
+      "since": "10.3.1",
+      "type": "string"
+    },
+    "SoftWordBreakRule": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/SoftWordBreak"
+        },
+        {
+          "items": {
+            "$ref": "#/definitions/SoftWordBreak"
+          },
+          "type": "array"
+        }
+      ]
+    },
+    "SoftWordBreaks": {
+      "additionalProperties": {
+        "type": "boolean"
+      },
+      "description": "Allows enabling or disabling soft word break rules by name.",
+      "markdownDescription": "Allows enabling or disabling soft word break rules by name.",
+      "type": "object"
+    },
     "SubstitutionDefinition": {
       "additionalProperties": false,
       "description": "Allows for the definition of a substitution set. A substitution set is a collection of substitution entries that can be applied to a document before spell checking. This is useful for converting html entities, url encodings, or other transformations that may be necessary to get the correct text for spell checking.\n\nSubstitutions are applied based upon the longest matching find string. If there are multiple matches of the same `find`, the last one in the list is used. This allows for the overriding of substitutions. For example, if you have a substitution for `&` to `and`, and then a substitution for `&amp;` to `&`, the `&amp;` substitution will be used for the string `&amp;`, and the `&` substitution will be used for the string `&`.",
@@ -2402,6 +2480,18 @@
       "markdownDescription": "Show status.",
       "type": "boolean"
     },
+    "softWordBreakDefinitions": {
+      "$ref": "#/definitions/SoftWordBreakDefinitions",
+      "description": "Defines a set of word break rules that can be used for text segmentation.\n\nSoft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.\n\nThis allows for word breaks that might not be captured by the camel case detection.\n\nNote: soft-hyphens are removed before checking the word against the dictionaries.\n\nFor example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code` `error|code`, the following words would be checked against the dictionaries: `errorcode`, `error`, and `code`.",
+      "markdownDescription": "Defines a set of word break rules that can be used for text segmentation.\n\nSoft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.\n\nThis allows for word breaks that might not be captured by the camel case detection.\n\nNote: soft-hyphens are removed before checking the word against the dictionaries.\n\nFor example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code`\n`error|code`, the following words would be checked against\nthe dictionaries: `errorcode`, `error`, and `code`.",
+      "since": "10.3.1"
+    },
+    "softWordBreaks": {
+      "$ref": "#/definitions/SoftWordBreaks",
+      "description": "Allows enabling or disabling soft word break rules by name.",
+      "markdownDescription": "Allows enabling or disabling soft word break rules by name.",
+      "since": "10.3.1"
+    },
     "spellCheckDelayMs": {
       "deprecated": true,
       "description": "Delay in ms after a document has changed before checking it for spelling errors.",

package/dist/index.d.mts

@@ -1226,6 +1226,128 @@ type Substitutions = (SubstitutionEntry | SubstitutionID)[];
 //#region src/types.d.ts
 type Serializable = number | string | boolean | null | object;
 //#endregion
+//#region src/WordSegmentation.d.ts
+interface WordSegmentationSettings {
+  /**
+   * Enables enables locale-sensitive text segmentation to support languages like Japanese, Chinese, Thai, Lao, Khmer, Myanmar, etc.
+   * The locale used for the segmentation is based on the {@link language} setting.
+   *
+   * @since 10.2.0
+   */
+  useIntlWordSegmentation?: boolean;
+  /**
+   * Defines a set of word break rules that can be used for text segmentation.
+   *
+   * Soft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.
+   *
+   * This allows for word breaks that might not be captured by the camel case detection.
+   *
+   * Note: soft-hyphens are removed before checking the word against the dictionaries.
+   *
+   * For example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code`
+   * `error|code`, the following words would be checked against
+   * the dictionaries: `errorcode`, `error`, and `code`.
+   *
+   * @since 10.3.1
+   */
+  softWordBreakDefinitions?: SoftWordBreakDefinitions;
+  /**
+   * Allows enabling or disabling soft word break rules by name.
+   *
+   * @since 10.3.1
+   */
+  softWordBreaks?: SoftWordBreaks;
+}
+/**
+ * Represents a regular expression used for word break rules.
+ *
+ * The matching string will be prefixed and suffixed with a soft-hyphen.
+ * If the matching string is zero length, only a single soft-hyphen will be inserted.
+ * It is best to use lookahead and lookbehind assertions to ensure correct word break positions.
+ *
+ * Examples:
+ * - `/(?<=\bptr)/` -- The break would occur after the `ptr`, helping with pointer definitions starting with `ptr`, such as `ptrvalue`.
+ * - `/(?<=\bI)(?=[A-Z])/` -- The break would occur before an uppercase letter following an `I` at a word boundary, helping with interface definitions like `IError`.
+ *
+ * @since 10.3.1
+ * @note Hidden to prevent it from being exposed in the json-schema.
+ * @hidden
+ */
+type SoftWordBreakRegExp = RegExp;
+/**
+ * Represents a regular expression used for word break rules.
+ *
+ * The matching string will be prefixed and suffixed with a soft-hyphen.
+ * If the matching string is zero length, only a single soft-hyphen will be inserted.
+ * It is best to use lookahead and lookbehind assertions to ensure correct word break positions.
+ *
+ * Examples:
+ * - `"/(?<=\\bptr)/"` -- The break would occur after the `ptr`, helping with pointer definitions starting with `ptr`, such as `ptrvalue`.
+ * - `"/(?<=\\bI)(?=[A-Z])/"` -- The break would occur before an uppercase letter following an `I` at a word boundary, helping with interface definitions like `IError`.
+ *
+ * @since 10.3.1
+ */
+type SoftWordBreakRegExpString = string;
+/**
+ * Defines a word break rule based on a string.
+ *
+ * Format:
+ * - `"before|after"` -- Matches a word break between `before` and `after`
+ * - `"before|after$"` -- Matches a word break between `before` and `after` at the end of a word
+ * - `"^before|after"` -- Matches a word break between `before` at the start of a word and `after`
+ * - `"^before|after$"` -- Matches a word break between `before` at the start of a word and `after` at the end of a word
+ * - `"before|"` -- Matches a word break after `before`
+ * - `"^before|"` -- Matches a word break after `before` at the start of a word
+ * - `"|after"` -- Matches a word break before `after`
+ * - `"|after$"` -- Matches a word break before `after` at the end of a word
+ *
+ *
+ * Where `before` is the text before the word break and `after` is the text after the word break.
+ *
+ * Special characters like `|`, `^`, and `$` have specific meanings.
+ * - `|` -- Represents the position of the word break
+ * - `^` -- Indicates the start of a word
+ * - `$` -- Indicates the end of a word
+ *
+ * For more complicated word break rules, consider using regular expressions with the {@link SoftWordBreakRegExp} type.
+ *
+ * Examples:
+ * - `"^ptr|"` -- Would help with pointer definitions starting with `ptr`, such as `ptrvalue`.
+ * - `"^I|"` -- Would help with interface definitions starting with `I`, such as `IERROR`.
+ *
+ * @since 10.3.1
+ */
+type SoftWordBreakPattern = string;
+type SoftWordBreakRule = SoftWordBreak | SoftWordBreak[];
+type SoftWordBreak = SoftWordBreakRegExpString | SoftWordBreakPattern | SoftWordBreakRegExp;
+/**
+ * Defines a set of word break rules that can be used for text segmentation.
+ *
+ * Soft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.
+ *
+ * This allows for word breaks that might not be captured by the camel case detection.
+ *
+ * Note: soft-hyphens are removed before checking the word against the dictionaries.
+ *
+ * For example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code`
+ * `error|code`, the following words would be checked against
+ * the dictionaries: `errorcode`, `error`, and `code`.
+ *
+ * @since 10.3.1
+ */
+interface SoftWordBreakDefinitions {
+  /**
+   * A named set of soft word break rules.
+   */
+  [name: string]: SoftWordBreakRule;
+}
+/**
+ * Allows enabling or disabling soft word break rules by name.
+ */
+interface SoftWordBreaks {
+  [name: string]: boolean;
+}
+//#endregion
 //#region src/CSpellSettingsDef.d.ts
 /**
  * These settings come from user and workspace settings.
@@ -1637,7 +1759,7 @@ interface OverrideFilterFields {
   /** Glob pattern or patterns to match against. */
   filename: Glob | Glob[];
 }
-interface BaseSetting extends InlineDictionary, ExperimentalBaseSettings, UnknownWordsConfiguration {
+interface BaseSetting extends InlineDictionary, ExperimentalBaseSettings, UnknownWordsConfiguration, WordSegmentationSettings {
   /** Optional identifier. */
   id?: string;
   /** Optional name of configuration. */
@@ -1774,13 +1896,6 @@ interface BaseSetting extends InlineDictionary, ExperimentalBaseSettings, Unknow
    * @since 9.7.0
    */
   substitutions?: Substitutions;
-  /**
-   * Enables enables locale-sensitive text segmentation to support languages like Japanese, Chinese, Thai, Lao, Khmer, Myanmar, etc.
-   * The locale used for the segmentation is based on the {@link language} setting.
-   *
-   * @since 10.2.0
-   */
-  useIntlWordSegmentation?: boolean;
 }
 interface LanguageSetting extends LanguageSettingFilterFields, BaseSetting {}
 interface LanguageSettingFilterFields extends LanguageSettingFilterFieldsPreferred, LanguageSettingFilterFieldsDeprecated {}

package/dist/index.d.ts

@@ -1226,6 +1226,128 @@ type Substitutions = (SubstitutionEntry | SubstitutionID)[];
 //#region src/types.d.ts
 type Serializable = number | string | boolean | null | object;
 //#endregion
+//#region src/WordSegmentation.d.ts
+interface WordSegmentationSettings {
+  /**
+   * Enables enables locale-sensitive text segmentation to support languages like Japanese, Chinese, Thai, Lao, Khmer, Myanmar, etc.
+   * The locale used for the segmentation is based on the {@link language} setting.
+   *
+   * @since 10.2.0
+   */
+  useIntlWordSegmentation?: boolean;
+  /**
+   * Defines a set of word break rules that can be used for text segmentation.
+   *
+   * Soft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.
+   *
+   * This allows for word breaks that might not be captured by the camel case detection.
+   *
+   * Note: soft-hyphens are removed before checking the word against the dictionaries.
+   *
+   * For example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code`
+   * `error|code`, the following words would be checked against
+   * the dictionaries: `errorcode`, `error`, and `code`.
+   *
+   * @since 10.3.1
+   */
+  softWordBreakDefinitions?: SoftWordBreakDefinitions;
+  /**
+   * Allows enabling or disabling soft word break rules by name.
+   *
+   * @since 10.3.1
+   */
+  softWordBreaks?: SoftWordBreaks;
+}
+/**
+ * Represents a regular expression used for word break rules.
+ *
+ * The matching string will be prefixed and suffixed with a soft-hyphen.
+ * If the matching string is zero length, only a single soft-hyphen will be inserted.
+ * It is best to use lookahead and lookbehind assertions to ensure correct word break positions.
+ *
+ * Examples:
+ * - `/(?<=\bptr)/` -- The break would occur after the `ptr`, helping with pointer definitions starting with `ptr`, such as `ptrvalue`.
+ * - `/(?<=\bI)(?=[A-Z])/` -- The break would occur before an uppercase letter following an `I` at a word boundary, helping with interface definitions like `IError`.
+ *
+ * @since 10.3.1
+ * @note Hidden to prevent it from being exposed in the json-schema.
+ * @hidden
+ */
+type SoftWordBreakRegExp = RegExp;
+/**
+ * Represents a regular expression used for word break rules.
+ *
+ * The matching string will be prefixed and suffixed with a soft-hyphen.
+ * If the matching string is zero length, only a single soft-hyphen will be inserted.
+ * It is best to use lookahead and lookbehind assertions to ensure correct word break positions.
+ *
+ * Examples:
+ * - `"/(?<=\\bptr)/"` -- The break would occur after the `ptr`, helping with pointer definitions starting with `ptr`, such as `ptrvalue`.
+ * - `"/(?<=\\bI)(?=[A-Z])/"` -- The break would occur before an uppercase letter following an `I` at a word boundary, helping with interface definitions like `IError`.
+ *
+ * @since 10.3.1
+ */
+type SoftWordBreakRegExpString = string;
+/**
+ * Defines a word break rule based on a string.
+ *
+ * Format:
+ * - `"before|after"` -- Matches a word break between `before` and `after`
+ * - `"before|after$"` -- Matches a word break between `before` and `after` at the end of a word
+ * - `"^before|after"` -- Matches a word break between `before` at the start of a word and `after`
+ * - `"^before|after$"` -- Matches a word break between `before` at the start of a word and `after` at the end of a word
+ * - `"before|"` -- Matches a word break after `before`
+ * - `"^before|"` -- Matches a word break after `before` at the start of a word
+ * - `"|after"` -- Matches a word break before `after`
+ * - `"|after$"` -- Matches a word break before `after` at the end of a word
+ *
+ *
+ * Where `before` is the text before the word break and `after` is the text after the word break.
+ *
+ * Special characters like `|`, `^`, and `$` have specific meanings.
+ * - `|` -- Represents the position of the word break
+ * - `^` -- Indicates the start of a word
+ * - `$` -- Indicates the end of a word
+ *
+ * For more complicated word break rules, consider using regular expressions with the {@link SoftWordBreakRegExp} type.
+ *
+ * Examples:
+ * - `"^ptr|"` -- Would help with pointer definitions starting with `ptr`, such as `ptrvalue`.
+ * - `"^I|"` -- Would help with interface definitions starting with `I`, such as `IERROR`.
+ *
+ * @since 10.3.1
+ */
+type SoftWordBreakPattern = string;
+type SoftWordBreakRule = SoftWordBreak | SoftWordBreak[];
+type SoftWordBreak = SoftWordBreakRegExpString | SoftWordBreakPattern | SoftWordBreakRegExp;
+/**
+ * Defines a set of word break rules that can be used for text segmentation.
+ *
+ * Soft word breaks are done through injecting soft-hyphens at the appropriate positions in the text before spell checking.
+ *
+ * This allows for word breaks that might not be captured by the camel case detection.
+ *
+ * Note: soft-hyphens are removed before checking the word against the dictionaries.
+ *
+ * For example, if there is a soft-hyphen (represented by a `|`) injected between `error` and `code`
+ * `error|code`, the following words would be checked against
+ * the dictionaries: `errorcode`, `error`, and `code`.
+ *
+ * @since 10.3.1
+ */
+interface SoftWordBreakDefinitions {
+  /**
+   * A named set of soft word break rules.
+   */
+  [name: string]: SoftWordBreakRule;
+}
+/**
+ * Allows enabling or disabling soft word break rules by name.
+ */
+interface SoftWordBreaks {
+  [name: string]: boolean;
+}
+//#endregion
 //#region src/CSpellSettingsDef.d.ts
 /**
  * These settings come from user and workspace settings.
@@ -1637,7 +1759,7 @@ interface OverrideFilterFields {
   /** Glob pattern or patterns to match against. */
   filename: Glob | Glob[];
 }
-interface BaseSetting extends InlineDictionary, ExperimentalBaseSettings, UnknownWordsConfiguration {
+interface BaseSetting extends InlineDictionary, ExperimentalBaseSettings, UnknownWordsConfiguration, WordSegmentationSettings {
   /** Optional identifier. */
   id?: string;
   /** Optional name of configuration. */
@@ -1774,13 +1896,6 @@ interface BaseSetting extends InlineDictionary, ExperimentalBaseSettings, Unknow
    * @since 9.7.0
    */
   substitutions?: Substitutions;
-  /**
-   * Enables enables locale-sensitive text segmentation to support languages like Japanese, Chinese, Thai, Lao, Khmer, Myanmar, etc.
-   * The locale used for the segmentation is based on the {@link language} setting.
-   *
-   * @since 10.2.0
-   */
-  useIntlWordSegmentation?: boolean;
 }
 interface LanguageSetting extends LanguageSettingFilterFields, BaseSetting {}
 interface LanguageSettingFilterFields extends LanguageSettingFilterFieldsPreferred, LanguageSettingFilterFieldsDeprecated {}

package/dist/index.js

@@ -44,6 +44,8 @@ const ConfigFields = {
 	readonly: "readonly",
 	reporters: "reporters",
 	showStatus: "showStatus",
+	softWordBreaks: "softWordBreaks",
+	softWordBreakDefinitions: "softWordBreakDefinitions",
 	spellCheckDelayMs: "spellCheckDelayMs",
 	substitutionDefinitions: "substitutionDefinitions",
 	substitutions: "substitutions",
@@ -91,8 +93,11 @@ function defineConfig(config) {
 }
 //#endregion
 //#region src/merge.ts
+/** Merge Append Arrays */
 const mArr = mergeAppendArrays;
+/** Merge Records */
 const mRec = mergeRecords;
+/** Extract Key Values */
 const exKV = extractKeyValues;
 const mergeDefinitionFunctions = {
 	$schema: (key) => recKV(key, void 0),
@@ -142,6 +147,8 @@ const mergeDefinitionFunctions = {
 	reporters: (key, settings) => recKV(key, mArr(exKV(key, settings))),
 	showStatus: (key, settings) => recKV(key, lastValue(exKV(key, settings))),
 	spellCheckDelayMs: (key, settings) => recKV(key, lastValue(exKV(key, settings))),
+	softWordBreaks: (key, settings) => recKV(key, mRec(exKV(key, settings))),
+	softWordBreakDefinitions: (key, settings) => recKV(key, mRec(exKV(key, settings))),
 	substitutionDefinitions: (key, settings) => recKV(key, mArr(exKV(key, settings))),
 	substitutions: (key, settings) => recKV(key, mArr(exKV(key, settings))),
 	suggestionNumChanges: (key, settings) => recKV(key, lastValue(exKV(key, settings))),

package/dist/index.mjs

@@ -43,6 +43,8 @@ const ConfigFields = {
 	readonly: "readonly",
 	reporters: "reporters",
 	showStatus: "showStatus",
+	softWordBreaks: "softWordBreaks",
+	softWordBreakDefinitions: "softWordBreakDefinitions",
 	spellCheckDelayMs: "spellCheckDelayMs",
 	substitutionDefinitions: "substitutionDefinitions",
 	substitutions: "substitutions",
@@ -90,8 +92,11 @@ function defineConfig(config) {
 }
 //#endregion
 //#region src/merge.ts
+/** Merge Append Arrays */
 const mArr = mergeAppendArrays;
+/** Merge Records */
 const mRec = mergeRecords;
+/** Extract Key Values */
 const exKV = extractKeyValues;
 const mergeDefinitionFunctions = {
 	$schema: (key) => recKV(key, void 0),
@@ -141,6 +146,8 @@ const mergeDefinitionFunctions = {
 	reporters: (key, settings) => recKV(key, mArr(exKV(key, settings))),
 	showStatus: (key, settings) => recKV(key, lastValue(exKV(key, settings))),
 	spellCheckDelayMs: (key, settings) => recKV(key, lastValue(exKV(key, settings))),
+	softWordBreaks: (key, settings) => recKV(key, mRec(exKV(key, settings))),
+	softWordBreakDefinitions: (key, settings) => recKV(key, mRec(exKV(key, settings))),
 	substitutionDefinitions: (key, settings) => recKV(key, mArr(exKV(key, settings))),
 	substitutions: (key, settings) => recKV(key, mArr(exKV(key, settings))),
 	suggestionNumChanges: (key, settings) => recKV(key, lastValue(exKV(key, settings))),

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "10.3.0",
+  "version": "10.3.1-alpha.1",
   "description": "Types for cspell and cspell-lib",
   "type": "commonjs",
   "sideEffects": false,
@@ -85,5 +85,5 @@
     "node": ">=22.18.0"
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-types#readme",
-  "gitHead": "d8abd59fa15da6da47955eb6fcca180e8b5cbdbf"
+  "gitHead": "aa0576e5b7e666a7e8645939871bcfe4fa2a7eb5"
 }