@johnhenry/sitefile 0.0.0-stage → 0.0.0

package/lib/src/build-args.js

@@ -0,0 +1,164 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { SitefileError } from './errors.js';
+import { parseYaml } from './yaml.js';
+const KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+ * Read build-arg values from a file, by extension:
+ *
+ * - `.json`: a flat object, `{"TITLE": "Docs", "PORT": 8080}`
+ * - `.yaml` / `.yml`: a flat mapping, `TITLE: Docs`
+ * - `.env` (or a file named `.env`, `.env.*`, `*.env`): `KEY=value` lines
+ *
+ * Values must be strings, numbers or booleans; they become strings and are
+ * checked against each ARG's declared type later, like `--build-arg`.
+ * `.env` files are parsed, never executed: no `$VAR` or `$(…)` expansion.
+ */
+export async function loadBuildArgFile(file) {
+    const kind = buildArgFileKind(file); // an unknown extension is a usage error, before any IO
+    let text;
+    try {
+        text = await readFile(file, 'utf8');
+    }
+    catch (e) {
+        throw new SitefileError('E_NOT_FOUND', `cannot read build-arg file '${file}'`, undefined, { cause: e });
+    }
+    const label = path.relative(process.cwd(), path.resolve(file)) || file;
+    if (kind === 'env')
+        return parseEnvFile(text, label);
+    let value;
+    if (kind === 'json') {
+        try {
+            value = JSON.parse(text.replace(/^/, ''));
+        }
+        catch (e) {
+            throw new SitefileError('E_DATA', `${label} is not valid JSON: ${e.message}`, undefined, { cause: e });
+        }
+    }
+    else {
+        value = parseYaml(text, label);
+    }
+    return flatScalars(value, label);
+}
+export function buildArgFileKind(file) {
+    const base = path.basename(file).toLowerCase();
+    if (base.endsWith('.json'))
+        return 'json';
+    if (base.endsWith('.yaml') || base.endsWith('.yml'))
+        return 'yaml';
+    if (base === '.env' || base.startsWith('.env.') || base.endsWith('.env'))
+        return 'env';
+    throw new SitefileError('E_USAGE', `--build-arg-file '${file}': unknown format (use a .json, .yaml, .yml or .env file)`);
+}
+function flatScalars(value, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new SitefileError('E_DATA', `${label}: build-arg files must contain a mapping of NAME: value`);
+    }
+    const out = Object.create(null);
+    for (const [key, v] of Object.entries(value)) {
+        if (!KEY_RE.test(key))
+            throw new SitefileError('E_DATA', `${label}: '${key}' is not a valid ARG name`);
+        if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')
+            out[key] = String(v);
+        else {
+            throw new SitefileError('E_DATA', `${label}: ${key} must be a string, number or boolean (ARGs can't hold ${v === null ? 'null' : Array.isArray(v) ? 'lists' : 'objects'})`);
+        }
+    }
+    return out;
+}
+/**
+ * `.env` syntax: one `KEY=value` per line, optional `export ` prefix, `#`
+ * comment lines and blank lines. Unquoted values are trimmed and a ` #` starts
+ * a comment; `'single'` quotes are literal; `"double"` quotes understand
+ * `\n \t \r \" \\` and may span lines. Nothing is expanded or executed.
+ */
+export function parseEnvFile(text, label) {
+    const out = Object.create(null);
+    const src = text.replace(/^/, '').replace(/\r\n?/g, '\n');
+    const err = (line, msg) => new SitefileError('E_DATA', msg, { file: label, line, column: 1 });
+    let i = 0;
+    let line = 1;
+    while (i < src.length) {
+        const nl = src.indexOf('\n', i);
+        const end = nl === -1 ? src.length : nl;
+        const raw = src.slice(i, end);
+        const trimmed = raw.trim();
+        const startLine = line;
+        if (trimmed === '' || trimmed.startsWith('#')) {
+            i = end + 1;
+            line++;
+            continue;
+        }
+        const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*/.exec(raw);
+        if (!m)
+            throw err(line, `expected KEY=value, got '${trimmed}'`);
+        let j = i + m[0].length;
+        let value;
+        const q = src[j];
+        if (q === "'" || q === '"') {
+            j++;
+            value = '';
+            let closed = false;
+            while (j < src.length) {
+                const c = src[j];
+                if (c === q) {
+                    closed = true;
+                    j++;
+                    break;
+                }
+                if (c === '\n')
+                    line++;
+                if (q === '"' && c === '\\' && j + 1 < src.length) {
+                    const n = src[j + 1];
+                    value += n === 'n' ? '\n' : n === 't' ? '\t' : n === 'r' ? '\r' : n;
+                    j += 2;
+                    continue;
+                }
+                value += c;
+                j++;
+            }
+            if (!closed)
+                throw err(startLine, `unterminated ${q} quote for ${m[1]}`);
+            const restEnd = src.indexOf('\n', j) === -1 ? src.length : src.indexOf('\n', j);
+            const rest = src.slice(j, restEnd).trim();
+            if (rest !== '' && !rest.startsWith('#'))
+                throw err(line, `unexpected text after the quoted value of ${m[1]}`);
+            i = restEnd + 1;
+        }
+        else {
+            value = src.slice(j, end).replace(/\s+#.*$/, '').trim();
+            i = end + 1;
+        }
+        line++;
+        out[m[1]] = value;
+    }
+    return out;
+}
+/**
+ * The CLI's build args: `--build-arg-file` files in order (later files win), then
+ * `--build-arg NAME=value` (or `NAME`, read from the environment), which win over files.
+ * Malformed flags are E_USAGE errors.
+ */
+export async function collectBuildArgs(files, flags, env = process.env) {
+    const out = {};
+    for (const file of files)
+        Object.assign(out, await loadBuildArgFile(file));
+    for (const kv of flags) {
+        const eq = kv.indexOf('=');
+        if (eq === -1) {
+            // --build-arg NAME: take the value from the environment, as Docker does.
+            if (!KEY_RE.test(kv))
+                throw new SitefileError('E_USAGE', `--build-arg expects NAME=value or NAME, got '${kv}'`);
+            const v = env[kv];
+            if (v === undefined)
+                throw new SitefileError('E_USAGE', `--build-arg ${kv}: environment variable ${kv} is not set`);
+            out[kv] = v;
+            continue;
+        }
+        if (eq === 0)
+            throw new SitefileError('E_USAGE', `--build-arg expects NAME=value, got '${kv}'`);
+        out[kv.slice(0, eq)] = kv.slice(eq + 1);
+    }
+    return out;
+}
+//# sourceMappingURL=build-args.js.map

package/lib/src/cache-limit.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Size limit for what Sitefile keeps under $SITEFILE_HOME (docs/CLI.md, "Cache size limit").
+ *
+ * EVICTABLE data is the TRANSFORM result cache (cache/transform), the compiled wasm module cache
+ * (cache/wasm, written by the Rust build only) and, in the image store, untagged images and blobs
+ * no tagged image uses. Tagged images and every blob they reference are never evicted.
+ *
+ * After a build, when the evictable bytes exceed the limit ($SITEFILE_CACHE_MAX, default 1 GiB,
+ * 0 = no limit), the least recently used items are deleted until it fits. Recency is the file's
+ * mtime, refreshed on every cache hit (atime is often disabled): a TRANSFORM entry, a .cwasm file,
+ * an untagged image's manifest blob. Nothing touched within the grace period is deleted (10 minutes
+ * for the pure caches, 1 hour for the image store and for temp files), so a concurrent build never
+ * loses what it is writing or has just written; writes are temp file + rename, and the store part
+ * runs under the store lock. The check is one directory listing per cache when under the limit.
+ *
+ * Kept byte-for-byte in step with rust/src/cache_limit.rs.
+ */
+export declare const CACHE_MAX_ENV = "SITEFILE_CACHE_MAX";
+export declare const DEFAULT_CACHE_MAX: number;
+/** Files touched more recently than this are never evicted from the pure caches. */
+export declare const CACHE_GRACE_MS: number;
+/** Temp files and image-store data get a longer grace (pulls and builds can take a while). */
+export declare const LONG_GRACE_MS: number;
+/** `1048576`, `512K`, `512M`, `1.5G`, `2GiB`, `1T` (binary units, case-insensitive); `0` = no limit. */
+export declare function parseSize(raw: string): number | undefined;
+/** A limit as it is shown: `unlimited`, `1GiB`, `512MiB`, `100KiB`, else bytes (`1000B`). */
+export declare function formatLimit(bytes: number): string;
+/** The limit from $SITEFILE_CACHE_MAX (unset or empty: the default). A bad value warns and uses the default. */
+export declare function cacheLimitFromEnv(env?: NodeJS.ProcessEnv, warn?: (m: string) => void): number;
+export interface CacheUsage {
+    readonly name: 'transform' | 'wasm' | 'store' | 'servers';
+    readonly path: string;
+    /** TRANSFORM entries, .cwasm modules, store blobs, server files. */
+    readonly items: number;
+    readonly bytes: number;
+    /** Bytes the size limit may delete (everything but tagged images' blobs and server state). */
+    readonly evictable: number;
+}
+export declare function cachePaths(home: string): Record<CacheUsage['name'], string>;
+/** Sizes per cache under `home` (for `cache du`). */
+export declare function cacheUsage(home: string): Promise<CacheUsage[]>;
+export interface EvictResult {
+    /** TRANSFORM entries, modules, images and stray blobs deleted. */
+    readonly items: number;
+    readonly bytes: number;
+    /** Evictable bytes before and after. */
+    readonly before: number;
+    readonly after: number;
+}
+/**
+ * Delete least recently used evictable data until it fits in `limit` bytes (0: no limit).
+ * Cheap when under the limit: one listing per cache directory, no file is read.
+ */
+export declare function enforceCacheLimit(home: string, limit: number, now?: number): Promise<EvictResult>;

