ducjs/dist/serialize.js

The duc 2D CAD file format is a cornerstone of our advanced design system, conceived to cater to professionals seeking precision and efficiency in their design work.

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
/* eslint-disable @typescript-eslint/consistent-type-definitions */
/* IMPORTANT:
   - Single-file serializer for DUC FlatBuffers schema.
   - No enum remapping tables: use enums directly from ducjs/flatbuffers/duc.
   - No defaults added: only write what's present in TS objects.
   - PrecisionValue, Radian, Percentage, ScaleFactor, etc. are branded numbers:
     cast to number at the final write site (e.g. pv.value).
   - Keep args strongly typed. Never use any for function args.
*/
import * as Duc from "./flatbuffers/duc";
import * as flatbuffers from "flatbuffers";
import { restore } from "./restore";
import { encodeFunctionString, EXPORT_DATA_TYPES } from "./utils";
/**
 * Basic helpers
 */
const str = (b, v) => v == null ? undefined : b.createString(v);
function writeString(builder, str) {
    if (str === null || str === undefined)
        return undefined;
    return builder.createString(str);
}
function getPrecisionValue(value, useScopedValues) {
    return useScopedValues ? value.scoped : value.value;
}
function writeStringVector(builder, items) {
    if (!items || items.length === 0)
        return undefined;
    const arr = Array.isArray(items) ? items.slice() : Array.from(items);
    const offsets = arr.map(item => (item ? builder.createString(item) : 0)).filter((offset) => offset !== 0);
    if (offsets.length === 0)
        return undefined;
    // This helper is used for multiple vector fields; return a builder vector; caller decides which create*Vector to use.
    // For current callers that expect createGroupIdsVector specifically, fallback to generic createVector via builder.start/endVector
    builder.startVector(4, offsets.length, 4);
    for (let i = offsets.length - 1; i >= 0; i--) {
        builder.addOffset(offsets[i]);
    }
    return builder.endVector();
}
/**
 * Element style/content serializers
 */
function writeTiling(b, t, usv) {
    if (!t)
        return undefined;
    Duc.TilingProperties.startTilingProperties(b);
    Duc.TilingProperties.addSizeInPercent(b, t.sizeInPercent);
    Duc.TilingProperties.addAngle(b, t.angle);
    if (t.spacing !== undefined)
        Duc.TilingProperties.addSpacing(b, t.spacing);
    if (t.offsetX !== undefined)
        Duc.TilingProperties.addOffsetX(b, t.offsetX);
    if (t.offsetY !== undefined)
        Duc.TilingProperties.addOffsetY(b, t.offsetY);
    return Duc.TilingProperties.endTilingProperties(b);
}
function writeHatchPatternLine(b, l, usv) {
    const origin = writeDucPoint(b, l.origin, usv);
    const offsetVec = Duc.HatchPatternLine.createOffsetVector(b, [getPrecisionValue(l.offset[0], usv), getPrecisionValue(l.offset[1], usv)]);
    const dashVec = Duc.HatchPatternLine.createDashPatternVector(b, l.dashPattern.map(Number));
    Duc.HatchPatternLine.startHatchPatternLine(b);
    Duc.HatchPatternLine.addAngle(b, l.angle);
    if (origin)
        Duc.HatchPatternLine.addOrigin(b, origin);
    Duc.HatchPatternLine.addOffset(b, offsetVec);
    if (dashVec)
        Duc.HatchPatternLine.addDashPattern(b, dashVec);
    return Duc.HatchPatternLine.endHatchPatternLine(b);
}
function writeCustomHatch(b, p, usv) {
    if (!p)
        return undefined;
    const name = str(b, p.name);
    const desc = str(b, p.description);
    const lines = Duc.CustomHatchPattern.createLinesVector(b, p.lines.map((ln) => writeHatchPatternLine(b, ln, usv)));
    Duc.CustomHatchPattern.startCustomHatchPattern(b);
    if (name)
        Duc.CustomHatchPattern.addName(b, name);
    if (desc)
        Duc.CustomHatchPattern.addDescription(b, desc);
    Duc.CustomHatchPattern.addLines(b, lines);
    return Duc.CustomHatchPattern.endCustomHatchPattern(b);
}
function writeHatchStyle(b, h, usv) {
    if (!h)
        return undefined;
    const pattName = str(b, h.pattern.name);
    const pattOrigin = writeDucPoint(b, h.pattern.origin, usv);
    const custom = writeCustomHatch(b, h.customPattern, usv);
    Duc.DucHatchStyle.startDucHatchStyle(b);
    if (h.hatchStyle !== undefined)
        Duc.DucHatchStyle.addHatchStyle(b, h.hatchStyle);
    if (pattName)
        Duc.DucHatchStyle.addPatternName(b, pattName);
    Duc.DucHatchStyle.addPatternScale(b, h.pattern.scale);
    Duc.DucHatchStyle.addPatternAngle(b, h.pattern.angle);
    if (pattOrigin)
        Duc.DucHatchStyle.addPatternOrigin(b, pattOrigin);
    Duc.DucHatchStyle.addPatternDouble(b, h.pattern.double);
    if (custom)
        Duc.DucHatchStyle.addCustomPattern(b, custom);
    return Duc.DucHatchStyle.endDucHatchStyle(b);
}
function writeImageFilter(b, f, usv) {
    if (!f)
        return undefined;
    Duc.DucImageFilter.startDucImageFilter(b);
    Duc.DucImageFilter.addBrightness(b, f.brightness);
    Duc.DucImageFilter.addContrast(b, f.contrast);
    return Duc.DucImageFilter.endDucImageFilter(b);
}
function writeContentBase(b, c, usv) {
    if (!c)
        return undefined;
    const s = str(b, c.src);
    const til = writeTiling(b, c.tiling, usv);
    const hatch = writeHatchStyle(b, c.hatch, usv);
    const filt = writeImageFilter(b, c.imageFilter, usv);
    Duc.ElementContentBase.startElementContentBase(b);
    if (c.preference !== undefined)
        Duc.ElementContentBase.addPreference(b, c.preference);
    if (s)
        Duc.ElementContentBase.addSrc(b, s);
    Duc.ElementContentBase.addVisible(b, c.visible);
    Duc.ElementContentBase.addOpacity(b, c.opacity);
    if (til)
        Duc.ElementContentBase.addTiling(b, til);
    if (hatch)
        Duc.ElementContentBase.addHatch(b, hatch);
    if (filt)
        Duc.ElementContentBase.addImageFilter(b, filt);
    return Duc.ElementContentBase.endElementContentBase(b);
}
function writeStrokeStyle(b, s, usv) {
    var _a;
    if (!s)
        return undefined;
    const dashVec = ((_a = s.dash) === null || _a === void 0 ? void 0 : _a.length) ? Duc.StrokeStyle.createDashVector(b, s.dash) : undefined;
    const dashLineOverride = str(b, s.dashLineOverride);
    Duc.StrokeStyle.startStrokeStyle(b);
    if (s.preference !== undefined)
        Duc.StrokeStyle.addPreference(b, s.preference);
    if (s.cap != null)
        Duc.StrokeStyle.addCap(b, s.cap);
    if (s.join != null)
        Duc.StrokeStyle.addJoin(b, s.join);
    if (dashVec)
        Duc.StrokeStyle.addDash(b, dashVec);
    if (dashLineOverride)
        Duc.StrokeStyle.addDashLineOverride(b, dashLineOverride);
    if (s.dashCap != null)
        Duc.StrokeStyle.addDashCap(b, s.dashCap);
    if (s.miterLimit !== undefined)
        Duc.StrokeStyle.addMiterLimit(b, s.miterLimit);
    return Duc.StrokeStyle.endStrokeStyle(b);
}
function writeStrokeSides(b, ss, usv) {
    var _a;
    if (!ss)
        return undefined;
    const valuesVec = ((_a = ss.values) === null || _a === void 0 ? void 0 : _a.length) ? Duc.StrokeSides.createValuesVector(b, ss.values) : undefined;
    Duc.StrokeSides.startStrokeSides(b);
    if (ss.preference !== undefined)
        Duc.StrokeSides.addPreference(b, ss.preference);
    if (valuesVec)
        Duc.StrokeSides.addValues(b, valuesVec);
    return Duc.StrokeSides.endStrokeSides(b);
}
function writeElementStroke(b, s, usv) {
    if (!s)
        return undefined;
    const c = writeContentBase(b, s.content, usv);
    const st = writeStrokeStyle(b, s.style, usv);
    const sides = writeStrokeSides(b, s.strokeSides, usv);
    Duc.ElementStroke.startElementStroke(b);
    if (c)
        Duc.ElementStroke.addContent(b, c);
    if (s.width) {
        Duc.ElementStroke.addWidth(b, getPrecisionValue(s.width, usv));
    }
    if (st)
        Duc.ElementStroke.addStyle(b, st);
    if (s.placement)
        Duc.ElementStroke.addPlacement(b, s.placement);
    if (sides)
        Duc.ElementStroke.addStrokeSides(b, sides);
    return Duc.ElementStroke.endElementStroke(b);
}
function writeElementBackground(b, bg, usv) {
    if (!bg)
        return undefined;
    const c = writeContentBase(b, bg.content, usv);
    Duc.ElementBackground.startElementBackground(b);
    if (c)
        Duc.ElementBackground.addContent(b, c);
    return Duc.ElementBackground.endElementBackground(b);
}
function writeStylesBase(b, s, usv) {
    if (!s)
        return null;
    const bgArrRaw = s.background;
    const stArrRaw = s.stroke;
    if (bgArrRaw === undefined || stArrRaw === undefined) {
        return null;
    }
    const bgArr = Array.isArray(bgArrRaw)
        ? bgArrRaw
        : (bgArrRaw ? [bgArrRaw] : []);
    const stArr = Array.isArray(stArrRaw)
        ? stArrRaw
        : (stArrRaw ? [stArrRaw] : []);
    const bgOffsets = bgArr
        .map((x) => (x ? writeElementBackground(b, x, usv) : undefined))
        .filter((o) => o !== undefined);
    const stOffsets = stArr
        .map((x) => (x ? writeElementStroke(b, x, usv) : undefined))
        .filter((o) => o !== undefined);
    const bgs = Duc._DucElementStylesBase.createBackgroundVector(b, bgOffsets);
    const strokes = Duc._DucElementStylesBase.createStrokeVector(b, stOffsets);
    Duc._DucElementStylesBase.start_DucElementStylesBase(b);
    if (s.roundness) {
        Duc._DucElementStylesBase.addRoundness(b, getPrecisionValue(s.roundness, usv));
    }
    if (s.blending)
        Duc._DucElementStylesBase.addBlending(b, s.blending);
    Duc._DucElementStylesBase.addBackground(b, bgs);
    Duc._DucElementStylesBase.addStroke(b, strokes);
    if (s.opacity) {
        Duc._DucElementStylesBase.addOpacity(b, s.opacity);
    }
    return Duc._DucElementStylesBase.end_DucElementStylesBase(b);
}
/**
 * Generic helpers
 */
