hanzi-chai 0.3.0

package/dist/selector.js

@@ -0,0 +1,310 @@
+import { NoSchemeError, } from "./component.js";
+import { isMerge } from "./config.js";
+import { binaryToIndices } from "./degenerator.js";
+import { isEqual } from "lodash-es";
+import { sortTwoNumbers } from "./bezier.js";
+export const defaultSelector = [
+    "结构完整",
+    "根少优先",
+    "能连不交",
+    "能散不连",
+    "全符笔顺",
+    "取大优先",
+];
+export function isLess(a, b) {
+    if (typeof a === "number" && typeof b === "number") {
+        return a < b;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        for (const [i, v] of a.entries()) {
+            const u = b[i];
+            if (u === undefined)
+                return false;
+            if (v < u)
+                return true;
+            if (v > u)
+                return false;
+        }
+        return false;
+    }
+    return false;
+}
+export const length = {
+    title: "根少优先",
+    key: (scheme) => scheme.length,
+};
+const countStrokes = (n) => n < 2 ? n : (n & 1) + countStrokes(n >>> 1);
+/**
+ * 规则：取大优先
+ *
+ * 让顺序靠前的字根尽量取到更多的笔画
+ */
+export const bias = {
+    title: "取大优先",
+    key: (scheme) => scheme.map(countStrokes).map((x) => -x),
+    display: (data) => `(${data.map((x) => -x).join(", ")})`,
+};
+/**
+ * 规则：取小优先
+ *
+ * 让顺序靠前的字根尽量取到更少的笔画
+ */
+export const unbias = {
+    title: "取小优先",
+    key: (scheme) => scheme.map(countStrokes),
+    display: (data) => `(${data.join(", ")})`,
+};
+/**
+ * 规则：全符笔顺
+ *
+ * 各个字根中笔画的顺序连在一起是否与整个部件的笔顺相同，相同者优先
+ * 该规则采集自三码郑码的文档
+ *
+ * @see https://www.yuque.com/smzm/zhengma/otb32d
+ */
+export const order = {
+    title: "全符笔顺",
+    key: (scheme, { component }) => {
+        const indices = scheme.flatMap((x) => binaryToIndices(component.glyph.length)(x));
+        const isSorted = indices.slice(1).every((v, i) => indices[i] < v);
+        return Number(!isSorted);
+    },
+};
+/**
+ * 规则：连续笔顺
+ *
+ * 字根是否由部件中连续的几个笔画构成，不符合此特点的字根数量少者优先。该规则采集自宇浩输入法的文档。
+ *
+ * @see https://zhuyuhao.com/yuhao/docs/learn.html#符合笔顺
+ */
+export const order2 = {
+    title: "连续笔顺",
+    key: (scheme, { component }) => {
+        const indices = scheme.map(binaryToIndices(component.glyph.length));
+        // 如果一个字根不是由连续的笔画构成，那么称它是不连续的
+        const unSorted = indices.filter((x) => x.length - 1 !== x.at(-1) - x[0]).length;
+        // 让不连续的字根数量少者优先
+        return unSorted;
+    },
+};
+/**
+ * 规则：非形近根
+ *
+ * 尽量少使用被归并到其他字根的字根。该规则采集自三码郑码的文档
+ *
+ * @see https://www.yuque.com/smzm/zhengma/otb32d
+ */
+export const similar = {
+    title: "非形近根",
+    key: (scheme, { rootMap, roots }) => {
+        const rootList = scheme.map((x) => rootMap.get(x));
+        return rootList.filter((x) => {
+            const value = roots.get(x);
+            return value && isMerge(value);
+        }).length;
+    },
+};
+/**
+ * 规则：强字根
+ *
+ * 尽量多使用特定的一些字根。该规则采集自郑码的文档
+ */
+export const strong = {
+    title: "多强字根",
+    key: (scheme, { rootMap, analysis }) => {
+        const strong = analysis?.strong || [];
+        const roots = scheme.map((x) => rootMap.get(x));
+        return -roots.filter((x) => strong.includes(x)).length;
+    },
+};
+/**
+ * 规则：弱字根
+ *
+ * 尽量避免使用特定的一些字根
+ */
+export const weak = {
+    title: "少弱字根",
+    key: (scheme, { rootMap, analysis }) => {
+        const weak = analysis?.weak || [];
+        const roots = scheme.map((x) => rootMap.get(x));
+        return roots.filter((x) => weak.includes(x)).length;
+    },
+};
+const makeTopologySieve = (relationType, avoidRelationType, title) => {
+    const key = (scheme, { component }) => {
+        const parsedScheme = scheme.map((x) => binaryToIndices(component.glyph.length)(x));
+        let totalCrosses = 0;
+        for (const [i, bi] of parsedScheme.entries()) {
+            for (const [j, bj] of parsedScheme.entries()) {
+                if (j >= i)
+                    continue;
+                let r = false;
+                let a = false;
+                for (const k of bi) {
+                    for (const l of bj) {
+                        const [smaller, larger] = [Math.min(k, l), Math.max(k, l)];
+                        const relations = component.topology.matrix[larger]?.[smaller];
+                        r ||= relations.some((v) => v.type === relationType);
+                        a ||= relations.some((v) => avoidRelationType.includes(v.type));
+                    }
+                }
+                if (!a)
+                    totalCrosses += Number(r);
+            }
+        }
+        return totalCrosses;
+    };
+    return { key, title };
+};
+/**
+ * 规则：能连不交
+ *
+ * 尽量让字根不交叉。该规则采集自五笔
+ */
+export const crossing = makeTopologySieve("交", [], "能连不交");
+/**
+ * 规则：能散不连
+ *
+ * 尽量让字根不相连。该规则采集自五笔
+ */
+export const attaching = makeTopologySieve("连", ["交"], "能散不连");
+/**
+ * 规则：同向笔画
+ *
+ * 尽量让方向相同的笔画包含在同一个字根里。该规则采集自五笔
+ */
+export const orientation = {
+    title: "同向笔画",
+    key: (scheme, { component }) => {
+        const n = component.glyph.length;
+        const parsedScheme = scheme.map(binaryToIndices(n));
+        let totalCrosses = 0;
+        for (const [i, bi] of parsedScheme.entries()) {
+            for (const [j, bj] of parsedScheme.entries()) {
+                if (j >= i)
+                    continue;
+                let r = false;
+                for (const k of bi) {
+                    for (const l of bj) {
+                        const [smaller, larger] = sortTwoNumbers([k, l]);
+                        const oriented = component.topology.orientedPairs.some((x) => isEqual(x, [larger, smaller]));
+                        r ||= oriented;
+                    }
+                }
+                totalCrosses += Number(r);
+            }
+        }
+        return totalCrosses;
+    },
+};
+/**
+ * @param b1 - 以二进制数表示的切片
+ * @param b2 - 同上
+ * @returns 第一个切片是否包含第二个切片
+ */
+const contains = (b1, b2) => (b1 | b2) === b1;
+/**
+ * 规则：结构完整
+ *
+ * 避免框类部件被拆散。该规则采集自宇浩输入法的文档
+ *
+ * @see https://zhuyuhao.com/yuhao/docs/learn.html#结构完整
+ */
+export const integrity = {
+    title: "结构完整",
+    key: (scheme, { rootMap }) => {
+        const priorities = [
+            "口",
+            "囗",
+            "冂",
+            "\ue439" /* 见二 */,
+            "匚",
+            "凵",
+            "\ue009" /* 假右角 */,
+            "勹",
+            "尸",
+            "\uE407" /* 央三 */,
+        ];
+        const shouldHave = [...rootMap]
+            .filter(([_, name]) => priorities.includes(name))
+            .map(([binary]) => binary);
+        const breaks = shouldHave.filter((x) => !scheme.some((binary) => contains(binary, x))).length;
+        return breaks;
+    },
+};
+export const sieveMap = new Map([
+    length,
+    order,
+    order2,
+    bias,
+    unbias,
+    crossing,
+    attaching,
+    similar,
+    orientation,
+    integrity,
+    strong,
+    weak,
+].map((x) => [x.title, x]));
+/**
+ * 选择最优的拆分方案
+ *
+ * @param config - 配置
+ * @param component - 待拆分部件
+ * @param schemeList - 拆分方案列表
+ * @param rootMap - 字根映射，从切片的二进制表示到字根名称的映射
+ */
+export const select = (config, component, schemeList, rootMap, requiredRoots) => {
+    const environment = {
+        component,
+        rootMap,
+        ...config,
+    };
+    const sieveNames = config.analysis.selector ?? defaultSelector;
+    const schemeData = schemeList.map((scheme) => {
+        const evaluation = new Map();
+        for (const sieveName of sieveNames) {
+            const sieve = sieveMap.get(sieveName);
+            const value = sieve.key(scheme, environment);
+            evaluation.set(sieve.title, value);
+        }
+        return {
+            scheme,
+            roots: scheme.map((x) => rootMap.get(x)),
+            evaluation,
+            optional: false,
+        };
+    });
+    schemeData.sort((a, b) => {
+        for (const sieveName of sieveNames) {
+            const aValue = a.evaluation.get(sieveName);
+            const bValue = b.evaluation.get(sieveName);
+            if (isLess(aValue, bValue))
+                return -1;
+            if (isLess(bValue, aValue))
+                return 1;
+            continue;
+        }
+        return 0;
+    });
+    const requiredRootsNames = Array.from(requiredRoots).map((x) => rootMap.get(x));
+    const optionalRootsData = schemeData.map((x) => x.roots.filter((y) => !requiredRootsNames.includes(y)));
+    for (const [index, data] of schemeData.entries()) {
+        data.optional = true;
+        for (let prevIndex = 0; prevIndex != index; ++prevIndex) {
+            const current = optionalRootsData[index];
+            const previous = optionalRootsData[prevIndex];
+            if (previous.every((x) => current.includes(x))) {
+                data.optional = false;
+                break;
+            }
+        }
+        if (data.scheme.every((x) => requiredRoots.has(x) || (x & (x - 1)) === 0)) {
+            break;
+        }
+    }
+    // If there is no scheme, error
+    if (schemeData.length === 0)
+        return new NoSchemeError();
+    return schemeData;
+};

