byte-codec 1.0.0 → 1.0.1

package/src/image/png-decode.ts

@@ -1,263 +0,0 @@
-import { crc32 } from '../bytes/crc32';
-import { inflateTolerant } from '../bytes/flate';
-import { concatBytes } from '../bytes/writer';
-import { unfilterScanlines } from './png-filter';
-
-// Normalising every PNG colour type down to 8-bit gray-or-RGB plus a separate alpha plane is deliberate: it is exactly the shape a PDF Image XObject wants (/DeviceGray or /DeviceRGB, /BitsPerComponent 8, alpha as a separate /SMask /DeviceGray XObject), so the PDF writer does zero rearranging of whatever this decoder produces.
-export interface RawImage {
-  readonly width: number;
-  readonly height: number;
-  readonly channels: 1 | 3;
-  readonly data: Uint8Array<ArrayBuffer>;
-  readonly alpha?: Uint8Array<ArrayBuffer>;
-}
-
-export interface PngDecodeOptions {
-  readonly onWarning?: (message: string) => void;
-}
-
-const PNG_SIGNATURE: readonly number[] = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
-
-interface PngChunk {
-  readonly type: string;
-  readonly data: Uint8Array<ArrayBuffer>;
-}
-
-function requireDataView(bytes: Uint8Array<ArrayBuffer>): DataView {
-  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-}
-
-function readChunks(bytes: Uint8Array<ArrayBuffer>, onWarning: ((m: string) => void) | undefined): PngChunk[] {
-  const chunks: PngChunk[] = [];
-  const view = requireDataView(bytes);
-  let offset = PNG_SIGNATURE.length;
-  while (offset + 8 <= bytes.length) {
-    const length = view.getUint32(offset);
-    const typeBytes = bytes.subarray(offset + 4, offset + 8);
-    const type = new TextDecoder('latin1').decode(typeBytes);
-    const dataStart = offset + 8;
-    const dataEnd = dataStart + length;
-    if (dataEnd + 4 > bytes.length) {
-      throw new Error(`PNG chunk '${type}' declares a length that runs past the end of the file`);
-    }
-    const data = bytes.subarray(dataStart, dataEnd);
-    if (onWarning !== undefined) {
-      const storedCrc = view.getUint32(dataEnd);
-      const computedCrc = crc32(concatBytes([typeBytes, data]));
-      if (storedCrc !== computedCrc) {
-        onWarning(`PNG chunk '${type}' failed its CRC32 check`);
-      }
-    }
-    chunks.push({ type, data });
-    offset = dataEnd + 4;
-    if (type === 'IEND') {
-      break;
-    }
-  }
-  return chunks;
-}
-
-interface Ihdr {
-  readonly width: number;
-  readonly height: number;
-  readonly bitDepth: number;
-  readonly colorType: number;
-  readonly interlace: number;
-}
-
-function parseIhdr(data: Uint8Array<ArrayBuffer>): Ihdr {
-  const view = requireDataView(data);
-  return {
-    width: view.getUint32(0),
-    height: view.getUint32(4),
-    bitDepth: data[8]!,
-    colorType: data[9]!,
-    interlace: data[12]!,
-  };
-}
-
-function channelsForColorType(colorType: number): number {
-  if (colorType === 0) {
-    return 1; // grayscale
-  }
-  if (colorType === 2) {
-    return 3; // truecolor
-  }
-  if (colorType === 3) {
-    return 1; // palette index
-  }
-  if (colorType === 4) {
-    return 2; // grayscale + alpha
-  }
-  if (colorType === 6) {
-    return 4; // truecolor + alpha
-  }
-  throw new Error(`unsupported PNG colour type: ${colorType}`);
-}
-
-// PNG's own "bpp" for filtering purposes: bytes per complete pixel, rounded up, minimum 1.
-function filterBpp(bitDepth: number, channels: number): number {
-  return Math.max(1, Math.ceil((bitDepth * channels) / 8));
-}
-
-// Unpacks one already-unfiltered scanline into one number per sample (raw, unscaled -- 0..2^bitDepth-1 for bit depths under 16, or the 16-bit value's high byte for bitDepth 16, per this decoder's documented 16-bit handling: reduce every depth down to an 8-bit-equivalent raw sample here, and scale to a full 0..255 display range later only for grayscale, where sub-8-bit depths need it).
-function unpackRow(rowBytes: Uint8Array<ArrayBuffer>, width: number, channels: number, bitDepth: number): number[] {
-  const sampleCount = width * channels;
-  const samples: number[] = new Array<number>(sampleCount);
-  if (bitDepth === 8) {
-    for (let i = 0; i < sampleCount; i++) {
-      samples[i] = rowBytes[i]!;
-    }
-  } else if (bitDepth === 16) {
-    for (let i = 0; i < sampleCount; i++) {
-      samples[i] = rowBytes[i * 2]!; // high byte only
-    }
-  } else {
-    const mask = (1 << bitDepth) - 1;
-    for (let i = 0; i < sampleCount; i++) {
-      const bitOffset = i * bitDepth;
-      const byteIndex = bitOffset >> 3;
-      const shift = 8 - bitDepth - (bitOffset & 7);
-      samples[i] = (rowBytes[byteIndex]! >> shift) & mask;
-    }
-  }
-  return samples;
-}
-
-function readTrnsGrayValue(trns: Uint8Array<ArrayBuffer>): number {
-  return requireDataView(trns).getUint16(0);
-}
-
-function readTrnsRgbKey(trns: Uint8Array<ArrayBuffer>): readonly [number, number, number] {
-  const view = requireDataView(trns);
-  return [view.getUint16(0), view.getUint16(2), view.getUint16(4)];
-}
-
-function scaleToByte(sample: number, bitDepth: number): number {
-  if (bitDepth === 16) {
-    return sample; // already the high byte, i.e. already 0..255
-  }
-  const maxSample = (1 << bitDepth) - 1;
-  return Math.round((sample * 255) / maxSample);
-}
-
-// Decodes PNG file bytes into raw, normalised pixel data. Supports colour types 0/2/3/4/6 (gray, truecolor, indexed+PLTE, gray+alpha, truecolor+alpha) at bit depths 1/2/4/8/16 as applicable, plus tRNS transparency for all three non-alpha colour types. Adam7-interlaced sources are rejected explicitly (diagnostic-worthy but essentially never produced by Office/mainstream tooling) rather than silently decoded wrong.
-export function decodePng(bytes: Uint8Array<ArrayBuffer>, options: PngDecodeOptions = {}): RawImage {
-  for (let i = 0; i < PNG_SIGNATURE.length; i++) {
-    if (bytes[i] !== PNG_SIGNATURE[i]) {
-      throw new Error('not a valid PNG file: bad signature');
-    }
-  }
-
-  const chunks = readChunks(bytes, options.onWarning);
-  const ihdrChunk = chunks[0];
-  if (ihdrChunk?.type !== 'IHDR') {
-    throw new Error('PNG file does not begin with an IHDR chunk');
-  }
-  const ihdr = parseIhdr(ihdrChunk.data);
-  if (ihdr.interlace !== 0) {
-    throw new Error('Adam7-interlaced PNG images are not supported');
-  }
-
-  const channels = channelsForColorType(ihdr.colorType);
-  const bpp = filterBpp(ihdr.bitDepth, channels);
-  const bytesPerRow = Math.ceil((ihdr.width * channels * ihdr.bitDepth) / 8);
-
-  const idatChunks = chunks.filter((c) => c.type === 'IDAT').map((c) => c.data);
-  if (idatChunks.length === 0) {
-    throw new Error('PNG file has no IDAT chunks');
-  }
-  // Every IDAT chunk must be concatenated before inflating -- multi-IDAT files are routine (Office emits them), and inflating only the first chunk is the single most common PNG-decoder bug.
-  const compressed = concatBytes(idatChunks);
-  const { bytes: inflated, recovered } = inflateTolerant(compressed);
-  if (recovered && options.onWarning !== undefined) {
-    options.onWarning('PNG IDAT stream required tolerant recovery (truncated or malformed)');
-  }
-  const unfiltered = unfilterScanlines(inflated, ihdr.height, bytesPerRow, bpp);
-
-  const palette = ihdr.colorType === 3 ? chunks.find((c) => c.type === 'PLTE')?.data : undefined;
-  if (ihdr.colorType === 3 && palette === undefined) {
-    throw new Error('indexed-colour PNG has no PLTE chunk');
-  }
-  const trns = chunks.find((c) => c.type === 'tRNS')?.data;
-
-  return buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns);
-}
-
-function buildRawImage(
-  ihdr: Ihdr,
-  channels: number,
-  bytesPerRow: number,
-  unfiltered: Uint8Array<ArrayBuffer>,
-  palette: Uint8Array<ArrayBuffer> | undefined,
-  trns: Uint8Array<ArrayBuffer> | undefined,
-): RawImage {
-  const { width, height, bitDepth, colorType } = ihdr;
-  const outChannels: 1 | 3 = colorType === 0 || colorType === 4 ? 1 : 3;
-  const data = new Uint8Array(width * height * outChannels);
-  const hasAlpha = colorType === 4 || colorType === 6 || trns !== undefined;
-  const alpha = hasAlpha ? new Uint8Array(width * height).fill(255) : undefined;
-
-  const trnsGray = colorType === 0 && trns !== undefined ? readTrnsGrayValue(trns) : undefined;
-  const trnsRgb = colorType === 2 && trns !== undefined ? readTrnsRgbKey(trns) : undefined;
-
-  for (let y = 0; y < height; y++) {
-    const rowStart = y * bytesPerRow;
-    const rowBytes = unfiltered.subarray(rowStart, rowStart + bytesPerRow);
-    const samples = unpackRow(rowBytes, width, channels, bitDepth);
-    for (let x = 0; x < width; x++) {
-      const pixelBase = x * channels;
-      const outBase = (y * width + x) * outChannels;
-      const alphaIndex = y * width + x;
-
-      if (colorType === 0) {
-        const g = samples[pixelBase]!;
-        data[outBase] = scaleToByte(g, bitDepth);
-        if (alpha !== undefined && trnsGray !== undefined) {
-          alpha[alphaIndex] = g === trnsGray ? 0 : 255;
-        }
-      } else if (colorType === 2) {
-        const r = samples[pixelBase]!;
-        const g = samples[pixelBase + 1]!;
-        const b = samples[pixelBase + 2]!;
-        data[outBase] = r;
-        data[outBase + 1] = g;
-        data[outBase + 2] = b;
-        if (alpha !== undefined && trnsRgb !== undefined) {
-          const [kr, kg, kb] = trnsRgb;
-          alpha[alphaIndex] = r === kr && g === kg && b === kb ? 0 : 255;
-        }
-      } else if (colorType === 3) {
-        const index = samples[pixelBase]!;
-        if (palette === undefined) {
-          throw new Error('indexed-colour PNG has no PLTE chunk');
-        }
-        data[outBase] = palette[index * 3]!;
-        data[outBase + 1] = palette[index * 3 + 1]!;
-        data[outBase + 2] = palette[index * 3 + 2]!;
-        if (alpha !== undefined && trns !== undefined) {
-          alpha[alphaIndex] = index < trns.length ? trns[index]! : 255;
-        }
-      } else if (colorType === 4) {
-        const g = samples[pixelBase]!;
-        const a = samples[pixelBase + 1]!;
-        data[outBase] = scaleToByte(g, bitDepth);
-        if (alpha !== undefined) {
-          alpha[alphaIndex] = scaleToByte(a, bitDepth);
-        }
-      } else {
-        // colorType === 6: truecolor + alpha
-        data[outBase] = samples[pixelBase]!;
-        data[outBase + 1] = samples[pixelBase + 1]!;
-        data[outBase + 2] = samples[pixelBase + 2]!;
-        if (alpha !== undefined) {
-          alpha[alphaIndex] = samples[pixelBase + 3]!;
-        }
-      }
-    }
-  }
-
-  return alpha === undefined
-    ? { width, height, channels: outChannels, data }
-    : { width, height, channels: outChannels, data, alpha };
-}