function writeStringEntry(b, k, v) {
    const ko = b.createString(k);
    const vo = b.createString(v);
    Duc.StringValueEntry.startStringValueEntry(b);
    Duc.StringValueEntry.addKey(b, ko);
    Duc.StringValueEntry.addValue(b, vo);
    return Duc.StringValueEntry.endStringValueEntry(b);
}
function writeIdentifier(b, id) {
    var _a;
    const io = b.createString(id.id);
    const no = b.createString(id.name);
    const doff = b.createString((_a = id.description) !== null && _a !== void 0 ? _a : "");
    Duc.Identifier.startIdentifier(b);
    Duc.Identifier.addId(b, io);
    Duc.Identifier.addName(b, no);
    Duc.Identifier.addDescription(b, doff);
    return Duc.Identifier.endIdentifier(b);
}
/**
 * Geometry and bindings
 */
function writeDucPoint(b, p, usv) {
    if (!p)
        return undefined;
    Duc.DucPoint.startDucPoint(b);
    Duc.DucPoint.addX(b, getPrecisionValue(p.x, usv));
    Duc.DucPoint.addY(b, getPrecisionValue(p.y, usv));
    if (p.mirroring != null)
        Duc.DucPoint.addMirroring(b, p.mirroring);
    return Duc.DucPoint.endDucPoint(b);
}
function writeGeomPoint(b, p, usv) {
    if (!p)
        return undefined;
    return Duc.GeometricPoint.createGeometricPoint(b, p.x, p.y);
}
function writeHead(b, h, usv) {
    if (!h)
        return undefined;
    const blockId = str(b, h.blockId);
    Duc.DucHead.startDucHead(b);
    Duc.DucHead.addType(b, h.type);
    if (blockId)
        Duc.DucHead.addBlockId(b, blockId);
    Duc.DucHead.addSize(b, getPrecisionValue(h.size, usv));
    return Duc.DucHead.endDucHead(b);
}
function writeBindingPoint(b, p, usv) {
    if (!p)
        return undefined;
    Duc.PointBindingPoint.startPointBindingPoint(b);
    Duc.PointBindingPoint.addIndex(b, p.index);
    Duc.PointBindingPoint.addOffset(b, p.offset);
    return Duc.PointBindingPoint.endPointBindingPoint(b);
}
function writePointBinding(b, pb, usv) {
    if (!pb)
        return undefined;
    const el = str(b, pb.elementId);
    const fixed = pb.fixedPoint ? writeGeomPoint(b, pb.fixedPoint, usv) : undefined;
    const point = writeBindingPoint(b, pb.point, usv);
    const head = writeHead(b, pb.head, usv);
    Duc.DucPointBinding.startDucPointBinding(b);
    if (el)
        Duc.DucPointBinding.addElementId(b, el);
    Duc.DucPointBinding.addFocus(b, pb.focus);
    Duc.DucPointBinding.addGap(b, getPrecisionValue(pb.gap, usv));
    if (fixed)
        Duc.DucPointBinding.addFixedPoint(b, fixed);
    if (point)
        Duc.DucPointBinding.addPoint(b, point);
    if (head)
        Duc.DucPointBinding.addHead(b, head);
    return Duc.DucPointBinding.endDucPointBinding(b);
}
function writeLineRef(b, r, usv) {
    Duc.DucLineReference.startDucLineReference(b);
    Duc.DucLineReference.addIndex(b, r.index);
    if (r.handle) {
        const hx = getPrecisionValue(r.handle.x, usv);
        const hy = getPrecisionValue(r.handle.y, usv);
        const gp = Duc.GeometricPoint.createGeometricPoint(b, hx, hy);
        Duc.DucLineReference.addHandle(b, gp);
    }
    return Duc.DucLineReference.endDucLineReference(b);
}
function writeLine(b, l, usv) {
    const s = writeLineRef(b, l[0], usv);
    const e = writeLineRef(b, l[1], usv);
    Duc.DucLine.startDucLine(b);
    Duc.DucLine.addStart(b, s);
    Duc.DucLine.addEnd(b, e);
    return Duc.DucLine.endDucLine(b);
}
function writePath(b, p, usv) {
    const lineIndices = Duc.DucPath.createLineIndicesVector(b, p.lineIndices.map((x) => x));
    const bg = p.background ? writeElementBackground(b, p.background, usv) : undefined;
    const st = p.stroke ? writeElementStroke(b, p.stroke, usv) : undefined;
    Duc.DucPath.startDucPath(b);
    Duc.DucPath.addLineIndices(b, lineIndices);
    if (bg)
        Duc.DucPath.addBackground(b, bg);
    if (st)
        Duc.DucPath.addStroke(b, st);
    return Duc.DucPath.endDucPath(b);
}
/**
 * DucElement bases
 */
