imgcap 1.0.0

package/.commitlintrc

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "@commitlint/config-conventional"
+  ]
+}

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# https://github.com/dependabot/dependabot-core/issues/1736
+
+version: 2
+updates:
+  # Enable version updates for npm
+  - package-ecosystem: 'npm'
+    # Look for `package.json` and `lock` files in the `root` directory
+    directory: '/'
+    # Check the npm registry for updates every day (weekdays)
+    schedule:
+      interval: 'weekly'

package/.github/workflows/cd.yml

@@ -0,0 +1,85 @@
+name: CD
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      cache-hit: ${{ steps.pnpm-cache.outputs.cache-hit }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - uses: pnpm/action-setup@v4
+        with:
+          version: latest
+      - name: Cache pnpm store
+        uses: actions/cache@v3
+        id: pnpm-cache
+        with:
+          path: |
+            ~/.pnpm-store
+            node_modules
+          key: ${{ runner.os }}-pnpm-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+  linter:
+    needs: [setup]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - uses: pnpm/action-setup@v4
+        with:
+          version: latest
+      - name: Restore dependencies
+        if: needs.setup.outputs.cache-hit != 'true'
+        run: pnpm install --frozen-lockfile
+      - run: pnpm run build
+      - run: pnpm run lint
+      - run: pnpm run check
+
+  tests:
+    needs: [setup]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - uses: pnpm/action-setup@v4
+        with:
+          version: latest
+      - name: Restore dependencies
+        if: needs.setup.outputs.cache-hit != 'true'
+        run: pnpm install --frozen-lockfile
+      - run: pnpm run build
+      - run: pnpm run test
+  release:
+    needs: [setup, linter, tests]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - uses: pnpm/action-setup@v4
+        with:
+          version: latest
+      - name: Restore dependencies
+        if: needs.setup.outputs.cache-hit != 'true'
+        run: pnpm install --frozen-lockfile --ignore-scripts
+      - run: pnpm run build
+      - run: pnpm semantic-release
+        env:
+          GH_TOKEN: ${{ secrets.IMGCAP_GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.IMGCAP_NPM_TOKEN }}

package/.github/workflows/ci.yml

@@ -0,0 +1,65 @@
+name: CI
+
+on:
+  push:
+    branches: [develop]
+  pull_request:
+    branches: [develop]
+
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      cache-hit: ${{ steps.pnpm-cache.outputs.cache-hit }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - uses: pnpm/action-setup@v4
+        with:
+          version: latest
+      - name: Cache pnpm store
+        uses: actions/cache@v3
+        id: pnpm-cache
+        with:
+          path: |
+            ~/.pnpm-store
+            node_modules
+          key: ${{ runner.os }}-pnpm-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-
+  linter:
+    needs: [setup]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - uses: pnpm/action-setup@v4
+        with:
+          version: latest
+      - name: Restore dependencies
+        if: needs.setup.outputs.cache-hit != 'true'
+        run: pnpm install --frozen-lockfile
+      - run: pnpm run build
+      - run: pnpm run lint
+      - run: pnpm run check
+
+  tests:
+    needs: [setup]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - uses: pnpm/action-setup@v4
+        with:
+          version: latest
+      - name: Restore dependencies
+        if: needs.setup.outputs.cache-hit != 'true'
+        run: pnpm install --frozen-lockfile
+      - run: pnpm run build
+      - run: pnpm run test

package/.husky/commit-msg

@@ -0,0 +1 @@
+pnpm commitlint --edit "$1"

package/.husky/pre-commit

@@ -0,0 +1 @@
+pnpm lint && pnpm check

package/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "printWidth": 120
+}

package/.releaserc

@@ -0,0 +1,13 @@
+{
+  "branches": [
+    "master"
+  ],
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    "@semantic-release/github",
+    "@semantic-release/npm",
+    "@semantic-release/git"
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# 1.0.0 (2025-07-14)
+
+
+### Performance Improvements
+
+* add comments ([ae0d4ce](https://github.com/molvqingtai/imgcap/commit/ae0d4ce6adba6c3fb5794319a3ea005f1e1929f7))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 John Wu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# ImgCap
+
+> Automatically compress images to exact file size using binary search algorithm. No more "file too large" errors.
+
+## Why ImgCap?
+
+Users often encounter "File too large" errors when uploading images, forcing them to manually compress files using external tools. This creates friction and leads to user dropout. imgcap solves this by automatically compressing images to exact size requirements - no user intervention needed.
+
+```typescript
+// Before: User sees error, leaves frustrated
+❌ "File too large: Image upload size cannot exceed 2MB"
+
+// After: Seamless auto-compression
+✅ await imgcap(userPhoto, { targetSize: 2 * 1024 * 1024 })
+```
+
+## Installation
+
+```bash
+pnpm install imgcap
+```
+
+## Usage
+
+```typescript
+import imgcap from 'imgcap'
+
+// Social media avatar (500KB limit)
+const avatar = await imgcap(file, { targetSize: 500 * 1024 })
+
+// With format conversion
+const webp = await imgcap(imageFile, {
+  targetSize: 300 * 1024,
+  outputType: 'image/webp'
+})
+```
+
+## API
+
+```typescript
+interface Options {
+  targetSize: number // Target file size in bytes
+  toleranceSize?: number // Size tolerance (default: -1024)
+  outputType?: ImageType // Output format (default: same as input)
+}
+
+type ImageType = 'image/jpeg' | 'image/png' | 'image/webp' | 'image/avif'
+```
+
+**Browser only** - Requires OffscreenCanvas support (modern browsers).
+
+## License
+
+MIT © [molvqingtai](https://github.com/molvqingtai)

package/__tests__/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "printWidth": 120
+}

package/__tests__/eslint.config.ts

@@ -0,0 +1,18 @@
+import globals from 'globals'
+import pluginJs from '@eslint/js'
+import tseslint from 'typescript-eslint'
+import prettierPlugin from 'eslint-plugin-prettier/recommended'
+
+export default [
+  { files: ['**/*.{js,mjs,cjs,ts}'] },
+  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  prettierPlugin,
+  {
+    ignores: ['**/dist/*']
+  },
+  {
+    rules: {}
+  }
+]

package/__tests__/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "__tests__",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "vitest --browser.headless",
+    "lint": "eslint --fix --cache",
+    "check": "tsc --noEmit",
+    "postinstall": "playwright install --with-deps chromium"
+  },
+  "keywords": [],
+  "author": "molvqingtai",
+  "license": "MIT",
+  "dependencies": {
+    "imgcap": "workspace:*"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4",
+    "@vitest/browser": "^3.2.4",
+    "playwright": "^1.49.1",
+    "@eslint/js": "^9.31.0",
+    "eslint": "^9.31.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.5.1",
+    "globals": "^16.3.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.36.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/__tests__/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "baseUrl": ".",
+    "rootDir": ".",
+    /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+    "skipLibCheck": true /* Skip type checking of declaration files. */,
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
+    "moduleResolution": "Node",
+    "isolatedModules": true
+  }
+}

package/__tests__/unit/imgcap.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { createTestImageBlob } from '../utils'
+import { imgcap } from 'imgcap'
+
+describe('imgcap', () => {
+  let testImageBlob: Blob
+
+  beforeAll(async () => {
+    testImageBlob = await createTestImageBlob(200, 200, 'image/png')
+  })
+
+  describe('Input Validation', () => {
+    it('should throw error for unsupported image type', async () => {
+      const invalidBlob = new Blob(['test'], { type: 'text/plain' })
+
+      await expect(imgcap(invalidBlob, { targetSize: 10000 })).rejects.toThrow(
+        'Only PNG, JPEG, WebP and AVIF images are supported.'
+      )
+    })
+
+    it('should throw error for tolerance size less than 1024', async () => {
+      await expect(imgcap(testImageBlob, { targetSize: 10000, toleranceSize: 512 })).rejects.toThrow(
+        'Tolerance size must be at least ±1024 bytes.'
+      )
+    })
+
+    it('should throw error for negative tolerance size less than -1024', async () => {
+      await expect(imgcap(testImageBlob, { targetSize: 10000, toleranceSize: -512 })).rejects.toThrow(
+        'Tolerance size must be at least ±1024 bytes.'
+      )
+    })
+
+    it('should accept tolerance size of exactly ±1024', async () => {
+      await expect(imgcap(testImageBlob, { targetSize: 10000, toleranceSize: 1024 })).resolves.toBeDefined()
+
+      await expect(imgcap(testImageBlob, { targetSize: 10000, toleranceSize: -1024 })).resolves.toBeDefined()
+    })
+
+    it('should accept tolerance size greater than ±1024', async () => {
+      await expect(imgcap(testImageBlob, { targetSize: 10000, toleranceSize: 2048 })).resolves.toBeDefined()
+
+      await expect(imgcap(testImageBlob, { targetSize: 10000, toleranceSize: -2048 })).resolves.toBeDefined()
+    })
+  })
+
+  describe('Basic Functionality', () => {
+    it('should return original blob if already smaller than target size', async () => {
+      const smallBlob = await createTestImageBlob(10, 10, 'image/png')
+      const result = await imgcap(smallBlob, { targetSize: 100000 })
+
+      expect(result).toBe(smallBlob)
+      expect(result.size).toBe(smallBlob.size)
+    })
+
+    it('should compress image to approximate target size', async () => {
+      const targetSize = 5000
+      const result = await imgcap(testImageBlob, {
+        targetSize,
+        toleranceSize: -1024
+      })
+
+      expect(result).toBeInstanceOf(Blob)
+      expect(result.size).toBeLessThanOrEqual(targetSize)
+      // 允许更大的容差范围，因为压缩算法可能产生更小的文件
+      expect(result.size).toBeGreaterThan(500)
+    })
+
+    it('should respect tolerance range', async () => {
+      const targetSize = 3000
+      const toleranceSize = -1024
+      const result = await imgcap(testImageBlob, {
+        targetSize,
+        toleranceSize
+      })
+
+      const lowerBound = targetSize + Math.min(0, toleranceSize)
+      const upperBound = targetSize + Math.max(0, toleranceSize)
+
+      expect(result.size).toBeLessThanOrEqual(upperBound)
+      // 对于负容差，只检查上界，因为压缩可能产生比期望更小的文件
+      if (toleranceSize < 0) {
+        expect(result.size).toBeGreaterThan(500) // 确保不会过小
+      } else {
+        expect(result.size).toBeGreaterThanOrEqual(lowerBound)
+      }
+    })
+  })
+
+  describe('Output Format Control', () => {
+    it('should maintain original format when no outputType specified', async () => {
+      const jpegBlob = await createTestImageBlob(100, 100, 'image/jpeg')
+      const result = await imgcap(jpegBlob, { targetSize: 10000 })
+
+      expect(result.type).toBe('image/jpeg')
+    })
+
+    it('should convert to specified output format', async () => {
+      const result = await imgcap(testImageBlob, {
+        targetSize: 10000,
+        outputType: 'image/jpeg'
+      })
+
+      expect(result.type).toBe('image/jpeg')
+    })
+
+    it('should handle PNG to WebP conversion', async () => {
+      const result = await imgcap(testImageBlob, {
+        targetSize: 10000,
+        outputType: 'image/webp'
+      })
+
+      expect(result.type).toBe('image/webp')
+    })
+  })
+
+  describe('Compression Quality', () => {
+    it('should compress large images significantly', async () => {
+      const largeBlob = await createTestImageBlob(500, 500, 'image/png')
+      const targetSize = 5000
+      const result = await imgcap(largeBlob, { targetSize })
+
+      expect(result.size).toBeLessThan(largeBlob.size)
+      expect(result.size).toBeLessThanOrEqual(targetSize)
+    })
+
+    it('should handle very small target sizes', async () => {
+      const targetSize = 2000
+      const result = await imgcap(testImageBlob, {
+        targetSize,
+        toleranceSize: -1024
+      })
+
+      expect(result.size).toBeLessThanOrEqual(targetSize)
+      expect(result.size).toBeGreaterThan(500) // Should not be too small
+    })
+
+    it('should handle edge case with very large tolerance', async () => {
+      const targetSize = 5000
+      const toleranceSize = 10000
+      const result = await imgcap(testImageBlob, {
+        targetSize,
+        toleranceSize
+      })
+
+      expect(result.size).toBeLessThanOrEqual(targetSize + toleranceSize)
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should handle invalid image data gracefully', async () => {
+      const invalidImageBlob = new Blob(['not an image'], { type: 'text/plain' })
+
+      await expect(imgcap(invalidImageBlob, { targetSize: 10000 })).rejects.toThrow()
+    })
+
+    it('should handle zero target size', async () => {
+      await expect(imgcap(testImageBlob, { targetSize: 0 })).rejects.toThrow()
+    })
+
+    it('should handle negative target size', async () => {
+      await expect(imgcap(testImageBlob, { targetSize: -1000 })).rejects.toThrow()
+    })
+  })
+
+  describe('Format Support', () => {
+    it('should handle JPEG input', async () => {
+      const jpegBlob = await createTestImageBlob(150, 150, 'image/jpeg')
+      const result = await imgcap(jpegBlob, { targetSize: 8000 })
+
+      expect(result).toBeInstanceOf(Blob)
+      expect(result.type).toBe('image/jpeg')
+    })
+
+    it('should handle WebP format', async () => {
+      const webpBlob = await createTestImageBlob(150, 150, 'image/webp')
+      const result = await imgcap(webpBlob, { targetSize: 8000 })
+
+      expect(result).toBeInstanceOf(Blob)
+      expect(result.type).toBe('image/webp')
+    })
+  })
+
+  describe('Performance', () => {
+    it('should handle concurrent compressions', async () => {
+      const promises = Array.from({ length: 3 }, (_, i) => imgcap(testImageBlob, { targetSize: 4000 + i * 1000 }))
+
+      const results = await Promise.all(promises)
+
+      results.forEach((result, i) => {
+        expect(result).toBeInstanceOf(Blob)
+        expect(result.size).toBeLessThanOrEqual(4000 + i * 1000)
+      })
+    })
+  })
+})

package/__tests__/utils/index.ts

@@ -0,0 +1,18 @@
+import { type ImageType } from 'imgcap'
+
+// Helper function to create a test image blob
+export const createTestImageBlob = async (width: number = 100, height: number = 100, type: ImageType = 'image/png') => {
+  const canvas = new OffscreenCanvas(width, height)
+  const ctx = canvas.getContext('2d')!
+  // Draw a simple pattern
+  ctx.fillStyle = '#ff0000'
+  ctx.fillRect(0, 0, width / 2, height / 2)
+  ctx.fillStyle = '#00ff00'
+  ctx.fillRect(width / 2, 0, width / 2, height / 2)
+  ctx.fillStyle = '#0000ff'
+  ctx.fillRect(0, height / 2, width / 2, height / 2)
+  ctx.fillStyle = '#ffff00'
+  ctx.fillRect(width / 2, height / 2, width / 2, height / 2)
+
+  return await canvas.convertToBlob({ type })
+}

package/__tests__/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    browser: {
+      enabled: true,
+      provider: 'playwright',
+      instances: [{ browser: 'chromium' }]
+    }
+  }
+})

