zyf-model-engine 0.0.2 → 0.2.0

package/types/libs/MathUtils.d.ts

@@ -0,0 +1,26 @@
+function LinearColor(c: number): number;
+
+function SRgbColor(c: number): number;
+
+function Luminance(color: number): number;
+
+function ContrastRatio(c1: number, c2: number): number;
+
+function HlsToRgb({ h, l, s }: { [k: string]: number }): number;
+
+function RgbToHls(color: number): { h: number; l: number; s: number };
+
+function Lighten(color: number, factor: number): number;
+
+function Darken(color: number, factor: number): number;
+
+const MathUtils = {
+  HlsToRgb,
+  RgbToHls,
+  Lighten,
+  Darken,
+  Luminance,
+  ContrastRatio
+};
+
+export default MathUtils;

package/types/libs/ViewCube.d.ts

@@ -0,0 +1,21 @@
+import { Box3, Camera, Group } from 'three';
+import { OrbitControls } from '../vendor/controls/OrbitControls';
+declare class ViewCube {
+    readonly group: Group;
+    private sceneCamera;
+    private cubeCamera;
+    private element;
+    private meshs;
+    private currentMesh;
+    private raycaster;
+    private control;
+    private moveMesh;
+    private size;
+    private getAllObjectBox;
+    constructor(camera: Camera, cubeCamera: Camera, element: HTMLCanvasElement, getAllObjectBox: () => Box3, size?: number);
+    private mouseEvent;
+    private clickEvent;
+    private changeCamera;
+    setControl(control: OrbitControls): void;
+}
+export { ViewCube };

package/types/libs/materials.d.ts

@@ -0,0 +1,4 @@
+import { ShaderMaterial, SpriteMaterial } from 'three';
+declare const pointMaterial: SpriteMaterial;
+declare const shaderMterial: () => ShaderMaterial;
+export { pointMaterial, shaderMterial };

package/types/libs/svg.d.ts

@@ -0,0 +1,26 @@
+declare const viewImg: () => HTMLDivElement;
+declare const flyImg: () => HTMLDivElement;
+declare const distanceImg: () => HTMLDivElement;
+declare const personImg: () => HTMLDivElement;
+declare const angleImg: () => HTMLDivElement;
+declare const heightImg: () => HTMLDivElement;
+declare const roamingImg: () => HTMLDivElement;
+declare const screenImg: () => HTMLDivElement;
+declare const cuttingImg: () => HTMLDivElement;
+declare const measureImg: () => HTMLDivElement;
+declare const measureImg2: () => HTMLDivElement;
+declare const infoImg: () => HTMLDivElement;
+declare const fullImg: () => HTMLDivElement;
+declare const localCutting: () => HTMLDivElement;
+declare const globalCutting: () => HTMLDivElement;
+declare const triangleRound: () => HTMLDivElement;
+declare const checkBox: () => HTMLDivElement;
+declare const cutBox: () => HTMLDivElement;
+declare const verCut: () => HTMLDivElement;
+declare function iconSet(): HTMLDivElement;
+declare function iconSetting(): HTMLDivElement;
+declare function areaImg(): HTMLDivElement;
+declare function layersImg(): HTMLDivElement;
+declare function turnImg(): HTMLDivElement;
+declare function settingImg(): HTMLDivElement;
+export { viewImg, checkBox, iconSet, triangleRound, flyImg, measureImg, fullImg, infoImg, distanceImg, personImg, angleImg, heightImg, roamingImg, screenImg, cuttingImg, localCutting, globalCutting, verCut, cutBox, measureImg2, iconSetting, areaImg, layersImg, turnImg, settingImg };

package/types/libs/types.d.ts

