ducjs 2.1.0 → 2.2.3

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

@@ -1,6 +1,6 @@
 import * as flatbuffers from 'flatbuffers';
 import { DucBlockAttributeDefinitionEntry } from '../duc/duc-block-attribute-definition-entry';
-import { ElementWrapper } from '../duc/element-wrapper';
+import { DucBlockMetadata } from '../duc/duc-block-metadata';
 export declare class DucBlock {
     bb: flatbuffers.ByteBuffer | null;
     bb_pos: number;
@@ -14,21 +14,23 @@ export declare class DucBlock {
     description(): string | null;
     description(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
     version(): number;
-    elements(index: number, obj?: ElementWrapper): ElementWrapper | null;
-    elementsLength(): number;
     attributeDefinitions(index: number, obj?: DucBlockAttributeDefinitionEntry): DucBlockAttributeDefinitionEntry | null;
     attributeDefinitionsLength(): number;
+    metadata(obj?: DucBlockMetadata): DucBlockMetadata | null;
+    thumbnail(index: number): number | null;
+    thumbnailLength(): number;
+    thumbnailArray(): Uint8Array | null;
     static startDucBlock(builder: flatbuffers.Builder): void;
     static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
     static addLabel(builder: flatbuffers.Builder, labelOffset: flatbuffers.Offset): void;
     static addDescription(builder: flatbuffers.Builder, descriptionOffset: flatbuffers.Offset): void;
     static addVersion(builder: flatbuffers.Builder, version: number): void;
-    static addElements(builder: flatbuffers.Builder, elementsOffset: flatbuffers.Offset): void;
-    static createElementsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
-    static startElementsVector(builder: flatbuffers.Builder, numElems: number): void;
     static addAttributeDefinitions(builder: flatbuffers.Builder, attributeDefinitionsOffset: flatbuffers.Offset): void;
     static createAttributeDefinitionsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
     static startAttributeDefinitionsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addMetadata(builder: flatbuffers.Builder, metadataOffset: flatbuffers.Offset): void;
+    static addThumbnail(builder: flatbuffers.Builder, thumbnailOffset: flatbuffers.Offset): void;
+    static createThumbnailVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startThumbnailVector(builder: flatbuffers.Builder, numElems: number): void;
     static endDucBlock(builder: flatbuffers.Builder): flatbuffers.Offset;
-    static createDucBlock(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset, labelOffset: flatbuffers.Offset, descriptionOffset: flatbuffers.Offset, version: number, elementsOffset: flatbuffers.Offset, attributeDefinitionsOffset: flatbuffers.Offset): flatbuffers.Offset;
 }

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

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
 import * as flatbuffers from 'flatbuffers';
 import { DucBlockAttributeDefinitionEntry } from '../duc/duc-block-attribute-definition-entry';
-import { ElementWrapper } from '../duc/element-wrapper';
+import { DucBlockMetadata } from '../duc/duc-block-metadata';
 export class DucBlock {
     constructor() {
         this.bb = null;
@@ -36,24 +36,32 @@ export class DucBlock {
         const offset = this.bb.__offset(this.bb_pos, 10);
         return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
     }
-    elements(index, obj) {
+    attributeDefinitions(index, obj) {
         const offset = this.bb.__offset(this.bb_pos, 12);
-        return offset ? (obj || new ElementWrapper()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+        return offset ? (obj || new DucBlockAttributeDefinitionEntry()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
     }
-    elementsLength() {
+    attributeDefinitionsLength() {
         const offset = this.bb.__offset(this.bb_pos, 12);
         return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
     }
-    attributeDefinitions(index, obj) {
+    metadata(obj) {
         const offset = this.bb.__offset(this.bb_pos, 14);
-        return offset ? (obj || new DucBlockAttributeDefinitionEntry()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+        return offset ? (obj || new DucBlockMetadata()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
     }
-    attributeDefinitionsLength() {
-        const offset = this.bb.__offset(this.bb_pos, 14);
+    thumbnail(index) {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    }
+    thumbnailLength() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
         return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
     }
+    thumbnailArray() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        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;
+    }
     static startDucBlock(builder) {
-        builder.startObject(6);
+        builder.startObject(7);
     }
     static addId(builder, idOffset) {
         builder.addFieldOffset(0, idOffset, 0);
@@ -67,45 +75,38 @@ export class DucBlock {
     static addVersion(builder, version) {
         builder.addFieldInt32(3, version, 0);
     }
-    static addElements(builder, elementsOffset) {
-        builder.addFieldOffset(4, elementsOffset, 0);
+    static addAttributeDefinitions(builder, attributeDefinitionsOffset) {
+        builder.addFieldOffset(4, attributeDefinitionsOffset, 0);
     }
-    static createElementsVector(builder, data) {
+    static createAttributeDefinitionsVector(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 startElementsVector(builder, numElems) {
+    static startAttributeDefinitionsVector(builder, numElems) {
         builder.startVector(4, numElems, 4);
     }
-    static addAttributeDefinitions(builder, attributeDefinitionsOffset) {
-        builder.addFieldOffset(5, attributeDefinitionsOffset, 0);
+    static addMetadata(builder, metadataOffset) {
+        builder.addFieldOffset(5, metadataOffset, 0);
     }
-    static createAttributeDefinitionsVector(builder, data) {
-        builder.startVector(4, data.length, 4);
+    static addThumbnail(builder, thumbnailOffset) {
+        builder.addFieldOffset(6, thumbnailOffset, 0);
+    }
+    static createThumbnailVector(builder, data) {
+        builder.startVector(1, data.length, 1);
         for (let i = data.length - 1; i >= 0; i--) {
-            builder.addOffset(data[i]);
+            builder.addInt8(data[i]);
         }
         return builder.endVector();
     }
-    static startAttributeDefinitionsVector(builder, numElems) {
-        builder.startVector(4, numElems, 4);
+    static startThumbnailVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
     }
     static endDucBlock(builder) {
         const offset = builder.endObject();
         builder.requiredField(offset, 4); // id
         return offset;
     }
-    static createDucBlock(builder, idOffset, labelOffset, descriptionOffset, version, elementsOffset, attributeDefinitionsOffset) {
-        DucBlock.startDucBlock(builder);
-        DucBlock.addId(builder, idOffset);
-        DucBlock.addLabel(builder, labelOffset);
-        DucBlock.addDescription(builder, descriptionOffset);
-        DucBlock.addVersion(builder, version);
-        DucBlock.addElements(builder, elementsOffset);
-        DucBlock.addAttributeDefinitions(builder, attributeDefinitionsOffset);
-        return DucBlock.endDucBlock(builder);
-    }
 }

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

@@ -47,8 +47,14 @@ export declare class _DucElementBase {
     link(): string | null;
     link(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
     locked(): boolean;
-    customData(): string | null;
-    customData(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    blockIds(index: number): string;
+    blockIds(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;
+    blockIdsLength(): number;
+    instanceId(): string | null;
+    instanceId(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    customData(index: number): number | null;
+    customDataLength(): number;
+    customDataArray(): Uint8Array | null;
     static start_DucElementBase(builder: flatbuffers.Builder): void;
     static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
     static addStyles(builder: flatbuffers.Builder, stylesOffset: flatbuffers.Offset): void;
@@ -83,6 +89,12 @@ export declare class _DucElementBase {
     static addZIndex(builder: flatbuffers.Builder, zIndex: number): void;
     static addLink(builder: flatbuffers.Builder, linkOffset: flatbuffers.Offset): void;
     static addLocked(builder: flatbuffers.Builder, locked: boolean): void;
+    static addBlockIds(builder: flatbuffers.Builder, blockIdsOffset: flatbuffers.Offset): void;
+    static createBlockIdsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startBlockIdsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addInstanceId(builder: flatbuffers.Builder, instanceIdOffset: flatbuffers.Offset): void;
     static addCustomData(builder: flatbuffers.Builder, customDataOffset: flatbuffers.Offset): void;
+    static createCustomDataVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startCustomDataVector(builder: flatbuffers.Builder, numElems: number): void;
     static end_DucElementBase(builder: flatbuffers.Builder): flatbuffers.Offset;
 }

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

@@ -140,12 +140,32 @@ export class _DucElementBase {
         const offset = this.bb.__offset(this.bb_pos, 56);
         return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
     }
-    customData(optionalEncoding) {
-        const offset = this.bb.__offset(this.bb_pos, 58);
+    blockIds(index, optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 60);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+    }
+    blockIdsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 60);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    instanceId(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 62);
         return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
     }
+    customData(index) {
+        const offset = this.bb.__offset(this.bb_pos, 64);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    }
+    customDataLength() {
+        const offset = this.bb.__offset(this.bb_pos, 64);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    customDataArray() {
+        const offset = this.bb.__offset(this.bb_pos, 64);
+        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;
+    }
     static start_DucElementBase(builder) {
-        builder.startObject(28);
+        builder.startObject(31);
     }
     static addId(builder, idOffset) {
         builder.addFieldOffset(0, idOffset, 0);
@@ -258,8 +278,34 @@ export class _DucElementBase {
     static addLocked(builder, locked) {
         builder.addFieldInt8(26, +locked, +false);
     }
+    static addBlockIds(builder, blockIdsOffset) {
+        builder.addFieldOffset(28, blockIdsOffset, 0);
+    }
+    static createBlockIdsVector(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 startBlockIdsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addInstanceId(builder, instanceIdOffset) {
+        builder.addFieldOffset(29, instanceIdOffset, 0);
+    }
     static addCustomData(builder, customDataOffset) {
-        builder.addFieldOffset(27, customDataOffset, 0);
+        builder.addFieldOffset(30, customDataOffset, 0);
+    }
+    static createCustomDataVector(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 startCustomDataVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
     }
     static end_DucElementBase(builder) {
         const offset = builder.endObject();

package/dist/flatbuffers/duc/exported-data-state.d.ts

@@ -1,6 +1,8 @@
 import * as flatbuffers from 'flatbuffers';
 import { DictionaryEntry } from '../duc/dictionary-entry';
 import { DucBlock } from '../duc/duc-block';
+import { DucBlockCollection } from '../duc/duc-block-collection';
+import { DucBlockInstance } from '../duc/duc-block-instance';
 import { DucExternalFileEntry } from '../duc/duc-external-file-entry';
 import { DucGlobalState } from '../duc/duc-global-state';
 import { DucGroup } from '../duc/duc-group';
@@ -48,6 +50,10 @@ export declare class ExportedDataState {
     versionGraph(obj?: VersionGraph): VersionGraph | null;
     id(): string | null;
     id(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    blockInstances(index: number, obj?: DucBlockInstance): DucBlockInstance | null;
+    blockInstancesLength(): number;
+    blockCollections(index: number, obj?: DucBlockCollection): DucBlockCollection | null;
+    blockCollectionsLength(): number;
     static startExportedDataState(builder: flatbuffers.Builder): void;
     static addType(builder: flatbuffers.Builder, typeOffset: flatbuffers.Offset): void;
     static addVersionLegacy(builder: flatbuffers.Builder, versionLegacy: number): void;
@@ -84,6 +90,12 @@ export declare class ExportedDataState {
     static startExternalFilesVector(builder: flatbuffers.Builder, numElems: number): void;
     static addVersionGraph(builder: flatbuffers.Builder, versionGraphOffset: flatbuffers.Offset): void;
     static addId(builder: flatbuffers.Builder, idOffset: flatbuffers.Offset): void;
+    static addBlockInstances(builder: flatbuffers.Builder, blockInstancesOffset: flatbuffers.Offset): void;
+    static createBlockInstancesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startBlockInstancesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addBlockCollections(builder: flatbuffers.Builder, blockCollectionsOffset: flatbuffers.Offset): void;
+    static createBlockCollectionsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startBlockCollectionsVector(builder: flatbuffers.Builder, numElems: number): void;
     static endExportedDataState(builder: flatbuffers.Builder): flatbuffers.Offset;
     static finishExportedDataStateBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
     static finishSizePrefixedExportedDataStateBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;

package/dist/flatbuffers/duc/exported-data-state.js

@@ -3,6 +3,8 @@
 import * as flatbuffers from 'flatbuffers';
 import { DictionaryEntry } from '../duc/dictionary-entry';
 import { DucBlock } from '../duc/duc-block';
+import { DucBlockCollection } from '../duc/duc-block-collection';
+import { DucBlockInstance } from '../duc/duc-block-instance';
 import { DucExternalFileEntry } from '../duc/duc-external-file-entry';
 import { DucGlobalState } from '../duc/duc-global-state';
 import { DucGroup } from '../duc/duc-group';
@@ -140,8 +142,24 @@ export class ExportedDataState {
         const offset = this.bb.__offset(this.bb_pos, 36);
         return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
     }
+    blockInstances(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 38);
+        return offset ? (obj || new DucBlockInstance()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    blockInstancesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 38);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    blockCollections(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 40);
+        return offset ? (obj || new DucBlockCollection()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    blockCollectionsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 40);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
     static startExportedDataState(builder) {
-        builder.startObject(17);
+        builder.startObject(19);
     }
     static addType(builder, typeOffset) {
         builder.addFieldOffset(0, typeOffset, 0);
@@ -284,6 +302,32 @@ export class ExportedDataState {
     static addId(builder, idOffset) {
         builder.addFieldOffset(16, idOffset, 0);
     }
+    static addBlockInstances(builder, blockInstancesOffset) {
+        builder.addFieldOffset(17, blockInstancesOffset, 0);
+    }
+    static createBlockInstancesVector(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 startBlockInstancesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addBlockCollections(builder, blockCollectionsOffset) {
+        builder.addFieldOffset(18, blockCollectionsOffset, 0);
+    }
+    static createBlockCollectionsVector(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 startBlockCollectionsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
     static endExportedDataState(builder) {
         const offset = builder.endObject();
         return offset;

package/dist/flatbuffers/duc.d.ts

@@ -35,8 +35,12 @@ export { DucArrowElement } from './duc/duc-arrow-element';
 export { DucBlock } from './duc/duc-block';
 export { DucBlockAttributeDefinition } from './duc/duc-block-attribute-definition';
 export { DucBlockAttributeDefinitionEntry } from './duc/duc-block-attribute-definition-entry';
+export { DucBlockCollection } from './duc/duc-block-collection';
+export { DucBlockCollectionEntry } from './duc/duc-block-collection-entry';
 export { DucBlockDuplicationArray } from './duc/duc-block-duplication-array';
+export { DucBlockInstance } from './duc/duc-block-instance';
 export { DucBlockInstanceElement } from './duc/duc-block-instance-element';
+export { DucBlockMetadata } from './duc/duc-block-metadata';
 export { DucCommonStyle } from './duc/duc-common-style';
 export { DucDimensionElement } from './duc/duc-dimension-element';
 export { DucDimensionStyle } from './duc/duc-dimension-style';

package/dist/flatbuffers/duc.js

@@ -37,8 +37,12 @@ export { DucArrowElement } from './duc/duc-arrow-element';
 export { DucBlock } from './duc/duc-block';
 export { DucBlockAttributeDefinition } from './duc/duc-block-attribute-definition';
 export { DucBlockAttributeDefinitionEntry } from './duc/duc-block-attribute-definition-entry';
+export { DucBlockCollection } from './duc/duc-block-collection';
+export { DucBlockCollectionEntry } from './duc/duc-block-collection-entry';
 export { DucBlockDuplicationArray } from './duc/duc-block-duplication-array';
+export { DucBlockInstance } from './duc/duc-block-instance';
 export { DucBlockInstanceElement } from './duc/duc-block-instance-element';
+export { DucBlockMetadata } from './duc/duc-block-metadata';
 export { DucCommonStyle } from './duc/duc-common-style';
 export { DucDimensionElement } from './duc/duc-dimension-element';
 export { DucDimensionStyle } from './duc/duc-dimension-style';

package/dist/parse.js

@@ -7,9 +7,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { DucArrowElement as DucArrowElementFb, DucBlockInstanceElement as DucBlockInstanceElementFb, DucDimensionElement as DucDimensionElementFb, DucDocElement as DucDocElementFb, DucEllipseElement as DucEllipseElementFb, DucEmbeddableElement as DucEmbeddableElementFb, DucFeatureControlFrameElement as DucFeatureControlFrameElementFb, DucFrameElement as DucFrameElementFb, DucFreeDrawElement as DucFreeDrawElementFb, DucImageElement as DucImageElementFb, DucLeaderElement as DucLeaderElementFb, DucLinearElement as DucLinearElementFb, DucMermaidElement as DucMermaidElementFb, DucParametricElement as DucParametricElementFb, DucPdfElement as DucPdfElementFb, DucPlotElement as DucPlotElementFb, DucPolygonElement as DucPolygonElementFb, DucRectangleElement as DucRectangleElementFb, DucTableElement as DucTableElementFb, DucTextDynamicDictionarySource as DucTextDynamicDictionarySourceFb, DucTextDynamicElementSource as DucTextDynamicElementSourceFb, DucTextElement as DucTextElementFb, DucViewportElement as DucViewportElementFb, DucXRayElement as DucXRayElementFb, Element as ElementUnion, ExportedDataState, LEADER_CONTENT_TYPE as LEADER_CONTENT_TYPE_ENUM, LeaderBlockContent as LeaderBlockContentFb, LeaderTextBlockContent as LeaderTextBlockContentFb, TEXT_FIELD_SOURCE_TYPE } from "./flatbuffers/duc";
-import { restore } from "./restore";
+import { decompressSync, strFromU8 } from 'fflate';
 import * as flatbuffers from "flatbuffers";
+import { nanoid } from 'nanoid';
+import { DucArrowElement as DucArrowElementFb, DucDimensionElement as DucDimensionElementFb, DucDocElement as DucDocElementFb, DucEllipseElement as DucEllipseElementFb, DucEmbeddableElement as DucEmbeddableElementFb, DucFeatureControlFrameElement as DucFeatureControlFrameElementFb, DucFrameElement as DucFrameElementFb, DucFreeDrawElement as DucFreeDrawElementFb, DucImageElement as DucImageElementFb, DucLeaderElement as DucLeaderElementFb, DucLinearElement as DucLinearElementFb, DucMermaidElement as DucMermaidElementFb, DucParametricElement as DucParametricElementFb, DucPdfElement as DucPdfElementFb, DucPlotElement as DucPlotElementFb, DucPolygonElement as DucPolygonElementFb, DucRectangleElement as DucRectangleElementFb, DucTableElement as DucTableElementFb, DucTextDynamicDictionarySource as DucTextDynamicDictionarySourceFb, DucTextDynamicElementSource as DucTextDynamicElementSourceFb, DucTextElement as DucTextElementFb, DucViewportElement as DucViewportElementFb, DucXRayElement as DucXRayElementFb, Element as ElementUnion, ExportedDataState, LEADER_CONTENT_TYPE as LEADER_CONTENT_TYPE_ENUM, LeaderBlockContent as LeaderBlockContentFb, LeaderTextBlockContent as LeaderTextBlockContentFb, TEXT_FIELD_SOURCE_TYPE } from "./flatbuffers/duc";
+import { restore } from "./restore";
 // #region HELPERS & LOW-LEVEL CASTS
 // Helper functions for type casting
 const toPrecisionValue = (value) => ({
@@ -23,6 +25,29 @@ const toZoom = (value) => ({
     value: value
 });
 // #endregion
+// Helper function to parse binary JSON data (Uint8Array) to object
+// The data is zlib-compressed JSON (new format) or plain JSON string (legacy format)
+function parseBinaryToJson(binaryData) {
+    if (!binaryData || binaryData.length === 0)
+        return undefined;
+    // Try new format: zlib-compressed binary JSON
+    try {
+        const decompressed = decompressSync(binaryData);
+        const text = strFromU8(decompressed);
+        return JSON.parse(text);
+    }
+    catch (e) {
+        // Fall back to legacy format: plain JSON string (for old file compatibility)
+        try {
+            const text = new TextDecoder().decode(binaryData);
+            return JSON.parse(text);
+        }
+        catch (e2) {
+            console.warn('Failed to parse binary JSON (tried both compressed and legacy formats):', e2);
+            return undefined;
+        }
+    }
+}
 // #region GEOMETRY & UTILITY PARSERS
 export function parseGeometricPoint(point) {
     return {
@@ -164,10 +189,10 @@ export function parseElementBase(base) {
         stroke: [],
         opacity: toPercentage(1),
     };
-    return Object.assign({ id: base.id(), x: toPrecisionValue(base.x()), y: toPrecisionValue(base.y()), width: toPrecisionValue(base.width()), height: toPrecisionValue(base.height()), angle: toRadian(base.angle()), scope: base.scope(), label: base.label(), description: base.description(), isVisible: base.isVisible(), seed: base.seed(), version: base.version(), versionNonce: base.versionNonce(), updated: Number(base.updated()), index: base.index(), isPlot: base.isPlot(), isAnnotative: base.isAnnotative(), isDeleted: base.isDeleted(), groupIds: Array.from({ length: base.groupIdsLength() }, (_, i) => base.groupIds(i)), regionIds: Array.from({ length: base.regionIdsLength() }, (_, i) => base.regionIds(i)), layerId: base.layerId(), frameId: base.frameId(), boundElements: base.boundElementsLength() > 0 ? Array.from({ length: base.boundElementsLength() }, (_, i) => ({
+    return Object.assign({ id: base.id(), x: toPrecisionValue(base.x()), y: toPrecisionValue(base.y()), width: toPrecisionValue(base.width()), height: toPrecisionValue(base.height()), angle: toRadian(base.angle()), scope: base.scope(), label: base.label(), description: base.description(), isVisible: base.isVisible(), seed: base.seed(), version: base.version(), versionNonce: base.versionNonce(), updated: Number(base.updated()), index: base.index(), isPlot: base.isPlot(), isAnnotative: base.isAnnotative(), isDeleted: base.isDeleted(), groupIds: Array.from({ length: base.groupIdsLength() }, (_, i) => base.groupIds(i)), regionIds: Array.from({ length: base.regionIdsLength() }, (_, i) => base.regionIds(i)), blockIds: Array.from({ length: base.blockIdsLength() }, (_, i) => base.blockIds(i)), instanceId: base.instanceId(), layerId: base.layerId(), frameId: base.frameId(), boundElements: base.boundElementsLength() > 0 ? Array.from({ length: base.boundElementsLength() }, (_, i) => ({
             id: base.boundElements(i).id(),
             type: base.boundElements(i).type(),
-        })) : null, zIndex: base.zIndex(), link: base.link(), locked: base.locked(), customData: base.customData() ? JSON.parse(base.customData()) : undefined }, parsedStyles);
+        })) : null, zIndex: base.zIndex(), link: base.link(), locked: base.locked(), customData: parseBinaryToJson(base.customDataArray()) }, parsedStyles);
 }
 export function parseLineReference(ref) {
     return {
@@ -333,24 +358,60 @@ function parseFreeDrawElement(element) {
     const end = element.end();
     return Object.assign(Object.assign({ type: "freedraw" }, parseElementBase(element.base())), { points: Array.from({ length: element.pointsLength() }, (_, i) => parsePoint(element.points(i))), size: toPrecisionValue(element.size()), thinning: toPercentage(element.thinning()), smoothing: toPercentage(element.smoothing()), streamline: toPercentage(element.streamline()), easing: element.easing(), start: start ? { cap: start.cap(), taper: start.taper(), easing: start.easing() } : null, end: end ? { cap: end.cap(), taper: end.taper(), easing: end.easing() } : null, pressures: Array.from(element.pressuresArray() || []), simulatePressure: element.simulatePressure(), lastCommittedPoint: element.lastCommittedPoint() ? parsePoint(element.lastCommittedPoint()) : null, svgPath: element.svgPath() });
 }
-function parseBlockInstanceElement(element) {
-    const duplicationArray = element.duplicationArray();
+function parseBlockInstance(instance) {
+    const duplicationArray = instance.duplicationArray();
     const attributeValues = {};
-    for (let i = 0; i < element.attributeValuesLength(); i++) {
-        const entry = element.attributeValues(i);
+    for (let i = 0; i < instance.attributeValuesLength(); i++) {
+        const entry = instance.attributeValues(i);
         attributeValues[entry.key()] = entry.value();
     }
     const elementOverrides = {};
-    for (let i = 0; i < element.elementOverridesLength(); i++) {
-        const entry = element.elementOverrides(i);
+    for (let i = 0; i < instance.elementOverridesLength(); i++) {
+        const entry = instance.elementOverrides(i);
         elementOverrides[entry.key()] = entry.value();
     }
-    return Object.assign(Object.assign({ type: "blockinstance" }, parseElementBase(element.base())), { blockId: element.blockId(), attributeValues: attributeValues, elementOverrides: elementOverrides, duplicationArray: duplicationArray ? {
+    return {
+        id: instance.id(),
+        blockId: instance.blockId(),
+        version: instance.version(),
+        attributeValues: attributeValues,
+        elementOverrides: elementOverrides,
+        duplicationArray: duplicationArray ? {
             rows: duplicationArray.rows(),
             cols: duplicationArray.cols(),
             rowSpacing: toPrecisionValue(duplicationArray.rowSpacing()),
             colSpacing: toPrecisionValue(duplicationArray.colSpacing()),
-        } : null });
+        } : null,
+    };
+}
+// Helper function to parse block metadata from FlatBuffers
+function parseBlockMetadata(metadataFb) {
+    if (!metadataFb)
+        return undefined;
+    // localization is now binary JSON data (Uint8Array)
+    const localization = parseBinaryToJson(metadataFb.localizationArray());
+    const rawSource = metadataFb.source();
+    const source = typeof rawSource === "string" && rawSource.trim().length
+        ? rawSource.trim()
+        : undefined;
+    return Object.assign(Object.assign({}, (source ? { source } : {})), { usageCount: metadataFb.usageCount(), createdAt: Number(metadataFb.createdAt()), updatedAt: Number(metadataFb.updatedAt()), localization });
+}
+function parseBlockCollection(collection) {
+    const children = Array.from({ length: collection.childrenLength() }, (_, i) => {
+        const child = collection.children(i);
+        return {
+            id: child.id(),
+            isCollection: child.isCollection(),
+        };
+    });
+    const metadata = parseBlockMetadata(collection.metadata());
+    return {
+        id: collection.id(),
+        label: collection.label(),
+        children,
+        metadata,
+        thumbnail: collection.thumbnailArray() || undefined,
+    };
 }
 function parseFrameElement(element) {
     return Object.assign({ type: "frame" }, parseStackElementBase(element.stackElementBase()));
@@ -687,9 +748,6 @@ export function parseElementFromBinary(wrapper) {
         case ElementUnion.DucFreeDrawElement:
             element = wrapper.element(new DucFreeDrawElementFb());
             break;
-        case ElementUnion.DucBlockInstanceElement:
-            element = wrapper.element(new DucBlockInstanceElementFb());
-            break;
         case ElementUnion.DucFrameElement:
             element = wrapper.element(new DucFrameElementFb());
             break;
@@ -749,8 +807,6 @@ export function parseElementFromBinary(wrapper) {
             return parseArrowElement(element);
         case ElementUnion.DucFreeDrawElement:
             return parseFreeDrawElement(element);
-        case ElementUnion.DucBlockInstanceElement:
-            return parseBlockInstanceElement(element);
         case ElementUnion.DucFrameElement:
             return parseFrameElement(element);
         case ElementUnion.DucPlotElement:
@@ -787,14 +843,18 @@ export function parseBlockFromBinary(block) {
             isConstant: def.isConstant(),
         };
     }
+    // Parse metadata if present
+    const metadata = parseBlockMetadata(block.metadata());
+    // Parse thumbnail if present
+    const thumbnail = block.thumbnailArray();
     return {
         id: block.id(),
         label: block.label(),
         description: block.description() || undefined,
         version: block.version(),
-        // Filter out any nulls that may arise from malformed entries
-        elements: Array.from({ length: block.elementsLength() }, (_, i) => parseElementFromBinary(block.elements(i))).filter(Boolean),
         attributeDefinitions,
+        metadata,
+        thumbnail: thumbnail || undefined,
     };
 }
 export function parseDictionaryFromBinary(data) {
@@ -1191,15 +1251,7 @@ export function parseVersionGraphFromBinary(graph) {
                 description: base.description() || undefined,
                 isManualSave: base.isManualSave(),
                 userId: base.userId() || undefined,
-                patch: Array.from({ length: d.patchLength() }, (_, j) => {
-                    const p = d.patch(j);
-                    return {
-                        op: p.op(),
-                        path: p.path(),
-                        from: p.from() || undefined,
-                        value: p.value() ? JSON.parse(p.value()) : undefined,
-                    };
-                }),
+                patch: parseBinaryToJson(d.patchArray()),
             };
         }),
         metadata: {
@@ -1266,6 +1318,28 @@ export const parseDuc = (blob_1, ...args_1) => __awaiter(void 0, [blob_1, ...arg
             }
         }
     }
+    // Parse block instances
+    const blockInstances = [];
+    for (let i = 0; i < data.blockInstancesLength(); i++) {
+        const blockInstance = data.blockInstances(i);
+        if (blockInstance) {
+            const parsedBlockInstance = parseBlockInstance(blockInstance);
+            if (parsedBlockInstance) {
+                blockInstances.push(parsedBlockInstance);
+            }
+        }
+    }
+    // Parse block collections
+    const blockCollections = [];
+    for (let i = 0; i < data.blockCollectionsLength(); i++) {
+        const blockCollection = data.blockCollections(i);
+        if (blockCollection) {
+            const parsedBlockCollection = parseBlockCollection(blockCollection);
+            if (parsedBlockCollection) {
+                blockCollections.push(parsedBlockCollection);
+            }
+        }
+    }
     // Parse groups
     const groups = [];
     for (let i = 0; i < data.groupsLength(); i++) {
@@ -1317,21 +1391,24 @@ export const parseDuc = (blob_1, ...args_1) => __awaiter(void 0, [blob_1, ...arg
             }
         }
     }
-    const sanitized = restore({
+    const exportData = {
         thumbnail,
         dictionary,
         elements: elements,
         localState: parsedLocalState,
         globalState: parsedGlobalState,
         blocks,
+        blockInstances,
+        blockCollections,
         groups,
         regions,
         layers,
         standards,
         files: parsedFiles,
         versionGraph: versionGraph !== null && versionGraph !== void 0 ? versionGraph : undefined,
-        id: (_a = data.id()) !== null && _a !== void 0 ? _a : undefined,
-    }, {
+        id: (_a = data.id()) !== null && _a !== void 0 ? _a : nanoid(),
+    };
+    const sanitized = restore(exportData, {
         syncInvalidIndices: (elements) => elements,
         repairBindings: true,
         refreshDimensions: false,
@@ -1344,9 +1421,11 @@ export const parseDuc = (blob_1, ...args_1) => __awaiter(void 0, [blob_1, ...arg
         globalState: sanitized.globalState,
         files: sanitized.files,
         blocks: sanitized.blocks,
+        blockInstances: sanitized.blockInstances,
         groups: sanitized.groups,
         regions: sanitized.regions,
         layers: sanitized.layers,
+        blockCollections: sanitized.blockCollections,
         standards: sanitized.standards,
         versionGraph: sanitized.versionGraph,
         id: sanitized.id,