package/src/image/png-encode.ts

@@ -1,74 +0,0 @@
-import { crc32 } from '../bytes/crc32';
-import { deflate } from '../bytes/flate';
-import { ByteWriter, concatBytes } from '../bytes/writer';
-import type { RawImage } from './png-decode';
-import { filterScanlines } from './png-filter';
-
-const PNG_SIGNATURE = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-
-export interface PngEncodeOptions {
-  // 'adaptive' (the default) picks, per row, whichever of the five PNG filters minimises the sum of the filtered bytes' absolute values -- the PNG spec's own recommended heuristic. 'none' always emits filter type 0, useful for deterministic, human-auditable test output.
-  readonly filter?: 'none' | 'adaptive';
-}
-
-function u32be(value: number): Uint8Array<ArrayBuffer> {
-  const bytes = new Uint8Array(4);
-  new DataView(bytes.buffer).setUint32(0, value);
-  return bytes;
-}
-
-function writeChunk(writer: ByteWriter, type: string, data: Uint8Array<ArrayBuffer>): void {
-  const typeBytes = new TextEncoder().encode(type);
-  writer.writeBytes(u32be(data.length));
-  writer.writeBytes(typeBytes);
-  writer.writeBytes(data);
-  writer.writeBytes(u32be(crc32(concatBytes([typeBytes, data]))));
-}
-
-// IHDR colour type: 0 gray, 2 truecolor(RGB), 4 gray+alpha, 6 truecolor+alpha(RGBA). RawImage's channels/alpha combination maps onto these four (never 3, palette -- this encoder never emits an indexed-colour image, since RawImage carries no palette of its own).
-function colorTypeFor(image: RawImage): number {
-  if (image.channels === 1) {
-    return image.alpha === undefined ? 0 : 4;
-  }
-  return image.alpha === undefined ? 2 : 6;
-}
-
-// Encodes normalised raw pixel data (8 bits per channel, optionally with a separate alpha plane) into PNG file bytes -- the exact inverse of decodePng's RawImage shape.
-export function encodePng(image: RawImage, options: PngEncodeOptions = {}): Uint8Array<ArrayBuffer> {
-  const { width, height, channels, data, alpha } = image;
-  const outChannels = alpha === undefined ? channels : channels + 1;
-  const bytesPerRow = width * outChannels;
-  const pixelCount = width * height;
-
-  const interleaved = new Uint8Array(pixelCount * outChannels);
-  for (let i = 0; i < pixelCount; i++) {
-    const srcBase = i * channels;
-    const dstBase = i * outChannels;
-    for (let c = 0; c < channels; c++) {
-      interleaved[dstBase + c] = data[srcBase + c]!;
-    }
-    if (alpha !== undefined) {
-      interleaved[dstBase + channels] = alpha[i]!;
-    }
-  }
-
-  const filtered = filterScanlines(interleaved, height, bytesPerRow, outChannels, options.filter ?? 'adaptive');
-  const compressed = deflate(filtered);
-
-  const ihdr = new Uint8Array(13);
-  const ihdrView = new DataView(ihdr.buffer);
-  ihdrView.setUint32(0, width);
-  ihdrView.setUint32(4, height);
-  ihdr[8] = 8; // bit depth: always 8, since RawImage is always 8 bits per channel
-  ihdr[9] = colorTypeFor(image);
-  ihdr[10] = 0; // compression method: always 0 (deflate)
-  ihdr[11] = 0; // filter method: always 0 (the five-filter adaptive scheme)
-  ihdr[12] = 0; // interlace method: 0 (no interlacing)
-
-  const writer = new ByteWriter();
-  writer.writeBytes(PNG_SIGNATURE);
-  writeChunk(writer, 'IHDR', ihdr);
-  writeChunk(writer, 'IDAT', compressed);
-  writeChunk(writer, 'IEND', new Uint8Array(0));
-  return writer.toBytes();
-}

