fhirsmith 0.18.2 → 1.0.0

package/tx/cs/cs-cpt.js

@@ -4,6 +4,7 @@ const { CodeSystem } = require('../library/codesystem');
 const { FilterExecutionContext, CodeSystemFactoryProvider } = require('./cs-api');
 const {validateArrayParameter} = require("../../library/utilities");
 const {BaseCSServices} = require("./cs-base");
+const { guarded } = require('../library/sqlite-utilities');
 
 class CPTConceptDesignation {
   constructor(kind, value) {
@@ -123,10 +124,7 @@ class CPTServices extends BaseCSServices {
   }
 
   close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
+    this.closeDb();
   }
 
   // Metadata methods
@@ -228,6 +226,15 @@ class CPTServices extends BaseCSServices {
   isNotClosed() {
     return true;
   }
+  /**
+   * The concept's properties for $expand: built by extendLookup, so that an expansion reports
+   * the same properties $lookup does (see CodeSystemProvider._propertiesFromLookup). Not the
+   * copyright, which extendLookup always adds: it is about the code system, not the concept
+   */
+  async properties(context, names) {
+    return (await this._propertiesFromLookup(context, names)).filter(p => p.code !== 'copyright');
+  }
+
   async extendLookup(ctxt, props, params) {
     validateArrayParameter(props, 'props', String);
     validateArrayParameter(params, 'params', Object);
@@ -571,7 +578,8 @@ class CPTServices extends BaseCSServices {
 
 
 
-  // Subsumption testing - not implemented
+  // Subsumption: CPT codes have no subsumption relationships, so two codes that both exist are
+  // not-subsumed (the caller deals with equal codes: equivalent)
   async subsumesTest(codeA, codeB) {
     await this.#ensureContext(codeA);
     await this.#ensureContext(codeB);
@@ -585,9 +593,14 @@ class CPTServices extends BaseCSServices {
 }
 
 class CPTServicesFactory extends CodeSystemFactoryProvider {
-  constructor(i18n, dbPath) {
+  /**
+   * @param {Object} [options] - {readOnly: true} in a tx-worker (cluster.md): the file is
+   *   the master's; this process opens it read-only
+   */
+  constructor(i18n, dbPath, options = {}) {
     super(i18n);
     this.dbPath = dbPath;
+    this.readOnly = !!options.readOnly;
     this.uses = 0;
     this._loaded = false;
     this._sharedData = null;
@@ -613,8 +626,12 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
     }
   }
 
+  #open() {
+    return this.readOnly ? new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY) : new sqlite3.Database(this.dbPath);
+  }
+
   async load() {
-    const db = new sqlite3.Database(this.dbPath);
+    const db = this.#open();
 
     try {
       this._sharedData = {
@@ -645,7 +662,7 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
 
   async #loadVersion(db) {
     return new Promise((resolve, reject) => {
-      db.all('SELECT * FROM Information', (err, rows) => {
+      db.all('SELECT * FROM Information', guarded(reject, (err, rows) => {
         if (err) {
           reject(err);
         } else {
@@ -656,13 +673,13 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
           }
           resolve();
         }
-      });
+      }));
     });
   }
 
   async #loadConcepts(db) {
     return new Promise((resolve, reject) => {
-      db.all('SELECT * FROM Concepts', (err, rows) => {
+      db.all('SELECT * FROM Concepts', guarded(reject, (err, rows) => {
         if (err) {
           reject(err);
         } else {
@@ -680,13 +697,13 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
           }
           resolve();
         }
-      });
+      }));
     });
   }
 
   async #loadProperties(db) {
     return new Promise((resolve, reject) => {
-      db.all('SELECT * FROM Properties', (err, rows) => {
+      db.all('SELECT * FROM Properties', guarded(reject, (err, rows) => {
         if (err) {
           reject(err);
         } else {
@@ -698,13 +715,13 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
           }
           resolve();
         }
-      });
+      }));
     });
   }
 
   async #loadDesignations(db) {
     return new Promise((resolve, reject) => {
-      db.all('SELECT * FROM Designations', (err, rows) => {
+      db.all('SELECT * FROM Designations', guarded(reject, (err, rows) => {
         if (err) {
           reject(err);
         } else {
@@ -716,7 +733,7 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
           }
           resolve();
         }
-      });
+      }));
     });
   }
 
