@kecan0406/aninames 0.0.0-stage → 0.1.0

package/lib/client/format.js

@@ -0,0 +1,212 @@
+import { LAYERS } from "../model.js";
+import { flat } from "../text.js";
+import { compare } from "./order.js";
+export const FORMAT = 1;
+export const KEY_TABLES = ['flat', 'latin', 'sound', 'part', 'initial'];
+export const NAME_KINDS = [
+    'main',
+    'official',
+    'synonym',
+    'short',
+    'reading',
+    'redirect',
+    'section',
+    'generated',
+];
+export const TRUSTED = ['wikidata', 'aod', 'anidb', 'vndb'];
+export const CHARACTER = 1;
+export const MAIN = 2;
+export const ADULT = 4;
+export function present(layer) {
+    return 8 << LAYERS.indexOf(layer);
+}
+const HASH = /^[0-9a-f]{12}$/;
+export const HASH_LENGTH = 12;
+export function chunkPath(layer, table, hash) {
+    return `${layer}/${table}/${hash}.json.gz`;
+}
+const PATH = new RegExp(`^(${LAYERS.join('|')})/(${[...KEY_TABLES, 'entity'].join('|')})/([0-9a-f]{12})\\.json\\.gz$`);
+export function parsePath(path) {
+    const match = PATH.exec(path);
+    return match ? { layer: match[1], table: match[2], hash: match[3] } : undefined;
+}
+export function shared(a, b) {
+    const length = Math.min(a.length, b.length);
+    let at = 0;
+    while (at < length && a.charCodeAt(at) === b.charCodeAt(at))
+        at++;
+    const last = a.charCodeAt(at - 1);
+    return at > 0 && last >= 0xd800 && last <= 0xdbff ? at - 1 : at;
+}
+export function pack(keys, hashes, eids) {
+    const share = [];
+    const rest = [];
+    let previous = '';
+    for (const key of keys) {
+        const n = shared(previous, key);
+        share.push(n);
+        rest.push(key.slice(n));
+        previous = key;
+    }
+    const out = { share, rest, files: hashes.join('') };
+    if (eids)
+        out.eids = eids.map((eid, at) => eid - (at > 0 ? (eids[at - 1] ?? 0) : 0));
+    return out;
+}
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isCount = (value) => Number.isSafeInteger(value) && value >= 0;
+function bad(why) {
+    return new Error(`aninames: cannot read the manifest: ${why}`);
+}
+function unpack(value, where, numbered) {
+    if (!isObject(value))
+        throw bad(`${where} is missing`);
+    const { share, rest, files, eids } = value;
+    if (!Array.isArray(share) || !Array.isArray(rest) || typeof files !== 'string' || share.length !== rest.length)
+        throw bad(`${where} is malformed`);
+    if (files.length !== share.length * HASH_LENGTH)
+        throw bad(`${where} names ${files.length} hash characters`);
+    if (numbered && (!Array.isArray(eids) || eids.length !== share.length))
+        throw bad(`${where} has no entity numbers`);
+    const out = { bounds: [], files: [], eids: [] };
+    let previous = '';
+    let eid = 0;
+    for (let at = 0; at < share.length; at++) {
+        const n = share[at];
+        const tail = rest[at];
+        if (!isCount(n) || n > previous.length || typeof tail !== 'string')
+            throw bad(`${where} span ${at} is malformed`);
+        const key = previous.slice(0, n) + tail;
+        if (at > 0 && compare(previous, key) > 0)
+            throw bad(`${where} is out of order at span ${at}`);
+        const hash = files.slice(at * HASH_LENGTH, (at + 1) * HASH_LENGTH);
+        if (!HASH.test(hash))
+            throw bad(`${where} span ${at} has no file name`);
+        if (numbered) {
+            const delta = eids[at];
+            if (!isCount(delta) || (at > 0 && delta === 0))
+                throw bad(`${where} span ${at} has a bad entity number`);
+            eid += delta;
+            out.eids.push(eid);
+        }
+        out.bounds.push(key);
+        out.files.push(hash);
+        previous = key;
+    }
+    return out;
+}
+export function readManifest(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw bad('it is not JSON');
+    }
+    if (!isObject(value))
+        throw bad('it is not an object');
+    if (value.aninames !== FORMAT) {
+        throw new Error(`aninames: the manifest has format ${String(value.aninames)}, this library reads format ${FORMAT}; update @kecan0406/aninames`);
+    }
+    const built = typeof value.built === 'string' ? value.built : '';
+    if (!isObject(value.layers))
+        throw bad('it lists no layers');
+    const layers = new Map();
+    for (const layer of LAYERS) {
+        const tables = value.layers[layer];
+        if (tables === undefined)
+            continue;
+        if (!isObject(tables))
+            throw bad(`layer ${layer} is malformed`);
+        const keys = {};
+        for (const table of KEY_TABLES) {
+            const { bounds, files } = unpack(tables[table], `${layer}/${table}`, false);
+            keys[table] = { bounds, files };
+        }
+        layers.set(layer, { keys, entity: unpack(tables.entity, `${layer}/entity`, true) });
+    }
+    if (!layers.has('core'))
+        throw bad('it has no core layer');
+    return { built, layers };
+}
+export function manifestPaths(manifest) {
+    const paths = new Set();
+    for (const [layer, spans] of manifest.layers) {
+        for (const table of KEY_TABLES)
+            for (const hash of spans.keys[table].files)
+                paths.add(chunkPath(layer, table, hash));
+        for (const hash of spans.entity.files)
+            paths.add(chunkPath(layer, 'entity', hash));
+    }
+    return paths;
+}
+const isInt = (value) => Number.isSafeInteger(value);
+function keyRow(value) {
+    if (!Array.isArray(value) || value.length < 7)
+        return undefined;
+    const [key, eid, weight, flags, rank, standing, extra] = value;
+    if (typeof key !== 'string' || !isCount(eid))
+        return undefined;
+    if (!isInt(weight) || !isInt(flags) || !isInt(rank) || !isInt(standing) || !isInt(extra))
+        return undefined;
+    return [key, eid, weight, flags, rank, standing, extra];
+}
+function nameOf(value) {
+    if (!Array.isArray(value) || value.length < 4)
+        return undefined;
+    const [text, lang, kind, trust, qual] = value;
+    if (typeof text !== 'string' || (lang !== null && typeof lang !== 'string'))
+        return undefined;
+    const named = isCount(kind) ? NAME_KINDS[kind] : undefined;
+    if (!named || !isCount(trust))
+        return undefined;
+    if (qual !== undefined && qual !== null && typeof qual !== 'string')
+        return undefined;
+    return { text, lang, kind: named, trust, qual: qual ?? null, flat: flat(text) };
+}
+function list(value, item) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = [];
+    for (const entry of value) {
+        const read = item(entry);
+        if (read === undefined)
+            return undefined;
+        out.push(read);
+    }
+    return out;
+}
+const tagOf = (value) => Array.isArray(value) && typeof value[0] === 'string' && (value[1] === null || typeof value[1] === 'number')
+    ? [value[0], value[1]]
+    : undefined;
+const workOf = (value) => Array.isArray(value) && isCount(value[0]) && typeof value[1] === 'string' ? [value[0], value[1]] : undefined;
+const eidOf = (value) => (isCount(value) ? value : undefined);
+function entityRow(value) {
+    if (!Array.isArray(value) || value.length < 10)
+        return undefined;
+    const [eid, id, rawNames, rawTags, rawWorks, rawReach, rank, standing, extra, adult] = value;
+    if (!isCount(eid) || typeof id !== 'string')
+        return undefined;
+    const kind = id.startsWith('w/') ? 'work' : id.startsWith('c/') ? 'character' : undefined;
+    if (!kind || !isInt(rank) || !isInt(standing) || !isInt(extra))
+        return undefined;
+    const names = list(rawNames, nameOf);
+    const danbooru = list(rawTags, tagOf);
+    const works = list(rawWorks, workOf);
+    const reach = list(rawReach, eidOf);
+    if (!names || !danbooru || !works || !reach)
+        return undefined;
+    return { eid, id, kind, names, danbooru, works, reach, rank, standing, extra, adult: adult === 1 };
+}
+export function readRows(table, value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const read = table === 'entity' ? entityRow : keyRow;
+    const rows = [];
+    for (const row of value) {
+        const decoded = read(row);
+        if (decoded)
+            rows.push(decoded);
+    }
+    return rows;
+}

