@kensio/colophon 2.11.1 → 2.13.0

package/dist/text/fill.js

@@ -0,0 +1,57 @@
+import { nextSize } from "./step.js";
+import { largestUnbroken } from "./unbroken.js";
+import { wrapText } from "./wrap.js";
+/**
+ * How many whole lines fit in the box at a given size, and never fewer than one.
+ *
+ * A box too short for a single line gets that line anyway, running over rather
+ * than being left empty. That is the rule `distribute` follows for a group that
+ * overflows: a template which has asked for the impossible wants to see it.
+ */
+function linesInBox(maxHeight, advance) {
+    return Math.max(1, Math.floor(maxHeight / advance));
+}
+/**
+ * The size the search starts from, which is the largest one worth trying: no
+ * taller than a single line of the box, no larger than the caller's ceiling,
+ * and small enough that no word has to be broken to fit the width.
+ */
+function startingSize(text, measure, options) {
+    const ceiling = Math.min(options.maxFontSize, Math.floor(options.maxHeight / options.lineHeight));
+    return Math.max(options.minFontSize, largestUnbroken(text, measure, options.maxWidth, ceiling));
+}
+/**
+ * Wrap text into a box, at the largest size the whole of it fits at.
+ *
+ * This is {@link fitText} with the question turned round. `fitText` is given a
+ * size and shrinks only when the words need more lines than the layout allows,
+ * so a short title is drawn at whatever size the template named and no larger.
+ * That is right where the text sits in a group with other things, since a
+ * heading that grew to fill the space would stop looking like a heading.
+ *
+ * It is wrong where the text is the picture. A YouTube thumbnail is looked at
+ * in a fraction of the space it was rendered at, so its words have to take the
+ * room they are given rather than sit in the middle of it, and how much room
+ * that is depends on how many words there are: three of them should be drawn
+ * much larger than twelve. So the search comes down from the largest size the
+ * box could hold until the wrapped block fits both the width and the height.
+ *
+ * Text that will not fit even at the floor is cut to the lines there is room
+ * for, which is what `fitText` does at its own floor and for the same reason:
+ * below a certain size the image has stopped saying anything anybody can read.
+ */
+export function fillText(text, measure, options) {
+    const { maxWidth, maxHeight, lineHeight, minFontSize } = options;
+    let fontSize = startingSize(text, measure, options);
+    let lines = wrapText(text, maxWidth, (line) => measure(line, fontSize));
+    while (lines.length * fontSize * lineHeight > maxHeight &&
+        fontSize > minFontSize) {
+        fontSize = nextSize(fontSize, minFontSize);
+        lines = wrapText(text, maxWidth, (line) => measure(line, fontSize));
+    }
+    return {
+        lines: lines.slice(0, linesInBox(maxHeight, fontSize * lineHeight)),
+        fontSize,
+    };
+}
+//# sourceMappingURL=fill.js.map

package/dist/text/fill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill.js","sourceRoot":"","sources":["../../src/text/fill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAcrC;;;;;;GAMG;AACH,SAAS,UAAU,CAAC,SAAiB,EAAE,OAAe;IACpD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,OAAO,CAAC,CAAC,CAAC;AACtD,CAAC;AAED;;;;GAIG;AACH,SAAS,YAAY,CACnB,IAAY,EACZ,OAAkB,EAClB,OAAoB;IAEpB,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CACtB,OAAO,CAAC,WAAW,EACnB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CACnD,CAAC;IAEF,OAAO,IAAI,CAAC,GAAG,CACb,OAAO,CAAC,WAAW,EACnB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAC1D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,QAAQ,CACtB,IAAY,EACZ,OAAkB,EAClB,OAAoB;IAEpB,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;IACjE,IAAI,QAAQ,GAAG,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACpD,IAAI,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IAExE,OACE,KAAK,CAAC,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS;QAChD,QAAQ,GAAG,WAAW,EACtB,CAAC;QACD,QAAQ,GAAG,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAC3C,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IACtE,CAAC;IAED,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,SAAS,EAAE,QAAQ,GAAG,UAAU,CAAC,CAAC;QACnE,QAAQ;KACT,CAAC;AACJ,CAAC"}

package/dist/text/fit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fit.d.ts","sourceRoot":"","sources":["../../src/text/fit.ts"],"names":[],"mappings":"AAEA,uEAAuE;AACvE,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;AAEnE,uEAAuE;AACvE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAKD;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,UAAU,GAClB,UAAU,CAiBZ"}
+{"version":3,"file":"fit.d.ts","sourceRoot":"","sources":["../../src/text/fit.ts"],"names":[],"mappings":"AAGA,uEAAuE;AACvE,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;AAEnE,uEAAuE;AACvE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,UAAU,GAClB,UAAU,CAWZ"}

