@faicad/sheetmetal 0.13.0

package/dist/api.js

@@ -0,0 +1,367 @@
+/**
+ * Public API — short-named wrappers over the sheet-metal `*Fns` modules.
+ *
+ * These are the canonical entry points for the domain: they delegate to the
+ * underlying functional implementations without re-deriving any geometry, and
+ * preserve the `Result<T>` / warning-channel contract end to end. The fluent
+ * `sheetMetal()` facade in `./facade.js` is built on top of these.
+ */
+import { ok, err, validationError } from '@faicad/faijs/brepjs-compat';
+import { authorPart as authorPartFn, } from './authorFns.js';
+import { unfold as unfoldFn } from './unfoldFns.js';
+import { unfoldForeignSolid as unfoldForeignSolidFn } from './foreignUnfoldFns.js';
+import { fold as foldFn } from './foldFns.js';
+import { miterCut as miterCutFn, autoMiterCorner as autoMiterCornerFn, } from './miterFns.js';
+import { addBendRelief as addBendReliefFn, autoBendReliefs as autoBendReliefsFn, cornerRelief as cornerReliefFn, } from './reliefFns.js';
+import { addCutout as addCutoutFn, addHole as addHoleFn, addSlot as addSlotFn, addPolygonCutout as addPolygonCutoutFn, } from './cutoutFns.js';
+import { addTab as addTabFn, tabAndSlot as tabAndSlotFn, } from './tabFns.js';
+import { louver as louverFn, emboss as embossFn } from './formFns.js';
+import { authorContourFlange as authorContourFlangeFn } from './contourFlangeFns.js';
+import { authorLoftedFlange as authorLoftedFlangeFn } from './loftedFlangeFns.js';
+import { hem as hemFn } from './hemFns.js';
+import { jog as jogFn } from './jogFns.js';
+import { flatPatternToDXF as flatPatternToDXFFn } from './dxfFns.js';
+import { nest as nestFn, nestToDXF as nestToDXFFn, } from './nestFns.js';
+import { buildReport as buildReportFn, reportFromUnfold as reportFromUnfoldFn, reportToJSON as reportToJSONFn, } from './reportFns.js';
+import { validatePart as validatePartFn } from './validateFns.js';
+import { bendAllowance as bendAllowanceFn, developedLength as developedLengthFn } from './allowanceFns.js';
+import { registerBendTable as registerBendTableFn, getBendTable as getBendTableFn, resolveBendAllowance as resolveBendAllowanceFn, } from './bendTableFns.js';
+/**
+ * Author a straight-bend part: a base flat plus folded-up flanges.
+ * @param spec - the part definition: base flat, material thickness, and the flange list to fold up.
+ * @returns a `Result<SheetMetalPart>` carrying the authored part, or the first error encountered.
+ */
+export function author(spec) {
+    return authorPartFn(spec);
+}
+/**
+ * Extract the lone 3D solid of an authored part as its own `Result` terminal.
+ *
+ * `author`/`fold`/`hem` return the data model `SheetMetalPart`; its `.solid`
+ * field is the authored BREP solid. `.fai.js` statements cannot read nested
+ * member expressions (`p1.solid`), so this explicit terminal is the sanctioned
+ * way to pull the geometry out of a part.
+ * @param part - the sheet-metal part carrying the authored solid.
+ * @returns `Ok` with the part's surface, or `Err` (`NO_SOLID`) when the part
+ * has no authored solid yet (e.g. it was only built by `flatPattern`).
+ */
+export function solidOf(part) {
+    return part.solid ? ok(part.solid) : err(validationError('NO_SOLID', 'part has no authored solid'));
+}
+/**
+ * Flatten an authored part into a developed flat pattern + bend report + warnings.
+ * @param part - the authored sheet-metal part to flatten.
+ * @returns a `Result<UnfoldResult>` with the flat pattern, bend report, and any warnings.
+ */
+export function unfold(part) {
+    return unfoldFn(part);
+}
+/**
+ * Unfold an imported sheet-metal solid that has no feature tree, by detecting its
+ * geometry (planar panels + cylindrical bends) numerically. `kFactor` defaults to
+ * the mid-surface neutral axis (0.5); supply a known material's K-factor to match
+ * its development.
+ * @param solid - the imported solid (B-rep) to unfold.
+ * @param opts - optional overrides; `opts.kFactor` sets the K-factor used for the bend allowance.
+ * @returns a `Result<UnfoldResult>` with the detected flat pattern, report, and any warnings.
+ */
+export function unfoldSolid(solid, opts) {
+    return unfoldForeignSolidFn(solid, opts);
+}
+/**
+ * Fold a flat pattern (region-tree) up into a 3D part — the inverse of {@link unfold}.
+ * @param input - the flat pattern (region tree) to fold up.
+ * @returns a `Result<SheetMetalPart>` carrying the folded 3D part, or the first error.
+ */
+export function fold(input) {
+    return foldFn(input);
+}
+/**
+ * Cut a part by an oriented plane, removing material on the `+normal` side.
+ * @param part - the sheet-metal part to cut.
+ * @param plane - the oriented cutting plane; material on the plane's `+normal` side is removed.
+ * @returns a `Result<SheetMetalPart>` carrying the mitered part, or the first error.
+ */
+export function miter(part, plane) {
+    return miterCutFn(part, plane);
+}
+/**
+ * Auto-miter the shared corner of two flanges with an optional gap.
+ * @param part - the sheet-metal part whose corner is to be mitered.
+ * @param flangeIdA - id of the first flange meeting at the corner.
+ * @param flangeIdB - id of the second flange meeting at the corner.
+ * @param gap - optional gap (in millimetres) left between the two mitered edges; defaults to 0.
+ * @returns a `Result<SheetMetalPart>` carrying the mitered part, or the first error.
+ */
+export function miterCorner(part, flangeIdA, flangeIdB, gap = 0) {
+    return autoMiterCornerFn(part, flangeIdA, flangeIdB, gap);
+}
+/**
+ * Add a bend relief slot at each mid-edge end of a partial flange's bend line.
+ * @param part - the sheet-metal part to modify.
+ * @param flangeId - id of the partial flange whose bend-line ends get the relief.
+ * @param spec - optional relief specification overriding the defaults.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the relief added, or the first error.
+ */
+export function bendRelief(part, flangeId, spec) {
+    return addBendReliefFn(part, flangeId, spec);
+}
+/**
+ * Add a bend relief to every partial-span bend in the part.
+ * @param part - the sheet-metal part to modify.
+ * @param spec - optional relief specification applied to every partial bend.
+ * @returns a `Result<SheetMetalPart>` carrying the part with all reliefs added, or the first error.
+ */
+export function autoReliefs(part, spec) {
+    return autoBendReliefsFn(part, spec);
+}
+/**
+ * Cut a corner relief notch at the shared corner of two adjacent flanges.
+ * @param part - the sheet-metal part to modify.
+ * @param flangeIdA - id of the first flange forming the corner.
+ * @param flangeIdB - id of the second flange forming the corner.
+ * @param spec - optional relief specification overriding the defaults.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the corner relief added, or the first error.
+ */
+export function relieveCorner(part, flangeIdA, flangeIdB, spec) {
+    return cornerReliefFn(part, flangeIdA, flangeIdB, spec);
+}
+/**
+ * Punch a cutout (hole / slot / polygon) through a named flat region's thickness.
+ * @param part - the sheet-metal part to modify.
+ * @param spec - the cutout definition (kind, geometry, and target region).
+ * @returns a `Result<SheetMetalPart>` carrying the part with the cutout punched, or the first error.
+ */
+export function addCutout(part, spec) {
+    return addCutoutFn(part, spec);
+}
+/**
+ * Punch a circular hole of `diameter` centred at region-local `(x, y)`.
+ * @param part - the sheet-metal part to modify.
+ * @param region - name of the flat region the hole is punched through.
+ * @param x - region-local X of the hole centre.
+ * @param y - region-local Y of the hole centre.
+ * @param diameter - hole diameter.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the hole punched, or the first error.
+ */
+export function addHole(part, region, x, y, diameter) {
+    return addHoleFn(part, region, x, y, diameter);
+}
+/**
+ * Punch a slot (rectangular or obround) centred at region-local `(x, y)`.
+ * @param part - the sheet-metal part to modify.
+ * @param region - name of the flat region the slot is punched through.
+ * @param opts - slot geometry: centre `(x, y)`, `length`, `width`, optional `angleDeg` rotation, and `round` ends flag.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the slot punched, or the first error.
+ */
+export function addSlot(part, region, opts) {
+    return addSlotFn(part, region, opts);
+}
+/**
+ * Punch an arbitrary polygon cutout from its region-local `points`.
+ * @param part - the sheet-metal part to modify.
+ * @param region - name of the flat region the polygon is punched through.
+ * @param points - region-local polygon vertices as `[x, y]` pairs.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the polygon cutout, or the first error.
+ */
+export function addPolygonCutout(part, region, points) {
+    return addPolygonCutoutFn(part, region, points);
+}
+/**
+ * Fuse a rectangular tab (additive protrusion) onto a region's edge.
+ * @param part - the sheet-metal part to modify.
+ * @param spec - tab definition: edge, width, and length.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the tab added, or the first error.
+ */
+export function addTab(part, spec) {
+    return addTabFn(part, spec);
+}
+/**
+ * Self-fixturing tab-and-slot joint: a tab on one region + a matching slot on another.
+ * @param part - the sheet-metal part to modify.
+ * @param tab - the tab to add to the first region.
+ * @param slot - placement of the matching slot on the second region.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the joint added, or the first error.
+ */
+export function tabAndSlot(part, tab, slot) {
+    return tabAndSlotFn(part, tab, slot);
+}
+/**
+ * Form a louver (vent flap cut on 3 sides, formed up along the hinge) on a region.
+ * @param part - the sheet-metal part to modify.
+ * @param opts - louver geometry: target `region`, centre `(x, y)`, `length`, `width`, `height`, and optional `direction`.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the louver formed, or the first error.
+ */
+export function louver(part, opts) {
+    return louverFn(part, opts);
+}
+/**
+ * Form a round emboss (raised) or dimple (recessed) on a region.
+ * @param part - the sheet-metal part to modify.
+ * @param opts - emboss geometry: target `region`, centre `(x, y)`, `diameter`, `height`, and `kind` (`dimple` or `emboss`).
+ * @returns a `Result<SheetMetalPart>` carrying the part with the form added, or the first error.
+ */
+export function emboss(part, opts) {
+    return embossFn(part, opts);
+}
+/**
+ * Author a contour flange: an open line/arc profile swept along a base edge into a
+ * multi-bend cross-section. The development is exact (Σ segment developed lengths).
+ * @param part - the sheet-metal part the flange is added to.
+ * @param spec - contour flange definition: profile, base edge, and bend parameters.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the contour flange added, or the first error.
+ */
+export function contourFlange(part, spec) {
+    return authorContourFlangeFn(part, spec);
+}
+/**
+ * Author a lofted / ruled transition flange between two parallel open profiles. The
+ * development is by triangulation — exact for a developable transition, an
+ * approximation (with a `DEVELOPMENT_APPROXIMATE` unfold warning) otherwise.
+ * @param part - the sheet-metal part the flange is added to.
+ * @param spec - lofted flange definition: the two open profiles and their alignment.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the lofted flange added, or the first error.
+ */
+export function loftedFlange(part, spec) {
+    return authorLoftedFlangeFn(part, spec);
+}
+/**
+ * Author a hem: fold a region edge back ~180°+ onto its parent and run a short
+ * return leg. The development is exact (Σ curl bend allowances + return length).
+ * @param part - the sheet-metal part the hem is added to.
+ * @param spec - hem definition: edge, curl radius, and return leg length.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the hem added, or the first error.
+ */
+export function hem(part, spec) {
+    return hemFn(part, spec);
+}
+/**
+ * Author a jog (joggle): two opposite bends stepping the flat by `offsetHeight`
+ * perpendicular to its plane, then continuing parallel. Development is exact.
+ * @param part - the sheet-metal part the jog is added to.
+ * @param spec - jog definition: bend line, offset height, and radii.
+ * @returns a `Result<SheetMetalPart>` carrying the part with the jog added, or the first error.
+ */
+export function jog(part, spec) {
+    return jogFn(part, spec);
+}
+/**
+ * Emit an annotated multi-layer DXF string for a flat pattern.
+ * @param pattern - the flat pattern to serialize.
+ * @param options - optional DXF output options (layers, precision, units).
+ * @returns a `Result<string>` carrying the DXF text, or the first error.
+ */
+export function toDXF(pattern, options) {
+    return flatPatternToDXFFn(pattern, options);
+}
+/**
+ * Nest developed flat patterns onto stock sheets to reduce waste. The default
+ * `strategy: "bbox"` packs each part as its outline bounding box (fast, no
+ * interlocking). `strategy: "nfp"` is true-shape / no-fit-polygon nesting: the actual
+ * outline polygons are packed so concave (L-shaped) parts interlock for higher
+ * utilization. The NFP packer is a HEURISTIC (bottom-left-fill) — not provably
+ * optimal — but never overlaps parts and never drops a part silently.
+ * @param patterns - the flat patterns to place onto stock sheets.
+ * @param options - nesting configuration: stock sheet size, strategy, and spacing.
+ * @returns a `Result<NestResult>` carrying the placed sheets and part transforms, or the first error.
+ */
+export function nest(patterns, options) {
+    return nestFn(patterns, options);
+}
+/**
+ * Emit one fabrication-ready DXF for a single nested sheet (all parts placed).
+ * @param result - the nesting result containing the sheet to render.
+ * @param patterns - the original flat patterns referenced by `result`.
+ * @param sheetIndex - index of the nested sheet to emit.
+ * @param options - optional DXF output options (layers, precision, units).
+ * @returns a `Result<string>` carrying the DXF text, or the first error.
+ */
+export function nestToDXF(result, patterns, sheetIndex, options) {
+    return nestToDXFFn(result, patterns, sheetIndex, options);
+}
+/**
+ * Build a bend report by walking the part's feature tree.
+ * @param part - the sheet-metal part to report on.
+ * @returns a `Result<BendReport>` carrying the computed bend report, or the first error.
+ */
+export function report(part) {
+    return buildReportFn(part);
+}
+/**
+ * Project the report already computed by {@link unfold} without re-walking the tree.
+ * @param result - the unfold result whose bend report is to be projected.
+ * @returns a `Result<BendReport>` carrying the projected bend report, or the first error.
+ */
+export function reportFrom(result) {
+    return reportFromUnfoldFn(result);
+}
+/**
+ * Serialize a bend report to stable pretty-printed JSON.
+ * @param report - the bend report to serialize.
+ * @returns the stable pretty-printed JSON string.
+ */
+export function reportJSON(report) {
+    return reportToJSONFn(report);
+}
+/**
+ * Manufacturability checks — advisory warnings, never errors.
+ * @param part - the sheet-metal part to check.
+ * @returns the list of manufacturability warnings (empty when the part is clean).
+ */
+export function validate(part) {
+    return validatePartFn(part);
+}
+/**
+ * Bend allowance `BA = (π/180)·|angle|·(R + K·T)` for a single bend.
+ * @param angleDeg - the bend angle in degrees.
+ * @param thickness - the material thickness, in the same units as the rule radii.
+ * @param rule - the bend rule (K-factor, inner radius, or a bend-table reference) to apply.
+ * @param onWarning - optional callback invoked for non-fatal warnings during the computation.
+ * @returns a `Result<number>` carrying the bend allowance, or the first error.
+ */
+export function allowance(angleDeg, thickness, rule, onWarning) {
+    return bendAllowanceFn(angleDeg, thickness, rule, onWarning);
+}
+/**
+ * Neutral-axis developed length of a bend region (numerically equal to the allowance).
+ * @param angleDeg - the bend angle in degrees.
+ * @param thickness - the material thickness, in the same units as the rule radii.
+ * @param rule - the bend rule (K-factor, inner radius, or a bend-table reference) to apply.
+ * @param onWarning - optional callback invoked for non-fatal warnings during the computation.
+ * @returns a `Result<number>` carrying the developed length, or the first error.
+ */
+export function developed(angleDeg, thickness, rule, onWarning) {
+    return developedLengthFn(angleDeg, thickness, rule, onWarning);
+}
+/**
+ * Register (or replace) a shop bend table so rules can reference it by id.
+ * @param table - the bend table to register.
+ * @returns a `Result<BendTable>` carrying the registered table, or the first error.
+ */
+export function addBendTable(table) {
+    return registerBendTableFn(table);
+}
+/**
+ * Look up a registered bend table by id (starter tables included).
+ * @param id - the bend table id to look up.
+ * @returns the matching `BendTable`, or `undefined` when no such table is registered.
+ */
+export function bendTable(id) {
+    return getBendTableFn(id);
+}
+/**
+ * Resolve a bend's developed allowance through the single resolution point:
+ * a referenced bend table, then an explicit `rule.allowance`, then the K-factor
+ * formula. This is what {@link developed} delegates to.
+ * @param rule - the bend rule (bend-table reference, explicit allowance, or K-factor) to resolve.
+ * @param angleDeg - the bend angle in degrees.
+ * @param thickness - the material thickness, in the same units as the rule radii.
+ * @param onWarning - optional callback invoked for non-fatal warnings during the computation.
+ * @returns a `Result<number>` carrying the resolved allowance, or the first error.
+ */
+export function resolveAllowance(rule, angleDeg, thickness, onWarning) {
+    return resolveBendAllowanceFn(rule, angleDeg, thickness, onWarning);
+}
+/** The live bend-table registry (shared resource, §7.3). */
+export { bendTables } from './bendTableFns.js';
+//# sourceMappingURL=api.js.map

