@x-viewer/core 0.9.0

package/dist/types/core/dxf-parser/entities/viewport.d.ts

@@ -0,0 +1,56 @@
+import { DwgViewportEntity } from "@mlightcad/libredwg-web";
+import IGeometry, { IEntity, IPoint } from "./geomtry";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+/**
+ * Viewport is usually used in paper space.
+ */
+export interface IViewportEntity extends IEntity {
+    centerPoint: IPoint;
+    width_paperSpace: number;
+    height_paperSpace: number;
+    viewportStatus: number;
+    /**
+     * Not a handle hex string, but a int value? Usually is "1", "2", "3", etc.
+     * viewportId "1" means the Model space viewport.
+     * "2", "3", ... are paper space viewports.
+     */
+    viewportId: number;
+    centerPoint_dcs: IPoint;
+    snapBasePoint_dcs: IPoint;
+    snapSpacing_dcs: IPoint;
+    gridSpacing_dcs: IPoint;
+    viewDirection: IPoint;
+    viewTarget: IPoint;
+    perspectiveLens: number;
+    frontClippingPlaneZ: number;
+    backClippingPlaneZ: number;
+    viewHeight: number;
+    snapAngle: number;
+    viewTwistAngle: number;
+    circleZoomPercent: number;
+    frozenLayerHandles: string[];
+    viewportStatusFlags: number;
+    viewportClippingBoundaryhandleId: string;
+    plotStyleSheetName: string;
+    renderMode: number;
+    viewportFlag_ucs: number;
+    ucsIcon: string;
+    ucsOrigin: IPoint;
+    ucsXAxis: IPoint;
+    ucsYAxis: IPoint;
+    ucsTableRecordHandle: string;
+    baseUcsTableRecordHandle: string;
+    orthographicType: number;
+    elevation: number;
+    shadePlotMode: number;
+    frequency: number;
+    lightingFlag: number;
+    lightingType: number;
+    viewBrightness: number;
+    viewContrast: number;
+}
+export default class Viewport implements IGeometry {
+    ForEntityName: "VIEWPORT";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): IViewportEntity;
+    parseDwgEntity(entity: DwgViewportEntity): IEntity;
+}

package/dist/types/core/dxf-parser/entities/xline.d.ts

@@ -0,0 +1,12 @@
+import { DwgXlineEntity } from "@mlightcad/libredwg-web";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+import IGeometry, { IEntity, IPoint } from './geomtry';
+export interface IXLineEntity extends IEntity {
+    vertices: IPoint[];
+    directionVector: IPoint;
+}
+export default class XLine implements IGeometry {
+    ForEntityName: "XLINE";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): IXLineEntity;
+    parseDwgEntity(entity: DwgXlineEntity): IEntity;
+}

package/dist/types/core/dxf-parser/index.d.ts

@@ -0,0 +1,27 @@
+export { default, default as DxfParser } from "./DxfParser";
+export type { IDxf, IBlock, ILayerTypesTable, ILayersTable, ITables, IViewportTable, IBaseTable, ILayer, ILayerTableDefinition, ILineType, ILineTypeTableDefinition, ITable, ITableDefinitions, IViewport, IViewportTableDefinition, } from "./DxfParser";
+export type { IEntity, IPoint } from "./entities/geomtry";
+export type { I3DfaceEntity } from "./entities/3dface";
+export type { IArcEntity } from "./entities/arc";
+export type { IAttdefEntity } from "./entities/attdef";
+export type { ICircleEntity } from "./entities/circle";
+export type { IDimensionEntity } from "./entities/dimension";
+export type { ILeaderEntity } from "./entities/mleader";
+export type { IEllipseEntity } from "./entities/ellipse";
+export type { IHatchEntity } from "./entities/hatch";
+export type { IInsertEntity } from "./entities/insert";
+export type { ILineEntity } from "./entities/line";
+export type { ILwpolylineEntity } from "./entities/lwpolyline";
+export type { IMtextEntity } from "./entities/mtext";
+export type { IPointEntity } from "./entities/point";
+export type { IPolylineEntity } from "./entities/polyline";
+export type { ISolidEntity } from "./entities/solid";
+export type { ISplineEntity } from "./entities/spline";
+export type { ITextEntity } from "./entities/text";
+export type { ITableEntity, TableCell } from "./entities/table";
+export type { IVertexEntity } from "./entities/vertex";
+export type { IViewportEntity } from "./entities/viewport";
+export type { IObject } from "./objects/common";
+export type { IImageDefObject } from "./objects/imagedef";
+export type { ILayoutObject } from "./objects/layout";
+export type { ISortEntsObject, ISortEntsTableObject } from "./objects/sortentstable";