package/dist/topology.d.ts

@@ -0,0 +1,41 @@
+import type { SVGGlyph, SVGStroke } from "./data.js";
+import type { Curve, Position } from "./bezier.js";
+interface RenderedStroke extends Pick<SVGStroke, "feature"> {
+    curveList: Curve[];
+}
+type RenderedGlyph = RenderedStroke[];
+interface CrossRelation {
+    type: "交";
+}
+interface AttachRelation {
+    type: "连";
+    first: "前" | "中" | "后";
+    second: "前" | "中" | "后";
+}
+interface ParallelRelation {
+    type: "平行";
+    mainAxis: Position;
+    crossAxis: Position;
+}
+interface PerpendicularRelation {
+    type: "散";
+    x: Position;
+    y: Position;
+}
+type DisjointRelation = ParallelRelation | PerpendicularRelation;
+type CurveRelation = CrossRelation | AttachRelation | DisjointRelation;
+declare const curveRelation: (c1: Curve, c2: Curve) => CurveRelation;
+declare const strokeRelation: (stroke1: RenderedStroke, stroke2: RenderedStroke) => StrokeRelation;
+type StrokeRelation = CurveRelation[];
+declare const renderSVGStroke: ({ feature, start, curveList }: SVGStroke) => RenderedStroke;
+declare const renderSVGGlyph: (glyph: SVGGlyph) => RenderedStroke[];
+interface Topology {
+    matrix: StrokeRelation[][];
+    orientedPairs: [number, number][];
+}
+declare const isConforming: (r1: CurveRelation, r2: CurveRelation) => boolean;
+export type CornerSpecifier = [number, number, number, number];
+declare const findCorners: (renderedGlyph: RenderedGlyph) => CornerSpecifier;
+declare const findTopology: (renderedGlyph: RenderedGlyph) => Topology;
+export { isConforming, curveRelation, strokeRelation, renderSVGStroke, renderSVGGlyph, findTopology, findCorners, };
+export type { CurveRelation, StrokeRelation, RenderedGlyph, Topology };

