@knowvah/dot-engine 0.1.0

package/dist/common/arrows-miter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrows-miter.d.ts","sourceRoot":"","sources":["../../src/common/arrows-miter.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAA;CAAE,CAAC;AAwC3E;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,KAAK,EACf,CAAC,EAAE,KAAK,EACR,SAAS,EAAE,KAAK,EAChB,QAAQ,EAAE,MAAM,GACf,QAAQ,CAeV"}

package/dist/common/arrows-shapes-poly.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Complex arrowhead shape/length generators (crow/vee, tee, gap, curve) ported
+ * from lib/common/arrows.c. Split from {@link arrows-shapes} to keep each
+ * module under the size/complexity bar. Pure geometry; no layout/render deps.
+ *
+ * @see lib/common/arrows.c
+ */
+import type { Point } from '../model/geom.js';
+import type { GenResult } from './arrows-shapes-util.js';
+/** @see lib/common/arrows.c:arrow_type_crow (always filled; OPEN has no effect) */
+export declare function genCrow(p: Point, u: Point, arrowsize: number, penwidth: number, flag: number): GenResult;
+/** @see lib/common/arrows.c:arrow_length_crow */
+export declare function arrowLengthCrow(lenfact: number, arrowsize: number, penwidth: number, flag: number): number;
+/** @see lib/common/arrows.c:arrow_type_gap */
+export declare function genGap(p0: Point, u: Point, _arrowsize: number, _penwidth: number, _flag: number): GenResult;
+/** @see lib/common/arrows.c:arrow_type_tee */
+export declare function genTee(p0: Point, u: Point, _arrowsize: number, penwidth: number, flag: number): GenResult;
+/** @see lib/common/arrows.c:arrow_length_tee (preserves the C `_at_start` reuse) */
+export declare function arrowLengthTee(lenfact: number, arrowsize: number, penwidth: number): number;
+/** @see lib/common/arrows.c:arrow_type_curve */
+export declare function genCurve(p0: Point, u: Point, _arrowsize: number, penwidth: number, flag: number): GenResult;
+/** @see lib/common/arrows.c:arrow_length_curve */
+export declare const arrowLengthCurve: (lenfact: number, arrowsize: number, penwidth: number) => number;
+//# sourceMappingURL=arrows-shapes-poly.d.ts.map

package/dist/common/arrows-shapes-poly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrows-shapes-poly.d.ts","sourceRoot":"","sources":["../../src/common/arrows-shapes-poly.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAkGzD,mFAAmF;AACnF,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAOxG;AAED,iDAAiD;AACjD,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAa1G;AAOD,8CAA8C;AAC9C,wBAAgB,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAG3G;AAOD,8CAA8C;AAC9C,wBAAgB,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAyBzG;AAED,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQ3F;AA8BD,gDAAgD;AAChD,wBAAgB,QAAQ,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAiB3G;AAED,kDAAkD;AAClD,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,EAAE,WAAW,MAAM,EAAE,UAAU,MAAM,KAAG,MACrC,CAAC"}

