@treeviz/gedcom-parser 2.0.7 → 2.0.9

package/dist/factories/index.js

@@ -1394,6 +1394,20 @@ var LONG_NOTES = {
   "Bef.": "Before",
   "Aft.": "After"
 };
+var STANDARD_QUALIFIERS = {
+  ABT: "Abt.",
+  ABOUT: "Abt.",
+  BEF: "Bef.",
+  BEFORE: "Bef.",
+  AFT: "Aft.",
+  AFTER: "Aft."
+};
+var EXPORT_QUALIFIERS = {
+  "Abt.": "ABT",
+  "Bef.": "BEF",
+  "Aft.": "AFT"
+};
+var GEDCOM_MONTHS = /\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\b/g;
 var NOTE_MARKER = "####";
 var formatDateWithComponents = (date, hasDay, hasMonth, hasYear, noteValue, baseFormat = "dd MMM yyyy", locale) => {
   const hasNote = baseFormat.includes("NOTE");
@@ -1427,6 +1441,17 @@ var CommonDate = class extends Common {
         this.NOTE = this.NOTE || createCommon(this._gedcom, void 0, this.main);
         this.NOTE.value = noteMatch?.note;
         validValue = value.replace(noteRegExp, "");
+      } else {
+        const qualifierMatch = value.match(
+          /^(?<qualifier>ABT|ABOUT|BEF|BEFORE|AFT|AFTER)\b\s*/i
+        );
+        const qualifier = qualifierMatch?.groups?.qualifier?.toUpperCase();
+        const note = qualifier ? STANDARD_QUALIFIERS[qualifier] : void 0;
+        if (note) {
+          this.NOTE = this.NOTE || createCommon(this._gedcom, void 0, this.main);
+          this.NOTE.value = note;
+          validValue = value.slice(qualifierMatch[0].length);
+        }
       }
       const acceptedDate = this.isValidDateFormat(validValue);
       if (acceptedDate) {
@@ -1532,7 +1557,23 @@ var CommonDate = class extends Common {
     );
   }
   exportValue() {
-    return this.toValue("NOTE dd MMM yyyy", null);
+    const formatted = this.toValue("NOTE dd MMM yyyy", null);
+    if (!formatted) {
+      return formatted;
+    }
+    const note = this.NOTE?.value?.trim();
+    const qualifier = note ? EXPORT_QUALIFIERS[note] : void 0;
+    const standardized = qualifier ? formatted.replace(note, qualifier) : formatted;
+    return standardized.replace(
+      GEDCOM_MONTHS,
+      (month) => month.toUpperCase()
+    );
+  }
+  toGedcomLines(tag, level = 0, options) {
+    const internal = new RegExp(
+      `^${level} (DAY|MONTH|YEAR)( |$)|^${level} NOTE (Abt\\.|Bef\\.|Aft\\.)$`
+    );
+    return super.toGedcomLines(tag, level, options).filter((line) => !internal.test(line));
   }
   inRange(range, trueIfNoYear = false) {
     return inRange(this.YEAR?.value, range, trueIfNoYear);
@@ -1857,6 +1898,135 @@ var profilePictureCache = (gedcom, key, value) => {
   const cached = caches.profilePictureCache?.[fullKey];
   return cached;
 };
+var isNonBiologicalPath = (path) => path.some(
+  (item) => item.relation && item.relation !== "biological" /* BIOLOGICAL */
+);
+var invertHop = (kinship) => {
+  if (kinship === "parent") {
+    return "child";
+  }
+  if (kinship === "child") {
+    return "parent";
+  }
+  return kinship;
+};
+var hopRelation = (from, toIndi, kinship, inherited) => {
+  if (kinship === "parent" || kinship === "child") {
+    const parent = kinship === "parent" ? toIndi : from.indi;
+    const child = kinship === "parent" ? from.indi : toIndi;
+    const currentRelation = child.getParentType(parent);
+    if (currentRelation && currentRelation !== "biological" /* BIOLOGICAL */) {
+      return currentRelation;
+    }
+  }
+  if (inherited && inherited !== "biological" /* BIOLOGICAL */) {
+    return inherited;
+  }
+  return void 0;
+};
+var rebuildPathFromHops = (hops, skipRelation = false) => {
+  if (hops.length === 0) {
+    return [];
+  }
+  const path = [
+    {
+      indi: hops[0].indi,
+      kinship: "self",
+      level: 0,
+      levelUp: 0,
+      levelDown: 0,
+      degree: 0
+    }
+  ];
+  for (let i = 1; i < hops.length; i++) {
+    const prev = path[i - 1];
+    const { indi, kinship } = hops[i];
+    const relation = skipRelation ? void 0 : hopRelation(prev, indi, kinship, prev.relation);
+    if (kinship === "parent") {
+      path.push({
+        indi,
+        kinship,
+        relation,
+        level: prev.level + 1,
+        levelUp: prev.levelUp + 1,
+        levelDown: prev.levelDown,
+        degree: prev.degree
+      });
+      continue;
+    }
+    if (kinship === "child") {
+      path.push({
+        indi,
+        kinship,
+        relation,
+        level: prev.level - 1,
+        levelUp: prev.levelUp,
+        levelDown: prev.levelDown + 1,
+        degree: prev.levelUp ? prev.level > 0 ? prev.levelUp - prev.level + 1 : prev.levelDown - Math.abs(prev.level) : 0
+      });
+      continue;
+    }
+    path.push({
+      indi,
+      kinship,
+      relation,
+      level: prev.level,
+      levelUp: prev.levelUp,
+      levelDown: prev.levelDown,
+      degree: prev.degree
+    });
+  }
+  return path;
+};
+var storePathIfBetter = (gedcom, fromId, toId, path) => {
+  const key = `${fromId}|${toId}`;
+  const existing = pathCache(gedcom, key);
+  if (existing && (!isNonBiologicalPath(existing) || isNonBiologicalPath(path))) {
+    return;
+  }
+  pathCache(gedcom, key, path);
+};
+var cacheDiscoveredPath = (gedcom, path) => {
+  const n = path.length;
+  if (n < 2) {
+    return;
+  }
+  for (let i = 0; i < n; i++) {
+    const fromId = path[i].indi.id;
+    if (!fromId) {
+      continue;
+    }
+    for (let j = i + 1; j < n; j++) {
+      const toId = path[j].indi.id;
+      if (!toId) {
+        continue;
+      }
+      const isOriginalPair = i === 0 && j === n - 1;
+      const isDirectHop = j === i + 1;
+      const slice = path.slice(i, j + 1);
+      const sliceMixed = isNonBiologicalPath(slice);
+      if (!isOriginalPair && !isDirectHop && sliceMixed) {
+        continue;
+      }
+      const forward = i === 0 ? slice : rebuildPathFromHops(slice, !sliceMixed);
+      const reverseHops = [
+        {
+          indi: slice[slice.length - 1].indi,
+          kinship: "self"
+        }
+      ];
+      for (let k = slice.length - 2; k >= 0; k--) {
+        reverseHops.push({
+          indi: slice[k].indi,
+          kinship: invertHop(slice[k + 1].kinship)
+        });
+      }
+      const reverse = rebuildPathFromHops(reverseHops, !sliceMixed);
+      storePathIfBetter(gedcom, fromId, toId, forward);
+      storePathIfBetter(gedcom, toId, fromId, reverse);
+    }
+  }
+};
 
 // src/utils/get-places.ts
 var getPlaces = (common, type = ["ALL" /* All */], maxLevel = 1, level = 0, mainKey) => {
@@ -3905,7 +4075,6 @@ var Indi = class extends Common {
     if (cache) {
       return cache;
     }
-    const visited = new Individuals().append(this);
     const mainItem = {
       indi: this,
       level: 0,
@@ -3914,129 +4083,155 @@ var Indi = class extends Common {
       degree: 0,
       kinship: "self"
     };
-    const path = [mainItem];
+    const mainPath = [mainItem];
     if (this.id === usedIndi.id) {
-      return path;
+      return mainPath;
     }
-    const queue = [
-      {
-        ...mainItem,
-        path
-      }
-    ];
-    let helper = 0;
-    while (queue.length > 0) {
-      if (helper++ > 1e6) {
-        break;
-      }
-      const {
-        indi,
-        path: path2,
-        kinship,
-        relation,
-        level,
-        levelUp,
-        levelDown,
-        degree,
-        breakOnNext,
-        breakAfterNext,
-        inLaw
-      } = queue.shift();
-      if (usedIndi.id === indi.id) {
-        if (breakOnNext) {
-          return void 0;
+    const bfs = (biologicalOnly) => {
+      const visited = new Individuals().append(this);
+      const queue = [
+        {
+          ...mainItem,
+          path: mainPath
         }
-        pathCache(this._gedcom, cacheKey, path2);
-        return path2;
-      }
-      visited.append(indi);
-      const additional = {};
-      if (breakOnNext || breakAfterNext) {
-        additional.breakOnNext = breakOnNext || breakAfterNext;
-      }
-      if (inLaw) {
-        additional.inLaw = inLaw;
-      }
-      if (kinship === "spouse" && breakAfterSpouse) {
-        if (path2.length <= 2) {
-          additional.inLaw = true;
-        } else {
-          additional.breakOnNext = true;
+      ];
+      let helper = 0;
+      while (queue.length > 0) {
+        if (helper++ > 1e6) {
+          break;
         }
-      }
-      if (kinship !== "child" || !breakAfterSpouse) {
-        indi.getBiologicalFathers().copy().merge(indi.getBiologicalMothers()).merge(indi.getFathers().copy().merge(indi.getMothers())).forEach((relative) => {
+        const {
+          indi,
+          path,
+          kinship,
+          relation,
+          level,
+          levelUp,
+          levelDown,
+          degree,
+          breakOnNext,
+          breakAfterNext,
+          inLaw
+        } = queue.shift();
+        if (usedIndi.id === indi.id) {
+          if (breakOnNext) {
+            return void 0;
+          }
+          return path;
+        }
+        visited.append(indi);
+        const additional = {};
+        if (breakOnNext || breakAfterNext) {
+          additional.breakOnNext = breakOnNext || breakAfterNext;
+        }
+        if (inLaw) {
+          additional.inLaw = inLaw;
+        }
+        if (!biologicalOnly && kinship === "spouse" && breakAfterSpouse) {
+          if (path.length <= 2) {
+            additional.inLaw = true;
+          } else {
+            additional.breakOnNext = true;
+          }
+        }
+        if (kinship !== "child" || !breakAfterSpouse) {
+          indi.getBiologicalFathers().copy().merge(indi.getBiologicalMothers()).merge(indi.getFathers().copy().merge(indi.getMothers())).forEach((relative) => {
+            if (!visited.has(relative)) {
+              const currentRelation = indi.getParentType(relative);
+              const isNonBiological = !!currentRelation && currentRelation !== "biological" /* BIOLOGICAL */;
+              if (biologicalOnly && isNonBiological) {
+                return;
+              }
+              if (!biologicalOnly && breakAfterNonBiological && isNonBiological) {
+                additional.breakAfterNext = true;
+              }
+              const newItem = {
+                indi: relative,
+                kinship: "parent",
+                relation: isNonBiological ? currentRelation : relation,
+                level: level + 1,
+                levelUp: levelUp + 1,
+                levelDown,
+                degree,
+                ...additional
+              };
+              queue.push({
+                ...newItem,
+                path: [...path, newItem]
+              });
+            }
+          });
+        }
+        indi.getChildren().forEach((relative) => {
           if (!visited.has(relative)) {
-            const currentRelation = indi.getParentType(relative);
-            if (breakAfterNonBiological && currentRelation !== "biological" /* BIOLOGICAL */) {
+            const currentRelation = relative.getParentType(indi);
+            const isNonBiological = !!currentRelation && currentRelation !== "biological" /* BIOLOGICAL */;
+            if (biologicalOnly && isNonBiological) {
+              return;
+            }
+            if (!biologicalOnly && breakAfterNonBiological && isNonBiological) {
               additional.breakAfterNext = true;
             }
             const newItem = {
               indi: relative,
-              kinship: "parent",
-              relation: currentRelation && currentRelation !== "biological" /* BIOLOGICAL */ ? currentRelation : relation,
-              level: level + 1,
-              levelUp: levelUp + 1,
-              levelDown,
-              degree,
+              kinship: "child",
+              relation: isNonBiological ? currentRelation : relation,
+              level: level - 1,
+              levelUp,
+              levelDown: levelDown + 1,
+              degree: levelUp ? level > 0 ? levelUp - level + 1 : levelDown - Math.abs(level) : 0,
               ...additional
             };
             queue.push({
               ...newItem,
-              path: [...path2, newItem]
+              path: [...path, newItem]
             });
           }
         });
-      }
-      indi.getChildren().forEach((relative) => {
-        if (!visited.has(relative)) {
-          const currentRelation = relative.getParentType(indi);
-          if (breakAfterNonBiological && currentRelation !== "biological" /* BIOLOGICAL */) {
-            additional.breakAfterNext = true;
-          }
-          const newItem = {
-            indi: relative,
-            kinship: "child",
-            relation: currentRelation && currentRelation !== "biological" /* BIOLOGICAL */ ? currentRelation : relation,
-            level: level - 1,
-            levelUp,
-            levelDown: levelDown + 1,
-            degree: levelUp ? level > 0 ? levelUp - level + 1 : levelDown - Math.abs(level) : 0,
-            ...additional
-          };
-          queue.push({
-            ...newItem,
-            path: [...path2, newItem]
-          });
+        if (biologicalOnly) {
+          continue;
         }
-      });
-      indi.getCoParents().forEach((relative) => {
-        if (!visited.has(relative)) {
-          const currentAddition = {};
-          if (relation && relation !== "biological" /* BIOLOGICAL */) {
-            currentAddition.relation = relation;
-          }
-          if (inLaw) {
-            currentAddition.breakOnNext = true;
+        indi.getCoParents().forEach((relative) => {
+          if (!visited.has(relative)) {
+            const currentAddition = {};
+            if (relation && relation !== "biological" /* BIOLOGICAL */) {
+              currentAddition.relation = relation;
+            }
+            if (inLaw) {
+              currentAddition.breakOnNext = true;
+            }
+            const newItem = {
+              indi: relative,
+              kinship: "spouse",
+              level,
+              levelUp,
+              levelDown,
+              degree,
+              ...additional,
+              ...currentAddition
+            };
+            queue.push({
+              ...newItem,
+              path: [...path, newItem]
+            });
           }
-          const newItem = {
-            indi: relative,
-            kinship: "spouse",
-            level,
-            levelUp,
-            levelDown,
-            degree,
-            ...additional,
-            ...currentAddition
-          };
-          queue.push({
-            ...newItem,
-            path: [...path2, newItem]
-          });
-        }
-      });
+        });
+      }
+      return void 0;
+    };
+    const foundPath = bfs(false);
+    const lastItem = foundPath?.[foundPath.length - 1];
+    if (lastItem?.relation && lastItem.relation !== "biological" /* BIOLOGICAL */) {
+      const biologicalPath = bfs(true);
+      if (biologicalPath) {
+        cacheDiscoveredPath(this._gedcom, biologicalPath);
+        return biologicalPath;
+      }
     }
-    return void 0;
+    if (foundPath) {
+      cacheDiscoveredPath(this._gedcom, foundPath);
+    }
+    return foundPath;
   }
   kinship(other, showMainPerson, lang = "en", entirePath, displayName = "givenname") {
     const KinshipTranslatorClass2 = getKinshipTranslatorClass();
@@ -5008,6 +5203,44 @@ var KinshipTranslatorBasic = class {
     }
     return this.pathN?.indi;
   }
+  /**
+   * True when the path goes through a common ancestor whose two children
+   * (the person we came from and the person we go to) share fewer than two
+   * biological parents — i.e. they are half-siblings, so every collateral
+   * relative on this path is a half-aunt/half-cousin/... too.
+   *
+   * Direct ancestors/descendants and paths that already use a
+   * step/adopted/foster edge are never half-blood.
+   */
+  get isHalfBlood() {
+    const path = this.path;
+    if (!path || path.length < 3) {
+      return false;
+    }
+    if (path.some(
+      (item) => item.relation && item.relation !== "biological" /* BIOLOGICAL */
+    )) {
+      return false;
+    }
+    let peakIndex = -1;
+    for (let i = 1; i < path.length; i++) {
+      if (path[i].kinship === "parent") {
+        peakIndex = i;
+      }
+    }
+    if (peakIndex <= 0 || peakIndex >= path.length - 1) {
+      return false;
+    }
+    if (path[peakIndex + 1].kinship !== "child") {
+      return false;
+    }
+    const siblingA = path[peakIndex - 1].indi;
+    const siblingB = path[peakIndex + 1].indi;
+    const parentsA = siblingA.getBiologicalParents();
+    const parentsB = siblingB.getBiologicalParents();
+    const inter = parentsA.intersection(parentsB);
+    return inter.length === 1 && (parentsA.length > 1 || parentsB.length > 1);
+  }
   indirect() {
     return "";
   }
@@ -5035,6 +5268,9 @@ var KinshipTranslatorBasic = class {
   relationType(relation) {
     return relation ?? "";
   }
+  halfBlood(relation) {
+    return relation ?? "";
+  }
   of(relation) {
     return relation ?? "";
   }
@@ -5273,14 +5509,34 @@ var KinshipTranslatorHU = class extends KinshipTranslatorBasic {
     return `${prefix.replace(/nagy$/, "")}unoka`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    if (!inter || inter.length < 2) {
-      return "f\xE9ltestv\xE9r";
-    }
     return "testv\xE9r";
   }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    const [head, ...rest] = relation.split(" ");
+    if (!head) {
+      return relation;
+    }
+    const prefixed = this.prefixHalf(head);
+    return [prefixed, ...rest].join(" ");
+  }
+  /**
+   * AkH. 139: compounds of more than two members stay closed up to 6
+   * syllables; longer ones are hyphenated at the main boundary. A head
+   * that is already hyphenated also takes a hyphenated half- prefix.
+   */
+  prefixHalf(head) {
+    if (head.includes("-") || !/[aáeéiíoóöőuúüű]/i.test(head)) {
+      return `f\xE9l-${head}`;
+    }
+    const syllables = (head.match(/[aáeéiíoóöőuúüű]/gi) ?? []).length + 1;
+    if (syllables > 6) {
+      return `f\xE9l-${head}`;
+    }
+    return `f\xE9l${head}`;
+  }
   spouse() {
     if (this.personN?.isMale()) {
       return "f\xE9rj";
@@ -5479,20 +5735,22 @@ var KinshipTranslatorEn = class extends KinshipTranslatorBasic {
     return `${prefix}child`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    let prefix = "";
-    if (!inter || inter.length < 2) {
-      prefix = "half-";
-    }
     if (this.personN?.isMale()) {
-      return `${prefix}brother`;
+      return "brother";
     }
     if (this.personN?.isFemale()) {
-      return `${prefix}sister`;
+      return "sister";
+    }
+    return "sibling";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    if (relation.includes(" ")) {
+      return `half ${relation}`;
     }
-    return `${prefix}sibling`;
+    return `half-${relation}`;
   }
   spouse() {
     if (this.personN?.isMale()) {
@@ -5674,20 +5932,22 @@ var KinshipTranslatorDe = class extends KinshipTranslatorBasic {
     return `${prefix}kind`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    let prefix = "";
-    if (!inter || inter.length < 2) {
-      prefix = "Halb";
-    }
     if (this.personN?.isMale()) {
-      return `${prefix}bruder`;
+      return "bruder";
     }
     if (this.personN?.isFemale()) {
-      return `${prefix}schwester`;
+      return "schwester";
+    }
+    return "geschwister";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
+    }
+    if (/^[A-ZÄÖÜ]/.test(relation) || /[-\s]/.test(relation)) {
+      return `Halb-${relation}`;
     }
-    return `${prefix}geschwister`;
+    return `Halb${relation}`;
   }
   spouse() {
     if (this.personN?.isMale()) {
@@ -5869,20 +6129,19 @@ var KinshipTranslatorFr = class extends KinshipTranslatorBasic {
     return `${prefix}enfant`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    let prefix = "";
-    if (!inter || inter.length < 2) {
-      prefix = "demi-";
-    }
     if (this.personN?.isMale()) {
-      return `${prefix}fr\xE8re`;
+      return "fr\xE8re";
     }
     if (this.personN?.isFemale()) {
-      return `${prefix}s\u0153ur`;
+      return "s\u0153ur";
+    }
+    return "fr\xE8re/s\u0153ur";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
     }
-    return `${prefix}fr\xE8re/s\u0153ur`;
+    return `demi-${relation}`;
   }
   spouse() {
     if (this.personN?.isMale()) {
@@ -5979,12 +6238,12 @@ var InLawsEs = {
   "madre del (c\xF3nyuge|esposa|esposo)": "suegra",
   "padre del (c\xF3nyuge|esposa|esposo)": "suegro",
   "padre/madre del (c\xF3nyuge|esposa|esposo)": "suegro/suegra",
-  "esposa de (medio )?(hermano/hermana|hermana|hermano)": "cu\xF1ada",
-  "esposo de (medio )?(hermano/hermana|hermana|hermano)": "cu\xF1ado",
-  "c\xF3nyuge de (medio )?(hermano/hermana|hermana|hermano)": "cu\xF1ado/cu\xF1ada",
-  "(medio )?hermana del (c\xF3nyuge|esposa|esposo)": "cu\xF1ada",
-  "(medio )?hermano del (c\xF3nyuge|esposa|esposo)": "cu\xF1ado",
-  "(medio )?hermano/hermana del (c\xF3nyuge|esposa|esposo)": "cu\xF1ado/cu\xF1ada"
+  "esposa de (medio |media |medio/a )?(hermano/hermana|hermana|hermano)": "cu\xF1ada",
+  "esposo de (medio |media |medio/a )?(hermano/hermana|hermana|hermano)": "cu\xF1ado",
+  "c\xF3nyuge de (medio |media |medio/a )?(hermano/hermana|hermana|hermano)": "cu\xF1ado/cu\xF1ada",
+  "(medio |media |medio/a )?hermana del (c\xF3nyuge|esposa|esposo)": "cu\xF1ada",
+  "(medio |media |medio/a )?hermano del (c\xF3nyuge|esposa|esposo)": "cu\xF1ado",
+  "(medio |media |medio/a )?hermano/hermana del (c\xF3nyuge|esposa|esposo)": "cu\xF1ado/cu\xF1ada"
 };
 
 // src/kinship-translator/kinship-translator.es.ts
@@ -6064,20 +6323,25 @@ var KinshipTranslatorEs = class extends KinshipTranslatorBasic {
     return `${prefix}hijo/hija`;
   }
   sibling() {
-    const parents1 = this.person1?.getBiologicalParents();
-    const parentsN = this.personN?.getBiologicalParents();
-    const inter = parents1?.intersection(parentsN);
-    let prefix = "";
-    if (!inter || inter.length < 2) {
-      prefix = "medio ";
-    }
     if (this.personN?.isMale()) {
-      return `${prefix}hermano`;
+      return "hermano";
+    }
+    if (this.personN?.isFemale()) {
+      return "hermana";
+    }
+    return "hermano/hermana";
+  }
+  halfBlood(relation) {
+    if (!relation || !this.isHalfBlood) {
+      return relation ?? "";
     }
     if (this.personN?.isFemale()) {
-      return `${prefix}hermana`;
+      return `media ${relation}`;
+    }
+    if (this.personN?.isMale()) {
+      return `medio ${relation}`;
     }
-    return `${prefix}hermano/hermana`;
+    return `medio/a ${relation}`;
   }
   spouse() {
     if (this.personN?.isMale()) {
@@ -6259,6 +6523,7 @@ var KinshipTranslator = class {
     } else if (personN.level !== 0) {
       relation = this.removal();
     }
+    relation = this.translator?.halfBlood(relation);
     relation = this.translator?.relationType(relation);
     if (this.translator?.isOfSpouse) {
       relation = this.translator?.ofSpouse(relation);