package/dist/topology.js

@@ -0,0 +1,209 @@
+import { isEqual, minBy } from "lodash-es";
+import { subtract, distance } from "./mathjs.js";
+import { area, findCrossPoint, getBoundingBox, getIntervalOnOrientation, getIntervalPosition, isCollinear, makeCurve, } from "./bezier.js";
+const makeAttachRelation = (first, second) => ({ type: "连", first, second });
+const getParallelRelation = (a, b) => {
+    const [amain, across] = getIntervalOnOrientation(a);
+    const [bmain, bcross] = getIntervalOnOrientation(b);
+    const mainPosition = getIntervalPosition(amain, bmain);
+    const crossPosition = getIntervalPosition(across, bcross);
+    return { type: "平行", mainAxis: mainPosition, crossAxis: crossPosition };
+};
+const getDisjointRelation = (a, b) => {
+    if (a.orientation === b.orientation)
+        return getParallelRelation(a, b);
+    const [astart, aend] = getBoundingBox(a);
+    const [bstart, bend] = getBoundingBox(b);
+    return {
+        type: "散",
+        x: getIntervalPosition([astart[0], aend[0]], [bstart[0], bend[0]]),
+        y: getIntervalPosition([astart[1], aend[1]], [bstart[1], bend[1]]),
+    };
+};
+const getAttachRelation = (a, b) => {
+    const [astart, aend] = getBoundingBox(a);
+    const [bstart, bend] = getBoundingBox(b);
+    if (isEqual(astart, bstart))
+        return makeAttachRelation("前", "前");
+    if (isEqual(astart, bend))
+        return makeAttachRelation("前", "后");
+    if (isEqual(aend, bstart))
+        return makeAttachRelation("后", "前");
+    if (isEqual(aend, bend))
+        return makeAttachRelation("后", "后");
+    if (a.type === "linear") {
+        if (isCollinear(astart, aend, bstart))
+            return makeAttachRelation("中", "前");
+        if (isCollinear(astart, aend, bend))
+            return makeAttachRelation("中", "后");
+    }
+    if (b.type === "linear") {
+        if (isCollinear(bstart, bend, astart))
+            return makeAttachRelation("前", "中");
+        if (isCollinear(bstart, bend, aend))
+            return makeAttachRelation("后", "中");
+    }
+};
+const linearRelation = (a, b) => {
+    const [astart, aend] = a.controls;
+    const [bstart, bend] = b.controls;
+    const [v, v1, v2] = [
+        subtract(aend, astart),
+        subtract(bstart, astart),
+        subtract(bend, astart),
+    ];
+    const vc = area(v, v1) * area(v, v2);
+    const [u, u1, u2] = [
+        subtract(bend, bstart),
+        subtract(astart, bstart),
+        subtract(aend, bstart),
+    ];
+    const uc = area(u, u1) * area(u, u2);
+    if (vc < 0 && uc < 0) {
+        return { type: "交" };
+    }
+    return getDisjointRelation(a, b);
+};
+const genericRelation = (a, b) => {
+    const crossPoint = findCrossPoint(a, [0, 1], b, [0, 1]);
+    if (crossPoint === undefined)
+        return getDisjointRelation(a, b);
+    const [astart, aend] = getBoundingBox(a);
+    const [bstart, bend] = getBoundingBox(b);
+    const distanceThreshold = 3;
+    if (distance(crossPoint, astart) < distanceThreshold)
+        return makeAttachRelation("前", "中");
+    if (distance(crossPoint, aend) < distanceThreshold)
+        return makeAttachRelation("后", "中");
+    if (distance(crossPoint, bstart) < distanceThreshold)
+        return makeAttachRelation("中", "前");
+    if (distance(crossPoint, bend) < distanceThreshold)
+        return makeAttachRelation("中", "后");
+    return { type: "交" };
+};
+const curveRelation = (c1, c2) => {
+    const relation = getAttachRelation(c1, c2);
+    if (relation !== undefined)
+        return relation;
+    if (c1.type === "linear" && c2.type === "linear") {
+        return linearRelation(c1, c2);
+    }
+    return genericRelation(c1, c2);
+};
+const strokeRelation = (stroke1, stroke2) => {
+    const strokeRelation = [];
+    for (const curve1 of stroke1.curveList) {
+        for (const curve2 of stroke2.curveList) {
+            strokeRelation.push(curveRelation(curve1, curve2));
+        }
+    }
+    return strokeRelation;
+};
+const renderSVGStroke = ({ feature, start, curveList }) => {
+    const r = { feature, curveList: [] };
+    let previousPosition = start;
+    for (const draw of curveList) {
+        const curve = makeCurve(previousPosition, draw);
+        previousPosition =
+            curve.type === "linear"
+                ? curve.controls[1]
+                : curve.type === "arc"
+                    ? curve.controls[1]
+                    : curve.controls[3];
+        r.curveList.push(curve);
+    }
+    return r;
+};
+const renderSVGGlyph = (glyph) => glyph.map(renderSVGStroke);
+const isConforming = (r1, r2) => {
+    switch (r1.type) {
+        case "平行":
+            return r2.type === "平行";
+        case "散":
+            return true;
+        case "交":
+            return (r2.type === "交" ||
+                (r2.type === "连" && r2.second === "中") ||
+                r2.type === "散");
+        case "连":
+            if (r1.second === "中") {
+                return (r2.type === "交" ||
+                    r2.type === "散" ||
+                    (r2.type === "连" && r2.second === "中"));
+            }
+            return (r2.type === "连" && r2.second === r1.second) || r2.type === "散";
+    }
+};
+const hashPoint = (point) => `${point[0]}-${point[1]}`;
+const findCorners = (renderedGlyph) => {
+    const extremes = [];
+    const pointToStroke = new Map();
+    for (const [strokeIndex, { curveList }] of renderedGlyph.entries()) {
+        const subExtremes = [];
+        for (const [curveIndex, curve] of curveList.entries()) {
+            const [start, end] = getBoundingBox(curve);
+            if (curveIndex === 0)
+                subExtremes.push(start);
+            subExtremes.push(end);
+        }
+        for (const point of subExtremes) {
+            const hash = hashPoint(point);
+            if (!pointToStroke.has(hash))
+                pointToStroke.set(hash, strokeIndex);
+        }
+        extremes.push(...subExtremes);
+    }
+    const topLeft = minBy(extremes, (p) => distance(p, [0, 0]));
+    const topRight = minBy(extremes, (p) => distance(p, [100, 0]));
+    const bottomLeft = minBy(extremes, (p) => distance(p, [0, 100]));
+    const bottomRight = minBy(extremes, (p) => distance(p, [100, 100]));
+    return [topLeft, topRight, bottomLeft, bottomRight].map((point) => pointToStroke.get(hashPoint(point)));
+};
+const findTopology = (renderedGlyph) => {
+    const topology = { matrix: [], orientedPairs: [] };
+    for (const [index1, stroke1] of renderedGlyph.entries()) {
+        const row = [];
+        for (const [index2, stroke2] of renderedGlyph.entries()) {
+            if (index1 === index2)
+                row.push([]);
+            else
+                row.push(strokeRelation(stroke1, stroke2));
+        }
+        topology.matrix.push(row);
+    }
+    for (const [index1] of renderedGlyph.entries()) {
+        for (const [index2] of renderedGlyph.entries()) {
+            if (index2 >= index1)
+                break;
+            const relations = topology.matrix[index1]?.[index2];
+            if (relations.some((v) => v.type === "交" || v.type === "连"))
+                continue;
+            const parallelIndex = relations.findIndex((v) => v.type === "平行" && v.mainAxis === 0);
+            if (parallelIndex !== -1) {
+                topology.orientedPairs.push([index1, index2]);
+            }
+            // 想要严谨判断同向笔画特别困难，先不搞了
+            // if (parallelIndex === -1) continue;
+            // // drop this shit and compute from ab initio
+            // const index2Curves = renderedGlyph[index2]!.curveList;
+            // // we have: parallelIndex = index1Index * index2Curves + index2Index
+            // const index2Index = parallelIndex % index2Curves.length;
+            // const index1Index = (parallelIndex - index2Index) / index2Curves.length;
+            // // get all curves from all strokes other than k and l
+            // const otherStrokes = [...renderedGlyph.keys()].filter(
+            //   (_, index) => index !== index1 && index !== index2
+            // );
+            // if (
+            //   otherStrokes.every((x) => {
+            //     const r1 = topology.matrix[x]![index1]![index1Index]!;
+            //     const r2 = topology.matrix[x]![index2]![index2Index]!;
+            //     return isConforming(r1, r2) && isConforming(r2, r1);
+            //   })
+            // ) {
+            //   topology.orientedPairs.push([index1, index2]);
+            // }
+        }
+    }
+    return topology;
+};
+export { isConforming, curveRelation, strokeRelation, renderSVGStroke, renderSVGGlyph, findTopology, findCorners, };