function writeBoundElement(b, be, usv) {
    const id = str(b, be.id);
    const type = str(b, be.type);
    Duc.BoundElement.startBoundElement(b);
    Duc.BoundElement.addId(b, id);
    Duc.BoundElement.addType(b, type);
    return Duc.BoundElement.endBoundElement(b);
}
function writeElementBase(b, e, usv) {
    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
    const id = str(b, e.id);
    const styles = writeStylesBase(b, e, usv);
    const scope = str(b, e.scope);
    const label = str(b, (_a = e.label) !== null && _a !== void 0 ? _a : undefined);
    const desc = str(b, (_b = e.description) !== null && _b !== void 0 ? _b : undefined);
    const index = str(b, (_c = e.index) !== null && _c !== void 0 ? _c : undefined);
    const groupIds = ((_d = e.groupIds) === null || _d === void 0 ? void 0 : _d.length) ? Duc._DucElementBase.createGroupIdsVector(b, e.groupIds.map((g) => b.createString(g))) : undefined;
    const regionIds = ((_e = e.regionIds) === null || _e === void 0 ? void 0 : _e.length) ? Duc._DucElementBase.createRegionIdsVector(b, e.regionIds.map((r) => b.createString(r))) : undefined;
    const layerId = str(b, (_f = e.layerId) !== null && _f !== void 0 ? _f : undefined);
    const frameId = str(b, (_g = e.frameId) !== null && _g !== void 0 ? _g : undefined);
    const bound = ((_h = e.boundElements) === null || _h === void 0 ? void 0 : _h.length) ? Duc._DucElementBase.createBoundElementsVector(b, e.boundElements.map((x) => writeBoundElement(b, x, usv))) : undefined;
    const link = str(b, (_j = e.link) !== null && _j !== void 0 ? _j : undefined);
    const custom = e.customData != null ? str(b, JSON.stringify(e.customData)) : undefined;
    Duc._DucElementBase.start_DucElementBase(b);
    if (id)
        Duc._DucElementBase.addId(b, id);
    if (styles)
        Duc._DucElementBase.addStyles(b, styles);
    Duc._DucElementBase.addX(b, getPrecisionValue(e.x, usv));
    Duc._DucElementBase.addY(b, getPrecisionValue(e.y, usv));
    Duc._DucElementBase.addWidth(b, getPrecisionValue(e.width, usv));
    Duc._DucElementBase.addHeight(b, getPrecisionValue(e.height, usv));
    Duc._DucElementBase.addAngle(b, e.angle);
    if (scope)
        Duc._DucElementBase.addScope(b, scope);
    if (label)
        Duc._DucElementBase.addLabel(b, label);
    if (desc)
        Duc._DucElementBase.addDescription(b, desc);
    Duc._DucElementBase.addIsVisible(b, e.isVisible);
    Duc._DucElementBase.addSeed(b, e.seed);
    Duc._DucElementBase.addVersion(b, e.version);
    Duc._DucElementBase.addVersionNonce(b, e.versionNonce);
    Duc._DucElementBase.addUpdated(b, BigInt(e.updated));
    if (index)
        Duc._DucElementBase.addIndex(b, index);
    Duc._DucElementBase.addIsPlot(b, e.isPlot);
    Duc._DucElementBase.addIsAnnotative(b, e.isAnnotative);
    Duc._DucElementBase.addIsDeleted(b, e.isDeleted);
    if (groupIds)
        Duc._DucElementBase.addGroupIds(b, groupIds);
    if (regionIds)
        Duc._DucElementBase.addRegionIds(b, regionIds);
    if (layerId)
        Duc._DucElementBase.addLayerId(b, layerId);
    if (frameId)
        Duc._DucElementBase.addFrameId(b, frameId);
    if (bound)
        Duc._DucElementBase.addBoundElements(b, bound);
    Duc._DucElementBase.addZIndex(b, e.zIndex);
    if (link)
        Duc._DucElementBase.addLink(b, link);
    Duc._DucElementBase.addLocked(b, e.locked);
    if (custom)
        Duc._DucElementBase.addCustomData(b, custom);
    return Duc._DucElementBase.end_DucElementBase(b);
}
function writeLinearBase(b, e, usv) {
    var _a, _b, _c;
    const base = writeElementBase(b, e, usv);
    // Type-safe guards without using any: default to empty arrays if undefined
    const pointsArr = (_a = e.points) !== null && _a !== void 0 ? _a : [];
    const linesArr = (_b = e.lines) !== null && _b !== void 0 ? _b : [];
    const pathOverridesArr = (_c = e.pathOverrides) !== null && _c !== void 0 ? _c : [];
    const points = Duc._DucLinearElementBase.createPointsVector(b, pointsArr.map((p) => writeDucPoint(b, p, usv)).filter((v) => v !== undefined));
    const lines = Duc._DucLinearElementBase.createLinesVector(b, linesArr.map((ln) => writeLine(b, ln, usv)));
    const pathOverrides = pathOverridesArr.length
        ? Duc._DucLinearElementBase.createPathOverridesVector(b, pathOverridesArr.map((p) => writePath(b, p, usv)))
        : undefined;
    const lastCommitted = writeDucPoint(b, e.lastCommittedPoint, usv);
    const startBinding = writePointBinding(b, e.startBinding, usv);
    const endBinding = writePointBinding(b, e.endBinding, usv);
    Duc._DucLinearElementBase.start_DucLinearElementBase(b);
    Duc._DucLinearElementBase.addBase(b, base);
    Duc._DucLinearElementBase.addPoints(b, points);
    Duc._DucLinearElementBase.addLines(b, lines);
    if (pathOverrides)
        Duc._DucLinearElementBase.addPathOverrides(b, pathOverrides);
    if (lastCommitted)
        Duc._DucLinearElementBase.addLastCommittedPoint(b, lastCommitted);
    if (startBinding)
        Duc._DucLinearElementBase.addStartBinding(b, startBinding);
    if (endBinding)
        Duc._DucLinearElementBase.addEndBinding(b, endBinding);
    return Duc._DucLinearElementBase.end_DucLinearElementBase(b);
}
/**
 * Elements
 */
