matterviz 0.3.5 → 0.3.6

package/dist/src/lib/isosurface/parse.ts

@@ -0,0 +1,656 @@
+// Parsers for volumetric data file formats (VASP CHGCAR, Gaussian .cube)
+import { COMPRESSION_EXTENSIONS_REGEX, VASP_VOLUMETRIC_REGEX } from '$lib/constants'
+import type { ElementSymbol } from '$lib/element'
+import { ELEM_SYMBOLS } from '$lib/labels'
+import type { Matrix3x3, Vec3 } from '$lib/math'
+import * as math from '$lib/math'
+import type { Site } from '$lib/structure'
+import { wrap_to_unit_cell } from '$lib/structure/pbc'
+import type { ParsedStructure } from '$lib/structure/parse'
+import type { DataRange, VolumetricData, VolumetricFileData } from './types'
+
+// Bohr radius in Angstroms (for Gaussian .cube unit conversion)
+const BOHR_TO_ANGSTROM = 0.529177249
+
+// === Fast number parsing utilities ===
+
+// Parse whitespace-separated numbers directly from a string, starting at `pos`.
+// Writes into a pre-allocated Float64Array and returns { count, end_pos }.
+// Stops at `max_count` numbers, end of string, or when encountering a line
+// starting with a letter (e.g. "augmentation" in CHGCAR).
+function parse_float_block(
+  text: string,
+  pos: number,
+  max_count: number,
+  data: Float64Array,
+  data_offset: number = 0,
+): { count: number; end_pos: number } {
+  let idx = data_offset
+  const target = data_offset + max_count
+  const len = text.length
+
+  while (idx < target && pos < len) {
+    // Skip whitespace
+    let char_code = text.charCodeAt(pos)
+    while (pos < len && char_code <= 32) {
+      // After a newline, check if the next non-space char is a letter (section break)
+      if (char_code === 10 || char_code === 13) {
+        let peek = pos + 1
+        // Skip \r\n combo
+        if (char_code === 13 && peek < len && text.charCodeAt(peek) === 10) peek++
+        // Skip leading spaces on the new line
+        while (peek < len && text.charCodeAt(peek) === 32) peek++
+        if (peek < len) {
+          const next_char = text.charCodeAt(peek)
+          // Letter a-z or A-Z signals a non-numeric line (e.g. "augmentation")
+          if ((next_char >= 65 && next_char <= 90) || (next_char >= 97 && next_char <= 122)) {
+            return { count: idx - data_offset, end_pos: pos }
+          }
+        }
+      }
+      char_code = text.charCodeAt(++pos)
+    }
+    if (pos >= len) break
+
+    // Find end of token
+    const start = pos
+    while (pos < len && text.charCodeAt(pos) > 32) pos++
+
+    // Parse number using unary + (handles scientific notation)
+    const num = +text.substring(start, pos)
+    if (!Number.isNaN(num)) {
+      data[idx++] = num
+    }
+  }
+  return { count: idx - data_offset, end_pos: pos }
+}
+
+// Find the character offset for line N in a string (0-indexed).
+// Much faster than splitting the entire string into lines.
+function find_line_offset(text: string, target_line: number): number {
+  let line = 0
+  let pos = 0
+  while (line < target_line && pos < text.length) {
+    if (text.charCodeAt(pos) === 10) line++
+    pos++
+  }
+  return pos
+}
+
+// Read a single line from text at the given offset, returning the line and next offset
+function read_line(text: string, pos: number): { line: string; next: number } {
+  let end = pos
+  while (end < text.length && text.charCodeAt(end) !== 10 && text.charCodeAt(end) !== 13) end++
+  const line = text.substring(pos, end)
+  let next = end
+  if (next < text.length && text.charCodeAt(next) === 13) next++ // skip \r
+  if (next < text.length && text.charCodeAt(next) === 10) next++ // skip \n
+  return { line, next }
+}
+
+// Read N lines starting from pos, returning array of trimmed lines and final offset
+function read_lines(
+  text: string,
+  pos: number,
+  count: number,
+): { lines: string[]; next: number } {
+  const result: string[] = []
+  for (let idx = 0; idx < count; idx++) {
+    const { line, next } = read_line(text, pos)
+    result.push(line.trim())
+    pos = next
+  }
+  return { lines: result, next: pos }
+}
+
+// Build 3D grid directly from Float64Array, computing data_range in the same pass.
+type BuildGridOptions = {
+  data: Float64Array
+  nx: number
+  ny: number
+  nz: number
+  divisor?: number
+  data_order?: `x_fastest` | `z_fastest`
+}
+
+function build_grid({
+  data,
+  nx,
+  ny,
+  nz,
+  divisor = 1,
+  data_order = `z_fastest`,
+}: BuildGridOptions): { grid: number[][][]; data_range: DataRange } {
+  const grid: number[][][] = Array(nx)
+  let [min_val, max_val, sum] = [Infinity, -Infinity, 0]
+  const total = nx * ny * nz
+  const data_len = Math.min(data.length, total)
+
+  if (data_len === 0) {
+    // Empty data: return zeroed grid with neutral data_range
+    for (let ix = 0; ix < nx; ix++) {
+      const plane: number[][] = Array(ny)
+      for (let iy = 0; iy < ny; iy++) plane[iy] = Array(nz).fill(0)
+      grid[ix] = plane
+    }
+    return { grid, data_range: { min: 0, max: 0, abs_max: 0, mean: 0 } }
+  }
+
+  if (data_order === `z_fastest`) {
+    // .cube convention: z varies fastest, then y, then x.
+    const ny_nz = ny * nz
+    for (let ix = 0; ix < nx; ix++) {
+      const plane: number[][] = Array(ny)
+      for (let iy = 0; iy < ny; iy++) {
+        const row = Array(nz).fill(0)
+        const base = ix * ny_nz + iy * nz
+        const row_end = Math.min(base + nz, data_len)
+        for (let flat_idx = base; flat_idx < row_end; flat_idx++) {
+          const val = data[flat_idx] / divisor
+          row[flat_idx - base] = val
+          if (val < min_val) min_val = val
+          if (val > max_val) max_val = val
+          sum += val
+        }
+        plane[iy] = row
+      }
+      grid[ix] = plane
+    }
+  } else {
+    // VASP CHGCAR/ELFCAR/LOCPOT convention: x varies fastest, then y, then z.
+    for (let ix = 0; ix < nx; ix++) {
+      const plane: number[][] = Array(ny)
+      for (let iy = 0; iy < ny; iy++) plane[iy] = Array(nz).fill(0)
+      grid[ix] = plane
+    }
+    let [flat_idx, data_exhausted] = [0, false]
+    for (let iz = 0; iz < nz; iz++) {
+      for (let iy = 0; iy < ny; iy++) {
+        for (let ix = 0; ix < nx; ix++) {
+          if (flat_idx >= data_len) {
+            data_exhausted = true
+            break
+          }
+          const val = data[flat_idx] / divisor
+          grid[ix][iy][iz] = val
+          if (val < min_val) min_val = val
+          if (val > max_val) max_val = val
+          sum += val
+          flat_idx++
+        }
+        if (data_exhausted) break
+      }
+      if (data_exhausted) break
+    }
+  }
+
+  const abs_max = Math.max(Math.abs(min_val), Math.abs(max_val))
+  const data_range = { min: min_val, max: max_val, abs_max, mean: sum / data_len }
+  return { grid, data_range }
+}
+
+// === CHGCAR Parser ===
+
+// Parse VASP CHGCAR/AECCAR/ELFCAR/LOCPOT/PARCHG file format.
+// CHGCAR/PARCHG consists of a POSCAR header followed by volumetric data on a 3D grid.
+// Spin-polarized files contain two data blocks (total charge + magnetization).
+export function parse_chgcar(content: string): VolumetricFileData | null {
+  // Strip leading whitespace
+  let pos = 0
+  while (pos < content.length && content.charCodeAt(pos) <= 32) pos++
+
+  // Parse header line by line (only the first ~20 lines, not the whole file)
+  // Line 0: comment
+  let cur = read_line(content, pos)
+  pos = cur.next
+
+  // Line 1: scale factor
+  cur = read_line(content, pos)
+  const scale_factor = parseFloat(cur.line)
+  if (isNaN(scale_factor)) {
+    console.error(`Invalid scaling factor in CHGCAR`)
+    return null
+  }
+  pos = cur.next
+
+  // Lines 2-4: lattice vectors
+  const parse_vector = (line: string): Vec3 =>
+    math.scale(line.trim().split(/\s+/).slice(0, 3).map(Number) as Vec3, scale_factor)
+
+  const lat_lines = read_lines(content, pos, 3)
+  const lattice: Matrix3x3 = [
+    parse_vector(lat_lines.lines[0]),
+    parse_vector(lat_lines.lines[1]),
+    parse_vector(lat_lines.lines[2]),
+  ]
+  pos = lat_lines.next
+
+  // Lines 5+: element symbols and atom counts
+  let element_symbols: string[] = []
+  let atom_counts: number[] = []
+
+  cur = read_line(content, pos)
+  if (pos >= content.length) {
+    console.error(`CHGCAR: file ends before element/count lines`)
+    return null
+  }
+
+  // Detect VASP 5+ format (has element symbols before counts)
+  const first_token = cur.line.trim().split(/\s+/)[0]
+  const has_element_symbols = isNaN(parseInt(first_token))
+
+  if (has_element_symbols) {
+    element_symbols = cur.line.trim().split(/\s+/)
+    pos = cur.next
+    cur = read_line(content, pos)
+    if (pos >= content.length) {
+      console.error(`CHGCAR: file ends before atom counts line`)
+      return null
+    }
+    atom_counts = cur.line.trim().split(/\s+/).map(Number)
+    pos = cur.next
+  } else {
+    atom_counts = cur.line.trim().split(/\s+/).map(Number)
+    const fallback_elements = [`H`, `He`, `Li`, `Be`, `B`, `C`, `N`, `O`, `F`, `Ne`]
+    element_symbols = atom_counts.map(
+      (_count, idx) => fallback_elements[idx % fallback_elements.length],
+    )
+    pos = cur.next
+  }
+
+  if (pos >= content.length) {
+    console.error(`CHGCAR: file ends before coordinate mode line`)
+    return null
+  }
+
+  // Check for selective dynamics line
+  cur = read_line(content, pos)
+  if (cur.line.trim().toUpperCase().startsWith(`S`)) {
+    pos = cur.next // skip selective dynamics line
+    cur = read_line(content, pos)
+  }
+
+  if (pos >= content.length) {
+    console.error(`CHGCAR: file ends before coordinate mode line`)
+    return null
+  }
+
+  // Coordinate mode line
+  const is_direct = cur.line.trim().toUpperCase().startsWith(`D`)
+  pos = cur.next
+
+  // Parse atomic positions
+  let cart_to_frac: (v: Vec3) => Vec3
+  let frac_to_cart: (v: Vec3) => Vec3
+  try {
+    ;({ cart_to_frac, frac_to_cart } = math.create_lattice_converters(lattice))
+  } catch {
+    console.error(`CHGCAR: lattice matrix is singular; cannot convert coordinates`)
+    return null
+  }
+  const sites: Site[] = []
+  let atom_idx = 0
+
+  for (let elem_idx = 0; elem_idx < element_symbols.length; elem_idx++) {
+    const symbol = element_symbols[elem_idx].split(/[_/]/)[0]
+    const element = (
+      ELEM_SYMBOLS.includes(symbol as ElementSymbol) ? symbol : `H`
+    ) as ElementSymbol
+    const count = atom_counts[elem_idx]
+
+    for (let count_idx = 0; count_idx < count; count_idx++) {
+      if (pos >= content.length) {
+        console.error(`CHGCAR: file ends before all atom coordinates are read`)
+        return null
+      }
+      cur = read_line(content, pos)
+      const coords = cur.line.trim().split(/\s+/).slice(0, 3).map(Number) as Vec3
+      pos = cur.next
+
+      let abc: Vec3
+      let xyz: Vec3
+
+      if (is_direct) {
+        abc = wrap_to_unit_cell(coords)
+        xyz = frac_to_cart(abc)
+      } else {
+        xyz = math.scale(coords, scale_factor)
+        const raw = cart_to_frac(xyz)
+        abc = wrap_to_unit_cell(raw)
+      }
+
+      sites.push({
+        species: [{ element, occu: 1, oxidation_state: 0 }],
+        abc,
+        xyz,
+        label: `${element}${atom_idx + count_idx + 1}`,
+        properties: {},
+      })
+    }
+    atom_idx += count
+  }
+
+  // Build the structure (volumetric files are always periodic)
+  const lattice_params = math.calc_lattice_params(lattice)
+  const structure: ParsedStructure = {
+    sites,
+    lattice: { matrix: lattice, pbc: [true, true, true], ...lattice_params },
+  }
+
+  // Parse volumetric data blocks
+  const volumes: VolumetricData[] = []
+  const volume_labels = [`charge density`, `magnetization density`]
+
+  for (let vol_idx = 0; vol_idx < 2; vol_idx++) {
+    // Skip blank lines
+    while (pos < content.length) {
+      cur = read_line(content, pos)
+      if (cur.line.trim() !== ``) break
+      pos = cur.next
+    }
+
+    if (pos >= content.length) break
+
+    // Parse grid dimensions: NGX NGY NGZ
+    cur = read_line(content, pos)
+    const grid_tokens = cur.line.trim().split(/\s+/).map(Number)
+    if (grid_tokens.length < 3 || grid_tokens.some(isNaN)) break
+
+    const [ngx, ngy, ngz] = grid_tokens
+    pos = cur.next
+
+    // Fast-parse volumetric data directly from the string
+    const total_points = ngx * ngy * ngz
+    const data = new Float64Array(total_points)
+    const { count: parsed_count, end_pos } = parse_float_block(
+      content,
+      pos,
+      total_points,
+      data,
+    )
+    pos = end_pos
+
+    if (parsed_count < total_points) {
+      console.warn(
+        `CHGCAR volume ${vol_idx}: expected ${total_points} values, got ${parsed_count}`,
+      )
+      if (parsed_count === 0) break
+    }
+
+    // CHGCAR stores rho * V_cell, so normalize by dividing by cell volume.
+    // Use Math.abs to guard against negative determinant (left-handed lattice).
+    const cell_volume = Math.abs(lattice_params.volume)
+    const divisor = cell_volume > 1e-30 ? cell_volume : 1
+    const { grid, data_range } = build_grid({
+      data: data.subarray(0, parsed_count),
+      nx: ngx,
+      ny: ngy,
+      nz: ngz,
+      divisor,
+      data_order: `x_fastest`,
+    })
+
+    volumes.push({
+      grid,
+      grid_dims: [ngx, ngy, ngz],
+      lattice,
+      origin: [0, 0, 0],
+      data_range,
+      data_order: `x_fastest`,
+      periodic: true, // VASP grids span [0,1) with N points, wrapping at boundaries
+      label: volume_labels[vol_idx],
+    })
+
+    // Skip augmentation occupancies and any remaining non-numeric lines
+    while (pos < content.length) {
+      cur = read_line(content, pos)
+      const trimmed = cur.line.trim()
+      if (trimmed === `` || /^\d+\s+\d+\s+\d+$/.test(trimmed)) break
+      pos = cur.next
+    }
+  }
+
+  if (volumes.length === 0) {
+    console.error(`No volumetric data found in CHGCAR`)
+    return null
+  }
+
+  return { structure, volumes }
+}
+
+// === Gaussian .cube Parser ===
+
+// Parse Gaussian .cube file format.
+// Contains atomic structure and volumetric data in a single file.
+// Units: if grid dimensions are positive, coordinates are in Bohr; if negative, in Angstrom.
+export function parse_cube(
+  content: string,
+  options: { periodic?: boolean } = {},
+): VolumetricFileData | null {
+  // Quick line count check: need at least 7 lines (2 title + 1 header + 3 voxel + 1 atom)
+  let line_count = 0
+  for (let idx = 0; idx < content.length && line_count < 7; idx++) {
+    if (content.charCodeAt(idx) === 10) line_count++
+  }
+  if (line_count < 6) {
+    console.error(`.cube file too short`)
+    return null
+  }
+
+  // Parse header (first 6 lines + atom lines)
+  let pos = 0
+  const header = read_lines(content, pos, 6)
+  pos = header.next
+
+  // Line 2: n_atoms, origin_x, origin_y, origin_z
+  // (negative n_atoms indicates orbital data with extra header line)
+  const line2 = header.lines[2].split(/\s+/).map(Number)
+  if (line2.length < 4 || line2.some(isNaN)) {
+    console.error(`.cube header line 3 malformed: expected 4 numbers`)
+    return null
+  }
+  const n_atoms = Math.abs(line2[0])
+  const has_orbital_header = line2[0] < 0
+  const raw_origin: Vec3 = [line2[1], line2[2], line2[3]]
+
+  // Lines 3-5: grid dimensions and voxel vectors
+  // Positive N means coordinates in Bohr, negative N means Angstrom
+  const voxel_lines = [
+    header.lines[3].split(/\s+/).map(Number),
+    header.lines[4].split(/\s+/).map(Number),
+    header.lines[5].split(/\s+/).map(Number),
+  ]
+  if (voxel_lines.some((line) => line.length < 4 || line.some(isNaN))) {
+    console.error(`.cube voxel lines malformed: expected 4 numbers per line`)
+    return null
+  }
+
+  const n_grid: Vec3 = [
+    Math.abs(voxel_lines[0][0]),
+    Math.abs(voxel_lines[1][0]),
+    Math.abs(voxel_lines[2][0]),
+  ]
+
+  // Per Gaussian .cube convention, the sign of the first axis N determines units
+  const is_bohr = voxel_lines[0][0] > 0
+  const unit_scale = is_bohr ? BOHR_TO_ANGSTROM : 1.0
+
+  // Voxel vectors (convert to Angstrom if needed)
+  const [voxel_a, voxel_b, voxel_c] = voxel_lines.map((line) =>
+    math.scale(line.slice(1, 4) as Vec3, unit_scale),
+  )
+
+  // Lattice vectors = grid_dim * voxel_vector
+  const lattice: Matrix3x3 = [
+    math.scale(voxel_a, n_grid[0]),
+    math.scale(voxel_b, n_grid[1]),
+    math.scale(voxel_c, n_grid[2]),
+  ]
+
+  const origin = math.scale(raw_origin, unit_scale)
+
+  // Periodicity: use explicit override if provided, else heuristic based on origin.
+  // Molecular .cube files have a non-zero origin (bounding box offset); periodic
+  // systems (QE, CP2K) have origin at (0,0,0). Pass { periodic: true/false } to
+  // override when the heuristic is wrong (e.g. molecule centered at origin).
+  const is_periodic = options.periodic ?? Math.hypot(...origin) < 1e-6
+
+  // Parse atomic positions
+  const sites: Site[] = []
+  let cube_cart_to_frac: (v: Vec3) => Vec3
+  try {
+    cube_cart_to_frac = math.create_cart_to_frac(lattice)
+  } catch {
+    // Non-periodic system (molecule), use identity
+    cube_cart_to_frac = (v: Vec3): Vec3 => [v[0], v[1], v[2]]
+  }
+
+  for (let atom_idx = 0; atom_idx < n_atoms; atom_idx++) {
+    const cur = read_line(content, pos)
+    const atom_line = cur.line.trim().split(/\s+/).map(Number)
+    pos = cur.next
+
+    // Validate: need atomic_number, charge, x, y, z (5 tokens, indices 2-4 finite)
+    if (
+      atom_line.length < 5 ||
+      !isFinite(atom_line[2]) ||
+      !isFinite(atom_line[3]) ||
+      !isFinite(atom_line[4])
+    ) {
+      console.warn(`.cube atom ${atom_idx}: malformed line "${cur.line.trim()}", skipping`)
+      continue
+    }
+
+    // atom_line[1] is the charge (often 0)
+    const raw_xyz = math.scale([atom_line[2], atom_line[3], atom_line[4]] as Vec3, unit_scale)
+
+    // Convert Cartesian to fractional, accounting for origin offset.
+    // Store lattice-frame xyz (shifted) so abc and xyz stay consistent.
+    const xyz = math.subtract(raw_xyz, origin)
+    const abc = cube_cart_to_frac(xyz)
+
+    const element = atomic_number_to_symbol(atom_line[0])
+    sites.push({
+      species: [{ element, occu: 1, oxidation_state: 0 }],
+      abc,
+      xyz,
+      label: `${element}${atom_idx + 1}`,
+      properties: {},
+    })
+  }
+
+  // Build structure
+  const lattice_params = math.calc_lattice_params(lattice)
+  const structure: ParsedStructure = {
+    sites,
+    lattice: {
+      matrix: lattice,
+      pbc: [is_periodic, is_periodic, is_periodic],
+      ...lattice_params,
+    },
+  }
+
+  // Skip orbital header line if present
+  if (has_orbital_header && pos < content.length) {
+    const cur = read_line(content, pos)
+    pos = cur.next
+  }
+
+  // Fast-parse volumetric data directly from the string
+  const total_points = n_grid[0] * n_grid[1] * n_grid[2]
+  const data = new Float64Array(total_points)
+  const { count: parsed_count } = parse_float_block(content, pos, total_points, data)
+
+  if (parsed_count < total_points) {
+    console.warn(`.cube: expected ${total_points} data values, got ${parsed_count}`)
+    if (parsed_count === 0) {
+      console.error(`No volumetric data found in .cube file`)
+      return null
+    }
+  }
+
+  const { grid, data_range } = build_grid({
+    data: data.subarray(0, parsed_count),
+    nx: n_grid[0],
+    ny: n_grid[1],
+    nz: n_grid[2],
+    data_order: `z_fastest`,
+  })
+
+  const volumes: VolumetricData[] = [
+    {
+      grid,
+      grid_dims: n_grid,
+      lattice,
+      origin,
+      data_range,
+      data_order: `z_fastest`,
+      periodic: is_periodic, // periodic systems wrap; molecular .cube files include both endpoints
+      label: `volumetric data`,
+    },
+  ]
+
+  return { structure, volumes }
+}
+
+// Convert atomic number to element symbol using ELEM_SYMBOLS (1-indexed: H=1, He=2, ...)
+function atomic_number_to_symbol(atomic_number: number): ElementSymbol {
+  // ELEM_SYMBOLS is 0-indexed (H at index 0), atomic numbers are 1-indexed
+  const idx = atomic_number - 1
+  return idx >= 0 && idx < ELEM_SYMBOLS.length ? ELEM_SYMBOLS[idx] : `H`
+}
+
+// Auto-detect and parse volumetric file format based on filename and content
+export function parse_volumetric_file(
+  content: string,
+  filename?: string,
+): VolumetricFileData | null {
+  // Strip compression suffixes so "CHGCAR.gz" and "molecule.cube.bz2" match correctly
+  const lower_name = (filename ?? ``).toLowerCase().replace(COMPRESSION_EXTENSIONS_REGEX, ``)
+
+  // Extension-based detection
+  if (lower_name.endsWith(`.cube`)) return parse_cube(content)
+
+  // VASP volumetric file detection by filename
+  if (VASP_VOLUMETRIC_REGEX.test(lower_name)) return parse_chgcar(content)
+
+  // Content-based detection (only parse first few lines, not the whole file)
+  // Find enough lines for detection without splitting the entire string
+  const detection_end = find_line_offset(content, 10)
+  const detection_text = content.substring(0, detection_end)
+  const lines = detection_text.split(/\r?\n/)
+
+  // .cube detection: line 3 has 4 numbers (n_atoms + origin), line 4 has 4 numbers (grid dim + voxel)
+  if (lines.length > 4) {
+    const line2_tokens = lines[2].trim().split(/\s+/)
+    const line3_tokens = lines[3].trim().split(/\s+/)
+    if (
+      line2_tokens.length === 4 &&
+      line3_tokens.length === 4 &&
+      line2_tokens.every((tok) => !isNaN(Number(tok))) &&
+      line3_tokens.every((tok) => !isNaN(Number(tok)))
+    ) {
+      return parse_cube(content)
+    }
+  }
+
+  // CHGCAR detection: requires POSCAR-like header (scale factor on line 2) AND
+  // a grid dimensions line (3 integers) somewhere after the header. This distinguishes
+  // CHGCAR from plain POSCAR/CONTCAR files which share the same header format.
+  if (lines.length > 2 && !isNaN(parseFloat(lines[1].trim()))) {
+    // Scan for grid dimensions line (3 integers) starting from ~line 7
+    let scan_pos = find_line_offset(content, 7)
+    // Only scan a limited window, not the entire file
+    // Scan enough to cover large atom blocks (~100 chars/atom × ~200 atoms max)
+    const scan_end = Math.min(content.length, scan_pos + 25000)
+    while (scan_pos < scan_end) {
+      const { line, next } = read_line(content, scan_pos)
+      if (/^\s*\d+\s+\d+\s+\d+\s*$/.test(line)) {
+        return parse_chgcar(content)
+      }
+      scan_pos = next
+    }
+  }
+
+  return null
+}