@quillmark/quillify 0.0.0-stage → 0.3.1

package/dist/display-list.js

@@ -0,0 +1,372 @@
+import { Refused } from './refusal.js';
+import { square } from './xfa-widgets.js';
+const TRANSPARENT = /rgba\(.*,\s*0\)$/;
+const PAINTED_BORDER = new Set(['solid', 'double', 'groove', 'ridge', 'inset', 'outset']);
+function opaque(colour) {
+    return !!colour && colour !== 'transparent' && !TRANSPARENT.test(colour);
+}
+function rgb(colour) {
+    const m = /rgba?\((\d+),\s*(\d+),\s*(\d+)/.exec(colour);
+    return m ? [+m[1] / 255, +m[2] / 255, +m[3] / 255] : [0, 0, 0];
+}
+/** A stroke the browser does not paint. `stroke-width: 0` computes to `0px`. */
+function stroked(style) {
+    const width = parseFloat(style.strokeWidth);
+    if (!Number.isFinite(width) || width <= 0)
+        return null;
+    if (style.stroke === 'none' || !opaque(style.stroke))
+        return null;
+    return { width, colour: rgb(style.stroke) };
+}
+/**
+ * Turn a laid-out XFA page into primitives in page points. The browser solved
+ * the layout, and the rects here are read off it.
+ *
+ * What it can express is text, CSS backgrounds and borders, pictures, and
+ * inline SVG `line`, `rect`, `ellipse` and `circle`. A picture that did not
+ * load, a background image, a shape filled with a gradient or a pattern,
+ * another SVG shape, a border style it cannot draw and a transform it cannot
+ * carry are refused with the construct named: a background that is silently
+ * incomplete is worse than not taking the form. An element hidden by its own
+ * style, an SVG `line` with no stroke, a shape with neither stroke nor fill
+ * or of no width or height, and an HTML element under 0.3 pt on a side are
+ * passed over.
+ */
+export function displayList(page, pageNumber) {
+    const { layer, origin } = page;
+    const view = layer.ownerDocument.defaultView;
+    const drawn = [];
+    // The quarter turns each element is laid out under, its own and its ancestors'.
+    const turns = new Map([[layer, 0]]);
+    const X = (v) => +(v - origin.left).toFixed(2);
+    const Y = (v) => +(v - origin.top).toFixed(2);
+    const refuse = (construct, detail) => {
+        throw new Refused({ code: 'unpaintable', page: pageNumber - 1, construct, detail });
+    };
+    // CSS paints the boxes of what is in the flow under a positioned element,
+    // then its text, pictures and SVG shapes, then the positioned elements
+    // under it in tree order, each the same way.
+    const order = [];
+    const under = (root) => {
+        const front = [];
+        const positioned = [];
+        const flow = (parent) => {
+            for (const node of parent.childNodes) {
+                if (node.nodeType === Node.TEXT_NODE)
+                    front.push(node);
+                if (node.nodeType !== Node.ELEMENT_NODE)
+                    continue;
+                const el = node;
+                if (view.getComputedStyle(el).position !== 'static')
+                    positioned.push(el);
+                else {
+                    (/^(img|line|rect|ellipse|circle|input)$/i.test(el.tagName) ? front : order).push(el);
+                    flow(el);
+                }
+            }
+        };
+        flow(root);
+        for (const node of front)
+            order.push(node);
+        for (const el of positioned) {
+            order.push(el);
+            under(el);
+        }
+    };
+    under(layer);
+    for (const node of order) {
+        if (node.nodeType === Node.TEXT_NODE) {
+            collectText(node, X, Y, drawn, turns);
+            continue;
+        }
+        const el = node;
+        const tag = el.tagName.toLowerCase();
+        const style = view.getComputedStyle(el);
+        const own = quarterTurns(style.transform);
+        const turn = (turns.get(el.parentElement) + own) % 4;
+        turns.set(el, turn);
+        if (tag === 'svg' || tag === 'option' || tag === 'g' || tag === 'defs')
+            continue;
+        if (style.visibility === 'hidden' || style.display === 'none')
+            continue;
+        if (tag === 'img' || el.classList.contains('xfaImage')) {
+            const image = el;
+            // A picture that did not load has no size.
+            if (!image.naturalWidth || !image.naturalHeight)
+                refuse('image');
+            if (turn || unrepresentable(style.transform))
+                refuse('transform');
+            const rect = image.getBoundingClientRect();
+            if (rect.width < 0.3 || rect.height < 0.3)
+                continue;
+            // pdf.js stretches a picture to its box where the template says so. Any
+            // other the stylesheet fits into the box whole, from the top left.
+            const fit = style.objectFit === 'contain'
+                ? Math.min(rect.width / image.naturalWidth, rect.height / image.naturalHeight)
+                : 0;
+            drawn.push({
+                x: X(rect.x),
+                y: Y(rect.y),
+                w: +(fit ? image.naturalWidth * fit : rect.width).toFixed(2),
+                h: +(fit ? image.naturalHeight * fit : rect.height).toFixed(2),
+                image
+            });
+            continue;
+        }
+        if (tag === 'line' || tag === 'rect' || tag === 'ellipse' || tag === 'circle') {
+            const svg = el.ownerSVGElement;
+            if (!svg)
+                continue;
+            const edge = stroked(style);
+            if (tag === 'line') {
+                if (!edge)
+                    continue;
+                if (turn)
+                    refuse('transform');
+                const svgRect = svg.getBoundingClientRect();
+                // pdf.js writes these as percentages of the svg box ("100%", "50%").
+                const at = (key, span) => {
+                    const raw = el.getAttribute(key) ?? '0';
+                    const value = parseFloat(raw);
+                    if (!Number.isFinite(value))
+                        return 0;
+                    return raw.trim().endsWith('%') ? (span * value) / 100 : value;
+                };
+                drawn.push({
+                    x1: X(svgRect.x + at('x1', svgRect.width)),
+                    y1: Y(svgRect.y + at('y1', svgRect.height)),
+                    x2: X(svgRect.x + at('x2', svgRect.width)),
+                    y2: Y(svgRect.y + at('y2', svgRect.height)),
+                    width: edge.width,
+                    colour: edge.colour
+                });
+            }
+            else {
+                // pdf.js writes every shape a fill, and the browser drops one that is no
+                // color: a gradient or a pattern. What is left computes to black.
+                if (!el.style.fill && !el.hasAttribute('fill'))
+                    refuse('background_image');
+                // A shape whose edge is hidden has a stroke of no width.
+                const fill = style.fill !== 'none' && opaque(style.fill) ? rgb(style.fill) : null;
+                if (!edge && !fill)
+                    continue;
+                // SVG centers a stroke on the shape's edge, and a box's border is
+                // drawn inside it, so the box is half a stroke larger all round. What
+                // that adds to the fill lies under the stroke.
+                const half = (edge?.width ?? 0) / 2;
+                const r = el.getBoundingClientRect();
+                // The browser paints no shape of no width or height, whatever its stroke.
+                if (!r.width || !r.height)
+                    continue;
+                // The browser draws a rect square when its rx is below zero. An ellipse
+                // is a rect whose corners meet.
+                const radius = tag === 'rect' ? parseFloat(style.rx) : Math.max(r.width, r.height) / 2;
+                drawn.push({
+                    x: X(r.x - half),
+                    y: Y(r.y - half),
+                    w: +(r.width + 2 * half).toFixed(2),
+                    h: +(r.height + 2 * half).toFixed(2),
+                    fill,
+                    edges: [edge, edge, edge, edge],
+                    radius: radius > 0 ? radius : undefined
+                });
+            }
+            continue;
+        }
+        if (svgOnly(tag))
+            refuse('svg', tag);
+        const rect = el.getBoundingClientRect();
+        if (rect.width < 0.3 || rect.height < 0.3)
+            continue;
+        // A control's own chrome belongs to the browser, and an AcroForm widget is
+        // stamped where the control was. The printed square a checkmark goes in is
+        // the exception: nothing else draws it. It is drawn where the browser
+        // paints the control, which is where the widget is stamped.
+        const type = el.getAttribute('type')?.toLowerCase();
+        if (tag === 'input' || tag === 'textarea' || tag === 'select') {
+            // A field is stamped upright, so a turned one would fill the wrong way.
+            if (turn)
+                refuse('transform');
+            if (type === 'checkbox' || type === 'radio') {
+                const painted = square(rect);
+                const hair = { width: 1, colour: [0, 0, 0] };
+                drawn.push({
+                    x: X(painted.left),
+                    y: Y(painted.top),
+                    w: +painted.width.toFixed(2),
+                    h: +painted.height.toFixed(2),
+                    fill: null,
+                    edges: [hair, hair, hair, hair]
+                });
+            }
+            continue;
+        }
+        if (style.backgroundImage !== 'none')
+            refuse('background_image');
+        // pdf.js turns an element about its top left corner, which is where a
+        // template turns one it places. One a row or a column flows is left where
+        // it flowed, turned out of its cell.
+        if (own ? style.position !== 'absolute' : unrepresentable(style.transform))
+            refuse('transform');
+        const sides = ['Top', 'Right', 'Bottom', 'Left'];
+        const edges = sides.map((side) => {
+            const width = parseFloat(style.getPropertyValue(`border-${side.toLowerCase()}-width`)) || 0;
+            const kind = style.getPropertyValue(`border-${side.toLowerCase()}-style`);
+            const colour = style.getPropertyValue(`border-${side.toLowerCase()}-color`);
+            if (width <= 0 || kind === 'none' || kind === 'hidden' || !opaque(colour))
+                return null;
+            if (kind === 'dashed')
+                return { width, colour: rgb(colour), dashed: true };
+            if (!PAINTED_BORDER.has(kind))
+                refuse('border', kind);
+            return { width, colour: rgb(colour) };
+        });
+        // A quarter turn counter-clockwise has the element's right edge at the top.
+        for (let quarter = turn; quarter > 0; quarter--)
+            edges.push(edges.shift());
+        const fill = opaque(style.backgroundColor) ? rgb(style.backgroundColor) : null;
+        if (fill || edges.some(Boolean))
+            drawn.push({
+                x: X(rect.x),
+                y: Y(rect.y),
+                w: +rect.width.toFixed(2),
+                h: +rect.height.toFixed(2),
+                fill,
+                edges
+            });
+    }
+    return { drawn, width: page.width, height: page.height };
+}
+/**
+ * How many quarter turns counter-clockwise a transform is, and 0 for any
+ * other. pdf.js writes a template's `rotate="90"` as `rotate(-90deg)`.
+ */
+function quarterTurns(transform) {
+    return ([
+        'matrix(0, -1, 1, 0, 0, 0)',
+        'matrix(-1, 0, 0, -1, 0, 0)',
+        'matrix(0, 1, -1, 0, 0, 0)'
+    ].indexOf(transform) + 1);
+}
+/**
+ * True for a transform a run's box cannot carry. XFA offsets caption
+ * wrappers with a translation, which the rects already hold. A positive
+ * horizontal scale is carried too: `getClientRects` reports the scaled width and
+ * `drawRun` puts it back as `Tz`, which is how LiveCycle's
+ * `xfa-font-horizontal-scale` reaches the page. A rotation, a skew, a mirror or
+ * a vertical scale changes glyph shape or height, and a run carries neither. A
+ * quarter turn is read apart, by `quarterTurns`.
+ */
+export function unrepresentable(transform) {
+    if (transform === 'none')
+        return false;
+    const parts = /^matrix\(([^)]*)\)$/.exec(transform)?.[1].split(',').map(Number);
+    if (!parts || parts.length !== 6)
+        return true;
+    const [a, b, c, d] = parts;
+    return b !== 0 || c !== 0 || d !== 1 || a <= 0;
+}
+/** SVG shapes pdf.js can emit that the primitives above have no form for. */
+function svgOnly(tag) {
+    return ['path', 'polygon', 'polyline', 'image', 'use', 'text'].includes(tag);
+}
+/**
+ * One run per visual line, with the box the browser measured it into. Splitting
+ * where the rect top changes is what keeps a wrapped paragraph's second line at
+ * its own baseline. A tab ends a run too and is in none: the text after it
+ * starts a run at the box the layout moved it to.
+ */
+function collectText(node, X, Y, drawn, turns) {
+    const text = node.nodeValue;
+    const parent = node.parentElement;
+    if (!text || !text.trim() || !parent)
+        return;
+    // A <select> is de-chromed above; only the option the form shows is drawn.
+    if (parent.tagName === 'OPTION' && !parent.selected)
+        return;
+    const owner = node.ownerDocument;
+    const style = owner.defaultView.getComputedStyle(parent);
+    if (style.visibility === 'hidden' || style.display === 'none')
+        return;
+    const measure = owner.createElement('canvas').getContext('2d');
+    const range = owner.createRange();
+    const size = parseFloat(style.fontSize);
+    measure.font = `${style.fontStyle} ${style.fontWeight} ${size}px ${style.fontFamily}`;
+    const descent = measure.measureText('Hg').fontBoundingBoxDescent ?? size * 0.21;
+    const common = {
+        size: +size.toFixed(2),
+        family: style.fontFamily,
+        bold: parseInt(style.fontWeight, 10) >= 600 || style.fontWeight === 'bold',
+        italic: style.fontStyle === 'italic' || style.fontStyle === 'oblique',
+        colour: rgb(style.color),
+        letterSpacing: parseFloat(style.letterSpacing) || 0
+    };
+    // Under a turn each rect is read in the frame the text is upright in, and
+    // the start of each line's baseline is turned back to the page.
+    const turn = turns.get(parent);
+    const [cos, sin] = [
+        [1, 0],
+        [0, -1],
+        [-1, 0],
+        [0, 1]
+    ][turn];
+    const upright = ({ left, right, top, bottom }) => {
+        const [x1, x2] = [cos * left + sin * top, cos * right + sin * bottom];
+        const [y1, y2] = [cos * top - sin * left, cos * bottom - sin * right];
+        return {
+            x: Math.min(x1, x2),
+            right: Math.max(x1, x2),
+            top: Math.min(y1, y2),
+            bottom: Math.max(y1, y2)
+        };
+    };
+    let start = 0;
+    let top = null;
+    let box = null;
+    const flush = (end) => {
+        const slice = text.slice(start, end);
+        if (end <= start || !box || !slice.trim())
+            return;
+        const base = box.bottom - descent;
+        drawn.push({
+            text: slice,
+            x: X(cos * box.x - sin * base),
+            baseline: Y(sin * box.x + cos * base),
+            width: +(box.right - box.x).toFixed(2),
+            turn: turn || undefined,
+            ...common
+        });
+    };
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '\t') {
+            flush(i);
+            start = i + 1;
+            top = null;
+            box = null;
+            continue;
+        }
+        range.setStart(node, i);
+        range.setEnd(node, i + 1);
+        const rect = range.getClientRects()[0];
+        if (!rect)
+            continue;
+        const glyph = upright(rect);
+        if (top === null || Math.abs(glyph.top - top) < 0.6) {
+            top ??= glyph.top;
+            box = box
+                ? {
+                    x: Math.min(box.x, glyph.x),
+                    bottom: Math.max(box.bottom, glyph.bottom),
+                    right: Math.max(box.right, glyph.right)
+                }
+                : { x: glyph.x, bottom: glyph.bottom, right: glyph.right };
+        }
+        else {
+            flush(i);
+            start = i;
+            top = glyph.top;
+            box = { x: glyph.x, bottom: glyph.bottom, right: glyph.right };
+        }
+    }
+    flush(text.length);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { check, suggest } from './naming.js';
+export { quillify, type Quillified } from './quillify.js';
+export { sanitize, type Sanitized } from './sanitize.js';
+export type { Field, FieldNaming, Form, Naming, Place, Problem, Size } from './api.js';
+export type { Refusal } from './refusal.js';
+export { limits, type Rect } from './types.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { check, suggest } from './naming.js';
+export { quillify } from './quillify.js';
+export { sanitize } from './sanitize.js';
+export { limits } from './types.js';