package/lib/client/index.d.ts

@@ -0,0 +1,3 @@
+export type { Kind, Layer } from '../model.ts';
+export { type Found, Names } from './names.ts';
+export { cachedSource, fileSource, httpSource, type Source } from './source.ts';

package/lib/client/index.js

@@ -0,0 +1,2 @@
+export { Names } from "./names.js";
+export { cachedSource, fileSource, httpSource } from "./source.js";

package/lib/client/names.d.ts

@@ -0,0 +1,37 @@
+import { type Kind, type Layer } from '../model.ts';
+import { type Rows } from './chunks.ts';
+import { type Source } from './source.ts';
+export interface Found {
+    id: string;
+    kind: Kind;
+    label: string;
+    names: {
+        text: string;
+        lang: string | null;
+    }[];
+    danbooru: string[];
+    works: string[];
+    score: number;
+    adult: boolean;
+}
+export interface Trace {
+    rounds: number;
+    labels: number;
+    files: number;
+    bytes: number;
+}
+export declare function trace(names: Names): Readonly<Trace>;
+export declare function decode(path: string, bytes: Uint8Array): Rows;
+export declare class Names {
+    #private;
+    constructor(source: Source, options?: {
+        layers?: Layer[];
+    });
+    search(query: string, options?: {
+        kind?: Kind;
+        limit?: number;
+        adult?: boolean;
+        signal?: AbortSignal;
+    }): Promise<Found[]>;
+    lookup(ids: string[], signal?: AbortSignal): Promise<Found[]>;
+}

