hanzi-chai 0.3.0

package/dist/data.d.ts

@@ -0,0 +1,195 @@
+import type { BoundingBox } from "./bezier.js";
+import type { Feature } from "./classifier.js";
+export type N1 = [number];
+export type N2 = [number, number];
+export type N3 = [number, number, number];
+export type N6 = [number, number, number, number, number, number];
+/**
+ * 一条 SVG 路径命令
+ * h, v, c 的含义参见 SVG 规范
+ * z 和 c 的含义相同，但是只用于表示平撇、平点、平捺，这是为了区分
+ */
+export type Draw = {
+    command: "h" | "v";
+    parameterList: N1;
+} | {
+    command: "c" | "z";
+    parameterList: N6;
+} | {
+    command: "a";
+    parameterList: N1;
+};
+export type Point = N2;
+/**
+ * SVG 笔画
+ * feature: 笔画的种类
+ * start: 笔画的起点
+ * curveList: 笔画的命令列表
+ */
+export interface SVGStroke {
+    feature: Feature;
+    start: Point;
+    curveList: Draw[];
+}
+/**
+ * 引用笔画
+ * index: 源字中笔画的索引
+ */
+export interface ReferenceStroke {
+    feature: "reference";
+    index: number;
+}
+/**
+ * SVG 字形是一系列 SVG 笔画的列表
+ */
+export type SVGGlyph = SVGStroke[];
+export interface SVGGlyphWithBox {
+    strokes: SVGGlyph;
+    box: BoundingBox;
+}
+/**
+ * 广义的笔画，包括 SVG 笔画和引用笔画
+ */
+export type Stroke = SVGStroke | ReferenceStroke;
+/**
+ * 基本部件 BasicComponent
+ * tags: 部件的标签
+ * strokes: 部件包含的 SVG 笔画
+ */
+export interface BasicComponent {
+    type: "basic_component";
+    tags?: string[];
+    strokes: SVGStroke[];
+}
+/**
+ * 派生部件 DerivedComponent
+ * tags: 部件的标签
+ * source: 部件的源字
+ * strokes: 部件包含的 SVG 笔画或引用笔画
+ *
+ * 引用的笔画的内容需要在渲染时从源字中获取
+ */
+export interface DerivedComponent {
+    type: "derived_component";
+    tags?: string[];
+    source: string;
+    strokes: Stroke[];
+}
+/**
+ * 拼接部件 SplicedComponent
+ * 与复合体相同，但作为部件使用
+ */
+export interface SplicedComponent extends Omit<Compound, "type"> {
+    type: "spliced_component";
+}
+/**
+ * 部件，包括基本部件和派生部件
+ */
+export type Component = BasicComponent | DerivedComponent | SplicedComponent;
+export declare const operators: readonly ["⿰", "⿱", "⿲", "⿳", "⿴", "⿵", "⿶", "⿷", "⿸", "⿹", "⿺", "⿻", "⿼", "⿽", "⿾", "⿿"];
+/**
+ * 结构表示符
+ * 例如 ⿰、⿱ 等
+ * 符合 Unicode 中的 Ideography Description Characters
+ * 参见 https://en.wikipedia.org/wiki/Ideographic_Description_Characters_(Unicode_block)
+ */
+export type Operator = (typeof operators)[number];
+/**
+ * 一个笔画块
+ */
+export interface Block {
+    index: number;
+    strokes: number;
+}
+/**
+ * 复合体的参数
+ * gap2: 第二部分复合体和之前的间距
+ * scale2: 第二部分复合体的缩放比例
+ * gap3: 第三部分复合体和之前的间距
+ * scale3: 第三部分复合体的缩放比例
+ */
+export interface CompoundParameters {
+    gap2?: number;
+    scale2?: number;
+    gap3?: number;
+    scale3?: number;
+}
+/**
+ * 复合体 Compound
+ * operator: 结构表示符
+ * operandList: 部分列表，有可能是两部分，也可能是三部分（对于 ⿲、⿳）
+ * tags: 复合体的标签
+ * order: 笔画块的顺序
+ */
+export interface Compound {
+    type: "compound";
+    operator: Operator;
+    operandList: string[];
+    tags?: string[];
+    order?: Block[];
+    parameters?: CompoundParameters;
+}
+/**
+ * 全等 Identity
+ * source: 全等的源字
+ * tags: 全等的标签
+ */
+export interface Identity {
+    type: "identity";
+    tags?: string[];
+    source: string;
+}
+/**
+ * 一个字形可以是复合体、部件或全等
+ */
+export type Glyph = Component | Compound | Identity;
+/**
+ * 字符的读音
+ * pinyin: 字符的拼音
+ * importance: 读音占总读音的比例，范围为 0 到 100
+ */
+export interface Reading {
+    pinyin: string;
+    importance: number;
+}
+/**
+ * 原始字符 PrimitiveCharacter
+ * unicode: 字符的 Unicode 编码
+ * tygf: 字符在通用规范汉字集中的类型，0 为不存在，1 为一级字，2 为二级字，3 为三级字
+ * gb2312: 字符在 GB2312 中的类型，0 为不存在，1 为一级字，2 为二级字
+ * name: 字符的别名（当字符是 PUA 时，这个别名会用来在界面上渲染）
+ * gf0014_id: 字符在 GF0014-2009 中的编号
+ * gf3001_id: 字符在 GF3001-1997 中的编号
+ * readings: 字符的读音列表
+ * glyphs: 字符的字形列表，其中每一个有可能是基本部件、派生部件或复合体
+ * ambiguous: 字符是否有分部歧义
+ */
+export interface PrimitiveCharacter {
+    unicode: number;
+    tygf: 0 | 1 | 2 | 3;
+    gb2312: 0 | 1 | 2;
+    name: string | null;
+    gf0014_id: number | null;
+    gf3001_id: number | null;
+    readings: Reading[];
+    glyphs: Glyph[];
+    ambiguous: boolean;
+}
+/**
+ * 字符 Character
+ * 与原始字符相比，省略了 ambiguous 字段，并且将 glyphs 字段替换为唯一的一个 glyph
+ * 此时的 glyph 要么是基本部件，要么是复合体
+ */
+export interface Character extends Omit<PrimitiveCharacter, "glyphs" | "ambiguous"> {
+    glyph: BasicComponent | Compound;
+}
+export interface ComponentCharacter extends Character {
+    glyph: BasicComponent;
+}
+export interface CompoundCharacter extends Character {
+    glyph: Compound;
+}
+/** 原始字符集，为字符名称到原始字符的映射 */
+export type PrimitiveRepertoire = Record<string, PrimitiveCharacter>;
+/** 字符集，为字符名称到字符的映射 */
+export type Repertoire = Record<string, Character>;