@@ -0,0 +1,177 @@
+import { Color, Texture, Vector3, WebGLCubeRenderTarget, Material, MeshBasicMaterialParameters, Object3D } from 'three';
+import { UtilsMenuProps } from '../components/UtilsMenu/interface/index';
+export interface textType {
+    text: string;
+    hWorldText?: number;
+    hPxText?: number;
+    hWorldAll?: number;
+    vertical?: boolean;
+    fgColor?: string;
+    fontFamily?: string;
+    letterSpacing?: number;
+    bold?: string;
+    italic?: boolean;
+    textAlign?: CanvasRenderingContext2D["textAlign"];
+    bgColor?: string;
+}
+export type controlParams = {
+    scale?: number;
+    translate?: number;
+    moveSpeed?: number;
+    rotateSpeed?: number;
+};
+export interface LightParams {
+    color?: number;
+    intensity?: number;
+    distance?: number;
+    decay?: number;
+    position?: Vector3;
+    angle?: number;
+    penumbra?: number;
+}
+export interface FlyMaterialTypes {
+    time?: number;
+    number?: number;
+    speed?: number;
+    length?: number;
+    size?: number;
+    color?: Vector3;
+}
+export type blankMethod = (data: any, id?: any) => void;
+export interface ComponentConfig {
+    wrapper: HTMLBaseElement;
+    resetView?: {
+        img?: string;
+        text?: string;
+    };
+    roaming?: {
+        img?: string;
+        text?: string;
+        moveMax?: number;
+        rotateMax?: number;
+    };
+    screenshot?: {
+        img?: string;
+        text?: string;
+        download?: boolean;
+        eventName?: string;
+    };
+    cutting?: {
+        img?: string;
+        text?: string;
+    };
+    measure?: {
+        img?: string;
+        text?: string;
+    };
+    information?: {
+        callback: (guid: string, fileId: number) => Promise<any[]>;
+        img?: string;
+        text?: string;
+        color?: number;
+        opacity?: number;
+    };
+    fullScreen?: {
+        img?: string;
+        text?: string;
+    };
+    fitView?: {
+        img?: string;
+        text?: string;
+        padding?: number;
+    };
+    handleLayers?: {
+        img?: string;
+        text?: string;
+    };
+    dxfMeasure?: {
+        img?: string;
+        text?: string;
+    };
+    colorTurn?: {
+        img?: string;
+        text?: string;
+    };
+    baseInfo?: {
+        img?: string;
+        text?: string;
+    };
+    baseSetting?: {
+        img?: string;
+        text?: string;
+    };
+}
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export interface MouseEventType {
+    type: keyof HTMLElementEventMap;
+    callback?: (...arg: any[]) => any;
+    executeBeforeCallback?: (...arg: any[]) => any;
+    options?: boolean | AddEventListenerOptions;
+    rayResultOption?: {
+        highLightMesh?: boolean;
+        focus?: boolean;
+        useDefault?: boolean;
+        useRaycasterResult?: boolean;
+        intersectObjectsParams?: {
+            objects?: Object3D[];
+            recursive?: boolean;
+            optionalTarget?: any[];
+        };
+    };
+}
+export interface ViewerOptions {
+    baseConfig?: {
+        background?: Texture | Color | WebGLCubeRenderTarget | null;
+        clearColor?: number;
+        transparent?: number;
+        clickHighlight?: boolean;
+    };
+    cube?: {
+        show: boolean;
+        size?: number;
+    };
+    light?: {
+        ambient?: LightParams;
+        direct?: LightParams;
+    };
+    rayCaster?: MouseEventType | MouseEventType[] | undefined;
+    highLightMeshMaterial?: Material | MeshBasicMaterialParameters;
+    utilsMenu?: DeepPartial<UtilsMenuProps>;
+    hiddenMeshGuids?: string[];
+    maximumNumberOfThreads?: number;
+}
+export interface featureItem {
+    geometry: {
+        coordinates: Array<Array<Array<number>>>;
+        type: string;
+    };
+    properties: {
+        Id: number;
+        height: number;
+    };
+    type: string;
+}
+export interface TreeConfig {
+    model: {
+        show: boolean;
+        name: string;
+    };
+    floor: {
+        show: boolean;
+        name: string;
+        layer: number;
+    };
+    component: {
+        show: boolean;
+        name: string;
+        layer: number;
+    };
+    background: string;
+    highLightMeshs: boolean;
+    eventName: string;
+    triangleClickCallBack?: Function;
+    inputPointerupCallBack?: Function;
+}
+export {};

package/types/main.d.ts