package/dist/common/arrows-shapes-util.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Shared geometry primitives for the arrowhead shape/length generators
+ * ({@link arrows-shapes} closed shapes + {@link arrows-shapes-poly} complex
+ * shapes). Pure helpers ported from lib/common/arrows.c + geomprocs.h.
+ *
+ * @see lib/common/arrows.c
+ */
+import type { Point } from '../model/geom.js';
+import type { ArrowDrawOp, ResolvedArrow } from './arrows-types.js';
+export declare const vsub: (p: Point, q: Point) => Point;
+export declare const vadd: (p: Point, q: Point) => Point;
+export declare const vscale: (c: number, p: Point) => Point;
+/** A vector of length `dist` pointing along `-u` (zero for degenerate `u`). */
+export declare const negUnit: (u: Point, dist: number) => Point;
+/**
+ * The `penwidth/2` shift along `-u` that box/dot/curve/gap apply to pull the
+ * arrow off the node boundary (`delta` in those generators).
+ *
+ * @see lib/common/arrows.c:arrow_type_box / arrow_type_dot (delta computation)
+ */
+export declare const backwardDelta: (u: Point, penwidth: number) => Point;
+/**
+ * Project the segment `from`→`to` onto the arrow axis defined by `phiSrc`,
+ * returning a vector of the projected length (× `sign`) along that axis. This
+ * is the `delta_tip`/`delta_base` miter projection shared by normal0/crow0.
+ *
+ * @see lib/common/arrows.c:arrow_type_normal0 / arrow_type_crow0 (delta math)
+ */
+export declare function axialProjection(phiSrc: Point, from: Point, to: Point, sign: number): Point;
+/**
+ * Shaft vector for one component, reproducing `arrow_gen`'s normalization of the
+ * RAW shaft vector exactly: `s = ARROW_LENGTH / (hypot(u) + EPSILON)`, then nudge
+ * each component by `±EPSILON`, then `arrow_gen_type` scales by `lenfact *
+ * arrowsize`. `dir` MUST be the raw (un-normalized) tip→base vector — its
+ * magnitude is load-bearing because the EPSILON terms are relative to it.
+ * Pre-normalizing `dir` to a unit vector shifts the result by ~one ULP at the
+ * 2-decimal output and breaks byte parity on arrowhead polygons.
+ *
+ * @see lib/common/arrows.c:arrow_gen, arrow_gen_type (EPSILON .0001)
+ */
+export declare const componentU: (dir: Point, lenfact: number, arrowsize: number) => Point;
+/**
+ * Reconstruct the C arrow flag word (type code + INV + open/side modifiers)
+ * from a resolved component. `type` already carries the type code and INV bit.
+ */
+export declare const arrowFlag: (r: ResolvedArrow) => number;
+/** Result of one shape generator: its draw ops + the next tip (base point). */
+export interface GenResult {
+    readonly ops: ArrowDrawOp[];
+    readonly q: Point;
+}
+/**
+ * Map every point of an arrow draw-op through `fn` (and the ellipse center).
+ * Used to translate/rotate stored ops in postproc and flat-edge copy. rx/ry are
+ * left unchanged — arrow ellipses are circles (dot/odot), so a 90° rankdir
+ * rotation that would swap them is a no-op.
+ */
+export declare function mapArrowOpPoints(op: ArrowDrawOp, fn: (p: Point) => Point): ArrowDrawOp;
+/** Signature shared by every per-type shape generator. */
+export type ArrowGen = (p: Point, u: Point, arrowsize: number, penwidth: number, flag: number) => GenResult;
+/** Unit direction + signed angle of a segment `from`→`to` (miter_shape arm). */
+export interface Arm {
+    cos: number;
+    sin: number;
+    angle: number;
+}
+export declare function arm(from: Point, to: Point): Arm;
+/**
+ * Line-join shape (3-point triangle [apex, P1, P2]) at vertex `P` between the
+ * `base_left`→P and P→`base_right` segments, for a stroke of width `penwidth`.
+ * P1/P2 are the penwidth/2 perpendicular offsets of P along each arm.
+ *
+ * @see lib/common/arrows.c:miter_shape
+ * @see https://www.w3.org/TR/SVG2/painting.html#TermLineJoinShape
+ */
+export declare function miterShape(baseLeft: Point, P: Point, baseRight: Point, penwidth: number): Point[];
+//# sourceMappingURL=arrows-shapes-util.d.ts.map

package/dist/common/arrows-shapes-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrows-shapes-util.d.ts","sourceRoot":"","sources":["../../src/common/arrows-shapes-util.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAapE,eAAO,MAAM,IAAI,GAAI,GAAG,KAAK,EAAE,GAAG,KAAK,KAAG,KAAyC,CAAC;AACpF,eAAO,MAAM,IAAI,GAAI,GAAG,KAAK,EAAE,GAAG,KAAK,KAAG,KAAyC,CAAC;AACpF,eAAO,MAAM,MAAM,GAAI,GAAG,MAAM,EAAE,GAAG,KAAK,KAAG,KAAqC,CAAC;AAEnF,+EAA+E;AAC/E,eAAO,MAAM,OAAO,GAAI,GAAG,KAAK,EAAE,MAAM,MAAM,KAAG,KAIhD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,GAAG,KAAK,EAAE,UAAU,MAAM,KAAG,KAAmC,CAAC;AAE/F;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,CAY1F;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,KAAK,EAAE,SAAS,MAAM,EAAE,WAAW,MAAM,KAAG,KAK3E,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,GAAG,aAAa,KAAG,MAId,CAAC;AAEhC,+EAA+E;AAC/E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,CAAC;IAC5B,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,GAAG,WAAW,CAOtF;AAED,0DAA0D;AAC1D,MAAM,MAAM,QAAQ,GAAG,CACrB,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAClE,SAAS,CAAC;AASf,gFAAgF;AAChF,MAAM,WAAW,GAAG;IAAG,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AAChE,wBAAgB,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,GAAG,CAO/C;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,EAAE,CAiBjG"}