package/dist/data.js

@@ -0,0 +1,18 @@
+export const operators = [
+    "⿰",
+    "⿱",
+    "⿲",
+    "⿳",
+    "⿴",
+    "⿵",
+    "⿶",
+    "⿷",
+    "⿸",
+    "⿹",
+    "⿺",
+    "⿻",
+    "⿼",
+    "⿽",
+    "⿾",
+    "⿿",
+];

package/dist/degenerator.d.ts

@@ -0,0 +1,21 @@
+import type { RenderedGlyph } from "./topology.js";
+import type { Degenerator } from "./config.js";
+import type { ComputedComponent } from "./component.js";
+export declare const indicesToBinary: (n: number) => (indices: number[]) => number;
+export declare const binaryToIndices: (n: number) => (binary: number) => number[];
+export declare const defaultDegenerator: Degenerator;
+/**
+ * 给定一个部件和一个字根，找出这个部件所有包含这个字根的方式
+ * 如果部件不包含这个字根，就返回空列表
+ *
+ * @param config - 配置
+ * @param component - 待拆分部件
+ * @param root - 字根
+ */
+export declare const generateSliceBinaries: (degenerator: Degenerator, component: ComputedComponent, root: ComputedComponent) => number[];
+/**
+ * 字根认同的另一种算法，和上面的算法等价且更简单，但是效率比较差
+ * 这个算法是直接计算出一个部件在某个退化映射下的结果，然后和字根的结果比较
+ * 这种方式要求穷举一个部件中所有的笔画取幂集，复杂度为 O(2^n)，所以目前只用于测试
+ */
+export declare const degenerate: (degenerator: Degenerator, glyph: RenderedGlyph) => readonly [("横" | "提" | "竖" | "竖钩" | "撇" | "平撇" | "点" | "平点" | "捺" | "平捺" | "挑捺" | "横钩" | "横撇" | "横折" | "横折钩" | "横斜钩" | "横折提" | "横折折" | "横折弯" | "横撇弯钩" | "横折弯钩" | "横斜弯钩" | "横折折撇" | "横折折折" | "横折折折钩" | "竖提" | "竖折" | "竖弯" | "竖弯左" | "竖弯钩" | "竖折撇" | "竖折折钩" | "竖折折" | "撇点" | "撇折" | "弯钩" | "斜钩" | "撇钩" | "卧钩" | "圈" | "特殊笔画")[], import("./topology.js").Topology];

