@itwin/core-frontend 4.0.0-dev.4 → 4.0.0-dev.40

package/lib/esm/tile/GltfReader.js

@@ -293,16 +293,15 @@ function colorFromJson(values) {
     return ColorDef.from(values[0] * 255, values[1] * 255, values[2] * 255, (1.0 - values[3]) * 255);
 }
 function colorFromMaterial(material, isTransparent) {
-    var _a, _b, _c, _d, _e;
     let color = ColorDef.white;
     if (isGltf1Material(material)) {
-        if (((_a = material.values) === null || _a === void 0 ? void 0 : _a.color) && Array.isArray(material.values.color))
+        if (material.values?.color && Array.isArray(material.values.color))
             color = colorFromJson(material.values.color);
     }
-    else if ((_d = (_c = (_b = material.extensions) === null || _b === void 0 ? void 0 : _b.KHR_techniques_webgl) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d.u_color) {
+    else if (material.extensions?.KHR_techniques_webgl?.values?.u_color) {
         color = colorFromJson(material.extensions.KHR_techniques_webgl.values.u_color);
     }
-    else if ((_e = material.pbrMetallicRoughness) === null || _e === void 0 ? void 0 : _e.baseColorFactor) {
+    else if (material.pbrMetallicRoughness?.baseColorFactor) {
         color = colorFromJson(material.pbrMetallicRoughness.baseColorFactor);
     }
     // SPEC: Opaque materials ignore any alpha channel.
@@ -381,7 +380,6 @@ function compareTextureKeys(lhs, rhs) {
  */
 export class GltfReader {
     constructor(args) {
-        var _a, _b, _c, _d, _e, _f, _g;
         this._resolvedTextures = new Dictionary((lhs, rhs) => compareTextureKeys(lhs, rhs));
         this._dracoMeshes = new Map();
         /** The glTF spec says that if GltfSampler.wrapS/T are omitted, they default to Repeat.
@@ -394,17 +392,17 @@ export class GltfReader {
         this._version = args.props.version;
         this._yAxisUp = args.props.yAxisUp;
         this._baseUrl = args.props.baseUrl;
-        const rtcCenter = (_b = (_a = args.props.glTF.extensions) === null || _a === void 0 ? void 0 : _a.CESIUM_RTC) === null || _b === void 0 ? void 0 : _b.center;
+        const rtcCenter = args.props.glTF.extensions?.CESIUM_RTC?.center;
         if (rtcCenter && 3 === rtcCenter.length)
             if (0 !== rtcCenter[0] || 0 !== rtcCenter[1] || 0 !== rtcCenter[2])
                 this._returnToCenter = Point3d.fromJSON(rtcCenter);
         this._iModel = args.iModel;
         this._is3d = true !== args.is2d;
-        this._system = (_c = args.system) !== null && _c !== void 0 ? _c : IModelApp.renderSystem;
-        this._type = (_d = args.type) !== null && _d !== void 0 ? _d : BatchType.Primary;
+        this._system = args.system ?? IModelApp.renderSystem;
+        this._type = args.type ?? BatchType.Primary;
         this._canceled = args.shouldAbort;
-        this._deduplicateVertices = (_e = args.deduplicateVertices) !== null && _e !== void 0 ? _e : false;
-        this._vertexTableRequired = (_f = args.vertexTableRequired) !== null && _f !== void 0 ? _f : false;
+        this._deduplicateVertices = args.deduplicateVertices ?? false;
+        this._vertexTableRequired = args.vertexTableRequired ?? false;
         const binaryData = args.props.binaryData;
         if (binaryData) {
             const buffer = this._buffers[this._version === 2 ? 0 : "binary_glTF"];
@@ -417,20 +415,20 @@ export class GltfReader {
         // Perhaps some faulty tiles existed that didn't define their scenes properly?
         let sceneNodes;
         if (this._glTF.scenes && undefined !== this._glTF.scene)
-            sceneNodes = (_g = this._glTF.scenes[this._glTF.scene]) === null || _g === void 0 ? void 0 : _g.nodes;
+            sceneNodes = this._glTF.scenes[this._glTF.scene]?.nodes;
         if (!sceneNodes)
             sceneNodes = Object.keys(this._nodes);
         this._sceneNodes = sceneNodes;
     }
-    get _nodes() { var _a; return (_a = this._glTF.nodes) !== null && _a !== void 0 ? _a : emptyDict; }
-    get _meshes() { var _a; return (_a = this._glTF.meshes) !== null && _a !== void 0 ? _a : emptyDict; }
-    get _accessors() { var _a; return (_a = this._glTF.accessors) !== null && _a !== void 0 ? _a : emptyDict; }
-    get _bufferViews() { var _a; return (_a = this._glTF.bufferViews) !== null && _a !== void 0 ? _a : emptyDict; }
-    get _materials() { var _a; return (_a = this._glTF.materials) !== null && _a !== void 0 ? _a : emptyDict; }
-    get _samplers() { var _a; return (_a = this._glTF.samplers) !== null && _a !== void 0 ? _a : emptyDict; }
-    get _textures() { var _a; return (_a = this._glTF.textures) !== null && _a !== void 0 ? _a : emptyDict; }
-    get _images() { var _a; return (_a = this._glTF.images) !== null && _a !== void 0 ? _a : emptyDict; }
-    get _buffers() { var _a; return (_a = this._glTF.buffers) !== null && _a !== void 0 ? _a : emptyDict; }
+    get _nodes() { return this._glTF.nodes ?? emptyDict; }
+    get _meshes() { return this._glTF.meshes ?? emptyDict; }
+    get _accessors() { return this._glTF.accessors ?? emptyDict; }
+    get _bufferViews() { return this._glTF.bufferViews ?? emptyDict; }
+    get _materials() { return this._glTF.materials ?? emptyDict; }
+    get _samplers() { return this._glTF.samplers ?? emptyDict; }
+    get _textures() { return this._glTF.textures ?? emptyDict; }
+    get _images() { return this._glTF.images ?? emptyDict; }
+    get _buffers() { return this._glTF.buffers ?? emptyDict; }
     get _isCanceled() { return undefined !== this._canceled && this._canceled(this); }
     get _isVolumeClassifier() { return BatchType.VolumeClassifier === this._type; }
     /** Traverse the nodes specified by their Ids, recursing into their child nodes.
@@ -463,7 +461,6 @@ export class GltfReader {
         return transform;
     }
     readGltfAndCreateGraphics(isLeaf, featureTable, contentRange, transformToRoot, pseudoRtcBias, instances) {
-        var _a;
         if (this._isCanceled)
             return { readStatus: TileReadStatus.Canceled, isLeaf };
         // If contentRange was not supplied, we will compute it as we read the meshes.
@@ -472,7 +469,7 @@ export class GltfReader {
         else
             this._computedContentRange = undefined;
         // ###TODO this looks like a hack? Why does it assume the first node's transform is special, or that the transform will be specified as a matrix instead of translation+rot+scale?
-        if (this._returnToCenter || ((_a = this._nodes[0]) === null || _a === void 0 ? void 0 : _a.matrix) || (pseudoRtcBias && pseudoRtcBias.magnitude() < 1.0E5))
+        if (this._returnToCenter || this._nodes[0]?.matrix || (pseudoRtcBias && pseudoRtcBias.magnitude() < 1.0E5))
             pseudoRtcBias = undefined;
         const transformStack = new TransformStack();
         const renderGraphicList = [];
@@ -492,7 +489,7 @@ export class GltfReader {
             renderGraphic = this._system.createGraphicList(renderGraphicList);
         const transform = this.getTileTransform(transformToRoot, pseudoRtcBias);
         let range = contentRange;
-        const invTransform = transform === null || transform === void 0 ? void 0 : transform.inverse();
+        const invTransform = transform?.inverse();
         if (invTransform)
             range = invTransform.multiplyRange(contentRange);
         if (featureTable)
@@ -563,7 +560,7 @@ export class GltfReader {
             thisBias = (undefined === thisTransform) ? pseudoRtcBias : thisTransform.matrix.multiplyInverse(pseudoRtcBias);
         for (const meshKey of getNodeMeshIds(node)) {
             const nodeMesh = this._meshes[meshKey];
-            if (nodeMesh === null || nodeMesh === void 0 ? void 0 : nodeMesh.primitives) {
+            if (nodeMesh?.primitives) {
                 const meshes = this.readMeshPrimitives(node, featureTable, thisTransform, thisBias);
                 let renderGraphic;
                 if (0 !== meshes.length) {
@@ -661,7 +658,7 @@ export class GltfReader {
             if (!bufferView || undefined === bufferView.buffer)
                 return undefined;
             const buffer = this._buffers[bufferView.buffer];
-            const bufferData = buffer === null || buffer === void 0 ? void 0 : buffer.resolvedBuffer;
+            const bufferData = buffer?.resolvedBuffer;
             if (!bufferData)
                 return undefined;
             const type = accessor.componentType;
@@ -721,42 +718,39 @@ export class GltfReader {
         }
     }
     extractTextureId(material) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         if (typeof material !== "object")
             return undefined;
         // Bimium's shader value...almost certainly obsolete at this point.
         if (isGltf1Material(material))
-            return (_a = material.diffuse) !== null && _a !== void 0 ? _a : this.extractId((_b = material.values) === null || _b === void 0 ? void 0 : _b.tex);
+            return material.diffuse ?? this.extractId(material.values?.tex);
         // KHR_techniques_webgl extension
-        const techniques = (_d = (_c = this._glTF.extensions) === null || _c === void 0 ? void 0 : _c.KHR_techniques_webgl) === null || _d === void 0 ? void 0 : _d.techniques;
-        const ext = Array.isArray(techniques) ? (_e = material.extensions) === null || _e === void 0 ? void 0 : _e.KHR_techniques_webgl : undefined;
+        const techniques = this._glTF.extensions?.KHR_techniques_webgl?.techniques;
+        const ext = Array.isArray(techniques) ? material.extensions?.KHR_techniques_webgl : undefined;
         if (techniques && undefined !== ext && typeof (ext.values) === "object") {
             const uniforms = typeof ext.technique === "number" ? techniques[ext.technique].uniforms : undefined;
             if (typeof uniforms === "object") {
                 for (const uniformName of Object.keys(uniforms)) {
                     const uniform = uniforms[uniformName];
                     if (typeof uniform === "object" && uniform.type === GltfDataType.Sampler2d)
-                        return this.extractId((_f = ext.values[uniformName]) === null || _f === void 0 ? void 0 : _f.index);
+                        return this.extractId(ext.values[uniformName]?.index);
                 }
             }
         }
-        const id = this.extractId((_h = (_g = material.pbrMetallicRoughness) === null || _g === void 0 ? void 0 : _g.baseColorTexture) === null || _h === void 0 ? void 0 : _h.index);
-        return id !== null && id !== void 0 ? id : this.extractId((_j = material.emissiveTexture) === null || _j === void 0 ? void 0 : _j.index);
+        const id = this.extractId(material.pbrMetallicRoughness?.baseColorTexture?.index);
+        return id ?? this.extractId(material.emissiveTexture?.index);
     }
     extractNormalMapId(material) {
-        var _a;
         if (typeof material !== "object")
             return undefined;
         if (isGltf1Material(material))
             return undefined;
-        return this.extractId((_a = material.normalTexture) === null || _a === void 0 ? void 0 : _a.index);
+        return this.extractId(material.normalTexture?.index);
     }
     isMaterialTransparent(material) {
-        var _a, _b;
         if (isGltf1Material(material)) {
             if (this._glTF.techniques && undefined !== material.technique) {
                 const technique = this._glTF.techniques[material.technique];
-                if ((_b = (_a = technique === null || technique === void 0 ? void 0 : technique.states) === null || _a === void 0 ? void 0 : _a.enable) === null || _b === void 0 ? void 0 : _b.some((state) => state === GltfTechniqueState.Blend))
+                if (technique?.states?.enable?.some((state) => state === GltfTechniqueState.Blend))
                     return true;
             }
             return false;
@@ -784,13 +778,13 @@ export class GltfReader {
         const meshes = [];
         for (const meshKey of getNodeMeshIds(node)) {
             const nodeMesh = this._meshes[meshKey];
-            if (nodeMesh === null || nodeMesh === void 0 ? void 0 : nodeMesh.primitives) {
+            if (nodeMesh?.primitives) {
                 for (const primitive of nodeMesh.primitives) {
                     const mesh = this.readMeshPrimitive(primitive, featureTable, thisBias);
                     if (mesh) {
                         meshes.push(mesh);
                         if (this._computedContentRange && mesh.pointRange) {
-                            const invTransform = thisTransform === null || thisTransform === void 0 ? void 0 : thisTransform.inverse();
+                            const invTransform = thisTransform?.inverse();
                             const meshRange = invTransform ? invTransform.multiplyRange(mesh.pointRange) : mesh.pointRange;
                             this._computedContentRange.extendRange(meshRange);
                         }
@@ -801,12 +795,11 @@ export class GltfReader {
         return meshes;
     }
     readMeshPrimitive(primitive, featureTable, pseudoRtcBias) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const materialName = JsonUtils.asString(primitive.material);
-        const material = 0 < materialName.length ? this._materials[materialName] : undefined;
+        const material = 0 < materialName.length ? this._materials[materialName] : {};
         if (!material)
             return undefined;
-        const hasBakedLighting = undefined === primitive.attributes.NORMAL || undefined !== ((_a = material.extensions) === null || _a === void 0 ? void 0 : _a.KHR_materials_unlit);
+        const hasBakedLighting = undefined === primitive.attributes.NORMAL || undefined !== material.extensions?.KHR_materials_unlit;
         const displayParams = material ? this.createDisplayParams(material, hasBakedLighting) : undefined;
         if (!displayParams)
             return undefined;
@@ -847,9 +840,9 @@ export class GltfReader {
         if (undefined !== colorIndices && material) {
             let texStep;
             if (isGltf1Material(material))
-                texStep = (_b = material.values) === null || _b === void 0 ? void 0 : _b.texStep;
+                texStep = material.values?.texStep;
             else
-                texStep = (_e = (_d = (_c = material.extensions) === null || _c === void 0 ? void 0 : _c.KHR_techniques_webgl) === null || _d === void 0 ? void 0 : _d.values) === null || _e === void 0 ? void 0 : _e.u_texStep;
+                texStep = material.extensions?.KHR_techniques_webgl?.values?.u_texStep;
             if (texStep) {
                 const uvParams = [];
                 for (let i = 0; i < colorIndices.count; i++)
@@ -859,7 +852,7 @@ export class GltfReader {
                 mesh.uvQParams = paramList.params;
             }
         }
-        const draco = (_f = primitive.extensions) === null || _f === void 0 ? void 0 : _f.KHR_draco_mesh_compression;
+        const draco = primitive.extensions?.KHR_draco_mesh_compression;
         if (draco)
             return this.readDracoMeshPrimitive(mesh.primitive, draco) ? mesh : undefined;
         this.readBatchTable(mesh.primitive, primitive);
@@ -873,7 +866,7 @@ export class GltfReader {
                     return undefined;
                 if (!mesh.uvs) {
                     let texCoordIndex = 0;
-                    if (!isGltf1Material(material) && undefined !== ((_h = (_g = material.pbrMetallicRoughness) === null || _g === void 0 ? void 0 : _g.baseColorTexture) === null || _h === void 0 ? void 0 : _h.texCoord))
+                    if (!isGltf1Material(material) && undefined !== material.pbrMetallicRoughness?.baseColorTexture?.texCoord)
                         texCoordIndex = JsonUtils.asInt(material.pbrMetallicRoughness.baseColorTexture.texCoord);
                     this.readUVParams(mesh, primitive.attributes, `TEXCOORD_${texCoordIndex}`);
                 }
@@ -894,7 +887,7 @@ export class GltfReader {
         }
         if (displayParams.textureMapping && !mesh.uvs)
             return undefined;
-        if ((_j = primitive.extensions) === null || _j === void 0 ? void 0 : _j.CESIUM_primitive_outline) {
+        if (primitive.extensions?.CESIUM_primitive_outline) {
             const data = this.readBufferData32(primitive.extensions.CESIUM_primitive_outline, "indices");
             if (data !== undefined) {
                 assert(0 === data.count % 2);
@@ -906,14 +899,13 @@ export class GltfReader {
         return mesh;
     }
     readDracoMeshPrimitive(mesh, ext) {
-        var _a, _b, _c, _d, _e, _f;
         const draco = this._dracoMeshes.get(ext);
         if (!draco || "triangle-list" !== draco.topology)
             return false;
-        const indices = (_a = draco.indices) === null || _a === void 0 ? void 0 : _a.value;
+        const indices = draco.indices?.value;
         if (!indices || (indices.length % 3) !== 0)
             return false;
-        const pos = (_b = draco.attributes.POSITION) === null || _b === void 0 ? void 0 : _b.value;
+        const pos = draco.attributes.POSITION?.value;
         if (!pos || (pos.length % 3) !== 0)
             return false;
         // ###TODO: I have yet to see a draco-encoded mesh with interleaved attributes. Currently not checking.
@@ -923,7 +915,7 @@ export class GltfReader {
             mesh.addTriangle(triangle);
         }
         let posRange;
-        const bbox = (_c = draco.header) === null || _c === void 0 ? void 0 : _c.boundingBox;
+        const bbox = draco.header?.boundingBox;
         if (bbox) {
             posRange = Range3d.createXYZXYZ(bbox[0][0], bbox[0][1], bbox[0][2], bbox[1][0], bbox[1][1], bbox[1][2]);
         }
@@ -939,7 +931,7 @@ export class GltfReader {
             pt.set(pos[i], pos[i + 1], pos[i + 2]);
             mesh.points.add(pt);
         }
-        const normals = (_d = draco.attributes.NORMAL) === null || _d === void 0 ? void 0 : _d.value;
+        const normals = draco.attributes.NORMAL?.value;
         if (normals && (normals.length % 3) === 0) {
             const vec = Vector3d.createZero();
             for (let i = 0; i < normals.length; i += 3) {
@@ -947,11 +939,11 @@ export class GltfReader {
                 mesh.normals.push(OctEncodedNormal.fromVector(vec));
             }
         }
-        const uvs = (_e = draco.attributes.TEXCOORD_0) === null || _e === void 0 ? void 0 : _e.value;
+        const uvs = draco.attributes.TEXCOORD_0?.value;
         if (uvs && (uvs.length & 2) === 0)
             for (let i = 0; i < uvs.length; i += 2)
                 mesh.uvParams.push(new Point2d(uvs[i], uvs[i + 1]));
-        const batchIds = (_f = draco.attributes._BATCHID) === null || _f === void 0 ? void 0 : _f.value;
+        const batchIds = draco.attributes._BATCHID?.value;
         if (batchIds && mesh.features) {
             const featureIndices = [];
             for (const batchId of batchIds)
@@ -1070,7 +1062,6 @@ export class GltfReader {
     readBatchTable(_mesh, _json) {
     }
     readMeshIndices(mesh, json) {
-        var _a;
         if (undefined !== json.indices) {
             const data = this.readBufferData16(json, "indices") || this.readBufferData32(json, "indices");
             if (data && (data.buffer instanceof Uint8Array || data.buffer instanceof Uint16Array || data.buffer instanceof Uint32Array)) {
@@ -1080,7 +1071,7 @@ export class GltfReader {
             return false;
         }
         // Non-indexed geometry. Manufacture triangle indices from points.
-        const numPoints = (_a = mesh.points) === null || _a === void 0 ? void 0 : _a.length;
+        const numPoints = mesh.points?.length;
         if (undefined === numPoints || 0 !== numPoints % 3)
             return false;
         mesh.indices = numPoints < 255 ? new Uint8Array(numPoints) : (numPoints < 0xffff ? new Uint16Array(numPoints) : new Uint32Array(numPoints));
@@ -1208,7 +1199,6 @@ export class GltfReader {
         return true;
     }
     async resolveResources() {
-        var _a;
         // Load any external images and buffers.
         await this._resolveResources();
         // If any meshes are draco-compressed, dynamically load the decoder module and then decode the meshes.
@@ -1216,9 +1206,9 @@ export class GltfReader {
         for (const node of this.traverseScene()) {
             for (const meshId of getNodeMeshIds(node)) {
                 const mesh = this._meshes[meshId];
-                if (mesh === null || mesh === void 0 ? void 0 : mesh.primitives)
+                if (mesh?.primitives)
                     for (const primitive of mesh.primitives)
-                        if ((_a = primitive.extensions) === null || _a === void 0 ? void 0 : _a.KHR_draco_mesh_compression)
+                        if (primitive.extensions?.KHR_draco_mesh_compression)
                             dracoMeshes.push(primitive.extensions.KHR_draco_mesh_compression);
             }
         }
@@ -1254,14 +1244,13 @@ export class GltfReader {
         }
     }
     async decodeDracoMesh(ext, loader) {
-        var _a, _b;
         const bv = this._bufferViews[ext.bufferView];
         if (!bv || !bv.byteLength)
             return;
-        let buf = (_a = this._buffers[bv.buffer]) === null || _a === void 0 ? void 0 : _a.resolvedBuffer;
+        let buf = this._buffers[bv.buffer]?.resolvedBuffer;
         if (!buf)
             return;
-        const offset = (_b = bv.byteOffset) !== null && _b !== void 0 ? _b : 0;
+        const offset = bv.byteOffset ?? 0;
         buf = buf.subarray(offset, offset + bv.byteLength);
         const mesh = await loader.parse(buf, {}); // NB: `options` argument declared optional but will produce exception if not supplied.
         if (mesh)
@@ -1283,7 +1272,7 @@ export class GltfReader {
             const response = url ? await fetch(url) : undefined;
             if (this._isCanceled)
                 return;
-            const data = await (response === null || response === void 0 ? void 0 : response.arrayBuffer());
+            const data = await response?.arrayBuffer();
             if (this._isCanceled)
                 return;
             if (data)
@@ -1294,19 +1283,18 @@ export class GltfReader {
         }
     }
     async resolveImage(image) {
-        var _a, _b, _c;
         if (image.resolvedImage)
             return;
-        const bvSrc = undefined !== image.bufferView ? image : (_a = image.extensions) === null || _a === void 0 ? void 0 : _a.KHR_binary_glTF;
-        if (undefined !== (bvSrc === null || bvSrc === void 0 ? void 0 : bvSrc.bufferView)) {
+        const bvSrc = undefined !== image.bufferView ? image : image.extensions?.KHR_binary_glTF;
+        if (undefined !== bvSrc?.bufferView) {
             const format = undefined !== bvSrc.mimeType ? getImageSourceFormatForMimeType(bvSrc.mimeType) : undefined;
             const bufferView = this._bufferViews[bvSrc.bufferView];
             if (undefined === format || !bufferView || !bufferView.byteLength || bufferView.byteLength < 0)
                 return;
-            const bufferData = (_b = this._buffers[bufferView.buffer]) === null || _b === void 0 ? void 0 : _b.resolvedBuffer;
+            const bufferData = this._buffers[bufferView.buffer]?.resolvedBuffer;
             if (!bufferData)
                 return;
-            const offset = (_c = bufferView.byteOffset) !== null && _c !== void 0 ? _c : 0;
+            const offset = bufferView.byteOffset ?? 0;
             const bytes = bufferData.subarray(offset, offset + bufferView.byteLength);
             try {
                 const imageSource = new ImageSource(bytes, format);
@@ -1327,8 +1315,8 @@ export class GltfReader {
     /** Exposed strictly for testing. */
     getTextureType(sampler) {
         // ###TODO: RenderTexture currently does not support different wrapping behavior for U vs V, nor does it support mirrored repeat.
-        let wrapS = sampler === null || sampler === void 0 ? void 0 : sampler.wrapS;
-        let wrapT = sampler === null || sampler === void 0 ? void 0 : sampler.wrapT;
+        let wrapS = sampler?.wrapS;
+        let wrapT = sampler?.wrapT;
         if (undefined === wrapS && undefined === wrapT)
             wrapS = wrapT = this.defaultWrapMode;
         if (GltfWrapMode.ClampToEdge === wrapS || GltfWrapMode.ClampToEdge === wrapT)
@@ -1336,11 +1324,10 @@ export class GltfReader {
         return RenderTexture.Type.Normal;
     }
     resolveTexture(textureId, isTransparent) {
-        var _a;
         const texture = this._textures[textureId];
         if (!texture || undefined === texture.source)
             return false;
-        const image = (_a = this._images[texture.source]) === null || _a === void 0 ? void 0 : _a.resolvedImage;
+        const image = this._images[texture.source]?.resolvedImage;
         if (!image)
             return false;
         const samplerId = texture.sampler;
@@ -1353,7 +1340,7 @@ export class GltfReader {
                 transparency: isTransparent ? TextureTransparency.Mixed : TextureTransparency.Opaque,
             },
         });
-        return renderTexture !== null && renderTexture !== void 0 ? renderTexture : false;
+        return renderTexture ?? false;
     }
     findTextureMapping(id, isTransparent, normalMapId) {
         if (undefined === id && undefined === normalMapId)
@@ -1412,7 +1399,6 @@ export async function readGltfGraphics(args) {
  */
 export class GltfGraphicsReader extends GltfReader {
     constructor(props, args) {
-        var _a, _b, _c;
         super({
             props,
             iModel: args.iModel,
@@ -1422,9 +1408,9 @@ export class GltfGraphicsReader extends GltfReader {
         this._transform = args.transform;
         this._isLeaf = true !== args.hasChildren;
         this.binaryData = props.binaryData;
-        const pickableId = (_a = args.pickableOptions) === null || _a === void 0 ? void 0 : _a.id;
+        const pickableId = args.pickableOptions?.id;
         if (pickableId) {
-            this._featureTable = new FeatureTable(1, (_c = (_b = args.pickableOptions) === null || _b === void 0 ? void 0 : _b.modelId) !== null && _c !== void 0 ? _c : pickableId, BatchType.Primary);
+            this._featureTable = new FeatureTable(1, args.pickableOptions?.modelId ?? pickableId, BatchType.Primary);
             this._featureTable.insert(new Feature(pickableId));
         }
     }
@@ -1433,7 +1419,7 @@ export class GltfGraphicsReader extends GltfReader {
         return this.readGltfAndCreateGraphics(this._isLeaf, this._featureTable, this._contentRange, this._transform);
     }
     get nodes() { return this._nodes; }
-    get scenes() { var _a; return (_a = this._glTF.scenes) !== null && _a !== void 0 ? _a : emptyDict; }
+    get scenes() { return this._glTF.scenes ?? emptyDict; }
     get sceneNodes() { return this._sceneNodes; }
     get textures() { return this._textures; }
 }