@@ -729,7 +746,7 @@ class CPTServicesFactory extends CodeSystemFactoryProvider {
     this.recordUse();
 
     // Create fresh database connection for this provider instance
-    const db = new sqlite3.Database(this.dbPath);
+    const db = this.#open();
 
     return new CPTServices(opContext, supplements, db, this._sharedData);
   }

package/tx/cs/cs-cs.js

@@ -1,5 +1,5 @@
 const { CodeSystem}  = require("../library/codesystem");
-const { CodeSystemFactoryProvider, FilterExecutionContext }  = require( "./cs-api");
+const { CodeSystemFactoryProvider, FilterExecutionContext, CodeSystemProvider }  = require( "./cs-api");
 const { VersionUtilities }  = require("../../library/version-utilities");
 const { Language }  = require ("../../library/languages");
 const { validateOptionalParameter, getValuePrimitive, validateArrayParameter} = require("../../library/utilities");
@@ -56,7 +56,8 @@ function conceptSearchTexts(concept) {
       display: concept.display ? searchText(concept.display) : null,
       definition: concept.definition ? foldSearchText(concept.definition) : null,
       designations: Array.isArray(concept.designation)
-        ? concept.designation.filter(designation => designation.value).map(designation => searchText(designation.value))
+        ? concept.designation.filter(designation => designation.value)
+          .map(designation => ({ ...searchText(designation.value), language: designation.language || null }))
         : []
     };
     SEARCH_TEXTS.set(concept, texts);