package/core/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "printWidth": 120
+}

package/core/dist/index.d.ts

@@ -0,0 +1,35 @@
+//#region src/index.d.ts
+/** Supported image formats */
+type ImageType = 'image/jpeg' | 'image/png' | 'image/webp' | 'image/avif';
+/** Compression options */
+interface Options {
+  /** Target file size in bytes */
+  targetSize: number;
+  /** Size tolerance in bytes (default: -1024) */
+  toleranceSize?: number;
+  /** Output image format (default: same as input) */
+  outputType?: ImageType;
+}
+/**
+ * Compress an image to exact target file size using binary search algorithm.
+ *
+ * @param input - Image blob/file to compress
+ * @param options - Compression options
+ * @returns Promise that resolves to compressed image blob
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - compress to 500KB
+ * const compressed = await imgcap(imageFile, { targetSize: 500 * 1024 })
+ *
+ * // With format conversion
+ * const webp = await imgcap(imageFile, {
+ *   targetSize: 300 * 1024,
+ *   outputType: 'image/webp'
+ * })
+ * ```
+ */
+declare const imgcap: (input: Blob, options: Options) => Promise<Blob>;
+//#endregion
+export { ImageType, Options, imgcap as default, imgcap };
+//# sourceMappingURL=index.d.ts.map

