ducjs 1.0.0

package/dist/flatbuffers/duc/duc-global-state.js

@@ -0,0 +1,121 @@
+// 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 DucGlobalState {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDucGlobalState(bb, obj) {
+        return (obj || new DucGlobalState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDucGlobalState(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DucGlobalState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    name(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    viewBackgroundColor(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    mainScope(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    dashSpacingScale() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
+    }
+    isDashSpacingAffectedByViewportScale() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    }
+    scopeExponentThreshold() {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.readInt8(this.bb_pos + offset) : 0;
+    }
+    dimensionsAssociativeByDefault() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    }
+    useAnnotativeScaling() {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    }
+    displayPrecisionLinear() {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    }
+    displayPrecisionAngular() {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    }
+    pruningLevel() {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    static startDucGlobalState(builder) {
+        builder.startObject(11);
+    }
+    static addName(builder, nameOffset) {
+        builder.addFieldOffset(0, nameOffset, 0);
+    }
+    static addViewBackgroundColor(builder, viewBackgroundColorOffset) {
+        builder.addFieldOffset(1, viewBackgroundColorOffset, 0);
+    }
+    static addMainScope(builder, mainScopeOffset) {
+        builder.addFieldOffset(2, mainScopeOffset, 0);
+    }
+    static addDashSpacingScale(builder, dashSpacingScale) {
+        builder.addFieldFloat32(3, dashSpacingScale, 0.0);
+    }
+    static addIsDashSpacingAffectedByViewportScale(builder, isDashSpacingAffectedByViewportScale) {
+        builder.addFieldInt8(4, +isDashSpacingAffectedByViewportScale, +false);
+    }
+    static addScopeExponentThreshold(builder, scopeExponentThreshold) {
+        builder.addFieldInt8(5, scopeExponentThreshold, 0);
+    }
+    static addDimensionsAssociativeByDefault(builder, dimensionsAssociativeByDefault) {
+        builder.addFieldInt8(6, +dimensionsAssociativeByDefault, +false);
+    }
+    static addUseAnnotativeScaling(builder, useAnnotativeScaling) {
+        builder.addFieldInt8(7, +useAnnotativeScaling, +false);
+    }
+    static addDisplayPrecisionLinear(builder, displayPrecisionLinear) {
+        builder.addFieldInt32(8, displayPrecisionLinear, 0);
+    }
+    static addDisplayPrecisionAngular(builder, displayPrecisionAngular) {
+        builder.addFieldInt32(9, displayPrecisionAngular, 0);
+    }
+    static addPruningLevel(builder, pruningLevel) {
+        builder.addFieldInt8(10, pruningLevel, null);
+    }
+    static endDucGlobalState(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createDucGlobalState(builder, nameOffset, viewBackgroundColorOffset, mainScopeOffset, dashSpacingScale, isDashSpacingAffectedByViewportScale, scopeExponentThreshold, dimensionsAssociativeByDefault, useAnnotativeScaling, displayPrecisionLinear, displayPrecisionAngular, pruningLevel) {
+        DucGlobalState.startDucGlobalState(builder);
+        DucGlobalState.addName(builder, nameOffset);
+        DucGlobalState.addViewBackgroundColor(builder, viewBackgroundColorOffset);
+        DucGlobalState.addMainScope(builder, mainScopeOffset);
+        DucGlobalState.addDashSpacingScale(builder, dashSpacingScale);
+        DucGlobalState.addIsDashSpacingAffectedByViewportScale(builder, isDashSpacingAffectedByViewportScale);
+        DucGlobalState.addScopeExponentThreshold(builder, scopeExponentThreshold);
+        DucGlobalState.addDimensionsAssociativeByDefault(builder, dimensionsAssociativeByDefault);
+        DucGlobalState.addUseAnnotativeScaling(builder, useAnnotativeScaling);
+        DucGlobalState.addDisplayPrecisionLinear(builder, displayPrecisionLinear);
+        DucGlobalState.addDisplayPrecisionAngular(builder, displayPrecisionAngular);
+        if (pruningLevel !== null)
+            DucGlobalState.addPruningLevel(builder, pruningLevel);
+        return DucGlobalState.endDucGlobalState(builder);
+    }
+}

package/dist/flatbuffers/duc/duc-group.d.ts

@@ -0,0 +1,16 @@
+import * as flatbuffers from 'flatbuffers';
+import { _DucStackBase } from '../duc/duc-stack-base';
+export declare class DucGroup {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DucGroup;
+    static getRootAsDucGroup(bb: flatbuffers.ByteBuffer, obj?: DucGroup): DucGroup;
+    static getSizePrefixedRootAsDucGroup(bb: flatbuffers.ByteBuffer, obj?: DucGroup): DucGroup;
+    id(): string | null;
+    id(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    stackBase(obj?: _DucStackBase): _DucStackBase | null;
+    static startDucGroup(builder: flatbuffers.Builder): void;
+    static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
+    static addStackBase(builder: flatbuffers.Builder, stackBaseOffset: flatbuffers.Offset): void;
+    static endDucGroup(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/duc-group.js

@@ -0,0 +1,44 @@
+// 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 { _DucStackBase } from '../duc/duc-stack-base';
+export class DucGroup {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDucGroup(bb, obj) {
+        return (obj || new DucGroup()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDucGroup(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DucGroup()).__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;
+    }
+    stackBase(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new _DucStackBase()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startDucGroup(builder) {
+        builder.startObject(2);
+    }
+    static addId(builder, idOffset) {
+        builder.addFieldOffset(0, idOffset, 0);
+    }
+    static addStackBase(builder, stackBaseOffset) {
+        builder.addFieldOffset(1, stackBaseOffset, 0);
+    }
+    static endDucGroup(builder) {
+        const offset = builder.endObject();
+        builder.requiredField(offset, 4); // id
+        return offset;
+    }
+}

package/dist/flatbuffers/duc/duc-hatch-style.d.ts

@@ -0,0 +1,28 @@
+import * as flatbuffers from 'flatbuffers';
+import { CustomHatchPattern } from '../duc/custom-hatch-pattern';
+import { DucPoint } from '../duc/duc-point';
+import { HATCH_STYLE } from '../duc/hatch-style';
+export declare class DucHatchStyle {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DucHatchStyle;
+    static getRootAsDucHatchStyle(bb: flatbuffers.ByteBuffer, obj?: DucHatchStyle): DucHatchStyle;
+    static getSizePrefixedRootAsDucHatchStyle(bb: flatbuffers.ByteBuffer, obj?: DucHatchStyle): DucHatchStyle;
+    hatchStyle(): HATCH_STYLE | null;
+    patternName(): string | null;
+    patternName(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    patternScale(): number;
+    patternAngle(): number;
+    patternOrigin(obj?: DucPoint): DucPoint | null;
+    patternDouble(): boolean;
+    customPattern(obj?: CustomHatchPattern): CustomHatchPattern | null;
+    static startDucHatchStyle(builder: flatbuffers.Builder): void;
+    static addHatchStyle(builder: flatbuffers.Builder, hatchStyle: HATCH_STYLE): void;
+    static addPatternName(builder: flatbuffers.Builder, patternNameOffset: flatbuffers.Offset): void;
+    static addPatternScale(builder: flatbuffers.Builder, patternScale: number): void;
+    static addPatternAngle(builder: flatbuffers.Builder, patternAngle: number): void;
+    static addPatternOrigin(builder: flatbuffers.Builder, patternOriginOffset: flatbuffers.Offset): void;
+    static addPatternDouble(builder: flatbuffers.Builder, patternDouble: boolean): void;
+    static addCustomPattern(builder: flatbuffers.Builder, customPatternOffset: flatbuffers.Offset): void;
+    static endDucHatchStyle(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/duc-hatch-style.js

@@ -0,0 +1,79 @@
+// 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 { CustomHatchPattern } from '../duc/custom-hatch-pattern';
+import { DucPoint } from '../duc/duc-point';
+export class DucHatchStyle {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDucHatchStyle(bb, obj) {
+        return (obj || new DucHatchStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDucHatchStyle(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DucHatchStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    hatchStyle() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    patternName(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    patternScale() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
+    }
+    patternAngle() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    patternOrigin(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? (obj || new DucPoint()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    patternDouble() {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    }
+    customPattern(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? (obj || new CustomHatchPattern()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startDucHatchStyle(builder) {
+        builder.startObject(7);
+    }
+    static addHatchStyle(builder, hatchStyle) {
+        builder.addFieldInt8(0, hatchStyle, null);
+    }
+    static addPatternName(builder, patternNameOffset) {
+        builder.addFieldOffset(1, patternNameOffset, 0);
+    }
+    static addPatternScale(builder, patternScale) {
+        builder.addFieldFloat32(2, patternScale, 0.0);
+    }
+    static addPatternAngle(builder, patternAngle) {
+        builder.addFieldFloat64(3, patternAngle, 0.0);
+    }
+    static addPatternOrigin(builder, patternOriginOffset) {
+        builder.addFieldOffset(4, patternOriginOffset, 0);
+    }
+    static addPatternDouble(builder, patternDouble) {
+        builder.addFieldInt8(5, +patternDouble, +false);
+    }
+    static addCustomPattern(builder, customPatternOffset) {
+        builder.addFieldOffset(6, customPatternOffset, 0);
+    }
+    static endDucHatchStyle(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+}

package/dist/flatbuffers/duc/duc-head.d.ts

@@ -0,0 +1,19 @@
+import * as flatbuffers from 'flatbuffers';
+import { LINE_HEAD } from '../duc/line-head';
+export declare class DucHead {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DucHead;
+    static getRootAsDucHead(bb: flatbuffers.ByteBuffer, obj?: DucHead): DucHead;
+    static getSizePrefixedRootAsDucHead(bb: flatbuffers.ByteBuffer, obj?: DucHead): DucHead;
+    type(): LINE_HEAD | null;
+    blockId(): string | null;
+    blockId(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    size(): number;
+    static startDucHead(builder: flatbuffers.Builder): void;
+    static addType(builder: flatbuffers.Builder, type: LINE_HEAD): void;
+    static addBlockId(builder: flatbuffers.Builder, blockIdOffset: flatbuffers.Offset): void;
+    static addSize(builder: flatbuffers.Builder, size: number): void;
+    static endDucHead(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createDucHead(builder: flatbuffers.Builder, type: LINE_HEAD | null, blockIdOffset: flatbuffers.Offset, size: number): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/duc-head.js

@@ -0,0 +1,57 @@
+// 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 DucHead {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDucHead(bb, obj) {
+        return (obj || new DucHead()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDucHead(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DucHead()).__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;
+    }
+    blockId(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    size() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    static startDucHead(builder) {
+        builder.startObject(3);
+    }
+    static addType(builder, type) {
+        builder.addFieldInt8(0, type, null);
+    }
+    static addBlockId(builder, blockIdOffset) {
+        builder.addFieldOffset(1, blockIdOffset, 0);
+    }
+    static addSize(builder, size) {
+        builder.addFieldFloat64(2, size, 0.0);
+    }
+    static endDucHead(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createDucHead(builder, type, blockIdOffset, size) {
+        DucHead.startDucHead(builder);
+        if (type !== null)
+            DucHead.addType(builder, type);
+        DucHead.addBlockId(builder, blockIdOffset);
+        DucHead.addSize(builder, size);
+        return DucHead.endDucHead(builder);
+    }
+}

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

@@ -0,0 +1,35 @@
+import * as flatbuffers from 'flatbuffers';
+import { DucImageFilter } from '../duc/duc-image-filter';
+import { IMAGE_STATUS } from '../duc/image-status';
+import { ImageCrop } from '../duc/image-crop';
+import { _DucElementBase } from '../duc/duc-element-base';
+export declare class DucImageElement {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DucImageElement;
+    static getRootAsDucImageElement(bb: flatbuffers.ByteBuffer, obj?: DucImageElement): DucImageElement;
+    static getSizePrefixedRootAsDucImageElement(bb: flatbuffers.ByteBuffer, obj?: DucImageElement): DucImageElement;
+    base(obj?: _DucElementBase): _DucElementBase | null;
+    fileId(): string | null;
+    fileId(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    status(): IMAGE_STATUS | null;
+    scale(index: number): number | null;
+    scaleLength(): number;
+    scaleArray(): Float64Array | null;
+    crop(obj?: ImageCrop): ImageCrop | null;
+    filter(obj?: DucImageFilter): DucImageFilter | null;
+    static startDucImageElement(builder: flatbuffers.Builder): void;
+    static addBase(builder: flatbuffers.Builder, baseOffset: flatbuffers.Offset): void;
+    static addFileId(builder: flatbuffers.Builder, fileIdOffset: flatbuffers.Offset): void;
+    static addStatus(builder: flatbuffers.Builder, status: IMAGE_STATUS): void;
+    static addScale(builder: flatbuffers.Builder, scaleOffset: flatbuffers.Offset): void;
+    static createScaleVector(builder: flatbuffers.Builder, data: number[] | Float64Array): flatbuffers.Offset;
+    /**
+     * @deprecated This Uint8Array overload will be removed in the future.
+     */
+    static createScaleVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startScaleVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addCrop(builder: flatbuffers.Builder, cropOffset: flatbuffers.Offset): void;
+    static addFilter(builder: flatbuffers.Builder, filterOffset: flatbuffers.Offset): void;
+    static endDucImageElement(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

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

@@ -0,0 +1,91 @@
+// 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 { DucImageFilter } from '../duc/duc-image-filter';
+import { ImageCrop } from '../duc/image-crop';
+import { _DucElementBase } from '../duc/duc-element-base';
+export class DucImageElement {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDucImageElement(bb, obj) {
+        return (obj || new DucImageElement()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDucImageElement(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DucImageElement()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    base(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new _DucElementBase()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    fileId(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    status() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    scale(index) {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0;
+    }
+    scaleLength() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    scaleArray() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    }
+    crop(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? (obj || new ImageCrop()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    filter(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? (obj || new DucImageFilter()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startDucImageElement(builder) {
+        builder.startObject(6);
+    }
+    static addBase(builder, baseOffset) {
+        builder.addFieldOffset(0, baseOffset, 0);
+    }
+    static addFileId(builder, fileIdOffset) {
+        builder.addFieldOffset(1, fileIdOffset, 0);
+    }
+    static addStatus(builder, status) {
+        builder.addFieldInt8(2, status, null);
+    }
+    static addScale(builder, scaleOffset) {
+        builder.addFieldOffset(3, scaleOffset, 0);
+    }
+    static createScaleVector(builder, data) {
+        builder.startVector(8, data.length, 8);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addFloat64(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startScaleVector(builder, numElems) {
+        builder.startVector(8, numElems, 8);
+    }
+    static addCrop(builder, cropOffset) {
+        builder.addFieldOffset(4, cropOffset, 0);
+    }
+    static addFilter(builder, filterOffset) {
+        builder.addFieldOffset(5, filterOffset, 0);
+    }
+    static endDucImageElement(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+}

package/dist/flatbuffers/duc/duc-image-filter.d.ts

@@ -0,0 +1,15 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class DucImageFilter {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DucImageFilter;
+    static getRootAsDucImageFilter(bb: flatbuffers.ByteBuffer, obj?: DucImageFilter): DucImageFilter;
+    static getSizePrefixedRootAsDucImageFilter(bb: flatbuffers.ByteBuffer, obj?: DucImageFilter): DucImageFilter;
+    brightness(): number;
+    contrast(): number;
+    static startDucImageFilter(builder: flatbuffers.Builder): void;
+    static addBrightness(builder: flatbuffers.Builder, brightness: number): void;
+    static addContrast(builder: flatbuffers.Builder, contrast: number): void;
+    static endDucImageFilter(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createDucImageFilter(builder: flatbuffers.Builder, brightness: number, contrast: number): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/duc-image-filter.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 DucImageFilter {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDucImageFilter(bb, obj) {
+        return (obj || new DucImageFilter()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDucImageFilter(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DucImageFilter()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    brightness() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
+    }
+    contrast() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
+    }
+    static startDucImageFilter(builder) {
+        builder.startObject(2);
+    }
+    static addBrightness(builder, brightness) {
+        builder.addFieldFloat32(0, brightness, 0.0);
+    }
+    static addContrast(builder, contrast) {
+        builder.addFieldFloat32(1, contrast, 0.0);
+    }
+    static endDucImageFilter(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createDucImageFilter(builder, brightness, contrast) {
+        DucImageFilter.startDucImageFilter(builder);
+        DucImageFilter.addBrightness(builder, brightness);
+        DucImageFilter.addContrast(builder, contrast);
+        return DucImageFilter.endDucImageFilter(builder);
+    }
+}

package/dist/flatbuffers/duc/duc-layer-overrides.d.ts

@@ -0,0 +1,16 @@
+import * as flatbuffers from 'flatbuffers';
+import { ElementBackground } from '../duc/element-background';
+import { ElementStroke } from '../duc/element-stroke';
+export declare class DucLayerOverrides {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DucLayerOverrides;
+    static getRootAsDucLayerOverrides(bb: flatbuffers.ByteBuffer, obj?: DucLayerOverrides): DucLayerOverrides;
+    static getSizePrefixedRootAsDucLayerOverrides(bb: flatbuffers.ByteBuffer, obj?: DucLayerOverrides): DucLayerOverrides;
+    stroke(obj?: ElementStroke): ElementStroke | null;
+    background(obj?: ElementBackground): ElementBackground | null;
+    static startDucLayerOverrides(builder: flatbuffers.Builder): void;
+    static addStroke(builder: flatbuffers.Builder, strokeOffset: flatbuffers.Offset): void;
+    static addBackground(builder: flatbuffers.Builder, backgroundOffset: flatbuffers.Offset): void;
+    static endDucLayerOverrides(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/duc-layer-overrides.js

@@ -0,0 +1,44 @@
+// 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 { ElementBackground } from '../duc/element-background';
+import { ElementStroke } from '../duc/element-stroke';
+export class DucLayerOverrides {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDucLayerOverrides(bb, obj) {
+        return (obj || new DucLayerOverrides()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDucLayerOverrides(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DucLayerOverrides()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    stroke(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new ElementStroke()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    background(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new ElementBackground()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startDucLayerOverrides(builder) {
+        builder.startObject(2);
+    }
+    static addStroke(builder, strokeOffset) {
+        builder.addFieldOffset(0, strokeOffset, 0);
+    }
+    static addBackground(builder, backgroundOffset) {
+        builder.addFieldOffset(1, backgroundOffset, 0);
+    }
+    static endDucLayerOverrides(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+}

package/dist/flatbuffers/duc/duc-layer.d.ts

@@ -0,0 +1,21 @@
+import * as flatbuffers from 'flatbuffers';
+import { DucLayerOverrides } from '../duc/duc-layer-overrides';
+import { _DucStackBase } from '../duc/duc-stack-base';
+export declare class DucLayer {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DucLayer;
+    static getRootAsDucLayer(bb: flatbuffers.ByteBuffer, obj?: DucLayer): DucLayer;
+    static getSizePrefixedRootAsDucLayer(bb: flatbuffers.ByteBuffer, obj?: DucLayer): DucLayer;
+    id(): string | null;
+    id(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    stackBase(obj?: _DucStackBase): _DucStackBase | null;
+    readonly(): boolean;
+    overrides(obj?: DucLayerOverrides): DucLayerOverrides | null;
+    static startDucLayer(builder: flatbuffers.Builder): void;
+    static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
+    static addStackBase(builder: flatbuffers.Builder, stackBaseOffset: flatbuffers.Offset): void;
+    static addReadonly(builder: flatbuffers.Builder, readonly: boolean): void;
+    static addOverrides(builder: flatbuffers.Builder, overridesOffset: flatbuffers.Offset): void;
+    static endDucLayer(builder: flatbuffers.Builder): flatbuffers.Offset;
+}