@graphty/graph-io 0.3.48 → 0.3.49

package/dist/chunks/{importer-CVT-JyDE.js → importer-vRq4h3j5.js}

@@ -1,15 +1,269 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { L as LOSS, c as capabilities, r as resolveExportOptions, C as sanitizeIds, p as pairFolding, a as checkCapabilities, e as explicitWeights, O as canonicalId, R as RENAMED_CODE, d as resolveImportOptions, f as reportUnusedOptions, h as graphChosen, g as reportSinkOptions, i as DirectionResolver, I as IdCoercer, u as uniqueColumnName, j as declareResolved, P as coerceIdText, m as isWeightField, o as parseWeightText } from "./export-CZ7VRm4I.js";
-import { f as isPajekLabel, g as quotePajekLabel } from "./escape-DH2Egt-l.js";
-import { i as idText, b as formatNumber, d as formatDecimal, f as formatF32, c as formatInteger } from "./format-BMS-1Nxb.js";
-import { p as plural, a as agree, P as PRECISION_CODE, l as DUPLICATE_ATTRIBUTE_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, R as ROLE_TAKEN_CODE, I as ID_MERGED_CODE, k as DUPLICATE_NODE_CODE, Q as SYNTAX_CODE, W as AMBIGUOUS_GRAPH_NAME_CODE, Y as GRAPH_NOT_FOUND_CODE, i as MULTIPLE_GRAPHS_CODE, s as UNKNOWN_ENCODING_CODE, t as ENCODING_FALLBACK_CODE, u as INVALID_ENCODING_CODE, v as INVALID_UTF8_CODE, y as ELEMENT_ISSUE, z as INPUT_ISSUE, K as ImportReportBuilder } from "./report-CgdsL9Hb.js";
-import { i as inferTextDtype, W as WIDENING_UNSUPPORTED_CODE, a as isNumericText, T as TextCellWriter } from "./text-BuKQVMz2.js";
+import { p as pairFolding, i as idText, b as formatNumber, d as formatDecimal, f as formatF32, c as formatInteger, D as DirectionResolver } from "./format-BXiAb-1h.js";
+import { h as isPajekLabel, j as quotePajekLabel } from "./escape-CuCIzNMB.js";
+import { e as explicitWeights, L as LOSS, c as capabilities, r as resolveExportOptions, z as sanitizeIds, a as checkCapabilities, H as canonicalId, R as RENAMED_CODE, b as resolveImportOptions, d as reportUnusedOptions, h as graphChosen, f as reportSinkOptions, I as IdCoercer, u as uniqueColumnName, i as declareResolved, Q as coerceIdText, k as isWeightField, p as parseWeightText } from "./export-Cha4dRFz.js";
+import { p as plural, a as agree, P as PRECISION_CODE, l as DUPLICATE_ATTRIBUTE_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, R as ROLE_TAKEN_CODE, I as ID_MERGED_CODE, k as DUPLICATE_NODE_CODE, Q as SYNTAX_CODE, W as AMBIGUOUS_GRAPH_NAME_CODE, Y as GRAPH_NOT_FOUND_CODE, i as MULTIPLE_GRAPHS_CODE, s as UNKNOWN_ENCODING_CODE, t as ENCODING_FALLBACK_CODE, u as INVALID_ENCODING_CODE, v as INVALID_UTF8_CODE, y as ELEMENT_ISSUE, z as INPUT_ISSUE, K as ImportReportBuilder } from "./report-CwMfYa9J.js";
+import { i as inferTextDtype, W as WIDENING_UNSUPPORTED_CODE, a as isNumericText, T as TextCellWriter } from "./text-ystE2bYi.js";
 import { j as joinText, e as encodeChunks } from "./writer-DxjgHwSe.js";
-import { i as importChosenGraph } from "./choose-Cdx6Enl2.js";
-import { L as LineReader, b as throwIfAborted } from "./input-Ccg9I22A.js";
-import { w as writeStyleBlock, c as styleBlockLosses, u as StyleNotes, p as plainCell, v as parseStyleBlock, s as styleFingerprint, x as blockStyles, r as resolveStyles, o as canonText, l as canonEnum, h as canonNumber, g as canonColor, y as colorOpacity, D as DVIPS_COLORS } from "./block-Cu22ewuS.js";
-import { S as StyleApproximations } from "./approximations-C2riR4NT.js";
-import { v as valueColumns } from "./styles-yed-Cs1nmrjn.js";
+import { p as postscriptFont, f as graphvizFontName, i as importChosenGraph } from "./choose-CczZJaX_.js";
+import { L as LineReader, b as throwIfAborted } from "./input-CAxt_aV-.js";
+import { A as writeStyleBlock, B as styleBlockLosses, h as StyleNotes, p as plainCell, f as canonText, a as canonEnum, d as canonColor, e as colorOpacity, c as canonNumber, n as noteAt, b as STYLE_ISSUE, y as toolDefaults, L as DVIPS_COLORS } from "./block-iptrlMBb.js";
+import { S as StyleApproximations } from "./approximations-Bzn3L-je.js";
+import { e as elementValues, t as takeFromBlock } from "./round-trip-Zm3_ivgq.js";
+import { v as valueColumns } from "./styles-yed-UMFdNqze.js";
+const PAJEK_WINDOW = 500;
+function resolvePajekDraw(option) {
+  if (option === void 0) {
+    return null;
+  }
+  const bad = (found) => {
+    throw new GraphFormatError("E_UNSUPPORTED", "option pajekDraw: not an object of Pajek draw settings", {
+      option: "pajekDraw",
+      found
+    });
+  };
+  if (typeof option !== "object" || option === null || Array.isArray(option)) {
+    return bad(option);
+  }
+  const o = option;
+  const num = (v, fallback, positive) => {
+    if (v === void 0) {
+      return fallback;
+    }
+    if (typeof v !== "number" || !Number.isFinite(v)) {
+      return bad(v);
+    }
+    const inRange = positive ? v > 0 : v >= 0;
+    return inRange ? v : bad(v);
+  };
+  const ini = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(o.ini ?? {})) {
+    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      return bad(value);
+    }
+    ini.set(name, String(value));
+  }
+  return {
+    width: num(o.width, PAJEK_WINDOW, true),
+    height: num(o.height, PAJEK_WINDOW, true),
+    partition: num(o.partition, 0, false),
+    vector: num(o.vector, 0, false),
+    vector2: num(o.vector2, 0, false),
+    ini
+  };
+}
+function flag(draw, name) {
+  const v = draw.ini.get(name);
+  return v !== void 0 && v !== "0" && v !== "false";
+}
+function drawsLineLabels(draw) {
+  return draw !== null && flag(draw, "Form8.withLabels1");
+}
+function iniNumber(draw, name) {
+  const v = draw.ini.get(name);
+  const n = v === void 0 || v.trim() === "" ? Number.NaN : Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+const PARTITION_COLORS = [
+  "#00ffff",
+  "#ffff00",
+  "#7fff00",
+  "#ff0000",
+  "#0000ff",
+  "#ffd8f2",
+  "#ffffff",
+  "#ff6321",
+  "#8c23ff",
+  "#606dc4",
+  "#1ef9a3",
+  "#009900",
+  "#7f7f7f",
+  "#000000",
+  "#ad0000",
+  "#ccffb2",
+  "#ffff99",
+  "#ff00ff",
+  "#007091",
+  "#ffb528",
+  "#ff0a9b",
+  "#00e000",
+  "#ff779e",
+  "#d8f2ff",
+  "#d8ff4f",
+  "#ff84ff",
+  "#e5ffcc",
+  "#ccccff",
+  "#59ddff",
+  "#ffd9bc",
+  "#db9370",
+  "#ccffff",
+  "#d8d8d8",
+  "#666666",
+  "#a5a5a5",
+  "#3f3f3f",
+  "#e5e5e5",
+  "#262626",
+  "#bfbfbf",
+  "#595959"
+];
+const VERTEX_SIZE = 20;
+const VERTEX_FILL = "#ffd9bc";
+const SIZE_OF_VERTICES = 8;
+function objectValues(snapshot, kind, n) {
+  if (n < 1) {
+    return null;
+  }
+  const pajek = snapshot.meta.extra.pajek;
+  const name = pajek?.objects?.filter((o) => o.kind === kind)[n - 1]?.column;
+  if (name === void 0 || !snapshot.nodes.has(name)) {
+    return null;
+  }
+  return (i) => {
+    const v = snapshot.nodes.value(name, i);
+    return typeof v === "number" && Number.isFinite(v) ? v : null;
+  };
+}
+function column(values, property, n) {
+  values[property] ??= new Array(n).fill(null);
+  return values[property];
+}
+function drawVertices(draw, snapshot, node) {
+  const n = snapshot.nodeCount;
+  const width = column(node, "width", n);
+  const height = column(node, "height", n);
+  scaleVertexSizes(draw, width, height);
+  sizeByVectors(draw, snapshot, width, height);
+  colorByPartition(draw, snapshot, node);
+  const opacity = iniNumber(draw, "TransparencyofVertices");
+  if (opacity !== null && opacity < 1) {
+    const o = Math.max(0, opacity);
+    const fill = column(node, "fillOpacity", n);
+    fill.forEach((v, i) => {
+      fill[i] = (typeof v === "number" ? v : 1) * o;
+    });
+    column(node, "borderOpacity", n).fill(o * o);
+  }
+  if (flag(draw, "Form10.effect3d")) {
+    effect3d(snapshot, node);
+  }
+  markVertices(draw, node, n);
+  for (const property of ["width", "height"]) {
+    if (node[property].every((v) => v === null)) {
+      Reflect.deleteProperty(node, property);
+    }
+  }
+}
+function scaleVertexSizes(draw, width, height) {
+  const size = iniNumber(draw, "Form8.SizeofVertices");
+  if (size === null || size === SIZE_OF_VERTICES) {
+    return;
+  }
+  const f = size / SIZE_OF_VERTICES;
+  const scaled = (v) => typeof v === "number" ? v * f : VERTEX_SIZE * f * f;
+  for (let i = 0; i < width.length; i++) {
+    width[i] = scaled(width[i]);
+    height[i] = scaled(height[i]);
+  }
+}
+function colorByPartition(draw, snapshot, node) {
+  const partition = objectValues(snapshot, "partition", draw.partition);
+  if (partition === null) {
+    return;
+  }
+  const fill = column(node, "fill", snapshot.nodeCount);
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const k = partition(i);
+    if (k !== null) {
+      fill[i] = PARTITION_COLORS[Math.abs(k) % PARTITION_COLORS.length];
+    }
+  }
+}
+function markVertices(draw, node, n) {
+  const mark = iniNumber(draw, "Form8.MarkVerticesUsing");
+  if (mark === 2) {
+    column(node, "label", n).forEach((_, i, a) => {
+      a[i] = String(i + 1);
+    });
+  } else if (mark === 3 || mark === 4) {
+    column(node, "label", n).fill("");
+  }
+}
+function effect3d(snapshot, node) {
+  const n = snapshot.nodeCount;
+  const fill = column(node, "fill", n);
+  const end = column(node, "fillGradient", n);
+  const angle = column(node, "fillGradientAngle", n);
+  const half = (v) => {
+    const h = v / 2;
+    const f = Math.floor(h);
+    return h - f === 0.5 && f % 2 === 0 ? f : Math.round(h);
+  };
+  for (let i = 0; i < n; i++) {
+    const color = typeof fill[i] === "string" ? String(fill[i]) : VERTEX_FILL;
+    end[i] = `#${[1, 3, 5].map(
+      (k) => half(Number.parseInt(color.slice(k, k + 2), 16)).toString(16).padStart(2, "0")
+    ).join("")}`;
+    const phi = snapshot.nodes.has("phi") ? Number(snapshot.nodes.value("phi", i)) : 0;
+    angle[i] = Number.isFinite(phi) ? ((90 - phi) % 360 + 360) % 360 : 90;
+  }
+}
+function sizeByVectors(draw, snapshot, width, height) {
+  const first = objectValues(snapshot, "vector", draw.vector);
+  if (first === null) {
+    return;
+  }
+  const second = objectValues(snapshot, "vector", draw.vector2);
+  const scale = (sizes, i, v) => {
+    if (v !== null && v >= 0) {
+      sizes[i] = (typeof sizes[i] === "number" ? sizes[i] : VERTEX_SIZE) * v;
+    }
+  };
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const v = first(i);
+    if (second === null) {
+      const root = v === null || v < 0 ? null : Math.sqrt(v);
+      scale(width, i, root);
+      scale(height, i, root);
+    } else {
+      scale(width, i, v);
+      scale(height, i, second(i));
+    }
+  }
+}
+function drawLines(draw, snapshot, node, edge) {
+  const m = snapshot.edgeCount;
+  const opacity = iniNumber(draw, "TransparencyofLines");
+  if (opacity !== null && opacity < 1) {
+    const o = column(edge, "opacity", m);
+    o.forEach((v, e) => {
+      o[e] = (typeof v === "number" ? v : 1) * Math.max(0, opacity);
+    });
+  }
+  if (flag(draw, "Form10.StraightLinesOnly1")) {
+    const curved = column(edge, "curved", m);
+    for (let e = 0; e < m; e++) {
+      const bends = edge.bends?.[e];
+      if (bends === null || bends === void 0) {
+        curved[e] = false;
+      }
+    }
+  }
+  if (flag(draw, "Form10.ColorGradientLines")) {
+    const fill = node.fill;
+    const fillOf = (i) => typeof fill?.[i] === "string" ? fill[i] : VERTEX_FILL;
+    const colors = column(edge, "gradientColors", m);
+    const kind = column(edge, "gradientKind", m);
+    const sourceArrow = column(edge, "sourceArrowColor", m);
+    const targetArrow = column(edge, "targetArrowColor", m);
+    for (let e = 0; e < m; e++) {
+      const [s, t] = [fillOf(snapshot.edgeSource(e)), fillOf(snapshot.edgeTarget(e))];
+      colors[e] = `${s} ${t}`;
+      kind[e] = "linear";
+      sourceArrow[e] = s;
+      targetArrow[e] = t;
+    }
+  }
+}
 const LABEL_COLUMN = "label";
 const POSITION_COLUMN = "position";
 const SHAPE_COLUMN = "shape";
