@graphty/graph-io 0.3.42 → 0.3.44

package/dist/chunks/styles-Brt9JMfs.js

@@ -0,0 +1,690 @@
+import { T as TIME_TEXT_ROLE, m as TIME_TEXT_SUFFIX, e as explicitWeights } from "./export-D7IGzTG4.js";
+import { S as STYLE_BLOCK_NAME, j as StyleNotes, p as parseStyleBlock, k as styleFingerprint, l as blockStyles, r as resolveStyles, c as canonColor, h as canonText, m as plainCell, b as canonNumber, f as canonEnum } from "./block-JQiwViEt.js";
+import { S as StyleApproximations } from "./approximations-3Q4TsdTh.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,
+    extra: { units: "file" }
+  },
+  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 LABEL_COLUMN = NODE_COLUMNS.label;
+const GRAPHTY_XML_NAMESPACE = "https://graphty.app/ns/gexf";
+const GEXF_STYLE_CAPABILITIES = Object.freeze({
+  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 SOURCE_COLOR_KEY = "source-color";
+const WEIGHT_WIDTH_KEY = "weight-width";
+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 text = hex.trim();
+  if (!/^#?([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(text)) {
+    return null;
+  }
+  const c = canonColor(text.startsWith("#") ? text : `#${text}`, "css", {
+    notes: new StyleNotes(),
+    target: "node",
+    property: "fill"
+  });
+  if (c === null) {
+    return null;
+  }
+  const n = Number.parseInt(c.color.slice(1), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255, c.alpha];
+}
+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) {
+    viz.column("width")[i] = v;
+    if (viz.target === "node") {
+      viz.column("height")[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 directedEdges(snapshot) {
+  const out = new Array(snapshot.edgeCount).fill(snapshot.directed);
+  const col = snapshot.directed ? snapshot.edges.byRole("directed") : null;
+  if (col !== null) {
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+      out[e] = plainCell(col.value(e)) !== false;
+    }
+  }
+  return out;
+}
+function gephiRules(snapshot, nodeFill, edgeColor, budget, edgeWidth) {
+  const rules = [];
+  const columns = /* @__PURE__ */ new Map();
+  const directed = directedEdges(snapshot);
+  if (directed.some(Boolean)) {
+    columns.set(
+      DIRECTED_KEY,
+      directed.map((d) => d ? true : null)
+    );
+    rules.push({
+      id: "edge.tool.arrow",
+      target: "edge",
+      role: "group",
+      origin: "tool",
+      where: { has: { style: DIRECTED_KEY } },
+      set: { targetArrow: "triangle" }
+    });
+  }
+  const first = firstHalf(snapshot);
+  const sourceColor = withoutOwn(
+    edgeColor,
+    snapshot.edgeCount,
+    (e) => nodeFill?.[snapshot.edgeSource(first(e))] ?? GEPHI_NODE_FILL
+  );
+  const uncolored = sourceColor.filter((v) => v !== null).length;
+  budget.spend("edge", snapshot.edgeCount);
+  const weights = explicitWeights(snapshot);
+  const weightWidth = withoutOwn(edgeWidth, snapshot.edgeCount, (e) => {
+    const w = Number(weights.text(first(e)) ?? 1);
+    return Number.isFinite(w) && w > 0 ? w : 1;
+  });
+  const unsized = weightWidth.filter((v) => v !== null).length;
+  if (unsized > 0) {
+    columns.set(WEIGHT_WIDTH_KEY, weightWidth);
+    rules.push({
+      id: "edge.tool.weight-width",
+      target: "edge",
+      role: "passthrough",
+      origin: "tool",
+      where: { has: { style: WEIGHT_WIDTH_KEY } },
+      map: { width: { kind: "passthrough", by: { style: WEIGHT_WIDTH_KEY } } },
+      facts: { elements: unsized, reason: "EDGE_WEIGHT" }
+    });
+  }
+  if (uncolored > 0) {
+    columns.set(SOURCE_COLOR_KEY, sourceColor);
+    rules.push({
+      id: "edge.tool.source-color",
+      target: "edge",
+      role: "passthrough",
+      origin: "tool",
+      where: { has: { style: SOURCE_COLOR_KEY } },
+      map: { color: { kind: "passthrough", by: { style: SOURCE_COLOR_KEY } } },
+      facts: { elements: uncolored, reason: "SOURCE_NODE_COLOR" }
+    });
+  }
+  return { rules, columns };
+}
+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 = typeof context.kept === "string" ? context.kept : null;
+  if (block !== null) {
+    exactFromBlock(snapshot, block, node, edge);
+  }
+  const { rules, columns } = gephiRules(snapshot, node.fill, edge.color, context.budget, edge.width);
+  return {
+    canonical: true,
+    dialect: "gexf",
+    tool: "gephi",
+    units: "relative",
+    node: { values: node },
+    edge: { values: edge, rules, columns },
+    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 exactFromBlock(snapshot, text, node, edge) {
+  const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
+  const ex = parsed.ok ? blockStyles(parsed.block, snapshot, "gexf") : null;
+  if (ex === null) {
+    return;
+  }
+  const exact = (values, target, property, written) => {
+    const native = values[property];
+    if (native === void 0) {
+      return;
+    }
+    const want = resolveStyles(ex, target, property, snapshot);
+    for (let i = 0; i < native.length; i++) {
+      const w = want[i];
+      const writable = w !== null || property === "width" || property === "height";
+      if (writable && native[i] !== w && native[i] !== null && native[i] === written(w, i)) {
+        native[i] = w;
+      }
+    }
+  };
+  const width = resolveStyles(ex, "node", "width", snapshot);
+  const height = resolveStyles(ex, "node", "height", snapshot);
+  const size = (i) => {
+    const w = width[i];
+    const h = height[i];
+    return typeof w === "number" && typeof h === "number" ? Math.max(w, h) : w ?? h;
+  };
+  const read = /* @__PURE__ */ new Map([
+    ["disc", "ellipse"],
+    ["square", "rectangle"]
+  ]);
+  exact(node, "node", "shape", (v) => {
+    const written = gexfNodeShape(String(v)).value;
+    return read.get(written) ?? written;
+  });
+  exact(edge, "edge", "lineStyle", (v) => gexfEdgeShape(String(v)).value);
+  exact(node, "node", "width", (_v, i) => size(i));
+  exact(node, "node", "height", (_v, i) => size(i));
+}
+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)}"/>
+`) + shapeElement(s, s === "image" ? String(image[i]) : null, indent);
+    },
+    edge(e, indent) {
+      const w = thickness[e];
+      return colorElement(color[e], 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-Brt9JMfs.js.map