package/dist/types/core/dxf-parser/objects/common.d.ts

@@ -0,0 +1,26 @@
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+export interface IObject {
+    type: string;
+    handle: string;
+    ownerHandle: string;
+    extendedData?: {
+        customStrings?: string[];
+        applicationName?: string;
+    };
+}
+export interface IClass {
+    applicationName: string;
+    className: string;
+    cpp_class_name: string;
+    dxfName: string;
+    capabilitiesFlag: number;
+    proxyPackage?: string;
+    instanceCount?: number;
+    isAnEntityFlag?: boolean;
+    isProxy?: boolean;
+}
+export type ObjectName = "ACAD_PROXY_OBJECT" | "ACDBDICTIONARYWDFLT" | "ACDBPLACEHOLDER" | "DATATABLE" | "DICTIONARY" | "DICTIONARYVAR" | "DIMASSOC" | "FIELD" | "GEODATA" | "IDBUFFER" | "IMAGEDEF" | "IMAGEDEF_REACTOR" | "LAYER_INDEX" | "LAYER_FILTER" | "LAYOUT" | "LIGHTLIST" | "MATERIAL" | "MLINESTYLE" | "OBJECT_PTR" | "PLOTSETTINGS" | "RASTERVARIABLES" | "RENDER" | "SECTION" | "SPATIAL_INDEX" | "SPATIAL_FILTER" | "SORTENTSTABLE" | "TABLESTYLE" | "UNDERLAYDEFINITION" | "VISUALSTYLE" | "VBA_PROJECT" | "WIPEOUTVARIABLES" | "XRECORD";
+export interface IObjectParser {
+    ForObjectName: ObjectName;
+    parseObject(scanner: DxfBaseReader, curr: IGroup): IObject;
+}

package/dist/types/core/dxf-parser/objects/dictionary.d.ts

@@ -0,0 +1,23 @@
+import { IObject, IObjectParser } from "./common";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+export declare enum DictionaryCloningFlags {
+    NotApplicable = 0,
+    KeepExisting = 1,
+    UseClone = 2,
+    XrefName = 3,
+    Name = 4,
+    UnmangleName = 5
+}
+export interface IDictionaryObject extends IObject {
+    /**
+     * Key is handle hex string.
+     * Value is a string representing the name of the entry.
+     */
+    entries: Record<string, string>;
+    isHardOwner: boolean;
+    cloningFlag: DictionaryCloningFlags;
+}
+export declare class Dictionary implements IObjectParser {
+    ForObjectName: "DICTIONARY";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): IDictionaryObject;
+}

package/dist/types/core/dxf-parser/objects/imagedef.d.ts

@@ -0,0 +1,24 @@
+import { IObject, IObjectParser } from "./common";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+import { IPoint } from "../entities/geomtry";
+export declare enum ImgaeDefLoaded {
+    Unloaded = 0,
+    Loaded = 1
+}
+export declare enum ImageDefResolutionUnits {
+    NoUnits = 0,
+    Centimeters = 2,
+    Inches = 5
+}
+export interface IImageDefObject extends IObject {
+    classVersion: number;
+    filename: string;
+    imageSize: IPoint;
+    pixelSize: IPoint;
+    loaded: ImgaeDefLoaded;
+    resolutionUnits: ImageDefResolutionUnits;
+}
+export declare class ImageDef implements IObjectParser {
+    ForObjectName: "IMAGEDEF";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): IImageDefObject;
+}

package/dist/types/core/dxf-parser/objects/layout.d.ts

@@ -0,0 +1,29 @@
+import { IObject, IObjectParser } from './common';
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { IPoint } from '../entities/geomtry';
+/**
+ * @internal
+ */
+export interface ILayoutObject extends IObject {
+    plotSettings?: object;
+    layoutName: string;
+    flag: number;
+    tabOrder: number;
+    minLimit: IPoint;
+    maxLimit: IPoint;
+    basePoint: IPoint;
+    minExtent: IPoint;
+    maxExtent: IPoint;
+    elevation: number;
+    origin: IPoint;
+    XAxis: IPoint;
+    YAxis: IPoint;
+    orthographicType: number;
+    blockTableHandle: string;
+    viewportHandle: string;
+    associatedBlockName: string;
+}
+export declare class Layout implements IObjectParser {
+    ForObjectName: "LAYOUT";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): ILayoutObject;
+}