package/dist/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Public API — short-named wrappers over the sheet-metal `*Fns` modules.\n *\n * These are the canonical entry points for the domain: they delegate to the\n * underlying functional implementations without re-deriving any geometry, and\n * preserve the `Result<T>` / warning-channel contract end to end. The fluent\n * `sheetMetal()` facade in `./facade.js` is built on top of these.\n */\n\nimport { ok, err, validationError, type Result, type Solid } from '@faicad/faijs/brepjs-compat';\nimport {\n  authorPart as authorPartFn,\n  type AuthorSpec,\n  type FlangeSpec,\n} from './authorFns.js';\nimport { unfold as unfoldFn } from './unfoldFns.js';\nimport { unfoldForeignSolid as unfoldForeignSolidFn } from './foreignUnfoldFns.js';\nimport { fold as foldFn } from './foldFns.js';\nimport {\n  miterCut as miterCutFn,\n  autoMiterCorner as autoMiterCornerFn,\n  type MiterPlane,\n} from './miterFns.js';\nimport {\n  addBendRelief as addBendReliefFn,\n  autoBendReliefs as autoBendReliefsFn,\n  cornerRelief as cornerReliefFn,\n} from './reliefFns.js';\nimport {\n  addCutout as addCutoutFn,\n  addHole as addHoleFn,\n  addSlot as addSlotFn,\n  addPolygonCutout as addPolygonCutoutFn,\n} from './cutoutFns.js';\nimport {\n  addTab as addTabFn,\n  tabAndSlot as tabAndSlotFn,\n  type SlotPlacement,\n} from './tabFns.js';\nimport { louver as louverFn, emboss as embossFn } from './formFns.js';\nimport { authorContourFlange as authorContourFlangeFn } from './contourFlangeFns.js';\nimport { authorLoftedFlange as authorLoftedFlangeFn } from './loftedFlangeFns.js';\nimport { hem as hemFn } from './hemFns.js';\nimport { jog as jogFn } from './jogFns.js';\nimport { flatPatternToDXF as flatPatternToDXFFn, type DxfOptions } from './dxfFns.js';\nimport {\n  nest as nestFn,\n  nestToDXF as nestToDXFFn,\n  type NestOptions,\n  type NestResult,\n} from './nestFns.js';\nimport {\n  buildReport as buildReportFn,\n  reportFromUnfold as reportFromUnfoldFn,\n  reportToJSON as reportToJSONFn,\n} from './reportFns.js';\nimport { validatePart as validatePartFn } from './validateFns.js';\nimport { bendAllowance as bendAllowanceFn, developedLength as developedLengthFn } from './allowanceFns.js';\nimport {\n  registerBendTable as registerBendTableFn,\n  getBendTable as getBendTableFn,\n  resolveBendAllowance as resolveBendAllowanceFn,\n  type BendTable,\n} from './bendTableFns.js';\nimport type {\n  SheetMetalPart,\n  FlatPattern,\n  FlatInput,\n  BendReport,\n  BendRule,\n  ReliefSpec,\n  CutoutSpec,\n  TabSpec,\n  ContourFlangeSpec,\n  LoftedFlangeSpec,\n  HemSpec,\n  JogSpec,\n  UnfoldResult,\n  SheetMetalWarning,\n} from './types.js';\n\n/**\n * Author a straight-bend part: a base flat plus folded-up flanges.\n * @param spec - the part definition: base flat, material thickness, and the flange list to fold up.\n * @returns a `Result<SheetMetalPart>` carrying the authored part, or the first error encountered.\n */\nexport function author(spec: AuthorSpec): Result<SheetMetalPart> {\n  return authorPartFn(spec);\n}\n\n/**\n * Extract the lone 3D solid of an authored part as its own `Result` terminal.\n *\n * `author`/`fold`/`hem` return the data model `SheetMetalPart`; its `.solid`\n * field is the authored BREP solid. `.fai.js` statements cannot read nested\n * member expressions (`p1.solid`), so this explicit terminal is the sanctioned\n * way to pull the geometry out of a part.\n * @param part - the sheet-metal part carrying the authored solid.\n * @returns `Ok` with the part's surface, or `Err` (`NO_SOLID`) when the part\n * has no authored solid yet (e.g. it was only built by `flatPattern`).\n */\nexport function solidOf(part: SheetMetalPart): Result<Solid> {\n  return part.solid ? ok(part.solid) : err(validationError('NO_SOLID', 'part has no authored solid'));\n}\n\n/**\n * Flatten an authored part into a developed flat pattern + bend report + warnings.\n * @param part - the authored sheet-metal part to flatten.\n * @returns a `Result<UnfoldResult>` with the flat pattern, bend report, and any warnings.\n */\nexport function unfold(part: SheetMetalPart): Result<UnfoldResult> {\n  return unfoldFn(part);\n}\n\n/**\n * Unfold an imported sheet-metal solid that has no feature tree, by detecting its\n * geometry (planar panels + cylindrical bends) numerically. `kFactor` defaults to\n * the mid-surface neutral axis (0.5); supply a known material's K-factor to match\n * its development.\n * @param solid - the imported solid (B-rep) to unfold.\n * @param opts - optional overrides; `opts.kFactor` sets the K-factor used for the bend allowance.\n * @returns a `Result<UnfoldResult>` with the detected flat pattern, report, and any warnings.\n */\nexport function unfoldSolid(solid: Solid, opts?: { kFactor?: number }): Result<UnfoldResult> {\n  return unfoldForeignSolidFn(solid, opts);\n}\n\n/**\n * Fold a flat pattern (region-tree) up into a 3D part — the inverse of {@link unfold}.\n * @param input - the flat pattern (region tree) to fold up.\n * @returns a `Result<SheetMetalPart>` carrying the folded 3D part, or the first error.\n */\nexport function fold(input: FlatInput): Result<SheetMetalPart> {\n  return foldFn(input);\n}\n\n/**\n * Cut a part by an oriented plane, removing material on the `+normal` side.\n * @param part - the sheet-metal part to cut.\n * @param plane - the oriented cutting plane; material on the plane's `+normal` side is removed.\n * @returns a `Result<SheetMetalPart>` carrying the mitered part, or the first error.\n */\nexport function miter(part: SheetMetalPart, plane: MiterPlane): Result<SheetMetalPart> {\n  return miterCutFn(part, plane);\n}\n\n/**\n * Auto-miter the shared corner of two flanges with an optional gap.\n * @param part - the sheet-metal part whose corner is to be mitered.\n * @param flangeIdA - id of the first flange meeting at the corner.\n * @param flangeIdB - id of the second flange meeting at the corner.\n * @param gap - optional gap (in millimetres) left between the two mitered edges; defaults to 0.\n * @returns a `Result<SheetMetalPart>` carrying the mitered part, or the first error.\n */\nexport function miterCorner(\n  part: SheetMetalPart,\n  flangeIdA: string,\n  flangeIdB: string,\n  gap = 0\n): Result<SheetMetalPart> {\n  return autoMiterCornerFn(part, flangeIdA, flangeIdB, gap);\n}\n\n/**\n * Add a bend relief slot at each mid-edge end of a partial flange's bend line.\n * @param part - the sheet-metal part to modify.\n * @param flangeId - id of the partial flange whose bend-line ends get the relief.\n * @param spec - optional relief specification overriding the defaults.\n * @returns a `Result<SheetMetalPart>` carrying the part with the relief added, or the first error.\n */\nexport function bendRelief(\n  part: SheetMetalPart,\n  flangeId: string,\n  spec?: ReliefSpec\n): Result<SheetMetalPart> {\n  return addBendReliefFn(part, flangeId, spec);\n}\n\n/**\n * Add a bend relief to every partial-span bend in the part.\n * @param part - the sheet-metal part to modify.\n * @param spec - optional relief specification applied to every partial bend.\n * @returns a `Result<SheetMetalPart>` carrying the part with all reliefs added, or the first error.\n */\nexport function autoReliefs(part: SheetMetalPart, spec?: ReliefSpec): Result<SheetMetalPart> {\n  return autoBendReliefsFn(part, spec);\n}\n\n/**\n * Cut a corner relief notch at the shared corner of two adjacent flanges.\n * @param part - the sheet-metal part to modify.\n * @param flangeIdA - id of the first flange forming the corner.\n * @param flangeIdB - id of the second flange forming the corner.\n * @param spec - optional relief specification overriding the defaults.\n * @returns a `Result<SheetMetalPart>` carrying the part with the corner relief added, or the first error.\n */\nexport function relieveCorner(\n  part: SheetMetalPart,\n  flangeIdA: string,\n  flangeIdB: string,\n  spec?: ReliefSpec\n): Result<SheetMetalPart> {\n  return cornerReliefFn(part, flangeIdA, flangeIdB, spec);\n}\n\n/**\n * Punch a cutout (hole / slot / polygon) through a named flat region's thickness.\n * @param part - the sheet-metal part to modify.\n * @param spec - the cutout definition (kind, geometry, and target region).\n * @returns a `Result<SheetMetalPart>` carrying the part with the cutout punched, or the first error.\n */\nexport function addCutout(part: SheetMetalPart, spec: CutoutSpec): Result<SheetMetalPart> {\n  return addCutoutFn(part, spec);\n}\n\n/**\n * Punch a circular hole of `diameter` centred at region-local `(x, y)`.\n * @param part - the sheet-metal part to modify.\n * @param region - name of the flat region the hole is punched through.\n * @param x - region-local X of the hole centre.\n * @param y - region-local Y of the hole centre.\n * @param diameter - hole diameter.\n * @returns a `Result<SheetMetalPart>` carrying the part with the hole punched, or the first error.\n */\nexport function addHole(\n  part: SheetMetalPart,\n  region: string,\n  x: number,\n  y: number,\n  diameter: number\n): Result<SheetMetalPart> {\n  return addHoleFn(part, region, x, y, diameter);\n}\n\n/**\n * Punch a slot (rectangular or obround) centred at region-local `(x, y)`.\n * @param part - the sheet-metal part to modify.\n * @param region - name of the flat region the slot is punched through.\n * @param opts - slot geometry: centre `(x, y)`, `length`, `width`, optional `angleDeg` rotation, and `round` ends flag.\n * @returns a `Result<SheetMetalPart>` carrying the part with the slot punched, or the first error.\n */\nexport function addSlot(\n  part: SheetMetalPart,\n  region: string,\n  opts: { x: number; y: number; length: number; width: number; angleDeg?: number; round?: boolean }\n): Result<SheetMetalPart> {\n  return addSlotFn(part, region, opts);\n}\n\n/**\n * Punch an arbitrary polygon cutout from its region-local `points`.\n * @param part - the sheet-metal part to modify.\n * @param region - name of the flat region the polygon is punched through.\n * @param points - region-local polygon vertices as `[x, y]` pairs.\n * @returns a `Result<SheetMetalPart>` carrying the part with the polygon cutout, or the first error.\n */\nexport function addPolygonCutout(\n  part: SheetMetalPart,\n  region: string,\n  points: [number, number][]\n): Result<SheetMetalPart> {\n  return addPolygonCutoutFn(part, region, points);\n}\n\n/**\n * Fuse a rectangular tab (additive protrusion) onto a region's edge.\n * @param part - the sheet-metal part to modify.\n * @param spec - tab definition: edge, width, and length.\n * @returns a `Result<SheetMetalPart>` carrying the part with the tab added, or the first error.\n */\nexport function addTab(part: SheetMetalPart, spec: TabSpec): Result<SheetMetalPart> {\n  return addTabFn(part, spec);\n}\n\n/**\n * Self-fixturing tab-and-slot joint: a tab on one region + a matching slot on another.\n * @param part - the sheet-metal part to modify.\n * @param tab - the tab to add to the first region.\n * @param slot - placement of the matching slot on the second region.\n * @returns a `Result<SheetMetalPart>` carrying the part with the joint added, or the first error.\n */\nexport function tabAndSlot(\n  part: SheetMetalPart,\n  tab: TabSpec,\n  slot: SlotPlacement\n): Result<SheetMetalPart> {\n  return tabAndSlotFn(part, tab, slot);\n}\n\n/**\n * Form a louver (vent flap cut on 3 sides, formed up along the hinge) on a region.\n * @param part - the sheet-metal part to modify.\n * @param opts - louver geometry: target `region`, centre `(x, y)`, `length`, `width`, `height`, and optional `direction`.\n * @returns a `Result<SheetMetalPart>` carrying the part with the louver formed, or the first error.\n */\nexport function louver(\n  part: SheetMetalPart,\n  opts: {\n    region: string;\n    x: number;\n    y: number;\n    length: number;\n    width: number;\n    height: number;\n    direction?: 'up' | 'down';\n  }\n): Result<SheetMetalPart> {\n  return louverFn(part, opts);\n}\n\n/**\n * Form a round emboss (raised) or dimple (recessed) on a region.\n * @param part - the sheet-metal part to modify.\n * @param opts - emboss geometry: target `region`, centre `(x, y)`, `diameter`, `height`, and `kind` (`dimple` or `emboss`).\n * @returns a `Result<SheetMetalPart>` carrying the part with the form added, or the first error.\n */\nexport function emboss(\n  part: SheetMetalPart,\n  opts: { region: string; x: number; y: number; diameter: number; height: number; kind: 'dimple' | 'emboss' }\n): Result<SheetMetalPart> {\n  return embossFn(part, opts);\n}\n\n/**\n * Author a contour flange: an open line/arc profile swept along a base edge into a\n * multi-bend cross-section. The development is exact (Σ segment developed lengths).\n * @param part - the sheet-metal part the flange is added to.\n * @param spec - contour flange definition: profile, base edge, and bend parameters.\n * @returns a `Result<SheetMetalPart>` carrying the part with the contour flange added, or the first error.\n */\nexport function contourFlange(part: SheetMetalPart, spec: ContourFlangeSpec): Result<SheetMetalPart> {\n  return authorContourFlangeFn(part, spec);\n}\n\n/**\n * Author a lofted / ruled transition flange between two parallel open profiles. The\n * development is by triangulation — exact for a developable transition, an\n * approximation (with a `DEVELOPMENT_APPROXIMATE` unfold warning) otherwise.\n * @param part - the sheet-metal part the flange is added to.\n * @param spec - lofted flange definition: the two open profiles and their alignment.\n * @returns a `Result<SheetMetalPart>` carrying the part with the lofted flange added, or the first error.\n */\nexport function loftedFlange(part: SheetMetalPart, spec: LoftedFlangeSpec): Result<SheetMetalPart> {\n  return authorLoftedFlangeFn(part, spec);\n}\n\n/**\n * Author a hem: fold a region edge back ~180°+ onto its parent and run a short\n * return leg. The development is exact (Σ curl bend allowances + return length).\n * @param part - the sheet-metal part the hem is added to.\n * @param spec - hem definition: edge, curl radius, and return leg length.\n * @returns a `Result<SheetMetalPart>` carrying the part with the hem added, or the first error.\n */\nexport function hem(part: SheetMetalPart, spec: HemSpec): Result<SheetMetalPart> {\n  return hemFn(part, spec);\n}\n\n/**\n * Author a jog (joggle): two opposite bends stepping the flat by `offsetHeight`\n * perpendicular to its plane, then continuing parallel. Development is exact.\n * @param part - the sheet-metal part the jog is added to.\n * @param spec - jog definition: bend line, offset height, and radii.\n * @returns a `Result<SheetMetalPart>` carrying the part with the jog added, or the first error.\n */\nexport function jog(part: SheetMetalPart, spec: JogSpec): Result<SheetMetalPart> {\n  return jogFn(part, spec);\n}\n\n/**\n * Emit an annotated multi-layer DXF string for a flat pattern.\n * @param pattern - the flat pattern to serialize.\n * @param options - optional DXF output options (layers, precision, units).\n * @returns a `Result<string>` carrying the DXF text, or the first error.\n */\nexport function toDXF(pattern: FlatPattern, options?: DxfOptions): Result<string> {\n  return flatPatternToDXFFn(pattern, options);\n}\n\n/**\n * Nest developed flat patterns onto stock sheets to reduce waste. The default\n * `strategy: \"bbox\"` packs each part as its outline bounding box (fast, no\n * interlocking). `strategy: \"nfp\"` is true-shape / no-fit-polygon nesting: the actual\n * outline polygons are packed so concave (L-shaped) parts interlock for higher\n * utilization. The NFP packer is a HEURISTIC (bottom-left-fill) — not provably\n * optimal — but never overlaps parts and never drops a part silently.\n * @param patterns - the flat patterns to place onto stock sheets.\n * @param options - nesting configuration: stock sheet size, strategy, and spacing.\n * @returns a `Result<NestResult>` carrying the placed sheets and part transforms, or the first error.\n */\nexport function nest(patterns: FlatPattern[], options: NestOptions): Result<NestResult> {\n  return nestFn(patterns, options);\n}\n\n/**\n * Emit one fabrication-ready DXF for a single nested sheet (all parts placed).\n * @param result - the nesting result containing the sheet to render.\n * @param patterns - the original flat patterns referenced by `result`.\n * @param sheetIndex - index of the nested sheet to emit.\n * @param options - optional DXF output options (layers, precision, units).\n * @returns a `Result<string>` carrying the DXF text, or the first error.\n */\nexport function nestToDXF(\n  result: NestResult,\n  patterns: FlatPattern[],\n  sheetIndex: number,\n  options?: DxfOptions\n): Result<string> {\n  return nestToDXFFn(result, patterns, sheetIndex, options);\n}\n\n/**\n * Build a bend report by walking the part's feature tree.\n * @param part - the sheet-metal part to report on.\n * @returns a `Result<BendReport>` carrying the computed bend report, or the first error.\n */\nexport function report(part: SheetMetalPart): Result<BendReport> {\n  return buildReportFn(part);\n}\n\n/**\n * Project the report already computed by {@link unfold} without re-walking the tree.\n * @param result - the unfold result whose bend report is to be projected.\n * @returns a `Result<BendReport>` carrying the projected bend report, or the first error.\n */\nexport function reportFrom(result: UnfoldResult): Result<BendReport> {\n  return reportFromUnfoldFn(result);\n}\n\n/**\n * Serialize a bend report to stable pretty-printed JSON.\n * @param report - the bend report to serialize.\n * @returns the stable pretty-printed JSON string.\n */\nexport function reportJSON(report: BendReport): string {\n  return reportToJSONFn(report);\n}\n\n/**\n * Manufacturability checks — advisory warnings, never errors.\n * @param part - the sheet-metal part to check.\n * @returns the list of manufacturability warnings (empty when the part is clean).\n */\nexport function validate(part: SheetMetalPart): SheetMetalWarning[] {\n  return validatePartFn(part);\n}\n\n/**\n * Bend allowance `BA = (π/180)·|angle|·(R + K·T)` for a single bend.\n * @param angleDeg - the bend angle in degrees.\n * @param thickness - the material thickness, in the same units as the rule radii.\n * @param rule - the bend rule (K-factor, inner radius, or a bend-table reference) to apply.\n * @param onWarning - optional callback invoked for non-fatal warnings during the computation.\n * @returns a `Result<number>` carrying the bend allowance, or the first error.\n */\nexport function allowance(\n  angleDeg: number,\n  thickness: number,\n  rule: BendRule,\n  onWarning?: (warning: SheetMetalWarning) => void\n): Result<number> {\n  return bendAllowanceFn(angleDeg, thickness, rule, onWarning);\n}\n\n/**\n * Neutral-axis developed length of a bend region (numerically equal to the allowance).\n * @param angleDeg - the bend angle in degrees.\n * @param thickness - the material thickness, in the same units as the rule radii.\n * @param rule - the bend rule (K-factor, inner radius, or a bend-table reference) to apply.\n * @param onWarning - optional callback invoked for non-fatal warnings during the computation.\n * @returns a `Result<number>` carrying the developed length, or the first error.\n */\nexport function developed(\n  angleDeg: number,\n  thickness: number,\n  rule: BendRule,\n  onWarning?: (warning: SheetMetalWarning) => void\n): Result<number> {\n  return developedLengthFn(angleDeg, thickness, rule, onWarning);\n}\n\n/**\n * Register (or replace) a shop bend table so rules can reference it by id.\n * @param table - the bend table to register.\n * @returns a `Result<BendTable>` carrying the registered table, or the first error.\n */\nexport function addBendTable(table: BendTable): Result<BendTable> {\n  return registerBendTableFn(table);\n}\n\n/**\n * Look up a registered bend table by id (starter tables included).\n * @param id - the bend table id to look up.\n * @returns the matching `BendTable`, or `undefined` when no such table is registered.\n */\nexport function bendTable(id: string): BendTable | undefined {\n  return getBendTableFn(id);\n}\n\n/**\n * Resolve a bend's developed allowance through the single resolution point:\n * a referenced bend table, then an explicit `rule.allowance`, then the K-factor\n * formula. This is what {@link developed} delegates to.\n * @param rule - the bend rule (bend-table reference, explicit allowance, or K-factor) to resolve.\n * @param angleDeg - the bend angle in degrees.\n * @param thickness - the material thickness, in the same units as the rule radii.\n * @param onWarning - optional callback invoked for non-fatal warnings during the computation.\n * @returns a `Result<number>` carrying the resolved allowance, or the first error.\n */\nexport function resolveAllowance(\n  rule: BendRule,\n  angleDeg: number,\n  thickness: number,\n  onWarning?: (warning: SheetMetalWarning) => void\n): Result<number> {\n  return resolveBendAllowanceFn(rule, angleDeg, thickness, onWarning);\n}\n\nexport type { AuthorSpec, FlangeSpec, MiterPlane, DxfOptions, SlotPlacement, NestOptions, NestResult };\n\n/** The live bend-table registry (shared resource, §7.3). */\nexport { bendTables } from './bendTableFns.js';\n"]}