package/lib/src/cache-limit.js

@@ -0,0 +1,239 @@
+import { lstat, readdir, readFile, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { Store } from './store.js';
+/**
+ * Size limit for what Sitefile keeps under $SITEFILE_HOME (docs/CLI.md, "Cache size limit").
+ *
+ * EVICTABLE data is the TRANSFORM result cache (cache/transform), the compiled wasm module cache
+ * (cache/wasm, written by the Rust build only) and, in the image store, untagged images and blobs
+ * no tagged image uses. Tagged images and every blob they reference are never evicted.
+ *
+ * After a build, when the evictable bytes exceed the limit ($SITEFILE_CACHE_MAX, default 1 GiB,
+ * 0 = no limit), the least recently used items are deleted until it fits. Recency is the file's
+ * mtime, refreshed on every cache hit (atime is often disabled): a TRANSFORM entry, a .cwasm file,
+ * an untagged image's manifest blob. Nothing touched within the grace period is deleted (10 minutes
+ * for the pure caches, 1 hour for the image store and for temp files), so a concurrent build never
+ * loses what it is writing or has just written; writes are temp file + rename, and the store part
+ * runs under the store lock. The check is one directory listing per cache when under the limit.
+ *
+ * Kept byte-for-byte in step with rust/src/cache_limit.rs.
+ */
+export const CACHE_MAX_ENV = 'SITEFILE_CACHE_MAX';
+export const DEFAULT_CACHE_MAX = 1024 ** 3;
+/** Files touched more recently than this are never evicted from the pure caches. */
+export const CACHE_GRACE_MS = 10 * 60_000;
+/** Temp files and image-store data get a longer grace (pulls and builds can take a while). */
+export const LONG_GRACE_MS = 60 * 60_000;
+const HEX64 = /^[0-9a-f]{64}$/;
+const UNITS = { '': 1, k: 1024, m: 1024 ** 2, g: 1024 ** 3, t: 1024 ** 4 };
+/** `1048576`, `512K`, `512M`, `1.5G`, `2GiB`, `1T` (binary units, case-insensitive); `0` = no limit. */
+export function parseSize(raw) {
+    const m = /^(\d+(?:\.\d+)?)\s*(?:([kmgt])(?:i?b)?|b)?$/i.exec(raw.trim());
+    if (!m)
+        return undefined;
+    const n = Math.floor(Number(m[1]) * (UNITS[(m[2] ?? '').toLowerCase()] ?? 1));
+    return Number.isSafeInteger(n) ? n : undefined;
+}
+/** A limit as it is shown: `unlimited`, `1GiB`, `512MiB`, `100KiB`, else bytes (`1000B`). */
+export function formatLimit(bytes) {
+    if (bytes === 0)
+        return 'unlimited';
+    for (const [u, n] of [['TiB', 1024 ** 4], ['GiB', 1024 ** 3], ['MiB', 1024 ** 2], ['KiB', 1024]]) {
+        if (bytes % n === 0)
+            return `${bytes / n}${u}`;
+    }
+    return `${bytes}B`;
+}
+/** The limit from $SITEFILE_CACHE_MAX (unset or empty: the default). A bad value warns and uses the default. */
+export function cacheLimitFromEnv(env = process.env, warn = () => { }) {
+    const raw = env[CACHE_MAX_ENV];
+    if (raw === undefined || raw.trim() === '')
+        return DEFAULT_CACHE_MAX;
+    const n = parseSize(raw);
+    if (n !== undefined)
+        return n;
+    warn(`${CACHE_MAX_ENV}='${raw}' is not a size (bytes, or a number with K, M, G or T; 0 for no limit); using ${formatLimit(DEFAULT_CACHE_MAX)}`);
+    return DEFAULT_CACHE_MAX;
+}
+async function files(dir) {
+    const names = await readdir(dir).catch(() => []);
+    const out = [];
+    for (const name of names.sort()) {
+        const file = path.join(dir, name);
+        const st = await lstat(file).catch(() => undefined);
+        if (st?.isFile())
+            out.push({ name, file, size: st.size, mtime: st.mtimeMs });
+    }
+    return out;
+}
+export function cachePaths(home) {
+    return {
+        transform: path.join(home, 'cache', 'transform'),
+        wasm: path.join(home, 'cache', 'wasm'),
+        store: path.join(home, 'blobs', 'sha256'),
+        servers: path.join(home, 'servers'),
+    };
+}
+class Model {
+    blobs = new Map();
+    roots = [];
+    /** Bytes in the model (all evictable). */
+    total = 0;
+    blob(key, f, grace) {
+        this.blobs.set(key, { file: f.file, size: f.size, mtime: f.mtime, grace, refs: 0, gone: false });
+        this.total += f.size;
+    }
+    root(r) {
+        this.roots.push(r);
+        this.total += r.size;
+        for (const k of r.refs) {
+            const b = this.blobs.get(k);
+            if (b)
+                b.refs++;
+        }
+    }
+}
+async function addTransform(m, dir) {
+    for (const f of await files(path.join(dir, 'blobs')))
+        m.blob(`t:${f.name}`, f, HEX64.test(f.name) ? CACHE_GRACE_MS : LONG_GRACE_MS);
+    let entries = 0;
+    for (const f of await files(path.join(dir, 'entries'))) {
+        if (!f.name.endsWith('.json') || f.name.startsWith('.')) {
+            m.blob(`t:entries/${f.name}`, f, LONG_GRACE_MS);
+            continue;
+        }
+        entries++;
+        let refs = [];
+        try {
+            const j = JSON.parse(await readFile(f.file, 'utf8'));
+            if (Array.isArray(j.files))
+                refs = j.files.flatMap((x) => (Array.isArray(x) && typeof x[1] === 'string' && HEX64.test(x[1]) ? [`t:${x[1]}`] : []));
+        }
+        catch {
+            /* damaged: an entry with no blobs */
+        }
+        m.root({ key: `t:entries/${f.name}`, file: f.file, size: f.size, mtime: f.mtime, grace: CACHE_GRACE_MS, refs: [...new Set(refs)] });
+    }
+    return entries;
+}
+async function addWasm(m, dir) {
+    let modules = 0;
+    for (const f of await files(dir)) {
+        const ok = f.name.endsWith('.cwasm') && HEX64.test(f.name.slice(0, -'.cwasm'.length));
+        if (ok)
+            modules++;
+        m.blob(`w:${f.name}`, f, ok ? CACHE_GRACE_MS : LONG_GRACE_MS);
+    }
+    return modules;
+}
+/** Adds the store's evictable part; returns [blob count, total bytes]. */
+async function addStore(m, store, dir) {
+    const all = await files(dir);
+    const view = await store.gcView();
+    for (const f of all)
+        if (!view.live.has(f.name))
+            m.blob(`s:${f.name}`, f, LONG_GRACE_MS);
+    for (const im of view.untagged) {
+        const manifest = m.blobs.get(`s:${im.id.slice(7)}`);
+        m.root({
+            key: `s:image/${im.id}`,
+            file: undefined,
+            size: 0,
+            mtime: manifest?.mtime ?? 0,
+            grace: LONG_GRACE_MS,
+            refs: [...new Set(im.blobs.filter((h) => !view.live.has(h)).map((h) => `s:${h}`))],
+            image: im.id,
+        });
+    }
+    return [all.length, all.reduce((a, f) => a + f.size, 0)];
+}
+async function sizeOf(dir) {
+    const f = await files(dir);
+    return [f.length, f.reduce((a, x) => a + x.size, 0)];
+}
+/** Sizes per cache under `home` (for `cache du`). */
+export async function cacheUsage(home) {
+    const p = cachePaths(home);
+    const t = new Model();
+    const entries = await addTransform(t, p.transform);
+    const w = new Model();
+    const modules = await addWasm(w, p.wasm);
+    const s = new Model();
+    const store = await Store.openExisting(home);
+    let storeItems = 0;
+    let storeBytes = 0;
+    if (store)
+        [storeItems, storeBytes] = await addStore(s, store, p.store);
+    const [serverItems, serverBytes] = await sizeOf(p.servers);
+    return [
+        { name: 'transform', path: p.transform, items: entries, bytes: t.total, evictable: t.total },
+        { name: 'wasm', path: p.wasm, items: modules, bytes: w.total, evictable: w.total },
+        { name: 'store', path: p.store, items: storeItems, bytes: storeBytes, evictable: s.total },
+        { name: 'servers', path: p.servers, items: serverItems, bytes: serverBytes, evictable: 0 },
+    ];
+}
+/**
+ * Delete least recently used evictable data until it fits in `limit` bytes (0: no limit).
+ * Cheap when under the limit: one listing per cache directory, no file is read.
+ */
+export async function enforceCacheLimit(home, limit, now = Date.now()) {
+    if (limit === 0)
+        return { items: 0, bytes: 0, before: 0, after: 0 };
+    const p = cachePaths(home);
+    // Upper bound first (it counts tagged images too): under the limit, nothing more to do.
+    let bound = 0;
+    for (const d of [path.join(p.transform, 'blobs'), path.join(p.transform, 'entries'), p.wasm, p.store])
+        bound += (await sizeOf(d))[1];
+    if (bound <= limit)
+        return { items: 0, bytes: 0, before: bound, after: bound };
+    const store = await Store.openExisting(home);
+    const run = async () => {
+        const m = new Model();
+        await addTransform(m, p.transform);
+        await addWasm(m, p.wasm);
+        if (store)
+            await addStore(m, store, p.store);
+        const before = m.total;
+        let items = 0;
+        const cands = [
+            ...m.roots.map((r) => ({ mtime: r.mtime, key: r.key, root: r })),
+            ...[...m.blobs].filter(([, b]) => b.refs === 0).map(([key, b]) => ({ mtime: b.mtime, key, blob: b })),
+        ];
+        cands.sort((a, b) => a.mtime - b.mtime || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+        const drop = async (b) => {
+            await rm(b.file, { force: true });
+            b.gone = true;
+            m.total -= b.size;
+        };
+        for (const c of cands) {
+            if (m.total <= limit)
+                break;
+            if (c.root) {
+                const r = c.root;
+                if (now - r.mtime < r.grace)
+                    continue;
+                if (r.image && store)
+                    await store.dropUntaggedLocked(r.image);
+                if (r.file)
+                    await rm(r.file, { force: true });
+                m.total -= r.size;
+                items++;
+                for (const k of r.refs) {
+                    const b = m.blobs.get(k);
+                    if (!b || b.gone)
+                        continue;
+                    b.refs--;
+                    if (b.refs === 0 && now - b.mtime >= b.grace)
+                        await drop(b);
+                }
+            }
+            else if (c.blob && !c.blob.gone && c.blob.refs === 0 && now - c.blob.mtime >= c.blob.grace) {
+                await drop(c.blob);
+                items++;
+            }
+        }
+        return { items, bytes: before - m.total, before, after: m.total };
+    };
+    return store ? store.withLock(run) : run();
+}
+//# sourceMappingURL=cache-limit.js.map

package/lib/src/casefold-data.d.ts

@@ -0,0 +1,2 @@
+export declare const CASEFOLD_UNICODE_VERSION = "17.0.0";
+export declare const CASEFOLD_RUNS: ReadonlyArray<readonly [number, number, number, number]>;

package/lib/src/casefold-data.js

@@ -0,0 +1,217 @@
+// GENERATED by tools/gen-casefold.mjs from CaseFolding-17.0.0.txt; do not edit.
+// Unicode simple case folding (status C and S): 1512 mappings in 209 runs
+// [start, end, delta, step]: c in start..=end with (c - start) % step == 0 folds to c + delta.
+export const CASEFOLD_UNICODE_VERSION = '17.0.0';
+// prettier-ignore
+export const CASEFOLD_RUNS = [
+    [65, 90, 32, 1],
+    [181, 181, 775, 1],
+    [192, 214, 32, 1],
+    [216, 222, 32, 1],
+    [256, 302, 1, 2],
+    [306, 310, 1, 2],
+    [313, 327, 1, 2],
+    [330, 374, 1, 2],
+    [376, 376, -121, 1],
+    [377, 381, 1, 2],
+    [383, 383, -268, 1],
+    [385, 385, 210, 1],
+    [386, 388, 1, 2],
+    [390, 390, 206, 1],
+    [391, 391, 1, 1],
+    [393, 394, 205, 1],
+    [395, 395, 1, 1],
+    [398, 398, 79, 1],
+    [399, 399, 202, 1],
+    [400, 400, 203, 1],
+    [401, 401, 1, 1],
+    [403, 403, 205, 1],
+    [404, 404, 207, 1],
+    [406, 406, 211, 1],
+    [407, 407, 209, 1],
+    [408, 408, 1, 1],
+    [412, 412, 211, 1],
+    [413, 413, 213, 1],
+    [415, 415, 214, 1],
+    [416, 420, 1, 2],
+    [422, 422, 218, 1],
+    [423, 423, 1, 1],
+    [425, 425, 218, 1],
+    [428, 428, 1, 1],
+    [430, 430, 218, 1],
+    [431, 431, 1, 1],
+    [433, 434, 217, 1],
+    [435, 437, 1, 2],
+    [439, 439, 219, 1],
+    [440, 440, 1, 1],
+    [444, 444, 1, 1],
+    [452, 452, 2, 1],
+    [453, 453, 1, 1],
+    [455, 455, 2, 1],
+    [456, 456, 1, 1],
+    [458, 458, 2, 1],
+    [459, 475, 1, 2],
+    [478, 494, 1, 2],
+    [497, 497, 2, 1],
+    [498, 500, 1, 2],
+    [502, 502, -97, 1],
+    [503, 503, -56, 1],
+    [504, 542, 1, 2],
+    [544, 544, -130, 1],
+    [546, 562, 1, 2],
+    [570, 570, 10795, 1],
+    [571, 571, 1, 1],
+    [573, 573, -163, 1],
+    [574, 574, 10792, 1],
+    [577, 577, 1, 1],
+    [579, 579, -195, 1],
+    [580, 580, 69, 1],
+    [581, 581, 71, 1],
+    [582, 590, 1, 2],
+    [837, 837, 116, 1],
+    [880, 882, 1, 2],
+    [886, 886, 1, 1],
+    [895, 895, 116, 1],
+    [902, 902, 38, 1],
+    [904, 906, 37, 1],
+    [908, 908, 64, 1],
+    [910, 911, 63, 1],
+    [913, 929, 32, 1],
+    [931, 939, 32, 1],
+    [962, 962, 1, 1],
+    [975, 975, 8, 1],
+    [976, 976, -30, 1],
+    [977, 977, -25, 1],
+    [981, 981, -15, 1],
+    [982, 982, -22, 1],
+    [984, 1006, 1, 2],
+    [1008, 1008, -54, 1],
+    [1009, 1009, -48, 1],
+    [1012, 1012, -60, 1],
+    [1013, 1013, -64, 1],
+    [1015, 1015, 1, 1],
+    [1017, 1017, -7, 1],
+    [1018, 1018, 1, 1],
+    [1021, 1023, -130, 1],
+    [1024, 1039, 80, 1],
+    [1040, 1071, 32, 1],
+    [1120, 1152, 1, 2],
+    [1162, 1214, 1, 2],
+    [1216, 1216, 15, 1],
+    [1217, 1229, 1, 2],
+    [1232, 1326, 1, 2],
+    [1329, 1366, 48, 1],
+    [4256, 4293, 7264, 1],
+    [4295, 4295, 7264, 1],
+    [4301, 4301, 7264, 1],
+    [5112, 5117, -8, 1],
+    [7296, 7296, -6222, 1],
+    [7297, 7297, -6221, 1],
+    [7298, 7298, -6212, 1],
+    [7299, 7300, -6210, 1],
+    [7301, 7301, -6211, 1],
+    [7302, 7302, -6204, 1],
+    [7303, 7303, -6180, 1],
+    [7304, 7304, 35267, 1],
+    [7305, 7305, 1, 1],
+    [7312, 7354, -3008, 1],
+    [7357, 7359, -3008, 1],
+    [7680, 7828, 1, 2],
+    [7835, 7835, -58, 1],
+    [7838, 7838, -7615, 1],
+    [7840, 7934, 1, 2],
+    [7944, 7951, -8, 1],
+    [7960, 7965, -8, 1],
+    [7976, 7983, -8, 1],
+    [7992, 7999, -8, 1],
+    [8008, 8013, -8, 1],
+    [8025, 8031, -8, 2],
+    [8040, 8047, -8, 1],
+    [8072, 8079, -8, 1],
+    [8088, 8095, -8, 1],
+    [8104, 8111, -8, 1],
+    [8120, 8121, -8, 1],
+    [8122, 8123, -74, 1],
+    [8124, 8124, -9, 1],
+    [8126, 8126, -7173, 1],
+    [8136, 8139, -86, 1],
+    [8140, 8140, -9, 1],
+    [8147, 8147, -7235, 1],
+    [8152, 8153, -8, 1],
+    [8154, 8155, -100, 1],
+    [8163, 8163, -7219, 1],
+    [8168, 8169, -8, 1],
+    [8170, 8171, -112, 1],
+    [8172, 8172, -7, 1],
+    [8184, 8185, -128, 1],
+    [8186, 8187, -126, 1],
+    [8188, 8188, -9, 1],
+    [8486, 8486, -7517, 1],
+    [8490, 8490, -8383, 1],
+    [8491, 8491, -8262, 1],
+    [8498, 8498, 28, 1],
+    [8544, 8559, 16, 1],
+    [8579, 8579, 1, 1],
+    [9398, 9423, 26, 1],
+    [11264, 11311, 48, 1],
+    [11360, 11360, 1, 1],
+    [11362, 11362, -10743, 1],
+    [11363, 11363, -3814, 1],
+    [11364, 11364, -10727, 1],
+    [11367, 11371, 1, 2],
+    [11373, 11373, -10780, 1],
+    [11374, 11374, -10749, 1],
+    [11375, 11375, -10783, 1],
+    [11376, 11376, -10782, 1],
+    [11378, 11378, 1, 1],
+    [11381, 11381, 1, 1],
+    [11390, 11391, -10815, 1],
+    [11392, 11490, 1, 2],
+    [11499, 11501, 1, 2],
+    [11506, 11506, 1, 1],
+    [42560, 42604, 1, 2],
+    [42624, 42650, 1, 2],
+    [42786, 42798, 1, 2],
+    [42802, 42862, 1, 2],
+    [42873, 42875, 1, 2],
+    [42877, 42877, -35332, 1],
+    [42878, 42886, 1, 2],
+    [42891, 42891, 1, 1],
+    [42893, 42893, -42280, 1],
+    [42896, 42898, 1, 2],
+    [42902, 42920, 1, 2],
+    [42922, 42922, -42308, 1],
+    [42923, 42923, -42319, 1],
+    [42924, 42924, -42315, 1],
+    [42925, 42925, -42305, 1],
+    [42926, 42926, -42308, 1],
+    [42928, 42928, -42258, 1],
+    [42929, 42929, -42282, 1],
+    [42930, 42930, -42261, 1],
+    [42931, 42931, 928, 1],
+    [42932, 42946, 1, 2],
+    [42948, 42948, -48, 1],
+    [42949, 42949, -42307, 1],
+    [42950, 42950, -35384, 1],
+    [42951, 42953, 1, 2],
+    [42955, 42955, -42343, 1],
+    [42956, 42970, 1, 2],
+    [42972, 42972, -42561, 1],
+    [42997, 42997, 1, 1],
+    [43888, 43967, -38864, 1],
+    [64261, 64261, 1, 1],
+    [65313, 65338, 32, 1],
+    [66560, 66599, 40, 1],
+    [66736, 66771, 40, 1],
+    [66928, 66938, 39, 1],
+    [66940, 66954, 39, 1],
+    [66956, 66962, 39, 1],
+    [66964, 66965, 39, 1],
+    [68736, 68786, 64, 1],
+    [68944, 68965, 32, 1],
+    [71840, 71871, 32, 1],
+    [93760, 93791, 32, 1],
+    [93856, 93880, 27, 1],
+    [125184, 125217, 34, 1],
+];
+//# sourceMappingURL=casefold-data.js.map