package/dist/types/core/dxf-parser/objects/sortentstable.d.ts

@@ -0,0 +1,12 @@
+import { IObject, IObjectParser } from "./common";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+export interface ISortEntsObject extends IObject {
+    entityHandles: string[][];
+}
+export interface ISortEntsTableObject extends IObject {
+    sortEntsObject: ISortEntsObject;
+}
+export declare class SortEntsTable implements IObjectParser {
+    ForObjectName: "SORTENTSTABLE";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): ISortEntsTableObject;
+}

package/dist/types/core/dxf-parser/objects/spatialfilter.d.ts

@@ -0,0 +1,22 @@
+import { IObject, IObjectParser } from "./common";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+import { IPoint } from "../entities/geomtry";
+export interface ISpatialFilterObject extends IObject {
+    origin: IPoint;
+    numberOfPointsOnClipBoundary: number;
+    vertices: IPoint[];
+    extrusionDirectionX: number;
+    extrusionDirectionY: number;
+    extrusionDirectionZ: number;
+    clipBoundaryVisible: boolean;
+    frontClippingPlaneFlag: boolean;
+    frontClippingPlaneDistance: number;
+    backClippingPlaneFlag: boolean;
+    backClippingPlaneDistance: number;
+    matrix: number[];
+    invertBlockMatrix: number[];
+}
+export declare class SpatialFilter implements IObjectParser {
+    ForObjectName: "SPATIAL_FILTER";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): ISpatialFilterObject;
+}

package/dist/types/core/dxf-parser/objects/xrecord.d.ts

@@ -0,0 +1,11 @@
+import { IObject, IObjectParser } from "./common";
+import { DictionaryCloningFlags } from "./dictionary";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+export interface IXRecord extends IObject {
+    binaryData: string | undefined;
+    cloningFlag: DictionaryCloningFlags;
+}
+export declare class XRecord implements IObjectParser {
+    ForObjectName: "XRECORD";
+    parseObject(scanner: DxfBaseReader, curr: IGroup): IXRecord;
+}

package/dist/types/core/effect/EffectManager.d.ts

@@ -0,0 +1,43 @@
+import * as THREE from "three";
+import { type BaseViewer } from "../viewers";
+/**
+ * Visual effect manager for viewers.
+ */
+export declare class EffectManager {
+    private viewer;
+    private composerEnabled;
+    private composer?;
+    private renderPass?;
+    private effectFxaaPass?;
+    private saoPass?;
+    private ssaoPass?;
+    private outlinePass?;
+    private ssaaRenderPass?;
+    private bloomPass?;
+    private unrealBloomPass?;
+    private vertexNormalsHelpers?;
+    constructor(viewer: BaseViewer);
+    get enabled(): boolean;
+    set enabled(enable: boolean);
+    get renderPassEnabled(): boolean;
+    set renderPassEnabled(enable: boolean);
+    get fxaaPassEnabled(): boolean;
+    set fxaaPassEnabled(enable: boolean);
+    get saoPassEnabled(): boolean;
+    set saoPassEnabled(enable: boolean);
+    get ssaoPassEnabled(): boolean;
+    set ssaoPassEnabled(enable: boolean);
+    get outlinePassEnabled(): boolean;
+    set outlinePassEnabled(enable: boolean);
+    get ssaaPassEnabled(): boolean;
+    set ssaaPassEnabled(enable: boolean);
+    get bloomPassEnabled(): boolean;
+    set bloomPassEnabled(enable: boolean);
+    get unrealBloomPassEnabled(): boolean;
+    set unrealBloomPassEnabled(enable: boolean);
+    setOutlinePassSelectObjects(objects: THREE.Object3D[]): void;
+    enableModelEdges(enable: boolean): void;
+    showVertexNormals(show: boolean, size?: number): void;
+    render(): void;
+    destroy(): void;
+}

package/dist/types/core/effect/index.d.ts

@@ -0,0 +1 @@
+export * from "./EffectManager";

package/dist/types/core/font/BaseFont.d.ts