package/src/image/png-filter.ts

@@ -1,142 +0,0 @@
-// The five PNG scanline (un)filters (PNG spec section 9.2), shared by the PDF cross-reference stream predictor path (src/pdf/predictors.ts): xref streams are almost always /Predictor 12, which is exactly PNG's "Up" filter applied to fixed-width rows, so this module sits on the critical path for reading modern PDFs, not just for PNG images.
-export type PngFilterType = 0 | 1 | 2 | 3 | 4; // None, Sub, Up, Average, Paeth
-
-function paethPredictor(a: number, b: number, c: number): number {
-  const p = a + b - c;
-  const pa = Math.abs(p - a);
-  const pb = Math.abs(p - b);
-  const pc = Math.abs(p - c);
-  if (pa <= pb && pa <= pc) {
-    return a;
-  }
-  if (pb <= pc) {
-    return b;
-  }
-  return c;
-}
-
-// The value a filter type predicts from the left (a), above (b), and above-left (c) samples -- added back in during unfiltering, or subtracted out during filtering. Returning a value from a pure function (rather than assigning inside a switch) sidesteps having to prove a switch over a literal union is exhaustive to a variable declared without an initialiser.
-function isPngFilterType(value: number): value is PngFilterType {
-  return value === 0 || value === 1 || value === 2 || value === 3 || value === 4;
-}
-
-function predictorValue(filterType: PngFilterType, a: number, b: number, c: number): number {
-  if (filterType === 1) {
-    return a;
-  }
-  if (filterType === 2) {
-    return b;
-  }
-  if (filterType === 3) {
-    return Math.floor((a + b) / 2);
-  }
-  if (filterType === 4) {
-    return paethPredictor(a, b, c);
-  }
-  return 0; // None
-}
-
-// Reverses PNG's per-scanline filtering. `data` is the inflated IDAT payload: height rows, each prefixed by one filter-type byte followed by `bytesPerRow` filtered sample bytes. Returns the raw (unfiltered) pixel bytes, height * bytesPerRow long, with the filter-type bytes stripped.
-export function unfilterScanlines(
-  data: Uint8Array<ArrayBuffer>,
-  height: number,
-  bytesPerRow: number,
-  bpp: number,
-): Uint8Array<ArrayBuffer> {
-  const stride = bytesPerRow + 1;
-  if (data.length < height * stride) {
-    throw new Error(
-      `PNG scanline data too short: expected at least ${height * stride} bytes, got ${data.length}`,
-    );
-  }
-  const out = new Uint8Array(height * bytesPerRow);
-  for (let y = 0; y < height; y++) {
-    const filterByte = data[y * stride];
-    if (filterByte === undefined || !isPngFilterType(filterByte)) {
-      throw new Error(`unknown PNG filter type: ${String(filterByte)}`);
-    }
-    const rowStart = y * stride + 1;
-    const outRowStart = y * bytesPerRow;
-    const prevOutRowStart = y > 0 ? outRowStart - bytesPerRow : undefined;
-    for (let x = 0; x < bytesPerRow; x++) {
-      const raw = data[rowStart + x]!;
-      const a = x >= bpp ? out[outRowStart + x - bpp]! : 0;
-      const b = prevOutRowStart === undefined ? 0 : out[prevOutRowStart + x]!;
-      const c = x >= bpp && prevOutRowStart !== undefined ? out[prevOutRowStart + x - bpp]! : 0;
-      out[outRowStart + x] = (raw + predictorValue(filterByte, a, b, c)) & 0xff;
-    }
-  }
-  return out;
-}
-
-function sumOfAbsSigned(bytes: Uint8Array<ArrayBuffer>): number {
-  let sum = 0;
-  for (const byte of bytes) {
-    sum += byte < 128 ? byte : 256 - byte;
-  }
-  return sum;
-}
-
-function filterRowInto(
-  raw: Uint8Array<ArrayBuffer>,
-  rowStart: number,
-  prevRowStart: number | undefined,
-  bytesPerRow: number,
-  bpp: number,
-  filterType: PngFilterType,
-  out: Uint8Array<ArrayBuffer>,
-  outOffset: number,
-): void {
-  for (let x = 0; x < bytesPerRow; x++) {
-    const rawByte = raw[rowStart + x]!;
-    const a = x >= bpp ? raw[rowStart + x - bpp]! : 0;
-    const b = prevRowStart === undefined ? 0 : raw[prevRowStart + x]!;
-    const c = x >= bpp && prevRowStart !== undefined ? raw[prevRowStart + x - bpp]! : 0;
-    out[outOffset + x] = (rawByte - predictorValue(filterType, a, b, c)) & 0xff;
-  }
-}
-
-const ALL_FILTER_TYPES: readonly PngFilterType[] = [0, 1, 2, 3, 4];
-
-// Filters raw (unfiltered) pixel bytes into PNG's per-scanline IDAT payload shape. `strategy: 'none'` always emits filter type 0 (useful for deterministic, human-auditable test output); `'adaptive'` (the default) picks, per row, whichever of the five filters minimises the sum of the filtered bytes' absolute values interpreted as signed -- the heuristic the PNG spec itself recommends.
-export function filterScanlines(
-  raw: Uint8Array<ArrayBuffer>,
-  height: number,
-  bytesPerRow: number,
-  bpp: number,
-  strategy: 'none' | 'adaptive' = 'adaptive',
-): Uint8Array<ArrayBuffer> {
-  const stride = bytesPerRow + 1;
-  const out = new Uint8Array(height * stride);
-  const candidate = new Uint8Array(bytesPerRow);
-
-  for (let y = 0; y < height; y++) {
-    const rowStart = y * bytesPerRow;
-    const prevRowStart = y > 0 ? rowStart - bytesPerRow : undefined;
-    const outRowStart = y * stride;
-
-    if (strategy === 'none') {
-      out[outRowStart] = 0;
-      filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, 0, out, outRowStart + 1);
-      continue;
-    }
-
-    let bestType: PngFilterType = 0;
-    let bestSum = Number.POSITIVE_INFINITY;
-    let best: Uint8Array<ArrayBuffer> | undefined;
-    for (const filterType of ALL_FILTER_TYPES) {
-      filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, filterType, candidate, 0);
-      const sum = sumOfAbsSigned(candidate);
-      if (sum < bestSum) {
-        bestSum = sum;
-        bestType = filterType;
-        best = candidate.slice();
-      }
-    }
-    out[outRowStart] = bestType;
-    if (best !== undefined) {
-      out.set(best, outRowStart + 1);
-    }
-  }
-  return out;
-}

