npm - @domgell/gltf-parser - Versions diffs - 1.0.0 - Mend

@domgell/gltf-parser 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/.gitattributes ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ # Auto detect text files and perform LF normalization
2	+ * text=auto

package/gltf-importer.iml ADDED Viewed

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="GENERAL_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module" module-name="gltf-types" />
+  </component>
+</module>

package/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <!-- Get rid of "http://localhost:5173/favicon.ico not found" -->
+    <link rel="shortcut icon" href="#" />
+    <meta charset="UTF-8"/>
+    <script type="module" src="src/index.ts"></script>
+    <title></title>
+</head>
+<body>
+<canvas></canvas>
+</body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,18 @@
+{
+  "name": "@domgell/gltf-parser",
+  "version": "1.0.0",
+  "main": "src/index.ts",
+  "exports": "./src/index.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["gltf", "glb", "mesh", "parser"],
+  "author": "domgell",
+  "license": "ISC",
+  "description": "Parse .GLTF/.GLF files into JS objects",
+  "dependencies": {
+    "gltf-types": "file:../gltf-types",
+    "dom-game-math": "*"
+  },
+  "devDependencies": {}
+}

package/res/suzanne.glb ADDED Viewed

Binary file

package/src/Parser.ts ADDED Viewed

@@ -0,0 +1,330 @@
+import {
+    AccessorArrayType,
+    AccessorConstructorType,
+    assert,
+    chunk,
+    fail,
+    getTransform,
+} from "./util.ts";
+import * as Parsed from "./types.ts";
+import * as GLTF from "gltf-types";
+import {mat4, TransformOrder} from "dom-game-math";
+import {Matrix4x4, TextureFilterMap, TextureWrapModeMap} from "./types.ts";
+export type ParserOptions = {
+    transformOrder: TransformOrder,
+}
+export class Parser {
+    private constructor(
+        readonly path: string,
+        readonly options: ParserOptions,
+        readonly header: GLTF.GLTF,
+        readonly binary: ArrayBuffer,
+    ) {
+    }
+    static async create(path: string, options: Partial<ParserOptions> = {}) {
+        const r = await fetch(path);
+        assert(r.ok, `Failed to import at path: '${path}'`);
+        const data = await r.arrayBuffer();
+        const dataView = new DataView(data);
+        let offset = 12;
+        // Get JSON Header
+        const jsonChunkLength = dataView.getUint32(offset, true);
+        const jsonChunkData = new Uint8Array(data, offset + 8, jsonChunkLength);
+        const textDecoder = new TextDecoder("utf-8");
+        const json = textDecoder.decode(jsonChunkData);
+        const header = JSON.parse(json);
+        offset += 8 + jsonChunkLength;
+        // Get binary data
+        const binaryChunkLength = dataView.getUint32(offset, true);
+        const binary = new ArrayBuffer(binaryChunkLength);
+        const binaryChunkView = new Uint8Array(binary);
+        binaryChunkView.set(new Uint8Array(data, offset + 8, binaryChunkLength));
+        return new Parser(path, {transformOrder: options.transformOrder ?? "TRS"}, header, binary);
+    }
+    // ----------------------------------- Accessor ------------------------------------
+    accessor<T extends AccessorArrayType, I extends number | undefined>(index: I, type: T): I extends number ? AccessorConstructorType<T> : AccessorConstructorType<T> | undefined {
+        if (index === undefined) return undefined as any;
+        assert(this.header.accessors !== undefined, "Accessors are undefined");
+        assert(this.header.bufferViews !== undefined, "BufferViews are undefined");
+        const accessor = this.header.accessors[index]
+            ?? fail(`Accessor at index ${index} not found`);
+        assert(accessor.bufferView !== undefined, "Accessor bufferView is undefined");
+        const bufferView = this.header.bufferViews[accessor.bufferView];
+        const byteOffset = (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
+        const numComponents = {
+            "SCALAR": 1, "VEC2": 2, "VEC3": 3, "VEC4": 4, "MAT2": 4, "MAT3": 9, "MAT4": 16,
+        }[accessor.type];
+        const assertType = {
+            5120: Int8Array,
+            5121: Uint8Array,
+            5122: Int16Array,
+            5123: Uint16Array,
+            5125: Uint32Array,
+            5126: Float32Array,
+        }[accessor.componentType];
+        assert(assertType.name === type.name, `Mismatched types: requested '${type.name}' but got '${assertType.name}'`);
+        const byteLength = numComponents * accessor.count * type.BYTES_PER_ELEMENT;
+        return new type(this.binary.slice(byteOffset, byteOffset + byteLength)) as any;
+    }
+    // ------------------------------------- Mesh --------------------------------------
+    async mesh(gltfMesh: GLTF.Mesh) {
+        const primitives = new Array<Parsed.MeshPrimitive>(gltfMesh.primitives.length);
+        for (let i = 0; i < primitives.length; i++) {
+            primitives[i] = await this.primitive(gltfMesh.primitives[i]);
+        }
+        return {primitives, name: gltfMesh.name};
+    }
+    async primitive(gltfPrimitive: GLTF.MeshPrimitive): Promise<Parsed.MeshPrimitive> {
+        const positions = this.accessor(gltfPrimitive.attributes.POSITION, Float32Array);
+        const uvs = this.accessor(gltfPrimitive.attributes.TEXCOORD_0, Float32Array);
+        const normals = this.accessor(gltfPrimitive.attributes.NORMAL, Float32Array);
+        const colors = this.accessor(gltfPrimitive.attributes.COLOR_0, Float32Array); // TODO: Convert to RGBA
+        const weights = this.accessor(gltfPrimitive.attributes.WEIGHTS_0, Float32Array); // TODO: Max 4
+        const joints = this.accessor(gltfPrimitive.attributes.JOINTS_0, Uint8Array); // TODO: Max 4
+        const attributes: Parsed.MeshPrimitiveAttributes = {
+            positions: chunk(positions, 3),
+            uvs: uvs && chunk(uvs, 2),
+            normals: normals && chunk(normals, 3),
+            colors: colors && chunk(colors, 4),
+            weights: weights && chunk(weights, 4),
+            joints: joints && chunk(joints, 4),
+        };
+        let indices: Uint32Array | undefined;
+        if (gltfPrimitive.indices !== undefined) {
+            const gltfIndices = this.accessor(gltfPrimitive.indices, Uint16Array);
+            indices = new Uint32Array(gltfIndices);
+        }
+        let material: Parsed.Material | undefined;
+        if (gltfPrimitive.material !== undefined && this.header.materials !== undefined) {
+            const gltfMaterial = this.header.materials[gltfPrimitive.material];
+            material = await this.material(gltfMaterial);
+        }
+        return {attributes, indices, material};
+    }
+    // ------------------------------------- Skin --------------------------------------
+    skin(gltfSkin: GLTF.Skin) {
+        assert(this.header.nodes !== undefined, "`Nodes` is undefined");
+        // Default: Array of identity matrices with length = number of joints
+        const inverseBindMatrices = gltfSkin.inverseBindMatrices
+            ? chunk(this.accessor(gltfSkin.inverseBindMatrices, Float32Array), 16)
+            : gltfSkin.joints.map(() => Array.from(mat4.idt) as Matrix4x4);
+        const joints: Record<string, Parsed.Joint> = {};
+        let i = 0;
+        for (let jointNodeIndex of gltfSkin.joints) {
+            const gltfJoint = this.header.nodes[jointNodeIndex];
+            assert(gltfJoint.name !== undefined, "Joint node has no `name` property");
+            // Get joint transform as matrix
+            const transform = gltfJoint.matrix
+                ? [...gltfJoint.matrix] as Matrix4x4
+                : getTransform(gltfJoint, this.options.transformOrder);
+            const children = gltfJoint.children?.map(i => this.header.nodes![i].name!) ?? [];
+            //const inverseBindTransform = inverseBindMatrices[jointIndex];
+            const inverseBindTransform = inverseBindMatrices[i];
+            joints[gltfJoint.name] = {name: gltfJoint.name, transform, children, inverseBindTransform};
+            i++;
+        }
+        const gltfRoot = this.header.nodes[gltfSkin.joints[0]];
+        const root = joints[gltfRoot.name!] ?? fail("Invalid root node");
+        // Set parents
+        for (let name in joints) {
+            const joint = joints[name];
+            for (let childName of joint.children) {
+                joints[childName].parent = name;
+            }
+        }
+        // Animations targeting joints of this skin
+        const gltfAnimations = this.header.animations?.filter(animation => {
+            return animation.channels.some(channel => {
+                const target = this.header.nodes![channel.target.node!];
+                return joints[target.name!] !== undefined;
+            });
+        }) ?? [];
+        const animations = gltfAnimations.map(a => this.animation(a));
+        // TEMP: Calculate global inverse transform
+        const skinParentNode = this.header.nodes.find(n => n.children?.includes(gltfSkin.joints[0]));
+        const globalInverseTransform = skinParentNode
+            ? getTransform(skinParentNode, this.options.transformOrder)
+            : Array.from(mat4.idt) as Matrix4x4;
+        return {joints, root, animations, name: gltfSkin.name, globalInverseTransform};
+    }
+    animation(gltfAnimation: GLTF.Animation): Parsed.Animation {
+        assert(this.header.nodes !== undefined, "`Nodes` is undefined");
+        const channels: Record<string, Parsed.AnimationChannel> = {};
+        let duration = 0;
+        for (let gltfChannel of gltfAnimation.channels) {
+            const gltfTargetNode = this.header.nodes![gltfChannel.target.node!];
+            assert(gltfTargetNode !== undefined && gltfTargetNode.name !== undefined, "Invalid target node");
+            // Init channel if not already present
+            channels[gltfTargetNode.name] ??= {translation: [], rotation: [], scale: []};
+            const sampler = gltfAnimation.samplers[gltfChannel.sampler];
+            const times = this.accessor(sampler.input, Float32Array);
+            const values = this.accessor(sampler.output, Float32Array);
+            const numComponents = values.length / times.length;
+            assert(numComponents === 3 || numComponents === 4, `Invalid number of components: '${numComponents}'`);
+            // Set keyframes array of current 'path', e.g. 'translation'
+            const keyframes = chunk(values, numComponents).map((value, i) => ({time: times[i], value}));
+            channels[gltfTargetNode.name][gltfChannel.target.path] = keyframes as any;
+            duration = Math.max(duration, ...keyframes.map(k => k.time));
+        }
+        return {channels, name: gltfAnimation.name, duration};
+    }
+    // ----------------------------------- Material ------------------------------------
+    async material(gltfMaterial: GLTF.Material): Promise<Parsed.Material> {
+        const gltfPbr = gltfMaterial.pbrMetallicRoughness;
+        const metallicRoughness: Parsed.MaterialMetallicRoughnessInfo = {
+            baseColor: gltfPbr?.baseColorFactor ?? [1, 1, 1, 1],
+            baseColorTexture: gltfPbr?.baseColorTexture && await this.texture(gltfPbr.baseColorTexture),
+            metallicFactor: gltfPbr?.metallicFactor ?? 1,
+            roughnessFactor: gltfPbr?.roughnessFactor ?? 1,
+            metallicRoughnessTexture: gltfPbr?.metallicRoughnessTexture && await this.texture(gltfPbr.metallicRoughnessTexture),
+        };
+        let normal: Parsed.MaterialNormalInfo | undefined;
+        if (gltfMaterial.normalTexture !== undefined) {
+            fail("TODO");
+        }
+        let emissive: Parsed.MaterialEmissiveInfo | undefined;
+        if (gltfMaterial.emissiveTexture !== undefined) {
+            fail("TODO");
+        }
+        let ambientOcclusion: Parsed.MaterialAmbientOcclusionInfo | undefined;
+        if (gltfMaterial.occlusionTexture !== undefined) {
+            fail("TODO");
+        }
+        const alpha: Parsed.MaterialAlphaInfo = {
+            mode: gltfMaterial.alphaMode ?? "OPAQUE",
+            cutoff: gltfMaterial.alphaCutoff ?? 0.5,
+        };
+        const doubleSided = gltfMaterial.doubleSided ?? false;
+        return {metallicRoughness, normal, emissive, ambientOcclusion, alpha, doubleSided};
+    }
+    async texture(gltfTextureInfo: GLTF.TextureInfo): Promise<Parsed.Texture | undefined> {
+        // Get texture from textureInfo
+        assert(this.header.textures !== undefined, "Header `Textures` property is undefined");
+        const gltfTexture = this.header.textures[gltfTextureInfo.index];
+        // No textures without source
+        if (gltfTexture.source === undefined) return undefined;
+        // Load texture image
+        assert(this.header.images !== undefined, "Header `Images` property is undefined");
+        const gltfImage = this.header.images[gltfTexture.source];
+        const source = await this.image(gltfImage);
+        // Parse sampler
+        const sampler: Parsed.Sampler = {wrap: {s: "repeat", t: "repeat"}, filter: {min: "linear", mag: "linear"}};
+        if (this.header.samplers !== undefined && gltfTexture.sampler !== undefined) {
+            const gltfSampler = this.header.samplers[gltfTexture.sampler];
+            if (gltfSampler.minFilter !== undefined) sampler.filter.min = TextureFilterMap[gltfSampler.minFilter];
+            if (gltfSampler.magFilter !== undefined) sampler.filter.mag = TextureFilterMap[gltfSampler.magFilter];
+            if (gltfSampler.wrapS !== undefined) sampler.wrap.s = TextureWrapModeMap[gltfSampler.wrapS];
+            if (gltfSampler.wrapT !== undefined) sampler.wrap.t = TextureWrapModeMap[gltfSampler.wrapT];
+        }
+        return {source, sampler, name: gltfTexture.name};
+    }
+    async image(gltfImage: GLTF.Image): Promise<ImageBitmap> {
+        // Image from uri
+        if ("uri" in gltfImage) {
+            // TODO: URI is relative to GLTF file path
+            const response = await fetch(this.path + gltfImage.uri);
+            assert(response.ok, `Failed to fetch image at URI: '${gltfImage.uri}'`);
+            const blob = await response.blob();
+            return await createImageBitmap(blob);
+        }
+        // Image from buffer
+        else {
+            assert(this.header.bufferViews !== undefined, "Header `BufferViews` property is undefined");
+            assert(this.header.buffers !== undefined, "Header `Buffers` property is undefined");
+            const bufferView = this.header.bufferViews[gltfImage.bufferView];
+            const buffer = this.header.buffers[bufferView.buffer];
+            if (buffer.uri !== undefined) {
+                fail("TODO");
+            }
+            // TODO: buffer length + bufferView offset (?)
+            const data = this.binary.slice(bufferView.byteOffset ?? 0, (bufferView.byteOffset ?? 0) + bufferView.byteLength);
+            const blob = new Blob([new Uint8Array(data)]);
+            return await createImageBitmap(blob);
+        }
+    }
+    // ------------------------------------- Scene -------------------------------------
+    async scene(): Promise<Parsed.Scene> {
+        const nodes = []; // TODO
+        const cameras = []; // TODO
+        const meshes = this.header.meshes
+            ? await Promise.all(this.header.meshes.map(m => this.mesh(m)))
+            : [];
+        const skins = this.header.skins
+            ? this.header.skins.map(s => this.skin(s))
+            : [];
+        return {nodes, cameras, meshes, skins};
+    }
+}

package/src/index.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from "./types.ts";
2	+ export * from "./Parser.ts";

package/src/types.ts ADDED Viewed

@@ -0,0 +1,244 @@
+import {Tuple} from "./util.ts";
+export type Matrix4x4 = Tuple<number, 16>
+export type Vector2 = Tuple<number, 2>
+export type Vector3 = Tuple<number, 3>
+export type Vector4 = Tuple<number, 4>
+// ------------------------------- Scene -------------------------------
+export type Scene = {
+    /**
+     * All nodes in scene
+     */
+    nodes: Node[]
+    cameras: Camera[],
+    meshes: Mesh[],
+    skins: Skin[],
+}
+// ------------------------------- Node --------------------------------
+export type Node = {
+    transform: Matrix4x4,
+    name?: string,
+    children: Node[],
+    parent?: Node,
+} & ({ mesh: Mesh, skin?: undefined, camera?: undefined }
+    | { skin: Skin, mesh?: undefined, camera?: undefined }
+    | { camera: Camera, mesh?: undefined, skin?: undefined })
+// ------------------------------ Camera -------------------------------
+export type OrthographicCamera = {
+    type: "Orthographic"
+    xmag: number,
+    ymag: number,
+    zfar: number,
+    znear: number,
+    view: Matrix4x4,
+    projection: Matrix4x4,
+}
+export type PerspectiveCamera = {
+    type: "Perspective"
+    aspectRatio: number,
+    yfov: number,
+    zfar: number,
+    znear: number,
+    view: Matrix4x4,
+    projection: Matrix4x4,
+}
+export type Camera = OrthographicCamera | PerspectiveCamera
+// ------------------------------- Mesh --------------------------------
+export type MeshPrimitiveAttributes = {
+    positions: Vector3[],
+    uvs?: Vector2[],
+    normals?: Vector3[],
+    colors?: Vector4[]
+    weights?: Vector4[],
+    joints?: Vector4[],
+    tangents?: Vector4[], // TODO
+}
+export type MeshPrimitive = {
+    /**
+     * Vertex attributes of the mesh primitive
+     */
+    attributes: MeshPrimitiveAttributes,
+    indices?: Uint32Array,
+    material?: Material,
+}
+export type Mesh = {
+    primitives: MeshPrimitive[],
+    name?: string,
+}
+// -------------------------------- Skin -------------------------------
+export type Joint = {
+    name: string,
+    transform: Matrix4x4,
+    inverseBindTransform: Matrix4x4,
+    children: string[],
+    parent?: string,
+}
+export type Skin = {
+    root: Joint,
+    joints: Record<string, Joint>,
+    animations: Animation[],
+    globalInverseTransform: Matrix4x4,
+    name?: string,
+}
+// ----------------------------- Animation -----------------------------
+export type Animation = {
+    duration: number,
+    name?: string,
+    channels: Record<string, AnimationChannel>,
+}
+export type AnimationChannel = {
+    translation: AnimationKeyframe<Vector3>[]
+    rotation: AnimationKeyframe<Vector4>[]
+    scale: AnimationKeyframe<Vector3>[]
+}
+export type AnimationKeyframe<T> = { time: number, value: T }
+// ----------------------------- Texture -------------------------------
+// TODO: If source is undefined, don't create texture, if sampler is undefined create default sampler
+export type Texture = {
+    source: ImageBitmap,
+    sampler: Sampler,
+    name?: string,
+}
+export type Sampler = {
+    wrap: { s: TextureWrapMode, t: TextureWrapMode },
+    filter: { min: TextureMinFilter, mag: TextureMagFilter },
+}
+export type TextureMagFilter = "nearest" | "linear"
+export type TextureMinFilter =
+    "nearest"
+    | "linear"
+    | "nearest-mipmap-nearest"
+    | "linear-mipmap-nearest"
+    | "nearest-mipmap-linear"
+    | "linear-mipmap-linear"
+export type TextureWrapMode =
+    | "clamp-to-edge"
+    | "mirrored-repeat"
+    | "repeat"
+export const TextureWrapModeMap = {
+    [33071]: "clamp-to-edge",
+    [33648]: "mirrored-repeat",
+    [10497]: "repeat",
+} as const;
+export const TextureFilterMap = {
+    [9728]: "nearest",
+    [9729]: "linear",
+    [9984]: "nearest-mipmap-nearest",
+    [9985]: "linear-mipmap-nearest",
+    [9986]: "nearest-mipmap-linear",
+    [9987]: "linear-mipmap-linear",
+} as const;
+// ----------------------------- Material ------------------------------
+export type Material = {
+    metallicRoughness: MaterialMetallicRoughnessInfo,
+    normal?: MaterialNormalInfo,
+    emissive?: MaterialEmissiveInfo,
+    ambientOcclusion?: MaterialAmbientOcclusionInfo,
+    alpha: MaterialAlphaInfo,
+    /**
+     * Whether the material is double sided. Default is `false`.
+     */
+    doubleSided: boolean,
+}
+export type MaterialAlphaInfo = {
+    /**
+     * The alpha rendering mode of the material. Default is `"OPAQUE"`.
+     */
+    mode: "OPAQUE" | "MASK" | "BLEND",
+    /**
+     * The alpha cutoff value of the material. Default is `0.5`.
+     */
+    cutoff: number,
+}
+export type MaterialMetallicRoughnessInfo = {
+    /**
+     * The base color factor of the material. Default is `[1, 1, 1, 1]`.
+     */
+    baseColor: Vector4,
+    /**
+     * The base color texture of the material.
+     */
+    baseColorTexture?: Texture,
+    /**
+     * The factor for the metalness of the material. Default is `1`.
+     */
+    metallicFactor: number,
+    /**
+     * The factor for the roughness of the material. Default is `1`.
+     */
+    roughnessFactor: number,
+    /**
+     * The metallic roughness texture of the material.
+     */
+    metallicRoughnessTexture?: Texture,
+}
+export type MaterialNormalInfo = {
+    /**
+     * The normal texture of the material.
+     */
+    texture: Texture,
+    /**
+     * The scale applied to each vector of the normal map. Default is `1`.
+     */
+    scale: number,
+}
+export type MaterialEmissiveInfo = {
+    /**
+     * The emissive texture of the material.
+     */
+    texture: Texture,
+    /**
+     * The emissive factor of the material. Default is `[0, 0, 0]`.
+     */
+    factor: Vector3,
+}
+export type MaterialAmbientOcclusionInfo = {
+    /**
+     * The occlusion texture of the material.
+     */
+    texture: Texture,
+    /**
+     * The occlusion strength of the material. Default is `1`.
+     */
+    strength: number,
+}

package/src/util.ts ADDED Viewed

@@ -0,0 +1,67 @@
+import {TransformOrder, mat4, vec3, quat, Matrix4} from "dom-game-math";
+import {Matrix4x4} from "./types.ts";
+// ----------------------------------- fail & assert -----------------------------------
+export function fail(msg: string): never {
+    throw new Error(msg);
+}
+export function assert(condition: boolean, msg: string): asserts condition {
+    if (!condition) {
+        throw new Error(msg);
+    }
+}
+// ------------------------------------- Accessor --------------------------------------
+export type AccessorArrayType =
+    | Float32ArrayConstructor
+    | Uint32ArrayConstructor
+    | Uint16ArrayConstructor
+    | Int16ArrayConstructor
+    | Uint8ArrayConstructor
+    | Int8ArrayConstructor
+export type AccessorConstructorType<T extends AccessorArrayType> = ReturnType<T["from"]>
+// --------------------------------------- Tuple ---------------------------------------
+export type Tuple<T, N extends number> = T[] & { length: N };
+export function chunk<T, N extends number>(array: Iterable<T>, size: N): Tuple<T, N>[] {
+    const result = new Array<T[]>;
+    let chunk = new Array<T>();
+    for (const value of Array.from(array)) {
+        chunk.push(value);
+        if (chunk.length === size) {
+            result.push(chunk);
+            chunk = [];
+        }
+    }
+    if (chunk.length) {
+        result.push(chunk);
+    }
+    return result as Tuple<T, N>[];
+}
+export function getTransform(transform: {
+    translation?: number[],
+    rotation?: number[],
+    scale?: number[]
+}, order: TransformOrder, out?: Tuple<number, 16>) {
+    out ??= Array.from(mat4.idt) as Tuple<number, 16>;
+    mat4.compose({
+        translation: transform.translation && vec3.fromArray(transform.translation),
+        rotation: transform.rotation && quat.fromArray(transform.rotation),
+        scale: transform.scale && vec3.fromArray(transform.scale),
+        order,
+    }, out as Matrix4);
+    return out;
+}

package/tsconfig.json ADDED Viewed

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "ES2022",
+    "lib": [
+      "ES2023",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "useDefineForClassFields": true,
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+    "noEmit": true,
+    "noImplicitAny": false,
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "declaration": true,
+    "accessor-pairs": [
+      "error",
+      {
+        "setWithoutGet": true,
+        "getWithoutSet": true
+      }
+    ]
+  },
+  "include": [
+    "src"
+  ]
+}