@configura/web-core 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/cm/core3D/uvmapper/UVMapperPlane.js

@@ -1,84 +1,84 @@
-import { UVMapper } from "./UVMapper.js";
-/**
- * Calculate base vectors for the mapping plane where the first is orthogonal with the
- * normal-vector and flat along the ground and the other is orthogonal to the first two.
- */
-function calculateMappingPlaneVectors(normal) {
-    const [normalX, normalY, normalZ] = normal;
-    const normalLen = Math.sqrt(normalX * normalX + normalY * normalY + normalZ * normalZ);
-    // Probably already normalized, but just to be sure
-    const normalNormalized = normal.map((n) => n / normalLen);
-    if (normalNormalized[0] === 0 && normalNormalized[1] === 0 && normalNormalized[2] === 1) {
-        return [
-            [0, 1, 0],
-            [-1, 0, 0],
-        ];
-    }
-    const [normalNormalizedX, normalNormalizedY, normalNormalizedZ] = normalNormalized;
-    const base0Len = Math.sqrt(normalNormalizedX * normalNormalizedX + normalNormalizedY * normalNormalizedY);
-    // Along the ground (z is 0) as in CET
-    const base0 = [-normalNormalizedY / base0Len, normalNormalizedX / base0Len, 0];
-    const [base0X, base0Y, base0Z] = base0;
-    // Cross product, orthogonal to the plane normal and the "along the ground vector"
-    const base1 = [
-        normalNormalizedY * base0Z - normalNormalizedZ * base0Y,
-        normalNormalizedZ * base0X - normalNormalizedX * base0Z,
-        normalNormalizedX * base0Y - normalNormalizedY * base0X,
-    ];
-    return [base0, base1];
-}
-/** From a point over to the UV-coordinates by projecting */
-function toUv(point, mappingPlaneVectors) {
-    const [b0, b1] = mappingPlaneVectors;
-    const [x, y, z] = point;
-    return [b0[0] * x + b0[1] * y + b0[2] * z, b1[0] * x + b1[1] * y + b1[2] * z];
-}
-export function createUVPlaneCoordinates(env, positions) {
-    return createUV(env, positions, undefined);
-}
-export function createUVPlaneCoordinatesForStretched(env, positions, refPositions) {
-    return createUV(env, positions, refPositions);
-}
-function createUV(env, positions, refPositions) {
-    var _a;
-    if (env === undefined) {
-        throw new Error("env needed for plane mapper");
-    }
-    const xyzCount = positions.length;
-    const vertexCount = xyzCount / 3;
-    if (refPositions !== undefined && refPositions.length !== xyzCount) {
-        throw new Error(`Position count differs: ${refPositions.length} vs ${xyzCount}.`);
-    }
-    refPositions = refPositions || positions;
-    const normal = env.normal;
-    const transform = (_a = env.transforms) === null || _a === void 0 ? void 0 : _a[0];
-    const mappingPlaneVectors = calculateMappingPlaneVectors([normal.x, normal.y, normal.z]);
-    let refMinU = Number.POSITIVE_INFINITY;
-    let refMaxU = Number.NEGATIVE_INFINITY;
-    let refMinV = Number.POSITIVE_INFINITY;
-    let refMaxV = Number.NEGATIVE_INFINITY;
-    for (let i = 0; i < vertexCount; i++) {
-        const xyzOffset = i * 3;
-        const [u, v] = toUv([refPositions[xyzOffset], refPositions[xyzOffset + 1], refPositions[xyzOffset + 2]], mappingPlaneVectors);
-        refMinU = Math.min(refMinU, u);
-        refMaxU = Math.max(refMaxU, u);
-        refMinV = Math.min(refMinV, v);
-        refMaxV = Math.max(refMaxV, v);
-    }
-    const refSizeU = refMaxU - refMinU;
-    const refSizeV = refMaxV - refMinV;
-    const newUvs = new Float32Array(vertexCount * 2);
-    for (let i = 0; i < vertexCount; i++) {
-        const xyzOffset = i * 3;
-        const uvOffset = i * 2;
-        let [u, v] = toUv([positions[xyzOffset], positions[xyzOffset + 1], positions[xyzOffset + 2]], mappingPlaneVectors);
-        u = (u - refMinU) / refSizeU;
-        v = (v - refMinV) / refSizeV;
-        if (transform !== undefined) {
-            [u, v] = UVMapper.applyUvTransform([u, v], transform);
-        }
-        newUvs[uvOffset] = u;
-        newUvs[uvOffset + 1] = v;
-    }
-    return newUvs;
-}
+import { UVMapper } from "./UVMapper.js";
+/**
+ * Calculate base vectors for the mapping plane where the first is orthogonal with the
+ * normal-vector and flat along the ground and the other is orthogonal to the first two.
+ */
+function calculateMappingPlaneVectors(normal) {
+    const [normalX, normalY, normalZ] = normal;
+    const normalLen = Math.sqrt(normalX * normalX + normalY * normalY + normalZ * normalZ);
+    // Probably already normalized, but just to be sure
+    const normalNormalized = normal.map((n) => n / normalLen);
+    if (normalNormalized[0] === 0 && normalNormalized[1] === 0 && normalNormalized[2] === 1) {
+        return [
+            [0, 1, 0],
+            [-1, 0, 0],
+        ];
+    }
+    const [normalNormalizedX, normalNormalizedY, normalNormalizedZ] = normalNormalized;
+    const base0Len = Math.sqrt(normalNormalizedX * normalNormalizedX + normalNormalizedY * normalNormalizedY);
+    // Along the ground (z is 0) as in CET
+    const base0 = [-normalNormalizedY / base0Len, normalNormalizedX / base0Len, 0];
+    const [base0X, base0Y, base0Z] = base0;
+    // Cross product, orthogonal to the plane normal and the "along the ground vector"
+    const base1 = [
+        normalNormalizedY * base0Z - normalNormalizedZ * base0Y,
+        normalNormalizedZ * base0X - normalNormalizedX * base0Z,
+        normalNormalizedX * base0Y - normalNormalizedY * base0X,
+    ];
+    return [base0, base1];
+}
+/** From a point over to the UV-coordinates by projecting */
+function toUv(point, mappingPlaneVectors) {
+    const [b0, b1] = mappingPlaneVectors;
+    const [x, y, z] = point;
+    return [b0[0] * x + b0[1] * y + b0[2] * z, b1[0] * x + b1[1] * y + b1[2] * z];
+}
+export function createUVPlaneCoordinates(env, positions) {
+    return createUV(env, positions, undefined);
+}
+export function createUVPlaneCoordinatesForStretched(env, positions, refPositions) {
+    return createUV(env, positions, refPositions);
+}
+function createUV(env, positions, refPositions) {
+    var _a;
+    if (env === undefined) {
+        throw new Error("env needed for plane mapper");
+    }
+    const xyzCount = positions.length;
+    const vertexCount = xyzCount / 3;
+    if (refPositions !== undefined && refPositions.length !== xyzCount) {
+        throw new Error(`Position count differs: ${refPositions.length} vs ${xyzCount}.`);
+    }
+    refPositions = refPositions || positions;
+    const normal = env.normal;
+    const transform = (_a = env.transforms) === null || _a === void 0 ? void 0 : _a[0];
+    const mappingPlaneVectors = calculateMappingPlaneVectors([normal.x, normal.y, normal.z]);
+    let refMinU = Number.POSITIVE_INFINITY;
+    let refMaxU = Number.NEGATIVE_INFINITY;
+    let refMinV = Number.POSITIVE_INFINITY;
+    let refMaxV = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < vertexCount; i++) {
+        const xyzOffset = i * 3;
+        const [u, v] = toUv([refPositions[xyzOffset], refPositions[xyzOffset + 1], refPositions[xyzOffset + 2]], mappingPlaneVectors);
+        refMinU = Math.min(refMinU, u);
+        refMaxU = Math.max(refMaxU, u);
+        refMinV = Math.min(refMinV, v);
+        refMaxV = Math.max(refMaxV, v);
+    }
+    const refSizeU = refMaxU - refMinU;
+    const refSizeV = refMaxV - refMinV;
+    const newUvs = new Float32Array(vertexCount * 2);
+    for (let i = 0; i < vertexCount; i++) {
+        const xyzOffset = i * 3;
+        const uvOffset = i * 2;
+        let [u, v] = toUv([positions[xyzOffset], positions[xyzOffset + 1], positions[xyzOffset + 2]], mappingPlaneVectors);
+        u = (u - refMinU) / refSizeU;
+        v = (v - refMinV) / refSizeV;
+        if (transform !== undefined) {
+            [u, v] = UVMapper.applyUvTransform([u, v], transform);
+        }
+        newUvs[uvOffset] = u;
+        newUvs[uvOffset + 1] = v;
+    }
+    return newUvs;
+}