function writeRect(b, e, usv) {
    const base = writeElementBase(b, e, usv);
    Duc.DucRectangleElement.startDucRectangleElement(b);
    Duc.DucRectangleElement.addBase(b, base);
    return Duc.DucRectangleElement.endDucRectangleElement(b);
}
function writePolygon(b, e, usv) {
    const base = writeElementBase(b, e, usv);
    Duc.DucPolygonElement.startDucPolygonElement(b);
    Duc.DucPolygonElement.addBase(b, base);
    Duc.DucPolygonElement.addSides(b, e.sides);
    return Duc.DucPolygonElement.endDucPolygonElement(b);
}
function writeEllipse(b, e, usv) {
    const base = writeElementBase(b, e, usv);
    Duc.DucEllipseElement.startDucEllipseElement(b);
    Duc.DucEllipseElement.addBase(b, base);
    Duc.DucEllipseElement.addRatio(b, e.ratio);
    Duc.DucEllipseElement.addStartAngle(b, e.startAngle);
    Duc.DucEllipseElement.addEndAngle(b, e.endAngle);
    Duc.DucEllipseElement.addShowAuxCrosshair(b, e.showAuxCrosshair);
    return Duc.DucEllipseElement.endDucEllipseElement(b);
}
function writeLinear(b, e, usv) {
    const base = writeLinearBase(b, e, usv);
    Duc.DucLinearElement.startDucLinearElement(b);
    Duc.DucLinearElement.addLinearBase(b, base);
    Duc.DucLinearElement.addWipeoutBelow(b, e.wipeoutBelow);
    return Duc.DucLinearElement.endDucLinearElement(b);
}
function writeArrow(b, e, usv) {
    const base = writeLinearBase(b, e, usv);
    Duc.DucArrowElement.startDucArrowElement(b);
    Duc.DucArrowElement.addLinearBase(b, base);
    Duc.DucArrowElement.addElbowed(b, e.elbowed);
    return Duc.DucArrowElement.endDucArrowElement(b);
}
function writeFreeDrawEnds(b, ends, usv) {
    if (!ends)
        return undefined;
    const easing = str(b, encodeFunctionString(ends.easing));
    Duc.DucFreeDrawEnds.startDucFreeDrawEnds(b);
    Duc.DucFreeDrawEnds.addCap(b, ends.cap);
    Duc.DucFreeDrawEnds.addTaper(b, ends.taper);
    if (easing)
        Duc.DucFreeDrawEnds.addEasing(b, easing);
    return Duc.DucFreeDrawEnds.endDucFreeDrawEnds(b);
}
function writeImageCrop(b, c) {
    if (!c)
        return undefined;
    Duc.ImageCrop.startImageCrop(b);
    Duc.ImageCrop.addX(b, c.x);
    Duc.ImageCrop.addY(b, c.y);
    Duc.ImageCrop.addWidth(b, c.width);
    Duc.ImageCrop.addHeight(b, c.height);
    Duc.ImageCrop.addNaturalWidth(b, c.naturalWidth);
    Duc.ImageCrop.addNaturalHeight(b, c.naturalHeight);
    return Duc.ImageCrop.endImageCrop(b);
}
function writeImage(b, e, usv) {
    const base = writeElementBase(b, e, usv);
    const fileId = str(b, e.fileId);
    const scaleVec = e.scaleFlip ? Duc.DucImageElement.createScaleVector(b, [e.scaleFlip[0], e.scaleFlip[1]]) : undefined;
    const crop = writeImageCrop(b, e.crop);
    const filter = writeImageFilter(b, e.filter, usv);
    Duc.DucImageElement.startDucImageElement(b);
    Duc.DucImageElement.addBase(b, base);
    if (fileId)
        Duc.DucImageElement.addFileId(b, fileId);
    if (e.status)
        Duc.DucImageElement.addStatus(b, e.status);
    if (scaleVec)
        Duc.DucImageElement.addScale(b, scaleVec);
    if (crop)
        Duc.DucImageElement.addCrop(b, crop);
    if (filter)
        Duc.DucImageElement.addFilter(b, filter);
    return Duc.DucImageElement.endDucImageElement(b);
}
function writeFreeDraw(b, e, usv) {
    const base = writeElementBase(b, e, usv);
    const pointsVec = e.points && e.points.length
        ? Duc.DucFreeDrawElement.createPointsVector(b, e.points.map((p) => writeDucPoint(b, p, usv)).filter((v) => v !== undefined))
        : Duc.DucFreeDrawElement.createPointsVector(b, []);
    const pressuresVec = e.pressures && e.pressures.length
        ? Duc.DucFreeDrawElement.createPressuresVector(b, e.pressures)
        : undefined;
    const easing = b.createString(encodeFunctionString(e.easing));
    const startEnds = writeFreeDrawEnds(b, e.start, usv);
    const endEnds = writeFreeDrawEnds(b, e.end, usv);
    const lcp = e.lastCommittedPoint ? writeDucPoint(b, e.lastCommittedPoint, usv) : undefined;
    const svgPath = e.svgPath ? b.createString(e.svgPath) : undefined;
    Duc.DucFreeDrawElement.startDucFreeDrawElement(b);
    Duc.DucFreeDrawElement.addBase(b, base);
    Duc.DucFreeDrawElement.addPoints(b, pointsVec);
    Duc.DucFreeDrawElement.addSize(b, getPrecisionValue(e.size, usv));
    Duc.DucFreeDrawElement.addThinning(b, e.thinning);
    Duc.DucFreeDrawElement.addSmoothing(b, e.smoothing);
    Duc.DucFreeDrawElement.addStreamline(b, e.streamline);
    if (easing)
        Duc.DucFreeDrawElement.addEasing(b, easing);
    if (startEnds)
        Duc.DucFreeDrawElement.addStart(b, startEnds);
    if (endEnds)
        Duc.DucFreeDrawElement.addEnd(b, endEnds);
    if (pressuresVec)
        Duc.DucFreeDrawElement.addPressures(b, pressuresVec);
    Duc.DucFreeDrawElement.addSimulatePressure(b, !!e.simulatePressure);
    if (lcp)
        Duc.DucFreeDrawElement.addLastCommittedPoint(b, lcp);
    if (svgPath)
        Duc.DucFreeDrawElement.addSvgPath(b, svgPath);
    return Duc.DucFreeDrawElement.endDucFreeDrawElement(b);
}
/**
 * Text
 */
