edge_det 0.1.0 → 0.1.3

package/src/lib.rs

@@ -1,327 +0,0 @@
-use wasm_bindgen::prelude::*;
-
-const GAUSS: [f32; 5] = [1.0, 4.0, 6.0, 4.0, 1.0];
-const GAUSS_SUM: f32 = 16.0;
-
-fn grayscale(data: &[u8], w: usize, h: usize) -> Vec<f32> {
-    let n = w * h;
-    let mut g = vec![0.0f32; n];
-    for i in 0..n {
-        let o = i * 4;
-        g[i] = 0.299 * data[o] as f32 + 0.587 * data[o + 1] as f32 + 0.114 * data[o + 2] as f32;
-    }
-    g
-}
-
-fn blur(img: &[f32], w: usize, h: usize) -> Vec<f32> {
-    let mut tmp = vec![0.0f32; w * h];
-    let mut out = vec![0.0f32; w * h];
-    for y in 0..h {
-        for x in 0..w {
-            let mut s = 0.0f32;
-            for k in 0usize..5 {
-                let xx = ((x as i32) + k as i32 - 2).max(0).min(w as i32 - 1) as usize;
-                s += img[y * w + xx] * GAUSS[k];
-            }
-            tmp[y * w + x] = s / GAUSS_SUM;
-        }
-    }
-    for y in 0..h {
-        for x in 0..w {
-            let mut s = 0.0f32;
-            for k in 0usize..5 {
-                let yy = ((y as i32) + k as i32 - 2).max(0).min(h as i32 - 1) as usize;
-                s += tmp[yy * w + x] * GAUSS[k];
-            }
-            out[y * w + x] = s / GAUSS_SUM;
-        }
-    }
-    out
-}
-
-struct SobelResult {
-    mag: Vec<f32>,
-    dx: Vec<f32>,
-    dy: Vec<f32>,
-}
-
-fn sobel(img: &[f32], w: usize, h: usize) -> SobelResult {
-    let n = w * h;
-    let mut mag = vec![0.0f32; n];
-    let mut dx = vec![0.0f32; n];
-    let mut dy = vec![0.0f32; n];
-    for y in 1..h - 1 {
-        for x in 1..w - 1 {
-            let i = y * w + x;
-            let sx = -img[i - w - 1] - 2.0 * img[i - 1] - img[i + w - 1]
-                + img[i - w + 1] + 2.0 * img[i + 1] + img[i + w + 1];
-            let sy = -img[i - w - 1] - 2.0 * img[i - w] - img[i - w + 1]
-                + img[i + w - 1] + 2.0 * img[i + w] + img[i + w + 1];
-            dx[i] = sx;
-            dy[i] = sy;
-            mag[i] = (sx * sx + sy * sy).sqrt();
-        }
-    }
-    SobelResult { mag, dx, dy }
-}
-
-fn nms(result: &SobelResult, w: usize, h: usize) -> Vec<f32> {
-    let mut out = vec![0.0f32; w * h];
-    for y in 1..h - 1 {
-        for x in 1..w - 1 {
-            let i = y * w + x;
-            let m = result.mag[i];
-            if m < 0.5 {
-                continue;
-            }
-            let gx = result.dx[i];
-            let gy = result.dy[i];
-            let abs_gx = gx.abs();
-            let abs_gy = gy.abs();
-
-            let (mut mag1, mut mag2) = (0.0f32, 0.0f32);
-            if abs_gx > abs_gy {
-                let t = abs_gy / abs_gx;
-                if gx * gy > 0.0 {
-                    mag1 = result.mag[i - w - 1] * (1.0 - t) + result.mag[i - w] * t;
-                    mag2 = result.mag[i + w + 1] * (1.0 - t) + result.mag[i + w] * t;
-                } else {
-                    mag1 = result.mag[i - w + 1] * (1.0 - t) + result.mag[i - w] * t;
-                    mag2 = result.mag[i + w - 1] * (1.0 - t) + result.mag[i + w] * t;
-                }
-            } else if abs_gy > 0.0 {
-                let t = abs_gx / abs_gy;
-                if gx * gy > 0.0 {
-                    mag1 = result.mag[i - w - 1] * (1.0 - t) + result.mag[i - 1] * t;
-                    mag2 = result.mag[i + w + 1] * (1.0 - t) + result.mag[i + 1] * t;
-                } else {
-                    mag1 = result.mag[i - w + 1] * (1.0 - t) + result.mag[i + 1] * t;
-                    mag2 = result.mag[i + w - 1] * (1.0 - t) + result.mag[i - 1] * t;
-                }
-            }
-            out[i] = if m >= mag1 && m >= mag2 { m } else { 0.0 };
-        }
-    }
-    out
-}
-
-fn hysteresis(edges: &mut [u8], w: usize, h: usize) {
-    let mut stack: Vec<(i32, i32)> = Vec::new();
-    for y in 0..h {
-        for x in 0..w {
-            if edges[y * w + x] == 2 {
-                stack.push((x as i32, y as i32));
-            }
-        }
-    }
-    while let Some((x, y)) = stack.pop() {
-        for dy in -1..=1 {
-            for dx in -1..=1 {
-                let nx = x + dx;
-                let ny = y + dy;
-                if nx >= 0 && nx < w as i32 && ny >= 0 && ny < h as i32 {
-                    let ni = (ny * w as i32 + nx) as usize;
-                    if edges[ni] == 1 {
-                        edges[ni] = 2;
-                        stack.push((nx, ny));
-                    }
-                }
-            }
-        }
-    }
-    for e in edges.iter_mut() {
-        if *e == 1 {
-            *e = 0;
-        }
-    }
-}
-
-struct UF {
-    p: Vec<usize>,
-    r: Vec<u8>,
-}
-
-impl UF {
-    fn new(n: usize) -> Self {
-        Self {
-            p: (0..n).collect(),
-            r: vec![0; n],
-        }
-    }
-    fn find(&mut self, x: usize) -> usize {
-        if self.p[x] != x {
-            self.p[x] = self.find(self.p[x]);
-        }
-        self.p[x]
-    }
-    fn union(&mut self, a: usize, b: usize) {
-        let ra = self.find(a);
-        let rb = self.find(b);
-        if ra == rb {
-            return;
-        }
-        if self.r[ra] < self.r[rb] {
-            self.p[ra] = rb;
-        } else if self.r[ra] > self.r[rb] {
-            self.p[rb] = ra;
-        } else {
-            self.p[rb] = ra;
-            self.r[ra] += 1;
-        }
-    }
-}
-
-fn bounding_boxes(edges: &[u8], w: usize, h: usize, min_area: usize) -> Vec<[i32; 4]> {
-    let n = w * h;
-    let mut uf = UF::new(n);
-    for y in 0..h {
-        for x in 0..w {
-            let i = y * w + x;
-            if edges[i] == 0 {
-                continue;
-            }
-            if x + 1 < w && edges[i + 1] != 0 {
-                uf.union(i, i + 1);
-            }
-            if y + 1 < h && edges[i + w] != 0 {
-                uf.union(i, i + w);
-            }
-            if x + 1 < w && y + 1 < h && edges[i + w + 1] != 0 {
-                uf.union(i, i + w + 1);
-            }
-            if x > 0 && y + 1 < h && edges[i + w - 1] != 0 {
-                uf.union(i, i + w - 1);
-            }
-        }
-    }
-    let mut x0 = vec![w as i32; n];
-    let mut y0 = vec![h as i32; n];
-    let mut x1 = vec![0i32; n];
-    let mut y1 = vec![0i32; n];
-    let mut cnt = vec![0usize; n];
-    for y in 0..h {
-        for x in 0..w {
-            let i = y * w + x;
-            if edges[i] == 0 {
-                continue;
-            }
-            let r = uf.find(i);
-            x0[r] = x0[r].min(x as i32);
-            y0[r] = y0[r].min(y as i32);
-            x1[r] = x1[r].max(x as i32);
-            y1[r] = y1[r].max(y as i32);
-            cnt[r] += 1;
-        }
-    }
-    let mut boxes: Vec<[i32; 4]> = Vec::new();
-    for i in 0..n {
-        if cnt[i] >= min_area {
-            boxes.push([x0[i], y0[i], x1[i] - x0[i] + 1, y1[i] - y0[i] + 1]);
-        }
-    }
-    boxes.sort_by(|a, b| (b[2] * b[3]).cmp(&(a[2] * a[3])));
-    boxes
-}
-
-fn color_gradient(data: &[u8], w: usize, h: usize) -> SobelResult {
-    let n = w * h;
-    let mut r_ch = vec![0.0f32; n];
-    let mut g_ch = vec![0.0f32; n];
-    let mut b_ch = vec![0.0f32; n];
-    for i in 0..n {
-        let o = i * 4;
-        r_ch[i] = data[o] as f32;
-        g_ch[i] = data[o + 1] as f32;
-        b_ch[i] = data[o + 2] as f32;
-    }
-    let rb = blur(&r_ch, w, h);
-    let gb = blur(&g_ch, w, h);
-    let bb = blur(&b_ch, w, h);
-
-    let mut mag = vec![0.0f32; n];
-    let mut dx = vec![0.0f32; n];
-    let mut dy = vec![0.0f32; n];
-    for y in 1..h - 1 {
-        for x in 1..w - 1 {
-            let i = y * w + x;
-            let dr_x = rb[i + 1] - rb[i - 1];
-            let dg_x = gb[i + 1] - gb[i - 1];
-            let db_x = bb[i + 1] - bb[i - 1];
-            let dr_y = rb[i + w] - rb[i - w];
-            let dg_y = gb[i + w] - gb[i - w];
-            let db_y = bb[i + w] - bb[i - w];
-            let sx = (dr_x * dr_x + dg_x * dg_x + db_x * db_x).sqrt();
-            let sy = (dr_y * dr_y + dg_y * dg_y + db_y * db_y).sqrt();
-            let sign_x = if dr_x + dg_x + db_x >= 0.0 { 1.0 } else { -1.0 };
-            let sign_y = if dr_y + dg_y + db_y >= 0.0 { 1.0 } else { -1.0 };
-            dx[i] = sx * sign_x;
-            dy[i] = sy * sign_y;
-            mag[i] = (sx * sx + sy * sy).sqrt();
-        }
-    }
-    SobelResult { mag, dx, dy }
-}
-
-fn merge_and_threshold(
-    gray_sup: &[f32],
-    color_sup: &[f32],
-    w: usize,
-    h: usize,
-    lo: f32,
-    hi: f32,
-) -> Vec<u8> {
-    let n = w * h;
-    let mut out = vec![0u8; n];
-    for i in 0..n {
-        let v = gray_sup[i].max(color_sup[i]);
-        if v >= hi {
-            out[i] = 2;
-        } else if v >= lo {
-            out[i] = 1;
-        }
-    }
-    out
-}
-
-#[wasm_bindgen]
-pub fn detect_borders(
-    data: &[u8],
-    width: usize,
-    height: usize,
-    low_threshold: f32,
-    high_threshold: f32,
-    min_area: usize,
-) -> Vec<f32> {
-    let gray = grayscale(data, width, height);
-    let blurred = blur(&gray, width, height);
-    let gray_sobel = sobel(&blurred, width, height);
-    let gray_sup = nms(&gray_sobel, width, height);
-
-    let color_sobel = color_gradient(data, width, height);
-    let color_sup = nms(&color_sobel, width, height);
-
-    let mut edges = merge_and_threshold(
-        &gray_sup,
-        &color_sup,
-        width,
-        height,
-        low_threshold,
-        high_threshold,
-    );
-    hysteresis(&mut edges, width, height);
-
-    let boxes = bounding_boxes(&edges, width, height, min_area);
-    let mut out = Vec::with_capacity(boxes.len() * 4);
-    for b in &boxes {
-        out.push(b[0] as f32);
-        out.push(b[1] as f32);
-        out.push(b[2] as f32);
-        out.push(b[3] as f32);
-    }
-    out
-}
-
-#[wasm_bindgen]
-pub fn detect_borders_default(data: &[u8], width: usize, height: usize) -> Vec<f32> {
-    detect_borders(data, width, height, 20.0, 60.0, 100)
-}