package/dist/degenerator.js

@@ -0,0 +1,134 @@
+import { isEqual } from "lodash-es";
+import { findTopology } from "./topology.js";
+import { curveLength, isBoundedBy, isCollinear, sortTwoNumbers, } from "./bezier.js";
+export const indicesToBinary = (n) => (indices) => {
+    let binaryCode = 0;
+    for (const index of indices) {
+        binaryCode += 1 << (n - index - 1);
+    }
+    return binaryCode;
+};
+export const binaryToIndices = (n) => (binary) => {
+    const indices = [...Array(n).keys()];
+    return indices.filter((index) => binary & (1 << (n - index - 1)));
+};
+export const defaultDegenerator = {
+    feature: {
+        提: "横",
+        捺: "点",
+    },
+    no_cross: false,
+};
+const strokeFeatureEqual = (degenerator, s1, s2) => {
+    const feature = degenerator.feature ?? {};
+    const d1 = feature[s1] ?? s1;
+    const d2 = feature[s2] ?? s2;
+    return d1 === d2;
+};
+/**
+ * 对于一些特殊的字根，一般性的字根认同规则可能不足以区分它们，需要特殊处理
+ * 这里判断了待拆分部件中的某些笔画究竟是不是这个字根
+ *
+ * @param component - 待拆分部件
+ * @param root - 字根
+ * @param indices - 笔画索引列表
+ */
+const verifySpecialRoots = (component, root, indices) => {
+    if (["土", "士"].includes(root.name)) {
+        const [i1, _, i3] = indices;
+        const upperHeng = component.glyph[i1]?.curveList[0];
+        const lowerHeng = component.glyph[i3]?.curveList[0];
+        const lowerIsLonger = curveLength(upperHeng) < curveLength(lowerHeng);
+        return root.name === "土" ? lowerIsLonger : !lowerIsLonger;
+    }
+    if (["未", "末"].includes(root.name)) {
+        const [i1, i2] = indices;
+        const upperHeng = component.glyph[i1]?.curveList[0];
+        const lowerHeng = component.glyph[i2]?.curveList[0];
+        const lowerIsLonger = curveLength(upperHeng) < curveLength(lowerHeng);
+        return root.name === "未" ? lowerIsLonger : !lowerIsLonger;
+    }
+    if (["口", "囗"].includes(root.name)) {
+        if (["囗", "\ue02d"].includes(component.name)) {
+            return root.name === "囗";
+        }
+        const [i1, _, i3] = indices;
+        const upperLeft = component.glyph[i1]?.curveList[0]?.controls[0];
+        const lowerRight = component.glyph[i3]?.curveList[0]?.controls.at(-1);
+        const xrange = [upperLeft[0], lowerRight[0]];
+        const yrange = [upperLeft[1], lowerRight[1]];
+        const otherStrokes = component.glyph.filter((_, index) => !indices.includes(index));
+        const containsStroke = otherStrokes.some((stroke) => isBoundedBy(stroke, xrange, yrange));
+        return root.name === "囗" ? containsStroke : !containsStroke;
+    }
+    if (["\ue087" /* 木无十 */, "\ue43d" /* 全字头 */].includes(root.name)) {
+        const [i1] = indices;
+        const attachPoint = component.glyph[i1]?.curveList[0]?.controls[0];
+        const otherStrokes = component.glyph.filter((_, index) => !indices.includes(index));
+        const otherCurves = otherStrokes.flatMap((s) => s.curveList);
+        const pieAndNaIsSeparated = otherCurves.some((x) => x.type === "linear" &&
+            isCollinear(x.controls[0], x.controls[1], attachPoint));
+        return root.name === "\ue087" ? pieAndNaIsSeparated : !pieAndNaIsSeparated;
+    }
+    return true;
+};
+/**
+ * 给定一个部件和一个字根，找出这个部件所有包含这个字根的方式
+ * 如果部件不包含这个字根，就返回空列表
+ *
+ * @param config - 配置
+ * @param component - 待拆分部件
+ * @param root - 字根
+ */
+export const generateSliceBinaries = (degenerator, component, root) => {
+    const { glyph: cglyph, topology: ctopology } = component;
+    const { glyph: rglyph, topology: rtopology } = root;
+    if (cglyph.length < rglyph.length)
+        return [];
+    let queue = [[]];
+    for (const [rIndex, rStroke] of rglyph.entries()) {
+        const rStrokeTopology = rtopology.matrix[rIndex]?.slice(0, rIndex);
+        const end = cglyph.length - rglyph.length + rIndex + 1;
+        for (let _ = queue.length; _ !== 0; --_) {
+            const indexList = queue.shift();
+            const start = indexList.length ? indexList.at(-1) + 1 : 0;
+            for (const [cIndex, cStroke] of cglyph.slice(start, end).entries()) {
+                if (!strokeFeatureEqual(degenerator, cStroke.feature, rStroke.feature))
+                    continue;
+                const realIndex = cIndex + start;
+                const cStrokeTopology = ctopology.matrix[realIndex]?.filter((_, i) => indexList.includes(i));
+                if (!isEqual(cStrokeTopology, rStrokeTopology))
+                    continue;
+                queue.push(indexList.concat(realIndex));
+            }
+        }
+        if (!queue)
+            return [];
+    }
+    if (degenerator.no_cross) {
+        const allindices = [...Array(cglyph.length).keys()];
+        queue = queue.filter((indices) => {
+            const others = allindices.filter((x) => !indices.includes(x));
+            const allCombinations = indices.flatMap((x) => others.map((y) => sortTwoNumbers([x, y])));
+            return allCombinations.every(([x, y]) => {
+                const relation = ctopology.matrix[y]?.[x];
+                return relation.every((cr) => cr.type !== "交");
+            });
+        });
+    }
+    return queue
+        .filter((x) => verifySpecialRoots(component, root, x))
+        .map(indicesToBinary(cglyph.length));
+};
+/**
+ * 字根认同的另一种算法，和上面的算法等价且更简单，但是效率比较差
+ * 这个算法是直接计算出一个部件在某个退化映射下的结果，然后和字根的结果比较
+ * 这种方式要求穷举一个部件中所有的笔画取幂集，复杂度为 O(2^n)，所以目前只用于测试
+ */
+export const degenerate = (degenerator, glyph) => {
+    const featureMap = degenerator.feature ?? {};
+    return [
+        glyph.map((x) => x.feature).map((x) => featureMap[x] || x),
+        findTopology(glyph),
+    ];
+};

