hanzi-chai 0.3.0

package/dist/index.mjs

@@ -0,0 +1,3553 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/mathjs.ts
+var add = (a, b) => [a[0] + b[0], a[1] + b[1]];
+var subtract = (a, b) => [a[0] - b[0], a[1] - b[1]];
+var multiply = (a, b) => [a * b[0], a * b[1]];
+var divide = (a, b) => [a[0] / b, a[1] / b];
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1];
+var mean = (a) => (a[0] + a[1]) / 2;
+var distance = (a, b) => Math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2);
+
+// src/affine.ts
+import { cloneDeep } from "lodash-es";
+var Affine = class {
+  constructor(xscale, yscale, translate = [0, 0]) {
+    __publicField(this, "xscale");
+    __publicField(this, "yscale");
+    __publicField(this, "translate");
+    this.xscale = xscale;
+    this.yscale = yscale;
+    this.translate = translate;
+  }
+  transformDraw(draw) {
+    const next = cloneDeep(draw);
+    switch (next.command) {
+      case "h":
+        next.parameterList[0] *= this.xscale;
+        break;
+      case "v":
+        next.parameterList[0] *= this.yscale;
+        break;
+      case "c":
+      case "z":
+        for (const index of [0, 2, 4]) {
+          next.parameterList[index] *= this.xscale;
+          next.parameterList[index + 1] *= this.yscale;
+        }
+        break;
+    }
+    return next;
+  }
+  transformSVGStroke(stroke) {
+    const [x, y] = stroke.start;
+    const start = add(
+      [x * this.xscale, y * this.yscale],
+      this.translate
+    );
+    const next = {
+      ...stroke,
+      start,
+      curveList: stroke.curveList.map((c) => this.transformDraw(c))
+    };
+    return next;
+  }
+  transformSVGGlyph(glyph) {
+    return glyph.map((x) => this.transformSVGStroke(x));
+  }
+};
+var id = new Affine(1, 1);
+var left = new Affine(0.5, 1);
+var right = new Affine(0.5, 1, [50, 0]);
+var top = new Affine(1, 0.5);
+var bottom = new Affine(1, 0.5, [0, 50]);
+var leftThird = new Affine(0.33, 1);
+var centerThird = new Affine(0.33, 1, [33, 0]);
+var rightThird = new Affine(0.33, 1, [66, 0]);
+var topThird = new Affine(1, 0.33);
+var middleThird = new Affine(1, 0.33, [0, 33]);
+var bottomThird = new Affine(1, 0.33, [0, 66]);
+var affineMap = {
+  "\u2FF0": [left, right],
+  "\u2FF1": [top, bottom],
+  "\u2FF2": [leftThird, centerThird, rightThird],
+  "\u2FF3": [topThird, middleThird, bottomThird],
+  "\u2FF4": [id, new Affine(0.5, 0.5, [25, 25])],
+  "\u2FF5": [id, new Affine(0.5, 0.5, [25, 40])],
+  "\u2FF6": [id, new Affine(0.5, 0.5, [25, 10])],
+  "\u2FF7": [id, new Affine(0.5, 0.5, [40, 25])],
+  "\u2FF8": [id, new Affine(0.5, 0.5, [40, 40])],
+  "\u2FF9": [id, new Affine(0.5, 0.5, [10, 40])],
+  "\u2FFA": [id, new Affine(0.5, 0.5, [40, 10])],
+  "\u2FFC": [id, new Affine(0.5, 0.5, [10, 25])],
+  "\u2FFD": [id, new Affine(0.5, 0.5, [10, 10])],
+  "\u2FFB": [id, id],
+  "\u2FFE": [id],
+  "\u2FFF": [id]
+};
+function affineMerge(compound, glyphList) {
+  const { operator, order: order3, parameters } = compound;
+  const transformedGlyphs = [];
+  const boundingBox = { x: [0, 100], y: [0, 100] };
+  if (["\u2FF0", "\u2FF2", "\u2FF1", "\u2FF3"].includes(operator)) {
+    let mainAxisOffset = 0;
+    const isLR = ["\u2FF0", "\u2FF2"].includes(operator);
+    for (const [index, { strokes, box }] of glyphList.entries()) {
+      const mainAxisLength = isLR ? box.x[1] - box.x[0] : box.y[1] - box.y[0];
+      if (index === 0) {
+        transformedGlyphs.push(structuredClone(strokes));
+        boundingBox.x = structuredClone(box.x);
+        boundingBox.y = structuredClone(box.y);
+        mainAxisOffset = isLR ? box.x[1] : box.y[1];
+        continue;
+      }
+      let gap = 20;
+      if (index === 1 && parameters?.gap2 !== void 0) {
+        gap = parameters.gap2;
+      } else if (index === 2 && parameters?.gap3 !== void 0) {
+        gap = parameters.gap3;
+      }
+      mainAxisOffset += gap;
+      const increase = gap + mainAxisLength;
+      let affine;
+      if (isLR) {
+        affine = new Affine(1, 1, [mainAxisOffset - box.x[0], 0]);
+        boundingBox.x[1] += increase;
+        boundingBox.y[0] = Math.min(boundingBox.y[0], box.y[0]);
+        boundingBox.y[1] = Math.max(boundingBox.y[1], box.y[1]);
+      } else {
+        affine = new Affine(1, 1, [0, mainAxisOffset - box.y[0]]);
+        boundingBox.y[1] += increase;
+        boundingBox.x[0] = Math.min(boundingBox.x[0], box.x[0]);
+        boundingBox.x[1] = Math.max(boundingBox.x[1], box.x[1]);
+      }
+      transformedGlyphs.push(affine.transformSVGGlyph(strokes));
+      mainAxisOffset += mainAxisLength;
+    }
+  } else {
+    for (const [index, affine] of affineMap[operator].entries()) {
+      const transformed = affine.transformSVGGlyph(glyphList[index].strokes);
+      transformedGlyphs.push(transformed);
+    }
+  }
+  const result = [];
+  if (order3 === void 0) {
+    result.push(...transformedGlyphs.flat());
+  } else {
+    for (const { index, strokes } of order3) {
+      const glyph = transformedGlyphs[index];
+      if (glyph === void 0)
+        continue;
+      if (strokes === 0) {
+        result.push(...glyph);
+      } else {
+        result.push(...glyph.slice(0, strokes));
+        transformedGlyphs[index] = glyph.slice(strokes);
+      }
+    }
+  }
+  const merged = {
+    strokes: result,
+    box: boundingBox
+  };
+  return merged;
+}
+
+// src/element.ts
+var pronunciationElementTypes = [
+  "\u58F0\u6BCD",
+  "\u53CC\u62FC\u58F0\u6BCD",
+  "\u97F5\u6BCD",
+  "\u53CC\u62FC\u97F5\u6BCD",
+  "\u58F0\u8C03",
+  "\u9996\u5B57\u6BCD",
+  "\u672B\u5B57\u6BCD"
+];
+var r = String.raw;
+var defaultAlgebra = {
+  \u58F0\u6BCD: [
+    { type: "xform", from: "^([bpmfdtnlgkhjqxzcsr]h?|^).+$", to: "$1" },
+    { type: "xform", from: "^$", to: "0" }
+  ],
+  \u97F5\u6BCD: [
+    // 恢复 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" }
+  ],
+  \u53CC\u62FC\u58F0\u6BCD: [
+    { type: "xform", from: "^([bpmfdtnlgkhjqxzcsryw]h?|^).+$", to: "$1" },
+    { type: "xform", from: "^$", to: "0" }
+  ],
+  \u53CC\u62FC\u97F5\u6BCD: [{ type: "xform", from: r`^.*?([aeêiouv].*|m|ng?)\d$`, to: "$1" }],
+  \u58F0\u8C03: [{ type: "xform", from: r`.+(\d)`, to: "$1" }],
+  \u9996\u5B57\u6BCD: [{ type: "xform", from: r`^(.).+`, to: "$1" }],
+  \u672B\u5B57\u6BCD: [{ type: "xform", from: r`.*(.)\d`, to: "$1" }]
+};
+var 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}`;
+};
+var renderName = (object) => {
+  switch (object.type) {
+    case "\u6C49\u5B57":
+    case "\u7ED3\u6784":
+      return object.type;
+    case "\u56FA\u5B9A":
+      return object.key;
+    case "\u5B57\u97F3":
+      return object.subtype;
+    case "\u5B57\u6839":
+      return `\u6839 ${object.rootIndex}`;
+    case "\u7B14\u753B":
+      return `\u6839 ${object.rootIndex} \u7B14 ${object.strokeIndex}`;
+    case "\u4E8C\u7B14":
+      return `\u6839 ${object.rootIndex} \u7B14 (${object.strokeIndex * 2 - Math.sign(object.strokeIndex)}, ${object.strokeIndex * 2})`;
+    case "\u81EA\u5B9A\u4E49":
+      return `${object.subtype} ${object.rootIndex}`;
+    case "\u7279\u6B8A":
+      return object.subtype;
+  }
+};
+var renderList = (object) => {
+  const list = [object.type];
+  switch (object.type) {
+    case "\u56FA\u5B9A":
+      return [...list, object.key];
+    case "\u5B57\u97F3":
+      return [...list, object.subtype];
+    case "\u5B57\u6839":
+      return [...list, object.rootIndex];
+    case "\u7B14\u753B":
+      return [...list, object.rootIndex, object.strokeIndex];
+    case "\u4E8C\u7B14":
+      return [...list, object.rootIndex, object.strokeIndex];
+    case "\u81EA\u5B9A\u4E49":
+      return [...list, object.subtype, object.rootIndex];
+    case "\u7279\u6B8A":
+      return [...list, object.subtype];
+  }
+  return list;
+};
+var parseList = (value) => {
+  const type = value[0];
+  switch (type) {
+    case "\u56FA\u5B9A":
+      return { type, key: value[1] };
+    case "\u5B57\u97F3":
+      return { type, subtype: value[1] };
+    case "\u5B57\u6839":
+      return { type, rootIndex: value[1] };
+    case "\u7B14\u753B":
+      return {
+        type,
+        rootIndex: value[1],
+        strokeIndex: value[2]
+      };
+    case "\u4E8C\u7B14":
+      return {
+        type,
+        rootIndex: value[1],
+        strokeIndex: value[2]
+      };
+    case "\u81EA\u5B9A\u4E49":
+      return {
+        type,
+        subtype: value[1],
+        rootIndex: value[2]
+      };
+    case "\u7279\u6B8A":
+      return { type, subtype: value[1] };
+  }
+  return { type };
+};
+function signedIndex(a, i) {
+  return i >= 0 ? a[i - 1] : a[a.length + i];
+}
+var algebraCache = /* @__PURE__ */ new Map();
+var zhangmaSupplement = (result, { rootSequence }) => {
+  const coalesce = (n) => {
+    if (n === 6)
+      return 2;
+    if (n === 7)
+      return 5;
+    return n;
+  };
+  const { sequence } = result;
+  const first2 = rootSequence.get(sequence[0]);
+  const last = rootSequence.get(sequence[sequence.length - 1]);
+  const firstfirst = coalesce(first2[0]);
+  const lastlast = coalesce(last.at(-1));
+  if (sequence.length === 1 && first2.length === 1) {
+    return "61";
+  }
+  return result.operator && /[⿰⿲⿺]/.test(result.operator) ? `${firstfirst}${lastlast}` : `${lastlast}${firstfirst}`;
+};
+var zhangmaPseudoRoot = (result) => {
+  if (!("best" in result))
+    return "0";
+  const { best } = result;
+  return best.scheme.length === 2 && best.evaluation.get("\u80FD\u8FDE\u4E0D\u4EA4") ? "1" : "0";
+};
+var specialElementHandlers = {
+  \u5F20\u7801\u8865\u7801: zhangmaSupplement,
+  \u5F20\u7801\u51C6\u7801\u5143: zhangmaPseudoRoot
+};
+var 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 "\u6C49\u5B57":
+      return result.char;
+    case "\u56FA\u5B9A":
+      return object.key;
+    case "\u7ED3\u6784":
+      if ("operator" in result) {
+        return result.operator;
+      }
+      return void 0;
+    case "\u5B57\u97F3":
+      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 "\u5B57\u6839":
+      return signedIndex(sequence, object.rootIndex);
+    case "\u7B14\u753B":
+    case "\u4E8C\u7B14":
+      root = signedIndex(sequence, object.rootIndex);
+      if (root === void 0)
+        return void 0;
+      strokes = extra.rootSequence.get(root);
+      if (strokes === void 0) {
+        if (Math.abs(object.strokeIndex) === 1)
+          return root;
+        return void 0;
+      }
+      if (object.type === "\u7B14\u753B") {
+        const number = signedIndex(strokes, object.strokeIndex);
+        return number?.toString();
+      }
+      stroke1 = signedIndex(
+        strokes,
+        object.strokeIndex * 2 - Math.sign(object.strokeIndex)
+      );
+      if (stroke1 === void 0)
+        return void 0;
+      stroke2 = signedIndex(strokes, object.strokeIndex * 2);
+      return [stroke1, stroke2 ?? 0].join("");
+    case "\u81EA\u5B9A\u4E49":
+      return signedIndex(result.custom[object.subtype] ?? [], object.rootIndex);
+    case "\u7279\u6B8A":
+      return specialElementHandlers[object.subtype]?.(result, extra);
+  }
+};
+
+// src/bezier.ts
+var sortTwoNumbers = (ar) => ar.sort((a, b) => a - b);
+var getBoundingBox = (a) => [a.controls[0], a.controls[a.controls.length - 1]];
+var getIntervalOnOrientation = (a) => {
+  const start = a.controls[0];
+  const end = a.controls.at(-1);
+  const i1 = sortTwoNumbers([start[0], end[0]]);
+  const i2 = sortTwoNumbers([start[1], end[1]]);
+  if (a.orientation === "horizontal") {
+    return [i1, i2];
+  }
+  return [i2, i1];
+};
+var evaluate = (a, t) => {
+  if (a.type === "linear") {
+    return add(
+      multiply(1 - t, a.controls[0]),
+      multiply(t, a.controls[1])
+    );
+  }
+  if (a.type === "arc") {
+    return [0, 0];
+  }
+  const v01 = add(
+    multiply((1 - t) ** 3, a.controls[0]),
+    multiply(3 * (1 - t) ** 2 * t, a.controls[1])
+  );
+  const v23 = add(
+    multiply(3 * (1 - t) * t ** 2, a.controls[2]),
+    multiply(t ** 3, a.controls[3])
+  );
+  return add(v01, v23);
+};
+var makeCurve = (start, { command, parameterList }) => {
+  if (command === "a") {
+    return {
+      type: "arc",
+      orientation: "horizontal",
+      controls: [start, start]
+    };
+  }
+  if (command === "c" || command === "z") {
+    const p12 = add(start, parameterList.slice(0, 2));
+    const p2 = add(start, parameterList.slice(2, 4));
+    const p3 = add(start, parameterList.slice(4));
+    return {
+      type: "cubic",
+      orientation: command === "c" ? "vertical" : "horizontal",
+      controls: [start, p12, p2, p3]
+    };
+  }
+  let p1;
+  switch (command) {
+    case "h":
+      p1 = add(start, [parameterList[0], 0]);
+      break;
+    case "v":
+      p1 = add(start, [0, parameterList[0]]);
+      break;
+  }
+  return {
+    type: "linear",
+    orientation: command === "v" ? "vertical" : "horizontal",
+    controls: [start, p1]
+  };
+};
+var render = ({ feature, start, curveList }) => {
+  const r2 = { 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];
+    r2.curveList.push(curve);
+  }
+  return r2;
+};
+var area = (p, q) => p[0] * q[1] - p[1] * q[0];
+var getIntervalPosition = (i, j) => {
+  const [imin, imax] = i.sort((a, b) => a - b);
+  const [jmin, jmax] = j.sort((a, b) => a - b);
+  if (imax < jmin)
+    return -1;
+  if (imin > jmax)
+    return 1;
+  if (imin < jmin && imax < jmax)
+    return -0.5;
+  if (imin > jmin && imax > jmax)
+    return 0.5;
+  return 0;
+};
+var findCrossPoint = (a, at, b, bt) => {
+  const [astart, aend] = [evaluate(a, at[0]), evaluate(a, at[1])];
+  const [bstart, bend] = [evaluate(b, bt[0]), evaluate(b, bt[1])];
+  const xposition = getIntervalPosition(
+    [astart[0], aend[0]],
+    [bstart[0], bend[0]]
+  );
+  const yposition = getIntervalPosition(
+    [astart[1], aend[1]],
+    [bstart[1], bend[1]]
+  );
+  const totallyDisjoint = [-1, 1];
+  if (totallyDisjoint.includes(xposition) || totallyDisjoint.includes(yposition))
+    return void 0;
+  const [alength, blength] = [distance(astart, aend), distance(bstart, bend)];
+  const threshold = 1;
+  if (alength < threshold && blength < threshold)
+    return divide(add(add(astart, aend), add(bstart, bend)), 4);
+  const [atmid, btmid] = [mean(at), mean(bt)];
+  const a_firsthalf = [at[0], atmid];
+  const a_secondhalf = [atmid, at[1]];
+  const b_firsthalf = [bt[0], btmid];
+  const b_secondhalf = [btmid, bt[1]];
+  return findCrossPoint(a, a_firsthalf, b, b_firsthalf) || findCrossPoint(a, a_firsthalf, b, b_secondhalf) || findCrossPoint(a, a_secondhalf, b, b_firsthalf) || findCrossPoint(a, a_secondhalf, b, b_secondhalf);
+};
+var isCollinear = (from, to, point) => {
+  const [u, v] = [subtract(to, point), subtract(from, point)];
+  return area(u, v) === 0 && dot(u, v) < 0;
+};
+var curveLength = (curve) => {
+  const [start, end] = getBoundingBox(curve);
+  return distance(start, end);
+};
+var sort = (a) => a.sort((a2, b) => a2 - b);
+var contains = (r1, r2) => {
+  return r1[0] <= r2[0] && r1[1] >= r2[1];
+};
+var _isBoundedBy = (curve, xrange, yrange) => {
+  const [start, end] = getBoundingBox(curve);
+  const thisXRange = sort([start[0], end[0]]);
+  const thisYRange = sort([start[1], end[1]]);
+  return contains(xrange, thisXRange) && contains(yrange, thisYRange);
+};
+var isBoundedBy = (stroke, xrange, yrange) => {
+  return stroke.curveList.every((x) => _isBoundedBy(x, xrange, yrange));
+};
+
+// src/topology.ts
+import { isEqual, minBy } from "lodash-es";
+var makeAttachRelation = (first2, second) => ({ type: "\u8FDE", first: first2, second });
+var 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: "\u5E73\u884C", mainAxis: mainPosition, crossAxis: crossPosition };
+};
+var getDisjointRelation = (a, b) => {
+  if (a.orientation === b.orientation)
+    return getParallelRelation(a, b);
+  const [astart, aend] = getBoundingBox(a);
+  const [bstart, bend] = getBoundingBox(b);
+  return {
+    type: "\u6563",
+    x: getIntervalPosition([astart[0], aend[0]], [bstart[0], bend[0]]),
+    y: getIntervalPosition([astart[1], aend[1]], [bstart[1], bend[1]])
+  };
+};
+var getAttachRelation = (a, b) => {
+  const [astart, aend] = getBoundingBox(a);
+  const [bstart, bend] = getBoundingBox(b);
+  if (isEqual(astart, bstart))
+    return makeAttachRelation("\u524D", "\u524D");
+  if (isEqual(astart, bend))
+    return makeAttachRelation("\u524D", "\u540E");
+  if (isEqual(aend, bstart))
+    return makeAttachRelation("\u540E", "\u524D");
+  if (isEqual(aend, bend))
+    return makeAttachRelation("\u540E", "\u540E");
+  if (a.type === "linear") {
+    if (isCollinear(astart, aend, bstart))
+      return makeAttachRelation("\u4E2D", "\u524D");
+    if (isCollinear(astart, aend, bend))
+      return makeAttachRelation("\u4E2D", "\u540E");
+  }
+  if (b.type === "linear") {
+    if (isCollinear(bstart, bend, astart))
+      return makeAttachRelation("\u524D", "\u4E2D");
+    if (isCollinear(bstart, bend, aend))
+      return makeAttachRelation("\u540E", "\u4E2D");
+  }
+};
+var 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: "\u4EA4" };
+  }
+  return getDisjointRelation(a, b);
+};
+var genericRelation = (a, b) => {
+  const crossPoint = findCrossPoint(a, [0, 1], b, [0, 1]);
+  if (crossPoint === void 0)
+    return getDisjointRelation(a, b);
+  const [astart, aend] = getBoundingBox(a);
+  const [bstart, bend] = getBoundingBox(b);
+  const distanceThreshold = 3;
+  if (distance(crossPoint, astart) < distanceThreshold)
+    return makeAttachRelation("\u524D", "\u4E2D");
+  if (distance(crossPoint, aend) < distanceThreshold)
+    return makeAttachRelation("\u540E", "\u4E2D");
+  if (distance(crossPoint, bstart) < distanceThreshold)
+    return makeAttachRelation("\u4E2D", "\u524D");
+  if (distance(crossPoint, bend) < distanceThreshold)
+    return makeAttachRelation("\u4E2D", "\u540E");
+  return { type: "\u4EA4" };
+};
+var curveRelation = (c1, c2) => {
+  const relation = getAttachRelation(c1, c2);
+  if (relation !== void 0)
+    return relation;
+  if (c1.type === "linear" && c2.type === "linear") {
+    return linearRelation(c1, c2);
+  }
+  return genericRelation(c1, c2);
+};
+var strokeRelation = (stroke1, stroke2) => {
+  const strokeRelation2 = [];
+  for (const curve1 of stroke1.curveList) {
+    for (const curve2 of stroke2.curveList) {
+      strokeRelation2.push(curveRelation(curve1, curve2));
+    }
+  }
+  return strokeRelation2;
+};
+var renderSVGStroke = ({ feature, start, curveList }) => {
+  const r2 = { 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];
+    r2.curveList.push(curve);
+  }
+  return r2;
+};
+var renderSVGGlyph = (glyph) => glyph.map(renderSVGStroke);
+var isConforming = (r1, r2) => {
+  switch (r1.type) {
+    case "\u5E73\u884C":
+      return r2.type === "\u5E73\u884C";
+    case "\u6563":
+      return true;
+    case "\u4EA4":
+      return r2.type === "\u4EA4" || r2.type === "\u8FDE" && r2.second === "\u4E2D" || r2.type === "\u6563";
+    case "\u8FDE":
+      if (r1.second === "\u4E2D") {
+        return r2.type === "\u4EA4" || r2.type === "\u6563" || r2.type === "\u8FDE" && r2.second === "\u4E2D";
+      }
+      return r2.type === "\u8FDE" && r2.second === r1.second || r2.type === "\u6563";
+  }
+};
+var hashPoint = (point) => `${point[0]}-${point[1]}`;
+var findCorners = (renderedGlyph) => {
+  const extremes = [];
+  const pointToStroke = /* @__PURE__ */ 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))
+  );
+};
+var 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 === "\u4EA4" || v.type === "\u8FDE"))
+        continue;
+      const parallelIndex = relations.findIndex(
+        (v) => v.type === "\u5E73\u884C" && v.mainAxis === 0
+      );
+      if (parallelIndex !== -1) {
+        topology.orientedPairs.push([index1, index2]);
+      }
+    }
+  }
+  return topology;
+};
+
+// src/data.ts
+var operators = [
+  "\u2FF0",
+  "\u2FF1",
+  "\u2FF2",
+  "\u2FF3",
+  "\u2FF4",
+  "\u2FF5",
+  "\u2FF6",
+  "\u2FF7",
+  "\u2FF8",
+  "\u2FF9",
+  "\u2FFA",
+  "\u2FFB",
+  "\u2FFC",
+  "\u2FFD",
+  "\u2FFE",
+  "\u2FFF"
+];
+
+// src/config.ts
+var characterSetSpecifiers = [
+  "minimal",
+  "gb2312",
+  "general",
+  "basic",
+  "extended",
+  "supplement",
+  "maximal",
+  "custom"
+];
+function isVariableKey(key) {
+  return typeof key === "object" && key !== null && "variable" in key;
+}
+function isMerge(value) {
+  return typeof value === "object" && value !== null && "element" in value;
+}
+var binaryOps = [
+  "\u662F",
+  "\u4E0D\u662F",
+  "\u5339\u914D",
+  "\u4E0D\u5339\u914D",
+  "\u7F16\u7801\u5339\u914D",
+  "\u7F16\u7801\u4E0D\u5339\u914D"
+];
+var unaryOps = ["\u5B58\u5728", "\u4E0D\u5B58\u5728"];
+var ops = unaryOps.concat(...binaryOps);
+var wordLengthArray = [...Array(9).keys()].map((x) => ({
+  label: x + 1,
+  value: x + 1
+}));
+var fingeringLabels = [
+  "\u540C\u624B",
+  "\u5927\u8DE8",
+  "\u5C0F\u8DE8",
+  "\u5E72\u6270",
+  "\u9519\u624B",
+  "\u4E09\u8FDE",
+  "\u5907\u7528",
+  "\u5907\u7528"
+];
+var defaultOptimization = {
+  objective: {},
+  metaheuristic: {
+    algorithm: "SimulatedAnnealing"
+  }
+};
+
+// src/classifier.ts
+var classifier = {
+  \u6A2A: 1,
+  \u63D0: 1,
+  \u7AD6: 2,
+  \u7AD6\u94A9: 2,
+  \u6487: 3,
+  \u5E73\u6487: 3,
+  \u70B9: 4,
+  \u5E73\u70B9: 4,
+  \u637A: 4,
+  \u5E73\u637A: 4,
+  \u6311\u637A: 4,
+  \u6A2A\u94A9: 5,
+  \u6A2A\u6487: 5,
+  \u6A2A\u6298: 5,
+  \u6A2A\u6298\u94A9: 5,
+  \u6A2A\u659C\u94A9: 5,
+  \u6A2A\u6298\u63D0: 5,
+  \u6A2A\u6298\u6298: 5,
+  \u6A2A\u6298\u5F2F: 5,
+  \u6A2A\u6487\u5F2F\u94A9: 5,
+  \u6A2A\u6298\u5F2F\u94A9: 5,
+  \u6A2A\u659C\u5F2F\u94A9: 5,
+  \u6A2A\u6298\u6298\u6487: 5,
+  \u6A2A\u6298\u6298\u6298: 5,
+  \u6A2A\u6298\u6298\u6298\u94A9: 5,
+  \u7AD6\u63D0: 5,
+  \u7AD6\u6298: 5,
+  \u7AD6\u5F2F: 5,
+  \u7AD6\u5F2F\u5DE6: 5,
+  \u7AD6\u5F2F\u94A9: 5,
+  \u7AD6\u6298\u6487: 5,
+  \u7AD6\u6298\u6298\u94A9: 5,
+  \u7AD6\u6298\u6298: 5,
+  \u6487\u70B9: 5,
+  \u6487\u6298: 5,
+  \u5F2F\u94A9: 5,
+  \u659C\u94A9: 5,
+  \u6487\u94A9: 5,
+  \u5367\u94A9: 5,
+  \u5708: 5,
+  \u7279\u6B8A\u7B14\u753B: 5
+};
+var mergeClassifier = (partialClassifier) => {
+  return { ...classifier, ...partialClassifier ?? {} };
+};
+var schema = {
+  \u6A2A: ["h"],
+  \u63D0: ["h"],
+  // 美化：提
+  \u7AD6: ["v"],
+  \u7AD6\u94A9: ["v"],
+  // 美化：钩
+  \u6487: ["c"],
+  \u5E73\u6487: ["z"],
+  \u70B9: ["c"],
+  \u5E73\u70B9: ["z"],
+  \u637A: ["c"],
+  \u5E73\u637A: ["z"],
+  \u6311\u637A: ["h", "c"],
+  \u6A2A\u94A9: ["h"],
+  // 美化：钩
+  \u6A2A\u6487: ["h", "c"],
+  \u6A2A\u6298: ["h", "v"],
+  \u6A2A\u6298\u94A9: ["h", "v"],
+  // 美化：钩
+  \u6A2A\u659C\u94A9: ["h", "c"],
+  // 美化：钩
+  \u6A2A\u6298\u63D0: ["h", "v", "h"],
+  // 美化：提
+  \u6A2A\u6298\u6298: ["h", "v", "h"],
+  \u6A2A\u6298\u5F2F: ["h", "v", "h"],
+  \u6A2A\u6487\u5F2F\u94A9: ["h", "c", "v"],
+  // 美化：钩
+  \u6A2A\u6298\u5F2F\u94A9: ["h", "v", "h"],
+  // 美化：钩
+  \u6A2A\u659C\u5F2F\u94A9: ["h", "c"],
+  // 美化：钩
+  \u6A2A\u6298\u6298\u6487: ["h", "v", "h", "c"],
+  \u6A2A\u6298\u6298\u6298: ["h", "v", "h", "v"],
+  \u6A2A\u6298\u6298\u6298\u94A9: ["h", "v", "h", "v"],
+  // 美化：钩
+  \u7AD6\u63D0: ["v", "h"],
+  // 美化：提
+  \u7AD6\u6298: ["v", "h"],
+  \u7AD6\u5F2F: ["v", "h"],
+  \u7AD6\u5F2F\u5DE6: ["v", "h"],
+  \u7AD6\u5F2F\u94A9: ["v", "h"],
+  // 美化：钩
+  \u7AD6\u6298\u6487: ["v", "h", "c"],
+  \u7AD6\u6298\u6298\u94A9: ["v", "h", "v"],
+  // 美化：钩
+  \u7AD6\u6298\u6298: ["v", "h", "v"],
+  \u6487\u70B9: ["c", "c"],
+  \u6487\u6298: ["c", "h"],
+  \u5F2F\u94A9: ["v"],
+  // 美化：钩
+  \u659C\u94A9: ["c"],
+  // 美化：钩
+  \u6487\u94A9: ["c"],
+  // 美化：钩
+  \u5367\u94A9: ["c"],
+  // 美化：钩
+  \u5708: ["a"],
+  \u7279\u6B8A\u7B14\u753B: ["c"]
+};
+
+// src/repertoire.ts
+import { isEqual as isEqual4, sortBy as sortBy2 } from "lodash-es";
+
+// src/degenerator.ts
+import { isEqual as isEqual2 } from "lodash-es";
+var indicesToBinary = (n) => (indices) => {
+  let binaryCode = 0;
+  for (const index of indices) {
+    binaryCode += 1 << n - index - 1;
+  }
+  return binaryCode;
+};
+var binaryToIndices = (n) => (binary) => {
+  const indices = [...Array(n).keys()];
+  return indices.filter((index) => binary & 1 << n - index - 1);
+};
+var defaultDegenerator = {
+  feature: {
+    \u63D0: "\u6A2A",
+    \u637A: "\u70B9"
+  },
+  no_cross: false
+};
+var strokeFeatureEqual = (degenerator, s1, s2) => {
+  const feature = degenerator.feature ?? {};
+  const d1 = feature[s1] ?? s1;
+  const d2 = feature[s2] ?? s2;
+  return d1 === d2;
+};
+var verifySpecialRoots = (component, root, indices) => {
+  if (["\u571F", "\u58EB"].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 === "\u571F" ? lowerIsLonger : !lowerIsLonger;
+  }
+  if (["\u672A", "\u672B"].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 === "\u672A" ? lowerIsLonger : !lowerIsLonger;
+  }
+  if (["\u53E3", "\u56D7"].includes(root.name)) {
+    if (["\u56D7", "\uE02D"].includes(component.name)) {
+      return root.name === "\u56D7";
+    }
+    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(
+      (_2, index) => !indices.includes(index)
+    );
+    const containsStroke = otherStrokes.some(
+      (stroke) => isBoundedBy(stroke, xrange, yrange)
+    );
+    return root.name === "\u56D7" ? 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;
+};
+var 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(
+          (_2, i) => indexList.includes(i)
+        );
+        if (!isEqual2(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 !== "\u4EA4");
+      });
+    });
+  }
+  return queue.filter((x) => verifySpecialRoots(component, root, x)).map(indicesToBinary(cglyph.length));
+};
+var degenerate = (degenerator, glyph) => {
+  const featureMap = degenerator.feature ?? {};
+  return [
+    glyph.map((x) => x.feature).map((x) => featureMap[x] || x),
+    findTopology(glyph)
+  ];
+};
+
+// src/selector.ts
+import { isEqual as isEqual3 } from "lodash-es";
+var defaultSelector = [
+  "\u7ED3\u6784\u5B8C\u6574",
+  "\u6839\u5C11\u4F18\u5148",
+  "\u80FD\u8FDE\u4E0D\u4EA4",
+  "\u80FD\u6563\u4E0D\u8FDE",
+  "\u5168\u7B26\u7B14\u987A",
+  "\u53D6\u5927\u4F18\u5148"
+];
+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 === void 0)
+        return false;
+      if (v < u)
+        return true;
+      if (v > u)
+        return false;
+    }
+    return false;
+  }
+  return false;
+}
+var length = {
+  title: "\u6839\u5C11\u4F18\u5148",
+  key: (scheme) => scheme.length
+};
+var countStrokes = (n) => n < 2 ? n : (n & 1) + countStrokes(n >>> 1);
+var bias = {
+  title: "\u53D6\u5927\u4F18\u5148",
+  key: (scheme) => scheme.map(countStrokes).map((x) => -x),
+  display: (data) => `(${data.map((x) => -x).join(", ")})`
+};
+var unbias = {
+  title: "\u53D6\u5C0F\u4F18\u5148",
+  key: (scheme) => scheme.map(countStrokes),
+  display: (data) => `(${data.join(", ")})`
+};
+var order = {
+  title: "\u5168\u7B26\u7B14\u987A",
+  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);
+  }
+};
+var order2 = {
+  title: "\u8FDE\u7EED\u7B14\u987A",
+  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;
+  }
+};
+var similar = {
+  title: "\u975E\u5F62\u8FD1\u6839",
+  key: (scheme, { rootMap, secondaryRoots }) => {
+    const roots = scheme.map((x) => rootMap.get(x));
+    return roots.filter((x) => secondaryRoots.has(x)).length;
+  }
+};
+var strong = {
+  title: "\u591A\u5F3A\u5B57\u6839",
+  key: (scheme, { rootMap, analysis: analysis2 }) => {
+    const strong2 = analysis2?.strong || [];
+    const roots = scheme.map((x) => rootMap.get(x));
+    return -roots.filter((x) => strong2.includes(x)).length;
+  }
+};
+var weak = {
+  title: "\u5C11\u5F31\u5B57\u6839",
+  key: (scheme, { rootMap, analysis: analysis2 }) => {
+    const weak2 = analysis2?.weak || [];
+    const roots = scheme.map((x) => rootMap.get(x));
+    return roots.filter((x) => weak2.includes(x)).length;
+  }
+};
+var 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 r2 = 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];
+            r2 || (r2 = relations.some((v) => v.type === relationType));
+            a || (a = relations.some((v) => avoidRelationType.includes(v.type)));
+          }
+        }
+        if (!a)
+          totalCrosses += Number(r2);
+      }
+    }
+    return totalCrosses;
+  };
+  return { key, title };
+};
+var crossing = makeTopologySieve("\u4EA4", [], "\u80FD\u8FDE\u4E0D\u4EA4");
+var attaching = makeTopologySieve("\u8FDE", ["\u4EA4"], "\u80FD\u6563\u4E0D\u8FDE");
+var orientation = {
+  title: "\u540C\u5411\u7B14\u753B",
+  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 r2 = false;
+        for (const k of bi) {
+          for (const l of bj) {
+            const [smaller, larger] = sortTwoNumbers([k, l]);
+            const oriented = component.topology.orientedPairs.some(
+              (x) => isEqual3(x, [larger, smaller])
+            );
+            r2 || (r2 = oriented);
+          }
+        }
+        totalCrosses += Number(r2);
+      }
+    }
+    return totalCrosses;
+  }
+};
+var contains2 = (b1, b2) => (b1 | b2) === b1;
+var integrity = {
+  title: "\u7ED3\u6784\u5B8C\u6574",
+  key: (scheme, { rootMap }) => {
+    const priorities = [
+      "\u53E3",
+      "\u56D7",
+      "\u5182",
+      "\uE439",
+      "\u531A",
+      "\u51F5",
+      "\uE009",
+      "\u52F9",
+      "\u5C38",
+      "\uE407"
+    ];
+    const shouldHave = [...rootMap].filter(([_, name]) => priorities.includes(name)).map(([binary]) => binary);
+    const breaks = shouldHave.filter(
+      (x) => !scheme.some((binary) => contains2(binary, x))
+    ).length;
+    return breaks;
+  }
+};
+var sieveMap = new Map(
+  [
+    length,
+    order,
+    order2,
+    bias,
+    unbias,
+    crossing,
+    attaching,
+    similar,
+    orientation,
+    integrity,
+    strong,
+    weak
+  ].map((x) => [x.title, x])
+);
+var select = (config, component, schemeList, rootMap, requiredRoots) => {
+  const environment = {
+    component,
+    rootMap,
+    ...config
+  };
+  const sieveNames = config.analysis.selector ?? defaultSelector;
+  const schemeData = schemeList.map((scheme) => {
+    const evaluation = /* @__PURE__ */ 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 (schemeData.length === 0)
+    return new NoSchemeError();
+  return schemeData;
+};
+
+// src/component.ts
+import { bisectLeft, bisectRight } from "d3-array";
+
+// src/utils.ts
+import { range } from "lodash-es";
+import { dump } from "js-yaml";
+var printableAscii = range(33, 127).map(
+  (x) => String.fromCodePoint(x)
+);
+var formatDate = (date) => {
+  return `${date.getMonth() + 1}-${date.getDate()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`;
+};
+var unicodeBlocks = [
+  // 统一汉字基本集与扩展
+  {
+    name: "cjk",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57",
+    begin: 19968,
+    end: 40959,
+    count: 20992
+  },
+  {
+    name: "cjk-a",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55A",
+    begin: 13312,
+    end: 19903,
+    count: 6592
+  },
+  {
+    name: "cjk-b",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55B",
+    begin: 131072,
+    end: 173791,
+    count: 42720
+  },
+  {
+    name: "cjk-c",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55C",
+    begin: 173824,
+    end: 177983,
+    count: 4160
+  },
+  {
+    name: "cjk-d",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55D",
+    begin: 177984,
+    end: 178207,
+    count: 222
+  },
+  {
+    name: "cjk-e",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55E",
+    begin: 178208,
+    end: 183983,
+    count: 5774
+  },
+  {
+    name: "cjk-f",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55F",
+    begin: 183984,
+    end: 191471,
+    count: 7473
+  },
+  {
+    name: "cjk-g",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55G",
+    begin: 196608,
+    end: 201551,
+    count: 4939
+  },
+  {
+    name: "cjk-h",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55H",
+    begin: 201552,
+    end: 205743,
+    count: 4192
+  },
+  {
+    name: "cjk-i",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55I",
+    begin: 191472,
+    end: 192095,
+    count: 622
+  },
+  {
+    name: "cjk-j",
+    label: "\u4E2D\u65E5\u97E9\u7EDF\u4E00\u8868\u610F\u6587\u5B57\u6269\u5C55J",
+    begin: 205744,
+    end: 210047,
+    count: 4298
+  },
+  // 部件
+  {
+    name: "radicals-sup",
+    label: "\u4E2D\u65E5\u97E9\u90E8\u9996\u8865\u5145",
+    begin: 11904,
+    end: 12031,
+    count: 115
+  },
+  { name: "kangxi", label: "\u5EB7\u7199\u90E8\u9996", begin: 12032, end: 12255, count: 214 },
+  {
+    name: "strokes",
+    label: "\u4E2D\u65E5\u97E9\u7B14\u753B",
+    begin: 12736,
+    end: 12783,
+    count: 38
+  },
+  // 兼容汉字
+  {
+    name: "compat",
+    label: "\u4E2D\u65E5\u97E9\u517C\u5BB9\u8868\u610F\u6587\u5B57",
+    begin: 63744,
+    end: 64255,
+    count: 472
+  },
+  {
+    name: "compat-sup",
+    label: "\u4E2D\u65E5\u97E9\u517C\u5BB9\u8868\u610F\u6587\u5B57\u8865\u5145",
+    begin: 194560,
+    end: 195103,
+    count: 542
+  },
+  // 古文字系统
+  {
+    name: "tangut",
+    label: "\u897F\u590F\u6587",
+    begin: 94208,
+    end: 100351,
+    count: 6144
+  },
+  {
+    name: "tangut-comp",
+    label: "\u897F\u590F\u6587\u5B57\u6784\u4EF6",
+    begin: 100352,
+    end: 101119,
+    count: 768
+  },
+  {
+    name: "tangut-sup",
+    label: "\u897F\u590F\u6587\u8865\u5145",
+    begin: 101632,
+    end: 101759,
+    count: 31
+  },
+  {
+    name: "tangut-comp-sup",
+    label: "\u897F\u590F\u6587\u5B57\u6784\u4EF6\u8865\u5145",
+    begin: 101760,
+    end: 101887,
+    count: 115
+  },
+  {
+    name: "khitan-small",
+    label: "\u5951\u4E39\u5C0F\u5B57",
+    begin: 101120,
+    end: 101631,
+    count: 470
+  },
+  // 标点符号与排版字符
+  {
+    name: "punct",
+    label: "\u4E2D\u65E5\u97E9\u7B26\u53F7\u548C\u6807\u70B9",
+    begin: 12288,
+    end: 12351,
+    count: 64
+  },
+  {
+    name: "enclosed",
+    label: "\u4E2D\u65E5\u97E9\u5E26\u5708\u5B57\u6BCD\u548C\u6708\u4EFD",
+    begin: 12800,
+    end: 13055,
+    count: 255
+  },
+  {
+    name: "enclosed-sup",
+    label: "\u4E2D\u65E5\u97E9\u5E26\u5708\u6587\u5B57\u8865\u5145",
+    begin: 127488,
+    end: 127743,
+    count: 64
+  },
+  {
+    name: "ideo-symbols",
+    label: "\u8868\u610F\u6587\u5B57\u7B26\u53F7\u4E0E\u6807\u70B9",
+    begin: 94176,
+    end: 94207,
+    count: 7
+  },
+  // 私用区
+  { name: "pua", label: "\u79C1\u7528\u533A (BMP)", begin: 57344, end: 63743, count: 0 },
+  {
+    name: "pua-plane15",
+    label: "\u79C1\u7528\u533A (Plane 15)",
+    begin: 983040,
+    end: 1048573,
+    count: 0
+  }
+];
+var unicodeBlock = (code) => {
+  for (const block of unicodeBlocks) {
+    if (code >= block.begin && code <= block.end) {
+      return block.name;
+    }
+  }
+  return "unknown";
+};
+var unicodeBlockRank = (code) => {
+  for (const [rank, block] of unicodeBlocks.entries()) {
+    if (code >= block.begin && code <= block.end) {
+      return rank;
+    }
+  }
+  return -1;
+};
+var isValidCJKBasicChar = (char) => {
+  const code = char.codePointAt(0);
+  const block = unicodeBlock(code);
+  return block === "cjk";
+};
+var isValidCJKChar = (char) => {
+  const code = char.codePointAt(0);
+  const block = unicodeBlock(code);
+  return block.startsWith("cjk");
+};
+var isValidCJKSupplement = (char) => {
+  const code = char.codePointAt(0);
+  const block = unicodeBlock(code);
+  return block === "radicals-sup" || block === "kangxi" || block === "strokes" || block === "compat" || block === "compat-sup" || block === "punct";
+};
+var isPUA = (char) => {
+  const code = char.codePointAt(0);
+  const block = unicodeBlock(code);
+  return block === "pua" || block === "pua-plane15";
+};
+var chars = (s) => {
+  return Array.from(s).length;
+};
+var getDummyBasicComponent = () => ({
+  type: "basic_component",
+  strokes: [getDummySVGStroke("\u6A2A")]
+});
+var getDummyDerivedComponent = () => ({
+  type: "derived_component",
+  source: "\u4E00",
+  strokes: [getDummyReferenceStroke()]
+});
+var getDummySplicedComponent = () => ({
+  type: "spliced_component",
+  operator: "\u2FF0",
+  operandList: ["\u4E00", "\u4E28"]
+});
+var getDummyReferenceStroke = () => ({
+  feature: "reference",
+  index: 0
+});
+var getDummySVGStroke = (feature, start = [0, 0], oldCurveList = []) => {
+  const typelist = schema[feature];
+  return {
+    feature,
+    start,
+    curveList: typelist.map((command, index) => {
+      if (oldCurveList[index]?.command === command) {
+        return oldCurveList[index];
+      }
+      switch (command) {
+        case "a":
+          return { command, parameterList: [20] };
+        case "h":
+        case "v":
+          return { command, parameterList: [20] };
+        default:
+          return { command, parameterList: [10, 10, 20, 20, 30, 30] };
+      }
+    })
+  };
+};
+var getDummyCompound = (operator) => ({
+  type: "compound",
+  operator,
+  operandList: ["\u4E00", "\u4E00"]
+});
+var isComponent = (glyph) => glyph.type === "basic_component" || glyph.type === "derived_component" || glyph.type === "spliced_component" || glyph.type === "identity";
+var getSupplemental = (repertoire, list) => {
+  const set = new Set(list);
+  const reverseForm = Object.fromEntries(
+    Object.entries(repertoire).map(([x]) => [x, []])
+  );
+  for (const [char, { glyph }] of Object.entries(repertoire)) {
+    if (glyph?.type === "compound") {
+      glyph.operandList.forEach((x) => reverseForm[x]?.push(char));
+    }
+  }
+  const componentsNotChar = Object.entries(repertoire).filter(([, v]) => v.glyph?.type === "basic_component").map(([x]) => x).filter((x) => !set.has(x));
+  const suppList = [];
+  componentsNotChar.forEach((char) => {
+    let trial = char;
+    while (trial && !set.has(trial)) {
+      trial = reverseForm[trial]?.[0];
+    }
+    if (trial)
+      suppList.push(trial);
+  });
+  return Array.from(new Set(suppList));
+};
+var listToObject = (list) => Object.fromEntries(list.map((x) => [String.fromCodePoint(x.unicode), x]));
+function getRecordFromTSV(text) {
+  const tsv = text.trim().split("\n").map((x) => x.trim().split("	"));
+  const data = {};
+  tsv.forEach(([char, freq]) => {
+    if (char === void 0 || freq === void 0)
+      return;
+    const maybeNumber = Number(freq);
+    if (Number.isNaN(maybeNumber))
+      return;
+    data[char] = maybeNumber;
+  });
+  return data;
+}
+function getDistributionFromTSV(text) {
+  const tsv = text.trim().split("\n").map((x) => x.trim().split("	"));
+  const data = {};
+  tsv.forEach(([char, ideal_s, lt_penalty_s, gt_penalty_s]) => {
+    if (char === void 0 || ideal_s === void 0 || lt_penalty_s === void 0 || gt_penalty_s === void 0)
+      return;
+    const [ideal, lt_penalty, gt_penalty] = [
+      ideal_s,
+      lt_penalty_s,
+      gt_penalty_s
+    ].map(Number);
+    if (Number.isNaN(ideal) || Number.isNaN(lt_penalty) || Number.isNaN(gt_penalty))
+      return;
+    data[char] = { ideal, lt_penalty, gt_penalty };
+  });
+  return data;
+}
+function getDictFromTSV(text) {
+  const result = [];
+  for (const line of text.trim().split("\n")) {
+    const [key, value] = line.trim().split("	");
+    if (key === void 0 || value === void 0)
+      continue;
+    result.push([key, value]);
+  }
+  return result;
+}
+var processExport = (content, filename) => {
+  const blob = new Blob([content], { type: "text/plain" });
+  const a = document.createElement("a");
+  a.download = filename;
+  const url = window.URL.createObjectURL(blob);
+  a.href = url;
+  a.click();
+  window.URL.revokeObjectURL(url);
+};
+var exportYAML = (config, filename, flowLevel = 4, sanitize = true) => {
+  const unsafeContent = dump(config, { flowLevel });
+  if (!sanitize) {
+    processExport(unsafeContent, `${filename}.yaml`);
+  } else {
+    const fileContent = unsafeContent.replace(/[\uE000-\uFFFF]/g, (c) => {
+      return `"\\u${c.codePointAt(0)?.toString(16)}"`;
+    });
+    processExport(fileContent, `${filename}.yaml`);
+  }
+};
+var exportJSON = (data, filename) => {
+  const unsafeContent = JSON.stringify(data);
+  const fileContent = unsafeContent.replace(/[\uE000-\uFFFF]/g, (c) => {
+    return `\\u${c.codePointAt(0)?.toString(16)}`;
+  });
+  processExport(fileContent, filename);
+};
+var exportTSV = (data, filename) => {
+  const fileContent = data.map((x) => x.join("	")).join("\n");
+  processExport(fileContent, filename);
+};
+var stringify = (element) => {
+  if (element === void 0) {
+    return "\u03B5";
+  } else if (typeof element === "string") {
+    return element;
+  } else {
+    return `${element.element}.${element.index}`;
+  }
+};
+var parseKey = (key) => {
+  if (key === "\u03B5") {
+    return void 0;
+  } else if (key.includes(".")) {
+    const [element, index_s] = key.split(".");
+    const index = Number(index_s);
+    if (Number.isNaN(index)) {
+      throw new Error(`\u65E0\u6CD5\u89E3\u6790\u7684\u952E\uFF1A${key}`);
+    }
+    return { element, index };
+  } else {
+    return key;
+  }
+};
+var joinKeys = (keys) => {
+  return keys.every((x) => typeof x === "string") ? keys.join("") : keys;
+};
+var match = (character, input) => {
+  const { tag, operator, part } = input;
+  if ("glyphs" in character) {
+    const isTagMatched2 = tag === void 0 || character.glyphs.some((x) => x.tags?.includes(tag));
+    const isOperatorMatched2 = operator === void 0 || character.glyphs.some(
+      (x) => "operator" in x && x.operator.includes(operator)
+    );
+    const isPartMatched2 = part === void 0 || character.glyphs.some(
+      (x) => "operandList" in x && x.operandList.includes(part)
+    );
+    return isTagMatched2 && isOperatorMatched2 && isPartMatched2;
+  }
+  const isTagMatched = tag === void 0 || character.glyph?.tags?.includes(tag);
+  const isOperatorMatched = operator === void 0 || character.glyph?.type === "compound" && character.glyph.operator.includes(operator);
+  const isPartMatched = part === void 0 || character.glyph?.type === "compound" && character.glyph.operandList.includes(part);
+  return isTagMatched && isOperatorMatched && isPartMatched;
+};
+var makeCharacterFilter = (input, repertoire, sequenceMap) => {
+  let sequenceRegex;
+  try {
+    if (input.sequence) {
+      sequenceRegex = new RegExp(input.sequence);
+    }
+  } catch {
+  }
+  return (name) => {
+    const character = repertoire[name];
+    if (character === void 0)
+      return false;
+    const sequence = sequenceMap.get(name) ?? "";
+    const isNameMatched = ((character.name ?? "") + name).includes(
+      input.name ?? ""
+    );
+    const isSequenceMatched = sequenceRegex?.test(sequence) ?? true;
+    const isUnicodeMatched = input.unicode === void 0 || input.unicode === name.codePointAt(0);
+    const isMatched = match(character, input);
+    return isNameMatched && isSequenceMatched && isUnicodeMatched && isMatched;
+  };
+};
+var makeFilter = (input, form, sequence) => (char) => {
+  if ((sequence.get(char)?.length ?? 0) <= 1)
+    return false;
+  const name = form[char]?.name ?? "";
+  const seq = sequence.get(char) ?? "";
+  return name.includes(input) || char.includes(input) || seq.startsWith(input);
+};
+var makeDefaultAnalyzer = (maxLength) => {
+  const form = {
+    type: "all",
+    position: range(0, maxLength),
+    top: 0
+  };
+  return form;
+};
+function \u6700\u5927\u9006\u5411\u5339\u914D\u5206\u8BCD(\u8BCD\u5178, \u6587\u672C) {
+  const \u8BCD\u5217\u8868 = [];
+  const \u5B57\u7B26\u5217\u8868 = [...\u6587\u672C];
+  let \u7ED3\u675F\u4F4D\u7F6E = \u5B57\u7B26\u5217\u8868.length;
+  while (\u7ED3\u675F\u4F4D\u7F6E > 0) {
+    const \u672B\u5B57 = \u5B57\u7B26\u5217\u8868[\u7ED3\u675F\u4F4D\u7F6E - 1];
+    if (!\u8BCD\u5178.has(\u672B\u5B57)) {
+      \u8BCD\u5217\u8868.unshift(\u672B\u5B57);
+      \u7ED3\u675F\u4F4D\u7F6E -= 1;
+      continue;
+    }
+    for (let \u5F00\u59CB\u4F4D\u7F6E = 0; \u5F00\u59CB\u4F4D\u7F6E < \u7ED3\u675F\u4F4D\u7F6E; \u5F00\u59CB\u4F4D\u7F6E++) {
+      const \u8BCD = \u5B57\u7B26\u5217\u8868.slice(\u5F00\u59CB\u4F4D\u7F6E, \u7ED3\u675F\u4F4D\u7F6E).join("");
+      if (\u8BCD\u5178.has(\u8BCD)) {
+        \u8BCD\u5217\u8868.unshift(\u8BCD);
+        \u7ED3\u675F\u4F4D\u7F6E = \u5F00\u59CB\u4F4D\u7F6E;
+        break;
+      }
+    }
+  }
+  return \u8BCD\u5217\u8868;
+}
+var adapt = (\u539F\u59CB\u8BCD\u9891\u6620\u5C04, \u8BCD\u5178) => {
+  const \u65B0\u8BCD\u9891\u6620\u5C04 = /* @__PURE__ */ new Map();
+  for (const [\u8BCD, \u8BCD\u9891] of Object.entries(\u539F\u59CB\u8BCD\u9891\u6620\u5C04)) {
+    if (\u8BCD\u5178.has(\u8BCD)) {
+      \u65B0\u8BCD\u9891\u6620\u5C04.set(\u8BCD, (\u65B0\u8BCD\u9891\u6620\u5C04.get(\u8BCD) ?? 0) + \u8BCD\u9891);
+    } else {
+      const \u5B50\u8BCD\u5217\u8868 = \u6700\u5927\u9006\u5411\u5339\u914D\u5206\u8BCD(\u8BCD\u5178, \u8BCD);
+      for (const \u5B50\u8BCD of \u5B50\u8BCD\u5217\u8868) {
+        \u65B0\u8BCD\u9891\u6620\u5C04.set(\u5B50\u8BCD, (\u65B0\u8BCD\u9891\u6620\u5C04.get(\u5B50\u8BCD) ?? 0) + \u8BCD\u9891);
+      }
+    }
+  }
+  return \u65B0\u8BCD\u9891\u6620\u5C04;
+};
+var getReversedMapping = (mapping, alphabet) => {
+  const reversedMapping = new Map(
+    Array.from(alphabet).map((key) => [key, []])
+  );
+  const recursivelyRenderKey = (key) => {
+    if (typeof key === "string")
+      return key;
+    const mapped = mapping[key.element];
+    if (typeof mapped === "object" && "element" in mapped) {
+      return "";
+    }
+    return recursivelyRenderKey(mapped[key.index]);
+  };
+  for (const [name, code] of Object.entries(mapping)) {
+    if (typeof code === "string" || Array.isArray(code)) {
+      const first2 = recursivelyRenderKey(code[0]);
+      reversedMapping.get(first2)?.push({ name, code });
+    }
+  }
+  return reversedMapping;
+};
+
+// src/compound.ts
+import { range as range2, sortBy } from "lodash-es";
+var getGlyphBoundingBox = (glyph) => {
+  let [xmin, ymin, xmax, ymax] = [
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY
+  ];
+  for (const { start, curveList } of glyph) {
+    let [x, y] = start;
+    xmin = Math.min(xmin, x);
+    ymin = Math.min(ymin, y);
+    xmax = Math.max(xmax, x);
+    ymax = Math.max(ymax, y);
+    for (const { command, parameterList } of curveList) {
+      switch (command) {
+        case "h":
+          x += parameterList[0];
+          break;
+        case "v":
+          y += parameterList[0];
+          break;
+        case "a":
+          xmin = Math.min(xmin, x - parameterList[0]);
+          xmax = Math.max(xmax, x + parameterList[0]);
+          ymax = Math.max(ymax, y + 2 * parameterList[0]);
+          break;
+        default: {
+          const [_x1, _y1, _x2, _y2, x3, y3] = parameterList;
+          x += x3;
+          y += y3;
+          break;
+        }
+      }
+      xmin = Math.min(xmin, x);
+      ymin = Math.min(ymin, y);
+      xmax = Math.max(xmax, x);
+      ymax = Math.max(ymax, y);
+    }
+  }
+  const bb = { x: [xmin, xmax], y: [ymin, ymax] };
+  return bb;
+};
+var recursiveRenderCompound = (compound, repertoire, glyphCache = /* @__PURE__ */ new Map()) => {
+  const glyphs = [];
+  for (const char of compound.operandList) {
+    const glyph = repertoire[char]?.glyph;
+    if (glyph === void 0)
+      return new InvalidGlyphError();
+    if (glyph.type === "basic_component") {
+      let box = glyphCache.get(char)?.box;
+      if (box === void 0) {
+        box = getGlyphBoundingBox(glyph.strokes);
+        glyphCache.set(char, { strokes: glyph.strokes, box });
+      }
+      glyphs.push({ strokes: glyph.strokes, box });
+    } else {
+      const cache = glyphCache.get(char);
+      if (cache !== void 0) {
+        glyphs.push(cache);
+        continue;
+      }
+      const rendered = recursiveRenderCompound(glyph, repertoire, glyphCache);
+      if (rendered instanceof Error)
+        return rendered;
+      glyphs.push(rendered);
+      glyphCache.set(char, rendered);
+    }
+  }
+  return affineMerge(compound, glyphs);
+};
+var recursiveRenderStrokeSequence = (compound, repertoire, sequenceCache = /* @__PURE__ */ new Map()) => {
+  const sequences = [];
+  for (const char of compound.operandList) {
+    const glyph = repertoire[char]?.glyph;
+    if (glyph === void 0)
+      return new InvalidGlyphError();
+    if (glyph.type === "basic_component") {
+      sequences.push(glyph.strokes.map((x) => classifier[x.feature]).join(""));
+    } else {
+      const cache = sequenceCache.get(char);
+      if (cache !== void 0) {
+        sequences.push(cache);
+        continue;
+      }
+      const rendered = recursiveRenderStrokeSequence(
+        glyph,
+        repertoire,
+        sequenceCache
+      );
+      if (rendered instanceof Error)
+        return rendered;
+      sequences.push(rendered);
+      sequenceCache.set(char, rendered);
+    }
+  }
+  const { order: order3 } = compound;
+  if (order3 === void 0) {
+    return sequences.join("");
+  } else {
+    const merged = [];
+    for (const { index, strokes } of order3) {
+      const seq = sequences[index];
+      if (seq === void 0)
+        continue;
+      if (strokes === 0) {
+        merged.push(seq);
+      } else {
+        merged.push(seq.slice(0, strokes));
+        sequences[index] = seq.slice(strokes);
+      }
+    }
+    return merged.join("");
+  }
+};
+var topologicalSort = (repertoire, required, config) => {
+  let compounds = /* @__PURE__ */ new Map();
+  for (let i = 0; i !== 10; ++i) {
+    const thisLevelCompound = /* @__PURE__ */ new Map();
+    for (const [name, character] of Object.entries(repertoire)) {
+      if (!required.has(name) || compounds.get(name))
+        continue;
+      const { glyph } = character;
+      if (glyph === void 0 || glyph.type !== "compound")
+        continue;
+      const wellKnown = glyph.operandList.every(
+        (x) => repertoire[x]?.glyph?.type === "basic_component" || compounds.get(x) !== void 0
+      );
+      const isRoot = config.roots.has(name) && !config.optionalRoots.has(name);
+      if (wellKnown || isRoot) {
+        thisLevelCompound.set(name, character);
+      }
+    }
+    compounds = new Map([...compounds, ...thisLevelCompound]);
+  }
+  return compounds;
+};
+var sequentialSerializer = (operandResults, glyph) => {
+  const rest = {
+    operator: glyph.operator,
+    operandResults
+  };
+  if (glyph.order === void 0) {
+    const full2 = operandResults.flatMap((x) => x.full);
+    return { sequence: [...full2], full: full2, ...rest };
+  }
+  const full = [];
+  const subsequences = operandResults.map((x) => ({
+    rest: x.full,
+    taken: 0
+  }));
+  for (const { index, strokes } of glyph.order) {
+    const data = subsequences[index];
+    if (data === void 0) {
+      continue;
+    }
+    if (strokes === 0) {
+      full.push(...data.rest);
+      data.rest = [];
+    } else {
+      const partitionResult = operandResults[index];
+      if ("schemes" in partitionResult) {
+        const { best, strokes: totalStrokes } = partitionResult;
+        const upperBound = 1 << totalStrokes - data.taken;
+        const lowerBound = 1 << totalStrokes - data.taken - strokes;
+        const toTake = best.scheme.filter(
+          (binary) => binary >= lowerBound && binary < upperBound
+        ).length;
+        full.push(...data.rest.slice(0, toTake));
+        data.rest = data.rest.slice(toTake);
+      } else {
+        full.push(...data.rest);
+        data.rest = [];
+      }
+    }
+  }
+  return { sequence: [...full], full, ...rest };
+};
+var zhenmaSerializer = (operandResults, glyph) => {
+  const sequence = [];
+  if (glyph.operator === "\u2FF6") {
+    sequence.push(...operandResults[1].sequence);
+    sequence.push(...operandResults[0].sequence);
+  } else {
+    operandResults.map((x) => x.sequence).forEach((x) => sequence.push(...x));
+  }
+  return {
+    sequence,
+    full: [],
+    operator: glyph.operator,
+    operandResults
+  };
+};
+var regularize = (x, direction) => {
+  const result = [];
+  const regex = direction === "\u2FF0" ? /[⿰⿲]/ : /[⿱⿳]/;
+  for (const part of x) {
+    if (result.length < 2 && "operandResults" in part && regex.test(part.operator)) {
+      result.push(...part.operandResults);
+    } else {
+      result.push(part);
+    }
+  }
+  return result;
+};
+var zhangmaSerializer = (operandResults, glyph) => {
+  const sequence = [];
+  const full = [];
+  if (glyph.operator === "\u2FF6" || glyph.operator === "\u2FFA" && glyph.operandList[0] === "\uE09D") {
+    for (const part of operandResults.reverse())
+      full.push(...part.full);
+  } else {
+    for (const part of operandResults)
+      full.push(...part.full);
+  }
+  const getShouMo = (x) => x.length === 1 ? x : [x[0], x.at(-1)];
+  const regularizedResults = operandResults.length === 2 && /[⿰⿱]/.test(glyph.operator) ? regularize(operandResults, glyph.operator) : operandResults;
+  if (/[⿱⿳]/.test(glyph.operator)) {
+    const dieyanIndex = regularizedResults.findIndex(
+      (x) => "operandResults" in x && /[⿰⿲]/.test(x.operator)
+    );
+    const dieyan = regularizedResults.at(
+      dieyanIndex
+    );
+    const aboveDieyanSequence = [];
+    switch (dieyanIndex) {
+      case -1:
+        for (const part of regularizedResults)
+          sequence.push(...part.full);
+        break;
+      case 0:
+        for (const part of dieyan.operandResults)
+          sequence.push(...part.full[0]);
+        if (regularizedResults.length > 2) {
+          sequence.push(regularizedResults[1]?.full[0]);
+          sequence.push(regularizedResults.at(-1)?.full.at(-1));
+        } else {
+          sequence.push(...getShouMo(regularizedResults[1].full));
+        }
+        break;
+      default:
+        for (let index = 0; index < dieyanIndex; ++index) {
+          aboveDieyanSequence.push(...regularizedResults[index].full);
+        }
+        sequence.push(...aboveDieyanSequence.slice(0, 2));
+        if (dieyanIndex + 1 < regularizedResults.length) {
+          sequence.push(dieyan.operandResults[0]?.full[0]);
+          if (sequence.length === 2) {
+            sequence.push(dieyan.operandResults.at(-1)?.full[0]);
+          }
+          sequence.push(regularizedResults.at(-1)?.full.at(-1));
+        } else {
+          sequence.push(...dieyan.full);
+        }
+    }
+  } else if (/[⿰⿲]/.test(glyph.operator)) {
+    const left2 = regularizedResults[0];
+    if ("operandResults" in left2 && /[⿱⿳]/.test(left2.operator)) {
+      const dieyanIndex = left2.operandResults.findIndex(
+        (x) => "operandResults" in x && /[⿰⿲]/.test(x.operator)
+      );
+      const dieyan = left2.operandResults.at(
+        dieyanIndex
+      );
+      if (dieyanIndex !== -1) {
+        sequence.push(left2.operandResults[0]?.full[0]);
+        if (dieyanIndex === 0)
+          sequence.push(dieyan.operandResults.at(-1)?.full[0]);
+        else
+          sequence.push(dieyan.operandResults[0]?.full[0]);
+        sequence.push(left2.operandResults.at(-1)?.full.at(-1));
+      }
+    }
+    if (sequence.length > 0) {
+      sequence.push(regularizedResults.at(-1)?.full.at(-1));
+    } else {
+      sequence.push(...getShouMo(left2.full));
+      if (regularizedResults.length > 2) {
+        sequence.push(...getShouMo(regularizedResults[1].full));
+      }
+      if (sequence.length === 4)
+        sequence.pop();
+      for (let index = Math.min(2, regularizedResults.length - 1); index < regularizedResults.length; ++index) {
+        sequence.push(...regularizedResults[index].full);
+      }
+    }
+  } else {
+    sequence.push(...full);
+  }
+  return {
+    sequence,
+    full,
+    operator: glyph.operator,
+    operandResults: regularizedResults
+  };
+};
+var snow2Serializer = (operandResults, glyph) => {
+  const order3 = glyph.order ?? glyph.operandList.map((_, i) => ({ index: i, strokes: 0 }));
+  const sortedOperandResults = sortBy(
+    range2(operandResults.length),
+    (i) => order3.findIndex((b) => b.index === i)
+  ).map((i) => operandResults[i]);
+  const first2 = sortedOperandResults[0];
+  const second = sortedOperandResults[1];
+  const marker = first2.full.length == 1 ? second.full.length == 1 ? "q" : "e" : second.full.length == 1 ? "w" : "r";
+  const full = [first2.sequence[0], second.sequence[0]];
+  const sequence = [...full, marker];
+  return {
+    sequence,
+    full,
+    operator: glyph.operator,
+    operandResults
+  };
+};
+var limit = (sequence, maximum, config) => {
+  let codes = 0;
+  const { roots } = config;
+  const final = [];
+  for (const x of sequence) {
+    if (x === "\xB7") {
+      final.push(x);
+      continue;
+    }
+    const length2 = 1;
+    codes += length2;
+    final.push(x);
+    if (codes >= maximum)
+      break;
+  }
+  return final;
+};
+var xkjdSerializer = (operandResults, glyph, config) => {
+  const { roots: primaryRoots } = config;
+  const order3 = glyph.order ?? glyph.operandList.map((_, i) => ({ index: i, strokes: 0 }));
+  const sequence = [];
+  const full = [];
+  const sequential = sequentialSerializer(operandResults, glyph, config);
+  full.push(...sequential.full);
+  if (order3[0]?.strokes !== 1) {
+    const sortedOperandResults = sortBy(
+      range2(operandResults.length),
+      (i) => order3.findIndex((b) => b.index === i)
+    ).map((i) => operandResults[i]);
+    for (const [index, part] of sortedOperandResults.entries()) {
+      if (index === 0) {
+        let codes = 0;
+        for (const x of part.full) {
+          const length2 = 1;
+          if (codes === 1 && length2 > 1) {
+            const equivalent = {
+              \u571F: "1",
+              \u8279: "2",
+              \u91D1: "2",
+              \u624B: "2",
+              \u5341: "3",
+              \u65E5: "4",
+              \u8D1D: "5"
+            };
+            sequence.push(equivalent[x] ?? "1");
+          } else {
+            sequence.push(x);
+          }
+          codes += length2;
+          if (codes >= 2)
+            break;
+        }
+      } else {
+        sequence.push(...part.full);
+      }
+    }
+  } else {
+    sequence.push(...sequential.sequence);
+  }
+  const finalSequence = limit(sequence, 4, config);
+  return {
+    sequence: finalSequence,
+    full,
+    operator: glyph.operator,
+    operandResults
+  };
+};
+var shouyouSerializer = (operandResults, glyph, config) => {
+  const order3 = glyph.order ?? glyph.operandList.map((_, i) => ({ index: i, strokes: 0 }));
+  const sortedOperandResults = sortBy(
+    range2(operandResults.length),
+    (i) => order3.findIndex((b) => b.index === i)
+  ).map((i) => operandResults[i]);
+  const first2 = sortedOperandResults[0];
+  const second = sortedOperandResults[1];
+  let sequence;
+  const full = sequentialSerializer(operandResults, glyph, config).full;
+  if (/[⿰⿲]/.test(glyph.operator) || glyph.operator === "\u2FFA" && order3[0].index === 0)
+    sequence = [first2.full[0], second.full[0]];
+  else {
+    sequence = [...full];
+  }
+  return {
+    sequence,
+    full,
+    operator: glyph.operator,
+    operandResults
+  };
+};
+var feihuaSerializer = (operandResults, glyph, config) => {
+  const order3 = glyph.order ?? glyph.operandList.map((_, i) => ({ index: i, strokes: 0 }));
+  const sortedOperandResults = sortBy(
+    range2(operandResults.length),
+    (i) => order3.findIndex((b) => b.index === i)
+  ).map((i) => operandResults[i]);
+  const sequence = [];
+  const first2 = sortedOperandResults[0];
+  const last = sortedOperandResults.at(-1);
+  const handleResidual = (sequence2, parts) => {
+    if (parts.length > 1) {
+      for (const x of parts) {
+        sequence2.push(...x.full2[0]);
+      }
+    } else {
+      const part = parts[0];
+      if ("operandResults" in part) {
+        for (const x of part.operandResults) {
+          sequence2.push(...x.full2[0]);
+        }
+      } else {
+        sequence2.push(...part.full2);
+      }
+    }
+  };
+  if (/[⿴⿵⿶⿷⿸⿹⿺⿼⿽⿻]/.test(glyph.operator) && "strokes" in operandResults[0]) {
+    sequence.push(operandResults[0].full[0]);
+    handleResidual(sequence, operandResults.slice(1));
+  } else if (first2.full.length === 1 && /[又]/.test(first2.full[0]) && last.full.length === 1) {
+    sequence.push(last.full[0]);
+    handleResidual(sequence, sortedOperandResults.slice(0, -1));
+  } else if (first2.full.length !== 1 && last.full.length === 1) {
+    sequence.push(last.full[0]);
+    handleResidual(sequence, sortedOperandResults.slice(0, -1));
+  } else {
+    sequence.push(first2.full[0]);
+    handleResidual(sequence, sortedOperandResults.slice(1));
+  }
+  const full = sequentialSerializer(operandResults, glyph, config).full;
+  const backups = operandResults.map((x) => x.full);
+  operandResults.forEach((part) => {
+    part.full = [...part.full2];
+  });
+  const full2 = sequentialSerializer(operandResults, glyph, config).full;
+  operandResults.forEach((part, i) => {
+    part.full = backups[i];
+  });
+  return {
+    sequence,
+    full,
+    full2,
+    operator: glyph.operator,
+    operandResults
+  };
+};
+var erbiSerializer = (operandResults, glyph, config) => {
+  const order3 = glyph.order ?? glyph.operandList.map((_, i) => ({ index: i, strokes: 0 }));
+  const sortedOperandResults = sortBy(
+    range2(operandResults.length),
+    (i) => order3.findIndex((b) => b.index === i)
+  ).map((i) => operandResults[i]);
+  const sequence = [];
+  for (const [index, part] of sortedOperandResults.entries()) {
+    if (index === sortedOperandResults.length - 1)
+      sequence.push(...part.sequence);
+    else
+      sequence.push(part.sequence[0]);
+  }
+  return {
+    sequence,
+    full: sequence,
+    operator: glyph.operator,
+    operandResults
+  };
+};
+var serializerTypes = [
+  "sequential",
+  "zhangma",
+  "zhenma",
+  "snow2",
+  "xkjd",
+  "shouyou",
+  "feihua",
+  "erbi"
+];
+var serializerMap = {
+  sequential: sequentialSerializer,
+  zhangma: zhangmaSerializer,
+  zhenma: zhenmaSerializer,
+  snow2: snow2Serializer,
+  xkjd: xkjdSerializer,
+  shouyou: shouyouSerializer,
+  feihua: feihuaSerializer,
+  erbi: erbiSerializer
+};
+var disassembleCompounds = (repertoire, config, componentResults, characters, requiredCompounds) => {
+  const knownCharacters = new Set(characters);
+  const compounds = topologicalSort(repertoire, requiredCompounds, config);
+  const compoundResults = /* @__PURE__ */ new Map();
+  const compoundError = [];
+  const getResult = (s) => componentResults.get(s) || compoundResults.get(s);
+  const serializerName = config.analysis.serializer ?? "sequential";
+  const serializer = serializerMap[serializerName] ?? sequentialSerializer;
+  if (serializerName === "xkjd") {
+    for (const [_, result] of componentResults.entries()) {
+      result.sequence = limit(result.sequence, 4, config);
+    }
+  } else if (serializerName === "snow2") {
+    for (const [key, result] of componentResults.entries()) {
+      result.sequence = result.sequence.slice(0, 1);
+      if (result.sequence[0] !== key)
+        result.sequence.push("");
+    }
+  } else if (serializerName === "feihua") {
+    for (const [key, result] of componentResults.entries()) {
+      if ("schemes" in result) {
+        const dc = config.analysis?.dynamic_customize ?? {};
+        const schemeList = dc[key] ?? result.schemes.filter((x) => x.optional).map((x) => x.roots);
+        const scheme = schemeList.find(
+          (x) => x.every((r2) => {
+            let value = config.roots.get(r2);
+            while (isMerge(value)) {
+              value = config.roots.get(value.element);
+            }
+            return /[aoeiuv;/]/.test(value);
+          })
+        );
+        result.full2 = scheme;
+        result.sequence = scheme.slice(0, 3);
+      } else {
+        result.full2 = [...result.full];
+      }
+    }
+  }
+  for (const [char, { glyph }] of compounds.entries()) {
+    if (config.roots.has(char)) {
+      if (serializerName === "feihua") {
+        const rawOperandResults2 = glyph.operandList.map(getResult);
+        const operandResults = rawOperandResults2;
+        const serialization = serializer(operandResults, glyph, config);
+        serialization.full = [char];
+        let value = config.roots.get(char);
+        while (isMerge(value)) {
+          value = config.roots.get(value.element);
+        }
+        if (/[aoeiuv;/]/.test(value)) {
+          serialization.full2 = [char];
+        }
+        compoundResults.set(char, serialization);
+        continue;
+      }
+      const sequence = [char];
+      if (serializerName === "snow2") {
+        sequence.push("q");
+      }
+      compoundResults.set(char, {
+        sequence,
+        full: [char],
+        // @ts-ignore
+        full2: [char],
+        strokes: 0,
+        operator: void 0
+      });
+      continue;
+    }
+    const rawOperandResults = glyph.operandList.map(getResult);
+    if (rawOperandResults.every((x) => x !== void 0)) {
+      const operandResults = rawOperandResults;
+      const serialization = serializer(operandResults, glyph, config);
+      compoundResults.set(char, serialization);
+    } else {
+      if (knownCharacters.has(char)) {
+        compoundError.push(char);
+      }
+    }
+  }
+  return [compoundResults, compoundError];
+};
+
+// src/component.ts
+var InvalidGlyphError = class extends Error {
+};
+var makeIntervalSum = (strokes, rootsSet) => {
+  const array = [...Array(strokes).keys()].map((x) => 1 << x).reverse();
+  const intervalSums = /* @__PURE__ */ new Set();
+  for (let start = 0; start !== strokes - 1; ++start) {
+    let sum = array[start];
+    for (let end = start + 1; end !== strokes; ++end) {
+      sum += array[end];
+      if (rootsSet.has(sum)) {
+        intervalSums.add(sum);
+      }
+    }
+  }
+  return intervalSums;
+};
+var generateSchemes = (strokes, roots, requiredRoots) => {
+  const schemeList = [];
+  const total = (1 << strokes) - 1;
+  const intervalSums = makeIntervalSum(strokes, requiredRoots);
+  const combineNext = (partialSum, scheme, revcumsum) => {
+    const restBin = total - partialSum;
+    const restBin1st = 1 << restBin.toString(2).length - 1;
+    const start = bisectLeft(roots, restBin1st);
+    const end = bisectRight(roots, restBin);
+    for (const binary of roots.slice(start, end)) {
+      if ((partialSum & binary) !== 0)
+        continue;
+      const newPartialSum = partialSum + binary;
+      const newRevcumsum = revcumsum.map((x) => x + binary);
+      const newScheme = scheme.concat(binary);
+      if (newRevcumsum.some((x) => intervalSums.has(x))) {
+        continue;
+      }
+      newRevcumsum.push(binary);
+      if (newPartialSum === total) {
+        schemeList.push(newScheme);
+      } else {
+        combineNext(newPartialSum, newScheme, newRevcumsum);
+      }
+    }
+  };
+  combineNext(0, [], []);
+  return schemeList;
+};
+var NoSchemeError = class extends Error {
+};
+var MultipleSchemeError2 = class extends Error {
+};
+var getComponentScheme = (component, rootData, config, classifier2) => {
+  const currentRoots = /* @__PURE__ */ new Set([...config.roots.keys()]);
+  const optionalRoots = /* @__PURE__ */ new Set([...config.optionalRoots.keys()]);
+  const requiredRoots = new Set(
+    [...currentRoots].filter((x) => !optionalRoots.has(x))
+  );
+  if (requiredRoots.has(component.name))
+    return {
+      strokes: component.glyph.length,
+      sequence: [component.name],
+      full: [component.name],
+      operator: void 0
+    };
+  if (config.analysis.serializer === "erbi") {
+    const firstStroke = component.glyph[0];
+    const secondStroke = component.glyph[1];
+    const first2 = classifier2[firstStroke.feature].toString();
+    const second = secondStroke ? classifier2[secondStroke.feature].toString() : "0";
+    const sequence2 = [first2 + second];
+    if (component.glyph.length > 2) {
+      const lastStroke = component.glyph[component.glyph.length - 1];
+      const last = classifier2[lastStroke.feature].toString();
+      sequence2.push(last);
+    }
+    return {
+      strokes: component.glyph.length,
+      sequence: sequence2,
+      full: sequence2,
+      operator: void 0
+    };
+  }
+  const rootMap = new Map(
+    component.glyph.map((stroke, index) => {
+      const binary = 1 << component.glyph.length - 1 - index;
+      return [binary, classifier2[stroke.feature].toString()];
+    })
+  );
+  for (const root of rootData) {
+    const binaries = generateSliceBinaries(
+      config.analysis?.degenerator ?? defaultDegenerator,
+      component,
+      root
+    );
+    binaries.forEach((binary) => rootMap.set(binary, root.name));
+  }
+  const roots = Array.from(rootMap.keys()).sort((a, b) => a - b);
+  const requiredRootsBinary = new Set(
+    [...rootMap].filter(([K, v]) => requiredRoots.has(v)).map(([K, v]) => K)
+  );
+  const schemeList = generateSchemes(
+    component.glyph.length,
+    roots,
+    requiredRootsBinary
+  );
+  if (schemeList.length === 0) {
+    return new NoSchemeError();
+  }
+  const selectResult = select(
+    config,
+    component,
+    schemeList,
+    rootMap,
+    requiredRootsBinary
+  );
+  if (selectResult instanceof Error) {
+    return selectResult;
+  }
+  const best = selectResult.find(
+    (x) => x.scheme.every(
+      (y) => currentRoots.has(rootMap.get(y)) || /\d/.test(rootMap.get(y))
+    )
+  );
+  let sequence = best.scheme.map((n) => rootMap.get(n));
+  return {
+    sequence,
+    full: [...sequence],
+    strokes: component.glyph.length,
+    map: rootMap,
+    best,
+    schemes: selectResult,
+    operator: void 0
+  };
+};
+var recursiveRenderComponent = (component, repertoire, glyphCache = /* @__PURE__ */ new Map(), depth = 0) => {
+  if (depth > 100) {
+    console.error("Recursion depth exceeded", component);
+    return new InvalidGlyphError();
+  }
+  if (component.type === "basic_component")
+    return component.strokes;
+  if (component.type === "derived_component") {
+    const sourceComponent = repertoire[component.source]?.glyphs?.find?.(isComponent);
+    if (sourceComponent === void 0)
+      return new InvalidGlyphError();
+    const sourceGlyph = recursiveRenderComponent(
+      sourceComponent,
+      repertoire,
+      glyphCache,
+      depth + 1
+    );
+    if (sourceGlyph instanceof InvalidGlyphError)
+      return sourceGlyph;
+    const glyph = [];
+    component.strokes.forEach((x) => {
+      if (x.feature === "reference") {
+        const sourceStroke = sourceGlyph[x.index];
+        if (sourceStroke === void 0)
+          return;
+        glyph.push(sourceStroke);
+      } else {
+        glyph.push(x);
+      }
+    });
+    return glyph;
+  }
+  if (component.type === "spliced_component") {
+    const glyphs = [];
+    for (const name of component.operandList) {
+      const sourceComponent = repertoire[name]?.glyphs?.find?.(isComponent);
+      if (sourceComponent === void 0)
+        return new InvalidGlyphError();
+      const sourceGlyph = recursiveRenderComponent(
+        sourceComponent,
+        repertoire,
+        glyphCache,
+        depth + 1
+      );
+      if (sourceGlyph instanceof InvalidGlyphError)
+        return sourceGlyph;
+      const box = getGlyphBoundingBox(sourceGlyph);
+      glyphs.push({ strokes: sourceGlyph, box });
+    }
+    const asCompound = { ...component, type: "compound" };
+    return affineMerge(asCompound, glyphs).strokes;
+  }
+  if (component.type === "identity") {
+    const sourceComponent = repertoire[component.source]?.glyphs?.find?.(isComponent);
+    if (sourceComponent === void 0)
+      return new InvalidGlyphError();
+    return recursiveRenderComponent(
+      sourceComponent,
+      repertoire,
+      glyphCache,
+      depth + 1
+    );
+  }
+  return new InvalidGlyphError();
+};
+var computeComponent = (name, svgglyph) => {
+  const glyph = renderSVGGlyph(svgglyph);
+  const topology = findTopology(glyph);
+  const cache = { glyph, topology, name };
+  return cache;
+};
+var renderRootList = (repertoire, elements) => {
+  const rootList = /* @__PURE__ */ new Map();
+  for (const root of elements) {
+    const glyph = repertoire[root]?.glyph;
+    if (glyph === void 0)
+      continue;
+    if (glyph.type === "basic_component") {
+      rootList.set(root, computeComponent(root, glyph.strokes));
+    } else {
+      const rendered = recursiveRenderCompound(glyph, repertoire);
+      if (rendered instanceof Error)
+        continue;
+      rootList.set(root, computeComponent(root, rendered.strokes));
+    }
+  }
+  return rootList;
+};
+var disassembleComponents = (repertoire, config, characters, components) => {
+  const rootMap = renderRootList(repertoire, [
+    ...config.roots.keys(),
+    ...config.optionalRoots.keys()
+  ]);
+  const rootList = [...rootMap.values()];
+  const classifier2 = mergeClassifier(config.analysis?.classifier);
+  const result = [];
+  const error = [];
+  Object.entries(repertoire).forEach(([name, character]) => {
+    if (character.glyph?.type !== "basic_component" || !components.has(name))
+      return;
+    const cache = rootMap.has(name) ? rootMap.get(name) : computeComponent(name, character.glyph.strokes);
+    const scheme = getComponentScheme(cache, rootList, config, classifier2);
+    if (scheme instanceof Error) {
+      error.push(name);
+    } else {
+      result.push([name, scheme]);
+    }
+  });
+  result.sort((a, b) => {
+    return a[1].strokes - b[1].strokes;
+  });
+  return [new Map(result), error];
+};
+
+// src/repertoire.ts
+import { range as range3 } from "d3-array";
+var findGlyphIndex = (glyphs, tags) => {
+  for (const tag of tags) {
+    const withTag = glyphs.findIndex((x) => (x.tags ?? []).includes(tag));
+    if (withTag !== -1)
+      return withTag;
+  }
+  return 0;
+};
+var determine = (repertoire, customGlyph = {}, customReadings = {}, tags = []) => {
+  const determined = {};
+  const glyphCache = /* @__PURE__ */ new Map();
+  for (const [name, character] of Object.entries(repertoire)) {
+    const { ambiguous: _, glyphs, readings, ...rest } = character;
+    const selectedIndex = findGlyphIndex(glyphs, tags);
+    const rawglyph = customGlyph[name] ?? glyphs[selectedIndex] ?? getDummyBasicComponent();
+    const glyph = recursiveHandleRawGlyph(rawglyph, glyphCache, repertoire);
+    const finalReadings = customReadings[name] ?? readings;
+    const determined_character = {
+      ...rest,
+      glyph,
+      readings: finalReadings
+    };
+    determined[name] = determined_character;
+  }
+  return determined;
+};
+function recursiveHandleRawGlyph(glyph, glyphCache, repertoire) {
+  if (glyph.type === "derived_component" || glyph.type === "spliced_component") {
+    const svgglyph = recursiveRenderComponent(glyph, repertoire, glyphCache);
+    return {
+      type: "basic_component",
+      tags: glyph.tags,
+      strokes: svgglyph instanceof Error ? [] : svgglyph
+    };
+  } else if (glyph.type === "identity") {
+    return recursiveHandleRawGlyph(
+      repertoire[glyph.source].glyphs[0],
+      glyphCache,
+      repertoire
+    );
+  } else {
+    return glyph;
+  }
+}
+var getRootSequence = (repertoire, config) => {
+  const classifier2 = mergeClassifier(config.analysis?.classifier);
+  const findSequence = (x) => {
+    if (x.match(/[0-9]+/)) {
+      return [...x].map(Number);
+    }
+    const glyph = repertoire[x]?.glyph;
+    if (glyph === void 0) {
+      return [];
+    }
+    if (glyph.type === "basic_component") {
+      return glyph.strokes.map((s) => classifier2[s.feature]);
+    }
+    const sequence = recursiveRenderCompound(glyph, repertoire);
+    if (sequence instanceof Error)
+      return [];
+    return sequence.strokes.map((s) => classifier2[s.feature]);
+  };
+  const rootSequence = /* @__PURE__ */ new Map();
+  const roots = /* @__PURE__ */ new Set([
+    ...config.roots.keys(),
+    ...config.optionalRoots.keys()
+  ]);
+  for (const root of roots) {
+    rootSequence.set(root, findSequence(root));
+  }
+  for (const num of Object.values(classifier2)) {
+    rootSequence.set(num.toString(), [num]);
+  }
+  return rootSequence;
+};
+var getRequiredTargets = (repertoire, config, characters) => {
+  const queue = [...characters];
+  const components = /* @__PURE__ */ new Set();
+  const compounds = /* @__PURE__ */ new Set();
+  const knownSet = new Set(characters);
+  while (queue.length) {
+    const char = queue.shift();
+    const glyph = repertoire[char].glyph;
+    if (glyph.type === "compound") {
+      compounds.add(char);
+      const isCurrentRoot = config.roots.has(char);
+      const isOptionalRoot = config.optionalRoots.has(char);
+      if (isCurrentRoot && !isOptionalRoot)
+        continue;
+      glyph.operandList.forEach((x) => {
+        if (!knownSet.has(x)) {
+          knownSet.add(x);
+          queue.push(x);
+        }
+      });
+    } else {
+      components.add(char);
+    }
+  }
+  return { components, compounds };
+};
+var analysis = (repertoire, config, characters) => {
+  const { components, compounds } = getRequiredTargets(
+    repertoire,
+    config,
+    characters
+  );
+  const [componentResults, componentError] = disassembleComponents(
+    repertoire,
+    config,
+    characters,
+    components
+  );
+  const customizations = /* @__PURE__ */ new Map();
+  const customConfig = config.analysis?.customize ?? {};
+  for (const [component, sequence] of Object.entries(customConfig)) {
+    const previousResult = componentResults.get(component);
+    if (previousResult === void 0)
+      continue;
+    if (previousResult !== void 0 && "best" in previousResult) {
+      const maybeBetter = previousResult.schemes.find((x) => {
+        const list = x.scheme.map((y) => previousResult.map.get(y));
+        return isEqual4(list, sequence);
+      });
+      if (maybeBetter !== void 0) {
+        const genuineResult = {
+          ...previousResult,
+          best: maybeBetter,
+          sequence,
+          full: sequence
+        };
+        customizations.set(component, genuineResult);
+        continue;
+      }
+    }
+    const pseudoResult = {
+      strokes: 0,
+      sequence,
+      full: sequence,
+      operator: void 0
+    };
+    customizations.set(component, pseudoResult);
+  }
+  const all = /* @__PURE__ */ new Set([...config.roots.keys()]);
+  for (const [component, sequenceList] of Object.entries(
+    config.analysis?.dynamic_customize ?? {}
+  )) {
+    const previousResult = componentResults.get(
+      component
+    );
+    for (const sequence of sequenceList) {
+      if (!sequence.every((x) => /\d/.test(x) || all.has(x)))
+        continue;
+      const pseudoResult = {
+        ...previousResult,
+        sequence,
+        full: sequence
+      };
+      customizations.set(component, pseudoResult);
+      break;
+    }
+  }
+  const customized = new Map([...componentResults, ...customizations]);
+  const [compoundResults, compoundError] = disassembleCompounds(
+    repertoire,
+    config,
+    customized,
+    characters,
+    compounds
+  );
+  const rootSequence = getRootSequence(repertoire, config);
+  return {
+    componentResults,
+    componentError,
+    customizations,
+    customized,
+    compoundResults,
+    compoundError,
+    rootSequence
+  };
+};
+var dynamicAnalysis = (repertoire, config, characters, dictionary, adaptedFrequency, algebra) => {
+  const { components, compounds } = getRequiredTargets(
+    repertoire,
+    config,
+    characters
+  );
+  const [componentResults, componentError] = disassembleComponents(
+    repertoire,
+    config,
+    characters,
+    components
+  );
+  const segmentMap = /* @__PURE__ */ new Map();
+  const segmentDynamicAnalysis = /* @__PURE__ */ new Map();
+  const bushouMap = /* @__PURE__ */ new Map();
+  for (const [name, analysis2] of componentResults) {
+    const maybeCustomDynamicAnalysis = config.analysis.dynamic_customize?.[name];
+    const dynamicAnalysis2 = "schemes" in analysis2 ? analysis2.schemes.filter((x) => x.optional).map((x) => x.roots) : [analysis2.sequence];
+    segmentDynamicAnalysis.set(
+      name,
+      maybeCustomDynamicAnalysis ?? dynamicAnalysis2
+    );
+    segmentMap.set(name, [name]);
+  }
+  const sortedCompounds = topologicalSort(repertoire, compounds, config);
+  const rootMap = renderRootList(repertoire, [
+    ...config.roots.keys(),
+    ...config.optionalRoots.keys()
+  ]);
+  const classifier2 = mergeClassifier(config.analysis?.classifier);
+  const rootList = [...rootMap.values()];
+  const cachedGetSegment = (part, start, end) => {
+    const character = repertoire[part];
+    const name = `${isPUA(part) ? character.name : part}.${start}-${end ?? 0}`;
+    if (segmentDynamicAnalysis.has(name)) {
+      return name;
+    }
+    if (character.glyph.type !== "basic_component") {
+      console.log(`Cannot segment non-basic component: ${part}`);
+      return name;
+    }
+    const glyph = character.glyph.strokes.slice(start, end);
+    const cache = computeComponent(name, glyph);
+    console.log(
+      `Part: ${part} (${part.codePointAt(0)}) [${start}${end ? `-${end}` : ""}]`
+    );
+    const analysis2 = getComponentScheme(
+      cache,
+      rootList,
+      config,
+      classifier2
+    );
+    segmentDynamicAnalysis.set(
+      name,
+      analysis2.schemes.filter((x) => x.optional).map((x) => x.roots)
+    );
+    segmentMap.set(name, [name]);
+    return name;
+  };
+  const fullSegmentMap = new Map(segmentMap.entries());
+  for (const [name, compound] of sortedCompounds) {
+    const isCurrentRoots = config.roots.has(name);
+    const isOptionalRoots = config.optionalRoots.has(name);
+    if (isCurrentRoots && !isOptionalRoots) {
+      segmentDynamicAnalysis.set(name, [[name]]);
+      segmentMap.set(name, [name]);
+      fullSegmentMap.set(name, [name]);
+      continue;
+    }
+    const glyph = compound.glyph;
+    const componentList = [];
+    const order3 = glyph.order ?? glyph.operandList.map((_, i) => ({ index: i, strokes: 0 }));
+    if (config.analysis.serializer === "qingyun") {
+      const seenIndex = /* @__PURE__ */ new Map();
+      for (const { index, strokes } of order3) {
+        const part = glyph.operandList[index];
+        if (strokes === 0) {
+          if (!seenIndex.has(index)) {
+            componentList.push(...segmentMap.get(part));
+          } else {
+            const start = seenIndex.get(index);
+            const name2 = cachedGetSegment(part, start);
+            componentList.push(name2);
+          }
+        } else {
+          const start = seenIndex.get(index) ?? 0;
+          const end = start + strokes;
+          const name2 = cachedGetSegment(part, start, end);
+          componentList.push(name2);
+          seenIndex.set(index, end);
+        }
+      }
+    } else if (config.analysis.serializer === "feihua") {
+      const sortedOperandList = sortBy2(
+        range3(glyph.operandList.length),
+        (i) => order3.findIndex((b) => b.index === i)
+      ).map((i) => glyph.operandList[i]);
+      const fullComponentList = [];
+      for (const child of sortedOperandList) {
+        fullComponentList.push(...fullSegmentMap.get(child));
+      }
+      fullSegmentMap.set(name, fullComponentList);
+      const first2 = sortedOperandList[0];
+      const last = sortedOperandList.at(-1);
+      const firstDynamic = segmentDynamicAnalysis.get(first2);
+      const lastDynamic = segmentDynamicAnalysis.get(last);
+      const res = [];
+      if (/[⿴⿵⿶⿷⿸⿹⿺⿼⿽⿻]/.test(glyph.operator) && componentResults.has(glyph.operandList[0])) {
+        bushouMap.set(
+          name,
+          segmentDynamicAnalysis.get(glyph.operandList[0])[0][0]
+        );
+        res.push(...glyph.operandList.slice(1));
+      } else if (firstDynamic?.[0]?.length === 1 && lastDynamic?.[0]?.length === 1 && /[又]/.test(firstDynamic[0][0])) {
+        bushouMap.set(name, lastDynamic[0][0]);
+        res.push(...sortedOperandList.slice(0, -1));
+      } else if (firstDynamic?.[0]?.length === 1) {
+        bushouMap.set(name, firstDynamic[0][0]);
+        res.push(...sortedOperandList.slice(1));
+      } else if (lastDynamic?.[0]?.length === 1) {
+        bushouMap.set(name, lastDynamic[0][0]);
+        res.push(...sortedOperandList.slice(0, -1));
+      } else {
+        const firstSegments = fullSegmentMap.get(first2);
+        const segment = firstSegments[0];
+        const bushou = segmentDynamicAnalysis.get(segment)[0][0];
+        bushouMap.set(name, bushou);
+        res.push(...sortedOperandList.slice(1));
+      }
+      if (res.length === 1) {
+        const only = res[0];
+        if (!sortedCompounds.has(only)) {
+          componentList.push(...fullSegmentMap.get(only).slice(0, 2));
+        } else {
+          const subglyph = sortedCompounds.get(only).glyph;
+          const order4 = subglyph.order ?? subglyph.operandList.map((_, i) => ({ index: i, strokes: 0 }));
+          const sortedOperandList2 = sortBy2(
+            range3(subglyph.operandList.length),
+            (i) => order4.findIndex((b) => b.index === i)
+          ).map((i) => subglyph.operandList[i]);
+          for (const part of sortedOperandList2) {
+            componentList.push(...fullSegmentMap.get(part)[0]);
+          }
+        }
+      } else {
+        for (const child of res) {
+          componentList.push(fullSegmentMap.get(child)[0]);
+        }
+      }
+    } else {
+      const sortedOperandList = sortBy2(
+        range3(glyph.operandList.length),
+        (i) => order3.findIndex((b) => b.index === i)
+      ).map((i) => glyph.operandList[i]);
+      for (const child of sortedOperandList) {
+        componentList.push(...segmentMap.get(child));
+      }
+    }
+    if (isOptionalRoots) {
+      let dynamic = [[]];
+      for (const operand of componentList) {
+        const dynamicAnalysis2 = segmentDynamicAnalysis.get(operand);
+        dynamic = dynamic.map((x) => dynamicAnalysis2.map((y) => x.concat(y))).flat();
+      }
+      segmentDynamicAnalysis.set(name, [[name]].concat(dynamic));
+      segmentMap.set(name, [name]);
+    } else {
+      segmentMap.set(name, componentList);
+    }
+  }
+  const \u6C49\u5B57\u4FE1\u606F = characters.map((x) => {
+    const readings = repertoire[x]?.readings ?? [];
+    const frequency = adaptedFrequency.get(x) ?? 0;
+    const frequencies = readings.map(({ pinyin, importance }) => {
+      const entry = {
+        \u62FC\u97F3: pinyin,
+        \u9891\u7387: Math.round(frequency * importance / 100)
+      };
+      for (const [name, rules] of Object.entries(algebra)) {
+        entry[name] = applyRules(name, rules, pinyin);
+      }
+      return entry;
+    });
+    return {
+      \u6C49\u5B57: x,
+      \u901A\u89C4: repertoire[x].tygf,
+      gb2312: repertoire[x].gb2312,
+      \u9891\u7387: frequency,
+      \u8BFB\u97F3: frequencies,
+      \u5B57\u5757: segmentMap.get(x) ?? [],
+      \u90E8\u9996: bushouMap.get(x)
+    };
+  });
+  const \u591A\u5B57\u8BCD\u4FE1\u606F = dictionary.map(([word, syllables]) => {
+    const frequency = adaptedFrequency.get(word) ?? 0;
+    const readings = syllables.split(" ").map((pinyin) => {
+      const entry = {
+        \u62FC\u97F3: pinyin
+      };
+      for (const [name, rules] of Object.entries(algebra)) {
+        entry[name] = applyRules(name, rules, pinyin);
+      }
+      return entry;
+    });
+    return {
+      \u8BCD: word,
+      \u9891\u7387: frequency,
+      \u8BFB\u97F3: readings
+    };
+  });
+  const result = {
+    \u6C49\u5B57\u4FE1\u606F,
+    \u591A\u5B57\u8BCD\u4FE1\u606F,
+    \u52A8\u6001\u62C6\u5206: Object.fromEntries(segmentDynamicAnalysis),
+    \u5B57\u6839\u7B14\u753B: Object.fromEntries(getRootSequence(repertoire, config))
+  };
+  return result;
+};
+
+// src/assembly.ts
+var getPriorityMap = (priorityShortCodes) => {
+  return new Map(
+    priorityShortCodes.map(([word, pinyin_list, level]) => {
+      const hash = `${word}-${pinyin_list}`;
+      return [hash, level];
+    })
+  );
+};
+var table = {
+  \u662F: (t, v) => t === v,
+  \u4E0D\u662F: (t, v) => t !== v,
+  \u5339\u914D: (t, v) => t !== void 0 && new RegExp(v).test(t),
+  \u4E0D\u5339\u914D: (t, v) => t !== void 0 && !new RegExp(v).test(t),
+  \u7F16\u7801\u5339\u914D: (t, v, m) => t !== void 0 && new RegExp(v).test(m[t]),
+  \u7F16\u7801\u4E0D\u5339\u914D: (t, v, m) => t !== void 0 && !new RegExp(v).test(m[t]),
+  \u5B58\u5728: (t) => t !== void 0,
+  \u4E0D\u5B58\u5728: (t) => t === void 0
+};
+var satisfy = (condition, result, config, extra, totalMapping) => {
+  const { object, operator } = condition;
+  const target = findElement(object, result, config, extra);
+  const fn = table[operator];
+  if ("value" in condition) {
+    return fn(target, condition.value, totalMapping);
+  }
+  return fn(target, null, totalMapping);
+};
+var compile = (keyboard, encoder, algebra) => {
+  const { mapping } = keyboard;
+  const alphabet = keyboard.alphabet ?? "";
+  const totalMapping = {};
+  return (result, data, extra) => {
+    let node = "s0";
+    const codes = [];
+    while (node) {
+      if (node.startsWith("s")) {
+        const source = encoder.sources[node];
+        const { object, next, index } = source;
+        if (node !== "s0") {
+          const element = findElement(object, result, algebra, extra);
+          if (element === void 0) {
+            node = next;
+            continue;
+          }
+          if (element.length === 1 && alphabet.includes(element)) {
+            codes.push(element);
+            node = next;
+            continue;
+          }
+          let mapped = mapping[element];
+          let groupedElement = element;
+          if (mapped === void 0) {
+            node = next;
+            continue;
+          }
+          while (isMerge(mapped)) {
+            groupedElement = mapped.element;
+            mapped = mapping[mapped.element];
+          }
+          if (index === void 0) {
+            for (const [index2, key] of Array.from(mapped).entries()) {
+              codes.push(
+                // typeof key === "string"
+                //   ? { element: groupedElement, index }
+                //   : key,
+                { element: groupedElement, index: index2 }
+              );
+            }
+          } else {
+            const key = mapped[index];
+            if (key !== void 0) {
+              codes.push(
+                // typeof key === "string"
+                //   ? { element: groupedElement, index }
+                //   : key,
+                { element: groupedElement, index }
+              );
+            }
+          }
+        }
+        node = next;
+      } else {
+        const condition = encoder.conditions[node];
+        if (satisfy(condition, result, algebra, extra, totalMapping)) {
+          node = condition.positive;
+        } else {
+          node = condition.negative;
+        }
+      }
+    }
+    return codes.slice(0, encoder.max_length ?? codes.length);
+  };
+};
+var signedIndex2 = (elements, index) => {
+  const order3 = index.codePointAt(0) - "a".codePointAt(0);
+  const signedOrder = order3 < 13 ? order3 : order3 - 26;
+  return elements.at(signedOrder);
+};
+var gather = (totalElements, rules) => {
+  const result = [];
+  let matched = false;
+  for (const rule of rules) {
+    if ("length_equal" in rule) {
+      matched = totalElements.length === rule.length_equal;
+    } else if ("length_in_range" in rule) {
+      matched = totalElements.length >= rule.length_in_range[0] && totalElements.length <= rule.length_in_range[1];
+    }
+    if (matched) {
+      const tokens = Array.from(rule.formula);
+      for (let i = 0; i < tokens.length; i = i + 2) {
+        const charIndex = tokens[i].toLowerCase();
+        const elementIndex = tokens[i + 1];
+        const elements = signedIndex2(totalElements, charIndex);
+        if (elements === void 0)
+          continue;
+        const element = signedIndex2(elements, elementIndex);
+        if (element === void 0)
+          continue;
+        result.push(element);
+      }
+      break;
+    }
+  }
+  if (matched)
+    return result;
+};
+var assemble = (repertoire, config, characters, dictionary, adaptedFrequency, analysisResult, customElements) => {
+  const { customized, compoundResults } = analysisResult;
+  const extra = { rootSequence: analysisResult.rootSequence };
+  const func = compile(config.keyboard, config.encoder, config.algebra);
+  const result = [];
+  algebraCache.clear();
+  const characterCache = /* @__PURE__ */ new Map();
+  const customLookup = (character) => Object.fromEntries(
+    Object.entries(customElements).map(([name, map]) => {
+      return [name, (map[character] ?? []).map((x) => `${name}-${x}`)];
+    })
+  );
+  for (const character of characters) {
+    const frequency = adaptedFrequency.get(character) ?? 0;
+    const shapeInfo = customized.get(character) || compoundResults.get(character);
+    if (shapeInfo === void 0)
+      continue;
+    const final = [];
+    if (character in repertoire === false)
+      continue;
+    const readings = [...repertoire[character].readings];
+    if (readings.length === 0) {
+      readings.push({ pinyin: "", importance: 100 });
+    }
+    for (const reading of readings) {
+      const result2 = {
+        char: character,
+        pinyin: reading.pinyin,
+        frequency: Math.round(frequency * (reading.importance / 100)),
+        ...shapeInfo,
+        custom: customLookup(character)
+      };
+      const elements = func(result2, repertoire, extra);
+      characterCache.set(`${character}:${reading.pinyin}`, elements);
+      const summary = summarize(elements);
+      let isDuplicated = false;
+      for (const previous of final) {
+        if (summarize(previous.sequence) === summary) {
+          previous.frequency += result2.frequency;
+          previous.pinyin_list.push(reading.pinyin);
+          isDuplicated = true;
+          break;
+        }
+      }
+      if (!isDuplicated) {
+        final.push({
+          name: character,
+          sequence: elements,
+          frequency: result2.frequency,
+          pinyin_list: [reading.pinyin]
+        });
+      }
+    }
+    result.push(...final);
+  }
+  const rules = config.encoder.rules;
+  if (!rules)
+    return result;
+  const knownWords = /* @__PURE__ */ new Set();
+  for (const [word, pinyin] of dictionary) {
+    const frequency = adaptedFrequency.get(word) ?? 0;
+    const characters2 = Array.from(word);
+    const syllables = pinyin.split(" ");
+    let valid = true;
+    const totalElements = [];
+    for (const [i, character] of characters2.entries()) {
+      const pinyin2 = syllables[i];
+      const hash2 = `${character}:${pinyin2}`;
+      let elements = characterCache.get(hash2);
+      if (elements !== void 0) {
+        totalElements.push(elements);
+        continue;
+      }
+      const shapeInfo = customized.get(character) || compoundResults.get(character);
+      if (shapeInfo === void 0) {
+        valid = false;
+        break;
+      }
+      const result2 = {
+        char: character,
+        pinyin: pinyin2,
+        frequency,
+        ...shapeInfo,
+        custom: customLookup(character)
+      };
+      elements = func(result2, repertoire, extra);
+      totalElements.push(elements);
+    }
+    if (!valid)
+      continue;
+    const wordElements = gather(totalElements, rules);
+    if (wordElements === void 0)
+      continue;
+    const hash = `${word}:${summarize(wordElements)}`;
+    if (knownWords.has(hash))
+      continue;
+    result.push({
+      name: word,
+      sequence: wordElements,
+      frequency,
+      pinyin_list: [pinyin]
+    });
+    knownWords.add(hash);
+  }
+  const priorityMap = getPriorityMap(config.priority);
+  return result.map((x) => {
+    const hash = `${x.name}-${x.pinyin_list.join(",")}`;
+    const level = priorityMap.get(hash);
+    return level !== void 0 ? { ...x, level } : x;
+  });
+};
+var stringifySequence = (result) => {
+  return result.map((x) => {
+    return { ...x, sequence: summarize(x.sequence) };
+  });
+};
+var summarize = (elements) => {
+  return elements.map((x) => {
+    if (x === void 0)
+      return "\u03B5";
+    if (typeof x === "string")
+      return x;
+    if (x.index === 0) {
+      return x.element;
+    }
+    return `${x.element}.${x.index}`;
+  }).join(" ");
+};
+
+// src/templates.ts
+import * as path from "path";
+import { load } from "js-yaml";
+import { readFileSync } from "fs";
+function loadConfig(name) {
+  const yamlPath = path.join(__dirname, `examples/${name}.yaml`);
+  const content = readFileSync(yamlPath, "utf8");
+  return load(content);
+}
+var snow4 = loadConfig("snow4");
+var bxm = loadConfig("bxm");
+var mswb = loadConfig("mswb");
+var ziyuan = loadConfig("ziyuan");
+var jdh = loadConfig("jdh");
+var cqkm = loadConfig("cqkm");
+var shouyou = loadConfig("shouyou");
+var xkjd = loadConfig("xkjd");
+var longma = loadConfig("longma");
+var easy = loadConfig("easy");
+var yustar = loadConfig("yustar");
+var yujoy = loadConfig("yujoy");
+var tianma = loadConfig("tianma");
+var zhengma = loadConfig("zhengma");
+var zhenma = loadConfig("zhenma");
+var zhangma = loadConfig("zhangma");
+var xuma = loadConfig("xuma");
+var huma = loadConfig("huma");
+var sapphire = loadConfig("sapphire");
+var examples = {
+  snow4,
+  longma,
+  jdh,
+  shouyou,
+  xkjd,
+  cqkm,
+  bxm,
+  mswb,
+  ziyuan,
+  easy,
+  huma,
+  tianma,
+  sapphire,
+  xuma,
+  yustar,
+  yujoy,
+  zhangma,
+  zhengma,
+  zhenma
+};
+var classifierTypes = [
+  "\u56FD\u6807\u4E94\u5206\u7C7B",
+  "\u8868\u5F62\u7801\u516D\u5206\u7C7B",
+  "\u90D1\u7801\u4E03\u5206\u7C7B"
+];
+var classifierMap = {
+  \u56FD\u6807\u4E94\u5206\u7C7B: {},
+  \u8868\u5F62\u7801\u516D\u5206\u7C7B: examples.mswb.analysis.classifier,
+  \u90D1\u7801\u4E03\u5206\u7C7B: examples.zhengma.analysis.classifier
+};
+var keyboardTypes = [
+  "\u51B0\u96EA\u56DB\u62FC",
+  "\u9F99\u7801",
+  "\u7B80\u5355\u9E64",
+  "\u9996\u53F3\u62FC\u97F3",
+  "\u661F\u7A7A\u952E\u9053",
+  "\u8D85\u5F3A\u5FEB\u7801",
+  "\u8868\u5F62\u7801",
+  "\u7C73\u5341\u4E94\u7B14",
+  "\u5B57\u6E90",
+  "\u5B87\u6D69\xB7\u661F\u9648",
+  "\u537F\u4E91",
+  "\u90D1\u7801",
+  "\u771F\u7801",
+  "\u5F20\u7801",
+  "\u5F90\u7801",
+  "\u864E\u7801",
+  "\u5929\u7801",
+  "\u84DD\u5B9D\u77F3",
+  "\u65E0"
+];
+var keyboardMap = {
+  \u51B0\u96EA\u56DB\u62FC: examples.snow4.form,
+  \u9F99\u7801: examples.longma.form,
+  \u7B80\u5355\u9E64: examples.jdh.form,
+  \u9996\u53F3\u62FC\u97F3: examples.shouyou.form,
+  \u661F\u7A7A\u952E\u9053: examples.xkjd.form,
+  \u8D85\u5F3A\u5FEB\u7801: examples.cqkm.form,
+  \u8868\u5F62\u7801: examples.bxm.form,
+  \u7C73\u5341\u4E94\u7B14: examples.mswb.form,
+  \u5B57\u6E90: examples.ziyuan.form,
+  "\u5B87\u6D69\xB7\u661F\u9648": examples.yustar.form,
+  \u537F\u4E91: examples.yujoy.form,
+  \u90D1\u7801: examples.zhengma.form,
+  \u771F\u7801: examples.zhenma.form,
+  \u5F20\u7801: examples.zhangma.form,
+  \u5F90\u7801: examples.xuma.form,
+  \u864E\u7801: examples.huma.form,
+  \u5929\u7801: examples.tianma.form,
+  \u84DD\u5B9D\u77F3: examples.sapphire.form,
+  \u65E0: {
+    alphabet: "qwertyuiopasdfghjklzxcvbnm",
+    mapping: {}
+  }
+};
+var encoderTypes = [
+  "\u97F3\u7801\uFF08\u51B0\u96EA\u56DB\u62FC\uFF09",
+  "\u97F3\u7801\uFF08\u9F99\u7801\uFF09",
+  "\u97F3\u5F62\u7801\uFF08\u7B80\u5355\u9E64\uFF09",
+  "\u97F3\u5F62\u7801\uFF08\u9996\u53F3\u62FC\u97F3\uFF09",
+  "\u97F3\u5F62\u7801\uFF08\u661F\u7A7A\u952E\u9053\uFF09",
+  "\u97F3\u5F62\u7801\uFF08\u8D85\u5F3A\u5FEB\u7801\uFF09",
+  "\u5F62\u97F3\u7801\uFF08\u8868\u5F62\u7801\uFF09",
+  "\u5F62\u97F3\u7801\uFF08\u7C73\u5341\u4E94\u7B14\uFF09",
+  "\u5F62\u97F3\u7801\uFF08\u5B57\u6E90\uFF09",
+  "\u5355\u7F16\u5F62\u7801\uFF08\u5F20\u7801\uFF09",
+  "\u5355\u7F16\u5F62\u7801\uFF08\u84DD\u5B9D\u77F3\uFF09",
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u90D1\u7801\uFF09",
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u771F\u7801\uFF09",
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u5F90\u7801\uFF09",
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u6613\u7801\uFF09",
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u5B87\u6D69\xB7\u661F\u9648\uFF09",
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u537F\u4E91\uFF09",
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u864E\u7801\uFF09",
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u5929\u7801\uFF09"
+];
+var encoderMap = {
+  "\u97F3\u7801\uFF08\u51B0\u96EA\u56DB\u62FC\uFF09": examples.snow4.encoder,
+  "\u97F3\u7801\uFF08\u9F99\u7801\uFF09": examples.longma.encoder,
+  "\u97F3\u5F62\u7801\uFF08\u7B80\u5355\u9E64\uFF09": examples.jdh.encoder,
+  "\u97F3\u5F62\u7801\uFF08\u9996\u53F3\u62FC\u97F3\uFF09": examples.shouyou.encoder,
+  "\u97F3\u5F62\u7801\uFF08\u661F\u7A7A\u952E\u9053\uFF09": examples.xkjd.encoder,
+  "\u97F3\u5F62\u7801\uFF08\u8D85\u5F3A\u5FEB\u7801\uFF09": examples.cqkm.encoder,
+  "\u5F62\u97F3\u7801\uFF08\u8868\u5F62\u7801\uFF09": examples.bxm.encoder,
+  "\u5F62\u97F3\u7801\uFF08\u7C73\u5341\u4E94\u7B14\uFF09": examples.mswb.encoder,
+  "\u5F62\u97F3\u7801\uFF08\u5B57\u6E90\uFF09": examples.ziyuan.encoder,
+  "\u5355\u7F16\u5F62\u7801\uFF08\u5F20\u7801\uFF09": examples.zhangma.encoder,
+  "\u5355\u7F16\u5F62\u7801\uFF08\u84DD\u5B9D\u77F3\uFF09": examples.sapphire.encoder,
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u90D1\u7801\uFF09": examples.zhengma.encoder,
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u771F\u7801\uFF09": examples.zhenma.encoder,
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u5F90\u7801\uFF09": examples.xuma.encoder,
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u6613\u7801\uFF09": examples.easy.encoder,
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u5B87\u6D69\xB7\u661F\u9648\uFF09": examples.yustar.encoder,
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u537F\u4E91\uFF09": examples.yujoy.encoder,
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u864E\u7801\uFF09": examples.huma.encoder,
+  "\u53CC\u7F16\u5F62\u7801\uFF08\u5929\u7801\uFF09": examples.tianma.encoder
+};
+var createConfig = (starter) => {
+  const form = keyboardMap[starter.keyboard];
+  const classifier2 = classifierMap[starter.data];
+  for (const value of Object.values(mergeClassifier(classifier2))) {
+    const element = value.toString();
+    if (!form.mapping[element]) {
+      form.mapping[element] = form.alphabet?.[0];
+    }
+  }
+  return {
+    version: "0.3",
+    source: null,
+    info: {
+      name: starter.name,
+      author: "\u65E0\u540D\u6C0F",
+      version: "1.0.0",
+      description: "\u4ECE\u6A21\u677F\u521B\u5EFA"
+    },
+    analysis: {
+      classifier: classifier2,
+      degenerator: defaultDegenerator,
+      selector: defaultSelector
+    },
+    form,
+    encoder: encoderMap[starter.encoder]
+  };
+};
+var defaultConfig = createConfig({
+  name: "",
+  data: "\u56FD\u6807\u4E94\u5206\u7C7B",
+  keyboard: "\u65E0",
+  encoder: "\u5F62\u97F3\u7801\uFF08\u7C73\u5341\u4E94\u7B14\uFF09"
+});
+export {
+  InvalidGlyphError,
+  MultipleSchemeError2 as MultipleSchemeError,
+  NoSchemeError,
+  adapt,
+  affineMerge,
+  algebraCache,
+  analysis,
+  applyRules,
+  area,
+  assemble,
+  attaching,
+  bias,
+  binaryOps,
+  binaryToIndices,
+  characterSetSpecifiers,
+  chars,
+  classifier,
+  classifierTypes,
+  computeComponent,
+  createConfig,
+  crossing,
+  curveLength,
+  curveRelation,
+  defaultAlgebra,
+  defaultConfig,
+  defaultDegenerator,
+  defaultOptimization,
+  defaultSelector,
+  degenerate,
+  determine,
+  disassembleComponents,
+  disassembleCompounds,
+  distance,
+  dynamicAnalysis,
+  encoderTypes,
+  examples,
+  exportJSON,
+  exportTSV,
+  exportYAML,
+  findCorners,
+  findCrossPoint,
+  findElement,
+  findGlyphIndex,
+  findTopology,
+  fingeringLabels,
+  formatDate,
+  generateSchemes,
+  generateSliceBinaries,
+  getBoundingBox,
+  getComponentScheme,
+  getDictFromTSV,
+  getDistributionFromTSV,
+  getDummyBasicComponent,
+  getDummyCompound,
+  getDummyDerivedComponent,
+  getDummyReferenceStroke,
+  getDummySVGStroke,
+  getDummySplicedComponent,
+  getGlyphBoundingBox,
+  getIntervalOnOrientation,
+  getIntervalPosition,
+  getPriorityMap,
+  getRecordFromTSV,
+  getRequiredTargets,
+  getReversedMapping,
+  getSupplemental,
+  indicesToBinary,
+  integrity,
+  isBoundedBy,
+  isCollinear,
+  isComponent,
+  isConforming,
+  isLess,
+  isMerge,
+  isPUA,
+  isValidCJKBasicChar,
+  isValidCJKChar,
+  isValidCJKSupplement,
+  isVariableKey,
+  joinKeys,
+  keyboardTypes,
+  length,
+  listToObject,
+  makeCharacterFilter,
+  makeCurve,
+  makeDefaultAnalyzer,
+  makeFilter,
+  makeIntervalSum,
+  mergeClassifier,
+  operators,
+  ops,
+  order,
+  order2,
+  orientation,
+  parseKey,
+  parseList,
+  printableAscii,
+  pronunciationElementTypes,
+  recursiveRenderComponent,
+  recursiveRenderCompound,
+  recursiveRenderStrokeSequence,
+  render,
+  renderList,
+  renderName,
+  renderRootList,
+  renderSVGGlyph,
+  renderSVGStroke,
+  schema,
+  select,
+  serializerMap,
+  serializerTypes,
+  sieveMap,
+  similar,
+  sortTwoNumbers,
+  stringify,
+  stringifySequence,
+  strokeRelation,
+  strong,
+  summarize,
+  topologicalSort,
+  unaryOps,
+  unbias,
+  unicodeBlock,
+  unicodeBlockRank,
+  unicodeBlocks,
+  weak,
+  wordLengthArray
+};