@cosyte/terminology 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 0.1.7
+
+### Patch Changes
+
+- c688d91: Faster value set membership and translation, and leaner CSV, GEM and UCUM reading. Every answer,
+  loaded model, warning and error is unchanged, and no signature changes. One thing is deliberately
+  different: within one `loadGems` result, the entries that carry the same five flag digits now share
+  one frozen `flags` object rather than each holding its own. Every field reads the same; only
+  `entryA.flags === entryB.flags` is now `true` for two such entries. If you told entries apart by
+  the identity of their `flags`, compare the entries themselves, or their fields, instead.
+
+  - `validateCodeInValueSet` builds a loaded release's hierarchy index on the first membership
+    question over a filter and reuses it, rather than walking the whole release for every code. A code
+    system whose `concepts` you assembled by hand is still indexed afresh on every call, so a change
+    you make to it between two calls is read.
+  - `translate` finds a loaded ConceptMap's elements through an index of each group by source code,
+    built on the first translation through the group, rather than reading every element for each code.
+    A map you assembled by hand is still read element by element.
+  - `loadCodeSystem` reads a CSV release row by row and builds only the configured columns, so a long
+    column you did not configure costs no memory. The strings a loaded model keeps are copied out of
+    the release text, so the model does not keep that text alive after the load; the same holds for
+    `parseCsv` and `loadGems`.
+  - `loadGems` reads each line in place instead of splitting the file into lines and each line into
+    fields, and decodes each distinct flag field once per load (the shared `flags` object above).
+  - `validateUcum`, `ucumEqual` and `parseUcum` match a unit against the atoms and prefixes that start
+    with the same character, from an index of the unit table built once, rather than against the whole
+    table.
+
+  The indexes are kept with the loaded release or map and go when it does. A source coding with no
+  `code` is still matched against a loaded map's elements that have none, as before.
+
+  The package's npm keywords also gain `snomed`, `icd10` and `cpt`, so a search on those terms finds
+  it.
+
 ## 0.1.6
 
 ### Patch Changes

package/dist/index.cjs

@@ -446,6 +446,10 @@ function loadUnmapped(raw, path) {
   assignString(out, raw, "url");
   return Object.freeze(out);
 }