package/dist/element.d.ts

@@ -0,0 +1,56 @@
+import type { Algebra, Rule } from "./config.js";
+import type { CharacterResult } from "./assembly.js";
+export interface Extra {
+    rootSequence: Map<string, number[]>;
+}
+interface Base {
+    type: string;
+}
+export declare const pronunciationElementTypes: readonly ["声母", "双拼声母", "韵母", "双拼韵母", "声调", "首字母", "末字母"];
+export type PronunciationElementTypes = (typeof pronunciationElementTypes)[number];
+export declare const defaultAlgebra: Record<PronunciationElementTypes, Rule[]>;
+export declare const applyRules: (name: string, rules: Rule[], syllable: string) => string;
+interface This extends Base {
+    type: "汉字";
+}
+interface Constant extends Base {
+    type: "固定";
+    key: string;
+}
+interface Structure extends Base {
+    type: "结构";
+}
+interface Pronunciation extends Base {
+    type: "字音";
+    subtype: PronunciationElementTypes;
+}
+interface Root extends Base {
+    type: "字根";
+    rootIndex: number;
+}
+interface Stroke extends Base {
+    type: "笔画";
+    rootIndex: number;
+    strokeIndex: number;
+}
+interface StrokePair extends Base {
+    type: "二笔";
+    rootIndex: number;
+    strokeIndex: number;
+}
+interface Custom extends Base {
+    type: "自定义";
+    subtype: string;
+    rootIndex: number;
+}
+interface Special extends Base {
+    type: "特殊";
+    subtype: string;
+}
+export type CodableObject = This | Constant | Structure | Pronunciation | Root | Stroke | StrokePair | Custom | Special;
+export declare const renderName: (object: CodableObject) => string;
+export declare const renderList: (object: CodableObject) => (string | number)[];
+export declare const parseList: (value: (string | number)[]) => CodableObject;
+export declare const algebraCache: Map<string, string>;
+export declare const findElement: (object: CodableObject, result: CharacterResult, algebra: Algebra, extra: Extra) => string | undefined;
+export {};