package/dist/text/fit.js

@@ -1,6 +1,5 @@
+import { nextSize } from "./step.js";
 import { wrapText } from "./wrap.js";
-/** How much of the size is given up each time the text does not fit. */
-const shrinkStep = 0.94;
 /**
  * Wrap text into the space it has, shrinking it until it fits.
  *
@@ -18,10 +17,7 @@ export function fitText(text, measure, options) {
     let fontSize = options.fontSize;
     let lines = wrapText(text, maxWidth, (line) => measure(line, fontSize));
     while (lines.length > maxLines && fontSize > minFontSize) {
-        // Both terms are here to guarantee progress: the proportional step is what
-        // makes the search short, and the whole pixel is what stops it stalling
-        // once the sizes are small enough for rounding to swallow the step.
-        fontSize = Math.max(minFontSize, Math.min(fontSize - 1, Math.floor(fontSize * shrinkStep)));
+        fontSize = nextSize(fontSize, minFontSize);
         lines = wrapText(text, maxWidth, (line) => measure(line, fontSize));
     }
     return { lines: lines.slice(0, maxLines), fontSize };

package/dist/text/fit.js.map

@@ -1 +1 @@
-{"version":3,"file":"fit.js","sourceRoot":"","sources":["../../src/text/fit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAqBrC,wEAAwE;AACxE,MAAM,UAAU,GAAG,IAAI,CAAC;AAExB;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,OAAO,CACrB,IAAY,EACZ,OAAkB,EAClB,OAAmB;IAEnB,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;IACpD,IAAI,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAChC,IAAI,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IAExE,OAAO,KAAK,CAAC,MAAM,GAAG,QAAQ,IAAI,QAAQ,GAAG,WAAW,EAAE,CAAC;QACzD,2EAA2E;QAC3E,wEAAwE;QACxE,oEAAoE;QACpE,QAAQ,GAAG,IAAI,CAAC,GAAG,CACjB,WAAW,EACX,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,CAC1D,CAAC;QACF,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC;AACvD,CAAC"}
+{"version":3,"file":"fit.js","sourceRoot":"","sources":["../../src/text/fit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAqBrC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,OAAO,CACrB,IAAY,EACZ,OAAkB,EAClB,OAAmB;IAEnB,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;IACpD,IAAI,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAChC,IAAI,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IAExE,OAAO,KAAK,CAAC,MAAM,GAAG,QAAQ,IAAI,QAAQ,GAAG,WAAW,EAAE,CAAC;QACzD,QAAQ,GAAG,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAC3C,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC;AACvD,CAAC"}

package/dist/text/index.d.ts

@@ -4,6 +4,8 @@ export type { TextAttributes } from "./element.js";
 export { breakWord } from "./break.js";
 export { clampLine } from "./clamp.js";
 export { ellipsis } from "./ellipsis.js";
+export { fillText } from "./fill.js";
+export type { FillOptions } from "./fill.js";
 export { fitText } from "./fit.js";
 export type { FitOptions, FittedText, MeasureAt } from "./fit.js";
 export { wrapText } from "./wrap.js";

package/dist/text/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/text/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/text/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC"}

package/dist/text/index.js

@@ -3,6 +3,7 @@ export { textElement } from "./element.js";
 export { breakWord } from "./break.js";
 export { clampLine } from "./clamp.js";
 export { ellipsis } from "./ellipsis.js";
+export { fillText } from "./fill.js";
 export { fitText } from "./fit.js";
 export { wrapText } from "./wrap.js";
 //# sourceMappingURL=index.js.map

package/dist/text/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/text/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/text/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC"}

package/dist/text/step.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The next size down to try, for a search that is shrinking text into a space.
+ *
+ * Both terms are here to guarantee progress: the proportional step is what
+ * makes the search short, and the whole pixel is what stops it stalling once
+ * the sizes are small enough for rounding to swallow the step.
+ *
+ * It is shared by the two searches rather than written out in each, since a
+ * step that differed between them would mean two layouts settling on different
+ * sizes for the same words with no reason a reader could name.
+ */
+export declare function nextSize(fontSize: number, minFontSize: number): number;
+//# sourceMappingURL=step.d.ts.map

package/dist/text/step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/text/step.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKtE"}

package/dist/text/step.js

@@ -0,0 +1,17 @@
+/** How much of the size is given up each time the text does not fit. */
+const shrinkRatio = 0.94;
+/**
+ * The next size down to try, for a search that is shrinking text into a space.
+ *
+ * Both terms are here to guarantee progress: the proportional step is what
+ * makes the search short, and the whole pixel is what stops it stalling once
+ * the sizes are small enough for rounding to swallow the step.
+ *
+ * It is shared by the two searches rather than written out in each, since a
+ * step that differed between them would mean two layouts settling on different
+ * sizes for the same words with no reason a reader could name.
+ */
+export function nextSize(fontSize, minFontSize) {
+    return Math.max(minFontSize, Math.min(fontSize - 1, Math.floor(fontSize * shrinkRatio)));
+}
+//# sourceMappingURL=step.js.map

