@qvac/harness 0.7.3 → 0.8.0

package/dist-lib/lib/office/engine/xlsx/write.d.ts

@@ -0,0 +1,2 @@
+export type EmbeddedValue = string | number | null | undefined;
+export declare function writeWorkbook(rows: EmbeddedValue[][], sheet?: string): Uint8Array;

package/dist-lib/lib/office/engine/xlsx/write.js

@@ -0,0 +1,42 @@
+import { Package } from '../opc/package.js';
+import * as xml from '../xml.js';
+import { cell } from './refs.js';
+const SML = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+const REL_BASE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/';
+const TYPES = {
+    workbook: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml',
+    worksheet: 'application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml',
+    styles: 'application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'
+};
+const STYLES = `<styleSheet xmlns="${SML}"><fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts><fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills><borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders><cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs><cellXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/></cellXfs><cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles></styleSheet>`;
+function escape(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function cellXml(value, ref) {
+    if (value === null || value === undefined || value === '')
+        return '';
+    if (typeof value === 'number')
+        return `<c r="${ref}"><v>${value}</v></c>`;
+    return `<c r="${ref}" t="inlineStr"><is><t xml:space="preserve">${escape(value)}</t></is></c>`;
+}
+function sheetXml(rows) {
+    const data = rows
+        .map((row, r) => `<row r="${r + 1}">${row.map((value, c) => cellXml(value, cell(r, c))).join('')}</row>`)
+        .join('');
+    return `<worksheet xmlns="${SML}"><sheetData>${data}</sheetData></worksheet>`;
+}
+export function writeWorkbook(rows, sheet = 'Sheet1') {
+    const pkg = Package.create();
+    const workbook = `<workbook xmlns="${SML}" xmlns:r="${xml.ns.r}"><sheets><sheet name="${escape(sheet)}" sheetId="1" r:id="rId1"/></sheets></workbook>`;
+    pkg.add('/xl/workbook.xml', xml.parse(workbook), TYPES.workbook);
+    pkg.add('/xl/worksheets/sheet1.xml', xml.parse(sheetXml(rows)), TYPES.worksheet);
+    pkg.add('/xl/styles.xml', xml.parse(STYLES), TYPES.styles);
+    pkg.rels('/').add(REL_BASE + 'officeDocument', '/xl/workbook.xml');
+    pkg.rels('/xl/workbook.xml').add(REL_BASE + 'worksheet', '/xl/worksheets/sheet1.xml');
+    pkg.rels('/xl/workbook.xml').add(REL_BASE + 'styles', '/xl/styles.xml');
+    return pkg.save();
+}

package/dist-lib/lib/office/engine/xml.d.ts

@@ -0,0 +1,45 @@
+import { Element, type Document, type Node } from '@xmldom/xmldom';
+export type { Document, Element, Node };
+export declare const ns: {
+    readonly a: 'http://schemas.openxmlformats.org/drawingml/2006/main';
+    readonly p: 'http://schemas.openxmlformats.org/presentationml/2006/main';
+    readonly r: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+    readonly w: 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+    readonly p14: 'http://schemas.microsoft.com/office/powerpoint/2010/main';
+    readonly wp: 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing';
+    readonly pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture';
+    readonly c: 'http://schemas.openxmlformats.org/drawingml/2006/chart';
+    readonly xdr: 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing';
+    readonly x: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+    readonly rels: 'http://schemas.openxmlformats.org/package/2006/relationships';
+    readonly ct: 'http://schemas.openxmlformats.org/package/2006/content-types';
+};
+export type Attributes = Record<string, string | number | undefined | null>;
+export type Build = (local: string, attributes?: Attributes) => Element;
+export declare function decode(bytes: Uint8Array): string;
+export declare function parse(input: Uint8Array | string, name?: string): Document;
+export declare function toString(doc: Document): string;
+export declare function serialize(doc: Document): Uint8Array;
+export declare function root(doc: Document): Element;
+export declare function owner(node: Node): Document;
+export declare function isElement(node: Node | null, namespace?: string, local?: string): node is Element;
+export declare function children(el: Node, namespace?: string, local?: string): Element[];
+export declare function child(el: Node, namespace?: string, local?: string): Element | null;
+export declare function descendants(el: Element | Document, namespace: string, local: string): Element[];
+export declare function text(node: Node | null): string;
+export declare function clean(value: string): string;
+export declare function setText(el: Element, value: string): void;
+export declare function attr(el: Element, name: string): string;
+export declare function setAttributes(el: Element, attributes?: Attributes): Element;
+export declare function named(doc: Document, qualifiedName: string, namespace: string): Element;
+export declare function qualify(doc: Document, namespace: string, local: string): string;
+export declare function builder(doc: Document, namespace: string): Build;
+export interface QualifiedName {
+    namespace: string;
+    local: string;
+}
+export declare function setNsAttribute(el: Element, name: QualifiedName, value: string): void;
+export declare function insertOrdered(parent: Element, el: Element, order: readonly string[]): Element;
+export declare function remove(node: Node): void;
+export declare function append(parent: Node, node: Element): Element;
+export declare function clone(el: Element): Element;

package/dist-lib/lib/office/engine/xml.js

@@ -0,0 +1,258 @@
+import { DOMParser, XMLSerializer, Element } from '@xmldom/xmldom';
+import { DocsError } from './errors.js';
+import { errorMessage } from '../../guards.js';
+import * as utf8 from './utf8.js';
+export const ns = {
+    a: 'http://schemas.openxmlformats.org/drawingml/2006/main',
+    p: 'http://schemas.openxmlformats.org/presentationml/2006/main',
+    r: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+    w: 'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+    p14: 'http://schemas.microsoft.com/office/powerpoint/2010/main',
+    wp: 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing',
+    pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture',
+    c: 'http://schemas.openxmlformats.org/drawingml/2006/chart',
+    xdr: 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing',
+    x: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+    rels: 'http://schemas.openxmlformats.org/package/2006/relationships',
+    ct: 'http://schemas.openxmlformats.org/package/2006/content-types'
+};
+const MAX_DEPTH = 256;
+const NOT_XML = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+const DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+const UNPREFIXED = [ns.rels, ns.ct, ns.x];
+const PREFIXES = new Map(Object.entries(ns)
+    .filter(([, uri]) => !UNPREFIXED.includes(uri))
+    .map(([prefix, uri]) => [uri, prefix]));
+const SKIPPED = [
+    ['<!--', '-->'],
+    ['<![CDATA[', ']]>'],
+    ['<?', '?>'],
+    ['<!', '>']
+];
+function skipped(text, at) {
+    for (const [open, close] of SKIPPED) {
+        if (text.startsWith(open, at)) {
+            const end = text.indexOf(close, at + open.length);
+            return end === -1 ? -1 : end + close.length;
+        }
+    }
+    return null;
+}
+function tagEnd(text, at) {
+    let quote = '';
+    for (let i = at; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            quote = c === quote ? '' : quote;
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+        }
+        else if (c === '>') {
+            return i;
+        }
+    }
+    return -1;
+}
+function checkDepth(text, name) {
+    let depth = 0;
+    for (let i = text.indexOf('<'); i !== -1; i = text.indexOf('<', i)) {
+        const after = skipped(text, i);
+        if (after === -1) {
+            return;
+        }
+        if (after !== null) {
+            i = after;
+            continue;
+        }
+        const end = tagEnd(text, i + 1);
+        if (end === -1) {
+            return;
+        }
+        if (text[i + 1] === '/') {
+            depth--;
+        }
+        else if (text[end - 1] !== '/') {
+            depth++;
+        }
+        if (depth > MAX_DEPTH) {
+            throw new DocsError('UNSAFE_XML', `${name} nests elements more than ${MAX_DEPTH} levels deep`);
+        }
+        i = end + 1;
+    }
+}
+function decodeUtf16(bytes, endian) {
+    const littleEndian = endian === 'le';
+    let out = '';
+    for (let i = 2; i + 1 < bytes.length; i += 2) {
+        const code = littleEndian ? bytes[i] | (bytes[i + 1] << 8) : (bytes[i] << 8) | bytes[i + 1];
+        out += String.fromCharCode(code);
+    }
+    return out;
+}
+export function decode(bytes) {
+    if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        return utf8.decode(bytes.subarray(3));
+    }
+    if (bytes[0] === 0xff && bytes[1] === 0xfe) {
+        return decodeUtf16(bytes, 'le');
+    }
+    if (bytes[0] === 0xfe && bytes[1] === 0xff) {
+        return decodeUtf16(bytes, 'be');
+    }
+    return utf8.decode(bytes);
+}
+function causeOf(err) {
+    return err instanceof Error ? err.cause : undefined;
+}
+export function parse(input, name = 'part') {
+    const text = (typeof input === 'string' ? input : decode(input)).replace(/^/, '');
+    if (/<!DOCTYPE/i.test(text)) {
+        throw new DocsError('UNSAFE_XML', `${name} declares a DOCTYPE, which Office files never do`);
+    }
+    checkDepth(text, name);
+    const invalid = (message) => new DocsError('INVALID_XML', `${name} is not well-formed XML: ${message}`);
+    const parser = new DOMParser({
+        onError(level, message) {
+            if (level !== 'warning') {
+                throw invalid(message);
+            }
+        }
+    });
+    let doc;
+    try {
+        doc = parser.parseFromString(text, 'application/xml');
+    }
+    catch (err) {
+        if (err instanceof DocsError) {
+            throw err;
+        }
+        const cause = causeOf(err);
+        if (cause instanceof DocsError) {
+            throw cause;
+        }
+        throw invalid(errorMessage(err));
+    }
+    if (!doc.documentElement) {
+        throw new DocsError('INVALID_XML', `${name} has no root element`);
+    }
+    return doc;
+}
+export function toString(doc) {
+    return new XMLSerializer().serializeToString(doc);
+}
+export function serialize(doc) {
+    const text = toString(doc);
+    if (!text.startsWith('<?xml')) {
+        return utf8.encode(DECLARATION + text);
+    }
+    return utf8.encode(text.replace(/^(<\?xml[^?]*?encoding=)(["'])[^"']*\2/i, '$1$2UTF-8$2'));
+}
+export function root(doc) {
+    const el = doc.documentElement;
+    if (!el) {
+        throw new DocsError('INVALID_XML', 'the part has no root element');
+    }
+    return el;
+}
+export function owner(node) {
+    const doc = node.ownerDocument;
+    if (!doc) {
+        throw new DocsError('INVALID_XML', 'the element belongs to no document');
+    }
+    return doc;
+}
+export function isElement(node, namespace, local) {
+    return (node instanceof Element &&
+        (namespace === undefined || node.namespaceURI === namespace) &&
+        (local === undefined || node.localName === local));
+}
+export function children(el, namespace, local) {
+    const out = [];
+    for (let n = el.firstChild; n; n = n.nextSibling) {
+        if (isElement(n, namespace, local)) {
+            out.push(n);
+        }
+    }
+    return out;
+}
+export function child(el, namespace, local) {
+    for (let n = el.firstChild; n; n = n.nextSibling) {
+        if (isElement(n, namespace, local))
+            return n;
+    }
+    return null;
+}
+export function descendants(el, namespace, local) {
+    return Array.from(el.getElementsByTagNameNS(namespace, local));
+}
+export function text(node) {
+    return node?.textContent ?? '';
+}
+export function clean(value) {
+    return value.replace(NOT_XML, '');
+}
+export function setText(el, value) {
+    while (el.firstChild) {
+        el.removeChild(el.firstChild);
+    }
+    el.appendChild(owner(el).createTextNode(clean(value)));
+}
+export function attr(el, name) {
+    return el.getAttribute(name) ?? '';
+}
+export function setAttributes(el, attributes = {}) {
+    for (const [key, value] of Object.entries(attributes)) {
+        if (value !== undefined && value !== null) {
+            el.setAttribute(key, String(value));
+        }
+    }
+    return el;
+}
+export function named(doc, qualifiedName, namespace) {
+    return doc.createElementNS(namespace, qualifiedName);
+}
+export function qualify(doc, namespace, local) {
+    const top = root(doc);
+    if (top.namespaceURI === namespace && !top.prefix) {
+        return local;
+    }
+    const prefix = top.lookupPrefix(namespace) ?? PREFIXES.get(namespace);
+    return prefix ? `${prefix}:${local}` : local;
+}
+export function builder(doc, namespace) {
+    return (local, attributes) => setAttributes(named(doc, qualify(doc, namespace, local), namespace), attributes);
+}
+export function setNsAttribute(el, name, value) {
+    const doc = owner(el);
+    const prefix = root(doc).lookupPrefix(name.namespace) ?? PREFIXES.get(name.namespace) ?? name.local;
+    el.setAttributeNS(name.namespace, `${prefix}:${name.local}`, value);
+}
+export function insertOrdered(parent, el, order) {
+    const rank = order.indexOf(el.localName ?? '');
+    for (let n = parent.firstChild; n; n = n.nextSibling) {
+        if (!(n instanceof Element))
+            continue;
+        const other = order.indexOf(n.localName ?? '');
+        if (other > rank || other === -1) {
+            parent.insertBefore(el, n);
+            return el;
+        }
+    }
+    parent.appendChild(el);
+    return el;
+}
+export function remove(node) {
+    node.parentNode?.removeChild(node);
+}
+export function append(parent, node) {
+    parent.appendChild(node);
+    return node;
+}
+export function clone(el) {
+    const copy = el.cloneNode(true);
+    if (!(copy instanceof Element)) {
+        throw new DocsError('INVALID_XML', 'cloning an element produced no element');
+    }
+    return copy;
+}

package/dist-lib/lib/tools/exec/scope.d.ts

@@ -1,3 +1,5 @@
 export declare function bareBin(token: string): string | null;
 export declare function firstCommandToken(command: string): string;
+export declare function escapeLiteralDollars(command: string): string;
+export declare const SHELL_EXPANSION_ERROR: string;
 export declare function sanitizeCommand(command: string): string | null;

package/dist-lib/lib/tools/exec/scope.js

@@ -50,12 +50,43 @@ function skipDoubleQuoted(chars, open) {
             return 'command must not use backtick substitution';
         }
         if (chars[i] === '$') {
-            return 'command must not use shell expansion';
+            return SHELL_EXPANSION_ERROR;
         }
         i++;
     }
     return i + 1;
 }
+const EXPANDS = /[A-Za-z_{(?#@*!$-]/;
+export function escapeLiteralDollars(command) {
+    const chars = [...command];
+    let out = '';
+    let quoted = false;
+    for (let i = 0; i < chars.length; i++) {
+        const c = chars[i] ?? '';
+        if (c === "'" && !quoted) {
+            const end = chars.indexOf("'", i + 1);
+            const stop = end === -1 ? chars.length : end + 1;
+            out += chars.slice(i, stop).join('');
+            i = stop - 1;
+            continue;
+        }
+        if (c === '\\') {
+            out += c + (chars[i + 1] ?? '');
+            i++;
+            continue;
+        }
+        if (c === '"') {
+            quoted = !quoted;
+        }
+        if (c === '$' && !EXPANDS.test(chars[i + 1] ?? '')) {
+            out += '\\';
+        }
+        out += c;
+    }
+    return out;
+}
+export const SHELL_EXPANSION_ERROR = 'command must not use shell expansion: $ outside single quotes is expanded by the shell. ' +
+    "Put text containing $ (prices, amounts) in single quotes, e.g. content='Total: $1,348'";
 export function sanitizeCommand(command) {
     const chars = [...command];
     let i = 0;
@@ -98,7 +129,7 @@ export function sanitizeCommand(command) {
             return 'command must not use backtick substitution';
         }
         if (c === '$') {
-            return 'command must not use shell expansion';
+            return SHELL_EXPANSION_ERROR;
         }
         if (c === ';') {
             return 'command must not chain with ;';

package/dist-lib/lib/tools/pdf/build.d.ts

@@ -0,0 +1,43 @@
+import type { PdfRequest } from './request.ts';
+export type Pdfium = typeof import('bare-pdfium');
+export type Doc = ReturnType<Pdfium['open']>;
+type Field = ReturnType<Doc['fields']>[number];
+export interface Source {
+    readonly attachmentId: string;
+    readonly fileName: string;
+    readonly bytes: Uint8Array;
+}
+export interface Opened {
+    readonly source: Source;
+    readonly doc: Doc;
+}
+export interface Built {
+    readonly bytes: Uint8Array;
+    readonly pageCount: number;
+}
+export interface ReadField {
+    readonly name: string;
+    readonly type: string;
+    readonly value: Field['value'];
+    readonly options: readonly string[] | undefined;
+    readonly readOnly: true | undefined;
+}
+export interface ReadDocument {
+    readonly attachmentId: string;
+    readonly fileName: string;
+    readonly pageCount: number;
+    readonly pages: readonly {
+        page: number;
+        text: string;
+    }[];
+    readonly fields: readonly ReadField[];
+    readonly note: string | undefined;
+    readonly truncated: true | undefined;
+}
+export interface ReadDocuments {
+    readonly documents: readonly ReadDocument[];
+}
+export declare function pagesLabel(count: number): string;
+export declare function readDocs(opened: readonly Opened[]): ReadDocument | ReadDocuments;
+export declare function build(pdfium: Pdfium, request: PdfRequest, opened: readonly Opened[]): Built | string;
+export {};

package/dist-lib/lib/tools/pdf/build.js

@@ -0,0 +1,150 @@
+import b4a from 'b4a';
+const READ_TEXT_LIMIT = 30_000;
+function plural(count, noun) {
+    return `${count} ${noun}${count === 1 ? '' : 's'}`;
+}
+export function pagesLabel(count) {
+    return plural(count, 'page');
+}
+function zeroBased(opened, pages) {
+    if (!pages) {
+        return Array.from({ length: opened.doc.pageCount() }, (_, page) => page);
+    }
+    const count = opened.doc.pageCount();
+    const outside = pages.filter((page) => page < 1 || page > count);
+    if (outside.length) {
+        return `${opened.source.fileName} has ${pagesLabel(count)}, numbered 1 to ${count}; there is no page ${outside.join(', ')}`;
+    }
+    return pages.map((page) => page - 1);
+}
+function describeField(field) {
+    return {
+        name: field.name,
+        type: field.type,
+        value: field.value,
+        options: field.options,
+        readOnly: field.readOnly || undefined
+    };
+}
+function scannedNote(scanned) {
+    if (!scanned.length)
+        return undefined;
+    const one = scanned.length === 1;
+    return `${one ? 'page' : 'pages'} ${scanned.join(', ')} ${one ? 'has' : 'have'} no text layer: ${one ? 'it is a scanned image' : 'they are scanned images'}, and there is no OCR here`;
+}
+function readOne({ source, doc }, budget) {
+    const pages = [];
+    const scanned = [];
+    let truncated = false;
+    for (const { page, text } of doc.textPages()) {
+        const clean = text.replace(/\r\n?/g, '\n').trim();
+        if (!clean) {
+            scanned.push(page + 1);
+        }
+        const kept = clean.slice(0, Math.max(0, budget.chars));
+        budget.chars -= kept.length;
+        truncated ||= kept.length < clean.length;
+        if (budget.chars > 0 || kept) {
+            pages.push({ page: page + 1, text: kept });
+        }
+    }
+    return {
+        attachmentId: source.attachmentId,
+        fileName: source.fileName,
+        pageCount: doc.pageCount(),
+        pages,
+        fields: doc.fields().map(describeField),
+        note: scannedNote(scanned),
+        truncated: truncated || undefined
+    };
+}
+export function readDocs(opened) {
+    const budget = { chars: READ_TEXT_LIMIT };
+    const documents = opened.map((one) => readOne(one, budget));
+    const [only] = documents;
+    return documents.length === 1 && only ? only : { documents };
+}
+function fromDoc(doc, bytes) {
+    return { bytes, pageCount: doc.pageCount() };
+}
+function joinPages(pdfium, parts, pages) {
+    const out = pdfium.create();
+    try {
+        for (const part of parts) {
+            out.importPages(part.doc, { pages });
+        }
+        return fromDoc(out, out.save());
+    }
+    finally {
+        out.close();
+    }
+}
+function textFile({ source, doc }) {
+    const text = [...doc.textPages()]
+        .map((page) => page.text.replace(/\r\n?/g, '\n').trim())
+        .join('\n\n');
+    if (!text.trim()) {
+        return `${source.fileName} has no text layer: its pages are scanned images, and there is no OCR here`;
+    }
+    return { bytes: b4a.from(text + '\n', 'utf8'), pageCount: doc.pageCount() };
+}
+function create(pdfium, request) {
+    const encrypt = request.password ? { password: request.password } : undefined;
+    const bytes = pdfium.compose(request.markdown, {
+        pageSize: request.pageSize,
+        landscape: request.landscape,
+        pageNumbers: request.pageNumbers,
+        encrypt
+    });
+    return { bytes, pageCount: pdfium.pageCount(bytes, { password: request.password }) };
+}
+function editOne(opened, request) {
+    const { doc } = opened;
+    switch (request.action) {
+        case 'rotate':
+        case 'watermark': {
+            const pages = zeroBased(opened, request.pages);
+            if (typeof pages === 'string') {
+                return pages;
+            }
+            if (request.action === 'rotate') {
+                doc.rotate(request.degrees, { pages });
+            }
+            else {
+                doc.watermark(request.text, { pages, opacity: request.opacity, position: request.position });
+            }
+            return fromDoc(doc, doc.save());
+        }
+        case 'fill':
+            doc.fillFields(request.values);
+            return fromDoc(doc, doc.save());
+        case 'encrypt': {
+            const password = request.password ?? '';
+            const { ownerPassword, permissions } = request;
+            return fromDoc(doc, doc.save({ encrypt: { password, ownerPassword, permissions } }));
+        }
+        case 'decrypt':
+            return fromDoc(doc, doc.save({ removeSecurity: true }));
+        case 'text':
+            return textFile(opened);
+        default:
+            return `${request.action} is not an edit`;
+    }
+}
+export function build(pdfium, request, opened) {
+    const [first] = opened;
+    if (request.action === 'create') {
+        return create(pdfium, request);
+    }
+    if (!first) {
+        return 'no PDF to work on';
+    }
+    if (request.action === 'merge') {
+        return joinPages(pdfium, opened);
+    }
+    if (request.action !== 'split') {
+        return editOne(first, request);
+    }
+    const pages = zeroBased(first, request.pages);
+    return typeof pages === 'string' ? pages : joinPages(pdfium, [first], pages);
+}

package/dist-lib/lib/tools/pdf/images.d.ts

@@ -0,0 +1,7 @@
+import type { ToolExecuteContext } from '../../capabilities/completion.ts';
+import { type CreateRequest } from './request.ts';
+interface ToolError {
+    readonly error: string;
+}
+export declare function placeImages(request: CreateRequest, ctx: ToolExecuteContext): Promise<CreateRequest | ToolError>;
+export {};