package/dist/element.js

@@ -0,0 +1,225 @@
+export const pronunciationElementTypes = [
+    "声母",
+    "双拼声母",
+    "韵母",
+    "双拼韵母",
+    "声调",
+    "首字母",
+    "末字母",
+];
+const r = String.raw;
+export const defaultAlgebra = {
+    声母: [
+        { type: "xform", from: "^([bpmfdtnlgkhjqxzcsr]h?|^).+$", to: "$1" },
+        { type: "xform", from: "^$", to: "0" },
+    ],
+    韵母: [
+        // 恢复 v
+        { type: "xform", from: "^([jqxy])u", to: "$1v" },
+        // 恢复合、齐、撮口的韵母形式
+        { type: "xform", from: "yv", to: "v" },
+        { type: "xform", from: "yi?", to: "i" },
+        { type: "xform", from: "wu?", to: "u" },
+        // 恢复 iou, uei, uen
+        { type: "xform", from: "iu", to: "iou" },
+        { type: "xform", from: "u([in])", to: "ue$1" },
+        { type: "xform", from: r `^.*?([aeêiouv].*|m|ng?)\d$`, to: "$1" },
+    ],
+    双拼声母: [
+        { type: "xform", from: "^([bpmfdtnlgkhjqxzcsryw]h?|^).+$", to: "$1" },
+        { type: "xform", from: "^$", to: "0" },
+    ],
+    双拼韵母: [{ type: "xform", from: r `^.*?([aeêiouv].*|m|ng?)\d$`, to: "$1" }],
+    声调: [{ type: "xform", from: r `.+(\d)`, to: "$1" }],
+    首字母: [{ type: "xform", from: r `^(.).+`, to: "$1" }],
+    末字母: [{ type: "xform", from: r `.*(.)\d`, to: "$1" }],
+};
+export const applyRules = (name, rules, syllable) => {
+    let result = syllable;
+    for (const { type, from, to } of rules) {
+        switch (type) {
+            case "xform":
+                result = result.replace(new RegExp(from), to);
+                break;
+            case "xlit":
+                result = result.replace(new RegExp(`[${from}]`), (s) => {
+                    const index = from.indexOf(s);
+                    return to[index] || "";
+                });
+                break;
+        }
+    }
+    return `${name}-${result}`;
+};
+export const renderName = (object) => {
+    switch (object.type) {
+        case "汉字":
+        case "结构":
+            return object.type;
+        case "固定":
+            return object.key;
+        case "字音":
+            return object.subtype;
+        case "字根":
+            return `根 ${object.rootIndex}`;
+        case "笔画":
+            return `根 ${object.rootIndex} 笔 ${object.strokeIndex}`;
+        case "二笔":
+            return `根 ${object.rootIndex} 笔 (${object.strokeIndex * 2 - Math.sign(object.strokeIndex)}, ${object.strokeIndex * 2})`;
+        case "自定义":
+            return `${object.subtype} ${object.rootIndex}`;
+        case "特殊":
+            return object.subtype;
+    }
+};
+export const renderList = (object) => {
+    const list = [object.type];
+    switch (object.type) {
+        case "固定":
+            return [...list, object.key];
+        case "字音":
+            return [...list, object.subtype];
+        case "字根":
+            return [...list, object.rootIndex];
+        case "笔画":
+            return [...list, object.rootIndex, object.strokeIndex];
+        case "二笔":
+            return [...list, object.rootIndex, object.strokeIndex];
+        case "自定义":
+            return [...list, object.subtype, object.rootIndex];
+        case "特殊":
+            return [...list, object.subtype];
+    }
+    return list;
+};
+export const parseList = (value) => {
+    const type = value[0];
+    switch (type) {
+        case "固定":
+            return { type, key: value[1] };
+        case "字音":
+            return { type, subtype: value[1] };
+        case "字根":
+            return { type, rootIndex: value[1] };
+        case "笔画":
+            return {
+                type,
+                rootIndex: value[1],
+                strokeIndex: value[2],
+            };
+        case "二笔":
+            return {
+                type,
+                rootIndex: value[1],
+                strokeIndex: value[2],
+            };
+        case "自定义":
+            return {
+                type,
+                subtype: value[1],
+                rootIndex: value[2],
+            };
+        case "特殊":
+            return { type, subtype: value[1] };
+    }
+    return { type };
+};
+function signedIndex(a, i) {
+    return i >= 0 ? a[i - 1] : a[a.length + i];
+}
+export const algebraCache = new Map();
+// 张码补码
+const zhangmaSupplement = (result, { rootSequence }) => {
+    // 在补码时，竖钩视为竖，横折弯钩视为折
+    const coalesce = (n) => {
+        if (n === 6)
+            return 2;
+        if (n === 7)
+            return 5;
+        return n;
+    };
+    const { sequence } = result;
+    const first = rootSequence.get(sequence[0]);
+    const last = rootSequence.get(sequence[sequence.length - 1]);
+    const firstfirst = coalesce(first[0]);
+    const lastlast = coalesce(last.at(-1));
+    // 单笔画补码用 61 表示
+    if (sequence.length === 1 && first.length === 1) {
+        return "61";
+    }
+    // 并型和左下围，首 + 末
+    // 其他情况，末 + 首
+    return result.operator && /[⿰⿲⿺]/.test(result.operator)
+        ? `${firstfirst}${lastlast}`
+        : `${lastlast}${firstfirst}`;
+};
+// 张码判断是否为准码元
+const zhangmaPseudoRoot = (result) => {
+    if (!("best" in result))
+        return "0";
+    const { best } = result;
+    return best.scheme.length === 2 && best.evaluation.get("能连不交")
+        ? "1"
+        : "0";
+};
+const specialElementHandlers = {
+    张码补码: zhangmaSupplement,
+    张码准码元: zhangmaPseudoRoot,
+};
+export const findElement = (object, result, algebra, extra) => {
+    const { pinyin, sequence } = result;
+    let root;
+    let strokes;
+    let name;
+    let hash;
+    let rules;
+    let transformed;
+    let stroke1;
+    let stroke2;
+    switch (object.type) {
+        case "汉字":
+            return result.char;
+        case "固定":
+            return object.key;
+        case "结构":
+            if ("operator" in result) {
+                return result.operator;
+            }
+            return undefined;
+        case "字音":
+            name = object.subtype;
+            hash = `${name}:${pinyin}`;
+            if (algebraCache.has(hash))
+                return algebraCache.get(hash);
+            rules = defaultAlgebra[name] || algebra?.[name];
+            transformed = applyRules(name, rules, pinyin);
+            algebraCache.set(hash, transformed);
+            return transformed;
+        case "字根":
+            return signedIndex(sequence, object.rootIndex);
+        case "笔画":
+        case "二笔":
+            root = signedIndex(sequence, object.rootIndex);
+            if (root === undefined)
+                return undefined;
+            strokes = extra.rootSequence.get(root);
+            if (strokes === undefined) {
+                if (Math.abs(object.strokeIndex) === 1)
+                    return root;
+                return undefined;
+            }
+            if (object.type === "笔画") {
+                const number = signedIndex(strokes, object.strokeIndex);
+                return number?.toString();
+            }
+            stroke1 = signedIndex(strokes, object.strokeIndex * 2 - Math.sign(object.strokeIndex));
+            if (stroke1 === undefined)
+                return undefined;
+            stroke2 = signedIndex(strokes, object.strokeIndex * 2);
+            return [stroke1, stroke2 ?? 0].join("");
+        case "自定义":
+            return signedIndex(result.custom[object.subtype] ?? [], object.rootIndex);
+        case "特殊":
+            return specialElementHandlers[object.subtype]?.(result, extra);
+    }
+};

package/dist/equivalence.d.ts

@@ -0,0 +1,21 @@
+export interface EquivalenceData {
+    user: string;
+    model: string;
+    data: (Pair & {
+        time: number;
+    })[];
+}
+type Relation<T> = (v1: T, v2: T) => boolean;
+interface Model<T> {
+    group: Set<T>;
+    relation: Relation<T>;
+}
+export declare function partition<T>({ group, relation }: Model<T>): Set<T>[];
+export interface Pair {
+    initial: number;
+    final: number;
+}
+export declare const distance: (p: Pair) => number;
+export declare const displacement: (p: Pair) => readonly [number, number];
+export declare const 手机五行七列: Model<Pair>;
+export {};