package/dist/text/step.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.js","sourceRoot":"","sources":["../../src/text/step.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,MAAM,WAAW,GAAG,IAAI,CAAC;AAEzB;;;;;;;;;;GAUG;AACH,MAAM,UAAU,QAAQ,CAAC,QAAgB,EAAE,WAAmB;IAC5D,OAAO,IAAI,CAAC,GAAG,CACb,WAAW,EACX,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAC,CAC3D,CAAC;AACJ,CAAC"}

package/dist/text/unbroken.d.ts

@@ -0,0 +1,22 @@
+import type { MeasureAt } from "./fit.js";
+/**
+ * The largest size, no more than `ceiling`, at which every word fits on a line
+ * of its own.
+ *
+ * Text that is being grown to fill a box is the one case where wrapping is
+ * under pressure to break a word in half. `wrapText` breaks a word too wide for
+ * its line, which is the right answer when the size is settled and the
+ * alternative is a line running off the image, and the wrong one here: two
+ * lines of a broken word are shorter than one whole one, so a search measuring
+ * only the height it filled would happily settle on `Frontmatte` above `r`.
+ *
+ * So the search starts below the size where any breaking happens. A word that
+ * cannot fit even at the floor is broken as it always was, since by then there
+ * is nothing else to be done with it.
+ *
+ * Measuring at the ceiling and scaling is exact rather than a guess: widths are
+ * held per em and multiplied by the size, and the estimate used for a font the
+ * build cannot read is linear in the size too.
+ */
+export declare function largestUnbroken(text: string, measure: MeasureAt, maxWidth: number, ceiling: number): number;
+//# sourceMappingURL=unbroken.d.ts.map

package/dist/text/unbroken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbroken.d.ts","sourceRoot":"","sources":["../../src/text/unbroken.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,EAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,MAAM,CAUR"}

package/dist/text/unbroken.js

@@ -0,0 +1,29 @@
+/**
+ * The largest size, no more than `ceiling`, at which every word fits on a line
+ * of its own.
+ *
+ * Text that is being grown to fill a box is the one case where wrapping is
+ * under pressure to break a word in half. `wrapText` breaks a word too wide for
+ * its line, which is the right answer when the size is settled and the
+ * alternative is a line running off the image, and the wrong one here: two
+ * lines of a broken word are shorter than one whole one, so a search measuring
+ * only the height it filled would happily settle on `Frontmatte` above `r`.
+ *
+ * So the search starts below the size where any breaking happens. A word that
+ * cannot fit even at the floor is broken as it always was, since by then there
+ * is nothing else to be done with it.
+ *
+ * Measuring at the ceiling and scaling is exact rather than a guess: widths are
+ * held per em and multiplied by the size, and the estimate used for a font the
+ * build cannot read is linear in the size too.
+ */
+export function largestUnbroken(text, measure, maxWidth, ceiling) {
+    const words = text.split(/\s+/).filter((word) => word !== "");
+    return words.reduce((size, word) => {
+        const width = measure(word, ceiling);
+        return width <= maxWidth
+            ? size
+            : Math.min(size, Math.floor((ceiling * maxWidth) / width));
+    }, ceiling);
+}
+//# sourceMappingURL=unbroken.js.map

package/dist/text/unbroken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbroken.js","sourceRoot":"","sources":["../../src/text/unbroken.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,eAAe,CAC7B,IAAY,EACZ,OAAkB,EAClB,QAAgB,EAChB,OAAe;IAEf,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC;IAE9D,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;QACjC,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAErC,OAAO,KAAK,IAAI,QAAQ;YACtB,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,QAAQ,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAC/D,CAAC,EAAE,OAAO,CAAC,CAAC;AACd,CAAC"}

package/dist/texture/chevrons.d.ts

@@ -0,0 +1,13 @@
+import type { Dimensions, Texture } from "../types.js";
+/**
+ * Rows of chevrons: one V to a tile, meeting its neighbours at the tile edge.
+ *
+ * The V spans the whole width and stops short of the top and bottom, so the
+ * rows have air between them. Its ends sit at the same height on both edges,
+ * which is what makes one tile's chevron continue into the next rather than
+ * ending in a corner.
+ */
+export declare function chevronsSvg(texture: Extract<Texture, {
+    readonly type: "chevrons";
+}>, dimensions: Dimensions, id: string): string;
+//# sourceMappingURL=chevrons.d.ts.map

