@quillmark/quillify 0.0.0-stage → 0.3.0

package/dist/display-list.js

@@ -0,0 +1,339 @@
+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` and `rect`. A picture that did not load, a background
+ * image, a `rect` 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 `rect` with neither stroke nor fill 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 boxes = [];
+    const pictures = [];
+    const lines = [];
+    const runs = [];
+    // 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 });
+    };
+    for (const el of layer.querySelectorAll('*')) {
+        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;
+            pictures.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') {
+            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;
+                };
+                lines.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 rectangle 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 rectangle 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 rectangle'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 draws a rect square when its rx is below zero.
+                const radius = parseFloat(style.rx);
+                boxes.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] };
+                boxes.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))
+            boxes.push({
+                x: X(rect.x),
+                y: Y(rect.y),
+                w: +rect.width.toFixed(2),
+                h: +rect.height.toFixed(2),
+                fill,
+                edges
+            });
+    }
+    collectText(layer, X, Y, runs, turns);
+    return { boxes, pictures, lines, runs, 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
+ * `drawRuns` 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', 'circle', 'ellipse', '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(layer, X, Y, runs, turns) {
+    const owner = layer.ownerDocument;
+    const view = owner.defaultView;
+    const measure = owner.createElement('canvas').getContext('2d');
+    const walker = owner.createTreeWalker(layer, NodeFilter.SHOW_TEXT);
+    const range = owner.createRange();
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+        const text = node.nodeValue;
+        const parent = node.parentElement;
+        if (!text || !text.trim() || !parent)
+            continue;
+        // A <select> is de-chromed above; only the option the form shows is drawn.
+        if (parent.tagName === 'OPTION' && !parent.selected)
+            continue;
+        const style = view.getComputedStyle(parent);
+        if (style.visibility === 'hidden' || style.display === 'none')
+            continue;
+        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;
+            runs.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 type { Rect } from './types.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { check, suggest } from './naming.js';
+export { quillify } from './quillify.js';
+export { sanitize } from './sanitize.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,175 @@
+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_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 });
+            dims.push({ width: view[2] - view[0], height: view[3] - view[1] });
+            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[];

package/dist/naming.js

@@ -0,0 +1,116 @@
+import { SNAKE_CASE } from './types.js';
+const MAX_LENGTH = 40;
+const snake = (text) => text
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[^A-Za-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase();
+/** The last segment of the LiveCycle id `form1[0].page1[0].Header[0].dateReq[0]` is `dateReq`. */
+const lastSegment = (path) => path.slice(path.lastIndexOf('.') + 1).replace(/\[\d+\]$/, '');
+const squeeze = (text) => text.trim().replace(/\s+/g, ' ');
+const lead = (words) => (/^[a-z]/.test(words) ? words : words ? `field_${words}` : 'field');
+/** The whole words of `words` that fit in `limit`, or nothing when no whole word does. */
+function whole(words, limit) {
+    if (words.length <= limit)
+        return words;
+    const head = words.slice(0, Math.max(0, words.lastIndexOf('_', limit)));
+    return head === 'field' ? '' : head;
+}
+/** `words` cut to `limit`: the whole words that fit, or its first `limit` characters when no whole word does. */
+const fit = (words, limit) => whole(words, limit) || words.slice(0, limit);
+export function suggest(fields) {
+    // Options of one group whose tooltips read alike are told apart by their on-states.
+    const tooltips = fields.map((field) => snake(field.tooltip ?? ''));
+    const keys = fields.map((field, at) => field.kind === 'radio' && tooltips[at] ? `${tooltips[at]}\0${field.group}` : '');
+    const once = new Set();
+    const alike = new Set();
+    for (const key of keys)
+        if (key)
+            (once.has(key) ? alike : once).add(key);
+    const taken = new Set();
+    return fields.map((field, at) => {
+        const radio = field.kind === 'radio' ? field : undefined;
+        const said = radio && alike.has(keys[at]) ? squeeze(radio.on ?? '') : '';
+        const on = snake(said);
+        const head = on && whole(lead(tooltips[at]), MAX_LENGTH - 1 - on.length);
+        const words = on ||
+            tooltips[at] ||
+            snake(radio ? `${lastSegment(radio.group)} ${radio.on ?? ''}` : lastSegment(field.id));
+        const base = head ? `${head}_${on}` : fit(lead(words), MAX_LENGTH);
+        let name = base;
+        for (let n = 2; taken.has(name); n++)
+            name = `${base}_${n}`;
+        taken.add(name);
+        const tooltip = squeeze(field.tooltip ?? '');
+        const description = said ? `${tooltip} (${said})` : tooltip;
+        return { id: field.id, keep: !field.readOnly, name, description };
+    });
+}
+const TEXT = new Set(['line', 'paragraph', 'lines']);
+/**
+ * A naming can be a model's JSON, which TypeScript never saw. A slot of the
+ * wrong type is a mistake in the call and no fault of a name, so it throws: a
+ * pattern reads `null` as the word, and the word is a name.
+ */
+function shaped({ name, description, fields }) {
+    const not = (slot, kind) => {
+        throw new TypeError(`naming.${slot} is not ${kind}.`);
+    };
+    if (typeof name !== 'string')
+        not('name', 'a string');
+    if (typeof description !== 'string')
+        not('description', 'a string');
+    if (!Array.isArray(fields))
+        not('fields', 'an array');
+    fields.forEach((entry, at) => {
+        const slot = `fields[${at}]`;
+        if (typeof entry !== 'object' || entry === null)
+            return not(slot, 'an object');
+        if (typeof entry.id !== 'string')
+            not(`${slot}.id`, 'a string');
+        if (typeof entry.keep !== 'boolean')
+            not(`${slot}.keep`, 'a boolean');
+        if (typeof entry.name !== 'string')
+            not(`${slot}.name`, 'a string');
+        if (typeof entry.description !== 'string')
+            not(`${slot}.description`, 'a string');
+        if (entry.example !== undefined && typeof entry.example !== 'string')
+            not(`${slot}.example`, 'a string');
+        if (entry.text !== undefined && !TEXT.has(entry.text))
+            not(`${slot}.text`, "'line', 'paragraph' or 'lines'");
+    });
+}
+export function check(fields, naming) {
+    shaped(naming);
+    const problems = [];
+    if (!SNAKE_CASE.test(naming.name))
+        problems.push({ code: 'quill_name' });
+    if (/^\p{White_Space}*$/u.test(naming.description))
+        problems.push({ code: 'quill_description' });
+    const ids = new Set(fields.map((field) => field.id));
+    const entries = Map.groupBy(naming.fields, (entry) => entry.id);
+    for (const id of entries.keys())
+        if (!ids.has(id))
+            problems.push({ code: 'unknown_field', id });
+    for (const [id, sharing] of entries)
+        if (sharing.length > 1)
+            problems.push({ code: 'repeated_field', id });
+    for (const id of ids)
+        if (!entries.has(id))
+            problems.push({ code: 'unnamed_field', id });
+    // A read-only field is left out whatever its entry says, so it counts as dropped.
+    const fillable = new Set(fields.filter((field) => !field.readOnly).map((field) => field.id));
+    const kept = naming.fields.filter((entry) => entry.keep && fillable.has(entry.id));
+    if (kept.length === 0)
+        problems.push({ code: 'nothing_kept' });
+    for (const { id, name } of kept)
+        if (!SNAKE_CASE.test(name))
+            problems.push({ code: 'field_name', id });
+    for (const [name, sharing] of Map.groupBy(kept, (entry) => entry.name))
+        if (sharing.length > 1)
+            problems.push({ code: 'duplicate_name', name });
+    for (const { id, kind } of fields)
+        if (kind !== 'text' && entries.get(id)?.some((entry) => entry.text))
+            problems.push({ code: 'text_on_non_text', id });
+    return problems;
+}