@graphty/graph-io 0.0.0 → 0.2.1

package/dist/chunks/writer-DxSKC7TL.js

@@ -0,0 +1,2842 @@
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+const MISSING_ID_CODE = "E_MISSING_ID";
+const MISSING_ENDPOINT_CODE = "E_MISSING_ENDPOINT";
+const DUPLICATE_NODE_CODE = "W_DUPLICATE_NODE";
+const NO_GRAPH_CODE = "E_NO_GRAPH";
+const MULTIPLE_GRAPHS_CODE = "W_MULTIPLE_GRAPHS";
+const EMPTY_INPUT_CODE = "E_EMPTY_INPUT";
+const SYNTAX_CODE = "E_SYNTAX";
+const XML_SYNTAX_CODE = "E_XML_SYNTAX";
+const UNKNOWN_ELEMENT_CODE = "W_UNKNOWN_ELEMENT";
+const STRAY_TEXT_CODE = "W_STRAY_TEXT";
+const UNKNOWN_PARENT_CODE = "E_UNKNOWN_PARENT";
+const HYPEREDGE_CODE = "E_HYPEREDGE";
+const DUPLICATE_KEY_CODE = "E_DUPLICATE_KEY";
+const COLUMN_RENAMED_CODE = "W_COLUMN_RENAMED";
+const ROLE_TAKEN_CODE = "W_ROLE_TAKEN";
+const PRECISION_CODE = "W_PRECISION";
+const ID_MERGED_CODE = "W_ID_MERGED";
+const SINK_OPTION_CODE = "W_SINK_OPTION";
+const OPTION_IGNORED_CODE = "W_OPTION_IGNORED";
+const INVALID_UTF8_CODE = "E_INVALID_UTF8";
+const DIRECTION_REFUSED_CODE = "W_DIRECTION_REFUSED";
+const DIRECTION_FORCED_CODE = "W_DIRECTION_FORCED";
+const MIXED_DIRECTION_CODE = "E_MIXED_DIRECTION";
+const COUNT_HINT_CODE = "W_COUNT_HINT";
+const UNKNOWN_ATTR_TYPE_CODE = "W_UNKNOWN_ATTR_TYPE";
+const BAD_DEFAULT_CODE = "W_BAD_DEFAULT";
+const BAD_OPTIONS_CODE = "W_BAD_OPTIONS";
+const DUPLICATE_EDGE_ID_CODE = "E_DUPLICATE_EDGE_ID";
+const ROLE_DROPPED_CODE = "W_ROLE_DROPPED";
+const PARENTS_DROPPED_CODE = "W_PARENTS_DROPPED";
+const TEMPORAL_DROPPED_CODE = "W_TEMPORAL_DROPPED";
+const MUTUAL_EXPANDED_CODE = "W_MUTUAL_EXPANDED";
+const MUTUAL_AS_UNDIRECTED_CODE = "W_MUTUAL_AS_UNDIRECTED";
+const ID_TEXT_TYPE_CODE = "W_ID_TEXT_TYPE";
+const ID_TEXT_COLLISION_CODE = "E_ID_TEXT_COLLISION";
+const TEMPORAL_TEXT_DROPPED_CODE = "W_TEMPORAL_TEXT_DROPPED";
+const WEIGHT_KEY_CLASH_CODE = "W_WEIGHT_KEY_CLASH";
+const ROLE_ASSUMED_CODE = "W_ROLE_ASSUMED";
+const COLUMN_RENAMED_LOSS_CODE = "W_COLUMN_NAME_CHANGED";
+const EMPTY_COLUMN_DROPPED_CODE = "W_EMPTY_COLUMN_DROPPED";
+const STORAGE_CLASS_CODE = "W_STORAGE_CLASS_CHANGED";
+const INTEGRAL_F64_CODE = "W_INTEGRAL_F64_AS_I32";
+const TEXT_INFERRED_CODE = "W_TEXT_INFERRED";
+const XML_ILLEGAL_CHAR_CODE = "E_XML_ILLEGAL_CHAR";
+const OPTIONS_GAINED_CODE = "W_OPTIONS_GAINED";
+const TIME_TEXT_ROLE = "timeText";
+const TIME_TEXT_SUFFIX = ".text";
+const DATE_TIME$1 = /^(-?[0-9]{4,})-([0-9]{2})-([0-9]{2})(?:[T ]([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\.([0-9]{1,9}))?)?)?(Z|z|[+-][0-9]{2}(?::?[0-9]{2})?)?$/;
+const TIME$1 = /^([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\.([0-9]{1,9}))?)?(Z|z|[+-][0-9]{2}(?::?[0-9]{2})?)?$/;
+const NUMERIC = /^[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?$/;
+const MS_PER_MINUTE = 6e4;
+const MS_PER_DAY = 864e5;
+function parseTemporal(text, kind) {
+  let value;
+  switch (kind) {
+    case "date":
+    case "dateTime":
+    case "localDateTime":
+      value = parseDateTime(text, kind);
+      break;
+    case "time":
+    case "localTime":
+      value = parseTime(text, kind);
+      break;
+    default: {
+      const name = kind;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown temporal kind ${name}`, { kind: name });
+    }
+  }
+  const canonical = formatTemporal(value, kind);
+  return { value, text: canonical === text ? null : text };
+}
+function parseTimeText(text, timeFormat) {
+  const trimmed = text.trim();
+  switch (timeFormat) {
+    case "integer":
+    case "double":
+      return parseNumericTime(trimmed);
+    case "date":
+      return parseTemporal(trimmed, "date");
+    case "dateTime":
+      return parseTemporal(trimmed, "dateTime");
+    case null:
+      return NUMERIC.test(trimmed) ? parseNumericTime(trimmed) : parseTemporal(trimmed, "dateTime");
+    default: {
+      const name = timeFormat;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown timeformat ${name}`, { timeFormat: name });
+    }
+  }
+}
+function formatTemporal(value, kind) {
+  switch (kind) {
+    case "date": {
+      const d = new Date(value);
+      return `${year(d)}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+    }
+    case "dateTime":
+    case "localDateTime": {
+      const d = new Date(value);
+      const date = `${year(d)}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+      const time = clock(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+      return kind === "dateTime" ? `${date}T${time}Z` : `${date}T${time}`;
+    }
+    case "time":
+    case "localTime": {
+      const ms = (value % MS_PER_DAY + MS_PER_DAY) % MS_PER_DAY;
+      const h = Math.floor(ms / 36e5);
+      const m = Math.floor(ms % 36e5 / MS_PER_MINUTE);
+      const s = Math.floor(ms % MS_PER_MINUTE / 1e3);
+      const text = clock(h, m, s, ms % 1e3);
+      return kind === "time" ? `${text}Z` : text;
+    }
+    default: {
+      const name = kind;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown temporal kind ${name}`, { kind: name });
+    }
+  }
+}
+function formatTimeValue(value, timeFormat) {
+  switch (timeFormat) {
+    case "date":
+      return formatTemporal(value, "date");
+    case "dateTime":
+      return formatTemporal(value, "dateTime");
+    case "integer":
+    case "double":
+    case null:
+      return String(value);
+    default: {
+      const name = timeFormat;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown timeformat ${name}`, { timeFormat: name });
+    }
+  }
+}
+function timeTextCompanion(column) {
+  return {
+    name: column + TIME_TEXT_SUFFIX,
+    dtype: "string",
+    role: TIME_TEXT_ROLE,
+    nullable: true,
+    extra: { for: column }
+  };
+}
+function parseNumericTime(text) {
+  if (!NUMERIC.test(text)) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is not a numeric time`, { value: text });
+  }
+  const value = Number(text);
+  return { value, text: String(value) === text ? null : text };
+}
+function parseDateTime(text, kind) {
+  const m = DATE_TIME$1.exec(text);
+  if (m === null) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is not an ISO-8601 ${kind}`, { value: text, kind });
+  }
+  const y = Number(m[1]);
+  const month = Number(m[2]);
+  const day = Number(m[3]);
+  const hour = m[4] === void 0 ? 0 : Number(m[4]);
+  const minute = m[5] === void 0 ? 0 : Number(m[5]);
+  const second = m[6] === void 0 ? 0 : Number(m[6]);
+  const ms = m[7] === void 0 ? 0 : fractionMs(m[7]);
+  if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 24 || minute > 59 || second > 60) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is out of range for a ${kind}`, { value: text, kind });
+  }
+  const d = /* @__PURE__ */ new Date(0);
+  d.setUTCFullYear(y, month - 1, day);
+  d.setUTCHours(hour, minute, second, ms);
+  if (d.getUTCDate() !== day && hour !== 24) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is not a calendar date`, { value: text, kind });
+  }
+  const offset = m[8] === void 0 ? 0 : offsetMinutes(m[8]);
+  return d.getTime() - offset * MS_PER_MINUTE;
+}
+function parseTime(text, kind) {
+  const m = TIME$1.exec(text);
+  if (m === null) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is not an ISO-8601 ${kind}`, { value: text, kind });
+  }
+  const hour = Number(m[1]);
+  const minute = Number(m[2]);
+  const second = m[3] === void 0 ? 0 : Number(m[3]);
+  const ms = m[4] === void 0 ? 0 : fractionMs(m[4]);
+  if (hour > 24 || minute > 59 || second > 60) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${text}" is out of range for a ${kind}`, { value: text, kind });
+  }
+  const local = ((hour * 60 + minute) * 60 + second) * 1e3 + ms;
+  const offset = m[5] === void 0 ? 0 : offsetMinutes(m[5]);
+  const utc = local - offset * MS_PER_MINUTE;
+  return (utc % MS_PER_DAY + MS_PER_DAY) % MS_PER_DAY;
+}
+function fractionMs(digits) {
+  return Math.floor(Number(`0.${digits}`) * 1e3);
+}
+function offsetMinutes(zone) {
+  if (zone === "Z" || zone === "z") {
+    return 0;
+  }
+  const sign = zone.startsWith("-") ? -1 : 1;
+  const digits = zone.slice(1).replace(":", "");
+  const hours = Number(digits.slice(0, 2));
+  const minutes = digits.length > 2 ? Number(digits.slice(2, 4)) : 0;
+  return sign * (hours * 60 + minutes);
+}
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function year(d) {
+  const y = d.getUTCFullYear();
+  const abs = String(Math.abs(y)).padStart(4, "0");
+  return y < 0 ? `-${abs}` : abs;
+}
+function clock(h, m, s, ms) {
+  const base = `${pad2(h)}:${pad2(m)}:${pad2(s)}`;
+  return ms === 0 ? base : `${base}.${String(ms).padStart(3, "0")}`;
+}
+const BOOLEAN = { dtype: "bool", kind: "boolean" };
+const INTEGER = { dtype: "i32", kind: "integer" };
+const LONG = { dtype: "f64", kind: "long", precision: true };
+const FLOAT = { dtype: "f32", kind: "float" };
+const DOUBLE = { dtype: "f64", kind: "double" };
+const STRING = { dtype: "string", kind: "string" };
+const DATE = { dtype: "f64", kind: "temporal", temporal: "date" };
+const DATE_TIME = { dtype: "f64", kind: "temporal", temporal: "dateTime" };
+const LOCAL_DATE_TIME = { dtype: "f64", kind: "temporal", temporal: "localDateTime" };
+const TIME = { dtype: "f64", kind: "temporal", temporal: "time" };
+const LOCAL_TIME = { dtype: "f64", kind: "temporal", temporal: "localTime" };
+const DURATION = { dtype: "string", kind: "duration" };
+const POINT = { dtype: "json", kind: "point" };
+const RECORD = { dtype: "json", kind: "json" };
+const GEXF_SCALARS = {
+  integer: INTEGER,
+  long: LONG,
+  double: DOUBLE,
+  float: FLOAT,
+  boolean: BOOLEAN,
+  string: STRING,
+  anyuri: STRING,
+  char: STRING,
+  byte: INTEGER,
+  short: INTEGER,
+  bigdecimal: STRING,
+  biginteger: STRING,
+  date: DATE,
+  datetime: DATE_TIME
+};
+const GRAPHML_SCALARS = {
+  boolean: BOOLEAN,
+  int: INTEGER,
+  long: LONG,
+  float: FLOAT,
+  double: DOUBLE,
+  string: STRING
+};
+const GML_SCALARS = {
+  int: INTEGER,
+  real: DOUBLE,
+  string: STRING,
+  record: RECORD
+};
+const NEO4J_SCALARS = {
+  int: INTEGER,
+  integer: LONG,
+  long: LONG,
+  float: FLOAT,
+  double: DOUBLE,
+  boolean: BOOLEAN,
+  byte: INTEGER,
+  short: INTEGER,
+  char: STRING,
+  string: STRING,
+  point: POINT,
+  date: DATE,
+  localtime: LOCAL_TIME,
+  time: TIME,
+  localdatetime: LOCAL_DATE_TIME,
+  datetime: DATE_TIME,
+  duration: DURATION
+};
+const TABLES = {
+  gexf: GEXF_SCALARS,
+  graphml: GRAPHML_SCALARS,
+  gml: GML_SCALARS,
+  neo4j: NEO4J_SCALARS
+};
+const INTEGER_TEXT$1 = /^[+-]?[0-9]+$/;
+const DECIMAL_TEXT = /^[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?$/;
+const I32_MIN = -2147483648;
+const I32_MAX = 2147483647;
+function mapDeclaredType(format, type, long) {
+  const table = TABLES[format];
+  let key = type.trim().toLowerCase();
+  let list2 = false;
+  if (format === "gexf" && key.startsWith("list") && key.length > 4) {
+    list2 = true;
+    key = key.slice(4);
+  } else if (format === "neo4j" && key.endsWith("[]")) {
+    list2 = true;
+    key = key.slice(0, -2);
+  } else if (format === "gml" && key === "list") {
+    return {
+      declared: type,
+      dtype: "list",
+      itemDtype: "json",
+      kind: "json",
+      list: true,
+      temporal: null,
+      precision: false
+    };
+  }
+  let entry = table[key];
+  if (entry === void 0) {
+    return null;
+  }
+  if (entry.kind === "long" && long === "string") {
+    entry = STRING;
+  }
+  return {
+    declared: type,
+    dtype: list2 ? "list" : entry.dtype,
+    itemDtype: list2 ? entry.dtype : null,
+    kind: entry.kind,
+    list: list2,
+    temporal: entry.temporal ?? null,
+    precision: entry.precision ?? false
+  };
+}
+function stringSpec(declared) {
+  return {
+    declared: declared ?? "",
+    dtype: "string",
+    itemDtype: null,
+    kind: "string",
+    list: false,
+    temporal: null,
+    precision: false
+  };
+}
+function parseScalarText(text, kind, temporal = null) {
+  switch (kind) {
+    case "boolean": {
+      const value = parseBooleanText(text);
+      if (value === null) {
+        throw typeError(text, kind);
+      }
+      return value;
+    }
+    case "integer": {
+      const trimmed = text.trim();
+      if (!INTEGER_TEXT$1.test(trimmed)) {
+        throw typeError(text, kind);
+      }
+      const value = Number(trimmed);
+      if (value < I32_MIN || value > I32_MAX) {
+        throw new GraphFormatError("E_COLUMN_TYPE", `"${trimmed}" is outside the 32-bit integer range`, {
+          value: trimmed,
+          kind
+        });
+      }
+      return value;
+    }
+    case "long": {
+      const trimmed = text.trim();
+      if (!INTEGER_TEXT$1.test(trimmed)) {
+        throw typeError(text, kind);
+      }
+      return Number(trimmed);
+    }
+    case "float":
+    case "double":
+      return parseDecimalText(text, kind);
+    case "string":
+    case "duration":
+      return text;
+    case "temporal": {
+      if (temporal === null) {
+        throw new GraphFormatError("E_COLUMN_TYPE", "a temporal value needs its temporal kind", { kind });
+      }
+      return parseTemporal(text.trim(), temporal).value;
+    }
+    case "point":
+      return parsePointText(text);
+    case "json":
+      return parseJsonText(text);
+    default: {
+      const name = kind;
+      throw new GraphFormatError("E_COLUMN_TYPE", `unknown value kind ${name}`, { kind: name });
+    }
+  }
+}
+function parseBooleanText(text) {
+  switch (text.trim().toLowerCase()) {
+    case "true":
+    case "1":
+      return true;
+    case "false":
+    case "0":
+      return false;
+    default:
+      return null;
+  }
+}
+function parseDecimalText(text, kind = "double") {
+  const trimmed = text.trim();
+  if (DECIMAL_TEXT.test(trimmed)) {
+    return Number(trimmed);
+  }
+  switch (trimmed) {
+    case "INF":
+    case "+INF":
+    case "Infinity":
+    case "+Infinity":
+      return Infinity;
+    case "-INF":
+    case "-Infinity":
+      return -Infinity;
+    case "NaN":
+      return NaN;
+    default:
+      throw typeError(text, kind);
+  }
+}
+function parsePointText(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    throw typeError(text, "point");
+  }
+  const out = {};
+  const inner = trimmed.slice(1, -1).trim();
+  if (inner.length === 0) {
+    return out;
+  }
+  for (const part of inner.split(",")) {
+    const colon = part.indexOf(":");
+    if (colon < 0) {
+      throw typeError(text, "point");
+    }
+    const key = part.slice(0, colon).trim().replace(/^["']|["']$/g, "");
+    const raw = part.slice(colon + 1).trim();
+    if (key.length === 0) {
+      throw typeError(text, "point");
+    }
+    if (DECIMAL_TEXT.test(raw)) {
+      out[key] = Number(raw);
+    } else if (raw.startsWith("'") && raw.endsWith("'") || raw.startsWith('"') && raw.endsWith('"')) {
+      out[key] = raw.slice(1, -1);
+    } else {
+      throw typeError(text, "point");
+    }
+  }
+  return out;
+}
+function parseJsonText(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw typeError(text, "json");
+  }
+}
+function typeError(text, kind) {
+  const shown = text.length > 40 ? `${text.slice(0, 40)}...` : text;
+  return new GraphFormatError("E_COLUMN_TYPE", `"${shown}" is not a ${kind}`, { value: text, kind });
+}
+function splitListText(text, syntax) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  switch (syntax) {
+    case "gexf": {
+      if (isBracketed(trimmed)) {
+        return splitBracketed(trimmed);
+      }
+      const separator = firstSeparator(trimmed, ["|", ",", ";"]);
+      return separator === null ? [trimmed] : splitOn(trimmed, separator);
+    }
+    case "brackets":
+      return isBracketed(trimmed) ? splitBracketed(trimmed) : [trimmed];
+    case "pipe":
+      return splitOn(trimmed, "|");
+    case "comma":
+      return splitOn(trimmed, ",");
+    case "semicolon":
+      return splitOn(trimmed, ";");
+    default: {
+      const name = syntax;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown list syntax ${name}`, {
+        option: "listSyntax",
+        found: name
+      });
+    }
+  }
+}
+function joinListText(items, syntax) {
+  switch (syntax) {
+    case "gexf":
+    case "brackets":
+      return `[${items.map(quoteBracketItem).join(", ")}]`;
+    case "pipe":
+      return items.join("|");
+    case "comma":
+      return items.join(",");
+    case "semicolon":
+      return items.join(";");
+    default: {
+      const name = syntax;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown list syntax ${name}`, {
+        option: "listSyntax",
+        found: name
+      });
+    }
+  }
+}
+function isBracketed(text) {
+  return text.length >= 2 && text.startsWith("[") && text.endsWith("]");
+}
+function firstSeparator(text, candidates) {
+  for (const candidate of candidates) {
+    if (text.includes(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function splitOn(text, separator) {
+  return text.split(separator).map((item) => item.trim());
+}
+function splitBracketed(text) {
+  const inner = text.slice(1, -1);
+  const items = [];
+  const n = inner.length;
+  if (inner.trim().length === 0) {
+    return items;
+  }
+  let i = 0;
+  for (; ; ) {
+    while (i < n && isSpace(inner.charCodeAt(i))) {
+      i++;
+    }
+    let item = "";
+    if (i < n && (inner[i] === '"' || inner[i] === "'")) {
+      const quote = inner[i];
+      i++;
+      while (i < n) {
+        if (inner[i] === quote) {
+          if (inner[i + 1] === quote) {
+            item += quote;
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        item += inner[i];
+        i++;
+      }
+    }
+    let end = inner.indexOf(",", i);
+    if (end < 0) {
+      end = n;
+    }
+    item += inner.slice(i, end).trim();
+    items.push(item);
+    i = end;
+    if (i >= n) {
+      return items;
+    }
+    i++;
+    if (inner.slice(i).trim().length === 0) {
+      items.push("");
+      return items;
+    }
+  }
+}
+function isSpace(c) {
+  return c === 32 || c === 9 || c === 13 || c === 10;
+}
+function quoteBracketItem(item) {
+  if (item.length === 0 || /[,[\]"']/.test(item) || item !== item.trim()) {
+    return `"${item.replace(/"/g, '""')}"`;
+  }
+  return item;
+}
+const UNKNOWN_TYPE_CODE = UNKNOWN_ATTR_TYPE_CODE;
+const RENAMED_CODE = COLUMN_RENAMED_CODE;
+const DICT_SAMPLE_ROWS = 1024;
+function declareAttribute(input) {
+  const issues = [];
+  const listSyntax = input.listSyntax ?? "gexf";
+  let spec;
+  if (input.type === null) {
+    spec = stringSpec(null);
+  } else {
+    const mapped = mapDeclaredType(input.format, input.type, input.long);
+    if (mapped === null) {
+      spec = stringSpec(input.type);
+      issues.push({
+        category: "unsupported",
+        code: UNKNOWN_TYPE_CODE,
+        message: `${input.format} type "${input.type}" is not supported; values kept as text`
+      });
+    } else {
+      spec = mapped;
+    }
+  }
+  const { name, renamed } = resolveName(input);
+  if (renamed) {
+    issues.push({
+      category: "coercion",
+      code: RENAMED_CODE,
+      message: `attribute "${input.title ?? input.id ?? ""}" renamed to "${name}": the name was taken`
+    });
+  }
+  const decl = {
+    name,
+    dtype: spec.dtype,
+    nullable: true,
+    origin: {
+      format: input.format,
+      id: input.id,
+      title: input.title !== null && input.title !== name ? input.title : null,
+      type: input.type,
+      namespace: input.namespace ?? null
+    }
+  };
+  if (spec.list) {
+    decl.itemDtype = spec.itemDtype ?? "string";
+  }
+  if (input.role !== void 0 && input.role !== null) {
+    decl.role = input.role;
+  }
+  if (input.dynamic === true) {
+    decl.dynamic = true;
+  }
+  const optionsText = input.optionsText ?? null;
+  if (optionsText !== null) {
+    try {
+      const options = splitListText(optionsText, listSyntax).map((item) => parseItem(item, spec));
+      decl.options = options;
+      if (spec.dtype === "string" && !spec.list && options.every((o) => typeof o === "string")) {
+        decl.dtype = "dict";
+        spec = { ...spec, dtype: "dict" };
+      }
+    } catch (err) {
+      issues.push({
+        category: "validation-error",
+        code: BAD_OPTIONS_CODE,
+        message: `options "${optionsText}" of attribute "${name}" do not parse as ${spec.declared}: ${messageOf(err)}`
+      });
+    }
+  }
+  const defaultText = input.defaultText ?? null;
+  if (defaultText !== null) {
+    try {
+      decl.default = parseDeclaredValue(defaultText, spec, listSyntax);
+    } catch (err) {
+      issues.push({
+        category: "validation-error",
+        code: BAD_DEFAULT_CODE,
+        message: `default "${defaultText}" of attribute "${name}" does not parse as ${spec.declared}: ${messageOf(err)}`
+      });
+    }
+  }
+  const companion = spec.temporal !== null && !spec.list ? timeTextCompanion(name) : null;
+  return { decl, spec, listSyntax, companion, renamed, issues };
+}
+function parseDeclaredValue(text, spec, listSyntax) {
+  if (spec.list) {
+    return splitListText(text, listSyntax).map((item) => parseItem(item, spec));
+  }
+  return parseItem(text, spec);
+}
+function parseDeclaredTemporal(text, spec) {
+  if (spec.temporal === null || spec.list) {
+    throw new GraphFormatError("E_COLUMN_TYPE", `"${spec.declared}" is not a scalar temporal type`, {
+      declared: spec.declared
+    });
+  }
+  return parseTemporal(text.trim(), spec.temporal);
+}
+const INTEGER_TEXT = /^[+-]?[0-9]+$/;
+function losesPrecision(spec, text) {
+  if (!spec.precision) {
+    return false;
+  }
+  const trimmed = text.trim();
+  if (!INTEGER_TEXT.test(trimmed)) {
+    return false;
+  }
+  const n = Number(trimmed);
+  return !Number.isFinite(n) || BigInt(trimmed) !== BigInt(n);
+}
+function declareOn(sink, domain, decl) {
+  return domain === "node" ? sink.declareNodeColumn(decl) : sink.declareEdgeColumn(decl);
+}
+function declareResolved(sink, domain, decl, report, where) {
+  let current = decl;
+  let renamed = false;
+  let roleDropped = false;
+  for (; ; ) {
+    try {
+      return { handle: declareOn(sink, domain, current), decl: current, renamed, roleDropped };
+    } catch (err) {
+      if (!(err instanceof GraphFormatError)) {
+        throw err;
+      }
+      if (err.code === "E_COLUMN_EXISTS" && !renamed) {
+        const taken = takenIn(sink, domain);
+        const id = current.origin?.id ?? null;
+        const name = uniqueColumnName(current.name, id, taken);
+        report.warning(
+          "coercion",
+          COLUMN_RENAMED_CODE,
+          `${domain} column "${current.name}" renamed to "${name}": the sink already holds that name with another shape`,
+          { ...where, element: where?.element ?? current.name }
+        );
+        current = { ...current, name };
+        renamed = true;
+        continue;
+      }
+      if (err.code === "E_DUPLICATE_ROLE" && current.role !== void 0 && !roleDropped) {
+        const holder = typeof err.details.holder === "string" ? err.details.holder : "another column";
+        report.warning(
+          "coercion",
+          ROLE_TAKEN_CODE,
+          `${domain} column "${current.name}" loses the ${current.role} role: "${holder}" already holds it`,
+          { ...where, element: where?.element ?? current.name }
+        );
+        const { role: _role, ...withoutRole } = current;
+        current = withoutRole;
+        roleDropped = true;
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+function declareCompanion(sink, domain, companion, report) {
+  try {
+    return declareOn(sink, domain, companion);
+  } catch (err) {
+    if (err instanceof GraphFormatError && err.code === "E_DUPLICATE_ROLE") {
+      report?.warnOnce(
+        "coercion",
+        ROLE_TAKEN_CODE,
+        `${domain} column "${companion.name}" is declared without the timeText role: another companion holds it (exporters use extra.for)`,
+        { element: companion.name }
+      );
+      const { role: _role, ...withoutRole } = companion;
+      return declareOn(sink, domain, withoutRole);
+    }
+    throw err;
+  }
+}
+function takenIn(sink, domain) {
+  return (name) => (domain === "node" ? sink.nodeColumn(name) : sink.edgeColumn(name)) !== INVALID_INDEX;
+}
+function uniqueColumnName(name, id, taken) {
+  if (!taken(name)) {
+    return name;
+  }
+  const base = id === null ? name : `${name}#${id}`;
+  if (id !== null && !taken(base)) {
+    return base;
+  }
+  for (let n = 2; ; n++) {
+    const candidate = `${base}#${n}`;
+    if (!taken(candidate)) {
+      return candidate;
+    }
+  }
+}
+class DictHeuristic {
+  /**
+   * Create a heuristic.
+   * @param sampleRows - rows observed before deciding; DICT_SAMPLE_ROWS by default
+   */
+  constructor(sampleRows = DICT_SAMPLE_ROWS) {
+    this.distinct = /* @__PURE__ */ new Set();
+    this.rowsSeen = 0;
+    this.sampleRows = sampleRows;
+  }
+  /**
+   * Rows observed so far.
+   * @returns the count
+   */
+  get rows() {
+    return this.rowsSeen;
+  }
+  /**
+   * Distinct values observed so far.
+   * @returns the count
+   */
+  get distinctCount() {
+    return this.distinct.size;
+  }
+  /**
+   * Whether the sample is full.
+   * @returns true once sampleRows values were observed
+   */
+  get decided() {
+    return this.rowsSeen >= this.sampleRows;
+  }
+  /**
+   * Observe one value.
+   * @param value - the value text
+   * @returns true when this observation completed the sample
+   */
+  observe(value) {
+    this.rowsSeen++;
+    if (this.distinct.size < this.rowsSeen) {
+      this.distinct.add(value);
+    }
+    return this.rowsSeen === this.sampleRows;
+  }
+  /**
+   * The dtype the sample suggests: dict when the distinct count is below rows / 2 (and at least
+   * one row was seen), string otherwise. Valid before the sample is full (end of input).
+   * @returns "dict" or "string"
+   */
+  decide() {
+    return this.rowsSeen > 0 && this.distinct.size * 2 < this.rowsSeen ? "dict" : "string";
+  }
+}
+function resolveName(input) {
+  const preferred = input.title !== null && input.title.length > 0 ? input.title : input.id;
+  if (preferred === null || preferred.length === 0) {
+    throw new GraphFormatError("E_COLUMN_TYPE", "an attribute declaration needs a title or an id", {
+      field: "name",
+      format: input.format
+    });
+  }
+  if (input.taken === void 0) {
+    return { name: preferred, renamed: false };
+  }
+  const name = uniqueColumnName(preferred, input.id, input.taken);
+  return { name, renamed: name !== preferred };
+}
+function parseItem(text, spec) {
+  return parseScalarText(text, spec.kind, spec.temporal);
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+const DIRECTED_COLUMN = "graphty.directed";
+const PAIR_COLUMN = "graphty.pair";
+const MUTUAL_COLUMN = "graphty.mutual";
+const DIRECTED_DECL = { name: DIRECTED_COLUMN, dtype: "bool", role: "directed" };
+const PAIR_DECL = { name: PAIR_COLUMN, dtype: "u32", role: "pair", refersTo: "edge" };
+const MUTUAL_DECL = { name: MUTUAL_COLUMN, dtype: "bool", role: "mutual" };
+class DirectionResolver {
+  /**
+   * Create a resolver.
+   * @param sink - the sink edges are pushed into
+   * @param report - the report issues are recorded in
+   * @param policy - the resolved onMixedDirection option
+   */
+  constructor(sink, report, policy) {
+    this.directedHandle = INVALID_INDEX;
+    this.pairHandle = INVALID_INDEX;
+    this.mutualHandle = INVALID_INDEX;
+    this.firstEdge = -1;
+    this.nextEdge = -1;
+    this.forcedCount = 0;
+    this.headerSet = false;
+    this.mirrorOfLast = INVALID_INDEX;
+    this.sink = sink;
+    this.report = report;
+    this.policy = policy;
+  }
+  /**
+   * The sink's current direction.
+   * @returns true when directed
+   */
+  get directed() {
+    return this.sink.directed;
+  }
+  /**
+   * Whether the reserved direction columns exist (the sink holds expanded edges).
+   * @returns true once graphty.pair was declared or adopted
+   */
+  get expanded() {
+    return this.pairHandle !== INVALID_INDEX;
+  }
+  /**
+   * Rule 1 of design section 8.4: set the sink's direction from the file's header (or the
+   * `defaultDirected` option for a file that declares none) before the first edge. Under the
+   * "directed" / "undirected" policies the policy's direction is used instead and the difference
+   * is reported. A refusal (E_DIRECTED: locked, or a non-empty directed sink for an undirected
+   * header) is recorded as a coercion issue and the sink's direction stands; a non-empty unlocked
+   * undirected sink with a directed header is expanded in place.
+   * @param headerDirected - the direction the file declares (or the default)
+   * @param where - the line of the header, when known
+   */
+  setHeader(headerDirected, where) {
+    this.headerSet = true;
+    let wanted = headerDirected;
+    if (this.policy === "directed" || this.policy === "undirected") {
+      wanted = this.policy === "directed";
+      if (wanted !== headerDirected) {
+        this.report.warning(
+          "coercion",
+          DIRECTION_FORCED_CODE,
+          `the file declares ${direction(headerDirected)} edges; read as ${direction(wanted)} per onMixedDirection`,
+          { line: where?.line ?? null }
+        );
+      }
+    }
+    const { sink } = this;
+    if (sink.directed === wanted) {
+      this.adoptExisting();
+      return;
+    }
+    try {
+      if (wanted && sink.edgeCount > 0 && !sink.directedLocked) {
+        const before = sink.edgeCount;
+        sink.setDirected(true, { expand: true });
+        this.adoptExpansionColumns();
+        this.report.counts.expandedMixed += before;
+      } else {
+        sink.setDirected(wanted);
+      }
+    } catch (err) {
+      if (!(err instanceof GraphFormatError) || err.code !== "E_DIRECTED") {
+        throw err;
+      }
+      this.report.warning(
+        "coercion",
+        DIRECTION_REFUSED_CODE,
+        `the file is ${direction(wanted)} but the sink is ${direction(sink.directed)} (${reasonOf(err)}); read as ${direction(sink.directed)}`,
+        { line: where?.line ?? null }
+      );
+    }
+    this.adoptExisting();
+  }
+  /**
+   * Pick up reserved columns a caller's sink already holds (an earlier expansion), so every edge
+   * pushed from now on gets its graphty.directed value.
+   */
+  adoptExisting() {
+    if (this.pairHandle === INVALID_INDEX && this.sink.edgeColumn(PAIR_COLUMN) !== INVALID_INDEX) {
+      this.adoptExpansionColumns();
+    }
+  }
+  /**
+   * The mirror half of the edge most recently pushed by addEdge(), when it was expanded into a
+   * pair; INVALID_INDEX otherwise. An importer that learns an edge's weight after pushing it
+   * (a GEXF attvalue) sets it on both halves.
+   * @returns the mirror's logical index, or INVALID_INDEX
+   */
+  get lastMirror() {
+    return this.mirrorOfLast;
+  }
+  /**
+   * Rule 2 of design section 8.4: push one source edge. An edge whose direction equals the
+   * sink's is one addEdge; one that differs is expanded, forced or refused per the policy.
+   * @param source - the source id
+   * @param target - the target id
+   * @param kind - the edge's direction in the file
+   * @param weight - the weight, or undefined when the file gives none
+   * @param where - the line and element, for issues
+   * @returns the logical index of the (primary) edge
+   */
+  addEdge(source, target, kind, weight, where) {
+    if (!this.headerSet) {
+      throw new GraphFormatError("E_DIRECTED", "DirectionResolver.setHeader() must run before the first edge", {
+        reason: "header not set"
+      });
+    }
+    const { sink } = this;
+    this.mirrorOfLast = INVALID_INDEX;
+    const edgeDirected = kind !== "undirected";
+    if (edgeDirected === sink.directed && kind !== "mutual") {
+      const e = sink.addEdge(source, target, weight);
+      this.track(e);
+      if (this.directedHandle !== INVALID_INDEX) {
+        sink.setEdgeValue(this.directedHandle, e, edgeDirected);
+      }
+      return e;
+    }
+    switch (this.policy) {
+      case "directed":
+      case "undirected": {
+        this.forcedCount++;
+        this.report.warnOnce(
+          "coercion",
+          DIRECTION_FORCED_CODE,
+          `${kind} edges read as ${direction(sink.directed)} per onMixedDirection`,
+          where
+        );
+        const e = sink.addEdge(source, target, weight);
+        this.track(e);
+        if (this.directedHandle !== INVALID_INDEX) {
+          sink.setEdgeValue(this.directedHandle, e, sink.directed);
+        }
+        return e;
+      }
+      case "error":
+        this.report.error(
+          "validation-error",
+          MIXED_DIRECTION_CODE,
+          `${kind} edge in a ${direction(sink.directed)} graph (onMixedDirection: "error")`,
+          where
+        );
+        throw this.report.abort("mixed direction refused", { code: MIXED_DIRECTION_CODE });
+      case "expand":
+        return this.expand(source, target, kind, weight, where);
+      default: {
+        const name = this.policy;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown onMixedDirection ${name}`, {
+          option: "onMixedDirection",
+          found: name
+        });
+      }
+    }
+  }
+  /**
+   * How many edges were pushed with a direction other than their own under the forcing policies.
+   * @returns the count
+   */
+  get forced() {
+    return this.forcedCount;
+  }
+  /**
+   * Expand one edge that differs from the sink's direction.
+   * @param source - the source id
+   * @param target - the target id
+   * @param kind - the edge's direction in the file
+   * @param weight - the weight, or undefined
+   * @param where - the line and element, for issues
+   * @returns the primary edge index
+   */
+  expand(source, target, kind, weight, where) {
+    const { sink } = this;
+    if (!sink.directed) {
+      try {
+        const before = sink.edgeCount;
+        sink.setDirected(true, { expand: true });
+        this.adoptExpansionColumns();
+        this.report.counts.expandedMixed += before;
+      } catch (err) {
+        if (!(err instanceof GraphFormatError) || err.code !== "E_DIRECTED") {
+          throw err;
+        }
+        this.report.error(
+          "coercion",
+          DIRECTION_REFUSED_CODE,
+          `${direction(true)} edge in a locked ${direction(false)} sink cannot be expanded`,
+          where
+        );
+        throw this.report.abort("the sink refused the expansion to directed", {
+          code: DIRECTION_REFUSED_CODE,
+          reason: err.details.reason
+        });
+      }
+      if (kind === "directed") {
+        const e = sink.addEdge(source, target, weight);
+        this.track(e);
+        sink.setEdgeValue(this.directedHandle, e, true);
+        return e;
+      }
+    }
+    this.ensureExpansionColumns();
+    const first = sink.addEdge(source, target, weight);
+    this.track(first);
+    const mutual = kind === "mutual";
+    sink.setEdgeValue(this.directedHandle, first, mutual);
+    this.report.counts.expandedMixed++;
+    if (mutual) {
+      this.ensureMutualColumn();
+      sink.setEdgeValue(this.mutualHandle, first, true);
+    }
+    const u = sink.indexOf(source);
+    const v = sink.indexOf(target);
+    if (u === v) {
+      return first;
+    }
+    const mirror = sink.addEdge(target, source, weight);
+    this.track(mirror);
+    this.mirrorOfLast = mirror;
+    sink.setEdgeValue(this.directedHandle, mirror, mutual);
+    sink.setEdgeValue(this.pairHandle, first, mirror);
+    sink.setEdgeValue(this.pairHandle, mirror, first);
+    return first;
+  }
+  /**
+   * Note an edge index this resolver pushed, for the backfill of graphty.directed.
+   * @param e - the edge index
+   */
+  track(e) {
+    if (this.firstEdge < 0) {
+      this.firstEdge = e;
+    }
+    this.nextEdge = e + 1;
+  }
+  /**
+   * Pick up the reserved columns the builder wrote during its own expansion.
+   */
+  adoptExpansionColumns() {
+    this.directedHandle = this.sink.declareEdgeColumn(DIRECTED_DECL);
+    this.pairHandle = this.sink.declareEdgeColumn(PAIR_DECL);
+  }
+  /**
+   * Declare the reserved columns on first use in a directed sink and backfill graphty.directed
+   * = true for every edge this resolver pushed so far (they were directed in the source).
+   */
+  ensureExpansionColumns() {
+    if (this.pairHandle !== INVALID_INDEX) {
+      return;
+    }
+    this.directedHandle = this.sink.declareEdgeColumn(DIRECTED_DECL);
+    this.pairHandle = this.sink.declareEdgeColumn(PAIR_DECL);
+    if (this.firstEdge >= 0) {
+      for (let e = this.firstEdge; e < this.nextEdge; e++) {
+        this.sink.setEdgeValue(this.directedHandle, e, true);
+      }
+    }
+  }
+  /** Declare graphty.mutual on first use. */
+  ensureMutualColumn() {
+    if (this.mutualHandle === INVALID_INDEX) {
+      this.mutualHandle = this.sink.declareEdgeColumn(MUTUAL_DECL);
+    }
+  }
+}
+function reasonOf(err) {
+  const { reason } = err.details;
+  return typeof reason === "string" ? reason : "refused";
+}
+function direction(directed) {
+  return directed ? "directed" : "undirected";
+}
+function pairFolding(snapshot, options = {}) {
+  const foldMutual = options.foldMutual ?? false;
+  const directedColumn = roleColumn(snapshot.edges.byRole("directed"), "bool");
+  const pairColumn = roleColumn(snapshot.edges.byRole("pair"), "u32");
+  const mutualColumn = roleColumn(snapshot.edges.byRole("mutual"), "bool");
+  const { edgeCount } = snapshot;
+  const mateOf = (e) => {
+    if (pairColumn === null || !pairColumn.isSet(e)) {
+      return INVALID_INDEX;
+    }
+    const mate = pairColumn.value(e);
+    return typeof mate === "number" && mate !== INVALID_INDEX ? mate : INVALID_INDEX;
+  };
+  const sourceDirected = (e) => directedColumn === null || !directedColumn.isSet(e) || directedColumn.value(e) === true;
+  const isMutual = (e) => {
+    if (mutualColumn === null) {
+      return false;
+    }
+    if (mutualColumn.isSet(e) && mutualColumn.value(e) === true) {
+      return true;
+    }
+    const mate = mateOf(e);
+    return mate !== INVALID_INDEX && mutualColumn.isSet(mate) && mutualColumn.value(mate) === true;
+  };
+  const folded = (e) => {
+    const mate = mateOf(e);
+    if (mate === INVALID_INDEX || mate >= e) {
+      return false;
+    }
+    return !sourceDirected(e) || foldMutual && isMutual(e);
+  };
+  let mutualCount = 0;
+  if (mutualColumn !== null) {
+    for (let e = 0; e < edgeCount; e++) {
+      if (mutualColumn.isSet(e) && mutualColumn.value(e) === true && mateOf(e) > e) {
+        mutualCount++;
+      }
+    }
+  }
+  return { expanded: pairColumn !== null, mutualCount, folded, mateOf, sourceDirected, isMutual };
+}
+function roleColumn(column, dtype) {
+  return column !== null && column.dtype === dtype ? column : null;
+}
+const CANONICAL_INTEGER = /^-?(0|[1-9][0-9]*)$/;
+function canonicalId(text) {
+  if (text !== "-0" && CANONICAL_INTEGER.test(text)) {
+    const n = Number(text);
+    if (Number.isSafeInteger(n)) {
+      return n;
+    }
+  }
+  return text;
+}
+function isCanonicalIntegerText(text) {
+  return typeof canonicalId(text) === "number";
+}
+function coerceIdText(text, mode) {
+  switch (mode) {
+    case "keep":
+    case "string":
+      return text;
+    case "canonical":
+      return canonicalId(text);
+    case "number": {
+      if (text.trim().length === 0) {
+        throw invalidId(text, "empty text is not a number");
+      }
+      const n = Number(text);
+      if (!Number.isFinite(n)) {
+        throw invalidId(text, "not a finite number");
+      }
+      return n;
+    }
+    default: {
+      const name = mode;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown id coercion ${name}`, { option: "ids", found: name });
+    }
+  }
+}
+function coerceId(value, mode) {
+  if (typeof value === "string") {
+    return coerceIdText(value, mode);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw invalidId(value, "not a finite number");
+    }
+    return mode === "string" ? String(value) : value;
+  }
+  if (mode === "string" && (typeof value === "boolean" || typeof value === "bigint" || value === null)) {
+    return String(value);
+  }
+  throw invalidId(value, `a ${value === null ? "null" : typeof value} is not an id under ids: "${mode}"`);
+}
+function invalidId(value, reason) {
+  const shown = typeof value === "string" || typeof value === "number" ? value : typeof value;
+  return new GraphFormatError("E_INVALID_ID", `invalid node id ${JSON.stringify(shown)}: ${reason}`, {
+    reason,
+    value: typeof value === "bigint" ? value.toString() : value
+  });
+}
+class IdCoercer {
+  /**
+   * Create a coercer.
+   * @param mode - the rule
+   */
+  constructor(mode) {
+    this.mergeCount = 0;
+    this.lastMerge = null;
+    this.mode = mode;
+    this.firstText = mode === "number" ? /* @__PURE__ */ new Map() : null;
+  }
+  /**
+   * Coerce a text cell, recording a merge under "number" when a different text already produced
+   * the same number.
+   * @param text - the cell text
+   * @returns the id
+   */
+  text(text) {
+    const id = coerceIdText(text, this.mode);
+    this.lastMerge = null;
+    if (this.firstText !== null && typeof id === "number") {
+      const previous = this.firstText.get(id);
+      if (previous === void 0) {
+        this.firstText.set(id, text);
+      } else if (previous !== text) {
+        this.mergeCount++;
+        this.lastMerge = { id, text, previousText: previous };
+      }
+    }
+    return id;
+  }
+  /**
+   * Coerce a typed value.
+   * @param value - the value
+   * @returns the id
+   */
+  value(value) {
+    if (typeof value === "string") {
+      return this.text(value);
+    }
+    this.lastMerge = null;
+    return coerceId(value, this.mode);
+  }
+}
+const DECODE_SLICE = 256 * 1024;
+const BOM = String.fromCharCode(65279);
+function isImportInput(input) {
+  if (typeof input === "string" || input instanceof Uint8Array) {
+    return true;
+  }
+  if (typeof input !== "object" || input === null) {
+    return false;
+  }
+  return typeof input.getReader === "function" || Symbol.asyncIterator in input;
+}
+function inputLength(input) {
+  if (typeof input === "string") {
+    return input.length;
+  }
+  if (input instanceof Uint8Array) {
+    return input.byteLength;
+  }
+  return null;
+}
+function throwIfAborted(signal) {
+  if (signal === null || signal === void 0 || !signal.aborted) {
+    return;
+  }
+  const { reason } = signal;
+  if (reason === void 0) {
+    throw abortError();
+  }
+  throw reason;
+}
+function abortError() {
+  const message = "The import was aborted";
+  if (typeof DOMException === "function") {
+    return new DOMException(message, "AbortError");
+  }
+  const err = new Error(message);
+  err.name = "AbortError";
+  return err;
+}
+async function* textChunks(input, report, options = {}) {
+  const signal = options.signal ?? null;
+  const onProgress = options.onProgress ?? null;
+  const total = inputLength(input);
+  let done = 0;
+  let first = true;
+  const emit = (text) => {
+    if (first && text.length > 0) {
+      first = false;
+      return text.startsWith(BOM) ? text.slice(1) : text;
+    }
+    return text;
+  };
+  throwIfAborted(signal);
+  if (typeof input === "string") {
+    const text = emit(input);
+    done = input.length;
+    if (text.length > 0) {
+      yield text;
+    }
+    onProgress?.(done, total ?? void 0);
+    return;
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  const decode = (bytes, stream) => {
+    try {
+      return decoder.decode(bytes, { stream });
+    } catch (err) {
+      if (err instanceof TypeError) {
+        report.fail(INVALID_UTF8_CODE, `invalid UTF-8 near byte ${done}`, void 0, { byteOffset: done });
+      }
+      throw err;
+    }
+  };
+  if (input instanceof Uint8Array) {
+    for (let offset = 0; offset < input.byteLength; offset += DECODE_SLICE) {
+      throwIfAborted(signal);
+      const slice = input.subarray(offset, Math.min(offset + DECODE_SLICE, input.byteLength));
+      const text = emit(decode(slice, offset + DECODE_SLICE < input.byteLength));
+      done = Math.min(offset + DECODE_SLICE, input.byteLength);
+      if (text.length > 0) {
+        yield text;
+      }
+      onProgress?.(done, total ?? void 0);
+    }
+    if (input.byteLength === 0) {
+      onProgress?.(0, 0);
+    }
+    return;
+  }
+  const chunks = isReadableStream(input) ? streamChunks(input, signal) : input;
+  for await (const chunk of chunks) {
+    throwIfAborted(signal);
+    let text;
+    if (typeof chunk === "string") {
+      const pending = decode(new Uint8Array(0), false);
+      text = emit(pending + chunk);
+      done += chunk.length;
+    } else if (chunk instanceof Uint8Array) {
+      text = emit(decode(chunk, true));
+      done += chunk.byteLength;
+    } else {
+      throw new GraphFormatError("E_UNSUPPORTED", "an input chunk must be a string or a Uint8Array", {
+        reason: "chunk type",
+        found: typeof chunk
+      });
+    }
+    if (text.length > 0) {
+      yield text;
+    }
+    onProgress?.(done);
+  }
+  const tail = emit(decode(new Uint8Array(0), false));
+  if (tail.length > 0) {
+    yield tail;
+  }
+  onProgress?.(done, done);
+}
+function isReadableStream(input) {
+  return typeof input.getReader === "function";
+}
+async function* streamChunks(stream, signal) {
+  const reader = stream.getReader();
+  let finished = false;
+  try {
+    for (; ; ) {
+      throwIfAborted(signal);
+      const { done, value } = await reader.read();
+      if (done) {
+        finished = true;
+        return;
+      }
+      yield value;
+    }
+  } finally {
+    if (!finished) {
+      await reader.cancel(signal?.reason).catch(() => void 0);
+    }
+    reader.releaseLock();
+  }
+}
+async function readText(input, report, options = {}) {
+  if (typeof input === "string") {
+    throwIfAborted(options.signal);
+    options.onProgress?.(input.length, input.length);
+    return input.startsWith(BOM) ? input.slice(1) : input;
+  }
+  const parts = [];
+  for await (const chunk of textChunks(input, report, options)) {
+    parts.push(chunk);
+  }
+  return parts.length === 1 ? parts[0] : parts.join("");
+}
+class LineReader {
+  /**
+   * Create a reader over an input; nothing is read until iteration starts.
+   * @param input - the input
+   * @param report - the report decode errors are recorded in
+   * @param options - cancellation and progress
+   */
+  constructor(input, report, options = {}) {
+    this.lineNumber = 0;
+    this.input = input;
+    this.report = report;
+    this.options = options;
+  }
+  /**
+   * The 1-based number of the line most recently yielded.
+   * @returns the line number; 0 before the first line
+   */
+  get line() {
+    return this.lineNumber;
+  }
+  /**
+   * Iterate the lines.
+   * @yields one line at a time, terminator removed
+   * @returns nothing
+   */
+  async *[Symbol.asyncIterator]() {
+    const pending = [];
+    let trailingCr = false;
+    for await (const chunk of textChunks(this.input, this.report, this.options)) {
+      let start = 0;
+      const end = chunk.length;
+      if (trailingCr) {
+        trailingCr = false;
+        this.lineNumber++;
+        const joined = pending.join("");
+        pending.length = 0;
+        yield joined.slice(0, -1);
+        if (chunk.charCodeAt(0) === 10) {
+          start = 1;
+        }
+      }
+      let nl = chunk.indexOf("\n", start);
+      let cr = chunk.indexOf("\r", start);
+      while (nl >= 0 || cr >= 0) {
+        let cut;
+        let next;
+        if (cr >= 0 && (nl < 0 || cr < nl)) {
+          if (cr === end - 1) {
+            break;
+          }
+          cut = cr;
+          next = chunk.charCodeAt(cr + 1) === 10 ? cr + 2 : cr + 1;
+        } else {
+          cut = nl;
+          next = nl + 1;
+        }
+        this.lineNumber++;
+        const piece = chunk.slice(start, cut);
+        if (pending.length === 0) {
+          yield piece;
+        } else {
+          pending.push(piece);
+          const joined = pending.join("");
+          pending.length = 0;
+          yield joined;
+        }
+        start = next;
+        if (nl >= 0 && nl < next) {
+          nl = chunk.indexOf("\n", next);
+        }
+        if (cr >= 0 && cr < next) {
+          cr = chunk.indexOf("\r", next);
+        }
+      }
+      if (start < end) {
+        pending.push(start === 0 ? chunk : chunk.slice(start));
+        trailingCr = chunk.charCodeAt(end - 1) === 13;
+      }
+    }
+    if (pending.length > 0) {
+      this.lineNumber++;
+      const joined = pending.join("");
+      yield joined.endsWith("\r") ? joined.slice(0, -1) : joined;
+    }
+  }
+}
+const ID_COERCIONS = /* @__PURE__ */ new Set(["keep", "canonical", "string", "number"]);
+const NODE_ID_SOURCES = /* @__PURE__ */ new Set(["id", "label", "index"]);
+const DUPLICATE_POLICIES = /* @__PURE__ */ new Set(["keep", "error", "first", "last", "sum", "min", "max"]);
+const SELF_LOOP_POLICIES = /* @__PURE__ */ new Set(["keep", "drop", "error"]);
+const IMPORT_MIXED_POLICIES = /* @__PURE__ */ new Set(["expand", "directed", "undirected", "error"]);
+const EXPORT_MIXED_POLICIES = /* @__PURE__ */ new Set(["error", "directed", "undirected"]);
+const WEIGHT_DTYPES = /* @__PURE__ */ new Set(["f32", "f64"]);
+const LONG_MODES = /* @__PURE__ */ new Set(["f64", "string"]);
+const HYPEREDGE_POLICIES = /* @__PURE__ */ new Set(["error", "skip", "star", "clique"]);
+const SANITIZE_MODES = /* @__PURE__ */ new Set(["error", "mangle"]);
+const DEFAULT_ERROR_LIMIT = 100;
+const SINK_OPTION_NAMES = ["addMissingNodes", "duplicateEdges", "selfLoops", "weightDtype"];
+function reportSinkOptions(sink, options, report, enforcesMissingNodes = false) {
+  if (options === void 0) {
+    return 0;
+  }
+  let recorded = 0;
+  for (const name of SINK_OPTION_NAMES) {
+    const wanted = options[name];
+    const actual = sink.options[name];
+    if (wanted === void 0 || wanted === actual) {
+      continue;
+    }
+    if (name === "addMissingNodes" && enforcesMissingNodes && wanted === false) {
+      continue;
+    }
+    report.warning(
+      "coercion",
+      SINK_OPTION_CODE,
+      `option ${name}: ${JSON.stringify(wanted)} requested but the sink uses ${JSON.stringify(actual)}; the sink's setting applies`,
+      { element: name }
+    );
+    recorded++;
+  }
+  return recorded;
+}
+const IGNORABLE_OPTION_NAMES = [
+  "ids",
+  "nodeIdFrom",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "defaultDirected",
+  "weightFrom",
+  "weightDtype",
+  "long",
+  "restoreMangledIds",
+  "hyperedges"
+];
+function reportUnusedOptions(options, report, used) {
+  if (options === void 0) {
+    return 0;
+  }
+  let recorded = 0;
+  for (const name of IGNORABLE_OPTION_NAMES) {
+    if (used.has(name) || SINK_OPTION_NAMES.includes(name)) {
+      continue;
+    }
+    const value = options[name];
+    if (value === void 0) {
+      continue;
+    }
+    report.warning(
+      "unsupported",
+      OPTION_IGNORED_CODE,
+      `option ${name}: ${JSON.stringify(value)} has no effect on the ${report.format} importer`,
+      { element: name }
+    );
+    recorded++;
+  }
+  return recorded;
+}
+function resolveImportOptions(options, defaults) {
+  const o = options ?? {};
+  return Object.freeze({
+    ids: enumOption("ids", o.ids, defaults.ids, ID_COERCIONS),
+    nodeIdFrom: enumOption("nodeIdFrom", o.nodeIdFrom, "id", NODE_ID_SOURCES),
+    addMissingNodes: booleanOption("addMissingNodes", o.addMissingNodes, defaults.addMissingNodes ?? true),
+    duplicateEdges: enumOption("duplicateEdges", o.duplicateEdges, "keep", DUPLICATE_POLICIES),
+    selfLoops: enumOption("selfLoops", o.selfLoops, "keep", SELF_LOOP_POLICIES),
+    onMixedDirection: enumOption("onMixedDirection", o.onMixedDirection, "expand", IMPORT_MIXED_POLICIES),
+    defaultDirected: booleanOption("defaultDirected", o.defaultDirected, defaults.defaultDirected),
+    weightFrom: weightFromOption(o.weightFrom, defaults.weightFrom),
+    weightDtype: enumOption("weightDtype", o.weightDtype, "f64", WEIGHT_DTYPES),
+    long: enumOption("long", o.long, "f64", LONG_MODES),
+    restoreMangledIds: booleanOption("restoreMangledIds", o.restoreMangledIds, true),
+    hyperedges: enumOption("hyperedges", o.hyperedges, "skip", HYPEREDGE_POLICIES),
+    errorLimit: errorLimitOption(o.errorLimit),
+    signal: signalOption(o.signal),
+    onProgress: progressOption(o.onProgress)
+  });
+}
+function resolveExportOptions(options) {
+  const o = options ?? {};
+  return Object.freeze({
+    sanitizeIds: enumOption("sanitizeIds", o.sanitizeIds, "error", SANITIZE_MODES),
+    onMixedDirection: enumOption("onMixedDirection", o.onMixedDirection, "error", EXPORT_MIXED_POLICIES)
+  });
+}
+function enumOption(name, value, fallback, allowed) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "string" || !allowed.has(value)) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option ${name}: ${describe(value)} is not one of ${list(allowed)}`,
+      {
+        option: name,
+        found: value,
+        supported: [...allowed]
+      }
+    );
+  }
+  return value;
+}
+function booleanOption(name, value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "boolean") {
+    throw new GraphFormatError("E_UNSUPPORTED", `option ${name}: ${describe(value)} is not a boolean`, {
+      option: name,
+      found: value
+    });
+  }
+  return value;
+}
+function weightFromOption(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (value === null || typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  throw new GraphFormatError(
+    "E_UNSUPPORTED",
+    `option weightFrom: ${describe(value)} is not an attribute name or null`,
+    { option: "weightFrom", found: value }
+  );
+}
+function errorLimitOption(value) {
+  if (value === void 0) {
+    return DEFAULT_ERROR_LIMIT;
+  }
+  if (typeof value === "number" && value >= 0 && (Number.isInteger(value) || value === Infinity)) {
+    return value;
+  }
+  throw new GraphFormatError(
+    "E_UNSUPPORTED",
+    `option errorLimit: ${describe(value)} is not a non-negative integer or Infinity`,
+    { option: "errorLimit", found: value }
+  );
+}
+function signalOption(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "object" && typeof value.aborted === "boolean") {
+    return value;
+  }
+  throw new GraphFormatError("E_UNSUPPORTED", `option signal: ${describe(value)} is not an AbortSignal`, {
+    option: "signal",
+    found: typeof value
+  });
+}
+function progressOption(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "function") {
+    return value;
+  }
+  throw new GraphFormatError("E_UNSUPPORTED", `option onProgress: ${describe(value)} is not a function`, {
+    option: "onProgress",
+    found: typeof value
+  });
+}
+function describe(value) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+    case "boolean":
+      return String(value);
+    default:
+      return value === null ? "null" : typeof value;
+  }
+}
+function list(allowed) {
+  return [...allowed].map((v) => JSON.stringify(v)).join(", ");
+}
+class ImportError extends GraphFormatError {
+  /**
+   * Create an ImportError.
+   * @param message - a plain-ASCII human-readable message
+   * @param report - the partial report
+   * @param details - optional machine-readable context
+   */
+  constructor(message, report, details) {
+    super("E_IMPORT", message, details);
+    this.name = "ImportError";
+    this.report = report;
+  }
+}
+const CATEGORY_BY_CODE = {
+  E_UNKNOWN_NODE: "missing-value",
+  E_UNKNOWN_COLUMN: "missing-value",
+  E_DIRECTED: "coercion",
+  E_TOO_LARGE: "unsupported",
+  E_UNSUPPORTED: "unsupported",
+  E_GPU_INELIGIBLE: "unsupported"
+};
+const PARSE_ERROR_CODE = "E_PARSE";
+class ImportReportBuilder {
+  /**
+   * Create a builder for one import call.
+   * @param format - the importer's format name
+   * @param errorLimit - errors tolerated before the import aborts; Infinity for no limit
+   */
+  constructor(format, errorLimit) {
+    this.counts = { nodes: 0, edges: 0, skippedNodes: 0, skippedEdges: 0, expandedMixed: 0 };
+    this.issueList = [];
+    this.lossList = [];
+    this.onceCodes = /* @__PURE__ */ new Set();
+    this.errors = 0;
+    this.warnings = 0;
+    this.truncatedFlag = false;
+    this.format = format;
+    this.errorLimit = errorLimit;
+    this.startedAt = now();
+  }
+  /**
+   * Issues recorded so far, in order.
+   * @returns the live list (not copied; finish() copies)
+   */
+  get issues() {
+    return this.issueList;
+  }
+  /**
+   * Issues with severity "error".
+   * @returns the count
+   */
+  get errorCount() {
+    return this.errors;
+  }
+  /**
+   * Issues with severity "warning".
+   * @returns the count
+   */
+  get warningCount() {
+    return this.warnings;
+  }
+  /**
+   * Whether the error limit was exceeded.
+   * @returns true once an error beyond the limit was recorded
+   */
+  get truncated() {
+    return this.truncatedFlag;
+  }
+  /**
+   * Loss notes recorded so far.
+   * @returns the live list
+   */
+  get lossy() {
+    return this.lossList;
+  }
+  /**
+   * Record an error. When the count goes beyond the error limit the report is marked truncated
+   * and an ImportError carrying it is thrown; the importer does not catch that.
+   * @param category - the issue category
+   * @param code - a stable code such as "E_UNKNOWN_NODE"
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @returns the recorded issue
+   */
+  error(category, code, message, where) {
+    const issue = makeIssue(category, "error", code, message, where);
+    this.issueList.push(issue);
+    this.errors++;
+    if (this.errors > this.errorLimit) {
+      this.truncatedFlag = true;
+      throw this.abort(`error limit of ${this.errorLimit} exceeded: ${message}`, {
+        code,
+        limit: this.errorLimit
+      });
+    }
+    return issue;
+  }
+  /**
+   * Record a warning; warnings never count toward the limit.
+   * @param category - the issue category
+   * @param code - a stable code such as "W_WIDENED"
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @returns the recorded issue
+   */
+  warning(category, code, message, where) {
+    const issue = makeIssue(category, "warning", code, message, where);
+    this.issueList.push(issue);
+    this.warnings++;
+    return issue;
+  }
+  /**
+   * Record a warning the first time its key is seen and ignore later repeats, for conditions
+   * that would otherwise produce one warning per row.
+   * @param category - the issue category
+   * @param code - the stable code
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @param key - what repeats are deduplicated on; the code itself by default (pass `code:column`
+   * to warn once per column)
+   * @returns the recorded issue, or null when the key was already recorded
+   */
+  warnOnce(category, code, message, where, key = code) {
+    if (this.onceCodes.has(key)) {
+      return null;
+    }
+    this.onceCodes.add(key);
+    return this.warning(category, code, message, where);
+  }
+  /**
+   * Record something the importer could not represent.
+   * @param code - a stable code
+   * @param message - a plain-ASCII message
+   * @param column - the affected column, or null
+   * @param count - the affected count, or null
+   * @returns the recorded note
+   */
+  loss(code, message, column = null, count = null) {
+    const note = Object.freeze({ code, message, column, count });
+    this.lossList.push(note);
+    return note;
+  }
+  /**
+   * The per-element catch of design section 8.6: record a thrown GraphFormatError as an error
+   * issue with its code and the category the code implies. Anything else is re-thrown unchanged:
+   * an ImportError (the import already aborted), an abort reason, and any other thrown value (a
+   * TypeError or RangeError is a programming error in the importer or the sink, never a defect of
+   * the input, so it must surface as an exception rather than as an issue blamed on the file).
+   * @param err - the thrown value
+   * @param where - the line and element, when known
+   * @returns the recorded issue
+   */
+  recordError(err, where) {
+    if (err instanceof GraphFormatError && !(err instanceof ImportError)) {
+      const category = CATEGORY_BY_CODE[err.code] ?? "validation-error";
+      return this.error(category, err.code, err.message, where);
+    }
+    throw err;
+  }
+  /**
+   * Build the ImportError that aborts the import, carrying the report so far. The caller throws
+   * it; this method only constructs it so it can be used in expression position.
+   * @param message - a plain-ASCII message
+   * @param details - optional machine-readable context
+   * @returns the error to throw
+   */
+  abort(message, details) {
+    return new ImportError(message, this.finish(), details);
+  }
+  /**
+   * Record a fatal parse error and abort: the issue is recorded (even beyond the error limit)
+   * and an ImportError carrying the report is thrown.
+   * @param code - a stable code such as "E_INVALID_UTF8"
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @param details - optional machine-readable context for the ImportError
+   */
+  fail(code, message, where, details) {
+    const issue = makeIssue("parse-error", "error", code, message, where);
+    this.issueList.push(issue);
+    this.errors++;
+    if (this.errors > this.errorLimit) {
+      this.truncatedFlag = true;
+    }
+    throw this.abort(message, { code, ...details });
+  }
+  /**
+   * The report as it stands: a frozen snapshot with the parse duration so far. Can be called more
+   * than once; each call reflects everything recorded up to that point.
+   * @returns the report
+   */
+  finish() {
+    const { nodes, edges, skippedNodes, skippedEdges, expandedMixed } = this.counts;
+    return Object.freeze({
+      format: this.format,
+      counts: Object.freeze({ nodes, edges, skippedNodes, skippedEdges, expandedMixed }),
+      issues: Object.freeze([...this.issueList]),
+      errorCount: this.errors,
+      warningCount: this.warnings,
+      truncated: this.truncatedFlag,
+      lossy: Object.freeze([...this.lossList]),
+      durationMs: now() - this.startedAt
+    });
+  }
+}
+function makeIssue(category, severity, code, message, where) {
+  return Object.freeze({
+    category,
+    severity,
+    code,
+    message,
+    line: where?.line ?? null,
+    element: where?.element ?? null
+  });
+}
+function isAbortError(err) {
+  return typeof err === "object" && err !== null && err.name === "AbortError";
+}
+function now() {
+  return typeof performance === "object" ? performance.now() : Date.now();
+}
+function formatF32(value) {
+  if (!Number.isFinite(value)) {
+    return String(value);
+  }
+  if (value === 0) {
+    return "0";
+  }
+  for (let digits = 1; digits <= 9; digits++) {
+    const text = value.toPrecision(digits);
+    if (Math.fround(Number(text)) === value) {
+      return String(Number(text));
+    }
+  }
+  return String(value);
+}
+function formatF64(value) {
+  return String(value);
+}
+function formatDecimal(value, dtype = "f64") {
+  if (!Number.isFinite(value)) {
+    return String(value);
+  }
+  if (Object.is(value, -0)) {
+    return "-0.0";
+  }
+  const text = formatNumber(value, dtype);
+  return text.includes(".") || text.includes("e") ? text : `${text}.0`;
+}
+function formatGmlReal(value, dtype = "f64") {
+  if (Number.isNaN(value)) {
+    return "NAN";
+  }
+  if (!Number.isFinite(value)) {
+    return value > 0 ? "+INF" : "-INF";
+  }
+  const text = formatDecimal(value, dtype);
+  if (text.includes(".")) {
+    return text;
+  }
+  const e = text.indexOf("e");
+  return `${text.slice(0, e)}.0${text.slice(e)}`;
+}
+function formatInteger(value) {
+  if (Number.isSafeInteger(value) || !Number.isFinite(value)) {
+    return String(value);
+  }
+  return BigInt(value).toString();
+}
+function formatNumber(value, dtype) {
+  return dtype === "f32" ? formatF32(value) : formatF64(value);
+}
+const DEFAULT_WEIGHT = 1;
+function isWeightField(name, weightFrom) {
+  return weightFrom !== null && name === weightFrom;
+}
+function parseWeightText(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  let value;
+  try {
+    value = parseDecimalText(trimmed);
+  } catch (err) {
+    throw invalidWeight(text, err);
+  }
+  if (Number.isNaN(value)) {
+    throw invalidWeight(text, null);
+  }
+  return value;
+}
+function weightFromValue(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) {
+      throw invalidWeight(value, null);
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    return parseWeightText(value);
+  }
+  throw invalidWeight(value, null);
+}
+function invalidWeight(value, cause) {
+  let shown;
+  switch (typeof value) {
+    case "string":
+      shown = JSON.stringify(value);
+      break;
+    case "number":
+      shown = String(value);
+      break;
+    default:
+      shown = typeof value;
+  }
+  return new GraphFormatError("E_INVALID_WEIGHT", `invalid edge weight ${shown}`, {
+    value: typeof value === "object" ? typeof value : value,
+    cause: cause instanceof Error ? cause.message : null
+  });
+}
+const NUMERIC_DTYPES = /* @__PURE__ */ new Set(["f32", "f64", "i32", "u32", "u8"]);
+function weightFormatter(dtype) {
+  switch (dtype) {
+    case "f32":
+      return formatF32;
+    case "f64":
+      return formatF64;
+    default:
+      return formatInteger;
+  }
+}
+function explicitWeights(snapshot) {
+  const shadowColumn = snapshot.edges.byRole("weight");
+  const shadow = shadowColumn !== null && NUMERIC_DTYPES.has(shadowColumn.dtype) ? shadowColumn : null;
+  if (shadow !== null) {
+    const dtype = shadow.dtype === "f32" ? "f32" : "f64";
+    const format = weightFormatter(shadow.dtype);
+    return {
+      weighted: true,
+      dtype,
+      isExplicit: (e) => shadow.isSet(e),
+      value: (e) => shadow.value(e),
+      text: (e, integral = false) => {
+        if (!shadow.isSet(e)) {
+          return null;
+        }
+        const value = shadow.value(e);
+        return integral && Number.isInteger(value) ? formatInteger(value) : format(value);
+      }
+    };
+  }
+  const { weights } = snapshot.edgeList();
+  if (weights === null || !snapshot.flags.weighted) {
+    return {
+      weighted: false,
+      dtype: "f32",
+      isExplicit: () => false,
+      value: () => DEFAULT_WEIGHT,
+      text: () => null
+    };
+  }
+  return {
+    weighted: true,
+    dtype: "f32",
+    isExplicit: () => true,
+    value: (e) => weights[e],
+    text: (e, integral = false) => {
+      const value = weights[e];
+      return integral && Number.isInteger(value) ? formatInteger(value) : formatF32(value);
+    }
+  };
+}
+const LOSS = Object.freeze({
+  /** The format has no mixed direction; expanded pairs are written per onMixedDirection. */
+  MIXED_DIRECTION: "W_MIXED_DIRECTION",
+  /** The format has no mixed direction and onMixedDirection is "error": export() will throw E_DIRECTED. */
+  MIXED_DIRECTION_ERROR: MIXED_DIRECTION_CODE,
+  /** Parallel edges in a format without them. */
+  MULTI_EDGES: "W_MULTI_EDGES",
+  /** Self-loops in a format without them. */
+  SELF_LOOPS: "W_SELF_LOOPS",
+  /** The format requires edge ids and the snapshot has none; canonical e0..e{E-1} are generated. */
+  EDGE_IDS_GENERATED: "W_EDGE_IDS_GENERATED",
+  /** The snapshot has an edge id column and the format cannot write one. */
+  EDGE_IDS_DROPPED: "W_EDGE_IDS_DROPPED",
+  /** Ids outside the format's charset are rewritten (sanitizeIds "mangle"). */
+  ID_MANGLED: "W_ID_MANGLED",
+  /** Ids outside the format's charset and sanitizeIds "error": export() will throw E_INVALID_ID. */
+  ID_CHARSET: "E_ID_CHARSET",
+  /** The format numbers nodes 1..N; ids that are not their 1-based index are kept as labels only. */
+  ID_RENUMBERED: "W_ID_RENUMBERED",
+  /** A column dtype the format does not keep as declared. */
+  DTYPE: "W_DTYPE_UNSUPPORTED",
+  /** A multi-component column in a format without strides. */
+  COMPONENTS: "W_COMPONENTS_FLATTENED",
+  /** A list column in a format without lists. */
+  LIST: "W_LIST_UNSUPPORTED",
+  /** A json column in a format without nested values. */
+  JSON: "W_JSON_UNSUPPORTED",
+  /** A declared default in a format without defaults. */
+  DEFAULT: "W_DEFAULT_DROPPED",
+  /** Declared options in a format without enumerations. */
+  OPTIONS: "W_OPTIONS_DROPPED",
+  /** A parent / parents column in a format without containment. */
+  HIERARCHY: "W_HIERARCHY_DROPPED",
+  /** A start / end / timestamp column in a format without temporal support. */
+  TEMPORAL: TEMPORAL_DROPPED_CODE,
+  /** A `<column>.text` companion (design section 5.1) the format cannot carry. */
+  TEMPORAL_TEXT: TEMPORAL_TEXT_DROPPED_CODE,
+  /** A role column the format has no slot for; written as a plain attribute, the role lost. */
+  ROLE: ROLE_DROPPED_CODE,
+  /** A parents (multi-parent) column in a format with single containment only. */
+  PARENTS: PARENTS_DROPPED_CODE,
+  /** A mutual pair written as two directed edges without the mutual mark. */
+  MUTUAL_EXPANDED: MUTUAL_EXPANDED_CODE,
+  /** A mutual pair written as one undirected edge; the mark is lost and the pair reads back undirected. */
+  MUTUAL_AS_UNDIRECTED: MUTUAL_AS_UNDIRECTED_CODE,
+  /** Node ids whose written text reads back as the other type under the importer's id rule. */
+  ID_TEXT_TYPE: ID_TEXT_TYPE_CODE,
+  /** Two node ids share one written text; export() throws E_INVALID_ID. */
+  ID_TEXT_COLLISION: ID_TEXT_COLLISION_CODE,
+  /** A plain column named like the importer's weight key reads back as THE weight. */
+  WEIGHT_KEY_CLASH: WEIGHT_KEY_CLASH_CODE,
+  /** A role-less column whose written name the importer maps to a role. */
+  ROLE_ASSUMED: ROLE_ASSUMED_CODE,
+  /** A role column written into the format's slot reads back under the importer's fixed name. */
+  COLUMN_NAME_CHANGED: COLUMN_RENAMED_LOSS_CODE,
+  /** A declared column whose every row is unset vanishes through a format without declarations. */
+  EMPTY_COLUMN: EMPTY_COLUMN_DROPPED_CODE,
+  /** A string / dict column that reads back as the other storage class (the dictionary heuristic). */
+  STORAGE_CLASS: STORAGE_CLASS_CODE,
+  /** An f64 column whose set values are all integral reads back as i32 through an untyped format. */
+  INTEGRAL_F64: INTEGRAL_F64_CODE,
+  /** Text cells that read back as numbers or booleans under the 5.1 grammar. */
+  TEXT_INFERRED: TEXT_INFERRED_CODE,
+  /** A string cell holding a character XML 1.0 forbids; export() throws E_COLUMN_TYPE. */
+  XML_ILLEGAL_CHAR: XML_ILLEGAL_CHAR_CODE,
+  /** A dict column without declared options gains one on re-import. */
+  OPTIONS_GAINED: OPTIONS_GAINED_CODE,
+  /** A spells column in a format without spells. */
+  SPELLS: "W_SPELLS_DROPPED",
+  /** Dynamic attribute values (extension tables) in a format without them. */
+  DYNAMIC_VALUES: "W_DYNAMIC_VALUES_DROPPED",
+  /** An open-interval column in a format without open intervals (design section 5.1). */
+  OPEN_INTERVAL: "W_OPEN_INTERVAL",
+  /** Graph-level attributes in a format without them. */
+  GRAPH_ATTRIBUTES: "W_GRAPH_ATTRIBUTES_DROPPED",
+  /** A position column in a format without positions. */
+  POSITIONS: "W_POSITIONS_DROPPED",
+  /** Visual columns in a format without them. */
+  VIZ: "W_VIZ_DROPPED",
+  /** An extension table the format cannot carry. */
+  EXTENSION_TABLE: "W_EXTENSION_TABLE_DROPPED"
+});
+const NO_CAPABILITIES = Object.freeze({
+  mixedDirection: false,
+  multiEdges: false,
+  selfLoops: false,
+  edgeIds: "none",
+  idCharset: "any",
+  dtypes: Object.freeze([]),
+  components: false,
+  lists: false,
+  json: false,
+  defaults: false,
+  options: false,
+  hierarchy: false,
+  temporal: "none",
+  graphAttributes: false,
+  positions: false,
+  viz: false
+});
+function capabilities(supported) {
+  return Object.freeze({ ...NO_CAPABILITIES, ...supported, dtypes: Object.freeze([...supported.dtypes ?? []]) });
+}
+const STRUCTURAL_ROLES = /* @__PURE__ */ new Set(["directed", "pair", "mutual", "weight", "originalId"]);
+const VIZ_ROLES = /* @__PURE__ */ new Set(["color", "size", "shape", "thickness"]);
+const TEMPORAL_ROLES = /* @__PURE__ */ new Set(["start", "end", "timestamp", "timestamps"]);
+const HIERARCHY_ROLES = /* @__PURE__ */ new Set(["parent", "parents"]);
+function checkCapabilities(snapshot, caps, options, extras = {}) {
+  const notes = [];
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  const mixed = countMixedEdges(snapshot);
+  if (mixed > 0 && !caps.mixedDirection) {
+    if (options.onMixedDirection === "error") {
+      note(
+        LOSS.MIXED_DIRECTION_ERROR,
+        `${mixed} undirected edge(s) in a directed graph; the format has no mixed direction and onMixedDirection is "error"`,
+        null,
+        mixed
+      );
+    } else {
+      note(
+        LOSS.MIXED_DIRECTION,
+        `${mixed} undirected edge(s) in a directed graph written as ${options.onMixedDirection}`,
+        null,
+        mixed
+      );
+    }
+  }
+  if (snapshot.flags.multigraph && !caps.multiEdges) {
+    const parallel = countParallelArcs(snapshot);
+    note(LOSS.MULTI_EDGES, `${parallel} parallel edge(s); the format has no parallel edges`, null, parallel);
+  }
+  if (snapshot.selfLoopCount > 0 && !caps.selfLoops) {
+    note(
+      LOSS.SELF_LOOPS,
+      `${snapshot.selfLoopCount} self-loop(s); the format has no self-loops`,
+      null,
+      snapshot.selfLoopCount
+    );
+  }
+  const edgeIds = snapshot.edges.byRole("id");
+  if (caps.edgeIds === "required" && edgeIds === null && snapshot.edgeCount > 0) {
+    note(
+      LOSS.EDGE_IDS_GENERATED,
+      "the format requires edge ids; canonical e0..e{E-1} are generated and not written back",
+      null,
+      snapshot.edgeCount
+    );
+  } else if (caps.edgeIds === "none" && edgeIds !== null) {
+    note(
+      LOSS.EDGE_IDS_DROPPED,
+      `edge id column "${edgeIds.meta.name}" cannot be written`,
+      edgeIds.meta.name,
+      snapshot.edgeCount
+    );
+  }
+  const unrepresentable = countUnrepresentableIds(snapshot, caps.idCharset);
+  if (unrepresentable > 0) {
+    if (caps.idCharset === "dense-1-based") {
+      note(
+        LOSS.ID_RENUMBERED,
+        options.sanitizeIds === "mangle" ? `${unrepresentable} node id(s) are not their 1-based index; nodes are numbered 1..N, the originals kept in the exporter's originalId attribute (restored by restoreMangledIds) and as labels of the nodes without a label value` : `${unrepresentable} node id(s) are not their 1-based index; nodes are numbered 1..N and ids kept as labels of the nodes without a label value (a node with one loses its id)`,
+        null,
+        unrepresentable
+      );
+    } else if (options.sanitizeIds === "mangle") {
+      note(
+        LOSS.ID_MANGLED,
+        `${unrepresentable} node id(s) outside the ${caps.idCharset} charset are rewritten; originals kept in the originalId attribute`,
+        null,
+        unrepresentable
+      );
+    } else {
+      note(
+        LOSS.ID_CHARSET,
+        `${unrepresentable} node id(s) outside the ${caps.idCharset} charset; export() will throw unless sanitizeIds is "mangle"`,
+        null,
+        unrepresentable
+      );
+    }
+  }
+  checkColumns(snapshot.nodes, "node", caps, extras, note);
+  checkColumns(snapshot.edges, "edge", caps, extras, note);
+  const graphColumns = snapshot.graph.names();
+  if (graphColumns.length > 0) {
+    if (caps.graphAttributes) {
+      checkColumns(snapshot.graph, "graph", caps, extras, note);
+    } else {
+      note(
+        LOSS.GRAPH_ATTRIBUTES,
+        `${graphColumns.length} graph attribute(s) cannot be written`,
+        null,
+        graphColumns.length
+      );
+    }
+  }
+  for (const [name, table] of snapshot.extensions) {
+    if (name.startsWith("temporal:")) {
+      if (caps.temporal !== "dynamic-values") {
+        note(
+          LOSS.DYNAMIC_VALUES,
+          `dynamic values of "${name}" (${table.rowCount} row(s)) cannot be written`,
+          name,
+          table.rowCount
+        );
+      }
+    } else {
+      note(
+        LOSS.EXTENSION_TABLE,
+        `extension table "${name}" (${table.rowCount} row(s)) cannot be written`,
+        name,
+        table.rowCount
+      );
+    }
+  }
+  return notes;
+}
+function checkColumns(table, domain, caps, extras, note) {
+  for (const column of table) {
+    const { meta } = column;
+    const { name, role } = meta;
+    if (role !== null && STRUCTURAL_ROLES.has(role)) {
+      continue;
+    }
+    const label = `${domain} column "${name}"`;
+    if (role !== null && extras.roleNames !== void 0) {
+      const fixed = extras.roleNames[role];
+      if (fixed !== void 0 && fixed !== name) {
+        note(
+          LOSS.COLUMN_NAME_CHANGED,
+          `${label} (${role}) is written into the format's ${role} slot and reads back as "${fixed}"`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+    }
+    if (domain === "edge" && role === "id") {
+      continue;
+    }
+    if (role === "timeText") {
+      if (extras.temporalText !== true) {
+        note(
+          LOSS.TEMPORAL_TEXT,
+          `${label} (the lexical form of a temporal column, design section 5.1) cannot be written`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+      continue;
+    }
+    if (role === "position") {
+      if (!caps.positions) {
+        note(LOSS.POSITIONS, `${label} (positions) cannot be written`, name, column.length - column.nullCount);
+      } else if (extras.positionDtype !== void 0 && meta.dtype !== extras.positionDtype) {
+        note(
+          LOSS.DTYPE,
+          `${label} (positions) is ${meta.dtype}; the format reads positions back as ${extras.positionDtype}`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+      continue;
+    }
+    if (role !== null && VIZ_ROLES.has(role)) {
+      if (!caps.viz) {
+        note(LOSS.VIZ, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);
+      }
+      continue;
+    }
+    if (role !== null && HIERARCHY_ROLES.has(role)) {
+      if (!caps.hierarchy) {
+        note(LOSS.HIERARCHY, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);
+      }
+      continue;
+    }
+    if (role !== null && TEMPORAL_ROLES.has(role)) {
+      if (caps.temporal === "none") {
+        note(LOSS.TEMPORAL, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);
+      }
+      continue;
+    }
+    if (role === "spells") {
+      if (caps.temporal !== "spells" && caps.temporal !== "dynamic-values") {
+        note(LOSS.SPELLS, `${label} (spells) cannot be written`, name, column.length - column.nullCount);
+      }
+      continue;
+    }
+    if (role === "open") {
+      if (extras.openIntervals !== true) {
+        note(
+          LOSS.OPEN_INTERVAL,
+          `${label} (open intervals) cannot be written`,
+          name,
+          column.length - column.nullCount
+        );
+      }
+      continue;
+    }
+    if (role !== null && !(extras.roles?.has(role) ?? false)) {
+      note(
+        LOSS.ROLE,
+        `${label} (${role}) is written as a plain attribute; the format has no ${role} slot and the role is lost`,
+        name,
+        column.length - column.nullCount
+      );
+    }
+    if (meta.dynamic && caps.temporal !== "dynamic-values") {
+      note(LOSS.DYNAMIC_VALUES, `${label} is dynamic; only its static value can be written`, name, null);
+    }
+    checkDtype(column, label, caps, note);
+    if (meta.default !== void 0 && !caps.defaults) {
+      note(LOSS.DEFAULT, `${label} declares a default; the format has no defaults`, name, null);
+    }
+    if (meta.options !== null && !caps.options) {
+      note(LOSS.OPTIONS, `${label} declares options; the format has no enumerations`, name, null);
+    }
+  }
+}
+function checkDtype(column, label, caps, note) {
+  const { meta } = column;
+  const { name } = meta;
+  const set = column.length - column.nullCount;
+  switch (meta.dtype) {
+    case "list":
+      if (!caps.lists) {
+        note(LOSS.LIST, `${label} is a list; the format has no lists`, name, set);
+      } else if (meta.itemDtype !== null && !caps.dtypes.includes(meta.itemDtype)) {
+        note(
+          LOSS.DTYPE,
+          `${label} holds ${meta.itemDtype} items; the format cannot keep that dtype`,
+          name,
+          set
+        );
+      } else if (meta.itemDtype === "dict") {
+        note(LOSS.DTYPE, `${label} holds dict items; list items read back as string`, name, set);
+      }
+      break;
+    case "json":
+      if (!caps.json) {
+        note(LOSS.JSON, `${label} holds nested values; the format has no nested values`, name, set);
+      }
+      break;
+    default:
+      if (!caps.dtypes.includes(meta.dtype)) {
+        note(LOSS.DTYPE, `${label} is ${meta.dtype}; the format cannot keep that dtype`, name, set);
+      }
+      if (meta.components > 1 && !caps.components) {
+        note(
+          LOSS.COMPONENTS,
+          `${label} has ${meta.components} components; the format has no strides`,
+          name,
+          set
+        );
+      }
+      break;
+  }
+}
+function countMixedEdges(snapshot) {
+  if (!snapshot.directed) {
+    return 0;
+  }
+  const directed = snapshot.edges.byRole("directed");
+  if (directed === null || directed.dtype !== "bool") {
+    return 0;
+  }
+  const pair = snapshot.edges.byRole("pair");
+  let undirectedRows = 0;
+  let paired = 0;
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (directed.isSet(e) && directed.value(e) === false) {
+      undirectedRows++;
+      if (pair !== null && pair.dtype === "u32" && pair.isSet(e) && pair.data[e] !== INVALID_INDEX) {
+        paired++;
+      }
+    }
+  }
+  return paired / 2 + (undirectedRows - paired);
+}
+function countParallelArcs(snapshot) {
+  const { rowPtr, colIdx, nodeCount } = snapshot;
+  let count = 0;
+  for (let u = 0; u < nodeCount; u++) {
+    for (let a = rowPtr[u] + 1; a < rowPtr[u + 1]; a++) {
+      if (colIdx[a] === colIdx[a - 1]) {
+        count++;
+      }
+    }
+  }
+  return snapshot.directed ? count : Math.ceil(count / 2);
+}
+const NAME_CHAR_RANGES = [
+  [45, 46],
+  [48, 58],
+  [65, 90],
+  [95, 95],
+  [97, 122],
+  [183, 183],
+  [192, 214],
+  [216, 246],
+  [248, 893],
+  [895, 8191],
+  [8204, 8205],
+  [8255, 8256],
+  [8304, 8591],
+  [11264, 12271],
+  [12289, 55295],
+  [63744, 64975],
+  [65008, 65533],
+  [65536, 983039]
+];
+function isNameChar(cp) {
+  for (const [lo, hi] of NAME_CHAR_RANGES) {
+    if (cp < lo) {
+      return false;
+    }
+    if (cp <= hi) {
+      return true;
+    }
+  }
+  return false;
+}
+function isNmtoken(text) {
+  if (text.length === 0) {
+    return false;
+  }
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (cp === void 0 || !isNameChar(cp)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isRepresentableId(id, charset) {
+  switch (charset) {
+    case "any":
+      return true;
+    case "nmtoken":
+      return isNmtoken(String(id));
+    case "integer":
+      return typeof id === "number" && Number.isSafeInteger(id);
+    case "dense-1-based":
+      return false;
+    default: {
+      const name = charset;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown id charset ${name}`, { charset: name });
+    }
+  }
+}
+function countUnrepresentableIds(snapshot, charset) {
+  const { ids } = snapshot;
+  if (charset === "any") {
+    return 0;
+  }
+  if (charset === "dense-1-based") {
+    if (ids.kind === "identity" && ids.offset === 1) {
+      return 0;
+    }
+    let changed = 0;
+    for (let i = 0; i < ids.size; i++) {
+      if (ids.idOf(i) !== i + 1) {
+        changed++;
+      }
+    }
+    return changed;
+  }
+  let count = 0;
+  for (let i = 0; i < ids.size; i++) {
+    if (!isRepresentableId(ids.idOf(i), charset)) {
+      count++;
+    }
+  }
+  return count;
+}
+function sanitizeIds(snapshot, charset, mode) {
+  const { ids } = snapshot;
+  const n = ids.size;
+  if (charset === "dense-1-based") {
+    const changed = countUnrepresentableIds(snapshot, charset);
+    return {
+      charset,
+      changed,
+      idAt: (i) => i + 1,
+      isChanged: (i) => ids.idOf(i) !== i + 1,
+      originalAt: (i) => ids.idOf(i)
+    };
+  }
+  const unchanged = {
+    charset,
+    changed: 0,
+    idAt: (i) => ids.idOf(i),
+    isChanged: () => false,
+    originalAt: (i) => ids.idOf(i)
+  };
+  if (charset === "any") {
+    return unchanged;
+  }
+  const bad = [];
+  for (let i = 0; i < n; i++) {
+    if (!isRepresentableId(ids.idOf(i), charset)) {
+      bad.push(i);
+    }
+  }
+  if (bad.length === 0) {
+    return unchanged;
+  }
+  if (mode === "error") {
+    const first = ids.idOf(bad[0]);
+    throw new GraphFormatError(
+      "E_INVALID_ID",
+      `${bad.length} node id(s) cannot be written as ${charset} (first: ${JSON.stringify(first)} at index ${bad[0]}); pass sanitizeIds: "mangle" to rewrite them`,
+      { reason: "charset", charset, count: bad.length, id: first, index: bad[0] }
+    );
+  }
+  const written = /* @__PURE__ */ new Map();
+  if (charset === "nmtoken") {
+    const used = /* @__PURE__ */ new Set();
+    for (let i = 0; i < n; i++) {
+      const id = ids.idOf(i);
+      if (isRepresentableId(id, charset)) {
+        used.add(String(id));
+      }
+    }
+    for (const i of bad) {
+      const base = mangleNmtoken(String(ids.idOf(i)));
+      let candidate = base;
+      for (let k = 2; used.has(candidate); k++) {
+        candidate = `${base}_${k}`;
+      }
+      used.add(candidate);
+      written.set(i, candidate);
+    }
+  } else {
+    const used = /* @__PURE__ */ new Set();
+    for (let i = 0; i < n; i++) {
+      const id = ids.idOf(i);
+      if (typeof id === "number" && Number.isSafeInteger(id)) {
+        used.add(id);
+      }
+    }
+    let next = 0;
+    for (const i of bad) {
+      while (used.has(next)) {
+        next++;
+      }
+      used.add(next);
+      written.set(i, next);
+      next++;
+    }
+  }
+  return {
+    charset,
+    changed: bad.length,
+    idAt: (i) => written.get(i) ?? ids.idOf(i),
+    isChanged: (i) => written.has(i),
+    originalAt: (i) => ids.idOf(i)
+  };
+}
+function mangleNmtoken(text) {
+  let out = "";
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    out += cp !== void 0 && isNameChar(cp) ? ch : "_";
+  }
+  return out.length === 0 ? "_" : out;
+}
+const DEFAULT_CHUNK_BYTES = 64 * 1024;
+async function* encodeChunks(parts, chunkBytes = DEFAULT_CHUNK_BYTES) {
+  const encoder = new TextEncoder();
+  let pending = [];
+  let pendingUnits = 0;
+  for await (const part of parts) {
+    if (part.length === 0) {
+      continue;
+    }
+    pending.push(part);
+    pendingUnits += part.length;
+    if (pendingUnits >= chunkBytes) {
+      yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(""));
+      pending = [];
+      pendingUnits = 0;
+    }
+  }
+  if (pending.length > 0) {
+    yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(""));
+  }
+}
+async function joinText(parts) {
+  const collected = [];
+  for await (const part of parts) {
+    collected.push(part);
+  }
+  return collected.join("");
+}
+async function decodeChunks(chunks) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const parts = [];
+  for await (const chunk of chunks) {
+    parts.push(decoder.decode(chunk, { stream: true }));
+  }
+  parts.push(decoder.decode());
+  return parts.join("");
+}
+async function collectBytes(chunks) {
+  const parts = [];
+  let total = 0;
+  for await (const chunk of chunks) {
+    parts.push(chunk);
+    total += chunk.byteLength;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.byteLength;
+  }
+  return out;
+}
+function toReadableStream(chunks) {
+  const iterator = chunks[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await iterator.next();
+      if (done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(value);
+    },
+    async cancel() {
+      await iterator.return?.(void 0);
+    }
+  });
+}
+export {
+  TEMPORAL_TEXT_DROPPED_CODE as $,
+  MUTUAL_COLUMN as A,
+  BAD_DEFAULT_CODE as B,
+  COLUMN_RENAMED_CODE as C,
+  DEFAULT_CHUNK_BYTES as D,
+  EMPTY_COLUMN_DROPPED_CODE as E,
+  MUTUAL_EXPANDED_CODE as F,
+  NO_GRAPH_CODE as G,
+  HYPEREDGE_CODE as H,
+  ImportReportBuilder as I,
+  OPTION_IGNORED_CODE as J,
+  PARENTS_DROPPED_CODE as K,
+  LOSS as L,
+  MISSING_ENDPOINT_CODE as M,
+  NO_CAPABILITIES as N,
+  OPTIONS_GAINED_CODE as O,
+  PAIR_COLUMN as P,
+  PARSE_ERROR_CODE as Q,
+  PRECISION_CODE as R,
+  RENAMED_CODE as S,
+  ROLE_ASSUMED_CODE as T,
+  ROLE_DROPPED_CODE as U,
+  ROLE_TAKEN_CODE as V,
+  SINK_OPTION_CODE as W,
+  STORAGE_CLASS_CODE as X,
+  STRAY_TEXT_CODE as Y,
+  SYNTAX_CODE as Z,
+  TEMPORAL_DROPPED_CODE as _,
+  throwIfAborted as a,
+  TEXT_INFERRED_CODE as a0,
+  UNKNOWN_ATTR_TYPE_CODE as a1,
+  UNKNOWN_ELEMENT_CODE as a2,
+  UNKNOWN_PARENT_CODE as a3,
+  UNKNOWN_TYPE_CODE as a4,
+  WEIGHT_KEY_CLASH_CODE as a5,
+  XML_ILLEGAL_CHAR_CODE as a6,
+  XML_SYNTAX_CODE as a7,
+  canonicalId as a8,
+  capabilities as a9,
+  reportUnusedOptions as aA,
+  resolveExportOptions as aB,
+  resolveImportOptions as aC,
+  sanitizeIds as aD,
+  toReadableStream as aE,
+  isNameChar as aF,
+  countMixedEdges as aG,
+  weightFromValue as aH,
+  uniqueColumnName as aI,
+  TIME_TEXT_ROLE as aJ,
+  TIME_TEXT_SUFFIX as aK,
+  declareAttribute as aL,
+  parseDeclaredTemporal as aM,
+  parseDeclaredValue as aN,
+  losesPrecision as aO,
+  parseTimeText as aP,
+  splitListText as aQ,
+  timeTextCompanion as aR,
+  parseDecimalText as aS,
+  formatTimeValue as aT,
+  mapDeclaredType as aU,
+  joinListText as aV,
+  formatTemporal as aW,
+  DictHeuristic as aX,
+  DICT_SAMPLE_ROWS as aY,
+  takenIn as aZ,
+  declareOn as a_,
+  checkCapabilities as aa,
+  coerceId as ab,
+  coerceIdText as ac,
+  collectBytes as ad,
+  declareCompanion as ae,
+  declareResolved as af,
+  decodeChunks as ag,
+  encodeChunks as ah,
+  explicitWeights as ai,
+  formatDecimal as aj,
+  formatF32 as ak,
+  formatF64 as al,
+  formatGmlReal as am,
+  formatInteger as an,
+  inputLength as ao,
+  isAbortError as ap,
+  isCanonicalIntegerText as aq,
+  isImportInput as ar,
+  isNmtoken as as,
+  isWeightField as at,
+  joinText as au,
+  mangleNmtoken as av,
+  pairFolding as aw,
+  parseWeightText as ax,
+  readText as ay,
+  reportSinkOptions as az,
+  BAD_OPTIONS_CODE as b,
+  COLUMN_RENAMED_LOSS_CODE as c,
+  COUNT_HINT_CODE as d,
+  DEFAULT_ERROR_LIMIT as e,
+  DIRECTED_COLUMN as f,
+  DIRECTION_FORCED_CODE as g,
+  DIRECTION_REFUSED_CODE as h,
+  DUPLICATE_EDGE_ID_CODE as i,
+  DUPLICATE_KEY_CODE as j,
+  DUPLICATE_NODE_CODE as k,
+  DirectionResolver as l,
+  EMPTY_INPUT_CODE as m,
+  ID_MERGED_CODE as n,
+  ID_TEXT_COLLISION_CODE as o,
+  ID_TEXT_TYPE_CODE as p,
+  INTEGRAL_F64_CODE as q,
+  INVALID_UTF8_CODE as r,
+  IdCoercer as s,
+  textChunks as t,
+  ImportError as u,
+  LineReader as v,
+  MISSING_ID_CODE as w,
+  MIXED_DIRECTION_CODE as x,
+  MULTIPLE_GRAPHS_CODE as y,
+  MUTUAL_AS_UNDIRECTED_CODE as z
+};
+//# sourceMappingURL=writer-DxSKC7TL.js.map