package/dist/texture/chevrons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chevrons.d.ts","sourceRoot":"","sources":["../../src/texture/chevrons.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAMvD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,EACxD,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,GACT,MAAM,CAkBR"}

package/dist/texture/chevrons.js

@@ -0,0 +1,22 @@
+import { fallbackColor } from "./color.js";
+import { tile } from "./tile.js";
+const chevronDefaults = { opacity: 0.07, width: 2, gap: 36 };
+/**
+ * Rows of chevrons: one V to a tile, meeting its neighbours at the tile edge.
+ *
+ * The V spans the whole width and stops short of the top and bottom, so the
+ * rows have air between them. Its ends sit at the same height on both edges,
+ * which is what makes one tile's chevron continue into the next rather than
+ * ending in a corner.
+ */
+export function chevronsSvg(texture, dimensions, id) {
+    const gap = texture.gap ?? chevronDefaults.gap;
+    const low = String(gap * 0.7);
+    const high = String(gap * 0.3);
+    const chevron = `<path d="M0 ${low}L${String(gap / 2)} ${high}L${String(gap)} ${low}"` +
+        ` stroke="${texture.color ?? fallbackColor}"` +
+        ` stroke-width="${String(texture.width ?? chevronDefaults.width)}"` +
+        ` fill="none"/>`;
+    return tile(id, gap, chevron, "", dimensions, texture.opacity ?? chevronDefaults.opacity);
+}
+//# sourceMappingURL=chevrons.js.map

package/dist/texture/chevrons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chevrons.js","sourceRoot":"","sources":["../../src/texture/chevrons.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,eAAe,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC;AAE7D;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CACzB,OAAwD,EACxD,UAAsB,EACtB,EAAU;IAEV,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,eAAe,CAAC,GAAG,CAAC;IAC/C,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;IAC9B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;IAC/B,MAAM,OAAO,GACX,eAAe,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG;QACtE,YAAY,OAAO,CAAC,KAAK,IAAI,aAAa,GAAG;QAC7C,kBAAkB,MAAM,CAAC,OAAO,CAAC,KAAK,IAAI,eAAe,CAAC,KAAK,CAAC,GAAG;QACnE,gBAAgB,CAAC;IAEnB,OAAO,IAAI,CACT,EAAE,EACF,GAAG,EACH,OAAO,EACP,EAAE,EACF,UAAU,EACV,OAAO,CAAC,OAAO,IAAI,eAAe,CAAC,OAAO,CAC3C,CAAC;AACJ,CAAC"}

package/dist/texture/grid.d.ts

@@ -0,0 +1,14 @@
+import type { Dimensions, Texture } from "../types.js";
+/**
+ * Squared paper: lines both ways, and a heavier one every so often.
+ *
+ * The heavy lines are a second tile rather than part of the first, since what
+ * makes them heavy is that they repeat at a multiple of the spacing. Drawing
+ * both from `<pattern>`s keeps this among the cheap treatments: the tiles are
+ * square to the image, so a row of the rendered picture repeats, which is what
+ * the compression works on.
+ */
+export declare function gridSvg(texture: Extract<Texture, {
+    readonly type: "grid";
+}>, dimensions: Dimensions, id: string): string;
+//# sourceMappingURL=grid.d.ts.map

package/dist/texture/grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../src/texture/grid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AA4BvD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACpD,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,GACT,MAAM,CA8BR"}

package/dist/texture/grid.js

@@ -0,0 +1,38 @@
+import { fallbackColor } from "./color.js";
+import { tile } from "./tile.js";
+const gridDefaults = { opacity: 0.07, width: 1, gap: 32, major: 5 };
+/** How much heavier the every-so-often line is than the rest. */
+const majorScale = 2;
+/** One square's worth of grid: a line along two of its edges. */
+function square(texture, gap, width) {
+    const middle = String(gap / 2);
+    const size = String(gap);
+    // Down the middle of the tile on both axes rather than along its edges, for
+    // the reason `rulesSvg` gives: a stroke centred on the edge would have half
+    // of itself outside the tile, where the pattern does not repeat it.
+    return (`<path d="M0 ${middle}H${size}M${middle} 0V${size}"` +
+        ` stroke="${texture.color ?? fallbackColor}"` +
+        ` stroke-width="${String(width)}" fill="none"/>`);
+}
+/**
+ * Squared paper: lines both ways, and a heavier one every so often.
+ *
+ * The heavy lines are a second tile rather than part of the first, since what
+ * makes them heavy is that they repeat at a multiple of the spacing. Drawing
+ * both from `<pattern>`s keeps this among the cheap treatments: the tiles are
+ * square to the image, so a row of the rendered picture repeats, which is what
+ * the compression works on.
+ */
+export function gridSvg(texture, dimensions, id) {
+    const gap = texture.gap ?? gridDefaults.gap;
+    const width = texture.width ?? gridDefaults.width;
+    const opacity = texture.opacity ?? gridDefaults.opacity;
+    const major = texture.major ?? gridDefaults.major;
+    const fine = tile(`${id}a`, gap, square(texture, gap, width), "", dimensions, opacity);
+    if (major < 2) {
+        return fine;
+    }
+    return (fine +
+        tile(`${id}b`, gap * major, square(texture, gap * major, width * majorScale), "", dimensions, opacity));
+}
+//# sourceMappingURL=grid.js.map