package/dist/common/arrows-shapes.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Arrowhead geometry — pure port of the closed-shape (normal/box/diamond/dot)
+ * generators and the length/dispatch layer of lib/common/arrows.c. Complex
+ * shapes (crow/vee/tee/gap/curve) live in {@link arrows-shapes-poly}; shared
+ * primitives in {@link arrows-shapes-util}. Produces {@link ArrowDrawOp}s and
+ * clip lengths from a resolved arrow type, a tip point, and a shaft direction.
+ *
+ * Convention (from `arrow_gen`/`arrow_gen_type`): `u` is the shaft vector from
+ * the tip toward the base, length `ARROW_LENGTH * lenfact * arrowsize` per
+ * component. Each generator returns the visual start point `q` (the base),
+ * which becomes the tip of the next stacked component (compound stacking).
+ *
+ * @see lib/common/arrows.c
+ * @see plans/arrowhead-geometry/decisions.md ADR-2
+ */
+import type { Point } from '../model/geom.js';
+import type { ArrowDrawOp, ResolvedArrow } from './arrows-types.js';
+import { type GenResult } from './arrows-shapes-util.js';
+/**
+ * Length of one resolved component (the per-type length function), matching the
+ * `Arrowtypes[].len` dispatch. gap/none use `arrow_length_generic`.
+ *
+ * @see lib/common/arrows.c:arrow_length (per-type dispatch)
+ */
+export declare function arrowLengthOne(r: ResolvedArrow, arrowsize: number, penwidth: number): number;
+/**
+ * Total clip length over a parsed compound arrow (sum of component lengths).
+ * Returns 0 when arrowsize is 0, matching `arrow_length`.
+ *
+ * @see lib/common/arrows.c:arrow_length (:253)
+ */
+export declare function arrowLength(comps: ResolvedArrow[], arrowsize: number, penwidth: number): number;
+/**
+ * Generate draw ops for ONE resolved component at `tip`, with shaft direction
+ * `dir` (tip → base). Dispatches across all eight arrow types.
+ *
+ * @see lib/common/arrows.c:arrow_gen_type
+ */
+export declare function dispatchSimple(r: ResolvedArrow, tip: Point, dir: Point, arrowsize: number, penwidth: number): GenResult;
+/**
+ * Generate all draw ops for a parsed compound arrow (up to 4 stacked
+ * components). Each component is drawn at the running tip and advances the tip
+ * to its base, matching `arrow_gen`'s loop. Stops at the first NONE component.
+ *
+ * @see lib/common/arrows.c:arrow_gen
+ */
+export declare function arrowDrawOps(comps: ResolvedArrow[], tip: Point, dir: Point, arrowsize: number, penwidth: number): ArrowDrawOp[];
+//# sourceMappingURL=arrows-shapes.d.ts.map

package/dist/common/arrows-shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrows-shapes.d.ts","sourceRoot":"","sources":["../../src/common/arrows-shapes.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAEkB,KAAK,SAAS,EACtC,MAAM,yBAAyB,CAAC;AA2PjC;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAY5F;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM/F;AAOD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAC5E,SAAS,CAeX;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,aAAa,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAClF,WAAW,EAAE,CAYf"}

