@ideare/kit 0.0.0-stage → 0.1.0-next.0

package/dist/imports/unzip.d.ts

@@ -0,0 +1,32 @@
+import { type ImportEntry, type ImportMime, type ImportSkipReason } from "./folder.ts";
+export type UnzippedFile = {
+    path: string;
+    bytes: Uint8Array<ArrayBuffer>;
+    mime: ImportMime;
+};
+export type UnzipResult = {
+    files: UnzippedFile[];
+    skipped: (ImportEntry & {
+        reason: ImportSkipReason;
+        ext?: string;
+    })[];
+};
+/**
+ * A file's name as its owner typed it. fflate reads a name as Latin-1 unless the zip flags it as
+ * UTF-8, but macOS's zip and many others write UTF-8 without the flag, so "Café" would come out
+ * as "Café". When the bytes are valid UTF-8, they are UTF-8.
+ */
+export declare function zipName(name: string): string;
+/**
+ * The files of a zip that ideare reads, inflated as a stream with the limits held on the bytes
+ * that come out, whatever sizes the zip claims: one file stops at IMPORT_LIMITS.fileBytes, all of
+ * them at IMPORT_LIMITS.totalBytes, and at most IMPORT_LIMITS.files are kept, so a zip bomb costs
+ * the limits and no more. Nothing is written to disk, so a name like `../../x` reaches nowhere.
+ * Every file left out comes back in `skipped` with its reason, like planImport's. Throws when the
+ * bytes are not a zip, or a zip with no files.
+ *
+ * ponytail: files are kept in the zip's own order, so a zip with more than 200 readable files
+ * keeps its first 200 (planImport puts the guide and fonts first for a folder). Upgrade path: read
+ * the central directory first and sort it the same way.
+ */
+export declare function unzipImport(source: Uint8Array | AsyncIterable<Uint8Array>): Promise<UnzipResult>;

package/dist/imports/unzip.js