package/dist/texture/grid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid.js","sourceRoot":"","sources":["../../src/texture/grid.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,YAAY,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;AAEpE,iEAAiE;AACjE,MAAM,UAAU,GAAG,CAAC,CAAC;AAErB,iEAAiE;AACjE,SAAS,MAAM,CACb,OAAoD,EACpD,GAAW,EACX,KAAa;IAEb,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IAC/B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAEzB,4EAA4E;IAC5E,4EAA4E;IAC5E,oEAAoE;IACpE,OAAO,CACL,eAAe,MAAM,IAAI,IAAI,IAAI,MAAM,MAAM,IAAI,GAAG;QACpD,YAAY,OAAO,CAAC,KAAK,IAAI,aAAa,GAAG;QAC7C,kBAAkB,MAAM,CAAC,KAAK,CAAC,iBAAiB,CACjD,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,OAAO,CACrB,OAAoD,EACpD,UAAsB,EACtB,EAAU;IAEV,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,YAAY,CAAC,GAAG,CAAC;IAC5C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC,KAAK,CAAC;IAClD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,YAAY,CAAC,OAAO,CAAC;IACxD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC,KAAK,CAAC;IAElD,MAAM,IAAI,GAAG,IAAI,CACf,GAAG,EAAE,GAAG,EACR,GAAG,EACH,MAAM,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,EAC3B,EAAE,EACF,UAAU,EACV,OAAO,CACR,CAAC;IAEF,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,CACL,IAAI;QACJ,IAAI,CACF,GAAG,EAAE,GAAG,EACR,GAAG,GAAG,KAAK,EACX,MAAM,CAAC,OAAO,EAAE,GAAG,GAAG,KAAK,EAAE,KAAK,GAAG,UAAU,CAAC,EAChD,EAAE,EACF,UAAU,EACV,OAAO,CACR,CACF,CAAC;AACJ,CAAC"}

package/dist/texture/halftone.d.ts

@@ -0,0 +1,14 @@
+import type { Dimensions, Texture } from "../types.js";
+/**
+ * A grid of dots that grow across the image, which is a gradient made out of
+ * print.
+ *
+ * It cannot be a tile: every dot is a different size, which is the whole
+ * effect. What keeps it affordable is that the size depends on the position
+ * rather than on chance, so a run of dots across the image is a smooth ramp
+ * and there is nothing noisy for the compression to choke on.
+ */
+export declare function halftoneSvg(texture: Extract<Texture, {
+    readonly type: "halftone";
+}>, dimensions: Dimensions): string;
+//# sourceMappingURL=halftone.d.ts.map

package/dist/texture/halftone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"halftone.d.ts","sourceRoot":"","sources":["../../src/texture/halftone.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAsCvD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,EACxD,UAAU,EAAE,UAAU,GACrB,MAAM,CAuBR"}

package/dist/texture/halftone.js

