@hexpro/qr-code-studio 0.0.0-stage → 0.1.0

package/dist/design/validate.js

@@ -0,0 +1,986 @@
+/**
+ * Checking a design document.
+ *
+ * A design arrives from a file, a link or a form, so the checker assumes
+ * nothing about its shape and reports every problem it finds, each with the
+ * exact path to it and a message key, and never the offending value: a
+ * design's colours are harmless, but its name and caption are text a person
+ * typed, and an issue is the thing that gets pasted into a bug report.
+ *
+ * Problems with one obvious fix are fixed and reported as warnings, and the
+ * fixed design is returned:
+ *
+ * - keys the schema does not know are dropped (an entry's unknown parameters
+ *   too);
+ * - `light`, `logo`, a logo's `plate`, `frame` and `regions` left out mean
+ *   none, `output` and its colour space left out mean screen colour, and a
+ *   gradient's `space` left out means the symbol's;
+ * - an angle outside 0 to 360 is brought round into it;
+ * - a paint on a picture logo, which only icons take, is dropped, as is a
+ *   caption on a frame that has nowhere to put one;
+ * - embedded images nothing uses are dropped.
+ *
+ * A caption in a font the font registry does not hold is a warning and is
+ * kept as it is: the website registers a person's own fonts at runtime, so a
+ * design made there may name one that this registry has not been given yet,
+ * and the scene builder leaves such a caption out rather than set it in
+ * another font.
+ *
+ * Anything else is an error and the design comes back null. Region pairs
+ * that would not make a finder the strict reader finds are a warning: the
+ * design is valid, and the studio uses the warning to steer the choice.
+ */
+import { issue } from '../core/issue.js';
+import { parseColour } from '../render/colour.js';
+import { PNG_SIGNATURE } from '../render/png.js';
+import { createFontRegistry } from '../text/registry.js';
+import { base64Decode } from './base64.js';
+import { codePoints } from './caption.js';
+import { DESIGN_VERSION, LIMITS, MIN_QUIET_ZONE } from './document.js';
+import { moduleFamilyOf, regionPairConforms, ringKindOf } from './finder.js';
+import { paramProblem, resolveParams } from './params.js';
+/** A sentinel for a value that could not be checked into shape. */
+const BAD = Symbol('bad');
+const KEBAB = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+/** Keys from the file that may appear in an issue's path: short and plain. */
+const PLAIN_KEY = /^[A-Za-z][A-Za-z0-9_-]{0,31}$/;
+const VERSION_NAMES = Object.freeze({
+    qr: /^(?:[1-9]|[1-3][0-9]|40)$/,
+    micro: /^M[1-4]$/,
+    rmqr: /^R(?:7|9|11|13|15|17)x(?:27|43|59|77|99|139)$/,
+});
+const MASK_LIMIT = Object.freeze({ qr: 7, micro: 3, rmqr: 0 });
+/** The concentric kind each region role is, for the pair check. */
+const ROLE_KINDS = Object.freeze({
+    finder: 'concentric-7',
+    'sub-finder': 'concentric-5',
+    'corner-finder': 'corner-l',
+});
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function own(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+/** The position of the first control character other than those `allowed`, or -1. */
+function controlAt(text, allowed = []) {
+    for (let i = 0; i < text.length; i += 1) {
+        const unit = text.charCodeAt(i);
+        if ((unit < 0x20 || (unit >= 0x7f && unit < 0xa0)) && !allowed.includes(unit))
+            return i;
+    }
+    return -1;
+}
+class Checker {
+    registries;
+    issues = [];
+    errors = 0;
+    fontRegistry;
+    constructor(registries, fonts) {
+        this.registries = registries;
+        this.fontRegistry = fonts;
+    }
+    /** The fonts captions are checked against, the built-in family unless the caller gave some. */
+    get fonts() {
+        this.fontRegistry ??= createFontRegistry();
+        return this.fontRegistry;
+    }
+    error(code, path, params) {
+        this.errors += 1;
+        this.issues.push(issue(code, path, 'error', params));
+        return BAD;
+    }
+    warn(code, path, params) {
+        this.issues.push(issue(code, path, 'warning', params));
+    }
+    /** An object, with every key it is not allowed reported and dropped. */
+    record(value, path, allowed) {
+        if (!isRecord(value))
+            return this.error('design.issue.not-an-object', path);
+        let hidden = 0;
+        for (const key of Object.keys(value)) {
+            if (allowed.includes(key))
+                continue;
+            if (PLAIN_KEY.test(key))
+                this.warn('design.issue.unknown-key', [...path, key]);
+            else
+                hidden += 1;
+        }
+        if (hidden > 0)
+            this.warn('design.issue.unknown-key', path, { count: hidden });
+        return value;
+    }
+    number(value, path, range, code = 'design.issue.out-of-range') {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return this.error('design.issue.not-a-number', path);
+        if (range.integer === true && !Number.isInteger(value))
+            return this.error('design.issue.not-an-integer', path);
+        if ((range.min !== undefined && value < range.min) ||
+            (range.max !== undefined && value > range.max)) {
+            const params = {};
+            if (range.min !== undefined)
+                params.min = range.min;
+            if (range.max !== undefined)
+                params.max = range.max;
+            return this.error(code, path, params);
+        }
+        return value;
+    }
+    boolean(value, path) {
+        return typeof value === 'boolean' ? value : this.error('design.issue.not-a-boolean', path);
+    }
+    option(value, path, options) {
+        return typeof value === 'string' && options.includes(value)
+            ? value
+            : this.error('design.issue.invalid-option', path);
+    }
+    /** Brought round into 0 to 360 when it is outside, with a warning. */
+    angle(value, path) {
+        const checked = this.number(value, path, {});
+        if (checked === BAD)
+            return BAD;
+        if (checked >= 0 && checked < 360)
+            return checked;
+        this.warn('design.issue.angle-normalised', path);
+        return ((checked % 360) + 360) % 360;
+    }
+    ink(value, path) {
+        if (typeof value === 'string') {
+            try {
+                parseColour(value);
+                return value;
+            }
+            catch {
+                return this.error('design.issue.invalid-colour', path);
+            }
+        }
+        const record = this.record(value, path, ['srgb', 'cmyk']);
+        if (record === BAD)
+            return BAD;
+        let screen = BAD;
+        const srgb = record.srgb;
+        if (typeof srgb === 'string')
+            screen = this.ink(srgb, [...path, 'srgb']);
+        else
+            this.error('design.issue.invalid-colour', [...path, 'srgb']);
+        const cmyk = record.cmyk;
+        let print = BAD;
+        if (!Array.isArray(cmyk) || cmyk.length !== 4) {
+            this.error('design.issue.cmyk', [...path, 'cmyk']);
+        }
+        else {
+            const values = cmyk.map((part, i) => this.number(part, [...path, 'cmyk', i], { min: 0, max: 1 }));
+            if (!values.includes(BAD))
+                print = values;
+        }
+        if (screen === BAD || print === BAD)
+            return BAD;
+        return { srgb: screen, cmyk: print };
+    }
+    stops(value, path) {
+        if (!Array.isArray(value))
+            return this.error('design.issue.not-a-list', path);
+        if (value.length < 2 || value.length > LIMITS.stops) {
+            return this.error('design.issue.stop-count', path, { min: 2, max: LIMITS.stops });
+        }
+        const out = [];
+        let failed = false;
+        let previous = 0;
+        value.forEach((stop, i) => {
+            const at = [...path, i];
+            const record = this.record(stop, at, ['offset', 'ink']);
+            if (record === BAD) {
+                failed = true;
+                return;
+            }
+            const offset = this.number(record.offset, [...at, 'offset'], { min: 0, max: 1 });
+            const ink = this.ink(record.ink, [...at, 'ink']);
+            if (offset !== BAD && offset < previous) {
+                this.error('design.issue.stop-order', [...at, 'offset']);
+                failed = true;
+            }
+            if (offset === BAD || ink === BAD) {
+                failed = true;
+                return;
+            }
+            previous = offset;
+            out.push({ offset, ink });
+        });
+        return failed ? BAD : out;
+    }
+    space(record, path) {
+        if (!own(record, 'space')) {
+            this.warn('design.issue.filled-default', [...path, 'space']);
+            return 'symbol';
+        }
+        return this.option(record.space, [...path, 'space'], ['symbol', 'module']);
+    }
+    paint(value, path) {
+        if (!isRecord(value))
+            return this.error('design.issue.not-an-object', path);
+        const kind = this.option(value.kind, [...path, 'kind'], [
+            'solid',
+            'linear',
+            'radial',
+            'conic',
+            'entry',
+        ]);
+        if (kind === BAD)
+            return BAD;
+        const centre = { min: LIMITS.centre.min, max: LIMITS.centre.max };
+        switch (kind) {
+            case 'solid': {
+                this.record(value, path, ['kind', 'ink']);
+                const ink = this.ink(value.ink, [...path, 'ink']);
+                return ink === BAD ? BAD : { kind, ink };
+            }
+            case 'linear': {
+                this.record(value, path, ['kind', 'angle', 'stops', 'space']);
+                const angle = this.angle(value.angle, [...path, 'angle']);
+                const stops = this.stops(value.stops, [...path, 'stops']);
+                const space = this.space(value, path);
+                return angle === BAD || stops === BAD || space === BAD
+                    ? BAD
+                    : { kind, angle, stops, space };
+            }
+            case 'radial': {
+                this.record(value, path, ['kind', 'cx', 'cy', 'radius', 'stops', 'space']);
+                const cx = this.number(value.cx, [...path, 'cx'], centre);
+                const cy = this.number(value.cy, [...path, 'cy'], centre);
+                const radius = this.number(value.radius, [...path, 'radius'], LIMITS.radius);
+                const stops = this.stops(value.stops, [...path, 'stops']);
+                const space = this.space(value, path);
+                return cx === BAD || cy === BAD || radius === BAD || stops === BAD || space === BAD
+                    ? BAD
+                    : { kind, cx, cy, radius, stops, space };
+            }
+            case 'conic': {
+                this.record(value, path, ['kind', 'cx', 'cy', 'angle', 'stops', 'space']);
+                const cx = this.number(value.cx, [...path, 'cx'], centre);
+                const cy = this.number(value.cy, [...path, 'cy'], centre);
+                const angle = this.angle(value.angle, [...path, 'angle']);
+                const stops = this.stops(value.stops, [...path, 'stops']);
+                const space = this.space(value, path);
+                return cx === BAD || cy === BAD || angle === BAD || stops === BAD || space === BAD
+                    ? BAD
+                    : { kind, cx, cy, angle, stops, space };
+            }
+            case 'entry': {
+                this.record(value, path, ['kind', 'ref']);
+                const ref = this.ref(value.ref, [...path, 'ref'], this.registries.fills, 'fill');
+                return ref === BAD ? BAD : { kind, ref: ref.ref };
+            }
+        }
+    }
+    /** An entry reference: a registered id, and parameters that fit its schema. */
+    ref(value, path, registry, kind) {
+        const record = this.record(value, path, ['id', 'params']);
+        if (record === BAD)
+            return BAD;
+        const id = record.id;
+        const entry = typeof id === 'string' ? registry.get(id) : undefined;
+        if (entry === undefined) {
+            return this.error('design.issue.unknown-entry', [...path, 'id'], typeof id === 'string' && id.length <= 64 && KEBAB.test(id) ? { kind, id } : { kind });
+        }
+        if (!own(record, 'params'))
+            return { ref: { id: entry.id }, entry };
+        const params = this.record(record.params, [...path, 'params'], entry.params.map((p) => p.key));
+        if (params === BAD)
+            return BAD;
+        const kept = {};
+        let failed = false;
+        for (const schema of entry.params) {
+            if (!own(params, schema.key))
+                continue;
+            const problem = paramProblem(schema, params[schema.key]);
+            if (problem !== null) {
+                this.error(problem.code, [...path, 'params', schema.key], problem.params);
+                failed = true;
+            }
+            else
+                kept[schema.key] = params[schema.key];
+        }
+        if (failed)
+            return BAD;
+        return { ref: { id: entry.id, params: kept }, entry };
+    }
+    text(value, path, max) {
+        if (typeof value !== 'string')
+            return this.error('design.issue.not-text', path);
+        const length = codePoints(value);
+        if (length > max)
+            return this.error('design.issue.too-long', path, { length, max });
+        return value;
+    }
+}
+function checkSymbol(checker, value) {
+    const path = ['symbol'];
+    const record = checker.record(value, path, [
+        'symbology',
+        'ecLevel',
+        'boostEc',
+        'minVersion',
+        'maxVersion',
+        'mask',
+        'segmentation',
+    ]);
+    if (record === BAD)
+        return BAD;
+    let failed = false;
+    const symbology = record.symbology;
+    if (typeof symbology !== 'string' || symbology.length > 32 || !KEBAB.test(symbology)) {
+        checker.error('design.issue.symbology', [...path, 'symbology']);
+        return BAD;
+    }
+    const out = {
+        symbology,
+    };
+    if (own(record, 'ecLevel')) {
+        const level = checker.option(record.ecLevel, [...path, 'ecLevel'], [
+            'L',
+            'M',
+            'Q',
+            'H',
+        ]);
+        if (level === BAD)
+            failed = true;
+        else
+            out.ecLevel = level;
+    }
+    if (own(record, 'boostEc')) {
+        const boost = checker.boolean(record.boostEc, [...path, 'boostEc']);
+        if (boost === BAD)
+            failed = true;
+        else
+            out.boostEc = boost;
+    }
+    const versionName = VERSION_NAMES[symbology] ?? /^[A-Za-z0-9]{1,16}$/;
+    for (const key of ['minVersion', 'maxVersion']) {
+        if (!own(record, key))
+            continue;
+        const name = record[key];
+        if (typeof name !== 'string' || !versionName.test(name)) {
+            checker.error('design.issue.version-name', [...path, key]);
+            failed = true;
+        }
+        else
+            out[key] = name;
+    }
+    if (symbology === 'qr' && out.minVersion !== undefined && out.maxVersion !== undefined) {
+        if (Number(out.minVersion) > Number(out.maxVersion)) {
+            checker.error('design.issue.version-range', [...path, 'maxVersion']);
+            failed = true;
+        }
+    }
+    if (own(record, 'mask')) {
+        const mask = record.mask;
+        const limit = MASK_LIMIT[symbology] ?? 7;
+        if (mask === 'auto')
+            out.mask = 'auto';
+        else if (typeof mask !== 'number' || !Number.isInteger(mask) || mask < 0 || mask > limit) {
+            checker.error('design.issue.mask', [...path, 'mask'], { max: limit });
+            failed = true;
+        }
+        else
+            out.mask = mask;
+    }
+    if (own(record, 'segmentation')) {
+        const at = [...path, 'segmentation'];
+        const policy = checker.record(record.segmentation, at, ['kanji', 'eci']);
+        if (policy === BAD)
+            failed = true;
+        else {
+            const segmentation = {};
+            if (own(policy, 'kanji')) {
+                const kanji = checker.option(policy.kanji, [...at, 'kanji'], [
+                    'never',
+                    'when-smaller',
+                    'always',
+                ]);
+                if (kanji === BAD)
+                    failed = true;
+                else
+                    segmentation.kanji = kanji;
+            }
+            if (own(policy, 'eci')) {
+                const eci = checker.option(policy.eci, [...at, 'eci'], ['auto', 'never', 'utf-8']);
+                if (eci === BAD)
+                    failed = true;
+                else
+                    segmentation.eci = eci;
+            }
+            out.segmentation = segmentation;
+        }
+    }
+    return failed ? BAD : out;
+}
+function checkModules(checker, value) {
+    const path = ['modules'];
+    const record = checker.record(value, path, ['shape', 'paint', 'light']);
+    if (record === BAD)
+        return BAD;
+    const shape = own(record, 'shape')
+        ? checker.ref(record.shape, [...path, 'shape'], checker.registries.moduleShapes, 'module-shape')
+        : checker.error('design.issue.required', [...path, 'shape']);
+    const paint = own(record, 'paint')
+        ? checker.paint(record.paint, [...path, 'paint'])
+        : checker.error('design.issue.required', [...path, 'paint']);
+    let light = null;
+    if (!own(record, 'light'))
+        checker.warn('design.issue.filled-default', [...path, 'light']);
+    else if (record.light !== null) {
+        const at = [...path, 'light'];
+        const inner = checker.record(record.light, at, ['shape', 'paint']);
+        if (inner === BAD)
+            light = BAD;
+        else {
+            const lightShape = own(inner, 'shape')
+                ? checker.ref(inner.shape, [...at, 'shape'], checker.registries.moduleShapes, 'module-shape')
+                : checker.error('design.issue.required', [...at, 'shape']);
+            const lightPaint = own(inner, 'paint')
+                ? checker.paint(inner.paint, [...at, 'paint'])
+                : checker.error('design.issue.required', [...at, 'paint']);
+            light =
+                lightShape === BAD || lightPaint === BAD
+                    ? BAD
+                    : { shape: lightShape.ref, paint: lightPaint };
+        }
+    }
+    if (shape === BAD || paint === BAD || light === BAD)
+        return BAD;
+    return { shape: shape.ref, paint, light };
+}
+/** `family` is the module shape's, whose finder pairs the QR finder is held to. */
+function checkRegions(checker, value, family) {
+    const path = ['regions'];
+    if (value === undefined) {
+        checker.warn('design.issue.filled-default', path);
+        return {};
+    }
+    const roles = ['finder', 'sub-finder', 'corner-finder'];
+    const record = checker.record(value, path, roles);
+    if (record === BAD)
+        return BAD;
+    const out = {};
+    let failed = false;
+    for (const role of roles) {
+        if (!own(record, role))
+            continue;
+        const at = [...path, role];
+        const style = checker.record(record[role], at, ['outer', 'inner', 'outerPaint', 'innerPaint']);
+        if (style === BAD) {
+            failed = true;
+            continue;
+        }
+        const part = (key) => {
+            if (!own(style, key))
+                return checker.error('design.issue.required', [...at, key]);
+            const found = checker.ref(style[key], [...at, key], checker.registries.regionShapes, 'region-shape');
+            if (found === BAD)
+                return BAD;
+            if (found.entry.part !== key)
+                return checker.error('design.issue.region-part', [...at, key, 'id'], { part: key });
+            return found;
+        };
+        const outer = part('outer');
+        const inner = part('inner');
+        const outerPaint = own(style, 'outerPaint')
+            ? checker.paint(style.outerPaint, [...at, 'outerPaint'])
+            : undefined;
+        const innerPaint = own(style, 'innerPaint')
+            ? checker.paint(style.innerPaint, [...at, 'innerPaint'])
+            : undefined;
+        if (outer === BAD || inner === BAD || outerPaint === BAD || innerPaint === BAD) {
+            failed = true;
+            continue;
+        }
+        const kind = ROLE_KINDS[role];
+        for (const [name, found] of [
+            ['outer', outer],
+            ['inner', inner],
+        ]) {
+            // A centre has nothing to draw in the corner pattern.
+            if (name === 'inner' && kind === 'corner-l')
+                continue;
+            if (!found.entry.kinds.includes(kind)) {
+                checker.issues.push(issue('design.issue.region-kind', [...at, name], 'info', { kind }));
+            }
+        }
+        if ((kind === 'concentric-7' || kind === 'concentric-5') &&
+            // A ring of dots pairs with nothing as the QR finder, for a reason
+            // of its own, given with the symbology below.
+            !(kind === 'concentric-7' && ringKindOf(outer.entry) === 'dotted') &&
+            outer.entry.kinds.includes(kind) &&
+            inner.entry.kinds.includes(kind) &&
+            !regionPairConforms(outer.entry, resolveParams(outer.entry.params, outer.ref.params), inner.entry, resolveParams(inner.entry.params, inner.ref.params), kind, family)) {
+            checker.warn('design.issue.region-pair', at, { kind });
+        }
+        const styleOut = {
+            outer: outer.ref,
+            inner: inner.ref,
+        };
+        if (outerPaint !== undefined)
+            styleOut.outerPaint = outerPaint;
+        if (innerPaint !== undefined)
+            styleOut.innerPaint = innerPaint;
+        out[role] = styleOut;
+    }
+    return failed ? BAD : out;
+}
+function checkLogo(checker, value, assets) {
+    const path = ['logo'];
+    if (value === undefined) {
+        checker.warn('design.issue.filled-default', path);
+        return null;
+    }
+    if (value === null)
+        return null;
+    const record = checker.record(value, path, [
+        'source',
+        'size',
+        'clear',
+        'padding',
+        'plate',
+        'paint',
+    ]);
+    if (record === BAD)
+        return BAD;
+    let failed = false;
+    let source = null;
+    const sourceRecord = checker.record(record.source, [...path, 'source'], ['kind', 'id']);
+    if (sourceRecord === BAD)
+        failed = true;
+    else {
+        const kind = checker.option(sourceRecord.kind, [...path, 'source', 'kind'], [
+            'icon',
+            'asset',
+        ]);
+        const id = sourceRecord.id;
+        if (kind === BAD)
+            failed = true;
+        else if (kind === 'icon') {
+            if (typeof id === 'string' && checker.registries.icons.has(id))
+                source = { kind, id };
+            else {
+                checker.error('design.issue.unknown-entry', [...path, 'source', 'id'], typeof id === 'string' && id.length <= 64 && KEBAB.test(id)
+                    ? { kind: 'icon', id }
+                    : { kind: 'icon' });
+                failed = true;
+            }
+        }
+        else if (typeof id === 'string' && assets !== null && own(assets, id))
+            source = { kind, id };
+        else {
+            checker.error('design.issue.asset-missing', [...path, 'source', 'id']);
+            failed = true;
+        }
+    }
+    const size = checker.number(record.size, [...path, 'size'], LIMITS.logoSize);
+    const clear = checker.option(record.clear, [...path, 'clear'], ['none', 'box', 'shape']);
+    const padding = checker.number(record.padding, [...path, 'padding'], LIMITS.logoPadding);
+    let plate = null;
+    if (!own(record, 'plate'))
+        checker.warn('design.issue.filled-default', [...path, 'plate']);
+    else if (record.plate !== null) {
+        const at = [...path, 'plate'];
+        const plateRecord = checker.record(record.plate, at, ['paint', 'shape']);
+        if (plateRecord === BAD)
+            plate = BAD;
+        else {
+            const paint = checker.paint(plateRecord.paint, [...at, 'paint']);
+            const shape = checker.option(plateRecord.shape, [...at, 'shape'], [
+                'square',
+                'rounded',
+                'circle',
+            ]);
+            plate = paint === BAD || shape === BAD ? BAD : { paint, shape };
+        }
+    }
+    let paint;
+    if (own(record, 'paint')) {
+        if (source !== null && source.kind === 'asset')
+            checker.warn('design.issue.logo-paint-ignored', [...path, 'paint']);
+        else
+            paint = checker.paint(record.paint, [...path, 'paint']);
+    }
+    if (failed ||
+        source === null ||
+        size === BAD ||
+        clear === BAD ||
+        padding === BAD ||
+        plate === BAD ||
+        paint === BAD) {
+        return BAD;
+    }
+    return paint === undefined
+        ? { source, size, clear, padding, plate }
+        : { source, size, clear, padding, plate, paint };
+}
+function checkFrame(checker, value) {
+    const path = ['frame'];
+    if (value === undefined) {
+        checker.warn('design.issue.filled-default', path);
+        return null;
+    }
+    if (value === null)
+        return null;
+    const record = checker.record(value, path, ['ref', 'paint', 'text']);
+    if (record === BAD)
+        return BAD;
+    const ref = checker.ref(record.ref, [...path, 'ref'], checker.registries.frames, 'frame');
+    const paint = own(record, 'paint') ? checker.paint(record.paint, [...path, 'paint']) : undefined;
+    let text;
+    if (own(record, 'text') && ref !== BAD) {
+        const at = [...path, 'text'];
+        const limits = ref.entry.text;
+        if (limits === null)
+            checker.warn('design.issue.caption-unsupported', at);
+        else {
+            const textRecord = checker.record(record.text, at, ['content', 'fontId', 'paint']);
+            if (textRecord === BAD)
+                text = BAD;
+            else {
+                const content = checker.text(textRecord.content, [...at, 'content'], Math.min(limits.maxChars, LIMITS.caption));
+                let contentOk = content !== BAD;
+                if (content !== BAD) {
+                    const control = controlAt(content, [0x0a]);
+                    const lines = content.split('\n').length;
+                    if (control !== -1) {
+                        checker.error('design.issue.control-character', [...at, 'content'], {
+                            position: control,
+                        });
+                        contentOk = false;
+                    }
+                    else if (lines > limits.maxLines) {
+                        checker.error('design.issue.too-many-lines', [...at, 'content'], {
+                            lines,
+                            max: limits.maxLines,
+                        });
+                        contentOk = false;
+                    }
+                }
+                const fontId = textRecord.fontId;
+                const fontOk = typeof fontId === 'string' && fontId.length <= 64 && KEBAB.test(fontId);
+                if (!fontOk)
+                    checker.error('design.issue.font-id', [...at, 'fontId']);
+                else if (!checker.fonts.has(fontId))
+                    checker.warn('design.issue.font-unavailable', [...at, 'fontId']);
+                const textPaint = own(textRecord, 'paint')
+                    ? checker.paint(textRecord.paint, [...at, 'paint'])
+                    : undefined;
+                if (!contentOk || !fontOk || textPaint === BAD)
+                    text = BAD;
+                else {
+                    const caption = { content: content, fontId: fontId };
+                    text = textPaint === undefined ? caption : { ...caption, paint: textPaint };
+                }
+            }
+        }
+    }
+    if (ref === BAD || paint === BAD || text === BAD)
+        return BAD;
+    const out = { ref: ref.ref };
+    if (paint !== undefined)
+        out.paint = paint;
+    if (text !== undefined)
+        out.text = text;
+    return out;
+}
+function checkOutput(checker, value) {
+    const path = ['output'];
+    if (value === undefined) {
+        checker.warn('design.issue.filled-default', path);
+        return { colourSpace: 'srgb' };
+    }
+    const record = checker.record(value, path, ['sizeMm', 'sizeBasis', 'dpi', 'colourSpace']);
+    if (record === BAD)
+        return BAD;
+    const out = {
+        colourSpace: 'srgb',
+    };
+    let failed = false;
+    if (own(record, 'sizeMm')) {
+        const size = checker.number(record.sizeMm, [...path, 'sizeMm'], LIMITS.sizeMm);
+        if (size === BAD)
+            failed = true;
+        else
+            out.sizeMm = size;
+    }
+    if (own(record, 'sizeBasis')) {
+        const basis = checker.option(record.sizeBasis, [...path, 'sizeBasis'], [
+            'artwork',
+            'symbol',
+        ]);
+        if (basis === BAD)
+            failed = true;
+        else
+            out.sizeBasis = basis;
+    }
+    if (own(record, 'dpi')) {
+        const dpi = checker.number(record.dpi, [...path, 'dpi'], { ...LIMITS.dpi, integer: true });
+        if (dpi === BAD)
+            failed = true;
+        else
+            out.dpi = dpi;
+    }
+    if (!own(record, 'colourSpace'))
+        checker.warn('design.issue.filled-default', [...path, 'colourSpace']);
+    else {
+        const space = checker.option(record.colourSpace, [...path, 'colourSpace'], [
+            'srgb',
+            'cmyk',
+        ]);
+        if (space === BAD)
+            failed = true;
+        else
+            out.colourSpace = space;
+    }
+    return failed ? BAD : out;
+}
+/** The width and height a PNG's header gives, or null when the bytes are not a PNG. */
+function pngSize(bytes) {
+    if (bytes.length < 33)
+        return null;
+    for (let i = 0; i < 8; i += 1)
+        if (bytes[i] !== PNG_SIGNATURE[i])
+            return null;
+    // The first chunk must be IHDR, 13 bytes long.
+    const type = String.fromCharCode(bytes[12], bytes[13], bytes[14], bytes[15]);
+    if (type !== 'IHDR')
+        return null;
+    const read = (at) => ((bytes[at] << 24) |
+        (bytes[at + 1] << 16) |
+        (bytes[at + 2] << 8) |
+        bytes[at + 3]) >>>
+        0;
+    return { width: read(16), height: read(20) };
+}
+function checkAssets(checker, value) {
+    const path = ['assets'];
+    if (value === undefined)
+        return null;
+    if (!isRecord(value))
+        return checker.error('design.issue.not-an-object', path);
+    const ids = Object.keys(value);
+    if (ids.length > LIMITS.assets) {
+        return checker.error('design.issue.too-many-assets', path, {
+            count: ids.length,
+            max: LIMITS.assets,
+        });
+    }
+    const out = {};
+    let failed = false;
+    for (const id of ids) {
+        if (id.length > 32 || !KEBAB.test(id)) {
+            checker.error('design.issue.asset-id', PLAIN_KEY.test(id) ? [...path, id] : path);
+            failed = true;
+            continue;
+        }
+        const at = [...path, id];
+        const record = checker.record(value[id], at, ['png', 'width', 'height']);
+        if (record === BAD) {
+            failed = true;
+            continue;
+        }
+        const side = { min: 1, max: LIMITS.assetSide, integer: true };
+        const width = checker.number(record.width, [...at, 'width'], side);
+        const height = checker.number(record.height, [...at, 'height'], side);
+        const png = record.png;
+        let bytes = null;
+        if (typeof png !== 'string')
+            checker.error('design.issue.asset-encoding', [...at, 'png']);
+        else if (png.length > Math.ceil(LIMITS.assetBytes / 3) * 4) {
+            checker.error('design.issue.asset-too-large', [...at, 'png'], { max: LIMITS.assetBytes });
+        }
+        else {
+            bytes = base64Decode(png);
+            if (bytes === null)
+                checker.error('design.issue.asset-encoding', [...at, 'png']);
+        }
+        const size = bytes === null ? null : pngSize(bytes);
+        if (bytes !== null && size === null)
+            checker.error('design.issue.asset-not-png', [...at, 'png']);
+        if (size !== null &&
+            width !== BAD &&
+            height !== BAD &&
+            (size.width !== width || size.height !== height)) {
+            checker.error('design.issue.asset-mismatch', [...at, 'png']);
+            failed = true;
+        }
+        if (size === null || width === BAD || height === BAD) {
+            failed = true;
+            continue;
+        }
+        out[id] = { png: png, width, height };
+    }
+    return failed ? BAD : out;
+}
+/**
+ * Every problem at once. `design` is the input made valid where that is
+ * unambiguous, or null. `options.fonts` is where a caption's font is looked
+ * up, the built-in family by default: a contract addition, as for
+ * `buildScene`'s context.
+ */
+export function validateDesign(input, registries, options = {}) {
+    if (typeof registries !== 'object' || registries === null) {
+        throw new TypeError('validateDesign: registries is the design registries.');
+    }
+    if (typeof options !== 'object' || options === null) {
+        throw new TypeError('validateDesign: options is an object.');
+    }
+    const checker = new Checker(registries, options.fonts);
+    const top = [
+        'schema',
+        'version',
+        'symbol',
+        'quietZone',
+        'background',
+        'modules',
+        'regions',
+        'logo',
+        'frame',
+        'output',
+        'assets',
+        'name',
+    ];
+    if (!isRecord(input)) {
+        checker.error('design.issue.not-an-object', []);
+        return { design: null, issues: checker.issues };
+    }
+    if (input.schema !== 'qr-design') {
+        checker.error('design.issue.schema', ['schema']);
+        return { design: null, issues: checker.issues };
+    }
+    if (input.version !== DESIGN_VERSION) {
+        checker.error('design.issue.unsupported-version', ['version'], { supported: DESIGN_VERSION });
+        return { design: null, issues: checker.issues };
+    }
+    checker.record(input, [], top);
+    const symbol = own(input, 'symbol')
+        ? checkSymbol(checker, input.symbol)
+        : checker.error('design.issue.required', ['symbol']);
+    const quietZone = own(input, 'quietZone')
+        ? checker.number(input.quietZone, ['quietZone'], {
+            min: 0,
+            max: LIMITS.quietZone,
+            integer: true,
+        })
+        : checker.error('design.issue.required', ['quietZone']);
+    if (symbol !== BAD && quietZone !== BAD) {
+        const minimum = MIN_QUIET_ZONE[symbol.symbology];
+        if (minimum !== undefined && quietZone < minimum) {
+            checker.warn('design.issue.quiet-zone-small', ['quietZone'], { min: minimum });
+        }
+    }
+    let background = BAD;
+    if (!own(input, 'background'))
+        checker.error('design.issue.required', ['background']);
+    else
+        background = input.background === null ? null : checker.paint(input.background, ['background']);
+    const modules = own(input, 'modules')
+        ? checkModules(checker, input.modules)
+        : checker.error('design.issue.required', ['modules']);
+    const regions = checkRegions(checker, input.regions, modules === BAD ? 'square' : moduleFamilyOf(registries.moduleShapes.get(modules.shape.id)));
+    const assets = checkAssets(checker, input.assets);
+    const rawAssets = isRecord(input.assets) ? input.assets : null;
+    const logo = checkLogo(checker, input.logo, rawAssets);
+    const frame = checkFrame(checker, input.frame);
+    const output = checkOutput(checker, input.output);
+    let name;
+    if (own(input, 'name')) {
+        name = checker.text(input.name, ['name'], LIMITS.name);
+        if (name !== BAD && controlAt(name) !== -1)
+            name = checker.error('design.issue.control-character', ['name'], {
+                position: controlAt(name),
+            });
+    }
+    // Embedded images nothing refers to are dropped. Which image the logo
+    // names is read from the input, so this is reported with everything else
+    // even when the logo itself has a problem.
+    const named = isRecord(input.logo) && isRecord(input.logo.source) && input.logo.source.kind === 'asset'
+        ? input.logo.source.id
+        : undefined;
+    const keepUsed = (all) => {
+        if (all === null)
+            return null;
+        let kept = null;
+        for (const id of Object.keys(all)) {
+            if (id === named) {
+                kept ??= {};
+                kept[id] = all[id];
+            }
+            else
+                checker.warn('design.issue.unused-asset', ['assets', id]);
+        }
+        return kept;
+    };
+    const usedAssets = assets === BAD ? null : keepUsed(assets);
+    // A reader that traces the finder's sides (zxing-cpp, inside many phones)
+    // cannot trace a ring of dots, and loses a round ring at a slant; see
+    // `ringKind` in decode. Micro QR and rMQR draw their finder's ring square
+    // whatever the style, so this is a question for QR only.
+    const finderStyle = regions === BAD ? undefined : regions.finder;
+    const ringShape = finderStyle === undefined ? undefined : registries.regionShapes.get(finderStyle.outer.id);
+    if (ringShape !== undefined &&
+        ringShape.kinds.includes('concentric-7') &&
+        !(symbol !== BAD && (symbol.symbology === 'micro' || symbol.symbology === 'rmqr'))) {
+        const traced = ringKindOf(ringShape);
+        if (traced === 'dotted') {
+            checker.error('design.issue.ring-not-traceable', ['regions', 'finder', 'outer']);
+        }
+        else if (traced === 'round') {
+            checker.warn('design.issue.ring-round', ['regions', 'finder', 'outer']);
+        }
+    }
+    // What the scene builder will change on Micro QR and rMQR, said up front.
+    if (symbol !== BAD &&
+        regions !== BAD &&
+        (symbol.symbology === 'micro' || symbol.symbology === 'rmqr')) {
+        for (const role of ['finder', 'sub-finder', 'corner-finder']) {
+            const style = regions[role];
+            if (style === undefined)
+                continue;
+            // The finder keeps a styled centre; the smaller patterns are plain.
+            const plain = style.outer.id === 'square' &&
+                (role !== 'sub-finder' || style.inner.id === 'square-centre');
+            if (!plain)
+                checker.issues.push(issue('design.issue.region-corners', ['regions', role], 'info'));
+        }
+    }
+    if (symbol !== BAD &&
+        frame !== BAD &&
+        frame !== null &&
+        symbol.symbology === 'rmqr' &&
+        frame.ref.id !== 'none') {
+        checker.warn('design.issue.frame-unsupported', ['frame']);
+    }
+    if (checker.errors > 0 ||
+        symbol === BAD ||
+        quietZone === BAD ||
+        background === BAD ||
+        modules === BAD ||
+        regions === BAD ||
+        assets === BAD ||
+        logo === BAD ||
+        frame === BAD ||
+        output === BAD ||
+        name === BAD) {
+        return { design: null, issues: checker.issues };
+    }
+    const design = {
+        schema: 'qr-design',
+        version: 1,
+        symbol,
+        quietZone,
+        background,
+        modules,
+        regions,
+        logo,
+        frame,
+        output,
+        ...(usedAssets === null ? {} : { assets: usedAssets }),
+        ...(name === undefined ? {} : { name }),
+    };
+    return { design, issues: checker.issues };
+}
+//# sourceMappingURL=validate.js.map