@@ -0,0 +1,41 @@
+import * as THREE from "three";
+import { Font } from "three/examples/jsm/loaders/FontLoader.js";
+import { Orientation } from "./shx";
+import { FontDataTableRecord } from "../indexeddb";
+export declare abstract class BaseFont extends Font {
+    info: string;
+    orientation: Orientation;
+    baseUp: number;
+    baseDown: number;
+    fileHeader: string;
+    fileVersion: string;
+    fileName: string;
+    data: any;
+    order: number;
+    unsupportedChars: Record<string, number>;
+    constructor(fileName: string, fileData: any);
+    abstract getCharShape(char: string, size: number): THREE.Shape | undefined;
+    abstract getNotFoundTextShape(size: number): THREE.Shape | undefined;
+    /**
+     * Just for log usage
+     */
+    protected addUnsupportedChar(char: string): void;
+    protected getFontFile(): {
+        order: number;
+        data: any;
+        info: string;
+        orientation: Orientation;
+        baseUp: number;
+        baseDown: number;
+        fileName: string;
+        fileHeader: string;
+        fileVersion: string;
+    };
+    setFontFile(data: FontDataTableRecord): void;
+    /**
+     * Catches dxf data into indexedDb
+     */
+    setFontDataToIndexedDb(): Promise<void>;
+    getFontDataByIndexedDb(): Promise<FontDataTableRecord>;
+    releaseFontData(): void;
+}

package/dist/types/core/font/FontManager.d.ts