@@ -0,0 +1,55 @@
+import { fallbackColor } from "./color.js";
+const halftoneDefaults = {
+    opacity: 0.12,
+    size: 12,
+    gap: 30,
+    angle: 90,
+    from: 0.1,
+};
+/**
+ * How far along the growth a point is, from 0 at one edge to 1 at the other.
+ *
+ * It is the point's distance along the direction the dots grow in, measured
+ * from whichever corner is furthest back along it, so the ramp covers the
+ * whole image whatever angle it runs at.
+ */
+function ramp(dimensions, angle) {
+    const radians = (angle * Math.PI) / 180;
+    const dx = Math.cos(radians);
+    const dy = Math.sin(radians);
+    const { width, height } = dimensions;
+    // The four corners projected onto the direction give its full span, so the
+    // ends of the ramp land on the image rather than somewhere outside it.
+    const corners = [0, width].flatMap((cx) => [0, height].map((cy) => cx * dx + cy * dy));
+    const low = Math.min(...corners);
+    const span = Math.max(...corners) - low || 1;
+    return (px, py) => (px * dx + py * dy - low) / span;
+}
+/**
+ * A grid of dots that grow across the image, which is a gradient made out of
+ * print.
+ *
+ * It cannot be a tile: every dot is a different size, which is the whole
+ * effect. What keeps it affordable is that the size depends on the position
+ * rather than on chance, so a run of dots across the image is a smooth ramp
+ * and there is nothing noisy for the compression to choke on.
+ */
+export function halftoneSvg(texture, dimensions) {
+    const gap = texture.gap ?? halftoneDefaults.gap;
+    const size = texture.size ?? halftoneDefaults.size;
+    const from = texture.from ?? halftoneDefaults.from;
+    const at = ramp(dimensions, texture.angle ?? halftoneDefaults.angle);
+    let dots = "";
+    for (let y = gap / 2; y < dimensions.height + gap; y += gap) {
+        for (let x = gap / 2; x < dimensions.width + gap; x += gap) {
+            const radius = (size / 2) * (from + (1 - from) * at(x, y));
+            dots +=
+                `<circle cx="${String(Math.round(x))}" cy="${String(Math.round(y))}"` +
+                    ` r="${String(Math.round(radius * 100) / 100)}"/>`;
+        }
+    }
+    return (`<g fill="${texture.color ?? fallbackColor}"` +
+        ` opacity="${String(texture.opacity ?? halftoneDefaults.opacity)}">` +
+        `${dots}</g>`);
+}
+//# sourceMappingURL=halftone.js.map

package/dist/texture/halftone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"halftone.js","sourceRoot":"","sources":["../../src/texture/halftone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,gBAAgB,GAAG;IACvB,OAAO,EAAE,IAAI;IACb,IAAI,EAAE,EAAE;IACR,GAAG,EAAE,EAAE;IACP,KAAK,EAAE,EAAE;IACT,IAAI,EAAE,GAAG;CACV,CAAC;AAEF;;;;;;GAMG;AACH,SAAS,IAAI,CACX,UAAsB,EACtB,KAAa;IAEb,MAAM,OAAO,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;IACxC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC7B,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC7B,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,UAAU,CAAC;IAErC,2EAA2E;IAC3E,uEAAuE;IACvE,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CACxC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAC3C,CAAC;IACF,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC;IACjC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;IAE7C,OAAO,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC;AACtD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CACzB,OAAwD,EACxD,UAAsB;IAEtB,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,gBAAgB,CAAC,GAAG,CAAC;IAChD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,gBAAgB,CAAC,IAAI,CAAC;IACnD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,gBAAgB,CAAC,IAAI,CAAC;IACnD,MAAM,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,KAAK,IAAI,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAErE,IAAI,IAAI,GAAG,EAAE,CAAC;IAEd,KAAK,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC;QAC5D,KAAK,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,KAAK,GAAG,GAAG,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC;YAC3D,MAAM,MAAM,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAE3D,IAAI;gBACF,eAAe,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG;oBACrE,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC;QACvD,CAAC;IACH,CAAC;IAED,OAAO,CACL,YAAY,OAAO,CAAC,KAAK,IAAI,aAAa,GAAG;QAC7C,aAAa,MAAM,CAAC,OAAO,CAAC,OAAO,IAAI,gBAAgB,CAAC,OAAO,CAAC,IAAI;QACpE,GAAG,IAAI,MAAM,CACd,CAAC;AACJ,CAAC"}

package/dist/texture/honeycomb.d.ts

@@ -0,0 +1,14 @@
+import type { Dimensions, Texture } from "../types.js";
+/**
+ * A honeycomb of hexagon outlines.
+ *
+ * The grid repeats every three sides across and every `side * sqrt(3)` down,
+ * which is the smallest rectangle a honeycomb fits in. Two hexagons go in it,
+ * the second offset by half of each, and the ones that fall outside are drawn
+ * anyway so that the tile joins its neighbours: the pattern clips them, and a
+ * hexagon cut in half by the tile edge meets its other half in the next tile.
+ */
+export declare function honeycombSvg(texture: Extract<Texture, {
+    readonly type: "honeycomb";
+}>, dimensions: Dimensions, id: string): string;
+//# sourceMappingURL=honeycomb.d.ts.map

package/dist/texture/honeycomb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"honeycomb.d.ts","sourceRoot":"","sources":["../../src/texture/honeycomb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AA8BvD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,EACzD,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,GACT,MAAM,CAwBR"}

package/dist/texture/honeycomb.js

