@formio/uag 1.13.2 → 2.0.0-rc.10

package/lib/documents/detect.d.ts

@@ -0,0 +1,31 @@
+import type { Converter } from './types';
+/** A file refused for what its bytes are. The message names the file, never its content. */
+export declare class DetectionError extends Error {
+    constructor(message: string);
+}
+/**
+ * The names in a ZIP archive's central directory, read from the end of the
+ * buffer only: no entry is ever inflated. Undefined when it is not a readable
+ * ZIP archive.
+ */
+export declare function zipEntryNames(buffer: Buffer): string[] | undefined;
+/** Whether a buffer is valid UTF-8 (or UTF-16 with a byte order mark) without NUL bytes. */
+export declare function isText(buffer: Buffer): boolean;
+/**
+ * Whether a buffer is text in a legacy 8-bit encoding (Latin-1, Windows-1252):
+ * no NUL bytes and no control characters other than tab, line breaks, form feed
+ * and the DOS end-of-file mark. Spreadsheet and editor exports still write these.
+ */
+export declare function isLegacyText(buffer: Buffer): boolean;
+/**
+ * Identify a file's type from its bytes. The name and the client's MIME type
+ * are hints only: known signatures first, then each converter's `detect`, then
+ * text (typed by extension). A detected type that contradicts the family the
+ * extension promises is refused.
+ */
+export declare function identify(buffer: Buffer, hint: {
+    name: string;
+    type?: string;
+}, converters?: Converter[]): string;
+/** The extensions known for a type, from the converters that accept it and the usual ones. */
+export declare function extensionsOf(type: string, converters?: Converter[]): string[];

