modern-text 1.11.1 → 2.0.0

package/dist/index.mjs

@@ -1,5 +1,7 @@
-import { T as Text } from './shared/modern-text.Dqw5Z6MV.mjs';
-export { C as Canvas2DRenderer, a as Character, F as Fragment, M as Measurer, P as Paragraph, b as backgroundPlugin, c as createSvgLoader, d as createSvgParser, e as definePlugin, g as getEffectTransform2D, f as getHighlightStyle, h as highlightPlugin, i as isEqualObject, j as isEqualValue, l as listStylePlugin, o as outlinePlugin, p as parseColormap, k as parseTransformOrigin, m as parseValueNumber, r as renderPlugin, t as textDecorationPlugin, n as textDefaultStyle } from './shared/modern-text.Dqw5Z6MV.mjs';
+import { T as Text } from './shared/modern-text.ChzjFjsk.mjs';
+export { C as Canvas2DRenderer, a as Character, D as DomMeasurer, F as FontMeasurer, b as Fragment, P as Paragraph, c as backgroundPlugin, d as createSvgLoader, e as createSvgParser, g as getEffectTransform2D, f as getHighlightStyle, h as highlightPlugin, i as isEqualObject, j as isEqualValue, l as listStylePlugin, o as outlinePlugin, p as parseColormap, k as parseTransformOrigin, m as parseValueNumber, r as renderPlugin, t as textDecorationPlugin, n as textDefaultStyle } from './shared/modern-text.ChzjFjsk.mjs';
+export { d as defineDeformation, a as definePlugin, b as deformationPlugin, g as getDeformationNames, r as removeDeformation } from './shared/modern-text.JF1ny7A-.mjs';
+export { C as CircleCurve, E as EllipseCurve, H as HeartCurve, P as PolygonCurve, R as RectangularCurve } from './shared/modern-text.fT17R5HY.mjs';
 import 'modern-idoc';
 import 'modern-path2d';
 import 'modern-font';

package/dist/shared/modern-text.B2xfrqDc.cjs

