@pallasoft/ps-file-components 1.3.0 → 1.5.0

package/dist/esm/services/ps-scan-enhance-service.js

@@ -0,0 +1,97 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanFilter } from '../constants/ps-scan-filter';
+import { PsScanImageFilterService } from './ps-scan-image-filter-service';
+import { PsScanRasterService } from './ps-scan-raster-service';
+export class PsScanEnhanceService {
+    static apply(source, filter) {
+        if (filter === PsScanFilter.Original)
+            return source;
+        if (filter === PsScanFilter.Colour)
+            return PsScanEnhanceService.colour(source);
+        if (filter === PsScanFilter.Greyscale)
+            return PsScanEnhanceService.greyscale(source);
+        return PsScanEnhanceService.document(source);
+    }
+    static colour(source) {
+        const gray = PsScanImageFilterService.grayscale(source);
+        const { black, white } = PsScanEnhanceService.levels(gray);
+        const gain = 255 / Math.max(1, white - black);
+        const target = PsScanRasterService.create(source.width, source.height);
+        for (let at = 0; at < source.data.length; at += 4) {
+            target.data[at] = (source.data[at] - black) * gain;
+            target.data[at + 1] = (source.data[at + 1] - black) * gain;
+            target.data[at + 2] = (source.data[at + 2] - black) * gain;
+            target.data[at + 3] = 255;
+        }
+        return target;
+    }
+    static document(source) {
+        const { height, width } = source;
+        const gray = PsScanImageFilterService.grayscale(source);
+        const integral = new Float64Array((width + 1) * (height + 1));
+        for (let y = 0; y < height; y += 1) {
+            let row = 0;
+            for (let x = 0; x < width; x += 1) {
+                row += gray[y * width + x];
+                integral[(y + 1) * (width + 1) + x + 1] = integral[y * (width + 1) + x + 1] + row;
+            }
+        }
+        const half = Math.max(PsScanConfig.adaptiveWindowMin, Math.floor(Math.min(width, height) / PsScanConfig.adaptiveWindowDivisor)) >> 1;
+        const target = PsScanRasterService.create(width, height);
+        for (let y = 0; y < height; y += 1) {
+            const y0 = Math.max(0, y - half);
+            const y1 = Math.min(height, y + half + 1);
+            for (let x = 0; x < width; x += 1) {
+                const x0 = Math.max(0, x - half);
+                const x1 = Math.min(width, x + half + 1);
+                const sum = integral[y1 * (width + 1) + x1] -
+                    integral[y0 * (width + 1) + x1] -
+                    integral[y1 * (width + 1) + x0] +
+                    integral[y0 * (width + 1) + x0];
+                const mean = sum / ((x1 - x0) * (y1 - y0));
+                const value = gray[y * width + x] < mean * PsScanConfig.adaptiveRatio ? 0 : 255;
+                const at = (y * width + x) * 4;
+                target.data[at] = value;
+                target.data[at + 1] = value;
+                target.data[at + 2] = value;
+                target.data[at + 3] = 255;
+            }
+        }
+        return target;
+    }
+    static greyscale(source) {
+        const gray = PsScanImageFilterService.grayscale(source);
+        const { black, white } = PsScanEnhanceService.levels(gray);
+        const gain = 255 / Math.max(1, white - black);
+        const target = PsScanRasterService.create(source.width, source.height);
+        for (let index = 0; index < gray.length; index += 1) {
+            const value = (gray[index] - black) * gain;
+            const at = index * 4;
+            target.data[at] = value;
+            target.data[at + 1] = value;
+            target.data[at + 2] = value;
+            target.data[at + 3] = 255;
+        }
+        return target;
+    }
+    static levels(gray) {
+        const bins = new Uint32Array(256);
+        gray.forEach((value) => {
+            bins[value] += 1;
+        });
+        const find = (fraction) => {
+            const target = gray.length * fraction;
+            let cumulative = 0;
+            for (let bin = 0; bin < 256; bin += 1) {
+                cumulative += bins[bin];
+                if (cumulative >= target)
+                    return bin;
+            }
+            return 255;
+        };
+        return {
+            black: find(PsScanConfig.levelLowPercentile),
+            white: find(PsScanConfig.levelHighPercentile),
+        };
+    }
+}

