@kensio/colophon 2.3.0 → 2.5.0

package/dist/templates/text.d.ts

@@ -0,0 +1,37 @@
+import type { MeasureText } from "../types.js";
+/** One group of a template's text: the space it has and how it is drawn. */
+export interface TextBlock {
+    readonly maxWidth: number;
+    readonly maxLines: number;
+    readonly fontSize: number;
+    /**
+     * Fraction of `fontSize` this group may shrink to before it is cut instead.
+     * The title of a layout has the furthest to fall, because it is the line
+     * worth keeping whole; a subtitle that has shrunk much has stopped being
+     * readable in a feed, so it may as well lose its tail.
+     */
+    readonly floor: number;
+    readonly fontWeight: number;
+}
+/** A block along with how the lines it produces are drawn. */
+export interface StyledBlock extends TextBlock {
+    readonly opacity: number;
+    /** Space inserted before the group's first line, to separate it from the last. */
+    readonly gapBefore?: number;
+}
+/** One line of a template's text block, ready to be stacked and drawn. */
+export interface TextLine {
+    readonly text: string;
+    readonly fontSize: number;
+    readonly fontWeight: number;
+    readonly opacity: number;
+    readonly gapBefore?: number;
+}
+/**
+ * Fit one group of a template's text, from a prop that may not be there, and
+ * return its lines. Each group is fitted on its own, so a long title shrinking
+ * does not drag the subtitle down with it. A group whose prop is absent or
+ * empty produces no lines at all.
+ */
+export declare function blockLines(value: unknown, measure: MeasureText, fontFamily: string, block: StyledBlock): TextLine[];
+//# sourceMappingURL=text.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/templates/text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C,4EAA4E;AAC5E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,8DAA8D;AAC9D,MAAM,WAAW,WAAY,SAAQ,SAAS;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,kFAAkF;IAClF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,0EAA0E;AAC1E,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,WAAW,GACjB,QAAQ,EAAE,CAoBZ"}

package/dist/templates/text.js

@@ -0,0 +1,26 @@
+import { fitText } from "../text/index.js";
+import { measureIn } from "./measure.js";
+import { optionalString } from "./props.js";
+/**
+ * Fit one group of a template's text, from a prop that may not be there, and
+ * return its lines. Each group is fitted on its own, so a long title shrinking
+ * does not drag the subtitle down with it. A group whose prop is absent or
+ * empty produces no lines at all.
+ */
+export function blockLines(value, measure, fontFamily, block) {
+    const fitted = fitText(optionalString(value) ?? "", measureIn(measure, fontFamily, block.fontWeight), {
+        maxWidth: block.maxWidth,
+        maxLines: block.maxLines,
+        fontSize: block.fontSize,
+        minFontSize: Math.round(block.fontSize * block.floor),
+    });
+    return fitted.lines.map((text, index) => ({
+        text,
+        fontSize: fitted.fontSize,
+        fontWeight: block.fontWeight,
+        opacity: block.opacity,
+        ...(index === 0 &&
+            block.gapBefore !== undefined && { gapBefore: block.gapBefore }),
+    }));
+}
+//# sourceMappingURL=text.js.map

package/dist/templates/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sourceRoot":"","sources":["../../src/templates/text.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAiC5C;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CACxB,KAAc,EACd,OAAoB,EACpB,UAAkB,EAClB,KAAkB;IAElB,MAAM,MAAM,GAAe,OAAO,CAChC,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,EAC3B,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,EAChD;QACE,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC;KACtD,CACF,CAAC;IAEF,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;QACxC,IAAI;QACJ,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,GAAG,CAAC,KAAK,KAAK,CAAC;YACb,KAAK,CAAC,SAAS,KAAK,SAAS,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;KACnE,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/text/break.d.ts

@@ -0,0 +1,11 @@
+import type { MeasureLine } from "./wrap.js";
+/**
+ * Break one word across as many lines as it takes, for a word that is wider
+ * than the line it has to fit on. A URL, a compound German noun, or a whole
+ * Japanese sentence, which has no spaces to break at in the first place.
+ *
+ * Always returns at least one piece, even where a single character is wider
+ * than the line: overflowing by one glyph beats looping forever.
+ */
+export declare function breakWord(word: string, maxWidth: number, measure: MeasureLine): string[];
+//# sourceMappingURL=break.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"break.d.ts","sourceRoot":"","sources":["../../src/text/break.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAS7C;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,WAAW,GACnB,MAAM,EAAE,CAgBV"}