package/core/dist/index.js

@@ -0,0 +1,2 @@
+const e=async(t,n,r,i,a,o)=>{let s=(r+i)/2,c=Math.round(t.width*s),l=Math.round(t.height*s),u=new OffscreenCanvas(c,l),d=u.getContext(`2d`);d.drawImage(t,0,0,t.width,t.height,0,0,c,l);let f=await u.convertToBlob({type:o,quality:s}),p=f.size,m=n+Math.min(0,a),h=n+Math.max(0,a);return p>=m&&p<=h||(i-r)/i<.001?f:p>n?await e(t,n,r,s,a,o):await e(t,n,s,i,a,o)},t=async(t,n)=>{let{targetSize:r,toleranceSize:i=-1024}=n;if(![`image/jpeg`,`image/png`,`image/webp`,`image/avif`].includes(t.type))throw Error(`Only PNG, JPEG, WebP and AVIF images are supported.`);if(Math.abs(i)<1024)throw Error(`Tolerance size must be at least ±1024 bytes.`);let a=n.outputType||t.type;if(t.size<=r&&t.type===a)return t;let o=await createImageBitmap(t),s=0,c=1;return await e(o,r,s,c,i,a)};var n=t;export{n as default,t as imgcap};
+//# sourceMappingURL=index.js.map