package/dist/esm/services/ps-scan-file-name-service.js

@@ -0,0 +1,25 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanOutputFormat } from '../constants/ps-scan-output-format';
+export class PsScanFileNameService {
+    static build(base, format, index, count) {
+        const stem = PsScanFileNameService.sanitize(base);
+        if (format === PsScanOutputFormat.Pdf)
+            return `${stem}.pdf`;
+        if (count <= 1)
+            return `${stem}.jpg`;
+        return `${stem}-${String(index + 1).padStart(String(count).length, '0')}.jpg`;
+    }
+    static mimeType(format) {
+        return format === PsScanOutputFormat.Pdf ? 'application/pdf' : 'image/jpeg';
+    }
+    static sanitize(base) {
+        const cleaned = Array.from(base)
+            .filter((char) => char.charCodeAt(0) >= 32)
+            .join('')
+            .replace(/\.(pdf|jpe?g)$/i, '')
+            .replace(/[\\/:*?"<>|]+/g, '-')
+            .replace(/\s+/g, ' ')
+            .replace(/^[\s.-]+|[\s.-]+$/g, '');
+        return cleaned.length === 0 ? PsScanConfig.defaultFileName : cleaned.slice(0, 80);
+    }
+}

package/dist/esm/services/ps-scan-geometry-service.js

@@ -0,0 +1,116 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+export class PsScanGeometryService {
+    static area(points) {
+        let sum = 0;
+        points.forEach((point, index) => {
+            const next = points[(index + 1) % points.length];
+            sum += point.x * next.y - next.x * point.y;
+        });
+        return Math.abs(sum) / 2;
+    }
+    static clamp(point) {
+        return { x: Math.min(1, Math.max(0, point.x)), y: Math.min(1, Math.max(0, point.y)) };
+    }
+    static cover(container, content) {
+        if (container.width <= 0 || container.height <= 0 || content.width <= 0 || content.height <= 0)
+            return { height: 0, width: 0 };
+        const scale = Math.max(container.width / content.width, container.height / content.height);
+        return { height: content.height * scale, width: content.width * scale };
+    }
+    static defaultQuad() {
+        const inset = 0.08;
+        return [
+            { x: inset, y: inset },
+            { x: 1 - inset, y: inset },
+            { x: 1 - inset, y: 1 - inset },
+            { x: inset, y: 1 - inset },
+        ];
+    }
+    static distance(from, to) {
+        return Math.hypot(to.x - from.x, to.y - from.y);
+    }
+    static fit(container, content) {
+        if (container.width <= 0 || container.height <= 0 || content.width <= 0 || content.height <= 0)
+            return { height: 0, width: 0 };
+        const scale = Math.min(container.width / content.width, container.height / content.height);
+        return { height: content.height * scale, width: content.width * scale };
+    }
+    static fitWithin(size, maxDimension) {
+        const longest = Math.max(size.width, size.height);
+        if (longest <= maxDimension)
+            return { height: Math.round(size.height), width: Math.round(size.width) };
+        const scale = maxDimension / longest;
+        return {
+            height: Math.max(1, Math.round(size.height * scale)),
+            width: Math.max(1, Math.round(size.width * scale)),
+        };
+    }
+    static inset(quad, distance) {
+        const centre = {
+            x: quad.reduce((sum, point) => sum + point.x, 0) / quad.length,
+            y: quad.reduce((sum, point) => sum + point.y, 0) / quad.length,
+        };
+        return quad.map((point) => {
+            const length = PsScanGeometryService.distance(point, centre);
+            const ratio = length <= distance ? 0 : (length - distance) / length;
+            return {
+                x: centre.x + (point.x - centre.x) * ratio,
+                y: centre.y + (point.y - centre.y) * ratio,
+            };
+        });
+    }
+    static isConvex(points) {
+        let sign = 0;
+        for (let index = 0; index < points.length; index += 1) {
+            const a = points[index];
+            const b = points[(index + 1) % points.length];
+            const c = points[(index + 2) % points.length];
+            const cross = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
+            if (Math.abs(cross) < 1e-9)
+                return false;
+            if (sign === 0)
+                sign = Math.sign(cross);
+            else if (Math.sign(cross) !== sign)
+                return false;
+        }
+        return true;
+    }
+    static isUsable(quad) {
+        return (PsScanGeometryService.isConvex(quad) &&
+            PsScanGeometryService.area(quad) > PsScanConfig.minCornerGap * PsScanConfig.minCornerGap);
+    }
+    static nudge(quad, index, dx, dy) {
+        const moved = PsScanGeometryService.clamp({ x: quad[index].x + dx, y: quad[index].y + dy });
+        const next = quad.map((point, at) => (at === index ? moved : point));
+        return PsScanGeometryService.isUsable(next) ? next : quad;
+    }
+    static order(points) {
+        const centre = {
+            x: points.reduce((sum, point) => sum + point.x, 0) / points.length,
+            y: points.reduce((sum, point) => sum + point.y, 0) / points.length,
+        };
+        const sorted = [...points].sort((a, b) => Math.atan2(a.y - centre.y, a.x - centre.x) - Math.atan2(b.y - centre.y, b.x - centre.x));
+        const sums = sorted.map((point) => point.x + point.y);
+        const start = sums.indexOf(Math.min(...sums));
+        return [0, 1, 2, 3].map((offset) => sorted[(start + offset) % 4]);
+    }
+    static outputSize(quad, raster) {
+        const pixels = PsScanGeometryService.toPixels(quad, raster);
+        const width = (PsScanGeometryService.distance(pixels[0], pixels[1]) +
+            PsScanGeometryService.distance(pixels[3], pixels[2])) /
+            2;
+        const height = (PsScanGeometryService.distance(pixels[0], pixels[3]) +
+            PsScanGeometryService.distance(pixels[1], pixels[2])) /
+            2;
+        return { height: Math.max(1, Math.round(height)), width: Math.max(1, Math.round(width)) };
+    }
+    static rotateSize(size, rotation) {
+        return rotation % 180 === 0 ? size : { height: size.width, width: size.height };
+    }
+    static toPixels(quad, size) {
+        return quad.map((point) => ({
+            x: point.x * size.width,
+            y: point.y * size.height,
+        }));
+    }
+}

package/dist/esm/services/ps-scan-homography-service.js

@@ -0,0 +1,46 @@
+export class PsScanHomographyService {
+    static apply(matrix, x, y) {
+        const w = matrix[6] * x + matrix[7] * y + matrix[8];
+        return {
+            x: (matrix[0] * x + matrix[1] * y + matrix[2]) / w,
+            y: (matrix[3] * x + matrix[4] * y + matrix[5]) / w,
+        };
+    }
+    static fromUnitSquare(quad) {
+        const unit = [
+            [0, 0],
+            [1, 0],
+            [1, 1],
+            [0, 1],
+        ];
+        const rows = [];
+        unit.forEach(([u, v], index) => {
+            const { x, y } = quad[index];
+            rows.push([u, v, 1, 0, 0, 0, -u * x, -v * x, x]);
+            rows.push([0, 0, 0, u, v, 1, -u * y, -v * y, y]);
+        });
+        return [...PsScanHomographyService.solve(rows), 1];
+    }
+    static solve(rows) {
+        const size = rows.length;
+        const matrix = rows.map((row) => [...row]);
+        for (let column = 0; column < size; column += 1) {
+            let pivot = column;
+            for (let row = column + 1; row < size; row += 1)
+                if (Math.abs(matrix[row][column]) > Math.abs(matrix[pivot][column]))
+                    pivot = row;
+            [matrix[column], matrix[pivot]] = [matrix[pivot], matrix[column]];
+            const lead = matrix[column][column];
+            if (Math.abs(lead) < 1e-12)
+                return [1, 0, 0, 0, 1, 0, 0, 0];
+            for (let row = 0; row < size; row += 1) {
+                if (row === column)
+                    continue;
+                const factor = matrix[row][column] / lead;
+                for (let at = column; at <= size; at += 1)
+                    matrix[row][at] -= factor * matrix[column][at];
+            }
+        }
+        return matrix.map((row, index) => row[size] / row[index]);
+    }
+}

package/dist/esm/services/ps-scan-hull-service.js

@@ -0,0 +1,59 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanGeometryService } from './ps-scan-geometry-service';
+export class PsScanHullService {
+    static bestQuad(hull) {
+        const points = PsScanHullService.reduce(hull, PsScanConfig.hullCandidateLimit);
+        if (points.length <= 4)
+            return points;
+        let best = points.slice(0, 4);
+        let bestArea = 0;
+        for (let a = 0; a < points.length - 3; a += 1)
+            for (let b = a + 1; b < points.length - 2; b += 1)
+                for (let c = b + 1; c < points.length - 1; c += 1)
+                    for (let d = c + 1; d < points.length; d += 1) {
+                        const candidate = [points[a], points[b], points[c], points[d]];
+                        const area = PsScanGeometryService.area(candidate);
+                        if (area > bestArea) {
+                            bestArea = area;
+                            best = candidate;
+                        }
+                    }
+        return best;
+    }
+    static convexHull(input) {
+        const points = [...input].sort((a, b) => (a.x === b.x ? a.y - b.y : a.x - b.x));
+        if (points.length < 3)
+            return points;
+        const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+        const build = (list) => {
+            const chain = [];
+            list.forEach((point) => {
+                while (chain.length >= 2 &&
+                    cross(chain[chain.length - 2], chain[chain.length - 1], point) <= 0)
+                    chain.pop();
+                chain.push(point);
+            });
+            chain.pop();
+            return chain;
+        };
+        return [...build(points), ...build([...points].reverse())];
+    }
+    static reduce(hull, limit) {
+        const points = [...hull];
+        while (points.length > limit) {
+            let weakest = 0;
+            let weakestArea = Infinity;
+            points.forEach((point, index) => {
+                const previous = points[(index - 1 + points.length) % points.length];
+                const next = points[(index + 1) % points.length];
+                const area = PsScanGeometryService.area([previous, point, next]);
+                if (area < weakestArea) {
+                    weakestArea = area;
+                    weakest = index;
+                }
+            });
+            points.splice(weakest, 1);
+        }
+        return points;
+    }
+}

package/dist/esm/services/ps-scan-image-filter-service.js

@@ -0,0 +1,52 @@
+export class PsScanImageFilterService {
+    static blur(gray, width, height) {
+        const kernel = [1, 4, 6, 4, 1];
+        const pass = new Float32Array(width * height);
+        const out = new Uint8ClampedArray(width * height);
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                let sum = 0;
+                for (let k = -2; k <= 2; k += 1)
+                    sum += gray[y * width + Math.min(width - 1, Math.max(0, x + k))] * kernel[k + 2];
+                pass[y * width + x] = sum / 16;
+            }
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                let sum = 0;
+                for (let k = -2; k <= 2; k += 1)
+                    sum += pass[Math.min(height - 1, Math.max(0, y + k)) * width + x] * kernel[k + 2];
+                out[y * width + x] = sum / 16;
+            }
+        return out;
+    }
+    static grayscale(raster) {
+        const out = new Uint8ClampedArray(raster.width * raster.height);
+        for (let index = 0; index < out.length; index += 1) {
+            const at = index * 4;
+            out[index] =
+                0.299 * raster.data[at] + 0.587 * raster.data[at + 1] + 0.114 * raster.data[at + 2];
+        }
+        return out;
+    }
+    static sobel(gray, width, height) {
+        const out = new Uint16Array(width * height);
+        for (let y = 1; y < height - 1; y += 1)
+            for (let x = 1; x < width - 1; x += 1) {
+                const i = y * width + x;
+                const gx = -gray[i - width - 1] +
+                    gray[i - width + 1] -
+                    2 * gray[i - 1] +
+                    2 * gray[i + 1] -
+                    gray[i + width - 1] +
+                    gray[i + width + 1];
+                const gy = -gray[i - width - 1] -
+                    2 * gray[i - width] -
+                    gray[i - width + 1] +
+                    gray[i + width - 1] +
+                    2 * gray[i + width] +
+                    gray[i + width + 1];
+                out[i] = Math.hypot(gx, gy) / 4;
+            }
+        return out;
+    }
+}

