@graphty/graph-io 0.0.0 → 0.2.1

package/dist/neo4j.js

@@ -0,0 +1,2046 @@
+import { V as ROLE_TAKEN_CODE$1, n as ID_MERGED_CODE$1, k as DUPLICATE_NODE_CODE$1, M as MISSING_ENDPOINT_CODE$1, w as MISSING_ID_CODE$1, aC as resolveImportOptions, I as ImportReportBuilder, az as reportSinkOptions, aA as reportUnusedOptions, a as throwIfAborted, s as IdCoercer, l as DirectionResolver, u as ImportError, aL as declareAttribute, a_ as declareOn, aI as uniqueColumnName, S as RENAMED_CODE, ax as parseWeightText, aM as parseDeclaredTemporal, aN as parseDeclaredValue, aO as losesPrecision, ae as declareCompanion, R as PRECISION_CODE, aQ as splitListText, ar as isImportInput, aZ as takenIn, ao as inputLength, a9 as capabilities, o as ID_TEXT_COLLISION_CODE, p as ID_TEXT_TYPE_CODE, au as joinText, ah as encodeChunks, aB as resolveExportOptions, aa as checkCapabilities, aw as pairFolding, L as LOSS, aU as mapDeclaredType, ai as explicitWeights, aq as isCanonicalIntegerText, aW as formatTemporal, al as formatF64, ak as formatF32, an as formatInteger, W as SINK_OPTION_CODE, J as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, a1 as UNKNOWN_ATTR_TYPE_CODE, r as INVALID_UTF8_CODE, a5 as WEIGHT_KEY_CLASH_CODE, U as ROLE_DROPPED_CODE, F as MUTUAL_EXPANDED_CODE } from "./chunks/writer-DxSKC7TL.js";
+import { c as checkRecordSyntax, R as RecordReader, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-CGpxszm1.js";
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+import { m as quoteCsvCell } from "./chunks/escape-DyI8JofU.js";
+const STRUCTURAL = /* @__PURE__ */ new Set(["ID", "LABEL", "START_ID", "END_ID", "TYPE", "IGNORE"]);
+const SPACE_KINDS = /* @__PURE__ */ new Set(["ID", "START_ID", "END_ID"]);
+const HEADER_MARKER = /^[^:{}()]*:\s*(ID|START_ID|END_ID)\s*(\(|\{|$)/i;
+const CELL = /^([^:(){}]*)(?::([^:(){}]*))?(?:\(([^)]*)\))?(?:\{([^}]*)\})?$/;
+function isHeaderRecord(cells, count) {
+  for (let i = 0; i < count; i++) {
+    const cell = cells[i];
+    if (cell.indexOf(":") >= 0 && HEADER_MARKER.test(cell.trim())) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseHeaderField(text) {
+  const trimmed = text.trim();
+  const m = CELL.exec(trimmed);
+  if (m === null) {
+    throw headerError$1(text, "not a neo4j header cell");
+  }
+  const name = m[1].trim();
+  const rawType = m[2] === void 0 ? null : m[2].trim();
+  const space = m[3] === void 0 ? null : m[3].trim();
+  const options = parseOptions(text, m[4]);
+  if (rawType === null) {
+    if (name.length === 0) {
+      throw headerError$1(text, "an empty header cell");
+    }
+    if (space !== null || options.size > 0) {
+      throw headerError$1(text, "an id space or options need a field type");
+    }
+    return { text, name, kind: "PROPERTY", type: null, space: null, options };
+  }
+  if (rawType.length === 0) {
+    throw headerError$1(text, "an empty field type");
+  }
+  const upper = rawType.toUpperCase();
+  if (STRUCTURAL.has(upper)) {
+    const kind = upper;
+    if (space !== null && !SPACE_KINDS.has(kind)) {
+      throw headerError$1(text, `an id space is only allowed on ID, START_ID and END_ID, not ${kind}`);
+    }
+    if (name.length > 0 && kind !== "ID" && kind !== "IGNORE") {
+      throw headerError$1(text, `a ${kind} field cannot be stored as a property`);
+    }
+    return { text, name, kind, type: null, space: space === "" ? null : space, options };
+  }
+  if (name.length === 0) {
+    throw headerError$1(text, "a property column needs a name");
+  }
+  if (space !== null) {
+    throw headerError$1(text, "an id space is only allowed on ID, START_ID and END_ID");
+  }
+  return { text, name, kind: "PROPERTY", type: rawType, space: null, options };
+}
+function parseOptions(text, body) {
+  const options = /* @__PURE__ */ new Map();
+  if (body === void 0 || body.trim().length === 0) {
+    return options;
+  }
+  for (const part of body.split(",")) {
+    const colon = part.indexOf(":");
+    if (colon < 0) {
+      throw headerError$1(text, `option "${part.trim()}" is not key:value`);
+    }
+    const key = part.slice(0, colon).trim().toLowerCase();
+    const value = part.slice(colon + 1).trim();
+    if (key.length === 0) {
+      throw headerError$1(text, "an option needs a key");
+    }
+    options.set(key, value);
+  }
+  return options;
+}
+function headerError$1(text, reason) {
+  return new GraphFormatError("E_UNSUPPORTED", `header cell "${text}": ${reason}`, {
+    reason: "header",
+    cell: text,
+    detail: reason
+  });
+}
+function formatHeaderField(name, type, space) {
+  const base = `${name}:${type}`;
+  return space === null ? base : `${base}(${space})`;
+}
+const LABELS_COLUMN = "labels";
+const TYPE_COLUMN = "type";
+const ID_SPACE_COLUMN = "idSpace";
+const HEADER_CODE = "E_NEO4J_HEADER";
+const COLUMN_COUNT_CODE = "E_NEO4J_COLUMN_COUNT";
+const MISSING_ID_CODE = MISSING_ID_CODE$1;
+const MISSING_ENDPOINT_CODE = MISSING_ENDPOINT_CODE$1;
+const DUPLICATE_NODE_CODE = DUPLICATE_NODE_CODE$1;
+const ID_SPACE_COLLISION_CODE = "E_NEO4J_ID_SPACE_COLLISION";
+const ID_MERGED_CODE = ID_MERGED_CODE$1;
+const HEADER_OPTION_CODE = "W_NEO4J_HEADER_OPTION_IGNORED";
+const ROLE_TAKEN_CODE = ROLE_TAKEN_CODE$1;
+const IGNORED_COLUMNS_LOSS = "W_NEO4J_IGNORED_COLUMNS";
+const USED_OPTIONS = /* @__PURE__ */ new Set([
+  "ids",
+  "addMissingNodes",
+  "duplicateEdges",
+  "selfLoops",
+  "onMixedDirection",
+  "weightFrom",
+  "weightDtype",
+  "long",
+  "errorLimit",
+  "signal",
+  "onProgress"
+]);
+const NEO4J$1 = "neo4j";
+const ABORT_CHECK_INTERVAL = 64;
+const LABELS_DECL = {
+  name: LABELS_COLUMN,
+  dtype: "list",
+  itemDtype: "dict",
+  nullable: true,
+  role: "labels",
+  origin: { format: NEO4J$1, id: ":LABEL", title: null, type: "LABEL", namespace: null }
+};
+const TYPE_DECL = {
+  name: TYPE_COLUMN,
+  dtype: "dict",
+  nullable: true,
+  role: "kind",
+  origin: { format: NEO4J$1, id: ":TYPE", title: null, type: "TYPE", namespace: null }
+};
+const ID_SPACE_DECL = {
+  name: ID_SPACE_COLUMN,
+  dtype: "dict",
+  nullable: true,
+  role: "idSpace",
+  origin: { format: NEO4J$1, id: ":ID", title: null, type: "ID", namespace: null }
+};
+const ARRAY_DELIMITERS = { ";": "semicolon", ",": "comma", "|": "pipe" };
+const NEO4J_DELIMITER_CANDIDATES = Object.freeze([",", "	"]);
+function resolveNeo4jOptions(options) {
+  const o = options ?? {};
+  const arrayDelimiter = o.arrayDelimiter ?? ";";
+  const listSyntax = ARRAY_DELIMITERS[arrayDelimiter];
+  if (typeof arrayDelimiter !== "string" || listSyntax === void 0) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option arrayDelimiter: ${JSON.stringify(arrayDelimiter)} is not one of ";", ",", "|"`,
+      { option: "arrayDelimiter", found: arrayDelimiter }
+    );
+  }
+  const syntax = checkRecordSyntax({
+    delimiter: o.delimiter ?? null,
+    quote: o.quote ?? '"',
+    candidates: NEO4J_DELIMITER_CANDIDATES.filter((d) => d !== arrayDelimiter)
+  });
+  if (syntax.delimiter === arrayDelimiter) {
+    throw new GraphFormatError("E_UNSUPPORTED", "options delimiter and arrayDelimiter must differ", {
+      option: "arrayDelimiter",
+      found: arrayDelimiter
+    });
+  }
+  return {
+    nodes: inputList("nodes", o.nodes),
+    relationships: inputList("relationships", o.relationships),
+    syntax,
+    listSyntax
+  };
+}
+function inputList(name, value) {
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  const list = Array.isArray(value) ? value : [value];
+  for (const item of list) {
+    if (!isImportInput(item)) {
+      throw new GraphFormatError("E_UNSUPPORTED", `option ${name}: an entry is not an ImportInput`, {
+        option: name,
+        found: typeof item
+      });
+    }
+  }
+  return list;
+}
+class NodeRegistry {
+  constructor() {
+    this.codes = new Uint32Array(1024);
+    this.spaces = /* @__PURE__ */ new Map();
+  }
+  /**
+   * The code of an id space (1 for "no space").
+   * @param space - the space name or null
+   * @returns a code >= 1
+   */
+  codeOf(space) {
+    let code = this.spaces.get(space);
+    if (code === void 0) {
+      code = this.spaces.size + 1;
+      this.spaces.set(space, code);
+    }
+    return code;
+  }
+  /**
+   * Record that a node row declared a node.
+   * @param index - the node index
+   * @param code - the space code
+   * @returns "new" for a first declaration, "duplicate" for a repeat in the same space, "collision" across spaces
+   */
+  declare(index, code) {
+    if (index >= this.codes.length) {
+      let size = this.codes.length * 2;
+      while (size <= index) {
+        size *= 2;
+      }
+      const grown = new Uint32Array(size);
+      grown.set(this.codes);
+      this.codes = grown;
+    }
+    const previous = this.codes[index];
+    if (previous === 0) {
+      this.codes[index] = code;
+      return "new";
+    }
+    return previous === code ? "duplicate" : "collision";
+  }
+}
+class ProgressTracker {
+  /**
+   * Create a tracker.
+   * @param callback - the caller's onProgress, or null
+   * @param inputs - every input in reading order
+   */
+  constructor(callback, inputs) {
+    this.offset = 0;
+    this.lastDone = 0;
+    this.callback = callback;
+    let total = 0;
+    for (const input of inputs) {
+      const length = inputLength(input);
+      if (length === null) {
+        total = void 0;
+        break;
+      }
+      total += length;
+    }
+    this.total = total;
+  }
+  /**
+   * The read options for one input.
+   * @param signal - the cancellation signal
+   * @returns options whose onProgress reports cumulative bytes
+   */
+  optionsFor(signal) {
+    const { callback } = this;
+    if (callback === null) {
+      return { signal };
+    }
+    return {
+      signal,
+      onProgress: (done) => {
+        this.lastDone = done;
+        callback(this.offset + done, this.total);
+      }
+    };
+  }
+  /** Move the offset past the input just finished. */
+  finishInput() {
+    this.offset += this.lastDone;
+    this.lastDone = 0;
+  }
+}
+class Neo4jImportSession {
+  /**
+   * Create a session.
+   * @param sink - the sink
+   * @param report - the report
+   * @param common - the resolved common options
+   * @param options - the resolved format options
+   */
+  constructor(sink, report, common, options) {
+    this.registry = new NodeRegistry();
+    this.labelsHandle = INVALID_INDEX;
+    this.typeHandle = INVALID_INDEX;
+    this.idSpaceHandle = INVALID_INDEX;
+    this.ignoredColumns = 0;
+    this.headerSet = false;
+    this.values = [];
+    this.texts = [];
+    this.precisionSlots = [];
+    this.sink = sink;
+    this.report = report;
+    this.common = common;
+    this.options = options;
+    this.coercer = new IdCoercer(common.ids);
+    this.direction = new DirectionResolver(sink, report, common.onMixedDirection);
+  }
+  /**
+   * Read every input.
+   * @param inputs - the inputs in reading order
+   */
+  async run(inputs) {
+    const progress = new ProgressTracker(this.common.onProgress, inputs);
+    for (const input of inputs) {
+      await this.readInput(input, progress.optionsFor(this.common.signal));
+      progress.finishInput();
+    }
+    if (this.ignoredColumns > 0) {
+      this.report.loss(
+        IGNORED_COLUMNS_LOSS,
+        `${this.ignoredColumns} :IGNORE column(s) were skipped as the header instructs`,
+        null,
+        this.ignoredColumns
+      );
+    }
+  }
+  /**
+   * Read one input: a header row, then data rows until the next header row.
+   * @param input - the input
+   * @param readOptions - cancellation and progress
+   */
+  async readInput(input, readOptions) {
+    const reader = new RecordReader(input, this.report, this.options.syntax, readOptions);
+    let section = null;
+    let sinceCheck = 0;
+    for await (const count of reader) {
+      if (section === null || isHeaderRecord(reader.cells, count)) {
+        section = this.declareSection(reader, count);
+        continue;
+      }
+      if (section.kind === "node") {
+        this.nodeRow(section, reader, count);
+      } else {
+        this.relationshipRow(section, reader, count);
+      }
+      if (++sinceCheck >= ABORT_CHECK_INTERVAL) {
+        sinceCheck = 0;
+        throwIfAborted(readOptions.signal);
+      }
+    }
+    if (section === null) {
+      this.report.fail(HEADER_CODE, "the input has no header row", { line: 1 });
+    }
+  }
+  /**
+   * Interpret a header row: parse every cell, check the section shape, declare its columns.
+   * @param reader - the reader positioned on the header
+   * @param count - the number of header cells
+   * @returns the section
+   */
+  declareSection(reader, count) {
+    const { line } = reader;
+    const fields = [];
+    try {
+      for (let i = 0; i < count; i++) {
+        fields.push(parseHeaderField(reader.cells[i]));
+      }
+      const kinds = /* @__PURE__ */ new Map();
+      fields.forEach((field, i) => {
+        const list = kinds.get(field.kind);
+        if (list === void 0) {
+          kinds.set(field.kind, [i]);
+        } else {
+          list.push(i);
+        }
+      });
+      const ids = kinds.get("ID") ?? [];
+      const starts = kinds.get("START_ID") ?? [];
+      const ends = kinds.get("END_ID") ?? [];
+      const isNode = ids.length > 0;
+      const isRelationship = starts.length > 0 || ends.length > 0;
+      if (isNode && isRelationship) {
+        throw headerError("a header mixes :ID with :START_ID / :END_ID");
+      }
+      if (!isNode && !isRelationship) {
+        throw headerError(
+          "a header needs an :ID column (nodes) or :START_ID and :END_ID columns (relationships)"
+        );
+      }
+      checkPropertyNames(fields);
+      this.ignoredColumns += (kinds.get("IGNORE") ?? []).length;
+      if (isNode) {
+        if (ids.length > 1) {
+          throw headerError("a node header has more than one :ID column");
+        }
+        if (kinds.has("TYPE")) {
+          throw headerError("a node header cannot have a :TYPE column");
+        }
+        return this.declareNodeSection(fields, ids[0], kinds.get("LABEL") ?? [], line);
+      }
+      if (starts.length !== 1 || ends.length !== 1) {
+        throw headerError("a relationship header needs exactly one :START_ID and one :END_ID column");
+      }
+      if (kinds.has("LABEL")) {
+        throw headerError("a relationship header cannot have a :LABEL column");
+      }
+      const types = kinds.get("TYPE") ?? [];
+      if (types.length > 1) {
+        throw headerError("a relationship header has more than one :TYPE column");
+      }
+      return this.declareRelationshipSection(
+        fields,
+        starts[0],
+        ends[0],
+        types.length === 1 ? types[0] : -1,
+        line
+      );
+    } catch (err) {
+      if (err instanceof GraphFormatError && !(err instanceof ImportError)) {
+        this.report.fail(HEADER_CODE, `line ${line}: ${err.message}`, { line }, { cause: err.code });
+      }
+      throw err;
+    }
+  }
+  /**
+   * Declare the columns of a node section.
+   * @param fields - the parsed header
+   * @param idCell - the `:ID` cell
+   * @param labelCells - the `:LABEL` cells
+   * @param line - the header line
+   * @returns the section
+   */
+  declareNodeSection(fields, idCell, labelCells, line) {
+    const idField = fields[idCell];
+    const extraLabels = [];
+    for (const field of fields) {
+      for (const [key, value] of field.options) {
+        if (key === "label" && field.kind === "ID") {
+          extraLabels.push(value);
+        } else {
+          this.report.warning(
+            "unsupported",
+            HEADER_OPTION_CODE,
+            `header option ${key}:${value} of "${field.text}" is ignored`,
+            { line, element: field.text }
+          );
+        }
+      }
+    }
+    if (labelCells.length > 0 || extraLabels.length > 0) {
+      this.ensureLabels();
+    }
+    if (idField.space !== null) {
+      this.ensureIdSpace();
+    }
+    let idHandle = INVALID_INDEX;
+    if (idField.name.length > 0) {
+      idHandle = this.declareProperty(
+        "node",
+        { ...idField, type: null },
+        idCell,
+        { origin: { format: NEO4J$1, id: idField.name, title: null, type: "ID", namespace: idField.space } },
+        line
+      ).handle;
+    }
+    const properties = this.declareProperties("node", fields, line, null);
+    return {
+      kind: "node",
+      width: fields.length,
+      idCell,
+      idHandle,
+      space: idField.space,
+      spaceCode: this.registry.codeOf(idField.space),
+      labelCells,
+      extraLabels,
+      properties
+    };
+  }
+  /**
+   * Declare the columns of a relationship section.
+   * @param fields - the parsed header
+   * @param startCell - the `:START_ID` cell
+   * @param endCell - the `:END_ID` cell
+   * @param typeCell - the `:TYPE` cell, or -1
+   * @param line - the header line
+   * @returns the section
+   */
+  declareRelationshipSection(fields, startCell, endCell, typeCell, line) {
+    for (const field of fields) {
+      for (const [key, value] of field.options) {
+        this.report.warning(
+          "unsupported",
+          HEADER_OPTION_CODE,
+          `header option ${key}:${value} of "${field.text}" is ignored`,
+          { line, element: field.text }
+        );
+      }
+    }
+    if (typeCell >= 0) {
+      this.ensureType();
+    }
+    const { weightFrom } = this.common;
+    let weightCell = -1;
+    if (weightFrom !== null) {
+      weightCell = fields.findIndex((field) => field.kind === "PROPERTY" && field.name === weightFrom);
+    }
+    const properties = this.declareProperties("edge", fields, line, weightCell);
+    return { kind: "relationship", width: fields.length, startCell, endCell, typeCell, weightCell, properties };
+  }
+  /**
+   * Declare every PROPERTY field of a header.
+   * @param domain - node or edge
+   * @param fields - the parsed header
+   * @param line - the header line
+   * @param skipCell - a cell to leave undeclared (the weight), or null
+   * @returns the property slots
+   */
+  declareProperties(domain, fields, line, skipCell) {
+    const slots = [];
+    fields.forEach((field, cell) => {
+      if (field.kind !== "PROPERTY" || cell === skipCell) {
+        return;
+      }
+      slots.push(this.declareProperty(domain, field, cell, {}, line));
+    });
+    const width = fields.length;
+    if (this.values.length < width) {
+      this.values = new Array(width);
+      this.texts = new Array(width);
+    }
+    return slots;
+  }
+  /**
+   * Declare one property column on the sink: the same name and shape again shares the column;
+   * a different shape under the same name is renamed `<name>#<name>` (design section 5.6).
+   * @param domain - node or edge
+   * @param field - the header field
+   * @param cell - the field's cell index
+   * @param patch - declaration fields to override (the id property's origin)
+   * @param line - the header line
+   * @returns the slot
+   */
+  declareProperty(domain, field, cell, patch, line) {
+    const { sink, report } = this;
+    const { listSyntax } = this.options;
+    const input = {
+      format: NEO4J$1,
+      id: field.name,
+      title: null,
+      type: field.type,
+      namespace: null,
+      listSyntax,
+      long: this.common.long
+    };
+    let declared = declareAttribute(input);
+    let decl = { ...declared.decl, ...patch };
+    let handle;
+    try {
+      handle = declareOn(sink, domain, decl);
+    } catch (err) {
+      if (!(err instanceof GraphFormatError) || err.code !== "E_COLUMN_EXISTS") {
+        throw err;
+      }
+      declared = declareAttribute({ ...input, taken: takenIn(sink, domain) });
+      decl = { ...declared.decl, ...patch, name: declared.decl.name };
+      handle = declareOn(sink, domain, decl);
+    }
+    for (const issue of declared.issues) {
+      report.warning(issue.category, issue.code, issue.message, { line, element: field.text });
+    }
+    return {
+      cell,
+      name: decl.name,
+      handle,
+      spec: declared.spec,
+      companionDecl: declared.companion,
+      companion: INVALID_INDEX
+    };
+  }
+  /** Declare (or adopt) the labels column. */
+  ensureLabels() {
+    if (this.labelsHandle === INVALID_INDEX) {
+      this.labelsHandle = this.declareReserved("node", LABELS_DECL);
+    }
+  }
+  /** Declare (or adopt) the relationship type column. */
+  ensureType() {
+    if (this.typeHandle === INVALID_INDEX) {
+      this.typeHandle = this.declareReserved("edge", TYPE_DECL);
+    }
+  }
+  /** Declare (or adopt) the id space column. */
+  ensureIdSpace() {
+    if (this.idSpaceHandle === INVALID_INDEX) {
+      this.idSpaceHandle = this.declareReserved("node", ID_SPACE_DECL);
+    }
+  }
+  /**
+   * Declare a reserved column: the same shape again shares it; a name taken by another shape is
+   * renamed `<name>#<origin.id>` and reported; a role the sink already holds elsewhere is dropped
+   * and reported.
+   * @param domain - node or edge
+   * @param decl - the reserved declaration
+   * @returns the handle
+   */
+  declareReserved(domain, decl) {
+    const { sink, report } = this;
+    let current = decl;
+    for (; ; ) {
+      try {
+        return declareOn(sink, domain, current);
+      } catch (err) {
+        if (!(err instanceof GraphFormatError)) {
+          throw err;
+        }
+        if (err.code === "E_COLUMN_EXISTS") {
+          const name = uniqueColumnName(current.name, current.origin?.id ?? null, takenIn(sink, domain));
+          report.warning(
+            "coercion",
+            RENAMED_CODE,
+            `column "${current.name}" renamed to "${name}": the name was taken`,
+            { element: current.name }
+          );
+          current = { ...current, name };
+        } else if (err.code === "E_DUPLICATE_ROLE") {
+          report.warning(
+            "coercion",
+            ROLE_TAKEN_CODE,
+            `column "${current.name}" declared without role "${String(current.role)}": the sink already holds that role`,
+            { element: current.name }
+          );
+          const { role: _role, ...withoutRole } = current;
+          current = withoutRole;
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+  /**
+   * Push one node row.
+   * @param section - the section
+   * @param reader - the reader positioned on the row
+   * @param count - the row's cell count
+   */
+  nodeRow(section, reader, count) {
+    const { sink, report } = this;
+    const { cells, quoted, line } = reader;
+    if (count !== section.width) {
+      report.error(
+        "validation-error",
+        COLUMN_COUNT_CODE,
+        `row has ${count} cell(s) but the header has ${section.width}`,
+        { line }
+      );
+      report.counts.skippedNodes++;
+      return;
+    }
+    const idText2 = cells[section.idCell];
+    if (idText2.length === 0 && !quoted[section.idCell]) {
+      report.error("missing-value", MISSING_ID_CODE, "empty :ID cell", { line });
+      report.counts.skippedNodes++;
+      return;
+    }
+    const id = this.coerceId(idText2, line);
+    if (id === null || !this.parseProperties(section.properties, cells, quoted, line, idText2)) {
+      report.counts.skippedNodes++;
+      return;
+    }
+    let labels;
+    if (section.labelCells.length > 0 || section.extraLabels.length > 0) {
+      labels = this.labelsOf(section, cells, quoted);
+    }
+    const index = sink.addNode(id);
+    const status = this.registry.declare(index, section.spaceCode);
+    if (status === "collision") {
+      report.error(
+        "validation-error",
+        ID_SPACE_COLLISION_CODE,
+        `node ${idText2} is declared in id space ${section.space ?? "(none)"} and in another id space; the core has one id space and this row is skipped`,
+        { line, element: idText2 }
+      );
+      report.counts.skippedNodes++;
+      return;
+    }
+    if (status === "duplicate") {
+      report.warning(
+        "merged",
+        DUPLICATE_NODE_CODE,
+        `node ${idText2} is declared twice; the later properties win`,
+        {
+          line,
+          element: idText2
+        }
+      );
+    }
+    if (section.idHandle !== INVALID_INDEX) {
+      sink.setNodeValue(section.idHandle, index, idText2);
+    }
+    if (section.space !== null) {
+      sink.setNodeValue(this.idSpaceHandle, index, section.space);
+    }
+    if (labels !== void 0) {
+      sink.setNodeValue(this.labelsHandle, index, labels);
+    }
+    this.writeProperties("node", section.properties, index);
+    this.reportPrecision(line, idText2);
+    report.counts.nodes++;
+  }
+  /**
+   * Push one relationship row.
+   * @param section - the section
+   * @param reader - the reader positioned on the row
+   * @param count - the row's cell count
+   */
+  relationshipRow(section, reader, count) {
+    const { sink, report } = this;
+    const { cells, quoted, line } = reader;
+    if (!this.headerSet) {
+      this.headerSet = true;
+      this.direction.setHeader(true, { line });
+    }
+    if (count !== section.width) {
+      report.error(
+        "validation-error",
+        COLUMN_COUNT_CODE,
+        `row has ${count} cell(s) but the header has ${section.width}`,
+        { line }
+      );
+      report.counts.skippedEdges++;
+      return;
+    }
+    const startText = cells[section.startCell];
+    const endText = cells[section.endCell];
+    const startMissing = startText.length === 0 && !quoted[section.startCell];
+    if (startMissing || endText.length === 0 && !quoted[section.endCell]) {
+      report.error(
+        "missing-value",
+        MISSING_ENDPOINT_CODE,
+        `empty ${startMissing ? ":START_ID" : ":END_ID"} cell`,
+        {
+          line
+        }
+      );
+      report.counts.skippedEdges++;
+      return;
+    }
+    const element = `${startText}->${endText}`;
+    const source = this.coerceId(startText, line);
+    const target = source === null ? null : this.coerceId(endText, line);
+    if (source === null || target === null) {
+      report.counts.skippedEdges++;
+      return;
+    }
+    let weight;
+    if (section.weightCell >= 0) {
+      try {
+        weight = parseWeightText(cells[section.weightCell]);
+      } catch (err) {
+        report.recordError(err, { line, element });
+        report.counts.skippedEdges++;
+        return;
+      }
+    }
+    if (!this.parseProperties(section.properties, cells, quoted, line, element)) {
+      report.counts.skippedEdges++;
+      return;
+    }
+    let edge;
+    try {
+      edge = this.direction.addEdge(source, target, "directed", weight, { line, element });
+    } catch (err) {
+      report.recordError(err, { line, element });
+      report.counts.skippedEdges++;
+      return;
+    }
+    if (section.typeCell >= 0) {
+      const type = cells[section.typeCell];
+      if (type.length > 0) {
+        sink.setEdgeValue(this.typeHandle, edge, type);
+      }
+    }
+    this.writeProperties("edge", section.properties, edge);
+    this.reportPrecision(line, element);
+    report.counts.edges++;
+  }
+  /**
+   * Coerce an id cell, reporting a merge under `ids: "number"` and an invalid id as an error.
+   * @param text - the cell
+   * @param line - the row's line
+   * @returns the id, or null when the cell was rejected (the error is recorded)
+   */
+  coerceId(text, line) {
+    const { coercer, report } = this;
+    let id;
+    try {
+      id = coercer.text(text);
+    } catch (err) {
+      report.recordError(err, { line, element: text });
+      return null;
+    }
+    const merge = coercer.lastMerge;
+    if (merge !== null) {
+      report.warning(
+        "coercion",
+        ID_MERGED_CODE,
+        `id "${merge.text}" merged with "${merge.previousText}" as ${merge.id} under ids: "number"`,
+        { line, element: text }
+      );
+    }
+    return id;
+  }
+  /**
+   * Parse the property cells of a row into the scratch arrays.
+   * @param slots - the section's property slots
+   * @param cells - the row's cells
+   * @param quoted - whether each cell was quoted
+   * @param line - the row's line
+   * @param element - the row's element name for issues
+   * @returns true when every cell parsed; false after recording the first error
+   */
+  parseProperties(slots, cells, quoted, line, element) {
+    const { values, texts, precisionSlots } = this;
+    precisionSlots.length = 0;
+    for (const slot of slots) {
+      const text = cells[slot.cell];
+      texts[slot.cell] = null;
+      if (text.length === 0) {
+        values[slot.cell] = quoted[slot.cell] ? emptyValue(slot.spec) : void 0;
+        continue;
+      }
+      const { spec } = slot;
+      try {
+        if (spec.temporal !== null && !spec.list) {
+          const parsed = parseDeclaredTemporal(text, spec);
+          values[slot.cell] = parsed.value;
+          texts[slot.cell] = parsed.text;
+        } else {
+          values[slot.cell] = parseDeclaredValue(text, spec, this.options.listSyntax);
+        }
+      } catch (err) {
+        this.report.recordError(err, { line, element: `${element} ${slot.name}` });
+        return false;
+      }
+      if (spec.precision && losesPrecision(spec, text)) {
+        precisionSlots.push(slot);
+      }
+    }
+    return true;
+  }
+  /**
+   * Write the parsed property values of a row.
+   * @param domain - node or edge
+   * @param slots - the section's property slots
+   * @param row - the node or edge index
+   */
+  writeProperties(domain, slots, row) {
+    const { sink, values, texts } = this;
+    for (const slot of slots) {
+      const value = values[slot.cell];
+      if (value === void 0) {
+        continue;
+      }
+      const text = texts[slot.cell];
+      if (text !== null && slot.companion === INVALID_INDEX && slot.companionDecl !== null) {
+        slot.companion = declareCompanion(sink, domain, slot.companionDecl);
+      }
+      if (domain === "node") {
+        sink.setNodeValue(slot.handle, row, value);
+        if (text !== null) {
+          sink.setNodeValue(slot.companion, row, text);
+        }
+      } else {
+        sink.setEdgeValue(slot.handle, row, value);
+        if (text !== null) {
+          sink.setEdgeValue(slot.companion, row, text);
+        }
+      }
+    }
+  }
+  /**
+   * Report the precision losses of the row just accepted.
+   * @param line - the row's line
+   * @param element - the row's element name
+   */
+  reportPrecision(line, element) {
+    for (const slot of this.precisionSlots) {
+      this.report.warning(
+        "precision",
+        PRECISION_CODE,
+        `long value of "${slot.name}" is beyond 2^53 and was stored as the nearest f64`,
+        { line, element }
+      );
+    }
+    this.precisionSlots.length = 0;
+  }
+  /**
+   * The labels of a node row: every `:LABEL` cell split by the array delimiter (empty items
+   * dropped), plus the header's `{label:...}` options.
+   * @param section - the section
+   * @param cells - the row's cells
+   * @param quoted - whether each cell was quoted
+   * @returns the labels, or undefined when every label cell is unset and no extra label exists
+   */
+  labelsOf(section, cells, quoted) {
+    let labels;
+    for (const cell of section.labelCells) {
+      const text = cells[cell];
+      if (text.length === 0 && !quoted[cell]) {
+        continue;
+      }
+      if (labels === void 0) {
+        labels = [];
+      }
+      for (const item of splitListText(text, this.options.listSyntax)) {
+        if (item.length > 0) {
+          labels.push(item);
+        }
+      }
+    }
+    if (section.extraLabels.length > 0) {
+      if (labels === void 0) {
+        labels = [];
+      }
+      labels.push(...section.extraLabels);
+    }
+    return labels;
+  }
+}
+function emptyValue(spec) {
+  if (spec.list) {
+    return [];
+  }
+  if (spec.kind === "string" || spec.kind === "duration") {
+    return "";
+  }
+  return void 0;
+}
+function checkPropertyNames(fields) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (field.name.length === 0 || field.kind === "IGNORE") {
+      continue;
+    }
+    if (seen.has(field.name)) {
+      throw headerError(`property "${field.name}" is declared twice`);
+    }
+    seen.add(field.name);
+  }
+}
+function headerError(reason) {
+  return new GraphFormatError("E_UNSUPPORTED", reason, { reason: "header" });
+}
+function sniffNeo4j(head) {
+  const text = new TextDecoder("utf-8", { fatal: false, ignoreBOM: false }).decode(head);
+  const end = text.search(/[\r\n]/);
+  const first = end < 0 ? text : text.slice(0, end);
+  const cells = first.split(/[,;|\t]/);
+  return isHeaderRecord(cells, cells.length) ? 0.95 : 0;
+}
+const neo4jImporter = Object.freeze({
+  format: NEO4J$1,
+  extensions: Object.freeze([".csv", ".tsv"]),
+  mimeTypes: Object.freeze(["text/csv", "text/tab-separated-values"]),
+  sniff: sniffNeo4j,
+  /**
+   * Read one or more neo4j-admin CSV inputs into the sink.
+   * @param input - the primary input (a node table, a relationship table, or sections of both)
+   * @param sink - the sink
+   * @param options - format-specific and common options
+   * @returns the report; ImportError beyond the error limit or on a malformed header
+   */
+  async import(input, sink, options) {
+    const common = resolveImportOptions(options, { ids: "canonical", defaultDirected: true, weightFrom: "weight" });
+    const format = resolveNeo4jOptions(options);
+    const report = new ImportReportBuilder(NEO4J$1, common.errorLimit);
+    reportSinkOptions(sink, options, report);
+    reportUnusedOptions(options, report, USED_OPTIONS);
+    const session = new Neo4jImportSession(sink, report, common, format);
+    await session.run([input, ...format.nodes, ...format.relationships]);
+    throwIfAborted(common.signal);
+    return report.finish();
+  }
+});
+const UNDIRECTED_LOSS = "W_NEO4J_UNDIRECTED_AS_DIRECTED";
+const ID_TEXT_TYPE_LOSS = ID_TEXT_TYPE_CODE;
+const ID_TEXT_COLLISION_LOSS = ID_TEXT_COLLISION_CODE;
+const WEIGHT_COLUMN_TAKEN_LOSS = "E_NEO4J_WEIGHT_COLUMN_TAKEN";
+const ID_COLUMN_TAKEN_LOSS = "E_NEO4J_ID_COLUMN_TAKEN";
+const MULTIPLE_ID_PROPERTIES_LOSS = "W_NEO4J_MULTIPLE_ID_PROPERTIES";
+const DECLARED_TYPE_CHANGED_LOSS = "W_NEO4J_DECLARED_TYPE_CHANGED";
+const ARRAY_DELIMITER_LOSS = "W_NEO4J_ARRAY_DELIMITER";
+const SLOT_ROLES = /* @__PURE__ */ new Set(["kind", "labels", "idSpace"]);
+const NEO4J = "neo4j";
+const ID_TYPE = "ID";
+const DEFAULT_WEIGHT_COLUMN = "weight";
+const ROLE_NAMES = Object.freeze({
+  kind: TYPE_COLUMN,
+  labels: LABELS_COLUMN,
+  idSpace: ID_SPACE_COLUMN
+});
+const NEO4J_CAPABILITIES = capabilities({
+  mixedDirection: false,
+  multiEdges: true,
+  selfLoops: true,
+  edgeIds: "none",
+  idCharset: "any",
+  dtypes: ["f32", "f64", "i32", "bool", "string"],
+  components: false,
+  lists: true,
+  json: false,
+  defaults: false,
+  options: false,
+  hierarchy: false,
+  temporal: "none",
+  graphAttributes: false,
+  positions: false,
+  viz: false
+});
+const SKIPPED_ROLES = /* @__PURE__ */ new Set([
+  "directed",
+  "pair",
+  "mutual",
+  "weight",
+  "timeText",
+  "originalId",
+  "parent",
+  "parents",
+  "start",
+  "end",
+  "timestamp",
+  "timestamps",
+  "spells",
+  "open"
+]);
+const EDGE_NOTE_CODES = /* @__PURE__ */ new Set([
+  LOSS.MIXED_DIRECTION,
+  LOSS.MIXED_DIRECTION_ERROR,
+  LOSS.MULTI_EDGES,
+  LOSS.SELF_LOOPS,
+  LOSS.EDGE_IDS_GENERATED,
+  LOSS.EDGE_IDS_DROPPED,
+  UNDIRECTED_LOSS,
+  WEIGHT_COLUMN_TAKEN_LOSS
+]);
+const NODE_NOTE_CODES = /* @__PURE__ */ new Set([
+  LOSS.ID_MANGLED,
+  LOSS.ID_CHARSET,
+  LOSS.ID_RENUMBERED,
+  ID_TEXT_TYPE_LOSS,
+  ID_COLUMN_TAKEN_LOSS,
+  MULTIPLE_ID_PROPERTIES_LOSS
+]);
+const ARRAY_SYNTAXES = /* @__PURE__ */ new Set([";", ",", "|"]);
+const PARTS = /* @__PURE__ */ new Set(["all", "nodes", "relationships"]);
+function resolveNeo4jExportOptions(options) {
+  const o = options ?? {};
+  const part = o.part ?? "all";
+  if (!PARTS.has(part)) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option part: ${JSON.stringify(part)} is not "all", "nodes" or "relationships"`,
+      {
+        option: "part",
+        found: part
+      }
+    );
+  }
+  const arrayDelimiter = o.arrayDelimiter ?? ";";
+  if (!ARRAY_SYNTAXES.has(arrayDelimiter)) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option arrayDelimiter: ${JSON.stringify(arrayDelimiter)} is not one of ";", ",", "|"`,
+      { option: "arrayDelimiter", found: arrayDelimiter }
+    );
+  }
+  const delimiter = o.delimiter ?? ",";
+  const syntax = { ...checkRecordSyntax({ delimiter, quote: o.quote ?? '"' }), delimiter };
+  if (syntax.delimiter === arrayDelimiter) {
+    throw new GraphFormatError("E_UNSUPPORTED", "options delimiter and arrayDelimiter must differ", {
+      option: "arrayDelimiter",
+      found: arrayDelimiter
+    });
+  }
+  const weightColumn = o.weightColumn === void 0 ? "weight" : o.weightColumn;
+  if (weightColumn !== null && (typeof weightColumn !== "string" || weightColumn.length === 0)) {
+    throw new GraphFormatError("E_UNSUPPORTED", "option weightColumn: expected a non-empty name or null", {
+      option: "weightColumn",
+      found: weightColumn
+    });
+  }
+  const idColumn = o.idColumn ?? null;
+  if (idColumn !== null && (typeof idColumn !== "string" || idColumn.length === 0)) {
+    throw new GraphFormatError("E_UNSUPPORTED", "option idColumn: expected a non-empty name or null", {
+      option: "idColumn",
+      found: idColumn
+    });
+  }
+  return { part, syntax, arrayDelimiter, weightColumn, idColumn };
+}
+class ExportPlan {
+  /**
+   * Build the plan.
+   * @param snapshot - the snapshot
+   * @param options - the resolved format options
+   * @param common - the resolved common options
+   */
+  constructor(snapshot, options, common) {
+    this.notes = [];
+    this.ownNotes = [];
+    this.fatalNodes = null;
+    this.fatalEdges = null;
+    this.fatalAll = null;
+    this.nodeColumns = [];
+    this.edgeColumns = [];
+    this.idColumns = [];
+    this.snapshot = snapshot;
+    this.options = options;
+    this.common = common;
+    this.idSpace = snapshot.nodes.byRole("idSpace");
+    this.labels = snapshot.nodes.byRole("labels");
+    this.kind = snapshot.edges.byRole("kind");
+    for (const column of snapshot.nodes) {
+      if (isStoredId(column.meta)) {
+        this.idColumns.push(column);
+      }
+    }
+    const generic = checkCapabilities(snapshot, NEO4J_CAPABILITIES, common, {
+      roles: SLOT_ROLES,
+      roleNames: ROLE_NAMES,
+      temporalText: true
+    });
+    this.planColumns("node", snapshot.nodes, this.nodeColumns);
+    this.planColumns("edge", snapshot.edges, this.edgeColumns);
+    this.weights = this.planWeightSource();
+    this.folding = pairFolding(snapshot);
+    this.checkIds();
+    this.checkIdColumn();
+    this.checkStoredIds();
+    this.directionNotes();
+    const slots = new Set([this.kind, this.labels, this.idSpace].flatMap((c) => c === null ? [] : [c.meta.name]));
+    for (const gen of generic) {
+      if (gen.code === LOSS.JSON && gen.column !== null && this.writtenAsPoint(gen.column)) {
+        continue;
+      }
+      if (gen.code === LOSS.DTYPE && gen.column !== null && slots.has(gen.column)) {
+        continue;
+      }
+      if (gen.code === LOSS.MIXED_DIRECTION_ERROR && this.fatalEdges === null) {
+        this.fatalEdges = new GraphFormatError("E_DIRECTED", gen.message, { reason: "mixed direction" });
+      }
+      if ((gen.code === LOSS.POSITIONS || gen.code === LOSS.VIZ) && gen.column !== null) {
+        this.notes.push(
+          Object.freeze({
+            code: gen.code,
+            message: `node column "${gen.column}" is written as a plain property; its role is lost on re-import`,
+            column: gen.column,
+            count: gen.count
+          })
+        );
+        continue;
+      }
+      this.notes.push(gen);
+    }
+    this.notes.push(...this.ownNotes);
+    this.filterNotesByPart();
+  }
+  /**
+   * The direction notes: an undirected snapshot writes every edge as a directed relationship;
+   * a mixed snapshot folds its undirected pairs to one directed relationship each under
+   * "directed" or "undirected" (Neo4j has no undirected relationship, so both policies write
+   * the same file and the generic W_MIXED_DIRECTION note names the policy); a mutual pair is
+   * written as two relationships without its mark.
+   */
+  directionNotes() {
+    const { snapshot, folding } = this;
+    if (!snapshot.directed) {
+      this.note(
+        UNDIRECTED_LOSS,
+        `the snapshot is undirected; every edge is written as a directed relationship (${snapshot.edgeCount} edge(s))`,
+        null,
+        snapshot.edgeCount
+      );
+    } else if (this.common.onMixedDirection !== "error") {
+      let undirected = 0;
+      for (let e = 0; e < snapshot.edgeCount; e++) {
+        if (!folding.folded(e) && !folding.sourceDirected(e)) {
+          undirected++;
+        }
+      }
+      if (undirected > 0) {
+        this.note(
+          UNDIRECTED_LOSS,
+          `${undirected} undirected edge(s) are written as one directed relationship each (source to target, a pair folded to its primary); Neo4j has no undirected relationship`,
+          null,
+          undirected
+        );
+      }
+    }
+    if (folding.mutualCount > 0) {
+      this.note(
+        LOSS.MUTUAL_EXPANDED,
+        `${folding.mutualCount} mutual pair(s) are written as two directed relationships; the mutual mark is lost`,
+        null,
+        folding.mutualCount
+      );
+    }
+  }
+  /**
+   * Record a note.
+   * @param code - the code
+   * @param message - the message
+   * @param column - the column, or null
+   * @param count - the count, or null
+   */
+  note(code, message, column = null, count = null) {
+    this.ownNotes.push(Object.freeze({ code, message, column, count }));
+  }
+  /**
+   * Plan the property columns of one table.
+   * @param domain - node or edge
+   * @param table - the table
+   * @param out - receives the plans in declaration order
+   */
+  planColumns(domain, table, out) {
+    const all = [...table];
+    const names = new Set(all.map((column) => column.meta.name));
+    const companionFor = /* @__PURE__ */ new Map();
+    const companions = /* @__PURE__ */ new Set();
+    for (const column of all) {
+      const target = column.meta.extra.for;
+      if (column.dtype === "string" && typeof target === "string" && names.has(target)) {
+        companionFor.set(target, column);
+        companions.add(column);
+      }
+    }
+    for (const column of all) {
+      const { meta } = column;
+      const { role } = meta;
+      if (companions.has(column) || role !== null && SKIPPED_ROLES.has(role)) {
+        continue;
+      }
+      if (domain === "node" && (isStoredId(meta) || column === this.idSpace || column === this.labels)) {
+        continue;
+      }
+      if (domain === "edge" && (role === "id" || column === this.kind)) {
+        continue;
+      }
+      out.push(this.planColumn(column, companionFor.get(meta.name) ?? null));
+    }
+  }
+  /**
+   * Plan one property column: its header type, cell kind and notes.
+   * @param column - the column
+   * @param companion - its text companion, or null
+   * @returns the plan
+   */
+  planColumn(column, companion) {
+    const { meta } = column;
+    const declared = meta.origin?.type ?? null;
+    const mapped = declared === null ? null : mapDeclaredType(NEO4J, declared, "f64");
+    const label = `${meta.domain} column "${meta.name}"`;
+    if (meta.dtype === "list") {
+      const itemDtype = meta.itemDtype ?? "string";
+      const compatible2 = mapped !== null && mapped.list && mapped.itemDtype === itemDtype && mapped.kind !== "long";
+      let scalar2 = compatible2 ? { type: declaredScalar(declared), kind: kindOf(mapped), temporal: mapped.temporal } : defaultScalar(itemDtype);
+      if (mapped !== null && mapped.list && mapped.kind === "long" && itemDtype === "f64") {
+        scalar2 = this.integralOrDouble(column, declaredScalar(declared), label);
+      }
+      const itemComponents = meta.itemComponents ?? 1;
+      if (itemComponents > 1) {
+        this.note(
+          LOSS.COMPONENTS,
+          `${label} holds items of ${itemComponents} components; they are flattened into one array`,
+          meta.name,
+          column.length - column.nullCount
+        );
+      }
+      this.checkArrayItems(column, scalar2, label);
+      return {
+        column,
+        header: formatHeaderField(meta.name, `${scalar2.type}[]`, null),
+        scalar: scalar2,
+        list: true,
+        companion
+      };
+    }
+    let scalar;
+    const compatible = mapped !== null && !mapped.list && mapped.dtype === meta.dtype;
+    if (compatible && mapped.kind === "long") {
+      scalar = this.integralOrDouble(column, declared, label);
+    } else if (compatible) {
+      scalar = { type: declared, kind: kindOf(mapped), temporal: mapped.temporal };
+    } else {
+      scalar = defaultScalar(meta.dtype);
+    }
+    const visual = meta.role === "position" || meta.role !== null && isVizRole(meta.role);
+    if (visual && meta.dtype === "json" && scalar.kind !== "point") {
+      this.note(
+        LOSS.JSON,
+        `${label} holds nested values; the format has no nested values`,
+        meta.name,
+        column.length - column.nullCount
+      );
+    } else if (visual && meta.dtype !== "json" && !NEO4J_CAPABILITIES.dtypes.includes(meta.dtype)) {
+      this.note(
+        LOSS.DTYPE,
+        `${label} is ${meta.dtype}; the format cannot keep that dtype`,
+        meta.name,
+        column.length - column.nullCount
+      );
+    }
+    if (meta.components > 1) {
+      if (visual) {
+        this.note(
+          LOSS.COMPONENTS,
+          `${label} has ${meta.components} components; the format has no strides`,
+          meta.name,
+          column.length - column.nullCount
+        );
+      }
+      return {
+        column,
+        header: formatHeaderField(meta.name, `${scalar.type}[]`, null),
+        scalar,
+        list: true,
+        companion
+      };
+    }
+    const untyped = declared === null && meta.origin?.format === NEO4J && meta.dtype === "string";
+    const header = untyped ? meta.name : formatHeaderField(meta.name, scalar.type, null);
+    return { column, header, scalar, list: false, companion };
+  }
+  /**
+   * The plan of an f64 column declared with an integer type: kept when every set value is
+   * integral, written as double (with a note) otherwise.
+   * @param column - the column
+   * @param declared - the declared type text
+   * @param label - the column label for messages
+   * @returns the scalar plan
+   */
+  integralOrDouble(column, declared, label) {
+    let integral = true;
+    if (column.dtype === "f64") {
+      for (let r = 0; r < column.length && integral; r++) {
+        if (column.isSet(r) && !Number.isInteger(column.data[r])) {
+          integral = false;
+        }
+      }
+    } else if (column.dtype === "list" && column.child.dtype === "f64") {
+      const { data } = column.child;
+      for (let i = 0; i < data.length && integral; i++) {
+        if (!Number.isInteger(data[i])) {
+          integral = false;
+        }
+      }
+    }
+    if (integral) {
+      return { type: declared, kind: "integer", temporal: null };
+    }
+    this.note(
+      DECLARED_TYPE_CHANGED_LOSS,
+      `${label} is declared ${declared} but holds non-integral values; written as double`,
+      column.meta.name,
+      null
+    );
+    return { type: "double", kind: "double", temporal: null };
+  }
+  /**
+   * Count the rows of a list column with an item containing the array delimiter.
+   * @param column - the list column
+   * @param scalar - the item plan
+   * @param label - the column label
+   */
+  checkArrayItems(column, scalar, label) {
+    if (column.dtype !== "list" || scalar.kind !== "string" && scalar.kind !== "json" && scalar.kind !== "point") {
+      return;
+    }
+    const { arrayDelimiter } = this.options;
+    let rows = 0;
+    for (let r = 0; r < column.length; r++) {
+      if (!column.isSet(r)) {
+        continue;
+      }
+      for (const item of column.sliceOf(r)) {
+        if (formatScalar(item, scalar, null).includes(arrayDelimiter)) {
+          rows++;
+          break;
+        }
+      }
+    }
+    if (rows > 0) {
+      this.note(
+        ARRAY_DELIMITER_LOSS,
+        `${label}: ${rows} row(s) hold an item containing the array delimiter "${arrayDelimiter}", which Neo4j cannot escape`,
+        column.meta.name,
+        rows
+      );
+    }
+  }
+  /**
+   * The explicit weights (design section 3.7), and the weight-column name check.
+   * @returns the weights, or null when no weights are written
+   */
+  planWeightSource() {
+    const { snapshot } = this;
+    const name = this.options.weightColumn;
+    if (name === null) {
+      return null;
+    }
+    const weights = explicitWeights(snapshot);
+    const taken = this.edgeColumns.find((plan2) => plan2.column.meta.name === name);
+    if (taken !== void 0 && weights.weighted) {
+      this.note(
+        WEIGHT_COLUMN_TAKEN_LOSS,
+        `edge column "${name}" already exists; explicit weights cannot be written under weightColumn "${name}"`,
+        name,
+        null
+      );
+      if (this.fatalEdges === null) {
+        this.fatalEdges = new GraphFormatError(
+          "E_COLUMN_EXISTS",
+          `edge column "${name}" already exists; choose another weightColumn`,
+          { column: name, domain: "edge" }
+        );
+      }
+    } else if (taken !== void 0 && name === DEFAULT_WEIGHT_COLUMN) {
+      this.note(
+        LOSS.WEIGHT_KEY_CLASH,
+        `edge column "${name}" is written under the property the importer reads THE weight from (weightFrom "${name}"); it reads back as the weight, not as a column`,
+        name,
+        taken.column.length - taken.column.nullCount
+      );
+    }
+    return weights.weighted ? weights : null;
+  }
+  /** Check the node ids' text forms: type changes under the canonical rule and collisions. */
+  checkIds() {
+    const { ids } = this.snapshot;
+    let typeChanges = 0;
+    let collisions = 0;
+    switch (ids.kind) {
+      case "identity":
+      case "dense":
+        break;
+      case "numeric":
+        for (let i = 0; i < ids.size; i++) {
+          if (!Number.isSafeInteger(ids.idOf(i))) {
+            typeChanges++;
+          }
+        }
+        break;
+      case "string":
+        for (let i = 0; i < ids.size; i++) {
+          if (isCanonicalIntegerText(String(ids.idOf(i)))) {
+            typeChanges++;
+          }
+        }
+        break;
+      case "mixed": {
+        const seen = /* @__PURE__ */ new Set();
+        for (let i = 0; i < ids.size; i++) {
+          const id = ids.idOf(i);
+          const text = String(id);
+          if (typeof id === "number" ? !Number.isSafeInteger(id) : isCanonicalIntegerText(text)) {
+            typeChanges++;
+          }
+          if (seen.has(text)) {
+            collisions++;
+          } else {
+            seen.add(text);
+          }
+        }
+        break;
+      }
+      default: {
+        const name = ids.kind;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown id map kind ${name}`, { kind: name });
+      }
+    }
+    if (typeChanges > 0) {
+      this.note(
+        ID_TEXT_TYPE_LOSS,
+        `${typeChanges} node id(s) re-import as another type under the canonical id rule (a string of canonical integer text, or a non-integer number)`,
+        null,
+        typeChanges
+      );
+    }
+    if (collisions > 0) {
+      this.note(
+        ID_TEXT_COLLISION_LOSS,
+        `${collisions} node id(s) share their text with another id (a number and a string); export() will throw`,
+        null,
+        collisions
+      );
+      this.fatalAll = new GraphFormatError(
+        "E_INVALID_ID",
+        `${collisions} node id(s) share their text with another id; Neo4j ids are text`,
+        { reason: "text collision", count: collisions }
+      );
+    }
+  }
+  /** Check that the idColumn option does not name an existing node property. */
+  checkIdColumn() {
+    const name = this.options.idColumn;
+    if (name === null) {
+      return;
+    }
+    const taken = this.nodeColumns.some((plan2) => plan2.column.meta.name === name) || this.idColumns.some((column) => column.meta.name === name);
+    if (!taken) {
+      return;
+    }
+    this.note(
+      ID_COLUMN_TAKEN_LOSS,
+      `node column "${name}" already exists; the :ID column cannot be named idColumn "${name}"`,
+      name,
+      null
+    );
+    if (this.fatalNodes === null) {
+      this.fatalNodes = new GraphFormatError(
+        "E_COLUMN_EXISTS",
+        `node column "${name}" already exists; choose another idColumn`,
+        { column: name, domain: "node" }
+      );
+    }
+  }
+  /** Count the nodes with more than one stored-id column set. */
+  checkStoredIds() {
+    if (this.idColumns.length < 2) {
+      return;
+    }
+    let count = 0;
+    for (let i = 0; i < this.snapshot.nodeCount; i++) {
+      let set = 0;
+      for (const column of this.idColumns) {
+        if (column.isSet(i)) {
+          set++;
+        }
+      }
+      if (set > 1) {
+        count++;
+      }
+    }
+    if (count > 0) {
+      this.note(
+        MULTIPLE_ID_PROPERTIES_LOSS,
+        `${count} node(s) have more than one stored-id column set; only the first in declaration order is written`,
+        null,
+        count
+      );
+    }
+  }
+  /**
+   * Whether a json column is written as Neo4j points (so the generic nested-value note does not apply).
+   * @param name - the column name
+   * @returns true when its plan writes point literals
+   */
+  writtenAsPoint(name) {
+    for (const plan2 of [...this.nodeColumns, ...this.edgeColumns]) {
+      if (plan2.column.meta.name === name && plan2.scalar.kind === "point") {
+        return true;
+      }
+    }
+    return false;
+  }
+  /** Drop the notes about the part that is not written. */
+  filterNotesByPart() {
+    const { part } = this.options;
+    if (part === "all") {
+      return;
+    }
+    const { snapshot } = this;
+    const keep = this.notes.filter((n) => {
+      if (part === "nodes") {
+        if (EDGE_NOTE_CODES.has(n.code)) {
+          return false;
+        }
+        return n.column === null || !snapshot.edges.has(n.column) || snapshot.nodes.has(n.column);
+      }
+      if (NODE_NOTE_CODES.has(n.code)) {
+        return false;
+      }
+      return n.column === null || !snapshot.nodes.has(n.column) || snapshot.edges.has(n.column);
+    });
+    this.notes.length = 0;
+    this.notes.push(...keep);
+  }
+  /**
+   * The error export() throws for the requested part, or null when the export can proceed.
+   * @returns the error
+   */
+  get fatal() {
+    if (this.fatalAll !== null) {
+      return this.fatalAll;
+    }
+    const { part } = this.options;
+    if (part !== "relationships" && this.fatalNodes !== null) {
+      return this.fatalNodes;
+    }
+    return part === "nodes" ? null : this.fatalEdges;
+  }
+  /**
+   * The id space of a node.
+   * @param index - the node index
+   * @returns the space name, or null
+   */
+  spaceOf(index) {
+    const { idSpace } = this;
+    if (idSpace === null || !idSpace.isSet(index)) {
+      return null;
+    }
+    const value = idSpace.value(index);
+    return typeof value === "string" ? value : String(value);
+  }
+  /**
+   * The stored-id column of a node: the first one set in declaration order.
+   * @param index - the node index
+   * @returns the column, or null
+   */
+  storedIdOf(index) {
+    for (const column of this.idColumns) {
+      if (column.isSet(index)) {
+        return column;
+      }
+    }
+    return null;
+  }
+  /**
+   * The node sections, then the relationship sections, as CSV lines.
+   * @yields one line at a time (with its line break)
+   * @returns nothing
+   */
+  *lines() {
+    if (this.fatal !== null) {
+      throw this.fatal;
+    }
+    const { part } = this.options;
+    if (part !== "relationships") {
+      yield* this.nodeLines();
+    }
+    if (part !== "nodes") {
+      yield* this.relationshipLines();
+    }
+  }
+  /**
+   * The node sections.
+   * @yields one line at a time
+   * @returns nothing
+   */
+  *nodeLines() {
+    const { snapshot, labels, nodeColumns } = this;
+    const { ids } = snapshot;
+    const { delimiter } = this.options.syntax;
+    const propertyHeaders = nodeColumns.map((plan2) => plan2.header).join(delimiter);
+    let sections = 0;
+    let sectionSpace = null;
+    let sectionIdName = null;
+    const cells = [];
+    for (let i = 0; i < snapshot.nodeCount; i++) {
+      const space = this.spaceOf(i);
+      const stored = this.storedIdOf(i);
+      const idName = stored === null ? this.options.idColumn ?? "" : stored.meta.name;
+      if (sections === 0 || space !== sectionSpace || idName !== sectionIdName) {
+        sections++;
+        sectionSpace = space;
+        sectionIdName = idName;
+        const header = [formatHeaderField(idName, ID_TYPE, space)];
+        if (labels !== null) {
+          header.push(":LABEL");
+        }
+        if (propertyHeaders.length > 0) {
+          header.push(propertyHeaders);
+        }
+        yield `${header.join(delimiter)}
+`;
+      }
+      cells.length = 0;
+      cells.push(this.cell(idText(ids.idOf(i))));
+      if (labels !== null) {
+        cells.push(this.cell(this.labelsText(i)));
+      }
+      for (const plan2 of nodeColumns) {
+        cells.push(this.cell(this.valueText(plan2, i)));
+      }
+      yield `${cells.join(delimiter)}
+`;
+    }
+    if (sections === 0) {
+      const header = [formatHeaderField(this.options.idColumn ?? "", ID_TYPE, null)];
+      if (labels !== null) {
+        header.push(":LABEL");
+      }
+      if (propertyHeaders.length > 0) {
+        header.push(propertyHeaders);
+      }
+      yield `${header.join(delimiter)}
+`;
+    }
+  }
+  /**
+   * The relationship sections.
+   * @yields one line at a time
+   * @returns nothing
+   */
+  *relationshipLines() {
+    const { snapshot, kind, weights, edgeColumns, folding } = this;
+    const { ids } = snapshot;
+    const { delimiter } = this.options.syntax;
+    const list = snapshot.edgeList();
+    const propertyHeaders = edgeColumns.map((plan2) => plan2.header).join(delimiter);
+    const weightHeader = weights === null ? null : formatHeaderField(this.options.weightColumn ?? "weight", "double", null);
+    let sections = 0;
+    let sectionStart = null;
+    let sectionEnd = null;
+    const cells = [];
+    const headerOf = (startSpace, endSpace) => {
+      const header = [formatHeaderField("", "START_ID", startSpace), formatHeaderField("", "END_ID", endSpace)];
+      if (kind !== null) {
+        header.push(":TYPE");
+      }
+      if (weightHeader !== null) {
+        header.push(weightHeader);
+      }
+      if (propertyHeaders.length > 0) {
+        header.push(propertyHeaders);
+      }
+      return `${header.join(delimiter)}
+`;
+    };
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+      if (folding.folded(e)) {
+        continue;
+      }
+      const u = list.src[e];
+      const v = list.dst[e];
+      const startSpace = this.spaceOf(u);
+      const endSpace = this.spaceOf(v);
+      if (sections === 0 || startSpace !== sectionStart || endSpace !== sectionEnd) {
+        sections++;
+        sectionStart = startSpace;
+        sectionEnd = endSpace;
+        yield headerOf(startSpace, endSpace);
+      }
+      cells.length = 0;
+      cells.push(this.cell(idText(ids.idOf(u))), this.cell(idText(ids.idOf(v))));
+      if (kind !== null) {
+        cells.push(this.cell(kind.isSet(e) ? textOf(kind, e) : null));
+      }
+      if (weights !== null) {
+        cells.push(this.cell(weights.text(e)));
+      }
+      for (const plan2 of edgeColumns) {
+        cells.push(this.cell(this.valueText(plan2, e)));
+      }
+      yield `${cells.join(delimiter)}
+`;
+    }
+    if (sections === 0) {
+      yield headerOf(null, null);
+    }
+  }
+  /**
+   * A CSV cell: empty for an unset value, a quoted empty string for a set empty string, the
+   * quoted text otherwise.
+   * @param text - the value text, or null for unset
+   * @returns the cell as written
+   */
+  cell(text) {
+    if (text === null) {
+      return "";
+    }
+    const { quote } = this.options.syntax;
+    if (text.length === 0) {
+      return quote + quote;
+    }
+    return quoteCsvCell(text, this.options.syntax.delimiter);
+  }
+  /**
+   * The `:LABEL` cell of a node.
+   * @param index - the node index
+   * @returns the labels joined by the array delimiter, or null when unset
+   */
+  labelsText(index) {
+    const { labels } = this;
+    if (labels === null || !labels.isSet(index)) {
+      return null;
+    }
+    if (labels.dtype === "list") {
+      return labels.sliceOf(index).map((item) => String(item)).join(this.options.arrayDelimiter);
+    }
+    return textOf(labels, index);
+  }
+  /**
+   * The text of one property cell.
+   * @param plan - the column plan
+   * @param row - the row
+   * @returns the text, or null when unset
+   */
+  valueText(plan2, row) {
+    const { column, scalar, companion } = plan2;
+    if (!column.isSet(row)) {
+      return null;
+    }
+    if (plan2.list) {
+      const items = column.dtype === "list" ? column.sliceOf(row) : column.value(row);
+      const texts = [];
+      for (const item of Array.from(items)) {
+        if (Array.isArray(item) || ArrayBuffer.isView(item)) {
+          for (const component of Array.from(item)) {
+            texts.push(formatScalar(component, scalar, null));
+          }
+        } else {
+          texts.push(formatScalar(item, scalar, null));
+        }
+      }
+      return texts.join(this.options.arrayDelimiter);
+    }
+    const text = companion !== null && companion.isSet(row) ? textOf(companion, row) : null;
+    return formatScalar(column.dtype === "json" ? column.values[row] : column.value(row), scalar, text);
+  }
+}
+function isStoredId(meta) {
+  return meta.role === null && meta.dtype === "string" && meta.origin !== null && meta.origin.format === NEO4J && meta.origin.type === ID_TYPE;
+}
+function isVizRole(role) {
+  return role === "color" || role === "size" || role === "shape" || role === "thickness";
+}
+function declaredScalar(declared) {
+  const trimmed = declared.trim();
+  return trimmed.endsWith("[]") ? trimmed.slice(0, -2) : trimmed;
+}
+function kindOf(spec) {
+  switch (spec.kind) {
+    case "boolean":
+      return "boolean";
+    case "integer":
+    case "long":
+      return "integer";
+    case "float":
+      return "float";
+    case "double":
+      return "double";
+    case "string":
+    case "duration":
+      return "string";
+    case "temporal":
+      return "temporal";
+    case "point":
+      return "point";
+    case "json":
+      return "json";
+    default: {
+      const name = spec.kind;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown value kind ${name}`, { kind: name });
+    }
+  }
+}
+function defaultScalar(dtype) {
+  switch (dtype) {
+    case "f32":
+      return { type: "float", kind: "float", temporal: null };
+    case "f64":
+      return { type: "double", kind: "double", temporal: null };
+    case "i32":
+    case "u8":
+      return { type: "int", kind: "integer", temporal: null };
+    case "u32":
+      return { type: "long", kind: "integer", temporal: null };
+    case "bool":
+      return { type: "boolean", kind: "boolean", temporal: null };
+    case "dict":
+    case "string":
+      return { type: "string", kind: "string", temporal: null };
+    case "json":
+      return { type: "string", kind: "json", temporal: null };
+    case "list":
+      return { type: "string", kind: "json", temporal: null };
+    default: {
+      const name = dtype;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown dtype ${name}`, { dtype: name });
+    }
+  }
+}
+function formatScalar(value, scalar, text) {
+  switch (scalar.kind) {
+    case "integer":
+      return typeof value === "number" ? formatInteger(value) : String(value);
+    case "float":
+      return typeof value === "number" ? formatF32(value) : String(value);
+    case "double":
+      return typeof value === "number" ? formatF64(value) : String(value);
+    case "boolean":
+      return value === true ? "true" : "false";
+    case "string":
+      return typeof value === "string" ? value : String(value);
+    case "temporal":
+      if (text !== null) {
+        return text;
+      }
+      return typeof value === "number" && scalar.temporal !== null ? formatTemporal(value, scalar.temporal) : String(value);
+    case "point":
+      return formatPoint(value);
+    case "json":
+      return JSON.stringify(value) ?? "";
+    default: {
+      const name = scalar.kind;
+      throw new GraphFormatError("E_UNSUPPORTED", `unknown cell kind ${name}`, { kind: name });
+    }
+  }
+}
+function formatPoint(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return JSON.stringify(value) ?? "";
+  }
+  const parts = [];
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item === "number") {
+      parts.push(`${key}:${formatF64(item)}`);
+    } else if (typeof item === "string") {
+      parts.push(`${key}:'${item.replace(/'/g, "")}'`);
+    } else {
+      return JSON.stringify(value) ?? "";
+    }
+  }
+  return `{${parts.join(", ")}}`;
+}
+function idText(id) {
+  if (typeof id === "string") {
+    return id;
+  }
+  return Number.isInteger(id) ? formatInteger(id) : String(id);
+}
+function textOf(column, row) {
+  switch (column.dtype) {
+    case "string":
+      return column.valueAt(row);
+    case "dict":
+      return String(column.value(row));
+    case "list":
+      return column.sliceOf(row).map(String).join(",");
+    case "json":
+      return JSON.stringify(column.values[row]) ?? "";
+    case "bool":
+      return column.value(row) === true ? "true" : "false";
+    default: {
+      const value = column.value(row);
+      return typeof value === "number" ? String(value) : Array.from(value).join(",");
+    }
+  }
+}
+const neo4jExporter = Object.freeze({
+  format: NEO4J,
+  capabilities: NEO4J_CAPABILITIES,
+  /**
+   * Pre-flight: what export() would lose.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the notes
+   */
+  check(snapshot, options) {
+    return Object.freeze([...plan(snapshot, options).notes]);
+  },
+  /**
+   * Write the snapshot as UTF-8 chunks.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the chunks
+   */
+  export(snapshot, options) {
+    return encodeChunks(plan(snapshot, options).lines());
+  },
+  /**
+   * Write the snapshot as one string.
+   * @param snapshot - the snapshot
+   * @param options - format-specific and common options
+   * @returns the document
+   */
+  exportToString(snapshot, options) {
+    return joinText(plan(snapshot, options).lines());
+  }
+});
+function plan(snapshot, options) {
+  return new ExportPlan(snapshot, resolveNeo4jExportOptions(options), resolveExportOptions(options));
+}
+const NEO4J_ISSUE = Object.freeze({
+  /** The input holds invalid UTF-8 (fatal). */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /** An unterminated quoted field (fatal). */
+  CSV_UNCLOSED_QUOTE: UNCLOSED_QUOTE_CODE,
+  /** Text after a closing quote (fatal). */
+  CSV_QUOTE: BAD_QUOTE_CODE,
+  /** No header or a malformed header (fatal). */
+  HEADER: HEADER_CODE,
+  /** A row with a different field count than the header. */
+  COLUMN_COUNT: COLUMN_COUNT_CODE,
+  /** A node row without an id. */
+  MISSING_ID: MISSING_ID_CODE,
+  /** A relationship row without a start or end id. */
+  MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
+  /** A node id repeated in one id space (last write wins). */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** A node id declared in two id spaces. */
+  ID_SPACE_COLLISION: ID_SPACE_COLLISION_CODE,
+  /** Two id texts merged into one number under ids "number". */
+  ID_MERGED: ID_MERGED_CODE,
+  /** A header brace option the importer does not apply. */
+  HEADER_OPTION_IGNORED: HEADER_OPTION_CODE,
+  /** A declared type the format does not define (kept as string). */
+  UNKNOWN_ATTR_TYPE: UNKNOWN_ATTR_TYPE_CODE,
+  /** A long value beyond 2^53 rounded. */
+  PRECISION: PRECISION_CODE,
+  /** A column renamed `<name>#<id>` because the name was taken (design section 5.6). */
+  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
+  /** A role the caller's sink already holds. */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** A common option the importer has no use for (nodeIdFrom, defaultDirected, ...). */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /** A builder-policy option the sink does not honour. */
+  SINK_OPTION: SINK_OPTION_CODE
+});
+const NEO4J_LOSS = Object.freeze({
+  /** `:IGNORE` columns skipped on import. */
+  IGNORED_COLUMNS: IGNORED_COLUMNS_LOSS,
+  /** Undirected edges (an undirected snapshot, the folded pairs of a mixed one) written as directed relationships. */
+  UNDIRECTED_AS_DIRECTED: UNDIRECTED_LOSS,
+  /** A mutual pair written as two directed relationships without its mark. */
+  MUTUAL_EXPANDED: MUTUAL_EXPANDED_CODE,
+  /** A role column Neo4j has no slot for (label, ...) written as a plain property. */
+  ROLE_DROPPED: ROLE_DROPPED_CODE,
+  /** A plain `weight` edge column reads back as THE weight (the importer's weightFrom default). */
+  WEIGHT_KEY_CLASH: WEIGHT_KEY_CLASH_CODE,
+  /** A node id whose text re-imports as another type under the canonical rule. */
+  ID_TEXT_TYPE: ID_TEXT_TYPE_LOSS,
+  /** A number and a string id with the same text; export() throws. */
+  ID_TEXT_COLLISION: ID_TEXT_COLLISION_LOSS,
+  /** The weight column name is taken by an edge column; export() throws. */
+  WEIGHT_COLUMN_TAKEN: WEIGHT_COLUMN_TAKEN_LOSS,
+  /** The id column name is taken by a node column; export() throws. */
+  ID_COLUMN_TAKEN: ID_COLUMN_TAKEN_LOSS,
+  /** Several stored-id properties; one becomes the `:ID` column. */
+  MULTIPLE_ID_PROPERTIES: MULTIPLE_ID_PROPERTIES_LOSS,
+  /** An integer-typed column with non-integral values written as double. */
+  DECLARED_TYPE_CHANGED: DECLARED_TYPE_CHANGED_LOSS,
+  /** A list item containing the array delimiter, which Neo4j cannot escape. */
+  ARRAY_DELIMITER: ARRAY_DELIMITER_LOSS
+});
+export {
+  ID_SPACE_COLUMN,
+  LABELS_COLUMN,
+  NEO4J_CAPABILITIES,
+  NEO4J_ISSUE,
+  NEO4J_LOSS,
+  TYPE_COLUMN,
+  neo4jExporter,
+  neo4jImporter
+};
+//# sourceMappingURL=neo4j.js.map