@@ -0,0 +1,22 @@
+import { default as Viewer } from './index';
+import { default as ViewerCom } from './index.vue';
+import { default as DxfViewerCom } from './index-dxf.vue';
+import { DxfViewer } from './workbench/DxfViewer';
+import { DxfTools, FitView, HandleLayers, dxfMeasure } from './workbench/dxfTools';
+import { Measure } from './components/UtilsMenu/components/Measure/measure';
+import { Clipping } from './workbench/clipping';
+import { information } from './workbench/clickInfo';
+import { DXFMeasure } from './workbench/dxfMeasure';
+import { default as ModelTree } from './workbench/modelTree';
+import { FunctionalComponent, resetView, roaming, screenShot, cutting, fullScreen, constructInfo, measureFun } from './workbench/functionalComponent';
+import { createTwoFace, createThreeFace } from './libs/CFace';
+import { CLine } from './libs/CLine';
+import { createText, createHeightText } from './libs/CText';
+import { default as MathUtils } from './libs/MathUtils';
+import { viewImg, checkBox, iconSet, triangleRound, flyImg, measureImg, fullImg, infoImg, distanceImg, personImg, angleImg, heightImg, roamingImg, screenImg, cuttingImg, localCutting, globalCutting, verCut, cutBox, measureImg2, iconSetting, layersImg, areaImg } from './libs/svg';
+import { GLTFLoader } from './vendor/loaders/GLTFLoader';
+import { calculateArea, calculateAngle } from './tools/math';
+import { default as Event } from './tools/Events';
+import { DxfParser } from './vendor/DXFPaser/index';
+import * as THREE from "three";
+export { ViewerCom, DxfViewerCom, Viewer, Measure, Clipping, information, ModelTree, FunctionalComponent, resetView, roaming, screenShot, cutting, fullScreen, constructInfo, measureFun, THREE, Event, DxfParser, DxfViewer, DXFMeasure, createTwoFace, createThreeFace, viewImg, checkBox, iconSet, triangleRound, flyImg, measureImg, fullImg, infoImg, distanceImg, personImg, angleImg, heightImg, roamingImg, screenImg, cuttingImg, localCutting, globalCutting, verCut, cutBox, measureImg2, iconSetting, CLine, createText, createHeightText, MathUtils, GLTFLoader, calculateArea, calculateAngle, layersImg, areaImg, DxfTools, FitView, HandleLayers, dxfMeasure };

package/types/manager/highLightMeshManager.d.ts

@@ -0,0 +1,31 @@
+import { BufferGeometry, Mesh, MeshBasicMaterial, LineBasicMaterial, LineSegments, Material, MeshBasicMaterialParameters } from 'three';
+import { default as Viewer } from '../index';
+export default class HighLightMeshManager {
+    private viewer;
+    highLightMesh: Mesh;
+    highLightMeshLine: LineSegments;
+    sparklingMesh: Mesh | Mesh[];
+    keyDisplay: Mesh[];
+    constructor(viewer: Viewer);
+    setHighLightMeshMaterial(meshMaterial: MeshBasicMaterial | MeshBasicMaterialParameters, lineMaterial?: LineBasicMaterial | MeshBasicMaterialParameters): void;
+    /**
+     * 高亮指定的 Mesh。
+     *
+     * @param ids - 需要高亮的 Mesh 的 ID 数组
+     * @param idType - ID 的类型，uuid 或 guid
+     * @param animation - 是否播放动画
+     */
+    setHighLightById(ids: string[], idType?: "uuid" | "guid", animation?: boolean, getMesh?: boolean): (Mesh<import('three').Geometry | BufferGeometry, Material | Material[]> | LineSegments<import('three').Geometry | BufferGeometry, Material | Material[]>)[];
+    /**
+     * 设置高亮 Mesh。
+     * @param geometry - 高亮的几何体
+     */
+    setHighLightMesh(geometry: BufferGeometry): void;
+    updateHighLightMeshLine(): void;
+    setKeyDisplay(mesh: Mesh | Mesh[]): void;
+    clearHeightMeshAndTreeHeightLight(): void;
+    /**
+     * 清除高亮 Mesh。
+     */
+    clearHighLightMesh(resetView?: boolean): void;
+}

package/types/manager/lightManager.d.ts

@@ -0,0 +1,35 @@
+import { AmbientLight, DirectionalLight, PointLight, SpotLight } from 'three';
+import { LightParams } from '../libs/types';
+import { default as Viewer } from '../index';
+/**
+ * 灯光管理器。
+ */
+export default class LightManager {
+    private viewer;
+    constructor(viewer: Viewer);
+    /**
+     * 添加环境光。
+     * @param params - 灯光参数
+     * @returns 添加的环境光
+     */
+    addAmbientLight(params: LightParams): AmbientLight;
+    /**
+     * 添加点光源。
+     * @param params - 灯光参数
+     * @returns 添加的点光源
+     */
+    addPointLight(params: LightParams): PointLight;
+    /**
+     * 添加聚光灯。
+     * @param params - 灯光参数
+     * @returns 添加的聚光灯
+     */
+    addSpotLight(params: LightParams): SpotLight;
+    /**
+     * 添加平行光。
+     * @param params - 灯光参数
+     * @returns 添加的平行光
+     */
+    addDirectionalLight(params: LightParams): DirectionalLight;
+    updateLightIntensity(light: AmbientLight | DirectionalLight, intensity: number): void;
+}