package/lib/client/names.js

@@ -0,0 +1,202 @@
+import { gunzipSync } from 'node:zlib';
+import { LAYERS } from "../model.js";
+import { View } from "./chunks.js";
+import { search } from "./engine.js";
+import { parsePath, readManifest, readRows } from "./format.js";
+import { Missing } from "./source.js";
+const KEEP = 256;
+const PARALLEL = 16;
+const TIMEOUT = 30_000;
+const LABEL_LANGS = ['ja', 'en', 'ja-Latn', 'ko'];
+const SHOWN = new Set(['main', 'official', 'synonym', 'short']);
+const traces = new WeakMap();
+export function trace(names) {
+    return traces.get(names) ?? { rounds: 0, labels: 0, files: 0, bytes: 0 };
+}
+function race(promise, signal) {
+    if (!signal)
+        return promise;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const stop = () => reject(signal.reason);
+        signal.addEventListener('abort', stop, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', stop));
+    });
+}
+export function decode(path, bytes) {
+    const where = parsePath(path);
+    let rows;
+    try {
+        const text = bytes[0] === 0x1f && bytes[1] === 0x8b ? gunzipSync(bytes) : bytes;
+        rows = where && readRows(where.table, JSON.parse(new TextDecoder().decode(text)));
+    }
+    catch {
+        rows = undefined;
+    }
+    if (!rows)
+        throw new Error(`aninames: ${path} is not a chunk file`);
+    return rows;
+}
+function label(id, rows) {
+    const names = rows.flatMap((row) => row.names);
+    for (const lang of LABEL_LANGS) {
+        for (const trust of [0, 1, 2, 3, undefined]) {
+            const found = names.find((n) => n.lang === lang && (n.kind === 'official' || n.kind === 'main') && (trust === undefined || n.trust === trust));
+            if (found)
+                return found.text;
+        }
+    }
+    return names.find((n) => n.kind === 'main')?.text ?? names[0]?.text ?? id;
+}
+function card(rows, score, adult) {
+    const head = rows[0];
+    const seen = new Set();
+    const names = [];
+    for (const name of rows.flatMap((row) => row.names)) {
+        const key = `${name.lang ?? ''}\u0000${name.text}`;
+        if (!SHOWN.has(name.kind) || seen.has(key))
+            continue;
+        seen.add(key);
+        names.push({ text: name.text, lang: name.lang });
+    }
+    const posts = new Map();
+    for (const [tag, count] of rows.flatMap((row) => row.danbooru)) {
+        if (!posts.has(tag) || (count ?? -1) > (posts.get(tag) ?? -1))
+            posts.set(tag, count);
+    }
+    const danbooru = [...posts]
+        .map(([tag, count], at) => ({ tag, count, at }))
+        .sort((a, b) => (b.count ?? -1) - (a.count ?? -1) || a.at - b.at)
+        .map((entry) => entry.tag);
+    const works = head.kind === 'character' ? [...new Set(rows.flatMap((row) => row.works.map(([, id]) => id)))] : [];
+    return { id: head.id, kind: head.kind, label: label(head.id, rows), names, danbooru, works, score, adult };
+}
+export class Names {
+    #source;
+    #layers;
+    #state;
+    #cache = new Map();
+    #loading = new Map();
+    #queue = [];
+    #active = 0;
+    #runs = 0;
+    constructor(source, options = {}) {
+        this.#source = source;
+        this.#layers = options.layers ?? LAYERS;
+        traces.set(this, { rounds: 0, labels: 0, files: 0, bytes: 0 });
+    }
+    search(query, options = {}) {
+        const { signal, ...rest } = options;
+        return this.#run(signal, (view) => {
+            const hits = search(view, query, rest);
+            if (!hits)
+                return undefined;
+            view.labels = true;
+            const out = hits.flatMap((hit) => {
+                const rows = view.entity(hit.eid, hit.mask);
+                return rows.length > 0 ? [card(rows, hit.score, hit.adult)] : [];
+            });
+            return view.wanted.size > 0 ? undefined : out;
+        });
+    }
+    lookup(ids, signal) {
+        const wanted = [...new Set(ids.filter((id) => typeof id === 'string'))];
+        return this.#run(signal, (view) => {
+            view.labels = true;
+            const out = wanted.flatMap((id) => {
+                const rows = view.byId(id);
+                return rows.length > 0 ? [card(rows, 0, rows[0].adult)] : [];
+            });
+            return view.wanted.size > 0 ? undefined : out;
+        });
+    }
+    #open() {
+        if (this.#state)
+            return this.#state;
+        const state = this.#source
+            .manifest(AbortSignal.timeout(TIMEOUT))
+            .then((text) => ({ text, manifest: readManifest(text) }));
+        this.#state = state;
+        state.catch(() => {
+            if (this.#state === state)
+                this.#state = undefined;
+        });
+        return state;
+    }
+    #view(manifest) {
+        const layers = LAYERS.filter((layer) => (layer === 'core' || this.#layers.includes(layer)) && manifest.layers.has(layer));
+        return new View(manifest, layers, (path) => {
+            const rows = this.#cache.get(path);
+            if (rows) {
+                this.#cache.delete(path);
+                this.#cache.set(path, rows);
+            }
+            return rows;
+        });
+    }
+    async #run(signal, compute) {
+        signal?.throwIfAborted();
+        const counts = traces.get(this);
+        this.#runs++;
+        try {
+            for (let retry = true;; retry = false) {
+                const state = await race(this.#open(), signal);
+                try {
+                    for (;;) {
+                        const view = this.#view(state.manifest);
+                        const value = compute(view);
+                        if (view.wanted.size === 0)
+                            return value;
+                        if (view.labels)
+                            counts.labels++;
+                        else
+                            counts.rounds++;
+                        await race(this.#load([...view.wanted]), signal);
+                    }
+                }
+                catch (error) {
+                    if (!retry || !(error instanceof Missing))
+                        throw error;
+                    const text = await race(this.#source.manifest(AbortSignal.timeout(TIMEOUT)), signal);
+                    if (text === state.text)
+                        throw error;
+                    this.#state = Promise.resolve({ text, manifest: readManifest(text) });
+                }
+            }
+        }
+        finally {
+            this.#runs--;
+            if (this.#runs === 0)
+                for (const path of [...this.#cache.keys()].slice(0, -KEEP))
+                    this.#cache.delete(path);
+        }
+    }
+    #load(paths) {
+        return Promise.all(paths.map((path) => {
+            if (this.#cache.has(path))
+                return undefined;
+            let loading = this.#loading.get(path);
+            if (!loading) {
+                loading = this.#fetch(path).finally(() => this.#loading.delete(path));
+                this.#loading.set(path, loading);
+            }
+            return loading;
+        }));
+    }
+    async #fetch(path) {
+        while (this.#active >= PARALLEL)
+            await new Promise((go) => this.#queue.push(go));
+        this.#active++;
+        try {
+            const bytes = await this.#source.file(path, AbortSignal.timeout(TIMEOUT));
+            this.#cache.set(path, decode(path, bytes));
+            const counts = traces.get(this);
+            counts.files++;
+            counts.bytes += bytes.byteLength;
+        }
+        finally {
+            this.#active--;
+            this.#queue.shift()?.();
+        }
+    }
+}

package/lib/client/order.d.ts

@@ -0,0 +1 @@
+export declare function compare(a: string, b: string): number;

package/lib/client/order.js

@@ -0,0 +1,13 @@
+function unit(code) {
+    return code >= 0xe000 ? code - 0x800 : code >= 0xd800 ? code + 0x2000 : code;
+}
+export function compare(a, b) {
+    const length = Math.min(a.length, b.length);
+    for (let i = 0; i < length; i++) {
+        const x = a.charCodeAt(i);
+        const y = b.charCodeAt(i);
+        if (x !== y)
+            return unit(x) - unit(y);
+    }
+    return a.length - b.length;
+}

package/lib/client/source.d.ts

@@ -0,0 +1,14 @@
+export interface Source {
+    manifest(signal?: AbortSignal): Promise<string>;
+    file(path: string, signal?: AbortSignal): Promise<Uint8Array>;
+}
+export declare class Missing extends Error {
+}
+export declare function httpSource(base: string, options?: {
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+}): Source;
+export declare function fileSource(dir: string): Source;
+export declare function cachedSource(source: Source, dir: string, options?: {
+    maxAge?: number;
+}): Source;

package/lib/client/source.js

@@ -0,0 +1,180 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { USER_AGENT } from "../model.js";
+import { KEY_TABLES, manifestPaths, parsePath, readManifest } from "./format.js";
+export class Missing extends Error {
+}
+const revalidators = new WeakMap();
+function checked(path) {
+    if (!parsePath(path))
+        throw new Error(`aninames: ${JSON.stringify(path)} is not a chunk file name`);
+    return path;
+}
+export function httpSource(base, options = {}) {
+    const root = base.endsWith('/') ? base : `${base}/`;
+    const request = async (path, signal, extra = {}) => {
+        const url = new URL(path, root);
+        const response = await (options.fetch ?? fetch)(url, {
+            headers: { 'user-agent': USER_AGENT, ...options.headers, ...extra },
+            ...(signal ? { signal } : {}),
+        });
+        if (response.status === 404)
+            throw new Missing(`aninames: ${url} is not there (404)`);
+        if (!response.ok && response.status !== 304)
+            throw new Error(`aninames: ${url} answered ${response.status}`);
+        return response;
+    };
+    const source = {
+        manifest: async (signal) => (await request('manifest.json', signal)).text(),
+        file: async (path, signal) => new Uint8Array(await (await request(checked(path), signal)).arrayBuffer()),
+    };
+    revalidators.set(source, async ({ etag, modified }, signal) => {
+        const response = await request('manifest.json', signal, {
+            ...(etag ? { 'if-none-match': etag } : {}),
+            ...(modified ? { 'if-modified-since': modified } : {}),
+        });
+        if (response.status === 304)
+            return undefined;
+        return {
+            text: await response.text(),
+            etag: response.headers.get('etag'),
+            modified: response.headers.get('last-modified'),
+        };
+    });
+    return source;
+}
+const missing = (error) => error?.code === 'ENOENT';
+export function fileSource(dir) {
+    return {
+        async manifest(signal) {
+            try {
+                return await readFile(join(dir, 'manifest.json'), { encoding: 'utf8', ...(signal ? { signal } : {}) });
+            }
+            catch (error) {
+                if (missing(error))
+                    throw new Error(`aninames: ${join(dir, 'manifest.json')} is missing; run mise run chunk`);
+                throw error;
+            }
+        },
+        async file(path, signal) {
+            try {
+                return new Uint8Array(await readFile(join(dir, checked(path)), signal ? { signal } : {}));
+            }
+            catch (error) {
+                if (missing(error))
+                    throw new Missing(`aninames: ${join(dir, path)} is missing`);
+                throw error;
+            }
+        },
+    };
+}
+function cachedOf(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const { text, etag, modified, checked } = value;
+    if (typeof text !== 'string' || typeof checked !== 'number')
+        return undefined;
+    return {
+        text,
+        checked,
+        etag: typeof etag === 'string' ? etag : null,
+        modified: typeof modified === 'string' ? modified : null,
+    };
+}
+async function put(path, data) {
+    const part = `${path}.${randomUUID()}.part`;
+    try {
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(part, data);
+        await rename(part, path);
+    }
+    catch {
+        await rm(part, { force: true });
+    }
+}
+async function prune(dir, text) {
+    const named = manifestPaths(readManifest(text));
+    for (const layer of await readdir(dir).catch(() => [])) {
+        for (const table of [...KEY_TABLES, 'entity']) {
+            const folder = join(dir, layer, table);
+            for (const file of await readdir(folder).catch(() => [])) {
+                const path = `${layer}/${table}/${file}`;
+                if (parsePath(path) && !named.has(path))
+                    await rm(join(folder, file), { force: true });
+            }
+        }
+    }
+}
+export function cachedSource(source, dir, options = {}) {
+    const maxAge = options.maxAge ?? 86_400_000;
+    const state = join(dir, 'manifest.cache.json');
+    let stale = false;
+    const read = async () => {
+        try {
+            return cachedOf(JSON.parse(await readFile(state, 'utf8')));
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const fetchFresh = async (cached, signal) => {
+        const revalidate = revalidators.get(source);
+        if (revalidate)
+            return revalidate(cached ?? { etag: null, modified: null }, signal);
+        return { text: await source.manifest(signal), etag: null, modified: null };
+    };
+    return {
+        async manifest(signal) {
+            const cached = await read();
+            if (cached && !stale && Date.now() - cached.checked < maxAge)
+                return cached.text;
+            let fresh;
+            try {
+                fresh = await fetchFresh(cached, signal);
+            }
+            catch (error) {
+                if (cached && !signal?.aborted)
+                    return cached.text;
+                throw error;
+            }
+            stale = false;
+            if (!fresh) {
+                if (!cached)
+                    throw new Error('aninames: the server answered 304 to a manifest request without validators');
+                await put(state, JSON.stringify({ ...cached, checked: Date.now() }));
+                return cached.text;
+            }
+            readManifest(fresh.text);
+            await put(state, JSON.stringify({ ...fresh, checked: Date.now() }));
+            if (fresh.text !== cached?.text)
+                await prune(dir, fresh.text);
+            return fresh.text;
+        },
+        async file(path, signal) {
+            const target = join(dir, checked(path));
+            try {
+                return new Uint8Array(await readFile(target));
+            }
+            catch (error) {
+                if (!missing(error))
+                    throw error;
+            }
+            let bytes;
+            try {
+                bytes = await source.file(path, signal);
+            }
+            catch (error) {
+                if (error instanceof Missing)
+                    stale = true;
+                throw error;
+            }
+            const hash = createHash('sha256').update(bytes).digest('hex');
+            if (!hash.startsWith(parsePath(path)?.hash ?? '-')) {
+                throw new Error(`aninames: ${path} arrived with other contents (sha256 ${hash.slice(0, 12)})`);
+            }
+            await put(target, bytes);
+            return bytes;
+        },
+    };
+}

package/lib/match.d.ts

@@ -0,0 +1,9 @@
+import type { NameKind } from './model.ts';
+export declare const TOP = "\uDBFF\uDFFF";
+export declare function weightOf(row: {
+    kind: NameKind;
+    variant: number;
+    support: number;
+}): number;
+export declare function typing(q: string): [string, string][];
+export declare function swapLayout(query: string): string | undefined;