package/dist/cm/core3D/uvmapper/UVTransformer.d.ts

@@ -1,6 +1,6 @@
-import { Transform2D } from "../../geometry/Transform2D.js";
-export declare class UVTransformer {
-    transform: Transform2D;
-    constructor(transform: Transform2D);
-}
+import { Transform2D } from "../../geometry/Transform2D.js";
+export declare class UVTransformer {
+    transform: Transform2D;
+    constructor(transform: Transform2D);
+}
 //# sourceMappingURL=UVTransformer.d.ts.map

package/dist/cm/core3D/uvmapper/UVTransformer.js

@@ -1,5 +1,5 @@
-export class UVTransformer {
-    constructor(transform) {
-        this.transform = transform;
-    }
-}
+export class UVTransformer {
+    constructor(transform) {
+        this.transform = transform;
+    }
+}

package/dist/cm/core3D/uvmapper/instantiateUVMapper.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from "@configura/web-utilities";
-import { UVMapper } from "./UVMapper.js";
-export declare function instantiateUVMapper(logger: Logger, className: string): UVMapper;
+import { Logger } from "@configura/web-utilities";
+import { UVMapper } from "./UVMapper.js";
+export declare function instantiateUVMapper(logger: Logger, className: string): UVMapper;
 //# sourceMappingURL=instantiateUVMapper.d.ts.map