package/dist/text/break.js

@@ -0,0 +1,30 @@
+/**
+ * Grapheme segmentation, so a break never lands inside an emoji or between a
+ * letter and the accent that belongs to it. Built once, since a build breaks
+ * a great many words and the segmenter carries locale data with it.
+ */
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+/**
+ * Break one word across as many lines as it takes, for a word that is wider
+ * than the line it has to fit on. A URL, a compound German noun, or a whole
+ * Japanese sentence, which has no spaces to break at in the first place.
+ *
+ * Always returns at least one piece, even where a single character is wider
+ * than the line: overflowing by one glyph beats looping forever.
+ */
+export function breakWord(word, maxWidth, measure) {
+    const pieces = [];
+    let current = "";
+    for (const { segment } of graphemes.segment(word)) {
+        const next = current + segment;
+        if (current !== "" && measure(next) > maxWidth) {
+            pieces.push(current);
+            current = segment;
+        }
+        else {
+            current = next;
+        }
+    }
+    return current === "" ? [word] : [...pieces, current];
+}
+//# sourceMappingURL=break.js.map

package/dist/text/break.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"break.js","sourceRoot":"","sources":["../../src/text/break.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;AAE7E;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS,CACvB,IAAY,EACZ,QAAgB,EAChB,OAAoB;IAEpB,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,OAAO,GAAG,EAAE,CAAC;IAEjB,KAAK,MAAM,EAAE,OAAO,EAAE,IAAI,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,MAAM,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC;QAE/B,IAAI,OAAO,KAAK,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,QAAQ,EAAE,CAAC;YAC/C,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,OAAO,GAAG,OAAO,CAAC;QACpB,CAAC;aAAM,CAAC;YACN,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;IACH,CAAC;IAED,OAAO,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE,OAAO,CAAC,CAAC;AACxD,CAAC"}

package/dist/text/fit.d.ts

@@ -0,0 +1,30 @@
+/** The width a run of text would be drawn at, at a given font size. */
+export type MeasureAt = (text: string, fontSize: number) => number;
+/** The space a block of text has, and the sizes it may be drawn at. */
+export interface FitOptions {
+    readonly maxWidth: number;
+    readonly maxLines: number;
+    /** The size to draw at when the text fits at it. */
+    readonly fontSize: number;
+    /** The size below which shrinking costs more legibility than it is worth. */
+    readonly minFontSize: number;
+}
+/** A block of text with the size it turned out to fit at. */
+export interface FittedText {
+    readonly lines: readonly string[];
+    readonly fontSize: number;
+}
+/**
+ * Wrap text into the space it has, shrinking it until it fits.
+ *
+ * The alternative, and what Colophon did before it could measure anything, is
+ * to wrap at one size and drop whatever is left over. That reads as a mistake
+ * rather than a design: a long title loses its last few words, and the image
+ * says something the post does not. Shrinking keeps the words.
+ *
+ * It only shrinks so far, because a title small enough to fit anything is a
+ * title nobody reads in a feed. Text that still does not fit at the floor is
+ * cut to `maxLines` as before.
+ */
+export declare function fitText(text: string, measure: MeasureAt, options: FitOptions): FittedText;
+//# sourceMappingURL=fit.d.ts.map

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

@@ -0,0 +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"}

package/dist/text/fit.js

@@ -0,0 +1,29 @@
+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.
+ *
+ * The alternative, and what Colophon did before it could measure anything, is
+ * to wrap at one size and drop whatever is left over. That reads as a mistake
+ * rather than a design: a long title loses its last few words, and the image
+ * says something the post does not. Shrinking keeps the words.
+ *
+ * It only shrinks so far, because a title small enough to fit anything is a
+ * title nobody reads in a feed. Text that still does not fit at the floor is
+ * cut to `maxLines` as before.
+ */
+export function fitText(text, measure, options) {
+    const { maxWidth, maxLines, minFontSize } = 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)));
+        lines = wrapText(text, maxWidth, (line) => measure(line, fontSize));
+    }
+    return { lines: lines.slice(0, maxLines), fontSize };
+}
+//# sourceMappingURL=fit.js.map

package/dist/text/fit.js.map

@@ -0,0 +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"}

package/dist/text/index.d.ts

@@ -1,7 +1,9 @@
 export { escapeXml } from "./escape.js";
 export { textElement } from "./element.js";
 export type { TextAttributes } from "./element.js";