function writeLineSpacing(b, ls, usv) {
    if (!ls)
        return undefined;
    Duc.LineSpacing.startLineSpacing(b);
    if (typeof ls.value === "number") {
        Duc.LineSpacing.addValue(b, ls.value);
    }
    else {
        Duc.LineSpacing.addValue(b, getPrecisionValue(ls.value, usv));
    }
    Duc.LineSpacing.addType(b, ls.type);
    return Duc.LineSpacing.endLineSpacing(b);
}
function writeTextStyle(b, s, usv) {
    const base = writeStylesBase(b, s, usv);
    const lineSpacing = writeLineSpacing(b, s.lineSpacing, usv);
    const fontFamily = str(b, s.fontFamily.toString());
    const bigFont = str(b, s.bigFontFamily);
    Duc.DucTextStyle.startDucTextStyle(b);
    if (base)
        Duc.DucTextStyle.addBaseStyle(b, base);
    Duc.DucTextStyle.addIsLtr(b, s.isLtr);
    if (fontFamily)
        Duc.DucTextStyle.addFontFamily(b, fontFamily);
    if (bigFont)
        Duc.DucTextStyle.addBigFontFamily(b, bigFont);
    if (s.textAlign !== undefined)
        Duc.DucTextStyle.addTextAlign(b, s.textAlign);
    if (s.verticalAlign !== undefined)
        Duc.DucTextStyle.addVerticalAlign(b, s.verticalAlign);
    Duc.DucTextStyle.addLineHeight(b, s.lineHeight);
    if (lineSpacing)
        Duc.DucTextStyle.addLineSpacing(b, lineSpacing);
    Duc.DucTextStyle.addObliqueAngle(b, s.obliqueAngle);
    Duc.DucTextStyle.addFontSize(b, getPrecisionValue(s.fontSize, usv));
    if (s.paperTextHeight !== undefined)
        Duc.DucTextStyle.addPaperTextHeight(b, getPrecisionValue(s.paperTextHeight, usv));
    Duc.DucTextStyle.addWidthFactor(b, s.widthFactor);
    Duc.DucTextStyle.addIsUpsideDown(b, s.isUpsideDown);
    Duc.DucTextStyle.addIsBackwards(b, s.isBackwards);
    return Duc.DucTextStyle.endDucTextStyle(b);
}
function writePrimaryUnits(b, units, usv) {
    if (!units)
        return undefined;
    // Linear
    Duc._UnitSystemBase.start_UnitSystemBase(b);
    Duc._UnitSystemBase.addSystem(b, units.linear.system);
    Duc._UnitSystemBase.addPrecision(b, units.linear.precision);
    Duc._UnitSystemBase.addSuppressLeadingZeros(b, units.linear.suppressLeadingZeros);
    Duc._UnitSystemBase.addSuppressTrailingZeros(b, units.linear.suppressTrailingZeros);
    const baseLinear = Duc._UnitSystemBase.end_UnitSystemBase(b);
    Duc.LinearUnitSystem.startLinearUnitSystem(b);
    Duc.LinearUnitSystem.addBase(b, baseLinear);
    Duc.LinearUnitSystem.addFormat(b, units.linear.format);
    Duc.LinearUnitSystem.addDecimalSeparator(b, units.linear.decimalSeparator);
    Duc.LinearUnitSystem.addSuppressZeroFeet(b, units.linear.suppressZeroFeet);
    Duc.LinearUnitSystem.addSuppressZeroInches(b, units.linear.suppressZeroInches);
    const linear = Duc.LinearUnitSystem.endLinearUnitSystem(b);
    // Angular
    Duc._UnitSystemBase.start_UnitSystemBase(b);
    Duc._UnitSystemBase.addSystem(b, units.angular.system);
    Duc._UnitSystemBase.addPrecision(b, units.angular.precision);
    Duc._UnitSystemBase.addSuppressLeadingZeros(b, units.angular.suppressLeadingZeros);
    Duc._UnitSystemBase.addSuppressTrailingZeros(b, units.angular.suppressTrailingZeros);
    const baseAngular = Duc._UnitSystemBase.end_UnitSystemBase(b);
    Duc.AngularUnitSystem.startAngularUnitSystem(b);
    Duc.AngularUnitSystem.addBase(b, baseAngular);
    Duc.AngularUnitSystem.addFormat(b, units.angular.format);
    const angular = Duc.AngularUnitSystem.endAngularUnitSystem(b);
    Duc.PrimaryUnits.startPrimaryUnits(b);
    Duc.PrimaryUnits.addLinear(b, linear);
    Duc.PrimaryUnits.addAngular(b, angular);
    return Duc.PrimaryUnits.endPrimaryUnits(b);
}
function writeTextDynamicSource(b, s, usv) {
    // discriminate by sourceType union ("element" | "dictionary")
    if (s.sourceType === Duc.TEXT_FIELD_SOURCE_TYPE.ELEMENT) {
        const el = str(b, s.elementId);
        const prop = s.property;
        Duc.DucTextDynamicElementSource.startDucTextDynamicElementSource(b);
        if (el)
            Duc.DucTextDynamicElementSource.addElementId(b, el);
        Duc.DucTextDynamicElementSource.addProperty(b, prop);
        const elem = Duc.DucTextDynamicElementSource.endDucTextDynamicElementSource(b);
        Duc.DucTextDynamicSource.startDucTextDynamicSource(b);
        Duc.DucTextDynamicSource.addTextSourceType(b, Duc.TEXT_FIELD_SOURCE_TYPE.ELEMENT);
        Duc.DucTextDynamicSource.addSourceType(b, Duc.DucTextDynamicSourceData.DucTextDynamicElementSource);
        Duc.DucTextDynamicSource.addSource(b, elem);
        return Duc.DucTextDynamicSource.endDucTextDynamicSource(b);
    }
    const key = str(b, s.key);
    Duc.DucTextDynamicDictionarySource.startDucTextDynamicDictionarySource(b);
    if (key)
        Duc.DucTextDynamicDictionarySource.addKey(b, key);
    const dict = Duc.DucTextDynamicDictionarySource.endDucTextDynamicDictionarySource(b);
    Duc.DucTextDynamicSource.startDucTextDynamicSource(b);
    Duc.DucTextDynamicSource.addTextSourceType(b, Duc.TEXT_FIELD_SOURCE_TYPE.DICTIONARY);
    Duc.DucTextDynamicSource.addSourceType(b, Duc.DucTextDynamicSourceData.DucTextDynamicDictionarySource);
    Duc.DucTextDynamicSource.addSource(b, dict);
    return Duc.DucTextDynamicSource.endDucTextDynamicSource(b);
}
function writeTextDynamicPart(b, p, usv) {
    const tag = str(b, p.tag);
    const src = writeTextDynamicSource(b, p.source, usv);
    const fmt = writePrimaryUnits(b, p.formatting, usv);
    const cached = str(b, p.cachedValue);
    Duc.DucTextDynamicPart.startDucTextDynamicPart(b);
    if (tag)
        Duc.DucTextDynamicPart.addTag(b, tag);
    Duc.DucTextDynamicPart.addSource(b, src);
    if (fmt)
        Duc.DucTextDynamicPart.addFormatting(b, fmt);
    if (cached)
        Duc.DucTextDynamicPart.addCachedValue(b, cached);
    return Duc.DucTextDynamicPart.endDucTextDynamicPart(b);
}
function writeTextColumn(b, c, usv) {
    Duc.TextColumn.startTextColumn(b);
    Duc.TextColumn.addWidth(b, getPrecisionValue(c.width, usv));
    Duc.TextColumn.addGutter(b, getPrecisionValue(c.gutter, usv));
    return Duc.TextColumn.endTextColumn(b);
}
function writeParagraphFormatting(b, p, usv) {
    const tabs = Duc.ParagraphFormatting.createTabStopsVector(b, p.tabStops.map((t) => getPrecisionValue(t, usv)));
    Duc.ParagraphFormatting.startParagraphFormatting(b);
    Duc.ParagraphFormatting.addFirstLineIndent(b, getPrecisionValue(p.firstLineIndent, usv));
    Duc.ParagraphFormatting.addHangingIndent(b, getPrecisionValue(p.hangingIndent, usv));
    Duc.ParagraphFormatting.addLeftIndent(b, getPrecisionValue(p.leftIndent, usv));
    Duc.ParagraphFormatting.addRightIndent(b, getPrecisionValue(p.rightIndent, usv));
    Duc.ParagraphFormatting.addSpaceBefore(b, getPrecisionValue(p.spaceBefore, usv));
    Duc.ParagraphFormatting.addSpaceAfter(b, getPrecisionValue(p.spaceAfter, usv));
    Duc.ParagraphFormatting.addTabStops(b, tabs);
    return Duc.ParagraphFormatting.endParagraphFormatting(b);
}
function writeStackFormat(b, s, usv) {
    const chars = Duc.StackFormat.createStackCharsVector(b, [...s.stackChars].map((c) => b.createString(c)));
    Duc.StackFormatProperties.startStackFormatProperties(b);
    Duc.StackFormatProperties.addUpperScale(b, s.properties.upperScale);
    Duc.StackFormatProperties.addLowerScale(b, s.properties.lowerScale);
    Duc.StackFormatProperties.addAlignment(b, s.properties.alignment);
    const props = Duc.StackFormatProperties.endStackFormatProperties(b);
    Duc.StackFormat.startStackFormat(b);
    Duc.StackFormat.addAutoStack(b, s.autoStack);
    Duc.StackFormat.addStackChars(b, chars);
    Duc.StackFormat.addProperties(b, props);
    return Duc.StackFormat.endStackFormat(b);
}
function writeDocStyle(b, s, usv) {
    const text = writeTextStyle(b, s, usv);
    const para = writeParagraphFormatting(b, s.paragraph, usv);
    const stack = writeStackFormat(b, s.stackFormat, usv);
    Duc.DucDocStyle.startDucDocStyle(b);
    Duc.DucDocStyle.addTextStyle(b, text);
    Duc.DucDocStyle.addParagraph(b, para);
    Duc.DucDocStyle.addStackFormat(b, stack);
    return Duc.DucDocStyle.endDucDocStyle(b);
}
function writeColumnLayout(b, c, usv) {
    const defs = Duc.ColumnLayout.createDefinitionsVector(b, c.definitions.map((d) => writeTextColumn(b, d, usv)));
    Duc.ColumnLayout.startColumnLayout(b);
    Duc.ColumnLayout.addType(b, c.type);
    Duc.ColumnLayout.addDefinitions(b, defs);
    Duc.ColumnLayout.addAutoHeight(b, c.autoHeight);
    return Duc.ColumnLayout.endColumnLayout(b);
}
function writeText(b, e, usv) {
    var _a;
    const base = writeElementBase(b, e, usv);
    const style = writeTextStyle(b, e, usv);
    const text = str(b, e.text);
    const dynamic = Duc.DucTextElement.createDynamicVector(b, e.dynamic.map((d) => writeTextDynamicPart(b, d, usv)));
    const containerId = str(b, (_a = e.containerId) !== null && _a !== void 0 ? _a : undefined);
    const original = str(b, e.originalText);
    Duc.DucTextElement.startDucTextElement(b);
    Duc.DucTextElement.addBase(b, base);
    Duc.DucTextElement.addStyle(b, style);
    if (text)
        Duc.DucTextElement.addText(b, text);
    Duc.DucTextElement.addDynamic(b, dynamic);
    Duc.DucTextElement.addAutoResize(b, e.autoResize);
    if (containerId)
        Duc.DucTextElement.addContainerId(b, containerId);
    if (original)
        Duc.DucTextElement.addOriginalText(b, original);
    return Duc.DucTextElement.endDucTextElement(b);
}
/**
 * Blocks
 */