@@ -0,0 +1,52 @@
+import * as THREE from "three";
+import { BaseFont } from "./BaseFont";
+export declare class FontManager {
+    private loader;
+    protected fontMap: Map<string, BaseFont>;
+    protected fileNames?: string[];
+    unsupportedChars: Record<string, number>;
+    missingFonts: Record<string, number>;
+    enableFontCache: boolean;
+    constructor();
+    /**
+     *
+     * @param urls The order represents the priority
+     * @returns
+     * @description The best fonts order is: Load linear fonts first followed by ttf fonts, font types load Western fonts first in loaded chinese fonts.
+     * @description Microsoft Yahei is the most worthy choice of Chinese font on the Win platform, but it is not the default viewer and needs to be set; Sans-serif fonts such as Arial and Tahoma are the main fonts for Western fonts.
+     * @description At present, the latest font launched by Apple and San Francisco for Apple, the display effect is also the most elegant, but only the latest system can support, while blackface - Jane and Helvetica can get more system version support, the display effect is also similar, can be accepted.
+     * @example font-family: Helvetica, Tahoma, Arial, "PingFang SC", "Hiragino Sans GB", "Heiti SC", "Microsoft YaHei", "WenQuanYi Micro Hei", sans-serif;
+     */
+    loadFonts(urls: string[]): Promise<void>;
+    /**
+     *
+     * @param text
+     * @param fontName
+     * @param size
+     * @returns
+     * @description Gets text shape by fontName and size.
+     */
+    getTextShape(text: string, fontName: string, size: number): THREE.Shape[] | undefined;
+    /**
+     *
+     * @param fontName
+     * @param char
+     * @param size
+     * @returns
+     */
+    getCharShape(char: string, fontName: string, size: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
+    getNotFoundTextShape(size: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
+    private checkAllFontsLoaded;
+    getFontFromIndexeddb(): Promise<void>;
+    isShxFont(fontName: string): boolean | undefined;
+    /**
+     * Just for log usage
+     */
+    getUnsupportedChar(): Record<string, number>;
+    releaseFontData(): void;
+    destroy(): void;
+    static isShxFile(url: string): boolean;
+    static isTtfFile(url: string): boolean;
+    static isJsonFile(url: string): boolean;
+    static getFileName(url: string): string;
+}

package/dist/types/core/font/MeshFont.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+import { BaseFont } from "./BaseFont";
+import { FontDataTableRecord } from "../indexeddb";
+export declare class MeshFont extends BaseFont {
+    reversed: boolean;
+    constructor(fileName: string, fileData: object | FontDataTableRecord | ArrayBuffer);
+    generateShapes(text: string, size: number): THREE.Shape[];
+    getCharShape(char: string, size: number): THREE.Shape | undefined;
+    /**
+     * For an unsupported char, use "？" as a replacement.
+     */
+    getNotFoundTextShape(size: number): THREE.Shape | undefined;
+    private parseTTF;
+}

package/dist/types/core/font/ShxFont.d.ts

@@ -0,0 +1,49 @@
+import * as THREE from "three";
+import { BaseFont } from "./BaseFont";
+import { ShxFontType } from "./shx/Shx.constants";
+import { TextShape } from "./shx/TextShape";
+import { FontDataTableRecord } from "../../core/indexeddb";
+export declare class ShxFont extends BaseFont {
+    static readonly DEFAULT_SIZE = 12;
+    isExtend: boolean;
+    isUniCode: boolean;
+    isEmbedded: boolean;
+    fontType: ShxFontType;
+    private textShapesCache;
+    private graphicData;
+    constructor(fileName: string, fileData: ArrayBuffer | FontDataTableRecord);
+    generateShapes(text: string, size: number): TextShape[];
+    /**
+     * Gets TextShape by a char
+     */
+    getCharShape(char: string, size: number): TextShape | undefined;
+    /**
+     * Gets TextShape by a char code
+     */
+    getGraphicDataByCode(code: number, size: number): TextShape | undefined;
+    /**
+     * Gets TextShape by char's code, font size and offset
+     */
+    getGraphicDataByCodeWithOffset(code: number, size: number, translate: THREE.Vector2): TextShape | undefined;
+    private parseBigFont;
+    private parseUniFont;
+    private parseShapeFont;
+    /**
+     * For an unsupported char, use "？" as a replacement.
+     */
+    getNotFoundTextShape(size: number): TextShape | undefined;
+    protected getFontFile(): {
+        fontType: ShxFontType;
+        order: number;
+        data: any;
+        info: string;
+        orientation: import("./shx/Shx.constants").Orientation;
+        baseUp: number;
+        baseDown: number;
+        fileName: string;
+        fileHeader: string;
+        fileVersion: string;
+    };
+    setFontFile(data: FontDataTableRecord): void;
+    releaseFontData(): void;
+}

package/dist/types/core/font/index.d.ts

@@ -0,0 +1 @@
+export * from "./FontManager";

package/dist/types/core/font/shx/ExtraLettersTemplate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Extra letters/chars that don't exist in any font file can be defined here.
+ */
+export declare const ExtraLetters: Record<string, Array<Array<Array<number>>>>;

package/dist/types/core/font/shx/Shx.constants.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Text orientation.
+ */
+export declare enum Orientation {
+    Horizontal = 0,
+    Vertical = 1,
+    All = 2
+}
+/**
+ * Shx font type.
+ */
+export declare enum ShxFontType {
+    Shapes = 0,
+    Bigfont = 1,
+    Unifont = 2
+}
+/**
+ * Default font size.
+ */
+export declare const DefaultFontSize = 12;

package/dist/types/core/font/shx/ShxParser.d.ts

@@ -0,0 +1,18 @@
+import { TextShape } from "./TextShape";
+import type { ShxFont } from "../ShxFont";
+import { BinaryReader } from "../../../core/helpers/BinaryReader";
+export declare class ShxParser {
+    static readonly FILE_STOP_FLAG: string[];
+    static readonly CIRCLE_SPAN: number;
+    static parserHeader(reader: BinaryReader, stopMatch: string[]): string;
+    /**
+     * Gets code id of a char.
+     */
+    static getCode(char: string): number;
+    /**
+     * Parses code data and generates TextShape.
+     */
+    static parserCode(file: ShxFont, data: Uint8Array, scale: number): TextShape;
+    private static skipCode;
+    private static generateArcPoints;
+}

package/dist/types/core/font/shx/TextShape.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from "three";
+/**
+ * Text shape, to describe a specific character.
+ */
+export declare class TextShape extends THREE.Shape {
+    width: number;
+    lastPoint: THREE.Vector2;
+    polylines: Array<Array<THREE.Vector2>>;
+    private bounds;
+    constructor(lastPoint: THREE.Vector2, polylines: Array<Array<THREE.Vector2>>);
+    /**
+     * Gets an offsetted new TextShape
+     */
+    offset(vector: THREE.Vector2): TextShape;
+    /**
+     * Gets an transformed new TextShape
+     */
+    transform(matrix: THREE.Matrix3): TextShape;
+    protected calcWidth(polylines: THREE.Vector2[][]): number;
+    /**
+     * Converts a TextShape to THREE.BufferGeometry
+     */
+    toThreeGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+}

package/dist/types/core/font/shx/gbk/index.d.ts

@@ -0,0 +1,4 @@
+export declare function encode(str: string): Uint8Array;
+export declare function traditionalChineseToSimpliled(text: string): string;
+export declare function isChinese(text: string): boolean;
+export declare function isTraditionalChinese(text: string): boolean;

package/dist/types/core/font/shx/index.d.ts

@@ -0,0 +1 @@
+export * from "./Shx.constants";

package/dist/types/core/font/shx/util/BitConverter.d.ts

@@ -0,0 +1,18 @@
+export declare class BitConverter {
+    static GetBytes(value: string | number | boolean | []): Uint8Array;
+    static Get1Bytes(value: number | boolean | []): Uint8Array;
+    static byteTosbyte(byte: number): number;
+    static ToBoolean(value: Uint8Array, startIndex: number): boolean;
+    static ToInt8(value: Uint8Array, startIndex: number): number;
+    static ToUInt8(value: Uint8Array, startIndex: number): number;
+    static ToInt16(value: Uint8Array, startIndex: number): number;
+    static ToInt32(value: Uint8Array, startIndex: number): number;
+    static ToUInt16(value: Uint8Array, startIndex: number): number;
+    static ToUInt32(value: Uint8Array, startIndex: number): number;
+    static ToChar(value: Uint8Array, startIndex: number): string;
+    static ToAscii(value: Uint8Array, startIndex: number): string;
+    static ToAsciiString(value: Uint8Array, startIndex: number, length: number): string;
+    static ToUTF16String(value: Uint8Array, startIndex: number, length: number): string;
+    static ToFloat32(value: Uint8Array, startIndex: number): number;
+    static ToFloat64(value: Uint8Array, startIndex: number): number;
+}

package/dist/types/core/geometry-offset/Edge.d.ts

@@ -0,0 +1,27 @@
+import type { Pair } from "polygon-clipping";
+/**
+ * Offset edge
+ * @internal
+ */
+export declare class Edge {
+    current: Pair;
+    next: Pair;
+    inNormal: Pair;
+    outNormal: Pair;
+    constructor(current: Pair, next: Pair);
+    /**
+     * Creates outwards normal
+     */
+    private outwardsNormal;
+    /**
+     * Creates inwards normal
+     */
+    private inwardsNormal;
+    /**
+     * Offsets the edge by dx, dy
+     */
+    offset(dx: number, dy: number): Edge;
+    inverseOffset(dx: number, dy: number): Edge;
+    inverse(): Edge;
+    static offsetEdge(current: Pair, next: Pair, dx: number, dy: number): Edge;
+}

package/dist/types/core/geometry-offset/Offset.d.ts

@@ -0,0 +1,46 @@
+import type { MultiPolygon, Pair, Polygon, Ring } from "polygon-clipping";
+import { Edge } from "./Edge";
+/**
+ * Offset builder
+ * @internal
+ */
+export declare class Offset {
+    vertices: Pair | Ring | Polygon;
+    edges: Edge[] | Edge[][];
+    private arcSegments;
+    private distance;
+    constructor(vertices: Pair | Ring | Polygon, arcSegments?: number);
+    /**
+     * Recursively process contour to create normals
+     */
+    private processContour;
+    setArcSegments(arcSegments: number): this;
+    /**
+     * Creates arch between two edges
+     *
+     * @param  {Array.<Object>} vertices
+     * @param  {Object}         center
+     * @param  {Number}         radius
+     * @param  {Object}         startVertex
+     * @param  {Object}         endVertex
+     * @param  {Number}         segments
+     * @param  {Boolean}        bOutwards
+     */
+    private createArc;
+    setDistance(dist: number): this;
+    private ensureLastPoint;
+    /**
+     * Decides by the sign if it's a padding or a margin
+     */
+    offset(dist: number): Pair | Ring | Polygon | MultiPolygon;
+    private offsetSegment;
+    private margin;
+    private padding;
+    offsetLine(dist: number): Pair | Ring | Polygon | MultiPolygon;
+    /**
+     * Just offsets lines, no fill
+     */
+    private offsetLines;
+    private offsetContour;
+    offsetPoint(distance: number): MultiPolygon;
+}

package/dist/types/core/geometry-offset/index.d.ts

@@ -0,0 +1 @@
+export * from "./Offset";