@@ -83,9 +84,16 @@ function wordsRatio(words, text) {
  * Context class for FHIR CodeSystem provider concepts
  */
 class FhirCodeSystemProviderContext {
-  constructor(code, concept) {
+  /**
+   * @param {string} code - the code
+   * @param {Object} concept - its definition in the code system
+   * @param {boolean} reserved - true if the code system doesn't define the code, but it is in its
+   *   reserved code space (so the concept is just the code, and supplements may define it)
+   */
+  constructor(code, concept, reserved = false) {
     this.code = code;
     this.concept = concept;
+    this.reserved = reserved;
   }
 }
 
@@ -190,6 +198,16 @@ function providerClassFor(url) {
 }
 
 class FhirCodeSystemProvider extends BaseCSServices {
+  /**
+   * A code system that reserves code spaces for users (codesystem-reservedCodeSpace) has codes that
+   * aren't listed in an expansion of all of it
+   * @returns {string|null}
+   */
+  openCodeSpaceReason() {
+    return this.codeSystem.reservedCodeSpaces().length > 0 ?
+      "The code system '" + this.system() + "' reserves code spaces for users to define their own codes, and those codes are not in the expansion" : null;
+  }
+
   /**
    * The provider for a CodeSystem resource: a FhirCodeSystemProvider, or the subclass
    * registered for its url. Always use this rather than the constructor.
@@ -464,6 +482,16 @@ class FhirCodeSystemProvider extends BaseCSServices {
       };
     }
 
+    // a code the code system doesn't define, in a code space it reserves for users to define their own
+    // codes, is a valid code. An extension-codes supplement in scope may define it (display etc); if
+    // none does, it has no display
+    if (this.codeSystem.isInReservedCodeSpace(code)) {
+      return {
+        context: new FhirCodeSystemProviderContext(code, { code: code }, true),
+        message: null
+      };
+    }
+
     return {
       context: null,
       message: undefined
@@ -511,6 +539,11 @@ class FhirCodeSystemProvider extends BaseCSServices {
     if (supplementDisplay) {
       return supplementDisplay;
     }
+    // a code in the reserved code space has the display an extension-codes supplement gives it,
+    // whatever languages were asked for - or, if none does, the code space's default display
+    if (ctxt.reserved) {
+      return this._extensionCodeDisplay(ctxt.code) || this.codeSystem.reservedCodeSpaceFor(ctxt.code).defaultDisplay;
+    }
 
     // Use language-aware display logic
     if (this.opContext.langs && !this.opContext.langs.isEnglishOrNothing()) {
@@ -774,8 +807,17 @@ class FhirCodeSystemProvider extends BaseCSServices {
       }
     }
 
+    // a code in the reserved code space that no extension-codes supplement in scope gives a display has
+    // its code space's default display ('User-assigned'). It is a placeholder, so (as for ISO 3166's
+    // user-assigned codes) another display is not wrong - see validate.js checkDisplays
+    if (ctxt.reserved && !this._extensionCodeDisplay(ctxt.code)) {
+      displays.userDefined = true;
+      const displayLang = this.defaultLanguage ? this.defaultLanguage.toString() : null;
+      displays.addDesignation(true, 'active', displayLang, CodeSystem.makeUseForDisplay(), this.codeSystem.reservedCodeSpaceFor(ctxt.code).defaultDisplay);
+    }
+
     // Add supplement designations
-    this._listSupplementDesignations(ctxt.code, displays);
+    this._listSupplementDesignations(ctxt.code, displays, ctxt.reserved);
   }
 
   /**
@@ -1132,9 +1174,10 @@ class FhirCodeSystemProvider extends BaseCSServices {
    * @param {boolean} iterate - True if results will be iterated
    * @returns {FilterExecutionContext} Filter context
    */
-  async getPrepContext(iterate) {
-    
-    return new FilterExecutionContext(iterate);
+  async getPrepContext(iterate, languages = null) {
+    const result = new FilterExecutionContext(iterate);
+    result.languages = languages; // what the request asked for (a text filter searches one language)
+    return result;
   }
 
   /**
@@ -1161,7 +1204,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     }
     // Supported hierarchy filters
     if ((prop === 'concept' || prop === 'code') &&
-      ['is-a', 'descendent-of', 'is-not-a', 'child-of', 'in', '=', 'regex'].includes(op)) {
+      ['is-a', 'descendent-of', 'descendent-leaf', 'is-not-a', 'child-of', 'in', 'not-in', '=', 'regex'].includes(op)) {
       return true;
     }
 
@@ -1304,13 +1347,16 @@ class FhirCodeSystemProvider extends BaseCSServices {
     const results = new FhirCodeSystemProviderFilterContext();
     const searchTerm = foldSearchText(filter.filter);
     const searchWords = searchTerm.split(/[^\p{L}\p{N}]+/u).filter(word => word !== '');
+    // the display, definition and designations in one language only (see searchLanguage),
+    // with the designations that supplements in use give in that language
+    const lang = this.searchLanguage(filterContext.languages);
 
     // Search through all concepts
     const allConcepts = this.codeSystem.getAllConcepts();
 
     for (const concept of allConcepts) {
       this.opContext.deadCheck('cs:searchFilter');
-      const rating = this._calculateSearchRating(concept, searchTerm, searchWords);
+      const rating = this._calculateSearchRating(concept, searchTerm, searchWords, lang);
       if (rating > 0) {
         results.add(concept, rating);
       }
@@ -1337,8 +1383,20 @@ class FhirCodeSystemProvider extends BaseCSServices {
    * @returns {number} Rating (0 = no match, higher = better match)
    * @private
    */
-  _calculateSearchRating(concept, searchTerm, searchWords) {
-    const texts = conceptSearchTexts(concept);
+  _calculateSearchRating(concept, searchTerm, searchWords, lang = null) {
+    const all = conceptSearchTexts(concept);
+    let texts = all;
+    if (lang) {
+      const csLang = this.defLang();
+      const inLang = CodeSystemProvider.inSearchLanguage(csLang, lang);
+      texts = {
+        code: all.code,
+        display: inLang ? all.display : null,
+        definition: inLang ? all.definition : null,
+        designations: all.designations.filter(d => CodeSystemProvider.inSearchLanguage(d.language, lang, csLang))
+          .concat(this.#supplementSearchTexts(concept.code, lang))
+      };
+    }
     const display = texts.display;
     let rating = 0;
 
@@ -1389,6 +1447,55 @@ class FhirCodeSystemProvider extends BaseCSServices {
     return rating;
   }
 
+  /**
+   * As for any code system (CodeSystemProvider.searchLanguage), but whether there is text in
+   * a language is decided by what the code system actually has: its own language, a designation
+   * in it, or a supplement's (hasAnyDisplays says yes to English whatever the code system's
+   * language is)
+   */
+  searchLanguage(languages) {
+    for (const lang of (languages && languages.languages) || []) {
+      if (lang && lang.language && lang.code !== '*' && this.#hasSearchText(lang)) {
+        return lang;
+      }
+    }
+    return new Language(this.defLang());
+  }
+
+  #hasSearchText(lang) {
+    const csLang = this.defLang();
+    if (CodeSystemProvider.inSearchLanguage(csLang, lang)) {
+      return true;
+    }
+    for (const concept of this.codeSystem.getAllConcepts()) {
+      if ((concept.designation || []).some(d => d.value && CodeSystemProvider.inSearchLanguage(d.language, lang, csLang))) {
+        return true;
+      }
+    }
+    return this._hasSupplementText(lang);
+  }
+
+  // the displays and designations that supplements in use give a code, in the search language
+  #supplementSearchTexts(code, lang) {
+    const result = [];
+    for (const supplement of this.supplements || []) {
+      const concept = supplement.getConceptByCode(code);
+      if (!concept) {
+        continue;
+      }
+      const suppLang = supplement.jsonObj.language || this.defLang();
+      if (concept.display && CodeSystemProvider.inSearchLanguage(suppLang, lang)) {
+        result.push(searchText(concept.display));
+      }
+      for (const d of concept.designation || []) {
+        if (d.value && CodeSystemProvider.inSearchLanguage(d.language, lang, suppLang)) {
+          result.push(searchText(d.value));
+        }
+      }
+    }
+    return result;
+  }
+
   /**
    * Execute a value set filter
    * @param {FilterExecutionContext} filterContext - Filter context
@@ -1479,7 +1586,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
    */
   _isCacheableFilter(prop, op) {
     if (prop === 'concept' || prop === 'code') {
-      return op === 'is-a' || op === 'descendent-of' || op === 'is-not-a' || op === 'regex';
+      return op === 'is-a' || op === 'descendent-of' || op === 'descendent-leaf' || op === 'is-not-a' || op === 'regex';
     }
     if (prop === 'child' && op === 'exists') {
       return true;
@@ -1518,6 +1625,19 @@ class FhirCodeSystemProvider extends BaseCSServices {
       // Find all descendants of the specified code
       const includeRoot = (op === 'is-a');
       await this._addDescendants(results, value, includeRoot);
+    } else if (op === 'descendent-leaf') {
+      // R5: the descendants that have no children of their own
+      if (this.codeSystem.getConceptByCode(value)) {
+        for (const code of this.codeSystem.getDescendants(value)) {
+          this.opContext.deadCheck('cs:conceptFilter:descendent-leaf');
+          if (code !== value && this.codeSystem.getChildren(code).length === 0) {
+            const concept = this.codeSystem.getConceptByCode(code);
+            if (concept) {
+              results.add(concept, 0);
+            }
+          }
+        }
+      }
     } else if (op === 'child-of') {
       // Find all descendants of the specified code
       await this._addChildren(results, value);
@@ -1547,6 +1667,20 @@ class FhirCodeSystemProvider extends BaseCSServices {
         }
       }
     }
+    else if (op === 'not-in') {
+      // Every code except the listed ones (comma separated) - their descendants are not excluded
+      const excludeSet = new Set(value.split(',').map(c => c.trim()));
+      const allCodes = this.codeSystem.getAllCodes();
+      for (const code of allCodes) {
+        this.opContext.deadCheck('cs:conceptFilter:not-in');
+        if (!excludeSet.has(code)) {
+          const concept = this.codeSystem.getConceptByCode(code);
+          if (concept) {
+            results.add(concept, 0);
+          }
+        }
+      }
+    }
     else if (op === '=') {
       // Exact match
       const concept = this.codeSystem.getConceptByCode(value);
@@ -1557,7 +1691,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     else if (op === 'regex') {
       // Regular expression match
       try {
-        const regex = regexUtilities.compile('^' + value + '$');
+        const regex = regexUtilities.compile('^(?:' + value + ')$'); // the whole value: a|b is ^(?:a|b)$, not ^a|b$
         const allCodes = this.codeSystem.getAllCodes();
         for (const code of allCodes) {
           this.opContext.deadCheck('cs:conceptFilter:regex');
@@ -1705,7 +1839,7 @@ class FhirCodeSystemProvider extends BaseCSServices {
     }
     else if (op === 'regex') {
       try {
-        const regex = regexUtilities.compile('^' + value + '$');
+        const regex = regexUtilities.compile('^(?:' + value + ')$'); // the whole value: a|b is ^(?:a|b)$, not ^a|b$
         return properties.some(p => regex.test(this._getPropertyValue(p)));
       } catch (error) {
         return false;

package/tx/cs/cs-currency.js

@@ -245,7 +245,7 @@ class Iso4217Services extends CodeSystemProvider {
         return concept;
       }
     }
-    return `Code '${code}' not found in filter set`;
+    return null;
   }
 
   async filterCheck(filterContext, set, concept) {

package/tx/cs/cs-icd11.js

@@ -22,6 +22,7 @@ const { ICD11Expression, parseExpression, axisLabel } = require('./icd11-express
 const { Issue } = require('../library/operation-outcome');
 const { DesignationUse } = require('../library/designations');
 const assert = require('assert');
+const { guarded } = require('../library/sqlite-utilities');
 
 // WHO's own vocabulary for the kinds of text an entity carries, used as designation.use.
 const SCHEMA_NS = 'http://id.who.int/icd/schema';
@@ -100,10 +101,7 @@ class ICD11Services extends BaseCSServices {
   }
 
   close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
+    this.closeDb();
   }
 
   // -- small promise wrappers, so no query below carries callback boilerplate -----------
@@ -116,7 +114,7 @@ class ICD11Services extends BaseCSServices {
 
   #all(sql, params = []) {
     return new Promise((resolve, reject) => {
-      this.db.all(sql, params, (err, rows) => err ? reject(err) : resolve(rows || []));
+      this.db.all(sql, params, guarded(reject, (err, rows) => err ? reject(err) : resolve(rows || [])));
     });
   }
 
@@ -993,12 +991,22 @@ class ICD11ServicesFactory extends CodeSystemFactoryProvider {
 
   id() { return `icd11-${this.systemCode}`; }
 
+  /**
+   * The WHO browser page for the concept, as the ICD-API gives it (browserUrl, kept in the
+   * database: https://icd.who.int/browse/2026-01/mms/en#257068234). A postcoordinated
+   * expression links to its stem.
+   */
+  codeLink(context) {
+    const concept = context && context.tokens ? context.tokens[0]?.concept : context;
+    return concept && concept.browserUrl ? concept.browserUrl : undefined;
+  }
+
   async load() {
     if (this._loaded) return;
     const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY);
     try {
       const get = (sql, p) => new Promise((res, rej) =>
-        db.get(sql, p, (e, r) => e ? rej(e) : res(r)));
+        db.get(sql, p, guarded(rej, (e, r) => e ? rej(e) : res(r))));
       const sys = await get('SELECT * FROM system WHERE code = ?', [this.systemCode]);
       if (!sys) {
         throw new Error(`ICD-11 database ${this.dbPath} has no '${this.systemCode}' code system`);
@@ -1007,7 +1015,7 @@ class ICD11ServicesFactory extends CodeSystemFactoryProvider {
       const langs = await get("SELECT value FROM meta WHERE key = 'languages'", []);
       // per-language titles; a database built before system_title existed has none
       const all = (sql, p) => new Promise((res, rej) =>
-        db.all(sql, p, (e, r) => e ? rej(e) : res(r || [])));
+        db.all(sql, p, guarded(rej, (e, r) => e ? rej(e) : res(r || []))));
       const titles = {};
       const hasTitles = await get(
         "SELECT 1 x FROM sqlite_master WHERE type = 'table' AND name = 'system_title'", []);
@@ -1054,8 +1062,8 @@ class ICD11ServicesFactory extends CodeSystemFactoryProvider {
 
     const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY);
     try {
-      const get = (sql, p) => new Promise((res, rej) => db.get(sql, p, (e, r) => e ? rej(e) : res(r)));
-      const all = (sql, p) => new Promise((res, rej) => db.all(sql, p, (e, r) => e ? rej(e) : res(r || [])));
+      const get = (sql, p) => new Promise((res, rej) => db.get(sql, p, guarded(rej, (e, r) => e ? rej(e) : res(r))));
+      const all = (sql, p) => new Promise((res, rej) => db.all(sql, p, guarded(rej, (e, r) => e ? rej(e) : res(r || []))));
       const scale = await get(
         `SELECT ps.id, ps.axis, ps.axis_name, ps.required, ps.allow_multiple,
                 c.entity_id, c.code AS stem_code, c.uri AS stem_uri
@@ -1100,14 +1108,14 @@ class ICD11ServicesFactory extends CodeSystemFactoryProvider {
   /** Which code systems a given database holds, so the library can register one each. */
   static listSystems(dbPath) {
     return new Promise((resolve, reject) => {
-      const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, (err) => {
+      const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, guarded(reject, (err) => {
         if (err) { reject(new Error(`cannot open ICD-11 database ${dbPath}: ${err.message}`)); return; }
-        db.all('SELECT code, url, version, title FROM system ORDER BY code', (e, rows) => {
+        db.all('SELECT code, url, version, title FROM system ORDER BY code', guarded(reject, (e, rows) => {
           db.close();
           if (e) reject(new Error(`${dbPath} is not an ICD-11 database: ${e.message}`));
           else resolve(rows || []);
-        });
-      });
+        }));
+      }));
     });
   }
 }

package/tx/cs/cs-icf.js

@@ -195,9 +195,23 @@ class IcfCodeSystemProvider extends FhirCodeSystemProvider {
     return ctxt instanceof IcfQualifiedContext ? ctxt.qualifiedCode : super.code(ctxt);
   }
 
-  /** The category's display, then the qualifiers' displays, leaving out any 8 (not specified). */
+  /**
+   * A qualified code's display is the one an extension-codes supplement in scope gives it, if one
+   * does. Otherwise it is generated: the category's display, then the qualifiers' displays, leaving
+   * out any 8 (not specified).
+   */
   async display(context) {
     const ctxt = await this.#resolve(context);
+    if (ctxt instanceof IcfQualifiedContext) {
+      const ext = this._extensionCodeDisplay(ctxt.qualifiedCode);
+      if (ext) {
+        return ext;
+      }
+    }
+    return this.#generatedDisplay(ctxt);
+  }
+
+  async #generatedDisplay(ctxt) {
     const display = await super.display(ctxt);
     if (!(ctxt instanceof IcfQualifiedContext)) {
       return display;
@@ -207,14 +221,19 @@ class IcfCodeSystemProvider extends FhirCodeSystemProvider {
     return parts.length > 0 ? display + ': ' + parts.join(', ') : display;
   }
 
-  /** A qualified code has one designation: its display. The category's translations do not describe it. */
+  /**
+   * A qualified code's designations: the display an extension-codes supplement in scope gives it
+   * (first, so it is the preferred display), and its generated display, which stays a valid one. The
+   * category's translations do not describe it.
+   */
   async designations(context, displays) {
     const ctxt = await this.#resolve(context);
     if (!(ctxt instanceof IcfQualifiedContext)) {
       return super.designations(ctxt, displays);
     }
+    this._listSupplementDesignations(ctxt.qualifiedCode, displays, true);
     const lang = this.defaultLanguage ? this.defaultLanguage.toString() : null;
-    displays.addDesignation(true, 'active', lang, CodeSystem.makeUseForDisplay(), await this.display(ctxt));
+    displays.addDesignation(true, 'active', lang, CodeSystem.makeUseForDisplay(), await this.#generatedDisplay(ctxt));
   }
 
   /**

package/tx/cs/cs-lang.js

@@ -75,7 +75,7 @@ class IETFLanguageCodeFilter {
   }
 
   /** Why a code did not match, for the caller. @returns {string} */
-  describe(code, _lang) {
+  describe(code) {
     const action = this.status ? 'does not contain' : 'contains';
     const requirement = this.status ? 'required' : 'not allowed';
     return `The language code ${code} ${action} a ${this.component}, and it is ${requirement}`;
@@ -101,7 +101,7 @@ class IETFLanguageEqualityFilter {
     return value.toLowerCase() === this.value.toLowerCase();
   }
 
-  describe(code, _lang) {
+  describe(code) {
     return `The language code ${code} does not have a ${this.component} of '${this.value}'`;
   }
 }