@graphty/graph-io 0.3.24 → 0.3.26

package/dist/chunks/exporter-BMqk5oxW.js

@@ -0,0 +1,3465 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, R as ROLE_TAKEN_CODE, ay as RENAMED_CODE, I as ID_MERGED_CODE, i as DANGLING_REFERENCE_CODE, g as UNKNOWN_ELEMENT_CODE, o as DUPLICATE_ATTRIBUTE_CODE, n as DUPLICATE_NODE_CODE, a3 as BAD_VALUE_CODE, t as MISSING_ID_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, E as EMPTY_INPUT_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, am as throwIfAborted, b as plural, a1 as declareResolved, ar as IdCoercer, aq as DirectionResolver, $ as agree, az as LineReader, c as capabilities, L as LOSS, au as ROLE_ASSUMED_CODE, aA as NODE_ORDER_CODE, aB as GRAPH_COLUMN_AS_METADATA_CODE, aC as TYPEDEF_NODES_CODE, aD as RELATION_ASSUMED_CODE, at as COLUMN_AS_PROPERTY_VALUE_CODE, r as resolveExportOptions, p as pairFolding, e as explicitWeights, av as formatNumber } from "./export-BTI4yQgy.js";
+import { S as SYNONYM_SCOPES, O as OBO_NODE_COLUMNS, o as oboColumnDecl, P as PLACEHOLDER_COLUMN, f as framelessNodes, m as movedNodes, s as slotColumn, c as capabilityNotes, e as emptyColumnNotes, a as cellOf, F as FRAME_KINDS$1, U as UNWRITTEN_ROLES, n as notePropertyColumn, b as fitsVocabulary, i as isQualifierRecord, t as textOf } from "./ontology-export-B9Tcf37D.js";
+import { j as joinText, e as encodeChunks } from "./writer-DxjgHwSe.js";
+const ESCAPES = Object.freeze({
+  n: "\n",
+  t: "	",
+  // the guides read `\W` as a space; the 1.4 BNF (and fastobo) as the letter W (design 4.1)
+  W: " "
+});
+function unescapeObo(text) {
+  if (!text.includes("\\")) {
+    return text;
+  }
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch !== "\\") {
+      out += ch;
+      continue;
+    }
+    i++;
+    if (i < text.length) {
+      const next = text[i];
+      out += ESCAPES[next] ?? next;
+    }
+  }
+  return out;
+}
+function isEscaped(text, index) {
+  let run = 0;
+  for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) {
+    run++;
+  }
+  return run % 2 === 1;
+}
+function splitFormFeeds(line) {
+  if (!line.includes("\f")) {
+    return [line];
+  }
+  const pieces = [];
+  let quoted = false;
+  let start = 0;
+  for (let i = 0; i < line.length; i += line[i] === "\\" ? 2 : 1) {
+    const ch = line[i];
+    if (ch === '"') {
+      quoted = !quoted;
+    } else if (ch === "\f" && !quoted) {
+      pieces.push(line.slice(start, i));
+      start = i + 1;
+    }
+  }
+  pieces.push(line.slice(start));
+  return pieces;
+}
+function endsWithContinuation(line) {
+  return line.endsWith("\\") && !isEscaped(line, line.length - 1);
+}
+function splitTagValue(line) {
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (line[i] === ":") {
+      return { tag: unescapeObo(line.slice(0, i).trim()), rest: line.slice(i + 1).trimStart() };
+    }
+  }
+  return null;
+}
+function stripComment(rest) {
+  let quoted = false;
+  for (let i = 0; i < rest.length; i++) {
+    const ch = rest[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    const atStart = i === 0 || rest[i - 1] === " " || rest[i - 1] === "	";
+    if (ch === '"' && (quoted || atStart)) {
+      quoted = !quoted;
+    } else if (ch === "!" && !quoted && atStart) {
+      return rest.slice(0, i).trimEnd();
+    }
+  }
+  return rest.trimEnd();
+}
+function splitQualifiers(value) {
+  if (!value.endsWith("}")) {
+    return { value, qualifiers: null, badBlock: null };
+  }
+  const blocks = braceBlocks(value);
+  const parsed = [];
+  let end = value.length;
+  let badBlock = null;
+  while (end > 0 && value[end - 1] === "}" && !isEscaped(value, end - 1)) {
+    const open = blocks.get(end - 1) ?? -1;
+    const block = open < 0 ? null : parseQualifiers(value.slice(open + 1, end - 1));
+    if (block === null) {
+      badBlock = value.slice(Math.max(open, 0), end);
+      break;
+    }
+    parsed.push(block);
+    end = open;
+    while (end > 0 && /\s/.test(value[end - 1])) {
+      end--;
+    }
+  }
+  let qualifiers = null;
+  for (let i = parsed.length - 1; i >= 0; i--) {
+    qualifiers ??= /* @__PURE__ */ Object.create(null);
+    for (const [name, v] of Object.entries(parsed[i])) {
+      addQualifier(qualifiers, name, v);
+    }
+  }
+  return { value: value.slice(0, end), qualifiers, badBlock };
+}
+function braceBlocks(value) {
+  const blocks = /* @__PURE__ */ new Map();
+  let quoted = false;
+  let open = -1;
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      quoted = !quoted;
+    } else if (!quoted && ch === "{") {
+      open = i;
+    } else if (!quoted && ch === "}") {
+      blocks.set(i, open);
+      open = -1;
+    }
+  }
+  return blocks;
+}
+function unclosedBlock(value) {
+  let quoted = false;
+  let open = -1;
+  for (let i = 0; i < value.length; i += value[i] === "\\" ? 2 : 1) {
+    const ch = value[i];
+    if (ch === "\\") {
+      continue;
+    }
+    if (ch === '"' && open < 0) {
+      quoted = !quoted;
+    } else if (!quoted && ch === "{") {
+      open = i;
+    } else if (!quoted && ch === "}") {
+      open = -1;
+    }
+  }
+  return open;
+}
+function addQualifier(record, name, value) {
+  const values = Array.isArray(value) ? value : [value];
+  if (!Object.prototype.hasOwnProperty.call(record, name)) {
+    record[name] = Array.isArray(value) ? [...value] : value;
+    return;
+  }
+  const before = record[name];
+  if (Array.isArray(before)) {
+    for (const v of values) {
+      before.push(v);
+    }
+  } else {
+    record[name] = [before, ...values];
+  }
+}
+function parseQualifiers(inner) {
+  const out = /* @__PURE__ */ Object.create(null);
+  let i = 0;
+  const n = inner.length;
+  let any = false;
+  while (i < n) {
+    while (i < n && (inner[i] === " " || inner[i] === "	" || inner[i] === ",")) {
+      i++;
+    }
+    if (i >= n) {
+      break;
+    }
+    const eq = inner.indexOf("=", i);
+    if (eq < 0) {
+      return null;
+    }
+    const name = unescapeObo(inner.slice(i, eq).trim());
+    if (name.length === 0 || name.includes('"')) {
+      return null;
+    }
+    i = eq + 1;
+    while (i < n && (inner[i] === " " || inner[i] === "	")) {
+      i++;
+    }
+    let value;
+    if (inner[i] === '"') {
+      const end = closingQuote(inner, i + 1);
+      if (end < 0) {
+        return null;
+      }
+      value = unescapeObo(inner.slice(i + 1, end));
+      i = end + 1;
+    } else {
+      let end = i;
+      while (end < n && inner[end] !== ",") {
+        end += inner[end] === "\\" ? 2 : 1;
+      }
+      value = unescapeObo(inner.slice(i, end).trim());
+      i = end;
+    }
+    addQualifier(out, name, value);
+    any = true;
+  }
+  return any ? out : null;
+}
+function closingQuote(text, from) {
+  for (let i = from; i < text.length; i++) {
+    if (text[i] === "\\") {
+      i++;
+    } else if (text[i] === '"') {
+      return i;
+    }
+  }
+  return -1;
+}
+function tokenize(value) {
+  const tokens = [];
+  const n = value.length;
+  let i = 0;
+  while (i < n) {
+    const ch = value[i];
+    if (ch === " " || ch === "	") {
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      const end2 = closingQuote(value, i + 1);
+      const stop = end2 < 0 ? n : end2;
+      let after = stop + 1;
+      if (end2 >= 0 && value[after] === "@") {
+        while (after < n && value[after] !== " " && value[after] !== "	") {
+          after++;
+        }
+      }
+      const suffix = end2 < 0 ? "" : value.slice(stop + 1, after);
+      tokens.push({
+        kind: "quoted",
+        text: unescapeObo(value.slice(i + 1, stop)) + suffix,
+        unterminated: end2 < 0
+      });
+      i = after;
+      continue;
+    }
+    if (ch === "[") {
+      const end2 = closingBracket(value, i + 1);
+      const stop = end2 < 0 ? n : end2;
+      tokens.push({ kind: "list", text: value.slice(i + 1, stop), unterminated: end2 < 0 });
+      i = stop + 1;
+      continue;
+    }
+    let end = i;
+    while (end < n && value[end] !== " " && value[end] !== "	") {
+      end += value[end] === "\\" ? 2 : 1;
+    }
+    tokens.push({ kind: "word", text: unescapeObo(value.slice(i, Math.min(end, n))), unterminated: false });
+    i = end;
+  }
+  return tokens;
+}
+function closingBracket(text, from) {
+  let quoted = false;
+  for (let i = from; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i++;
+    } else if (ch === '"') {
+      quoted = !quoted;
+    } else if (ch === "]" && !quoted) {
+      return i;
+    }
+  }
+  return -1;
+}
+function parseXref(raw) {
+  const { value, qualifiers } = splitQualifiers(raw.trim());
+  let quote = -1;
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] === "\\") {
+      i++;
+    } else if (value[i] === '"') {
+      quote = i;
+      break;
+    }
+  }
+  const id = unescapeObo((quote < 0 ? value : value.slice(0, quote)).trim());
+  if (id.length === 0) {
+    return null;
+  }
+  let description = null;
+  let unterminated = false;
+  if (quote >= 0) {
+    const end = closingQuote(value, quote + 1);
+    unterminated = end < 0;
+    description = unescapeObo(value.slice(quote + 1, end < 0 ? value.length : end));
+  }
+  return { id, description, qualifiers, unterminated };
+}
+function parseXrefList(inner) {
+  const out = [];
+  let quoted = false;
+  let depth = 0;
+  let start = 0;
+  const flush = (end) => {
+    const xref = parseXref(inner.slice(start, end));
+    if (xref !== null) {
+      out.push(xref);
+    }
+  };
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch === "\\") {
+      i++;
+    } else if (ch === '"') {
+      quoted = !quoted;
+    } else if (!quoted && ch === "{") {
+      depth++;
+    } else if (!quoted && ch === "}") {
+      depth = Math.max(0, depth - 1);
+    } else if (!quoted && depth === 0 && ch === ",") {
+      flush(i);
+      start = i + 1;
+    }
+  }
+  flush(inner.length);
+  return out;
+}
+function hasStrayBrace(value) {
+  let quoted = false;
+  let listed = false;
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch === "\\") {
+      i++;
+    } else if (ch === '"') {
+      quoted = !quoted;
+    } else if (!quoted && (ch === "[" || ch === "]")) {
+      listed = ch === "[";
+    } else if (!quoted && !listed && (ch === "{" || ch === "}")) {
+      return true;
+    }
+  }
+  return false;
+}
+const LINE_ENDS = /\r\n|\r|\f/g;
+function hasLineEnd(text) {
+  return text.includes("\r") || text.includes("\f");
+}
+function escapeOboQuoted(text) {
+  return text.replaceAll(LINE_ENDS, "\n").replaceAll(/[\\"\n\t]/g, (ch) => {
+    switch (ch) {
+      case "\n":
+        return String.raw`\n`;
+      case "	":
+        return String.raw`\t`;
+      default:
+        return `\\${ch}`;
+    }
+  });
+}
+function escapeOboValue(text) {
+  return escapeOboQuoted(text).replaceAll(/[!{}[\],]/g, (ch) => `\\${ch}`);
+}
+function isOboWord(text) {
+  return text.length > 0 && !NOT_IN_WORD.test(text);
+}
+const NOT_IN_WORD = /[\s!{}\p{Cc}]/u;
+function escapeOboWord(word) {
+  const out = word.replaceAll(/[\\"]/g, (ch) => `\\${ch}`);
+  return out.startsWith("[") ? `\\${out}` : out;
+}
+function isQualifierName(name) {
+  return name.length > 0 && name === name.trim() && !/[=",{}[\]!\\\n\r\t\f]/.test(name);
+}
+function qualifierBlock(pairs) {
+  if (pairs.length === 0) {
+    return "";
+  }
+  const items = pairs.map(([name, value]) => `${name}="${escapeOboQuoted(value)}"`);
+  return ` {${items.join(", ")}}`;
+}
+const OBO_ISSUE = Object.freeze({
+  ...INPUT_ISSUE,
+  ...ELEMENT_ISSUE,
+  /** The input is empty or whitespace. The import stops. */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** The input is not valid UTF-8. The import stops. */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /**
+   * Some bytes are not valid in the encoding that was chosen (by a byte order mark or the `encoding` option). The
+   * import stops.
+   */
+  INVALID_ENCODING: INVALID_ENCODING_CODE,
+  /** Bytes that are not UTF-8 were read as windows-1252. */
+  ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
+  /** A declared encoding the platform cannot decode was ignored. */
+  UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
+  /** A frame without an `id` clause; the frame is skipped. */
+  MISSING_ID: MISSING_ID_CODE,
+  /** A clause whose value cannot be read (a boolean other than true / false, a relationship with one or three values); the clause is skipped. */
+  BAD_VALUE: BAD_VALUE_CODE,
+  /** Two frames have the same id, so they were merged into one node. */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** A tag that may appear once per frame appears twice; the first value is kept. */
+  DUPLICATE_ATTRIBUTE: DUPLICATE_ATTRIBUTE_CODE,
+  /** An unknown tag (kept in `obo.unrecognized`) or frame type (skipped), once per name. */
+  UNKNOWN_ELEMENT: UNKNOWN_ELEMENT_CODE,
+  /** A target no frame declares: a placeholder node was made, or the edge dropped under addMissingNodes false. */
+  DANGLING_REFERENCE: DANGLING_REFERENCE_CODE,
+  /** A line without a colon, an unterminated quote, a def without its xref list, a qualifier block that does not parse, an unescaped brace. */
+  SYNTAX: "W_OBO_SYNTAX",
+  /**
+   * Nothing in the input looks like OBO: there is no frame header and no header tag. It may be an HTML page, a JSON
+   * or GML file, or UTF-16 text without a byte order mark. The import stops.
+   */
+  NOT_OBO: "E_OBO_NOT_OBO",
+  /**
+   * The header has no `format-version` (OBO 1.2 and 1.4 require one), or names a version other than 1.0, 1.2 or 1.4.
+   * The file is read accepting the tags of every version.
+   */
+  FORMAT_VERSION: "W_OBO_FORMAT_VERSION",
+  /** The frame's `id` is not its first clause; it is used anyway. */
+  ID_NOT_FIRST: "W_OBO_ID_NOT_FIRST",
+  /** A synonym without a scope in a file that does not say 1.2, or with a scope that is not one of the four. */
+  SYNONYM_SCOPE: "W_OBO_SYNONYM_SCOPE",
+  /** A relation, subset or synonym type that nothing declares. */
+  UNDECLARED: "W_OBO_UNDECLARED",
+  /** One id for a Term and a Typedef (or an Instance); the Term (the first node frame) is the node. */
+  ID_KIND_CLASH: "W_OBO_ID_KIND_CLASH",
+  /** A frame has only one `intersection_of` or `union_of` clause, where OBO needs at least two. */
+  CARDINALITY: "W_OBO_CARDINALITY",
+  /** An obsolete term with is_a / relationship, or replaced_by / consider on a term that is not obsolete. */
+  OBSOLETION: "W_OBO_OBSOLETION",
+  /** An OBO 1.0 / 1.2 tag read as its 1.4 meaning (exact_synonym, xref_analog, use_term, typeref, version). */
+  DEPRECATED_TAG: "W_OBO_DEPRECATED_TAG",
+  /** A backslash line continuation (deprecated in 1.4). */
+  DEPRECATED_SYNTAX: "W_OBO_DEPRECATED_SYNTAX",
+  /**
+   * A header clause whose meaning graph-io does not apply (`import`, `id-mapping`, the `treat-xrefs` macros,
+   * `owl-axioms`); it is kept in `snapshot.meta.extra.obo.header`.
+   */
+  HEADER_NOT_APPLIED: "W_OBO_HEADER_NOT_APPLIED",
+  /** Obsolete terms and their edges left out under obsolete: "drop". */
+  OBSOLETE_DROPPED: "W_OBO_OBSOLETE_DROPPED",
+  /**
+   * Two different id texts became the same number because `ids` is "number" (for example, "042" and "42"), so their nodes
+   * were merged.
+   */
+  ID_MERGED: ID_MERGED_CODE,
+  /** An OBO attribute was renamed `<name>#obo` because another attribute already has its name. */
+  COLUMN_RENAMED: RENAMED_CODE,
+  /**
+   * You read into a graph builder that already has an id, label or position attribute, so this file's one is kept as
+   * a plain attribute.
+   */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** You set an option this format does not use; it had no effect. The message names the option. */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /**
+   * You read into your own graph builder, which was created with a different `addMissingNodes`, `duplicateEdges`,
+   * `selfLoops` or `weightDtype` than the option you passed; the builder's setting applies.
+   */
+  SINK_OPTION: SINK_OPTION_CODE
+});
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "weightDtype",
+  "errorLimit",
+  "signal",
+  "onProgress",
+  "encoding",
+  "restoreMangledIds"
+]);
+const ORIGINAL_ID$1 = "graphty:originalId";
+const DEFAULTS = { ids: "keep", defaultDirected: true, weightFrom: null };
+const ABORT_CHECK_INTERVAL = 64;
+const SNIFF_BYTES = 4096;
+const FRAME_KINDS = /* @__PURE__ */ new Set(["Term", "Typedef", "Instance"]);
+const NOT_APPLIED_HEADER = /^(import|typeref|id-mapping|default-relationship-id-prefix|owl-axioms|treat-xrefs-as-.*)$/;
+const DEPRECATED_HEADER = /* @__PURE__ */ new Map([
+  ["typeref", "import"],
+  ["version", "data-version"]
+]);
+const DEPRECATED_TAGS = /* @__PURE__ */ new Map([
+  ["exact_synonym", ["synonym", "EXACT"]],
+  ["narrow_synonym", ["synonym", "NARROW"]],
+  ["broad_synonym", ["synonym", "BROAD"]],
+  ["related_synonym", ["synonym", "RELATED"]],
+  ["xref_analog", ["xref", null]],
+  ["xref_unk", ["xref", null]],
+  ["xref_unknown", ["xref", null]],
+  ["use_term", ["consider", null]]
+]);
+const BUILTIN_RELATIONS$1 = /* @__PURE__ */ new Set([
+  "is_a",
+  "instance_of",
+  "disjoint_from",
+  "inverse_of",
+  "union_of",
+  "intersection_of"
+]);
+const TEXT_TAGS = /* @__PURE__ */ new Set([
+  "name",
+  "namespace",
+  "comment",
+  "created_by",
+  "creation_date",
+  "domain",
+  "range",
+  "inverse_of"
+]);
+const BOOL_TAGS = new Set(
+  Object.keys(OBO_NODE_COLUMNS).filter((name) => OBO_NODE_COLUMNS[name].dtype === "bool")
+);
+const ID_LIST_TAGS = /* @__PURE__ */ new Set([
+  "alt_id",
+  "subset",
+  "replaced_by",
+  "consider",
+  "union_of",
+  "equivalent_to",
+  "disjoint_from",
+  "transitive_over",
+  "disjoint_over"
+]);
+const SINGLE_HEADER_TAGS = /* @__PURE__ */ new Set([
+  "format-version",
+  "data-version",
+  "version",
+  "date",
+  "saved-by",
+  "auto-generated-by",
+  "default-namespace",
+  "ontology",
+  "default-relationship-id-prefix"
+]);
+const KNOWN_VERSION = /^(GO_)?1\.[024]$/;
+const ID_VALUE_TAGS = /* @__PURE__ */ new Set([
+  ...ID_LIST_TAGS,
+  "is_a",
+  "instance_of",
+  "relationship",
+  "intersection_of"
+]);
+const MAX_TALLIES_PER_CODE = 100;
+function hasControl(text) {
+  for (const ch of text) {
+    if (ch < " " && ch !== "	" && ch !== "\n" && ch !== "\f" && ch !== "\r" || ch === "") {
+      return true;
+    }
+  }
+  return false;
+}
+function isTagName(tag) {
+  return tag.length > 0 && !hasControl(tag) && !/[\s{}"<>[\]()]/.test(tag);
+}
+function ownRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function append(map, key, value) {
+  if (Object.hasOwn(map, key)) {
+    map[key].push(value);
+  } else {
+    map[key] = [value];
+  }
+}
+const TYPEDEF_TAGS = /* @__PURE__ */ new Set([
+  "domain",
+  "range",
+  "inverse_of",
+  "transitive_over",
+  "disjoint_over",
+  "holds_over_chain",
+  "equivalent_to_chain",
+  "expand_assertion_to",
+  "expand_expression_to",
+  "is_cyclic",
+  "is_reflexive",
+  "is_symmetric",
+  "is_anti_symmetric",
+  "is_asymmetric",
+  "is_transitive",
+  "is_functional",
+  "is_inverse_functional",
+  "is_metadata_tag",
+  "is_class_level"
+]);
+function resolveOboOptions$1(options) {
+  const obsolete = options?.obsolete ?? "keep";
+  const typedefs = options?.typedefs ?? "metadata";
+  if (obsolete !== "keep" && obsolete !== "drop") {
+    throw unsupported("obsolete", obsolete, ["keep", "drop"]);
+  }
+  if (typedefs !== "metadata" && typedefs !== "nodes") {
+    throw unsupported("typedefs", typedefs, ["metadata", "nodes"]);
+  }
+  return { obsolete, typedefs };
+}
+function unsupported(option, found, supported) {
+  return new GraphFormatError(
+    "E_UNSUPPORTED",
+    `option ${option}: ${JSON.stringify(found)} is not one of ${supported.join(", ")}`,
+    {
+      option,
+      found,
+      supported
+    }
+  );
+}
+class OboReader {
+  /**
+   * Create a reader.
+   * @param report - the report
+   * @param signal - the cancellation signal
+   * @param typedefsAsNodes - whether `[Typedef]` frames are nodes
+   */
+  constructor(report, signal, typedefsAsNodes) {
+    this.header = ownRecord();
+    this.frameSeen = false;
+    this.tagClauses = 0;
+    this.firstBadLine = null;
+    this.version = null;
+    this.defaultNamespace = null;
+    this.subsets = /* @__PURE__ */ new Set();
+    this.synonymTypes = /* @__PURE__ */ new Map();
+    this.nodes = /* @__PURE__ */ new Map();
+    this.typedefs = /* @__PURE__ */ new Map();
+    this.tallies = /* @__PURE__ */ new Map();
+    this.frame = null;
+    this.unknownFrames = [];
+    this.framesSinceCheck = 0;
+    this.significant = false;
+    this.report = report;
+    this.signal = signal;
+    this.typedefsAsNodes = typedefsAsNodes;
+  }
+  /**
+   * Read one logical line.
+   * @param text - the line, continuation joined
+   * @param line - its 1-based number
+   */
+  line(text, line) {
+    const t = text.trim();
+    if (t.length === 0) {
+      return;
+    }
+    this.significant = true;
+    if (t.startsWith("!")) {
+      return;
+    }
+    if (t.startsWith("[") && this.frameHeader(t, line)) {
+      return;
+    }
+    const tv = splitTagValue(stripComment(t));
+    if (tv === null || tv.tag.length === 0) {
+      this.firstBadLine ??= line;
+      const what = tv === null ? "a line without a colon was skipped" : "a line without a tag was skipped";
+      this.tally("parse-error", OBO_ISSUE.SYNTAX, what, "line", line);
+      return;
+    }
+    const clause = { tag: tv.tag, value: stripComment(tv.rest), line };
+    if (this.frame === null) {
+      if (isTagName(tv.tag)) {
+        this.tagClauses++;
+      } else {
+        this.firstBadLine ??= line;
+      }
+      this.headerClause(clause);
+    } else {
+      this.frame.clauses.push(clause);
+    }
+  }
+  /**
+   * Start a frame at a line opening with `[`: a well-formed header, or one damaged so that only a
+   * frame header can be meant (a known frame name, or no colon: `[Term`, `[Term] extra`), with a
+   * warning, so the clauses after it never merge into the frame before.
+   * @param t - the trimmed line
+   * @param line - its number
+   * @returns false when the line is not a frame header
+   */
+  frameHeader(t, line) {
+    const close = t.indexOf("]");
+    const name = (close < 0 ? t.slice(1) : t.slice(1, close)).trim();
+    const after = close < 0 ? "" : t.slice(close + 1).trim();
+    const clean = close >= 0 && (after.length === 0 || after.startsWith("!"));
+    if (!clean && !FRAME_KINDS.has(name) && t.includes(":")) {
+      return false;
+    }
+    if (!clean) {
+      const what = close < 0 ? "a frame header without its closing ] starts the frame" : "text after a frame header was ignored";
+      this.tally("parse-error", OBO_ISSUE.SYNTAX, what, `[${name}]`, line);
+    }
+    const proof = FRAME_KINDS.has(name) || clean && /^[A-Za-z]/.test(name) && isTagName(name);
+    if (!proof) {
+      this.firstBadLine ??= line;
+    }
+    this.startFrame(name, line, proof);
+    return true;
+  }
+  /**
+   * Start a frame, finishing the one before.
+   * @param name - the frame type
+   * @param line - the header's line
+   * @param proof - whether the header shows the input is OBO
+   */
+  startFrame(name, line, proof) {
+    this.finishFrame();
+    this.frameSeen ||= proof;
+    const kind = FRAME_KINDS.has(name) ? name : null;
+    if (kind === null) {
+      this.tally(
+        "validation-error",
+        OBO_ISSUE.UNKNOWN_ELEMENT,
+        "frames of an unknown type are not nodes; kept in meta.extra.obo.unknownFrames",
+        `[${name}]`,
+        line
+      );
+    }
+    this.frame = { kind, name, line, clauses: [] };
+  }
+  /**
+   * Record one header clause.
+   * @param clause - the clause
+   */
+  headerClause(clause) {
+    append(this.header, clause.tag, clause.value);
+    const { tag } = clause;
+    if (SINGLE_HEADER_TAGS.has(tag) && this.header[tag].length > 1) {
+      this.tally(
+        "validation-error",
+        OBO_ISSUE.DUPLICATE_ATTRIBUTE,
+        "a single-valued header tag given twice; the first is kept",
+        tag,
+        clause.line
+      );
+    }
+    const tokens = tokenize(splitQualifiers(clause.value).value);
+    const first = tokens.length > 0 && tokens[0].kind === "word" ? tokens[0].text : null;
+    if (tag === "format-version") {
+      this.version ??= unescapeObo(clause.value).trim();
+    } else if (tag === "default-namespace") {
+      this.defaultNamespace ??= first;
+    } else if ((tag === "subsetdef" || tag === "synonymtypedef") && first === null) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "a declaration whose name is not a word declares nothing",
+        tag,
+        clause.line
+      );
+    } else if (tag === "subsetdef" && first !== null) {
+      this.subsets.add(first);
+    } else if (tag === "synonymtypedef" && first !== null) {
+      const scope = tokens.slice(1).find((t) => t.kind === "word" && SYNONYM_SCOPES.has(t.text));
+      this.synonymTypes.set(first, scope?.text ?? null);
+    }
+    const now = DEPRECATED_HEADER.get(tag);
+    if (now !== void 0) {
+      this.tally("coercion", OBO_ISSUE.DEPRECATED_TAG, `the 1.0 header tag is read as ${now}`, tag, clause.line);
+    }
+    if (NOT_APPLIED_HEADER.test(tag)) {
+      this.tally(
+        "unsupported",
+        OBO_ISSUE.HEADER_NOT_APPLIED,
+        "kept in meta.extra.obo.header, not applied",
+        tag,
+        clause.line
+      );
+    }
+  }
+  /** Finish the frame being read: find its id and merge its clauses into the record of that id. */
+  finishFrame() {
+    const { frame } = this;
+    this.frame = null;
+    if (frame === null) {
+      return;
+    }
+    if (frame.kind === null) {
+      const clauses = ownRecord();
+      for (const clause of frame.clauses) {
+        append(clauses, clause.tag, clause.value);
+      }
+      this.unknownFrames.push({ type: frame.name, clauses });
+      return;
+    }
+    if (++this.framesSinceCheck >= ABORT_CHECK_INTERVAL) {
+      this.framesSinceCheck = 0;
+      throwIfAborted(this.signal);
+    }
+    const idAt = frame.clauses.findIndex((c) => c.tag === "id");
+    const idParts = idAt < 0 ? null : splitQualifiers(frame.clauses[idAt].value);
+    const rawId = idParts === null ? "" : idParts.value.trim();
+    const id = unescapeObo(rawId).trim();
+    const wouldBeNode = frame.kind !== "Typedef" || this.typedefsAsNodes;
+    if (id.length === 0) {
+      this.report.error(
+        "missing-value",
+        OBO_ISSUE.MISSING_ID,
+        `a [${frame.kind}] frame has no id; it is skipped`,
+        {
+          line: frame.line
+        }
+      );
+      if (wouldBeNode) {
+        this.report.counts.skippedNodes++;
+      }
+      return;
+    }
+    if (tokenize(rawId).length > 1 || hasControl(id)) {
+      this.report.error(
+        "validation-error",
+        OBO_ISSUE.BAD_VALUE,
+        `a [${frame.kind}] frame's id ${JSON.stringify(id)} holds unescaped whitespace or a control character; the frame is skipped`,
+        { line: frame.clauses[idAt].line, element: id }
+      );
+      if (wouldBeNode) {
+        this.report.counts.skippedNodes++;
+      }
+      return;
+    }
+    if (idAt > 0) {
+      this.tally(
+        "validation-error",
+        OBO_ISSUE.ID_NOT_FIRST,
+        "the id clause is not the frame's first; it is used",
+        "id",
+        frame.clauses[idAt].line
+      );
+    }
+    const target = this.recordFor(frame.kind, id, frame.line);
+    this.extraQualifiers(target, "id", id, idParts?.qualifiers ?? null);
+    for (let i = 0; i < frame.clauses.length; i++) {
+      const clause = frame.clauses[i];
+      if (clause.tag === "id") {
+        if (i !== idAt) {
+          this.tally(
+            "validation-error",
+            OBO_ISSUE.DUPLICATE_ATTRIBUTE,
+            "a frame names a second id; the first is kept",
+            "id",
+            clause.line
+          );
+        }
+        continue;
+      }
+      this.applyClause(target, clause);
+    }
+    if (target.kind === "Typedef" && !Object.hasOwn(target.raw, "id")) {
+      target.raw.id = [id];
+    }
+  }
+  /**
+   * The record a frame merges into: the existing one of its id, or a new one.
+   * @param kind - the frame type
+   * @param id - the id
+   * @param line - the frame's line
+   * @returns the record
+   */
+  recordFor(kind, id, line) {
+    const map = kind === "Typedef" ? this.typedefs : this.nodes;
+    const existing = map.get(id);
+    if (existing !== void 0) {
+      if (existing.kind !== kind) {
+        this.tally(
+          "validation-error",
+          OBO_ISSUE.ID_KIND_CLASH,
+          `an id names both a ${existing.kind} and an ${kind}; the ${existing.kind} is the node`,
+          id,
+          line
+        );
+      } else {
+        this.tally(
+          "merged",
+          OBO_ISSUE.DUPLICATE_NODE,
+          `[${kind}] frames with this id are merged (spec 4.1.1)`,
+          id,
+          line
+        );
+      }
+      return existing;
+    }
+    const created = {
+      id,
+      kind,
+      line,
+      values: /* @__PURE__ */ new Map(),
+      lists: /* @__PURE__ */ new Map(),
+      edges: [],
+      seen: /* @__PURE__ */ new Set(),
+      raw: ownRecord()
+    };
+    map.set(id, created);
+    return created;
+  }
+  /**
+   * A clause's tag (a 1.0 tag read as its current one), the synonym scope that tag implies, its
+   * qualifier block and its value, with the syntax warnings about stray braces recorded.
+   * @param clause - the clause
+   * @returns the parts
+   */
+  clauseParts(clause) {
+    let { tag } = clause;
+    let scope = null;
+    const deprecated = DEPRECATED_TAGS.get(tag);
+    if (deprecated !== void 0) {
+      this.tally(
+        "coercion",
+        OBO_ISSUE.DEPRECATED_TAG,
+        `the 1.0 tag is read as ${deprecated[0]}`,
+        tag,
+        clause.line
+      );
+      [tag, scope] = deprecated;
+    }
+    let split = splitQualifiers(clause.value);
+    const open = ID_VALUE_TAGS.has(tag) ? unclosedBlock(split.value) : -1;
+    if (open >= 0) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "a qualifier block without its closing brace was dropped",
+        tag,
+        clause.line
+      );
+      split = splitQualifiers(split.value.slice(0, open).trimEnd());
+    }
+    const { qualifiers } = split;
+    if (split.badBlock !== null) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "a closing brace that is not a qualifier block was kept as text",
+        tag,
+        clause.line
+      );
+    } else if (hasStrayBrace(split.value)) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "an unescaped brace inside a value was kept as text",
+        tag,
+        clause.line
+      );
+    }
+    return { tag, scope, qualifiers, value: split.value };
+  }
+  /**
+   * A def, expand_assertion_to or expand_expression_to clause: quoted text and its xref list.
+   * @param record - the record
+   * @param tag - the tag
+   * @param value - the clause value
+   * @param tokens - its tokens
+   * @param qualifiers - its qualifier block
+   * @param line - its line
+   */
+  definition(record, tag, value, tokens, qualifiers, line) {
+    if (tag === "def" && record.values.has("def")) {
+      this.single(record, "def", null, line);
+      return;
+    }
+    const text = this.quotedWithXrefs(record, tag, value, tokens, line);
+    if (tag === "def") {
+      this.single(record, "def", text.text, line, () => {
+        record.values.set("def.xrefs", text.xrefs);
+      });
+      this.extraQualifiers(record, tag, text.text, qualifiers);
+    } else {
+      this.push(record, tag, withQualifiers({ template: text.text, xrefs: text.xrefs }, qualifiers));
+    }
+  }
+  /**
+   * Apply one clause to a record.
+   * @param record - the record
+   * @param clause - the clause
+   */
+  applyClause(record, clause) {
+    const key = `${clause.tag}\0${clause.value}`;
+    if (record.seen.has(key)) {
+      return;
+    }
+    record.seen.add(key);
+    if (record.kind === "Typedef") {
+      append(record.raw, clause.tag, clause.value);
+    }
+    const { tag, scope, qualifiers, value } = this.clauseParts(clause);
+    const where = { line: clause.line, element: record.id };
+    if (TYPEDEF_TAGS.has(tag) && record.kind !== "Typedef") {
+      this.unrecognized(record, clause);
+      return;
+    }
+    if (TEXT_TAGS.has(tag)) {
+      this.text(record, tag, value, qualifiers, clause.line);
+      return;
+    }
+    if (BOOL_TAGS.has(tag)) {
+      const text = unescapeObo(value).trim();
+      if (text !== "true" && text !== "false") {
+        this.report.error(
+          "validation-error",
+          OBO_ISSUE.BAD_VALUE,
+          `${tag}: ${JSON.stringify(text)} is not true or false; the clause is skipped`,
+          where
+        );
+        return;
+      }
+      this.single(record, tag, text === "true", clause.line);
+      this.extraQualifiers(record, tag, text, qualifiers);
+      return;
+    }
+    const tokens = tokenize(value);
+    if (ID_LIST_TAGS.has(tag)) {
+      const id = this.oneWord(tokens, tag, where);
+      if (id !== null) {
+        this.push(record, tag, id);
+        this.extraQualifiers(record, tag, id, qualifiers);
+        if (tag === "subset" && !this.subsets.has(id)) {
+          this.tally(
+            "validation-error",
+            OBO_ISSUE.UNDECLARED,
+            "a subset no subsetdef declares",
+            id,
+            clause.line
+          );
+        }
+      }
+      return;
+    }
+    switch (tag) {
+      case "is_a":
+      case "instance_of": {
+        if (tag === "instance_of" && record.kind !== "Instance") {
+          this.unrecognized(record, clause);
+          return;
+        }
+        const target = this.oneWord(tokens, tag, where);
+        if (target !== null) {
+          record.edges.push({ relation: tag, target, qualifiers, line: clause.line });
+        }
+        return;
+      }
+      case "relationship": {
+        if (tokens.length !== 2 || tokens.some((t) => t.kind !== "word")) {
+          this.report.error(
+            "validation-error",
+            OBO_ISSUE.BAD_VALUE,
+            `relationship needs a relation and a target, found ${JSON.stringify(unescapeObo(value))}; the clause is skipped`,
+            where
+          );
+          return;
+        }
+        record.edges.push({ relation: tokens[0].text, target: tokens[1].text, qualifiers, line: clause.line });
+        return;
+      }
+      case "intersection_of": {
+        if (tokens.length < 1 || tokens.length > 2 || tokens.some((t) => t.kind !== "word")) {
+          this.report.error(
+            "validation-error",
+            OBO_ISSUE.BAD_VALUE,
+            `intersection_of needs a class, or a relation and a class, found ${JSON.stringify(unescapeObo(value))}; the clause is skipped`,
+            where
+          );
+          return;
+        }
+        const item = tokens.length === 1 ? { relation: null, target: tokens[0].text } : { relation: tokens[0].text, target: tokens[1].text };
+        this.push(record, tag, withQualifiers(item, qualifiers));
+        return;
+      }
+      case "holds_over_chain":
+      case "equivalent_to_chain": {
+        if (tokens.length !== 2 || tokens.some((t) => t.kind !== "word")) {
+          this.report.error(
+            "validation-error",
+            OBO_ISSUE.BAD_VALUE,
+            `${tag} needs two relations; the clause is skipped`,
+            where
+          );
+          return;
+        }
+        this.push(record, tag, [tokens[0].text, tokens[1].text]);
+        this.extraQualifiers(record, tag, `${tokens[0].text} ${tokens[1].text}`, qualifiers);
+        return;
+      }
+      case "def":
+      case "expand_assertion_to":
+      case "expand_expression_to":
+        this.definition(record, tag, value, tokens, qualifiers, clause.line);
+        return;
+      case "synonym":
+        this.synonym(record, tokens, scope, qualifiers, clause.line);
+        return;
+      case "xref": {
+        const xref = parseXref(value);
+        if (xref === null) {
+          this.report.error(
+            "validation-error",
+            OBO_ISSUE.BAD_VALUE,
+            "xref has no id; the clause is skipped",
+            where
+          );
+          return;
+        }
+        this.push(record, "xref", xref.id);
+        this.describe(record, [xref], tag, clause.line);
+        this.extraQualifiers(record, tag, xref.id, qualifiers ?? xref.qualifiers);
+        return;
+      }
+      case "property_value":
+        this.propertyValue(record, tokens, qualifiers, where);
+        return;
+      default:
+        this.unrecognized(record, clause);
+    }
+  }
+  /**
+   * A single-valued text clause (name, comment, ...), warning about a quote that never closes
+   * (stripComment() then keeps a `!` comment after it as text).
+   * @param record - the record
+   * @param tag - the tag
+   * @param value - the raw value
+   * @param qualifiers - its qualifier block
+   * @param line - its line
+   */
+  text(record, tag, value, qualifiers, line) {
+    if (tokenize(value).some((t) => t.kind === "quoted" && t.unterminated)) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "an unterminated quote; the text after it, a comment included, is kept",
+        tag,
+        line
+      );
+    }
+    const text = unescapeObo(value).trim();
+    this.single(record, tag, text, line);
+    this.extraQualifiers(record, tag, text, qualifiers);
+  }
+  /**
+   * Read a value that must be one word.
+   * @param tokens - the value's tokens
+   * @param tag - the tag, for the message
+   * @param where - the location
+   * @returns the word, or null after reporting E_BAD_VALUE
+   */
+  oneWord(tokens, tag, where) {
+    if (tokens.length === 1 && tokens[0].kind === "word") {
+      return tokens[0].text;
+    }
+    const found = tokens.map((t) => t.text).join(" ");
+    this.report.error(
+      "validation-error",
+      OBO_ISSUE.BAD_VALUE,
+      `${tag} needs one id, found ${JSON.stringify(found)}; the clause is skipped`,
+      where
+    );
+    return null;
+  }
+  /**
+   * Read `"text" [xrefs]` (def, expand_*), reporting the forms the grammar does not allow.
+   * @param record - the record (xref descriptions go to its `xref.descriptions`)
+   * @param tag - the tag
+   * @param value - the raw value
+   * @param tokens - its tokens
+   * @param line - the line
+   * @returns the text and the xref ids
+   */
+  quotedWithXrefs(record, tag, value, tokens, line) {
+    if (tokens.length === 0 || tokens[0].kind !== "quoted") {
+      this.tally("parse-error", OBO_ISSUE.SYNTAX, "the text is not quoted; the whole value is kept", tag, line);
+      return { text: unescapeObo(value).trim(), xrefs: [] };
+    }
+    if (tokens[0].unterminated) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "an unterminated quote; the text runs to the end of the line",
+        tag,
+        line
+      );
+      return { text: tokens[0].text, xrefs: [] };
+    }
+    const list = tokens[1];
+    if (list?.kind !== "list") {
+      this.tally("parse-error", OBO_ISSUE.SYNTAX, "the xref list is missing", tag, line);
+      return { text: tokens[0].text, xrefs: [] };
+    }
+    if (list.unterminated) {
+      this.tally("parse-error", OBO_ISSUE.SYNTAX, "an xref list without its closing ]; kept as read", tag, line);
+    }
+    if (tokens.length > 2) {
+      this.tally("parse-error", OBO_ISSUE.SYNTAX, "text after the xref list was ignored", tag, line);
+    }
+    const xrefs = parseXrefList(list.text);
+    this.describe(record, xrefs, tag, line);
+    this.xrefQualifiers(record, tag, xrefs);
+    return { text: tokens[0].text, xrefs: xrefs.map((x) => x.id) };
+  }
+  /**
+   * Read a synonym: `"text" SCOPE? TYPE? [xrefs]` (the scope optional in 1.2).
+   * @param record - the record
+   * @param tokens - the value's tokens
+   * @param fixedScope - the scope of a 1.0 tag (exact_synonym), or null
+   * @param qualifiers - the clause's qualifiers
+   * @param line - the line
+   */
+  synonym(record, tokens, fixedScope, qualifiers, line) {
+    if (tokens.length === 0 || tokens[0].kind !== "quoted") {
+      this.report.error(
+        "validation-error",
+        OBO_ISSUE.BAD_VALUE,
+        "a synonym needs its quoted text; the clause is skipped",
+        {
+          line,
+          element: record.id
+        }
+      );
+      return;
+    }
+    if (tokens[0].unterminated) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "an unterminated quote; the text runs to the end of the line",
+        "synonym",
+        line
+      );
+    }
+    const words = tokens.slice(1).filter((t) => t.kind === "word").map((t) => t.text);
+    const list = tokens.slice(1).find((t) => t.kind === "list");
+    let scope = fixedScope;
+    let type = null;
+    if (fixedScope === null) {
+      if (words.length > 0 && SYNONYM_SCOPES.has(words[0])) {
+        [scope] = words;
+        type = words[1] ?? null;
+      } else if (words.length > 0 && this.synonymTypes.has(words[0])) {
+        [type] = words;
+        scope = "RELATED";
+      } else if (words.length > 0) {
+        [type] = words;
+        this.tally(
+          "validation-error",
+          OBO_ISSUE.SYNONYM_SCOPE,
+          `a scope that is not EXACT, BROAD, NARROW or RELATED was kept as the type, scope null`,
+          words[0],
+          line
+        );
+      } else {
+        scope = "RELATED";
+      }
+      if (scope === "RELATED" && (words.length === 0 || words[0] === type) && !this.allowsMissingScope()) {
+        this.tally(
+          "validation-error",
+          OBO_ISSUE.SYNONYM_SCOPE,
+          "a synonym without a scope (1.2 only) is read as RELATED",
+          "synonym",
+          line
+        );
+      }
+    }
+    if (type !== null) {
+      const declared = this.synonymTypes.get(type);
+      if (declared === void 0) {
+        if (scope !== null) {
+          this.tally(
+            "validation-error",
+            OBO_ISSUE.UNDECLARED,
+            "a synonym type no synonymtypedef declares",
+            type,
+            line
+          );
+        }
+      } else if (declared !== null) {
+        scope = declared;
+      }
+    }
+    if (words.length > 2 || list === void 0) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        list === void 0 ? "a synonym without its xref list" : "extra words after the synonym type",
+        "synonym",
+        line
+      );
+    }
+    const listAt = list === void 0 ? -1 : tokens.indexOf(list);
+    const stray = tokens.some(
+      (t, k) => k > 0 && (t.kind === "quoted" || t.kind === "list" && k !== listAt || listAt >= 0 && k > listAt)
+    );
+    if (stray) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "a second quoted string, a second xref list or text after the list was ignored",
+        "synonym",
+        line
+      );
+    }
+    if (list?.unterminated === true) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "an xref list without its closing ]; kept as read",
+        "synonym",
+        line
+      );
+    }
+    const xrefs = list === void 0 ? [] : parseXrefList(list.text);
+    this.describe(record, xrefs, "synonym", line);
+    this.xrefQualifiers(record, "synonym", xrefs);
+    this.push(
+      record,
+      "synonym",
+      withQualifiers({ text: tokens[0].text, scope, type, xrefs: xrefs.map((x) => x.id) }, qualifiers)
+    );
+  }
+  /**
+   * Whether the file's version lets a synonym omit its scope (1.0 and 1.2).
+   * @returns true for a 1.2 or 1.0 file
+   */
+  allowsMissingScope() {
+    return this.version !== null && /^(1\.[0-2]|GO_1\.[0-2])\b/.test(this.version);
+  }
+  /**
+   * Read a property_value: `relation "literal" datatype` or `relation id`.
+   * @param record - the record
+   * @param tokens - the value's tokens
+   * @param qualifiers - the clause's qualifiers
+   * @param where - the location
+   */
+  propertyValue(record, tokens, qualifiers, where) {
+    if (tokens.length < 2 || tokens.length > 3 || tokens[0].kind !== "word" || tokens[1].kind === "list") {
+      this.report.error(
+        "validation-error",
+        OBO_ISSUE.BAD_VALUE,
+        "property_value needs a relation and a value; the clause is skipped",
+        where
+      );
+      return;
+    }
+    if (tokens.some((t) => t.unterminated)) {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "an unterminated quote; the text runs to the end of the line",
+        "property_value",
+        where.line
+      );
+    }
+    let datatype = tokens.length === 3 ? tokens[2].text : null;
+    if (tokens.length === 3 && tokens[2].kind !== "word") {
+      this.tally(
+        "parse-error",
+        OBO_ISSUE.SYNTAX,
+        "a datatype that is not a word was ignored",
+        "property_value",
+        where.line
+      );
+      datatype = null;
+    }
+    this.push(
+      record,
+      "property_value",
+      withQualifiers({ relation: tokens[0].text, value: tokens[1].text, datatype }, qualifiers)
+    );
+  }
+  /**
+   * Set a single-valued column, keeping the first value of an id.
+   * @param record - the record
+   * @param column - the column
+   * @param value - the value
+   * @param line - the line
+   * @param also - more to set together with the value
+   */
+  single(record, column, value, line, also) {
+    if (record.values.has(column)) {
+      this.tally(
+        "validation-error",
+        OBO_ISSUE.DUPLICATE_ATTRIBUTE,
+        "a single-valued tag given twice for one id; the first is kept",
+        column,
+        line
+      );
+      return;
+    }
+    record.values.set(column, value);
+    also?.();
+  }
+  /**
+   * Append to a list column, without repeats (merged frames take the union).
+   * @param record - the record
+   * @param column - the column
+   * @param value - the item
+   */
+  push(record, column, value) {
+    let list = record.lists.get(column);
+    if (list === void 0) {
+      list = [];
+      record.lists.set(column, list);
+    }
+    if (typeof value === "object" || !list.includes(value)) {
+      list.push(value);
+    }
+  }
+  /**
+   * Record xref descriptions in `xref.descriptions` (the first description of an id is kept),
+   * warning about a description whose quote never closes.
+   * @param target - the record
+   * @param xrefs - the xrefs
+   * @param tag - the clause's tag
+   * @param line - the clause's line
+   */
+  describe(target, xrefs, tag, line) {
+    for (const xref of xrefs) {
+      if (xref.unterminated) {
+        this.tally(
+          "parse-error",
+          OBO_ISSUE.SYNTAX,
+          "an xref description whose quote never closes runs to the end",
+          tag,
+          line
+        );
+      }
+      if (xref.description !== null) {
+        let map = target.values.get("xref.descriptions");
+        if (map === void 0) {
+          map = ownRecord();
+          target.values.set("xref.descriptions", map);
+        }
+        if (!Object.hasOwn(map, xref.id)) {
+          map[xref.id] = xref.description;
+        }
+      }
+    }
+  }
+  /**
+   * Keep the per-xref qualifiers of an xref list (OBO 1.2: `[A:1 {source="x"}]`) in
+   * `obo.qualifiers` under `<tag>.xrefs`.
+   * @param record - the record
+   * @param tag - the clause's tag
+   * @param xrefs - the list's xrefs
+   */
+  xrefQualifiers(record, tag, xrefs) {
+    for (const xref of xrefs) {
+      this.extraQualifiers(record, `${tag}.xrefs`, xref.id, xref.qualifiers);
+    }
+  }
+  /**
+   * Keep the qualifiers of a clause whose column has no place for them in `obo.qualifiers`.
+   * @param record - the record
+   * @param tag - the tag
+   * @param value - the clause's value as stored
+   * @param qualifiers - the qualifiers, or null
+   */
+  extraQualifiers(record, tag, value, qualifiers) {
+    if (qualifiers === null) {
+      return;
+    }
+    const map = record.values.get("obo.qualifiers") ?? {};
+    (map[tag] ??= []).push({ value, qualifiers });
+    record.values.set("obo.qualifiers", map);
+  }
+  /**
+   * Keep an unknown clause in `obo.unrecognized`.
+   * @param record - the record
+   * @param clause - the clause
+   */
+  unrecognized(record, clause) {
+    let map = record.values.get("obo.unrecognized");
+    if (map === void 0) {
+      map = ownRecord();
+      record.values.set("obo.unrecognized", map);
+    }
+    append(map, clause.tag, unescapeObo(clause.value));
+    this.tally(
+      "validation-error",
+      OBO_ISSUE.UNKNOWN_ELEMENT,
+      "an unknown tag was kept in obo.unrecognized",
+      clause.tag,
+      clause.line
+    );
+  }
+  /**
+   * Count a warning, recorded once per code and element at the end.
+   * @param category - the category
+   * @param code - the code
+   * @param what - what happened
+   * @param element - the tag, id or name it is about
+   * @param line - the first line
+   */
+  tally(category, code, what, element, line) {
+    const key = `${code}\0${element}\0${what}`;
+    const found = this.tallies.get(key);
+    if (found === void 0) {
+      this.tallies.set(key, { category, code, element, what, line, count: 1 });
+    } else {
+      found.count++;
+    }
+  }
+  /**
+   * Record the counted warnings, in the order they were first seen; past MAX_TALLIES_PER_CODE
+   * of one code, the rest are summed up in one warning.
+   */
+  flushTallies() {
+    const listed = /* @__PURE__ */ new Map();
+    const over = /* @__PURE__ */ new Map();
+    for (const t of this.tallies.values()) {
+      const n = (listed.get(t.code) ?? 0) + 1;
+      listed.set(t.code, n);
+      if (n > MAX_TALLIES_PER_CODE) {
+        const rest = over.get(t.code) ?? [];
+        rest.push(t);
+        over.set(t.code, rest);
+        continue;
+      }
+      this.report.warning(
+        t.category,
+        t.code,
+        `${t.element}: ${t.what} (${t.count} time${plural(t.count)}, first at line ${t.line})`,
+        {
+          line: t.line,
+          element: t.element
+        }
+      );
+    }
+    for (const [code, rest] of over) {
+      this.report.warning(
+        rest[0].category,
+        code,
+        `${rest.length} more element${plural(rest.length)} with this warning, not listed (first: ${rest[0].element}: ${rest[0].what}, line ${rest[0].line})`,
+        { line: rest[0].line }
+      );
+    }
+    this.tallies.clear();
+  }
+  /**
+   * The first line that makes the input not OBO: null unless no frame header and no plausible
+   * header tag was read while some line was neither (an HTML page, a JSON, GML, DOT or CSV file,
+   * UTF-16 read without its BOM). A file of only comments is OBO, if an empty one.
+   * @returns the line, or null
+   */
+  notObo() {
+    return this.frameSeen || this.tagClauses > 0 ? null : this.firstBadLine;
+  }
+  /**
+   * Warn about the header once the file is read: a missing or unknown format-version (the
+   * synonym-scope rule depends on it), a date that is not a real calendar date.
+   */
+  checkHeader() {
+    if (this.version === null) {
+      const empty = this.frameSeen ? "" : " and the file has no frames: nothing was read";
+      this.tally(
+        "validation-error",
+        OBO_ISSUE.FORMAT_VERSION,
+        `the header has no format-version (required by 1.2 and 1.4)${empty}; read as the 1.0 / 1.2 / 1.4 union`,
+        "format-version",
+        1
+      );
+    } else if (!KNOWN_VERSION.test(this.version)) {
+      this.tally(
+        "validation-error",
+        OBO_ISSUE.FORMAT_VERSION,
+        `format-version ${JSON.stringify(this.version)} is not 1.0, 1.2 or 1.4; read as 1.4`,
+        "format-version",
+        1
+      );
+    }
+    const date = this.header.date?.[0];
+    if (date !== void 0 && /^\d{2}:\d{2}:\d{4}\s+\d{2}:\d{2}$/.test(date.trim()) && oboDate$1(date.trim()) === null) {
+      this.tally(
+        "validation-error",
+        OBO_ISSUE.SYNTAX,
+        "the header date is not a real calendar date; created is null",
+        "date",
+        1
+      );
+    }
+  }
+  /**
+   * The header as GraphMeta fields (design 4.2): name from `ontology`, the version, `created` from
+   * the `dd:MM:yyyy HH:mm` date, `creator` from `saved-by`.
+   * @returns the metadata patch, without `extra`
+   */
+  meta() {
+    const first = (tag) => {
+      const values = this.header[tag];
+      return values === void 0 ? null : unescapeObo(values[0]).trim();
+    };
+    return {
+      name: first("ontology"),
+      sourceFormat: "obo",
+      sourceVersion: this.version,
+      created: oboDate$1(first("date")),
+      creator: first("saved-by")
+    };
+  }
+  /**
+   * The raw header clauses.
+   * @returns the header by tag
+   */
+  headerRecord() {
+    return this.header;
+  }
+  /**
+   * The namespace a frame without one gets.
+   * @returns the default namespace, or null
+   */
+  namespaceDefault() {
+    return this.defaultNamespace;
+  }
+}
+function withQualifiers(item, qualifiers) {
+  return qualifiers === null ? item : { ...item, qualifiers };
+}
+function oboDate$1(text) {
+  const m = text === null ? null : /^(\d{2}):(\d{2}):(\d{4})\s+(\d{2}):(\d{2})$/.exec(text);
+  if (m === null) {
+    return null;
+  }
+  const [, dd, mm, yyyy, hh, min] = m;
+  const day = new Date(Date.UTC(Number(yyyy), Number(mm) - 1, Number(dd)));
+  if (Number(mm) < 1 || Number(mm) > 12 || day.getUTCDate() !== Number(dd) || Number(hh) > 23 || Number(min) > 59) {
+    return null;
+  }
+  return `${yyyy}-${mm}-${dd}T${hh}:${min}`;
+}
+function planGraph(reader, report, addMissingNodes, obo) {
+  const records = [...reader.nodes.values()];
+  for (const [id, typedef] of reader.typedefs) {
+    const node = reader.nodes.get(id);
+    if (node !== void 0) {
+      reader.tally(
+        "validation-error",
+        OBO_ISSUE.ID_KIND_CLASH,
+        `an id names both a ${node.kind} and a Typedef; the ${node.kind} is the node`,
+        id,
+        typedef.line
+      );
+    } else if (obo.typedefs === "nodes") {
+      records.push(typedef);
+    }
+  }
+  for (const record of [...reader.nodes.values(), ...reader.typedefs.values()]) {
+    for (const tag of ["intersection_of", "union_of"]) {
+      if (record.lists.get(tag)?.length === 1) {
+        reader.tally(
+          "validation-error",
+          OBO_ISSUE.CARDINALITY,
+          "a single clause (a class expression needs two or more)",
+          tag,
+          record.line
+        );
+      }
+    }
+  }
+  const dropped = /* @__PURE__ */ new Set();
+  const kept = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    const obsolete = record.values.get("is_obsolete") === true;
+    (obo.obsolete === "drop" && obsolete ? dropped : kept).add(record.id);
+    if (obsolete && record.edges.length > 0) {
+      reader.tally(
+        "validation-error",
+        OBO_ISSUE.OBSOLETION,
+        "an obsolete term has is_a or relationship clauses; they are kept",
+        "is_obsolete",
+        record.edges[0].line
+      );
+    }
+    if (!obsolete && (record.lists.has("replaced_by") || record.lists.has("consider"))) {
+      reader.tally(
+        "validation-error",
+        OBO_ISSUE.OBSOLETION,
+        "replaced_by or consider on a term that is not obsolete; kept",
+        "replaced_by",
+        record.line
+      );
+    }
+  }
+  const declared = new Set(reader.typedefs.keys());
+  for (const typedef of reader.typedefs.values()) {
+    for (const xref of typedef.lists.get("xref") ?? []) {
+      declared.add(xref);
+    }
+  }
+  const dangling = [];
+  const danglingSet = /* @__PURE__ */ new Set();
+  let danglingEdges = 0;
+  let droppedEdges = 0;
+  const edges = [];
+  for (const record of records) {
+    for (const edge of record.edges) {
+      if (dropped.has(record.id) || dropped.has(edge.target)) {
+        droppedEdges++;
+        continue;
+      }
+      if (!BUILTIN_RELATIONS$1.has(edge.relation) && !declared.has(edge.relation)) {
+        reader.tally(
+          "validation-error",
+          OBO_ISSUE.UNDECLARED,
+          "a relation no Typedef declares",
+          edge.relation,
+          edge.line
+        );
+      }
+      if (!kept.has(edge.target)) {
+        if (!danglingSet.has(edge.target)) {
+          danglingSet.add(edge.target);
+          dangling.push(edge.target);
+        }
+        if (!addMissingNodes) {
+          danglingEdges++;
+          report.counts.skippedEdges++;
+          continue;
+        }
+      }
+      edges.push({ source: record.id, edge });
+    }
+  }
+  reader.flushTallies();
+  reportDangling(records, dangling, addMissingNodes, danglingEdges, report, new Set(reader.typedefs.keys()));
+  if (dropped.size > 0) {
+    report.warning(
+      "merged",
+      OBO_ISSUE.OBSOLETE_DROPPED,
+      `${dropped.size} obsolete term${plural(dropped.size)} and ${droppedEdges} edge${plural(droppedEdges)} to or from them were left out (obsolete: "drop")`,
+      { element: [...dropped][0] }
+    );
+  }
+  return {
+    nodes: records.filter((record) => kept.has(record.id)),
+    placeholders: addMissingNodes ? dangling : [],
+    edges
+  };
+}
+function reportDangling(records, dangling, addMissingNodes, droppedEdges, report, typedefs) {
+  if (dangling.length === 0) {
+    return;
+  }
+  const altOf = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    for (const alt of record.lists.get("alt_id") ?? []) {
+      altOf.set(alt, record.id);
+    }
+  }
+  const shown = dangling.slice(0, 5).map((id) => {
+    const primary = altOf.get(id);
+    if (typedefs.has(id)) {
+      return `${id} (a Typedef, kept as metadata, not a node)`;
+    }
+    return primary === void 0 ? id : `${id} (an alt_id of ${primary})`;
+  });
+  const more = dangling.length > 5 ? `, ... (${dangling.length - 5} more)` : "";
+  const action = addMissingNodes ? "each became a placeholder node (graphty.placeholder)" : `${droppedEdges} edge${plural(droppedEdges)} to them ${agree(droppedEdges, "was", "were")} dropped (addMissingNodes false)`;
+  report.warning(
+    "validation-error",
+    OBO_ISSUE.DANGLING_REFERENCE,
+    `${dangling.length} target${plural(dangling.length)} no frame declares: ${shown.join(", ")}${more}; ${action}`,
+    { element: dangling[0] }
+  );
+}
+class Pusher {
+  /**
+   * Create a pusher.
+   * @param sink - the sink
+   * @param report - the report
+   * @param options - the resolved common options
+   */
+  constructor(sink, report, options) {
+    this.restored = /* @__PURE__ */ new Map();
+    this.since = 0;
+    this.sink = sink;
+    this.report = report;
+    this.coercer = new IdCoercer(options.ids);
+    this.signal = options.signal;
+  }
+  /**
+   * An id text under the `ids` rule, reporting a merge.
+   * @param text - the id as written
+   * @returns the node id
+   */
+  id(text) {
+    const id = this.coercer.text(this.restored.get(text) ?? text);
+    const merge = this.coercer.lastMerge;
+    if (merge !== null) {
+      this.report.warning(
+        "coercion",
+        OBO_ISSUE.ID_MERGED,
+        `id text ${JSON.stringify(merge.text)} merged with ${JSON.stringify(merge.previousText)} as ${merge.id}`,
+        { element: text }
+      );
+    }
+    return id;
+  }
+  /**
+   * Add a node, counting it, or record why it was refused.
+   * @param text - the id as written
+   * @param line - the line, when known
+   * @returns the node index, or -1 when refused
+   */
+  node(text, line) {
+    this.tick();
+    try {
+      const id = this.id(text);
+      const known = this.sink.indexOf(id) !== INVALID_INDEX;
+      const index = this.sink.addNode(id);
+      if (!known) {
+        this.report.counts.nodes++;
+      }
+      return index;
+    } catch (err) {
+      this.report.recordError(err, { line, element: text });
+      this.report.counts.skippedNodes++;
+      return -1;
+    }
+  }
+  /** Check the cancellation signal every ABORT_CHECK_INTERVAL pushes. */
+  tick() {
+    if (++this.since >= ABORT_CHECK_INTERVAL) {
+      this.since = 0;
+      throwIfAborted(this.signal);
+    }
+  }
+}
+function writeGraph(reader, sink, report, options, obo) {
+  const plan2 = planGraph(reader, report, options.addMissingNodes, obo);
+  const push = new Pusher(sink, report, options);
+  if (options.restoreMangledIds) {
+    restoreIds(plan2.nodes, push.restored);
+  }
+  const namespace = reader.namespaceDefault();
+  const used = /* @__PURE__ */ new Set(["type"]);
+  for (const record of plan2.nodes) {
+    for (const name of [...record.values.keys(), ...record.lists.keys()]) {
+      used.add(name);
+    }
+  }
+  if (namespace !== null) {
+    used.add("namespace");
+  }
+  const columns = /* @__PURE__ */ new Map();
+  for (const name of plan2.nodes.length > 0 ? Object.keys(OBO_NODE_COLUMNS) : []) {
+    if (used.has(name)) {
+      columns.set(name, declareResolved(sink, "node", oboColumnDecl("node", name), report).handle);
+    }
+  }
+  sink.reserve(plan2.nodes.length + plan2.placeholders.length, plan2.edges.length);
+  for (const record of plan2.nodes) {
+    const index = push.node(record.id, record.line);
+    if (index < 0) {
+      continue;
+    }
+    const cells = [["type", record.kind], ...record.values, ...record.lists];
+    if (namespace !== null && !record.values.has("namespace")) {
+      cells.push(["namespace", namespace]);
+    }
+    for (const [name, value] of cells) {
+      const handle = columns.get(name);
+      if (handle !== void 0) {
+        sink.setNodeValue(handle, index, value);
+      }
+    }
+  }
+  if (plan2.placeholders.length > 0) {
+    const placeholder = declareResolved(sink, "node", oboColumnDecl("node", PLACEHOLDER_COLUMN), report).handle;
+    for (const text of plan2.placeholders) {
+      const index = push.node(text);
+      if (index >= 0) {
+        sink.setNodeValue(placeholder, index, true);
+      }
+    }
+  }
+  writeEdges(plan2, push, options);
+}
+function restoreIds(records, restored) {
+  const taken = new Set(records.map((r) => r.id));
+  for (const record of records) {
+    const values = record.lists.get("property_value");
+    const at = values?.findIndex((v) => v.relation === ORIGINAL_ID$1) ?? -1;
+    if (values === void 0 || at < 0) {
+      continue;
+    }
+    const original = originalText(values[at].value);
+    if (taken.has(original)) {
+      continue;
+    }
+    taken.add(original);
+    restored.set(record.id, original);
+    values.splice(at, 1);
+    if (values.length === 0) {
+      record.lists.delete("property_value");
+    }
+  }
+}
+function originalText(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "string" ? parsed : value;
+  } catch {
+    return value;
+  }
+}
+function writeEdges(plan2, push, options) {
+  const { sink, report } = push;
+  const direction = new DirectionResolver(sink, report, options.onMixedDirection);
+  direction.setHeader(true);
+  if (plan2.edges.length === 0) {
+    return;
+  }
+  const relation = declareResolved(sink, "edge", oboColumnDecl("edge", "relation"), report).handle;
+  const qualifiers = plan2.edges.some((e) => e.edge.qualifiers !== null) ? declareResolved(sink, "edge", oboColumnDecl("edge", "qualifiers"), report).handle : null;
+  for (const { source, edge } of plan2.edges) {
+    push.tick();
+    const before = sink.edgeCount;
+    try {
+      const e = direction.addEdge(push.id(source), push.id(edge.target), "directed", void 0, {
+        line: edge.line,
+        element: source
+      });
+      report.counts.edges += sink.edgeCount - before;
+      if (e < 0) {
+        continue;
+      }
+      sink.setEdgeValue(relation, e, edge.relation);
+      if (qualifiers !== null && edge.qualifiers !== null) {
+        sink.setEdgeValue(qualifiers, e, edge.qualifiers);
+      }
+    } catch (err) {
+      report.recordError(err, { line: edge.line, element: source });
+      report.counts.skippedEdges++;
+    }
+  }
+}
+async function readLines(lines, reader) {
+  const parts = [];
+  let partLine = 0;
+  const feed = (text, line) => {
+    for (const piece of splitFormFeeds(text)) {
+      reader.line(piece, line);
+    }
+  };
+  for await (const physical of lines) {
+    const { line } = lines;
+    if (parts.length > 0) {
+      const head = physical.trimStart();
+      if (head.length === 0 || head.startsWith("[")) {
+        reader.tally(
+          "parse-error",
+          OBO_ISSUE.SYNTAX,
+          "a line continuation before a frame header or a blank line was ignored",
+          "\\",
+          partLine
+        );
+        feed(parts.join(""), partLine);
+        parts.length = 0;
+      } else {
+        reader.tally(
+          "coercion",
+          OBO_ISSUE.DEPRECATED_SYNTAX,
+          "a backslash line continuation was joined (deprecated in 1.4)",
+          "\\",
+          partLine
+        );
+      }
+    }
+    if (endsWithContinuation(physical) && stripComment(physical) === physical) {
+      parts.push(physical.slice(0, -1));
+      partLine = line;
+      continue;
+    }
+    if (parts.length > 0) {
+      parts.push(physical);
+      feed(parts.join(""), line);
+      parts.length = 0;
+    } else {
+      feed(physical, line);
+    }
+  }
+  if (parts.length > 0) {
+    reader.tally(
+      "coercion",
+      OBO_ISSUE.DEPRECATED_SYNTAX,
+      "a backslash line continuation was joined (deprecated in 1.4)",
+      "\\",
+      partLine
+    );
+    feed(parts.join(""), partLine);
+  }
+}
+function sniffObo(head) {
+  let text = new TextDecoder("utf-8").decode(head.subarray(0, SNIFF_BYTES));
+  if (text.charCodeAt(0) === 65279) {
+    text = text.slice(1);
+  }
+  const lines = text.split(/\r\n|\r|\n|\f/);
+  if (lines.length > 1 && head.byteLength >= SNIFF_BYTES) {
+    lines.pop();
+  }
+  let tagLines2 = 0;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.length === 0 || line.startsWith("!")) {
+      continue;
+    }
+    if (/^\[(Term|Typedef|Instance)\]\s*(!.*)?$/.test(line)) {
+      return 0.9;
+    }
+    if (tagLines2 === 0 && /^format-version\s*:/.test(line)) {
+      return 0.9;
+    }
+    if (/^[A-Za-z][A-Za-z0-9_-]*\s*:(\s|$)/.test(line)) {
+      tagLines2++;
+      continue;
+    }
+    return 0;
+  }
+  return tagLines2 > 0 ? 0.4 : 0;
+}
+const oboImporter = Object.freeze({
+  format: "obo",
+  options: Object.freeze(["obsolete", "typedefs"]),
+  extensions: Object.freeze([".obo"]),
+  mimeTypes: Object.freeze(["text/obo", "application/obo"]),
+  /**
+   * Confidence that the head is an OBO file.
+   * @param head - the first bytes
+   * @returns the confidence
+   */
+  sniff(head) {
+    return sniffObo(head);
+  },
+  /**
+   * Read an OBO file into the sink.
+   * @param input - the text, bytes or stream
+   * @param sink - the sink
+   * @param options - format-specific and common options
+   * @returns the import report; ImportError on a fatal error or beyond the error limit
+   */
+  async import(input, sink, options) {
+    const resolved = resolveImportOptions(options, DEFAULTS);
+    const obo = resolveOboOptions$1(options);
+    const report = new ImportReportBuilder("obo", resolved.errorLimit);
+    reportSinkOptions(sink, options, report, true);
+    reportUnusedOptions(options, report, USED_OPTIONS);
+    const reader = new OboReader(report, resolved.signal, obo.typedefs === "nodes");
+    await readLines(new LineReader(input, report, resolved), reader);
+    reader.finishFrame();
+    if (!reader.significant) {
+      report.fail(OBO_ISSUE.EMPTY_INPUT, "the input is empty");
+    }
+    const notObo = reader.notObo();
+    if (notObo !== null) {
+      report.fail(
+        OBO_ISSUE.NOT_OBO,
+        `the input is not OBO: it has no frame header and no header tag, and line ${notObo} is not a tag-value line`,
+        { line: notObo }
+      );
+    }
+    throwIfAborted(resolved.signal);
+    reader.checkHeader();
+    writeGraph(reader, sink, report, resolved, obo);
+    const typedefs = ownRecord();
+    for (const [id, record] of reader.typedefs) {
+      typedefs[id] = record.raw;
+    }
+    const extra = { header: reader.headerRecord(), typedefs };
+    if (reader.unknownFrames.length > 0) {
+      extra.unknownFrames = reader.unknownFrames;
+    }
+    sink.setMeta({ ...reader.meta(), extra: { obo: extra } });
+    throwIfAborted(resolved.signal);
+    return report.finish();
+  }
+});
+const OBO_LOSS = Object.freeze({
+  /** A node column outside the OBO vocabulary (or one whose values a tag cannot carry exactly) reads back inside the `property_value` column. */
+  COLUMN_AS_PROPERTY_VALUE: COLUMN_AS_PROPERTY_VALUE_CODE,
+  /** An edge column (or the explicit weights) reads back inside the `qualifiers` column. */
+  EDGE_COLUMN_AS_QUALIFIER: "W_OBO_EDGE_COLUMN_AS_QUALIFIER",
+  /** Every edge is written from its source to its target, so an undirected graph reads back as directed. */
+  UNDIRECTED_AS_DIRECTED: "W_OBO_UNDIRECTED_AS_DIRECTED",
+  /** Two identical clauses on one frame (parallel edges with one relation and the same qualifiers, a repeated list item) read back as one. */
+  DUPLICATE_CLAUSE: "W_OBO_DUPLICATE_CLAUSE",
+  /** An edge without a relation is written with the `relation` option (default `is_a`). */
+  RELATION_ASSUMED: RELATION_ASSUMED_CODE,
+  /** A relation that is not an OBO id (empty, or holding a space, `!`, `{` or `}`) is written with `_` in place of those characters. */
+  RELATION_RENAMED: "W_OBO_RELATION_RENAMED",
+  /** The graph name is not an ontology id; the header `ontology` is written with `_` in place of the other characters. */
+  ONTOLOGY_NAME: "W_OBO_ONTOLOGY_NAME",
+  /** `[Typedef]` frames read back as nodes only under the importer's `typedefs: "nodes"`; by default they are metadata. */
+  TYPEDEF_NODES: TYPEDEF_NODES_CODE,
+  /** Edges are written in the frame of their source node, so they read back grouped by source, in node order. */
+  EDGE_ORDER: "W_OBO_EDGE_ORDER",
+  /**
+   * A graph attribute is written as a header `property_value` and reads back in `snapshot.meta.extra.obo.header`,
+   * not as a graph attribute.
+   */
+  GRAPH_COLUMN_AS_METADATA: GRAPH_COLUMN_AS_METADATA_CODE,
+  /** A carriage return or form feed in a text cannot be written; it is written as a line feed. */
+  LINE_END: "W_OBO_LINE_END",
+  /** The nodes read back in a different order. */
+  NODE_ORDER: NODE_ORDER_CODE,
+  /** A mutual pair is written as two clauses without its mark. */
+  MUTUAL_EXPANDED: LOSS.MUTUAL_EXPANDED,
+  /**
+   * The undirected edges of a mixed graph are written the way `onMixedDirection` chose ("directed" or "undirected").
+   */
+  MIXED_DIRECTION: LOSS.MIXED_DIRECTION,
+  /**
+   * The graph has both directed and undirected edges and `onMixedDirection` is "error". An import stops; a save to a
+   * format that holds one direction per file fails with E_DIRECTED. Pass "directed" or "undirected" to read or write
+   * it anyway.
+   */
+  MIXED_DIRECTION_ERROR: LOSS.MIXED_DIRECTION_ERROR,
+  /** OBO has no edge ids. */
+  EDGE_IDS_DROPPED: LOSS.EDGE_IDS_DROPPED,
+  /** OBO has no positions. */
+  POSITIONS_DROPPED: LOSS.POSITIONS,
+  /** OBO has no containment. */
+  HIERARCHY_DROPPED: LOSS.HIERARCHY,
+  /** OBO has no time. */
+  TEMPORAL_DROPPED: LOSS.TEMPORAL,
+  /** OBO has no visual columns. */
+  VIZ_DROPPED: LOSS.VIZ,
+  /** An attribute with a role the format has no place for is written as a plain attribute; the role is lost. */
+  ROLE_DROPPED: LOSS.ROLE,
+  /**
+   * An attribute without a role is written where the format keeps a role (for example, a `name` column as the label), and
+   * reads back with that role.
+   */
+  ROLE_ASSUMED: ROLE_ASSUMED_CODE,
+  /**
+   * An attribute with a role (for example, the label) is written where the format keeps that role, and reads back under the
+   * name the format's importer gives it.
+   */
+  COLUMN_NAME_CHANGED: LOSS.COLUMN_NAME_CHANGED,
+  /**
+   * An OBO attribute stored as text where graph-io uses a dictionary (or the other way round); it reads back with
+   * graph-io's usual type. The values are the same.
+   */
+  DTYPE_UNSUPPORTED: LOSS.DTYPE,
+  /** A column without a value on any written element reads back absent. */
+  EMPTY_COLUMN_DROPPED: LOSS.EMPTY_COLUMN,
+  /** A declared default: OBO has none. */
+  DEFAULT_DROPPED: LOSS.DEFAULT,
+  /** Declared options: OBO has no enumerations. */
+  OPTIONS_DROPPED: LOSS.OPTIONS,
+  /** An extension table OBO cannot carry. */
+  EXTENSION_TABLE_DROPPED: LOSS.EXTENSION_TABLE,
+  /**
+   * Node ids the format cannot write, under `sanitizeIds: "error"`; the save fails with E_INVALID_ID. Pass
+   * `sanitizeIds: "mangle"` to rewrite them.
+   */
+  ID_CHARSET: LOSS.ID_CHARSET,
+  /** Node ids OBO cannot write as they are, under sanitizeIds "mangle": rewritten, the original kept. */
+  ID_MANGLED: LOSS.ID_MANGLED,
+  /** Numeric ids are written as text and read back as strings. */
+  ID_TEXT_TYPE: LOSS.ID_TEXT_TYPE,
+  /**
+   * Two node ids would be written as the same text (the number 5 and the text "5"); the save fails with
+   * E_INVALID_ID.
+   */
+  ID_TEXT_COLLISION: LOSS.ID_TEXT_COLLISION
+});
+const OBO_CAPABILITIES = capabilities({
+  mixedDirection: false,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "none",
+  idCharset: "any",
+  dtypes: [],
+  components: false,
+  lists: false,
+  json: false,
+  defaults: false,
+  options: false,
+  hierarchy: false,
+  temporal: "none",
+  graphAttributes: false,
+  positions: false,
+  viz: false
+});
+const ORIGINAL_ID = "graphty:originalId";
+const RELATION_COLUMN = "relation";
+const QUALIFIERS_COLUMN = "qualifiers";
+const WEIGHT_QUALIFIER = "weight";
+const BUILTIN_RELATIONS = /* @__PURE__ */ new Set([
+  "is_a",
+  "instance_of",
+  "disjoint_from",
+  "inverse_of",
+  "union_of",
+  "intersection_of"
+]);
+const EDGES = "\0edges";
+const UNRECOGNIZED = "obo.unrecognized";
+const TAG_ORDER = [
+  "is_anonymous",
+  "name",
+  "namespace",
+  "alt_id",
+  "def",
+  "comment",
+  "subset",
+  "synonym",
+  "xref",
+  "builtin",
+  "property_value",
+  "domain",
+  "range",
+  "holds_over_chain",
+  "is_anti_symmetric",
+  "is_cyclic",
+  "is_reflexive",
+  "is_symmetric",
+  "is_asymmetric",
+  "is_transitive",
+  "is_functional",
+  "is_inverse_functional",
+  EDGES,
+  "intersection_of",
+  "union_of",
+  "equivalent_to",
+  "disjoint_from",
+  "inverse_of",
+  "transitive_over",
+  "equivalent_to_chain",
+  "disjoint_over",
+  "created_by",
+  "creation_date",
+  "is_obsolete",
+  "replaced_by",
+  "consider",
+  "expand_assertion_to",
+  "expand_expression_to",
+  "is_metadata_tag",
+  "is_class_level",
+  UNRECOGNIZED
+];
+const HEADER_ORDER = [
+  "format-version",
+  "data-version",
+  "version",
+  "date",
+  "saved-by",
+  "auto-generated-by",
+  "import",
+  "subsetdef",
+  "synonymtypedef",
+  "idspace",
+  "default-relationship-id-prefix",
+  "id-mapping",
+  "default-namespace",
+  "namespace-id-rule",
+  "remark",
+  "ontology"
+];
+const APPLIED_TAGS = /* @__PURE__ */ new Set([
+  "id",
+  "is_a",
+  "instance_of",
+  "relationship",
+  "intersection_of",
+  "holds_over_chain",
+  "equivalent_to_chain",
+  "def",
+  "expand_assertion_to",
+  "expand_expression_to",
+  "synonym",
+  "xref",
+  "property_value",
+  ...TEXT_TAGS,
+  ...BOOL_TAGS,
+  ...ID_LIST_TAGS,
+  ...DEPRECATED_TAGS.keys()
+]);
+const TAG_COLUMNS = new Set(
+  Object.keys(OBO_NODE_COLUMNS).filter((name) => name !== "type" && name !== "name" && name !== "propertyType")
+);
+const XSD = Object.freeze({
+  string: "xsd:string",
+  dict: "xsd:string",
+  bool: "xsd:boolean",
+  i32: "xsd:integer",
+  u32: "xsd:integer",
+  u8: "xsd:integer",
+  f32: "xsd:double",
+  f64: "xsd:double"
+});
+function isTrimmed(text) {
+  return text.length > 0 && text === text.trim();
+}
+function arrayOf(value, item, nonEmpty = true) {
+  return Array.isArray(value) && (!nonEmpty || value.length > 0) && value.every(item);
+}
+function isXrefId(value) {
+  return typeof value === "string" && value.length > 0 && isTrimmed(value);
+}
+function isWord(value) {
+  return typeof value === "string" && isOboWord(value);
+}
+function hasKeys(value, keys) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const own = Object.keys(value);
+  const record = value;
+  if (Object.hasOwn(record, "qualifiers")) {
+    if (!isQualifierRecord(record.qualifiers, isQualifierName)) {
+      return false;
+    }
+    return own.length === keys.length + 1 && keys.every((k) => Object.hasOwn(record, k));
+  }
+  return own.length === keys.length && keys.every((k) => Object.hasOwn(record, k));
+}
+function wordOf(text) {
+  const out = text.replaceAll(new RegExp(NOT_IN_WORD.source, "gu"), "_");
+  return out.length === 0 ? "_" : out;
+}
+function qualifierPairs(record) {
+  const out = [];
+  for (const [name, value] of Object.entries(record)) {
+    for (const item of Array.isArray(value) ? value : [value]) {
+      out.push([name, item]);
+    }
+  }
+  return out;
+}
+function resolveOboOptions(options) {
+  const relation = options?.relation ?? "is_a";
+  if (typeof relation !== "string" || !isOboWord(relation)) {
+    throw new GraphFormatError("E_UNSUPPORTED", `option relation: ${JSON.stringify(relation)} is not an OBO id`, {
+      option: "relation",
+      found: relation
+    });
+  }
+  const ontology = options?.ontology ?? null;
+  if (ontology !== null && (typeof ontology !== "string" || !/^[A-Za-z0-9_.\-/]+$/.test(ontology))) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option ontology: ${JSON.stringify(ontology)} is not an ontology id (letters, digits, _ . - /)`,
+      { option: "ontology", found: ontology }
+    );
+  }
+  return { relation, ontology };
+}
+function planIds(snapshot, mode, note) {
+  const n = snapshot.nodeCount;
+  const ids = new Array(n);
+  const bad = [];
+  let numeric = 0;
+  for (let i = 0; i < n; i++) {
+    const id = snapshot.ids.idOf(i);
+    if (typeof id === "number") {
+      numeric++;
+    }
+    ids[i] = String(id);
+    if (!isOboWord(ids[i])) {
+      bad.push(i);
+    }
+  }
+  if (numeric > 0) {
+    note(
+      LOSS.ID_TEXT_TYPE,
+      `${numeric} numeric node id${plural(numeric)} ${agree(numeric, "is", "are")} written as text and read back as strings`,
+      null,
+      numeric
+    );
+  }
+  const originals = /* @__PURE__ */ new Map();
+  let fatal = null;
+  if (bad.length > 0 && mode === "error") {
+    fatal = refuseIds(snapshot, ids, bad, note);
+  } else if (bad.length > 0) {
+    mangleIds(ids, bad, originals, note);
+  }
+  return { ids, originals, fatal: fatal ?? collidingIds(snapshot, ids, note) };
+}
+function refuseIds(snapshot, ids, bad, note) {
+  note(
+    LOSS.ID_CHARSET,
+    `${bad.length} node id${plural(bad.length)} ${agree(bad.length, "is", "are")} not OBO ids (empty, or holding whitespace, a control character, "!", "{" or "}"); the save fails unless sanitizeIds is "mangle"`,
+    null,
+    bad.length
+  );
+  return new GraphFormatError(
+    "E_INVALID_ID",
+    `${bad.length} node id${plural(bad.length)} cannot be written as OBO ids (first: ${JSON.stringify(ids[bad[0]])}); pass sanitizeIds: "mangle" to rewrite them`,
+    { reason: "charset", count: bad.length, id: snapshot.ids.idOf(bad[0]), index: bad[0] }
+  );
+}
+function mangleIds(ids, bad, originals, note) {
+  const badSet = new Set(bad);
+  const used = new Set(ids.filter((_, i) => !badSet.has(i)));
+  for (const i of bad) {
+    const base = wordOf(ids[i]);
+    let candidate = base;
+    let k = 2;
+    while (used.has(candidate)) {
+      candidate = `${base}_${k}`;
+      k++;
+    }
+    used.add(candidate);
+    originals.set(i, ids[i]);
+    ids[i] = candidate;
+  }
+  note(
+    LOSS.ID_MANGLED,
+    `${bad.length} node id${plural(bad.length)} that ${agree(bad.length, "is", "are")} not OBO ids ${agree(bad.length, "is", "are")} rewritten with "_"; the originals are kept as ${ORIGINAL_ID} property values (JSON text; an import with restoreMangledIds: true reads them back as the ids)`,
+    null,
+    bad.length
+  );
+}
+function collidingIds(snapshot, ids, note) {
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ids.length; i++) {
+    const before = seen.get(ids[i]);
+    if (before !== void 0) {
+      note(
+        LOSS.ID_TEXT_COLLISION,
+        `node ids ${JSON.stringify(snapshot.ids.idOf(before))} and ${JSON.stringify(snapshot.ids.idOf(i))} have the same text; the save fails`,
+        null,
+        1
+      );
+      return new GraphFormatError("E_INVALID_ID", "two node ids have the same text; OBO keeps ids as text", {
+        reason: "collision"
+      });
+    }
+    seen.set(ids[i], i);
+  }
+  return null;
+}
+function planEdges(snapshot, folding, common, note) {
+  const { src, dst } = snapshot.edgeList();
+  const written2 = [];
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (!folding.folded(e)) {
+      written2.push(e);
+    }
+  }
+  const edgeStart = new Uint32Array(snapshot.nodeCount + 1);
+  for (const e of written2) {
+    edgeStart[src[e] + 1]++;
+  }
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    edgeStart[i + 1] += edgeStart[i];
+  }
+  const fill = edgeStart.slice(0, snapshot.nodeCount);
+  const edgeOrder = new Uint32Array(written2.length);
+  for (const e of written2) {
+    edgeOrder[fill[src[e]]++] = e;
+  }
+  let moved = 0;
+  for (let k = 0; k < edgeOrder.length; k++) {
+    if (edgeOrder[k] !== written2[k]) {
+      moved++;
+    }
+  }
+  if (moved > 0) {
+    note(
+      OBO_LOSS.EDGE_ORDER,
+      `${moved} edge${plural(moved)} ${agree(moved, "reads", "read")} back at another position: edges are written on their source's frame, grouped by source in node order`,
+      null,
+      moved
+    );
+  }
+  if (!snapshot.directed) {
+    note(
+      OBO_LOSS.UNDIRECTED_AS_DIRECTED,
+      `the snapshot is undirected; every edge is written from its source to its target and reads back directed (${written2.length} edge${plural(written2.length)})`,
+      null,
+      written2.length
+    );
+  } else if (common.onMixedDirection !== "error") {
+    const undirected = written2.filter((e) => !folding.sourceDirected(e)).length;
+    if (undirected > 0) {
+      note(
+        OBO_LOSS.UNDIRECTED_AS_DIRECTED,
+        `${undirected} undirected edge${plural(undirected)} ${agree(undirected, "is", "are")} written as one directed clause each; OBO has no undirected edge`,
+        null,
+        undirected
+      );
+    }
+  }
+  if (folding.mutualCount > 0) {
+    note(
+      LOSS.MUTUAL_EXPANDED,
+      `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as two clauses; the mutual mark is lost`,
+      null,
+      folding.mutualCount
+    );
+  }
+  return { written: written2, edgeStart, edgeOrder, dst };
+}
+function planKinds(snapshot, frameless) {
+  const kinds = new Array(snapshot.nodeCount).fill("Term");
+  const type = snapshot.nodes.get("type");
+  if (type === null || type.dtype !== "dict" && type.dtype !== "string") {
+    return { kinds, type: null };
+  }
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    if (frameless[i] === 1) {
+      if (type.isSet(i)) {
+        return { kinds: kinds.fill("Term"), type: null };
+      }
+      continue;
+    }
+    const value = cellOf(type, i);
+    if (typeof value !== "string" || !FRAME_KINDS$1.has(value)) {
+      return { kinds: kinds.fill("Term"), type: null };
+    }
+    kinds[i] = value;
+  }
+  return { kinds, type };
+}
+function tagCarries(name, column, rows, kinds, scopes) {
+  const spec = OBO_NODE_COLUMNS[name];
+  if (!fitsVocabulary(spec.dtype, column) || column.meta.components > 1) {
+    return false;
+  }
+  const typedefOnly = TYPEDEF_TAGS.has(name);
+  const valid = (v) => {
+    if (TEXT_TAGS.has(name)) {
+      return typeof v === "string" && isTrimmed(v);
+    }
+    if (BOOL_TAGS.has(name)) {
+      return typeof v === "boolean";
+    }
+    if (ID_LIST_TAGS.has(name)) {
+      return arrayOf(v, isWord);
+    }
+    switch (name) {
+      case "def":
+        return typeof v === "string";
+      case "def.xrefs":
+        return arrayOf(v, isXrefId, false);
+      case "xref":
+        return arrayOf(v, isXrefId);
+      case "xref.descriptions":
+        return typeof v === "object" && v !== null && !Array.isArray(v) && Object.values(v).every((d) => typeof d === "string");
+      case "synonym":
+        return arrayOf(
+          v,
+          (s) => hasKeys(s, ["text", "scope", "type", "xrefs"]) && typeof s.text === "string" && typeof s.scope === "string" && SYNONYM_SCOPES.has(s.scope) && (s.type === null || isWord(s.type)) && (s.type === null || (scopes.get(s.type) ?? s.scope) === s.scope) && arrayOf(s.xrefs, isXrefId, false)
+        );
+      case "intersection_of":
+        return arrayOf(
+          v,
+          (x) => hasKeys(x, ["relation", "target"]) && (x.relation === null || isWord(x.relation)) && isWord(x.target)
+        );
+      case "property_value":
+        return arrayOf(
+          v,
+          (x) => hasKeys(x, ["relation", "value", "datatype"]) && isWord(x.relation) && x.relation !== ORIGINAL_ID && typeof x.value === "string" && (x.datatype === null || isWord(x.datatype))
+        );
+      case "holds_over_chain":
+      case "equivalent_to_chain":
+        return arrayOf(v, (pair) => arrayOf(pair, isWord) && pair.length === 2);
+      case "expand_assertion_to":
+      case "expand_expression_to":
+        return arrayOf(
+          v,
+          (x) => hasKeys(x, ["template", "xrefs"]) && typeof x.template === "string" && arrayOf(x.xrefs, isXrefId, false)
+        );
+      case "obo.qualifiers":
+        return typeof v === "object" && v !== null && !Array.isArray(v) && Object.values(v).every(
+          (entries) => arrayOf(
+            entries,
+            (entry) => hasKeys(entry, ["value"]) && Object.hasOwn(entry, "qualifiers") && typeof entry.value === "string" && isQualifierRecord(entry.qualifiers, isQualifierName)
+          )
+        );
+      default:
+        return false;
+    }
+  };
+  for (const i of rows) {
+    if (!column.isSet(i)) {
+      continue;
+    }
+    if (typedefOnly && kinds[i] !== "Typedef") {
+      return false;
+    }
+    if (!valid(cellOf(column, i))) {
+      return false;
+    }
+  }
+  return true;
+}
+function unrecognizedCarried(column, rows, kinds) {
+  if (column.dtype !== "json") {
+    return false;
+  }
+  for (const i of rows) {
+    const v = cellOf(column, i);
+    if (v === void 0) {
+      continue;
+    }
+    if (typeof v !== "object" || v === null || Array.isArray(v)) {
+      return false;
+    }
+    for (const [tag, values] of Object.entries(v)) {
+      const applied = (APPLIED_TAGS.has(tag) || TYPEDEF_TAGS.has(tag)) && !(TYPEDEF_TAGS.has(tag) && kinds[i] !== "Typedef") && !(tag === "instance_of" && kinds[i] !== "Instance");
+      if (applied || tag.length === 0 || !isTrimmed(tag) || !arrayOf(values, (t) => typeof t === "string" && isTrimmed(t))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function synonymTypeScopes(header) {
+  const out = /* @__PURE__ */ new Map();
+  for (const raw of header.synonymtypedef ?? []) {
+    const tokens = tokenize(raw);
+    if (tokens.length > 0 && tokens[0].kind === "word") {
+      const scope = tokens.slice(1).find((t) => t.kind === "word" && SYNONYM_SCOPES.has(t.text));
+      out.set(tokens[0].text, scope?.text ?? null);
+    }
+  }
+  return out;
+}
+function keptObo(snapshot) {
+  const raw = snapshot.meta.extra.obo;
+  const record = typeof raw === "object" && raw !== null && !Array.isArray(raw) ? raw : {};
+  const clauses = (value) => {
+    const out = {};
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      for (const [tag, values] of Object.entries(value)) {
+        if (Array.isArray(values)) {
+          out[tag] = values.filter((v) => typeof v === "string");
+        }
+      }
+    }
+    return out;
+  };
+  const typedefs = {};
+  if (typeof record.typedefs === "object" && record.typedefs !== null && !Array.isArray(record.typedefs)) {
+    for (const [id, frame] of Object.entries(record.typedefs)) {
+      typedefs[id] = clauses(frame);
+    }
+  }
+  const unknownFrames = Array.isArray(record.unknownFrames) ? record.unknownFrames.flatMap(
+    (f) => typeof f === "object" && f !== null && typeof f.type === "string" ? [{ type: f.type, clauses: clauses(f.clauses) }] : []
+  ) : [];
+  return { header: clauses(record.header), typedefs, unknownFrames };
+}
+function plan(snapshot, options) {
+  const common = resolveExportOptions(options);
+  const obo = resolveOboOptions(options);
+  const notes = [];
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  let fatal = null;
+  const { ids, originals, fatal: idFatal } = planIds(snapshot, common.sanitizeIds, note);
+  fatal ??= idFatal;
+  const folding = pairFolding(snapshot);
+  const { written: written2, edgeStart, edgeOrder, dst } = planEdges(snapshot, folding, common, note);
+  const frameless = framelessNodes(snapshot, written2, {
+    outgoingAllowed: false,
+    changed: (i) => originals.has(i)
+  });
+  const moved = movedNodes(
+    frameless,
+    Array.from(edgeOrder, (e) => dst[e])
+  );
+  if (moved > 0) {
+    note(
+      NODE_ORDER_CODE,
+      `${moved} node${plural(moved)} ${agree(moved, "reads", "read")} back at another position: placeholder nodes have no frame and read back after the written nodes`,
+      null,
+      moved
+    );
+  }
+  const rows = [];
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    if (frameless[i] === 0) {
+      rows.push(i);
+    }
+  }
+  const { kinds, type } = planKinds(snapshot, frameless);
+  const typedefNodes = rows.filter((i) => kinds[i] === "Typedef").length;
+  if (typedefNodes > 0) {
+    note(
+      OBO_LOSS.TYPEDEF_NODES,
+      `${typedefNodes} node${plural(typedefNodes)} ${agree(typedefNodes, "is", "are")} written as [Typedef] frames; they read back as nodes only when imported with typedefs: "nodes", and then after the other nodes, with the [Typedef] frames that declare the relations`,
+      "type",
+      typedefNodes
+    );
+  }
+  const kept = keptObo(snapshot);
+  const scopes = synonymTypeScopes(kept.header);
+  const labelSlot = slotColumn(snapshot.nodes, "label", "name");
+  const labelColumn = labelSlot.column;
+  const label = labelColumn !== null && rows.every((i) => !labelColumn.isSet(i) || isTrimmed(String(labelColumn.value(i)))) ? labelColumn : null;
+  const tags = planTags(snapshot, rows, kinds, scopes, label);
+  fatal ??= capabilityNotes(snapshot, common, {
+    caps: OBO_CAPABILITIES,
+    label,
+    labelAssumed: labelSlot.assumed,
+    edgeSlot: "a qualifier",
+    note
+  });
+  oboColumnNotes(snapshot, label, tags, note);
+  const properties = planProperties(snapshot, rows, frameless, label, tags, type, note);
+  const relationSlot = slotColumn(snapshot.edges, "kind", RELATION_COLUMN);
+  const relations = planRelations(snapshot, written2, relationSlot.column, obo.relation, note);
+  if (relationSlot.assumed && relationSlot.column !== null) {
+    note(
+      ROLE_ASSUMED_CODE,
+      `edge column "${RELATION_COLUMN}" has no role, so it is taken as the relation of each edge: it is written as each line's relation, and reads back with the relation role ("kind")`,
+      RELATION_COLUMN,
+      relationSlot.column.length - relationSlot.column.nullCount
+    );
+  }
+  const weights = explicitWeights(snapshot);
+  const { qualifiers, edgeColumns } = planEdgeColumns(snapshot, written2, relationSlot.column, weights, note);
+  emptyColumnNotes(snapshot, rows, frameless, written2, note);
+  const p = {
+    notes,
+    fatal,
+    options: obo,
+    ids,
+    originals,
+    frameless,
+    kinds,
+    label,
+    tags,
+    properties,
+    edgeStart,
+    edgeOrder,
+    dst,
+    relations,
+    qualifiers,
+    edgeColumns,
+    weights,
+    header: [],
+    tail: []
+  };
+  let stats = simulate(p, rows);
+  if (!stats.qualifiersPlaced) {
+    tags.delete("obo.qualifiers");
+    const column = snapshot.nodes.get("obo.qualifiers");
+    if (column !== null) {
+      properties.push({ column, relation: "obo.qualifiers" });
+      notePropertyColumn(note, column, rows, "property_value lines (relation obo.qualifiers)");
+    }
+    stats = simulate(p, rows);
+  }
+  if (stats.duplicates > 0) {
+    note(
+      OBO_LOSS.DUPLICATE_CLAUSE,
+      `${stats.duplicates} clause${plural(stats.duplicates)} ${agree(stats.duplicates, "repeats", "repeat")} another clause of their frame word for word (parallel edges with one relation and the same qualifiers, a repeated list item) and read back as one`,
+      null,
+      stats.duplicates
+    );
+  }
+  const header = planHeader(snapshot, kept.header, obo, rows, tags, note, stats);
+  const tail = planTail({
+    kept,
+    rows,
+    kinds,
+    ids,
+    properties,
+    relations,
+    edges: edgeOrder,
+    xref: tags.get("xref") ?? null
+  });
+  if (stats.lineEnds > 0) {
+    note(
+      OBO_LOSS.LINE_END,
+      `${stats.lineEnds} text${plural(stats.lineEnds)} ${agree(stats.lineEnds, "holds", "hold")} a carriage return or form feed, which OBO cannot carry; written as a line feed`,
+      null,
+      stats.lineEnds
+    );
+  }
+  return { ...p, header, tail };
+}
+function planTags(snapshot, rows, kinds, scopes, label) {
+  const tags = /* @__PURE__ */ new Map();
+  for (const name of TAG_COLUMNS) {
+    const column = snapshot.nodes.get(name);
+    if (column === null || column === label || column.meta.role !== null && column.meta.role !== "label") {
+      continue;
+    }
+    if (name === UNRECOGNIZED ? unrecognizedCarried(column, rows, kinds) : tagCarries(name, column, rows, kinds, scopes)) {
+      tags.set(name, column);
+    }
+  }
+  const def = tags.get("def");
+  const defXrefs = tags.get("def.xrefs");
+  if (defXrefs !== void 0 && (def === void 0 || rows.some((i) => def.isSet(i) !== defXrefs.isSet(i)))) {
+    tags.delete("def.xrefs");
+  }
+  if (def !== void 0 && !tags.has("def.xrefs") && snapshot.nodes.get("def.xrefs") !== null) {
+    tags.delete("def");
+  }
+  const descriptions = tags.get("xref.descriptions");
+  if (descriptions !== void 0 && !rows.every((i) => describedXrefsWritten(tags, descriptions, i))) {
+    tags.delete("xref.descriptions");
+  }
+  return tags;
+}
+function describedXrefsWritten(tags, descriptions, row) {
+  const map = cellOf(descriptions, row);
+  if (map === void 0) {
+    return true;
+  }
+  const written2 = /* @__PURE__ */ new Set();
+  const add = (values) => {
+    if (Array.isArray(values)) {
+      for (const v of values) {
+        if (typeof v === "string") {
+          written2.add(v);
+        }
+      }
+    }
+  };
+  for (const name of ["def.xrefs", "xref"]) {
+    const column = tags.get(name);
+    if (column !== void 0) {
+      add(cellOf(column, row));
+    }
+  }
+  for (const name of ["synonym", "expand_assertion_to", "expand_expression_to"]) {
+    const column = tags.get(name);
+    const items = column === void 0 ? void 0 : cellOf(column, row);
+    if (Array.isArray(items)) {
+      for (const item of items) {
+        add(item.xrefs);
+      }
+    }
+  }
+  return Object.keys(map).every((id) => written2.has(id));
+}
+function oboColumnNotes(snapshot, label, tags, note) {
+  for (const [name, column] of [...tags, ...label === null ? [] : [["name", label]]]) {
+    const want = name === "name" ? "string" : OBO_NODE_COLUMNS[name].dtype;
+    if ((want === "string" || want === "dict") && column.dtype !== want || column.dtype === "list" && column.child.dtype !== "string") {
+      const held = column.dtype === "list" ? `${column.child.dtype} items` : column.dtype;
+      note(
+        LOSS.DTYPE,
+        `node column "${column.meta.name}" holds ${held}; it reads back as ${column.dtype === "list" ? "string items" : want}`,
+        column.meta.name,
+        column.length - column.nullCount
+      );
+    }
+  }
+  for (const column of snapshot.graph) {
+    note(
+      GRAPH_COLUMN_AS_METADATA_CODE,
+      `graph column "${column.meta.name}" is written as a header property_value and reads back in meta.extra.obo.header, not as a column`,
+      column.meta.name,
+      column.length - column.nullCount
+    );
+  }
+}
+function planProperties(snapshot, rows, frameless, label, tags, type, note) {
+  const out = [];
+  const slotted = /* @__PURE__ */ new Set([
+    ...tags.values(),
+    ...label === null ? [] : [label],
+    ...type === null ? [] : [type]
+  ]);
+  for (const column of snapshot.nodes) {
+    const { role, name } = column.meta;
+    if (slotted.has(column) || role !== null && UNWRITTEN_ROLES.has(role)) {
+      continue;
+    }
+    if (name === PLACEHOLDER_COLUMN && rows.every((i) => !column.isSet(i)) && frameless.includes(1)) {
+      continue;
+    }
+    const relation = isOboWord(name) && name !== ORIGINAL_ID ? name : wordOf(name.replaceAll(":", "_"));
+    out.push({ column, relation });
+    notePropertyColumn(note, column, rows, `property_value lines (relation ${relation})`);
+  }
+  return out;
+}
+function planRelations(snapshot, written2, relation, fallback, note) {
+  const out = new Array(snapshot.edgeCount).fill(fallback);
+  let assumed = 0;
+  let renamed = 0;
+  for (const e of written2) {
+    const value = relation === null ? void 0 : cellOf(relation, e);
+    if (typeof value !== "string") {
+      assumed++;
+      continue;
+    }
+    if (isOboWord(value)) {
+      out[e] = value;
+    } else {
+      out[e] = wordOf(value);
+      renamed++;
+    }
+  }
+  if (assumed > 0) {
+    note(
+      OBO_LOSS.RELATION_ASSUMED,
+      `${assumed} edge${plural(assumed)} ${agree(assumed, "has", "have")} no relation; written as ${fallback} (an ontology reads is_a as subclassing)`,
+      relation?.meta.name ?? null,
+      assumed
+    );
+  }
+  if (renamed > 0) {
+    note(
+      OBO_LOSS.RELATION_RENAMED,
+      `${renamed} relation${plural(renamed)} ${agree(renamed, "is", "are")} not OBO ids; written with "_" in place of the space, "!", "{" or "}"`,
+      relation?.meta.name ?? null,
+      renamed
+    );
+  }
+  return out;
+}
+function planEdgeColumns(snapshot, written2, relation, weights, note) {
+  const qualifiers = qualifierRecords(snapshot, written2);
+  const edgeColumns = [];
+  const count = (column) => written2.filter((e) => column.isSet(e)).length;
+  const merged = qualifiers === null ? "" : " (merged with its values)";
+  for (const column of snapshot.edges) {
+    const { role, name } = column.meta;
+    if (column === relation || column === qualifiers || role === "id" || role !== null && UNWRITTEN_ROLES.has(role)) {
+      continue;
+    }
+    const written22 = isQualifierName(name) ? name : wordOf(name.replaceAll(/[=",[\]\\]/g, "_"));
+    edgeColumns.push({ column, name: written22 });
+    const n = count(column);
+    if (n > 0) {
+      note(
+        OBO_LOSS.EDGE_COLUMN_AS_QUALIFIER,
+        `edge column "${name}" is written as the qualifier ${written22} and reads back inside the qualifiers column${merged}`,
+        name,
+        n
+      );
+    }
+  }
+  const explicit = weights.weighted ? written2.filter((e) => weights.isExplicit(e)).length : 0;
+  if (explicit > 0) {
+    note(
+      OBO_LOSS.EDGE_COLUMN_AS_QUALIFIER,
+      `${explicit} explicit edge weight${plural(explicit)} ${agree(explicit, "is", "are")} written as the qualifier ${WEIGHT_QUALIFIER} and read back inside the qualifiers column, not as weights`,
+      snapshot.edges.byRole("weight")?.meta.name ?? null,
+      explicit
+    );
+  }
+  return { qualifiers, edgeColumns };
+}
+function qualifierRecords(snapshot, written2) {
+  const qualifiers = snapshot.edges.get(QUALIFIERS_COLUMN);
+  if (qualifiers?.dtype !== "json" || qualifiers.meta.role !== null) {
+    return null;
+  }
+  const records = written2.every(
+    (e) => !qualifiers.isSet(e) || isQualifierRecord(cellOf(qualifiers, e), isQualifierName)
+  );
+  return records ? qualifiers : null;
+}
+function planHeader(snapshot, kept, obo, rows, tags, note, stats) {
+  const { values, filled } = headerFields(snapshot, kept, obo.ontology, note);
+  const namespace = tags.get("namespace");
+  if (values.has("default-namespace") && (namespace === void 0 || rows.some((i) => !namespace.isSet(i)))) {
+    values.delete("default-namespace");
+  }
+  const lines = [];
+  const tagsInOrder = [
+    ...HEADER_ORDER.filter((t) => filled.has(t)),
+    ...[...values.keys()].filter((t) => !filled.has(t))
+  ];
+  for (const tag of tagsInOrder) {
+    for (const value of values.get(tag) ?? []) {
+      lines.push(`${escapeTag(tag)}: ${value}`);
+    }
+  }
+  if (lines.length === 0 && rows.length === 0) {
+    lines.push("format-version: 1.4");
+  }
+  for (const column of snapshot.graph) {
+    const relation = isOboWord(column.meta.name) ? column.meta.name : wordOf(column.meta.name);
+    for (const line of propertyLines({ column, relation }, 0, stats)) {
+      lines.push(`property_value: ${line}`);
+    }
+  }
+  return lines;
+}
+function headerFields(snapshot, kept, ontologyOption, note) {
+  const { meta } = snapshot;
+  const values = new Map(Object.entries(kept).map(([tag, v]) => [tag, v.map(rawValue)]));
+  const filled = /* @__PURE__ */ new Set();
+  const fill = (tag, value) => {
+    if (value !== null && !values.has(tag)) {
+      values.set(tag, [value]);
+      filled.add(tag);
+    }
+  };
+  if (meta.sourceFormat !== "obo") {
+    fill("format-version", "1.4");
+    fill("date", oboDate(meta.created));
+    fill("saved-by", meta.creator === null ? null : escapeOboValue(meta.creator));
+  }
+  const ontology = ontologyField(ontologyOption, meta.name, values.has("ontology"), note);
+  if (ontology !== null) {
+    if (!values.has("ontology")) {
+      filled.add("ontology");
+    }
+    values.set("ontology", [ontology]);
+  }
+  return { values, filled };
+}
+function ontologyField(option, name, kept, note) {
+  if (option !== null) {
+    return option;
+  }
+  if (name === null || name.length === 0 || kept) {
+    return null;
+  }
+  if (/^[A-Za-z0-9_.\-/]+$/.test(name)) {
+    return name;
+  }
+  const slug = name.replaceAll(/[^A-Za-z0-9_.-]/g, "_");
+  note(
+    OBO_LOSS.ONTOLOGY_NAME,
+    `the graph name ${JSON.stringify(name)} is not an ontology id; written as ${slug}`,
+    null,
+    null
+  );
+  return slug;
+}
+function rawValue(raw) {
+  return raw.replaceAll(/\r\n|\r|\n|\f/g, String.raw`\n`);
+}
+function escapeTag(tag) {
+  return escapeOboValue(tag).replaceAll(":", String.raw`\:`);
+}
+function oboDate(iso) {
+  const m = iso === null ? null : /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}))?/.exec(iso);
+  if (m === null) {
+    return null;
+  }
+  return `${m[3]}:${m[2]}:${m[1]} ${m[4] ?? "00"}:${m[5] ?? "00"}`;
+}
+function planTail(input) {
+  const { kept, rows, properties, relations } = input;
+  const lines = [];
+  const declared = nodeTypedefs(input);
+  keptTypedefLines(kept.typedefs, declared, lines);
+  const declare = (relation, metadata) => {
+    if (declared.has(relation)) {
+      return;
+    }
+    declared.add(relation);
+    lines.push("", "[Typedef]", `id: ${escapeOboWord(relation)}`, `name: ${escapeOboValue(relation)}`);
+    if (metadata) {
+      lines.push("is_metadata_tag: true");
+    }
+  };
+  const used = /* @__PURE__ */ new Set();
+  for (const e of input.edges) {
+    used.add(relations[e]);
+  }
+  for (const { column, relation } of properties) {
+    if (rows.some((i) => column.isSet(i))) {
+      declare(relation, true);
+    }
+  }
+  for (const relation of used) {
+    declare(relation, false);
+  }
+  for (const frame of kept.unknownFrames) {
+    lines.push("", `[${frame.type.replaceAll(/[\]\r\n]/g, "_")}]`, ...clauseLines(frame.clauses));
+  }
+  return lines;
+}
+function nodeTypedefs(input) {
+  const { rows, kinds, ids, xref } = input;
+  const declared = new Set(BUILTIN_RELATIONS);
+  for (const i of rows) {
+    if (kinds[i] !== "Typedef") {
+      continue;
+    }
+    declared.add(ids[i]);
+    const xrefs = xref === null ? void 0 : cellOf(xref, i);
+    for (const x of Array.isArray(xrefs) ? xrefs : []) {
+      declared.add(String(x));
+    }
+  }
+  return declared;
+}
+function keptTypedefLines(typedefs, declared, lines) {
+  for (const [id, clauses] of Object.entries(typedefs)) {
+    if (declared.has(id) && !BUILTIN_RELATIONS.has(id)) {
+      continue;
+    }
+    declared.add(id);
+    lines.push("", "[Typedef]", `id: ${escapeOboWord(id)}`, ...clauseLines(clauses, "id"));
+    for (const xref of clauses.xref ?? []) {
+      declared.add(xref.trim());
+    }
+  }
+}
+function clauseLines(clauses, skip = null) {
+  return Object.entries(clauses).filter(([tag]) => tag !== skip).flatMap(([tag, values]) => values.map((value) => `${escapeTag(tag)}: ${rawValue(value)}`));
+}
+class QualifierCursor {
+  /**
+   * Create a cursor.
+   * @param cell - the frame's `obo.qualifiers` cell, or undefined
+   */
+  constructor(cell) {
+    this.next = /* @__PURE__ */ new Map();
+    this.entries = cell ?? {};
+  }
+  /**
+   * The qualifier block of a clause: the next entry of its tag when that entry is for this value.
+   * @param tag - the tag (or `<tag>.xrefs` for an xref inside a list)
+   * @param value - the clause's value as the column holds it
+   * @returns the block with a leading space, or ""
+   */
+  block(tag, value) {
+    const list = Object.hasOwn(this.entries, tag) ? this.entries[tag] : void 0;
+    const k = this.next.get(tag) ?? 0;
+    if (list === void 0 || k >= list.length || list[k].value !== value) {
+      return "";
+    }
+    this.next.set(tag, k + 1);
+    return qualifierBlock(qualifierPairs(list[k].qualifiers));
+  }
+  /**
+   * Whether every entry found its clause.
+   * @returns true when all were placed
+   */
+  placed() {
+    return Object.entries(this.entries).every(([tag, list]) => (this.next.get(tag) ?? 0) === list.length);
+  }
+}
+function counted(s, text) {
+  if (hasLineEnd(text)) {
+    s.lineEnds++;
+  }
+  return text;
+}
+function xrefText(f, id, listTag) {
+  let out = escapeOboValue(counted(f.stats, id));
+  const descriptions = f.p.tags.get("xref.descriptions");
+  const map = descriptions === void 0 ? void 0 : cellOf(descriptions, f.row);
+  if (map !== void 0 && Object.hasOwn(map, id) && !f.described.has(id)) {
+    f.described.add(id);
+    out += ` "${escapeOboQuoted(counted(f.stats, map[id]))}"`;
+  }
+  if (listTag !== null) {
+    out += f.cursor.block(listTag, id);
+  }
+  return out;
+}
+function xrefList(f, ids, tag) {
+  const field = `${tag}.xrefs`;
+  return `[${ids.map((id) => xrefText(f, id, field)).join(", ")}]`;
+}
+function propertyLines(prop, row, stats) {
+  const { column, relation } = prop;
+  const value = cellOf(column, row);
+  if (value === void 0) {
+    return [];
+  }
+  const head = escapeOboWord(relation);
+  const one = (v, dtype) => {
+    let text;
+    let xsd = XSD[dtype] ?? "xsd:string";
+    if (typeof v === "number" && xsd === "xsd:double") {
+      text = xsdDouble(v, dtype);
+    } else if (typeof v === "string" || typeof v === "boolean" || typeof v === "number") {
+      text = textOf(v, dtype);
+    } else {
+      text = JSON.stringify(v) ?? "null";
+      xsd = "xsd:string";
+    }
+    return `${head} "${escapeOboQuoted(counted(stats, text))}" ${xsd}`;
+  };
+  if (column.dtype === "list") {
+    return value.map((item) => one(item, column.child.dtype));
+  }
+  if (column.dtype === "json" || column.meta.components > 1) {
+    return [one(value, "json")];
+  }
+  return [one(value, column.dtype)];
+}
+function xsdDouble(v, dtype) {
+  if (Number.isNaN(v)) {
+    return "NaN";
+  }
+  if (!Number.isFinite(v)) {
+    return v > 0 ? "INF" : "-INF";
+  }
+  return formatNumber(v, dtype === "f32" ? "f32" : "f64");
+}
+function edgeQualifiers(f, e) {
+  const { p } = f;
+  const pairs = [];
+  if (p.qualifiers !== null) {
+    const record = cellOf(p.qualifiers, e);
+    if (record !== void 0) {
+      pairs.push(...qualifierPairs(record));
+    }
+  }
+  for (const { column, name } of p.edgeColumns) {
+    pairs.push(...qualifierTexts(column, e).map((text) => [name, text]));
+  }
+  const weight = p.weights.text(e);
+  if (weight !== null) {
+    pairs.push([WEIGHT_QUALIFIER, weight]);
+  }
+  for (const [, value] of pairs) {
+    counted(f.stats, value);
+  }
+  return qualifierBlock(pairs);
+}
+function qualifierTexts(column, e) {
+  const value = cellOf(column, e);
+  if (value === void 0) {
+    return [];
+  }
+  if (column.dtype === "list") {
+    return value.map((item) => textOf(item, column.child.dtype));
+  }
+  return [column.dtype === "json" ? JSON.stringify(value) ?? "null" : textOf(value, column.dtype)];
+}
+function tagLines(f, tag, column, out) {
+  const value = cellOf(column, f.row);
+  if (value === void 0) {
+    return;
+  }
+  const { cursor, stats } = f;
+  const push = (text, stored, raw = false) => {
+    out.push(`${tag}: ${raw ? text : escapeOboValue(counted(stats, text))}${cursor.block(tag, stored)}`);
+  };
+  if (TEXT_TAGS.has(tag)) {
+    push(value, value);
+    return;
+  }
+  if (BOOL_TAGS.has(tag)) {
+    push(value ? "true" : "false", value ? "true" : "false", true);
+    return;
+  }
+  if (ID_LIST_TAGS.has(tag)) {
+    for (const id of value) {
+      push(escapeOboWord(id), id, true);
+    }
+    return;
+  }
+  if (Object.hasOwn(STRUCTURED_TAGS, tag)) {
+    STRUCTURED_TAGS[tag](f, tag, value, out);
+  }
+}
+function blockOf(qualifiers) {
+  return qualifiers === void 0 ? "" : qualifierBlock(qualifierPairs(qualifiers));
+}
+const STRUCTURED_TAGS = {
+  def(f, _tag, value, out) {
+    const xrefs = f.p.tags.get("def.xrefs");
+    const ids = xrefs === void 0 ? [] : cellOf(xrefs, f.row) ?? [];
+    const text = value;
+    out.push(
+      `def: "${escapeOboQuoted(counted(f.stats, text))}" ${xrefList(f, ids, "def")}${f.cursor.block("def", text)}`
+    );
+  },
+  xref(f, _tag, value, out) {
+    for (const id of value) {
+      out.push(`xref: ${xrefText(f, id, null)}${f.cursor.block("xref", id)}`);
+    }
+  },
+  synonym(f, _tag, value, out) {
+    for (const s of value) {
+      const type = s.type === null ? "" : ` ${escapeOboWord(s.type)}`;
+      out.push(
+        `synonym: "${escapeOboQuoted(counted(f.stats, s.text))}" ${s.scope}${type} ${xrefList(f, s.xrefs, "synonym")}${blockOf(s.qualifiers)}`
+      );
+    }
+  },
+  intersection_of(_f, _tag, value, out) {
+    for (const x of value) {
+      const relation = x.relation === null ? "" : `${escapeOboWord(x.relation)} `;
+      out.push(`intersection_of: ${relation}${escapeOboWord(x.target)}${blockOf(x.qualifiers)}`);
+    }
+  },
+  property_value(f, _tag, value, out) {
+    for (const x of value) {
+      const datatype = x.datatype === null ? "" : ` ${escapeOboWord(x.datatype)}`;
+      const literal = x.datatype === null && isOboWord(x.value) ? escapeOboWord(x.value) : `"${escapeOboQuoted(counted(f.stats, x.value))}"${datatype}`;
+      out.push(`property_value: ${escapeOboWord(x.relation)} ${literal}${blockOf(x.qualifiers)}`);
+    }
+  },
+  holds_over_chain: chainLines,
+  equivalent_to_chain: chainLines,
+  expand_assertion_to: expansionLines,
+  expand_expression_to: expansionLines,
+  [UNRECOGNIZED](f, _tag, value, out) {
+    for (const [unknown, values] of Object.entries(value)) {
+      for (const v of values) {
+        out.push(`${escapeTag(unknown)}: ${escapeOboValue(counted(f.stats, v))}`);
+      }
+    }
+  }
+};
+function chainLines(f, tag, value, out) {
+  for (const [a, b] of value) {
+    const pair = `${a} ${b}`;
+    out.push(`${tag}: ${escapeOboWord(a)} ${escapeOboWord(b)}${f.cursor.block(tag, pair)}`);
+  }
+}
+function expansionLines(f, tag, value, out) {
+  for (const x of value) {
+    out.push(
+      `${tag}: "${escapeOboQuoted(counted(f.stats, x.template))}" ${xrefList(f, x.xrefs, tag)}${blockOf(x.qualifiers)}`
+    );
+  }
+}
+function frameLines(p, row, stats) {
+  const qualifiersColumn = p.tags.get("obo.qualifiers");
+  const f = {
+    p,
+    row,
+    cursor: new QualifierCursor(qualifiersColumn === void 0 ? void 0 : cellOf(qualifiersColumn, row)),
+    described: /* @__PURE__ */ new Set(),
+    stats
+  };
+  const out = [`[${p.kinds[row]}]`, `id: ${escapeOboWord(p.ids[row])}`];
+  for (const tag of TAG_ORDER) {
+    if (tag === "name") {
+      nameLine(f, out);
+    } else if (tag === "property_value") {
+      propertyValueLines(f, out);
+    } else if (tag === EDGES) {
+      edgeLines(f, out);
+    } else {
+      const column = p.tags.get(tag);
+      if (column !== void 0) {
+        tagLines(f, tag, column, out);
+      }
+    }
+  }
+  stats.qualifiersPlaced &&= f.cursor.placed();
+  return out;
+}
+function nameLine(f, out) {
+  const name = f.p.label === null ? void 0 : cellOf(f.p.label, f.row);
+  if (typeof name === "string") {
+    out.push(`name: ${escapeOboValue(counted(f.stats, name))}${f.cursor.block("name", name)}`);
+  }
+}
+function propertyValueLines(f, out) {
+  const { p, row } = f;
+  const original = p.originals.get(row);
+  if (original !== void 0) {
+    out.push(`property_value: ${ORIGINAL_ID} "${escapeOboQuoted(JSON.stringify(original))}" xsd:string`);
+  }
+  const column = p.tags.get("property_value");
+  if (column !== void 0) {
+    tagLines(f, "property_value", column, out);
+  }
+  for (const prop of p.properties) {
+    for (const line of propertyLines(prop, row, f.stats)) {
+      out.push(`property_value: ${line}`);
+    }
+  }
+}
+function edgeLines(f, out) {
+  const { p, row } = f;
+  for (let k = p.edgeStart[row]; k < p.edgeStart[row + 1]; k++) {
+    const e = p.edgeOrder[k];
+    const target = escapeOboWord(p.ids[p.dst[e]]);
+    const relation = p.relations[e];
+    const block = edgeQualifiers(f, e);
+    if (relation === "is_a" || relation === "instance_of" && p.kinds[row] === "Instance") {
+      out.push(`${relation}: ${target}${block}`);
+    } else {
+      out.push(`relationship: ${escapeOboWord(relation)} ${target}${block}`);
+    }
+  }
+}
+function simulate(p, rows) {
+  const stats = { lineEnds: 0, qualifiersPlaced: true, duplicates: 0 };
+  for (const i of rows) {
+    const lines = frameLines(p, i, stats);
+    const seen = /* @__PURE__ */ new Set();
+    for (let k = 2; k < lines.length; k++) {
+      if (seen.has(lines[k])) {
+        stats.duplicates++;
+      }
+      seen.add(lines[k]);
+    }
+  }
+  return stats;
+}
+function* write(p) {
+  if (p.fatal !== null) {
+    throw p.fatal;
+  }
+  yield p.header.map((line) => `${line}
+`).join("");
+  const stats = { lineEnds: 0, qualifiersPlaced: true };
+  for (let i = 0; i < p.ids.length; i++) {
+    if (p.frameless[i] === 0) {
+      yield `
+${frameLines(p, i, stats).join("\n")}
+`;
+    }
+  }
+  if (p.tail.length > 0) {
+    yield `${p.tail.join("\n")}
+`;
+  }
+}
+function* written(snapshot, options) {
+  yield* write(plan(snapshot, options));
+}
+const oboExporter = Object.freeze({
+  format: "obo",
+  options: Object.freeze(["ontology", "relation"]),
+  capabilities: OBO_CAPABILITIES,
+  /**
+   * Pre-flight: what export() would lose, without writing anything.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    return Object.freeze([...plan(snapshot, options).notes]);
+  },
+  /**
+   * Write the file as UTF-8 chunks.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the chunks
+   */
+  export(snapshot, options) {
+    return encodeChunks(written(snapshot, options));
+  },
+  /**
+   * Write the file as one string.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the file
+   */
+  exportToString(snapshot, options) {
+    return joinText(written(snapshot, options));
+  }
+});
+export {
+  OBO_CAPABILITIES as O,
+  OBO_ISSUE as a,
+  OBO_LOSS as b,
+  oboImporter as c,
+  oboExporter as o
+};
+//# sourceMappingURL=exporter-BMqk5oxW.js.map