package/dist/authorFns.d.ts

@@ -0,0 +1,118 @@
+import { type Result, type Vec3 } from '@faicad/faijs/brepjs-compat';
+import type { BendRule, EdgeRef, FlatSide, MaterialSpec, MiterSpec, SheetMetalPart } from './types.js';
+import { type FeatureTree } from './featureTreeFns.js';
+/** Authoring options for the base flat the flanges attach to. */
+export interface BaseFlatSpec {
+    /** Extent along the run (+X) axis. */
+    length: number;
+    /** Extent along the width (+Y) axis. */
+    width: number;
+}
+/** Which edge a flange folds off (of the base, or of its parent flange). */
+export type FlangeSide = FlatSide;
+/** A single flange to author off an edge of its parent flat. */
+export interface FlangeSpec {
+    id: string;
+    /** Flat length measured from the end of the bend along the flange plane. */
+    length: number;
+    /** Signed fold angle in degrees. */
+    angleDeg: number;
+    rule: BendRule;
+    /** Parent edge to attach to. Default `'xmax'` (the leading +X edge). */
+    side?: FlangeSide | undefined;
+    /** Fold direction relative to the parent face normal. Default `'up'`. */
+    direction?: 'up' | 'down' | undefined;
+    /** Id of another flange this flange folds off (its distal edge). Default = base flat. */
+    parent?: string | undefined;
+    /** Start position along the parent edge. Default `0`. */
+    offset?: number | undefined;
+    /** Extent along the parent edge. Default = full parent-edge length. */
+    width?: number | undefined;
+    miter?: MiterSpec | undefined;
+}
+/**
+ * A seam: a bend connecting two already-authored flats that is intentionally left
+ * unfolded (a free edge). Closing the last wall of a box/tube back onto an earlier
+ * flat produces a cyclic feature graph; the feature tree turns this edge into a
+ * SEAM_CUT, and the unfold leaves the flats connected through the spanning tree.
+ */
+export interface SeamSpec {
+    /** Flat id the seam folds from (an authored flange, or `'root'`/`'face-0'` for the base). */
+    parent: string;
+    /** Flat id the seam meets (must already be authored; `'root'`/`'face-0'` = base). */
+    child: string;
+    angleDeg: number;
+    rule: BendRule;
+}
+/** Inputs for {@link authorPart}. */
+export interface AuthorSpec {
+    thickness: number;
+    base: BaseFlatSpec;
+    flanges: FlangeSpec[];
+    material?: MaterialSpec | undefined;
+    /** Optional seams that close a profile into a tube/box (left unfolded). */
+    seams?: SeamSpec[] | undefined;
+}
+/**
+ * Stable edge reference for flange attachment. The base flat is `face-0`; every
+ * flange face is `face-<n+1>` in authoring order. The leading edge of a flat is
+ * `edgeIndex 0`. The reference also carries `parentId`/`side`/`offset`/`extent`
+ * so the feature tree and recursive unfold can resolve the exact parent edge a
+ * flange folds from without reading topology back out of the B-rep.
+ *
+ * @param faceIndex - the face index of the flat: `0` for the base, `n+1` for the
+ *   flange authored in the `n`-th position.
+ * @returns an {@link EdgeRef} pointing at the flat's leading edge (`edgeIndex 0`).
+ */
+export declare function baseEdgeRef(faceIndex: number): EdgeRef;
+/**
+ * A flat in the part: the base, or a placed flange face. Each carries the world
+ * frame (origin + orthonormal axes) of its top surface so a child flange can be
+ * built directly off any of its four edges, at any fold direction.
+ */
+export interface FlatFrame {
+    id: string;
+    /** Near corner of the flat on its −normal (bottom) surface; the flat spans
+     * `thickness` along +n. Local `(x, y)` maps to `origin + x·u + y·v`. */
+    origin: Vec3;
+    /** In-plane direction; the flat spans `[0, uLen]` along it. */
+    u: Vec3;
+    /** In-plane direction; the flat spans `[0, vLen]` along it. */
+    v: Vec3;
+    /** Outward face normal of the top surface (n = u × v). */
+    n: Vec3;
+    uLen: number;
+    vLen: number;
+}
+/**
+ * Author a sheet-metal part: a base flat plus an arbitrary tree of flanges. Each
+ * flange folds off one of the four edges of its parent flat (the base by default,
+ * or another flange via `parent`), in the requested direction (up/down), over an
+ * optional sub-span of that edge (`offset`/`width`). Returns a {@link SheetMetalPart}
+ * carrying the folded 3D solid and the recorded bend feature tree the unfold
+ * consumes. All construction stays on the public, OCCT-WASM-safe API.
+ *
+ * @param spec - the authoring spec: sheet thickness, base flat dimensions, the
+ *   flange list, optional material, and optional closing seams.
+ * @returns a `Result<SheetMetalPart>` — `ok` with the folded part on success, or
+ *   `err` with a `validationError` for an invalid thickness / base / flange /
+ *   seam specification.
+ */
+export declare function authorPart(spec: AuthorSpec): Result<SheetMetalPart>;
+/**
+ * World {@link FlatFrame} of every flat region of an authored part, keyed by region
+ * id (`'root'` for the base). Reconstructed from the recorded bend/flange feature
+ * tree using the exact same edge/transform/child-frame math {@link authorPart} uses
+ * to place the geometry, so a cutout authored in a region's local `(x, y)` lands on
+ * the matching folded face. Walks the feature tree in BFS order so a chained
+ * flange's parent frame is always known first.
+ *
+ * @param part - the authored sheet-metal part whose flat regions to resolve.
+ * @param tree - optional pre-built {@link FeatureTree}; when omitted the tree is
+ *   reconstructed from `part` via {@link featureTree}.
+ * @returns a `Result<Map<string, FlatFrame>>` — `ok` with a map of region id
+ *   (`'root'` for the base, otherwise the flange id) to its world {@link FlatFrame},
+ *   or `err` when a flange's parent frame is missing from the tree.
+ */
+export declare function worldFrames(part: SheetMetalPart, tree?: FeatureTree): Result<Map<string, FlatFrame>>;
+//# sourceMappingURL=authorFns.d.ts.map

package/dist/authorFns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorFns.d.ts","sourceRoot":"","sources":["../src/authorFns.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,IAAI,EAoBV,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAEV,QAAQ,EAER,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EAA6B,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElF,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,4EAA4E;AAC5E,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC;AAElC,gEAAgE;AAChE,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;IACf,wEAAwE;IACxE,IAAI,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IAC9B,yEAAyE;IACzE,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC;IACtC,yFAAyF;IACzF,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CAC/B;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,6FAA6F;IAC7F,MAAM,EAAE,MAAM,CAAC;IACf,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,qCAAqC;AACrC,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,QAAQ,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;IACpC,2EAA2E;IAC3E,KAAK,CAAC,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX;4EACwE;IACxE,MAAM,EAAE,IAAI,CAAC;IACb,+DAA+D;IAC/D,CAAC,EAAE,IAAI,CAAC;IACR,+DAA+D;IAC/D,CAAC,EAAE,IAAI,CAAC;IACR,0DAA0D;IAC1D,CAAC,EAAE,IAAI,CAAC;IACR,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CA6GnE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,cAAc,EACpB,IAAI,CAAC,EAAE,WAAW,GACjB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAuChC"}