ducjs 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ducflair
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,42 @@
+<p align="center">
+  <br/>
+  <a href="https://duc.ducflair.com" target="_blank"><img width="256px" src="https://raw.githubusercontent.com/ducflair/assets/refs/heads/main/src/duc/duc-extended.png" /></a>
+  <p align="center">2D CAD File Format</p>
+  <p align="center" style="align: center;">
+    <a href="https://www.npmjs.com/package/ducjs"><img src="https://shields.io/badge/NPM-cc3534?logo=Npm&logoColor=white&style=round-square" alt="NPM" /></a>
+    <a href="https://github.com/ducflair/duc/releases"><img src="https://img.shields.io/npm/v/ducjs/latest?style=round-square&label=latest%20stable" alt="NPM ducjs@latest release" /></a>
+    <a href="https://www.npmtrends.com/ducjs"><img src="https://img.shields.io/npm/dm/ducjs?style=round-square&color=salmon" alt="Downloads" /></a>
+    <img src="https://shields.io/badge/TypeScript-3178C6?logo=TypeScript&logoColor=fff&style=round-square" alt="TypeScript" />
+  </p>
+</p>
+
+
+# ducjs
+
+The `ducjs` package offers comprehensive TypeScript types and helper functions to work effortlessly with the `duc` CAD file format. Built with Flatbuffers and optimized for performance, this package enables you to parse, validate, and manipulate `duc` files with ease.
+
+## Documentation
+
+For detailed documentation, including all available types and utility functions, visit our [Documentation](https://duc.ducflair.com).
+
+## Tools
+
+- [Playground](https://ducflair.com/core): Experiment with the `duc` format in a live environment.
+- [Documentation](https://duc.ducflair.com): Comprehensive guides and API references.
+
+## Contributing
+
+At the moment we are not accepting contributions to this package. However, we welcome feedback and suggestions for future improvements. Feel free to open an issue or contact us at [Ducflair Support](https://www.ducflair.com/support).
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](./LICENSE) file for more details.
+
+
+## Commit Message Guidelines
+
+To ensure smooth releases with semantic-release, please follow [these guidelines](https://semantic-release.gitbook.io/semantic-release#how-does-it-work).
+
+---
+
+*The duc format and libraries are constantly evolving, aiming to set new standards in the 2D CAD industry. Be a part of this transformation and help shape the future of design technology!*

package/dist/flatbuffers/duc/alternate-units.d.ts

@@ -0,0 +1,21 @@
+import * as flatbuffers from 'flatbuffers';
+import { DIMENSION_UNITS_FORMAT } from '../duc/dimension-units-format';
+import { _UnitSystemBase } from '../duc/unit-system-base';
+export declare class AlternateUnits {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): AlternateUnits;
+    static getRootAsAlternateUnits(bb: flatbuffers.ByteBuffer, obj?: AlternateUnits): AlternateUnits;
+    static getSizePrefixedRootAsAlternateUnits(bb: flatbuffers.ByteBuffer, obj?: AlternateUnits): AlternateUnits;
+    base(obj?: _UnitSystemBase): _UnitSystemBase | null;
+    format(): DIMENSION_UNITS_FORMAT | null;
+    isVisible(): boolean;
+    multiplier(): number;
+    static startAlternateUnits(builder: flatbuffers.Builder): void;
+    static addBase(builder: flatbuffers.Builder, baseOffset: flatbuffers.Offset): void;
+    static addFormat(builder: flatbuffers.Builder, format: DIMENSION_UNITS_FORMAT): void;
+    static addIsVisible(builder: flatbuffers.Builder, isVisible: boolean): void;
+    static addMultiplier(builder: flatbuffers.Builder, multiplier: number): void;
+    static endAlternateUnits(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createAlternateUnits(builder: flatbuffers.Builder, baseOffset: flatbuffers.Offset, format: DIMENSION_UNITS_FORMAT | null, isVisible: boolean, multiplier: number): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/alternate-units.js

@@ -0,0 +1,66 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { _UnitSystemBase } from '../duc/unit-system-base';
+export class AlternateUnits {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsAlternateUnits(bb, obj) {
+        return (obj || new AlternateUnits()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsAlternateUnits(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new AlternateUnits()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    base(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new _UnitSystemBase()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    format() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    isVisible() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    }
+    multiplier() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
+    }
+    static startAlternateUnits(builder) {
+        builder.startObject(4);
+    }
+    static addBase(builder, baseOffset) {
+        builder.addFieldOffset(0, baseOffset, 0);
+    }
+    static addFormat(builder, format) {
+        builder.addFieldInt8(1, format, null);
+    }
+    static addIsVisible(builder, isVisible) {
+        builder.addFieldInt8(2, +isVisible, +false);
+    }
+    static addMultiplier(builder, multiplier) {
+        builder.addFieldFloat32(3, multiplier, 0.0);
+    }
+    static endAlternateUnits(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createAlternateUnits(builder, baseOffset, format, isVisible, multiplier) {
+        AlternateUnits.startAlternateUnits(builder);
+        AlternateUnits.addBase(builder, baseOffset);
+        if (format !== null)
+            AlternateUnits.addFormat(builder, format);
+        AlternateUnits.addIsVisible(builder, isVisible);
+        AlternateUnits.addMultiplier(builder, multiplier);
+        return AlternateUnits.endAlternateUnits(builder);
+    }
+}

package/dist/flatbuffers/duc/angular-unit-system.d.ts

@@ -0,0 +1,17 @@
+import * as flatbuffers from 'flatbuffers';
+import { ANGULAR_UNITS_FORMAT } from '../duc/angular-units-format';
+import { _UnitSystemBase } from '../duc/unit-system-base';
+export declare class AngularUnitSystem {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): AngularUnitSystem;
+    static getRootAsAngularUnitSystem(bb: flatbuffers.ByteBuffer, obj?: AngularUnitSystem): AngularUnitSystem;
+    static getSizePrefixedRootAsAngularUnitSystem(bb: flatbuffers.ByteBuffer, obj?: AngularUnitSystem): AngularUnitSystem;
+    base(obj?: _UnitSystemBase): _UnitSystemBase | null;
+    format(): ANGULAR_UNITS_FORMAT | null;
+    static startAngularUnitSystem(builder: flatbuffers.Builder): void;
+    static addBase(builder: flatbuffers.Builder, baseOffset: flatbuffers.Offset): void;
+    static addFormat(builder: flatbuffers.Builder, format: ANGULAR_UNITS_FORMAT): void;
+    static endAngularUnitSystem(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createAngularUnitSystem(builder: flatbuffers.Builder, baseOffset: flatbuffers.Offset, format: ANGULAR_UNITS_FORMAT | null): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/angular-unit-system.js

@@ -0,0 +1,50 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { _UnitSystemBase } from '../duc/unit-system-base';
+export class AngularUnitSystem {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsAngularUnitSystem(bb, obj) {
+        return (obj || new AngularUnitSystem()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsAngularUnitSystem(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new AngularUnitSystem()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    base(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new _UnitSystemBase()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    format() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    static startAngularUnitSystem(builder) {
+        builder.startObject(2);
+    }
+    static addBase(builder, baseOffset) {
+        builder.addFieldOffset(0, baseOffset, 0);
+    }
+    static addFormat(builder, format) {
+        builder.addFieldInt8(1, format, null);
+    }
+    static endAngularUnitSystem(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createAngularUnitSystem(builder, baseOffset, format) {
+        AngularUnitSystem.startAngularUnitSystem(builder);
+        AngularUnitSystem.addBase(builder, baseOffset);
+        if (format !== null)
+            AngularUnitSystem.addFormat(builder, format);
+        return AngularUnitSystem.endAngularUnitSystem(builder);
+    }
+}

package/dist/flatbuffers/duc/angular-units-format.d.ts

@@ -0,0 +1,7 @@
+export declare enum ANGULAR_UNITS_FORMAT {
+    DECIMAL_DEGREES = 10,
+    DEGREES_MINUTES_SECONDS = 11,
+    GRADS = 12,
+    RADIANS = 13,
+    SURVEYOR = 14
+}

package/dist/flatbuffers/duc/angular-units-format.js

@@ -0,0 +1,10 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var ANGULAR_UNITS_FORMAT;
+(function (ANGULAR_UNITS_FORMAT) {
+    ANGULAR_UNITS_FORMAT[ANGULAR_UNITS_FORMAT["DECIMAL_DEGREES"] = 10] = "DECIMAL_DEGREES";
+    ANGULAR_UNITS_FORMAT[ANGULAR_UNITS_FORMAT["DEGREES_MINUTES_SECONDS"] = 11] = "DEGREES_MINUTES_SECONDS";
+    ANGULAR_UNITS_FORMAT[ANGULAR_UNITS_FORMAT["GRADS"] = 12] = "GRADS";
+    ANGULAR_UNITS_FORMAT[ANGULAR_UNITS_FORMAT["RADIANS"] = 13] = "RADIANS";
+    ANGULAR_UNITS_FORMAT[ANGULAR_UNITS_FORMAT["SURVEYOR"] = 14] = "SURVEYOR";
+})(ANGULAR_UNITS_FORMAT || (ANGULAR_UNITS_FORMAT = {}));

package/dist/flatbuffers/duc/axis.d.ts

@@ -0,0 +1,5 @@
+export declare enum AXIS {
+    X = 10,
+    Y = 20,
+    Z = 30
+}

package/dist/flatbuffers/duc/axis.js

@@ -0,0 +1,8 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var AXIS;
+(function (AXIS) {
+    AXIS[AXIS["X"] = 10] = "X";
+    AXIS[AXIS["Y"] = 20] = "Y";
+    AXIS[AXIS["Z"] = 30] = "Z";
+})(AXIS || (AXIS = {}));

package/dist/flatbuffers/duc/bezier-mirroring.d.ts

@@ -0,0 +1,5 @@
+export declare enum BEZIER_MIRRORING {
+    NONE = 10,
+    ANGLE = 11,
+    ANGLE_LENGTH = 12
+}

package/dist/flatbuffers/duc/bezier-mirroring.js

@@ -0,0 +1,8 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var BEZIER_MIRRORING;
+(function (BEZIER_MIRRORING) {
+    BEZIER_MIRRORING[BEZIER_MIRRORING["NONE"] = 10] = "NONE";
+    BEZIER_MIRRORING[BEZIER_MIRRORING["ANGLE"] = 11] = "ANGLE";
+    BEZIER_MIRRORING[BEZIER_MIRRORING["ANGLE_LENGTH"] = 12] = "ANGLE_LENGTH";
+})(BEZIER_MIRRORING || (BEZIER_MIRRORING = {}));

package/dist/flatbuffers/duc/blending.d.ts

@@ -0,0 +1,9 @@
+export declare enum BLENDING {
+    MULTIPLY = 11,
+    SCREEN = 12,
+    OVERLAY = 13,
+    DARKEN = 14,
+    LIGHTEN = 15,
+    DIFFERENCE = 16,
+    EXCLUSION = 17
+}

package/dist/flatbuffers/duc/blending.js

@@ -0,0 +1,12 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var BLENDING;
+(function (BLENDING) {
+    BLENDING[BLENDING["MULTIPLY"] = 11] = "MULTIPLY";
+    BLENDING[BLENDING["SCREEN"] = 12] = "SCREEN";
+    BLENDING[BLENDING["OVERLAY"] = 13] = "OVERLAY";
+    BLENDING[BLENDING["DARKEN"] = 14] = "DARKEN";
+    BLENDING[BLENDING["LIGHTEN"] = 15] = "LIGHTEN";
+    BLENDING[BLENDING["DIFFERENCE"] = 16] = "DIFFERENCE";
+    BLENDING[BLENDING["EXCLUSION"] = 17] = "EXCLUSION";
+})(BLENDING || (BLENDING = {}));

package/dist/flatbuffers/duc/block-attachment.d.ts

@@ -0,0 +1,4 @@
+export declare enum BLOCK_ATTACHMENT {
+    CENTER_EXTENTS = 10,
+    INSERTION_POINT = 11
+}

package/dist/flatbuffers/duc/block-attachment.js

@@ -0,0 +1,7 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var BLOCK_ATTACHMENT;
+(function (BLOCK_ATTACHMENT) {
+    BLOCK_ATTACHMENT[BLOCK_ATTACHMENT["CENTER_EXTENTS"] = 10] = "CENTER_EXTENTS";
+    BLOCK_ATTACHMENT[BLOCK_ATTACHMENT["INSERTION_POINT"] = 11] = "INSERTION_POINT";
+})(BLOCK_ATTACHMENT || (BLOCK_ATTACHMENT = {}));

package/dist/flatbuffers/duc/boolean-operation.d.ts

@@ -0,0 +1,6 @@
+export declare enum BOOLEAN_OPERATION {
+    UNION = 10,
+    SUBTRACT = 11,
+    INTERSECT = 12,
+    EXCLUDE = 13
+}

package/dist/flatbuffers/duc/boolean-operation.js

@@ -0,0 +1,9 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var BOOLEAN_OPERATION;
+(function (BOOLEAN_OPERATION) {
+    BOOLEAN_OPERATION[BOOLEAN_OPERATION["UNION"] = 10] = "UNION";
+    BOOLEAN_OPERATION[BOOLEAN_OPERATION["SUBTRACT"] = 11] = "SUBTRACT";
+    BOOLEAN_OPERATION[BOOLEAN_OPERATION["INTERSECT"] = 12] = "INTERSECT";
+    BOOLEAN_OPERATION[BOOLEAN_OPERATION["EXCLUDE"] = 13] = "EXCLUDE";
+})(BOOLEAN_OPERATION || (BOOLEAN_OPERATION = {}));

package/dist/flatbuffers/duc/bound-element.d.ts

@@ -0,0 +1,17 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class BoundElement {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): BoundElement;
+    static getRootAsBoundElement(bb: flatbuffers.ByteBuffer, obj?: BoundElement): BoundElement;
+    static getSizePrefixedRootAsBoundElement(bb: flatbuffers.ByteBuffer, obj?: BoundElement): BoundElement;
+    id(): string | null;
+    id(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    type(): string | null;
+    type(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    static startBoundElement(builder: flatbuffers.Builder): void;
+    static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
+    static addType(builder: flatbuffers.Builder, typeOffset: flatbuffers.Offset): void;
+    static endBoundElement(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createBoundElement(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset, typeOffset: flatbuffers.Offset): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/bound-element.js

@@ -0,0 +1,48 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+export class BoundElement {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsBoundElement(bb, obj) {
+        return (obj || new BoundElement()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsBoundElement(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new BoundElement()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    id(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    type(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    static startBoundElement(builder) {
+        builder.startObject(2);
+    }
+    static addId(builder, idOffset) {
+        builder.addFieldOffset(0, idOffset, 0);
+    }
+    static addType(builder, typeOffset) {
+        builder.addFieldOffset(1, typeOffset, 0);
+    }
+    static endBoundElement(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createBoundElement(builder, idOffset, typeOffset) {
+        BoundElement.startBoundElement(builder);
+        BoundElement.addId(builder, idOffset);
+        BoundElement.addType(builder, typeOffset);
+        return BoundElement.endBoundElement(builder);
+    }
+}

package/dist/flatbuffers/duc/checkpoint.d.ts

@@ -0,0 +1,22 @@
+import * as flatbuffers from 'flatbuffers';
+import { VersionBase } from '../duc/version-base';
+export declare class Checkpoint {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): Checkpoint;
+    static getRootAsCheckpoint(bb: flatbuffers.ByteBuffer, obj?: Checkpoint): Checkpoint;
+    static getSizePrefixedRootAsCheckpoint(bb: flatbuffers.ByteBuffer, obj?: Checkpoint): Checkpoint;
+    base(obj?: VersionBase): VersionBase | null;
+    data(index: number): number | null;
+    dataLength(): number;
+    dataArray(): Uint8Array | null;
+    sizeBytes(): bigint;
+    static startCheckpoint(builder: flatbuffers.Builder): void;
+    static addBase(builder: flatbuffers.Builder, baseOffset: flatbuffers.Offset): void;
+    static addData(builder: flatbuffers.Builder, dataOffset: flatbuffers.Offset): void;
+    static createDataVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startDataVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addSizeBytes(builder: flatbuffers.Builder, sizeBytes: bigint): void;
+    static endCheckpoint(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createCheckpoint(builder: flatbuffers.Builder, baseOffset: flatbuffers.Offset, dataOffset: flatbuffers.Offset, sizeBytes: bigint): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/checkpoint.js

@@ -0,0 +1,75 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { VersionBase } from '../duc/version-base';
+export class Checkpoint {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsCheckpoint(bb, obj) {
+        return (obj || new Checkpoint()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsCheckpoint(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new Checkpoint()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    base(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new VersionBase()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    data(index) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    }
+    dataLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    dataArray() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    }
+    sizeBytes() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt('0');
+    }
+    static startCheckpoint(builder) {
+        builder.startObject(3);
+    }
+    static addBase(builder, baseOffset) {
+        builder.addFieldOffset(0, baseOffset, 0);
+    }
+    static addData(builder, dataOffset) {
+        builder.addFieldOffset(1, dataOffset, 0);
+    }
+    static createDataVector(builder, data) {
+        builder.startVector(1, data.length, 1);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addInt8(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startDataVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
+    }
+    static addSizeBytes(builder, sizeBytes) {
+        builder.addFieldInt64(2, sizeBytes, BigInt('0'));
+    }
+    static endCheckpoint(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createCheckpoint(builder, baseOffset, dataOffset, sizeBytes) {
+        Checkpoint.startCheckpoint(builder);
+        Checkpoint.addBase(builder, baseOffset);
+        Checkpoint.addData(builder, dataOffset);
+        Checkpoint.addSizeBytes(builder, sizeBytes);
+        return Checkpoint.endCheckpoint(builder);
+    }
+}

package/dist/flatbuffers/duc/column-layout.d.ts

@@ -0,0 +1,22 @@
+import * as flatbuffers from 'flatbuffers';
+import { COLUMN_TYPE } from '../duc/column-type';
+import { TextColumn } from '../duc/text-column';
+export declare class ColumnLayout {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): ColumnLayout;
+    static getRootAsColumnLayout(bb: flatbuffers.ByteBuffer, obj?: ColumnLayout): ColumnLayout;
+    static getSizePrefixedRootAsColumnLayout(bb: flatbuffers.ByteBuffer, obj?: ColumnLayout): ColumnLayout;
+    type(): COLUMN_TYPE | null;
+    definitions(index: number, obj?: TextColumn): TextColumn | null;
+    definitionsLength(): number;
+    autoHeight(): boolean;
+    static startColumnLayout(builder: flatbuffers.Builder): void;
+    static addType(builder: flatbuffers.Builder, type: COLUMN_TYPE): void;
+    static addDefinitions(builder: flatbuffers.Builder, definitionsOffset: flatbuffers.Offset): void;
+    static createDefinitionsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startDefinitionsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addAutoHeight(builder: flatbuffers.Builder, autoHeight: boolean): void;
+    static endColumnLayout(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createColumnLayout(builder: flatbuffers.Builder, type: COLUMN_TYPE | null, definitionsOffset: flatbuffers.Offset, autoHeight: boolean): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/column-layout.js

@@ -0,0 +1,72 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { TextColumn } from '../duc/text-column';
+export class ColumnLayout {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsColumnLayout(bb, obj) {
+        return (obj || new ColumnLayout()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsColumnLayout(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new ColumnLayout()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    type() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    definitions(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new TextColumn()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    definitionsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    autoHeight() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    }
+    static startColumnLayout(builder) {
+        builder.startObject(3);
+    }
+    static addType(builder, type) {
+        builder.addFieldInt8(0, type, null);
+    }
+    static addDefinitions(builder, definitionsOffset) {
+        builder.addFieldOffset(1, definitionsOffset, 0);
+    }
+    static createDefinitionsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startDefinitionsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addAutoHeight(builder, autoHeight) {
+        builder.addFieldInt8(2, +autoHeight, +false);
+    }
+    static endColumnLayout(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createColumnLayout(builder, type, definitionsOffset, autoHeight) {
+        ColumnLayout.startColumnLayout(builder);
+        if (type !== null)
+            ColumnLayout.addType(builder, type);
+        ColumnLayout.addDefinitions(builder, definitionsOffset);
+        ColumnLayout.addAutoHeight(builder, autoHeight);
+        return ColumnLayout.endColumnLayout(builder);
+    }
+}

package/dist/flatbuffers/duc/column-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum COLUMN_TYPE {
+    NO_COLUMNS = 10,
+    STATIC_COLUMNS = 11,
+    DYNAMIC_COLUMNS = 12
+}

package/dist/flatbuffers/duc/column-type.js

@@ -0,0 +1,8 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var COLUMN_TYPE;
+(function (COLUMN_TYPE) {
+    COLUMN_TYPE[COLUMN_TYPE["NO_COLUMNS"] = 10] = "NO_COLUMNS";
+    COLUMN_TYPE[COLUMN_TYPE["STATIC_COLUMNS"] = 11] = "STATIC_COLUMNS";
+    COLUMN_TYPE[COLUMN_TYPE["DYNAMIC_COLUMNS"] = 12] = "DYNAMIC_COLUMNS";
+})(COLUMN_TYPE || (COLUMN_TYPE = {}));

package/dist/flatbuffers/duc/custom-hatch-pattern.d.ts

@@ -0,0 +1,23 @@
+import * as flatbuffers from 'flatbuffers';
+import { HatchPatternLine } from '../duc/hatch-pattern-line';
+export declare class CustomHatchPattern {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): CustomHatchPattern;
+    static getRootAsCustomHatchPattern(bb: flatbuffers.ByteBuffer, obj?: CustomHatchPattern): CustomHatchPattern;
+    static getSizePrefixedRootAsCustomHatchPattern(bb: flatbuffers.ByteBuffer, obj?: CustomHatchPattern): CustomHatchPattern;
+    name(): string | null;
+    name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    description(): string | null;
+    description(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    lines(index: number, obj?: HatchPatternLine): HatchPatternLine | null;
+    linesLength(): number;
+    static startCustomHatchPattern(builder: flatbuffers.Builder): void;
+    static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset): void;
+    static addDescription(builder: flatbuffers.Builder, descriptionOffset: flatbuffers.Offset): void;
+    static addLines(builder: flatbuffers.Builder, linesOffset: flatbuffers.Offset): void;
+    static createLinesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startLinesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static endCustomHatchPattern(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createCustomHatchPattern(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset, descriptionOffset: flatbuffers.Offset, linesOffset: flatbuffers.Offset): flatbuffers.Offset;
+}