package/dist/common/arrows-types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Typed arrow draw-op union and the resolved-arrow descriptor.
+ *
+ * graphviz C emits arrowheads at render time as a sequence of primitive draw
+ * calls (`gvrender_polygon` / `gvrender_ellipse` / `gvrender_polyline`). A
+ * single `Point[]` cannot represent an `<ellipse>` (dot/odot) nor a compound
+ * arrow that stacks several primitives, so this port models each emitted
+ * primitive as a discriminated-union op (ADR-1).
+ *
+ * @see lib/common/arrows.c:arrow_gen / arrow_gencode (emit sequence)
+ * @see plans/arrowhead-geometry/decisions.md ADR-1
+ */
+import type { Point } from '../model/geom.js';
+/**
+ * One primitive draw operation produced for an arrowhead. Geometry is in
+ * graphviz (y-up) space; the SVG y-flip happens later in the renderer.
+ */
+export type ArrowDrawOp = {
+    readonly kind: 'polygon';
+    readonly points: Point[];
+    readonly filled: boolean;
+} | {
+    readonly kind: 'ellipse';
+    readonly center: Point;
+    readonly rx: number;
+    readonly ry: number;
+    readonly filled: boolean;
+} | {
+    readonly kind: 'polyline';
+    readonly points: Point[];
+} | {
+    readonly kind: 'bezier';
+    readonly points: Point[];
+};
+/**
+ * A single parsed arrow component resolved to its dispatch info: the
+ * `ARR_TYPE_*` code (with `ARR_MOD_INV` OR'd in for inv/vee/icurve), the
+ * open/side modifiers, and the type's length factor.
+ *
+ * `type` carries the type code in its low `BITS_PER_ARROW_TYPE` bits plus the
+ * `ARR_MOD_INV` bit when the name implies inversion; `open`/`left`/`right`
+ * mirror the user-supplied `o`/`l`/`r` prefix modifiers from the parsed
+ * component.
+ *
+ * @see lib/common/arrows.c:Arrowtypes
+ */
+export interface ResolvedArrow {
+    /** ARR_TYPE_* code, optionally OR'd with ARR_MOD_INV. */
+    readonly type: number;
+    /** Open/outline-only (`o`/`e` prefix, or `empty`/`invempty`). */
+    readonly open: boolean;
+    /** Left half only (`l`/`half` prefix). */
+    readonly left: boolean;
+    /** Right half only (`r` prefix). */
+    readonly right: boolean;
+    /** Ratio of this type's length to the standard ARROW_LENGTH. */
+    readonly lenfact: number;
+}
+//# sourceMappingURL=arrows-types.d.ts.map

package/dist/common/arrows-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrows-types.d.ts","sourceRoot":"","sources":["../../src/common/arrows-types.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;GAGG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAChF;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,GAGvD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,oCAAoC;IACpC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B"}

package/dist/common/arrows.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Arrow type definitions, compound arrow parsing, and rendering stubs.
+ * Ported from lib/common/arrows.c and lib/common/arrows.h.
+ *
+ * @see lib/common/arrows.c
+ * @see lib/common/arrows.h
+ */
+import type { Point } from '../model/geom.js';
+import type { ResolvedArrow } from './arrows-types.js';
+/** One component in a parsed compound arrow string. */
+export interface ArrowComponent {
+    name: string;
+    open: boolean;
+    left: boolean;
+    right: boolean;
+}
+/** Stub edge type; replaced by real EdgeInfo in T24+. */
+export interface ArrowEdgeStub {
+    attr?: Record<string, string>;
+}
+/** Stub port type; replaced by real Port in T24+. */
+export interface ArrowPortStub {
+    x: number;
+    y: number;
+}
+/** Stub render job; replaced by real RenderJob in T24+. */
+export interface ArrowJobStub {
+}
+/** Bundled clip arguments — keeps arrowEndClip/arrowStartClip under 5 params. */
+export interface ArrowClipArgs {
+    e: ArrowEdgeStub;
+    psflag: number;
+    eflag: number;
+    sp: ArrowPortStub;
+    ep: ArrowPortStub;
+}
+/** All valid user-facing arrow type names from arrows.c. */
+export declare const ARROW_NAMES: readonly string[];
+/**
+ * Parse a compound arrow type string into its components.
+ * E.g. "odot" → [{name:'dot', open:true, left:false, right:false}]
+ *
+ * @see lib/common/arrows.c:arrow_type
+ */
+export declare function parseArrow(str: string): ArrowComponent[];
+/**
+ * Resolve a parsed arrow component to its dispatch info: ARR_TYPE_* code (with
+ * ARR_MOD_INV OR'd in for inv/vee/icurve), the open/side modifiers, and the
+ * type's length factor. An unknown name resolves to ARR_TYPE_NORM, matching the
+ * C default when no name fragment matches.
+ *
+ * @see lib/common/arrows.c:Arrowtypes (lenfact column)
+ */
+export declare function resolveArrowType(comp: ArrowComponent): ResolvedArrow;
+/**
+ * Clip edge spline at arrowhead end and emit drawing calls.
+ * Stub implementation; fully ported in T24.
+ *
+ * @see lib/common/arrows.c:arrowEndClip
+ */
+export declare function arrowEndClip(_args: ArrowClipArgs, _ps: Point[], _job: ArrowJobStub): void;
+/**
+ * Clip edge spline at arrowtail start and emit drawing calls.
+ * Stub implementation; fully ported in T24.
+ *
+ * @see lib/common/arrows.c:arrowStartClip
+ */
+export declare function arrowStartClip(_args: ArrowClipArgs, _ps: Point[], _job: ArrowJobStub): void;
+//# sourceMappingURL=arrows.d.ts.map

