@ifc-lite/parser 2.1.0 → 2.1.1

package/dist/columnar-parser.js

@@ -5,7 +5,9 @@ import { SpatialHierarchyBuilder } from './spatial-hierarchy-builder.js';
 import { EntityExtractor } from './entity-extractor.js';
 import { extractLengthUnitScale } from './unit-extractor.js';
 import { getAttributeNames } from './ifc-schema.js';
-import { StringTable, EntityTableBuilder, PropertyTableBuilder, QuantityTableBuilder, RelationshipGraphBuilder, RelationshipType, QuantityType, PropertyValueType, } from '@ifc-lite/data';
+import { parsePropertyValue } from './on-demand-extractors.js';
+import { buildCompactEntityIndex } from './compact-entity-index.js';
+import { StringTable, EntityTableBuilder, PropertyTableBuilder, QuantityTableBuilder, RelationshipGraphBuilder, RelationshipType, QuantityType, } from '@ifc-lite/data';
 // Pre-computed type sets for O(1) lookups
 const GEOMETRY_TYPES = new Set([
     'IFCWALL', 'IFCWALLSTANDARDCASE', 'IFCDOOR', 'IFCWINDOW', 'IFCSLAB',
@@ -126,10 +128,21 @@ export class ColumnarParser {
         const propertyTableBuilder = new PropertyTableBuilder(strings);
         const quantityTableBuilder = new QuantityTableBuilder(strings);
         const relationshipGraphBuilder = new RelationshipGraphBuilder();
-        // Build entity index early (needed for property relationship lookup)
+        // Build compact entity index (typed arrays instead of Map for ~3x memory reduction)
+        const compactByIdIndex = buildCompactEntityIndex(entityRefs);
+        // Also build byType index (Map<string, number[]>)
+        const byType = new Map();
+        for (const ref of entityRefs) {
+            let typeList = byType.get(ref.type);
+            if (!typeList) {
+                typeList = [];
+                byType.set(ref.type, typeList);
+            }
+            typeList.push(ref.expressId);
+        }
         const entityIndex = {
-            byId: new Map(),
-            byType: new Map(),
+            byId: compactByIdIndex,
+            byType,
         };
         // First pass: collect spatial, geometry, relationship, property, and type refs for targeted parsing
         const spatialRefs = [];
@@ -140,14 +153,6 @@ export class ColumnarParser {
         const associationRelRefs = [];
         const typeObjectRefs = [];
         for (const ref of entityRefs) {
-            // Build entity index
-            entityIndex.byId.set(ref.expressId, ref);
-            let typeList = entityIndex.byType.get(ref.type);
-            if (!typeList) {
-                typeList = [];
-                entityIndex.byType.set(ref.type, typeList);
-            }
-            typeList.push(ref.expressId);
             // Categorize refs for targeted parsing
             const typeUpper = ref.type.toUpperCase();
             if (SPATIAL_TYPES.has(typeUpper)) {
@@ -627,806 +632,6 @@ export function extractAllEntityAttributes(store, entityId) {
     }
     return result;
 }
-/**
- * Extract classifications for a single entity ON-DEMAND.
- * Uses the onDemandClassificationMap built during parsing.
- * Falls back to relationship graph when on-demand map is not available (e.g., server-loaded models).
- * Also checks type-level associations via IfcRelDefinesByType.
- * Returns an array of classification references with system info.
- */
-export function extractClassificationsOnDemand(store, entityId) {
-    let classRefIds;
-    if (store.onDemandClassificationMap) {
-        classRefIds = store.onDemandClassificationMap.get(entityId);
-    }
-    else if (store.relationships) {
-        // Fallback: use relationship graph (server-loaded models)
-        const related = store.relationships.getRelated(entityId, RelationshipType.AssociatesClassification, 'inverse');
-        if (related.length > 0)
-            classRefIds = related;
-    }
-    // Also check type-level classifications via IfcRelDefinesByType
-    if (store.relationships) {
-        const typeIds = store.relationships.getRelated(entityId, RelationshipType.DefinesByType, 'inverse');
-        for (const typeId of typeIds) {
-            let typeClassRefs;
-            if (store.onDemandClassificationMap) {
-                typeClassRefs = store.onDemandClassificationMap.get(typeId);
-            }
-            else {
-                const related = store.relationships.getRelated(typeId, RelationshipType.AssociatesClassification, 'inverse');
-                if (related.length > 0)
-                    typeClassRefs = related;
-            }
-            if (typeClassRefs && typeClassRefs.length > 0) {
-                classRefIds = classRefIds ? [...classRefIds, ...typeClassRefs] : [...typeClassRefs];
-            }
-        }
-    }
-    if (!classRefIds || classRefIds.length === 0)
-        return [];
-    if (!store.source?.length)
-        return [];
-    const extractor = new EntityExtractor(store.source);
-    const results = [];
-    for (const classRefId of classRefIds) {
-        const ref = store.entityIndex.byId.get(classRefId);
-        if (!ref)
-            continue;
-        const entity = extractor.extractEntity(ref);
-        if (!entity)
-            continue;
-        const typeUpper = entity.type.toUpperCase();
-        const attrs = entity.attributes || [];
-        if (typeUpper === 'IFCCLASSIFICATIONREFERENCE') {
-            // IfcClassificationReference: [Location, Identification, Name, ReferencedSource, Description, Sort]
-            const info = {
-                location: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                identification: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                name: typeof attrs[2] === 'string' ? attrs[2] : undefined,
-                description: typeof attrs[4] === 'string' ? attrs[4] : undefined,
-            };
-            // Walk up to find the classification system name
-            const referencedSourceId = typeof attrs[3] === 'number' ? attrs[3] : undefined;
-            if (referencedSourceId) {
-                const path = walkClassificationChain(store, extractor, referencedSourceId);
-                info.system = path.systemName;
-                info.path = path.codes;
-            }
-            results.push(info);
-        }
-        else if (typeUpper === 'IFCCLASSIFICATION') {
-            // IfcClassification: [Source, Edition, EditionDate, Name, Description, Location, ReferenceTokens]
-            results.push({
-                system: typeof attrs[3] === 'string' ? attrs[3] : undefined,
-                name: typeof attrs[3] === 'string' ? attrs[3] : undefined,
-                description: typeof attrs[4] === 'string' ? attrs[4] : undefined,
-                location: typeof attrs[5] === 'string' ? attrs[5] : undefined,
-            });
-        }
-    }
-    return results;
-}
-/**
- * Walk up the IfcClassificationReference chain to find the root IfcClassification system.
- */
-function walkClassificationChain(store, extractor, startId) {
-    const codes = [];
-    let currentId = startId;
-    const visited = new Set();
-    while (currentId !== undefined && !visited.has(currentId)) {
-        visited.add(currentId);
-        const ref = store.entityIndex.byId.get(currentId);
-        if (!ref)
-            break;
-        const entity = extractor.extractEntity(ref);
-        if (!entity)
-            break;
-        const typeUpper = entity.type.toUpperCase();
-        const attrs = entity.attributes || [];
-        if (typeUpper === 'IFCCLASSIFICATION') {
-            // Root: IfcClassification [Source, Edition, EditionDate, Name, ...]
-            const systemName = typeof attrs[3] === 'string' ? attrs[3] : undefined;
-            return { systemName, codes };
-        }
-        if (typeUpper === 'IFCCLASSIFICATIONREFERENCE') {
-            // IfcClassificationReference [Location, Identification, Name, ReferencedSource, ...]
-            const code = typeof attrs[1] === 'string' ? attrs[1] :
-                typeof attrs[2] === 'string' ? attrs[2] : undefined;
-            if (code)
-                codes.unshift(code);
-            currentId = typeof attrs[3] === 'number' ? attrs[3] : undefined;
-        }
-        else {
-            break;
-        }
-    }
-    return { codes };
-}
-/**
- * Extract materials for a single entity ON-DEMAND.
- * Uses the onDemandMaterialMap built during parsing.
- * Falls back to relationship graph when on-demand map is not available (e.g., server-loaded models).
- * Also checks type-level material assignments via IfcRelDefinesByType.
- * Resolves the full material structure (layers, profiles, constituents, lists).
- */
-export function extractMaterialsOnDemand(store, entityId) {
-    let materialId;
-    if (store.onDemandMaterialMap) {
-        materialId = store.onDemandMaterialMap.get(entityId);
-    }
-    else if (store.relationships) {
-        // Fallback: use relationship graph (server-loaded models)
-        const related = store.relationships.getRelated(entityId, RelationshipType.AssociatesMaterial, 'inverse');
-        if (related.length > 0)
-            materialId = related[0];
-    }
-    // Check type-level material if occurrence has none
-    if (materialId === undefined && store.relationships) {
-        const typeIds = store.relationships.getRelated(entityId, RelationshipType.DefinesByType, 'inverse');
-        for (const typeId of typeIds) {
-            if (store.onDemandMaterialMap) {
-                materialId = store.onDemandMaterialMap.get(typeId);
-            }
-            else {
-                const related = store.relationships.getRelated(typeId, RelationshipType.AssociatesMaterial, 'inverse');
-                if (related.length > 0)
-                    materialId = related[0];
-            }
-            if (materialId !== undefined)
-                break;
-        }
-    }
-    if (materialId === undefined)
-        return null;
-    if (!store.source?.length)
-        return null;
-    const extractor = new EntityExtractor(store.source);
-    return resolveMaterial(store, extractor, materialId, new Set());
-}
-/**
- * Resolve a material entity by ID, handling all IFC material types.
- * Uses visited set to prevent infinite recursion on cyclic *Usage references.
- */
-function resolveMaterial(store, extractor, materialId, visited = new Set()) {
-    if (visited.has(materialId))
-        return null;
-    visited.add(materialId);
-    const ref = store.entityIndex.byId.get(materialId);
-    if (!ref)
-        return null;
-    const entity = extractor.extractEntity(ref);
-    if (!entity)
-        return null;
-    const typeUpper = entity.type.toUpperCase();
-    const attrs = entity.attributes || [];
-    switch (typeUpper) {
-        case 'IFCMATERIAL': {
-            // IfcMaterial: [Name, Description, Category]
-            return {
-                type: 'Material',
-                name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                description: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-            };
-        }
-        case 'IFCMATERIALLAYERSET': {
-            // IfcMaterialLayerSet: [MaterialLayers, LayerSetName, Description]
-            const layerIds = Array.isArray(attrs[0]) ? attrs[0].filter((id) => typeof id === 'number') : [];
-            const layers = [];
-            for (const layerId of layerIds) {
-                const layerRef = store.entityIndex.byId.get(layerId);
-                if (!layerRef)
-                    continue;
-                const layerEntity = extractor.extractEntity(layerRef);
-                if (!layerEntity)
-                    continue;
-                const la = layerEntity.attributes || [];
-                // IfcMaterialLayer: [Material, LayerThickness, IsVentilated, Name, Description, Category, Priority]
-                const matId = typeof la[0] === 'number' ? la[0] : undefined;
-                let materialName;
-                if (matId) {
-                    const matRef = store.entityIndex.byId.get(matId);
-                    if (matRef) {
-                        const matEntity = extractor.extractEntity(matRef);
-                        if (matEntity) {
-                            materialName = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : undefined;
-                        }
-                    }
-                }
-                layers.push({
-                    materialName,
-                    thickness: typeof la[1] === 'number' ? la[1] : undefined,
-                    isVentilated: la[2] === true || la[2] === '.T.',
-                    name: typeof la[3] === 'string' ? la[3] : undefined,
-                    category: typeof la[5] === 'string' ? la[5] : undefined,
-                });
-            }
-            return {
-                type: 'MaterialLayerSet',
-                name: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                description: typeof attrs[2] === 'string' ? attrs[2] : undefined,
-                layers,
-            };
-        }
-        case 'IFCMATERIALPROFILESET': {
-            // IfcMaterialProfileSet: [Name, Description, MaterialProfiles, CompositeProfile]
-            const profileIds = Array.isArray(attrs[2]) ? attrs[2].filter((id) => typeof id === 'number') : [];
-            const profiles = [];
-            for (const profId of profileIds) {
-                const profRef = store.entityIndex.byId.get(profId);
-                if (!profRef)
-                    continue;
-                const profEntity = extractor.extractEntity(profRef);
-                if (!profEntity)
-                    continue;
-                const pa = profEntity.attributes || [];
-                // IfcMaterialProfile: [Name, Description, Material, Profile, Priority, Category]
-                const matId = typeof pa[2] === 'number' ? pa[2] : undefined;
-                let materialName;
-                if (matId) {
-                    const matRef = store.entityIndex.byId.get(matId);
-                    if (matRef) {
-                        const matEntity = extractor.extractEntity(matRef);
-                        if (matEntity) {
-                            materialName = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : undefined;
-                        }
-                    }
-                }
-                profiles.push({
-                    materialName,
-                    name: typeof pa[0] === 'string' ? pa[0] : undefined,
-                    category: typeof pa[5] === 'string' ? pa[5] : undefined,
-                });
-            }
-            return {
-                type: 'MaterialProfileSet',
-                name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                description: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                profiles,
-            };
-        }
-        case 'IFCMATERIALCONSTITUENTSET': {
-            // IfcMaterialConstituentSet: [Name, Description, MaterialConstituents]
-            const constituentIds = Array.isArray(attrs[2]) ? attrs[2].filter((id) => typeof id === 'number') : [];
-            const constituents = [];
-            for (const constId of constituentIds) {
-                const constRef = store.entityIndex.byId.get(constId);
-                if (!constRef)
-                    continue;
-                const constEntity = extractor.extractEntity(constRef);
-                if (!constEntity)
-                    continue;
-                const ca = constEntity.attributes || [];
-                // IfcMaterialConstituent: [Name, Description, Material, Fraction, Category]
-                const matId = typeof ca[2] === 'number' ? ca[2] : undefined;
-                let materialName;
-                if (matId) {
-                    const matRef = store.entityIndex.byId.get(matId);
-                    if (matRef) {
-                        const matEntity = extractor.extractEntity(matRef);
-                        if (matEntity) {
-                            materialName = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : undefined;
-                        }
-                    }
-                }
-                constituents.push({
-                    materialName,
-                    name: typeof ca[0] === 'string' ? ca[0] : undefined,
-                    fraction: typeof ca[3] === 'number' ? ca[3] : undefined,
-                    category: typeof ca[4] === 'string' ? ca[4] : undefined,
-                });
-            }
-            return {
-                type: 'MaterialConstituentSet',
-                name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                description: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                constituents,
-            };
-        }
-        case 'IFCMATERIALLIST': {
-            // IfcMaterialList: [Materials]
-            const matIds = Array.isArray(attrs[0]) ? attrs[0].filter((id) => typeof id === 'number') : [];
-            const materials = [];
-            for (const matId of matIds) {
-                const matRef = store.entityIndex.byId.get(matId);
-                if (!matRef)
-                    continue;
-                const matEntity = extractor.extractEntity(matRef);
-                if (matEntity) {
-                    const name = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : `Material #${matId}`;
-                    materials.push(name);
-                }
-            }
-            return {
-                type: 'MaterialList',
-                materials,
-            };
-        }
-        case 'IFCMATERIALLAYERSETUSAGE': {
-            // IfcMaterialLayerSetUsage: [ForLayerSet, LayerSetDirection, DirectionSense, OffsetFromReferenceLine, ...]
-            const layerSetId = typeof attrs[0] === 'number' ? attrs[0] : undefined;
-            if (layerSetId) {
-                return resolveMaterial(store, extractor, layerSetId, visited);
-            }
-            return null;
-        }
-        case 'IFCMATERIALPROFILESETUSAGE': {
-            // IfcMaterialProfileSetUsage: [ForProfileSet, ...]
-            const profileSetId = typeof attrs[0] === 'number' ? attrs[0] : undefined;
-            if (profileSetId) {
-                return resolveMaterial(store, extractor, profileSetId, visited);
-            }
-            return null;
-        }
-        default:
-            return null;
-    }
-}
-/**
- * Parse a property entity's value based on its IFC type.
- * Handles all 6 IfcProperty subtypes:
- * - IfcPropertySingleValue: direct value
- * - IfcPropertyEnumeratedValue: list of enum values → joined string
- * - IfcPropertyBoundedValue: upper/lower bounds → "value [min – max]"
- * - IfcPropertyListValue: list of values → joined string
- * - IfcPropertyTableValue: defining/defined value pairs → "Table(N rows)"
- * - IfcPropertyReferenceValue: entity reference → "Reference #ID"
- */
-function parsePropertyValue(propEntity) {
-    const attrs = propEntity.attributes || [];
-    const typeUpper = propEntity.type.toUpperCase();
-    switch (typeUpper) {
-        case 'IFCPROPERTYENUMERATEDVALUE': {
-            // [Name, Description, EnumerationValues (list), EnumerationReference]
-            const enumValues = attrs[2];
-            if (Array.isArray(enumValues)) {
-                const values = enumValues.map(v => {
-                    if (Array.isArray(v) && v.length === 2)
-                        return String(v[1]); // Typed value
-                    return String(v);
-                }).filter(v => v !== 'null' && v !== 'undefined');
-                return { type: 0, value: values.join(', ') };
-            }
-            return { type: 0, value: null };
-        }
-        case 'IFCPROPERTYBOUNDEDVALUE': {
-            // [Name, Description, UpperBoundValue, LowerBoundValue, Unit, SetPointValue]
-            const upper = extractNumericValue(attrs[2]);
-            const lower = extractNumericValue(attrs[3]);
-            const setPoint = extractNumericValue(attrs[5]);
-            const displayValue = setPoint ?? upper ?? lower;
-            let display = displayValue != null ? String(displayValue) : '';
-            if (lower != null && upper != null) {
-                display += ` [${lower} – ${upper}]`;
-            }
-            return { type: displayValue != null ? 1 : 0, value: display || null };
-        }
-        case 'IFCPROPERTYLISTVALUE': {
-            // [Name, Description, ListValues (list), Unit]
-            const listValues = attrs[2];
-            if (Array.isArray(listValues)) {
-                const values = listValues.map(v => {
-                    if (Array.isArray(v) && v.length === 2)
-                        return String(v[1]);
-                    return String(v);
-                }).filter(v => v !== 'null' && v !== 'undefined');
-                return { type: 0, value: values.join(', ') };
-            }
-            return { type: 0, value: null };
-        }
-        case 'IFCPROPERTYTABLEVALUE': {
-            // [Name, Description, DefiningValues, DefinedValues, ...]
-            const definingValues = attrs[2];
-            const definedValues = attrs[3];
-            const rowCount = Array.isArray(definingValues) ? definingValues.length : 0;
-            if (rowCount > 0 && Array.isArray(definedValues)) {
-                return { type: 0, value: `Table (${rowCount} rows)` };
-            }
-            return { type: 0, value: null };
-        }
-        case 'IFCPROPERTYREFERENCEVALUE': {
-            // [Name, Description, PropertyReference]
-            const refValue = attrs[2];
-            if (typeof refValue === 'number') {
-                return { type: 0, value: `#${refValue}` };
-            }
-            return { type: 0, value: null };
-        }
-        default: {
-            // IfcPropertySingleValue and fallback: [Name, Description, NominalValue, Unit]
-            const nominalValue = attrs[2];
-            let type = PropertyValueType.String;
-            let value = nominalValue;
-            // Handle typed values like IFCBOOLEAN(.T.), IFCREAL(1.5)
-            if (Array.isArray(nominalValue) && nominalValue.length === 2) {
-                const innerValue = nominalValue[1];
-                const typeName = String(nominalValue[0]).toUpperCase();
-                if (typeName.includes('BOOLEAN')) {
-                    type = PropertyValueType.Boolean;
-                    value = innerValue === '.T.' || innerValue === true;
-                }
-                else if (typeName.includes('LOGICAL')) {
-                    type = PropertyValueType.Logical;
-                    // Preserve .U. (unknown) as null; .T./.F. as boolean
-                    if (innerValue === '.U.' || innerValue === '.X.') {
-                        value = null;
-                    }
-                    else {
-                        value = innerValue === '.T.' || innerValue === true;
-                    }
-                }
-                else if (typeof innerValue === 'number') {
-                    if (Number.isInteger(innerValue)) {
-                        type = PropertyValueType.Integer;
-                    }
-                    else {
-                        type = PropertyValueType.Real;
-                    }
-                    value = innerValue;
-                }
-                else {
-                    type = PropertyValueType.String;
-                    value = String(innerValue);
-                }
-            }
-            else if (typeof nominalValue === 'number') {
-                type = Number.isInteger(nominalValue) ? PropertyValueType.Integer : PropertyValueType.Real;
-            }
-            else if (typeof nominalValue === 'boolean') {
-                type = PropertyValueType.Boolean;
-            }
-            else if (nominalValue !== null && nominalValue !== undefined) {
-                value = String(nominalValue);
-            }
-            return { type, value };
-        }
-    }
-}
-/** Extract a numeric value from a possibly typed STEP value. */
-function extractNumericValue(attr) {
-    if (typeof attr === 'number')
-        return attr;
-    if (Array.isArray(attr) && attr.length === 2 && typeof attr[1] === 'number')
-        return attr[1];
-    return null;
-}
-/**
- * Extract property sets from a list of pset IDs using the entity index.
- * Shared logic between instance-level and type-level property extraction.
- */
-function extractPsetsFromIds(store, extractor, psetIds) {
-    const result = [];
-    for (const psetId of psetIds) {
-        const psetRef = store.entityIndex.byId.get(psetId);
-        if (!psetRef)
-            continue;
-        // Only extract IFCPROPERTYSET entities (skip quantity sets etc.)
-        if (psetRef.type.toUpperCase() !== 'IFCPROPERTYSET')
-            continue;
-        const psetEntity = extractor.extractEntity(psetRef);
-        if (!psetEntity)
-            continue;
-        const psetAttrs = psetEntity.attributes || [];
-        const psetGlobalId = typeof psetAttrs[0] === 'string' ? psetAttrs[0] : undefined;
-        const psetName = typeof psetAttrs[2] === 'string' ? psetAttrs[2] : `PropertySet #${psetId}`;
-        const hasProperties = psetAttrs[4];
-        const properties = [];
-        if (Array.isArray(hasProperties)) {
-            for (const propRef of hasProperties) {
-                if (typeof propRef !== 'number')
-                    continue;
-                const propEntityRef = store.entityIndex.byId.get(propRef);
-                if (!propEntityRef)
-                    continue;
-                const propEntity = extractor.extractEntity(propEntityRef);
-                if (!propEntity)
-                    continue;
-                const propAttrs = propEntity.attributes || [];
-                const propName = typeof propAttrs[0] === 'string' ? propAttrs[0] : '';
-                if (!propName)
-                    continue;
-                const parsed = parsePropertyValue(propEntity);
-                properties.push({ name: propName, type: parsed.type, value: parsed.value });
-            }
-        }
-        if (properties.length > 0 || psetName) {
-            result.push({ name: psetName, globalId: psetGlobalId, properties });
-        }
-    }
-    return result;
-}
-/**
- * Extract type-level properties for a single entity ON-DEMAND.
- * Finds the element's type via IfcRelDefinesByType, then extracts property sets from:
- * 1. The type entity's HasPropertySets attribute (IFC2X3/IFC4: index 5 on IfcTypeObject)
- * 2. The onDemandPropertyMap for the type entity (IFC4 IFCRELDEFINESBYPROPERTIES → type)
- * Returns null if no type relationship exists.
- */
-export function extractTypePropertiesOnDemand(store, entityId) {
-    if (!store.relationships)
-        return null;
-    // Find type entity via DefinesByType relationship (inverse: element → type)
-    const typeIds = store.relationships.getRelated(entityId, RelationshipType.DefinesByType, 'inverse');
-    if (typeIds.length === 0)
-        return null;
-    const typeId = typeIds[0]; // An element typically has one type
-    const typeRef = store.entityIndex.byId.get(typeId);
-    if (!typeRef)
-        return null;
-    if (!store.source?.length)
-        return null;
-    const extractor = new EntityExtractor(store.source);
-    // Get type name from entity
-    const typeEntity = extractor.extractEntity(typeRef);
-    const typeName = typeEntity && typeof typeEntity.attributes?.[2] === 'string'
-        ? typeEntity.attributes[2]
-        : typeRef.type;
-    const allPsets = [];
-    const seenPsetNames = new Set();
-    // Source 1: HasPropertySets attribute on the type entity (index 5 for IfcTypeObject subtypes)
-    // Works for both IFC2X3 and IFC4
-    if (typeEntity) {
-        const hasPropertySets = typeEntity.attributes?.[5];
-        if (Array.isArray(hasPropertySets)) {
-            const psetIds = hasPropertySets.filter((id) => typeof id === 'number');
-            const psets = extractPsetsFromIds(store, extractor, psetIds);
-            for (const pset of psets) {
-                seenPsetNames.add(pset.name);
-                allPsets.push(pset);
-            }
-        }
-    }
-    // Source 2: onDemandPropertyMap for the type entity (IFC4: via IFCRELDEFINESBYPROPERTIES)
-    if (store.onDemandPropertyMap) {
-        const typePsetIds = store.onDemandPropertyMap.get(typeId);
-        if (typePsetIds && typePsetIds.length > 0) {
-            const psets = extractPsetsFromIds(store, extractor, typePsetIds);
-            for (const pset of psets) {
-                if (!seenPsetNames.has(pset.name)) {
-                    allPsets.push(pset);
-                }
-            }
-        }
-    }
-    if (allPsets.length === 0)
-        return null;
-    return {
-        typeName,
-        typeId,
-        properties: allPsets,
-    };
-}
-/**
- * Extract properties from a type entity's own HasPropertySets attribute.
- * Used when the type entity itself is selected (e.g., via "By Type" tree).
- * Returns the type's own property sets from attribute index 5 + any via IfcRelDefinesByProperties.
- */
-export function extractTypeEntityOwnProperties(store, typeEntityId) {
-    const ref = store.entityIndex.byId.get(typeEntityId);
-    if (!ref || !store.source?.length)
-        return [];
-    const extractor = new EntityExtractor(store.source);
-    const typeEntity = extractor.extractEntity(ref);
-    if (!typeEntity)
-        return [];
-    const allPsets = [];
-    const seenPsetNames = new Set();
-    // Source 1: HasPropertySets attribute (index 5 for IfcTypeObject subtypes)
-    const hasPropertySets = typeEntity.attributes?.[5];
-    if (Array.isArray(hasPropertySets)) {
-        const psetIds = hasPropertySets.filter((id) => typeof id === 'number');
-        const psets = extractPsetsFromIds(store, extractor, psetIds);
-        for (const pset of psets) {
-            seenPsetNames.add(pset.name);
-            allPsets.push(pset);
-        }
-    }
-    // Source 2: onDemandPropertyMap (IFC4: via IFCRELDEFINESBYPROPERTIES)
-    if (store.onDemandPropertyMap) {
-        const typePsetIds = store.onDemandPropertyMap.get(typeEntityId);
-        if (typePsetIds && typePsetIds.length > 0) {
-            const psets = extractPsetsFromIds(store, extractor, typePsetIds);
-            for (const pset of psets) {
-                if (!seenPsetNames.has(pset.name)) {
-                    allPsets.push(pset);
-                }
-            }
-        }
-    }
-    return allPsets;
-}
-/**
- * Extract documents for a single entity ON-DEMAND.
- * Uses the onDemandDocumentMap built during parsing.
- * Falls back to relationship graph when on-demand map is not available.
- * Also checks type-level documents via IfcRelDefinesByType.
- * Returns an array of document info objects.
- */
-export function extractDocumentsOnDemand(store, entityId) {
-    let docRefIds;
-    if (store.onDemandDocumentMap) {
-        docRefIds = store.onDemandDocumentMap.get(entityId);
-    }
-    else if (store.relationships) {
-        const related = store.relationships.getRelated(entityId, RelationshipType.AssociatesDocument, 'inverse');
-        if (related.length > 0)
-            docRefIds = related;
-    }
-    // Also check type-level documents via IfcRelDefinesByType
-    if (store.relationships) {
-        const typeIds = store.relationships.getRelated(entityId, RelationshipType.DefinesByType, 'inverse');
-        for (const typeId of typeIds) {
-            let typeDocRefs;
-            if (store.onDemandDocumentMap) {
-                typeDocRefs = store.onDemandDocumentMap.get(typeId);
-            }
-            else {
-                const related = store.relationships.getRelated(typeId, RelationshipType.AssociatesDocument, 'inverse');
-                if (related.length > 0)
-                    typeDocRefs = related;
-            }
-            if (typeDocRefs && typeDocRefs.length > 0) {
-                docRefIds = docRefIds ? [...docRefIds, ...typeDocRefs] : [...typeDocRefs];
-            }
-        }
-    }
-    if (!docRefIds || docRefIds.length === 0)
-        return [];
-    if (!store.source?.length)
-        return [];
-    const extractor = new EntityExtractor(store.source);
-    const results = [];
-    for (const docId of docRefIds) {
-        const docRef = store.entityIndex.byId.get(docId);
-        if (!docRef)
-            continue;
-        const docEntity = extractor.extractEntity(docRef);
-        if (!docEntity)
-            continue;
-        const typeUpper = docEntity.type.toUpperCase();
-        const attrs = docEntity.attributes || [];
-        if (typeUpper === 'IFCDOCUMENTREFERENCE') {
-            // IFC4: [Location, Identification, Name, Description, ReferencedDocument]
-            // IFC2X3: [Location, ItemReference, Name]
-            const info = {
-                location: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                identification: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                name: typeof attrs[2] === 'string' ? attrs[2] : undefined,
-                description: typeof attrs[3] === 'string' ? attrs[3] : undefined,
-            };
-            // Walk to IfcDocumentInformation if ReferencedDocument is set (IFC4 attr[4])
-            if (typeof attrs[4] === 'number') {
-                const docInfoRef = store.entityIndex.byId.get(attrs[4]);
-                if (docInfoRef) {
-                    const docInfoEntity = extractor.extractEntity(docInfoRef);
-                    if (docInfoEntity && docInfoEntity.type.toUpperCase() === 'IFCDOCUMENTINFORMATION') {
-                        const ia = docInfoEntity.attributes || [];
-                        // IfcDocumentInformation: [Identification, Name, Description, Location, Purpose, IntendedUse, Scope, Revision, ...]
-                        if (!info.identification && typeof ia[0] === 'string')
-                            info.identification = ia[0];
-                        if (!info.name && typeof ia[1] === 'string')
-                            info.name = ia[1];
-                        if (!info.description && typeof ia[2] === 'string')
-                            info.description = ia[2];
-                        if (!info.location && typeof ia[3] === 'string')
-                            info.location = ia[3];
-                        if (typeof ia[4] === 'string')
-                            info.purpose = ia[4];
-                        if (typeof ia[5] === 'string')
-                            info.intendedUse = ia[5];
-                        if (typeof ia[7] === 'string')
-                            info.revision = ia[7];
-                    }
-                }
-            }
-            if (info.name || info.location || info.identification) {
-                results.push(info);
-            }
-        }
-        else if (typeUpper === 'IFCDOCUMENTINFORMATION') {
-            // Direct IfcDocumentInformation (less common)
-            const info = {
-                identification: typeof attrs[0] === 'string' ? attrs[0] : undefined,
-                name: typeof attrs[1] === 'string' ? attrs[1] : undefined,
-                description: typeof attrs[2] === 'string' ? attrs[2] : undefined,
-                location: typeof attrs[3] === 'string' ? attrs[3] : undefined,
-                purpose: typeof attrs[4] === 'string' ? attrs[4] : undefined,
-                intendedUse: typeof attrs[5] === 'string' ? attrs[5] : undefined,
-                revision: typeof attrs[7] === 'string' ? attrs[7] : undefined,
-            };
-            if (info.name || info.location || info.identification) {
-                results.push(info);
-            }
-        }
-    }
-    return results;
-}
-/**
- * Extract structural relationships for a single entity ON-DEMAND.
- * Finds openings (VoidsElement), fills (FillsElement), groups (AssignsToGroup),
- * and path connections (ConnectsPathElements).
- */
-export function extractRelationshipsOnDemand(store, entityId) {
-    const result = {
-        voids: [],
-        fills: [],
-        groups: [],
-        connections: [],
-    };
-    if (!store.relationships)
-        return result;
-    const getEntityInfo = (id) => {
-        const ref = store.entityIndex.byId.get(id);
-        if (!ref)
-            return { type: 'Unknown' };
-        const name = store.entities?.getName(id);
-        return { name: name || undefined, type: ref.type };
-    };
-    // VoidsElement: openings that void this element
-    const voidsIds = store.relationships.getRelated(entityId, RelationshipType.VoidsElement, 'forward');
-    for (const id of voidsIds) {
-        const info = getEntityInfo(id);
-        result.voids.push({ id, ...info });
-    }
-    // FillsElement: this element fills an opening
-    const fillsIds = store.relationships.getRelated(entityId, RelationshipType.FillsElement, 'inverse');
-    for (const id of fillsIds) {
-        const info = getEntityInfo(id);
-        result.fills.push({ id, ...info });
-    }
-    // AssignsToGroup: groups this element belongs to
-    const groupIds = store.relationships.getRelated(entityId, RelationshipType.AssignsToGroup, 'inverse');
-    for (const id of groupIds) {
-        const name = store.entities?.getName(id);
-        result.groups.push({ id, name: name || undefined });
-    }
-    // ConnectsPathElements: connected walls
-    const connectedIds = store.relationships.getRelated(entityId, RelationshipType.ConnectsPathElements, 'forward');
-    const connectedInverseIds = store.relationships.getRelated(entityId, RelationshipType.ConnectsPathElements, 'inverse');
-    const allConnected = new Set([...connectedIds, ...connectedInverseIds]);
-    allConnected.delete(entityId);
-    for (const id of allConnected) {
-        const info = getEntityInfo(id);
-        result.connections.push({ id, ...info });
-    }
-    return result;
-}
-// ============================================================================
-// On-Demand Georeferencing Extraction
-// ============================================================================
-import { extractGeoreferencing as extractGeorefFromEntities } from './georef-extractor.js';
-/**
- * Extract georeferencing info from on-demand store (source buffer + entityIndex).
- * Bridges to the entity-based georef extractor by resolving entities lazily.
- */
-export function extractGeoreferencingOnDemand(store) {
-    if (!store.source?.length || !store.entityIndex)
-        return null;
-    const extractor = new EntityExtractor(store.source);
-    const { byId, byType } = store.entityIndex;
-    // Build a lightweight entity map for just the georef-related types
-    const entityMap = new Map();
-    const typeMap = new Map();
-    for (const typeName of ['IFCMAPCONVERSION', 'IFCPROJECTEDCRS']) {
-        const ids = byType.get(typeName);
-        if (!ids?.length)
-            continue;
-        // Use mixed-case for the georef extractor's type lookup
-        const displayName = typeName === 'IFCMAPCONVERSION' ? 'IfcMapConversion' : 'IfcProjectedCRS';
-        typeMap.set(displayName, ids);
-        for (const id of ids) {
-            const ref = byId.get(id);
-            if (!ref)
-                continue;
-            const entity = extractor.extractEntity(ref);
-            if (entity) {
-                entityMap.set(id, entity);
-            }
-        }
-    }
-    if (entityMap.size === 0)
-        return null;
-    // Cast to IfcEntity (they share the same shape)
-    return extractGeorefFromEntities(entityMap, typeMap);
-}
+// Re-export on-demand extraction functions from focused module
+export { extractClassificationsOnDemand, extractMaterialsOnDemand, extractTypePropertiesOnDemand, extractTypeEntityOwnProperties, extractDocumentsOnDemand, extractRelationshipsOnDemand, extractGeoreferencingOnDemand, parsePropertyValue, extractPsetsFromIds, } from './on-demand-extractors.js';
 //# sourceMappingURL=columnar-parser.js.map