ts-d2 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -0,0 +1,896 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/Border/index.ts
+import Proto from "docframe-types";
+var Border = class {
+  constructor(width, color) {
+    this.width = width;
+    this.color = color;
+  }
+  toDocFrame() {
+    return new Proto.ProtoBorder({
+      weight: this.width.toDocFrame(),
+      color: this.color.toDocFrame()
+    });
+  }
+};
+var SideBorders = class {
+  constructor(settings) {
+    this.value = settings;
+  }
+  toDocFrame() {
+    var _a, _b, _c, _d;
+    return new Proto.ProtoSideBorders({
+      top: (_a = this.value.top) == null ? void 0 : _a.toDocFrame(),
+      right: (_b = this.value.right) == null ? void 0 : _b.toDocFrame(),
+      bottom: (_c = this.value.bottom) == null ? void 0 : _c.toDocFrame(),
+      left: (_d = this.value.left) == null ? void 0 : _d.toDocFrame()
+    });
+  }
+};
+
+// src/Color/index.ts
+import Proto2 from "docframe-types";
+var Color = class _Color {
+  static rgb(r, g, b) {
+    if (r < 0 || r > 255) {
+      throw new Error(`Invalid red value: ${r}`);
+    }
+    if (g < 0 || g > 255) {
+      throw new Error(`Invalid green value: ${g}`);
+    }
+    if (b < 0 || b > 255) {
+      throw new Error(`Invalid blue value: ${b}`);
+    }
+    return new _Color(Proto2.ProtoColor.create({
+      type: Proto2.ProtoColorType.RGB,
+      r,
+      g,
+      b
+    }));
+  }
+  static cmyk(c, m, y, k) {
+    if (c < 0 || c > 100) {
+      throw new Error(`Invalid cyan value: ${c}`);
+    }
+    if (m < 0 || m > 100) {
+      throw new Error(`Invalid magenta value: ${m}`);
+    }
+    if (y < 0 || y > 100) {
+      throw new Error(`Invalid yellow value: ${y}`);
+    }
+    if (k < 0 || k > 100) {
+      throw new Error(`Invalid black value: ${k}`);
+    }
+    return new _Color(Proto2.ProtoColor.create({
+      type: Proto2.ProtoColorType.CMYK,
+      c,
+      m,
+      y,
+      k
+    }));
+  }
+  static fromHex(hex) {
+    if (hex.startsWith("#")) {
+      hex = hex.slice(1);
+    }
+    if (hex.length !== 6) {
+      throw new Error(`Invalid hex color: ${hex}`);
+    }
+    const r = parseInt(hex.slice(0, 2), 16);
+    const g = parseInt(hex.slice(2, 4), 16);
+    const b = parseInt(hex.slice(4, 6), 16);
+    return new _Color(Proto2.ProtoColor.create({
+      type: Proto2.ProtoColorType.RGB,
+      r,
+      g,
+      b
+    }));
+  }
+  constructor(color) {
+    this.color = color;
+  }
+  toDocFrame() {
+    return this.color;
+  }
+};
+var Colors;
+((Colors2) => {
+  Colors2.white = Color.rgb(255, 255, 255);
+  Colors2.black = Color.cmyk(0, 0, 0, 100);
+})(Colors || (Colors = {}));
+
+// src/Content/Barcode/index.ts
+import Proto5 from "docframe-types";
+
+// src/Content/DocumentElement/index.ts
+var DocumentElement = class {
+};
+
+// src/Measure/index.ts
+var Measure_exports = {};
+__export(Measure_exports, {
+  AbsoluteMeasure: () => AbsoluteMeasure,
+  Measure: () => Measure,
+  SideMeasures: () => SideMeasures
+});
+
+// src/Measure/Measure.ts
+import Proto3 from "docframe-types";
+var _Measure = class _Measure {
+  constructor(value, unit) {
+    this.value = value;
+    this.unit = unit;
+  }
+  toDocFrame() {
+    switch (this.unit) {
+      case "pt":
+        return new Proto3.ProtoMeasure({
+          value: this.value,
+          mtype: Proto3.ProtoMeasureType.PT
+        });
+      case "cm":
+        return new Proto3.ProtoMeasure({
+          value: this.value,
+          mtype: Proto3.ProtoMeasureType.CM
+        });
+      case "mm":
+        return new Proto3.ProtoMeasure({
+          value: this.value,
+          mtype: Proto3.ProtoMeasureType.MM
+        });
+      case "in":
+        return new Proto3.ProtoMeasure({
+          value: this.value,
+          mtype: Proto3.ProtoMeasureType.IN
+        });
+      case "px":
+        return new Proto3.ProtoMeasure({
+          value: this.value,
+          mtype: Proto3.ProtoMeasureType.PX
+        });
+      case "%":
+        return new Proto3.ProtoMeasure({
+          value: this.value,
+          mtype: Proto3.ProtoMeasureType.PERCENT
+        });
+      default:
+        throw new Error(`Unknown measure unit: ${this.unit}`);
+    }
+  }
+};
+_Measure.zero = new _Measure(0, "pt");
+var Measure = _Measure;
+var AbsoluteMeasure = class extends Measure {
+};
+var SideMeasures = class {
+  constructor(settings) {
+    this.value = settings;
+  }
+  toDocFrame() {
+    var _a, _b, _c, _d;
+    return new Proto3.ProtoSideMeasures({
+      top: (_a = this.value.top) == null ? void 0 : _a.toDocFrame(),
+      right: (_b = this.value.right) == null ? void 0 : _b.toDocFrame(),
+      bottom: (_c = this.value.bottom) == null ? void 0 : _c.toDocFrame(),
+      left: (_d = this.value.left) == null ? void 0 : _d.toDocFrame()
+    });
+  }
+};
+
+// src/Content/ReferencePoint/index.ts
+import Proto4 from "docframe-types";
+function referencePointToDocFrame(point) {
+  switch (point) {
+    case "top-left":
+      return Proto4.ProtoImageReferencePoint.REF_POINT_TOP_LEFT;
+    case "top-right":
+      return Proto4.ProtoImageReferencePoint.REF_POINT_TOP_RIGHT;
+    case "center":
+      return Proto4.ProtoImageReferencePoint.REF_POINT_CENTER;
+    case "bottom-left":
+      return Proto4.ProtoImageReferencePoint.REF_POINT_BOTTOM_LEFT;
+    case "bottom-right":
+      return Proto4.ProtoImageReferencePoint.REF_POINT_BOTTOM_RIGHT;
+    default:
+      throw new Error(`Unknown reference point: ${point}`);
+  }
+}
+
+// src/Content/Barcode/index.ts
+var Barcode = class extends DocumentElement {
+  constructor(props) {
+    super();
+    this.props = props;
+  }
+  toDocFrame() {
+    return Proto5.Node.create({
+      barcode: Proto5.ProtoBarcode.create({
+        type: this.props.type,
+        positionAbsolute: this.props.positionAbsolute,
+        referencePoint: referencePointToDocFrame(this.props.referencePoint),
+        x: this.props.x.toDocFrame(),
+        y: this.props.y.toDocFrame(),
+        rotation: this.props.rotation,
+        width: this.props.width.toDocFrame(),
+        height: this.props.height.toDocFrame(),
+        padding: Measure.zero.toDocFrame(),
+        data: this.props.data
+      })
+    });
+  }
+};
+
+// src/Content/ColumnDefinition/index.ts
+import Proto6 from "docframe-types";
+import { v4 as uuidv4 } from "uuid";
+var ColumnPositionMode = class {
+  constructor(value) {
+    this.value = value;
+  }
+  toDocFrame() {
+    return this.value;
+  }
+};
+var ColumnPosition;
+((ColumnPosition2) => {
+  ColumnPosition2.Center = new ColumnPositionMode(Proto6.ProtoPositionMode.CENTER);
+  ColumnPosition2.Left = new ColumnPositionMode(Proto6.ProtoPositionMode.LEFT);
+  ColumnPosition2.Folio = new ColumnPositionMode(Proto6.ProtoPositionMode.FOLIO);
+  ColumnPosition2.Right = new ColumnPositionMode(Proto6.ProtoPositionMode.RIGHT);
+  ColumnPosition2.ReverseFolio = new ColumnPositionMode(
+    Proto6.ProtoPositionMode.REVERSE_FOLIO
+  );
+})(ColumnPosition || (ColumnPosition = {}));
+var ColumnDefinition = class {
+  constructor(props) {
+    this.props = props;
+    this.uuid = uuidv4();
+  }
+  toDocFrame(applyImmediate) {
+    const result = [
+      Proto6.Node.create({
+        cDef: Proto6.ProtoCDef.create({
+          Uuid: this.uuid,
+          columSettings: Proto6.ProtoColumnSettings.create({
+            width: Proto6.ProtoBoxedMeasure.create({
+              isNull: false,
+              value: this.props.width.toDocFrame()
+            }),
+            positionOffset: Proto6.ProtoBoxedMeasure.create({
+              isNull: false,
+              value: this.props.positionOffset.toDocFrame()
+            }),
+            positionMode: this.props.position.toDocFrame(),
+            interColumnSpace: Proto6.ProtoBoxedMeasure.create({
+              isNull: false,
+              value: this.props.interColumnSpace.toDocFrame()
+            })
+          })
+        })
+      })
+    ];
+    if (applyImmediate) {
+      result.push(
+        Proto6.Node.create({
+          applyCDef: Proto6.ProtoApplyProtoCDef.create({
+            cDefUuid: this.uuid
+          })
+        })
+      );
+    }
+    return result;
+  }
+};
+var ColumnDefinitions = {
+  A4: {
+    Single: new ColumnDefinition({
+      width: new AbsoluteMeasure(490, "pt"),
+      position: ColumnPosition.Left,
+      positionOffset: new AbsoluteMeasure(70, "pt"),
+      interColumnSpace: new AbsoluteMeasure(30, "pt")
+    }),
+    Double: new ColumnDefinition({
+      width: new AbsoluteMeasure(230, "pt"),
+      position: ColumnPosition.Left,
+      positionOffset: new AbsoluteMeasure(70, "pt"),
+      interColumnSpace: new AbsoluteMeasure(30, "pt")
+    })
+  }
+};
+
+// src/Content/Document/index.ts
+import Proto14 from "docframe-types";
+
+// src/Connection/index.ts
+import axios from "axios";
+import FormData from "form-data";
+import Proto7 from "docframe-types";
+var Connection = class {
+  constructor(url = "http://localhost:8080", token = "") {
+    this.url = url;
+    this.token = token;
+  }
+  get docframeCallUrl() {
+    return `${this.url}/api/docframe?token=${this.token}`;
+  }
+  convertTo(format, doc, outputParams) {
+    const node = doc.toDocFrame();
+    const protoData = Proto7.Node.encode(node).finish();
+    const form = new FormData();
+    let meta = {
+      format
+    };
+    if (outputParams) {
+      meta = {
+        ...meta,
+        ...outputParams
+      };
+    }
+    form.append("meta", JSON.stringify(meta), {
+      contentType: "application/json",
+      filename: "meta"
+    });
+    form.append("proto-data", protoData, {
+      contentType: "application/protobuf",
+      filename: "data.proto"
+    });
+    return new Promise((resolve, reject) => {
+      axios.postForm(this.docframeCallUrl, form, {
+        headers: {
+          ...form.getHeaders()
+        },
+        responseType: "arraybuffer"
+      }).then(async (res) => {
+        const blob = await new Response(res.data, {
+          headers: {
+            "Content-Type": res.headers["content-type"]
+          }
+        }).blob();
+        resolve(blob);
+      }).catch((err) => {
+        reject(err);
+      });
+    });
+  }
+};
+var defaultConnection = new Connection();
+
+// src/OutputFormat/index.ts
+var OutputFormat = /* @__PURE__ */ ((OutputFormat2) => {
+  OutputFormat2["PDF"] = "pdf";
+  OutputFormat2["PNG"] = "png";
+  OutputFormat2["JPEG"] = "jpeg";
+  OutputFormat2["HTML"] = "html";
+  OutputFormat2["PS"] = "ps";
+  OutputFormat2["TEXT"] = "text";
+  return OutputFormat2;
+})(OutputFormat || {});
+
+// src/Content/Text/index.ts
+import Proto8 from "docframe-types";
+var Text = class extends DocumentElement {
+  constructor(content) {
+    super();
+    this.content = content;
+  }
+  toDocFrame() {
+    return Proto8.Node.create({
+      text: Proto8.ProtoText.create({
+        content: this.content
+      })
+    });
+  }
+};
+
+// src/Content/BranchDocumentElement/index.ts
+var BranchDocumentElement = class extends DocumentElement {
+  constructor(children, props) {
+    super();
+    this.children = [];
+    this._props = props;
+    if (children === void 0) {
+      this.children = [];
+      return;
+    }
+    this.children = documentElementsFromContent(children);
+  }
+  appendChildren(children) {
+    this.children = this.children.concat(children);
+  }
+  appendChild(child) {
+    this.children.push(child);
+  }
+  prependChildren(children) {
+    this.children = children.concat(this.children);
+  }
+  prependChild(child) {
+    this.children.unshift(child);
+  }
+  childrenToDocFrame() {
+    return this.children.map((child) => child.toDocFrame());
+  }
+  set props(props) {
+    this._props = props;
+  }
+  get props() {
+    return this._props;
+  }
+};
+function documentElementsFromContent(content) {
+  if (typeof content === "string") {
+    return [new Text(content)];
+  } else if (Array.isArray(content)) {
+    return content.map(documentElementsFromContent).flat();
+  } else {
+    return [content];
+  }
+}
+
+// src/Content/Footer/index.ts
+import Proto9 from "docframe-types";
+var Footer = class extends BranchDocumentElement {
+  toDocFrame() {
+    return Proto9.Node.create({
+      footer: Proto9.ProtoFooter.create(),
+      children: this.childrenToDocFrame()
+    });
+  }
+};
+
+// src/Content/Header/index.ts
+import Proto10 from "docframe-types";
+var Header = class extends BranchDocumentElement {
+  toDocFrame() {
+    return Proto10.Node.create({
+      header: Proto10.ProtoHeader.create(),
+      children: this.childrenToDocFrame()
+    });
+  }
+};
+
+// src/Content/PageDefinition/index.ts
+import Proto11 from "docframe-types";
+import { v4 } from "uuid";
+var PageDefinition = class {
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    this.uuid = v4();
+  }
+  toDocFrame() {
+    var _a, _b;
+    return new Proto11.ProtoPDef({
+      pageDepth: new Proto11.ProtoBoxedMeasure({
+        isNull: this.height === void 0,
+        value: (_a = this.height) == null ? void 0 : _a.toDocFrame()
+      }),
+      pageWidth: new Proto11.ProtoBoxedMeasure({
+        isNull: this.width === void 0,
+        value: (_b = this.width) == null ? void 0 : _b.toDocFrame()
+      }),
+      Uuid: this.uuid
+    });
+  }
+};
+var PageDefinitions;
+((PageDefinitions2) => {
+  PageDefinitions2.A3 = new PageDefinition(
+    new AbsoluteMeasure(297, "mm"),
+    new AbsoluteMeasure(420, "mm")
+  );
+  PageDefinitions2.A4 = new PageDefinition(
+    new AbsoluteMeasure(210, "mm"),
+    new AbsoluteMeasure(297, "mm")
+  );
+  PageDefinitions2.A5 = new PageDefinition(
+    new AbsoluteMeasure(148, "mm"),
+    new AbsoluteMeasure(210, "mm")
+  );
+})(PageDefinitions || (PageDefinitions = {}));
+
+// src/ParagraphFormat/index.ts
+import Proto12 from "docframe-types";
+import { v4 as uuidv42 } from "uuid";
+var ParagraphFormat = class {
+  constructor(props) {
+    this.props = props;
+    this.props.name = props.name || uuidv42();
+  }
+  toDocFrame() {
+    let format = {
+      default: Proto12.ProtoBoxedBool.create({
+        isNull: false,
+        value: this.props.default || false
+      }),
+      name: Proto12.ProtoBoxedString.create({
+        isNull: false,
+        value: this.props.name
+      })
+    };
+    if (this.props.alignment) {
+      format.alignment = Proto12.ProtoBoxedHorizontalAlignment.create({
+        isNull: false,
+        value: this.props.alignment.toDocFrame()
+      });
+    }
+    if (this.props.font) {
+      format.font = Proto12.ProtoBoxedFont.create({
+        isNull: false,
+        value: this.props.font.toDocFrame()
+      });
+    }
+    if (this.props.fontSize) {
+      format.fontSize = Proto12.ProtoBoxedMeasure.create({
+        isNull: false,
+        value: this.props.fontSize.toDocFrame()
+      });
+    }
+    if (this.props.characterWidth) {
+      format.characterWidth = Proto12.ProtoBoxedMeasure.create({
+        isNull: false,
+        value: this.props.characterWidth.toDocFrame()
+      });
+    }
+    if (this.props.characterSpacing) {
+      format.characterSpacing = Proto12.ProtoBoxedMeasure.create({
+        isNull: false,
+        value: this.props.characterSpacing.toDocFrame()
+      });
+    }
+    if (this.props.lineFeed) {
+      format.lineFeed = Proto12.ProtoBoxedMeasure.create({
+        isNull: false,
+        value: this.props.lineFeed.toDocFrame()
+      });
+    }
+    if (this.props.indentionLevel !== void 0) {
+      format.indentionLevel = Proto12.ProtoBoxedInt32.create({
+        isNull: false,
+        value: this.props.indentionLevel
+      });
+    }
+    if (this.props.indentionWidth) {
+      format.indentionWidth = Proto12.ProtoBoxedMeasure.create({
+        isNull: false,
+        value: this.props.indentionWidth.toDocFrame()
+      });
+    }
+    if (this.props.bold !== void 0) {
+      format.bold = Proto12.ProtoBoxedBool.create({
+        isNull: false,
+        value: !!this.props.bold
+      });
+    }
+    if (this.props.italic !== void 0) {
+      format.italic = Proto12.ProtoBoxedBool.create({
+        isNull: false,
+        value: !!this.props.italic
+      });
+    }
+    if (this.props.spaceAbove) {
+      format.spaceAbove = Proto12.ProtoBoxedMeasure.create({
+        isNull: false,
+        value: this.props.spaceAbove.toDocFrame()
+      });
+    }
+    if (this.props.spaceBelow) {
+      format.spaceBelow = Proto12.ProtoBoxedMeasure.create({
+        isNull: false,
+        value: this.props.spaceBelow.toDocFrame()
+      });
+    }
+    return Proto12.ProtoParagraphFormat.create(format);
+  }
+};
+
+// src/Content/SpaceVertically/index.ts
+import Proto13 from "docframe-types";
+var SpaceVertically = class extends DocumentElement {
+  constructor(space) {
+    super();
+    this.space = space;
+  }
+  toDocFrame() {
+    return Proto13.Node.create({
+      spaceVertically: Proto13.ProtoSpaceVertically.create({
+        space: this.space.toDocFrame()
+      })
+    });
+  }
+};
+
+// src/Font/index.ts
+import { ProtoFont } from "docframe-types";
+var Font = class {
+  constructor(name) {
+    this.name = name;
+  }
+  toDocFrame() {
+    return ProtoFont.create({
+      name: this.name
+    });
+  }
+};
+var StandardFonts = {
+  Helvetica: new Font("helvetica")
+};
+
+// src/Content/Document/index.ts
+var Document = class extends BranchDocumentElement {
+  constructor(content, props) {
+    super(content, props);
+    this.paragraphFormats = {};
+    if (props === void 0) {
+      this.props = {
+        pageDefinition: PageDefinitions.A4,
+        columnDefinition: ColumnDefinitions.A4.Single,
+        defaultHeader: new Header(
+          new SpaceVertically(new AbsoluteMeasure(40, "pt"))
+        ),
+        defaultFooter: new Footer(
+          new SpaceVertically(new AbsoluteMeasure(40, "pt"))
+        )
+      };
+    } else {
+      this.props = props;
+    }
+    this.paragraphFormats = this.props.paragraphFormats || {
+      Text: new ParagraphFormat({
+        font: StandardFonts.Helvetica,
+        fontSize: new AbsoluteMeasure(12, "pt"),
+        lineFeed: new AbsoluteMeasure(14, "pt"),
+        indentionWidth: new AbsoluteMeasure(15, "pt"),
+        name: "Text",
+        default: true
+      })
+    };
+  }
+  getParagraphFormat(name) {
+    return this.paragraphFormats[name];
+  }
+  registerParagraphFormat(name, pf) {
+    this.paragraphFormats[name] = pf;
+  }
+  convertTo(outputFormat, outputParams) {
+    return defaultConnection.convertTo(outputFormat, this, outputParams);
+  }
+  convertToPDF(outputParams) {
+    return defaultConnection.convertTo("pdf" /* PDF */, this, outputParams);
+  }
+  /*
+    public getProtoParagraphFormat(format?: ParagraphFormat): Proto.IProtoParagraphFormat {
+      if (!format) {
+        return this.defaultParagraphFormat;
+      }
+  
+      if (!format.format.name) {
+        throw new Error("ParagraphFormat must have a name");
+      }
+  
+      if (!this.paragraphFormats[format.format.name]) {
+        this.paragraphFormats[format.format.name] = format.toDocFrame();
+      }
+  
+      return this.paragraphFormats[format.format.name];
+    }
+    */
+  toDocFrame() {
+    const props = this.props;
+    const docSettings = Object.values(this.paragraphFormats).map(
+      (pf) => Proto14.Node.create({
+        paragraphFormat: pf.toDocFrame()
+      })
+    ).concat([
+      Proto14.Node.create({
+        pDef: props.pageDefinition.toDocFrame()
+      }),
+      Proto14.Node.create({
+        applyPDef: Proto14.ProtoApplyProtoPDef.create({
+          pDefUuid: props.pageDefinition.uuid
+        })
+      }),
+      ...props.columnDefinition.toDocFrame(true)
+    ]);
+    if (props.defaultHeader) {
+      docSettings.push(props.defaultHeader.toDocFrame());
+    }
+    if (props.defaultFooter) {
+      docSettings.push(props.defaultFooter.toDocFrame());
+    }
+    const content = this.childrenToDocFrame();
+    for (const format of Object.values(this.paragraphFormats)) {
+      docSettings.push(
+        Proto14.Node.create({
+          paragraphFormat: format.toDocFrame()
+        })
+      );
+    }
+    return Proto14.Node.create({
+      children: docSettings.concat(...content)
+    });
+  }
+};
+
+// src/Content/Formatted/index.ts
+import Proto15 from "docframe-types";
+var Formatted = class extends DocumentElement {
+  constructor(doctypeContent, htmlContent) {
+    super();
+    this.content = {
+      doctype: doctypeContent,
+      html: htmlContent
+    };
+  }
+  toDocFrame() {
+    return Proto15.Node.create({
+      formatted: Proto15.ProtoFormatted.create({
+        doctypeContent: this.content.doctype,
+        htmlContent: this.content.html
+      })
+    });
+  }
+};
+
+// src/Content/Pagebreak/index.ts
+import Proto16 from "docframe-types";
+var Pagebreak = class extends DocumentElement {
+  toDocFrame() {
+    return Proto16.Node.create({
+      newPage: Proto16.ProtoNewPage.create({})
+    });
+  }
+};
+
+// src/Content/Paragraph/index.ts
+import Proto17 from "docframe-types";
+var Paragraph = class extends BranchDocumentElement {
+  constructor(content, paragraphFormatName, overwrite) {
+    var _a;
+    super(content, {
+      overwrite,
+      paragraphFormatName: typeof paragraphFormatName === "string" ? paragraphFormatName : (_a = paragraphFormatName == null ? void 0 : paragraphFormatName.props) == null ? void 0 : _a.name
+    });
+  }
+  toDocFrame() {
+    const par = {};
+    if (this.props.overwrite) {
+      par.overwrite = this.props.overwrite.toDocFrame();
+    }
+    if (this.props.paragraphFormatName) {
+      par.format = Proto17.ProtoParagraphFormat.create({
+        name: Proto17.ProtoBoxedString.create({
+          isNull: false,
+          value: this.props.paragraphFormatName
+        })
+      });
+    }
+    return Proto17.Node.create({
+      paragraph: Proto17.ProtoParagraph.create(par),
+      children: this.childrenToDocFrame()
+    });
+  }
+};
+
+// src/Content/Table/index.ts
+import Proto18 from "docframe-types";
+var Table = class extends BranchDocumentElement {
+  constructor(content, props) {
+    super(content, props || {});
+    if (!this.props.xOffset) {
+      this.props.xOffset = Measure.zero;
+    }
+  }
+  toDocFrame() {
+    var _a, _b;
+    const props = this.props;
+    return Proto18.Node.create({
+      table: Proto18.ProtoTable.create({
+        settings: Proto18.ProtoTableSettings.create({
+          width: (_a = props.width) == null ? void 0 : _a.toDocFrame(),
+          leftMeasure: Proto18.ProtoBoxedBool.create({
+            isNull: false,
+            value: false
+          }),
+          xOffset: (_b = props.xOffset) == null ? void 0 : _b.toDocFrame()
+        })
+      }),
+      children: this.childrenToDocFrame()
+    });
+  }
+};
+
+// src/Content/TableCell/index.ts
+import Proto19 from "docframe-types";
+var TableCell = class extends BranchDocumentElement {
+  constructor(content, props) {
+    super(content, props || {});
+  }
+  toDocFrame() {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const props = this.props;
+    return Proto19.Node.create({
+      tableCell: Proto19.ProtoTableCell.create({
+        settings: Proto19.ProtoTableCellSettings.create({
+          align: Proto19.ProtoBoxedHorizontalAlignment.create({
+            isNull: false,
+            value: ((_a = props.alignment) == null ? void 0 : _a.toDocFrame()) || Proto19.ProtoHorizontalAlignment.ALIGN_LEFT
+          }),
+          backgroundColor: (_b = props.backgroundColor) == null ? void 0 : _b.toDocFrame(),
+          border: (_c = props.border) == null ? void 0 : _c.toDocFrame(),
+          margin: (_d = props.margin) == null ? void 0 : _d.toDocFrame(),
+          padding: (_e = props.padding) == null ? void 0 : _e.toDocFrame(),
+          valign: Proto19.ProtoBoxedVerticalAlignment.create({
+            isNull: false,
+            value: ((_f = props.verticalAlignment) == null ? void 0 : _f.toDocFrame()) || Proto19.ProtoVerticalAlignment.TOP
+          }),
+          width: (_g = props.width) == null ? void 0 : _g.toDocFrame()
+        })
+      }),
+      children: this.childrenToDocFrame()
+    });
+  }
+};
+
+// src/Content/TableRow/index.ts
+import Proto20 from "docframe-types";
+var TableRow = class extends BranchDocumentElement {
+  constructor(content, props) {
+    super(content, props || {});
+  }
+  toDocFrame() {
+    var _a;
+    return Proto20.Node.create({
+      tableRow: Proto20.ProtoTableRow.create({
+        settings: Proto20.ProtoTableRowSettings.create({
+          minHeight: (_a = this.props.minHeight) == null ? void 0 : _a.toDocFrame()
+        })
+      }),
+      children: this.childrenToDocFrame()
+    });
+  }
+};
+
+// src/Content/index.ts
+var Content_default = {
+  Barcode,
+  ColumnDefinition,
+  ColumnPosition,
+  Document,
+  Formatted,
+  PageDefinition,
+  Pagebreak,
+  Paragraph,
+  SpaceVertically,
+  Table,
+  TableCell,
+  TableRow,
+  Text
+};
+
+// src/index.ts
+var index_default = {
+  Border: {
+    Border,
+    SideBorders
+  },
+  Color: {
+    Color,
+    Colors
+  },
+  Content: Content_default,
+  Font: {
+    Font,
+    StandardFonts
+  },
+  Measure: Measure_exports,
+  OutputFormat,
+  ParagraphFormat
+};
+export {
+  index_default as default
+};