@@ -256,7 +510,7 @@ function parseIntervals(token) {
     return [];
   }
   const spells = [];
-  for (const part of body.split(",")) {
+  for (const part of body.split(/[,/]/)) {
     spells.push(parseSpell(token, part));
   }
   return spells;
@@ -328,6 +582,20 @@ function isParameterKey(text) {
   }
   return !/^[+-]?(\.\d|\d)/.test(text) && !/^[+-]?(?:nan|inf|infinity)$/i.test(text);
 }
+const VOIDING_KEYS = /* @__PURE__ */ new Set([
+  "bc",
+  "bw",
+  "s_size",
+  "phi",
+  "r",
+  "q",
+  "lc",
+  "la",
+  "lr",
+  "lphi",
+  "fos",
+  "font"
+]);
 const PAJEK_STYLE_CAPABILITIES = Object.freeze({
   tool: "pajek",
   node: Object.freeze([
@@ -338,22 +606,93 @@ const PAJEK_STYLE_CAPABILITIES = Object.freeze({
     "borderColor",
     "borderWidth",
     "shape",
+    "shapePoints",
     "width",
     "height",
     "labelColor",
-    "labelSize"
+    "labelSize",
+    "labelFont",
+    "labelPosition",
+    "labelOffsetX",
+    "labelOffsetY",
+    "labelShiftX"
+  ]),
+  edge: Object.freeze([
+    "color",
+    "opacity",
+    "width",
+    "lineStyle",
+    "sourceArrow",
+    "targetArrow",
+    "arrowPosition",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont"
   ]),
-  edge: Object.freeze(["color", "opacity", "width", "lineStyle", "sourceArrow", "targetArrow"]),
   block: "native"
 });
-const VERTEX_SIZE = 5;
-const NODE_KEYS = ["ic", "bc", "bw", "x_fact", "y_fact", "lc", "fos"];
-const EDGE_KEYS = ["c", "w", "p"];
+const PAJEK_VERTEX_SIZE = 20;
+const PAJEK_FIGURES = /* @__PURE__ */ new Map([
+  ["other:man", [2.502, 6.487]],
+  ["other:woman", [3.003, 6.478]]
+]);
+const PAJEK_POINTS_PER_UNIT = 500;
+const NODE_KEYS = [
+  "ic",
+  "bc",
+  "bw",
+  "s_size",
+  "x_fact",
+  "y_fact",
+  "phi",
+  "q",
+  "lc",
+  "fos",
+  "font",
+  "lr",
+  "lphi",
+  "la"
+];
+const EDGE_KEYS = ["c", "w", "p", "s", "ap", "l", "lc", "fos", "font"];
+const CARRIED = {
+  node: [SHAPE_COLUMN, ...NODE_KEYS],
+  edge: ["c", "w", "p", "s", "ap"]
+};
+const CARRIED_LINE = CARRIED.edge.filter((key) => key !== "p");
+const EDGE_WIDTH_PER_W = 2;
+const ARC_DEFAULTS = { color: "#999999", width: 1 };
+function carriedParams(keys, whole) {
+  let last = /* @__PURE__ */ new Map();
+  return (get) => {
+    const own = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const v = get(key);
+      if (v !== null) {
+        own.set(key, v);
+      }
+    }
+    if (whole) {
+      if (own.size > 0) {
+        last = own;
+        return get;
+      }
+    } else {
+      for (const [key, v] of own) {
+        last.set(key, v);
+      }
+    }
+    const carried = last;
+    return (key) => get(key) ?? (keys.includes(key) ? carried.get(key) ?? null : null);
+  };
+}
 const DIRECTED_KEY = "directed";
 const READ = {
   node: [
     "label",
     "shape",
+    "shapePoints",
+    "shapePointsStretch",
     "fill",
     "fillOpacity",
     "borderColor",
@@ -361,9 +700,26 @@ const READ = {
     "width",
     "height",
     "labelColor",
-    "labelSize"
+    "labelSize",
+    "labelFont",
+    "labelPosition",
+    "labelOffsetX",
+    "labelOffsetY",
+    "labelShiftX",
+    "labelRotation"
   ],
-  edge: ["color", "opacity", "width", "lineStyle"]
+  edge: [
+    "color",
+    "opacity",
+    "width",
+    "lineStyle",
+    "arrowSize",
+    "arrowPosition",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont"
+  ]
 };
 function readColor(raw, property, opacity, put, at) {
   if (raw === null) {
@@ -371,6 +727,10 @@ function readColor(raw, property, opacity, put, at) {
   }
   const c = canonColor(raw, "dvips", at(property));
   if (c === null) {
+    const unknown = UNKNOWN_COLORS.get(property);
+    if (unknown !== void 0 && typeof raw === "string" && /^[A-Za-z]\w*$/.test(raw.trim())) {
+      put(property, unknown);
+    }
     return;
   }
   put(property, c.color);
@@ -379,43 +739,437 @@ function readColor(raw, property, opacity, put, at) {
     put(opacity, alpha);
   }
 }
+const UNKNOWN_COLORS = /* @__PURE__ */ new Map([
+  ["fill", "#ffffff"],
+  ["color", "#000000"]
+]);
 function readNumber(raw, property, put, at) {
   if (raw !== null) {
     put(property, canonNumber(raw, at(property)));
   }
 }
-function readVertex(get, put, at) {
+function readVertex(get, put, at, place = null) {
   const label = get(LABEL_COLUMN);
   if (label !== null && label !== "") {
     put("label", canonText(label, at("label")));
   }
-  const shape = get(SHAPE_COLUMN);
-  if (shape !== null) {
-    put("shape", canonEnum("shape", shape, "dvips", at("shape")));
+  const raw = get(SHAPE_COLUMN);
+  const shape = raw === null ? null : canonEnum("shape", raw, "dvips", at("shape"));
+  if (raw !== null) {
+    put("shape", shape);
   }
   readColor(get("ic"), "fill", "fillOpacity", put, at);
   readColor(get("bc"), "borderColor", null, put, at);
-  const bw = get("bw");
-  if (bw !== null) {
-    const width = canonNumber(bw, at("borderWidth"));
-    put("borderWidth", width === null ? null : width / VERTEX_SIZE);
-  }
-  readNumber(get("x_fact"), "width", put, at);
-  readNumber(get("y_fact"), "height", put, at);
+  readNumber(get("bw"), "borderWidth", put, at);
+  readSize(get, put, at, PAJEK_FIGURES.get(String(shape)));
+  readOutline(get, put, shape);
   readColor(get("lc"), "labelColor", null, put, at);
   readNumber(get("fos"), "labelSize", put, at);
+  readFont(get("font"), put, at);
+  readLabelPosition(get, put, at);
+  readLabelAngle(get("la"), put, at, place);
+  if (shape === "none") {
+    for (const [property, value] of EMPTY_LABEL) {
+      put(property, value);
+    }
+  }
+}
+const PAJEK_OUTLINES = /* @__PURE__ */ new Map([
+  [
+    "rectangle",
+    [
+      [-1, 1],
+      [1, 1],
+      [1, -1],
+      [-1, -1]
+    ]
+  ],
+  [
+    "triangle",
+    [
+      [1, -1],
+      [0, 1],
+      [-1, -1]
+    ]
+  ],
+  [
+    "other:house",
+    [
+      [-0.7, -1],
+      [0.7, -1],
+      [0.7, 0.3],
+      [1, 0.3],
+      [1, 0.4],
+      [0, 1],
+      [-1, 0.4],
+      [-1, 0.3],
+      [-0.7, 0.3]
+    ]
+  ]
+]);
+const PAJEK_DIAMOND_Q = 1e-3;
+function readOutline(get, put, shape) {
+  const phi = numberOrNull(get("phi")) ?? 0;
+  const q = numberOrNull(get("q")) ?? PAJEK_DIAMOND_Q;
+  const diamond = [
+    [-1, 0],
+    [-q, 1],
+    [q, 1],
+    [1, 0],
+    [q, -1],
+    [-q, -1]
+  ];
+  const corners = shape === "diamond" ? diamond : PAJEK_OUTLINES.get(String(shape));
+  if (corners === void 0 || shape !== "diamond" && phi % 360 === 0) {
+    return;
+  }
+  const [w, h] = [numberOrNull(get("x_fact")) || 1, numberOrNull(get("y_fact")) || 1];
+  const [c, s] = [Math.cos(phi * Math.PI / 180), Math.sin(phi * Math.PI / 180)];
+  const round = (v) => String(Number(v.toFixed(4)) + 0);
+  const points = corners.map(([x, y]) => {
+    const [px, py] = [x * w, y * h];
+    return `${round((px * c - py * s) / w)},${round((px * s + py * c) / h)}`;
+  });
+  put("shape", "polygon");
+  put("shapePoints", points.join(" "));
+  put("shapePointsStretch", false);
+}
+const EMPTY_LABEL = [
+  ["labelSize", 1],
+  ["labelColor", "#ffffff"],
+  ["labelPosition", "center"],
+  ["labelOffsetX", 0],
+  ["labelOffsetY", 0],
+  ["labelShiftX", 0]
+];
+function readFont(raw, put, at) {
+  if (raw === null || raw === "") {
+    return;
+  }
+  const ps = typeof raw === "string" ? postscriptFont(raw.trim()) : null;
+  if (ps === null) {
+    readText(raw, "labelFont", put, at);
+    return;
+  }
+  put("labelFont", ps.family);
 }
-function readLine(get, put, at) {
+function readLabelAngle(raw, put, at, place) {
+  let a = raw === null ? null : canonNumber(raw, at("labelRotation"));
+  if (a !== null && a >= 360) {
+    a = place === null ? null : Math.atan2(0.5 - place[1], place[0] - 0.5) * 180 / Math.PI + a - 360;
+  }
+  if (a !== null) {
+    put("labelRotation", Number((((360 - a) % 360 + 360) % 360).toPrecision(12)));
+  }
+}
+function readSize(get, put, at, figure) {
+  for (const [key, property, k] of [
+    ["x_fact", "width", 0],
+    ["y_fact", "height", 1]
+  ]) {
+    const f = get(key);
+    if (f === null && figure === void 0) {
+      continue;
+    }
+    const factor = f === null ? 1 : canonNumber(f, at(property));
+    const over = figure?.[k] ?? 1;
+    put(property, factor === null ? null : Number((PAJEK_VERTEX_SIZE * factor * over).toPrecision(15)));
+  }
+}
+function readText(raw, property, put, at) {
+  if (raw !== null && raw !== "") {
+    put(property, canonText(raw, at(property)));
+  }
+}
+const SIDE_ANGLES = /* @__PURE__ */ new Map([
+  ["right", 0],
+  ["top-right", 90],
+  ["left", 180],
+  ["bottom-right", 285]
+]);
+const NEAREST_SIDES = /* @__PURE__ */ new Map([
+  ["top", "top-right"],
+  ["top-left", "top-right"],
+  ["bottom", "bottom-right"],
+  ["bottom-left", "bottom-right"]
+]);
+function readLabelPosition(get, put, at) {
+  const [lr, lphi, fos] = [get("lr"), get("lphi"), get("fos")];
+  if (lr === null && lphi === null && fos === null) {
+    return;
+  }
+  const radius = lr === null ? PAJEK_LABEL_RADIUS : canonNumber(lr, at("labelPosition"));
+  const angle = lphi === null ? PAJEK_LABEL_ANGLE : canonNumber(lphi, at("labelPosition"));
+  const size = fos === null ? PAJEK_LABEL_SIZE : canonNumber(fos, at("labelSize"));
+  if (radius === null || angle === null || size === null) {
+    return;
+  }
+  const [x, y] = labelOffset(radius, angle, size);
+  put("labelPosition", "center");
+  put("labelOffsetX", x);
+  put("labelOffsetY", y);
+  put("labelShiftX", radius === 0 ? 0 : 0.5);
+}
+function labelOffset(radius, angle, size) {
+  if (radius === 0) {
+    return [0, 0];
+  }
+  const t = angle * Math.PI / 180;
+  const round = (v) => Number(v.toFixed(9)) + 0;
+  return [round(radius * Math.cos(t)), round(-radius * Math.sin(t) - PAJEK_BASELINE_TO_MIDDLE * size)];
+}
+const PAJEK_LABEL_RADIUS = 20;
+const PAJEK_LABEL_ANGLE = 285;
+const PAJEK_LABEL_SIZE = 15;
+const PAJEK_BASELINE_TO_MIDDLE = 0.3465;
+function readLine(get, put, at, directed, labels = true, run = null, loop = null) {
   readColor(get("c"), "color", "opacity", put, at);
-  readNumber(get("w"), "width", put, at);
+  readNumber(
+    get("w"),
+    "width",
+    (property, value) => {
+      put(property, typeof value === "number" && !directed ? value * EDGE_WIDTH_PER_W : value);
+    },
+    at
+  );
   const p = get("p");
-  if (p !== null) {
-    put("lineStyle", canonEnum("lineStyle", p, "dvips", at("lineStyle")));
+  if (p === "Dots") {
+    put("lineStyle", pajekDash(get, directed));
+  } else if (p === "Solid") {
+    put("lineStyle", "solid");
+  } else if (p !== null) {
+    noteAt(at("lineStyle"), STYLE_ISSUE.UNKNOWN_VALUE, typeof p === "string" ? p : JSON.stringify(p));
+    put("lineStyle", "solid");
+  }
+  readNumber(get("s"), "arrowSize", put, at);
+  readArrowPosition(get("ap"), put, at);
+  const line = loop === null ? get : loopParam(get);
+  const controls = loop === null ? null : readLoop(line, put, loop);
+  if (labels) {
+    readText(get("l"), "label", put, at);
+    if (controls === null) {
+      readLineLabelPlace(get, put, at, run);
+    } else {
+      readLineLabelPlace(line, put, at, [PAJEK_POINTS_PER_UNIT, 0], loopTop(controls));
+    }
+  }
+  if (loop === null) {
+    readBezier(get, put, run);
+  }
+  readColor(get("lc"), "labelColor", null, put, at);
+  readNumber(get("fos"), "labelSize", put, at);
+  readFont(get("font"), put, at);
+}
+const LOOP_DEFAULTS = { a1: -70, k1: 0.3, a2: -70, k2: 0.3 };
+function loopParam(get) {
+  return (key) => get(key) ?? (key in LOOP_DEFAULTS ? LOOP_DEFAULTS[key] : null);
+}
+function readLoop(get, put, loop) {
+  const run = [PAJEK_POINTS_PER_UNIT, 0];
+  const controls = bezierControls(get, run);
+  if (controls === null) {
+    return null;
+  }
+  const [[a1, l1], [a2, l2]] = controls;
+  const L = PAJEK_POINTS_PER_UNIT;
+  const [c1, c2] = [
+    [a1 * L, -l1 * L],
+    [(a2 - 1) * L, -l2 * L]
+  ];
+  loop([c1, c2]);
+  put("curved", true);
+  put("bendCurve", "bezier");
+  put("targetArrow", "none");
+  return [c1, c2];
+}
+function loopTop(controls) {
+  const [c1, c2] = controls;
+  return Math.atan2(c2[1] - c1[1], c2[0] - c1[0]) * 180 / Math.PI;
+}
+function layLoops(snapshot, loops, node, edge) {
+  const fraction = (x) => String(Math.round(x * 1e4) / 1e4 || 0);
+  for (const [e, controls] of loops) {
+    const v = snapshot.edgeSource(e);
+    const half = (property) => {
+      const size = node[property]?.[v];
+      return (typeof size === "number" && size > 0 ? size : PAJEK_VERTEX_SIZE) / 2;
+    };
+    const [hw, hh] = [half("width"), half("height")];
+    const column2 = (property) => edge[property] ??= new Array(snapshot.edgeCount).fill(null);
+    column2("bends")[e] = controls.map(([x, y]) => `${fraction(x / hw)},${fraction(-y / hh)}`).join(" ");
+    column2("curved")[e] = true;
+    column2("bendCurve")[e] = "bezier";
+  }
+}
+function readLineLabelPlace(get, put, at, run, direction) {
+  const length = run === null ? 0 : Math.hypot(run[0], run[1]);
+  if (run === null || length === 0) {
+    return;
+  }
+  const n = (key, fallback, property) => {
+    const v = get(key);
+    return v === null ? fallback : canonNumber(v, at(property));
+  };
+  const [lp, lr, lphi, la] = [
+    n("lp", 0.5, "labelOffsetX"),
+    n("lr", 0, "labelOffsetX"),
+    n("lphi", 0, "labelOffsetX"),
+    n("la", 0, "labelRotation")
+  ];
+  const size = n("fos", PAJEK_LABEL_SIZE, "labelSize");
+  if (lp === null || lr === null || lphi === null || la === null || size === null) {
+    return;
+  }
+  const along = 0.5 - (lp <= 1 ? lp : lp / length);
+  const t = lphi * Math.PI / 180;
+  const round = (v) => Number(v.toFixed(9)) + 0;
+  const turn = ((direction ?? lineDirection(get, run, along + 0.5)) - la) % 360 + 360;
+  const up = turn * Math.PI / 180;
+  const rise = PAJEK_BASELINE_TO_MIDDLE * size;
+  put("labelPosition", "center");
+  put("labelOffsetX", round(along * run[0] + lr * Math.cos(t) + rise * Math.sin(up)));
+  put("labelOffsetY", round(along * run[1] - lr * Math.sin(t) - rise * Math.cos(up)));
+  put("labelRotation", round(turn % 360));
+}
+function readBezier(get, put, run) {
+  const controls = bezierControls(get, run);
+  if (controls === null) {
+    return;
+  }
+  const fraction = (x) => String(Math.round(x * 1e4) / 1e4 || 0);
+  put("curved", true);
+  put("bendCurve", "bezier");
+  put("bends", controls.map(([along, across]) => `${fraction(along)},${fraction(across)}`).join(" "));
+}
+function readArcEnd(get, put, run, target) {
+  const ap = numberOrNull(get("ap")) ?? 0;
+  const length = Math.hypot(run[0], run[1]);
+  if (ap !== 0 || length === 0 || bezierControls(get, run) === null) {
+    return;
+  }
+  const [ux, uy] = [run[0] / length, run[1] / length];
+  const r = 1 / Math.hypot(ux / (target[0] / 2), uy / (target[1] / 2));
+  const back = 1.5 + 5 * (numberOrNull(get("s")) ?? 1);
+  const turn = -(numberOrNull(get("a2")) ?? 0) * Math.PI / 180;
+  const [c, s] = [Math.cos(turn), Math.sin(turn)];
+  const end = [run[0] - r * ux - back * (ux * c - uy * s), run[1] - r * uy - back * (ux * s + uy * c)];
+  const controls = bezierControls(get, end);
+  if (controls === null) {
+    return;
+  }
+  const L2 = length * length;
+  const fraction = (x) => String(Math.round(x * 1e4) / 1e4 || 0);
+  const bends = controls.map(([along, left]) => {
+    const [x, y] = [along * end[0] + left * end[1], along * end[1] - left * end[0]];
+    return `${fraction((x * run[0] + y * run[1]) / L2)},${fraction((x * run[1] - y * run[0]) / L2)}`;
+  });
+  put("bends", bends.join(" "));
+}
+function bezierControls(get, run) {
+  const [a1, k1, a2, k2] = ["a1", "k1", "a2", "k2"].map((key) => numberOrNull(get(key)));
+  if (a1 === null && k1 === null && a2 === null && k2 === null || run === null || run[0] === 0 && run[1] === 0) {
+    return null;
+  }
+  const [s, t] = [k1 ?? 1, k2 ?? 1];
+  if (s < 0 || t < 0) {
+    return null;
+  }
+  const rad = Math.PI / 180;
+  const [u, v] = [(a1 ?? 0) * rad, (a2 ?? 0) * rad];
+  return [
+    [s / 2 * Math.cos(u), -s / 2 * Math.sin(u)],
+    [1 - t / 2 * Math.cos(v), -t / 2 * Math.sin(v)]
+  ];
+}
+function lineDirection(get, run, along) {
+  const controls = bezierControls(get, run);
+  let [dx, dy] = run;
+  if (controls !== null) {
+    const t = Math.min(1, Math.max(0, along));
+    const p = [[0, 0], ...controls, [1, 0]];
+    const d = (k) => 3 * (1 - t) ** 2 * (p[1][k] - p[0][k]) + 6 * (1 - t) * t * (p[2][k] - p[1][k]) + 3 * t ** 2 * (p[3][k] - p[2][k]);
+    const [a, l] = [d(0), d(1)];
+    [dx, dy] = [a * run[0] + l * run[1], a * run[1] - l * run[0]];
+  }
+  return Math.atan2(dy, dx) * 180 / Math.PI;
+}
+function readLineValue(value, get, put, directed = true) {
+  if (value === 0) {
+    put("visible", false);
+  } else if (value !== null && value < 0 && get("p") === null) {
+    put("lineStyle", pajekDash(get, directed));
+  }
+}
+const PAJEK_DASH = 5;
+function pajekDash(get, directed) {
+  const w = numberOrNull(get("w"));
+  const width = (w ?? 1) * (directed ? 1 : EDGE_WIDTH_PER_W);
+  return PAJEK_DASH <= 1.5 * Math.max(1, width) ? "dotted" : "dashed";
+}
+function readHooks(get, put, source, target) {
+  for (const [key, property, shape] of [
+    ["h1", "sourcePort", source],
+    ["h2", "targetPort", target]
+  ]) {
+    const hook = numberOrNull(get(key));
+    const port = hook === null ? null : hookPort(shape, hook);
+    if (port !== null) {
+      const round = (v) => String(Number(v.toFixed(4)) + 0);
+      put(property, `${round(port[0])},${round(port[1])}`);
+    }
+  }
+}
+function hookPort(shape, hook) {
+  if (!Number.isInteger(hook) || hook < 1) {
+    return null;
+  }
+  const keyword = typeof shape === "string" ? shape.toLowerCase() : "ellipse";
+  if (keyword === "ellipse" || keyword === "cross") {
+    const a = hook * Math.PI / 180;
+    return [Math.cos(a), Math.sin(a)];
+  }
+  if (keyword !== "box" || hook > 400) {
+    return null;
+  }
+  const d = hook * 0.02;
+  if (hook <= 50) {
+    return [1, d];
+  }
+  if (hook <= 150) {
+    return [2 - d, 1];
+  }
+  if (hook <= 250) {
+    return [-1, 4 - d];
+  }
+  return hook <= 350 ? [d - 6, -1] : [1, d - 8];
+}
+function numberOrNull(raw) {
+  if (typeof raw === "string" && raw.trim() !== "") {
+    raw = Number(raw);
+  }
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+}
+function readArrowPosition(raw, put, at) {
+  if (raw === null) {
+    return;
+  }
+  const ap = canonNumber(raw, at("arrowPosition"));
+  if (ap !== null && ap > 1) {
+    noteAt(at("arrowPosition"), STYLE_ISSUE.NOT_CARRIED, `ap ${String(ap)}`);
+    return;
+  }
+  if (ap !== 0) {
+    put("arrowPosition", ap);
   }
 }
 function cells(table, i) {
-  return (key) => table.has(key) ? plainCell(table.value(key, i)) : null;
+  return (key) => {
+    const v = table.has(key) ? plainCell(table.value(key, i)) : null;
+    return COLOR_PARAMS.has(key) && typeof v === "string" && NUMERIC_COLOR.test(v) ? null : v;
+  };
 }
+const COLOR_PARAMS = /* @__PURE__ */ new Set(["ic", "bc", "lc", "c"]);
+const NUMERIC_COLOR = /^[\d.]+(?: [\d.]+)*$/;
 function directedEdges(snapshot) {
   const out = new Array(snapshot.edgeCount).fill(snapshot.directed);
   const col = snapshot.directed ? snapshot.edges.byRole("directed") : null;
@@ -431,32 +1185,72 @@ function styleColumns(table, keys) {
 }
 function pajekStyles(snapshot, context) {
   const notes = new StyleNotes();
+  const { block, draw, voided } = keptOf(context.kept);
+  const labels = drawsLineLabels(draw);
+  const place = places(snapshot);
+  const window = draw ?? { width: PAJEK_POINTS_PER_UNIT, height: PAJEK_POINTS_PER_UNIT };
+  const loops = /* @__PURE__ */ new Map();
+  const runOf = (e) => {
+    const [s, t] = [place(snapshot.edgeSource(e)), place(snapshot.edgeTarget(e))];
+    return s === null || t === null ? null : [(t[0] - s[0]) * window.width, (t[1] - s[1]) * window.height];
+  };
   const read = (target) => {
     const table = target === "node" ? snapshot.nodes : snapshot.edges;
     const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
     const out = valueColumns(n);
+    const carry = carriedParams(target === "node" ? CARRIED.node : CARRIED_LINE, target === "node");
     for (let i = 0; i < n; i++) {
       context.budget.spend(target, 1);
       const at = (property) => ({ notes, target, property, element: i, budget: context.budget });
-      (target === "node" ? readVertex : readLine)(
-        cells(table, i),
-        (property, value) => {
-          out.put(i, property, value);
-        },
-        at
-      );
+      const put = (property, value) => {
+        out.put(i, property, value);
+      };
+      const own = cells(table, i);
+      const get = target === "node" && voided.has(i) ? voidedParams(own, keywords[i - 1] ?? null) : carry(own);
+      if (target === "node") {
+        readVertex(get, put, at, place(i));
+        keywords[i] = get(SHAPE_COLUMN);
+      } else {
+        readEdge(i, get, put, at);
+      }
     }
     return out.values;
   };
+  const readEdge = (i, get, put, at) => {
+    const run = runOf(i);
+    const loop = run !== null && block === null && snapshot.edgeSource(i) === snapshot.edgeTarget(i) ? (controls) => {
+      loops.set(i, controls);
+    } : null;
+    readLine(get, put, at, directed[i], labels, run, loop);
+    if (directed[i] && loop === null && run !== null) {
+      readArcEnd(get, put, run, targetSize(snapshot.edgeTarget(i)));
+    }
+    readLineValue(lineValue(i), get, put, directed[i]);
+    readHooks(get, put, keywords[snapshot.edgeSource(i)], keywords[snapshot.edgeTarget(i)]);
+  };
+  const directed = directedEdges(snapshot);
+  const keywords = [];
+  const weights = explicitWeights(snapshot);
+  const lineValue = (e) => weights.isExplicit(e) ? weights.value(e) : numberOrNull(cells(snapshot.edges, e)(VALUE_COLUMN));
   const node = read("node");
+  const targetSize = (v) => {
+    const size = (property) => {
+      const s = node[property]?.[v];
+      return typeof s === "number" && s > 0 ? s : PAJEK_VERTEX_SIZE;
+    };
+    return [size("width"), size("height")];
+  };
   const edge = read("edge");
-  const block = typeof context.kept === "string" ? context.kept : null;
+  if (draw !== null) {
+    drawVertices(draw, snapshot, node);
+    drawLines(draw, snapshot, node, edge);
+  }
+  layLoops(snapshot, loops, node, edge);
   if (block !== null) {
-    exactFromBlock(snapshot, block, { node, edge });
+    exactFromBlock(snapshot, block, { node, edge }, labels);
   }
   const rules = [];
   const columns = /* @__PURE__ */ new Map();
-  const directed = directedEdges(snapshot);
   if (directed.some(Boolean)) {
     columns.set(
       DIRECTED_KEY,
@@ -468,14 +1262,14 @@ function pajekStyles(snapshot, context) {
       role: "group",
       origin: "tool",
       where: { has: { style: DIRECTED_KEY } },
-      set: { targetArrow: "triangle" }
+      set: { targetArrow: "triangle", color: ARC_DEFAULTS.color, width: ARC_DEFAULTS.width }
     });
   }
   return {
     canonical: true,
     dialect: "dvips",
     tool: "pajek",
-    units: "relative",
+    units: "px",
     node: { values: node },
     edge: { values: edge, rules, columns },
     notes: notes.list(),
@@ -486,6 +1280,39 @@ function pajekStyles(snapshot, context) {
     }
   };
 }
+function places(snapshot) {
+  const col = snapshot.nodes.byRole("position");
+  return (i) => {
+    const v = col === null || col === void 0 ? null : col.value(i);
+    if (v === null || typeof v !== "object" || !("length" in v)) {
+      return null;
+    }
+    const [x, y] = v;
+    return typeof x === "number" && typeof y === "number" ? [x, y] : null;
+  };
+}
+function keptOf(kept) {
+  if (typeof kept === "string") {
+    return { block: kept, draw: null, voided: /* @__PURE__ */ new Set() };
+  }
+  if (typeof kept === "object" && kept !== null) {
+    const { block, pajekDraw, voided } = kept;
+    return {
+      block: typeof block === "string" ? block : null,
+      draw: pajekDraw ?? null,
+      voided: new Set(voided ?? [])
+    };
+  }
+  return { block: null, draw: null, voided: /* @__PURE__ */ new Set() };
+}
+function voidedParams(own, before) {
+  return (key) => {
+    if (key === LABEL_COLUMN) {
+      return own(key);
+    }
+    return key === SHAPE_COLUMN ? before : null;
+  };
+}
 const SHAPES = /* @__PURE__ */ new Map([
   ["ellipse", "ellipse"],
   ["rectangle", "box"],
@@ -526,9 +1353,37 @@ function shapeKeyword(get, approximate) {
   if (keyword !== void 0) {
     return keyword;
   }
+  if (shape === "polygon" && diamondQ(get) !== null) {
+    return "diamond";
+  }
   approximate("shape", shape);
+  const points = get("shapePoints");
+  if (shape === "polygon" && points !== null) {
+    approximate("shapePoints", points);
+  }
   return NEAREST_SHAPES.get(shape) ?? "ellipse";
 }
+function diamondQ(get) {
+  const points = get("shapePoints");
+  const corners = typeof points === "string" ? points.trim().split(/\s+/).map((p) => p.split(",").map(Number)) : [];
+  if (corners.length !== 6) {
+    return null;
+  }
+  const q = corners[2][0];
+  const want = [
+    [-1, 0],
+    [-q, 1],
+    [q, 1],
+    [1, 0],
+    [q, -1],
+    [-q, -1]
+  ];
+  return want.every(([x, y], k) => corners[k][0] === x && corners[k][1] === y) ? q : null;
+}
+function pajekDefault(target, property) {
+  const values = toolDefaults("pajek")?.[target];
+  return values?.[property]?.value;
+}
 function vertexParams(get, approximate) {
   const out = /* @__PURE__ */ new Map();
   opaque(get, ["fillOpacity", "opacity"], approximate);
@@ -536,54 +1391,117 @@ function vertexParams(get, approximate) {
   if (keyword !== "ellipse") {
     out.set(SHAPE_COLUMN, keyword);
   }
+  const q = diamondQ(get);
+  if (q !== null && q !== PAJEK_DIAMOND_Q) {
+    out.set("q", q);
+  }
+  vertexColorParams(get, out);
+  vertexSizeParams(get, out);
+  const bw = get("borderWidth");
+  if (typeof bw === "number" && bw !== pajekDefault("node", "borderWidth")) {
+    out.set("bw", bw);
+  }
+  fontParam(get, out, pajekDefault("node", "labelFont"));
+  labelPositionParams(get, out, approximate);
+  return out;
+}
+function vertexColorParams(get, out) {
   const colors = [
     ["fill", "ic"],
     ["borderColor", "bc"],
     ["labelColor", "lc"]
   ];
-  const numbers = [
-    ["width", "x_fact"],
-    ["height", "y_fact"],
-    ["labelSize", "fos"]
-  ];
   for (const [property, key] of colors) {
     const v = get(property);
-    if (typeof v === "string" && (property === "fill" || v !== "#000000")) {
+    if (typeof v === "string" && v !== pajekDefault("node", property)) {
       out.set(key, pajekColorText(v));
     }
   }
-  for (const [property, key] of numbers) {
+}
+function vertexSizeParams(get, out) {
+  const numbers = [
+    ["width", "x_fact", PAJEK_VERTEX_SIZE],
+    ["height", "y_fact", PAJEK_VERTEX_SIZE],
+    ["labelSize", "fos", 1]
+  ];
+  const figure = PAJEK_FIGURES.get(String(get("shape")));
+  for (const [property, key, per] of numbers) {
     const v = get(property);
-    if (typeof v === "number") {
-      out.set(key, v);
+    let over = 1;
+    if (figure !== void 0 && key !== "fos") {
+      over = figure[key === "x_fact" ? 0 : 1];
+    }
+    if (typeof v === "number" && (over !== 1 || v !== pajekDefault("node", property))) {
+      out.set(key, Number((v / (per * over)).toPrecision(15)));
     }
   }
-  const bw = get("borderWidth");
-  if (typeof bw === "number") {
-    const written = Number((bw * VERTEX_SIZE).toPrecision(15));
-    if (written === 1) {
-      out.delete("bw");
-    } else {
-      out.set("bw", written);
+}
+function fontParam(get, out, skip) {
+  const font = get("labelFont");
+  const name = typeof font === "string" && font !== "" ? graphvizFontName(font, false, false) : null;
+  if (name !== null && name !== skip) {
+    out.set("font", name);
+  }
+}
+function labelPositionParams(get, out, approximate) {
+  const position = get("labelPosition");
+  if (typeof position !== "string") {
+    return;
+  }
+  if (position === "center") {
+    const polar = polarOf(get);
+    if (polar === null) {
+      out.set("lr", 0);
+    } else if (polar[0] !== PAJEK_LABEL_RADIUS || polar[1] !== PAJEK_LABEL_ANGLE) {
+      out.set("lr", polar[0]);
+      out.set("lphi", polar[1]);
     }
+    return;
+  }
+  const nearest = NEAREST_SIDES.get(position);
+  if (nearest !== void 0) {
+    approximate("labelPosition", position);
+  }
+  const angle = SIDE_ANGLES.get(nearest ?? position);
+  if (angle !== void 0 && angle !== PAJEK_LABEL_ANGLE) {
+    out.set("lphi", angle);
   }
-  return out;
+}
+function polarOf(get) {
+  const [x, y, shift] = [get("labelOffsetX"), get("labelOffsetY"), get("labelShiftX")];
+  if (typeof x !== "number" || typeof y !== "number" || shift !== 0.5) {
+    return null;
+  }
+  const size = get("labelSize");
+  const up = y + PAJEK_BASELINE_TO_MIDDLE * (typeof size === "number" ? size : PAJEK_LABEL_SIZE);
+  const round = (v) => Number(v.toFixed(6)) + 0;
+  const lr = round(Math.hypot(x, up));
+  return lr === 0 ? null : [lr, round((Math.atan2(-up, x) * 180 / Math.PI % 360 + 360) % 360)];
+}
+function lineDefaults(directed) {
+  return directed ? ARC_DEFAULTS : { color: pajekDefault("edge", "color"), width: pajekDefault("edge", "width") };
 }
 function lineParams(get, directed, approximate) {
   const out = /* @__PURE__ */ new Map();
   opaque(get, ["opacity"], approximate);
+  const defaults = lineDefaults(directed);
   const color = get("color");
-  if (typeof color === "string" && color !== "#000000") {
+  if (typeof color === "string" && color !== defaults.color) {
     out.set("c", pajekColorText(color));
   }
   const width = get("width");
-  if (typeof width === "number") {
-    out.set("w", width);
+  if (typeof width === "number" && width !== defaults.width) {
+    out.set("w", directed ? width : Number((width / EDGE_WIDTH_PER_W).toPrecision(15)));
   }
   const lineStyle = get("lineStyle");
-  if (typeof lineStyle === "string" && lineStyle !== "solid" && pajekDots(lineStyle, approximate)) {
+  if (typeof lineStyle === "string" && lineStyle !== "solid" && pajekDots(lineStyle, out, directed, approximate)) {
     out.set("p", "Dots");
   }
+  const position = get("arrowPosition");
+  if (typeof position === "number" && position > 0) {
+    out.set("ap", position);
+  }
+  lineLabelParams(get, out, approximate);
   const target = get("targetArrow");
   if (target !== null && target !== (directed ? "triangle" : "none")) {
     approximate("targetArrow", target);
@@ -594,47 +1512,50 @@ function lineParams(get, directed, approximate) {
   }
   return out;
 }
-function pajekDots(lineStyle, approximate) {
-  if (lineStyle === "dotted") {
-    return true;
+function lineLabelParams(get, out, approximate) {
+  const label = get("label");
+  if (typeof label === "string" && label !== "") {
+    const text = pajekLabelText(label);
+    if (text !== label) {
+      approximate("label", label);
+    }
+    out.set("l", text);
   }
-  approximate("lineStyle", lineStyle);
-  return lineStyle === "dashed" || lineStyle === "dash-dot" || lineStyle === "long-dash";
-}
-function getter(picture, target) {
-  const columns = /* @__PURE__ */ new Map();
-  for (const p of PAJEK_STYLE_CAPABILITIES[target]) {
-    columns.set(p, picture(target, p));
+  const labelColor = get("labelColor");
+  if (typeof labelColor === "string") {
+    out.set("lc", pajekColorText(labelColor));
+  }
+  const labelSize = get("labelSize");
+  if (typeof labelSize === "number") {
+    out.set("fos", labelSize);
   }
-  return (i) => (property) => columns.get(property)?.[i] ?? null;
+  fontParam(get, out);
 }
-function exactFromBlock(snapshot, text, read) {
-  const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
-  const ex = parsed.ok ? blockStyles(parsed.block, snapshot, "pajek") : null;
-  if (ex === null) {
-    return;
+function pajekDots(lineStyle, params, directed, approximate) {
+  if (lineStyle === pajekDash((key) => params.get(key) ?? null, directed)) {
+    return true;
   }
+  approximate("lineStyle", lineStyle);
+  return ["dashed", "dotted", "dash-dot", "long-dash"].includes(lineStyle);
+}
+function exactFromBlock(snapshot, text, read, labels) {
   const notes = new StyleNotes();
   const directed = directedEdges(snapshot);
-  for (const target of ["node", "edge"]) {
-    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
-    const get = getter((t, p) => resolveStyles(ex, t, p, snapshot), target);
-    const values = read[target];
-    for (let i = 0; i < n; i++) {
-      const want = get(i);
-      const back = writtenAndReadBack(target, want, directed[i], notes);
-      for (const property of READ[target]) {
-        const native = values[property]?.[i] ?? null;
-        const w = want(property);
-        if (w !== null && native !== w && native === (back.get(property) ?? null)) {
-          values[property] ??= new Array(n).fill(null);
-          values[property][i] = w;
-        }
-      }
-    }
-  }
+  takeFromBlock(snapshot, text, "pajek", (target) => ({
+    values: read[target],
+    properties: READ[target],
+    writes: PAJEK_STYLE_CAPABILITIES[target],
+    readBack: (i, want) => {
+      const back = writtenAndReadBack(target, want, directed[i], notes, labels);
+      return (property) => back.get(property) ?? null;
+    },
+    // a label the block places by a side clears the offsets its `lphi` reads back as
+    take: (property, wanted) => wanted !== null || LABEL_PLACE.has(property) || OUTLINE.has(property)
+  }));
 }
-function writtenAndReadBack(target, want, directed, notes) {
+const OUTLINE = /* @__PURE__ */ new Set(["shapePoints", "shapePointsStretch"]);
+const LABEL_PLACE = /* @__PURE__ */ new Set(["labelOffsetX", "labelOffsetY", "labelShiftX"]);
+function writtenAndReadBack(target, want, directed, notes, labels) {
   const ignore = () => void 0;
   const params = target === "node" ? vertexParams(want, ignore) : lineParams(want, directed, ignore);
   const back = /* @__PURE__ */ new Map();
@@ -642,15 +1563,26 @@ function writtenAndReadBack(target, want, directed, notes) {
   if (typeof label === "string") {
     params.set(LABEL_COLUMN, pajekLabelText(label));
   }
-  (target === "node" ? readVertex : readLine)(
-    (key) => params.get(key) ?? null,
-    (property, value) => {
-      if (value !== null) {
-        back.set(property, value);
-      }
-    },
-    (property) => ({ notes, target, property })
-  );
+  if (target === "node" && [...params.keys()].every((key) => key === LABEL_COLUMN)) {
+    params.set(SHAPE_COLUMN, "ellipse");
+  }
+  for (const key of target === "edge" ? CARRIED.edge : []) {
+    if (!params.has(key)) {
+      params.set(key, lineRestated(key, directed));
+    }
+  }
+  const get = (key) => params.get(key) ?? null;
+  const put = (property, value) => {
+    if (value !== null) {
+      back.set(property, value);
+    }
+  };
+  const at = (property) => ({ notes, target, property });
+  if (target === "node") {
+    readVertex(get, put, at);
+  } else {
+    readLine(get, put, at, directed, labels);
+  }
   return back;
 }
 function pajekStyledExport(snapshot, input) {
@@ -665,14 +1597,15 @@ function pajekStyledExport(snapshot, input) {
     const approximate = (property, value) => {
       approximated.add(target, property, value);
     };
-    const get = getter((t, p) => input.picture(t, p), target);
+    const get = elementValues((t, p) => input.picture(t, p), target, PAJEK_STYLE_CAPABILITIES[target]);
     const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
     const params = (i) => target === "node" ? vertexParams(get(i), approximate) : lineParams(get(i), directed[i], approximate);
-    replaceParamColumns(
-      table,
-      target === "node" ? [SHAPE_COLUMN, ...NODE_KEYS] : EDGE_KEYS,
-      paramColumns(n, params)
-    );
+    const columns = paramColumns(n, params);
+    if (target === "edge") {
+      keepLineLabels(snapshot, columns);
+    }
+    restateCarried(target, columns, directed);
+    replaceParamColumns(table, target === "node" ? [SHAPE_COLUMN, ...NODE_KEYS] : EDGE_KEYS, columns);
   }
   out.nodes.set(
     LABEL_COLUMN,
@@ -687,6 +1620,23 @@ function pajekStyledExport(snapshot, input) {
   notes.push(...styleBlockLosses(block, input.rules.styles.rules.length, "size"));
   return { snapshot: out, comment: PAJEK_STYLE_COMMENT + block, notes };
 }
+function keepLineLabels(snapshot, columns) {
+  if (!snapshot.edges.has("l")) {
+    return;
+  }
+  const own = (e) => plainCell(snapshot.edges.value("l", e));
+  let col = columns.get("l");
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    const v = own(e);
+    if (typeof v === "string" && v !== "" && (col?.[e] ?? null) === null) {
+      col ??= new Array(snapshot.edgeCount).fill(null);
+      col[e] = pajekLabelText(v);
+    }
+  }
+  if (col !== void 0) {
+    columns.set("l", col);
+  }
+}
 function drawnLabels(input, n, approximated) {
   const drawn = input.picture("node", "label");
   const out = new Array(n).fill("");
@@ -715,6 +1665,45 @@ function replaceParamColumns(table, keys, columns) {
     table.set(key, col, { dtype: numeric ? "f64" : "string" });
   }
 }
+function restateCarried(target, columns, directed) {
+  if (target === "node") {
+    const all = [...columns.values()];
+    if (all.length === 0) {
+      return;
+    }
+    const n = all[0].length;
+    const shape = columns.get(SHAPE_COLUMN) ?? new Array(n).fill(null);
+    for (let i = 0; i < n; i++) {
+      if (all.every((col) => col[i] === null)) {
+        shape[i] = "ellipse";
+      }
+    }
+    columns.set(SHAPE_COLUMN, shape);
+    return;
+  }
+  for (const key of CARRIED.edge) {
+    const col = columns.get(key);
+    if (col === void 0) {
+      continue;
+    }
+    for (let i = 0; i < col.length; i++) {
+      col[i] ??= lineRestated(key, directed[i]);
+    }
+  }
+}
+function lineRestated(key, directed) {
+  const defaults = lineDefaults(directed);
+  switch (key) {
+    case "c":
+      return pajekColorText(String(defaults.color));
+    case "w":
+      return directed ? Number(defaults.width) : Number(defaults.width) / EDGE_WIDTH_PER_W;
+    case "p":
+      return "Solid";
+    default:
+      return 0;
+  }
+}
 function paramColumns(n, params) {
   const columns = /* @__PURE__ */ new Map();
   for (let i = 0; i < n; i++) {
@@ -815,58 +1804,58 @@ const CAPABILITIES = capabilities({
 });
 function plan(table, domain, notes) {
   const planned = [];
-  for (const column of table) {
-    const slot = columnSlot(column, domain, notes);
+  for (const column2 of table) {
+    const slot = columnSlot(column2, domain, notes);
     if (slot !== null) {
-      planned.push({ column, slot });
+      planned.push({ column: column2, slot });
     }
   }
   return planned;
 }
-function columnNote(notes, code, message, column) {
-  notes?.push(note(code, message, column.meta.name, column.length - column.nullCount));
+function columnNote(notes, code, message, column2) {
+  notes?.push(note(code, message, column2.meta.name, column2.length - column2.nullCount));
 }
-function columnSlot(column, domain, notes) {
-  const { role, name } = column.meta;
+function columnSlot(column2, domain, notes) {
+  const { role, name } = column2.meta;
   if (role === "label" && domain === "node") {
-    return labelSlot(column, notes);
+    return labelSlot(column2, notes);
   }
   if (role === "position") {
-    return positionSlot(column, domain, notes);
+    return positionSlot(column2, domain, notes);
   }
   if (role === "spells") {
-    return spellsSlot(column, domain, notes);
+    return spellsSlot(column2, domain, notes);
   }
   if (role !== null && DROPPED_TEMPORAL_ROLES.has(role)) {
     columnNote(
       notes,
       PAJEK_LOSS.TEMPORAL_DROPPED,
       `${domain} column "${name}" (${role}) cannot be written; Pajek intervals come from the spells role`,
-      column
+      column2
     );
     return null;
   }
-  if (writtenElsewhere(column, domain)) {
+  if (writtenElsewhere(column2, domain)) {
     return null;
   }
-  return namedSlot(column, domain, notes);
+  return namedSlot(column2, domain, notes);
 }
-function labelSlot(column, notes) {
-  const { name, dtype } = column.meta;
+function labelSlot(column2, notes) {
+  const { name, dtype } = column2.meta;
   if (dtype !== "string" && dtype !== "dict") {
     columnNote(
       notes,
       PAJEK_LOSS.LABEL_AS_TEXT,
       `node column "${name}" (label) is ${dtype}; labels are text and re-import as string`,
-      column
+      column2
     );
   }
   return "label";
 }
-function positionSlot(column, domain, notes) {
-  const { name, components } = column.meta;
+function positionSlot(column2, domain, notes) {
+  const { name, components } = column2.meta;
   if (domain === "edge") {
-    columnNote(notes, LOSS.POSITIONS, `edge column "${name}" (position) cannot be written`, column);
+    columnNote(notes, LOSS.POSITIONS, `edge column "${name}" (position) cannot be written`, column2);
     return null;
   }
   if (components === 2 || components === 3) {
@@ -876,12 +1865,12 @@ function positionSlot(column, domain, notes) {
     notes,
     PAJEK_LOSS.POSITION_STRIDE,
     `node column "${name}" (position) has ${components} components; Pajek coordinates are x y [z]`,
-    column
+    column2
   );
   return null;
 }
-function spellsSlot(column, domain, notes) {
-  const { name, dtype, itemDtype } = column.meta;
+function spellsSlot(column2, domain, notes) {
+  const { name, dtype, itemDtype } = column2.meta;
   if (dtype === "list" && (itemDtype === "f64" || itemDtype === "i32" || itemDtype === "f32")) {
     return "spells";
   }
@@ -889,22 +1878,22 @@ function spellsSlot(column, domain, notes) {
     notes,
     LOSS.SPELLS,
     `${domain} column "${name}" (spells) is not a list of number pairs; it cannot be written`,
-    column
+    column2
   );
   return null;
 }
-function writtenElsewhere(column, domain) {
-  const { role, dtype } = column.meta;
+function writtenElsewhere(column2, domain) {
+  const { role, dtype } = column2.meta;
   if (role !== null && (STRUCTURAL_ROLES.has(role) || CHECKED_ROLES.has(role))) {
     return true;
   }
   return domain === "edge" && role === "id" || dtype === "list" || dtype === "json";
 }
-function namedSlot(column, domain, notes) {
-  const { name, dtype } = column.meta;
+function namedSlot(column2, domain, notes) {
+  const { name, dtype } = column2.meta;
   const text = dtype === "dict" || dtype === "string";
   if (text && domain === "node" && name === SHAPE_COLUMN) {
-    return shapeSlot(column, notes);
+    return shapeSlot(column2, notes);
   }
   if (text && domain === "edge" && name === RELATION_COLUMN) {
     return "relation";
@@ -914,22 +1903,22 @@ function namedSlot(column, domain, notes) {
       notes,
       PAJEK_LOSS.KEY_DROPPED,
       `${domain} column "${name}" cannot be a Pajek parameter key; it is not written`,
-      column
+      column2
     );
     return null;
   }
   return "param";
 }
-function shapeSlot(column, notes) {
-  if (allShapeKeywords(column)) {
+function shapeSlot(column2, notes) {
+  if (allShapeKeywords(column2)) {
     return "shape";
   }
-  if (column.meta.dtype === "dict") {
+  if (column2.meta.dtype === "dict") {
     columnNote(
       notes,
       PAJEK_LOSS.SHAPE_AS_PARAMETER,
-      `node column "${column.meta.name}" holds values outside the Pajek shape keywords; it is written as a parameter and reads back as string`,
-      column
+      `node column "${column2.meta.name}" holds values outside the Pajek shape keywords; it is written as a parameter and reads back as string`,
+      column2
     );
   }
   return "param";
@@ -937,9 +1926,9 @@ function shapeSlot(column, notes) {
 function labelNotes(snapshot, nodePlan, notes) {
   let labels = null;
   let carried = 0;
-  for (const { column, slot } of nodePlan) {
+  for (const { column: column2, slot } of nodePlan) {
     if (slot === "label") {
-      labels = column;
+      labels = column2;
     } else if (slot !== "skip" && slot !== "relation") {
       carried++;
     }
@@ -986,16 +1975,16 @@ function unlabeled(nodeCount, labels) {
   }
   return count;
 }
-function allShapeKeywords(column) {
-  for (let r = 0; r < column.length; r++) {
-    if (column.isSet(r) && !SHAPES$1.has(column.value(r))) {
+function allShapeKeywords(column2) {
+  for (let r = 0; r < column2.length; r++) {
+    if (column2.isSet(r) && !SHAPES$1.has(column2.value(r))) {
       return false;
     }
   }
   return true;
 }
-function note(code, message, column = null, count = null) {
-  return Object.freeze({ code, message, column, count });
+function note(code, message, column2 = null, count = null) {
+  return Object.freeze({ code, message, column: column2, count });
 }
 function numberText(value, dtype) {
   switch (dtype) {
@@ -1013,53 +2002,53 @@ function numberText(value, dtype) {
     }
   }
 }
-function cellText(column, row) {
-  switch (column.dtype) {
+function cellText(column2, row) {
+  switch (column2.dtype) {
     case "f32":
     case "f64":
     case "i32":
     case "u32":
     case "u8": {
-      const value = column.value(row);
+      const value = column2.value(row);
       if (typeof value === "number") {
-        return numberText(value, column.dtype);
+        return numberText(value, column2.dtype);
       }
       const parts = [];
       const vector = value;
       for (let k = 0; k < vector.length; k++) {
-        parts.push(numberText(vector[k], column.dtype));
+        parts.push(numberText(vector[k], column2.dtype));
       }
       return parts.join(" ");
     }
     case "bool":
-      return column.value(row) === true ? "true" : "false";
+      return column2.value(row) === true ? "true" : "false";
     case "dict":
     case "string":
-      return column.value(row);
+      return column2.value(row);
     case "list":
     case "json":
-      return JSON.stringify(column.value(row));
+      return JSON.stringify(column2.value(row));
     default: {
-      const name = column.dtype;
+      const name = column2.dtype;
       throw new Error(`unknown dtype ${name}`);
     }
   }
 }
 function checkCells(planned, domain, notes) {
-  for (const { column, slot } of planned) {
+  for (const { column: column2, slot } of planned) {
     if (slot === "position" || slot === "spells") {
       continue;
     }
-    const { name } = column.meta;
+    const { name } = column2.meta;
     let badText = 0;
     let nonFinite = 0;
     let typed = 0;
-    for (let r = 0; r < column.length; r++) {
-      if (!column.isSet(r)) {
+    for (let r = 0; r < column2.length; r++) {
+      if (!column2.isSet(r)) {
         continue;
       }
-      if (column.dtype === "f64" || column.dtype === "f32") {
-        const value = column.value(r);
+      if (column2.dtype === "f64" || column2.dtype === "f32") {
+        const value = column2.value(r);
         if (typeof value === "number") {
           if (!Number.isFinite(value)) {
             nonFinite++;
@@ -1067,8 +2056,8 @@ function checkCells(planned, domain, notes) {
         } else if (value !== void 0 && !Array.from(value).every((v) => Number.isFinite(v))) {
           nonFinite++;
         }
-      } else if (column.dtype === "string" || column.dtype === "dict") {
-        const text = column.value(r);
+      } else if (column2.dtype === "string" || column2.dtype === "dict") {
+        const text = column2.value(r);
         if (!isPajekLabel(text)) {
           badText++;
         } else if (slot === "param" && inferTextDtype(text) !== "string") {
@@ -1131,11 +2120,11 @@ function labelOf(labels, ids, i, needed) {
   }
   return null;
 }
-function spellsText(column, row) {
-  if (column.dtype !== "list" || !column.isSet(row)) {
+function spellsText(column2, row) {
+  if (column2.dtype !== "list" || !column2.isSet(row)) {
     return null;
   }
-  const items = column.sliceOf(row);
+  const items = column2.sliceOf(row);
   if (items.length === 0) {
     return null;
   }
@@ -1146,29 +2135,29 @@ function spellsText(column, row) {
   }
   return formatIntervals(pairs);
 }
-function coordinatesText(column, i, writeZ) {
-  if (!column.isSet(i)) {
+function coordinatesText(column2, i, writeZ) {
+  if (!column2.isSet(i)) {
     return null;
   }
-  const dtype = column.dtype;
-  const vector = column.value(i);
+  const dtype = column2.dtype;
+  const vector = column2.value(i);
   const x = formatNumber(vector[0], dtype);
   const y = formatNumber(vector[1], dtype);
-  if (column.meta.components === 3 && writeZ) {
+  if (column2.meta.components === 3 && writeZ) {
     return `${x} ${y} ${formatNumber(vector[2], dtype)}`;
   }
   return `${x} ${y}`;
 }
-function needsZ(column) {
-  if (column.meta.components !== 3) {
+function needsZ(column2) {
+  if (column2.meta.components !== 3) {
     return false;
   }
-  if (column.meta.extra.sourceDims !== 2) {
+  if (column2.meta.extra.sourceDims !== 2) {
     return true;
   }
-  for (let i = 0; i < column.length; i++) {
-    if (column.isSet(i)) {
-      const vector = column.value(i);
+  for (let i = 0; i < column2.length; i++) {
+    if (column2.isSet(i)) {
+      const vector = column2.value(i);
       if (vector[2] !== 0) {
         return true;
       }
@@ -1251,27 +2240,49 @@ function checkIdTexts(nodeCount, ids, mangle, notes) {
   }
 }
 function* writeVertices(snapshot, ids, nodePlan, mangle) {
-  let labels = null;
-  let position = null;
-  let shape = null;
-  let nodeSpells = null;
-  const nodeParams = [];
-  for (const { column, slot } of nodePlan) {
+  const slots = vertexSlots(nodePlan);
+  const writeZ = slots.position !== null && needsZ(slots.position);
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const parts = vertexParts(slots, i, writeZ);
+    if (mangle && ids.isChanged(i)) {
+      parts.push(`${ORIGINAL_ID_KEY} ${quotePajekLabel(idText(ids.originalAt(i)))}`);
+    }
+    if (slots.spells !== null) {
+      const spells = spellsText(slots.spells, i);
+      if (spells !== null) {
+        parts.push(spells);
+      }
+    }
+    const label = labelOf(slots.labels, ids, i, parts.length > 0);
+    let line = String(i + 1);
+    if (label !== null) {
+      line += ` ${quotePajekLabel(encodeCharacterReferences(label))}`;
+    }
+    if (parts.length > 0) {
+      line += ` ${parts.join(" ")}`;
+    }
+    yield `${line}
+`;
+  }
+}
+function vertexSlots(nodePlan) {
+  const slots = { labels: null, position: null, shape: null, spells: null, params: [] };
+  for (const { column: column2, slot } of nodePlan) {
     switch (slot) {
       case "label":
-        labels = column;
+        slots.labels = column2;
         break;
       case "position":
-        position = column;
+        slots.position = column2;
         break;
       case "shape":
-        shape = column;
+        slots.shape = column2;
         break;
       case "spells":
-        nodeSpells = column;
+        slots.spells = column2;
         break;
       case "param":
-        nodeParams.push(column);
+        slots.params.push(column2);
         break;
       case "relation":
       case "skip":
@@ -1282,48 +2293,32 @@ function* writeVertices(snapshot, ids, nodePlan, mangle) {
       }
     }
   }
-  const writeZ = position !== null && needsZ(position);
-  for (let i = 0; i < snapshot.nodeCount; i++) {
-    const parts = [];
-    if (position !== null) {
-      const coordinates = coordinatesText(position, i, writeZ);
-      if (coordinates !== null) {
-        parts.push(coordinates);
-      }
-    }
-    if (shape?.isSet(i)) {
-      const keyword = cellText(shape, i);
-      if (SHAPES$1.has(keyword)) {
-        parts.push(keyword);
-      } else {
-        parts.push(`${SHAPE_COLUMN} ${quotePajekLabel(keyword)}`);
-      }
-    }
-    for (const column of nodeParams) {
-      if (column.isSet(i)) {
-        parts.push(`${column.meta.name} ${quotePajekLabel(cellText(column, i))}`);
-      }
-    }
-    if (mangle && ids.isChanged(i)) {
-      parts.push(`${ORIGINAL_ID_KEY} ${quotePajekLabel(idText(ids.originalAt(i)))}`);
-    }
-    if (nodeSpells !== null) {
-      const spells = spellsText(nodeSpells, i);
-      if (spells !== null) {
-        parts.push(spells);
-      }
-    }
-    const label = labelOf(labels, ids, i, parts.length > 0);
-    let line = String(i + 1);
-    if (label !== null) {
-      line += ` ${quotePajekLabel(encodeCharacterReferences(label))}`;
+  return slots;
+}
+function vertexParts(slots, i, writeZ) {
+  const { position, shape } = slots;
+  const parts = [];
+  const coordinates = position === null ? null : coordinatesText(position, i, writeZ);
+  if (coordinates !== null) {
+    parts.push(coordinates);
+  }
+  const placed = parts.length > 0;
+  const shaped = shape?.isSet(i) === true;
+  if (shaped) {
+    const keyword = cellText(shape, i);
+    parts.push(SHAPES$1.has(keyword) ? keyword : `${SHAPE_COLUMN} ${quotePajekLabel(keyword)}`);
+  }
+  const named = parts.length;
+  for (const column2 of slots.params) {
+    if (!column2.isSet(i)) {
+      continue;
     }
-    if (parts.length > 0) {
-      line += ` ${parts.join(" ")}`;
+    if (placed && !shaped && parts.length === named && VOIDING_KEYS.has(column2.meta.name)) {
+      parts.push("ellipse");
     }
-    yield `${line}
-`;
+    parts.push(`${column2.meta.name} ${quotePajekLabel(cellText(column2, i))}`);
   }
+  return parts;
 }
 function* writeLines(snapshot, edgePlan) {
   const folding = pairFolding(snapshot, { foldMutual: true });
@@ -1332,16 +2327,16 @@ function* writeLines(snapshot, edgePlan) {
   let relation = null;
   let edgeSpells = null;
   const edgeParams = [];
-  for (const { column, slot } of edgePlan) {
+  for (const { column: column2, slot } of edgePlan) {
     switch (slot) {
       case "relation":
-        relation = column;
+        relation = column2;
         break;
       case "spells":
-        edgeSpells = column;
+        edgeSpells = column2;
         break;
       case "param":
-        edgeParams.push(column);
+        edgeParams.push(column2);
         break;
       case "label":
       case "position":
@@ -1388,9 +2383,9 @@ function* writeLines(snapshot, edgePlan) {
     if (weight !== null) {
       line += ` ${weight}`;
     }
-    for (const column of edgeParams) {
-      if (column.isSet(e)) {
-        line += ` ${column.meta.name} ${quotePajekLabel(cellText(column, e))}`;
+    for (const column2 of edgeParams) {
+      if (column2.isSet(e)) {
+        line += ` ${column2.meta.name} ${quotePajekLabel(cellText(column2, e))}`;
       }
     }
     if (edgeSpells !== null) {
@@ -1478,16 +2473,16 @@ function withOriginalIds(options) {
 }
 function ownedColumns(snapshot, planned) {
   const owned = /* @__PURE__ */ new Set();
-  const key = (column) => `${column.meta.domain}:${column.meta.name}`;
-  for (const { column, slot } of planned) {
-    const shapeParam = slot === "param" && column.meta.domain === "node" && column.meta.name === SHAPE_COLUMN;
+  const key = (column2) => `${column2.meta.domain}:${column2.meta.name}`;
+  for (const { column: column2, slot } of planned) {
+    const shapeParam = slot === "param" && column2.meta.domain === "node" && column2.meta.name === SHAPE_COLUMN;
     if (slot === "shape" || slot === "relation" || shapeParam) {
-      owned.add(key(column));
+      owned.add(key(column2));
     }
   }
-  for (const column of [...snapshot.nodes, ...snapshot.edges]) {
-    if (column.meta.role === "spells") {
-      owned.add(key(column));
+  for (const column2 of [...snapshot.nodes, ...snapshot.edges]) {
+    if (column2.meta.role === "spells") {
+      owned.add(key(column2));
     }
   }
   return owned;
@@ -1530,13 +2525,13 @@ function checkPlain(snapshot, options) {
   const owned = ownedColumns(snapshot, [...nodePlan, ...edgePlan]);
   notes.push(...capabilityNotes(snapshot, resolved, owned));
   labelNotes(snapshot, nodePlan, notes);
-  for (const column of [...snapshot.edges].filter((c) => c.meta.role === "label")) {
+  for (const column2 of [...snapshot.edges].filter((c) => c.meta.role === "label")) {
     notes.push(
       note(
         LOSS.ROLE,
-        `edge column "${column.meta.name}" (label) is written as a plain parameter; Pajek labels vertices only and the role is lost`,
-        column.meta.name,
-        column.length - column.nullCount
+        `edge column "${column2.meta.name}" (label) is written as a plain parameter; Pajek labels vertices only and the role is lost`,
+        column2.meta.name,
+        column2.length - column2.nullCount
       )
     );
   }
@@ -1731,7 +2726,7 @@ function spellsDecl() {
     origin: { format: "pajek", id: "interval" }
   };
 }
-function positionDecl(sourceDims) {
+function positionDecl(sourceDims, window) {
   return {
     name: POSITION_COLUMN,
     dtype: "f64",
@@ -1740,10 +2735,21 @@ function positionDecl(sourceDims) {
     role: "position",
     origin: { format: "pajek", id: "coordinates" },
     // Pajek draws y downward (USAir97.net has Deadhorse, Alaska at y 0.10 and Miami at 0.53),
-    // centers depth on 0.5, and NetworkX writes "0.0 0.0" for a node with no position
-    extra: { sourceDims, units: "file", yAxis: "down", zOrigin: 0.5, zeroUnplaced: true }
+    // centers depth on 0.5, and NetworkX writes "0.0 0.0" for a node with no position; one unit
+    // is the Draw window's width in points across and its height down (500 each by default,
+    // PAJEK_POINTS_PER_UNIT): Pajek stretches 0..1 to the window one axis at a time
+    extra: {
+      sourceDims,
+      units: "file",
+      pxPerUnit: window.width,
+      ...window.height === window.width ? {} : { pxPerUnitY: window.height },
+      yAxis: "down",
+      zOrigin: 0.5,
+      zeroUnplaced: true
+    }
   };
 }
+const DEFAULT_WINDOW = { width: PAJEK_POINTS_PER_UNIT, height: PAJEK_POINTS_PER_UNIT };
 class LineError extends Error {
   /**
    * Create a line error.
@@ -1770,8 +2776,11 @@ class PajekParser {
    * @param report - the report
    * @param options - the resolved common options
    * @param firstVertex - the firstVertex format option
+   * @param window - the Draw window the coordinates are stretched to
    */
-  constructor(sink, report, options, firstVertex) {
+  constructor(sink, report, options, firstVertex, window = DEFAULT_WINDOW) {
+    this.keptBlock = null;
+    this.voided = [];
     this.section = "none";
     this.kind = "directed";
     this.relation = null;
@@ -1808,6 +2817,7 @@ class PajekParser {
     this.ended = false;
     this.edgeParams = /* @__PURE__ */ new Map();
     this.styleBlockKept = false;
+    this.window = window;
     this.sink = sink;
     this.report = report;
     this.options = options;
@@ -1827,7 +2837,8 @@ class PajekParser {
     const trimmed = text.trimStart();
     if (trimmed.startsWith(PAJEK_STYLE_COMMENT)) {
       this.styleBlockKept = true;
-      this.report.keepForStyles(trimmed.slice(PAJEK_STYLE_COMMENT.length));
+      this.keptBlock = trimmed.slice(PAJEK_STYLE_COMMENT.length);
+      this.report.keepForStyles(this.keptBlock);
     }
   }
   /**
@@ -2290,6 +3301,55 @@ class PajekParser {
    */
   vertexLine(text, line) {
     const tokens = this.tokens(text, "node", line);
+    const { k, pos } = this.vertexNumber(tokens, line);
+    let i = 1;
+    let label = null;
+    if (tokens.length > 1 && !startsWithCoordinates(text, tokens)) {
+      label = this.labelOf(tokens[1], k, line);
+      i = 2;
+    }
+    const { xyz, dims, next } = this.vertexCoordinates(tokens, i, k);
+    i = next;
+    this.checkCoordinates(text, tokens, i, dims === 2 && label !== null, k, line);
+    let shape = null;
+    if (i < tokens.length && isShapeKeyword(tokens[i])) {
+      shape = tokens[i].toLowerCase();
+      i++;
+    }
+    const extras = this.extras(tokens, i, "node", line);
+    shape = extras.shape ?? shape;
+    const restored = this.restoredId(extras);
+    this.createNodes();
+    const repeated = this.markVertexSeen(pos, k, line);
+    const index = this.vertexIndex(pos, k, label, restored, repeated, line);
+    if (shape === null && dims > 0 && extras.keys.length > 0 && VOIDING_KEYS.has(extras.keys[0])) {
+      this.voided.push(index);
+    }
+    if (label !== null) {
+      this.labelHandle = this.nodeHandle(this.labelHandle, LABEL_DECL, line);
+      this.sink.setNodeValue(this.labelHandle, index, label);
+    }
+    if (dims > 0) {
+      this.writePosition(index, dims, xyz, k, line);
+    }
+    if (shape !== null) {
+      this.writeShape(index, shape, line);
+    }
+    for (let p = 0; p < extras.keys.length; p++) {
+      this.writeParameter("node", extras.keys[p], index, extras.values[p]);
+    }
+    if (extras.spells !== null) {
+      this.nodeSpellsHandle = this.nodeHandle(this.nodeSpellsHandle, spellsDecl(), line);
+      this.sink.setNodeValue(this.nodeSpellsHandle, index, extras.spells);
+    }
+  }
+  /**
+   * A vertex line's number, checked: it starts the line and is in the declared range.
+   * @param tokens - the line's tokens
+   * @param line - the line number
+   * @returns the vertex number and its position
+   */
+  vertexNumber(tokens, line) {
     if (!isVertexNumber(tokens[0])) {
       this.report.counts.skippedNodes++;
       throw new LineError(
@@ -2312,27 +3372,25 @@ class PajekParser {
         `vertex ${k} is outside ${this.base}..${this.base + this.vertexCount - 1}`
       );
     }
-    let i = 1;
-    let label = null;
-    if (tokens.length > 1 && !startsWithCoordinates(text, tokens)) {
-      label = this.labelOf(tokens[1], k, line);
-      i = 2;
-    }
-    let x = 0;
-    let y = 0;
-    let z = 0;
-    let dims = 0;
+    return { k, pos };
+  }
+  /**
+   * A vertex line's coordinates: two or three numbers, or none; a single one is an error.
+   * @param tokens - the line's tokens
+   * @param i - where the coordinates would start
+   * @param k - the vertex number
+   * @returns x, y and z (0 when absent), how many were read, and the index after them
+   */
+  vertexCoordinates(tokens, i, k) {
     if (i + 1 < tokens.length && isNumericText(tokens[i]) && isNumericText(tokens[i + 1])) {
-      x = Number(tokens[i]);
-      y = Number(tokens[i + 1]);
-      i += 2;
-      dims = 2;
-      if (i < tokens.length && isNumericText(tokens[i])) {
-        z = Number(tokens[i]);
-        i++;
-        dims = 3;
+      const x = Number(tokens[i]);
+      const y = Number(tokens[i + 1]);
+      if (i + 2 < tokens.length && isNumericText(tokens[i + 2])) {
+        return { xyz: [x, y, Number(tokens[i + 2])], dims: 3, next: i + 3 };
       }
-    } else if (i < tokens.length && isNumericText(tokens[i])) {
+      return { xyz: [x, y, 0], dims: 2, next: i + 2 };
+    }
+    if (i < tokens.length && isNumericText(tokens[i])) {
       this.report.counts.skippedNodes++;
       throw new LineError(
         "parse-error",
@@ -2340,81 +3398,88 @@ class PajekParser {
         `vertex ${k}: a single coordinate "${tokens[i]}"; coordinates are x y [z]`
       );
     }
-    this.checkCoordinates(text, tokens, i, dims === 2 && label !== null, k, line);
-    let shape = null;
-    if (i < tokens.length && isShapeKeyword(tokens[i])) {
-      shape = tokens[i].toLowerCase();
-      i++;
-    }
-    const extras = this.extras(tokens, i, "node", line);
-    shape = extras.shape ?? shape;
-    const restored = this.restoredId(extras);
-    this.createNodes();
-    const repeated = this.seen[pos] !== 0;
-    if (repeated) {
+    return { xyz: [0, 0, 0], dims: 0, next: i };
+  }
+  /**
+   * Marks a vertex's position as having a line, warning when it already had one.
+   * @param pos - the vertex's position
+   * @param k - the vertex number
+   * @param line - the line number
+   * @returns whether the vertex already had a line
+   */
+  markVertexSeen(pos, k, line) {
+    if (this.seen[pos] !== 0) {
       this.report.warning(
         "merged",
         PAJEK_ISSUE.DUPLICATE_NODE,
         `vertex ${k} has more than one line; the later values overwrite`,
         { line, element: String(k) }
       );
-    } else {
-      this.seen[pos] = 1;
-      this.seenCount++;
+      return true;
     }
-    let index;
-    if (this.idOfPos !== null && !repeated && this.options.nodeIdFrom === "label") {
-      index = this.deferredNode(this.idOfPos, pos, k, label, line, "label");
-    } else if (this.idOfPos !== null && this.idOfPos[pos] === void 0) {
+    this.seen[pos] = 1;
+    this.seenCount++;
+    return false;
+  }
+  /**
+   * The node index a vertex line writes to, creating the node when its id is deferred to its line.
+   * @param pos - the vertex's position
+   * @param k - the vertex number
+   * @param label - the line's label, or null
+   * @param restored - the original id the line carries, or null
+   * @param repeated - whether the vertex already had a line
+   * @param line - the line number
+   * @returns the node index
+   */
+  vertexIndex(pos, k, label, restored, repeated, line) {
+    const { idOfPos } = this;
+    if (idOfPos !== null && !repeated && this.options.nodeIdFrom === "label") {
+      return this.deferredNode(idOfPos, pos, k, label, line, "label");
+    }
+    if (idOfPos !== null && idOfPos[pos] === void 0) {
       for (let p = this.filledBelow; p < pos; p++) {
-        if (this.idOfPos[p] === void 0) {
-          this.numberedNode(this.idOfPos, p);
+        if (idOfPos[p] === void 0) {
+          this.numberedNode(idOfPos, p);
         }
       }
       if (pos > this.filledBelow) {
         this.filledBelow = pos;
       }
-      index = this.deferredNode(this.idOfPos, pos, k, restored, line, "originalId");
-    } else {
-      index = this.indexOfPos[pos];
-      if (restored !== null && !repeated) {
-        this.report.warning(
-          "coercion",
-          PAJEK_ISSUE.ORIGINAL_ID_UNRESTORED,
-          `vertex ${k} carries ${ORIGINAL_ID_KEY} ${JSON.stringify(restored)} but a later vertex's line came first and created it under its number; the original id is not restored`,
-          { line, element: String(k) }
-        );
-      }
-    }
-    const { sink } = this;
-    if (label !== null) {
-      if (this.labelHandle === INVALID_INDEX) {
-        this.labelHandle = declareResolved(sink, "node", LABEL_DECL, this.report, { line }).handle;
-      }
-      sink.setNodeValue(this.labelHandle, index, label);
+      return this.deferredNode(idOfPos, pos, k, restored, line, "originalId");
     }
-    if (dims > 0) {
-      this.writePosition(index, dims, [x, y, z], k, line);
-    }
-    if (shape !== null) {
-      if (this.shapeHandle === INVALID_INDEX && this.nodeParams.has(SHAPE_COLUMN)) {
-        this.writeParameter("node", SHAPE_COLUMN, index, shape);
-      } else {
-        if (this.shapeHandle === INVALID_INDEX) {
-          this.shapeHandle = declareResolved(sink, "node", SHAPE_DECL, this.report, { line }).handle;
-        }
-        sink.setNodeValue(this.shapeHandle, index, shape);
-      }
-    }
-    for (let p = 0; p < extras.keys.length; p++) {
-      this.writeParameter("node", extras.keys[p], index, extras.values[p]);
+    if (restored !== null && !repeated) {
+      this.report.warning(
+        "coercion",
+        PAJEK_ISSUE.ORIGINAL_ID_UNRESTORED,
+        `vertex ${k} carries ${ORIGINAL_ID_KEY} ${JSON.stringify(restored)} but a later vertex's line came first and created it under its number; the original id is not restored`,
+        { line, element: String(k) }
+      );
     }
-    if (extras.spells !== null) {
-      if (this.nodeSpellsHandle === INVALID_INDEX) {
-        this.nodeSpellsHandle = declareResolved(sink, "node", spellsDecl(), this.report, { line }).handle;
-      }
-      sink.setNodeValue(this.nodeSpellsHandle, index, extras.spells);
+    return this.indexOfPos[pos];
+  }
+  /**
+   * A node column's handle, declared on first use.
+   * @param handle - the handle so far, or INVALID_INDEX
+   * @param decl - the column's declaration
+   * @param line - the line number
+   * @returns the handle
+   */
+  nodeHandle(handle, decl, line) {
+    return handle === INVALID_INDEX ? declareResolved(this.sink, "node", decl, this.report, { line }).handle : handle;
+  }
+  /**
+   * Writes a vertex's shape keyword: to the shape column, or to an earlier `shape "<text>"` parameter's column.
+   * @param index - the node index
+   * @param shape - the keyword
+   * @param line - the line number
+   */
+  writeShape(index, shape, line) {
+    if (this.shapeHandle === INVALID_INDEX && this.nodeParams.has(SHAPE_COLUMN)) {
+      this.writeParameter("node", SHAPE_COLUMN, index, shape);
+      return;
     }
+    this.shapeHandle = this.nodeHandle(this.shapeHandle, SHAPE_DECL, line);
+    this.sink.setNodeValue(this.shapeHandle, index, shape);
   }
   /**
    * A vertex label as written, its character references decoded.
@@ -2475,7 +3540,9 @@ class PajekParser {
   writePosition(index, dims, point, k, line) {
     if (this.positionHandle === INVALID_INDEX) {
       this.coordDims = dims;
-      this.positionHandle = declareResolved(this.sink, "node", positionDecl(dims), this.report, { line }).handle;
+      this.positionHandle = declareResolved(this.sink, "node", positionDecl(dims, this.window), this.report, {
+        line
+      }).handle;
     } else if (dims !== this.coordDims) {
       this.report.warnOnce(
         "validation-error",
@@ -2862,7 +3929,7 @@ class PajekParser {
     for (let i = start; i < tokens.length; ) {
       const token = tokens[i];
       if (token.startsWith("[")) {
-        extras.spells = this.intervals(token, domain);
+        extras.spells = this.intervals(token, domain, line);
         i++;
         continue;
       }
@@ -2885,8 +3952,9 @@ class PajekParser {
       }
       seen.add(token);
       extras.keys.push(token);
-      extras.values.push(tokens[i + 1]);
-      i += 2;
+      const triple = COLOR_KEYS.has(token) ? colorTriple(tokens, i + 1) : null;
+      extras.values.push(triple ?? tokens[i + 1]);
+      i += triple === null ? 2 : 4;
     }
     return extras;
   }
@@ -2915,12 +3983,15 @@ class PajekParser {
     );
   }
   /**
-   * The spells of a row's interval token; a malformed one skips the row.
+   * The spells of a row's interval token. A token not closed by "]" skips the row; a closed one
+   * whose times cannot be read (`[287-?]`, lin-rel4.net) is reported and dropped, and the rest of
+   * the row (its label, coordinates and parameters) is kept.
    * @param token - the token, starting with "["
-   * @param domain - what is skipped when the token is malformed
-   * @returns the spells, or null for an empty `[]`, which is no spell at all
+   * @param domain - what is skipped when the token is not closed
+   * @param line - the line number
+   * @returns the spells, or null for an empty `[]`, which is no spell at all, and for a dropped one
    */
-  intervals(token, domain) {
+  intervals(token, domain, line) {
     if (!isIntervalToken(token)) {
       this.skip(domain);
       throw new LineError(
@@ -2933,12 +4004,13 @@ class PajekParser {
       const spells = parseIntervals(token);
       return spells.length === 0 ? null : spells;
     } catch (err) {
-      this.skip(domain);
-      throw new LineError(
+      this.report.error(
         "validation-error",
         PAJEK_ISSUE.INTERVAL,
-        err instanceof Error ? err.message : String(err)
+        `${err instanceof Error ? err.message : String(err)}; the interval is dropped and the rest of the line kept`,
+        { line }
       );
+      return null;
     }
   }
   /**
@@ -2976,6 +4048,12 @@ class PajekParser {
     writer.write(row, text);
   }
 }
+const COLOR_KEYS = /* @__PURE__ */ new Set(["ic", "bc", "lc", "c"]);
+function colorTriple(tokens, at) {
+  const parts = tokens.slice(at, at + 3);
+  const fraction = (t) => /^[01]?(?:\.\d+)?$/.test(t) && t !== "" && Number(t) <= 1;
+  return parts.length === 3 && parts.every(fraction) ? parts.join(" ") : null;
+}
 function startsWithCoordinates(text, tokens) {
   if (quotedAfterNumber(text, tokens)) {
     return false;
@@ -3015,10 +4093,29 @@ function headSection(text) {
 }
 const pajekImporter = Object.freeze({
   format: "pajek",
-  options: Object.freeze(["firstVertex"]),
+  options: Object.freeze(["firstVertex", "pajekDraw"]),
   extensions: Object.freeze([".net", ".paj"]),
   mimeTypes: Object.freeze(["text/x-pajek", "text/plain"]),
   styles: pajekStyles,
+  /**
+   * Where Pajek 6.02 draws a network whose vertices have no coordinates: round a circle in vertex order, the first
+   * on the left, the rest going clockwise on screen (y down), at radius 0.4 about the middle of the Draw window
+   * (pajek-iliad: 311 vertices 200 points from the middle of its 500-point window). A file with coordinates is read
+   * from its position column.
+   * @param snapshot - the imported graph
+   * @returns the circle for a file with no coordinates, else null
+   */
+  positions(snapshot) {
+    if (snapshot.nodes.byRole("position") !== null) {
+      return null;
+    }
+    return {
+      units: "file",
+      pxPerUnit: PAJEK_POINTS_PER_UNIT,
+      yAxis: "down",
+      unplacedCircle: { center: [0.5, 0.5], radius: 0.4, startDegrees: 180, direction: 1 }
+    };
+  },
   /**
    * Confidence that the input is a Pajek network: it starts with `*Vertices` (or `*Network`),
    * after any `%` comment lines.
@@ -3046,10 +4143,11 @@ const pajekImporter = Object.freeze({
     }
     const resolved = resolveImportOptions(options, DEFAULTS);
     const firstVertex = firstVertexOption(options?.firstVertex);
+    const draw = resolvePajekDraw(options?.pajekDraw);
     const report = new ImportReportBuilder("pajek", resolved.errorLimit);
     reportSinkOptions(sink, options, report);
     reportUnusedOptions(options, report, USED_OPTIONS);
-    const parser = new PajekParser(sink, report, resolved, firstVertex);
+    const parser = new PajekParser(sink, report, resolved, firstVertex, draw ?? DEFAULT_WINDOW);
     const reader = new LineReader(input, report, resolved);
     let rest = null;
     let restLine = 0;
@@ -3069,6 +4167,9 @@ const pajekImporter = Object.freeze({
       }
     }
     parser.finish();
+    if (draw !== null || parser.voided.length > 0) {
+      report.keepForStyles({ block: parser.keptBlock, pajekDraw: draw ?? void 0, voided: parser.voided });
+    }
     if (rest !== null) {
       const objects = rest.objects > 0 ? `; ${rest.objects} *Partition / *Vector object(s) after them are not read` : "";
       report.warning(
@@ -3093,13 +4194,25 @@ const pajekImporter = Object.freeze({
   async importAll(input, sinkFor, options) {
     const resolved = resolveImportOptions(options, DEFAULTS);
     const firstVertex = firstVertexOption(options?.firstVertex);
+    const draw = resolvePajekDraw(options?.pajekDraw);
     const reports = [new ImportReportBuilder("pajek", resolved.errorLimit)];
     reportUnusedOptions(options, reports[0], USED_OPTIONS);
     const open = () => {
       const report = reports[reports.length - 1];
       const sink = sinkFor(reports.length - 1);
       reportSinkOptions(sink, options, report);
-      return new PajekParser(sink, report, resolved, firstVertex);
+      return new PajekParser(sink, report, resolved, firstVertex, draw ?? DEFAULT_WINDOW);
+    };
+    const close = (p) => {
+      p.finish();
+      const last = reports.at(-1);
+      if (last !== void 0 && (draw !== null || p.voided.length > 0)) {
+        last.keepForStyles({
+          block: p.keptBlock,
+          pajekDraw: draw ?? void 0,
+          voided: p.voided
+        });
+      }
     };
     let parser = open();
     const reader = new LineReader(input, reports[0], resolved);
@@ -3107,7 +4220,7 @@ const pajekImporter = Object.freeze({
     for await (const raw of reader) {
       const text = withoutStrayBom(raw);
       if (parser.line(text, reader.line)) {
-        parser.finish();
+        close(parser);
         reports.push(new ImportReportBuilder("pajek", resolved.errorLimit));
         parser = open();
         parser.line(text, reader.line);
@@ -3117,7 +4230,7 @@ const pajekImporter = Object.freeze({
         throwIfAborted(resolved.signal);
       }
     }
-    parser.finish();
+    close(parser);
     throwIfAborted(resolved.signal);
     return reports.map((r) => r.finish());
   }
@@ -3179,4 +4292,4 @@ export {
   pajekImporter as d,
   pajekExporter as p
 };
-//# sourceMappingURL=importer-CVT-JyDE.js.map
+//# sourceMappingURL=importer-vRq4h3j5.js.map