@graphty/graph-io 0.3.24 → 0.3.26

package/dist/chunks/report-B1z4WT9e.js

@@ -1,2372 +0,0 @@
-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 INVALID_ENCODING_CODE = "E_INVALID_ENCODING";
-const ENCODING_FALLBACK_CODE = "W_ENCODING_FALLBACK";
-const UNKNOWN_ENCODING_CODE = "W_UNKNOWN_ENCODING";
-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 BAD_VALUE_CODE = "E_BAD_VALUE";
-const WIDENED_CODE = "W_WIDENED";
-const DANGLING_REFERENCE_CODE = "W_DANGLING_REFERENCE";
-const DUPLICATE_ATTRIBUTE_CODE = "W_DUPLICATE_ATTRIBUTE";
-const PARENT_CYCLE_CODE = "E_PARENT_CYCLE";
-const EQUATION_AS_TEXT_CODE = "W_EQUATION_AS_TEXT";
-const STYLES_NOT_IMPORTED_CODE = "W_STYLES_NOT_IMPORTED";
-const BAD_ASPECT_BLOCK_CODE = "E_BAD_ASPECT_BLOCK";
-const ASPECT_ORDER_CODE = "W_ASPECT_ORDER";
-const COUNT_MISMATCH_CODE = "W_COUNT_MISMATCH";
-const STATUS_FAILED_CODE = "E_STATUS_FAILED";
-const STATUS_WARNING_CODE = "W_STATUS_WARNING";
-const TOO_LARGE_CODE = "E_TOO_LARGE";
-const GRAPH_NOT_FOUND_CODE = "E_GRAPH_NOT_FOUND";
-const AMBIGUOUS_GRAPH_NAME_CODE = "E_AMBIGUOUS_GRAPH_NAME";
-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 HEAD_BYTES = 1024;
-const BOM_BYTES = 3;
-function canonicalEncoding(label) {
-  try {
-    return new TextDecoder(label.trim()).encoding;
-  } catch {
-    return null;
-  }
-}
-function bomEncoding(head) {
-  if (head.byteLength >= 3 && head[0] === 239 && head[1] === 187 && head[2] === 191) {
-    return "utf-8";
-  }
-  if (head.byteLength >= 2 && head[0] === 255 && head[1] === 254) {
-    return "utf-16le";
-  }
-  if (head.byteLength >= 2 && head[0] === 254 && head[1] === 255) {
-    return "utf-16be";
-  }
-  return null;
-}
-class ByteDecoder {
-  /**
-   * Create the decoder of one import.
-   * @param report - where warnings and the fatal decode error go
-   * @param options - the encoding option and the format's declaration reader
-   */
-  constructor(report, options) {
-    this.report = report;
-    this.options = options;
-    this.decoder = null;
-    this.encoding = "utf-8";
-    this.mayFallBack = false;
-    this.asciiSoFar = true;
-    this.carry = new Uint8Array(0);
-    this.offset = 0;
-  }
-  /**
-   * Whether start() ran.
-   * @returns true once the encoding is chosen
-   */
-  get started() {
-    return this.decoder !== null;
-  }
-  /**
-   * Choose the encoding from the first bytes of the input.
-   * @param head - the first bytes (up to HEAD_BYTES; fewer when the input is shorter)
-   */
-  start(head) {
-    const explicit = this.options.encoding ?? null;
-    if (explicit !== null) {
-      this.use(explicit, false);
-      return;
-    }
-    const bom = bomEncoding(head);
-    if (bom !== null) {
-      this.use(bom, false);
-      return;
-    }
-    const declared = this.options.declaredEncoding?.(new TextDecoder("windows-1252").decode(head)) ?? null;
-    if (declared !== null) {
-      const canonical = canonicalEncoding(declared);
-      if (canonical === null) {
-        this.report.warning(
-          "unsupported",
-          UNKNOWN_ENCODING_CODE,
-          `the input declares the encoding ${JSON.stringify(declared)}, which this platform cannot decode; reading it as UTF-8`,
-          { element: declared }
-        );
-      } else if (canonical !== "utf-8" && !canonical.startsWith("utf-16")) {
-        this.use(canonical, false);
-        return;
-      }
-    }
-    this.use("utf-8", true);
-  }
-  /**
-   * Decode the next bytes.
-   * @param bytes - the bytes
-   * @param stream - whether more bytes follow
-   * @returns the text
-   */
-  decode(bytes, stream) {
-    const decoder = this.decoder;
-    let text;
-    try {
-      text = decoder.decode(bytes, { stream });
-    } catch (err) {
-      if (!(err instanceof TypeError)) {
-        throw err;
-      }
-      text = this.recover(bytes, stream);
-    }
-    if (this.asciiSoFar && this.mayFallBack) {
-      if (/[\u0080-\uffff]/.test(text)) {
-        this.asciiSoFar = false;
-        this.carry = new Uint8Array(0);
-      } else {
-        const all = this.carry.byteLength === 0 ? bytes : concatBytes([this.carry, bytes]);
-        this.carry = all.slice(text.length);
-      }
-    }
-    this.offset += bytes.byteLength;
-    return text;
-  }
-  /**
-   * A decode failed: switch to windows-1252 when allowed, else fail the import.
-   * @param bytes - the bytes that failed
-   * @param stream - whether more bytes follow
-   * @returns the bytes decoded as windows-1252
-   */
-  recover(bytes, stream) {
-    const where = { byteOffset: this.offset };
-    const all = this.carry.byteLength === 0 ? bytes : concatBytes([this.carry, bytes]);
-    if (this.mayFallBack && this.asciiSoFar && !all.includes(0) && !startsWithUtf8(all)) {
-      this.report.warning(
-        "coercion",
-        ENCODING_FALLBACK_CODE,
-        `the input is not valid UTF-8 (near byte ${this.offset}) and declares no encoding; read as windows-1252 (pass the encoding option to choose another)`
-      );
-      this.use("windows-1252", false);
-      return this.decoder.decode(all, { stream });
-    }
-    if (this.encoding === "utf-8") {
-      const after = this.mayFallBack ? " after valid non-ASCII UTF-8 text; pass the encoding option" : "";
-      return this.report.fail(
-        INVALID_UTF8_CODE,
-        `invalid UTF-8 near byte ${this.offset}${after}`,
-        void 0,
-        where
-      );
-    }
-    return this.report.fail(
-      INVALID_ENCODING_CODE,
-      `the bytes near byte ${this.offset} are not valid ${this.encoding}`,
-      void 0,
-      where
-    );
-  }
-  /**
-   * Switch to an encoding.
-   * @param label - the encoding label
-   * @param mayFallBack - whether a UTF-8 failure may switch to windows-1252
-   */
-  use(label, mayFallBack) {
-    this.decoder = new TextDecoder(label, { fatal: true, ignoreBOM: true });
-    this.encoding = this.decoder.encoding;
-    this.mayFallBack = mayFallBack;
-  }
-}
-function startsWithUtf8(bytes) {
-  const i = bytes.findIndex((b) => b >= 128);
-  const lead = bytes[i];
-  let length = 0;
-  if (lead >= 194 && lead <= 223) {
-    length = 2;
-  } else if (lead >= 224 && lead <= 239) {
-    length = 3;
-  } else if (lead >= 240 && lead <= 244) {
-    length = 4;
-  }
-  if (i < 0 || length === 0 || i + length > bytes.byteLength) {
-    return false;
-  }
-  try {
-    new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(i, i + length));
-    return true;
-  } catch {
-    return false;
-  }
-}
-function decodeEntryName(bytes) {
-  try {
-    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
-  } catch {
-    return new TextDecoder("windows-1252").decode(bytes);
-  }
-}
-function concatBytes(chunks) {
-  if (chunks.length === 1) {
-    return chunks[0];
-  }
-  const out = new Uint8Array(chunks.reduce((sum, c) => sum + c.byteLength, 0));
-  let offset = 0;
-  for (const chunk of chunks) {
-    out.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return out;
-}
-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 ByteDecoder(report, options);
-  if (input instanceof Uint8Array) {
-    decoder.start(input.subarray(0, HEAD_BYTES));
-    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(decoder.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 needed = options.declaredEncoding === void 0 ? BOM_BYTES : HEAD_BYTES;
-  let head = [];
-  let headLength = 0;
-  const flushHead = (stream) => {
-    const bytes = concatBytes(head);
-    head = [];
-    headLength = 0;
-    decoder.start(bytes.subarray(0, HEAD_BYTES));
-    return decoder.decode(bytes, stream);
-  };
-  const chunks = isReadableStream(input) ? streamChunks(input, signal) : input;
-  for await (const chunk of chunks) {
-    throwIfAborted(signal);
-    let text;
-    if (typeof chunk === "string") {
-      let pending = "";
-      if (!decoder.started && headLength > 0) {
-        pending = flushHead(false);
-      } else if (decoder.started) {
-        pending = decoder.decode(new Uint8Array(0), false);
-      }
-      text = emit(pending + chunk);
-      done += chunk.length;
-    } else if (chunk instanceof Uint8Array) {
-      done += chunk.byteLength;
-      if (decoder.started) {
-        text = emit(decoder.decode(chunk, true));
-      } else {
-        head.push(chunk);
-        headLength += chunk.byteLength;
-        text = headLength >= needed ? emit(flushHead(true)) : "";
-      }
-    } 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);
-  }
-  let tail = "";
-  if (!decoder.started && headLength > 0) {
-    tail = flushHead(false);
-  } else if (decoder.started) {
-    tail = decoder.decode(new Uint8Array(0), false);
-  }
-  tail = emit(tail);
-  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 readBytes(input, options = {}) {
-  const signal = options.signal ?? null;
-  throwIfAborted(signal);
-  if (typeof input === "string") {
-    return null;
-  }
-  if (input instanceof Uint8Array) {
-    options.onProgress?.(input.byteLength, input.byteLength);
-    return input;
-  }
-  const parts = [];
-  let done = 0;
-  for await (const chunk of isReadableStream(input) ? streamChunks(input, signal) : input) {
-    throwIfAborted(signal);
-    if (typeof chunk === "string") {
-      return null;
-    }
-    if (!(chunk instanceof Uint8Array)) {
-      throw new GraphFormatError("E_UNSUPPORTED", "an input chunk must be a string or a Uint8Array", {
-        reason: "chunk type",
-        found: typeof chunk
-      });
-    }
-    parts.push(chunk);
-    done += chunk.byteLength;
-    options.onProgress?.(done);
-  }
-  options.onProgress?.(done, done);
-  return parts.length === 0 ? new Uint8Array(0) : concatBytes(parts);
-}
-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 chooseGraph(names, options, report) {
-  const { graphIndex, graphName } = options ?? {};
-  if (graphIndex !== void 0 && (typeof graphIndex !== "number" || !Number.isInteger(graphIndex) || graphIndex < 0)) {
-    throw new GraphFormatError(
-      "E_UNSUPPORTED",
-      `option graphIndex: ${describe(graphIndex)} is not a non-negative integer`,
-      {
-        option: "graphIndex",
-        found: graphIndex
-      }
-    );
-  }
-  if (graphName !== void 0 && typeof graphName !== "string") {
-    throw new GraphFormatError("E_UNSUPPORTED", `option graphName: ${describe(graphName)} is not a string`, {
-      option: "graphName",
-      found: graphName
-    });
-  }
-  if (graphIndex !== void 0 && graphName !== void 0) {
-    throw new GraphFormatError("E_UNSUPPORTED", "options graphIndex and graphName both choose a graph; pass one", {
-      option: "graphName",
-      found: graphName
-    });
-  }
-  if (names.length === 0) {
-    return report.fail(NO_GRAPH_CODE, "the input holds no graph");
-  }
-  if (graphName !== void 0) {
-    const matches = names.flatMap((name, i) => name === graphName ? [i] : []);
-    if (matches.length > 1) {
-      return report.fail(
-        AMBIGUOUS_GRAPH_NAME_CODE,
-        `graphName ${JSON.stringify(graphName)} names the graphs at indexes ${matches.join(", ")}; pass graphIndex`,
-        { element: graphName }
-      );
-    }
-    if (matches.length === 0) {
-      return report.fail(
-        GRAPH_NOT_FOUND_CODE,
-        `graphName ${JSON.stringify(graphName)} names none of the ${names.length} graph(s)`,
-        { element: graphName },
-        { names: [...names] }
-      );
-    }
-    return matches[0];
-  }
-  const index = graphIndex ?? 0;
-  if (index >= names.length) {
-    return report.fail(GRAPH_NOT_FOUND_CODE, `graphIndex ${index} is beyond the ${names.length} graph(s)`);
-  }
-  return index;
-}
-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),
-    encoding: encodingOption(o.encoding)
-  });
-}
-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 encodingOption(value) {
-  if (value === void 0 || value === null) {
-    return null;
-  }
-  const canonical = typeof value === "string" ? canonicalEncoding(value) : null;
-  if (canonical === null) {
-    throw new GraphFormatError(
-      "E_UNSUPPORTED",
-      `option encoding: ${describe(value)} is not an encoding this platform's TextDecoder knows`,
-      { option: "encoding", found: value }
-    );
-  }
-  return canonical;
-}
-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();
-}
-export {
-  OPTIONS_GAINED_CODE as $,
-  AMBIGUOUS_GRAPH_NAME_CODE as A,
-  BAD_VALUE_CODE as B,
-  COLUMN_RENAMED_CODE as C,
-  DIRECTION_FORCED_CODE as D,
-  ENCODING_FALLBACK_CODE as E,
-  reportSinkOptions as F,
-  GRAPH_NOT_FOUND_CODE as G,
-  chooseGraph as H,
-  ID_MERGED_CODE as I,
-  DirectionResolver as J,
-  IdCoercer as K,
-  declareResolved as L,
-  MULTIPLE_GRAPHS_CODE as M,
-  NO_GRAPH_CODE as N,
-  OPTION_IGNORED_CODE as O,
-  PRECISION_CODE as P,
-  uniqueColumnName as Q,
-  ROLE_TAKEN_CODE as R,
-  SINK_OPTION_CODE as S,
-  TOO_LARGE_CODE as T,
-  UNKNOWN_PARENT_CODE as U,
-  resolveExportOptions as V,
-  WIDENED_CODE as W,
-  pairFolding as X,
-  UNKNOWN_ELEMENT_CODE as Y,
-  BAD_DEFAULT_CODE as Z,
-  DictHeuristic as _,
-  DIRECTION_REFUSED_CODE as a,
-  XML_ILLEGAL_CHAR_CODE as a0,
-  TEXT_INFERRED_CODE as a1,
-  INTEGRAL_F64_CODE as a2,
-  STORAGE_CLASS_CODE as a3,
-  EMPTY_COLUMN_DROPPED_CODE as a4,
-  COLUMN_RENAMED_LOSS_CODE as a5,
-  ROLE_ASSUMED_CODE as a6,
-  WEIGHT_KEY_CLASH_CODE as a7,
-  ID_TEXT_COLLISION_CODE as a8,
-  MUTUAL_AS_UNDIRECTED_CODE as a9,
-  declareCompanion as aA,
-  decodeEntryName as aB,
-  inputLength as aC,
-  isAbortError as aD,
-  isCanonicalIntegerText as aE,
-  isImportInput as aF,
-  readText as aG,
-  parseDecimalText as aH,
-  TIME_TEXT_ROLE as aI,
-  TIME_TEXT_SUFFIX as aJ,
-  declareAttribute as aK,
-  parseDeclaredTemporal as aL,
-  parseDeclaredValue as aM,
-  losesPrecision as aN,
-  parseTimeText as aO,
-  splitListText as aP,
-  timeTextCompanion as aQ,
-  formatTimeValue as aR,
-  mapDeclaredType as aS,
-  joinListText as aT,
-  formatTemporal as aU,
-  DICT_SAMPLE_ROWS as aV,
-  declareOn as aW,
-  takenIn as aX,
-  readBytes as aY,
-  MUTUAL_EXPANDED_CODE as aa,
-  PARENTS_DROPPED_CODE as ab,
-  ROLE_DROPPED_CODE as ac,
-  TEMPORAL_TEXT_DROPPED_CODE as ad,
-  TEMPORAL_DROPPED_CODE as ae,
-  MIXED_DIRECTION_CODE as af,
-  describe as ag,
-  BAD_OPTIONS_CODE as ah,
-  COUNT_HINT_CODE as ai,
-  DEFAULT_ERROR_LIMIT as aj,
-  DIRECTED_COLUMN as ak,
-  DUPLICATE_KEY_CODE as al,
-  EQUATION_AS_TEXT_CODE as am,
-  HYPEREDGE_CODE as an,
-  ImportError as ao,
-  LineReader as ap,
-  MUTUAL_COLUMN as aq,
-  PAIR_COLUMN as ar,
-  PARSE_ERROR_CODE as as,
-  RENAMED_CODE as at,
-  STRAY_TEXT_CODE as au,
-  UNKNOWN_TYPE_CODE as av,
-  XML_SYNTAX_CODE as aw,
-  canonicalId as ax,
-  coerceId as ay,
-  coerceIdText as az,
-  ID_TEXT_TYPE_CODE as b,
-  DUPLICATE_EDGE_ID_CODE as c,
-  DUPLICATE_NODE_CODE as d,
-  MISSING_ENDPOINT_CODE as e,
-  MISSING_ID_CODE as f,
-  STYLES_NOT_IMPORTED_CODE as g,
-  PARENT_CYCLE_CODE as h,
-  DUPLICATE_ATTRIBUTE_CODE as i,
-  DANGLING_REFERENCE_CODE as j,
-  UNKNOWN_ATTR_TYPE_CODE as k,
-  COUNT_MISMATCH_CODE as l,
-  ASPECT_ORDER_CODE as m,
-  BAD_ASPECT_BLOCK_CODE as n,
-  STATUS_WARNING_CODE as o,
-  STATUS_FAILED_CODE as p,
-  UNKNOWN_ENCODING_CODE as q,
-  INVALID_ENCODING_CODE as r,
-  INVALID_UTF8_CODE as s,
-  SYNTAX_CODE as t,
-  EMPTY_INPUT_CODE as u,
-  resolveImportOptions as v,
-  ImportReportBuilder as w,
-  textChunks as x,
-  throwIfAborted as y,
-  reportUnusedOptions as z
-};
-//# sourceMappingURL=report-B1z4WT9e.js.map