-export { layoutStack } from "./stack.js";
-export type { PlacedLine, StackLine } from "./stack.js";
-export { estimateCharsPerLine, wrapText } from "./wrap.js";
+export { breakWord } from "./break.js";
+export { fitText } from "./fit.js";
+export type { FitOptions, FittedText, MeasureAt } from "./fit.js";
+export { wrapText } from "./wrap.js";
+export type { MeasureLine } from "./wrap.js";
 //# sourceMappingURL=index.d.ts.map

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,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,QAAQ,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,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

@@ -1,5 +1,6 @@
 export { escapeXml } from "./escape.js";
 export { textElement } from "./element.js";
-export { layoutStack } from "./stack.js";
-export { estimateCharsPerLine, wrapText } from "./wrap.js";
+export { breakWord } from "./break.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,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAAE,oBAAoB,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,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC"}

package/dist/text/wrap.d.ts

@@ -1,12 +1,22 @@
 /**
- * Naive greedy word-wrap by character count. Words longer than the limit are
- * kept intact on their own line rather than being split.
+ * The width a run of text will be drawn at, in the same units as the space it
+ * has to fit. Bound to a font and a size by whoever is doing the wrapping.
  */
-export declare function wrapText(text: string, charactersPerLine: number): string[];
+export type MeasureLine = (text: string) => number;
 /**
- * Estimate how many characters of the given font size fit within `widthPx`.
- * The `widthFactor` approximates average glyph width as a fraction of the font
- * size (bolder/wider faces want a larger factor).
+ * Greedy word-wrap to a width rather than to a character count.
+ *
+ * Wrapping by characters means assuming every glyph is the same fraction of
+ * the font size, which is wrong by a little for Latin text and wrong by half
+ * for anything wider. Measuring the words is what puts the break where it
+ * belongs.
+ *
+ * A single word too wide for the line is broken, since the alternative is a
+ * line that runs off the image. Text written without spaces, which is most of
+ * how Japanese and Chinese are set, is one long word by this reckoning and so
+ * breaks at whatever character reaches the edge. That is a plain wrap rather
+ * than a correct one: it does not know that a line should not begin with
+ * closing punctuation.
  */
-export declare function estimateCharsPerLine(widthPx: number, fontSize: number, widthFactor?: number): number;
+export declare function wrapText(text: string, maxWidth: number, measure: MeasureLine): string[];
 //# sourceMappingURL=wrap.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wrap.d.ts","sourceRoot":"","sources":["../../src/text/wrap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,MAAM,EAAE,CAsB1E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,WAAW,SAAO,GACjB,MAAM,CAER"}