function writeBlockAttrDef(b, d, usv) {
    const tag = b.createString(d.tag);
    const prompt = b.createString(d.prompt);
    const defVal = b.createString(d.defaultValue);
    Duc.DucBlockAttributeDefinition.startDucBlockAttributeDefinition(b);
    Duc.DucBlockAttributeDefinition.addTag(b, tag);
    Duc.DucBlockAttributeDefinition.addPrompt(b, prompt);
    Duc.DucBlockAttributeDefinition.addDefaultValue(b, defVal);
    Duc.DucBlockAttributeDefinition.addIsConstant(b, d.isConstant);
    return Duc.DucBlockAttributeDefinition.endDucBlockAttributeDefinition(b);
}
function writeBlock(b, bl, usv) {
    var _a, _b;
    const id = b.createString(bl.id);
    const label = b.createString(bl.label);
    const desc = b.createString((_a = bl.description) !== null && _a !== void 0 ? _a : "");
    const elems = Duc.DucBlock.createElementsVector(b, bl.elements.map((el) => writeElementWrapper(b, el, usv)));
    const defs = Duc.DucBlock.createAttributeDefinitionsVector(b, Object.entries((_b = bl.attributeDefinitions) !== null && _b !== void 0 ? _b : {}).map(([k, v]) => {
        const key = b.createString(k);
        const val = writeBlockAttrDef(b, v, usv);
        Duc.DucBlockAttributeDefinitionEntry.startDucBlockAttributeDefinitionEntry(b);
        Duc.DucBlockAttributeDefinitionEntry.addKey(b, key);
        Duc.DucBlockAttributeDefinitionEntry.addValue(b, val);
        return Duc.DucBlockAttributeDefinitionEntry.endDucBlockAttributeDefinitionEntry(b);
    }));
    Duc.DucBlock.startDucBlock(b);
    Duc.DucBlock.addId(b, id);
    Duc.DucBlock.addLabel(b, label);
    Duc.DucBlock.addDescription(b, desc);
    Duc.DucBlock.addVersion(b, bl.version);
    Duc.DucBlock.addElements(b, elems);
    Duc.DucBlock.addAttributeDefinitions(b, defs);
    return Duc.DucBlock.endDucBlock(b);
}
function writeBlockInstance(b, e, usv) {
    var _a, _b;
    const base = writeElementBase(b, e, usv);
    const blockId = b.createString(e.blockId);
    const overrides = Duc.DucBlockInstanceElement.createElementOverridesVector(b, Object.entries((_a = e.elementOverrides) !== null && _a !== void 0 ? _a : {}).map(([k, v]) => writeStringEntry(b, k, v)));
    const attrs = Duc.DucBlockInstanceElement.createAttributeValuesVector(b, Object.entries((_b = e.attributeValues) !== null && _b !== void 0 ? _b : {}).map(([k, v]) => writeStringEntry(b, k, v)));
    const dup = e.duplicationArray
        ? (() => {
            Duc.DucBlockDuplicationArray.startDucBlockDuplicationArray(b);
            Duc.DucBlockDuplicationArray.addRows(b, e.duplicationArray.rows);
            Duc.DucBlockDuplicationArray.addCols(b, e.duplicationArray.cols);
            Duc.DucBlockDuplicationArray.addRowSpacing(b, getPrecisionValue(e.duplicationArray.rowSpacing, usv));
            Duc.DucBlockDuplicationArray.addColSpacing(b, getPrecisionValue(e.duplicationArray.colSpacing, usv));
            return Duc.DucBlockDuplicationArray.endDucBlockDuplicationArray(b);
        })()
        : undefined;
    Duc.DucBlockInstanceElement.startDucBlockInstanceElement(b);
    Duc.DucBlockInstanceElement.addBase(b, base);
    Duc.DucBlockInstanceElement.addBlockId(b, blockId);
    if (overrides)
        Duc.DucBlockInstanceElement.addElementOverrides(b, overrides);
    if (attrs)
        Duc.DucBlockInstanceElement.addAttributeValues(b, attrs);
    if (dup)
        Duc.DucBlockInstanceElement.addDuplicationArray(b, dup);
    return Duc.DucBlockInstanceElement.endDucBlockInstanceElement(b);
}
/**
 * Stack containers
 */
