@graphty/graph-io 0.3.48 → 0.3.49

package/dist/chunks/styles-P_gmFAOi.js

@@ -1,770 +0,0 @@
-import { T as TIME_TEXT_ROLE, k as TIME_TEXT_SUFFIX, e as explicitWeights } from "./export-CZ7VRm4I.js";
-import { S as STYLE_BLOCK_NAME, u as StyleNotes, v as parseStyleBlock, s as styleFingerprint, x as blockStyles, r as resolveStyles, g as canonColor, o as canonText, p as plainCell, h as canonNumber, l as canonEnum } from "./block-Cu22ewuS.js";
-import { S as StyleApproximations } from "./approximations-C2riR4NT.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({
-  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 MIXED_COLOR_KEY = "mixed-color";
-const BORDER_COLOR_KEY = "border-color";
-const BORDER_WIDTH_KEY = "border-width";
-const LABEL_SIZE_KEY = "label-size";
-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, node, edge, budget) {
-  return { node: gephiNodeRules(snapshot, node, budget), edge: gephiEdgeRules(snapshot, node, edge, budget) };
-}
-const GEPHI_BORDER_DARKEN = 0.498;
-const GEPHI_BORDER_SHARE = 0.08;
-const GEPHI_NODE_SIZE = 10;
-const GEPHI_LABEL_PER_SIZE = 1.2;
-function gephiNodeRules(snapshot, node, budget) {
-  const rules = [];
-  const columns = /* @__PURE__ */ new Map();
-  const n = snapshot.nodeCount;
-  budget.spend("node", n);
-  const color = withoutOwn(node.borderColor, n, (i) => darker(node.fill?.[i] ?? GEPHI_NODE_FILL));
-  const size = (i) => {
-    const w = node.width?.[i];
-    return typeof w === "number" ? w : GEPHI_NODE_SIZE;
-  };
-  const width = withoutOwn(node.borderWidth, n, (i) => round6(size(i) * GEPHI_BORDER_SHARE));
-  const labelSize = withoutOwn(node.labelSize, n, (i) => round6(size(i) * GEPHI_LABEL_PER_SIZE));
-  for (const [property, key, values, reason] of [
-    ["borderColor", BORDER_COLOR_KEY, color, "FILL_BORDER"],
-    ["borderWidth", BORDER_WIDTH_KEY, width, "FILL_BORDER"],
-    ["labelSize", LABEL_SIZE_KEY, labelSize, "NODE_SIZE_LABEL"]
-  ]) {
-    const elements = values.filter((v) => v !== null).length;
-    if (elements > 0) {
-      columns.set(key, values);
-      rules.push({
-        id: `node.tool.${key}`,
-        target: "node",
-        role: "passthrough",
-        origin: "tool",
-        where: { has: { style: key } },
-        map: { [property]: { kind: "passthrough", by: { style: key } } },
-        facts: { elements, reason }
-      });
-    }
-  }
-  const label = snapshot.nodes.names().find((name) => snapshot.nodes.get(name)?.meta.role === "label");
-  if (label !== void 0 && node.label === void 0) {
-    rules.push({
-      id: "node.tool.label",
-      target: "node",
-      role: "passthrough",
-      origin: "tool",
-      where: { has: { data: label } },
-      map: { label: { kind: "passthrough", by: { data: label } } },
-      facts: { reason: "NODE_NAME" }
-    });
-  }
-  return { rules, columns };
-}
-function gephiEdgeRules(snapshot, node, edge, budget) {
-  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 fill = (i) => node.fill?.[i] ?? GEPHI_NODE_FILL;
-  const mixed = withoutOwn(
-    edge.color,
-    snapshot.edgeCount,
-    (e) => mix(fill(snapshot.edgeSource(e)), fill(snapshot.edgeTarget(e)))
-  );
-  const uncolored = mixed.filter((v) => v !== null).length;
-  budget.spend("edge", snapshot.edgeCount);
-  const first = firstHalf(snapshot);
-  const weights = explicitWeights(snapshot);
-  const weightWidth = withoutOwn(edge.width, 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(MIXED_COLOR_KEY, mixed);
-    rules.push({
-      id: "edge.tool.mixed-color",
-      target: "edge",
-      role: "passthrough",
-      origin: "tool",
-      where: { has: { style: MIXED_COLOR_KEY } },
-      map: { color: { kind: "passthrough", by: { style: MIXED_COLOR_KEY } } },
-      facts: { elements: uncolored, reason: "END_NODES_COLOR" }
-    });
-  }
-  return { rules, columns };
-}
-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 gephiDarker(c) {
-  const x = Number.parseInt(c.slice(1), 16);
-  let out = 0;
-  for (const shift of [16, 8, 0]) {
-    out |= Math.min(255, Math.round((x >> shift & 255) * GEPHI_BORDER_DARKEN)) << shift;
-  }
-  return `#${out.toString(16).padStart(6, "0")}`;
-}
-const mix = (a, b) => gephiMix(String(a), String(b));
-const darker = (c) => gephiDarker(String(c));
-const round6 = (x) => Math.round(x * 1e6) / 1e6;
-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 gephi = gephiRules(snapshot, node, edge, context.budget);
-  return {
-    canonical: true,
-    dialect: "gexf",
-    tool: "gephi",
-    units: "relative",
-    node: { values: node, ...gephi.node },
-    edge: { values: edge, ...gephi.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 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];
-      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-P_gmFAOi.js.map