package/dist/esm/services/ps-scan-order-service.js

@@ -0,0 +1,13 @@
+export class PsScanOrderService {
+    static move(items, from, to) {
+        if (from === to || from < 0 || to < 0 || from >= items.length || to >= items.length)
+            return items;
+        const next = [...items];
+        const [item] = next.splice(from, 1);
+        next.splice(to, 0, item);
+        return next;
+    }
+    static step(items, index, direction) {
+        return PsScanOrderService.move(items, index, index + direction);
+    }
+}

package/dist/esm/services/ps-scan-output-service.js

@@ -0,0 +1,24 @@
+import { PsScanOutputFormat } from '../constants/ps-scan-output-format';
+import { PsScanFileNameService } from './ps-scan-file-name-service';
+import { PsScanPdfService } from './ps-scan-pdf-service';
+import { PsScanPipelineService } from './ps-scan-pipeline-service';
+export class PsScanOutputService {
+    static async build(pages, options) {
+        const rendered = [];
+        for (const page of pages)
+            rendered.push(await PsScanPipelineService.render(page, options.maxDimension, options.jpegQuality));
+        const type = PsScanFileNameService.mimeType(options.format);
+        if (options.format === PsScanOutputFormat.Jpeg)
+            return rendered.map((item, index) => new File([item.blob], PsScanFileNameService.build(options.fileName, options.format, index, rendered.length), { type }));
+        const jpegs = await Promise.all(rendered.map(async (item) => ({
+            height: item.height,
+            jpeg: new Uint8Array(await item.blob.arrayBuffer()),
+            width: item.width,
+        })));
+        return [
+            new File([PsScanPdfService.build(jpegs)], PsScanFileNameService.build(options.fileName, options.format, 0, 1), {
+                type,
+            }),
+        ];
+    }
+}

