brepjs 18.6.0 → 18.14.3

package/dist/text.d.ts

@@ -0,0 +1,12 @@
+/**
+ * brepjs/text — Font loading and text-to-geometry conversion.
+ *
+ * @example
+ * ```typescript
+ * import { loadFont, sketchText } from 'brepjs/text';
+ * ```
+ */
+export { loadFont, getFont } from './text/fontRegistry.js';
+export { textBlueprints } from './text/textBlueprints.js';
+export { sketchText } from './text/sketchText.js';
+export { textMetrics, fontMetrics, type TextMetricsResult, type FontMetricsResult, } from './text/textMetrics.js';

package/dist/text.js

@@ -0,0 +1,3 @@
+import { n as getFont, r as loadFont, t as textBlueprints } from "./textBlueprints-Do6xNsLt.js";
+import { n as textMetrics, r as sketchText, t as fontMetrics } from "./textMetrics-BjJ8sn_e.js";
+export { fontMetrics, getFont, loadFont, sketchText, textBlueprints, textMetrics };

package/dist/textBlueprints-Do6xNsLt.js

@@ -0,0 +1,643 @@
+import { X as getKernel, h as isShape3D, o as createFace, p as isFace, t as castShape, u as createWire } from "./shapeTypes-C--1jaT1.js";
+import { A as ok, R as unwrap, T as isOk, b as err, d as validationError, h as bug, i as kernelError, l as typeCastError, r as ioError, t as BrepErrorCode } from "./errors-0fYW_YnO.js";
+import { r as toVec3 } from "./types-BIdk_GJY.js";
+import { d as vecNormalize, h as vecScale, r as vecCross } from "./vecOps-DVROrqTV.js";
+import { n as createPlane } from "./planeOps-4i2qEraD.js";
+import { _ as downcast, g as cast } from "./faceFns-BFWz17_E.js";
+import { c as curveStartPoint, l as curveTangentAt } from "./curveFns-B4tWuinR.js";
+import { n as getAtOrThrow, t as firstOrThrow } from "./arrayAccess-C5IWcxs9.js";
+import { i as makeNewFaceWithinFace, r as makeFace, t as addHolesInFace } from "./surfaceBuilders-CinmHCbZ.js";
+import { r as organiseBlueprints, t as BlueprintSketcher } from "./blueprintSketcher-xDsl9GXO.js";
+import { o as makeSolid, t as makeCompound } from "./solidBuilders-Xs7VDMGD.js";
+import { c as sweep, i as complexExtrude, l as twistExtrude, r as revolve, t as extrude } from "./extrudeFns-7pE8dIWz.js";
+import opentype from "opentype.js";
+//#region src/operations/loftFns.ts
+/**
+* Functional loft operation using branded shape types.
+*/
+/**
+* Loft through a set of wire profiles to create a 3D shape.
+*
+* Builds a `BRepOffsetAPI_ThruSections` surface through the given wires,
+* optionally starting and/or ending at point vertices. Produces a solid
+* by default, or a shell when `returnShell` is `true`.
+*
+* @param wires - Ordered wire profiles to loft through.
+* @param config - Loft configuration (ruled interpolation, start/end points).
+* @param returnShell - When `true`, return a shell instead of a solid.
+* @returns `Result` containing the lofted 3D shape, or an error on failure.
+*
+* @example
+* ```ts
+* const result = loft([bottomWire, topWire], { ruled: false });
+* ```
+*
+* @see {@link loft!loft | loft} for the OOP API equivalent.
+*/
+function loft(wires, { ruled = true, startPoint, endPoint, tolerance = 1e-6 } = {}, returnShell = false) {
+	if (wires.length === 0 && !startPoint && !endPoint) return err(validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
+	const kernel = getKernel();
+	const startVertex = startPoint ? kernel.makeVertex(...toVec3(startPoint)) : void 0;
+	const endVertex = endPoint ? kernel.makeVertex(...toVec3(endPoint)) : void 0;
+	try {
+		const result = castShape(kernel.loftAdvanced(wires.map((w) => w.wrapped), {
+			solid: !returnShell,
+			ruled,
+			tolerance,
+			...startVertex ? { startVertex } : {},
+			...endVertex ? { endVertex } : {}
+		}));
+		if (!isShape3D(result)) return err(typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
+		return ok(result);
+	} catch (e) {
+		return err(kernelError("LOFT_FAILED", "Loft operation failed", e, void 0, "Common causes: wire profiles with different edge counts, self-intersecting result, or profiles too far apart. Ensure profiles are compatible and ordered."));
+	}
+}
+/**
+* Batch loft: build N independent lofts in a single kernel call.
+*
+* Uses the C++ LoftBatch extractor when available (single WASM call),
+* falling back to N individual loft operations otherwise.
+*
+* @returns Array of 3D shapes, one per entry.
+*/
+function loftAll(entries) {
+	if (entries.length === 0) return ok([]);
+	const kernel = getKernel();
+	const verticesToDelete = [];
+	const kernelEntries = entries.map((e) => {
+		const startVertex = e.startPoint ? kernel.makeVertex(...toVec3(e.startPoint)) : void 0;
+		const endVertex = e.endPoint ? kernel.makeVertex(...toVec3(e.endPoint)) : void 0;
+		if (startVertex) verticesToDelete.push(startVertex);
+		if (endVertex) verticesToDelete.push(endVertex);
+		return {
+			wires: e.wires.map((w) => w.wrapped),
+			solid: true,
+			ruled: e.ruled ?? true,
+			tolerance: e.tolerance ?? 1e-6,
+			startVertex,
+			endVertex
+		};
+	});
+	try {
+		const shapes = kernel.loftBatch?.(kernelEntries) ?? kernelEntries.map((e) => kernel.loftAdvanced(e.wires, {
+			solid: e.solid,
+			ruled: e.ruled,
+			tolerance: e.tolerance,
+			startVertex: e.startVertex,
+			endVertex: e.endVertex
+		}));
+		const results = [];
+		for (const shape of shapes) {
+			const cast = castShape(shape);
+			if (!isShape3D(cast)) return err(typeCastError("LOFT_ALL_NOT_3D", "Batch loft entry did not produce a 3D shape"));
+			results.push(cast);
+		}
+		return ok(results);
+	} catch (e) {
+		return err(kernelError("LOFT_ALL_FAILED", "Batch loft operation failed", e));
+	} finally {
+		for (const v of verticesToDelete) kernel.dispose(v);
+	}
+}
+//#endregion
+//#region src/sketching/compoundSketch.ts
+/**
+* Represent a face with holes as a group of sketches (one outer + zero or more inner).
+*
+* All contained sketches must share the same base surface. The first sketch is
+* treated as the outer boundary; subsequent sketches define holes.
+*
+* Typically produced from a {@link CompoundBlueprint} via `sketchOnPlane`.
+*
+* The class methods are thin delegations to the canonical functions in
+* `sketchFns.ts` (`compoundSketchExtrude`, `compoundSketchRevolve`, etc.).
+*
+* @see {@link Sketch} for single-wire profiles without holes.
+* @category Sketching
+*/
+var CompoundSketch = class {
+	sketches;
+	constructor(sketches) {
+		if (sketches.length === 0) bug("CompoundSketch", "Cannot create CompoundSketch with an empty array of sketches");
+		this.sketches = sketches;
+	}
+	/** Release all kernel resources held by every sub-sketch. */
+	delete() {
+		this.sketches.forEach((sketch) => {
+			sketch.delete();
+		});
+	}
+	/** Get the outer boundary sketch (the first in the array). */
+	get outerSketch() {
+		return firstOrThrow(this.sketches);
+	}
+	/** Get the hole sketches (all but the first). */
+	get innerSketches() {
+		return this.sketches.slice(1);
+	}
+	/** Return all wires (outer + holes) combined into a compound shape. */
+	get wires() {
+		return compoundSketchWires(this);
+	}
+	/** Build a face from the outer boundary with inner wires subtracted as holes. */
+	face() {
+		return compoundSketchFace(this);
+	}
+	/**
+	* Extrude the compound face (with holes) along the default or given direction.
+	*
+	* Supports twist and profile extrusions. For twist/profile modes each
+	* sub-sketch is extruded as a shell, then capped into a solid.
+	*/
+	extrude(extrusionDistance, config = {}) {
+		return compoundSketchExtrude(this, extrusionDistance, config);
+	}
+	/**
+	* Revolves the drawing on an axis (defined by its direction and an origin
+	* (defaults to the sketch origin)
+	*/
+	revolve(revolutionAxis, config = {}) {
+		return compoundSketchRevolve(this, revolutionAxis, config);
+	}
+	/** Loft between this compound sketch and another with matching sub-sketch counts. */
+	loftWith(otherCompound, loftConfig) {
+		return compoundSketchLoft(this, otherCompound, loftConfig);
+	}
+};
+//#endregion
+//#region src/sketching/sketchFns.ts
+/** Wrap SketchData into a Sketch instance. */
+function wrapSketchData(data) {
+	const opts = {};
+	if (data.defaultOrigin) opts.defaultOrigin = data.defaultOrigin;
+	if (data.defaultDirection) opts.defaultDirection = data.defaultDirection;
+	const sketch = new Sketch(data.wire, opts);
+	if (data.baseFace) sketch.baseFace = data.baseFace;
+	return sketch;
+}
+/** Wrap an array of SketchData into a CompoundSketch. */
+function wrapSketchDataArray(dataArr) {
+	return new CompoundSketch(dataArr.map(wrapSketchData));
+}
+/** Build a face from a sketch's closed planar wire. */
+function sketchFace(sketch) {
+	let face;
+	if (!sketch.baseFace) face = unwrap(makeFace(sketch.wire));
+	else face = makeNewFaceWithinFace(sketch.baseFace, sketch.wire);
+	return face;
+}
+/** Return an independent clone of the sketch's wire. */
+function sketchWires(sketch) {
+	return createWire(unwrap(downcast(sketch.wire.wrapped)));
+}
+/**
+* Revolve a sketch around an axis to produce a solid of revolution.
+*
+* @remarks Consumes the sketch — calling twice throws on the second call.
+*/
+function sketchRevolve(sketch, revolutionAxis, { origin } = {}) {
+	const face = unwrap(makeFace(sketch.wire));
+	const solid = unwrap(revolve(face, origin ? toVec3(origin) : sketch.defaultOrigin, revolutionAxis ? toVec3(revolutionAxis) : [
+		0,
+		0,
+		1
+	]));
+	face.delete();
+	sketch.delete();
+	return solid;
+}
+/**
+* Extrude a sketch to a given distance.
+*
+* Supports profile (taper) extrusion via `extrusionProfile`, twist extrusion
+* via `twistAngle`, and direction/origin overrides.
+*
+* @remarks Consumes the sketch — calling twice throws on the second call.
+*/
+function sketchExtrude(sketch, extrusionDistance, { extrusionDirection, extrusionProfile, twistAngle, origin } = {}) {
+	const extrusionVec = vecScale(vecNormalize(extrusionDirection ? toVec3(extrusionDirection) : sketch.defaultDirection), extrusionDistance);
+	const originVec = origin ? toVec3(origin) : sketch.defaultOrigin;
+	if (extrusionProfile && !twistAngle) {
+		const solid = unwrap(complexExtrude(sketch.wire, [...originVec], [...extrusionVec], extrusionProfile));
+		sketch.delete();
+		return solid;
+	}
+	if (twistAngle) {
+		const solid = unwrap(twistExtrude(sketch.wire, twistAngle, [...originVec], [...extrusionVec], extrusionProfile));
+		sketch.delete();
+		return solid;
+	}
+	const solid = unwrap(extrude(unwrap(makeFace(sketch.wire)), [...extrusionVec]));
+	sketch.delete();
+	return solid;
+}
+/**
+* Sweep a profile sketch (built by `sketchOnPlane`) along this sketch's wire path.
+*
+* @remarks Consumes both this sketch and the one returned by `sketchOnPlane` —
+* calling either twice throws on the second call.
+*/
+function sketchSweep(sketch, sketchOnPlane, sweepConfig = {}) {
+	const startPoint = curveStartPoint(sketch.wire);
+	const normal = vecNormalize(vecScale(curveTangentAt(sketch.wire, 1e-9), -1));
+	const defaultDir = sketch.defaultDirection;
+	const xDir = vecScale(vecCross(normal, defaultDir), -1);
+	const result = sketchOnPlane(createPlane([...startPoint], [...xDir], [...normal]), [...startPoint]);
+	let profile;
+	if ("sketches" in result && Array.isArray(result.sketches)) {
+		const pieces = result.sketches;
+		profile = pieces[0];
+		for (let i = 1; i < pieces.length; i++) pieces[i]?.delete();
+	} else profile = result;
+	const config = {
+		forceProfileSpineOthogonality: true,
+		...sweepConfig
+	};
+	if (sketch.baseFace) config.support = sketch.baseFace.wrapped;
+	const shape = unwrap(sweep(profile.wire, sketch.wire, config));
+	sketch.delete();
+	return shape;
+}
+/**
+* Loft between this sketch and one or more other sketches.
+*
+* @remarks Consumes all input sketches — calling twice throws on the second call.
+*/
+function sketchLoft(sketch, otherSketches, loftConfig = {}, returnShell = false) {
+	const sketchArray = Array.isArray(otherSketches) ? [sketch, ...otherSketches] : [sketch, otherSketches];
+	const shape = unwrap(loft(sketchArray.map((s) => s.wire), loftConfig, returnShell));
+	sketchArray.forEach((s) => {
+		s.delete();
+	});
+	return shape;
+}
+var guessFaceFromWires = (wires) => {
+	const wireShapes = wires.map((w) => w.wrapped);
+	const newFace = unwrap(cast(getKernel().fillSurface(wireShapes)));
+	if (!isFace(newFace)) bug("guessFaceFromWires", "Failed to create a face");
+	return newFace;
+};
+var fixWire = (wire, baseFace) => {
+	return createWire(getKernel().fixWireOnFace(wire.wrapped, baseFace.wrapped, 1e-9));
+};
+var faceFromWires = (wires) => {
+	let baseFace;
+	let holeWires;
+	const faceResult = makeFace(firstOrThrow(wires));
+	if (isOk(faceResult)) {
+		baseFace = faceResult.value;
+		holeWires = wires.slice(1);
+	} else {
+		baseFace = guessFaceFromWires(wires);
+		holeWires = wires.slice(1).map((w) => fixWire(w, baseFace));
+	}
+	return addHolesInFace(baseFace, holeWires);
+};
+var solidFromShellGenerator = (sketches, shellGenerator) => {
+	const shells = [];
+	const startWires = [];
+	const endWires = [];
+	sketches.forEach((sketch) => {
+		const [shell, startWire, endWire] = unwrap(shellGenerator(sketch));
+		shells.push(shell);
+		startWires.push(startWire);
+		endWires.push(endWire);
+	});
+	const startFace = faceFromWires(startWires);
+	const endFace = faceFromWires(endWires);
+	return unwrap(makeSolid([
+		startFace,
+		...shells,
+		endFace
+	]));
+};
+/** Build a face from a compound sketch (outer boundary with holes). */
+function compoundSketchFace(sketch) {
+	return addHolesInFace(sketch.outerSketch.face(), sketch.innerSketches.map((s) => s.wire));
+}
+/** Return all wires (outer + holes) combined into a compound shape. */
+function compoundSketchWires(sketch) {
+	return makeCompound(sketch.sketches.map((s) => s.wire));
+}
+/**
+* Extrude a compound sketch (outer + holes) along the default or given direction.
+*
+* Supports twist and profile extrusions. For twist/profile modes each
+* sub-sketch is extruded as a shell, then capped into a solid.
+*/
+function compoundSketchExtrude(sketch, extrusionDistance, { extrusionDirection, extrusionProfile, twistAngle, origin } = {}) {
+	const extrusionVec = vecScale(vecNormalize(extrusionDirection ? toVec3(extrusionDirection) : sketch.outerSketch.defaultDirection), extrusionDistance);
+	if (extrusionProfile && !twistAngle) return solidFromShellGenerator(sketch.sketches, (s) => complexExtrude(s.wire, origin ? toVec3(origin) : sketch.outerSketch.defaultOrigin, extrusionVec, extrusionProfile, true));
+	if (twistAngle) return solidFromShellGenerator(sketch.sketches, (s) => twistExtrude(s.wire, twistAngle, origin ? toVec3(origin) : sketch.outerSketch.defaultOrigin, extrusionVec, extrusionProfile, true));
+	return unwrap(extrude(compoundSketchFace(sketch), extrusionVec));
+}
+/** Revolve a compound sketch (outer + holes) around an axis. */
+function compoundSketchRevolve(sketch, revolutionAxis, { origin } = {}) {
+	const center = origin ? toVec3(origin) : sketch.outerSketch.defaultOrigin;
+	const dir = revolutionAxis ? toVec3(revolutionAxis) : [
+		0,
+		0,
+		1
+	];
+	return unwrap(revolve(compoundSketchFace(sketch), center, dir));
+}
+/** Loft between two compound sketches with matching sub-sketch counts. */
+function compoundSketchLoft(sketch, other, loftConfig) {
+	if (sketch.sketches.length !== other.sketches.length) bug("CompoundSketch.loftWith", "You need to loft with another compound with the same number of sketches");
+	const shells = sketch.sketches.map((base, cIndex) => {
+		const outer = getAtOrThrow(other.sketches, cIndex);
+		const loftOpts = {};
+		if (loftConfig.ruled !== void 0) loftOpts.ruled = loftConfig.ruled;
+		return base.clone().loftWith(outer.clone(), loftOpts, true);
+	});
+	const baseFace = createFace(unwrap(downcast(compoundSketchFace(sketch).wrapped)));
+	shells.push(baseFace, compoundSketchFace(other));
+	return unwrap(makeSolid(shells));
+}
+//#endregion
+//#region src/sketching/sketch.ts
+/**
+* Represent a closed or open wire profile with a default extrusion origin and direction.
+*
+* A Sketch wraps a single {@link Wire} and carries metadata (origin, direction,
+* optional base face) so that downstream operations like {@link Sketch.extrude},
+* {@link Sketch.revolve}, {@link Sketch.sweepSketch}, and {@link Sketch.loftWith}
+* know how to act on it without extra arguments.
+*
+* The class methods are thin delegations to the canonical functions in
+* `sketchFns.ts` (`sketchExtrude`, `sketchRevolve`, etc.). New functionality
+* should be added there.
+*
+* @remarks Most operations consume (delete) the sketch after producing a solid.
+*
+* @see {@link Sketcher} to build a Sketch interactively.
+* @see {@link CompoundSketch} for multi-wire (outer + holes) profiles.
+* @category Sketching
+*/
+var Sketch = class Sketch {
+	/**
+	* The wire is typed as `ClosedWire & PlanarWire` to reflect the contract at
+	* Sketcher boundaries: `Sketcher.close()`, `closeWithMirror()`,
+	* `closeWithCustomCorner()`, and the canned-sketch factories all produce
+	* closed planar wires. Callers constructing `Sketch` from an arbitrary
+	* `Wire` must assert validity at the construction site.
+	*/
+	wire;
+	/**
+	* @ignore
+	*/
+	_defaultOrigin;
+	/**
+	* @ignore
+	*/
+	_defaultDirection;
+	_baseFace;
+	constructor(wire, { defaultOrigin = [
+		0,
+		0,
+		0
+	], defaultDirection = [
+		0,
+		0,
+		1
+	] } = {}) {
+		this.wire = wire;
+		this._defaultOrigin = toVec3(defaultOrigin);
+		this._defaultDirection = toVec3(defaultDirection);
+		this.baseFace = null;
+	}
+	get baseFace() {
+		return this._baseFace;
+	}
+	set baseFace(newFace) {
+		if (this._baseFace) this._baseFace.delete();
+		this._baseFace = newFace ? createFace(unwrap(downcast(newFace.wrapped))) : newFace;
+	}
+	/** Release all kernel resources held by this sketch. */
+	delete() {
+		this.wire.delete();
+		if (this.baseFace) this.baseFace.delete();
+	}
+	/** Create an independent deep copy of this sketch. */
+	clone() {
+		const sketch = new Sketch(createWire(unwrap(downcast(this.wire.wrapped))), {
+			defaultOrigin: this.defaultOrigin,
+			defaultDirection: this.defaultDirection
+		});
+		if (this.baseFace) sketch.baseFace = createFace(unwrap(downcast(this.baseFace.wrapped)));
+		return sketch;
+	}
+	/** Get the 3D origin used as default for extrusion and revolution. */
+	get defaultOrigin() {
+		return this._defaultOrigin;
+	}
+	/** Set the 3D origin used as default for extrusion and revolution. */
+	set defaultOrigin(newOrigin) {
+		this._defaultOrigin = toVec3(newOrigin);
+	}
+	/** Get the default extrusion/normal direction. */
+	get defaultDirection() {
+		return this._defaultDirection;
+	}
+	/** Set the default extrusion/normal direction. */
+	set defaultDirection(newDirection) {
+		this._defaultDirection = toVec3(newDirection);
+	}
+	/** Transforms the lines into a face. The lines should be closed. */
+	face() {
+		return sketchFace(this);
+	}
+	/** Return a clone of the underlying wire. */
+	wires() {
+		return sketchWires(this);
+	}
+	/** Alias for {@link Sketch.face}. */
+	faces() {
+		return this.face();
+	}
+	/**
+	* Revolves the drawing on an axis (defined by its direction and an origin
+	* (defaults to the sketch origin)
+	*
+	* @remarks Consumes the sketch — calling this twice throws on the second call.
+	*/
+	revolve(revolutionAxis, config = {}) {
+		return sketchRevolve(this, revolutionAxis, config);
+	}
+	/** Extrudes the sketch to a certain distance (along the default direction
+	* and origin of the sketch).
+	*
+	* You can define another extrusion direction or origin,
+	*
+	* It is also possible to twist extrude with an angle (in degrees), or to
+	* give a profile to the extrusion (the endFactor will scale the face, and
+	* the profile will define how the scale is applied (either linearly or with
+	* a s-shape).
+	*
+	* @remarks Consumes the sketch — calling this twice throws on the second call.
+	*/
+	extrude(extrusionDistance, config = {}) {
+		return sketchExtrude(this, extrusionDistance, config);
+	}
+	/**
+	* Sweep along this sketch another sketch defined in the function
+	* `sketchOnPlane`.
+	*
+	* @remarks Consumes both this sketch and the one returned by `sketchOnPlane` —
+	* calling either consumer twice throws on the second call.
+	*/
+	sweepSketch(sketchOnPlane, sweepConfig = {}) {
+		return sketchSweep(this, sketchOnPlane, sweepConfig);
+	}
+	/** Loft between this sketch and another sketch (or an array of them)
+	*
+	* You can also define a `startPoint` for the loft (that will be placed
+	* before this sketch) and an `endPoint` after the last one.
+	*
+	* You can also define if you want the loft to result in a ruled surface.
+	*
+	* Note that all sketches will be deleted by this operation
+	*/
+	loftWith(otherSketches, loftConfig = {}, returnShell = false) {
+		return sketchLoft(this, otherSketches, loftConfig, returnShell);
+	}
+};
+//#endregion
+//#region src/sketching/sketches.ts
+/**
+* Batch wrapper around multiple {@link Sketch} or {@link CompoundSketch} instances.
+*
+* Applies the same operation (extrude, revolve, etc.) to every contained sketch
+* and returns the results combined into a single compound shape.
+*
+* @category Sketching
+*/
+var Sketches = class {
+	sketches;
+	constructor(sketches) {
+		this.sketches = sketches;
+	}
+	/** Return all wires combined into a single compound shape. */
+	wires() {
+		return makeCompound(this.sketches.map((s) => s instanceof Sketch ? s.wire : s.wires));
+	}
+	/** Return all sketch faces combined into a single compound shape. */
+	faces() {
+		return makeCompound(this.sketches.map((s) => s.face()));
+	}
+	/** Extrudes the sketch to a certain distance (along the default direction
+	* and origin of the sketch).
+	*
+	* You can define another extrusion direction or origin,
+	*
+	* It is also possible to twist extrude with an angle (in degrees), or to
+	* give a profile to the extrusion (the endFactor will scale the face, and
+	* the profile will define how the scale is applied (either linearly or with
+	* a s-shape).
+	*/
+	extrude(extrusionDistance, extrusionConfig = {}) {
+		return makeCompound(this.sketches.map((s) => s.extrude(extrusionDistance, extrusionConfig)));
+	}
+	/**
+	* Revolves the drawing on an axis (defined by its direction and an origin
+	* (defaults to the sketch origin)
+	*/
+	revolve(revolutionAxis, config) {
+		return makeCompound(this.sketches.map((s) => s.revolve(revolutionAxis, config)));
+	}
+};
+//#endregion
+//#region src/text/fontRegistry.ts
+var FONT_REGISTER = {};
+/**
+* Load and register an OpenType/TrueType font for use with text drawing functions.
+*
+* The font is fetched (if a URL string) or parsed (if an ArrayBuffer) and
+* stored in an internal registry keyed by `fontFamily`. The first font loaded
+* is also registered as `'default'`.
+*
+* @param fontPath - URL string or raw ArrayBuffer of the font file.
+* @param fontFamily - Registry key for later retrieval (defaults to `'default'`).
+* @param force - If true, overwrite a previously loaded font with the same key.
+* @returns The parsed opentype.js Font object.
+*/
+async function loadFont(fontPath, fontFamily = "default", force = false) {
+	if (!force && FONT_REGISTER[fontFamily]) return ok(FONT_REGISTER[fontFamily]);
+	let fontData;
+	if (typeof fontPath === "string") {
+		let response;
+		try {
+			response = await fetch(fontPath);
+		} catch (e) {
+			return err(ioError(BrepErrorCode.FONT_FETCH_FAILED, `Failed to fetch font from ${fontPath}: ${e instanceof Error ? e.message : String(e)}`, e));
+		}
+		if (!response.ok) return err(ioError(BrepErrorCode.FONT_FETCH_FAILED, `Failed to fetch font from ${fontPath}: HTTP ${response.status} ${response.statusText}`));
+		fontData = await response.arrayBuffer();
+	} else fontData = fontPath;
+	let font;
+	try {
+		font = opentype.parse(fontData);
+	} catch (e) {
+		return err(ioError(BrepErrorCode.FONT_PARSE_FAILED, `Failed to parse font data: ${e instanceof Error ? e.message : String(e)}`, e));
+	}
+	const typedFont = font;
+	FONT_REGISTER[fontFamily] = typedFont;
+	if (!FONT_REGISTER["default"]) FONT_REGISTER["default"] = typedFont;
+	return ok(typedFont);
+}
+/**
+* Retrieve a previously loaded font by family name.
+*
+* @param fontFamily - Registry key (defaults to `'default'`).
+* @returns The opentype.js Font object, or `undefined` if not loaded.
+*/
+var getFont = (fontFamily = "default") => {
+	return FONT_REGISTER[fontFamily];
+};
+//#endregion
+//#region src/text/textBlueprints.ts
+var sketchFontCommands = function* (commands) {
+	let sk = null;
+	let lastPoint = null;
+	for (const command of commands) {
+		if (command.type === "Z") {
+			if (sk) yield sk.close();
+			sk = null;
+			continue;
+		}
+		const p = [-command.x, command.y];
+		if (command.type === "M") {
+			if (sk) yield sk.done();
+			sk = new BlueprintSketcher();
+			sk.movePointerTo(p);
+			lastPoint = p;
+			continue;
+		}
+		if (lastPoint && Math.abs(p[0] - lastPoint[0]) < 1e-9 && Math.abs(p[1] - lastPoint[1]) < 1e-9) continue;
+		if (command.type === "L") sk?.lineTo(p);
+		if (command.type === "C") sk?.cubicBezierCurveTo(p, [-command.x1, command.y1], [-command.x2, command.y2]);
+		if (command.type === "Q") sk?.quadraticBezierCurveTo(p, [-command.x1, command.y1]);
+		lastPoint = p;
+	}
+};
+/**
+* Convert a text string into 2D Blueprints using a loaded font.
+*
+* Each glyph outline is traced as a series of line/bezier curves, then
+* organised into a {@link Blueprints} collection (outer contours + holes).
+*
+* @param text - The string to render.
+* @returns A Blueprints instance representing the text outlines.
+*
+* @remarks Requires a font to be loaded via {@link loadFont} before use.
+*/
+function textBlueprints(text, { startX = 0, startY = 0, fontSize = 16, fontFamily = "default" } = {}) {
+	let font = getFont(fontFamily);
+	if (!font) font = getFont();
+	if (!font) bug("text", "No fonts loaded. Call loadFont() before using text functions.");
+	const writtenText = font.getPath(text, -startX, -startY, fontSize);
+	return organiseBlueprints(Array.from(sketchFontCommands(writtenText.commands))).mirror([0, 0]);
+}
+//#endregion
+export { wrapSketchDataArray as _, Sketch as a, loftAll as b, compoundSketchLoft as c, sketchFace as d, sketchLoft as f, wrapSketchData as g, sketchWires as h, Sketches as i, compoundSketchRevolve as l, sketchSweep as m, getFont as n, compoundSketchExtrude as o, sketchRevolve as p, loadFont as r, compoundSketchFace as s, textBlueprints as t, sketchExtrude as u, CompoundSketch as v, loft as y };