// Observe SVG geometry and styles per node in root SVG coordinates.
;(opts) => {
  const wantDiff = !!(opts && opts.wantDiff)
  // Null reads all computed styles.
  const styles = (opts && opts.styles) || null
  const resourceStyles = (opts && opts.resourceStyles) || null
  const reuseOutline = !(opts && opts.reuseOutline === false)
  const r = (v) => Math.round(v * 1e4) / 1e4

  const root = document.querySelector('svg')
  if (!root) return { error: 'no <svg> in the document' }
  const baseline = window.__baseline
  if (wantDiff && !baseline) return { needsBaseline: true }

  // Remove page layout from the measured coordinates.
  const rootCTM = root.getScreenCTM()
  const inv = rootCTM ? rootCTM.inverse() : null
  const OUTLINE_SAMPLES = 32

  // Definitions are not painted, even though <defs> is an SVGGraphicsElement.
  const paints = (el) => el instanceof SVGGraphicsElement && el.tagName.toLowerCase() !== 'defs'

  const styleOf = (el, properties = styles) => {
    const cs = getComputedStyle(el)
    const out = {}
    if (properties) {
      for (const k of properties) out[k] = cs.getPropertyValue(k)
      return out
    }
    for (let i = 0; i < cs.length; i++) {
      const k = cs[i]
      out[k] = cs.getPropertyValue(k)
    }
    return out
  }

  // CSS geometry overrides SVG presentation attributes.
  const OUTLINE_INPUTS = {
    path: [['d'], []],
    circle: [['cx', 'cy', 'r'], []],
    ellipse: [['cx', 'cy', 'rx', 'ry'], []],
    rect: [['x', 'y', 'width', 'height', 'rx', 'ry'], []],
    line: [[], ['x1', 'y1', 'x2', 'y2']],
    polyline: [[], ['points']],
    polygon: [[], ['points']],
  }

  if (!window.__outline) window.__outline = {}
  const outlineCache = window.__outline

  const outlineSignature = (el, tag) => {
    const inputs = OUTLINE_INPUTS[tag]
    if (!inputs) return null
    const cs = getComputedStyle(el)
    let sig = tag
    for (const k of inputs[0]) sig += '|' + cs.getPropertyValue(k)
    for (const k of inputs[1]) sig += '|' + (el.getAttribute(k) || '')
    return sig
  }

  const sampleOutline = (el, length, ends) => {
    if (!ends) return null
    if (length <= 0) return [ends[0]]
    const closed = Math.hypot(ends[0][0] - ends[1][0], ends[0][1] - ends[1][1]) <= 1e-4
    const divisor = OUTLINE_SAMPLES - 1
    const points = []
    for (let i = 0; i < OUTLINE_SAMPLES; i++) {
      const p = el.getPointAtLength((length * i) / divisor)
      points.push([r(p.x), r(p.y)])
    }
    if (closed) points[points.length - 1] = points[0]
    return points
  }

  const placePoints = (points, matrix) => {
    if (!points || !matrix) return null
    return points.map(([x, y]) => [
      r(matrix.a * x + matrix.c * y + matrix.e),
      r(matrix.b * x + matrix.d * y + matrix.f),
    ])
  }

  // Fill interiors can remain visible when their outlines are clipped away.
  const paintedSamples = (el, bbox, contour, matrix) => {
    if (!matrix || !(el instanceof SVGGeometryElement)) return null
    const cs = getComputedStyle(el)
    const fillOpacity = parseFloat(cs.fillOpacity)
    if (bbox && cs.fill !== 'none' && (!Number.isFinite(fillOpacity) || fillOpacity > 0)) {
      const [x, y, width, height] = bbox
      const points = []
      for (let row = 0; row < 8; row++) {
        for (let column = 0; column < 8; column++) {
          const point = new DOMPoint(
            x + (width * (column + 0.5)) / 8,
            y + (height * (row + 0.5)) / 8,
          )
          if (el.isPointInFill(point)) points.push([point.x, point.y])
        }
      }
      if (points.length) return placePoints(points, matrix)
    }
    const strokeOpacity = parseFloat(cs.strokeOpacity)
    return cs.stroke !== 'none' && (!Number.isFinite(strokeOpacity) || strokeOpacity > 0)
      ? contour
      : null
  }

  // Stroke width is approximate under nonuniform scale.
  const linearScale = (matrix) =>
    matrix ? Math.sqrt((matrix.a ** 2 + matrix.b ** 2 + matrix.c ** 2 + matrix.d ** 2) / 2) : null
  const effectiveStrokeWidth = (el, matrix) => {
    if (!matrix) return null
    const cs = getComputedStyle(el)
    const width = parseFloat(cs.strokeWidth)
    const strokeOpacity = parseFloat(cs.strokeOpacity)
    if (cs.stroke === 'none' || !Number.isFinite(width) || width <= 0 || strokeOpacity === 0)
      return 0
    const scale =
      cs.vectorEffect === 'non-scaling-stroke' ? 1 / linearScale(rootCTM) : linearScale(matrix)
    return Number.isFinite(scale) ? r(width * scale) : null
  }

  const definitionOf = (reference) => {
    const found = /url\(["']?#([^"')]+)/.exec(reference || '')
    return found ? document.getElementById(found[1]) : null
  }

  // Definition records describe inputs, not composited pixels.
  const referenceStyles = [
    'fill',
    'stroke',
    'filter',
    'clip-path',
    'mask-image',
    'marker-start',
    'marker-mid',
    'marker-end',
  ]
  const hrefTags = new Set([
    'use',
    'image',
    'lineargradient',
    'radialgradient',
    'pattern',
    'textpath',
    'feimage',
    'mpath',
  ])
  const referencesOf = (el, cs) => {
    const refs = new Set()
    for (const property of referenceStyles) {
      const value = cs.getPropertyValue(property)
      for (const match of value.matchAll(/url\(\s*(?:"([^"]*)"|'([^']*)'|([^)]*?))\s*\)/g)) {
        refs.add((match[1] ?? match[2] ?? match[3]).trim())
      }
    }
    if (hrefTags.has(el.tagName.toLowerCase())) {
      const href = el.hasAttribute('href')
        ? el.getAttribute('href')
        : el.getAttributeNS('http://www.w3.org/1999/xlink', 'href')
      if (href) refs.add(href)
    }
    return refs
  }
  const resourceCache = new WeakMap()
  const definitionTags = new Set([
    'defs',
    'mask',
    'clippath',
    'filter',
    'lineargradient',
    'radialgradient',
    'pattern',
    'marker',
    'symbol',
  ])
  const resourceNode = (el) => {
    if (resourceCache.has(el)) return resourceCache.get(el)
    const cs = getComputedStyle(el)
    const attrs = Object.fromEntries(Array.from(el.attributes, (a) => [a.name, a.value]))
    const style = styleOf(el, resourceStyles)
    const children = Array.from(el.children)
      // Include nested definitions only when referenced.
      .filter(
        (child) => child instanceof SVGElement && !definitionTags.has(child.tagName.toLowerCase()),
      )
      .map(resourceNode)
    const refs = referencesOf(el, cs)
    for (const child of children) for (const ref of child.refs) refs.add(ref)
    const result = {
      value: {
        tag: el.tagName.toLowerCase(),
        attrs,
        style,
        children: children.map((c) => c.value),
      },
      refs,
    }
    resourceCache.set(el, result)
    return result
  }
  const resourceInputsOf = (el) => {
    const inputs = Object.create(null)
    const pending = Array.from(referencesOf(el, getComputedStyle(el)))
    for (let i = 0; i < pending.length; i++) {
      const reference = pending[i]
      if (Object.hasOwn(inputs, reference)) continue
      inputs[reference] = null // Unresolved references remain explicit.
      let target = null
      try {
        const url = new URL(reference, document.baseURI)
        if (url.hash && url.href.split('#')[0] === document.URL.split('#')[0]) {
          target = document.getElementById(decodeURIComponent(url.hash.slice(1)))
        }
      } catch (e) {
        /* malformed reference */
      }
      if (!(target instanceof SVGElement)) continue
      const record = resourceNode(target)
      inputs[reference] = record.value
      pending.push(...record.refs)
    }
    return inputs
  }

  // Place definition bounds using the referencing element's transform.
  const definitionBox = (el, reference) => {
    const def = reference.includes(',') ? null : definitionOf(reference)
    if (!def) return null
    let box = null
    for (const child of def.children) {
      try {
        const b = child.getBBox()
        const one = { x0: b.x, y0: b.y, x1: b.x + b.width, y1: b.y + b.height }
        box = box
          ? {
              x0: Math.min(box.x0, one.x0),
              y0: Math.min(box.y0, one.y0),
              x1: Math.max(box.x1, one.x1),
              y1: Math.max(box.y1, one.y1),
            }
          : one
      } catch (e) {
        /* a child with no box contributes nothing */
      }
    }
    if (!box) return null
    const m = el.getScreenCTM()
    if (!m || !inv) return null
    const l = inv.multiply(m)
    const xs = [],
      ys = []
    for (const [x, y] of [
      [box.x0, box.y0],
      [box.x1, box.y0],
      [box.x1, box.y1],
      [box.x0, box.y1],
    ]) {
      xs.push(l.a * x + l.c * y + l.e)
      ys.push(l.b * x + l.d * y + l.f)
    }
    return { x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) }
  }

  // Nonrectangular clip bounds can overestimate visible area.
  const clipOf = (el) => definitionBox(el, getComputedStyle(el).clipPath)

  // Hidden source nodes can produce unusable zero-area mask bounds.
  const maskOf = (el) => {
    const box = definitionBox(el, getComputedStyle(el).maskImage)
    if (!box || box.x1 <= box.x0 || box.y1 <= box.y0) return null
    return box
  }

  const chainTo = (el, one) => {
    let box = null
    for (let node = el; node && node.nodeType === 1; node = node.parentNode) {
      const here = one(node)
      if (!here) continue
      box = box
        ? {
            x0: Math.max(box.x0, here.x0),
            y0: Math.max(box.y0, here.y0),
            x1: Math.min(box.x1, here.x1),
            y1: Math.min(box.y1, here.y1),
          }
        : here
    }
    return box ? [r(box.x0), r(box.y0), r(box.x1), r(box.y1)] : null
  }

  // Unsupported clip or mask constructs remain unmeasurable.
  const constraintCache = new WeakMap()
  const opaquePaint = (paint, opacity) => {
    if (paint === 'none' || opacity === 0) return false
    if (opacity !== 1 || paint.startsWith('url(')) return null
    const rgba = /^rgba\([^,]+,[^,]+,[^,]+,\s*([\d.]+)\)$/.exec(paint)
    if (!rgba) return true
    const alpha = Number(rgba[1])
    return alpha === 0 ? false : alpha === 1 ? true : null
  }
  const constraintOf = (el, kind, reference) => {
    const cached = constraintCache.get(el) || {}
    if (kind in cached) return cached[kind]

    const def = reference.includes(',') ? null : definitionOf(reference)
    let checker = null
    if (
      def &&
      ((kind === 'clip' && def.tagName.toLowerCase() === 'clippath') ||
        (kind === 'mask' && def.tagName.toLowerCase() === 'mask'))
    ) {
      const unit = kind === 'clip' ? def.clipPathUnits : def.maskContentUnits
      const binaryAlphaMask =
        kind !== 'mask' ||
        ((def.getAttribute('mask-type') || getComputedStyle(def).maskType) === 'alpha' &&
          !['x', 'y', 'width', 'height'].some((name) => def.hasAttribute(name)))
      const descendants = Array.from(def.querySelectorAll('*'))
      const allowedContainers = new Set(['g', 'a', 'switch', 'title', 'desc', 'metadata'])
      const unsupportedNode = descendants.some(
        (node) =>
          !(node instanceof SVGGeometryElement) &&
          !allowedContainers.has(node.tagName.toLowerCase()),
      )
      const shapes = descendants.filter((node) => node instanceof SVGGeometryElement)
      const placed = []
      const ref = (() => {
        try {
          const m = el.getScreenCTM()
          return m && inv ? inv.multiply(m) : null
        } catch (e) {
          return null
        }
      })()
      let supported = !!unit && unit.baseVal === 1 && binaryAlphaMask && !unsupportedNode && !!ref
      for (const shape of shapes) {
        const cs = getComputedStyle(shape)
        if (cs.display === 'none' || cs.visibility === 'hidden') continue
        if (kind === 'clip' && cs.clipRule !== cs.fillRule) supported = false
        let ancestor = shape
        let opaque = true
        while (ancestor && ancestor !== def) {
          const style = getComputedStyle(ancestor)
          const opacity = parseFloat(style.opacity)
          if (kind === 'clip' && style.clipPath !== 'none') supported = false
          if (
            (Number.isFinite(opacity) && opacity !== 1) ||
            style.filter !== 'none' ||
            style.clipPath !== 'none' ||
            style.maskImage !== 'none'
          )
            opaque = false
          ancestor = ancestor.parentNode
        }
        const fillOpacity = parseFloat(cs.fillOpacity)
        const strokeOpacity = parseFloat(cs.strokeOpacity)
        const fillState = opaquePaint(cs.fill, fillOpacity)
        const strokeState = opaquePaint(cs.stroke, strokeOpacity)
        const fill = fillState === true
        const stroke = strokeState === true
        if (kind === 'mask' && (!opaque || fillState === null || strokeState === null))
          supported = false
        try {
          const m = shape.getScreenCTM()
          if (!m || !inv || !ref) {
            supported = false
            continue
          }
          const inverse = ref.multiply(inv.multiply(m)).inverse()
          if (
            ![inverse.a, inverse.b, inverse.c, inverse.d, inverse.e, inverse.f].every(
              Number.isFinite,
            )
          ) {
            supported = false
            continue
          }
          placed.push({
            shape,
            inverse,
            fill: kind === 'clip' || fill,
            stroke: kind === 'mask' && stroke,
          })
        } catch (e) {
          supported = false
        }
      }
      if (supported) {
        checker = ([x, y]) =>
          placed.some(({ shape, inverse, fill, stroke }) => {
            const point = new DOMPoint(
              inverse.a * x + inverse.c * y + inverse.e,
              inverse.b * x + inverse.d * y + inverse.f,
            )
            return (fill && shape.isPointInFill(point)) || (stroke && shape.isPointInStroke(point))
          })
      }
    }
    cached[kind] = checker
    constraintCache.set(el, cached)
    return checker
  }

  const visibleFractionOf = (el, bbox, contour, matrix) => {
    if (!contour || !contour.length) return null
    const constraints = []
    for (let node = el; node && node.nodeType === 1; node = node.parentNode) {
      const cs = getComputedStyle(node)
      for (const [kind, reference] of [
        ['clip', cs.clipPath],
        ['mask', cs.maskImage],
      ]) {
        if (!reference || reference === 'none') continue
        const checker = constraintOf(node, kind, reference)
        if (!checker) return null
        constraints.push(checker)
      }
    }
    if (!constraints.length) return 1
    const samples = paintedSamples(el, bbox, contour, matrix)
    if (!samples || !samples.length) return null
    return r(
      samples.filter((point) => constraints.every((checker) => checker(point))).length /
        samples.length,
    )
  }

  const rows = []
  let order = 0

  const walk = (el, parentPath) => {
    const tag = el.tagName.toLowerCase()
    if (!paints(el)) return

    const sameTag =
      parentPath === null
        ? []
        : Array.from(el.parentNode.children).filter((c) => c.tagName.toLowerCase() === tag)
    const idx = sameTag.indexOf(el)
    const seg = parentPath === null ? tag : `${tag}[${idx}]`
    const path = parentPath === null ? seg : `${parentPath}/${seg}`

    let ctm = null
    let rootMatrix = null
    try {
      const m = el.getScreenCTM()
      if (m && inv) {
        const l = inv.multiply(m)
        rootMatrix = l
        ctm = [r(l.a), r(l.b), r(l.c), r(l.d), r(l.e), r(l.f)]
      }
    } catch (e) {
      ctm = null
    }

    // CSS transforms are recorded separately from the transform attribute.
    let own = [1, 0, 0, 1, 0, 0]
    try {
      const c = el.transform.baseVal.consolidate()
      if (c)
        own = [
          r(c.matrix.a),
          r(c.matrix.b),
          r(c.matrix.c),
          r(c.matrix.d),
          r(c.matrix.e),
          r(c.matrix.f),
        ]
    } catch (e) {
      own = null
    }

    let bbox = null
    try {
      const b = el.getBBox()
      bbox = [r(b.x), r(b.y), r(b.width), r(b.height)]
    } catch (e) {
      bbox = null
    }

    let length = null
    let ends = null
    let localContour = null
    try {
      if (typeof el.getTotalLength === 'function') {
        // Cached geometry excludes transforms, which are applied afterward.
        const sig = reuseOutline ? outlineSignature(el, tag) : null
        const cached = sig === null ? null : outlineCache[path]
        if (cached && cached.sig === sig && cached.contour) {
          length = cached.length
          ends = cached.ends
          localContour = cached.contour
        } else {
          length = r(el.getTotalLength())
          const a = el.getPointAtLength(0)
          const b = el.getPointAtLength(length)
          ends = [
            [r(a.x), r(a.y)],
            [r(b.x), r(b.y)],
          ]
          localContour = sampleOutline(el, length, ends)
          if (sig !== null) outlineCache[path] = { sig, length, ends, contour: localContour }
        }
      }
    } catch (e) {
      length = null
      ends = null
      localContour = null
    }
    const contour = placePoints(localContour, rootMatrix)
    const strokeWidth = effectiveStrokeWidth(el, rootMatrix)

    const attrs = {}
    for (const a of el.attributes) attrs[a.name] = a.value

    const full = styleOf(el)
    let style = full
    if (baseline) {
      const base = baseline[path] || {}
      style = {}
      for (const k in full) if (full[k] !== base[k]) style[k] = full[k]
    }

    rows.push({
      path,
      tag,
      parent: parentPath,
      order: order++,
      ctm,
      own,
      bbox,
      length,
      ends,
      contour,
      stroke_width: strokeWidth,
      visible_fraction: visibleFractionOf(el, bbox, contour, rootMatrix),
      clip_box: chainTo(el, clipOf),
      mask_box: chainTo(el, maskOf),
      resource_inputs: resourceInputsOf(el),
      attrs,
      style,
    })

    for (const child of el.children) walk(child, path)
  }

  walk(root, null)

  const vb = root.getAttribute('viewBox')
  return {
    rows,
    canvas: {
      viewBox: vb
        ? vb
            .trim()
            .split(/[\s,]+/)
            .map(Number)
        : null,
      width: root.getAttribute('width'),
      height: root.getAttribute('height'),
    },
  }
}