@@ -0,0 +1,556 @@
+'use strict';
+
+const modernIdoc = require('modern-idoc');
+const modernPath2d = require('modern-path2d');
+
+function definePlugin(options) {
+  return options;
+}
+
+function splitCurve(curve, point) {
+  let { x, y } = point;
+  if (curve instanceof modernPath2d.QuadraticBezierCurve) {
+    const { p1: v0, cp: v1, p2: v2 } = curve;
+    const s = x !== void 0 && Math.abs(Math.sign(v0.x - x) + Math.sign(v1.x - x) + Math.sign(v2.x - x)) === 1;
+    const n = y !== void 0 && Math.abs(Math.sign(v0.y - y) + Math.sign(v1.y - y) + Math.sign(v2.y - y)) === 1;
+    let o, e, dist, c;
+    if (s) {
+      o = v0.x - 2 * v1.x + v2.x;
+      e = 2 * (-v0.x + v1.x);
+      dist = v0.x - x;
+    }
+    if (n) {
+      o = v0.y - 2 * v1.y + v2.y;
+      e = 2 * (-v0.y + v1.y);
+      dist = v0.y - y;
+    }
+    if (s || n) {
+      c = e * e - 4 * o * dist;
+      if (c > 0) {
+        const h = Math.sqrt(c);
+        const a = (-e + h) / 2 / o;
+        const b = (-e - h) / 2 / o;
+        const u = [a, b].find((v) => v > 0 && v < 1);
+        if (u) {
+          const r = modernPath2d.Vector2.lerp(v0, v1, u);
+          const d = modernPath2d.Vector2.lerp(v1, v2, u);
+          const B = modernPath2d.Vector2.lerp(r, d, u);
+          return [new modernPath2d.QuadraticBezierCurve(v0, r, B), new modernPath2d.QuadraticBezierCurve(B.clone(), d, v2)];
+        }
+      }
+    }
+  } else if (curve instanceof modernPath2d.CubicBezierCurve) {
+    const { p1: v0, cp1: v1, cp2: v2, p2: v3 } = curve;
+    const { min, max } = curve.getMinMax();
+    const e = x !== void 0 && (min.x - x) * (max.x - x) < 0;
+    const l = y !== void 0 && (min.y - y) * (max.y - y) < 0;
+    if (e || l) {
+      x = 0.5 * v0.x + 0.5 * v1.x;
+      y = 0.5 * v0.y + 0.5 * v1.y;
+      const c = new modernPath2d.Vector2(x, y);
+      x = 0.25 * v0.x + 0.5 * v1.x + 0.25 * v2.x;
+      y = 0.25 * v0.y + 0.5 * v1.y + 0.25 * v2.y;
+      const h = new modernPath2d.Vector2(x, y);
+      x = 0.125 * v0.x + 0.375 * v1.x + 0.375 * v2.x + 0.125 * v3.x;
+      y = 0.125 * v0.y + 0.375 * v1.y + 0.375 * v2.y + 0.125 * v3.y;
+      const a = new modernPath2d.Vector2(x, y);
+      x = 0.25 * v1.x + 0.5 * v2.x + 0.25 * v3.x;
+      y = 0.25 * v1.y + 0.5 * v2.y + 0.25 * v3.y;
+      const b = new modernPath2d.Vector2(x, y);
+      x = 0.5 * v2.x + 0.5 * v3.x;
+      y = 0.5 * v2.y + 0.5 * v3.y;
+      const u = new modernPath2d.Vector2(x, y);
+      return [new modernPath2d.CubicBezierCurve(v0, c, h, a), new modernPath2d.CubicBezierCurve(a.clone(), b, u, v3)];
+    }
+  } else if (curve instanceof modernPath2d.LineCurve) {
+    const { p1: v1, p2: v2 } = curve;
+    const changedX = x !== void 0 && (v1.x - x) * (v2.x - x) < 0;
+    const changedY = y !== void 0 && (v1.y - y) * (v2.y - y) < 0;
+    if (changedX) {
+      y = v1.y + (v2.y - v1.y) / (v2.x - v1.x) * (x - v1.x);
+    }
+    if (changedY) {
+      x = v1.x + (v2.x - v1.x) / (v2.y - v1.y) * (y - v1.y);
+    }
+    if (changedX || changedY) {
+      return [new modernPath2d.LineCurve(v1, new modernPath2d.Vector2(x, y)), new modernPath2d.LineCurve(new modernPath2d.Vector2(x, y), v2)];
+    }
+  }
+  return [curve];
+}
+
+class Deformer {
+  get boundingBox() {
+    return this.text.lineBox;
+  }
+  get paragraphs() {
+    return this.text.paragraphs;
+  }
+  get isHorizontal() {
+    return this.text.computedStyle.writingMode.startsWith("horizontal");
+  }
+  get baseWidth() {
+    return this.isHorizontal ? this.boundingBox.width : this.boundingBox.height;
+  }
+  get baseHeight() {
+    return this.isHorizontal ? this.boundingBox.height : this.boundingBox.width;
+  }
+  get characters() {
+    return this.paragraphs.flatMap((p) => p.fragments.flatMap((f) => f.characters));
+  }
+  constructor({ text, intensities = [], maxFontSize = 100 }) {
+    this.text = text;
+    this.intensities = intensities.map((val) => val / 100);
+    this.lineHeight = maxFontSize;
+  }
+  _breakLine() {
+    const isVertical = !this.isHorizontal;
+    const { left, top, bottom, right } = this.boundingBox;
+    const x = 0.5 * (left + right);
+    const y = 0.5 * (top + bottom);
+    this.characters.forEach((character) => {
+      if (!character.glyphBox) {
+        return;
+      }
+      character.path.curves.forEach((subPath) => {
+        subPath.curves = subPath.curves.flatMap((curve) => {
+          return splitCurve(curve, isVertical ? { y } : { x });
+        });
+      });
+    });
+  }
+  _makeTheJointSmooth() {
+    this.characters.forEach((character) => {
+      if (!character.glyphBox) {
+        return;
+      }
+      character.path.getFlatCurves().forEach((curve) => {
+        if (curve instanceof modernPath2d.QuadraticBezierCurve && curve.isFromLine) {
+          const { p1, cp, p2 } = curve;
+          cp.x = 2 * cp.x - 0.5 * (p1.x + p2.x);
+          cp.y = 2 * cp.y - 0.5 * (p1.y + p2.y);
+        }
+      });
+    });
+  }
+  _lineToQuadraticBezier() {
+    this.characters.forEach((character) => {
+      if (!character.glyphBox) {
+        return;
+      }
+      character.path.curves.forEach((subPath) => {
+        subPath.curves = subPath.curves.map((curve) => {
+          if (curve instanceof modernPath2d.LineCurve && curve.getLength() > 5) {
+            const { p1, p2 } = curve;
+            const res = new modernPath2d.QuadraticBezierCurve(
+              p1.clone(),
+              new modernPath2d.Vector2(0.5 * (p1.x + p2.x), 0.5 * (p1.y + p2.y)),
+              p2.clone()
+            );
+            res.isFromLine = true;
+            return res;
+          }
+          return curve;
+        });
+      });
+    });
+  }
+  _transform(transform, getArg1, getArg) {
+    const highlight = this.text.plugins.get("highlight");
+    const arg = getArg?.();
+    let i = 0;
+    const charactersLength = this.characters.filter((c) => c.glyphBox).length;
+    this.paragraphs.forEach((paragraph, paragraphIndex) => {
+      paragraph.fragments.forEach((fragment, fragmentIndex) => {
+        fragment.characters.forEach((character, characterIndex) => {
+          if (!character.glyphBox) {
+            return;
+          }
+          const arg1 = getArg1?.(
+            {
+              paragraphIndex,
+              fragmentIndex,
+              characterIndex,
+              character
+            },
+            arg
+          );
+          character.path.getControlPointRefs().forEach((point) => {
+            const [x, y] = transform(point, arg1);
+            point.set(x, y);
+          });
+          if (getArg1 && highlight?.pathSet?.paths) {
+            const step = highlight.pathSet.paths.length / charactersLength;
+            const start = i * step;
+            for (let _i = 0; _i < step; _i++) {
+              highlight?.pathSet?.paths[start + _i]?.getControlPointRefs().forEach((point) => {
+                const [x, y] = transform(point, arg1);
+                point.set(x, y);
+              });
+            }
+            i++;
+          }
+        });
+      });
+    });
+    this.paragraphs.forEach((paragraph) => {
+      paragraph.fragments.forEach((fragment) => {
+        fragment.characters.forEach((character) => {
+          character.glyphBox = character.getGlyphBoundingBox();
+          if (character.glyphBox) {
+            character.inlineBox = character.glyphBox;
+          }
+        });
+      });
+    });
+    if (!getArg1) {
+      highlight?.pathSet?.paths?.forEach((v) => {
+        v.getControlPointRefs().forEach((point) => {
+          const [x, y] = transform(point);
+          point.set(x, y);
+        });
+      });
+    }
+  }
+}
+
+class BendDeformer extends Deformer {
+  constructor(options, preset) {
+    super(options);
+    this.preset = preset;
+  }
+  deform() {
+    if (!Math.hypot(...this.intensities)) {
+      return;
+    }
+    this._lineToQuadraticBezier();
+    this._bend();
+    this._makeTheJointSmooth();
+  }
+  _bend() {
+    const { boundingBox, baseWidth, baseHeight, preset } = this;
+    const lineHeight = this.lineHeight * 2 / Math.sin(this.intensities[0] * Math.PI * 0.5);
+    const isVertical = preset.vertical === void 0 || preset.vertical === "auto" ? !this.isHorizontal : preset.vertical;
+    const { left, top, width, height } = boundingBox;
+    const size = (isVertical ? height : width) / 2 / lineHeight;
+    const center = {
+      x: left + width / 2,
+      y: top + height / 2
+    };
+    let centerDistAngle;
+    const centerDist = { x: center.x, y: center.y };
+    if (isVertical) {
+      centerDistAngle = 0;
+      centerDist.x -= baseHeight / 2 / Math.tan(size) + Math.sign(size) * width / 2;
+    } else {
+      centerDistAngle = 1.5 * Math.PI;
+      centerDist.y += baseWidth / 2 / Math.tan(size) + Math.sign(size) * height / 2;
+    }
+    const method = preset.transform({
+      lineHeight,
+      size,
+      center,
+      centerDist,
+      centerDistAngle,
+      width,
+      height,
+      isHorizontal: this.isHorizontal
+    });
+    this._transform(method);
+  }
+}
+
+class FfdDeformer extends Deformer {
+  constructor(options, preset) {
+    super(options);
+    this.preset = preset;
+  }
+  deform() {
+    if (!Math.hypot(...this.intensities)) {
+      return;
+    }
+    const { preset } = this;
+    if (preset.breakLine) {
+      this._breakLine();
+    }
+    if (preset.lineToQuad) {
+      this._lineToQuadraticBezier();
+    }
+    const [a, b] = this.intensities;
+    const points = this._createFFDControlPoints(preset.hBlocks, preset.vBlocks);
+    preset.build(points, {
+      a,
+      b,
+      baseWidth: this.baseWidth,
+      baseHeight: this.baseHeight,
+      lineHeight: this.lineHeight,
+      adjust: (point, dx, dy) => this._adjustControlPoints(point, { x: dx, y: dy })
+    });
+    if (preset.bezier) {
+      this._calculateForBezierFFD(points, preset.hBlocks, preset.vBlocks);
+      this._makeTheJointSmooth();
+    } else {
+      this._calculateForLinearFFD(points, preset.hBlocks, preset.vBlocks);
+    }
+  }
+  _calculateForFFD(cb, points, hBlocks, vBlocks) {
+    const { left, top, right, width, height } = this.boundingBox;
+    this._transform(
+      this.isHorizontal ? (point) => {
+        const xProgress = (point.x - left) / width;
+        const yProgress = (point.y - top) / height;
+        let [x, y] = [0, 0];
+        for (let h = 0; h < hBlocks + 2; h++) {
+          const _h = cb(hBlocks, h, xProgress);
+          for (let v = 0; v < vBlocks + 2; v++) {
+            const _v = cb(vBlocks, v, yProgress);
+            const p = points[h * (vBlocks + 2) + v];
+            x += _h * _v * p.x;
+            y += _h * _v * p.y;
+          }
+        }
+        return [x, y];
+      } : (point) => {
+        const xProgress = (right - point.x) / width;
+        const yProgress = (point.y - top) / height;
+        let [x, y] = [0, 0];
+        for (let h = 0; h < hBlocks + 2; h++) {
+          const _h = cb(hBlocks, h, yProgress);
+          for (let v = 0; v < vBlocks + 2; v++) {
+            const _v = cb(vBlocks, v, xProgress);
+            const p = points[h * (vBlocks + 2) + v];
+            x += _h * _v * p.x;
+            y += _h * _v * p.y;
+          }
+        }
+        return [x, y];
+      }
+    );
+  }
+  _createFFDControlPoints(hBlocks, vBlocks) {
+    const { left, top, right, width, height } = this.boundingBox;
+    const points = [];
+    if (this.isHorizontal) {
+      const avgWidth = width / (hBlocks + 1);
+      const avgHeight = height / (vBlocks + 1);
+      for (let h = 0; h < hBlocks + 2; h++) {
+        for (let v = 0; v < vBlocks + 2; v++) {
+          points.push(new modernPath2d.Vector2(left + h * avgWidth, top + v * avgHeight));
+        }
+      }
+    } else {
+      const avgWidth = width / (vBlocks + 1);
+      const avgHeight = height / (hBlocks + 1);
+      for (let h = 0; h < hBlocks + 2; h++) {
+        for (let v = 0; v < vBlocks + 2; v++) {
+          points.push(new modernPath2d.Vector2(right - v * avgWidth, top + h * avgHeight));
+        }
+      }
+    }
+    return points;
+  }
+  _adjustControlPoints(point1, point2) {
+    if (this.isHorizontal) {
+      point1.x += point2.x;
+      point1.y += point2.y;
+    } else {
+      point1.x -= point2.y;
+      point1.y += point2.x;
+    }
+  }
+  _factorialForFFD(val) {
+    let result = 1;
+    for (let i = 2; i <= val; i++) {
+      result *= i;
+    }
+    return result;
+  }
+  _combineForFFD(total, current) {
+    return this._factorialForFFD(total) / this._factorialForFFD(total - current) / this._factorialForFFD(current);
+  }
+  _calculateForBezierFFD(points, hBlocks, vBlocks) {
+    this._calculateForFFD(
+      (count, current, progress) => {
+        return this._combineForFFD(count + 1, current) * (1 - progress) ** (count + 1 - current) * progress ** current;
+      },
+      points,
+      hBlocks,
+      vBlocks
+    );
+  }
+  _linearBasis(count, current, progress) {
+    const t = current < progress * count ? current + 1 - progress * count : progress * count - current + 1;
+    return Math.max(0, t);
+  }
+  _calculateForLinearFFD(points, hBlocks, vBlocks) {
+    this._calculateForFFD(
+      (count, current, progress) => {
+        return this._linearBasis(count + 1, current, progress);
+      },
+      points,
+      hBlocks,
+      vBlocks
+    );
+  }
+}
+
+class VerbatimDeformer extends Deformer {
+  constructor(options, preset) {
+    super(options);
+    this.preset = preset;
+  }
+  _context() {
+    return {
+      intensities: this.intensities,
+      baseWidth: this.baseWidth,
+      lineHeight: this.lineHeight,
+      isHorizontal: this.isHorizontal,
+      boundingBox: this.boundingBox
+    };
+  }
+  deform() {
+    if (!Math.hypot(...this.intensities)) {
+      return;
+    }
+    const { preset } = this;
+    const ctx = this._context();
+    if (preset.engine === "offset") {
+      this._transform(
+        preset.point,
+        preset.perChar ? (info) => preset.perChar(ctx, info) : void 0
+      );
+    } else {
+      const followTangent = preset.followTangent ?? true;
+      const { funcPerChar, funcPerPoint } = this._getPerCharAndPointFunc(followTangent);
+      this._transform(funcPerPoint, funcPerChar, () => {
+        const { width, height, left, top } = this.boundingBox;
+        return {
+          width,
+          height,
+          left,
+          top,
+          curve: preset.makeCurve(ctx),
+          isHorizontal: this.isHorizontal,
+          needExpandAlongNormal: preset.expandAlongNormal ?? false
+        };
+      });
+    }
+  }
+  _getPerCharAndPointFunc(rotate = false) {
+    let funcPerChar;
+    let funcPerPoint;
+    if (rotate) {
+      funcPerPoint = this._resetPointPos;
+      funcPerChar = this._calculateNewCenter;
+    } else {
+      funcPerPoint = this._resetPointPosWithoutRotate;
+      funcPerChar = this._calculateNewCenterWithoutRotate;
+    }
+    return {
+      funcPerPoint,
+      funcPerChar
+    };
+  }
+  _calculateNewCenter({ character }, arg) {
+    const { width, height, left, top, curve, isHorizontal, needExpandAlongNormal = false } = arg;
+    const { center, centerDiviation } = character;
+    const pos = isHorizontal ? (center.x - left) / width : (center.y - top) / height;
+    const a = isHorizontal ? new modernPath2d.Vector2(0, center.y - top) : new modernPath2d.Vector2(center.x - left, 0);
+    if (needExpandAlongNormal) {
+      const p = curve.getNormal(pos);
+      a.x += p.x * -centerDiviation;
+      a.y += p.y * -centerDiviation;
+    }
+    const newCenter = curve.getPointAt(pos).add(a);
+    const tangent = curve.getTangent(pos);
+    const cos = tangent.x;
+    const sin = tangent.y;
+    return {
+      cos,
+      sin,
+      newCenter,
+      center
+    };
+  }
+  _calculateNewCenterWithoutRotate({ character }, arg) {
+    const { width, height, left, top, curve, isHorizontal } = arg;
+    const { center } = character;
+    const pos = isHorizontal ? (center.x - left) / width : (center.y - top) / height;
+    const offsetPoint = isHorizontal ? new modernPath2d.Vector2(0, center.y - top) : new modernPath2d.Vector2(center.x - left, 0);
+    return {
+      newCenter: curve.getPointAt(pos).add(offsetPoint),
+      center
+    };
+  }
+  _resetPointPos(point, arg) {
+    const { cos = 1, sin = 0, center, newCenter } = arg;
+    const dx = point.x - center.x;
+    const dy = point.y - center.y;
+    const x = newCenter.x + dx * cos - dy * sin;
+    const y = newCenter.y + dx * sin + dy * cos;
+    return [x, y];
+  }
+  _resetPointPosWithoutRotate(point, arg) {
+    const { center, newCenter } = arg;
+    const x = point.x - center.x + newCenter.x;
+    const y = point.y - center.y + newCenter.y;
+    return [x, y];
+  }
+}
+
+const deformationPresets = /* @__PURE__ */ new Map();
+function defineDeformation(name, preset) {
+  deformationPresets.set(name, preset);
+}
+function removeDeformation(name) {
+  deformationPresets.delete(name);
+}
+function getDeformationNames() {
+  return [...deformationPresets.keys()];
+}
+function deformationPlugin() {
+  return definePlugin({
+    name: "deformation",
+    updateOrder: 2,
+    update: (text) => {
+      const config = text.deformation;
+      const type = config?.type;
+      if (modernIdoc.isNone(type) || !type) {
+        return;
+      }
+      const preset = deformationPresets.get(type);
+      if (!preset) {
+        return;
+      }
+      const options = {
+        text,
+        intensities: config.intensities ?? preset.defaultIntensities,
+        maxFontSize: config.maxFontSize
+      };
+      let deformer;
+      switch (preset.engine) {
+        case "ffd":
+          deformer = new FfdDeformer(options, preset);
+          break;
+        case "bend":
+          deformer = new BendDeformer(options, preset);
+          break;
+        case "curve":
+        case "offset":
+          deformer = new VerbatimDeformer(options, preset);
+          break;
+      }
+      deformer.deform();
+      const box = text.getGlyphBox();
+      text.rawGlyphBox = box;
+      text.glyphBox = box;
+      text.lineBox = box;
+    }
+  });
+}
+
+exports.defineDeformation = defineDeformation;
+exports.definePlugin = definePlugin;
+exports.deformationPlugin = deformationPlugin;
+exports.getDeformationNames = getDeformationNames;
+exports.removeDeformation = removeDeformation;