package/core/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["imageBitmap: ImageBitmap","targetSize: number","low: number","high: number","toleranceSize: number","outputType: ImageType","input: Blob","options: Options"],"sources":["../src/index.ts"],"sourcesContent":["/** Supported image formats */\nexport type ImageType = 'image/jpeg' | 'image/png' | 'image/webp' | 'image/avif'\n\n/** Compression options */\nexport interface Options {\n  /** Target file size in bytes */\n  targetSize: number\n  /** Size tolerance in bytes (default: -1024) */\n  toleranceSize?: number\n  /** Output image format (default: same as input) */\n  outputType?: ImageType\n}\n\nconst compress = async (\n  imageBitmap: ImageBitmap,\n  targetSize: number,\n  low: number,\n  high: number,\n  toleranceSize: number,\n  outputType: ImageType\n): Promise<Blob> => {\n  // Calculate the middle quality value\n  const mid = (low + high) / 2\n\n  // Calculate the width and height after scaling\n  const width = Math.round(imageBitmap.width * mid)\n  const height = Math.round(imageBitmap.height * mid)\n\n  const offscreenCanvas = new OffscreenCanvas(width, height)\n  const offscreenContext = offscreenCanvas.getContext('2d')!\n\n  // Draw the scaled image\n  offscreenContext.drawImage(imageBitmap, 0, 0, imageBitmap.width, imageBitmap.height, 0, 0, width, height)\n\n  const outputBlob = await offscreenCanvas.convertToBlob({ type: outputType, quality: mid })\n\n  const currentSize = outputBlob.size\n\n  // Check if current size is within tolerance range\n  const lowerBound = targetSize + Math.min(0, toleranceSize)\n  const upperBound = targetSize + Math.max(0, toleranceSize)\n\n  if (currentSize >= lowerBound && currentSize <= upperBound) {\n    return outputBlob\n  }\n\n  // Use relative error\n  if ((high - low) / high < 0.001) {\n    return outputBlob\n  }\n\n  if (currentSize > targetSize) {\n    return await compress(imageBitmap, targetSize, low, mid, toleranceSize, outputType)\n  } else {\n    return await compress(imageBitmap, targetSize, mid, high, toleranceSize, outputType)\n  }\n}\n\n/**\n * Compress an image to exact target file size using binary search algorithm.\n *\n * @param input - Image blob/file to compress\n * @param options - Compression options\n * @returns Promise that resolves to compressed image blob\n *\n * @example\n * ```typescript\n * // Basic usage - compress to 500KB\n * const compressed = await imgcap(imageFile, { targetSize: 500 * 1024 })\n *\n * // With format conversion\n * const webp = await imgcap(imageFile, {\n *   targetSize: 300 * 1024,\n *   outputType: 'image/webp'\n * })\n * ```\n */\nexport const imgcap = async (input: Blob, options: Options) => {\n  const { targetSize, toleranceSize = -1024 } = options\n\n  if (!['image/jpeg', 'image/png', 'image/webp', 'image/avif'].includes(input.type)) {\n    throw new Error('Only PNG, JPEG, WebP and AVIF images are supported.')\n  }\n\n  if (Math.abs(toleranceSize) < 1024) {\n    throw new Error('Tolerance size must be at least ±1024 bytes.')\n  }\n\n  const outputType = options.outputType || (input.type as ImageType)\n\n  if (input.size <= targetSize && input.type === outputType) {\n    return input\n  }\n\n  const imageBitmap = await createImageBitmap(input)\n\n  // Initialize quality range\n  const low = 0\n  const high = 1\n\n  return await compress(imageBitmap, targetSize, low, high, toleranceSize, outputType)\n}\n\nexport default imgcap\n"],"mappings":"AAaA,MAAM,EAAW,MACfA,EACAC,EACAC,EACAC,EACAC,EACAC,IACkB,CAElB,IAAM,GAAO,EAAM,GAAQ,EAGrB,EAAQ,KAAK,MAAM,EAAY,MAAQ,EAAI,CAC3C,EAAS,KAAK,MAAM,EAAY,OAAS,EAAI,CAE7C,EAAkB,IAAI,gBAAgB,EAAO,GAC7C,EAAmB,EAAgB,WAAW,KAAK,CAGzD,EAAiB,UAAU,EAAa,EAAG,EAAG,EAAY,MAAO,EAAY,OAAQ,EAAG,EAAG,EAAO,EAAO,CAEzG,IAAM,EAAa,KAAM,GAAgB,cAAc,CAAE,KAAM,EAAY,QAAS,CAAK,EAAC,CAEpF,EAAc,EAAW,KAGzB,EAAa,EAAa,KAAK,IAAI,EAAG,EAAc,CACpD,EAAa,EAAa,KAAK,IAAI,EAAG,EAAc,CAcxD,OAZE,GAAe,GAAc,GAAe,IAK3C,EAAO,GAAO,EAAO,KACjB,EAGL,EAAc,EACT,KAAM,GAAS,EAAa,EAAY,EAAK,EAAK,EAAe,EAAW,CAE5E,KAAM,GAAS,EAAa,EAAY,EAAK,EAAM,EAAe,EAAW,AAEvF,EAqBY,EAAS,MAAOC,EAAaC,IAAqB,CAC7D,GAAM,CAAE,aAAY,gBAAgB,MAAO,CAAG,EAE9C,IAAK,CAAC,aAAc,YAAa,aAAc,YAAa,EAAC,SAAS,EAAM,KAAK,CAC/E,KAAM,CAAI,MAAM,sDAAA,CAGlB,GAAI,KAAK,IAAI,EAAc,CAAG,KAC5B,KAAM,CAAI,MAAM,+CAAA,CAGlB,IAAM,EAAa,EAAQ,YAAe,EAAM,KAEhD,GAAI,EAAM,MAAQ,GAAc,EAAM,OAAS,EAC7C,OAAO,EAGT,IAAM,EAAc,KAAM,mBAAkB,EAAM,CAG5C,EAAM,EACN,EAAO,EAEb,OAAO,KAAM,GAAS,EAAa,EAAY,EAAK,EAAM,EAAe,EAAW,AACrF,EAED,IAAA,EAAe"}

