@pallasoft/ps-file-components 1.4.0 → 2.0.0

package/dist/models/ps-scan-live-detection.d.ts

@@ -0,0 +1,4 @@
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanLiveDetection {
+    quad: PsScanQuad | null;
+}

package/dist/models/ps-scan-located.d.ts

@@ -0,0 +1,5 @@
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanLocated {
+    isDetected: boolean;
+    quad: PsScanQuad;
+}

package/dist/models/ps-scan-photo.d.ts

@@ -0,0 +1,9 @@
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanPhoto {
+    corners: PsScanQuad;
+    height: number;
+    isDetected: boolean;
+    source: Blob;
+    sourceUrl: string;
+    width: number;
+}

package/dist/models/ps-scan-region.d.ts

@@ -0,0 +1,5 @@
+import type { PsPoint } from './ps-point';
+export interface PsScanRegion {
+    area: number;
+    boundary: PsPoint[];
+}

package/dist/models/ps-scan-region.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-scan-result.d.ts

@@ -0,0 +1,6 @@
+export interface PsScanResult {
+    blob: Blob;
+    height: number;
+    url: string;
+    width: number;
+}

package/dist/models/ps-scan-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-scan-stability.d.ts

@@ -0,0 +1,5 @@
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanStability {
+    misses: number;
+    quad: PsScanQuad | null;
+}

package/dist/models/ps-scan-stability.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/ps-scan-camera-service.d.ts

