cloving 1.2.0 → 1.3.0

package/dist/src/phone/phone-link.js

@@ -0,0 +1,21 @@
+export function parsePhoneLink(text) {
+    if (text === undefined)
+        return undefined;
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const filled = (name) => {
+        const field = Reflect.get(value, name);
+        return typeof field === "string" && field !== "" ? field : undefined;
+    };
+    const daemonId = filled("daemonId");
+    const origin = filled("origin");
+    const token = filled("token");
+    const registeredAt = filled("registeredAt");
+    if (daemonId === undefined ||
+        origin === undefined ||
+        token === undefined ||
+        registeredAt === undefined)
+        return undefined;
+    return { daemonId, origin, token, registeredAt };
+}

package/dist/src/phone/qr-data.d.ts

@@ -0,0 +1,8 @@
+export declare function qrVersion(byteCount: number): number;
+export declare function qrDataCodewords(bytes: Uint8Array, version: number): number[];
+export declare function qrCorrection(data: readonly number[], degree: number): number[];
+export interface QrCodewords {
+    readonly version: number;
+    readonly codewords: readonly number[];
+}
+export declare function qrCodewords(text: string): QrCodewords;

package/dist/src/phone/qr-data.js

@@ -0,0 +1,133 @@
+const layouts = [
+    { correctionCodewords: 10, groups: [{ count: 1, dataCodewords: 16 }] },
+    { correctionCodewords: 16, groups: [{ count: 1, dataCodewords: 28 }] },
+    { correctionCodewords: 26, groups: [{ count: 1, dataCodewords: 44 }] },
+    { correctionCodewords: 18, groups: [{ count: 2, dataCodewords: 32 }] },
+    { correctionCodewords: 24, groups: [{ count: 2, dataCodewords: 43 }] },
+    { correctionCodewords: 16, groups: [{ count: 4, dataCodewords: 27 }] },
+    { correctionCodewords: 18, groups: [{ count: 4, dataCodewords: 31 }] },
+    {
+        correctionCodewords: 22,
+        groups: [
+            { count: 2, dataCodewords: 38 },
+            { count: 2, dataCodewords: 39 },
+        ],
+    },
+    {
+        correctionCodewords: 22,
+        groups: [
+            { count: 3, dataCodewords: 36 },
+            { count: 2, dataCodewords: 37 },
+        ],
+    },
+    {
+        correctionCodewords: 26,
+        groups: [
+            { count: 4, dataCodewords: 43 },
+            { count: 1, dataCodewords: 44 },
+        ],
+    },
+];
+function multiply(left, right) {
+    let product = 0;
+    for (let bit = 7; bit >= 0; bit -= 1) {
+        product = (product << 1) ^ ((product >>> 7) * 0x11d);
+        product ^= ((right >>> bit) & 1) * left;
+    }
+    return product;
+}
+function layoutOf(version) {
+    const layout = layouts[version - 1];
+    if (layout === undefined)
+        throw new Error("qr-version-unsupported");
+    return layout;
+}
+function dataCapacity(version) {
+    return layoutOf(version).groups.reduce((total, group) => total + group.count * group.dataCodewords, 0);
+}
+function countBits(version) {
+    return version < 10 ? 8 : 16;
+}
+export function qrVersion(byteCount) {
+    const version = layouts.findIndex((_, index) => 4 + countBits(index + 1) + 8 * byteCount <= 8 * dataCapacity(index + 1));
+    if (version < 0)
+        throw new Error("qr-text-too-long");
+    return version + 1;
+}
+function bitStream(bytes, version) {
+    const bits = [];
+    const append = (value, length) => {
+        for (let shift = length - 1; shift >= 0; shift -= 1)
+            bits.push((value >>> shift) & 1);
+    };
+    append(0b0100, 4);
+    append(bytes.length, countBits(version));
+    for (const byte of bytes)
+        append(byte, 8);
+    append(0, Math.min(4, 8 * dataCapacity(version) - bits.length));
+    append(0, (8 - (bits.length % 8)) % 8);
+    return bits;
+}
+export function qrDataCodewords(bytes, version) {
+    const bits = bitStream(bytes, version);
+    const codewords = [];
+    for (let start = 0; start < bits.length; start += 8)
+        codewords.push(bits.slice(start, start + 8).reduce((byte, bit) => (byte << 1) | bit, 0));
+    for (let index = 0; codewords.length < dataCapacity(version); index += 1)
+        codewords.push(index % 2 === 0 ? 0xec : 0x11);
+    return codewords;
+}
+function divisor(degree) {
+    let coefficients = [...Array.from({ length: degree - 1 }, () => 0), 1];
+    let root = 1;
+    for (let step = 0; step < degree; step += 1) {
+        const previous = coefficients;
+        coefficients = previous.map((value, index) => multiply(value, root) ^ (previous[index + 1] ?? 0));
+        root = multiply(root, 0x02);
+    }
+    return coefficients;
+}
+export function qrCorrection(data, degree) {
+    const coefficients = divisor(degree);
+    let remainder = Array.from({ length: degree }, () => 0);
+    for (const codeword of data) {
+        const [first, ...rest] = remainder;
+        const factor = codeword ^ Number(first);
+        remainder = [...rest, 0].map((value, index) => value ^ multiply(Number(coefficients[index]), factor));
+    }
+    return remainder;
+}
+function blocks(data, version) {
+    const result = [];
+    let start = 0;
+    for (const group of layoutOf(version).groups)
+        for (let block = 0; block < group.count; block += 1) {
+            result.push(data.slice(start, start + group.dataCodewords));
+            start += group.dataCodewords;
+        }
+    return result;
+}
+function interleaved(columns) {
+    const longest = Math.max(...columns.map((column) => column.length));
+    const result = [];
+    for (let index = 0; index < longest; index += 1)
+        for (const column of columns) {
+            const value = column[index];
+            if (value !== undefined)
+                result.push(value);
+        }
+    return result;
+}
+export function qrCodewords(text) {
+    const bytes = new TextEncoder().encode(text);
+    const version = qrVersion(bytes.length);
+    const dataBlocks = blocks(qrDataCodewords(bytes, version), version);
+    const degree = layoutOf(version).correctionCodewords;
+    return {
+        version,
+        codewords: [
+            ...interleaved(dataBlocks),
+            ...interleaved(dataBlocks.map((block) => qrCorrection(block, degree))),
+        ],
+    };
+}