package/lib/documents/detect.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetectionError = void 0;
+exports.zipEntryNames = zipEntryNames;
+exports.isText = isText;
+exports.isLegacyText = isLegacyText;
+exports.identify = identify;
+exports.extensionsOf = extensionsOf;
+const mime_1 = require("./mime");
+/** A file refused for what its bytes are. The message names the file, never its content. */
+class DetectionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DetectionError';
+    }
+}
+exports.DetectionError = DetectionError;
+const startsWith = (buffer, bytes, offset = 0) => {
+    const expected = typeof bytes === 'string' ? Buffer.from(bytes, 'latin1') : Buffer.from(bytes);
+    return buffer.length >= offset + expected.length && buffer.subarray(offset, offset + expected.length).equals(expected);
+};
+/**
+ * The names in a ZIP archive's central directory, read from the end of the
+ * buffer only: no entry is ever inflated. Undefined when it is not a readable
+ * ZIP archive.
+ */
+function zipEntryNames(buffer) {
+    // End of central directory: 22 bytes, plus a comment of up to 65535.
+    const start = Math.max(0, buffer.length - 22 - 0xffff);
+    let end = -1;
+    for (let i = buffer.length - 22; i >= start; i--) {
+        if (buffer.readUInt32LE(i) === 0x06054b50) {
+            end = i;
+            break;
+        }
+    }
+    if (end < 0)
+        return undefined;
+    const count = buffer.readUInt16LE(end + 10);
+    const size = buffer.readUInt32LE(end + 12);
+    let offset = buffer.readUInt32LE(end + 16);
+    if (offset + size > end)
+        return undefined;
+    const names = [];
+    for (let i = 0; i < count && offset + 46 <= end; i++) {
+        if (buffer.readUInt32LE(offset) !== 0x02014b50)
+            return undefined;
+        const nameLength = buffer.readUInt16LE(offset + 28);
+        const extraLength = buffer.readUInt16LE(offset + 30);
+        const commentLength = buffer.readUInt16LE(offset + 32);
+        names.push(buffer.subarray(offset + 46, offset + 46 + nameLength).toString('utf8'));
+        offset += 46 + nameLength + extraLength + commentLength;
+    }
+    return names;
+}
+/** An ODF document's type, from its `mimetype` entry when stored uncompressed first, as ODF requires. */
+function odfType(buffer) {
+    if (buffer.readUInt32LE(0) !== 0x04034b50)
+        return undefined;
+    const method = buffer.readUInt16LE(8);
+    const size = buffer.readUInt32LE(18);
+    const nameLength = buffer.readUInt16LE(26);
+    const extraLength = buffer.readUInt16LE(28);
+    const name = buffer.subarray(30, 30 + nameLength).toString('utf8');
+    if (method !== 0 || name !== 'mimetype' || size > 200)
+        return undefined;
+    const type = buffer.subarray(30 + nameLength + extraLength, 30 + nameLength + extraLength + size).toString('ascii').trim();
+    return /^application\/vnd\.oasis\.opendocument\.[a-z.-]+$/.test(type) ? type : undefined;
+}
+function zipType(buffer) {
+    const names = zipEntryNames(buffer);
+    if (!names)
+        return mime_1.MIME.zip;
+    const has = new Set(names);
+    if (has.has('word/document.xml'))
+        return mime_1.MIME.docx;
+    if (has.has('xl/workbook.xml'))
+        return mime_1.MIME.xlsx;
+    if (has.has('ppt/presentation.xml'))
+        return mime_1.MIME.pptx;
+    if (has.has('mimetype'))
+        return odfType(buffer) || mime_1.MIME.zip;
+    return mime_1.MIME.zip;
+}
+/** Whether a buffer is valid UTF-8 (or UTF-16 with a byte order mark) without NUL bytes. */
+function isText(buffer) {
+    if (startsWith(buffer, [0xff, 0xfe]) || startsWith(buffer, [0xfe, 0xff])) {
+        return buffer.length % 2 === 0;
+    }
+    if (buffer.includes(0))
+        return false;
+    try {
+        new TextDecoder('utf-8', { fatal: true }).decode(buffer);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether a buffer is text in a legacy 8-bit encoding (Latin-1, Windows-1252):
+ * no NUL bytes and no control characters other than tab, line breaks, form feed
+ * and the DOS end-of-file mark. Spreadsheet and editor exports still write these.
+ */
+function isLegacyText(buffer) {
+    for (const byte of buffer) {
+        if (byte < 0x20 && byte !== 0x09 && byte !== 0x0a && byte !== 0x0d && byte !== 0x0c && byte !== 0x1a)
+            return false;
+    }
+    return true;
+}
+/** The type the shared detection gives the bytes, or undefined when it does not know them. */
+function signatureType(buffer, ext) {
+    if (startsWith(buffer, '%PDF-'))
+        return mime_1.MIME.pdf;
+    if (startsWith(buffer, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))
+        return mime_1.MIME.png;
+    if (startsWith(buffer, [0xff, 0xd8, 0xff]))
+        return mime_1.MIME.jpeg;
+    if (startsWith(buffer, 'GIF87a') || startsWith(buffer, 'GIF89a'))
+        return mime_1.MIME.gif;
+    if (startsWith(buffer, 'RIFF') && startsWith(buffer, 'WEBP', 8))
+        return mime_1.MIME.webp;
+    if (startsWith(buffer, [0x50, 0x4b, 0x03, 0x04]) || startsWith(buffer, [0x50, 0x4b, 0x05, 0x06]))
+        return zipType(buffer);
+    if (startsWith(buffer, [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1])) {
+        return { '.doc': mime_1.MIME.doc, '.xls': mime_1.MIME.xls, '.ppt': mime_1.MIME.ppt }[ext] || mime_1.MIME.ole;
+    }
+    if (startsWith(buffer, '{\\rtf'))
+        return mime_1.MIME.rtf;
+    return undefined;
+}
+/**
+ * Identify a file's type from its bytes. The name and the client's MIME type
+ * are hints only: known signatures first, then each converter's `detect`, then
+ * text (typed by extension). A detected type that contradicts the family the
+ * extension promises is refused.
+ */
+function identify(buffer, hint, converters = []) {
+    const ext = (0, mime_1.extensionOf)(hint.name);
+    let type = signatureType(buffer, ext);
+    if (!type) {
+        const head = buffer.subarray(0, 4096);
+        for (const converter of converters) {
+            if (typeof converter.detect !== 'function')
+                continue;
+            const detected = converter.detect(head, { name: hint.name, type: hint.type || '' });
+            if (typeof detected === 'string' && detected) {
+                type = detected;
+                break;
+            }
+        }
+    }
+    if (!type) {
+        // Text named as text may also be in a legacy 8-bit encoding; decodeText reads it as Windows-1252.
+        const text = isText(buffer) || (!!mime_1.TEXT_BY_EXTENSION[ext] && isLegacyText(buffer));
+        type = text ? (mime_1.TEXT_BY_EXTENSION[ext] || mime_1.MIME.text) : mime_1.MIME.binary;
+    }
+    const promised = mime_1.FAMILY_BY_EXTENSION[ext];
+    if (promised && promised !== (0, mime_1.familyOf)(type)) {
+        throw new DetectionError(`"${hint.name}" is named ${ext} but its content is not a ${ext.slice(1).toUpperCase()} file; it was refused.`);
+    }
+    return type;
+}
+/** The extensions known for a type, from the converters that accept it and the usual ones. */
+function extensionsOf(type, converters = []) {
+    const fromConverters = converters.flatMap((converter) => converter.accepts.filter((accept) => accept.type === type).flatMap((accept) => accept.ext || []));
+    return [...new Set([...fromConverters, ...(mime_1.EXTENSIONS[type] || [])].map((ext) => ext.toLowerCase()))];
+}

package/lib/documents/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export { MIME } from './mime';
+export { identify, DetectionError, zipEntryNames } from './detect';
+export { runConverter, ConversionError, CONVERTER_DEFAULTS } from './convert';
+export { BUILT_IN_CONVERTERS, pdfTextConverter, textConverter, imagePdfConverter } from './converters';
+export { ConverterRoutes, stepName } from './routes';
+export type { FileRoute, AcceptEntry, Pins } from './routes';
+export { converterPluginType, registerDocuments, documentsOf } from './plugins';
+export { converterFileReader, readAsText } from './readers';

package/lib/documents/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAsText = exports.converterFileReader = exports.documentsOf = exports.registerDocuments = exports.converterPluginType = exports.stepName = exports.ConverterRoutes = exports.imagePdfConverter = exports.textConverter = exports.pdfTextConverter = exports.BUILT_IN_CONVERTERS = exports.CONVERTER_DEFAULTS = exports.ConversionError = exports.runConverter = exports.zipEntryNames = exports.DetectionError = exports.identify = exports.MIME = void 0;
+__exportStar(require("./types"), exports);
+var mime_1 = require("./mime");
+Object.defineProperty(exports, "MIME", { enumerable: true, get: function () { return mime_1.MIME; } });
+var detect_1 = require("./detect");
+Object.defineProperty(exports, "identify", { enumerable: true, get: function () { return detect_1.identify; } });
+Object.defineProperty(exports, "DetectionError", { enumerable: true, get: function () { return detect_1.DetectionError; } });
+Object.defineProperty(exports, "zipEntryNames", { enumerable: true, get: function () { return detect_1.zipEntryNames; } });
+var convert_1 = require("./convert");
+Object.defineProperty(exports, "runConverter", { enumerable: true, get: function () { return convert_1.runConverter; } });
+Object.defineProperty(exports, "ConversionError", { enumerable: true, get: function () { return convert_1.ConversionError; } });
+Object.defineProperty(exports, "CONVERTER_DEFAULTS", { enumerable: true, get: function () { return convert_1.CONVERTER_DEFAULTS; } });
+var converters_1 = require("./converters");
+Object.defineProperty(exports, "BUILT_IN_CONVERTERS", { enumerable: true, get: function () { return converters_1.BUILT_IN_CONVERTERS; } });
+Object.defineProperty(exports, "pdfTextConverter", { enumerable: true, get: function () { return converters_1.pdfTextConverter; } });
+Object.defineProperty(exports, "textConverter", { enumerable: true, get: function () { return converters_1.textConverter; } });
+Object.defineProperty(exports, "imagePdfConverter", { enumerable: true, get: function () { return converters_1.imagePdfConverter; } });
+var routes_1 = require("./routes");
+Object.defineProperty(exports, "ConverterRoutes", { enumerable: true, get: function () { return routes_1.ConverterRoutes; } });
+Object.defineProperty(exports, "stepName", { enumerable: true, get: function () { return routes_1.stepName; } });
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "converterPluginType", { enumerable: true, get: function () { return plugins_1.converterPluginType; } });
+Object.defineProperty(exports, "registerDocuments", { enumerable: true, get: function () { return plugins_1.registerDocuments; } });
+Object.defineProperty(exports, "documentsOf", { enumerable: true, get: function () { return plugins_1.documentsOf; } });
+var readers_1 = require("./readers");
+Object.defineProperty(exports, "converterFileReader", { enumerable: true, get: function () { return readers_1.converterFileReader; } });
+Object.defineProperty(exports, "readAsText", { enumerable: true, get: function () { return readers_1.readAsText; } });

package/lib/documents/mime.d.ts

@@ -0,0 +1,39 @@
+/** Canonical MIME types the UAG identifies, and the extensions that go with them. */
+export declare const MIME: {
+    readonly pdf: 'application/pdf';
+    readonly png: 'image/png';
+    readonly jpeg: 'image/jpeg';
+    readonly gif: 'image/gif';
+    readonly webp: 'image/webp';
+    readonly docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+    readonly xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+    readonly pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+    readonly doc: 'application/msword';
+    readonly xls: 'application/vnd.ms-excel';
+    readonly ppt: 'application/vnd.ms-powerpoint';
+    readonly rtf: 'application/rtf';
+    readonly zip: 'application/zip';
+    readonly ole: 'application/x-ole-storage';
+    readonly text: 'text/plain';
+    readonly markdown: 'text/markdown';
+    readonly csv: 'text/csv';
+    readonly json: 'application/json';
+    readonly html: 'text/html';
+    readonly xml: 'application/xml';
+    readonly binary: 'application/octet-stream';
+};
+/** Text types, by extension. */
+export declare const TEXT_BY_EXTENSION: Record<string, string>;
+/** The usual extensions of each type, for the builder's file picker. */
+export declare const EXTENSIONS: Record<string, string[]>;
+/**
+ * The family of content an extension promises. A file whose detected content
+ * belongs to another family is refused: a disguised file.
+ */
+export declare const FAMILY_BY_EXTENSION: Record<string, string>;
+/** The family of a detected type. */
+export declare function familyOf(type: string): string;
+/** A file name's extension, lower-case with its dot ('' when it has none). */
+export declare function extensionOf(name: string | undefined): string;
+/** Whether a type is one the built-in text converter reads. */
+export declare const TEXT_TYPES: string[];

package/lib/documents/mime.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEXT_TYPES = exports.FAMILY_BY_EXTENSION = exports.EXTENSIONS = exports.TEXT_BY_EXTENSION = exports.MIME = void 0;
+exports.familyOf = familyOf;
+exports.extensionOf = extensionOf;
+/** Canonical MIME types the UAG identifies, and the extensions that go with them. */
+exports.MIME = {
+    pdf: 'application/pdf',
+    png: 'image/png',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    doc: 'application/msword',
+    xls: 'application/vnd.ms-excel',
+    ppt: 'application/vnd.ms-powerpoint',
+    rtf: 'application/rtf',
+    zip: 'application/zip',
+    ole: 'application/x-ole-storage',
+    text: 'text/plain',
+    markdown: 'text/markdown',
+    csv: 'text/csv',
+    json: 'application/json',
+    html: 'text/html',
+    xml: 'application/xml',
+    binary: 'application/octet-stream'
+};
+/** Text types, by extension. */
+exports.TEXT_BY_EXTENSION = {
+    '.txt': exports.MIME.text,
+    '.text': exports.MIME.text,
+    '.md': exports.MIME.markdown,
+    '.markdown': exports.MIME.markdown,
+    '.csv': exports.MIME.csv,
+    '.json': exports.MIME.json,
+    '.html': exports.MIME.html,
+    '.htm': exports.MIME.html,
+    '.xml': exports.MIME.xml
+};
+/** The usual extensions of each type, for the builder's file picker. */
+exports.EXTENSIONS = {
+    [exports.MIME.pdf]: ['.pdf'],
+    [exports.MIME.png]: ['.png'],
+    [exports.MIME.jpeg]: ['.jpg', '.jpeg'],
+    [exports.MIME.gif]: ['.gif'],
+    [exports.MIME.webp]: ['.webp'],
+    [exports.MIME.docx]: ['.docx'],
+    [exports.MIME.xlsx]: ['.xlsx'],
+    [exports.MIME.pptx]: ['.pptx'],
+    [exports.MIME.doc]: ['.doc'],
+    [exports.MIME.xls]: ['.xls'],
+    [exports.MIME.ppt]: ['.ppt'],
+    [exports.MIME.rtf]: ['.rtf'],
+    [exports.MIME.text]: ['.txt'],
+    [exports.MIME.markdown]: ['.md', '.markdown'],
+    [exports.MIME.csv]: ['.csv'],
+    [exports.MIME.json]: ['.json'],
+    [exports.MIME.html]: ['.html', '.htm'],
+    [exports.MIME.xml]: ['.xml'],
+    'application/vnd.oasis.opendocument.text': ['.odt'],
+    'application/vnd.oasis.opendocument.spreadsheet': ['.ods'],
+    'application/vnd.oasis.opendocument.presentation': ['.odp']
+};
+/**
+ * The family of content an extension promises. A file whose detected content
+ * belongs to another family is refused: a disguised file.
+ */
+exports.FAMILY_BY_EXTENSION = {
+    '.pdf': 'pdf',
+    '.png': 'image', '.jpg': 'image', '.jpeg': 'image', '.gif': 'image', '.webp': 'image',
+    '.docx': 'zip', '.xlsx': 'zip', '.pptx': 'zip', '.odt': 'zip', '.ods': 'zip', '.odp': 'zip', '.zip': 'zip',
+    '.doc': 'ole', '.xls': 'ole', '.ppt': 'ole',
+    '.rtf': 'rtf',
+    ...Object.fromEntries(Object.keys(exports.TEXT_BY_EXTENSION).map((ext) => [ext, 'text']))
+};
+/** The family of a detected type. */
+function familyOf(type) {
+    if (type === exports.MIME.pdf)
+        return 'pdf';
+    if (type.startsWith('image/'))
+        return 'image';
+    if ([exports.MIME.docx, exports.MIME.xlsx, exports.MIME.pptx, exports.MIME.zip].includes(type) || type.startsWith('application/vnd.oasis.opendocument.'))
+        return 'zip';
+    if ([exports.MIME.doc, exports.MIME.xls, exports.MIME.ppt, exports.MIME.ole].includes(type))
+        return 'ole';
+    if (type === exports.MIME.rtf)
+        return 'rtf';
+    if (type.startsWith('text/') || type === exports.MIME.json || type === exports.MIME.xml)
+        return 'text';
+    return 'other';
+}
+/** A file name's extension, lower-case with its dot ('' when it has none). */
+function extensionOf(name) {
+    const match = /(\.[A-Za-z0-9]+)$/.exec(String(name || ''));
+    return match ? match[1].toLowerCase() : '';
+}
+/** Whether a type is one the built-in text converter reads. */
+exports.TEXT_TYPES = [exports.MIME.text, exports.MIME.markdown, exports.MIME.csv, exports.MIME.json, exports.MIME.html, exports.MIME.xml];

package/lib/documents/plugins.d.ts

@@ -0,0 +1,18 @@
+import type { PluginRegistry, PluginType } from '@formio/appserver';
+import { AcceptEntry, ConverterRoutes } from './routes';
+/** Per registry: the converter routes (with `documents.prefer`), once the converters are set up. */
+type DocumentsState = {
+    routes: ConverterRoutes;
+    accept: Map<string, AcceptEntry[]>;
+};
+/** The routes over the enabled converters, and each document plugin's `accept`, once the registry has started. */
+export declare function documentsOf(registry: PluginRegistry): DocumentsState;
+/** Plugin type `converter`: a file into a PDF or text. Chosen automatically by file type. Experimental in 2.0. */
+export declare const converterPluginType: PluginType;
+/**
+ * Register the converter type and the built-in converters, as the server's
+ * own. The `document` type comes with the AI Document module
+ * (@formio/uag-extras/modules/ai-document).
+ */
+export declare function registerDocuments(registry: PluginRegistry): void;
+export {};

package/lib/documents/plugins.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.converterPluginType = void 0;
+exports.documentsOf = documentsOf;
+exports.registerDocuments = registerDocuments;
+const converters_1 = require("./converters");
+const routes_1 = require("./routes");
+const REPRESENTATIONS = ['pdf', 'text'];
+const isObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const states = new WeakMap();
+/** The routes over the enabled converters, and each document plugin's `accept`, once the registry has started. */
+function documentsOf(registry) {
+    let state = states.get(registry);
+    if (!state) {
+        state = { routes: new routes_1.ConverterRoutes(registry.list('converter')), accept: new Map() };
+        states.set(registry, state);
+    }
+    return state;
+}
+/** Plugin type `converter`: a file into a PDF or text. Chosen automatically by file type. Experimental in 2.0. */
+exports.converterPluginType = {
+    type: 'converter',
+    title: 'Converter',
+    apiVersions: [1],
+    editForm: 'none',
+    unavailable: 'disable',
+    stability: 'experimental',
+    validate(plugin) {
+        const problems = [];
+        if (!Array.isArray(plugin.accepts) || !plugin.accepts.length || !plugin.accepts.every((accept) => isObject(accept) && typeof accept.type === 'string' && /^[a-z]+\/[a-z0-9.+-]+$/i.test(accept.type) &&
+            (accept.ext === undefined || (Array.isArray(accept.ext) && accept.ext.every((ext) => typeof ext === 'string' && /^\.[a-z0-9]+$/i.test(ext)))))) {
+            problems.push('"accepts" must list { type, ext? } entries: MIME types, and extensions such as ".docx"');
+        }
+        if (!Array.isArray(plugin.produces) || !plugin.produces.length || !plugin.produces.every((kind) => REPRESENTATIONS.includes(kind))) {
+            problems.push('"produces" must list "pdf", "text" or both');
+        }
+        if (typeof plugin.convert !== 'function')
+            problems.push('"convert" must be a function');
+        if (plugin.detect !== undefined && typeof plugin.detect !== 'function')
+            problems.push('"detect" must be a function');
+        if (plugin.rank !== undefined && !Number.isFinite(plugin.rank))
+            problems.push('"rank" must be a number');
+        if (plugin.limits !== undefined) {
+            if (!isObject(plugin.limits) || !Object.entries(plugin.limits).every(([key, value]) => ['maxBytes', 'timeoutMs', 'concurrency'].includes(key) && Number.isFinite(value) && value > 0)) {
+                problems.push('"limits" may hold positive maxBytes, timeoutMs and concurrency');
+            }
+        }
+        return problems;
+    },
+    /** Once every converter is set up: the routes between file types, with `documents.prefer`. */
+    initialize(registry, context) {
+        const prefer = context.server?.config?.documents?.prefer || {};
+        states.set(registry, { routes: new routes_1.ConverterRoutes(registry.list('converter'), prefer), accept: new Map() });
+    },
+    manifest: (plugin) => ({ accepts: plugin.accepts, produces: plugin.produces })
+};
+/**
+ * Register the converter type and the built-in converters, as the server's
+ * own. The `document` type comes with the AI Document module
+ * (@formio/uag-extras/modules/ai-document).
+ */
+function registerDocuments(registry) {
+    registry.addType(exports.converterPluginType, '@formio/uag');
+    registry.add(converters_1.BUILT_IN_CONVERTERS, '@formio/uag', { server: true });
+}

package/lib/documents/readers.d.ts

@@ -0,0 +1,19 @@
+import type { PluginRegistry } from '@formio/appserver';
+import type { FormflowFileReader } from '../formflow';
+/** Read a file as text through the converters: its detected type, its text, and its page count when known. */
+export declare function readAsText(registry: PluginRegistry, buffer: Buffer, meta: {
+    name: string;
+    type?: string;
+}, options?: {
+    signal?: AbortSignal;
+}): Promise<{
+    type: string;
+    text: string;
+    pages?: number;
+}>;
+/**
+ * A reader for task file inputs, built from the converters: it accepts a file
+ * whose type has a route to text, and reads it through that route. Task file
+ * inputs therefore read every type the installed converters handle.
+ */
+export declare function converterFileReader(registry: PluginRegistry): FormflowFileReader;

package/lib/documents/readers.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAsText = readAsText;
+exports.converterFileReader = converterFileReader;
+const detect_1 = require("./detect");
+const convert_1 = require("./convert");
+const mime_1 = require("./mime");
+const plugins_1 = require("./plugins");
+/** What a ZIP file is, from its extension: the first bytes cannot tell a Word file from any other ZIP. */
+const ZIP_BY_EXTENSION = {
+    '.docx': mime_1.MIME.docx, '.xlsx': mime_1.MIME.xlsx, '.pptx': mime_1.MIME.pptx,
+    '.odt': 'application/vnd.oasis.opendocument.text', '.ods': 'application/vnd.oasis.opendocument.spreadsheet', '.odp': 'application/vnd.oasis.opendocument.presentation'
+};
+const log = {
+    info: () => undefined,
+    warn: (msg) => console.warn(`[formio-uag] ${msg}`),
+    error: (msg) => console.error(`[formio-uag] ${msg}`)
+};
+/** Read a file as text through the converters: its detected type, its text, and its page count when known. */
+async function readAsText(registry, buffer, meta, options = {}) {
+    const converters = registry.list('converter');
+    const type = (0, detect_1.identify)(buffer, { name: meta.name, type: meta.type }, converters);
+    const steps = (0, plugins_1.documentsOf)(registry).routes.toText(type);
+    if (!steps) {
+        throw new Error(`"${meta.name}" (${type}) cannot be read as text: no installed converter reads it.`);
+    }
+    const output = await (0, convert_1.runRoute)(steps, { buffer, type, name: meta.name }, 'text', {
+        log,
+        signal: options.signal,
+        settingsOf: (converter) => registry.settings('converter', converter.name)
+    });
+    // No text, with the converters saying why (an image, a scan): an error, never an empty document.
+    if (!String(output.text).trim() && Array.isArray(output.warnings) && output.warnings.length) {
+        throw new convert_1.ConversionError(`"${meta.name}" has no text to read: ${output.warnings.join(' ')}`);
+    }
+    return { type, text: output.text, ...(Array.isArray(output.pages) && { pages: output.pages.length }) };
+}
+/**
+ * A reader for task file inputs, built from the converters: it accepts a file
+ * whose type has a route to text, and reads it through that route. Task file
+ * inputs therefore read every type the installed converters handle.
+ */
+function converterFileReader(registry) {
+    const converters = () => registry.list('converter');
+    return {
+        name: 'converters',
+        accepts(meta, head) {
+            let type;
+            try {
+                type = (0, detect_1.identify)(head, { name: meta.name, type: meta.type }, converters());
+            }
+            catch {
+                // Too few bytes to be sure, or a name that contradicts them: read() decides on the whole file.
+                return true;
+            }
+            if (type === mime_1.MIME.zip)
+                type = ZIP_BY_EXTENSION[(0, mime_1.extensionOf)(meta.name)] || type;
+            return !!(0, plugins_1.documentsOf)(registry).routes.toText(type);
+        },
+        async read(buffer, meta, options) {
+            return { text: (await readAsText(registry, buffer, meta, { signal: options?.signal })).text };
+        }
+    };
+}

package/lib/documents/routes.d.ts

@@ -0,0 +1,52 @@
+import type { Converter, Representation } from './types';
+/** How one file reaches the representations of one of a plugin's input sets. */
+export type FileRoute = {
+    inputs: Representation[];
+    /** The converters that make the PDF ([] for a PDF: identity). */
+    pdf?: Converter[];
+    /** The converters that make the text; with a PDF in the set, the PDF's own steps then PDF to text. */
+    text?: Converter[];
+};
+/** Converter pins by source type: a component's `uag.converters`. */
+export type Pins = Record<string, string>;
+/** A source type a document plugin can take, as its manifest's `accept` lists it. */
+export type AcceptEntry = {
+    type: string;
+    ext: string[];
+    /** The input set it reaches, and the converter names of each representation's route. */
+    routes: {
+        inputs: Representation[];
+        pdf?: string[];
+        text?: string[];
+    };
+    /** The converters that read this type: a pin chooses among them when there are several. */
+    converters: string[];
+};
+/** A converter as `name@version`, as results record routes. */
+export declare const stepName: (converter: Converter) => string;
+/**
+ * Routes from source types to representations over a set of converters.
+ * When several converters can do a step, the component's pin wins, then the
+ * operator's `documents.prefer`, then the highest rank, then the name.
+ */
+export declare class ConverterRoutes {
+    readonly converters: Converter[];
+    private readonly prefer;
+    constructor(converters: Converter[], prefer?: Record<string, string>);
+    /** The converter for one step from `source` to `target`, or undefined when none can do it. */
+    choose(source: string, target: Representation, pins?: Pins): Converter | undefined;
+    /** The steps from `source` to a PDF: [] for a PDF, one converter otherwise, or null. */
+    toPdf(source: string, pins?: Pins): Converter[] | null;
+    /** The steps from `source` to text: one converter, or to a PDF and then its text; null when none. */
+    toText(source: string, pins?: Pins): Converter[] | null;
+    /**
+     * The first of a plugin's input sets every representation of which the
+     * file can reach. With both PDF and text, the text is always that same
+     * PDF's text, so content made from the PDF is checked against it.
+     */
+    route(source: string, inputs: Representation[][], pins?: Pins): FileRoute | null;
+    /** Every source type a converter reads, and PDF. */
+    sourceTypes(): string[];
+    /** The source types a plugin with these inputs can take, with their routes: its manifest's `accept`. */
+    accept(inputs: Representation[][]): AcceptEntry[];
+}