package/dist/cm/core3D/uvmapper/instantiateUVMapper.js

@@ -1,4 +1,4 @@
-import { UVMapper } from "./UVMapper.js";
-export function instantiateUVMapper(logger, className) {
-    return new UVMapper();
-}
+import { UVMapper } from "./UVMapper.js";
+export function instantiateUVMapper(logger, className) {
+    return new UVMapper();
+}

package/dist/cm/format/cmsym/InvalidationEnv.d.ts

@@ -1,10 +1,10 @@
-import { SymInv } from "./SymInv.js";
-import { SymNode } from "./SymNode.js";
-export declare class InvalidationEnv {
-    node: SymNode;
-    invalidation: SymInv[];
-    n: number;
-    constructor(node: SymNode, invalidation: SymInv[], n?: number);
-    dump(): void;
-}
+import { SymInv } from "./SymInv.js";
+import { SymNode } from "./SymNode.js";
+export declare class InvalidationEnv {
+    node: SymNode;
+    invalidation: SymInv[];
+    n: number;
+    constructor(node: SymNode, invalidation: SymInv[], n?: number);
+    dump(): void;
+}
 //# sourceMappingURL=InvalidationEnv.d.ts.map

package/dist/cm/format/cmsym/InvalidationEnv.js

@@ -1,13 +1,13 @@
-export class InvalidationEnv {
-    constructor(node, invalidation, n = 0) {
-        this.node = node;
-        this.invalidation = invalidation;
-        this.n = n;
-    }
-    dump() {
-        console.log(`${" ".repeat(this.n)}${this.node}`);
-        for (const inv of this.invalidation) {
-            console.log(`${" ".repeat(this.n + 1)}${inv}`);
-        }
-    }
-}
+export class InvalidationEnv {
+    constructor(node, invalidation, n = 0) {
+        this.node = node;
+        this.invalidation = invalidation;
+        this.n = n;
+    }
+    dump() {
+        console.log(`${" ".repeat(this.n)}${this.node}`);
+        for (const inv of this.invalidation) {
+            console.log(`${" ".repeat(this.n + 1)}${inv}`);
+        }
+    }
+}