package/dist/src/phone/qr-matrix.d.ts

@@ -0,0 +1,6 @@
+export interface QrSymbol {
+    readonly version: number;
+    readonly mask: number;
+    readonly modules: readonly (readonly boolean[])[];
+}
+export declare function qrMatrix(text: string): QrSymbol;

package/dist/src/phone/qr-matrix.js

@@ -0,0 +1,175 @@
+import { qrCodewords } from "./qr-data.js";
+import { qrPenalty } from "./qr-penalty.js";
+const alignmentCenters = [
+    [],
+    [6, 18],
+    [6, 22],
+    [6, 26],
+    [6, 30],
+    [6, 34],
+    [6, 22, 38],
+    [6, 24, 42],
+    [6, 26, 46],
+    [6, 28, 50],
+];
+const masks = [
+    (row, column) => (row + column) % 2 === 0,
+    (row) => row % 2 === 0,
+    (_, column) => column % 3 === 0,
+    (row, column) => (row + column) % 3 === 0,
+    (row, column) => (Math.floor(row / 2) + Math.floor(column / 3)) % 2 === 0,
+    (row, column) => ((row * column) % 2) + ((row * column) % 3) === 0,
+    (row, column) => (((row * column) % 2) + ((row * column) % 3)) % 2 === 0,
+    (row, column) => (((row + column) % 2) + ((row * column) % 3)) % 2 === 0,
+];
+function grid(size) {
+    return Array.from({ length: size }, () => Array.from({ length: size }, () => false));
+}
+function mark(canvas, place) {
+    const [row, column, dark] = place;
+    const modules = canvas.modules[row];
+    const reserved = canvas.reserved[row];
+    if (modules === undefined || reserved === undefined)
+        return;
+    if (column < 0 || column >= canvas.size)
+        return;
+    modules[column] = dark;
+    reserved[column] = true;
+}
+function finder(canvas, corner) {
+    const [top, left] = corner;
+    for (let row = -1; row <= 7; row += 1)
+        for (let column = -1; column <= 7; column += 1) {
+            const distance = Math.max(Math.abs(row - 3), Math.abs(column - 3));
+            mark(canvas, [top + row, left + column, distance !== 2 && distance < 4]);
+        }
+}
+function alignment(canvas, center) {
+    const [top, left] = center;
+    for (let row = -2; row <= 2; row += 1)
+        for (let column = -2; column <= 2; column += 1)
+            mark(canvas, [
+                top + row,
+                left + column,
+                Math.max(Math.abs(row), Math.abs(column)) !== 1,
+            ]);
+}
+function functionPatterns(canvas, version) {
+    const last = canvas.size - 7;
+    for (let index = 8; index < canvas.size - 8; index += 1) {
+        mark(canvas, [6, index, index % 2 === 0]);
+        mark(canvas, [index, 6, index % 2 === 0]);
+    }
+    finder(canvas, [0, 0]);
+    finder(canvas, [0, last]);
+    finder(canvas, [last, 0]);
+    const centers = alignmentCenters[version - 1] ?? [];
+    const final = centers.length - 1;
+    centers.forEach((row, rowIndex) => {
+        centers.forEach((column, columnIndex) => {
+            const corner = (rowIndex === 0 && (columnIndex === 0 || columnIndex === final)) ||
+                (rowIndex === final && columnIndex === 0);
+            if (!corner)
+                alignment(canvas, [row, column]);
+        });
+    });
+}
+function formatPlaces(size) {
+    const first = [
+        ...[0, 1, 2, 3, 4, 5, 7, 8].map((row) => [row, 8]),
+        ...[7, 5, 4, 3, 2, 1, 0].map((column) => [8, column]),
+    ];
+    const second = [
+        ...[0, 1, 2, 3, 4, 5, 6, 7].map((index) => [
+            8,
+            size - 1 - index,
+        ]),
+        ...[6, 5, 4, 3, 2, 1, 0].map((index) => [
+            size - 1 - index,
+            8,
+        ]),
+    ];
+    return [...first, ...second];
+}
+function formatBits(mask) {
+    let remainder = mask;
+    for (let step = 0; step < 10; step += 1)
+        remainder = (remainder << 1) ^ ((remainder >>> 9) * 0x537);
+    return ((mask << 10) | remainder) ^ 0x5412;
+}
+function versionBits(version) {
+    let remainder = version;
+    for (let step = 0; step < 12; step += 1)
+        remainder = (remainder << 1) ^ ((remainder >>> 11) * 0x1f25);
+    return (version << 12) | remainder;
+}
+function formatInformation(canvas, mask) {
+    const format = formatBits(mask);
+    formatPlaces(canvas.size).forEach(([row, column], index) => {
+        mark(canvas, [row, column, ((format >>> (index % 15)) & 1) === 1]);
+    });
+    mark(canvas, [canvas.size - 8, 8, true]);
+}
+function versionInformation(canvas, version) {
+    if (version < 7)
+        return;
+    const bits = versionBits(version);
+    for (let index = 0; index < 18; index += 1) {
+        const near = Math.floor(index / 3);
+        const far = canvas.size - 11 + (index % 3);
+        const dark = ((bits >>> index) & 1) === 1;
+        mark(canvas, [near, far, dark]);
+        mark(canvas, [far, near, dark]);
+    }
+}
+function columnPairs(size) {
+    const columns = [];
+    for (let right = size - 1; right >= 1; right -= 2) {
+        if (right === 6)
+            right = 5;
+        columns.push(right);
+    }
+    return columns;
+}
+function dataPlaces(canvas) {
+    return columnPairs(canvas.size).flatMap((right) => {
+        const upward = ((right + 1) & 2) === 0;
+        return Array.from({ length: canvas.size }, (_, step) => upward ? canvas.size - 1 - step : step)
+            .flatMap((row) => [right, right - 1].map((column) => [row, column]))
+            .filter(([row, column]) => canvas.reserved[row]?.[column] !== true);
+    });
+}
+function placeData(canvas, codewords) {
+    dataPlaces(canvas).forEach(([row, column], index) => {
+        const codeword = codewords[Math.floor(index / 8)] ?? 0;
+        const modules = canvas.modules[row];
+        if (modules !== undefined)
+            modules[column] = ((codeword >>> (7 - (index % 8))) & 1) === 1;
+    });
+}
+function masked(canvas, mask) {
+    const condition = masks[mask] ?? (() => false);
+    return canvas.modules.map((row, rowIndex) => Array.from({ length: row.length }, (_, column) => {
+        const dark = row[column] === true;
+        return canvas.reserved[rowIndex]?.[column] === true
+            ? dark
+            : dark !== condition(rowIndex, column);
+    }));
+}
+function maskedCanvas(canvas, mask) {
+    const candidate = { ...canvas, modules: masked(canvas, mask) };
+    formatInformation(candidate, mask);
+    return candidate;
+}
+export function qrMatrix(text) {
+    const { version, codewords } = qrCodewords(text);
+    const size = 17 + 4 * version;
+    const canvas = { size, modules: grid(size), reserved: grid(size) };
+    functionPatterns(canvas, version);
+    formatInformation(canvas, 0);
+    versionInformation(canvas, version);
+    placeData(canvas, codewords);
+    const penalties = masks.map((_, mask) => qrPenalty(maskedCanvas(canvas, mask).modules));
+    const mask = penalties.indexOf(Math.min(...penalties));
+    return { version, mask, modules: maskedCanvas(canvas, mask).modules };
+}