package/dist/esm/services/ps-scan-pdf-service.js

@@ -0,0 +1,56 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+export class PsScanPdfService {
+    static build(pages) {
+        const encoder = new TextEncoder();
+        const chunks = [];
+        const offsets = [];
+        let length = 0;
+        const push = (chunk) => {
+            chunks.push(chunk);
+            length += chunk.length;
+        };
+        const text = (value) => push(encoder.encode(value));
+        const begin = (id) => {
+            offsets[id] = length;
+            text(`${id} 0 obj\n`);
+        };
+        const kids = pages.map((_, index) => `${3 + index * 3} 0 R`).join(' ');
+        push(Uint8Array.from([
+            0x25, 0x50, 0x44, 0x46, 0x2d, 0x31, 0x2e, 0x34, 0x0a, 0x25, 0xe2, 0xe3, 0xcf, 0xd3, 0x0a,
+        ]));
+        begin(1);
+        text('<< /Type /Catalog /Pages 2 0 R >>\nendobj\n');
+        begin(2);
+        text(`<< /Type /Pages /Kids [${kids}] /Count ${pages.length} >>\nendobj\n`);
+        pages.forEach((page, index) => {
+            const pageId = 3 + index * 3;
+            const widthPt = PsScanPdfService.points(page.width);
+            const heightPt = PsScanPdfService.points(page.height);
+            const content = `q ${widthPt} 0 0 ${heightPt} 0 0 cm /Im0 Do Q`;
+            begin(pageId);
+            text(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${widthPt} ${heightPt}] /Resources << /XObject << /Im0 ${pageId + 2} 0 R >> >> /Contents ${pageId + 1} 0 R >>\nendobj\n`);
+            begin(pageId + 1);
+            text(`<< /Length ${content.length} >>\nstream\n${content}\nendstream\nendobj\n`);
+            begin(pageId + 2);
+            text(`<< /Type /XObject /Subtype /Image /Width ${page.width} /Height ${page.height} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${page.jpeg.length} >>\nstream\n`);
+            push(page.jpeg);
+            text('\nendstream\nendobj\n');
+        });
+        const count = 3 + pages.length * 3;
+        const xrefAt = length;
+        text(`xref\n0 ${count}\n0000000000 65535 f \n`);
+        for (let id = 1; id < count; id += 1)
+            text(`${String(offsets[id]).padStart(10, '0')} 00000 n \n`);
+        text(`trailer\n<< /Size ${count} /Root 1 0 R >>\nstartxref\n${xrefAt}\n%%EOF\n`);
+        const out = new Uint8Array(length);
+        let at = 0;
+        chunks.forEach((chunk) => {
+            out.set(chunk, at);
+            at += chunk.length;
+        });
+        return out;
+    }
+    static points(pixels) {
+        return Math.round((pixels * PsScanConfig.pdfPointsPerInch * 100) / PsScanConfig.pdfDpi) / 100;
+    }
+}

package/dist/esm/services/ps-scan-pipeline-service.js

@@ -0,0 +1,40 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanCanvasService } from './ps-scan-canvas-service';
+import { PsScanEdgeService } from './ps-scan-edge-service';
+import { PsScanEnhanceService } from './ps-scan-enhance-service';
+import { PsScanGeometryService } from './ps-scan-geometry-service';
+import { PsScanRasterService } from './ps-scan-raster-service';
+import { PsScanWarpService } from './ps-scan-warp-service';
+export class PsScanPipelineService {
+    static async prepare(source) {
+        const decoded = await PsScanCanvasService.decode(source, PsScanConfig.detectMaxDimension * 2);
+        const detected = PsScanEdgeService.detect(decoded.raster);
+        return {
+            corners: detected === null ? PsScanGeometryService.defaultQuad() : detected,
+            height: decoded.naturalHeight,
+            isDetected: detected !== null,
+            width: decoded.naturalWidth,
+        };
+    }
+    static async measure(source) {
+        const decoded = await PsScanCanvasService.decode(source, PsScanConfig.previewMaxDimension);
+        return decoded.raster;
+    }
+    static process(page, raster, maxDimension) {
+        const size = PsScanGeometryService.fitWithin(PsScanGeometryService.outputSize(page.corners, raster), maxDimension);
+        const warped = PsScanWarpService.warp(raster, PsScanGeometryService.toPixels(page.corners, {
+            height: raster.height - 1,
+            width: raster.width - 1,
+        }), size.width, size.height);
+        return PsScanRasterService.rotate(PsScanEnhanceService.apply(warped, page.filter), page.rotation);
+    }
+    static async render(page, maxDimension, quality) {
+        const decoded = await PsScanCanvasService.decode(page.source, PsScanConfig.decodeMaxDimension);
+        const raster = PsScanPipelineService.process(page, decoded.raster, maxDimension);
+        return {
+            blob: await PsScanCanvasService.encode(raster, quality),
+            height: raster.height,
+            width: raster.width,
+        };
+    }
+}

package/dist/esm/services/ps-scan-platform-service.js

@@ -0,0 +1,15 @@
+import { PsScanPlatform } from '../constants/ps-scan-platform';
+export class PsScanPlatformService {
+    static detect() {
+        if (typeof navigator === 'undefined')
+            return PsScanPlatform.Desktop;
+        const agent = navigator.userAgent;
+        if (/iPhone|iPad|iPod/i.test(agent))
+            return PsScanPlatform.Ios;
+        if (/Macintosh/i.test(agent) && navigator.maxTouchPoints > 1)
+            return PsScanPlatform.Ios;
+        if (/Android/i.test(agent))
+            return PsScanPlatform.Android;
+        return PsScanPlatform.Desktop;
+    }
+}

package/dist/esm/services/ps-scan-raster-service.js

@@ -0,0 +1,67 @@
+export class PsScanRasterService {
+    static create(width, height) {
+        return { data: new Uint8ClampedArray(width * height * 4), height, width };
+    }
+    static resize(source, width, height) {
+        if (width === source.width && height === source.height)
+            return source;
+        const target = PsScanRasterService.create(width, height);
+        const scaleX = source.width / width;
+        const scaleY = source.height / height;
+        for (let y = 0; y < height; y += 1) {
+            const y0 = Math.floor(y * scaleY);
+            const y1 = Math.min(source.height, Math.max(y0 + 1, Math.ceil((y + 1) * scaleY)));
+            for (let x = 0; x < width; x += 1) {
+                const x0 = Math.floor(x * scaleX);
+                const x1 = Math.min(source.width, Math.max(x0 + 1, Math.ceil((x + 1) * scaleX)));
+                let r = 0;
+                let g = 0;
+                let b = 0;
+                let a = 0;
+                let count = 0;
+                for (let sy = y0; sy < y1; sy += 1)
+                    for (let sx = x0; sx < x1; sx += 1) {
+                        const at = (sy * source.width + sx) * 4;
+                        r += source.data[at];
+                        g += source.data[at + 1];
+                        b += source.data[at + 2];
+                        a += source.data[at + 3];
+                        count += 1;
+                    }
+                const out = (y * width + x) * 4;
+                target.data[out] = r / count;
+                target.data[out + 1] = g / count;
+                target.data[out + 2] = b / count;
+                target.data[out + 3] = a / count;
+            }
+        }
+        return target;
+    }
+    static rotate(source, degrees) {
+        const turns = ((Math.round(degrees / 90) % 4) + 4) % 4;
+        if (turns === 0)
+            return source;
+        const swapped = turns % 2 === 1;
+        const width = swapped ? source.height : source.width;
+        const height = swapped ? source.width : source.height;
+        const target = PsScanRasterService.create(width, height);
+        for (let y = 0; y < source.height; y += 1)
+            for (let x = 0; x < source.width; x += 1) {
+                let tx = x;
+                let ty = y;
+                if (turns === 1)
+                    [tx, ty] = [source.height - 1 - y, x];
+                else if (turns === 2)
+                    [tx, ty] = [source.width - 1 - x, source.height - 1 - y];
+                else
+                    [tx, ty] = [y, source.width - 1 - x];
+                const from = (y * source.width + x) * 4;
+                const to = (ty * width + tx) * 4;
+                target.data[to] = source.data[from];
+                target.data[to + 1] = source.data[from + 1];
+                target.data[to + 2] = source.data[from + 2];
+                target.data[to + 3] = source.data[from + 3];
+            }
+        return target;
+    }
+}

package/dist/esm/services/ps-scan-stability-service.js

@@ -0,0 +1,41 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanGeometryService } from './ps-scan-geometry-service';
+export class PsScanStabilityService {
+    static disarm(state) {
+        return { ...state, isArmed: false, stableMs: 0 };
+    }
+    static initial() {
+        return { isArmed: true, misses: 0, quad: null, raw: null, stableMs: 0 };
+    }
+    static movement(from, to) {
+        return Math.max(...from.map((point, index) => PsScanGeometryService.distance(point, to[index])));
+    }
+    static next(state, detected, elapsedMs) {
+        if (detected === null) {
+            const misses = state.misses + 1;
+            return misses > PsScanConfig.liveMissLimit
+                ? { isArmed: true, misses, quad: null, raw: null, stableMs: 0 }
+                : { ...state, misses, stableMs: 0 };
+        }
+        if (state.quad === null || state.raw === null)
+            return { ...state, misses: 0, quad: detected, raw: detected, stableMs: 0 };
+        const movement = PsScanStabilityService.movement(state.raw, detected);
+        const weight = PsScanConfig.liveSmoothing;
+        const quad = state.quad.map((point, index) => ({
+            x: point.x + (detected[index].x - point.x) * weight,
+            y: point.y + (detected[index].y - point.y) * weight,
+        }));
+        return {
+            isArmed: state.isArmed || movement > PsScanConfig.liveRearmMovement,
+            misses: 0,
+            quad,
+            raw: detected,
+            stableMs: movement <= PsScanConfig.liveStillMovement ? state.stableMs + elapsedMs : 0,
+        };
+    }
+    static progress(state) {
+        if (!state.isArmed || state.quad === null)
+            return 0;
+        return Math.min(1, state.stableMs / PsScanConfig.autoCaptureMs);
+    }
+}

package/dist/esm/services/ps-scan-template-service.js

@@ -0,0 +1,5 @@
+export class PsScanTemplateService {
+    static fill(template, values) {
+        return template.replace(/\{(\w+)\}/g, (match, key) => key in values ? String(values[key]) : match);
+    }
+}