@@ -1,9 +1,13 @@
 import { PsScanCameraStatus } from '../constants/ps-scan-camera-status';
 import type { PsScanCameraSession } from '../models/ps-scan-camera-session';
 export declare class PsScanCameraService {
+    static attach(video: HTMLVideoElement, session: PsScanCameraSession): Promise<void>;
+    static check(): Promise<PsScanCameraStatus>;
     static classify(error: unknown): PsScanCameraStatus;
+    static hasCamera(): Promise<boolean>;
     static isSupported(): boolean;
     static open(): Promise<PsScanCameraSession>;
+    static permission(): Promise<PermissionStatus | null>;
     static setTorch(track: MediaStreamTrack, isOn: boolean): Promise<boolean>;
     static stop(stream: MediaStream | null): void;
     static supportsTorch(track: MediaStreamTrack | undefined): boolean;

package/dist/services/ps-scan-camera-service.js

@@ -4,13 +4,45 @@ exports.PsScanCameraService = void 0;
 const ps_scan_camera_status_1 = require("../constants/ps-scan-camera-status");
 const ps_scan_config_1 = require("../constants/ps-scan-config");
 class PsScanCameraService {
+    static async attach(video, session) {
+        if (video.srcObject !== session.stream)
+            video.srcObject = session.stream;
+        await video.play().catch(() => undefined);
+    }
+    static async check() {
+        if (globalThis.isSecureContext === false)
+            return ps_scan_camera_status_1.PsScanCameraStatus.Insecure;
+        if (!PsScanCameraService.isSupported())
+            return ps_scan_camera_status_1.PsScanCameraStatus.Unavailable;
+        if (!(await PsScanCameraService.hasCamera()))
+            return ps_scan_camera_status_1.PsScanCameraStatus.Unavailable;
+        const permission = await PsScanCameraService.permission();
+        if (permission === null)
+            return ps_scan_camera_status_1.PsScanCameraStatus.Prompt;
+        if (permission.state === 'granted')
+            return ps_scan_camera_status_1.PsScanCameraStatus.Starting;
+        return permission.state === 'denied' ? ps_scan_camera_status_1.PsScanCameraStatus.Denied : ps_scan_camera_status_1.PsScanCameraStatus.Prompt;
+    }
     static classify(error) {
         const name = typeof error === 'object' && error !== null && 'name' in error ? String(error.name) : '';
-        return name === 'NotAllowedError' ||
-            name === 'SecurityError' ||
-            name === 'PermissionDeniedError'
-            ? ps_scan_camera_status_1.PsScanCameraStatus.Denied
-            : ps_scan_camera_status_1.PsScanCameraStatus.Unavailable;
+        if (name === 'NotAllowedError' || name === 'PermissionDeniedError')
+            return ps_scan_camera_status_1.PsScanCameraStatus.Denied;
+        if (name === 'SecurityError')
+            return ps_scan_camera_status_1.PsScanCameraStatus.Insecure;
+        if (name === 'NotReadableError' || name === 'TrackStartError' || name === 'AbortError')
+            return ps_scan_camera_status_1.PsScanCameraStatus.Busy;
+        return ps_scan_camera_status_1.PsScanCameraStatus.Unavailable;
+    }
+    static async hasCamera() {
+        if (typeof navigator.mediaDevices.enumerateDevices !== 'function')
+            return true;
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.length === 0 || devices.some((device) => device.kind === 'videoinput');
+        }
+        catch {
+            return true;
+        }
     }
     static isSupported() {
         return (typeof navigator !== 'undefined' &&
@@ -22,13 +54,26 @@ class PsScanCameraService {
             audio: false,
             video: {
                 facingMode: { ideal: 'environment' },
-                height: { ideal: 1440 },
-                width: { ideal: 1920 },
+                height: { ideal: 2160 },
+                width: { ideal: 3840 },
             },
         });
         const track = stream.getVideoTracks()[0];
         return { canTorch: PsScanCameraService.supportsTorch(track), stream, track };
     }
+    static async permission() {
+        if (typeof navigator.permissions === 'undefined' ||
+            typeof navigator.permissions.query !== 'function')
+            return null;
+        try {
+            return await navigator.permissions.query({
+                name: ps_scan_config_1.PsScanConfig.cameraPermission,
+            });
+        }
+        catch {
+            return null;
+        }
+    }
     static async setTorch(track, isOn) {
         try {
             await track.applyConstraints({

package/dist/services/ps-scan-canny-service.d.ts

@@ -0,0 +1,7 @@
+export declare class PsScanCannyService {
+    static edges(gray: Uint8ClampedArray, width: number, height: number): Uint8Array;
+    private static gradient;
+    private static highThreshold;
+    private static hysteresis;
+    private static suppress;
+}

package/dist/services/ps-scan-canny-service.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanCannyService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+class PsScanCannyService {
+    static edges(gray, width, height) {
+        const gradient = PsScanCannyService.gradient(gray, width, height);
+        const ridges = PsScanCannyService.suppress(gradient, width, height);
+        const high = PsScanCannyService.highThreshold(ridges);
+        return PsScanCannyService.hysteresis(ridges, width, height, high * ps_scan_config_1.PsScanConfig.cannyLowRatio, high);
+    }
+    static gradient(gray, width, height) {
+        const magnitude = new Float32Array(width * height);
+        const direction = new Uint8Array(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];
+                const ax = Math.abs(gx);
+                const ay = Math.abs(gy);
+                magnitude[i] = Math.hypot(gx, gy) / 4;
+                if (ay <= ax * 0.41421356)
+                    direction[i] = 0;
+                else if (ay >= ax * 2.41421356)
+                    direction[i] = 2;
+                else
+                    direction[i] = gx * gy > 0 ? 1 : 3;
+            }
+        return { direction, magnitude };
+    }
+    static highThreshold(ridges) {
+        const values = [];
+        for (let index = 0; index < ridges.length; index += 1)
+            if (ridges[index] > 0)
+                values.push(ridges[index]);
+        if (values.length === 0)
+            return ps_scan_config_1.PsScanConfig.cannyMinHigh;
+        values.sort((a, b) => a - b);
+        const at = Math.min(values.length - 1, Math.floor(values.length * ps_scan_config_1.PsScanConfig.cannyHighPercentile));
+        return Math.max(ps_scan_config_1.PsScanConfig.cannyMinHigh, values[at]);
+    }
+    static hysteresis(ridges, width, height, low, high) {
+        const out = new Uint8Array(width * height);
+        const stack = [];
+        for (let index = 0; index < ridges.length; index += 1)
+            if (ridges[index] >= high) {
+                out[index] = 1;
+                stack.push(index);
+            }
+        while (stack.length > 0) {
+            const index = stack.pop();
+            if (index === undefined)
+                break;
+            const x = index % width;
+            const y = (index - x) / width;
+            for (let dy = -1; dy <= 1; dy += 1)
+                for (let dx = -1; dx <= 1; dx += 1) {
+                    const nx = x + dx;
+                    const ny = y + dy;
+                    if (nx < 0 || ny < 0 || nx >= width || ny >= height)
+                        continue;
+                    const next = ny * width + nx;
+                    if (out[next] === 0 && ridges[next] >= low) {
+                        out[next] = 1;
+                        stack.push(next);
+                    }
+                }
+        }
+        return out;
+    }
+    static suppress(gradient, width, height) {
+        const { direction, magnitude } = gradient;
+        const out = new Float32Array(width * height);
+        const offsets = [1, width + 1, width, width - 1];
+        for (let y = 1; y < height - 1; y += 1)
+            for (let x = 1; x < width - 1; x += 1) {
+                const i = y * width + x;
+                const offset = offsets[direction[i]];
+                const value = magnitude[i];
+                if (value >= magnitude[i - offset] && value > magnitude[i + offset])
+                    out[i] = value;
+            }
+        return out;
+    }
+}
+exports.PsScanCannyService = PsScanCannyService;

package/dist/services/ps-scan-canvas-service.d.ts

@@ -4,5 +4,6 @@ export declare class PsScanCanvasService {
     static decode(blob: Blob, maxDimension: number): Promise<PsScanDecodedImage>;
     static encode(raster: PsScanRaster, quality: number): Promise<Blob>;
     static fromVideo(video: HTMLVideoElement, quality: number): Promise<Blob>;
+    static sample(video: HTMLVideoElement, maxDimension: number): PsScanRaster;
     private static context;
 }

package/dist/services/ps-scan-canvas-service.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanCanvasService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
 const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
 class PsScanCanvasService {
     static async decode(blob, maxDimension) {
         const bitmap = await createImageBitmap(blob, { imageOrientation: 'from-image' });
-        const size = ps_scan_geometry_service_1.PsScanGeometryService.fitWithin({ height: bitmap.height, width: bitmap.width }, maxDimension);
+        const capped = ps_scan_geometry_service_1.PsScanGeometryService.fitWithin({ height: bitmap.height, width: bitmap.width }, maxDimension);
+        const shrink = Math.min(1, Math.sqrt(ps_scan_config_1.PsScanConfig.decodeMaxPixels / (capped.width * capped.height)));
+        const size = {
+            height: Math.max(1, Math.round(capped.height * shrink)),
+            width: Math.max(1, Math.round(capped.width * shrink)),
+        };
         const context = PsScanCanvasService.context(size.width, size.height);
         context.drawImage(bitmap, 0, 0, size.width, size.height);
         const naturalHeight = bitmap.height;
@@ -30,6 +36,12 @@ class PsScanCanvasService {
         context.drawImage(video, 0, 0);
         return await PsScanCanvasService.encode(context.getImageData(0, 0, video.videoWidth, video.videoHeight), quality);
     }
+    static sample(video, maxDimension) {
+        const size = ps_scan_geometry_service_1.PsScanGeometryService.fitWithin({ height: video.videoHeight, width: video.videoWidth }, maxDimension);
+        const context = PsScanCanvasService.context(size.width, size.height);
+        context.drawImage(video, 0, 0, size.width, size.height);
+        return context.getImageData(0, 0, size.width, size.height);
+    }
     static context(width, height) {
         if (typeof OffscreenCanvas !== 'undefined') {
             const context = new OffscreenCanvas(width, height).getContext('2d', {

package/dist/services/ps-scan-edge-service.d.ts

@@ -1,9 +1,9 @@
+import type { PsScanLocated } from '../models/ps-scan-located';
 import type { PsScanQuad } from '../models/ps-scan-quad';
 import type { PsScanRaster } from '../models/ps-scan-raster';
 export declare class PsScanEdgeService {
-    static detect(source: PsScanRaster): PsScanQuad | null;
-    private static dilate;
-    private static foreground;
-    private static largestComponent;
-    private static threshold;
+    static detect(source: PsScanRaster, maxDimension: number): Promise<PsScanQuad | null>;
+    static locate(source: PsScanRaster, maxDimension: number): Promise<PsScanLocated>;
+    private static candidate;
+    private static normalise;
 }

package/dist/services/ps-scan-edge-service.js

@@ -2,159 +2,95 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanEdgeService = void 0;
 const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_canny_service_1 = require("./ps-scan-canny-service");
 const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
 const ps_scan_hull_service_1 = require("./ps-scan-hull-service");
 const ps_scan_image_filter_service_1 = require("./ps-scan-image-filter-service");
+const ps_scan_morphology_service_1 = require("./ps-scan-morphology-service");
+const ps_scan_polygon_service_1 = require("./ps-scan-polygon-service");
 const ps_scan_raster_service_1 = require("./ps-scan-raster-service");
+const ps_scan_region_service_1 = require("./ps-scan-region-service");
+const ps_scan_yield_service_1 = require("./ps-scan-yield-service");
 class PsScanEdgeService {
-    static detect(source) {
-        const scale = Math.min(1, ps_scan_config_1.PsScanConfig.detectMaxDimension / Math.max(source.width, source.height));
-        const width = Math.max(8, Math.round(source.width * scale));
-        const height = Math.max(8, Math.round(source.height * scale));
+    static async detect(source, maxDimension) {
+        const scale = Math.min(1, maxDimension / Math.max(source.width, source.height));
+        const width = Math.max(16, Math.round(source.width * scale));
+        const height = Math.max(16, Math.round(source.height * scale));
         const raster = ps_scan_raster_service_1.PsScanRasterService.resize(source, width, height);
         const gray = ps_scan_image_filter_service_1.PsScanImageFilterService.blur(ps_scan_image_filter_service_1.PsScanImageFilterService.grayscale(raster), width, height);
-        const edges = ps_scan_image_filter_service_1.PsScanImageFilterService.sobel(gray, width, height);
-        let mask = PsScanEdgeService.threshold(edges);
-        for (let step = 0; step < ps_scan_config_1.PsScanConfig.detectDilations; step += 1)
-            mask = PsScanEdgeService.dilate(mask, width, height);
-        const foreground = PsScanEdgeService.foreground(mask, width, height);
-        const component = PsScanEdgeService.largestComponent(foreground, width, height);
-        if (component.length < 8)
+        await ps_scan_yield_service_1.PsScanYieldService.next();
+        const edges = ps_scan_canny_service_1.PsScanCannyService.edges(gray, width, height);
+        for (let index = 0; index < width; index += 1) {
+            edges[index] = 1;
+            edges[(height - 1) * width + index] = 1;
+        }
+        for (let index = 0; index < height; index += 1) {
+            edges[index * width] = 1;
+            edges[index * width + width - 1] = 1;
+        }
+        let best = null;
+        let bestArea = 0;
+        for (const radius of ps_scan_config_1.PsScanConfig.closeRadii) {
+            await ps_scan_yield_service_1.PsScanYieldService.next();
+            const closed = ps_scan_morphology_service_1.PsScanMorphologyService.close(edges, width, height, radius);
+            const regions = ps_scan_region_service_1.PsScanRegionService.enclosed(closed, width, height, width * height * ps_scan_config_1.PsScanConfig.detectMinAreaRatio * 0.5);
+            for (const region of regions) {
+                const quad = PsScanEdgeService.candidate(region.boundary, width, height);
+                if (quad === null)
+                    continue;
+                const area = ps_scan_geometry_service_1.PsScanGeometryService.area(quad);
+                if (area > bestArea) {
+                    bestArea = area;
+                    best = quad;
+                }
+            }
+        }
+        if (best === null)
             return null;
-        const hull = ps_scan_hull_service_1.PsScanHullService.convexHull(component);
+        return PsScanEdgeService.normalise(best, width, height);
+    }
+    static async locate(source, maxDimension) {
+        const quad = await PsScanEdgeService.detect(source, maxDimension);
+        return quad === null
+            ? { isDetected: false, quad: ps_scan_geometry_service_1.PsScanGeometryService.defaultQuad() }
+            : { isDetected: true, quad };
+    }
+    static candidate(boundary, width, height) {
+        const points = boundary.map((point) => ({ x: point.x + 0.5, y: point.y + 0.5 }));
+        const hull = ps_scan_hull_service_1.PsScanHullService.convexHull(points);
         if (hull.length < 4)
             return null;
-        const quad = ps_scan_geometry_service_1.PsScanGeometryService.order(ps_scan_hull_service_1.PsScanHullService.bestQuad(hull));
-        const imageArea = width * height;
-        const quadArea = ps_scan_geometry_service_1.PsScanGeometryService.area(quad);
-        const hullArea = ps_scan_geometry_service_1.PsScanGeometryService.area(hull);
-        if (quadArea / imageArea < ps_scan_config_1.PsScanConfig.detectMinAreaRatio)
+        const corners = ps_scan_polygon_service_1.PsScanPolygonService.toQuad(hull);
+        if (corners === null)
+            return null;
+        const ordered = ps_scan_geometry_service_1.PsScanGeometryService.order(corners);
+        const margin = ps_scan_config_1.PsScanConfig.detectBorderMargin;
+        const onBorder = ordered.filter((point) => point.x <= margin ||
+            point.y <= margin ||
+            point.x >= width - margin ||
+            point.y >= height - margin);
+        if (onBorder.length >= 2)
             return null;
-        if (quadArea / imageArea > ps_scan_config_1.PsScanConfig.detectMaxAreaRatio)
+        const quad = ps_scan_geometry_service_1.PsScanGeometryService.expand(ordered, ps_scan_config_1.PsScanConfig.detectExpand);
+        const imageArea = width * height;
+        const area = ps_scan_geometry_service_1.PsScanGeometryService.area(quad);
+        const fill = ps_scan_geometry_service_1.PsScanGeometryService.area(ordered) / ps_scan_geometry_service_1.PsScanGeometryService.area(hull);
+        const ratio = area / imageArea;
+        if (ratio < ps_scan_config_1.PsScanConfig.detectMinAreaRatio || ratio > ps_scan_config_1.PsScanConfig.detectMaxAreaRatio)
             return null;
-        if (hullArea > 0 && quadArea / hullArea < ps_scan_config_1.PsScanConfig.detectMinHullFill)
+        if (fill < ps_scan_config_1.PsScanConfig.detectMinQuadFill)
             return null;
         if (!ps_scan_geometry_service_1.PsScanGeometryService.isConvex(quad))
             return null;
-        return quad.map((point) => ({
-            x: Math.min(1, Math.max(0, point.x / (width - 1))),
-            y: Math.min(1, Math.max(0, point.y / (height - 1))),
-        }));
-    }
-    static dilate(mask, width, height) {
-        const out = new Uint8Array(mask.length);
-        for (let y = 0; y < height; y += 1)
-            for (let x = 0; x < width; x += 1) {
-                if (mask[y * width + x] === 0)
-                    continue;
-                for (let dy = -1; dy <= 1; dy += 1)
-                    for (let dx = -1; dx <= 1; dx += 1) {
-                        const nx = x + dx;
-                        const ny = y + dy;
-                        if (nx >= 0 && ny >= 0 && nx < width && ny < height)
-                            out[ny * width + nx] = 1;
-                    }
-            }
-        return out;
-    }
-    static foreground(mask, width, height) {
-        const background = new Uint8Array(mask.length);
-        const stack = [];
-        const seed = (index) => {
-            if (mask[index] === 0 && background[index] === 0) {
-                background[index] = 1;
-                stack.push(index);
-            }
-        };
-        for (let x = 0; x < width; x += 1) {
-            seed(x);
-            seed((height - 1) * width + x);
-        }
-        for (let y = 0; y < height; y += 1) {
-            seed(y * width);
-            seed(y * width + width - 1);
-        }
-        while (stack.length > 0) {
-            const index = stack.pop();
-            if (index === undefined)
-                break;
-            const x = index % width;
-            const y = (index - x) / width;
-            if (x > 0)
-                seed(index - 1);
-            if (x < width - 1)
-                seed(index + 1);
-            if (y > 0)
-                seed(index - width);
-            if (y < height - 1)
-                seed(index + width);
-        }
-        return background.map((value) => 1 - value);
-    }
-    static largestComponent(mask, width, height) {
-        const seen = new Uint8Array(mask.length);
-        let best = [];
-        let bestSize = 0;
-        for (let start = 0; start < mask.length; start += 1) {
-            if (mask[start] === 0 || seen[start] === 1)
-                continue;
-            const members = [];
-            const stack = [start];
-            let size = 0;
-            seen[start] = 1;
-            while (stack.length > 0) {
-                const index = stack.pop();
-                if (index === undefined)
-                    break;
-                const x = index % width;
-                const y = (index - x) / width;
-                let isBoundary = false;
-                size += 1;
-                for (let dy = -1; dy <= 1; dy += 1)
-                    for (let dx = -1; dx <= 1; dx += 1) {
-                        if (dx === 0 && dy === 0)
-                            continue;
-                        const nx = x + dx;
-                        const ny = y + dy;
-                        if (nx < 0 || ny < 0 || nx >= width || ny >= height) {
-                            isBoundary = true;
-                            continue;
-                        }
-                        const next = ny * width + nx;
-                        if (mask[next] === 0)
-                            isBoundary = true;
-                        else if (seen[next] === 0) {
-                            seen[next] = 1;
-                            stack.push(next);
-                        }
-                    }
-                if (isBoundary)
-                    members.push({ x, y });
-            }
-            if (size > bestSize) {
-                bestSize = size;
-                best = members;
-            }
-        }
-        return best;
+        const shortSide = Math.min(width, height) * ps_scan_config_1.PsScanConfig.detectMinSideRatio;
+        const isLongEnough = quad.every((point, index) => ps_scan_geometry_service_1.PsScanGeometryService.distance(point, quad[(index + 1) % quad.length]) >= shortSide);
+        if (!isLongEnough)
+            return null;
+        const isSane = ps_scan_geometry_service_1.PsScanGeometryService.angles(quad).every((angle) => angle >= ps_scan_config_1.PsScanConfig.detectMinAngle && angle <= ps_scan_config_1.PsScanConfig.detectMaxAngle);
+        return isSane ? quad : null;
     }
-    static threshold(edges) {
-        const bins = new Uint32Array(512);
-        edges.forEach((value) => {
-            bins[Math.min(511, value)] += 1;
-        });
-        const target = edges.length * ps_scan_config_1.PsScanConfig.detectPercentile;
-        let cumulative = 0;
-        let high = 0;
-        for (let bin = 0; bin < bins.length; bin += 1) {
-            cumulative += bins[bin];
-            if (cumulative >= target) {
-                high = bin;
-                break;
-            }
-        }
-        const limit = Math.max(ps_scan_config_1.PsScanConfig.detectMinEdgeStrength, high * ps_scan_config_1.PsScanConfig.detectRelativeStrength);
-        return Uint8Array.from(edges, (value) => (value >= limit ? 1 : 0));
+    static normalise(quad, width, height) {
+        return quad.map((point) => ps_scan_geometry_service_1.PsScanGeometryService.clamp({ x: point.x / width, y: point.y / height }));
     }
 }
 exports.PsScanEdgeService = PsScanEdgeService;

package/dist/services/ps-scan-file-name-service.d.ts

@@ -1,6 +1,4 @@
-import { PsScanOutputFormat } from '../constants/ps-scan-output-format';
 export declare class PsScanFileNameService {
-    static build(base: string, format: PsScanOutputFormat, index: number, count: number): string;
-    static mimeType(format: PsScanOutputFormat): string;
+    static build(base: string): string;
     static sanitize(base: string): string;
 }

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

@@ -2,18 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanFileNameService = void 0;
 const ps_scan_config_1 = require("../constants/ps-scan-config");
-const ps_scan_output_format_1 = require("../constants/ps-scan-output-format");
 class PsScanFileNameService {
-    static build(base, format, index, count) {
-        const stem = PsScanFileNameService.sanitize(base);
-        if (format === ps_scan_output_format_1.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 === ps_scan_output_format_1.PsScanOutputFormat.Pdf ? 'application/pdf' : 'image/jpeg';
+    static build(base) {
+        return `${PsScanFileNameService.sanitize(base)}.jpg`;
     }
     static sanitize(base) {
         const cleaned = Array.from(base)

package/dist/services/ps-scan-geometry-service.d.ts

@@ -2,12 +2,16 @@ import type { PsPageSize } from '../models/ps-page-size';
 import type { PsPoint } from '../models/ps-point';
 import type { PsScanQuad } from '../models/ps-scan-quad';
 export declare class PsScanGeometryService {
+    static angles(quad: PsPoint[]): number[];
     static area(points: PsPoint[]): number;
     static clamp(point: PsPoint): PsPoint;
+    static cover(container: PsPageSize, content: PsPageSize): PsPageSize;
     static defaultQuad(): PsScanQuad;
     static distance(from: PsPoint, to: PsPoint): number;
+    static expand(quad: PsScanQuad, distance: number): PsScanQuad;
     static fit(container: PsPageSize, content: PsPageSize): PsPageSize;
     static fitWithin(size: PsPageSize, maxDimension: number): PsPageSize;
+    static inset(quad: PsScanQuad, distance: number): PsScanQuad;
     static isConvex(points: PsPoint[]): boolean;
     static isUsable(quad: PsScanQuad): boolean;
     static nudge(quad: PsScanQuad, index: number, dx: number, dy: number): PsScanQuad;