@@ -0,0 +1,43 @@
+import { fallbackColor } from "./color.js";
+import { tile } from "./tile.js";
+const combDefaults = { opacity: 0.07, width: 1.5, size: 26 };
+/** Rounded to keep the path short, since it is written out twice a tile. */
+function at(value) {
+    return String(Math.round(value * 100) / 100);
+}
+/**
+ * One flat-topped hexagon, from its centre and the length of a side.
+ *
+ * A hexagon of side `s` is `2s` across the points and `s * sqrt(3)` across the
+ * flats, which is where every number below comes from.
+ */
+function hexagon(cx, cy, side) {
+    const half = (side * Math.sqrt(3)) / 2;
+    return (`M${at(cx - side)} ${at(cy)}` +
+        `L${at(cx - side / 2)} ${at(cy - half)}` +
+        `L${at(cx + side / 2)} ${at(cy - half)}` +
+        `L${at(cx + side)} ${at(cy)}` +
+        `L${at(cx + side / 2)} ${at(cy + half)}` +
+        `L${at(cx - side / 2)} ${at(cy + half)}Z`);
+}
+/**
+ * A honeycomb of hexagon outlines.
+ *
+ * The grid repeats every three sides across and every `side * sqrt(3)` down,
+ * which is the smallest rectangle a honeycomb fits in. Two hexagons go in it,
+ * the second offset by half of each, and the ones that fall outside are drawn
+ * anyway so that the tile joins its neighbours: the pattern clips them, and a
+ * hexagon cut in half by the tile edge meets its other half in the next tile.
+ */
+export function honeycombSvg(texture, dimensions, id) {
+    const side = texture.size ?? combDefaults.size;
+    const height = side * Math.sqrt(3);
+    const width = side * 3;
+    const comb = `<path d="${hexagon(side, height / 2, side)}${hexagon(side * 2.5, 0, side)}${hexagon(side * 2.5, height, side)}" stroke="${texture.color ?? fallbackColor}"` +
+        ` stroke-width="${String(texture.width ?? combDefaults.width)}"` +
+        ` fill="none"/>`;
+    // Not the square tile the others use: a honeycomb's repeat is wider than it
+    // is tall, so `tile` takes the two separately here.
+    return tile(id, { width, height }, comb, "", dimensions, texture.opacity ?? combDefaults.opacity);
+}
+//# sourceMappingURL=honeycomb.js.map

package/dist/texture/honeycomb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"honeycomb.js","sourceRoot":"","sources":["../../src/texture/honeycomb.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,YAAY,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;AAE7D,4EAA4E;AAC5E,SAAS,EAAE,CAAC,KAAa;IACvB,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;GAKG;AACH,SAAS,OAAO,CAAC,EAAU,EAAE,EAAU,EAAE,IAAY;IACnD,MAAM,IAAI,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAEvC,OAAO,CACL,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;QAC7B,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE;QACxC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE;QACxC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;QAC7B,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE;QACxC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,CAC1C,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAyD,EACzD,UAAsB,EACtB,EAAU;IAEV,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,YAAY,CAAC,IAAI,CAAC;IAC/C,MAAM,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACnC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC;IAEvB,MAAM,IAAI,GACR,YAAY,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,OAAO,CACnD,IAAI,GAAG,GAAG,EACV,CAAC,EACD,IAAI,CACL,GAAG,OAAO,CAAC,IAAI,GAAG,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,aAAa,OAAO,CAAC,KAAK,IAAI,aAAa,GAAG;QACnF,kBAAkB,MAAM,CAAC,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC,KAAK,CAAC,GAAG;QAChE,gBAAgB,CAAC;IAEnB,4EAA4E;IAC5E,oDAAoD;IACpD,OAAO,IAAI,CACT,EAAE,EACF,EAAE,KAAK,EAAE,MAAM,EAAE,EACjB,IAAI,EACJ,EAAE,EACF,UAAU,EACV,OAAO,CAAC,OAAO,IAAI,YAAY,CAAC,OAAO,CACxC,CAAC;AACJ,CAAC"}

package/dist/texture/index.d.ts

@@ -1,12 +1,23 @@
 import type { Dimensions, Texture } from "../types.js";
-export { resolveTexture } from "./resolve.js";
+export { resolveTexture, resolveTextureScale } from "./resolve.js";
 /**
  * Render the treatment laid over a background as SVG, naming whatever it needs
- * in `<defs>` after the given `id`. Not every treatment needs one: `waves` is
- * plain elements and names nothing.
+ * in `<defs>` after the given `id`.
  *
  * It is drawn between the background and whatever a template draws, so a
  * texture never comes between a headline and the reader.
+ *
+ * `scale` draws the same picture larger, for an image that will be looked at
+ * much smaller than it was rendered. It is done here, once, rather than by
+ * every treatment reading it: the thirteen of them describe their geometry in
+ * a dozen different fields, and there is no arithmetic they could share except
+ * this. So the texture is drawn into a smaller image and that image is scaled
+ * back up, which is exactly what a magnifier over the corner of it would show.
+ * The dimensions are rounded up so the treatment still covers the last row of
+ * pixels, and the viewport is what trims the overhang.
+ *
+ * A scale of `1` writes what it always wrote, down to the byte, which is what
+ * leaves every image that does not ask for this alone.
  */