package/dist/src/phone/qr-penalty.d.ts

@@ -0,0 +1,3 @@
+type Line = readonly boolean[];
+export declare function qrPenalty(modules: readonly Line[]): number;
+export {};

package/dist/src/phone/qr-penalty.js

@@ -0,0 +1,67 @@
+function added(runs, length) {
+    runs.history.unshift(runs.history[0] === 0 ? length + runs.size : length);
+    runs.history.length = 7;
+}
+function finderLike(history) {
+    const at = (index) => history[index] ?? 0;
+    const unit = at(1);
+    const core = unit > 0 &&
+        [at(2), at(4), at(5)].every((run) => run === unit) &&
+        at(3) === unit * 3;
+    if (!core)
+        return 0;
+    return (Number(at(0) >= unit * 4 && at(6) >= unit) +
+        Number(at(6) >= unit * 4 && at(0) >= unit));
+}
+function lineScore(line) {
+    const runs = { size: line.length, history: [0, 0, 0, 0, 0, 0, 0] };
+    let score = 0;
+    let color = false;
+    let length = 0;
+    for (const dark of line) {
+        if (dark === color) {
+            length += 1;
+            score += length === 5 ? 3 : Number(length > 5);
+            continue;
+        }
+        added(runs, length);
+        if (!color)
+            score += finderLike(runs.history) * 40;
+        color = dark;
+        length = 1;
+    }
+    if (color) {
+        added(runs, length);
+        length = 0;
+    }
+    added(runs, length + line.length);
+    return score + finderLike(runs.history) * 40;
+}
+function blocks(modules) {
+    let score = 0;
+    modules.forEach((row, rowIndex) => {
+        const below = modules[rowIndex + 1];
+        for (let column = 0; column < row.length; column += 1) {
+            const dark = row[column];
+            const same = below !== undefined &&
+                dark === row[column + 1] &&
+                dark === below[column] &&
+                dark === below[column + 1];
+            if (same)
+                score += 3;
+        }
+    });
+    return score;
+}
+function balance(modules) {
+    const total = modules.length ** 2;
+    const dark = modules.flat().filter(Boolean).length;
+    return (10 *
+        (Math.floor((Math.abs(dark * 20 - total * 10) + total - 1) / total) - 1));
+}
+export function qrPenalty(modules) {
+    const columns = modules.map((_, column) => modules.map((row) => row[column] === true));
+    return ([...modules, ...columns].reduce((total, line) => total + lineScore(line), 0) +
+        blocks(modules) +
+        balance(modules));
+}

package/dist/src/phone/qr-picture.d.ts

@@ -0,0 +1,5 @@
+export interface QrPicture {
+    readonly size: number;
+    readonly path: string;
+}
+export declare function qrPicture(modules: readonly (readonly boolean[])[]): QrPicture;

package/dist/src/phone/qr-picture.js

@@ -0,0 +1,24 @@
+const quietZone = 4;
+function rowPath(row, top) {
+    let path = "";
+    let start = 0;
+    while (start < row.length) {
+        if (row[start] !== true) {
+            start += 1;
+            continue;
+        }
+        let end = start;
+        while (row[end] === true)
+            end += 1;
+        const width = String(end - start);
+        path += `M${String(start + quietZone)} ${String(top + quietZone)}h${width}v1h-${width}z`;
+        start = end;
+    }
+    return path;
+}
+export function qrPicture(modules) {
+    return {
+        size: modules.length + 2 * quietZone,
+        path: modules.map((row, top) => rowPath(row, top)).join(""),
+    };
+}