@@ -0,0 +1,128 @@
+import { Unzip, UnzipInflate } from "fflate";
+import { IMPORT_LIMITS, checkImportEntry, importPath, } from "./folder.js";
+/** Handed to the stream in slices this big, with a pause between them, so a page drawing a
+ *  progress bar keeps answering while a big zip opens. */
+const SLICE = 1024 * 1024;
+async function* slices(source) {
+    if (!(source instanceof Uint8Array)) {
+        yield* source;
+        return;
+    }
+    for (let at = 0; at < source.length; at += SLICE)
+        yield source.subarray(at, at + SLICE);
+}
+const pause = () => new Promise((resolve) => setTimeout(resolve, 0));
+const utf8 = new TextDecoder("utf-8", { fatal: true });
+/**
+ * A file's name as its owner typed it. fflate reads a name as Latin-1 unless the zip flags it as
+ * UTF-8, but macOS's zip and many others write UTF-8 without the flag, so "Café" would come out
+ * as "Café". When the bytes are valid UTF-8, they are UTF-8.
+ */
+export function zipName(name) {
+    const codes = Array.from(name, (char) => char.charCodeAt(0));
+    if (codes.every((code) => code < 0x80) || codes.some((code) => code > 0xff))
+        return name;
+    try {
+        return utf8.decode(Uint8Array.from(codes));
+    }
+    catch {
+        return name;
+    }
+}
+/**
+ * The files of a zip that ideare reads, inflated as a stream with the limits held on the bytes
+ * that come out, whatever sizes the zip claims: one file stops at IMPORT_LIMITS.fileBytes, all of
+ * them at IMPORT_LIMITS.totalBytes, and at most IMPORT_LIMITS.files are kept, so a zip bomb costs
+ * the limits and no more. Nothing is written to disk, so a name like `../../x` reaches nowhere.
+ * Every file left out comes back in `skipped` with its reason, like planImport's. Throws when the
+ * bytes are not a zip, or a zip with no files.
+ *
+ * ponytail: files are kept in the zip's own order, so a zip with more than 200 readable files
+ * keeps its first 200 (planImport puts the guide and fonts first for a folder). Upgrade path: read
+ * the central directory first and sort it the same way.
+ */
+export async function unzipImport(source) {
+    const result = { files: [], skipped: [] };
+    let total = 0;
+    let open = 0;
+    let failure = null;
+    let seen = 0;
+    const unzip = new Unzip((file) => {
+        seen++;
+        const path = importPath(zipName(file.name));
+        if (path.endsWith("/"))
+            return; // a folder entry: its files come on their own
+        const declared = file.originalSize ?? 1;
+        const check = checkImportEntry(path, declared);
+        const skip = (reason, size = declared, ext) => result.skipped.push({ path, size, reason, ...(ext ? { ext } : {}) });
+        // Unstarted files can still be fed: never let one reach fflate's default handler.
+        file.ondata = () => { };
+        if (!check.ok)
+            return skip(check.reason, declared, check.ext);
+        if (result.files.length + open >= IMPORT_LIMITS.files)
+            return skip("tooMany");
+        const chunks = [];
+        let size = 0;
+        let stopped = false;
+        open++;
+        const stop = (reason) => {
+            stopped = true;
+            open--;
+            file.terminate();
+            total -= size;
+            skip(reason, Math.max(size, declared));
+        };
+        file.ondata = (error, chunk, final) => {
+            if (stopped)
+                return;
+            if (error)
+                return stop("unreadable");
+            size += chunk.length;
+            total += chunk.length;
+            if (size > IMPORT_LIMITS.fileBytes)
+                return stop("tooBig");
+            if (total > IMPORT_LIMITS.totalBytes)
+                return stop("tooMuch");
+            chunks.push(chunk);
+            if (!final)
+                return;
+            open--;
+            if (size === 0)
+                return skip("empty", 0);
+            const bytes = new Uint8Array(size);
+            let at = 0;
+            for (const part of chunks) {
+                bytes.set(part, at);
+                at += part.length;
+            }
+            result.files.push({ path, bytes, mime: check.mime });
+        };
+        try {
+            file.start();
+        }
+        catch {
+            // A compression fflate can't read (LZMA, a password): that file only.
+            stopped = true;
+            open--;
+            skip("unreadable");
+        }
+    });
+    unzip.register(UnzipInflate);
+    try {
+        let previous = null;
+        for await (const chunk of slices(source)) {
+            if (previous)
+                unzip.push(previous);
+            previous = chunk;
+            await pause();
+        }
+        unzip.push(previous ?? new Uint8Array(0), true);
+    }
+    catch (error) {
+        failure = error instanceof Error ? error : new Error(String(error));
+    }
+    // A zip that breaks halfway still gives the files before the break.
+    if (seen === 0)
+        throw new Error(`This is not a zip, or it holds no files${failure ? ` (${failure.message})` : ""}.`);
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+export { VERSION } from "./version.ts";
+export { BRAND_SCHEMA_URL, BRAND_SCHEMA_VERSION, COLOR_ROLES, CONTACT_LINK_KINDS, FONT_ROLES, LINK_KINDS, LOCALES, brandJsonSchema, brandSchema, parseBrand, } from "./brand/schema.ts";
+export type { Brand, BrandCopy, BrandFont, BrandInput, BrandIssue, ColorRole, FontRole, LinkKind, Locale, Palette, ParseBrandResult, } from "./brand/schema.ts";
+export { contrast, formatRatio, luminance, normalizeHex, over, parseHex, toHex, } from "./color/wcag.ts";
+export { ensureContrast, fromOklch, isLight, onColor, toOklch } from "./color/contrast.ts";
+export type { ContrastFix, Oklch } from "./color/contrast.ts";
+export { CONTRAST_PAIRS, MOODS, generatePalette } from "./color/palette.ts";
+export type { Mood, PaletteSeed } from "./color/palette.ts";
+export { safeEqual, sign, verify, LIVE_IMAGE_PURPOSE, canonicalImageMessage, signImageUrl, verifyImageUrl, } from "./sign.ts";
+export { FONTSOURCE_CDN, FontLoadError, fetchFontResolver, fontFileName, fontsourceUrl, ideareFontUrl, } from "./text/fonts.ts";
+export type { FontFormat, FontKey, FontResolver, FontStyle } from "./text/fonts.ts";
+export { TextEngine, loadHarfbuzz } from "./text/engine.ts";
+export type { LoadedFont, Run, TextAlign, TextBlock, TextLayout, TextOverflow, TextVAlign, } from "./text/engine.ts";
+export { FONT_CATALOG } from "./fonts/catalog.ts";
+export { FONT_TAGS, catalogFont, catalogVersions, nearestWeight, pickFonts } from "./fonts/pick.ts";
+export type { CatalogFont, FontTag } from "./fonts/pick.ts";
+export { OFL_TEXT } from "./fonts/ofl.ts";
+export { aiProvenanceXmp, base64, isPng, itxtChunk, packIco, pngSize, readIco, sha256Hex, textChunk, withChunks, } from "./files/png.ts";
+export { BADGES, iconBody, iconMark, iconNames, initials, matchIcons, monogramMark, pathBounds, } from "./marks/draw.ts";
+export type { Badge } from "./marks/draw.ts";
+export { cleanMarkSvg, markBody, markSvg, parseMark } from "./marks/svg.ts";
+export type { MarkElement, MarkPaint, ParsedMark } from "./marks/svg.ts";
+export { FORMATS, SCENE_VERSION, layerSchema, parseScene, sceneSchema } from "./scene/schema.ts";
+export type * from "./scene/schema.ts";
+export { FILTER_BUDGET_PX, RENDERER_VERSION, createRenderCache, engineFor, renderScene, sceneRevision, } from "./scene/render.ts";
+export type { AssetResolver, LayerBox, RenderCache, RenderContext, RenderResult, SceneCheck, } from "./scene/render.ts";
+export { MIN_SIZE, SNAP_PX, boundsOf, centerOf, cornersOf, frameTransform, handlePoint, isCorner, localFrame, normalizeAngle, pageFrame, resizeFrame, rotatePoint, snapBox, snapGuides, turnAngle, unionOf, withHeight, } from "./scene/frame.ts";
+export type { Box, Guides, Handle, Point } from "./scene/frame.ts";
+export { DUPLICATE_OFFSET, MAX_PAGES, addLayer, addPage, alignLayers, distributeLayers, duplicateLayers, duplicatePage, findLayer, groupLayers, lockLayers, movePage, moveLayers, removeLayers, removePage, reorderLayers, resizeLayers, rotateLayers, scalePath, selectionFrame, setTextHeight, snapTargets, ungroupLayers, } from "./editor/operations.ts";
+export type { AlignMode, Edit, ZOrder } from "./editor/operations.ts";
+export { HISTORY_LIMIT, applyPatches, diffScenes, emptyHistory, endEditGroup, mergeScenes, rebaseHistory, recordEdit, redoEdit, undoEdit, } from "./editor/history.ts";
+export type { EditHistory, SceneMerge, ScenePatch } from "./editor/history.ts";
+export { POST_FORMATS, POST_TEMPLATES, POST_TEMPLATE_INFO, postTemplate, } from "./posts/templates.ts";
+export type { PostFormat, PostTemplateId, PostTemplateOptions } from "./posts/templates.ts";
+export { pixCode } from "./posts/pix.ts";
+export type { PixDetails } from "./posts/pix.ts";
+export { brandArt, fontFor, logoFragment } from "./scene/brand-art.ts";
+export type { BrandArt, LogoFragment, LogoTone, LogoVariant } from "./scene/brand-art.ts";
+export { qrMatrix, qrPath } from "./scene/qr.ts";
+export type { QrEcc } from "./scene/qr.ts";
+export type { Raster, Rasterizer } from "./files/raster.ts";
+export { GenerateRefusal, TARGETS, generate } from "./files/generate.ts";
+export type { CardPage, DerivedFile, GenerateOptions, TargetId } from "./files/generate.ts";
+export { brandMd, copyFor, headTags, ogAlt, promptMd, publicBrand, signatureHtml, slugOf, webManifest, } from "./files/docs.ts";
+export type { HeadOptions } from "./files/docs.ts";
+export { dtcgTokens, fontStack, fontsCss, registryTheme, tailwindCss, tokensCss, } from "./files/tokens.ts";
+export * as templates from "./files/templates.ts";
+export { check, summarize } from "./check/index.ts";
+export type { CheckContext, CheckFix, CheckLevel, CheckResult } from "./check/index.ts";
+export { DRAFT_FONT_PAIRS, DRAFT_LIMITS, draftBrand, draftFontFiles, draftParams, newDraftSeed, readDraftParams, } from "./draft/draft.ts";
+export type { DraftInput, DraftPicks } from "./draft/draft.ts";
+export { BANNED_WORDS, COPY_LIMITS, checkCopy } from "./check/copy.ts";
+export type { CopyField, CopyIssue } from "./check/copy.ts";
+export { oklabDistance } from "./color/contrast.ts";
+export { dpiChunk, pngChunk } from "./files/png.ts";
+export { IMPORT_LIMITS, IMPORT_MIMES, checkImportEntry, importPath, planImport, } from "./imports/folder.ts";
+export type { ImportCheck, ImportEntry, ImportMime, ImportPlan, ImportSkipReason, } from "./imports/folder.ts";
+export { unzipImport } from "./imports/unzip.ts";
+export type { UnzipResult, UnzippedFile } from "./imports/unzip.ts";

package/dist/index.js

@@ -0,0 +1,34 @@
+export { VERSION } from "./version.js";
+export { BRAND_SCHEMA_URL, BRAND_SCHEMA_VERSION, COLOR_ROLES, CONTACT_LINK_KINDS, FONT_ROLES, LINK_KINDS, LOCALES, brandJsonSchema, brandSchema, parseBrand, } from "./brand/schema.js";
+export { contrast, formatRatio, luminance, normalizeHex, over, parseHex, toHex, } from "./color/wcag.js";
+export { ensureContrast, fromOklch, isLight, onColor, toOklch } from "./color/contrast.js";
+export { CONTRAST_PAIRS, MOODS, generatePalette } from "./color/palette.js";
+export { safeEqual, sign, verify, LIVE_IMAGE_PURPOSE, canonicalImageMessage, signImageUrl, verifyImageUrl, } from "./sign.js";
+export { FONTSOURCE_CDN, FontLoadError, fetchFontResolver, fontFileName, fontsourceUrl, ideareFontUrl, } from "./text/fonts.js";
+export { TextEngine, loadHarfbuzz } from "./text/engine.js";
+export { FONT_CATALOG } from "./fonts/catalog.js";
+export { FONT_TAGS, catalogFont, catalogVersions, nearestWeight, pickFonts } from "./fonts/pick.js";
+export { OFL_TEXT } from "./fonts/ofl.js";
+export { aiProvenanceXmp, base64, isPng, itxtChunk, packIco, pngSize, readIco, sha256Hex, textChunk, withChunks, } from "./files/png.js";
+export { BADGES, iconBody, iconMark, iconNames, initials, matchIcons, monogramMark, pathBounds, } from "./marks/draw.js";
+export { cleanMarkSvg, markBody, markSvg, parseMark } from "./marks/svg.js";
+export { FORMATS, SCENE_VERSION, layerSchema, parseScene, sceneSchema } from "./scene/schema.js";
+export { FILTER_BUDGET_PX, RENDERER_VERSION, createRenderCache, engineFor, renderScene, sceneRevision, } from "./scene/render.js";
+export { MIN_SIZE, SNAP_PX, boundsOf, centerOf, cornersOf, frameTransform, handlePoint, isCorner, localFrame, normalizeAngle, pageFrame, resizeFrame, rotatePoint, snapBox, snapGuides, turnAngle, unionOf, withHeight, } from "./scene/frame.js";
+export { DUPLICATE_OFFSET, MAX_PAGES, addLayer, addPage, alignLayers, distributeLayers, duplicateLayers, duplicatePage, findLayer, groupLayers, lockLayers, movePage, moveLayers, removeLayers, removePage, reorderLayers, resizeLayers, rotateLayers, scalePath, selectionFrame, setTextHeight, snapTargets, ungroupLayers, } from "./editor/operations.js";
+export { HISTORY_LIMIT, applyPatches, diffScenes, emptyHistory, endEditGroup, mergeScenes, rebaseHistory, recordEdit, redoEdit, undoEdit, } from "./editor/history.js";
+export { POST_FORMATS, POST_TEMPLATES, POST_TEMPLATE_INFO, postTemplate, } from "./posts/templates.js";
+export { pixCode } from "./posts/pix.js";
+export { brandArt, fontFor, logoFragment } from "./scene/brand-art.js";
+export { qrMatrix, qrPath } from "./scene/qr.js";
+export { GenerateRefusal, TARGETS, generate } from "./files/generate.js";
+export { brandMd, copyFor, headTags, ogAlt, promptMd, publicBrand, signatureHtml, slugOf, webManifest, } from "./files/docs.js";
+export { dtcgTokens, fontStack, fontsCss, registryTheme, tailwindCss, tokensCss, } from "./files/tokens.js";
+export * as templates from "./files/templates.js";
+export { check, summarize } from "./check/index.js";
+export { DRAFT_FONT_PAIRS, DRAFT_LIMITS, draftBrand, draftFontFiles, draftParams, newDraftSeed, readDraftParams, } from "./draft/draft.js";
+export { BANNED_WORDS, COPY_LIMITS, checkCopy } from "./check/copy.js";
+export { oklabDistance } from "./color/contrast.js";
+export { dpiChunk, pngChunk } from "./files/png.js";
+export { IMPORT_LIMITS, IMPORT_MIMES, checkImportEntry, importPath, planImport, } from "./imports/folder.js";
+export { unzipImport } from "./imports/unzip.js";

package/dist/marks/draw.d.ts

@@ -0,0 +1,48 @@
+import type { LoadedFont, TextEngine } from "../text/engine.ts";
+/**
+ * Marks drawn by code (plan D7): a monogram in a shape, or an icon from Lucide matched by the
+ * business's words. Both cost nothing and never misspell the name. Icon marks come from an open
+ * set, so the studio labels them "not exclusive" (`source.kind: "icon"`).
+ */
+export declare const BADGES: readonly ["circle", "rounded", "square", "hexagon", "none"];
+export type Badge = (typeof BADGES)[number];
+/** The bounding box of absolute path data (control points included, so slightly generous). */
+export declare function pathBounds(d: string): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+/** Up to two initials: the first letters of the first two words that are not "de", "and" and the like. */
+export declare function initials(name: string, count?: number): string;
+/**
+ * A monogram: the initials outlined in the display font, centered on their ink (not their
+ * advance), inside a badge. With `badge: "none"` the letters take the fill color on their own.
+ */
+export declare function monogramMark(engine: TextEngine, font: LoadedFont, input: {
+    letters: string;
+    badge: Badge;
+    fill: string;
+    ink: string;
+    tracking?: number;
+}): string;
+export declare function iconNames(): string[];
+/** The inner markup of a 24 px Lucide icon, or undefined for a name outside the curated set. */
+export declare function iconBody(name: string): string | undefined;
+/**
+ * An icon mark: the Lucide icon stroked in `ink` inside a badge filled with `fill`. With
+ * `badge: "none"` the icon is stroked in the fill color on its own.
+ */
+export declare function iconMark(name: string, input: {
+    badge: Badge;
+    fill: string;
+    ink: string;
+}): string;
+/**
+ * Icons ranked for a business, from its name, description and tagline in any of its languages.
+ * Longer keywords count twice, since they say more. When nothing matches, a few friendly general icons come back, so there is always something to try.
+ */
+export declare function matchIcons(text: string, limit?: number): {
+    name: string;
+    score: number;
+}[];

package/dist/marks/draw.js

@@ -0,0 +1,149 @@
+import { fmt } from "../text/engine.js";
+import { LUCIDE_ICONS } from "./icons.data.js";
+/**
+ * Marks drawn by code (plan D7): a monogram in a shape, or an icon from Lucide matched by the
+ * business's words. Both cost nothing and never misspell the name. Icon marks come from an open
+ * set, so the studio labels them "not exclusive" (`source.kind: "icon"`).
+ */
+export const BADGES = ["circle", "rounded", "square", "hexagon", "none"];
+/** The bounding box of absolute path data (control points included, so slightly generous). */
+export function pathBounds(d) {
+    const numbers = d.match(/-?(?:\d+\.?\d*|\.\d+)(?:e-?\d+)?/gi)?.map(Number) ?? [];
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i + 1 < numbers.length; i += 2) {
+        const x = numbers[i] ?? 0;
+        const y = numbers[i + 1] ?? 0;
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minY = Math.min(minY, y);
+        maxY = Math.max(maxY, y);
+    }
+    if (minX > maxX)
+        return { x: 0, y: 0, w: 0, h: 0 };
+    return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+}
+const STOP_WORDS = new Set([
+    "de",
+    "da",
+    "do",
+    "das",
+    "dos",
+    "e",
+    "y",
+    "the",
+    "and",
+    "of",
+    "la",
+    "el",
+    "los",
+    "las",
+    "&",
+    "a",
+    "o",
+]);
+/** Up to two initials: the first letters of the first two words that are not "de", "and" and the like. */
+export function initials(name, count = 2) {
+    const words = name
+        .split(/[\s\-_/.]+/)
+        .map((word) => word.replace(/[^\p{L}\p{N}]/gu, ""))
+        .filter((word) => word && !STOP_WORDS.has(word.toLowerCase()));
+    const letters = words.slice(0, count).map((word) => [...word][0] ?? "");
+    return (letters.join("") || [...name.trim()][0] || "?").toLocaleUpperCase();
+}
+function badgeShape(shape, fill) {
+    switch (shape) {
+        case "circle":
+            return `<circle cx="50" cy="50" r="50" fill="${fill}"/>`;
+        case "rounded":
+            return `<rect width="100" height="100" rx="22" fill="${fill}"/>`;
+        case "square":
+            return `<rect width="100" height="100" fill="${fill}"/>`;
+        case "hexagon":
+            return `<path d="M50 0L93.3 25V75L50 100L6.7 75V25Z" fill="${fill}"/>`;
+        case "none":
+            return "";
+    }
+}
+const SVG_OPEN = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">';
+/**
+ * A monogram: the initials outlined in the display font, centered on their ink (not their
+ * advance), inside a badge. With `badge: "none"` the letters take the fill color on their own.
+ */
+export function monogramMark(engine, font, input) {
+    const letters = input.letters.slice(0, 3);
+    const room = input.badge === "none" ? 92 : input.badge === "circle" ? 58 : 64;
+    // Measure at 100 px, then scale the ink box into the room.
+    const run = engine.shape(font, letters, 100, input.tracking ?? 0);
+    const raw = engine.runPath(font, run, 100, 0, 0);
+    const box = pathBounds(raw);
+    if (box.w === 0)
+        throw new TypeError(`The font has no glyphs for "${letters}"`);
+    const scale = Math.min(room / box.w, (room * 0.8) / box.h);
+    const size = 100 * scale;
+    const drawn = engine.runPath(font, engine.shape(font, letters, size, input.tracking ?? 0), size, 0, 0);
+    const ink = pathBounds(drawn);
+    const dx = 50 - (ink.x + ink.w / 2);
+    const dy = 50 - (ink.y + ink.h / 2);
+    const color = input.badge === "none" ? input.fill : input.ink;
+    return `${SVG_OPEN}${badgeShape(input.badge, input.fill)}<path transform="translate(${fmt(dx)} ${fmt(dy)})" d="${drawn}" fill="${color}"/></svg>`;
+}
+export function iconNames() {
+    return Object.keys(LUCIDE_ICONS);
+}
+/** The inner markup of a 24 px Lucide icon, or undefined for a name outside the curated set. */
+export function iconBody(name) {
+    return LUCIDE_ICONS[name.replace(/^lucide:/, "")]?.body;
+}
+/**
+ * An icon mark: the Lucide icon stroked in `ink` inside a badge filled with `fill`. With
+ * `badge: "none"` the icon is stroked in the fill color on its own.
+ */
+export function iconMark(name, input) {
+    const body = iconBody(name);
+    if (!body)
+        throw new TypeError(`"${name}" is not in the kit's icon set`);
+    const color = input.badge === "none" ? input.fill : input.ink;
+    const size = input.badge === "none" ? 88 : input.badge === "circle" ? 52 : 58;
+    const offset = (100 - size) / 2;
+    const scale = size / 24;
+    return `${SVG_OPEN}${badgeShape(input.badge, input.fill)}<g transform="translate(${fmt(offset)} ${fmt(offset)}) scale(${fmt(scale)})" fill="none" stroke="${color}" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">${body}</g></svg>`;
+}
+/** Lowercase, without accents, so "Padaria Pão" matches "padar" and "pao". */
+function plain(text) {
+    return ` ${text
+        .normalize("NFD")
+        .replace(/\p{M}/gu, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, " ")
+        .replace(/\s+/g, " ")} `;
+}
+const FALLBACK_ICONS = ["sparkles", "star", "heart", "store", "leaf", "sun"];
+/**
+ * Icons ranked for a business, from its name, description and tagline in any of its languages.
+ * Longer keywords count twice, since they say more. When nothing matches, a few friendly general icons come back, so there is always something to try.
+ */
+export function matchIcons(text, limit = 6) {
+    const haystack = plain(text);
+    const ranked = Object.entries(LUCIDE_ICONS)
+        .map(([name, { words }]) => {
+        let score = 0;
+        // A keyword matches the start of a word; one with a trailing space, the whole word.
+        for (const word of words)
+            if (haystack.includes(` ${word}`))
+                score += word.length >= 5 ? 2 : 1;
+        return { name, score };
+    })
+        .filter((entry) => entry.score > 0)
+        .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+        .slice(0, limit);
+    for (const name of FALLBACK_ICONS) {
+        if (ranked.length >= limit)
+            break;
+        if (!ranked.some((entry) => entry.name === name))
+            ranked.push({ name, score: 0 });
+    }
+    return ranked;
+}

package/dist/marks/icons.data.d.ts

@@ -0,0 +1,5 @@
+/** The inner markup of each 24 px Lucide icon (stroked, round caps) and the words that match it. */
+export declare const LUCIDE_ICONS: Record<string, {
+    body: string;
+    words: string[];
+}>;