package/dist/common/arrows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrows.d.ts","sourceRoot":"","sources":["../../src/common/arrows.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAavD,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,yDAAyD;AACzD,MAAM,WAAW,aAAa;IAAG,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE;AAEhE,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAAG,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE;AAEvD,2DAA2D;AAC3D,MAAM,WAAW,YAAY;CAAG;AAEhC,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC5B,CAAC,EAAE,aAAa,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,aAAa,CAAC;IAClB,EAAE,EAAE,aAAa,CAAC;CACnB;AAQD,4DAA4D;AAC5D,eAAO,MAAM,WAAW,EAAE,SAAS,MAAM,EAGxC,CAAC;AA2DF;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,EAAE,CAWxD;AAkCD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,aAAa,CAWpE;AAMD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAAG;AAE7F;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAAG"}

package/dist/common/color.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Color translation utilities ported from lib/common/colxlate.c.
+ *
+ * @see lib/common/colxlate.c
+ */
+export type GVColor = {
+    type: 'rgba';
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+} | {
+    type: 'hsva';
+    h: number;
+    s: number;
+    v: number;
+    a: number;
+} | {
+    type: 'string';
+    s: string;
+} | {
+    type: 'none';
+};
+export type ColorType = 'rgba' | 'hsva' | 'string';
+/** @see lib/common/colxlate.c colorxlate return values */
+export declare const enum ColorxlateResult {
+    ColorOk = 0,
+    ColorUnknown = 1,
+    ColorError = 2
+}
+/** @see lib/common/colxlate.c:setColorScheme */
+export declare function setColorScheme(scheme: string): void;
+/** Returns the active color scheme (empty string means X11 default). */
+export declare function getColorScheme(): string;
+/**
+ * Convert HSV (all in [0,1]) to RGB (all in [0,1]).
+ * Exact algorithm from colxlate.c:hsv2rgb.
+ *
+ * @see lib/common/colxlate.c:hsv2rgb
+ */
+export declare function hsv2rgb(h: number, s: number, v: number): {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Convert RGB (all in [0,1]) to HSV (all in [0,1]).
+ * Exact algorithm from colxlate.c:rgb2hsv.
+ *
+ * @see lib/common/colxlate.c:rgb2hsv
+ */
+export declare function rgb2hsv(r: number, g: number, b: number): {
+    h: number;
+    s: number;
+    v: number;
+};
+/**
+ * Translate a color string into a GVColor of the requested target type.
+ * Mutates `color` in place (matching C's output-pointer convention).
+ * Returns ColorxlateResult.ColorOk on success, ColorxlateResult.ColorUnknown
+ * when the name is not found.
+ *
+ * @see lib/common/colxlate.c:colorxlate
+ */
+export declare function colorxlate(str: string, color: GVColor, targetType: ColorType): ColorxlateResult;
+//# sourceMappingURL=color.d.ts.map

package/dist/common/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/common/color.ts"],"names":[],"mappings":"AACA;;;;GAIG;AASH,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAErB,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEnD,0DAA0D;AAC1D,0BAAkB,gBAAgB;IAChC,OAAO,IAAI;IACX,YAAY,IAAI;IAChB,UAAU,IAAI;CACf;AAaD,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEnD;AAED,wEAAwE;AACxE,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAwBD;;;;;GAKG;AACH,wBAAgB,OAAO,CACrB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAUrC;AAuBD;;;;;GAKG;AACH,wBAAgB,OAAO,CACrB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAWrC;AA4KD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,SAAS,GACpB,gBAAgB,CAmBlB"}

package/dist/common/colorData.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Static color lookup table generated from Graphviz color definitions.
+ * Format: [name, h, s, v, r, g, b, a] - numeric values 0-255.
+ * Sorted case-insensitively by name.
+ *
+ * @see lib/common/colxlate.c
+ * @see lib/common/make_colortbl.py
+ */
+export declare const COLOR_LIB: readonly [string, number, number, number, number, number, number, number][];
+//# sourceMappingURL=colorData.d.ts.map

package/dist/common/colorData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorData.d.ts","sourceRoot":"","sources":["../../src/common/colorData.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,eAAO,MAAM,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EA6PhG,CAAC"}

package/dist/common/compass-port.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Port of compassPort and poly_port from lib/common/shapes.c.
+ *
+ * compassPort maps a compass string to a Port (p, theta, side, clip, dyna,
+ * defined, constrained, order).  poly_port is the portfn for all polygon
+ * shapes — it delegates to compassPort after checking the HTML label branch
+ * (the HTML branch calls htmlPort, which is not ported until T7; the stub
+ * returns null and yields a zero/default port).
+ *
+ * @see lib/common/shapes.c:compassPort (line 2698)
+ * @see lib/common/shapes.c:poly_port (line 2880)
+ */
+import type { Box } from '../model/geom.js';
+import type { Port } from '../model/geom.js';
+import type { Node } from '../model/node.js';
+/**
+ * Arguments to compassPort, bundled to satisfy the ≤4 param limit.
+ * Mirrors C `compassPort(n, bp, pp, compass, sides, ictxt)` where ictxt=null (AD2).
+ * @see lib/common/shapes.c:compassPort (line 2698)
+ */
+export type CompassArgs = {
+    /** Subfield bbox (record/HTML cell), or null to use node dims. */
+    bp: Box | null;
+    /** Compass direction: 'n','ne','e','se','s','sw','w','nw','c','_',''. */
+    compass: string;
+    /** Exposed sides bitmask (BOTTOM|RIGHT|TOP|LEFT). @see lib/common/const.h */
+    sides: number;
+};
+/** Attach compass point to pp. Returns 1 if compass unrecognized. @see lib/common/shapes.c:compassPort (line 2698) */
+export declare function compassPort(n: Node, args: CompassArgs, pp: Port): number;
+/**
+ * portfn for all polygon shapes. @see lib/common/shapes.c:poly_port (line 2880)
+ *
+ * Empty portname → makePort() (byte-stability: unported edges must be unchanged).
+ * Compass '' → '_' (C: `if (compass == NULL) compass = "_"`).
+ * HTML branch: stub always null (T7). Non-HTML: portname IS the compass string.
+ */
+export declare function polyPort(n: Node, portname: string, compass: string): Port;
+//# sourceMappingURL=compass-port.d.ts.map

package/dist/common/compass-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compass-port.d.ts","sourceRoot":"","sources":["../../src/common/compass-port.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAS,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAiO7C;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,kEAAkE;IAClE,EAAE,EAAE,GAAG,GAAG,IAAI,CAAC;IACf,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA+DF,sHAAsH;AACtH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,IAAI,GAAG,MAAM,CAYxE;AA4BD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAkBzE"}

package/dist/common/crand.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The C library rand() stream used by sfdp, ported bit-exactly.
+ *
+ * macOS libc rand() is the Park–Miller minstd LCG:
+ *   seed = seed · 16807 mod (2³¹ − 1),   RAND_MAX = 2³¹ − 1
+ * (verified empirically on the reference machine:
+ *  srand(123) → 2067261, 384717275, 2017463455, 888985702, …).
+ * The product never exceeds 16807·2³¹ < 2⁴⁶, so plain double
+ * arithmetic is exact.
+ *
+ * ALL sfdp randomness flows through this ONE stream: drand() position
+ * jitter (sparse/general.c:24) and the Fisher–Yates permutation used
+ * by multilevel coarsening (util/random.c) — the latter draws BEFORE
+ * srand() is called in the embedding, so the stream is global mutable
+ * state exactly as in C (unseeded state = srand(1)).
+ *
+ * @see Apple Libc rand(3) (Park–Miller minstd)
+ * @see lib/sparse/general.c:drand (15.0.0)
+ * @see lib/util/random.c:gv_random / gv_permutation (15.0.0)
+ */
+/** RAND_MAX on the reference platform. */
+export declare const C_RAND_MAX = 2147483647;
+/** srand(3). */
+export declare function csrand(seed: number): void;
+/** rand(3): minstd step. @see Apple Libc rand */
+export declare function crand(): number;
+/** drand: uniform in [0,1]. @see lib/sparse/general.c:drand */
+export declare function cdrand(): number;
+/**
+ * Uniform integer in [0, bound) with the discard-threshold rejection
+ * of the C helper (bound ≤ RAND_MAX assumed — random_big is not
+ * ported; no caller exceeds 2³¹−1).
+ * @see lib/util/random.c:random_small / gv_random
+ */
+export declare function gvRandom(bound: number): number;
+/**
+ * Random permutation of [0, bound) by Fisher–Yates, drawing from the
+ * global stream.
+ * @see lib/util/random.c:gv_permutation
+ */
+export declare function gvPermutation(bound: number): number[];
+//# sourceMappingURL=crand.d.ts.map

package/dist/common/crand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crand.d.ts","sourceRoot":"","sources":["../../src/common/crand.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,0CAA0C;AAC1C,eAAO,MAAM,UAAU,aAAa,CAAC;AAKrC,gBAAgB;AAChB,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzC;AAED,iDAAiD;AACjD,wBAAgB,KAAK,IAAI,MAAM,CAG9B;AAED,+DAA+D;AAC/D,wBAAgB,MAAM,IAAI,MAAM,CAE/B;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAS9C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAWrD"}

package/dist/common/edge-label-init.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Head/tail edge-label creation: port of the initFontLabelEdgeAttr +
+ * head/tail-label blocks inside common_init_edge (lib/common/utils.c:533-545).
+ *
+ * Called from dotInitNodeEdge after the regular edge-weight fields are set,
+ * mirroring the C call order in dot_init_node_edge → common_init_edge.
+ *
+ * @see lib/common/utils.c:common_init_edge
+ * @see lib/common/utils.c:initFontEdgeAttr
+ * @see lib/common/utils.c:initFontLabelEdgeAttr
+ */
+import type { Edge } from '../model/edge.js';
+import type { Graph } from '../model/graph.js';
+import type { TextMeasurer } from './textmeasure.js';
+/** Default fontsize for head/tail labels. @see lib/common/const.h:DEFAULT_LABEL_FONTSIZE */
+export declare const DEFAULT_LABEL_FONTSIZE = 11;
+/** Minimum fontsize (shared across all label types). @see lib/common/const.h:MIN_FONTSIZE */
+export declare const MIN_FONTSIZE = 1;
+interface FontInfo {
+    fontsize: number;
+    fontname: string;
+    fontcolor: string;
+}
+/**
+ * Reads the per-edge font attrs (fontname/fontsize/fontcolor) with fallback
+ * to the global defaults.  Mirrors initFontEdgeAttr in utils.c.
+ *
+ * @see lib/common/utils.c:initFontEdgeAttr
+ */
+export declare function initFontEdgeAttr(e: Edge): FontInfo;
+/**
+ * Reads labelfontname / labelfontsize / labelfontcolor with fallback to fi
+ * (the regular edge font attrs).  Mirrors initFontLabelEdgeAttr in utils.c.
+ *
+ * The fallback chain for each attribute:
+ *   labelfontsize  → fi.fontsize  → DEFAULT_FONTSIZE
+ *   labelfontname  → fi.fontname  → DEFAULT_FONTNAME
+ *   labelfontcolor → fi.fontcolor → DEFAULT_COLOR
+ *
+ * @see lib/common/utils.c:initFontLabelEdgeAttr
+ */
+export declare function initFontLabelEdgeAttr(e: Edge, fi: FontInfo): FontInfo;
+/**
+ * Port block of common_init_edge: populate tail_port/head_port from the
+ * tailport/headport attrs (DOT syntax or explicit), honoring tail/headclip.
+ * @see lib/common/utils.c:548-566
+ */
+export declare function initEdgePorts(e: Edge): void;
+export declare function initEdgeLabels(e: Edge, g: Graph, measurer: TextMeasurer): void;
+export {};
+//# sourceMappingURL=edge-label-init.d.ts.map

package/dist/common/edge-label-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-label-init.d.ts","sourceRoot":"","sources":["../../src/common/edge-label-init.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAI/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAUrD,4FAA4F;AAC5F,eAAO,MAAM,sBAAsB,KAAO,CAAC;AAE3C,6FAA6F;AAC7F,eAAO,MAAM,YAAY,IAAM,CAAC;AAMhC,UAAU,QAAQ;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAuBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,GAAG,QAAQ,CAMlD;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,GAAG,QAAQ,CAMrE;AAyLD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAS3C;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAO9E"}

package/dist/common/edge-offset.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Perpendicular-offset geometry for parallel multi-color edge rendering.
+ *
+ * Ports computeoffset_p and computeoffset_qr from lib/common/emit.c.
+ * Pure data-in / data-out; no rendering or ObjState mutation.
+ * Consumed by the M1 parallel-bezier branch in src/gvc/device.ts.
+ *
+ * @see lib/common/emit.c:1836 computeoffset_p
+ * @see lib/common/emit.c:1849 computeoffset_qr
+ * @see lib/common/emit.c:55   #define EPSILON 0.0001
+ * @see lib/common/emit.c:2364 #define SEP 2.0
+ */
+import type { Point } from '../model/geom.js';
+/**
+ * Epsilon guard used in the offset vector computation to keep the result
+ * finite as the line-segment length approaches zero.
+ * @see lib/common/emit.c:55
+ */
+export declare const OFFSET_EPSILON = 0.0001;
+/**
+ * Perpendicular separation between parallel color curves (in graph units).
+ * @see lib/common/emit.c:2364
+ */
+export declare const PARALLEL_SEP = 2;
+/**
+ * Calculate an offset vector, length d, perpendicular to line p→q.
+ * The result vector points 90° counter-clockwise from the direction p→q.
+ * Formula: res = { (p.y-q.y)*d/len, -(p.x-q.x)*d/len }
+ *
+ * @see lib/common/emit.c:1836 computeoffset_p
+ */
+export declare function computeOffsetP(p: Point, q: Point, d: number): Point;
+/**
+ * Calculate an offset vector, length d, perpendicular to spline p,q,r,s
+ * at the middle control points q and r.  When q and r coincide (len < ε),
+ * falls back to the p→s direction.
+ *
+ * @see lib/common/emit.c:1849 computeoffset_qr
+ */
+export declare function computeOffsetQR(p: Point, q: Point, r: Point, s: Point, d: number): Point;
+/**
+ * One parallel-offset bezier: a clone of the bezier's control-point array
+ * with every point offset by offVec × d (in-place via the tmp array).
+ *
+ * Returns { offlist, tmplist } for a SINGLE bezier segment with `size`
+ * control points (must be 4k+1 for k cubic segments).
+ *
+ * Algorithm:
+ *   - offlist[j]     = computeOffsetP(pf[j-1 or pf2_prev], pf[j+1], SEP)   at j=0 or next segment start
+ *   - offlist[j+1/2] = computeOffsetQR(pf0,pf1,pf2,pf3, SEP)               for the two middle CPs
+ *   - offlist[last]  = computeOffsetP(pf2, pf3, SEP)
+ *   - tmplist[j]     = pf[j] - numc2 * offlist[j]                           (outermost lane)
+ *
+ * @see lib/common/emit.c:2449-2480
+ */
+export declare function buildOffsetLists(pts: Point[], numc2: number): {
+    offlist: Point[];
+    tmplist: Point[];
+};
+/**
+ * Advance every tmp point by one offset step (add offlist[i] to tmplist[i]).
+ * Called once per color before drawing that color's curve.
+ * @see lib/common/emit.c:2501-2504
+ */
+export declare function advanceTmpList(tmplist: Point[], offlist: Point[]): void;
+//# sourceMappingURL=edge-offset.d.ts.map

package/dist/common/edge-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-offset.d.ts","sourceRoot":"","sources":["../../src/common/edge-offset.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAM9C;;;;GAIG;AACH,eAAO,MAAM,cAAc,SAAS,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,YAAY,IAAM,CAAC;AAMhC;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAMnE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAcxF;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,KAAK,EAAE,EACZ,KAAK,EAAE,MAAM,GACZ;IAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAAC,OAAO,EAAE,KAAK,EAAE,CAAA;CAAE,CA8BxC;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAIvE"}

package/dist/common/ellipse-wedge.d.ts

@@ -0,0 +1,10 @@
+import type { Point } from '../model/geom.js';
+/**
+ * Return a cubic-Bézier control-point list for an elliptical wedge, center
+ * `ctr`, x/y semi-axes `xsemi`/`ysemi`, start angle `angle0`, end angle
+ * `angle1`. Includes the beginning and ending line segments to the center.
+ * Point order and count match C's `Ppolyline_t.ps` / `pn`.
+ * @see lib/common/ellipse.c:ellipticWedge
+ */
+export declare function ellipticWedge(ctr: Point, xsemi: number, ysemi: number, angle0: number, angle1: number): Point[];
+//# sourceMappingURL=ellipse-wedge.d.ts.map

package/dist/common/ellipse-wedge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ellipse-wedge.d.ts","sourceRoot":"","sources":["../../src/common/ellipse-wedge.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAmK9C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GACvE,KAAK,EAAE,CAGT"}