+var loadedGroups = /* @__PURE__ */ new WeakSet();
+function isLoadedGroup(group) {
+  return loadedGroups.has(group);
+}
 function loadGroup(raw, path) {
   if (!isJsonObject(raw)) malformed(path, "group is not an object");
   const rawElements = getArray(raw, "element") ?? [];
@@ -460,7 +464,9 @@ function loadGroup(raw, path) {
   if (isJsonObject(raw) && raw["unmapped"] !== void 0) {
     out.unmapped = loadUnmapped(raw["unmapped"], `${path}.unmapped`);
   }
-  return Object.freeze(out);
+  const group = Object.freeze(out);
+  loadedGroups.add(group);
+  return group;
 }
 function loadConceptMap(json) {
   if (!isJsonObject(json)) malformed("", "resource is not a JSON object");
@@ -504,6 +510,24 @@ function groupApplies(group, system) {
   if (system === void 0) return true;
   return group.source === void 0 || group.source === system;
 }
+var elementIndex = /* @__PURE__ */ new WeakMap();
+var NO_ELEMENTS = Object.freeze([]);
+function candidates(group, code) {
+  if (typeof code !== "string" || !isLoadedGroup(group)) return group.element;
+  let index = elementIndex.get(group);
+  if (index === void 0) {
+    const built = /* @__PURE__ */ new Map();
+    for (const element of group.element) {
+      if (element.code === void 0) continue;
+      const list = built.get(element.code);
+      if (list === void 0) built.set(element.code, [element]);
+      else list.push(element);
+    }
+    index = built;
+    elementIndex.set(group, index);
+  }
+  return index.get(code) ?? NO_ELEMENTS;
+}
 function provenanceOf(map, group, sourceSystem) {
   const out = {};
   if (map.url !== void 0) out.conceptMapUrl = map.url;
@@ -537,7 +561,7 @@ function translate(sourceCoding, map) {
   for (const group of map.group) {
     if (!groupApplies(group, system)) continue;
     if (fallbackGroup === void 0 && group.unmapped !== void 0) fallbackGroup = group;
-    for (const element of group.element) {
+    for (const element of candidates(group, source.code)) {
       if (element.code !== source.code) continue;
       sourceCodePresent = true;
       for (const t of element.target) {
@@ -640,6 +664,12 @@ function frozenMap(source, what) {
   return Object.freeze(view);
 }
 
+// src/common/own-string.ts
+var VIEW_MIN_LENGTH = 13;
+function ownString(s) {
+  return s.length < VIEW_MIN_LENGTH ? s : ` ${s}`.slice(1);
+}
+
 // src/codesystem/status.ts
 var defaultStatusMapper = (raw) => {
   switch (raw.trim().toUpperCase()) {
@@ -674,7 +704,79 @@ function makeStatus(activity, raw, billable) {
 }
 
 // src/codesystem/csv.ts
-function parseCsvRows(content) {
+var QUOTE = 34;
+var COMMA = 44;
+var LINE_FEED = 10;
+var CARRIAGE_RETURN = 13;
+function scanCsv(content, sink) {
+  if (typeof content !== "string") return readCsvByCharAt(content, sink);
+  const n = content.length;
+  const cells = [];
+  let column = 0;
+  const keeps = (col) => sink.wanted === void 0 || sink.wanted[col] === true;
+  let keep = keeps(0);
+  let field = "";
+  let runStart = 0;
+  let inQuotes = false;
+  let fieldStart = true;
+  let sawAny = false;
+  const endField = (end) => {
+    if (keep) cells[column] = field + content.slice(runStart, end);
+    field = "";
+  };
+  const endRow = () => {
+    sink.row(cells, column + 1);
+    column = 0;
+    keep = keeps(0);
+  };
+  for (let i = 0; i < n; i++) {
+    const ch = content.charCodeAt(i);
+    if (inQuotes) {
+      if (ch === QUOTE) {
+        if (content.charCodeAt(i + 1) === QUOTE) {
+          if (keep) field += content.slice(runStart, i + 1);
+          i++;
+        } else {
+          if (keep) field += content.slice(runStart, i);
+          inQuotes = false;
+        }
+        runStart = i + 1;
+      }
+      continue;
+    }
+    if (ch === QUOTE && fieldStart) {
+      inQuotes = true;
+      fieldStart = false;
+      sawAny = true;
+      runStart = i + 1;
+    } else if (ch === COMMA) {
+      endField(i);
+      column++;
+      keep = keeps(column);
+      runStart = i + 1;
+      fieldStart = true;
+      sawAny = true;
+    } else if (ch === LINE_FEED) {
+      endField(i);
+      endRow();
+      runStart = i + 1;
+      fieldStart = true;
+      sawAny = false;
+    } else if (ch === CARRIAGE_RETURN) {
+      if (keep) field += content.slice(runStart, i);
+      runStart = i + 1;
+    } else {
+      fieldStart = false;
+      sawAny = true;
+    }
+  }
+  if (sawAny) {
+    endField(n);
+    endRow();
+  }
+  return inQuotes;
+}
+function readCsvByCharAt(content, sink) {
   const rows = [];
   let row = [];
   let field = "";
@@ -713,20 +815,30 @@ function parseCsvRows(content) {
       field = "";
       fieldStart = true;
       sawAny = false;
-    } else if (ch === "\r") ; else {
+    } else if (ch !== "\r") {
       field += ch;
       fieldStart = false;
       sawAny = true;
     }
   }
-  if (sawAny || field !== "" || row.length > 0) {
+  if (sawAny) {
     row.push(field);
     rows.push(row);
   }
-  return { rows, unterminatedQuote: inQuotes };
+  for (const r of rows) sink.row(r, r.length);
+  return inQuotes;
 }
 function parseCsv(content) {
-  return parseCsvRows(content).rows;
+  const rows = [];
+  scanCsv(content, {
+    wanted: void 0,
+    row: (cells, count) => {
+      const row = [];
+      for (let c = 0; c < count; c++) row.push(ownString(cells[c]));
+      rows.push(row);
+    }
+  });
+  return rows;
 }
 var MISSING_COLUMN_MESSAGE = Object.freeze({
   code: "CSV source: the configured 'code' column is not present in the header row",
@@ -743,47 +855,44 @@ function requireHeader(header, name, role) {
 }
 function parseCsvSource(source) {
   const statusMap = source.statusMap ?? defaultStatusMapper;
-  const { rows, unterminatedQuote } = parseCsvRows(source.content);
-  const header = rows[0];
-  if (header === void 0) {
-    throw new TerminologyError(
-      FATAL_CODES.TERM_CODESYSTEM_MALFORMED,
-      "CSV source: the file has no header row"
-    );
-  }
+  const content = source.content;
+  const concepts = /* @__PURE__ */ new Map();
   const warnings = [];
-  if (unterminatedQuote) {
-    warnings.push(
-      Object.freeze({
-        code: DIAGNOSTIC_CODES.TERM_CSV_MALFORMED,
-        line: rows.length,
-        detail: "an opened quoted field was not terminated before end-of-input"
-      })
-    );
-  }
-  const codeIdx = requireHeader(header, source.columns.code, "code");
-  const displayIdx = requireHeader(header, source.columns.display, "display");
-  const statusIdx = source.columns.status !== void 0 ? requireHeader(header, source.columns.status, "status") : void 0;
+  let rowCount = 0;
+  let codeIdx = 0;
+  let displayIdx = 0;
+  let statusIdx;
   const propIdx = [];
-  for (const n of source.columns.properties ?? []) {
-    propIdx.push({ name: n, index: requireHeader(header, n, "property") });
-  }
-  const needCols = Math.max(codeIdx, displayIdx, statusIdx ?? 0, ...propIdx.map((p) => p.index)) + 1;
-  const concepts = /* @__PURE__ */ new Map();
-  for (let r = 1; r < rows.length; r++) {
-    const cells = rows[r] ?? [];
-    const lineNo = r + 1;
-    if (cells.length < needCols) {
+  let needCols = 0;
+  const header = (cells, count) => {
+    const names = cells.slice(0, count);
+    codeIdx = requireHeader(names, source.columns.code, "code");
+    displayIdx = requireHeader(names, source.columns.display, "display");
+    statusIdx = source.columns.status !== void 0 ? requireHeader(names, source.columns.status, "status") : void 0;
+    for (const n of source.columns.properties ?? []) {
+      propIdx.push({ name: n, index: requireHeader(names, n, "property") });
+    }
+    needCols = Math.max(codeIdx, displayIdx, statusIdx ?? 0, ...propIdx.map((p) => p.index)) + 1;
+    const wanted = [];
+    wanted[codeIdx] = true;
+    wanted[displayIdx] = true;
+    if (statusIdx !== void 0) wanted[statusIdx] = true;
+    for (const p of propIdx) wanted[p.index] = true;
+    sink.wanted = wanted;
+  };
+  const dataRow = (cells, count, lineNo) => {
+    if (count < needCols) {
       warnings.push(
         Object.freeze({
           code: DIAGNOSTIC_CODES.TERM_CSV_MALFORMED,
           line: lineNo,
-          detail: `row has ${String(cells.length)} fields, need ${String(needCols)}`
+          detail: `row has ${String(count)} fields, need ${String(needCols)}`
         })
       );
-      continue;
+      return;
     }
-    const code = (cells[codeIdx] ?? "").trim();
+    const cell3 = (index) => cells[index];
+    const code = cell3(codeIdx).trim();
     if (code === "") {
       warnings.push(
         Object.freeze({
@@ -792,23 +901,47 @@ function parseCsvSource(source) {
           detail: "row is missing its code"
         })
       );
-      continue;
+      return;
     }
-    if (concepts.has(code)) continue;
-    const out = { code, properties: [] };
-    const display = (cells[displayIdx] ?? "").trim();
-    if (display !== "") out.display = display;
+    if (concepts.has(code)) return;
+    const out = { code: ownString(code), properties: [] };
+    const display = cell3(displayIdx).trim();
+    if (display !== "") out.display = ownString(display);
     if (statusIdx !== void 0) {
-      const rawStatus = (cells[statusIdx] ?? "").trim();
+      const rawStatus = ownString(cell3(statusIdx).trim());
       out.status = makeStatus(statusMap(rawStatus), rawStatus);
     }
     const props = [];
     for (const p of propIdx) {
-      const value = (cells[p.index] ?? "").trim();
-      if (value !== "") props.push(Object.freeze({ code: p.name, value }));
+      const value = cell3(p.index).trim();
+      if (value !== "") props.push(Object.freeze({ code: p.name, value: ownString(value) }));
     }
     out.properties = Object.freeze(props);
-    concepts.set(code, Object.freeze(out));
+    concepts.set(out.code, Object.freeze(out));
+  };
+  const sink = {
+    wanted: void 0,
+    row: (cells, count) => {
+      rowCount++;
+      if (rowCount === 1) header(cells, count);
+      else dataRow(cells, count, rowCount);
+    }
+  };
+  const unterminatedQuote = scanCsv(content, sink);
+  if (rowCount === 0) {
+    throw new TerminologyError(
+      FATAL_CODES.TERM_CODESYSTEM_MALFORMED,
+      "CSV source: the file has no header row"
+    );
+  }
+  if (unterminatedQuote) {
+    warnings.unshift(
+      Object.freeze({
+        code: DIAGNOSTIC_CODES.TERM_CSV_MALFORMED,
+        line: rowCount,
+        detail: "an opened quoted field was not terminated before end-of-input"
+      })
+    );
   }
   return { concepts, warnings };
 }
@@ -1068,6 +1201,10 @@ function parseRrf(source) {
 }
 
 // src/codesystem/load.ts
+var loadedConcepts = /* @__PURE__ */ new WeakSet();
+function isLoadedConcepts(concepts) {
+  return loadedConcepts.has(concepts);
+}
 function loadCodeSystem(source) {
   let concepts;
   let warnings;
@@ -1106,6 +1243,7 @@ function loadCodeSystem(source) {
   }
   out.count = concepts.size;
   out.concepts = frozenMap(concepts, "a loaded CodeSystem's concepts map");
+  loadedConcepts.add(out.concepts);
   out.warnings = Object.freeze(warnings);
   return Object.freeze(out);
 }
@@ -1308,8 +1446,11 @@ function directParents(concept) {
   return parents;
 }
 function buildSubsumption(cs) {
+  return subsumptionOver(cs.concepts);
+}
+function subsumptionOver(concepts) {
   const parentsOf = /* @__PURE__ */ new Map();
-  for (const concept of cs.concepts.values()) {
+  for (const concept of concepts.values()) {
     const parents = directParents(concept);
     if (parents.length > 0) parentsOf.set(concept.code, parents);
   }
@@ -1330,6 +1471,17 @@ function buildSubsumption(cs) {
   };
   return { ancestorsOf };
 }
+var loadedSubsumption = /* @__PURE__ */ new WeakMap();
+function subsumptionOf(cs) {
+  const concepts = cs.concepts;
+  if (!isLoadedConcepts(concepts)) return subsumptionOver(concepts);
+  let sub = loadedSubsumption.get(concepts);
+  if (sub === void 0) {
+    sub = subsumptionOver(concepts);
+    loadedSubsumption.set(concepts, sub);
+  }
+  return sub;
+}
 function isA(sub, code, anchor) {
   return code === anchor || sub.ancestorsOf(code).has(anchor);
 }
@@ -1732,7 +1884,7 @@ function matchComponent(target, component, ctx, visited, path, activeOnly = fals
           baseComplete = false;
         } else {
           const concpt = cs.concepts.get(target.code);
-          baseMatched = concpt !== void 0 && matchesAllFilters(concpt, filter, buildSubsumption(cs)).matched;
+          baseMatched = concpt !== void 0 && matchesAllFilters(concpt, filter, subsumptionOf(cs)).matched;
         }
       } else {
         baseMatched = cs.concepts.get(target.code) !== void 0;
@@ -4022,7 +4174,29 @@ function atBoundary(s, pos) {
 function prefixRank(m) {
   return m.prefix ? 1 : 0;
 }
+function byPreference(a, b) {
+  return b.len - a.len || prefixRank(a) - prefixRank(b);
+}
 function simpleMatches(essence, s, pos) {
+  if (typeof s !== "string") return simpleMatchesByScan(essence, s, pos);
+  const index = indexOf(essence);
+  const out = [];
+  for (const atom of index.atoms.get(s.charCodeAt(pos)) ?? NONE) {
+    if (s.startsWith(atom.code, pos)) out.push({ atom, len: atom.code.length });
+  }
+  for (const prefix of index.prefixes.get(s.charCodeAt(pos)) ?? NONE) {
+    if (!s.startsWith(prefix.code, pos)) continue;
+    const rem = pos + prefix.code.length;
+    for (const atom of index.metricAtoms.get(s.charCodeAt(rem)) ?? NONE) {
+      if (s.startsWith(atom.code, rem)) {
+        out.push({ prefix, atom, len: prefix.code.length + atom.code.length });
+      }
+    }
+  }
+  out.sort(byPreference);
+  return out;
+}
+function simpleMatchesByScan(essence, s, pos) {
   const out = [];
   for (const atom of essence.atoms) {
     if (s.startsWith(atom.code, pos)) out.push({ atom, len: atom.code.length });
@@ -4036,9 +4210,33 @@ function simpleMatches(essence, s, pos) {
       }
     }
   }
-  out.sort((a, b) => b.len - a.len || prefixRank(a) - prefixRank(b));
+  out.sort(byPreference);
   return out;
 }
+var NONE = Object.freeze([]);
+var firstCharIndexes = /* @__PURE__ */ new WeakMap();
+function byFirstChar(items) {
+  const out = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const first = item.code.charCodeAt(0);
+    const list = out.get(first);
+    if (list === void 0) out.set(first, [item]);
+    else list.push(item);
+  }
+  return out;
+}
+function indexOf(essence) {
+  let index = firstCharIndexes.get(essence);
+  if (index === void 0) {
+    index = {
+      atoms: byFirstChar(essence.atoms),
+      metricAtoms: byFirstChar(essence.atoms.filter((a) => a.metric)),
+      prefixes: byFirstChar(essence.prefixes)
+    };
+    firstCharIndexes.set(essence, index);
+  }
+  return index;
+}
 var MAX_PAREN_DEPTH = 100;
 function parseExponent(cur) {
   const { s } = cur;
@@ -4071,8 +4269,8 @@ function parseAnnotation(cur) {
   return { ok: false, reason: "annotation is not closed with '}'" };
 }
 function parseSimpleUnit(cur) {
-  const candidates = simpleMatches(cur.essence, cur.s, cur.pos);
-  for (const cand of candidates) {
+  const candidates2 = simpleMatches(cur.essence, cur.s, cur.pos);
+  for (const cand of candidates2) {
     const save = cur.pos;
     cur.pos = save + cand.len;
     const exp = parseExponent(cur);
@@ -4298,57 +4496,62 @@ function isNoMapSentinel(target) {
   return target === NO_DX || target === NO_PCS;
 }
 function decodeFlags(raw) {
-  if (!/^[0-9]{5}$/.test(raw)) return void 0;
   return Object.freeze({
-    approximate: raw[0] === "1",
-    noMap: raw[1] === "1",
-    combination: raw[2] === "1",
-    scenario: Number(raw[3]),
-    choiceList: Number(raw[4]),
+    approximate: raw.charCodeAt(0) === DIGIT_ONE,
+    noMap: raw.charCodeAt(1) === DIGIT_ONE,
+    combination: raw.charCodeAt(2) === DIGIT_ONE,
+    scenario: raw.charCodeAt(3) - DIGIT_ZERO,
+    choiceList: raw.charCodeAt(4) - DIGIT_ZERO,
     raw
   });
 }
+var DIGIT_ZERO = 48;
+var DIGIT_ONE = 49;
+var DIGIT_NINE = 57;
+var SPACE = 32;
+var NON_ASCII_SPACE = /^\s$/;
+function isSpace(c) {
+  if (c < 128) return c === SPACE || c >= 9 && c <= 13;
+  return NON_ASCII_SPACE.test(String.fromCharCode(c));
+}
 function loadGems(source) {
   const entries = /* @__PURE__ */ new Map();
   const warnings = [];
   let count = 0;
-  const lines = source.content.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const raw = lines[i];
-    if (raw === void 0) continue;
-    const trimmed = raw.trim();
-    if (trimmed === "") continue;
-    const fields = trimmed.split(/\s+/);
-    if (fields.length !== 3) {
+  const sink = {
+    flags: /* @__PURE__ */ new Map(),
+    malformed: (lineNo, fieldCount) => {
       warnings.push(
         Object.freeze({
           code: "TERM_GEM_MALFORMED_ROW",
-          line: i + 1,
-          detail: `expected 3 whitespace-delimited fields, found ${String(fields.length)}`
+          line: lineNo,
+          detail: `expected 3 whitespace-delimited fields, found ${String(fieldCount)}`
         })
       );
-      continue;
-    }
-    const [src, tgt, flagStr] = fields;
-    const flags = decodeFlags(flagStr);
-    if (flags === void 0) {
-      warnings.push(
-        Object.freeze({
-          code: "TERM_GEM_MALFORMED_ROW",
-          line: i + 1,
-          detail: "flag field is not a 5-digit code"
-        })
+    },
+    line: (lineNo, src, tgt, flags) => {
+      if (flags === void 0) {
+        warnings.push(
+          Object.freeze({
+            code: "TERM_GEM_MALFORMED_ROW",
+            line: lineNo,
+            detail: "flag field is not a 5-digit code"
+          })
+        );
+        return;
+      }
+      const frozen = Object.freeze(
+        isNoMapSentinel(tgt) ? { source: src, flags } : { source: src, flags, target: tgt }
       );
-      continue;
+      const list = entries.get(src);
+      if (list) list.push(frozen);
+      else entries.set(src, [frozen]);
+      count++;
     }
-    const entry = { source: src, flags };
-    if (!isNoMapSentinel(tgt)) entry.target = tgt;
-    const frozen = Object.freeze(entry);
-    const list = entries.get(src);
-    if (list) list.push(frozen);
-    else entries.set(src, [frozen]);
-    count++;
-  }
+  };
+  const content = source.content;
+  if (typeof content === "string") readLinesInPlace(content, sink);
+  else readLinesBySplit(content, sink);
   for (const list of entries.values()) Object.freeze(list);
   return Object.freeze({
     direction: source.direction,
@@ -4358,6 +4561,90 @@ function loadGems(source) {
     warnings: Object.freeze(warnings)
   });
 }
+function sharedFlags(sink, text, from, to) {
+  const key = fiveDigitsAt(text, from, to);
+  if (key === -1) return void 0;
+  let flags = sink.flags.get(key);
+  if (flags === void 0) {
+    flags = decodeFlags(text.slice(from, to));
+    sink.flags.set(key, flags);
+  }
+  return flags;
+}
+function fiveDigitsAt(content, from, to) {
+  if (to - from !== 5) return -1;
+  let value = 0;
+  for (let i = from; i < to; i++) {
+    const c = content.charCodeAt(i);
+    if (c < DIGIT_ZERO || c > DIGIT_NINE) return -1;
+    value = value * 10 + (c - DIGIT_ZERO);
+  }
+  return value;
+}
+function readLinesInPlace(content, sink) {
+  const n = content.length;
+  let lineNo = 0;
+  for (let start = 0; start <= n; ) {
+    let end = content.indexOf("\n", start);
+    if (end === -1) end = n;
+    lineNo++;
+    let fieldCount = 0;
+    let srcStart = 0;
+    let srcEnd = 0;
+    let tgtStart = 0;
+    let tgtEnd = 0;
+    let flagStart = 0;
+    let flagEnd = 0;
+    for (let i = start; i < end; ) {
+      if (isSpace(content.charCodeAt(i))) {
+        i++;
+        continue;
+      }
+      const from = i;
+      while (i < end && !isSpace(content.charCodeAt(i))) i++;
+      fieldCount++;
+      if (fieldCount === 1) {
+        srcStart = from;
+        srcEnd = i;
+      } else if (fieldCount === 2) {
+        tgtStart = from;
+        tgtEnd = i;
+      } else if (fieldCount === 3) {
+        flagStart = from;
+        flagEnd = i;
+      }
+    }
+    start = end + 1;
+    if (fieldCount === 0) continue;
+    if (fieldCount !== 3) {
+      sink.malformed(lineNo, fieldCount);
+      continue;
+    }
+    const flags = sharedFlags(sink, content, flagStart, flagEnd);
+    sink.line(
+      lineNo,
+      ownString(content.slice(srcStart, srcEnd)),
+      ownString(content.slice(tgtStart, tgtEnd)),
+      flags
+    );
+  }
+}
+function readLinesBySplit(content, sink) {
+  const lines = content.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (raw === void 0) continue;
+    const trimmed = raw.trim();
+    if (trimmed === "") continue;
+    const fields = trimmed.split(/\s+/);
+    if (fields.length !== 3) {
+      sink.malformed(i + 1, fields.length);
+      continue;
+    }
+    const [src, tgt, flagStr] = fields;
+    sink.line(i + 1, src, tgt, sharedFlags(sink, flagStr, 0, flagStr.length));
+  }
+}
 function buildCombinations(entries) {
   const combo = entries.filter((e) => e.flags.combination && e.target !== void 0);
   if (combo.length === 0) return void 0;
@@ -5019,7 +5306,7 @@ function approximateMatch(graph, query, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.1.6";
+var VERSION = "0.1.7";
 
 exports.COMPLEX_MAP_SOURCE_SYSTEM = COMPLEX_MAP_SOURCE_SYSTEM;
 exports.DIAGNOSTIC_CODES = DIAGNOSTIC_CODES;