package/dist/cm/format/cmsym/SymImportEnv.d.ts

@@ -1,10 +1,10 @@
-import { Semver } from "../../io/Semver.js";
-import { DexObj } from "../dex/DexObj.js";
-import { SymNode } from "./SymNode.js";
-export declare class SymImportEnv {
-    fileVersion: Semver;
-    sharedNodeMap: Map<DexObj, SymNode>;
-    constructor(fileVersion: Semver);
-    copy(): SymImportEnv;
-}
+import { Semver } from "../../io/Semver.js";
+import { DexObj } from "../dex/DexObj.js";
+import { SymNode } from "./SymNode.js";
+export declare class SymImportEnv {
+    fileVersion: Semver;
+    sharedNodeMap: Map<DexObj, SymNode>;
+    constructor(fileVersion: Semver);
+    copy(): SymImportEnv;
+}
 //# sourceMappingURL=SymImportEnv.d.ts.map

package/dist/cm/format/cmsym/SymImportEnv.js

@@ -1,9 +1,9 @@
-export class SymImportEnv {
-    constructor(fileVersion) {
-        this.fileVersion = fileVersion;
-        this.sharedNodeMap = new Map();
-    }
-    copy() {
-        return new SymImportEnv(this.fileVersion);
-    }
-}
+export class SymImportEnv {
+    constructor(fileVersion) {
+        this.fileVersion = fileVersion;
+        this.sharedNodeMap = new Map();
+    }
+    copy() {
+        return new SymImportEnv(this.fileVersion);
+    }
+}

package/dist/cm/format/cmsym/SymInv.d.ts

@@ -1,9 +1,9 @@
-import { SymNode } from "./SymNode.js";
-export declare class SymInv {
-    needToInvalidate(node: SymNode): boolean;
-    skip(node: SymNode): boolean;
-    propagate(): boolean;
-    invalidate(node: SymNode): void;
-    toString(): string;
-}
+import { SymNode } from "./SymNode.js";
+export declare class SymInv {
+    needToInvalidate(node: SymNode): boolean;
+    skip(node: SymNode): boolean;
+    propagate(): boolean;
+    invalidate(node: SymNode): void;
+    toString(): string;
+}
 //# sourceMappingURL=SymInv.d.ts.map

package/dist/cm/format/cmsym/SymInv.js

@@ -1,15 +1,17 @@
-export class SymInv {
-    needToInvalidate(node) {
-        return true;
-    }
-    skip(node) {
-        return false;
-    }
-    propagate() {
-        return true;
-    }
-    invalidate(node) { }
-    toString() {
-        return `SymInv()`;
-    }
-}
+export class SymInv {
+    needToInvalidate(node) {
+        return true;
+    }
+    skip(node) {
+        return false;
+    }
+    propagate() {
+        return true;
+    }
+    invalidate(node) {
+        // This method has been left intentionally blank
+    }
+    toString() {
+        return `SymInv()`;
+    }
+}

package/dist/cm/format/cmsym/SymNode.d.ts