package/types/manager/rayCasterManager.d.ts

@@ -0,0 +1,18 @@
+import { default as Viewer } from '../index';
+import { MouseEventType } from '../libs/types';
+export default class RayCasterManager {
+    private viewer;
+    private raycaster;
+    private eventHandler;
+    raycasterResultGuid: string;
+    private objs;
+    constructor(viewer: Viewer, event: MouseEventType | MouseEventType[]);
+    setEventHandler(event: MouseEventType | MouseEventType[]): void;
+    getRaycasterResult(event: Event, resultOption: MouseEventType["rayResultOption"]): {
+        [k: string]: any;
+    } | null;
+    /**
+     * 销毁场景：释放资源并停止渲染。
+     */
+    destroy(): void;
+}

package/types/tools/Events.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @description 全局单例事件总线（发布-订阅模式），用于 Viewer 内部多模块间通信。
+ * 提供 on / off / emit 三个方法；emit 时会模拟真实事件的 event.target
+ * 使用示例：Events.on("clickMesh", e => {...}) / Events.emit({ type: "clickMesh", target: mesh })
+ */
+declare class CustomEvent {
+    handlers: any;
+    constructor();
+    on(type: string, handler: (params: any) => void): void;
+    off(type: string, handler: (params: any) => void): void;
+    emit(event: any): void;
+}
+/** 全局事件总线单例（new CustomEvent()） */
+declare const _default: CustomEvent;
+export default _default;

package/types/tools/math.d.ts

@@ -0,0 +1,13 @@
+import { Vector3 } from 'three';
+/**
+ * 计算多点围成的凸多边形构造的面的面积
+ * @param points Vector3 数组
+ * @returns Number
+ */
+export declare const calculateArea: (points: Vector3[]) => number;
+/**
+ * 计算三点构成的角的角度
+ * @param points Vector3 数组
+ * @returns Number
+ */
+export declare const calculateAngle: (points: Vector3[]) => number;

package/types/vendor/DXFPaser/BatchingKey.d.ts

@@ -0,0 +1,25 @@
+/** Key for render batches. */
+export class BatchingKey {
+    layerName: string | null
+    blockName: string | null
+    geometryType: string | null
+    color: string | null
+    lineType: string | null
+    GeometryType: GeometryType
+    constructor(layerName?: string, blockName?: string, geometryType?: string, color?: string, lineType?: string)
+    Compare(other: any): number
+    IsIndexed(): boolean
+    IsInstanced(): boolean
+}
+
+interface GeometryType {
+    POINTS: 0,
+    LINES: 1,
+    INDEXED_LINES: 2,
+    TRIANGLES: 3,
+    INDEXED_TRIANGLES: 4,
+    BLOCK_INSTANCE: 5,
+    POINT_INSTANCE: 6
+}
+
+export function CompareValues(v1: number, v2: number): -1 | 0 | 1

package/types/vendor/DXFPaser/DxfFetcher.d.ts

@@ -0,0 +1,6 @@
+// 请求到dxf文件  并且解读
+export class DxfFetcher {
+    url: string
+    constructor(url: string)
+    async Fetch(): Promise<any>
+}

package/types/vendor/DXFPaser/DxfScene.d.ts