package/dist/inventory.d.ts

@@ -0,0 +1,4 @@
+import type { FieldInventory, View } from './types.js';
+export declare function inventoryPdf(bytes: Uint8Array, signal?: AbortSignal): Promise<FieldInventory & {
+    views: View[];
+}>;

package/dist/inventory.js

@@ -0,0 +1,179 @@
+import { PDFArray, PDFDict, PDFDocument, PDFHexString, PDFName, PDFString, pdfDocEncodingDecode } from 'pdf-lib';
+import { toTopLeftRect } from './coords.js';
+import { openPdf } from './pdfjs.js';
+import { Refused } from './refusal.js';
+import { MAX_PAGES, MAX_SIDE, MAX_WIDGETS, WIDGET_KINDS } from './types.js';
+/** pdf.js passes on whatever name a file gives `/FT`. */
+const isWidgetKind = (type) => WIDGET_KINDS.includes(type);
+export async function inventoryPdf(bytes, signal) {
+    const { pdf, close, within } = await openPdf(bytes, {}, signal);
+    try {
+        // XFA alone is not a refusal. A hybrid form carries its XFA template beside a
+        // complete AcroForm field tree, and pdf.js never XFA-renders one of those, so
+        // the widgets below are the real ones. A dynamic form has no field tree, and
+        // `xfaToAcroForm` has given it one by the time anything reaches here. What is
+        // left is a file that is neither, which has no field to read.
+        const { info } = (await within(pdf.getMetadata()));
+        const xfa = pdf.isPureXfa || !!info.IsXFAPresent;
+        // A catalog that declares a collection is a portfolio: its pages are a cover
+        // sheet, and the form is an attachment. AF 3070A is one, around a file named
+        // `MicrosoftIRMServices Protected PDF.pdf`. Counting the cover sheet's
+        // widgets would answer the wrong question.
+        if (info.IsCollectionPresent) {
+            const [attachment] = (await within(pdf.getAttachments()))?.keys() ?? [];
+            throw new Refused({ code: 'portfolio', attachment });
+        }
+        if (pdf.numPages > MAX_PAGES)
+            throw new Refused({ code: 'too_many_pages', pages: pdf.numPages, limit: MAX_PAGES });
+        const inherited = await tooltipsByField(bytes);
+        // The value of a checkbox field is the on-state of its ticked box, so boxes
+        // of one name that turn on as different values exclude each other. WH-380-E
+        // asks whether a job description `is` or `is not attached` that way. Each
+        // name's on-states are read ahead of the entries, since the first box of a
+        // name does not show what the next turns on as.
+        const states = new Map();
+        for (let index = 0; index < pdf.numPages; index++) {
+            const page = await within(pdf.getPage(index + 1));
+            for (const a of (await within(page.getAnnotations())))
+                if (a.checkBox && a.fieldName && !a.hidden)
+                    states.set(a.fieldName, (states.get(a.fieldName) ?? new Set()).add(a.exportValue));
+        }
+        const widgets = [];
+        const dims = [];
+        const views = [];
+        const seen = new Map();
+        const byName = new Map();
+        for (let index = 0; index < pdf.numPages; index++) {
+            const page = await within(pdf.getPage(index + 1));
+            if (page.rotate % 360 !== 0)
+                throw new Refused({ code: 'rotated', page: index });
+            const view = page.view;
+            views.push({ ref: page.ref, box: view });
+            const size = { width: view[2] - view[0], height: view[3] - view[1] };
+            if (page.userUnit !== 1 ||
+                Math.max(size.width, size.height, ...view.map(Math.abs)) > MAX_SIDE)
+                throw new Refused({ code: 'damaged' });
+            dims.push(size);
+            const annotations = (await within(page.getAnnotations()));
+            for (const a of annotations) {
+                // A push button runs an action; it holds no value, so it is no field.
+                if (a.subtype !== 'Widget' || a.hidden || !isWidgetKind(a.fieldType) || a.pushButton)
+                    continue;
+                const name = a.fieldName ?? '';
+                const place = { page: index, rect: toTopLeftRect(a.rect, view, page.rotate) };
+                // One name is one value in the file: typing into any widget that
+                // carries it fills every other. SF 1152 ships an original and a file
+                // copy sharing one field tree, so half its 60 field widgets are the
+                // other half painted again. A radio option is the exception, since
+                // its on-state is the whole point of being separate, and so is a
+                // checkbox whose name turns on as more than one value.
+                const option = !!a.checkBox && (states.get(name)?.size ?? 0) > 1;
+                const shared = a.radioButton || option || !name ? undefined : byName.get(name);
+                if (shared) {
+                    shared.places.push(place);
+                    continue;
+                }
+                const count = (seen.get(name) ?? 0) + 1;
+                seen.set(name, count);
+                const widget = {
+                    id: count === 1 ? name : `${name}#${count}`,
+                    name,
+                    kind: a.fieldType,
+                    places: [place],
+                    multiLine: a.multiLine ?? false,
+                    checkBox: !option && (a.checkBox ?? false),
+                    radioButton: option || (a.radioButton ?? false),
+                    combo: a.combo ?? false,
+                    options: (a.options ?? [])
+                        .map((o) => o.exportValue)
+                        .filter((value) => typeof value === 'string'),
+                    readOnly: a.readOnly ?? false,
+                    required: a.required ?? false,
+                    tooltip: a.alternativeText || inherited.get(name) || undefined,
+                    maxLen: a.maxLen ?? 0,
+                    buttonValue: (option ? a.exportValue : a.buttonValue) ?? undefined
+                };
+                widgets.push(widget);
+                if (!a.radioButton && !option && name)
+                    byName.set(name, widget);
+            }
+        }
+        // The cap reads a complete count. Inside the page loop it would name a
+        // running partial.
+        if (widgets.length > MAX_WIDGETS)
+            throw new Refused({ code: 'too_many_fields', fields: widgets.length, limit: MAX_WIDGETS });
+        if (widgets.length === 0)
+            throw new Refused({ code: 'no_fields', xfa });
+        return { pages: dims, widgets, views };
+    }
+    finally {
+        await close();
+    }
+}
+/**
+ * Every field's `/TU` by its fully qualified name.
+ *
+ * Acrobat writes `/T` and `/TU` on the field and puts bare widget annotations in
+ * `/Kids`. pdf.js walks `/Parent` for `/T` and inherits `/FT`, but reads `/TU`
+ * straight off the annotation, so every kid of a split field arrives unlabeled:
+ * 16 of EOIR-28's 53 widgets, 32 of VA 26-1880's 81, 60 of SF 1152's 63. A
+ * widget's tooltip is its field's tooltip, which is the same parent walk pdf.js
+ * already does for the name.
+ *
+ * The walk goes down `/Fields` through `/Kids` and joins the `/T` of each node
+ * that has one with a period, as pdf.js builds a field's name. A `/T` the two
+ * libraries decode apart finds no widget. It reads the objects themselves,
+ * since pdf-lib's form API throws on a tree it cannot type. Whatever is not
+ * the type the walk wants is passed over, and a node is read once, so a tree
+ * that loops ends.
+ *
+ * pdf-lib carries no decryption, so this only reads what `normalizePdf` has
+ * already decrypted.
+ */
+async function tooltipsByField(bytes) {
+    const found = new Map();
+    const doc = await PDFDocument.load(bytes, { updateMetadata: false });
+    const acroForm = doc.catalog.lookup(PDFName.of('AcroForm'));
+    const seen = new Set();
+    // Each list of nodes with the name of the field that holds it. An entry of
+    // `/Fields` is a field. A kid with no `/T` is a widget of the field above it.
+    const lists = [
+        [acroForm instanceof PDFDict ? acroForm.lookup(PDFName.of('Fields')) : undefined, undefined]
+    ];
+    for (let next = 0; next < lists.length; next++) {
+        const [nodes, above] = lists[next];
+        if (!(nodes instanceof PDFArray))
+            continue;
+        for (let index = 0; index < nodes.size(); index++) {
+            const node = nodes.lookup(index);
+            if (!(node instanceof PDFDict) || seen.has(node))
+                continue;
+            seen.add(node);
+            const part = text(node.lookup(PDFName.of('T')));
+            const name = part === undefined ? above : above === undefined ? part : `${above}.${part}`;
+            const tip = text(node.lookup(PDFName.of('TU')));
+            if (tip !== undefined && (part !== undefined || next === 0))
+                found.set(name ?? '', tip);
+            lists.push([node.lookup(PDFName.of('Kids')), name]);
+        }
+    }
+    return found;
+}
+/**
+ * A text string as pdf-lib's `decodeText` reads it: UTF-16 after a byte order
+ * mark, PDFDocEncoding without one. `decodeText` hands every character to one
+ * call, which overflows the stack near 130,000 of them.
+ */
+function text(value) {
+    if (!(value instanceof PDFString || value instanceof PDFHexString))
+        return undefined;
+    const bytes = value.asBytes();
+    if (bytes[0] === 0xfe && bytes[1] === 0xff)
+        return new TextDecoder('utf-16be').decode(bytes);
+    if (bytes[0] === 0xff && bytes[1] === 0xfe)
+        return new TextDecoder('utf-16le').decode(bytes);
+    let decoded = '';
+    for (let at = 0; at < bytes.length; at += 8192)
+        decoded += pdfDocEncodingDecode(bytes.subarray(at, at + 8192));
+    return decoded;
+}

package/dist/naming.d.ts

@@ -0,0 +1,3 @@
+import type { Field, FieldNaming, Naming, Problem } from './api.js';
+export declare function suggest(fields: readonly Field[]): FieldNaming[];
+export declare function check(fields: readonly Field[], naming: Naming): Problem[];