brepjs 18.6.0 → 18.14.3

package/dist/textBlueprints-oWhiABaY.cjs

@@ -0,0 +1,800 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_shapeTypes = require("./shapeTypes-BTt_LLbk.cjs");
+const require_errors = require("./errors-Dv6pfNct.cjs");
+const require_types = require("./types-CDkxah-M.cjs");
+const require_vecOps = require("./vecOps-D7xplSx8.cjs");
+const require_planeOps = require("./planeOps-CH4ruLuj.cjs");
+const require_faceFns = require("./faceFns-DP7i60yJ.cjs");
+const require_curveFns = require("./curveFns-CD20-4fM.cjs");
+const require_arrayAccess = require("./arrayAccess-7pTWqkJu.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-CYeTNW33.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-Bei866Bt.cjs");
+const require_solidBuilders = require("./solidBuilders-CX_197Xm.cjs");
+const require_extrudeFns = require("./extrudeFns-DD36mWKv.cjs");
+let opentype_js = require("opentype.js");
+opentype_js = __toESM(opentype_js, 1);
+//#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 require_errors.err(require_errors.validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
+	const kernel = require_shapeTypes.getKernel();
+	const startVertex = startPoint ? kernel.makeVertex(...require_types.toVec3(startPoint)) : void 0;
+	const endVertex = endPoint ? kernel.makeVertex(...require_types.toVec3(endPoint)) : void 0;
+	try {
+		const result = require_shapeTypes.castShape(kernel.loftAdvanced(wires.map((w) => w.wrapped), {
+			solid: !returnShell,
+			ruled,
+			tolerance,
+			...startVertex ? { startVertex } : {},
+			...endVertex ? { endVertex } : {}
+		}));
+		if (!require_shapeTypes.isShape3D(result)) return require_errors.err(require_errors.typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
+		return require_errors.ok(result);
+	} catch (e) {
+		return require_errors.err(require_errors.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 require_errors.ok([]);
+	const kernel = require_shapeTypes.getKernel();
+	const verticesToDelete = [];
+	const kernelEntries = entries.map((e) => {
+		const startVertex = e.startPoint ? kernel.makeVertex(...require_types.toVec3(e.startPoint)) : void 0;
+		const endVertex = e.endPoint ? kernel.makeVertex(...require_types.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 = require_shapeTypes.castShape(shape);
+			if (!require_shapeTypes.isShape3D(cast)) return require_errors.err(require_errors.typeCastError("LOFT_ALL_NOT_3D", "Batch loft entry did not produce a 3D shape"));
+			results.push(cast);
+		}
+		return require_errors.ok(results);
+	} catch (e) {
+		return require_errors.err(require_errors.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) require_errors.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 require_arrayAccess.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 = require_errors.unwrap(require_surfaceBuilders.makeFace(sketch.wire));
+	else face = require_surfaceBuilders.makeNewFaceWithinFace(sketch.baseFace, sketch.wire);
+	return face;
+}
+/** Return an independent clone of the sketch's wire. */
+function sketchWires(sketch) {
+	return require_shapeTypes.createWire(require_errors.unwrap(require_faceFns.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 = require_errors.unwrap(require_surfaceBuilders.makeFace(sketch.wire));
+	const solid = require_errors.unwrap(require_extrudeFns.revolve(face, origin ? require_types.toVec3(origin) : sketch.defaultOrigin, revolutionAxis ? require_types.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 = require_vecOps.vecScale(require_vecOps.vecNormalize(extrusionDirection ? require_types.toVec3(extrusionDirection) : sketch.defaultDirection), extrusionDistance);
+	const originVec = origin ? require_types.toVec3(origin) : sketch.defaultOrigin;
+	if (extrusionProfile && !twistAngle) {
+		const solid = require_errors.unwrap(require_extrudeFns.complexExtrude(sketch.wire, [...originVec], [...extrusionVec], extrusionProfile));
+		sketch.delete();
+		return solid;
+	}
+	if (twistAngle) {
+		const solid = require_errors.unwrap(require_extrudeFns.twistExtrude(sketch.wire, twistAngle, [...originVec], [...extrusionVec], extrusionProfile));
+		sketch.delete();
+		return solid;
+	}
+	const solid = require_errors.unwrap(require_extrudeFns.extrude(require_errors.unwrap(require_surfaceBuilders.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 = require_curveFns.curveStartPoint(sketch.wire);
+	const normal = require_vecOps.vecNormalize(require_vecOps.vecScale(require_curveFns.curveTangentAt(sketch.wire, 1e-9), -1));
+	const defaultDir = sketch.defaultDirection;
+	const xDir = require_vecOps.vecScale(require_vecOps.vecCross(normal, defaultDir), -1);
+	const result = sketchOnPlane(require_planeOps.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 = require_errors.unwrap(require_extrudeFns.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 = require_errors.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 = require_errors.unwrap(require_faceFns.cast(require_shapeTypes.getKernel().fillSurface(wireShapes)));
+	if (!require_shapeTypes.isFace(newFace)) require_errors.bug("guessFaceFromWires", "Failed to create a face");
+	return newFace;
+};
+var fixWire = (wire, baseFace) => {
+	return require_shapeTypes.createWire(require_shapeTypes.getKernel().fixWireOnFace(wire.wrapped, baseFace.wrapped, 1e-9));
+};
+var faceFromWires = (wires) => {
+	let baseFace;
+	let holeWires;
+	const faceResult = require_surfaceBuilders.makeFace(require_arrayAccess.firstOrThrow(wires));
+	if (require_errors.isOk(faceResult)) {
+		baseFace = faceResult.value;
+		holeWires = wires.slice(1);
+	} else {
+		baseFace = guessFaceFromWires(wires);
+		holeWires = wires.slice(1).map((w) => fixWire(w, baseFace));
+	}
+	return require_surfaceBuilders.addHolesInFace(baseFace, holeWires);
+};
+var solidFromShellGenerator = (sketches, shellGenerator) => {
+	const shells = [];
+	const startWires = [];
+	const endWires = [];
+	sketches.forEach((sketch) => {
+		const [shell, startWire, endWire] = require_errors.unwrap(shellGenerator(sketch));
+		shells.push(shell);
+		startWires.push(startWire);
+		endWires.push(endWire);
+	});
+	const startFace = faceFromWires(startWires);
+	const endFace = faceFromWires(endWires);
+	return require_errors.unwrap(require_solidBuilders.makeSolid([
+		startFace,
+		...shells,
+		endFace
+	]));
+};
+/** Build a face from a compound sketch (outer boundary with holes). */
+function compoundSketchFace(sketch) {
+	return require_surfaceBuilders.addHolesInFace(sketch.outerSketch.face(), sketch.innerSketches.map((s) => s.wire));
+}
+/** Return all wires (outer + holes) combined into a compound shape. */
+function compoundSketchWires(sketch) {
+	return require_solidBuilders.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 = require_vecOps.vecScale(require_vecOps.vecNormalize(extrusionDirection ? require_types.toVec3(extrusionDirection) : sketch.outerSketch.defaultDirection), extrusionDistance);
+	if (extrusionProfile && !twistAngle) return solidFromShellGenerator(sketch.sketches, (s) => require_extrudeFns.complexExtrude(s.wire, origin ? require_types.toVec3(origin) : sketch.outerSketch.defaultOrigin, extrusionVec, extrusionProfile, true));
+	if (twistAngle) return solidFromShellGenerator(sketch.sketches, (s) => require_extrudeFns.twistExtrude(s.wire, twistAngle, origin ? require_types.toVec3(origin) : sketch.outerSketch.defaultOrigin, extrusionVec, extrusionProfile, true));
+	return require_errors.unwrap(require_extrudeFns.extrude(compoundSketchFace(sketch), extrusionVec));
+}
+/** Revolve a compound sketch (outer + holes) around an axis. */
+function compoundSketchRevolve(sketch, revolutionAxis, { origin } = {}) {
+	const center = origin ? require_types.toVec3(origin) : sketch.outerSketch.defaultOrigin;
+	const dir = revolutionAxis ? require_types.toVec3(revolutionAxis) : [
+		0,
+		0,
+		1
+	];
+	return require_errors.unwrap(require_extrudeFns.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) require_errors.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 = require_arrayAccess.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 = require_shapeTypes.createFace(require_errors.unwrap(require_faceFns.downcast(compoundSketchFace(sketch).wrapped)));
+	shells.push(baseFace, compoundSketchFace(other));
+	return require_errors.unwrap(require_solidBuilders.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 = require_types.toVec3(defaultOrigin);
+		this._defaultDirection = require_types.toVec3(defaultDirection);
+		this.baseFace = null;
+	}
+	get baseFace() {
+		return this._baseFace;
+	}
+	set baseFace(newFace) {
+		if (this._baseFace) this._baseFace.delete();
+		this._baseFace = newFace ? require_shapeTypes.createFace(require_errors.unwrap(require_faceFns.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(require_shapeTypes.createWire(require_errors.unwrap(require_faceFns.downcast(this.wire.wrapped))), {
+			defaultOrigin: this.defaultOrigin,
+			defaultDirection: this.defaultDirection
+		});
+		if (this.baseFace) sketch.baseFace = require_shapeTypes.createFace(require_errors.unwrap(require_faceFns.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 = require_types.toVec3(newOrigin);
+	}
+	/** Get the default extrusion/normal direction. */
+	get defaultDirection() {
+		return this._defaultDirection;
+	}
+	/** Set the default extrusion/normal direction. */
+	set defaultDirection(newDirection) {
+		this._defaultDirection = require_types.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 require_solidBuilders.makeCompound(this.sketches.map((s) => s instanceof Sketch ? s.wire : s.wires));
+	}
+	/** Return all sketch faces combined into a single compound shape. */
+	faces() {
+		return require_solidBuilders.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 require_solidBuilders.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 require_solidBuilders.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 require_errors.ok(FONT_REGISTER[fontFamily]);
+	let fontData;
+	if (typeof fontPath === "string") {
+		let response;
+		try {
+			response = await fetch(fontPath);
+		} catch (e) {
+			return require_errors.err(require_errors.ioError(require_errors.BrepErrorCode.FONT_FETCH_FAILED, `Failed to fetch font from ${fontPath}: ${e instanceof Error ? e.message : String(e)}`, e));
+		}
+		if (!response.ok) return require_errors.err(require_errors.ioError(require_errors.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_js.default.parse(fontData);
+	} catch (e) {
+		return require_errors.err(require_errors.ioError(require_errors.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 require_errors.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 require_blueprintSketcher.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) require_errors.bug("text", "No fonts loaded. Call loadFont() before using text functions.");
+	const writtenText = font.getPath(text, -startX, -startY, fontSize);
+	return require_blueprintSketcher.organiseBlueprints(Array.from(sketchFontCommands(writtenText.commands))).mirror([0, 0]);
+}
+//#endregion
+Object.defineProperty(exports, "CompoundSketch", {
+	enumerable: true,
+	get: function() {
+		return CompoundSketch;
+	}
+});
+Object.defineProperty(exports, "Sketch", {
+	enumerable: true,
+	get: function() {
+		return Sketch;
+	}
+});
+Object.defineProperty(exports, "Sketches", {
+	enumerable: true,
+	get: function() {
+		return Sketches;
+	}
+});
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "compoundSketchExtrude", {
+	enumerable: true,
+	get: function() {
+		return compoundSketchExtrude;
+	}
+});
+Object.defineProperty(exports, "compoundSketchFace", {
+	enumerable: true,
+	get: function() {
+		return compoundSketchFace;
+	}
+});
+Object.defineProperty(exports, "compoundSketchLoft", {
+	enumerable: true,
+	get: function() {
+		return compoundSketchLoft;
+	}
+});
+Object.defineProperty(exports, "compoundSketchRevolve", {
+	enumerable: true,
+	get: function() {
+		return compoundSketchRevolve;
+	}
+});
+Object.defineProperty(exports, "getFont", {
+	enumerable: true,
+	get: function() {
+		return getFont;
+	}
+});
+Object.defineProperty(exports, "loadFont", {
+	enumerable: true,
+	get: function() {
+		return loadFont;
+	}
+});
+Object.defineProperty(exports, "loft", {
+	enumerable: true,
+	get: function() {
+		return loft;
+	}
+});
+Object.defineProperty(exports, "loftAll", {
+	enumerable: true,
+	get: function() {
+		return loftAll;
+	}
+});
+Object.defineProperty(exports, "sketchExtrude", {
+	enumerable: true,
+	get: function() {
+		return sketchExtrude;
+	}
+});
+Object.defineProperty(exports, "sketchFace", {
+	enumerable: true,
+	get: function() {
+		return sketchFace;
+	}
+});
+Object.defineProperty(exports, "sketchLoft", {
+	enumerable: true,
+	get: function() {
+		return sketchLoft;
+	}
+});
+Object.defineProperty(exports, "sketchRevolve", {
+	enumerable: true,
+	get: function() {
+		return sketchRevolve;
+	}
+});
+Object.defineProperty(exports, "sketchSweep", {
+	enumerable: true,
+	get: function() {
+		return sketchSweep;
+	}
+});
+Object.defineProperty(exports, "sketchWires", {
+	enumerable: true,
+	get: function() {
+		return sketchWires;
+	}
+});
+Object.defineProperty(exports, "textBlueprints", {
+	enumerable: true,
+	get: function() {
+		return textBlueprints;
+	}
+});
+Object.defineProperty(exports, "wrapSketchData", {
+	enumerable: true,
+	get: function() {
+		return wrapSketchData;
+	}
+});
+Object.defineProperty(exports, "wrapSketchDataArray", {
+	enumerable: true,
+	get: function() {
+		return wrapSketchDataArray;
+	}
+});