+{"version":3,"file":"wrap.d.ts","sourceRoot":"","sources":["../../src/text/wrap.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;AAEnD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,WAAW,GACnB,MAAM,EAAE,CA6BV"}

package/dist/text/wrap.js

@@ -1,33 +1,41 @@
+import { breakWord } from "./break.js";
 /**
- * Naive greedy word-wrap by character count. Words longer than the limit are
- * kept intact on their own line rather than being split.
+ * Greedy word-wrap to a width rather than to a character count.
+ *
+ * Wrapping by characters means assuming every glyph is the same fraction of
+ * the font size, which is wrong by a little for Latin text and wrong by half
+ * for anything wider. Measuring the words is what puts the break where it
+ * belongs.
+ *
+ * A single word too wide for the line is broken, since the alternative is a
+ * line that runs off the image. Text written without spaces, which is most of
+ * how Japanese and Chinese are set, is one long word by this reckoning and so
+ * breaks at whatever character reaches the edge. That is a plain wrap rather
+ * than a correct one: it does not know that a line should not begin with
+ * closing punctuation.
  */
-export function wrapText(text, charactersPerLine) {
-    const limit = Math.max(1, Math.floor(charactersPerLine));
+export function wrapText(text, maxWidth, measure) {
     const words = text.split(/\s+/).filter((word) => word !== "");
     const lines = [];
     let currentLine = "";
     for (const word of words) {
         const nextLine = currentLine === "" ? word : `${currentLine} ${word}`;
-        if (nextLine.length > limit && currentLine !== "") {
-            lines.push(currentLine);
-            currentLine = word;
-        }
-        else {
+        if (measure(nextLine) <= maxWidth) {
             currentLine = nextLine;
+            continue;
+        }
+        if (currentLine !== "") {
+            lines.push(currentLine);
         }
+        // The word starts a line of its own, and is only broken up if it cannot
+        // fit on one even there.
+        const pieces = breakWord(word, maxWidth, measure);
+        lines.push(...pieces.slice(0, -1));
+        currentLine = pieces.at(-1) ?? "";
     }
     if (currentLine !== "") {
         lines.push(currentLine);
     }
     return lines;
 }
-/**
- * Estimate how many characters of the given font size fit within `widthPx`.
- * The `widthFactor` approximates average glyph width as a fraction of the font
- * size (bolder/wider faces want a larger factor).
- */
-export function estimateCharsPerLine(widthPx, fontSize, widthFactor = 0.58) {
-    return Math.max(1, Math.floor(widthPx / (fontSize * widthFactor)));
-}
 //# sourceMappingURL=wrap.js.map

package/dist/text/wrap.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrap.js","sourceRoot":"","sources":["../../src/text/wrap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAY,EAAE,iBAAyB;IAC9D,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACzD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC;IAC9D,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,WAAW,GAAG,EAAE,CAAC;IAErB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,WAAW,IAAI,IAAI,EAAE,CAAC;QAEtE,IAAI,QAAQ,CAAC,MAAM,GAAG,KAAK,IAAI,WAAW,KAAK,EAAE,EAAE,CAAC;YAClD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACxB,WAAW,GAAG,IAAI,CAAC;QACrB,CAAC;aAAM,CAAC;YACN,WAAW,GAAG,QAAQ,CAAC;QACzB,CAAC;IACH,CAAC;IAED,IAAI,WAAW,KAAK,EAAE,EAAE,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC1B,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAAe,EACf,QAAgB,EAChB,WAAW,GAAG,IAAI;IAElB,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;AACrE,CAAC"}
+{"version":3,"file":"wrap.js","sourceRoot":"","sources":["../../src/text/wrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAQvC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,QAAQ,CACtB,IAAY,EACZ,QAAgB,EAChB,OAAoB;IAEpB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC;IAC9D,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,WAAW,GAAG,EAAE,CAAC;IAErB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,WAAW,IAAI,IAAI,EAAE,CAAC;QAEtE,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,EAAE,CAAC;YAClC,WAAW,GAAG,QAAQ,CAAC;YACvB,SAAS;QACX,CAAC;QAED,IAAI,WAAW,KAAK,EAAE,EAAE,CAAC;YACvB,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1B,CAAC;QAED,wEAAwE;QACxE,yBAAyB;QACzB,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QAClD,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,WAAW,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACpC,CAAC;IAED,IAAI,WAAW,KAAK,EAAE,EAAE,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC1B,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/texture/grain.d.ts

@@ -0,0 +1,17 @@
+import type { Dimensions, Texture } from "../types.js";
+/**
+ * Film grain, from one turbulence filter.
+ *
+ * `scale` is roughly the size of a speck in pixels, which is what someone
+ * tuning this actually wants to think about; the filter wants the reciprocal
+ * of that, so the two are inverses of each other. Three octaves is enough to
+ * stop the noise looking regular and cheap enough not to notice.
+ *
+ * The noise is desaturated to grey, since coloured specks over a brand colour
+ * read as a rendering fault rather than as grain. Grey does lighten what is
+ * under it a little, which is why the default opacity is as low as it is.
+ */
+export declare function grainSvg(texture: Extract<Texture, {
+    readonly type: "grain";
+}>, dimensions: Dimensions, id: string): string;
+//# sourceMappingURL=grain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grain.d.ts","sourceRoot":"","sources":["../../src/texture/grain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAKvD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,EACrD,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,GACT,MAAM,CAgBR"}

package/dist/texture/grain.js

@@ -0,0 +1,29 @@
+const defaultOpacity = 0.1;
+const defaultScale = 1.4;
+/**
+ * Film grain, from one turbulence filter.
+ *
+ * `scale` is roughly the size of a speck in pixels, which is what someone
+ * tuning this actually wants to think about; the filter wants the reciprocal
+ * of that, so the two are inverses of each other. Three octaves is enough to
+ * stop the noise looking regular and cheap enough not to notice.
+ *
+ * The noise is desaturated to grey, since coloured specks over a brand colour
+ * read as a rendering fault rather than as grain. Grey does lighten what is
+ * under it a little, which is why the default opacity is as low as it is.
+ */
+export function grainSvg(texture, dimensions, id) {
+    const { width, height } = dimensions;
+    const frequency = 1 / (texture.scale ?? defaultScale);
+    return (`<defs>` +
+        `<filter id="${id}" x="0" y="0" width="100%" height="100%">` +
+        `<feTurbulence type="fractalNoise" baseFrequency="${frequency.toFixed(3)}"` +
+        ` numOctaves="3" stitchTiles="stitch"/>` +
+        `<feColorMatrix type="saturate" values="0"/>` +
+        `</filter>` +
+        `</defs>` +
+        `<rect width="${String(width)}" height="${String(height)}"` +
+        ` filter="url(#${id})"` +
+        ` opacity="${String(texture.opacity ?? defaultOpacity)}"/>`);
+}
+//# sourceMappingURL=grain.js.map

package/dist/texture/grain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grain.js","sourceRoot":"","sources":["../../src/texture/grain.ts"],"names":[],"mappings":"AAEA,MAAM,cAAc,GAAG,GAAG,CAAC;AAC3B,MAAM,YAAY,GAAG,GAAG,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ,CACtB,OAAqD,EACrD,UAAsB,EACtB,EAAU;IAEV,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,UAAU,CAAC;IACrC,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC,CAAC;IAEtD,OAAO,CACL,QAAQ;QACR,eAAe,EAAE,2CAA2C;QAC5D,oDAAoD,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG;QAC3E,wCAAwC;QACxC,6CAA6C;QAC7C,WAAW;QACX,SAAS;QACT,gBAAgB,MAAM,CAAC,KAAK,CAAC,aAAa,MAAM,CAAC,MAAM,CAAC,GAAG;QAC3D,iBAAiB,EAAE,IAAI;QACvB,aAAa,MAAM,CAAC,OAAO,CAAC,OAAO,IAAI,cAAc,CAAC,KAAK,CAC5D,CAAC;AACJ,CAAC"}

package/dist/texture/index.d.ts

@@ -0,0 +1,11 @@
+import type { Dimensions, Texture } from "../types.js";
+export { resolveTexture } from "./resolve.js";
+/**
+ * Render the treatment laid over a background as SVG, naming whatever it needs
+ * 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.
+ */
+export declare function textureSvg(texture: Texture, dimensions: Dimensions, id: string): string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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;AAIvD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,GACT,MAAM,CAUR"}

package/dist/texture/index.js

@@ -0,0 +1,20 @@
+import { grainSvg } from "./grain.js";
+import { dotsSvg, rulesSvg } from "./pattern.js";
+export { resolveTexture } from "./resolve.js";
+/**
+ * Render the treatment laid over a background as SVG, naming whatever it needs
+ * 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.
+ */
+export function textureSvg(texture, dimensions, id) {
+    if (texture.type === "grain") {
+        return grainSvg(texture, dimensions, id);
+    }
+    if (texture.type === "dots") {
+        return dotsSvg(texture, dimensions, id);
+    }
+    return rulesSvg(texture, dimensions, id);
+}
+//# sourceMappingURL=index.js.map

package/dist/texture/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/texture/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CACxB,OAAgB,EAChB,UAAsB,EACtB,EAAU;IAEV,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC7B,OAAO,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAC5B,OAAO,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED,OAAO,QAAQ,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,CAAC,CAAC;AAC3C,CAAC"}

package/dist/texture/pattern.d.ts

@@ -0,0 +1,17 @@
+import type { Dimensions, Texture } from "../types.js";
+/** A grid of dots, one to a tile. */
+export declare function dotsSvg(texture: Extract<Texture, {
+    readonly type: "dots";
+}>, dimensions: Dimensions, id: string): string;
+/**
+ * Ruled lines, one to a tile, rotated as a set.
+ *
+ * The line runs down the middle of its tile rather than along the edge, so
+ * that the whole of its width is inside the tile: a stroke centred on the edge
+ * would have half of itself outside the tile, where the pattern does not
+ * repeat it, and the lines would come out half as thick as asked for.
+ */
+export declare function rulesSvg(texture: Extract<Texture, {
+    readonly type: "rules";
+}>, dimensions: Dimensions, id: string): string;
+//# sourceMappingURL=pattern.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.d.ts","sourceRoot":"","sources":["../../src/texture/pattern.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAiCvD,qCAAqC;AACrC,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,CAgBR;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,EACrD,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,GACT,MAAM,CAiBR"}

package/dist/texture/pattern.js

@@ -0,0 +1,45 @@
+/** Used where the palette did not supply one, so a texture always draws. */
+const fallbackColor = "#ffffff";
+const dotDefaults = { opacity: 0.08, size: 5, gap: 44 };
+const ruleDefaults = { opacity: 0.06, width: 2, gap: 28, angle: 45 };
+/**
+ * A tiled pattern over the whole image: the `<pattern>` under the given `id`,
+ * and the rect that fills with it.
+ */
+function tile(id, gap, contents, transform, dimensions, opacity) {
+    const { width, height } = dimensions;
+    const size = String(gap);
+    return (`<defs>` +
+        `<pattern id="${id}" width="${size}" height="${size}"` +
+        ` patternUnits="userSpaceOnUse"${transform}>${contents}</pattern>` +
+        `</defs>` +
+        `<rect width="${String(width)}" height="${String(height)}"` +
+        ` fill="url(#${id})" opacity="${String(opacity)}"/>`);
+}
+/** A grid of dots, one to a tile. */
+export function dotsSvg(texture, dimensions, id) {
+    const gap = texture.gap ?? dotDefaults.gap;
+    const centre = String(gap / 2);
+    const dot = `<circle cx="${centre}" cy="${centre}"` +
+        ` r="${String((texture.size ?? dotDefaults.size) / 2)}"` +
+        ` fill="${texture.color ?? fallbackColor}"/>`;
+    return tile(id, gap, dot, "", dimensions, texture.opacity ?? dotDefaults.opacity);
+}
+/**
+ * Ruled lines, one to a tile, rotated as a set.
+ *
+ * The line runs down the middle of its tile rather than along the edge, so
+ * that the whole of its width is inside the tile: a stroke centred on the edge
+ * would have half of itself outside the tile, where the pattern does not
+ * repeat it, and the lines would come out half as thick as asked for.
+ */
+export function rulesSvg(texture, dimensions, id) {
+    const gap = texture.gap ?? ruleDefaults.gap;
+    const x = String(gap / 2);
+    const line = `<line x1="${x}" y1="0" x2="${x}" y2="${String(gap)}"` +
+        ` stroke="${texture.color ?? fallbackColor}"` +
+        ` stroke-width="${String(texture.width ?? ruleDefaults.width)}"/>`;
+    const angle = texture.angle ?? ruleDefaults.angle;
+    return tile(id, gap, line, ` patternTransform="rotate(${String(angle)})"`, dimensions, texture.opacity ?? ruleDefaults.opacity);
+}
+//# sourceMappingURL=pattern.js.map

package/dist/texture/pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.js","sourceRoot":"","sources":["../../src/texture/pattern.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,MAAM,aAAa,GAAG,SAAS,CAAC;AAEhC,MAAM,WAAW,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC;AACxD,MAAM,YAAY,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;AAErE;;;GAGG;AACH,SAAS,IAAI,CACX,EAAU,EACV,GAAW,EACX,QAAgB,EAChB,SAAiB,EACjB,UAAsB,EACtB,OAAe;IAEf,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,UAAU,CAAC;IACrC,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAEzB,OAAO,CACL,QAAQ;QACR,gBAAgB,EAAE,YAAY,IAAI,aAAa,IAAI,GAAG;QACtD,iCAAiC,SAAS,IAAI,QAAQ,YAAY;QAClE,SAAS;QACT,gBAAgB,MAAM,CAAC,KAAK,CAAC,aAAa,MAAM,CAAC,MAAM,CAAC,GAAG;QAC3D,eAAe,EAAE,eAAe,MAAM,CAAC,OAAO,CAAC,KAAK,CACrD,CAAC;AACJ,CAAC;AAED,qCAAqC;AACrC,MAAM,UAAU,OAAO,CACrB,OAAoD,EACpD,UAAsB,EACtB,EAAU;IAEV,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC;IAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IAC/B,MAAM,GAAG,GACP,eAAe,MAAM,SAAS,MAAM,GAAG;QACvC,OAAO,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG;QACxD,UAAU,OAAO,CAAC,KAAK,IAAI,aAAa,KAAK,CAAC;IAEhD,OAAO,IAAI,CACT,EAAE,EACF,GAAG,EACH,GAAG,EACH,EAAE,EACF,UAAU,EACV,OAAO,CAAC,OAAO,IAAI,WAAW,CAAC,OAAO,CACvC,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CACtB,OAAqD,EACrD,UAAsB,EACtB,EAAU;IAEV,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,YAAY,CAAC,GAAG,CAAC;IAC5C,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IAC1B,MAAM,IAAI,GACR,aAAa,CAAC,gBAAgB,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,GAAG;QACtD,YAAY,OAAO,CAAC,KAAK,IAAI,aAAa,GAAG;QAC7C,kBAAkB,MAAM,CAAC,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC;IACrE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC,KAAK,CAAC;IAElD,OAAO,IAAI,CACT,EAAE,EACF,GAAG,EACH,IAAI,EACJ,6BAA6B,MAAM,CAAC,KAAK,CAAC,IAAI,EAC9C,UAAU,EACV,OAAO,CAAC,OAAO,IAAI,YAAY,CAAC,OAAO,CACxC,CAAC;AACJ,CAAC"}

package/dist/texture/resolve.d.ts

@@ -0,0 +1,16 @@
+import type { BrandColors, Texture } from "../types.js";
+/**
+ * Fill in the colour a texture left open, from the palette it will be drawn
+ * over.
+ *
+ * A dot grid or a set of rules has to be the foreground colour by default,
+ * because that is the one colour known to contrast with the background: a
+ * fixed white would disappear on a light theme, which is a texture that
+ * silently does nothing. Grain has no colour to fill in, being noise.
+ *
+ * It happens here rather than while drawing so that the resolved config says
+ * what will actually be drawn, which is also what the rebuild stamp hashes: a
+ * palette change then re-renders the texture that follows it.
+ */
+export declare function resolveTexture(texture: Texture | undefined, colors: Required<BrandColors>): Texture | undefined;
+//# sourceMappingURL=resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/texture/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAExD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,GAC5B,OAAO,GAAG,SAAS,CAMrB"}

package/dist/texture/resolve.js

@@ -0,0 +1,20 @@
+/**
+ * Fill in the colour a texture left open, from the palette it will be drawn
+ * over.
+ *
+ * A dot grid or a set of rules has to be the foreground colour by default,
+ * because that is the one colour known to contrast with the background: a
+ * fixed white would disappear on a light theme, which is a texture that
+ * silently does nothing. Grain has no colour to fill in, being noise.
+ *
+ * It happens here rather than while drawing so that the resolved config says
+ * what will actually be drawn, which is also what the rebuild stamp hashes: a
+ * palette change then re-renders the texture that follows it.
+ */
+export function resolveTexture(texture, colors) {
+    if (texture === undefined || texture.type === "grain") {
+        return texture;
+    }
+    return { color: colors.foreground, ...texture };
+}
+//# sourceMappingURL=resolve.js.map

package/dist/texture/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../src/texture/resolve.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAC5B,OAA4B,EAC5B,MAA6B;IAE7B,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QACtD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,GAAG,OAAO,EAAE,CAAC;AAClD,CAAC"}

package/dist/theme/index.d.ts

@@ -0,0 +1,27 @@
+import type { BrandColors, ColophonConfig, ThemeName } from "../types.js";
+export { themeNames } from "./presets.js";
+/**
+ * The palette a theme brings, or `undefined` where there is no theme.
+ *
+ * It is what a partial override merges over, so that a size asking for one
+ * darker shade keeps the rest of the look rather than dropping back to the
+ * neutral default palette.
+ */
+export declare function themePalette(theme: ThemeName | undefined): Required<BrandColors> | undefined;
+/**
+ * Fill in the fields a theme supplies and the config did not name.
+ *
+ * A theme is applied by merging rather than by resolving, so that everything
+ * downstream sees an ordinary config and nothing else in the package has to
+ * know that themes exist. Whatever the config sets wins, field by field: this
+ * is `colors`, `background` and `texture` as defaults, not as a look that
+ * cannot be argued with.
+ *
+ * The consequence worth knowing is that a config naming its own `colors`
+ * alongside a theme keeps the theme's background as it was written, so the
+ * accent colour changes and the picture behind it does not. That follows from
+ * the merge, and it is the honest reading of a theme: the background is part
+ * of the look rather than something derived from the palette.
+ */
+export declare function applyTheme(config: ColophonConfig): ColophonConfig;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/theme/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG1E,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,GAAG,SAAS,GAC3B,QAAQ,CAAC,WAAW,CAAC,GAAG,SAAS,CAEnC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAcjE"}