@pallasoft/ps-file-components 1.3.0 → 1.5.0

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

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

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

@@ -0,0 +1,5 @@
+export interface PsScanRaster {
+    data: Uint8ClampedArray<ArrayBuffer>;
+    height: number;
+    width: number;
+}

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

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

package/dist/models/ps-scan-rendered-page.d.ts

@@ -0,0 +1,5 @@
+export interface PsScanRenderedPage {
+    blob: Blob;
+    height: number;
+    width: number;
+}

package/dist/models/ps-scan-rendered-page.js

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

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

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

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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) : '';
+        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' &&
+            typeof navigator.mediaDevices !== 'undefined' &&
+            typeof navigator.mediaDevices.getUserMedia === 'function');
+    }
+    static async open() {
+        const stream = await navigator.mediaDevices.getUserMedia({
+            audio: false,
+            video: {
+                facingMode: { ideal: 'environment' },
+                height: { ideal: 1440 },
+                width: { ideal: 1920 },
+            },
+        });
+        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({
+                advanced: [{ [ps_scan_config_1.PsScanConfig.torchConstraint]: isOn }],
+            });
+            return isOn;
+        }
+        catch {
+            return false;
+        }
+    }
+    static stop(stream) {
+        if (stream === null)
+            return;
+        stream.getTracks().forEach((track) => track.stop());
+    }
+    static supportsTorch(track) {
+        if (track === undefined || typeof track.getCapabilities !== 'function')
+            return false;
+        return ps_scan_config_1.PsScanConfig.torchConstraint in track.getCapabilities();
+    }
+}
+exports.PsScanCameraService = PsScanCameraService;

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

@@ -0,0 +1,9 @@
+import type { PsScanDecodedImage } from '../models/ps-scan-decoded-image';
+import type { PsScanRaster } from '../models/ps-scan-raster';
+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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanCanvasService = void 0;
+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 context = PsScanCanvasService.context(size.width, size.height);
+        context.drawImage(bitmap, 0, 0, size.width, size.height);
+        const naturalHeight = bitmap.height;
+        const naturalWidth = bitmap.width;
+        bitmap.close();
+        return {
+            naturalHeight,
+            naturalWidth,
+            raster: context.getImageData(0, 0, size.width, size.height),
+        };
+    }
+    static async encode(raster, quality) {
+        const context = PsScanCanvasService.context(raster.width, raster.height);
+        context.putImageData(new ImageData(raster.data, raster.width, raster.height), 0, 0);
+        const canvas = context.canvas;
+        if (canvas instanceof HTMLCanvasElement)
+            return await new Promise((resolve, reject) => canvas.toBlob((blob) => (blob === null ? reject(new Error('encode')) : resolve(blob)), 'image/jpeg', quality));
+        return await canvas.convertToBlob({ quality, type: 'image/jpeg' });
+    }
+    static async fromVideo(video, quality) {
+        const context = PsScanCanvasService.context(video.videoWidth, video.videoHeight);
+        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', {
+                willReadFrequently: true,
+            });
+            if (context !== null)
+                return context;
+        }
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const context = canvas.getContext('2d', { willReadFrequently: true });
+        if (context === null)
+            throw new Error('canvas');
+        return context;
+    }
+}
+exports.PsScanCanvasService = PsScanCanvasService;

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

@@ -0,0 +1,9 @@
+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;
+}

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

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanEdgeService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+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_raster_service_1 = require("./ps-scan-raster-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));
+        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)
+            return null;
+        const hull = ps_scan_hull_service_1.PsScanHullService.convexHull(component);
+        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)
+            return null;
+        if (quadArea / imageArea > ps_scan_config_1.PsScanConfig.detectMaxAreaRatio)
+            return null;
+        if (hullArea > 0 && quadArea / hullArea < ps_scan_config_1.PsScanConfig.detectMinHullFill)
+            return null;
+        if (!ps_scan_geometry_service_1.PsScanGeometryService.isConvex(quad))
+            return null;
+        return ps_scan_geometry_service_1.PsScanGeometryService.inset(quad, ps_scan_config_1.PsScanConfig.detectInset).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;
+    }
+    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));
+    }
+}
+exports.PsScanEdgeService = PsScanEdgeService;

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

@@ -0,0 +1,9 @@
+import { PsScanFilter } from '../constants/ps-scan-filter';
+import type { PsScanRaster } from '../models/ps-scan-raster';
+export declare class PsScanEnhanceService {
+    static apply(source: PsScanRaster, filter: PsScanFilter): PsScanRaster;
+    private static colour;
+    private static document;
+    private static greyscale;
+    private static levels;
+}

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanEnhanceService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_filter_1 = require("../constants/ps-scan-filter");
+const ps_scan_image_filter_service_1 = require("./ps-scan-image-filter-service");
+const ps_scan_raster_service_1 = require("./ps-scan-raster-service");
+class PsScanEnhanceService {
+    static apply(source, filter) {
+        if (filter === ps_scan_filter_1.PsScanFilter.Original)
+            return source;
+        if (filter === ps_scan_filter_1.PsScanFilter.Colour)
+            return PsScanEnhanceService.colour(source);
+        if (filter === ps_scan_filter_1.PsScanFilter.Greyscale)
+            return PsScanEnhanceService.greyscale(source);
+        return PsScanEnhanceService.document(source);
+    }
+    static colour(source) {
+        const gray = ps_scan_image_filter_service_1.PsScanImageFilterService.grayscale(source);
+        const { black, white } = PsScanEnhanceService.levels(gray);
+        const gain = 255 / Math.max(1, white - black);
+        const target = ps_scan_raster_service_1.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 = ps_scan_image_filter_service_1.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(ps_scan_config_1.PsScanConfig.adaptiveWindowMin, Math.floor(Math.min(width, height) / ps_scan_config_1.PsScanConfig.adaptiveWindowDivisor)) >> 1;
+        const target = ps_scan_raster_service_1.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 * ps_scan_config_1.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 = ps_scan_image_filter_service_1.PsScanImageFilterService.grayscale(source);
+        const { black, white } = PsScanEnhanceService.levels(gray);
+        const gain = 255 / Math.max(1, white - black);
+        const target = ps_scan_raster_service_1.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(ps_scan_config_1.PsScanConfig.levelLowPercentile),
+            white: find(ps_scan_config_1.PsScanConfig.levelHighPercentile),
+        };
+    }
+}
+exports.PsScanEnhanceService = PsScanEnhanceService;

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

@@ -0,0 +1,6 @@
+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 sanitize(base: string): string;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+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 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 ? ps_scan_config_1.PsScanConfig.defaultFileName : cleaned.slice(0, 80);
+    }
+}
+exports.PsScanFileNameService = PsScanFileNameService;

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

@@ -0,0 +1,20 @@
+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 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 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;
+    static order(points: PsPoint[]): PsScanQuad;
+    static outputSize(quad: PsScanQuad, raster: PsPageSize): PsPageSize;
+    static rotateSize(size: PsPageSize, rotation: number): PsPageSize;
+    static toPixels(quad: PsScanQuad, size: PsPageSize): PsScanQuad;
+}