package/core/eslint.config.ts

@@ -0,0 +1,18 @@
+import globals from 'globals'
+import pluginJs from '@eslint/js'
+import tseslint from 'typescript-eslint'
+import prettierPlugin from 'eslint-plugin-prettier/recommended'
+
+export default [
+  { files: ['**/*.{js,mjs,cjs,ts}'] },
+  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  prettierPlugin,
+  {
+    ignores: ['**/dist/*']
+  },
+  {
+    rules: {}
+  }
+]

package/core/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "core",
+  "version": "1.0.0",
+  "description": "Precisely cap your image size.",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "dev": "tsdown src/index.ts --dts --format esm --sourcemap --watch",
+    "build": "tsdown src/index.ts --dts --format esm --sourcemap --minify --clean",
+    "lint": "eslint --fix --cache",
+    "check": "tsc --noEmit"
+  },
+  "keywords": [],
+  "author": "molvqingtai",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^9.31.0",
+    "eslint": "^9.31.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.5.1",
+    "globals": "^16.3.0",
+    "tsdown": "^0.12.9",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.36.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/core/src/index.ts

@@ -0,0 +1,104 @@
+/** Supported image formats */
+export type ImageType = 'image/jpeg' | 'image/png' | 'image/webp' | 'image/avif'
+
+/** Compression options */
+export interface Options {
+  /** Target file size in bytes */
+  targetSize: number
+  /** Size tolerance in bytes (default: -1024) */
+  toleranceSize?: number
+  /** Output image format (default: same as input) */
+  outputType?: ImageType
+}
+
+const compress = async (
+  imageBitmap: ImageBitmap,
+  targetSize: number,
+  low: number,
+  high: number,
+  toleranceSize: number,
+  outputType: ImageType
+): Promise<Blob> => {
+  // Calculate the middle quality value
+  const mid = (low + high) / 2
+
+  // Calculate the width and height after scaling
+  const width = Math.round(imageBitmap.width * mid)
+  const height = Math.round(imageBitmap.height * mid)
+
+  const offscreenCanvas = new OffscreenCanvas(width, height)
+  const offscreenContext = offscreenCanvas.getContext('2d')!
+
+  // Draw the scaled image
+  offscreenContext.drawImage(imageBitmap, 0, 0, imageBitmap.width, imageBitmap.height, 0, 0, width, height)
+
+  const outputBlob = await offscreenCanvas.convertToBlob({ type: outputType, quality: mid })
+
+  const currentSize = outputBlob.size
+
+  // Check if current size is within tolerance range
+  const lowerBound = targetSize + Math.min(0, toleranceSize)
+  const upperBound = targetSize + Math.max(0, toleranceSize)
+
+  if (currentSize >= lowerBound && currentSize <= upperBound) {
+    return outputBlob
+  }
+
+  // Use relative error
+  if ((high - low) / high < 0.001) {
+    return outputBlob
+  }
+
+  if (currentSize > targetSize) {
+    return await compress(imageBitmap, targetSize, low, mid, toleranceSize, outputType)
+  } else {
+    return await compress(imageBitmap, targetSize, mid, high, toleranceSize, outputType)
+  }
+}
+
+/**
+ * Compress an image to exact target file size using binary search algorithm.
+ *
+ * @param input - Image blob/file to compress
+ * @param options - Compression options
+ * @returns Promise that resolves to compressed image blob
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - compress to 500KB
+ * const compressed = await imgcap(imageFile, { targetSize: 500 * 1024 })
+ *
+ * // With format conversion
+ * const webp = await imgcap(imageFile, {
+ *   targetSize: 300 * 1024,
+ *   outputType: 'image/webp'
+ * })
+ * ```
+ */
+export const imgcap = async (input: Blob, options: Options) => {
+  const { targetSize, toleranceSize = -1024 } = options
+
+  if (!['image/jpeg', 'image/png', 'image/webp', 'image/avif'].includes(input.type)) {
+    throw new Error('Only PNG, JPEG, WebP and AVIF images are supported.')
+  }
+
+  if (Math.abs(toleranceSize) < 1024) {
+    throw new Error('Tolerance size must be at least ±1024 bytes.')
+  }
+
+  const outputType = options.outputType || (input.type as ImageType)
+
+  if (input.size <= targetSize && input.type === outputType) {
+    return input
+  }
+
+  const imageBitmap = await createImageBitmap(input)
+
+  // Initialize quality range
+  const low = 0
+  const high = 1
+
+  return await compress(imageBitmap, targetSize, low, high, toleranceSize, outputType)
+}
+
+export default imgcap