function writeStackLikeStyles(b, s, usv) {
    const color = b.createString(s.labelingColor);
    Duc.DucStackLikeStyles.startDucStackLikeStyles(b);
    Duc.DucStackLikeStyles.addOpacity(b, s.opacity);
    Duc.DucStackLikeStyles.addLabelingColor(b, color);
    return Duc.DucStackLikeStyles.endDucStackLikeStyles(b);
}
function writeStackBase(b, s, usv) {
    var _a;
    const label = b.createString(s.label);
    const desc = str(b, (_a = s.description) !== null && _a !== void 0 ? _a : undefined);
    const styles = writeStackLikeStyles(b, s, usv);
    Duc._DucStackBase.start_DucStackBase(b);
    Duc._DucStackBase.addLabel(b, label);
    if (desc)
        Duc._DucStackBase.addDescription(b, desc);
    Duc._DucStackBase.addIsCollapsed(b, s.isCollapsed);
    Duc._DucStackBase.addIsPlot(b, s.isPlot);
    Duc._DucStackBase.addIsVisible(b, s.isVisible);
    Duc._DucStackBase.addLocked(b, s.locked);
    Duc._DucStackBase.addStyles(b, styles);
    return Duc._DucStackBase.end_DucStackBase(b);
}
function writeStackElementBase(b, s, usv) {
    const base = writeElementBase(b, s, usv);
    const stackBase = writeStackBase(b, s, usv);
    const std = str(b, s.standardOverride);
    Duc._DucStackElementBase.start_DucStackElementBase(b);
    Duc._DucStackElementBase.addBase(b, base);
    Duc._DucStackElementBase.addStackBase(b, stackBase);
    Duc._DucStackElementBase.addClip(b, s.clip);
    Duc._DucStackElementBase.addLabelVisible(b, s.labelVisible);
    if (std)
        Duc._DucStackElementBase.addStandardOverride(b, std);
    return Duc._DucStackElementBase.end_DucStackElementBase(b);
}
function writeFrame(b, e, usv) {
    const base = writeStackElementBase(b, e, usv);
    Duc.DucFrameElement.startDucFrameElement(b);
    Duc.DucFrameElement.addStackElementBase(b, base);
    return Duc.DucFrameElement.endDucFrameElement(b);
}
function writePlotLayout(b, l, usv) {
    Duc.Margins.startMargins(b);
    Duc.Margins.addTop(b, getPrecisionValue(l.margins.top, usv));
    Duc.Margins.addRight(b, getPrecisionValue(l.margins.right, usv));
    Duc.Margins.addBottom(b, getPrecisionValue(l.margins.bottom, usv));
    Duc.Margins.addLeft(b, getPrecisionValue(l.margins.left, usv));
    const margins = Duc.Margins.endMargins(b);
    Duc.PlotLayout.startPlotLayout(b);
    Duc.PlotLayout.addMargins(b, margins);
    return Duc.PlotLayout.endPlotLayout(b);
}
function writePlot(b, e, usv) {
    const stackBase = writeStackElementBase(b, e, usv);
    const baseStyle = writeStylesBase(b, e, usv);
    const plotStyle = (() => {
        Duc.DucPlotStyle.startDucPlotStyle(b);
        if (baseStyle)
            Duc.DucPlotStyle.addBaseStyle(b, baseStyle);
        return Duc.DucPlotStyle.endDucPlotStyle(b);
    })();
    const layout = writePlotLayout(b, e.layout, usv);
    Duc.DucPlotElement.startDucPlotElement(b);
    Duc.DucPlotElement.addStackElementBase(b, stackBase);
    Duc.DucPlotElement.addStyle(b, plotStyle);
    Duc.DucPlotElement.addLayout(b, layout);
    return Duc.DucPlotElement.endDucPlotElement(b);
}
/**
 * Views / Viewports / XRay
 */
function writeView(b, v, usv) {
    const center = writeDucPoint(b, v.centerPoint, usv);
    const scope = b.createString(v.scope);
    Duc.DucView.startDucView(b);
    Duc.DucView.addScrollX(b, getPrecisionValue(v.scrollX, usv));
    Duc.DucView.addScrollY(b, getPrecisionValue(v.scrollY, usv));
    Duc.DucView.addZoom(b, v.zoom.value);
    Duc.DucView.addTwistAngle(b, v.twistAngle);
    if (center)
        Duc.DucView.addCenterPoint(b, center);
    Duc.DucView.addScope(b, scope);
    return Duc.DucView.endDucView(b);
}
function writeViewportStyle(b, s, usv) {
    const base = writeStylesBase(b, s, usv);
    Duc.DucViewportStyle.startDucViewportStyle(b);
    if (base)
        Duc.DucViewportStyle.addBaseStyle(b, base);
    Duc.DucViewportStyle.addScaleIndicatorVisible(b, s.scaleIndicatorVisible);
    return Duc.DucViewportStyle.endDucViewportStyle(b);
}
function writeViewport(b, e, usv) {
    var _a;
    const linear = writeLinearBase(b, e, usv);
    const stackBase = writeStackBase(b, e, usv);
    const style = writeViewportStyle(b, e, usv);
    const view = writeView(b, e.view, usv);
    const frozen = ((_a = e.frozenGroupIds) === null || _a === void 0 ? void 0 : _a.length) ? Duc.DucViewportElement.createFrozenGroupIdsVector(b, e.frozenGroupIds.map((id) => b.createString(id))) : undefined;
    const std = str(b, e.standardOverride);
    Duc.DucViewportElement.startDucViewportElement(b);
    Duc.DucViewportElement.addLinearBase(b, linear);
    Duc.DucViewportElement.addStackBase(b, stackBase);
    Duc.DucViewportElement.addStyle(b, style);
    Duc.DucViewportElement.addView(b, view);
    Duc.DucViewportElement.addScale(b, e.scale);
    if (e.shadePlot !== undefined)
        Duc.DucViewportElement.addShadePlot(b, e.shadePlot);
    if (frozen)
        Duc.DucViewportElement.addFrozenGroupIds(b, frozen);
    if (std)
        Duc.DucViewportElement.addStandardOverride(b, std);
    return Duc.DucViewportElement.endDucViewportElement(b);
}
function writeXRayStyle(b, s, usv) {
    const base = writeStylesBase(b, s, usv);
    const color = b.createString(s.color);
    Duc.DucXRayStyle.startDucXRayStyle(b);
    if (base)
        Duc.DucXRayStyle.addBaseStyle(b, base);
    Duc.DucXRayStyle.addColor(b, color);
    return Duc.DucXRayStyle.endDucXRayStyle(b);
}
function writeXRay(b, e, usv) {
    const base = writeElementBase(b, e, usv);
    const style = writeXRayStyle(b, e, usv);
    const origin = writeDucPoint(b, e.origin, usv);
    const direction = writeDucPoint(b, e.direction, usv);
    Duc.DucXRayElement.startDucXRayElement(b);
    Duc.DucXRayElement.addBase(b, base);
    Duc.DucXRayElement.addStyle(b, style);
    if (origin)
        Duc.DucXRayElement.addOrigin(b, origin);
    if (direction)
        Duc.DucXRayElement.addDirection(b, direction);
    Duc.DucXRayElement.addStartFromOrigin(b, e.startFromOrigin);
    return Duc.DucXRayElement.endDucXRayElement(b);
}
/**
 * Leader & Dimension & FCF
 */