package/dist/transformer.d.ts

@@ -0,0 +1,18 @@
+import type { Operator, Repertoire } from "./data.js";
+export interface 变换器 {
+    from: 模式;
+    to: 模式;
+}
+export type 节点类型 = 模式 | 结构变量 | string;
+export interface 模式 {
+    operator: Operator;
+    operandList: (string | 模式 | 结构变量)[];
+}
+export interface 结构变量 {
+    id: number;
+}
+export declare function isVariable(x: any): x is 结构变量;
+/**
+ * 应用变换器到数据库，返回新的数据库。
+ */
+export declare function 应用变换器(字库: Repertoire, 变换器: 变换器): Repertoire;

package/dist/transformer.js

@@ -0,0 +1,111 @@
+export function isVariable(x) {
+    return x && typeof x.id === "number";
+}
+/**
+ * 把 replacement pattern / variable / string 扁平化并写入 dbOut，返回引用该子树的 key。
+ * - 模式中的字符串直接视为已有的键引用
+ * - 变量使用 varMap 中绑定的键
+ * - 嵌套 pattern 递归生成子键
+ */
+function 替换(项, 映射, 输出, 签名缓存, 生成计数, 目标字符) {
+    if (typeof 项 === "string")
+        return 项;
+    if (isVariable(项)) {
+        const k = 映射[项.id];
+        if (!k)
+            throw new Error(`unbound variable $${项.id}`);
+        return k;
+    }
+    // Pattern
+    const 子键们 = 项.operandList.map((op) => 替换(op, 映射, 输出, 签名缓存, 生成计数));
+    const sig = `${项.operator}:${子键们.join(",")}`;
+    if (目标字符 === undefined) {
+        const existing = 签名缓存.get(sig);
+        if (existing)
+            return existing;
+    }
+    const 字符 = 目标字符 ?? String.fromCodePoint(生成计数.c++);
+    const 复合体 = {
+        type: "compound",
+        operator: 项.operator,
+        operandList: 子键们,
+    };
+    输出[字符] = {
+        unicode: 字符.codePointAt(0),
+        gb2312: 0,
+        tygf: 0,
+        gf0014_id: null,
+        gf3001_id: null,
+        name: null,
+        glyph: 复合体,
+        readings: [],
+    };
+    签名缓存.set(sig, 字符);
+    return 字符;
+}
+/**
+ * 在数据库上匹配模式到某个键（按需展开并递归调用自身），
+ * 变量绑定为子键字符串。
+ */
+function 匹配模式到键(模式, 字符, 变量映射, 字库) {
+    const 复合体 = 字库[字符]?.glyph;
+    if (!复合体 || 复合体.type !== "compound")
+        return false;
+    if (模式.operator !== 复合体.operator)
+        return false;
+    if (模式.operandList.length !== 复合体.operandList.length)
+        return false;
+    for (let i = 0; i < 模式.operandList.length; i++) {
+        const 操作数 = 模式.operandList[i];
+        const 子键 = 复合体.operandList[i];
+        if (typeof 操作数 === "string") {
+            if (子键 !== 操作数)
+                return false;
+        }
+        else if (isVariable(操作数)) {
+            const id = 操作数.id;
+            const 已绑定 = 变量映射[id];
+            if (已绑定 === undefined) {
+                变量映射[id] = 子键;
+            }
+            else {
+                if (已绑定 !== 子键)
+                    return false;
+            }
+        }
+        else {
+            // 嵌套 pattern，递归匹配对应的子键
+            if (!匹配模式到键(操作数, 子键, 变量映射, 字库))
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * 应用变换器到数据库，返回新的数据库。
+ */
+export function 应用变换器(字库, 变换器) {
+    // 逐键匹配（按需展开）
+    const 匹配集合 = new Map();
+    const 签名缓存 = new Map();
+    let 新字符起始码位 = 0x100000;
+    for (const 字符 of Object.keys(字库)) {
+        const 码位 = 字符.codePointAt(0);
+        if (码位 >= 0x100000) {
+            新字符起始码位 = Math.max(新字符起始码位, 码位 + 1);
+        }
+        const c = 字库[字符];
+        const sig = JSON.stringify(c.glyph);
+        签名缓存.set(sig, 字符);
+        const 变量映射 = {};
+        if (匹配模式到键(变换器.from, 字符, 变量映射, 字库)) {
+            匹配集合.set(字符, 变量映射);
+        }
+    }
+    const 输出数据库 = { ...字库 };
+    const 生成计数 = { c: 新字符起始码位 };
+    for (const [键, 变量映射] of 匹配集合) {
+        替换(变换器.to, 变量映射, 输出数据库, 签名缓存, 生成计数, 键);
+    }
+    return 输出数据库;
+}