@@ -1,94 +1,95 @@
-import { Logger } from "@configura/web-utilities";
-import { DetailLevel } from "../../geometry/DetailMask.js";
-import { DexManager } from "../dex/DexManager.js";
-import { DexObj } from "../dex/DexObj.js";
-import { SymBox } from "./components/SymBox.js";
-import { DexObjKey, SymComponent, SymComponentKey } from "./components/SymComponent.js";
-import { SymDexObj } from "./components/SymDexObj.js";
-import { SymGMaterial } from "./components/SymGMaterial.js";
-import { SymGMaterialSelector } from "./components/SymGMaterialSelector.js";
-import { SymMeasure } from "./components/SymMeasure.js";
-import { SymMesh } from "./components/SymMesh.js";
-import { SymPlane } from "./components/SymPlane.js";
-import { SymProps } from "./components/SymProps.js";
-import { SymReps } from "./components/SymReps.js";
-import { SymSphere } from "./components/SymSphere.js";
-import { SymTags } from "./components/SymTags.js";
-import { SymTransform } from "./components/SymTransform.js";
-import { SymUVMapper } from "./components/SymUVMapper.js";
-import { SymImportEnv } from "./SymImportEnv.js";
-export declare const VERBOSE_SYM_LOGGING = false;
-export declare class SymNode {
-    id: string;
-    _children?: Map<string, SymNode>;
-    components: Map<string, SymComponent>;
-    _parents?: SymNode[];
-    constructor(id: string);
-    setId(logger: Logger, newId: string): void;
-    children(logger: Logger, safe: true, load: boolean): Map<string, SymNode>;
-    children(logger: Logger, safe?: boolean, load?: boolean): Map<string, SymNode> | undefined;
-    ensureChildrenLoaded(logger: Logger): void;
-    dexChildrenCount(): number;
-    loadDexChildren(logger: Logger): void;
-    addChild(logger: Logger, child: SymNode, invalidate?: boolean): void;
-    loadChild(logger: Logger, dexChildren: DexObj, id: string, env?: SymImportEnv): SymNode | undefined;
-    addParent(parent?: SymNode, safe?: boolean): void;
-    invalidateParent(parent: SymNode, removed: boolean): void;
-    invalidate(removed: boolean): void;
-    importEnv(ascend?: boolean): SymImportEnv | undefined;
-    setImportEnv(env: SymImportEnv): (SymDexObj & Error) | undefined;
-    set(key: string, value: unknown): void;
-    get(key: string): unknown;
-    has(key: string): boolean;
-    fillPropsAfterLoad(): (SymProps & Error) | undefined;
-    hasDexComponent(key: string): boolean | (DexObj & Error);
-    breakDexConnection(loadChildren?: boolean, descend?: boolean): void;
-    _breakDexConnection(env: SymImportEnv, loadChildren: boolean, descend: boolean): void;
-    dexObj(): DexObj | undefined;
-    symDexObj(): SymDexObj | undefined;
-    symGMaterial(safe: true): SymGMaterial;
-    symGMaterial(safe?: boolean): SymGMaterial | undefined;
-    symGMaterialSelector(safe: true): SymGMaterialSelector;
-    symGMaterialSelector(safe?: boolean): SymGMaterialSelector | undefined;
-    symMesh(safe: true): SymMesh;
-    symMesh(safe?: boolean): SymMesh | undefined;
-    symSphere(safe: true): SymSphere;
-    symSphere(safe?: boolean): SymSphere | undefined;
-    symBox(safe: true): SymBox;
-    symBox(safe?: boolean): SymBox | undefined;
-    symPlane(safe: true): SymPlane;
-    symPlane(safe?: boolean): SymPlane | undefined;
-    symProps(safe: true): SymProps;
-    symProps(safe?: boolean): SymProps | undefined;
-    symReps(safe: true): SymReps;
-    symReps(safe?: boolean): SymReps | undefined;
-    symTags(safe: true): SymTags;
-    symTags(safe?: boolean): SymTags | undefined;
-    symTransform(safe: true): SymTransform;
-    symTransform(safe?: boolean): SymTransform | undefined;
-    symUVMapper(safe: true): SymUVMapper;
-    symUVMapper(safe?: boolean): SymUVMapper | undefined;
-    getMeasure(): SymMeasure | undefined;
-    private _isStretch;
-    isStretch(logger: Logger, detailLevel: DetailLevel): boolean;
-    getComponent(key: SymComponentKey): SymComponent | undefined;
-    addComponent(component: SymComponent, invalidate?: boolean): void;
-    hasComponent(key: SymComponentKey | DexObjKey): boolean;
-    removeComponent(key: SymComponentKey, invalidate?: boolean): void;
-    loadComponents(logger: Logger, force?: boolean): void;
-    loadComponent(logger: Logger, key: SymComponentKey | DexObjKey, obj: DexObj, env?: SymImportEnv, force?: boolean): boolean;
-    prepareAfterLoad(): void;
-    features(create?: boolean): Map<string, SymComponentKey>;
-    featureProviderKey(feature: string): SymComponentKey | undefined;
-    featureProvider(feature: string): SymComponent | undefined;
-    buildFeatures(): Map<string, SymComponentKey>;
-    addFeaturesFrom(component: SymComponent): void;
-    childrenProvider(): SymComponent | undefined;
-    meshProvider(): SymComponent | undefined;
-    get3DTmp(logger: Logger, detail: DetailLevel): import("./components/mesh.js").TaggedNode[];
-    toString(): string;
-}
-export declare function toSymNode(logger: Logger, obj: DexObj, parent?: SymNode, env?: SymImportEnv, putImportEnv?: boolean): SymNode;
-export declare function loadSymFile(logger: Logger, url: string, manager: DexManager, abortSignal?: AbortSignal): Promise<SymNode>;
-export declare function makeSymFromDex(logger: Logger, root: DexObj): SymNode;
+import { Logger } from "@configura/web-utilities";
+import { DetailLevel } from "../../geometry/DetailMask.js";
+import { DexManager } from "../dex/DexManager.js";
+import { DexObj } from "../dex/DexObj.js";
+import { TaggedNode } from "./components/mesh.js";
+import { SymBox } from "./components/SymBox.js";
+import { DexObjKey, SymComponent, SymComponentKey } from "./components/SymComponent.js";
+import { SymDexObj } from "./components/SymDexObj.js";
+import { SymGMaterial } from "./components/SymGMaterial.js";
+import { SymGMaterialSelector } from "./components/SymGMaterialSelector.js";
+import { SymMeasure } from "./components/SymMeasure.js";
+import { SymMesh } from "./components/SymMesh.js";
+import { SymPlane } from "./components/SymPlane.js";
+import { SymProps } from "./components/SymProps.js";
+import { SymReps } from "./components/SymReps.js";
+import { SymSphere } from "./components/SymSphere.js";
+import { SymTags } from "./components/SymTags.js";
+import { SymTransform } from "./components/SymTransform.js";
+import { SymUVMapper } from "./components/SymUVMapper.js";
+import { SymImportEnv } from "./SymImportEnv.js";
+export declare const VERBOSE_SYM_LOGGING = false;
+export declare class SymNode {
+    id: string;
+    _children?: Map<string, SymNode>;
+    components: Map<string, SymComponent>;
+    _parents?: SymNode[];
+    constructor(id: string);
+    setId(logger: Logger, newId: string): void;
+    children(logger: Logger, safe: true, load: boolean): Map<string, SymNode>;
+    children(logger: Logger, safe?: boolean, load?: boolean): Map<string, SymNode> | undefined;
+    ensureChildrenLoaded(logger: Logger): void;
+    dexChildrenCount(): number;
+    loadDexChildren(logger: Logger): void;
+    addChild(logger: Logger, child: SymNode, invalidate?: boolean): void;
+    loadChild(logger: Logger, dexChildren: DexObj, id: string, env?: SymImportEnv): SymNode | undefined;
+    addParent(parent?: SymNode, safe?: boolean): void;
+    invalidateParent(parent: SymNode, removed: boolean): void;
+    invalidate(removed: boolean): void;
+    importEnv(ascend?: boolean): SymImportEnv | undefined;
+    setImportEnv(env: SymImportEnv): (SymDexObj & Error) | undefined;
+    set(key: string, value: unknown): void;
+    get(key: string): unknown;
+    has(key: string): boolean;
+    fillPropsAfterLoad(): (SymProps | Error) | undefined;
+    hasDexComponent(key: string): boolean | Error;
+    breakDexConnection(loadChildren?: boolean, descend?: boolean): void;
+    _breakDexConnection(env: SymImportEnv, loadChildren: boolean, descend: boolean): void;
+    dexObj(): DexObj | undefined;
+    symDexObj(): SymDexObj | undefined;
+    symGMaterial(safe: true): SymGMaterial;
+    symGMaterial(safe?: boolean): SymGMaterial | undefined;
+    symGMaterialSelector(safe: true): SymGMaterialSelector;
+    symGMaterialSelector(safe?: boolean): SymGMaterialSelector | undefined;
+    symMesh(safe: true): SymMesh;
+    symMesh(safe?: boolean): SymMesh | undefined;
+    symSphere(safe: true): SymSphere;
+    symSphere(safe?: boolean): SymSphere | undefined;
+    symBox(safe: true): SymBox;
+    symBox(safe?: boolean): SymBox | undefined;
+    symPlane(safe: true): SymPlane;
+    symPlane(safe?: boolean): SymPlane | undefined;
+    symProps(safe: true): SymProps;
+    symProps(safe?: boolean): SymProps | undefined;
+    symReps(safe: true): SymReps;
+    symReps(safe?: boolean): SymReps | undefined;
+    symTags(safe: true): SymTags;
+    symTags(safe?: boolean): SymTags | undefined;
+    symTransform(safe: true): SymTransform;
+    symTransform(safe?: boolean): SymTransform | undefined;
+    symUVMapper(safe: true): SymUVMapper;
+    symUVMapper(safe?: boolean): SymUVMapper | undefined;
+    getMeasure(): SymMeasure | undefined;
+    private _isStretch;
+    isStretch(logger: Logger, detailLevel: DetailLevel): boolean;
+    getComponent(key: SymComponentKey): SymComponent | undefined;
+    addComponent(component: SymComponent, invalidate?: boolean): void;
+    hasComponent(key: SymComponentKey | DexObjKey): boolean;
+    removeComponent(key: SymComponentKey, invalidate?: boolean): void;
+    loadComponents(logger: Logger, force?: boolean): void;
+    loadComponent(logger: Logger, key: SymComponentKey | DexObjKey, obj: DexObj, env?: SymImportEnv, force?: boolean): boolean;
+    prepareAfterLoad(): void;
+    features(create?: boolean): Map<string, SymComponentKey>;
+    featureProviderKey(feature: string): SymComponentKey | undefined;
+    featureProvider(feature: string): SymComponent | undefined;
+    buildFeatures(): Map<string, SymComponentKey>;
+    addFeaturesFrom(component: SymComponent): void;
+    childrenProvider(): SymComponent | undefined;
+    meshProvider(): SymComponent | undefined;
+    get3DTmp(logger: Logger, detail: DetailLevel): TaggedNode[];
+    toString(): string;
+}
+export declare function toSymNode(logger: Logger, obj: DexObj, parent?: SymNode, env?: SymImportEnv, putImportEnv?: boolean): SymNode;
+export declare function loadSymFile(logger: Logger, url: string, manager: DexManager, abortSignal?: AbortSignal): Promise<SymNode>;
+export declare function makeSymFromDex(logger: Logger, root: DexObj): SymNode;
 //# sourceMappingURL=SymNode.d.ts.map