package/dist/shared/modern-text.BD7PBYt7.d.cts

@@ -0,0 +1,100 @@
+import { Vector2Like, BoundingBox, Vector2 } from 'modern-path2d';
+import { a as Character } from './modern-text.D4WopQCu.cjs';
+
+/** 逐字沿形状排布所需的曲线最小接口（实现了这三个方法即可当作变形曲线） */
+interface DeformationCurve {
+    getPointAt: (u: number, output?: Vector2) => Vector2;
+    getTangent: (t: number, output?: Vector2) => Vector2;
+    getNormal: (t: number, output?: Vector2) => Vector2;
+}
+/** FFD 预设 `build` 的上下文 */
+interface FfdContext {
+    /** 强度 1（intensities[0]，已 /100） */
+    a: number;
+    /** 强度 2（intensities[1]，已 /100） */
+    b: number;
+    baseWidth: number;
+    baseHeight: number;
+    lineHeight: number;
+    /** 沿当前书写方向调整控制点（内部处理横/竖轴向互换） */
+    adjust: (point: Vector2Like, dx: number, dy: number) => void;
+}
+/** Bend 预设 `transform` 的上下文（引擎已算好弯曲几何） */
+interface BendContext {
+    /** 弯曲半径 */
+    lineHeight: number;
+    size: number;
+    center: {
+        x: number;
+        y: number;
+    };
+    centerDist: {
+        x: number;
+        y: number;
+    };
+    /** 起始角 */
+    centerDistAngle: number;
+    width: number;
+    height: number;
+    isHorizontal: boolean;
+}
+/** 逐字预设（offset / curve）的上下文 */
+interface VerbatimContext {
+    /** 强度数组（已 /100） */
+    intensities: number[];
+    baseWidth: number;
+    lineHeight: number;
+    isHorizontal: boolean;
+    boundingBox: BoundingBox;
+}
+/** 逐字 `perChar` 回调拿到的字符信息 */
+interface DeformationCharInfo {
+    paragraphIndex: number;
+    fragmentIndex: number;
+    characterIndex: number;
+    character: Character;
+}
+interface PresetBase {
+    /** 未显式提供 intensities 时使用的默认值 */
+    defaultIntensities?: number[];
+}
+/** FFD（自由变形）预设：网格规格 + 预处理开关 + 控制点构造 */
+interface FfdPreset extends PresetBase {
+    engine: 'ffd';
+    /** true=贝塞尔 FFD（需平滑），false=线性 FFD */
+    bezier: boolean;
+    hBlocks: number;
+    vBlocks: number;
+    /** 变形前先把字形直线拆段 */
+    breakLine?: boolean;
+    /** 变形前把直线转二次贝塞尔 */
+    lineToQuad?: boolean;
+    build: (points: Vector2[], ctx: FfdContext) => void;
+}
+/** Bend（整体弯曲）预设 */
+interface BendPreset extends PresetBase {
+    engine: 'bend';
+    /** true=竖向弯曲，false=横向，'auto'/省略=跟随书写方向 */
+    vertical?: boolean | 'auto';
+    transform: (ctx: BendContext) => (point: Vector2Like) => readonly [number, number];
+}
+/** 逐字沿曲线排布预设 */
+interface CurvePreset extends PresetBase {
+    engine: 'curve';
+    /** 字符是否沿切线旋转，默认 true */
+    followTangent?: boolean;
+    /** 是否沿法线方向按 centerDiviation 外扩（多边形需要） */
+    expandAlongNormal?: boolean;
+    makeCurve: (ctx: VerbatimContext) => DeformationCurve;
+}
+/** 逐字位移/旋转预设 */
+interface OffsetPreset extends PresetBase {
+    engine: 'offset';
+    /** 逐控制点变换；arg 为 perChar 的返回值 */
+    point: (point: Vector2Like, arg: any) => readonly [number, number];
+    /** 逐字计算参数（透传给 point 的 arg） */
+    perChar?: (ctx: VerbatimContext, info: DeformationCharInfo) => any;
+}
+type DeformationPreset = FfdPreset | BendPreset | CurvePreset | OffsetPreset;
+
+export type { BendContext as B, CurvePreset as C, DeformationCharInfo as D, FfdContext as F, OffsetPreset as O, VerbatimContext as V, BendPreset as a, DeformationCurve as b, DeformationPreset as c, FfdPreset as d };