function writeLeaderContent(b, c, usv) {
    var _a, _b;
    if (!c)
        return undefined;
    let contentOffset;
    let contentType;
    if (c.type === "text") {
        const text = b.createString(c.text);
        Duc.LeaderTextBlockContent.startLeaderTextBlockContent(b);
        Duc.LeaderTextBlockContent.addText(b, text);
        contentOffset = Duc.LeaderTextBlockContent.endLeaderTextBlockContent(b);
        contentType = Duc.LeaderContentData.LeaderTextBlockContent;
    }
    else {
        const attrs = Duc.LeaderBlockContent.createAttributeValuesVector(b, Object.entries((_a = c.instanceData.attributeValues) !== null && _a !== void 0 ? _a : {}).map(([k, v]) => writeStringEntry(b, k, v)));
        const overrides = Duc.LeaderBlockContent.createElementOverridesVector(b, Object.entries((_b = c.instanceData.elementOverrides) !== null && _b !== void 0 ? _b : {}).map(([k, v]) => writeStringEntry(b, k, v)));
        const blockId = b.createString(c.blockId);
        Duc.LeaderBlockContent.startLeaderBlockContent(b);
        Duc.LeaderBlockContent.addBlockId(b, blockId);
        if (attrs)
            Duc.LeaderBlockContent.addAttributeValues(b, attrs);
        if (overrides)
            Duc.LeaderBlockContent.addElementOverrides(b, overrides);
        contentOffset = Duc.LeaderBlockContent.endLeaderBlockContent(b);
        contentType = Duc.LeaderContentData.LeaderBlockContent;
    }
    Duc.LeaderContent.startLeaderContent(b);
    Duc.LeaderContent.addLeaderContentType(b, Duc.LEADER_CONTENT_TYPE[c.type.toUpperCase()]);
    Duc.LeaderContent.addContentType(b, contentType);
    Duc.LeaderContent.addContent(b, contentOffset);
    return Duc.LeaderContent.endLeaderContent(b);
}
function writeLeaderStyle(b, s, usv) {
    const base = writeStylesBase(b, s, usv);
    const text = writeTextStyle(b, s.textStyle, usv);
    const heads = s.headsOverride ? Duc.DucLeaderStyle.createHeadsOverrideVector(b, s.headsOverride.map((h) => writeHead(b, h, usv))) : undefined;
    Duc.DucLeaderStyle.startDucLeaderStyle(b);
    if (base)
        Duc.DucLeaderStyle.addBaseStyle(b, base);
    if (heads)
        Duc.DucLeaderStyle.addHeadsOverride(b, heads);
    if (s.dogleg !== undefined)
        Duc.DucLeaderStyle.addDogleg(b, getPrecisionValue(s.dogleg, usv));
    Duc.DucLeaderStyle.addTextStyle(b, text);
    if (s.textAttachment !== undefined)
        Duc.DucLeaderStyle.addTextAttachment(b, s.textAttachment);
    if (s.blockAttachment !== undefined)
        Duc.DucLeaderStyle.addBlockAttachment(b, s.blockAttachment);
    return Duc.DucLeaderStyle.endDucLeaderStyle(b);
}
function writeLeader(b, e, usv) {
    const linear = writeLinearBase(b, e, usv);
    const style = writeLeaderStyle(b, e, usv);
    const content = writeLeaderContent(b, e.leaderContent, usv);
    const anchor = writeGeomPoint(b, e.contentAnchor, usv);
    Duc.DucLeaderElement.startDucLeaderElement(b);
    Duc.DucLeaderElement.addLinearBase(b, linear);
    Duc.DucLeaderElement.addStyle(b, style);
    if (content)
        Duc.DucLeaderElement.addContent(b, content);
    if (anchor)
        Duc.DucLeaderElement.addContentAnchor(b, anchor);
    return Duc.DucLeaderElement.endDucLeaderElement(b);
}
function writeDimDefPoints(b, d, usv) {
    const o1 = writeGeomPoint(b, d.origin1, usv);
    const o2 = d.origin2 ? writeGeomPoint(b, d.origin2, usv) : undefined;
    const loc = writeGeomPoint(b, d.location, usv);
    const center = d.center ? writeGeomPoint(b, d.center, usv) : undefined;
    const jog = d.jog ? writeGeomPoint(b, d.jog, usv) : undefined;
    Duc.DimensionDefinitionPoints.startDimensionDefinitionPoints(b);
    if (o1)
        Duc.DimensionDefinitionPoints.addOrigin1(b, o1);
    if (o2)
        Duc.DimensionDefinitionPoints.addOrigin2(b, o2);
    if (loc)
        Duc.DimensionDefinitionPoints.addLocation(b, loc);
    if (center)
        Duc.DimensionDefinitionPoints.addCenter(b, center);
    if (jog)
        Duc.DimensionDefinitionPoints.addJog(b, jog);
    return Duc.DimensionDefinitionPoints.endDimensionDefinitionPoints(b);
}
function writeDimBindings(b, d, usv) {
    if (!d)
        return undefined;
    const o1 = d.origin1 ? writePointBinding(b, d.origin1, usv) : undefined;
    const o2 = d.origin2 ? writePointBinding(b, d.origin2, usv) : undefined;
    const c = d.center ? writePointBinding(b, d.center, usv) : undefined;
    Duc.DimensionBindings.startDimensionBindings(b);
    if (o1)
        Duc.DimensionBindings.addOrigin1(b, o1);
    if (o2)
        Duc.DimensionBindings.addOrigin2(b, o2);
    if (c)
        Duc.DimensionBindings.addCenter(b, c);
    return Duc.DimensionBindings.endDimensionBindings(b);
}
function writeDimTolStyle(b, t, usv) {
    const textStyle = writeTextStyle(b, t.textStyle, usv);
    Duc.DimensionToleranceStyle.startDimensionToleranceStyle(b);
    Duc.DimensionToleranceStyle.addEnabled(b, t.enabled);
    Duc.DimensionToleranceStyle.addDisplayMethod(b, t.displayMethod);
    Duc.DimensionToleranceStyle.addUpperValue(b, t.upperValue);
    Duc.DimensionToleranceStyle.addLowerValue(b, t.lowerValue);
    Duc.DimensionToleranceStyle.addPrecision(b, t.precision);
    Duc.DimensionToleranceStyle.addTextStyle(b, textStyle);
    return Duc.DimensionToleranceStyle.endDimensionToleranceStyle(b);
}
function writeDimLineStyle(b, s, usv) {
    const st = writeElementStroke(b, s.stroke, usv);
    Duc.DimensionLineStyle.startDimensionLineStyle(b);
    if (st)
        Duc.DimensionLineStyle.addStroke(b, st);
    Duc.DimensionLineStyle.addTextGap(b, getPrecisionValue(s.textGap, usv));
    return Duc.DimensionLineStyle.endDimensionLineStyle(b);
}
function writeExtLineStyle(b, s, usv) {
    const st = writeElementStroke(b, s.stroke, usv);
    Duc.DimensionExtLineStyle.startDimensionExtLineStyle(b);
    if (st)
        Duc.DimensionExtLineStyle.addStroke(b, st);
    Duc.DimensionExtLineStyle.addOvershoot(b, getPrecisionValue(s.overshoot, usv));
    Duc.DimensionExtLineStyle.addOffset(b, getPrecisionValue(s.offset, usv));
    return Duc.DimensionExtLineStyle.endDimensionExtLineStyle(b);
}
function writeDimSymbolStyle(b, s, usv) {
    const heads = s.headsOverride ? Duc.DimensionSymbolStyle.createHeadsOverrideVector(b, s.headsOverride.map((h) => writeHead(b, h, usv))) : undefined;
    Duc.DimensionSymbolStyle.startDimensionSymbolStyle(b);
    if (heads)
        Duc.DimensionSymbolStyle.addHeadsOverride(b, heads);
    Duc.DimensionSymbolStyle.addCenterMarkType(b, s.centerMark.type);
    Duc.DimensionSymbolStyle.addCenterMarkSize(b, getPrecisionValue(s.centerMark.size, usv));
    return Duc.DimensionSymbolStyle.endDimensionSymbolStyle(b);
}
function writeDimStyle(b, s, usv) {
    const dim = writeDimLineStyle(b, s.dimLine, usv);
    const ext = writeExtLineStyle(b, s.extLine, usv);
    const text = writeTextStyle(b, s.textStyle, usv);
    const sym = writeDimSymbolStyle(b, s.symbols, usv);
    const tol = writeDimTo