@@ -0,0 +1,95 @@
+import { DynamicBuffer, NativeType } from './DynamicBuffer';
+import { BatchingKey } from './BatchingKey';
+import { Matrix3, Vector2, Vector3 } from 'three';
+import { TextRenderer } from './TextRenderer';
+import { RBTree } from './RBTree';
+import { MTextFormatParser } from './MTextFormatParser';
+import { Entity } from './Entity';
+interface object {
+  [k: string]: any;
+}
+interface vertex {
+  x: number;
+  y: number;
+  z: number;
+}
+
+export class DxfScene {
+  options: object;
+  origin: null | Vector2 | Vector3;
+  batches: RBTree;
+  layers: Map;
+  blocks: Map;
+  bounds: any;
+  pointShapeBlock: any;
+  numBlocksFlattened: number;
+  constructor(options: object);
+
+  async Build(dxf: object, fontFetchers: string[]): void;
+  async _FetchFonts(dxf: object): void;
+  private _ProcessDxfEntity(entity: object, blockCtx: any): void;
+  private _ProcessEntity(entity: object, blockCtx: any): void;
+  private _GetLineType(entity: any, vertex: any, blockCtx: any): 0;
+  private _IsPlainLine(entity: object): boolean;
+  *_DecomposeLine(entity: Entity, blockCtx: BlockContext): void;
+  private _GenerateBulgeVertices(vertices: any[], startVtx: vertex, endVtx: vertex, bulge: number): void;
+  private _GenerateArcVertices(obj: {
+    vertices: vertex[];
+    center: { x: number; y: number };
+    radius: number;
+    startAngle: number | null;
+    endAngle: number | null;
+    tessellationAngle: number | null;
+    yRadius: number | null;
+    transform: any | null;
+  }): void;
+  *_DecomposeArc(entity: Entity, blockCtx: BlockContext): void;
+  *_DecomposeCircle(entity: Entity, blockCtx: BlockContext): void;
+  *_DecomposeEllipse(entity: Entity, blockCtx: BlockContext): void;
+  *_DecomposePoint(entity: Entity, blockCtx: BlockContext): void;
+  private _CreatePointMarker(vertices: { x: number; y: number }[], markType: number, position: null | { x: number; y: number }): void;
+  private _CreatePointShapeBlock(): void;
+  *_Decompose3DFace(entity: Entity, blockCtx: BlockContext): void;
+  *_DecomposeSolid(entity: Entity, blockCtx: BlockContext): void;
+  *_DecomposeFace(entity: any, vertices: vertex[], blockCtx: any, wireframe: any, transform: any): void;
+  *_DecomposeText(entity: Entity, blockCtx: BlockContext): void;
+  *_DecomposeMText(entity: Entity, blockCtx: BlockContext): void;
+  private _ProcessInsert(entity: Entity, blockCtx: BlockContext): void;
+  private _FlattenBatch(blockBatch: any, layerName: string, blockColor: any, blockLineType: string, transform: any): void;
+  *_GenerateShapedPolyline(vertices: vertex[], layer: string, color: any, lineType: string, shape: any): void;
+  private _MirrorEntityVertices(entity: Entity, vertices: any[]): void;
+  *_DecomposePolyline(entity: Entity, vertices: any[]): void;
+  *_DecomposeSpline(entity: Entity, vertices: any[]): void;
+  _InterpolateSpline(t: number, degree: number, points: number[][], knots?: number[], weights?: number): number[];
+
+  _ProcessPoints(entity: Entity, blockCtx?: BlockContext): void;
+  _ProcessLineSegments(entity: Entity, blockCtx?: BlockContext): void;
+  _ProcessPolyline(entity: Entity, blockCtx?: BlockContext): void;
+  _ProcessTriangles(entity: Entity, blockCtx?: BlockContext): void;
+  _GetEntityColor(entity: Entity, blockCtx?: BlockContext): number;
+  _GetEntityLayer(entity: Entity, blockCtx?: BlockContext): string;
+  _GetEntityExtrusionTransform(entity: Entity): Matrix3;
+  _GetBatch(key: any): RenderBatch;
+  _TransformVertex(v: any, blockCtx?: BlockContext): { x: number; y: number };
+  _UpdateBounds(v: { x: number; y: number }): void;
+  _BuildScene(): {
+    vertices: ArrayBuffer;
+    indices: ArrayBuffer;
+    transforms: ArrayBuffer;
+    batches: any[];
+    layers: any[];
+    origin: any;
+    bounds: any;
+    hasMissingChars: any;
+  };
+}
+
+class BlockContext {
+  block: any;
+  type: string;
+  origin: any;
+  transform: Matrix3;
+  constructor(block: any, type: string);
+}
+
+export const ColorCode: { BY_LAYER: number; BY_BLOCK: number };

package/types/vendor/DXFPaser/DxfWorker.d.ts