-export declare function textureSvg(texture: Texture, dimensions: Dimensions, id: string): string;
+export declare function textureSvg(texture: Texture, dimensions: Dimensions, id: string, scale?: number): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/texture/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/texture/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAKvD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,GACT,MAAM,CAcR"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/texture/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAavD,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAuCnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,EACV,KAAK,SAAI,GACR,MAAM,CAgBR"}

package/dist/texture/index.js

@@ -1,25 +1,75 @@
+import { chevronsSvg } from "./chevrons.js";
 import { grainSvg } from "./grain.js";
-import { dotsSvg, rulesSvg } from "./pattern.js";
+import { halftoneSvg } from "./halftone.js";
+import { gridSvg } from "./grid.js";
+import { honeycombSvg } from "./honeycomb.js";
+import { moireSvg } from "./moire.js";
+import { crossesSvg, dotsSvg, rulesSvg } from "./pattern.js";
+import { raysSvg } from "./rays.js";
+import { scallopsSvg } from "./scallops.js";
+import { topographicSvg } from "./topographic/index.js";
 import { wavesSvg } from "./waves.js";
-export { resolveTexture } from "./resolve.js";
+export { resolveTexture, resolveTextureScale } from "./resolve.js";
+/**
+ * Which function draws which treatment.
+ *
+ * A table rather than a chain of `if`s, because the chain had a branch per
+ * texture and there are ten of them: the file was close to the complexity
+ * threshold and every new treatment made it worse. The type is what keeps this
+ * honest, and it does the job the chain's final `return` used to do badly: a
+ * variant added to `Texture` with no entry here fails to compile, where before
+ * it silently came out as ruled lines.
+ *
+ * `waves` and `rays` name nothing in `<defs>` and take no id. They are wrapped
+ * rather than given a parameter to ignore, so each one's own signature still
+ * says what it uses.
+ */
+const drawers = {
+    grain: grainSvg,
+    dots: dotsSvg,
+    rules: rulesSvg,
+    grid: gridSvg,
+    crosses: crossesSvg,
+    chevrons: chevronsSvg,
+    honeycomb: honeycombSvg,
+    moire: moireSvg,
+    scallops: scallopsSvg,
+    waves: (texture, dimensions) => wavesSvg(texture, dimensions),
+    rays: (texture, dimensions) => raysSvg(texture, dimensions),
+    halftone: (texture, dimensions) => halftoneSvg(texture, dimensions),
+    topographic: (texture, dimensions) => topographicSvg(texture, dimensions),
+};
 /**
  * Render the treatment laid over a background as SVG, naming whatever it needs
- * in `<defs>` after the given `id`. Not every treatment needs one: `waves` is
- * plain elements and names nothing.
+ * in `<defs>` after the given `id`.
  *
  * It is drawn between the background and whatever a template draws, so a
  * texture never comes between a headline and the reader.
+ *
+ * `scale` draws the same picture larger, for an image that will be looked at
+ * much smaller than it was rendered. It is done here, once, rather than by
+ * every treatment reading it: the thirteen of them describe their geometry in
+ * a dozen different fields, and there is no arithmetic they could share except
+ * this. So the texture is drawn into a smaller image and that image is scaled
+ * back up, which is exactly what a magnifier over the corner of it would show.
+ * The dimensions are rounded up so the treatment still covers the last row of
+ * pixels, and the viewport is what trims the overhang.
+ *
+ * A scale of `1` writes what it always wrote, down to the byte, which is what
+ * leaves every image that does not ask for this alone.
  */
-export function textureSvg(texture, dimensions, id) {
-    if (texture.type === "grain") {
-        return grainSvg(texture, dimensions, id);
-    }
-    if (texture.type === "dots") {
-        return dotsSvg(texture, dimensions, id);
-    }
-    if (texture.type === "waves") {
-        return wavesSvg(texture, dimensions);
+export function textureSvg(texture, dimensions, id, scale = 1) {
+    // The value and the lookup narrow separately, so the compiler cannot see
+    // that they are the same variant, though the table's type is what makes them
+    // so. This is the one line that knows better than the checker.
+    const draw = drawers[texture.type];
+    if (scale === 1) {
+        return draw(texture, dimensions, id);
     }
-    return rulesSvg(texture, dimensions, id);
+    const reduced = {
+        width: Math.ceil(dimensions.width / scale),
+        height: Math.ceil(dimensions.height / scale),
+    };
+    return `<g transform="scale(${String(scale)})">${draw(texture, reduced, id)}</g>`;
 }
 //# sourceMappingURL=index.js.map