package/core/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "baseUrl": ".",
+    "rootDir": "src",
+    "target": "ESNext" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
+    "module": "ESNext" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+    "lib": ["ESNext", "Dom"] /* Specify library files to be included in the compilation. */,
+    "outDir": "dist" /* Redirect output structure to the directory. */,
+    "sourceMap": true,
+    "declaration": true /* Generates corresponding '.d.ts' file. */,
+    /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+    "skipLibCheck": true /* Skip type checking of declaration files. */,
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
+    "moduleResolution": "Node",
+    "isolatedModules": true,
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src"]
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "imgcap",
+  "version": "1.0.0",
+  "description": "Precisely cap your image size.",
+  "type": "module",
+  "main": "core/dist/index.js",
+  "scripts": {
+    "dev": "pnpm --filter core dev",
+    "build": "pnpm --filter core build",
+    "lint": "npm-run-all -p lint:*",
+    "check": "npm-run-all -p check:*",
+    "test": "pnpm --filter __tests__ test",
+    "lint:core": "pnpm --filter core lint",
+    "lint:tests": "pnpm --filter __tests__ lint",
+    "check:core": "pnpm --filter core check",
+    "check:tests": "pnpm --filter __tests__ check",
+    "prepare": "husky"
+  },
+  "keywords": [
+    "image",
+    "compression",
+    "compress",
+    "resize",
+    "optimize",
+    "binary-search",
+    "file-size",
+    "target-size",
+    "precise-size",
+    "webp",
+    "avif",
+    "jpeg",
+    "png",
+    "browser",
+    "typescript",
+    "upload",
+    "quality",
+    "canvas",
+    "offscreen-canvas"
+  ],
+  "author": "molvqingtai",
+  "license": "MIT",
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "husky": "^9.1.7",
+    "npm-run-all": "^4.1.5",
+    "semantic-release": "^24.2.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+packages:
+  - 'core'
+  - '__tests__'