package/src_ts/index.ts

@@ -1,68 +0,0 @@
-import {
-  initSync,
-  detect_borders,
-  detect_borders_default,
-} from '../pkg/edge_det.js'
-import { WASM_BYTES } from './wasm_bytes'
-
-export interface Border {
-  x: number
-  y: number
-  w: number
-  h: number
-}
-
-let _initialized = false
-
-function ensureInit() {
-  if (!_initialized) {
-    initSync({ module: WASM_BYTES })
-    _initialized = true
-  }
-}
-
-export function detectBorders(
-  data: Uint8Array,
-  width: number,
-  height: number,
-  options?: { lowThreshold?: number; highThreshold?: number; minArea?: number }
-): Border[] {
-  ensureInit()
-  const result = detect_borders(
-    data,
-    width,
-    height,
-    options?.lowThreshold ?? 20,
-    options?.highThreshold ?? 60,
-    options?.minArea ?? 100
-  )
-  const borders: Border[] = []
-  for (let i = 0; i < result.length; i += 4) {
-    borders.push({
-      x: result[i],
-      y: result[i + 1],
-      w: result[i + 2],
-      h: result[i + 3],
-    })
-  }
-  return borders
-}
-
-export function detectBordersDefault(
-  data: Uint8Array,
-  width: number,
-  height: number
-): Border[] {
-  ensureInit()
-  const result = detect_borders_default(data, width, height)
-  const borders: Border[] = []
-  for (let i = 0; i < result.length; i += 4) {
-    borders.push({
-      x: result[i],
-      y: result[i + 1],
-      w: result[i + 2],
-      h: result[i + 3],
-    })
-  }
-  return borders
-}