package/src/index.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { crc32, encodePng, decodePng, readJpegInfo, ByteWriter, concatBytes } from './index';
-
-describe('byte-codec smoke', () => {
-  it('crc32 produces a consistent hash for known input', () => {
-    expect(crc32(new Uint8Array([1, 2, 3, 4]))).toBe(crc32(new Uint8Array([1, 2, 3, 4])));
-  });
-
-  it('encodePng then decodePng round-trips a small image', () => {
-    const pixels = new Uint8Array([255, 0, 0, 0, 255, 0, 0, 0, 255, 255, 255, 0]);
-    const png = encodePng({ width: 2, height: 2, channels: 3, data: pixels });
-    const decoded = decodePng(png);
-    expect(decoded.width).toBe(2);
-    expect(decoded.height).toBe(2);
-  });
-
-  it('ByteWriter accumulates and produces concatenated output', () => {
-    const w = new ByteWriter();
-    w.writeByte(1);
-    w.writeByte(2);
-    w.writeByte(3);
-    expect(Array.from(w.toBytes())).toEqual([1, 2, 3]);
-  });
-
-  it('concatBytes joins arrays', () => {
-    const result = concatBytes([new Uint8Array([1, 2]), new Uint8Array([3, 4])]);
-    expect(Array.from(result)).toEqual([1, 2, 3, 4]);
-  });
-
-  it('readJpegInfo throws for non-JPEG input', () => {
-    expect(() => readJpegInfo(new Uint8Array([0, 0, 0]))).toThrow(/JPEG/);
-  });
-});

