@qe-libs/refi-qda 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0
+
+- First release, from QE Studio's importer (`js/importers/refi-qda.js`):
+  `readProject`, `toTable`, `toCSV`, `writeCSV`, `QdaError`.
+- Runs in the browser (its own `DOMParser`) as well as Node (pass one in);
+  fflate is bundled; CSV writing no longer needs papaparse.
+- Coders: `coder: 'all'` (every coder agrees) and `coder: 'each'` (one row
+  per utterance per coder, with a Coder column) and `coder: 'columns'` (each
+  code once per coder, "Code [Coder A]") besides `'any'` and a single
+  coder; `codersOf(project)` lists the coders and their coded spans; the
+  report records the `coder` used.

package/README.md

@@ -1,3 +1,84 @@
-# Temporary Holding Version
+# @qe-libs/refi-qda
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Reads REFI-QDA projects (`.qdpx`, exported by NVivo, ATLAS.ti, MAXQDA,
+QualCoder and others) into the table ENA works on: one row per utterance,
+a 0/1 column per code. Runs in the browser and in Node; about 6 KB gzipped
+(the unzip library, fflate, is bundled).
+
+REFI-QDA is the open exchange standard from the Rotterdam Exchange Format
+Initiative. A `.qdpx` is a zip of `project.qde` (XML: codebook, coders,
+sources, coded spans) and the source texts.
+
+## Use
+
+```js
+import { toCSV } from '@qe-libs/refi-qda';
+
+const { csv, report, coders, textColumn } = toCSV(bytes, { coder: 'any' });
+```
+
+- `bytes`: an `ArrayBuffer`, `Uint8Array` or `Buffer`.
+- `coder`: whose coding becomes the code columns, for projects coded by
+  more than one person (see `codersOf`):
+
+  | `coder` | Rows | A line is 1 for a code when… |
+  |---|---|---|
+  | `'any'` (default) | one per utterance | any coder coded it |
+  | `'all'` | one per utterance | every coder coded it |
+  | `'each'` | one per utterance per coder, with a `Coder` column | that row's coder coded it |
+  | `'columns'` | one per utterance; each code once per coder, `Code [Coder A]` | that column's coder coded it |
+  | a coder's name or GUID | one per utterance | that coder coded it |
+
+  `'each'` and `'columns'` keep every coder's coding: `'each'` so coders can
+  be compared or combined in the model (Coder as a unit or a group),
+  `'columns'` so each coder's version of a code can be chosen or compared as
+  codes.
+- In Node, pass an XML parser: `toCSV(bytes, { DOMParser: require('@xmldom/xmldom').DOMParser })`.
+  The browser's own `DOMParser` is used otherwise.
+
+In a page without a bundler, `dist/refi-qda.umd.js` defines `window.RefiQda`.
+
+| Function | Returns |
+|---|---|
+| `codersOf(project)` | `[{ guid, name, spans }]`: the coders who coded something, with their number of coded spans |
+| `readProject(bytes, { DOMParser })` | The project: `codes`, `users`, `sources` (text, variables, coded spans), `skipped` |
+| `toTable(project, { coder })` | `{ fields, rows, report }` |
+| `toCSV(bytes, { coder, DOMParser })` | `{ csv, fields, rows, report, coders, textColumn }` |
+| `writeCSV(fields, rows)` | CSV text |
+
+Errors are `QdaError`s with a `code`: `not-zip`, `no-project`, `bad-xml`,
+`no-coder`, `misaligned`, `no-sources`. Their messages are written for the
+person importing.
+
+## The table
+
+Columns: `Source`, `Line`, `UserName` (the speaker), `Coder` (with
+`coder: 'each'`), the sources' variables,
+`Text`, then one column per codable code in codebook order (a repeated name
+gets its parent's: `Design talk / Cost`).
+
+Rows are the transcript lines that look like `Speaker: text`; a transcript
+without such lines gives one row per non-empty line. A line is 1 for a code
+when a span coded with it (by the chosen coder) overlaps the line.
+
+## Positions
+
+Coded spans are character positions in each source's text, and exporters
+count them differently: code points, UTF-16 units, or with CRLF line ends as
+two characters. Each source's spans are checked against the span text the
+project records, the reading that matches is used, and `report.notes` says
+when it isn't plain code points. When fewer than 90% match, the import stops
+(`misaligned`) rather than placing codes on the wrong lines.
+
+`report` also gives counts, the coders, skipped sources (audio, PDF, images)
+and how many spans were checked.
+
+## Develop
+
+```bash
+npm install
+npm test        # builds dist/, then runs tests/ (node --test)
+```
+
+`tests/fixtures/` holds a small invented project and the CSV expected for
+each coder; `make_sample.py` regenerates them.

package/dist/refi-qda.es.js

@@ -0,0 +1,562 @@
+var F = Uint8Array, Q = Uint16Array, $e = Int32Array, de = new F([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]), we = new F([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]), Te = new F([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), xe = function(e, r) {
+  for (var n = new Q(31), t = 0; t < 31; ++t)
+    n[t] = r += 1 << e[t - 1];
+  for (var o = new $e(n[30]), t = 1; t < 30; ++t)
+    for (var c = n[t]; c < n[t + 1]; ++c)
+      o[c] = c - n[t] << 5 | t;
+  return { b: n, r: o };
+}, be = xe(de, 2), Ae = be.b, Ee = be.r;
+Ae[28] = 258, Ee[258] = 28;
+var Fe = xe(we, 0), Me = Fe.b, ae = new Q(32768);
+for (var w = 0; w < 32768; ++w) {
+  var q = (w & 43690) >> 1 | (w & 21845) << 1;
+  q = (q & 52428) >> 2 | (q & 13107) << 2, q = (q & 61680) >> 4 | (q & 3855) << 4, ae[w] = ((q & 65280) >> 8 | (q & 255) << 8) >> 1;
+}
+var H = (function(e, r, n) {
+  for (var t = e.length, o = 0, c = new Q(r); o < t; ++o)
+    e[o] && ++c[e[o] - 1];
+  var a = new Q(r);
+  for (o = 1; o < r; ++o)
+    a[o] = a[o - 1] + c[o - 1] << 1;
+  var s;
+  if (n) {
+    s = new Q(1 << r);
+    var m = 15 - r;
+    for (o = 0; o < t; ++o)
+      if (e[o])
+        for (var v = o << 4 | e[o], d = r - e[o], i = a[e[o] - 1]++ << d, p = i | (1 << d) - 1; i <= p; ++i)
+          s[ae[i] >> m] = v;
+  } else
+    for (s = new Q(t), o = 0; o < t; ++o)
+      e[o] && (s[o] = ae[a[e[o] - 1]++] >> 15 - e[o]);
+  return s;
+}), J = new F(288);
+for (var w = 0; w < 144; ++w)
+  J[w] = 8;
+for (var w = 144; w < 256; ++w)
+  J[w] = 9;
+for (var w = 256; w < 280; ++w)
+  J[w] = 7;
+for (var w = 280; w < 288; ++w)
+  J[w] = 8;
+var Ce = new F(32);
+for (var w = 0; w < 32; ++w)
+  Ce[w] = 5;
+var Ue = /* @__PURE__ */ H(J, 9, 1), De = /* @__PURE__ */ H(Ce, 5, 1), ne = function(e) {
+  for (var r = e[0], n = 1; n < e.length; ++n)
+    e[n] > r && (r = e[n]);
+  return r;
+}, N = function(e, r, n) {
+  var t = r / 8 | 0;
+  return (e[t] | e[t + 1] << 8) >> (r & 7) & n;
+}, te = function(e, r) {
+  var n = r / 8 | 0;
+  return (e[n] | e[n + 1] << 8 | e[n + 2] << 16) >> (r & 7);
+}, Ne = function(e) {
+  return (e + 7) / 8 | 0;
+}, fe = function(e, r, n) {
+  return (r == null || r < 0) && (r = 0), (n == null || n > e.length) && (n = e.length), new F(e.subarray(r, n));
+}, Oe = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  // determined by compression function
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+], E = function(e, r, n) {
+  var t = new Error(r || Oe[e]);
+  if (t.code = e, Error.captureStackTrace && Error.captureStackTrace(t, E), !n)
+    throw t;
+  return t;
+}, Pe = function(e, r, n, t) {
+  var o = e.length, c = t ? t.length : 0;
+  if (!o || r.f && !r.l)
+    return n || new F(0);
+  var a = !n, s = a || r.i != 2, m = r.i;
+  a && (n = new F(o * 3));
+  var v = function(pe) {
+    var ve = n.length;
+    if (pe > ve) {
+      var ge = new F(Math.max(ve * 2, pe));
+      ge.set(n), n = ge;
+    }
+  }, d = r.f || 0, i = r.p || 0, p = r.b || 0, u = r.l, A = r.d, x = r.m, g = r.n, k = o * 8;
+  do {
+    if (!u) {
+      d = N(e, i, 1);
+      var f = N(e, i + 1, 3);
+      if (i += 3, f)
+        if (f == 1)
+          u = Ue, A = De, x = 9, g = 5;
+        else if (f == 2) {
+          var R = N(e, i, 31) + 257, z = N(e, i + 10, 15) + 4, W = R + N(e, i + 5, 31) + 1;
+          i += 14;
+          for (var B = new F(W), j = new F(19), y = 0; y < z; ++y)
+            j[Te[y]] = N(e, i + y * 3, 7);
+          i += z * 3;
+          for (var Y = ne(j), K = (1 << Y) - 1, l = H(j, Y, 1), y = 0; y < W; ) {
+            var C = l[N(e, i, K)];
+            i += C & 15;
+            var h = C >> 4;
+            if (h < 16)
+              B[y++] = h;
+            else {
+              var T = 0, b = 0;
+              for (h == 16 ? (b = 3 + N(e, i, 3), i += 2, T = B[y - 1]) : h == 17 ? (b = 3 + N(e, i, 7), i += 3) : h == 18 && (b = 11 + N(e, i, 127), i += 7); b--; )
+                B[y++] = T;
+            }
+          }
+          var M = B.subarray(0, R), O = B.subarray(R);
+          x = ne(M), g = ne(O), u = H(M, x, 1), A = H(O, g, 1);
+        } else
+          E(1);
+      else {
+        var h = Ne(i) + 4, S = e[h - 4] | e[h - 3] << 8, $ = h + S;
+        if ($ > o) {
+          m && E(0);
+          break;
+        }
+        s && v(p + S), n.set(e.subarray(h, $), p), r.b = p += S, r.p = i = $ * 8, r.f = d;
+        continue;
+      }
+      if (i > k) {
+        m && E(0);
+        break;
+      }
+    }
+    s && v(p + 131072);
+    for (var ke = (1 << x) - 1, ye = (1 << g) - 1, _ = i; ; _ = i) {
+      var T = u[te(e, i) & ke], L = T >> 4;
+      if (i += T & 15, i > k) {
+        m && E(0);
+        break;
+      }
+      if (T || E(2), L < 256)
+        n[p++] = L;
+      else if (L == 256) {
+        _ = i, u = null;
+        break;
+      } else {
+        var le = L - 254;
+        if (L > 264) {
+          var y = L - 257, X = de[y];
+          le = N(e, i, (1 << X) - 1) + Ae[y], i += X;
+        }
+        var ee = A[te(e, i) & ye], re = ee >> 4;
+        ee || E(3), i += ee & 15;
+        var O = Me[re];
+        if (re > 3) {
+          var X = we[re];
+          O += te(e, i) & (1 << X) - 1, i += X;
+        }
+        if (i > k) {
+          m && E(0);
+          break;
+        }
+        s && v(p + 131072);
+        var ue = p + le;
+        if (p < O) {
+          var he = c - O, Se = Math.min(O, ue);
+          for (he + p < 0 && E(3); p < Se; ++p)
+            n[p] = t[he + p];
+        }
+        for (; p < ue; ++p)
+          n[p] = n[p - O];
+      }
+    }
+    r.l = u, r.p = _, r.b = p, r.f = d, u && (d = 1, r.m = x, r.d = A, r.n = g);
+  } while (!d);
+  return p != n.length && a ? fe(n, 0, p) : n.subarray(0, p);
+}, Ve = /* @__PURE__ */ new F(0), V = function(e, r) {
+  return e[r] | e[r + 1] << 8;
+}, D = function(e, r) {
+  return (e[r] | e[r + 1] << 8 | e[r + 2] << 16 | e[r + 3] << 24) >>> 0;
+}, oe = function(e, r) {
+  return D(e, r) + D(e, r + 4) * 4294967296;
+};
+function Re(e, r) {
+  return Pe(e, { i: 2 }, r && r.out, r && r.dictionary);
+}
+var se = typeof TextDecoder < "u" && /* @__PURE__ */ new TextDecoder(), Be = 0;
+try {
+  se.decode(Ve, { stream: !0 }), Be = 1;
+} catch {
+}
+var qe = function(e) {
+  for (var r = "", n = 0; ; ) {
+    var t = e[n++], o = (t > 127) + (t > 223) + (t > 239);
+    if (n + o > e.length)
+      return { s: r, r: fe(e, n - 1) };
+    o ? o == 3 ? (t = ((t & 15) << 18 | (e[n++] & 63) << 12 | (e[n++] & 63) << 6 | e[n++] & 63) - 65536, r += String.fromCharCode(55296 | t >> 10, 56320 | t & 1023)) : o & 1 ? r += String.fromCharCode((t & 31) << 6 | e[n++] & 63) : r += String.fromCharCode((t & 15) << 12 | (e[n++] & 63) << 6 | e[n++] & 63) : r += String.fromCharCode(t);
+  }
+};
+function ie(e, r) {
+  if (r) {
+    for (var n = "", t = 0; t < e.length; t += 16384)
+      n += String.fromCharCode.apply(null, e.subarray(t, t + 16384));
+    return n;
+  } else {
+    if (se)
+      return se.decode(e);
+    var o = qe(e), c = o.s, n = o.r;
+    return n.length && E(8), c;
+  }
+}
+var ze = function(e, r) {
+  return r + 30 + V(e, r + 26) + V(e, r + 28);
+}, je = function(e, r, n) {
+  var t = V(e, r + 28), o = V(e, r + 30), c = ie(e.subarray(r + 46, r + 46 + t), !(V(e, r + 8) & 2048)), a = r + 46 + t, s = Ie(e, a, o, n, D(e, r + 20), D(e, r + 24), D(e, r + 42)), m = s[0], v = s[1], d = s[2];
+  return [V(e, r + 10), m, v, c, a + o + V(e, r + 32), d];
+}, Ie = function(e, r, n, t, o, c, a) {
+  var s = o == 4294967295, m = c == 4294967295, v = a == 4294967295, d = r + n, i = s + m + v;
+  if (t && i) {
+    for (; r + 4 < d; r += 4 + V(e, r + 2))
+      if (V(e, r) == 1)
+        return [
+          s ? oe(e, r + 4 + 8 * m) : o,
+          m ? oe(e, r + 4) : c,
+          v ? oe(e, r + 4 + 8 * (m + s)) : a,
+          1
+        ];
+    t < 2 && E(13);
+  }
+  return [o, c, a, 0];
+};
+function Le(e, r) {
+  for (var n = {}, t = e.length - 22; D(e, t) != 101010256; --t)
+    (!t || e.length - t > 65558) && E(13);
+  var o = V(e, t + 8);
+  if (!o)
+    return {};
+  var c = D(e, t + 16), a = D(e, t - 20) == 117853008;
+  if (a) {
+    var s = D(e, t - 12);
+    a = D(e, s) == 101075792, a && (o = D(e, s + 32), c = D(e, s + 48));
+  }
+  for (var m = 0; m < o; ++m) {
+    var v = je(e, c, a), d = v[0], i = v[1], p = v[2], u = v[3], A = v[4], x = v[5], g = ze(e, x);
+    c = A, d ? d == 8 ? n[u] = Re(e.subarray(g, g + i), { out: new F(p) }) : E(14, "unknown compression type " + d) : n[u] = fe(e, g, g + i);
+  }
+  return n;
+}
+class G extends Error {
+  constructor(r, n) {
+    super(r), this.name = "QdaError", this.code = n;
+  }
+}
+const U = (e, r) => e ? Array.from(e.childNodes).filter((n) => n.nodeType === 1 && (!r || n.localName === r)) : [], P = (e, r) => U(e, r)[0], Z = (e) => e && e.textContent || "";
+function Qe(e, r) {
+  const n = [];
+  let t;
+  try {
+    t = new e({ onError: (c, a) => {
+      c !== "warning" && n.push(a);
+    } }).parseFromString(r, "text/xml");
+  } catch (c) {
+    n.push(c.message);
+  }
+  const o = t && t.getElementsByTagName("parsererror")[0];
+  return o && n.push(Z(o).trim().split(`
+`)[0]), { root: n.length ? null : t && t.documentElement, error: n[0] };
+}
+function me(e, r) {
+  const n = r.toLowerCase(), t = Object.keys(e).find((o) => o.toLowerCase() === n || o.toLowerCase().endsWith("/" + n));
+  return t ? e[t] : null;
+}
+function Ge(e, { DOMParser: r = globalThis.DOMParser } = {}) {
+  if (!r) throw new Error("readProject needs a DOMParser: pass { DOMParser } (in Node, from @xmldom/xmldom).");
+  let n;
+  try {
+    n = Le(e instanceof Uint8Array ? e : new Uint8Array(e));
+  } catch {
+    throw new G("This file isn't a .qdpx project (it can't be opened as a zip archive).", "not-zip");
+  }
+  const t = me(n, "project.qde");
+  if (!t) throw new G("This .qdpx has no project.qde inside, so it isn't a REFI-QDA project.", "no-project");
+  const { root: o, error: c } = Qe(r, ie(t));
+  if (!o || o.localName !== "Project")
+    throw new G(`project.qde couldn't be read as a REFI-QDA project${c ? `: ${c}` : ""}.`, "bad-xml");
+  const a = new Map(U(P(o, "Users"), "User").map((u) => [u.getAttribute("guid"), u.getAttribute("name") || u.getAttribute("guid")])), s = [];
+  (function u(A, x) {
+    for (const g of U(A, "Code")) {
+      const k = g.getAttribute("name") || "(unnamed code)";
+      s.push({
+        guid: g.getAttribute("guid"),
+        name: k,
+        parent: x,
+        codable: g.getAttribute("isCodable") !== "false",
+        description: Z(P(g, "Description")).trim()
+      }), u(g, k);
+    }
+  })(P(P(o, "CodeBook"), "Codes"), null);
+  const m = new Map(U(P(o, "Variables"), "Variable").map((u) => [u.getAttribute("guid"), u.getAttribute("name")])), v = (u) => {
+    var g;
+    const A = (g = P(u, "VariableRef")) == null ? void 0 : g.getAttribute("targetGUID"), x = U(u).find((k) => k.localName !== "VariableRef");
+    return [m.get(A) || A, Z(x).trim()];
+  }, d = /* @__PURE__ */ new Map();
+  for (const u of U(P(o, "Cases"), "Case")) {
+    const A = U(u, "SourceRef");
+    if (u.getAttribute("name") || A.length !== 1) continue;
+    const x = A[0].getAttribute("targetGUID"), g = d.get(x) || {};
+    for (const k of U(u, "VariableValue")) {
+      const [f, h] = v(k);
+      g[f] = h;
+    }
+    d.set(x, g);
+  }
+  const i = [], p = [];
+  for (const u of U(P(o, "Sources"))) {
+    const A = u.getAttribute("name") || u.getAttribute("guid");
+    if (u.localName !== "TextSource") {
+      p.push(`${A} (${u.localName.replace(/Source$/, "").toLowerCase()})`);
+      continue;
+    }
+    let x = null;
+    const g = P(u, "PlainTextContent");
+    if (g) x = Z(g);
+    else {
+      const h = u.getAttribute("plainTextPath") || "", S = /^internal:\/\/(.+)$/.exec(h);
+      if (!S) {
+        p.push(`${A} (its text is stored outside the project: ${h || "no path"})`);
+        continue;
+      }
+      const $ = me(n, "Sources/" + S[1]);
+      if (!$) {
+        p.push(`${A} (Sources/${S[1]} is missing)`);
+        continue;
+      }
+      x = ie($);
+    }
+    x = x.replace(/^/, "");
+    const k = { ...d.get(u.getAttribute("guid")) || {} };
+    for (const h of U(u, "VariableValue")) {
+      const [S, $] = v(h);
+      k[S] = $;
+    }
+    const f = U(u, "PlainTextSelection").map((h) => ({
+      start: +h.getAttribute("startPosition"),
+      end: +h.getAttribute("endPosition"),
+      name: h.getAttribute("name"),
+      codings: U(h, "Coding").map((S) => {
+        var $;
+        return {
+          code: ($ = P(S, "CodeRef")) == null ? void 0 : $.getAttribute("targetGUID"),
+          user: S.getAttribute("creatingUser") || h.getAttribute("creatingUser")
+        };
+      })
+    }));
+    i.push({ guid: u.getAttribute("guid"), name: A, raw: x, vars: k, selections: f });
+  }
+  return { name: o.getAttribute("name") || "", users: a, codes: s, sources: i, skipped: p };
+}
+function We(e) {
+  const r = Array.from(e), n = [];
+  let t = 0;
+  for (let s = 0; s < r.length; s++)
+    n.push(t), !(r[s] === "\r" && r[s + 1] === `
+`) && t++;
+  n.push(t);
+  const o = e.replace(/\r\n?/g, `
+`), c = [];
+  let a = 0;
+  for (const s of o)
+    c.push(a), s.length === 2 && c.push(a), a++;
+  return c.push(a), {
+    text: o,
+    cps: Array.from(o),
+    ways: {
+      "code points": (s) => s,
+      "code points, CRLF as two": (s) => n[s],
+      "UTF-16 units": (s) => c[s]
+    }
+  };
+}
+const ce = (e) => String(e || "").replace(/\s+/g, " ").trim();
+function Ke(e, r, n) {
+  let t = 0;
+  for (const o of r) {
+    const c = n(o.start), a = n(o.end);
+    if (c === void 0 || a === void 0 || c > a) continue;
+    const s = ce(e.slice(c, a).join("")), m = ce(o.name);
+    s && (s === m || m.length >= 20 && s.startsWith(m)) && t++;
+  }
+  return t;
+}
+const Xe = new RegExp("^\\s*(\\p{L}[^:\\n]{0,39}?)\\s*:\\s+(\\S.*)$", "u"), I = "(no coder)";
+function He(e) {
+  const r = new Set(e.codes.filter((a) => a.codable).map((a) => a.guid)), n = /* @__PURE__ */ new Map();
+  for (const a of e.sources) for (const s of a.selections)
+    new Set(s.codings.filter((v) => r.has(v.code)).map((v) => v.user || I)).forEach((v) => n.set(v, (n.get(v) || 0) + 1));
+  const t = [...e.users].filter(([a]) => n.has(a)).map(([a, s]) => ({ guid: a, name: s, spans: n.get(a) })), o = [...n.keys()].filter((a) => a !== I && !e.users.has(a)).map((a) => ({ guid: a, name: a, spans: n.get(a) })), c = n.has(I) ? [{ guid: I, name: I, spans: n.get(I) }] : [];
+  return [...t, ...o, ...c];
+}
+function Je(e, { coder: r = "any" } = {}) {
+  const n = { sources: 0, rows: 0, codes: 0, coders: [...new Set(e.users.values())], skippedSources: e.skipped, notes: [] }, t = He(e);
+  n.coder = r;
+  let o = null;
+  if (!["any", "all", "each", "columns"].includes(r) && (o = [...e.users].filter(([f, h]) => h === r || f === r).map(([f]) => f), !o.length && t.some((f) => f.guid === r) && (o = [r]), !o.length))
+    throw new G(`There's no coder called “${r}” in this project.`, "no-coder");
+  const c = r === "each", a = r === "columns", s = e.codes.filter((f) => f.codable), m = {};
+  s.forEach((f) => {
+    m[f.name] = (m[f.name] || 0) + 1;
+  });
+  const v = s.map((f) => m[f.name] > 1 && f.parent ? `${f.parent} / ${f.name}` : f.name);
+  n.codes = v.length;
+  const d = [];
+  e.sources.forEach((f) => Object.keys(f.vars).forEach((h) => {
+    d.includes(h) || d.push(h);
+  }));
+  const i = ["Source", "Line", "UserName", ...c ? ["Coder"] : [], ...d, "Text"], p = a ? v.flatMap((f) => t.map((h) => `${f} [${h.name}]`)) : v.map((f) => i.includes(f) ? `${f} (code)` : f), u = [...i, ...p];
+  n.columns = p.length;
+  const A = new Map(s.map((f, h) => [f.guid, h]));
+  let x = 0, g = 0;
+  const k = [];
+  for (const f of e.sources) {
+    n.sources++;
+    const { text: h, cps: S, ways: $ } = We(f.raw), R = f.selections.filter((l) => ce(l.name));
+    let z = "code points";
+    if (R.length) {
+      let l = -1;
+      for (const [C, T] of Object.entries($)) {
+        const b = Ke(S, R, T);
+        b > l && (l = b, z = C);
+      }
+      if (x += R.length, g += l, l < R.length * 0.9)
+        throw new G(`The coded spans in “${f.name}” don't line up with its text (${l} of ${R.length} match), so the codes can't be placed on lines. The file may have been changed after it was coded.`, "misaligned");
+      z !== "code points" && n.notes.push(`“${f.name}”: positions counted as ${z}.`);
+    }
+    const W = $[z], B = [];
+    let j = 0;
+    for (const l of h.split(`
+`)) {
+      const C = Array.from(l).length;
+      B.push({ text: l, start: j, end: j + C }), j += C + 1;
+    }
+    let y = B.map((l, C) => {
+      const T = Xe.exec(l.text);
+      return T && { ...l, i: C, speaker: T[1], said: T[2].trim() };
+    }).filter(Boolean);
+    y.length || (y = B.map((l, C) => l.text.trim() && { ...l, i: C, speaker: "", said: l.text.trim() }).filter(Boolean), n.notes.push(`“${f.name}” has no “Name: text” lines, so each non-empty line is a row with no speaker.`));
+    const Y = f.selections.map((l) => ({
+      a: W(l.start),
+      b: W(l.end),
+      codings: l.codings.filter((C) => A.has(C.code)).map((C) => [A.get(C.code), C.user || I])
+    })).filter((l) => l.codings.length && l.a !== void 0 && l.b !== void 0), K = d.map((l) => f.vars[l] ?? "");
+    for (const l of y) {
+      const C = v.map(() => /* @__PURE__ */ new Set());
+      for (const b of Y) b.a < l.end && b.b > l.start && b.codings.forEach(([M, O]) => C[M].add(O));
+      if (a) {
+        k.push([f.name, l.i + 1, l.speaker, ...K, l.said, ...C.flatMap((b) => t.map((M) => +b.has(M.guid)))]);
+        continue;
+      }
+      if (c) {
+        for (const b of t) k.push([f.name, l.i + 1, l.speaker, b.name, ...K, l.said, ...C.map((M) => +M.has(b.guid))]);
+        continue;
+      }
+      const T = r === "any" ? (b) => b.size > 0 : r === "all" ? (b) => t.length > 0 && t.every((M) => b.has(M.guid)) : (b) => o.some((M) => b.has(M));
+      k.push([f.name, l.i + 1, l.speaker, ...K, l.said, ...C.map((b) => +T(b))]);
+    }
+  }
+  if (n.rows = k.length, n.positions = x ? `${g} of ${x} coded spans checked against their text` : "no span text to check positions against", !n.sources) throw new G(`This project has no text sources to import${e.skipped.length ? ` (skipped: ${e.skipped.join("; ")})` : ""}.`, "no-sources");
+  return { fields: u, rows: k, report: n };
+}
+const Ye = (e) => {
+  const r = e == null ? "" : String(e);
+  return /[",\r\n]/.test(r) || r[0] === " " || r[r.length - 1] === " " ? `"${r.replace(/"/g, '""')}"` : r;
+};
+function Ze(e, r) {
+  return [e, ...r].map((n) => n.map(Ye).join(",")).join(`
+`);
+}
+function _e(e, { coder: r = "any", DOMParser: n } = {}) {
+  const { fields: t, rows: o, report: c } = Je(Ge(e, { DOMParser: n }), { coder: r });
+  return { csv: Ze(t, o), fields: t, rows: o, report: c, coders: c.coders, textColumn: "Text" };
+}
+export {
+  G as QdaError,
+  He as codersOf,
+  Ge as readProject,
+  _e as toCSV,
+  Je as toTable,
+  Ze as writeCSV
+};
+//# sourceMappingURL=refi-qda.es.js.map