package/tests/detection.test.ts

@@ -1,238 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import * as PImage from 'pureimage'
-import { detectBorders, detectBordersDefault, Border } from '../src_ts/index'
-
-function createImage(
-  w: number,
-  h: number,
-  draw: (ctx: PImage.Context) => void
-): Uint8Array {
-  const img = PImage.make(w, h, {})
-  const ctx = img.getContext('2d')
-  ctx.fillStyle = '#ffffff'
-  ctx.fillRect(0, 0, w, h)
-  draw(ctx)
-  const buf = img.data
-  const rgba = new Uint8Array(w * h * 4)
-  for (let i = 0; i < w * h; i++) {
-    rgba[i * 4] = buf[i * 4]
-    rgba[i * 4 + 1] = buf[i * 4 + 1]
-    rgba[i * 4 + 2] = buf[i * 4 + 2]
-    rgba[i * 4 + 3] = buf[i * 4 + 3]
-  }
-  return rgba
-}
-
-function drawRect(
-  ctx: PImage.Context,
-  x: number,
-  y: number,
-  w: number,
-  h: number,
-  color: string,
-  lineWidth?: number
-) {
-  ctx.strokeStyle = color
-  ctx.lineWidth = lineWidth ?? 1
-  ctx.strokeRect(x, y, w, h)
-}
-
-function fillRect(
-  ctx: PImage.Context,
-  x: number,
-  y: number,
-  w: number,
-  h: number,
-  color: string
-) {
-  ctx.fillStyle = color
-  ctx.fillRect(x, y, w, h)
-}
-
-function mergeBounds(borders: Border[]) {
-  const m = { x: Infinity, y: Infinity, x2: -Infinity, y2: -Infinity }
-  for (const b of borders) {
-    m.x = Math.min(m.x, b.x)
-    m.y = Math.min(m.y, b.y)
-    m.x2 = Math.max(m.x2, b.x + b.w)
-    m.y2 = Math.max(m.y2, b.y + b.h)
-  }
-  return m
-}
-
-function areaOf(b: Border) {
-  return b.w * b.h
-}
-
-function coverage(borders: Border[], expected: { x: number; y: number; w: number; h: number }) {
-  const merged = mergeBounds(borders)
-  const ex = expected.x
-  const ey = expected.y
-  const ex2 = expected.x + expected.w
-  const ey2 = expected.y + expected.h
-  const iw = Math.max(0, Math.min(merged.x2, ex2) - Math.max(merged.x, ex))
-  const ih = Math.max(0, Math.min(merged.y2, ey2) - Math.max(merged.y, ey))
-  const inter = iw * ih
-  const unionArea = (merged.x2 - merged.x) * (merged.y2 - merged.y) + expected.w * expected.h - inter
-  return inter / unionArea
-}
-
-const TOL = 6
-
-describe('detectBorders', () => {
-  it('solid color → no borders', () => {
-    const w = 80, h = 80
-    const data = createImage(w, h, () => {})
-    const borders = detectBorders(data, w, h)
-    expect(borders.length).toBe(0)
-  })
-
-  it('white bg + gray filled rect (low contrast)', () => {
-    const w = 200, h = 200
-    const rect = { x: 30, y: 40, w: 80, h: 60 }
-    const data = createImage(w, h, (ctx) => {
-      fillRect(ctx, rect.x, rect.y, rect.w, rect.h, '#cccccc')
-    })
-    const borders = detectBorders(data, w, h, {
-      lowThreshold: 8,
-      highThreshold: 25,
-      minArea: 20,
-    })
-    expect(borders.length).toBeGreaterThanOrEqual(1)
-    const merged = mergeBounds(borders)
-    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
-    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
-    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
-    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
-  })
-
-  it('white bg + thin black 1px line rect', () => {
-    const w = 200, h = 200
-    const rect = { x: 20, y: 20, w: 100, h: 80 }
-    const data = createImage(w, h, (ctx) => {
-      drawRect(ctx, rect.x, rect.y, rect.w, rect.h, '#000000', 1)
-    })
-    const borders = detectBorders(data, w, h, {
-      lowThreshold: 15,
-      highThreshold: 45,
-      minArea: 10,
-    })
-    expect(borders.length).toBeGreaterThanOrEqual(1)
-    const merged = mergeBounds(borders)
-    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
-    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
-    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
-    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
-  })
-
-  it('white bg + thin black 2px line rect', () => {
-    const w = 200, h = 200
-    const rect = { x: 50, y: 30, w: 100, h: 120 }
-    const data = createImage(w, h, (ctx) => {
-      drawRect(ctx, rect.x, rect.y, rect.w, rect.h, '#000000', 2)
-    })
-    const borders = detectBorders(data, w, h, {
-      lowThreshold: 15,
-      highThreshold: 45,
-      minArea: 10,
-    })
-    expect(borders.length).toBeGreaterThanOrEqual(1)
-    const merged = mergeBounds(borders)
-    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
-    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
-    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
-    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
-  })
-
-  it('white bg + gray thin line rect (low contrast + thin)', () => {
-    const w = 200, h = 200
-    const rect = { x: 25, y: 25, w: 100, h: 100 }
-    const data = createImage(w, h, (ctx) => {
-      drawRect(ctx, rect.x, rect.y, rect.w, rect.h, '#999999', 1)
-    })
-    const borders = detectBorders(data, w, h, {
-      lowThreshold: 5,
-      highThreshold: 18,
-      minArea: 10,
-    })
-    expect(borders.length).toBeGreaterThanOrEqual(1)
-    const merged = mergeBounds(borders)
-    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
-    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
-    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
-    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
-  })
-
-  it('blue rect on gray bg (color)', () => {
-    const w = 200, h = 200
-    const rect = { x: 40, y: 30, w: 80, h: 60 }
-    const data = createImage(w, h, (ctx) => {
-      fillRect(ctx, 0, 0, w, h, '#555555')
-      fillRect(ctx, rect.x, rect.y, rect.w, rect.h, '#0088ff')
-    })
-    const borders = detectBorders(data, w, h, {
-      lowThreshold: 12,
-      highThreshold: 35,
-      minArea: 20,
-    })
-    expect(borders.length).toBeGreaterThanOrEqual(1)
-    const merged = mergeBounds(borders)
-    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
-    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
-    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
-    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
-  })
-
-  it('two rects — count and area', () => {
-    const w = 300, h = 300
-    const r1 = { x: 20, y: 20, w: 60, h: 60 }
-    const r2 = { x: 150, y: 120, w: 100, h: 80 }
-    const data = createImage(w, h, (ctx) => {
-      fillRect(ctx, r1.x, r1.y, r1.w, r1.h, '#cccccc')
-      fillRect(ctx, r2.x, r2.y, r2.w, r2.h, '#cccccc')
-    })
-    const borders = detectBorders(data, w, h, {
-      lowThreshold: 8,
-      highThreshold: 25,
-      minArea: 20,
-    })
-    expect(borders.length).toBe(2)
-    const areas = borders.map(areaOf).sort((a, b) => a - b)
-    const expectedAreas = [r1.w * r1.h, r2.w * r2.h].sort((a, b) => a - b)
-    for (let i = 0; i < 2; i++) {
-      expect(areas[i]).toBeGreaterThan(expectedAreas[i] * 0.5)
-      expect(areas[i]).toBeLessThan(expectedAreas[i] * 2.5)
-    }
-  })
-
-  it('two thin-line rects — count and area', () => {
-    const w = 300, h = 300
-    const r1 = { x: 20, y: 20, w: 80, h: 60 }
-    const r2 = { x: 160, y: 100, w: 100, h: 80 }
-    const data = createImage(w, h, (ctx) => {
-      drawRect(ctx, r1.x, r1.y, r1.w, r1.h, '#000000', 2)
-      drawRect(ctx, r2.x, r2.y, r2.w, r2.h, '#000000', 2)
-    })
-    const borders = detectBorders(data, w, h, {
-      lowThreshold: 15,
-      highThreshold: 45,
-      minArea: 10,
-    })
-    expect(borders.length).toBeGreaterThanOrEqual(2)
-    const sorted = [...borders].sort((a, b) => areaOf(a) - areaOf(b))
-    const r1Area = r1.w * r1.h
-    const r2Area = r2.w * r2.h
-    expect(areaOf(sorted[sorted.length - 1])).toBeGreaterThan(r2Area * 0.3)
-    expect(areaOf(sorted[sorted.length - 1])).toBeLessThan(r2Area * 3)
-  })
-
-  it('detectBordersDefault works', () => {
-    const w = 200, h = 200
-    const rect = { x: 30, y: 30, w: 100, h: 100 }
-    const data = createImage(w, h, (ctx) => {
-      fillRect(ctx, rect.x, rect.y, rect.w, rect.h, '#cccccc')
-    })
-    const borders = detectBordersDefault(data, w, h)
-    expect(borders.length).toBeGreaterThanOrEqual(1)
-  })
-})

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "declaration": true,
-    "outDir": "dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true
-  },
-  "include": ["src_ts"],
-  "exclude": ["tests", "node_modules"]
-}

package/vite.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'vite'
-
-export default defineConfig({
-  build: {
-    lib: {
-      entry: 'src_ts/index.ts',
-      formats: ['es'],
-    },
-  },
-})

package/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    include: ['tests/**/*.test.ts'],
-  },
-})