@@ -0,0 +1,44 @@
+import { DxfFetcher } from './DxfFetcher';
+import { DxfScene } from './DxfScene';
+import { default as opentype } from './parser/opentype';
+const MSG_SIGNATURE = "DxfWorkerMsg";
+
+export class DxfWorker {
+  worker: any;
+  reqSeq: number;
+  requests: Map;
+  progressCbk: any;
+  WorkerMsg: {
+    LOAD: "LOAD";
+    PROGRESS: "PROGRESS";
+    DESTROY: "DESTROY";
+  };
+  Request: Request;
+  constructor(worker: any, isWorker?: boolean): void;
+  async Load(url: string, fonts: string[], options: { [k: string]: any }, progressCbk: (phase: any, processedSize: number, totalSize: number) => {}): Promise<any>;
+  async Destroy(noWait?: boolean): void;
+  async _ProcessRequest(event: any): void;
+  async _ProcessRequestMessage(type: string, data: any, transfers: any[], seq: any): any;
+  async _ProcessResponse(event: any): void;
+  async _OnError(error: string): void;
+  async _SendRequest(type: string, data?: any, progressCbk?: any): any;
+
+  _SendProgress(seq: any, phase: any, size: number, totalSize: number): void;
+  async _Load(url: string, fonts: string[], options: any, progressCbk: any): any;
+
+  _CreateFontFetchers(urls: string[], progressCbk: any): any;
+  _CloneOptions(options: any): any;
+}
+
+class Request {
+  seq: any;
+  progressCbk: any;
+  promise: Promise;
+  _Resolve: any;
+  _Reject: any;
+  constructor(seq: any, progressCbk: any);
+
+  async GetResponse(): Promise;
+  SetResponse(response): void;
+  SetError(error): void;
+}

package/types/vendor/DXFPaser/DynamicBuffer.d.ts

@@ -0,0 +1,30 @@
+/** Typed-array-based buffer which can be dynamically extended. */
+
+export class DynamicBuffer {
+  type: string;
+  capacity: number;
+  size: number;
+  buffer: any;
+  constructor(type: string, initialCapacity?: number);
+  GetSize(): number;
+  Push(value: any): any;
+  Get(index: number): any;
+  CopyTo(dstBuffer: any[], dstOffset: number, srcOffset?: number, size?: number): void;
+  _CheckGrow(): void;
+}
+
+export const NativeType: {
+  INT8: 0;
+  UINT8: 1;
+  UINT8_CLAMPED: 2;
+  INT16: 3;
+  UINT16: 4;
+  INT32: 5;
+  UINT32: 6;
+  INT64: 7;
+  UINT64: 8;
+  FLOAT32: 9;
+  FLOAT64: 10;
+};
+
+export function NativeArray(type: number): ArrayBuffer;

package/types/vendor/DXFPaser/Entity.d.ts

@@ -0,0 +1,18 @@
+export class Entity {
+  type: number;
+  vertices: { x; y }[];
+  indices: number[];
+  layer: string;
+  color: number;
+  lineType: number;
+  shape: Boolean;
+  Type: {
+    POINTS: 0;
+    LINE_SEGMENTS: 1;
+    POLYLINE: 2;
+    TRIANGLES: 3;
+  };
+  constructor(object: { type: number; vertices: { x; y }[]; indices?: number[]; layer?: string; color: number; lineType?: number; shape?: boolean });
+  *_IterateVertices(startIndex: number, count: number): void;
+  *_IterateLineChunks(): void;
+}

package/types/vendor/DXFPaser/MTextFormatParser.d.ts

@@ -0,0 +1,15 @@
+export class MTextFormatParser {
+  entities: any[];
+  EntityType: {
+    TEXT: 0;
+    SCOPE: 1;
+    PARAGRAPH: 2;
+    NON_BREAKING_SPACE: 3;
+    PARAGRAPH_ALIGNMENT: 4;
+  };
+  constructor();
+
+  Parse(text: string): void;
+  GetContent(): any[];
+  *GetText(): void;
+}

package/types/vendor/DXFPaser/MaterialKey.d.ts

@@ -0,0 +1,8 @@
+export class MaterialKey {
+  instanceType: number;
+  geometryType: number;
+  color: number;
+  lineType: number;
+  constructor(instanceType: number, geometryType?: number, color?: number, lineType?: number);
+  Compare(other: any): any;
+}

package/types/vendor/DXFPaser/RBTree.d.ts

@@ -0,0 +1,5 @@
+export class RBTree {
+  constructor(comparator: any);
+  insert(data: any): boolean;
+  remove(data: any): boolean;
+}