package/src/index.ts

@@ -1,9 +0,0 @@
-// The shared byte/image utility package for the documents.js family: generic byte-level primitives (ByteWriter, ByteReader, CRC-32, deflate/inflate) and PNG/JPEG image encoding/decoding with zero PDF knowledge. Extracted from pdf-codec (where they lived as a directory-isolated subgraph with no PDF imports) so both pdf-codec and documents.js consume them from a neutral home rather than one fetching byte utilities from a backend.
-export * from './bytes/writer';
-export * from './bytes/reader';
-export * from './bytes/crc32';
-export * from './bytes/flate';
-export * from './image/png-encode';
-export * from './image/png-decode';
-export * from './image/png-filter';
-export * from './image/jpeg-info';

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "target": "ES2024",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ES2024"],
-    "types": ["node"],
-    "noEmit": true,
-    "skipLibCheck": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": true,
-    "forceConsistentCasingInFileNames": true,
-    "esModuleInterop": true
-  },
-  "include": ["src"]
-}

package/tsdown.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'tsdown';
-
-export default defineConfig({
-  entry: ['src/**/*.ts', '!src/**/*.test.ts'],
-  root: 'src',
-  format: ['esm', 'cjs'],
-  dts: true,
-  platform: 'neutral',
-  clean: true,
-});