@graphty/graph-io 0.3.48 → 0.3.50

package/dist/chunks/styles-CPczw1Jz.js

@@ -0,0 +1,1928 @@
+import { T as TIME_TEXT_ROLE, J as TIME_TEXT_SUFFIX, e as explicitWeights } from "./export-Cha4dRFz.js";
+import { S as STYLE_BLOCK_NAME, h as StyleNotes, p as plainCell, f as canonText, d as canonColor, c as canonNumber, a as canonEnum } from "./block-yl0f_qLO.js";
+import { S as StyleApproximations } from "./approximations-BRXsll0T.js";
+import { t as takeFromBlock } from "./round-trip-Cy3_SHRZ.js";
+const GEXF_FORMAT = "gexf";
+const GEXF_NAMESPACES = {
+  "1.2": { gexf: "http://www.gexf.net/1.2draft", viz: "http://www.gexf.net/1.2draft/viz" },
+  "1.3": { gexf: "http://gexf.net/1.3", viz: "http://gexf.net/1.3/viz" }
+};
+const TIME_FORMATS = /* @__PURE__ */ new Set(["integer", "double", "date", "dateTime"]);
+const GRAPH_MODES = /* @__PURE__ */ new Set(["static", "dynamic", "slice"]);
+const TIME_REPRESENTATIONS = /* @__PURE__ */ new Set(["interval", "timestamp"]);
+const VIZ_NAMESPACE = "viz";
+const XML_ORIGIN = { format: GEXF_FORMAT };
+const VIZ_ORIGIN = { format: GEXF_FORMAT, namespace: VIZ_NAMESPACE };
+const NODE_COLUMNS = Object.freeze({
+  label: "label",
+  parent: "parent",
+  parents: "parents",
+  start: "start",
+  end: "end",
+  timestamp: "timestamp",
+  spells: "spells",
+  spellsOpen: "spells.open",
+  timestamps: "timestamps",
+  open: "open",
+  position: "position",
+  color: "color",
+  size: "size",
+  shape: "shape",
+  shapeUri: "shape.uri"
+});
+const EDGE_COLUMNS = Object.freeze({
+  id: "id",
+  label: "label",
+  kind: "kind",
+  start: "start",
+  end: "end",
+  timestamp: "timestamp",
+  spells: "spells",
+  spellsOpen: "spells.open",
+  timestamps: "timestamps",
+  open: "open",
+  color: "color",
+  thickness: "thickness",
+  shape: "shape"
+});
+const RESERVED_NODE_NAMES = /* @__PURE__ */ new Set([
+  ...Object.values(NODE_COLUMNS),
+  NODE_COLUMNS.start + TIME_TEXT_SUFFIX,
+  NODE_COLUMNS.end + TIME_TEXT_SUFFIX,
+  NODE_COLUMNS.timestamp + TIME_TEXT_SUFFIX
+]);
+const RESERVED_EDGE_NAMES = /* @__PURE__ */ new Set([
+  ...Object.values(EDGE_COLUMNS),
+  EDGE_COLUMNS.start + TIME_TEXT_SUFFIX,
+  EDGE_COLUMNS.end + TIME_TEXT_SUFFIX,
+  EDGE_COLUMNS.timestamp + TIME_TEXT_SUFFIX
+]);
+const NODE_DECLS = {
+  label: { name: NODE_COLUMNS.label, dtype: "string", role: "label", nullable: true, origin: XML_ORIGIN },
+  parent: {
+    name: NODE_COLUMNS.parent,
+    dtype: "u32",
+    role: "parent",
+    refersTo: "node",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  parents: {
+    name: NODE_COLUMNS.parents,
+    dtype: "list",
+    itemDtype: "u32",
+    role: "parents",
+    refersTo: "node",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  start: { name: NODE_COLUMNS.start, dtype: "f64", role: "start", nullable: true, origin: XML_ORIGIN },
+  end: { name: NODE_COLUMNS.end, dtype: "f64", role: "end", nullable: true, origin: XML_ORIGIN },
+  timestamp: { name: NODE_COLUMNS.timestamp, dtype: "f64", role: "timestamp", nullable: true, origin: XML_ORIGIN },
+  spells: {
+    name: NODE_COLUMNS.spells,
+    dtype: "list",
+    itemDtype: "f64",
+    itemComponents: 2,
+    role: "spells",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  timestamps: {
+    name: NODE_COLUMNS.timestamps,
+    dtype: "list",
+    itemDtype: "f64",
+    role: "timestamps",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  open: { name: NODE_COLUMNS.open, dtype: "u8", role: "open", nullable: true, origin: XML_ORIGIN },
+  spellsOpen: {
+    name: NODE_COLUMNS.spellsOpen,
+    dtype: "list",
+    itemDtype: "u8",
+    role: "spellsOpen",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  position: {
+    name: NODE_COLUMNS.position,
+    dtype: "f64",
+    components: 3,
+    role: "position",
+    mutable: true,
+    nullable: true,
+    origin: VIZ_ORIGIN,
+    // Gephi puts a node with no viz:position at the origin (gexf-specimen-node-sizes-opacity: position-none)
+    extra: { units: "file", originUnplaced: true }
+  },
+  color: {
+    name: NODE_COLUMNS.color,
+    dtype: "f32",
+    components: 4,
+    role: "color",
+    nullable: true,
+    origin: VIZ_ORIGIN
+  },
+  size: { name: NODE_COLUMNS.size, dtype: "f32", role: "size", nullable: true, origin: VIZ_ORIGIN },
+  shape: { name: NODE_COLUMNS.shape, dtype: "dict", role: "shape", nullable: true, origin: VIZ_ORIGIN },
+  shapeUri: { name: NODE_COLUMNS.shapeUri, dtype: "string", nullable: true, origin: VIZ_ORIGIN }
+};
+const EDGE_DECLS = {
+  id: { name: EDGE_COLUMNS.id, dtype: "string", role: "id", unique: true, nullable: true, origin: XML_ORIGIN },
+  label: { name: EDGE_COLUMNS.label, dtype: "string", role: "label", nullable: true, origin: XML_ORIGIN },
+  kind: { name: EDGE_COLUMNS.kind, dtype: "dict", role: "kind", nullable: true, origin: XML_ORIGIN },
+  start: { name: EDGE_COLUMNS.start, dtype: "f64", role: "start", nullable: true, origin: XML_ORIGIN },
+  end: { name: EDGE_COLUMNS.end, dtype: "f64", role: "end", nullable: true, origin: XML_ORIGIN },
+  timestamp: { name: EDGE_COLUMNS.timestamp, dtype: "f64", role: "timestamp", nullable: true, origin: XML_ORIGIN },
+  spells: {
+    name: EDGE_COLUMNS.spells,
+    dtype: "list",
+    itemDtype: "f64",
+    itemComponents: 2,
+    role: "spells",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  timestamps: {
+    name: EDGE_COLUMNS.timestamps,
+    dtype: "list",
+    itemDtype: "f64",
+    role: "timestamps",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  open: { name: EDGE_COLUMNS.open, dtype: "u8", role: "open", nullable: true, origin: XML_ORIGIN },
+  spellsOpen: {
+    name: EDGE_COLUMNS.spellsOpen,
+    dtype: "list",
+    itemDtype: "u8",
+    role: "spellsOpen",
+    nullable: true,
+    origin: XML_ORIGIN
+  },
+  color: {
+    name: EDGE_COLUMNS.color,
+    dtype: "f32",
+    components: 4,
+    role: "color",
+    nullable: true,
+    origin: VIZ_ORIGIN
+  },
+  thickness: { name: EDGE_COLUMNS.thickness, dtype: "f32", role: "thickness", nullable: true, origin: VIZ_ORIGIN },
+  shape: { name: EDGE_COLUMNS.shape, dtype: "dict", role: "shape", nullable: true, origin: VIZ_ORIGIN }
+};
+const OPEN_START = 1;
+const OPEN_END = 2;
+const TEMPORAL_TABLE_PREFIX = "temporal:";
+const TEMPORAL_COLUMNS = Object.freeze({
+  element: "element",
+  start: "start",
+  end: "end",
+  value: "value",
+  open: "open",
+  startText: `start${TIME_TEXT_SUFFIX}`,
+  endText: `end${TIME_TEXT_SUFFIX}`,
+  valueText: `value${TIME_TEXT_SUFFIX}`
+});
+function temporalTableName(domain, column) {
+  return `${TEMPORAL_TABLE_PREFIX}${domain}:${column}`;
+}
+function parseTemporalTableName(name) {
+  if (!name.startsWith(TEMPORAL_TABLE_PREFIX)) {
+    return null;
+  }
+  const rest = name.slice(TEMPORAL_TABLE_PREFIX.length);
+  const colon = rest.indexOf(":");
+  if (colon < 0) {
+    return null;
+  }
+  const domain = rest.slice(0, colon);
+  if (domain !== "node" && domain !== "edge") {
+    return null;
+  }
+  return { domain, column: rest.slice(colon + 1) };
+}
+function temporalTableDecls(domain, value, temporalValue) {
+  const decls = [
+    { name: TEMPORAL_COLUMNS.element, dtype: "u32", refersTo: domain, nullable: false },
+    { name: TEMPORAL_COLUMNS.start, dtype: "f64", role: "start", nullable: true },
+    { name: TEMPORAL_COLUMNS.end, dtype: "f64", role: "end", nullable: true },
+    { name: TEMPORAL_COLUMNS.value, ...value, nullable: true },
+    {
+      name: TEMPORAL_COLUMNS.startText,
+      dtype: "string",
+      role: TIME_TEXT_ROLE,
+      nullable: true,
+      extra: { for: TEMPORAL_COLUMNS.start }
+    },
+    { name: TEMPORAL_COLUMNS.endText, dtype: "string", nullable: true, extra: { for: TEMPORAL_COLUMNS.end } },
+    { name: TEMPORAL_COLUMNS.open, dtype: "u8", role: "open", nullable: true }
+  ];
+  if (temporalValue) {
+    decls.push({
+      name: TEMPORAL_COLUMNS.valueText,
+      dtype: "string",
+      nullable: true,
+      extra: { for: TEMPORAL_COLUMNS.value }
+    });
+  }
+  return decls;
+}
+const TYPES_1_2 = /* @__PURE__ */ new Set(["integer", "long", "double", "float", "boolean", "string", "anyURI"]);
+const TYPES_1_3 = /* @__PURE__ */ new Set([
+  ...TYPES_1_2,
+  "bigdecimal",
+  "biginteger",
+  "byte",
+  "char",
+  "short",
+  "date",
+  "dateTime"
+]);
+function isScalarType(type, version) {
+  return (version === "1.2" ? TYPES_1_2 : TYPES_1_3).has(type);
+}
+function isListType(type, version) {
+  return type.startsWith("list") && type.length > 4 && isScalarType(type.slice(4), "1.3");
+}
+function canonicalScalarType(dtype) {
+  switch (dtype) {
+    case "bool":
+      return "boolean";
+    case "i32":
+    case "u8":
+      return "integer";
+    case "u32":
+      return "long";
+    case "f32":
+      return "float";
+    case "f64":
+      return "double";
+    case "dict":
+    case "string":
+    case "json":
+    case "list":
+      return "string";
+    default: {
+      const name = dtype;
+      return name;
+    }
+  }
+}
+const ASCII = [
+  318,
+  401,
+  460,
+  838,
+  636,
+  950,
+  780,
+  275,
+  390,
+  390,
+  500,
+  838,
+  318,
+  361,
+  318,
+  337,
+  636,
+  636,
+  636,
+  636,
+  636,
+  636,
+  636,
+  636,
+  636,
+  636,
+  337,
+  337,
+  838,
+  838,
+  838,
+  531,
+  1e3,
+  684,
+  686,
+  698,
+  770,
+  632,
+  575,
+  775,
+  752,
+  295,
+  295,
+  656,
+  557,
+  863,
+  748,
+  787,
+  603,
+  787,
+  695,
+  635,
+  611,
+  732,
+  684,
+  989,
+  685,
+  611,
+  685,
+  390,
+  337,
+  390,
+  838,
+  500,
+  500,
+  613,
+  635,
+  550,
+  635,
+  615,
+  352,
+  635,
+  634,
+  278,
+  278,
+  579,
+  278,
+  974,
+  634,
+  612,
+  635,
+  635,
+  411,
+  521,
+  392,
+  634,
+  592,
+  818,
+  592,
+  592,
+  525,
+  636,
+  337,
+  636,
+  838
+];
+const LATIN = [
+  318,
+  401,
+  636,
+  636,
+  636,
+  636,
+  337,
+  500,
+  500,
+  1e3,
+  471,
+  612,
+  838,
+  361,
+  1e3,
+  500,
+  500,
+  838,
+  401,
+  401,
+  500,
+  636,
+  636,
+  318,
+  500,
+  401,
+  471,
+  612,
+  969,
+  969,
+  969,
+  531,
+  684,
+  684,
+  684,
+  684,
+  684,
+  684,
+  974,
+  698,
+  632,
+  632,
+  632,
+  632,
+  295,
+  295,
+  295,
+  295,
+  775,
+  748,
+  787,
+  787,
+  787,
+  787,
+  787,
+  838,
+  787,
+  732,
+  732,
+  732,
+  732,
+  611,
+  605,
+  630,
+  613,
+  613,
+  613,
+  613,
+  613,
+  613,
+  982,
+  550,
+  615,
+  615,
+  615,
+  615,
+  278,
+  278,
+  278,
+  278,
+  612,
+  634,
+  612,
+  612,
+  612,
+  612,
+  612,
+  838,
+  612,
+  634,
+  634,
+  634,
+  634,
+  592,
+  635,
+  592,
+  684,
+  613,
+  684,
+  613,
+  684,
+  613,
+  698,
+  550,
+  698,
+  550,
+  698,
+  550,
+  698,
+  550,
+  770,
+  635,
+  775,
+  635,
+  632,
+  615,
+  632,
+  615,
+  632,
+  615,
+  632,
+  615,
+  632,
+  615,
+  775,
+  635,
+  775,
+  635,
+  775,
+  635,
+  775,
+  635,
+  752,
+  634,
+  916,
+  695,
+  295,
+  278,
+  295,
+  278,
+  295,
+  278,
+  295,
+  278,
+  295,
+  278,
+  590,
+  556,
+  295,
+  278,
+  656,
+  579,
+  579,
+  557,
+  278,
+  557,
+  278,
+  557,
+  375,
+  557,
+  342,
+  562,
+  284,
+  748,
+  634,
+  748,
+  634,
+  748,
+  634,
+  813,
+  748,
+  634,
+  787,
+  612,
+  787,
+  612,
+  787,
+  612,
+  1070,
+  1023,
+  695,
+  411,
+  695,
+  411,
+  695,
+  411,
+  635,
+  521,
+  635,
+  521,
+  635,
+  521,
+  635,
+  521,
+  611,
+  392,
+  611,
+  392,
+  611,
+  392,
+  732,
+  634,
+  732,
+  634,
+  732,
+  634,
+  732,
+  634,
+  732,
+  634,
+  732,
+  634,
+  989,
+  818,
+  611,
+  592,
+  611,
+  685,
+  525,
+  685,
+  525,
+  685,
+  525,
+  352,
+  635,
+  735,
+  686,
+  635,
+  686,
+  635,
+  703,
+  698,
+  550,
+  775,
+  819,
+  686,
+  635,
+  612,
+  632,
+  787,
+  614,
+  575,
+  352,
+  775,
+  687,
+  984,
+  354,
+  295,
+  746,
+  579,
+  278,
+  592,
+  974,
+  748,
+  634,
+  787,
+  913,
+  612,
+  949,
+  759,
+  652,
+  635,
+  695,
+  635,
+  521,
+  632,
+  336,
+  392,
+  611,
+  392,
+  611,
+  858,
+  634,
+  764,
+  721,
+  744,
+  730,
+  685,
+  525,
+  666,
+  666,
+  578,
+  525,
+  636,
+  666,
+  578,
+  510,
+  635,
+  295,
+  492,
+  459,
+  295,
+  1422,
+  1299,
+  1154,
+  835,
+  787,
+  457,
+  931,
+  924,
+  797,
+  684,
+  613,
+  295,
+  278,
+  787,
+  612,
+  732,
+  634,
+  732,
+  634,
+  732,
+  634,
+  732,
+  634,
+  732,
+  634,
+  615,
+  684,
+  613,
+  684,
+  613,
+  974,
+  982,
+  775,
+  635,
+  775,
+  635,
+  656,
+  579,
+  787,
+  612,
+  787,
+  612,
+  666,
+  578,
+  278,
+  1422,
+  1299,
+  1154,
+  775,
+  635,
+  1113,
+  682,
+  748,
+  634,
+  684,
+  613,
+  974,
+  982,
+  787,
+  612,
+  684,
+  613,
+  684,
+  613,
+  632,
+  615,
+  632,
+  615,
+  295,
+  278,
+  295,
+  278,
+  787,
+  612,
+  787,
+  612,
+  695,
+  411,
+  695,
+  411,
+  732,
+  634,
+  732,
+  634,
+  635,
+  521,
+  611,
+  392,
+  627,
+  521,
+  752,
+  634,
+  735,
+  838,
+  698,
+  610,
+  685,
+  525,
+  684,
+  613,
+  632,
+  615,
+  787,
+  612,
+  787,
+  612,
+  787,
+  612,
+  787,
+  612,
+  611,
+  592,
+  475,
+  843,
+  477,
+  278,
+  998,
+  998,
+  684,
+  698,
+  550,
+  557,
+  611,
+  521,
+  525,
+  603,
+  479,
+  686,
+  732,
+  684,
+  632,
+  615,
+  295,
+  278,
+  781,
+  635,
+  695,
+  411,
+  611,
+  592
+];
+const DIALOG_LINE_HEIGHT = 1.1640625;
+function dialogWidth(text) {
+  let sum = 0;
+  for (const ch of text) {
+    const c = ch.codePointAt(0) ?? 0;
+    if (c >= 32 && c < 127) {
+      sum += ASCII[c - 32];
+    } else {
+      sum += c >= 160 && c < 592 ? LATIN[c - 160] : 1e3;
+    }
+  }
+  return sum / 1e3;
+}
+const GEPHI_PREVIEW = Object.freeze({
+  "edge.show": "true",
+  "edge.thickness": "1.0",
+  "edge.use-weight": "true",
+  "edge.rescale-weight": "false",
+  "edge.rescale-weight.min": "0.4",
+  "edge.rescale-weight.max": "8.0",
+  "edge.color": "mixed",
+  "edge.opacity": "100.0",
+  "edge.curved": "true",
+  "arrow.size": "3.0",
+  "node.border.fixed": "false",
+  "node.border.width": "1.0",
+  "node.border.color": "darker",
+  "node.opacity": "100.0",
+  "node.per.node.opacity": "false",
+  "node.label.show": "true",
+  "node.label.customFont": "false",
+  "node.label.font": "Dialog,plain,12",
+  "node.label.proportinalSize": "true",
+  "node.label.color": "#000000",
+  "node.label.shorten": "false",
+  "node.label.avoidOverlap": "true",
+  "node.label.overlapGridSize": "10",
+  "node.label.scale": "1.0",
+  "node.label.max-char": "30",
+  "node.label.outline.size": "0.0",
+  "node.label.outline.color": "#ffffff",
+  "node.label.outline.opacity": "80.0",
+  "node.label.box": "false",
+  "node.label.box.color": "parent",
+  "node.label.box.opacity": "100.0",
+  "edge.label.show": "false",
+  "edge.label.customFont": "false",
+  "edge.label.font": "Dialog,plain,10",
+  "edge.label.color": "original",
+  "edge.label.shorten": "false",
+  "edge.label.max-char": "30",
+  "edge.label.outline.size": "0.0",
+  "edge.label.outline.color": "#ffffff",
+  "edge.label.outline.opacity": "80.0"
+});
+class GephiPreview {
+  /**
+   * The settings: Gephi's defaults under the ones given.
+   * @param given - the settings given, by Gephi's property names
+   */
+  constructor(given = {}) {
+    this.values = { ...GEPHI_PREVIEW, ...given };
+  }
+  /**
+   * A setting's text, trimmed and lower case.
+   * @param name - the property
+   * @returns the text
+   */
+  text(name) {
+    return (this.values[name] ?? "").trim().toLowerCase();
+  }
+  /**
+   * A boolean setting.
+   * @param name - the property
+   * @returns its value
+   */
+  on(name) {
+    return this.text(name) === "true";
+  }
+  /**
+   * A number setting; Gephi's default where the text is not a number.
+   * @param name - the property
+   * @returns its value
+   */
+  num(name) {
+    const v = Number(this.text(name));
+    return Number.isFinite(v) ? v : Number(GEPHI_PREVIEW[name] ?? 0);
+  }
+  /**
+   * The font of node or edge labels: the given font when `<target>.label.customFont` is on, else Gephi's.
+   * @param target - "node" or "edge"
+   * @returns the font
+   */
+  font(target) {
+    const name = `${target}.label.font`;
+    const raw = this.on(`${target}.label.customFont`) ? this.values[name] ?? "" : GEPHI_PREVIEW[name] ?? "";
+    const [family = "Dialog", style = "plain", size = ""] = raw.split(",").map((s2) => s2.trim());
+    const s = style.toLowerCase();
+    const pt = Number(size);
+    const fallback = target === "node" ? 12 : 10;
+    return {
+      family,
+      bold: s.includes("bold"),
+      italic: s.includes("italic"),
+      size: Number.isFinite(pt) && pt > 0 ? pt : fallback
+    };
+  }
+}
+function shortened(label, max) {
+  return label.length >= max + 3 ? `${label.slice(0, max)}...` : label;
+}
+function dependantColor(mode, parent) {
+  switch (mode) {
+    case "darker":
+      return parent.slice(0, 3).map((v) => Math.floor(v / 2));
+    case "lighter":
+      return parent.slice(0, 3).map((v) => Math.min(255, Math.floor(v * 1.5)));
+    case "parent":
+    case "original":
+      return parent.slice(0, 3);
+    default: {
+      const m = /^#([0-9a-f]{6})$/.exec(mode);
+      if (m === null) {
+        return null;
+      }
+      const n = Number.parseInt(m[1], 16);
+      return [n >> 16 & 255, n >> 8 & 255, n & 255];
+    }
+  }
+}
+function drawnLabels(labels, preview, target, kept = false) {
+  if (labels === void 0 || !preview.on(`${target}.label.show`)) {
+    return void 0;
+  }
+  const max = preview.on(`${target}.label.shorten`) ? preview.num(`${target}.label.max-char`) : Infinity;
+  const drawn = (l) => kept ? l : l.replaceAll(/[\r\n]/g, "");
+  return labels.map((l) => typeof l === "string" ? drawn(shortened(l, max)) : l);
+}
+function edgeThickness(weights, drawn, preview) {
+  const thickness = preview.num("edge.thickness");
+  if (!preview.on("edge.use-weight")) {
+    return weights.map(() => thickness);
+  }
+  if (!preview.on("edge.rescale-weight")) {
+    return weights.map((w) => w * thickness);
+  }
+  let lo = Infinity;
+  let hi = -Infinity;
+  weights.forEach((w, e) => {
+    if (drawn[e]) {
+      lo = Math.min(lo, w);
+      hi = Math.max(hi, w);
+    }
+  });
+  const min = preview.num("edge.rescale-weight.min");
+  const max = preview.num("edge.rescale-weight.max");
+  return weights.map((w) => (hi > lo ? min + (w - lo) / (hi - lo) * (max - min) : min) * thickness);
+}
+const LABEL_COLUMN = NODE_COLUMNS.label;
+const GRAPHTY_XML_NAMESPACE = "https://graphty.app/ns/gexf";
+const GEXF_STYLE_CAPABILITIES = Object.freeze({
+  tool: "gephi",
+  node: Object.freeze(["label", "fill", "fillOpacity", "width", "height", "shape", "image"]),
+  edge: Object.freeze(["color", "opacity", "width", "lineStyle"]),
+  block: "native"
+});
+const GEPHI_NODE_FILL = "#000000";
+const DIRECTED_KEY = "directed";
+const AVOID_OVERLAP_KEY = "label-avoid-overlap";
+const HIDDEN_KEY = "gephi-hidden";
+const MIXED_COLOR_KEY = "end-colors";
+const WEIGHT_WIDTH = ["width", "weight-width"];
+const GEPHI_NODE_WIDTH = 20;
+const SELF_LOOP_THICKNESS = 1.3;
+const NODE_SHAPES = /* @__PURE__ */ new Map([
+  ["ellipse", "disc"],
+  ["rectangle", "square"],
+  ["triangle", "triangle"],
+  ["diamond", "diamond"]
+]);
+const NEAREST_NODE_SHAPES = /* @__PURE__ */ new Map([
+  ["round-rectangle", "square"],
+  ["vee", "triangle"]
+]);
+const EDGE_SHAPES = /* @__PURE__ */ new Set(["solid", "dotted", "dashed", "double"]);
+function gexfNodeShape(shape) {
+  const exact = NODE_SHAPES.get(shape);
+  return exact === void 0 ? { value: NEAREST_NODE_SHAPES.get(shape) ?? "disc", exact: false } : { value: exact, exact: true };
+}
+function gexfEdgeShape(line) {
+  if (EDGE_SHAPES.has(line)) {
+    return { value: line, exact: true };
+  }
+  return { value: line === "dash-dot" || line === "long-dash" ? "dashed" : "solid", exact: false };
+}
+const VIZ_COLUMNS = {
+  node: ["color", "size", "shape", "shape.uri"],
+  edge: ["color", "thickness", "shape"]
+};
+function canonVizColor(hex) {
+  const m = /^([+-]?)(?:(0x|0X|#)([0-9a-fA-F]+)|(0[0-7]+)|(\d+))$/.exec(hex.trim());
+  if (m === null) {
+    return null;
+  }
+  const [, sign, , hexDigits, octal, decimal] = m;
+  let v;
+  if (hexDigits !== void 0) {
+    v = Number.parseInt(hexDigits, 16);
+  } else if (octal !== void 0) {
+    v = Number.parseInt(octal, 8);
+  } else {
+    v = Number.parseInt(decimal, 10);
+  }
+  if (sign === "-") {
+    v = -v;
+  }
+  if (v < -2147483648 || v > 2147483647) {
+    return null;
+  }
+  const n = v & 16777215;
+  return [n >> 16 & 255, n >> 8 & 255, n & 255, 1];
+}
+function vizColumn(snapshot, target, name) {
+  const col = (target === "node" ? snapshot.nodes : snapshot.edges).get(name);
+  return col !== null && col.meta.origin?.namespace === VIZ_NAMESPACE ? name : null;
+}
+function vizValues(snapshot, target, notes, context) {
+  const table = target === "node" ? snapshot.nodes : snapshot.edges;
+  const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+  const out = {};
+  const viz = {
+    table,
+    target,
+    column: (p) => out[p] ??= new Array(n).fill(null),
+    site: (i, property) => ({ notes, target, property, element: i, budget: context.budget })
+  };
+  const color = vizColumn(snapshot, target, "color");
+  const size = vizColumn(snapshot, target, target === "node" ? "size" : "thickness");
+  const shape = vizColumn(snapshot, target, "shape");
+  const uri = target === "node" ? vizColumn(snapshot, target, "shape.uri") : null;
+  const label = target === "node" ? table.byRole("label") : null;
+  for (let i = 0; i < n; i++) {
+    if (label !== null) {
+      readLabel(viz, label, i);
+    }
+    if (color !== null) {
+      readVizColor(viz, color, i);
+    }
+    if (size !== null) {
+      readVizSize(viz, size, i);
+    }
+    if (shape !== null && readVizShape(viz, shape, i) && uri !== null) {
+      readVizImage(viz, uri, i);
+    }
+  }
+  return out;
+}
+function readLabel(viz, label, i) {
+  const text = canonText(plainCell(label.value(i)), viz.site(i, "label"));
+  if (text !== null) {
+    viz.column("label")[i] = text;
+  }
+}
+function readVizImage(viz, uri, i) {
+  const v = plainCell(viz.table.value(uri, i));
+  if (typeof v === "string" && v.length > 0) {
+    viz.column("image")[i] = v;
+  }
+}
+function readVizColor(viz, color, i) {
+  const v = plainCell(viz.table.value(color, i));
+  if (!Array.isArray(v)) {
+    return;
+  }
+  const [fill, opacity] = viz.target === "node" ? ["fill", "fillOpacity"] : ["color", "opacity"];
+  const [r, g, b, a = 1] = v;
+  const c = canonColor({ r: r * 255, g: g * 255, b: b * 255, a }, "gexf", viz.site(i, fill));
+  if (c !== null) {
+    viz.column(fill)[i] = c.color;
+    if (c.alpha < 1) {
+      viz.column(opacity)[i] = c.alpha;
+    }
+  }
+}
+function readVizSize(viz, size, i) {
+  const v = canonNumber(plainCell(viz.table.value(size, i)), viz.site(i, "width"));
+  if (v !== null && !(v === 0 && viz.target === "node")) {
+    if (viz.target === "node") {
+      viz.column("width")[i] = 2 * v;
+      viz.column("height")[i] = 2 * v;
+    } else {
+      viz.column("width")[i] = v;
+    }
+  }
+}
+function readVizShape(viz, shape, i) {
+  const raw = plainCell(viz.table.value(shape, i));
+  if (raw === null) {
+    return false;
+  }
+  const kind = viz.target === "node" ? "shape" : "lineStyle";
+  viz.column(kind)[i] = canonEnum(kind, raw, "gexf", viz.site(i, kind));
+  return typeof raw === "string" && raw.toLowerCase() === "image";
+}
+function gephiEdges(snapshot, gexf) {
+  const n = snapshot.edgeCount;
+  const first = firstHalf(snapshot);
+  if (!gexf) {
+    return otherFormatEdges(snapshot);
+  }
+  const header = gexfDefaultEdgeType(snapshot);
+  const dirCol = snapshot.edges.byRole("directed");
+  const mutualCol = snapshot.edges.byRole("mutual");
+  const kindCol = snapshot.edges.byRole("kind");
+  const weightOf = gephiWeight(snapshot);
+  const out = {
+    directed: new Array(n).fill(false),
+    hidden: new Array(n).fill(false),
+    weight: new Array(n).fill(1)
+  };
+  const leaders = /* @__PURE__ */ new Map();
+  const drawnLeaders = [];
+  const ownDirection = gexfOwnDirection(header, dirCol, mutualCol);
+  for (let e = 0; e < n; e++) {
+    const f = first(e);
+    if (f !== e) {
+      continue;
+    }
+    const { ownUndirected, mismatched } = ownDirection(f);
+    if (mismatched) {
+      out.hidden[f] = true;
+      continue;
+    }
+    const s = snapshot.edgeSource(f);
+    const t = snapshot.edgeTarget(f);
+    const directed = header !== "undirected" && s !== t && !ownUndirected;
+    out.directed[f] = directed;
+    const kind = kindCol?.isSet(f) === true ? String(kindCol.value(f)) : "";
+    const key = `${kind}\0${gephiEndsKey(s, t, directed)}`;
+    const leader = leaders.get(key);
+    if (leader === void 0) {
+      leaders.set(key, f);
+      drawnLeaders.push(f);
+      out.weight[f] = weightOf(f);
+    } else {
+      out.weight[leader] += weightOf(f);
+      out.hidden[f] = true;
+    }
+  }
+  const smallest = drawnLeaders.reduce((m, f) => Math.min(m, out.weight[f]), Infinity);
+  const shift = smallest <= 0 ? 1 - smallest : 0;
+  for (let e = 0; e < n; e++) {
+    const f = first(e);
+    out.directed[e] = out.directed[f];
+    out.hidden[e] = out.hidden[f];
+    out.weight[e] = out.weight[f] + shift;
+  }
+  return out;
+}
+function gephiEndsKey(s, t, directed) {
+  return directed ? `${String(s)}>${String(t)}` : `${String(Math.min(s, t))}-${String(Math.max(s, t))}`;
+}
+function gexfOwnDirection(header, dirCol, mutualCol) {
+  const verdict = (ownUndirected, ownDirected) => ({
+    ownUndirected,
+    mismatched: header === "directed" && ownUndirected || header === "undirected" && ownDirected
+  });
+  return (f) => {
+    if (dirCol === null) {
+      return verdict(header === "undirected", header !== "undirected");
+    }
+    const mutual = mutualCol?.value(f) === true;
+    return verdict(dirCol.value(f) === false && !mutual, dirCol.value(f) === true && !mutual);
+  };
+}
+function otherFormatEdges(snapshot) {
+  const first = firstHalf(snapshot);
+  const weightOf = gephiWeight(snapshot);
+  const directed = new Array(snapshot.edgeCount).fill(snapshot.directed);
+  const col = snapshot.directed ? snapshot.edges.byRole("directed") : null;
+  const weight = [];
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    if (col !== null) {
+      directed[e] = plainCell(col.value(e)) !== false;
+    }
+    const w = weightOf(first(e));
+    weight.push(w > 0 ? w : 1);
+  }
+  return { directed, hidden: directed.map(() => false), weight };
+}
+function gexfDefaultEdgeType(snapshot) {
+  const written = snapshot.meta.extra.gexf?.defaultedgetype;
+  return typeof written === "string" ? written.trim().toLowerCase() : null;
+}
+function gephiWeight(snapshot) {
+  const isWeight = (v) => typeof v === "string" && v.toLowerCase() === "weight";
+  const dynamic = snapshot.edges.names().map((name) => snapshot.edges.get(name)).find(
+    (c) => c !== null && c.meta.dynamic && [c.meta.name, c.meta.origin?.id, c.meta.origin?.title].some(isWeight)
+  );
+  const table = dynamic === void 0 || dynamic === null ? void 0 : snapshot.extensions.get(temporalTableName("edge", dynamic.meta.name));
+  if (table !== void 0) {
+    const element = table.get(TEMPORAL_COLUMNS.element);
+    const start = table.get(TEMPORAL_COLUMNS.start);
+    const value = table.get(TEMPORAL_COLUMNS.value);
+    const earliest = /* @__PURE__ */ new Map();
+    for (let row = 0; element !== null && value !== null && row < table.rowCount; row++) {
+      const e = element.value(row);
+      const at = start?.isSet(row) === true ? start.value(row) : -Infinity;
+      const v = Number(value.value(row));
+      const seen = earliest.get(e);
+      if (Number.isFinite(v) && (seen === void 0 || at < seen.start)) {
+        earliest.set(e, { start: at, value: v });
+      }
+    }
+    return (e) => earliest.get(e)?.value ?? 0;
+  }
+  const weights = explicitWeights(snapshot);
+  return (e) => {
+    const w = Number(weights.text(e) ?? 1);
+    return Number.isFinite(w) ? w : 1;
+  };
+}
+function nodeChannels(fill, opacity) {
+  const n = Number.parseInt((typeof fill === "string" ? fill : GEPHI_NODE_FILL).slice(1), 16);
+  const a = typeof opacity === "number" ? Math.round(opacity * 255) : 255;
+  return [n >> 16 & 255, n >> 8 & 255, n & 255, a];
+}
+function hexOf(c) {
+  return `#${c.slice(0, 3).map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+}
+function perElementDefault(out, target, pair, column, reason) {
+  const [property, key] = pair;
+  const elements = column.filter((v) => v !== null).length;
+  if (elements === 0) {
+    return;
+  }
+  out.columns.set(key, column);
+  out.rules.push({
+    id: `${target}.tool.${key}`,
+    target,
+    role: "passthrough",
+    origin: "tool",
+    where: { has: { style: key } },
+    map: { [property]: { kind: "passthrough", by: { style: key } } },
+    facts: { elements, reason }
+  });
+}
+function everyElement(out, target, id, set) {
+  if (Object.keys(set).length > 0) {
+    out.rules.push({
+      id: `${target}.tool.${id}`,
+      target,
+      role: "group",
+      origin: "tool",
+      where: { all: true },
+      set
+    });
+  }
+}
+function gephiRules(snapshot, nodes, edges, budget, gexf) {
+  const preview = gexf?.preview ?? new GephiPreview();
+  const node = { rules: [], columns: /* @__PURE__ */ new Map() };
+  const edge = { rules: [], columns: /* @__PURE__ */ new Map() };
+  budget.spend("node", snapshot.nodeCount);
+  budget.spend("edge", snapshot.edgeCount);
+  const channels = Array.from(
+    { length: snapshot.nodeCount },
+    (_, i) => nodeChannels(nodes.fill?.[i], nodes.fillOpacity?.[i])
+  );
+  const labelSizes = nodeRules(node, snapshot, channels, nodes, preview);
+  edgeRules(edge, snapshot, channels, nodes, edges, gexf, preview);
+  nodeLabelRules(node, channels, labelSizes, preview, gexf?.overlapSettled === true);
+  labelBox(node, channels, nodes, preview);
+  return { node, edge };
+}
+function nodeWidth(nodes, i) {
+  const w = nodes.width?.[i];
+  return typeof w === "number" ? w : GEPHI_NODE_WIDTH;
+}
+function nodeRules(node, snapshot, channels, nodes, preview) {
+  const nodeIndices = Array.from({ length: snapshot.nodeCount }, (_, i) => i);
+  const perNode = preview.on("node.per.node.opacity");
+  const alpha = channels.map((c) => (perNode ? c[3] : 255) / 255 * (preview.num("node.opacity") / 100));
+  const translucent = alpha.map((a) => a < 1 ? a : null);
+  perElementDefault(node, "node", ["fillOpacity", "preview-opacity"], translucent, "NODE_OPACITY");
+  perElementDefault(node, "node", ["borderOpacity", "preview-border-opacity"], translucent, "NODE_OPACITY");
+  const borderMode = preview.text("node.border.color");
+  perElementDefault(
+    node,
+    "node",
+    ["borderColor", "border-shade"],
+    channels.map((c) => hexOf(dependantColor(borderMode, c) ?? c.map((v) => Math.floor(v / 2)))),
+    "NODE_FILL_SHADE"
+  );
+  const fixed = preview.on("node.border.fixed") ? preview.num("node.border.width") : null;
+  perElementDefault(
+    node,
+    "node",
+    ["borderWidth", "size-border"],
+    nodeIndices.map((i) => {
+      return fixed === null ? 0.08 * nodeWidth(nodes, i) : Math.min(fixed, nodeWidth(nodes, i) / 2);
+    }),
+    "NODE_SIZE"
+  );
+  const font = preview.font("node");
+  const labelSizes = nodeIndices.map(
+    (i) => preview.on("node.label.proportinalSize") ? Math.max(1, Math.round(font.size / 40 * nodeWidth(nodes, i))) : font.size
+  );
+  perElementDefault(node, "node", ["labelSize", "size-label"], labelSizes, "NODE_SIZE");
+  return labelSizes;
+}
+function nodeLabelRules(node, channels, sizes, preview, settled) {
+  const color = preview.text("node.label.color");
+  if (color !== "#000000" && color !== "original") {
+    perElementDefault(
+      node,
+      "node",
+      ["labelColor", "preview-label-color"],
+      channels.map((c) => hexOf(dependantColor(color, c) ?? [0, 0, 0])),
+      "NODE_LABEL_COLOR"
+    );
+  }
+  labelOutline(node, "node", channels, sizes, preview);
+  const font = preview.font("node");
+  everyElement(node, "node", "preview-label", fontValues(font, preview.on("node.label.customFont")));
+  if (preview.on("node.label.avoidOverlap") && !settled) {
+    node.columns.set(
+      AVOID_OVERLAP_KEY,
+      sizes.map(() => true)
+    );
+    node.rules.push({
+      id: "node.tool.label-avoid-overlap",
+      target: "node",
+      role: "group",
+      origin: "tool",
+      where: { has: { style: AVOID_OVERLAP_KEY } },
+      set: { labelAvoidOverlap: true }
+    });
+  }
+}
+function gephiAlpha(percent) {
+  return Math.floor(Math.min(Math.max(percent, 0), 100) / 100 * 255 + 1e-9) / 255;
+}
+function labelBox(node, channels, nodes, preview) {
+  if (!preview.on("node.label.box")) {
+    return;
+  }
+  const mode = preview.text("node.label.box.color");
+  perElementDefault(
+    node,
+    "node",
+    ["labelBorderColor", "preview-box-color"],
+    channels.map((c) => hexOf(dependantColor(mode, c) ?? c)),
+    "LABEL_BOX"
+  );
+  perElementDefault(
+    node,
+    "node",
+    ["labelBorderWidth", "preview-box-width"],
+    channels.map((_, i) => 0.04 * nodeWidth(nodes, i)),
+    "LABEL_BOX"
+  );
+  everyElement(node, "node", "preview-box", {
+    labelBorderOpacity: gephiAlpha(preview.num("node.label.box.opacity")),
+    labelPadding: 0,
+    labelLineHeight: 1
+  });
+}
+function fontValues(font, custom) {
+  if (!custom) {
+    return {};
+  }
+  return {
+    labelFont: font.family,
+    ...font.bold ? { labelWeight: "bold" } : {},
+    ...font.italic ? { labelItalic: true } : {}
+  };
+}
+function labelOutline(out, target, colors, sizes, preview) {
+  const size = preview.num(`${target}.label.outline.size`);
+  if (size <= 0) {
+    return;
+  }
+  const mode = preview.text(`${target}.label.outline.color`);
+  perElementDefault(
+    out,
+    target,
+    ["labelOutlineWidth", "preview-outline-width"],
+    sizes.map((s) => size / 32 * s),
+    "LABEL_OUTLINE"
+  );
+  perElementDefault(
+    out,
+    target,
+    ["labelOutlineColor", "preview-outline-color"],
+    colors.map((c) => hexOf(dependantColor(mode, c) ?? [255, 255, 255])),
+    "LABEL_OUTLINE"
+  );
+  everyElement(out, target, "preview-outline", {
+    labelOutlineOpacity: gephiAlpha(preview.num(`${target}.label.outline.opacity`))
+  });
+}
+function gephiOverlapHidden(snapshot, labels, widths, preview) {
+  const centers = gephiCenters(snapshot);
+  if (centers.includes(null)) {
+    return null;
+  }
+  const f = Math.fround;
+  const grid = preview.num("node.label.overlapGridSize");
+  const proportional = preview.on("node.label.proportinalSize");
+  const base = f(preview.font("node").size * preview.num("node.label.scale"));
+  const nodeSizes = centers.map((_, i) => {
+    const w = widths?.[i];
+    return f((typeof w === "number" ? w : GEPHI_NODE_WIDTH) / 2);
+  });
+  const sizes = nodeSizes.map(
+    (nodeSize) => proportional ? f(f(base * nodeSize) * f(0.05)) : f(base * f(1 + f(nodeSize * f(1e-5))))
+  );
+  const items = sizes.map((_, i) => i).sort((a, b) => nodeSizes[b] - nodeSizes[a]);
+  const cached = /* @__PURE__ */ new Map();
+  items.forEach((i) => cached.set(Math.round(sizes[i]), sizes[i]));
+  const at = centers.map((c) => [c?.[0] ?? 0, -(c?.[1] ?? 0)]);
+  let [loX, loY, hiX, hiY] = [Infinity, Infinity, -Infinity, -Infinity];
+  for (const [x, y] of at) {
+    [loX, loY, hiX, hiY] = [Math.min(loX, x), Math.min(loY, y), Math.max(hiX, x), Math.max(hiY, y)];
+  }
+  const [minX, minY] = [loX - grid, loY - grid];
+  const cols = Math.ceil((hiX + grid - minX) / grid);
+  const rows = Math.ceil((hiY + grid - minY) / grid);
+  const taken = /* @__PURE__ */ new Set();
+  const hidden = labels.map(() => false);
+  const order = [...items].sort((a, b) => sizes[b] - sizes[a]);
+  for (const i of order) {
+    const label = labels[i];
+    if (typeof label !== "string" || label.trim() === "") {
+      continue;
+    }
+    const size = cached.get(Math.round(sizes[i])) ?? sizes[i];
+    const half = [dialogWidth(label) * size / 2, DIALOG_LINE_HEIGHT * size / 2];
+    const cells = gridCells(
+      { min: [minX, minY], size: grid, cols, rows },
+      [at[i][0] - half[0], at[i][1] - half[1]],
+      [at[i][0] + half[0], at[i][1] + half[1]]
+    );
+    if (cells.some((k) => taken.has(k))) {
+      hidden[i] = true;
+    } else {
+      cells.forEach((k) => taken.add(k));
+    }
+  }
+  return hidden;
+}
+function gridCells(grid, lo, hi) {
+  const cell = (v, axis) => Math.min((axis === 0 ? grid.cols : grid.rows) - 1, Math.max(0, Math.trunc((v - grid.min[axis]) / grid.size)));
+  const cells = [];
+  for (let r = cell(lo[1], 1); r <= cell(hi[1], 1); r++) {
+    for (let c = cell(lo[0], 0); c <= cell(hi[0], 0); c++) {
+      cells.push(r * grid.cols + c);
+    }
+  }
+  return cells;
+}
+const GEPHI_ARC_CURVENESS = 1.2;
+function gephiCenters(snapshot) {
+  const position = snapshot.nodes.byRole("position");
+  return Array.from({ length: snapshot.nodeCount }, (_, i) => {
+    const v = position?.isSet(i) === true ? position.value(i) : null;
+    return v === null ? null : [v[0] || 0, v[1] || 0];
+  });
+}
+function swallowedEdges(snapshot, nodes, directed, thickness, preview) {
+  const centers = gephiCenters(snapshot);
+  const edgeRadius = preview.num("edge.radius");
+  const arrowSize = preview.num("arrow.size");
+  const arc = 2 * Math.asin(Math.min(1, GEPHI_ARC_CURVENESS / 2));
+  return Array.from({ length: snapshot.edgeCount }, (_, e) => {
+    const [a, b] = [snapshot.edgeSource(e), snapshot.edgeTarget(e)];
+    const [pa, pb] = [centers[a], centers[b]];
+    if (a === b || pa === null || pb === null) {
+      return null;
+    }
+    const d = Math.hypot(pb[0] - pa[0], pb[1] - pa[1]);
+    if (d === 0) {
+      return "all";
+    }
+    const r = d / GEPHI_ARC_CURVENESS;
+    const cut = (c) => c >= r * arc ? Infinity : 2 * Math.atan2(c / 2, Math.sqrt(r * r - c / 2 * (c / 2)));
+    const source = edgeRadius + nodeWidth(nodes, a) / 2;
+    const target = edgeRadius + nodeWidth(nodes, b) / 2 + (directed[e] ? arrowSize * thickness[e] : 0);
+    return cut(source) + cut(target) >= arc ? "line" : null;
+  });
+}
+const SELF_LOOP_STEPS = 96;
+function selfLoopBends(snapshot, thickness, hidden) {
+  const sizes = vizColumn(snapshot, "node", "size");
+  const sizeOf = (n) => {
+    const v = sizes === null ? null : Number(plainCell(snapshot.nodes.value(sizes, n)));
+    return v !== null && Number.isFinite(v) && v > 0 ? v : GEPHI_NODE_WIDTH / 2;
+  };
+  const fraction = (v) => String(Math.round(v * 1e4) / 1e4);
+  return Array.from({ length: snapshot.edgeCount }, (_, e) => {
+    const n = snapshot.edgeSource(e);
+    if (n !== snapshot.edgeTarget(e) || hidden[e]) {
+      return null;
+    }
+    const size = sizeOf(n);
+    const r = (0.5 * size + 0.33 * SELF_LOOP_THICKNESS * thickness[e]) / size;
+    const points = [];
+    for (let k = 0; k <= SELF_LOOP_STEPS; k++) {
+      const a = 5 * Math.PI / 4 - 2 * Math.PI * k / SELF_LOOP_STEPS;
+      points.push(`${fraction(r + r * Math.cos(a))},${fraction(r + r * Math.sin(a))}`);
+    }
+    return points.join(" ");
+  });
+}
+function edgeRules(edge, snapshot, channels, nodes, edges, gexf, preview) {
+  const drawn = gephiEdges(snapshot, gexf !== void 0);
+  const arrowSize = preview.num("arrow.size");
+  if (drawn.directed.some(Boolean) && arrowSize > 0) {
+    edge.columns.set(
+      DIRECTED_KEY,
+      drawn.directed.map((d) => d ? true : null)
+    );
+    edge.rules.push({
+      id: "edge.tool.arrow",
+      target: "edge",
+      role: "group",
+      origin: "tool",
+      where: { has: { style: DIRECTED_KEY } },
+      set: { targetArrow: "triangle", ...arrowSize === 3 ? {} : { arrowSize: arrowSize / 3 } }
+    });
+  }
+  const hidden = preview.on("edge.show") ? drawn.hidden : drawn.hidden.map(() => true);
+  const thickness = edgeThickness(
+    drawn.weight,
+    hidden.map((h) => !h),
+    preview
+  );
+  perElementDefault(
+    edge,
+    "edge",
+    WEIGHT_WIDTH,
+    // Gephi's self-loop is 1.3 times as thick (measured: weight 1 draws 1.3, 3.25 draws 4.225)
+    withoutOwn(
+      edges.width,
+      snapshot.edgeCount,
+      (e) => snapshot.edgeSource(e) === snapshot.edgeTarget(e) ? SELF_LOOP_THICKNESS * thickness[e] : thickness[e]
+    ),
+    "EDGE_WEIGHT"
+  );
+  perElementDefault(edge, "edge", ["bends", "self-loop"], selfLoopBends(snapshot, thickness, hidden), "NODE_SIZE");
+  const swallowed = preview.on("edge.curved") ? swallowedEdges(snapshot, nodes, drawn.directed, thickness, preview) : hidden.map(() => null);
+  hidden.forEach((h, e) => {
+    const arrow = drawn.directed[e] && arrowSize > 0 && swallowed[e] === "line";
+    hidden[e] = h || swallowed[e] !== null && !arrow;
+  });
+  if (hidden.some(Boolean)) {
+    edge.columns.set(
+      HIDDEN_KEY,
+      hidden.map((h) => h ? true : null)
+    );
+    edge.rules.push({
+      id: "edge.tool.gephi-hidden",
+      target: "edge",
+      role: "group",
+      origin: "tool",
+      where: { has: { style: HIDDEN_KEY } },
+      set: { visible: false }
+    });
+  }
+  const colors = edgeColors(snapshot, channels, gexf, preview);
+  perElementDefault(
+    edge,
+    "edge",
+    ["color", MIXED_COLOR_KEY],
+    withoutOwn(edges.color, snapshot.edgeCount, (e) => hexOf(colors[e])),
+    "END_NODE_COLORS"
+  );
+  perElementDefault(
+    edge,
+    "edge",
+    ["opacity", "end-opacity"],
+    withoutOwn(edges.color, snapshot.edgeCount, (e) => colors[e][3] / 255).map((v, e) => {
+      if (swallowed[e] !== null && !hidden[e]) {
+        return 0;
+      }
+      return v === 1 ? null : v;
+    }),
+    "END_NODE_COLORS"
+  );
+  everyElement(edge, "edge", "preview-curve", preview.on("edge.curved") ? {} : { curved: false });
+  const nodeGap = preview.num("edge.radius");
+  everyElement(edge, "edge", "preview-radius", nodeGap > 0 ? { nodeGap } : {});
+  edgeLabelRules(edge, colors, gexf, preview);
+}
+function edgeColors(snapshot, channels, gexf, preview) {
+  const mode = preview.text("edge.color");
+  const factor = preview.num("edge.opacity") / 100;
+  const own = (e) => {
+    const c = gexf?.original?.color?.[e];
+    const a = gexf?.original?.opacity?.[e];
+    return nodeChannels(typeof c === "string" ? c : GEPHI_NODE_FILL, typeof a === "number" ? a : null);
+  };
+  const custom = dependantColor(mode, [0, 0, 0]);
+  return Array.from({ length: snapshot.edgeCount }, (_, e) => {
+    const s = channels[snapshot.edgeSource(e)];
+    const t = channels[snapshot.edgeTarget(e)];
+    let c;
+    if (mode === "source") {
+      c = [...s];
+    } else if (mode === "target") {
+      c = [...t];
+    } else if (mode === "original") {
+      c = own(e);
+    } else if (mode.startsWith("#") && custom !== null) {
+      c = [...custom, 255];
+    } else {
+      c = s.map((v, k) => Math.floor((v + t[k]) / 2));
+    }
+    return factor === 1 ? c : [c[0], c[1], c[2], c[3] * factor];
+  });
+}
+function edgeLabelRules(edge, colors, gexf, preview) {
+  if (gexf?.edgeLabels === void 0 || !preview.on("edge.label.show")) {
+    return;
+  }
+  const font = preview.font("edge");
+  const color = preview.text("edge.label.color");
+  if (color !== "original") {
+    perElementDefault(
+      edge,
+      "edge",
+      ["labelColor", "preview-label-color"],
+      colors.map((c) => hexOf(dependantColor(color, c) ?? [0, 0, 0])),
+      "EDGE_LABEL_COLOR"
+    );
+  }
+  labelOutline(
+    edge,
+    "edge",
+    colors,
+    colors.map(() => font.size),
+    preview
+  );
+  everyElement(edge, "edge", "preview-label", {
+    labelSize: font.size,
+    labelPosition: "center",
+    ...fontValues(font, preview.on("edge.label.customFont"))
+  });
+}
+function gephiMix(a, b) {
+  const x = Number.parseInt(a.slice(1), 16);
+  const y = Number.parseInt(b.slice(1), 16);
+  let out = 0;
+  for (const shift of [16, 8, 0]) {
+    out |= Math.floor(((x >> shift & 255) + (y >> shift & 255)) / 2) << shift;
+  }
+  return `#${out.toString(16).padStart(6, "0")}`;
+}
+function firstHalf(snapshot) {
+  const pair = snapshot.edges.byRole("pair");
+  return (e) => pair?.isSet(e) === true ? Math.min(e, pair.value(e)) : e;
+}
+function withoutOwn(own, count, value) {
+  const out = new Array(count).fill(null);
+  for (let e = 0; e < count; e++) {
+    if (own?.[e] === null || own === void 0) {
+      out[e] = value(e);
+    }
+  }
+  return out;
+}
+function gexfStyles(snapshot, context) {
+  const notes = new StyleNotes();
+  const node = vizValues(snapshot, "node", notes, context);
+  const edge = vizValues(snapshot, "edge", notes, context);
+  const { block, preview } = keptOf(context.kept);
+  const nodeOpacity = node.fillOpacity;
+  const original = { color: edge.color, opacity: edge.opacity };
+  if (block === null) {
+    withoutUndrawn(node, edge);
+  } else {
+    exactFromBlock(snapshot, block, node, edge);
+  }
+  const labels = drawnLabels(node.label, preview, "node", block !== null);
+  const overlapHidden = block === null && labels !== void 0 && preview.on("node.label.avoidOverlap") ? gephiOverlapHidden(snapshot, labels, node.width, preview) : null;
+  overlapHidden?.forEach((hide, i) => {
+    if (hide && labels !== void 0) {
+      labels[i] = null;
+    }
+  });
+  if (labels === void 0) {
+    delete node.label;
+  } else {
+    node.label = labels;
+  }
+  const edgeLabels = drawnLabels(edgeLabelValues(snapshot), preview, "edge", block !== null);
+  if (edgeLabels !== void 0) {
+    edge.label = edgeLabels;
+  }
+  const rules = gephiRules(
+    snapshot,
+    { fill: node.fill, fillOpacity: nodeOpacity, width: node.width },
+    { color: edge.color, width: edge.width },
+    context.budget,
+    { preview, original, edgeLabels, overlapSettled: overlapHidden !== null }
+  );
+  return {
+    canonical: true,
+    dialect: "gexf",
+    tool: "gephi",
+    units: "relative",
+    node: { values: node, ...rules.node },
+    edge: { values: edge, ...rules.edge },
+    notes: notes.list(),
+    opacityInColor: true,
+    block,
+    readFrom: {
+      node: VIZ_COLUMNS.node.filter((name) => vizColumn(snapshot, "node", name) !== null),
+      edge: VIZ_COLUMNS.edge.filter((name) => vizColumn(snapshot, "edge", name) !== null)
+    }
+  };
+}
+function keptOf(kept) {
+  if (typeof kept === "string") {
+    return { block: kept, preview: new GephiPreview() };
+  }
+  if (typeof kept === "object" && kept !== null) {
+    const { block, gephiPreview } = kept;
+    return { block: typeof block === "string" ? block : null, preview: new GephiPreview(gephiPreview) };
+  }
+  return { block: null, preview: new GephiPreview() };
+}
+function edgeLabelValues(snapshot) {
+  const col = snapshot.edges.byRole("label");
+  if (col === null) {
+    return void 0;
+  }
+  return Array.from({ length: snapshot.edgeCount }, (_, e) => {
+    const v = plainCell(col.value(e));
+    return typeof v === "string" && v.length > 0 ? v : null;
+  });
+}
+function withoutUndrawn(node, edge) {
+  delete node.shape;
+  delete node.image;
+  delete node.fillOpacity;
+  delete edge.color;
+  delete edge.opacity;
+  delete edge.width;
+  delete edge.lineStyle;
+}
+function exactFromBlock(snapshot, text, node, edge) {
+  const shapeRead = /* @__PURE__ */ new Map([
+    ["disc", "ellipse"],
+    ["square", "rectangle"]
+  ]);
+  const size = (want) => {
+    const w = want("width");
+    const h = want("height");
+    return typeof w === "number" && typeof h === "number" ? Math.max(w, h) : w ?? h;
+  };
+  const written = {
+    shape: (want) => {
+      const { value } = gexfNodeShape(String(want("shape")));
+      return shapeRead.get(value) ?? value;
+    },
+    width: size,
+    height: size,
+    lineStyle: (want) => gexfEdgeShape(String(want("lineStyle"))).value
+  };
+  takeFromBlock(snapshot, text, "gexf", (target) => ({
+    values: target === "node" ? node : edge,
+    properties: target === "node" ? ["shape", "width", "height"] : ["lineStyle"],
+    readBack: (_i, want) => (property) => written[property](want),
+    // a size is written from the width and the height together: one the block leaves unset reads back too
+    take: (property, wanted, native) => native !== null && (wanted !== null || property === "width" || property === "height")
+  }));
+}
+function tagDtype(col) {
+  const kinds = new Set(col.filter((v) => v !== null).map((v) => typeof v));
+  if (kinds.size === 1 && kinds.has("number")) {
+    return "f64";
+  }
+  return kinds.size === 1 && kinds.has("boolean") ? "bool" : "string";
+}
+function gexfStyledExport(snapshot, input) {
+  if (input === void 0) {
+    return null;
+  }
+  const p = (target, property) => input.picture(target, property);
+  const fill = p("node", "fill");
+  const fillOpacity = p("node", "fillOpacity");
+  const image = p("node", "image");
+  const color = p("edge", "color");
+  const opacity = p("edge", "opacity");
+  const thickness = p("edge", "width");
+  const height = p("node", "height");
+  const approximated = new StyleApproximations();
+  const nodeShapes = p("node", "shape").map((s, i) => gexfShapeOf(s, typeof image[i] === "string", approximated));
+  const nodeSizes = p("node", "width").map((w, i) => gexfSizeOf(w, height[i], approximated));
+  const edgeShapes = p("edge", "lineStyle").map((s) => gexfLineOf(s, approximated));
+  return {
+    snapshot: withTagColumns(snapshot, input),
+    blockElement: `<graphty:styles xmlns:graphty="${GRAPHTY_XML_NAMESPACE}" name="${STYLE_BLOCK_NAME}">${escapeXml(input.block)}</graphty:styles>`,
+    notes: approximated.notes("GEXF"),
+    node(i, indent) {
+      const size = nodeSizes[i];
+      const s = nodeShapes[i];
+      return colorElement(fill[i], fillOpacity[i], indent) + (size === null ? "" : `${indent}<viz:size value="${String(size / 2)}"/>
+`) + shapeElement(s, s === "image" ? String(image[i]) : null, indent);
+    },
+    edge(e, indent) {
+      const w = thickness[e];
+      const c = color[e];
+      const end = (i) => String(fill[i] ?? GEPHI_NODE_FILL);
+      const mixed = typeof c === "string" && c === gephiMix(end(snapshot.edgeSource(e)), end(snapshot.edgeTarget(e)));
+      return (mixed && (opacity[e] ?? 1) === 1 ? "" : colorElement(c, opacity[e], indent)) + (typeof w === "number" ? `${indent}<viz:thickness value="${String(w)}"/>
+` : "") + shapeElement(edgeShapes[e], null, indent);
+    }
+  };
+}
+function withTagColumns(snapshot, input) {
+  const out = snapshot.withColumns();
+  for (const target of ["node", "edge"]) {
+    const table = target === "node" ? out.nodes : out.edges;
+    for (const name of VIZ_COLUMNS[target]) {
+      if (table.get(name)?.meta.origin?.namespace === VIZ_NAMESPACE) {
+        table.remove(name);
+      }
+    }
+    for (const [name, col] of input.tags[target]) {
+      const dtype = tagDtype(col);
+      table.set(name, dtype === "string" ? col.map((v) => v === null ? null : String(v)) : col, { dtype });
+    }
+  }
+  const label = input.picture("node", "label").map((v) => typeof v === "string" ? v : null);
+  out.nodes.set(LABEL_COLUMN, label, { dtype: "string", role: "label" }, { replaceRole: true });
+  return out;
+}
+function gexfShapeOf(s, pictured, approximated) {
+  if (pictured) {
+    if (typeof s === "string" && s !== "other:image") {
+      approximated.add("node", "shape", s);
+    }
+    return "image";
+  }
+  if (typeof s !== "string") {
+    return null;
+  }
+  const g = gexfNodeShape(s);
+  if (!g.exact) {
+    approximated.add("node", "shape", s);
+  }
+  return g.value;
+}
+function gexfLineOf(s, approximated) {
+  if (typeof s !== "string") {
+    return null;
+  }
+  const g = gexfEdgeShape(s);
+  if (!g.exact) {
+    approximated.add("edge", "lineStyle", s);
+  }
+  return g.value;
+}
+function gexfSizeOf(w, h, approximated) {
+  if (typeof w === "number" && typeof h === "number" && w !== h) {
+    approximated.add("node", w > h ? "height" : "width", `${String(w)} x ${String(h)}`);
+    return Math.max(w, h);
+  }
+  if (typeof w === "number") {
+    return w;
+  }
+  return typeof h === "number" ? h : null;
+}
+function colorElement(hex, alpha, indent) {
+  if (typeof hex !== "string") {
+    return "";
+  }
+  const n = Number.parseInt(hex.slice(1), 16);
+  const a = typeof alpha === "number" && alpha !== 1 ? ` a="${String(alpha)}"` : "";
+  return `${indent}<viz:color r="${String(n >> 16 & 255)}" g="${String(n >> 8 & 255)}" b="${String(n & 255)}"${a}/>
+`;
+}
+function shapeElement(shape, uri, indent) {
+  if (shape === null) {
+    return "";
+  }
+  return uri === null ? `${indent}<viz:shape value="${shape}"/>
+` : `${indent}<viz:shape value="${shape}" uri="${escapeXml(uri)}"/>
+`;
+}
+function escapeXml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+export {
+  EDGE_DECLS as E,
+  GEXF_FORMAT as G,
+  NODE_DECLS as N,
+  OPEN_START as O,
+  RESERVED_NODE_NAMES as R,
+  TIME_FORMATS as T,
+  VIZ_NAMESPACE as V,
+  GRAPHTY_XML_NAMESPACE as a,
+  GRAPH_MODES as b,
+  TIME_REPRESENTATIONS as c,
+  temporalTableDecls as d,
+  canonVizColor as e,
+  OPEN_END as f,
+  gexfStyles as g,
+  RESERVED_EDGE_NAMES as h,
+  gexfStyledExport as i,
+  GEXF_STYLE_CAPABILITIES as j,
+  GEXF_NAMESPACES as k,
+  TEMPORAL_COLUMNS as l,
+  NODE_COLUMNS as m,
+  isListType as n,
+  canonicalScalarType as o,
+  parseTemporalTableName as p,
+  isScalarType as q,
+  gephiRules as r,
+  temporalTableName as t
+};
+//# sourceMappingURL=styles-CPczw1Jz.js.map