@perplexdotgg/bounce 1.2.1 → 1.2.3

package/build/bounce.js

@@ -1,1276 +1,4 @@
-// @__NO_SIDE_EFFECTS__
-function NumberType(defaultValue, readOnly) {
-  return {
-    monomorph: {
-      serializedSize: 1
-    },
-    propertyType: 0,
-    optional: defaultValue !== void 0,
-    defaultValue,
-    readOnly
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function StringType(defaultValue, readOnly, maxLength) {
-  return {
-    monomorph: maxLength === void 0 ? {
-      serializedSize: 0,
-      getDynamicSize: (str) => str.length
-    } : {
-      serializedSize: maxLength
-    },
-    propertyType: 1,
-    optional: defaultValue !== void 0,
-    defaultValue,
-    readOnly
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function BooleanType(defaultValue, readOnly) {
-  return {
-    monomorph: {
-      serializedSize: 1
-    },
-    propertyType: 2,
-    optional: defaultValue !== void 0,
-    defaultValue,
-    readOnly
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function ReferenceListType(monomorphClass) {
-  return {
-    monomorph: {
-      serializedSize: 1,
-      // @ts-ignore
-      theClass: monomorphClass
-    },
-    propertyType: 6,
-    // this should really be false, but for some unknown reason that causes a recursive reference
-    // on a class if it has both a ReferenceListType and a self-referencing LazyReferenceType
-    optional: true,
-    defaultValue: void 0,
-    readOnly: false
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function LazyReferenceType(fn, readOnly) {
-  return {
-    monomorph: {
-      serializedSize: 2,
-      fnInArray: [fn],
-      theClass: null
-    },
-    propertyType: 4,
-    optional: true,
-    defaultValue: null,
-    readOnly
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function LazyReferenceListType(fn, readOnly) {
-  return {
-    monomorph: {
-      serializedSize: 2,
-      fnInArray: [fn],
-      theClass: null
-    },
-    propertyType: 7,
-    optional: true,
-    defaultValue: null,
-    readOnly
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function ReferenceType(monomorphClass, defaultValue, readOnly) {
-  return {
-    monomorph: monomorphClass,
-    propertyType: 3,
-    optional: true,
-    defaultValue: null,
-    readOnly
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function ChildType(monomorphClass, defaultValue, readOnly) {
-  return {
-    monomorph: monomorphClass,
-    propertyType: 8,
-    defaultValue,
-    optional: defaultValue !== void 0,
-    readOnly
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function makeSafeAsVariableName(name) {
-  return name.replaceAll(".", "DOT");
-}
-function populatePropsQueue(props, propsQueue, keySoFar = "", monomorphPathSoFar = "", depth = 0) {
-  for (const [key, maybePropertyDefinition] of Object.entries(props)) {
-    const fullKey = keySoFar + key;
-    const fullMonomorphPath = monomorphPathSoFar + key;
-    const referencePath = keySoFar + "__reference__" + key;
-    const uniqueKey = /* @__PURE__ */ makeSafeAsVariableName(fullKey);
-    const theType = typeof maybePropertyDefinition;
-    let propertyDefinition;
-    if (theType === "object" && "monomorph" in maybePropertyDefinition) {
-      propertyDefinition = maybePropertyDefinition;
-    } else {
-      if (theType === "function" && "serializedSize" in maybePropertyDefinition) {
-        propertyDefinition = /* @__PURE__ */ ChildType(maybePropertyDefinition);
-      } else if (theType === "number") {
-        propertyDefinition = /* @__PURE__ */ NumberType(maybePropertyDefinition);
-      } else if (theType === "boolean") {
-        propertyDefinition = /* @__PURE__ */ BooleanType(maybePropertyDefinition);
-      } else if (theType === "string") {
-        propertyDefinition = /* @__PURE__ */ StringType(maybePropertyDefinition);
-      } else {
-        throw new Error(`Invalid property definition for key "${fullKey}", theType ${theType} ${"serializedSize" in maybePropertyDefinition}`);
-      }
-      props[key] = propertyDefinition;
-    }
-    propsQueue.push({
-      key,
-      fullKey,
-      uniqueKey,
-      parentKey: keySoFar ? keySoFar.substring(0, keySoFar.length - 1) : "",
-      keyWithOptionalChaining: fullKey.replace(/\.([a-zA-Z])/g, (_, c3) => `?.${c3}`),
-      monomorphPath: fullMonomorphPath,
-      propertyDefinition,
-      referencePath,
-      depth
-    });
-    if (propertyDefinition.propertyType === 8) {
-      populatePropsQueue(propertyDefinition.monomorph.propertyDefinitionMap, propsQueue, fullKey + ".", fullMonomorphPath + ".monomorph.propertyDefinitionMap.", depth + 1);
-    }
-  }
-}
-// @__NO_SIDE_EFFECTS__
-function stringifyDefaultValue(defaultValue) {
-  return typeof defaultValue === "undefined" ? "null" : JSON.stringify(defaultValue);
-}
-// @__NO_SIDE_EFFECTS__
-function getClassCode(props, options = {}) {
-  options = {
-    debug: false,
-    afterConstructorCode: "",
-    ...options
-  };
-  let hasDynamicSize = false;
-  let hasReferences = false;
-  let hasPoolReferences = false;
-  let hasRequiredProps = false;
-  let dataHasBeenInitializedInResetCode = false;
-  let beforeClassCode = "";
-  let constructorCode = "";
-  let customTypesConstructorCode = "";
-  let constructorAndResetDataCode = "";
-  let constructorAndResetDataDefaultValueCode = "";
-  let onlyResetDataDefaultValueCode = "";
-  let customTypesOnlyResetCode = "";
-  let setCode = "";
-  let customTypesBeforeDestroyCode = "";
-  let copyCode = "";
-  let toArrayCode = "";
-  let toArrayCodeForPoolReferences = "";
-  let setSerializedSizeInstanceCode = "";
-  let fromArrayCode = "";
-  let fromArrayCodeForPoolReferences = "";
-  let fromArrayNoReferencesCode = "";
-  let fromArrayNoReferencesCodeForPoolReferences = "";
-  let fromArrayOnlyReferencesCode = "";
-  let fromArrayOnlyReferencesCodeForPoolReferences = "";
-  let fromArrayTemp;
-  let referenceGettersAndSettersCode = "";
-  let getDynamicSizeMethodCode = "";
-  let previousDepth = 0;
-  let previousKey = "";
-  const propsQueue = [];
-  populatePropsQueue(props, propsQueue);
-  const monomorphsAlreadyAdded = /* @__PURE__ */ new Set();
-  let propIndex = 0;
-  let totalStaticSize = 0;
-  while (propIndex < propsQueue.length) {
-    const { depth, fullKey, propertyDefinition } = propsQueue[propIndex];
-    propIndex++;
-    if (!hasRequiredProps && propertyDefinition.propertyType !== 8 && propertyDefinition.optional !== true) {
-      hasRequiredProps = true;
-    }
-    if (depth === 0) {
-      if (!hasPoolReferences && propertyDefinition.propertyType === 8 && "hasPoolReferences" in propertyDefinition.monomorph) {
-        hasPoolReferences = true;
-      }
-      if (propertyDefinition.propertyType === 3 || propertyDefinition.propertyType === 4 || propertyDefinition.propertyType === 6 || propertyDefinition.propertyType === 7) {
-        hasReferences = true;
-        totalStaticSize += 2;
-      } else if (propertyDefinition.propertyType === 5) {
-        hasPoolReferences = true;
-      } else if (typeof propertyDefinition.monomorph.getDynamicSize === "function") {
-        hasDynamicSize = true;
-        getDynamicSizeMethodCode += `
-          dynamicSize += this.${fullKey}.getDynamicSize(this.${fullKey});
-        `;
-      } else {
-        totalStaticSize += propertyDefinition.monomorph.serializedSize;
-      }
-    }
-  }
-  if (hasPoolReferences) {
-    totalStaticSize += 1;
-    toArrayCodeForPoolReferences = `
-      if (!skipPoolReferences) {
-        array[offset++] = 1;
-    `;
-    fromArrayCodeForPoolReferences = `
-      if (arrayOfData[offset++] === 1) {
-    `;
-    fromArrayOnlyReferencesCodeForPoolReferences = fromArrayCodeForPoolReferences;
-    fromArrayNoReferencesCodeForPoolReferences = `
-      offset++;
-    `;
-    if (hasDynamicSize) {
-      getDynamicSizeMethodCode = getDynamicSizeMethodCode.replace("dynamicSize +", `getDynamicSize(skipPoolReferences) {
-        let dynamicSize `);
-      getDynamicSizeMethodCode += "}";
-      setSerializedSizeInstanceCode = `
-        const serializedSize = ${totalStaticSize} + this.getDynamicSize(skipPoolReferences);
-      `;
-    } else {
-      setSerializedSizeInstanceCode += `
-        const serializedSize = ${totalStaticSize} + (skipPoolReferences ? 0 : 0/*todo: this.getDynamicSize()*/);
-      `;
-    }
-  } else if (hasDynamicSize) {
-    getDynamicSizeMethodCode = getDynamicSizeMethodCode.replace("dynamicSize +", `getDynamicSize() {
-      let dynamicSize `);
-    getDynamicSizeMethodCode += "}";
-    setSerializedSizeInstanceCode = `
-      const serializedSize = ${totalStaticSize} + this.getDynamicSize();
-    `;
-  } else {
-    setSerializedSizeInstanceCode += `
-      const serializedSize = ${totalStaticSize};
-    `;
-  }
-  if (hasReferences) {
-    fromArrayCode += `
-      let poolIndex;
-      let referenceVersion;
-      let reference;
-      let poolArray;
-    `;
-    fromArrayOnlyReferencesCode += fromArrayCode;
-    constructorAndResetDataDefaultValueCode = `
-      if (data !== undefined) {
-        ${constructorAndResetDataDefaultValueCode}
-      }
-    `;
-  }
-  propIndex = 0;
-  while (propIndex < propsQueue.length) {
-    const {
-      fullKey,
-      uniqueKey,
-      parentKey,
-      keyWithOptionalChaining,
-      monomorphPath,
-      propertyDefinition,
-      referencePath,
-      depth
-    } = propsQueue[propIndex];
-    propIndex++;
-    if (depth === 0) {
-      if ("monomorph" in propertyDefinition) {
-        if ("hasDynamicSize" in propertyDefinition.monomorph && propertyDefinition.monomorph.hasDynamicSize) {
-          hasDynamicSize = true;
-        }
-        if (propertyDefinition.propertyType === 8) {
-          constructorCode += `
-            this.${fullKey} = ${propertyDefinition.monomorph.name}.create(data${hasRequiredProps ? "" : "?"}.${fullKey});
-          `;
-          if (propertyDefinition.defaultValue === void 0) {
-            onlyResetDataDefaultValueCode += `
-              this.${fullKey}.reset(data?.${fullKey});
-            `;
-          } else {
-            onlyResetDataDefaultValueCode += `
-              this.${fullKey}.reset(data?.${fullKey}) ?? ${JSON.stringify(propertyDefinition.defaultValue)};
-            `;
-          }
-        } else if (propertyDefinition.propertyType === 3 || propertyDefinition.propertyType === 4) {
-          if (propertyDefinition.propertyType === 4) {
-            const name = "lazyRefMonomorph" + propIndex;
-            constructorCode += `
-              if (!${name}.theClass) {
-                ${name}.theClass = ${name}.fnInArray[0]();
-              }
-              this.__reference__${fullKey} = new ${name}.theClass.Reference(data${hasRequiredProps ? "" : "?"}.${fullKey});
-            `;
-          } else {
-            constructorCode += `
-              this.__reference__${fullKey} = new ${propertyDefinition.monomorph.name}.Reference(data${hasRequiredProps ? "" : "?"}.${fullKey});
-            `;
-          }
-          referenceGettersAndSettersCode += `
-            get ${fullKey}() {
-              const refInstance = this.__reference__${fullKey};
-              if (!refInstance.reference || refInstance.reference.version !== refInstance.version) {
-                return null;
-              }
-              return refInstance.reference;
-            }
-
-            set ${fullKey}(value) {
-              const refInstance = this.__reference__${fullKey};
-              if (!value || (value.version & 1)) {
-                refInstance.version = -1;
-                refInstance.reference = null;
-              } else {
-                refInstance.version = value.version;
-                refInstance.reference = value;
-              }
-            }
-          `;
-        } else if (propertyDefinition.propertyType === 7) {
-          const name = "lazyRefList" + propIndex;
-          constructorCode += `
-            if (!${name}.theClass) {
-              ${name}.theClass = ${name}.fnInArray[0]();
-            }
-            if (this.${fullKey}) {
-              this.${fullKey}.length = 0;
-            } else {
-              this.${fullKey} = new ${name}.theClass.ReferenceList(data${hasRequiredProps ? "" : "?"}.${fullKey}?.pool || new ${name}.theClass.Pool(), data${hasRequiredProps ? "" : "?"}.${fullKey}?.maxLength, data${hasRequiredProps ? "" : "?"}.${fullKey}?.items, ${name}.theClass);
-            }
-          `;
-        } else if (propertyDefinition.propertyType === 6) {
-          const className = propertyDefinition.monomorph.theClass.name;
-          constructorCode += `
-            if (this.${fullKey}) {
-              this.${fullKey}.length = 0;
-            } else {
-              this.${fullKey} = new ${className}.ReferenceList(data${hasRequiredProps ? "" : "?"}.${fullKey}?.pool || new ${className}.Pool(), data${hasRequiredProps ? "" : "?"}.${fullKey}?.maxLength, data${hasRequiredProps ? "" : "?"}.${fullKey}?.items, ${className});
-            }
-          `;
-        } else if (propertyDefinition.propertyType === 9) {
-          const customTypeConfig = propertyDefinition.monomorph;
-          const params = {
-            depth,
-            key: fullKey,
-            thisProperty: `this.${fullKey}`,
-            dataProperty: `data${hasRequiredProps ? "" : "?"}.${fullKey}`,
-            customTypeData: "customType" + propIndex
-          };
-          if (typeof customTypeConfig.constructorCode !== "undefined") {
-            customTypesConstructorCode += typeof customTypeConfig.constructorCode === "function" ? customTypeConfig.constructorCode(params) : customTypeConfig.constructorCode;
-          } else {
-            customTypesConstructorCode += `
-              this.${fullKey} = data${hasRequiredProps ? "" : "?"}.${fullKey} ?? ${/* @__PURE__ */ stringifyDefaultValue(propertyDefinition.defaultValue)}; // 111
-            `;
-          }
-          if (typeof customTypeConfig.resetCode !== "undefined") {
-            customTypesOnlyResetCode += typeof customTypeConfig.resetCode === "function" ? customTypeConfig.resetCode(params) : customTypeConfig.resetCode;
-          } else {
-            customTypesOnlyResetCode += `
-              this.${fullKey} = data${hasRequiredProps ? "" : "?"}.${fullKey} ?? this.${fullKey} ?? ${/* @__PURE__ */ stringifyDefaultValue(propertyDefinition.defaultValue)};
-            `;
-          }
-          if (typeof customTypeConfig.beforeDestroyCode !== "undefined") {
-            customTypesBeforeDestroyCode += typeof customTypeConfig.beforeDestroyCode === "function" ? customTypeConfig.beforeDestroyCode(params) : customTypeConfig.beforeDestroyCode;
-          } else {
-            customTypesBeforeDestroyCode += `
-              this.${fullKey} = null;
-            `;
-          }
-        }
-      }
-      if (propertyDefinition.defaultValue !== void 0 && propertyDefinition.propertyType !== 6 && propertyDefinition.propertyType !== 7) {
-        if (!dataHasBeenInitializedInResetCode) {
-          dataHasBeenInitializedInResetCode = true;
-          constructorAndResetDataDefaultValueCode += `
-            data = data ?? {};
-          `;
-        }
-        if (parentKey) {
-          constructorAndResetDataDefaultValueCode += `
-            data.${parentKey} = data.${parentKey} ?? {};
-          `;
-        }
-        constructorAndResetDataDefaultValueCode += `
-          data.${fullKey} = data.${fullKey} ?? ${JSON.stringify(propertyDefinition.defaultValue)};
-        `;
-      }
-      if (propertyDefinition.propertyType !== 8 && propertyDefinition.propertyType !== 6 && propertyDefinition.propertyType !== 7 && propertyDefinition.propertyType !== 9) {
-        if (hasRequiredProps) {
-          if (propertyDefinition.optional) {
-            constructorAndResetDataCode += `
-              this.${fullKey} = data.${fullKey} ?? ${propertyDefinition.defaultValue};
-            `;
-          } else {
-            constructorAndResetDataCode += `
-              this.${fullKey} = data.${fullKey};
-            `;
-          }
-        } else {
-          constructorAndResetDataCode += `
-            this.${fullKey} = data.${keyWithOptionalChaining};
-          `;
-        }
-      }
-    }
-    if (previousDepth < depth) {
-      setCode += `
-        if (data.${previousKey} !== undefined) {
-      `;
-      previousDepth = depth;
-    } else if (previousDepth > depth) {
-      while (previousDepth > depth) {
-        setCode += `
-          }
-        `;
-        previousDepth--;
-      }
-    }
-    previousKey = fullKey;
-    if (propertyDefinition.propertyType === 8 || propertyDefinition.propertyType === 3 || propertyDefinition.propertyType === 5) {
-      const monomorph = propertyDefinition.monomorph;
-      if (!monomorphsAlreadyAdded.has(monomorph.name)) {
-        beforeClassCode += `
-          const ${monomorph.name} = input.${monomorphPath}.monomorph;
-        `;
-        monomorphsAlreadyAdded.add(monomorph.name);
-      }
-    } else if (propertyDefinition.propertyType === 6) {
-      const monomorph = propertyDefinition.monomorph;
-      const className = monomorph.theClass.name;
-      if (!monomorphsAlreadyAdded.has(className)) {
-        beforeClassCode += `
-          const ${className} = input.${monomorphPath}.monomorph.theClass;
-        `;
-        monomorphsAlreadyAdded.add(className);
-      }
-    } else if (propertyDefinition.propertyType === 4) {
-      const name = "lazyRefMonomorph" + propIndex;
-      if (!monomorphsAlreadyAdded.has(name)) {
-        beforeClassCode += `
-          const ${name} = input.${monomorphPath}.monomorph;
-        `;
-        monomorphsAlreadyAdded.add(name);
-      }
-    } else if (propertyDefinition.propertyType === 7) {
-      const name = "lazyRefList" + propIndex;
-      if (!monomorphsAlreadyAdded.has(name)) {
-        beforeClassCode += `
-          const ${name} = input.${monomorphPath}.monomorph;
-        `;
-        monomorphsAlreadyAdded.add(name);
-      }
-    } else if (propertyDefinition.propertyType === 9) {
-      const customTypeConfig = propertyDefinition.monomorph;
-      const name = "customType" + propIndex;
-      if (customTypeConfig.beforeClassCode || customTypeConfig.constructorCode || customTypeConfig.resetCode || customTypeConfig.beforeDestroyCode) {
-        beforeClassCode += `
-          const ${name} = input.${monomorphPath}.monomorph.data;
-        `;
-      }
-      if (customTypeConfig.beforeClassCode) {
-        beforeClassCode += typeof customTypeConfig.beforeClassCode === "function" ? customTypeConfig.beforeClassCode({
-          depth,
-          key: fullKey,
-          // thisProperty: `this.${fullKey}`,
-          // dataProperty: `data${hasRequiredProps ? '' : '?'}.${fullKey}`,
-          customTypeData: name
-        }) : customTypeConfig.beforeClassCode;
-      }
-    }
-    if (propertyDefinition.propertyType !== 8) {
-      if (propertyDefinition.propertyType === 6 || propertyDefinition.propertyType === 7) {
-        setCode += `
-          if (data.${fullKey} !== undefined) {
-            this.${fullKey}.length = 0;
-          }
-        `;
-        copyCode += `
-          this.${fullKey}.maxLength = other.${fullKey}.maxLength;
-
-          const ${uniqueKey}length = other.${fullKey}.length;
-          this.${fullKey}.length = ${uniqueKey}length;
-          for (let i = 0; i < ${uniqueKey}length; i++) {
-            this.${fullKey}.arrayOfIndices[i] = other.${fullKey}.arrayOfIndices[i];
-            this.${fullKey}.arrayOfVersions[i] = other.${fullKey}.arrayOfVersions[i];
-          }
-        `;
-      } else if (propertyDefinition.propertyType === 9) {
-        const customTypeConfig = propertyDefinition.monomorph;
-        const params = {
-          depth,
-          key: fullKey,
-          thisProperty: `this.${fullKey}`,
-          dataProperty: `data.${fullKey}`,
-          customTypeData: "customType" + propIndex
-        };
-        if (typeof customTypeConfig.setCode !== "undefined") {
-          setCode += typeof customTypeConfig.setCode === "function" ? customTypeConfig.setCode(params) : customTypeConfig.setCode;
-        } else {
-          setCode += `
-            if (data.${fullKey} !== undefined) {
-              this.${fullKey} = data.${fullKey};
-            }
-          `;
-        }
-        if (typeof customTypeConfig.copyCode !== "undefined") {
-          copyCode += typeof customTypeConfig.copyCode === "function" ? customTypeConfig.copyCode({
-            depth,
-            key: fullKey,
-            thisProperty: `this.${fullKey}`,
-            otherProperty: `other.${fullKey}`,
-            customTypeData: "customType" + propIndex
-          }) : customTypeConfig.copyCode;
-        } else {
-          copyCode += `
-            this.${fullKey} = other.${fullKey};
-          `;
-        }
-      } else {
-        setCode += `
-          if (data.${fullKey} !== undefined) {
-            this.${fullKey} = data.${fullKey};
-          }
-        `;
-        copyCode += `
-          this.${fullKey} = other.${fullKey};
-        `;
-      }
-      switch (propertyDefinition.propertyType) {
-        case 0:
-          toArrayCode += `
-            array[offset++] = this.${fullKey};
-          `;
-          fromArrayTemp = `
-            this.${fullKey} = arrayOfData[offset++];
-          `;
-          fromArrayCode += fromArrayTemp;
-          fromArrayNoReferencesCode += fromArrayTemp;
-          fromArrayOnlyReferencesCode += `
-            offset++;
-          `;
-          break;
-        case 1:
-          toArrayCode += `
-            throw new Error('serializing strings is not implemented yet');
-          `;
-          fromArrayTemp = `
-            throw new Error('serializing strings is not implemented yet');
-          `;
-          fromArrayCode += fromArrayTemp;
-          fromArrayNoReferencesCode += fromArrayTemp;
-          fromArrayOnlyReferencesCode += fromArrayTemp;
-          break;
-        case 2:
-          toArrayCode += `
-            array[offset++] = Number(this.${fullKey});
-          `;
-          fromArrayTemp = `
-            this.${fullKey} = Boolean(arrayOfData[offset++]);
-          `;
-          fromArrayCode += fromArrayTemp;
-          fromArrayNoReferencesCode += fromArrayTemp;
-          fromArrayOnlyReferencesCode += `
-            offset++;
-          `;
-          break;
-        case 3:
-        case 4:
-          toArrayCode += `
-            if (this.${referencePath}.reference && this.${referencePath}.version === this.${referencePath}.reference.version) {
-              array[offset++] = this.${referencePath}.reference.index;
-              array[offset++] = this.${referencePath}.version;
-            } else {
-              array[offset++] = -1;
-              array[offset++] = -1;
-            }
-          `;
-          fromArrayTemp = `
-            poolIndex = arrayOfData[offset++];
-            if (poolIndex === -1) {
-              this.${referencePath}.reference = null;
-              this.${referencePath}.version = -1;
-              offset++; ${""}
-            } else {
-              poolArray = references.${fullKey}.array;
-              reference = poolArray[poolIndex];
-              referenceVersion = arrayOfData[offset++];
-
-              if (reference && reference.version === referenceVersion) {
-                this.${referencePath}.reference = reference;
-                this.${referencePath}.version = referenceVersion;
-              } else {
-                this.${referencePath}.reference = null;
-                this.${referencePath}.version = -1;
-              }
-            }
-          `;
-          fromArrayCode += fromArrayTemp;
-          fromArrayOnlyReferencesCode += fromArrayTemp;
-          fromArrayNoReferencesCode += `
-            offset += 2;
-          `;
-          break;
-        case 6:
-          toArrayCode += `
-            array[offset++] = this.${fullKey}.length;
-            for (let i = 0; i < this.${fullKey}.length; i++) {
-              array[offset++] = this.${fullKey}.arrayOfIndices[i];
-              array[offset++] = this.${fullKey}.arrayOfVersions[i];
-            }
-          `;
-          fromArrayTemp = `
-            const ${uniqueKey}ListLength = arrayOfData[offset++];
-            for (let i = 0; i < ${uniqueKey}ListLength; i++) {
-              this.${fullKey}.arrayOfIndices[i] = arrayOfData[offset++];
-              this.${fullKey}.arrayOfVersions[i] = arrayOfData[offset++];
-            }
-
-            this.${fullKey}.pool = references.${fullKey};
-          `;
-          fromArrayCode += fromArrayTemp;
-          fromArrayOnlyReferencesCode += fromArrayTemp;
-          fromArrayNoReferencesCode += `
-            offset += arrayOfData[offset++] * 2;
-          `;
-          break;
-        case 5:
-          toArrayCodeForPoolReferences += `
-            if (this.${fullKey} && this.${fullKey}.length > 0) {
-              array[offset++] = 1; // indicates that the pool reference is not empty
-              offset = this.${fullKey}.toArray(array, offset);
-            } else {
-              array[offset++] = 0; // indicates that the pool reference is empty
-            }
-          `;
-          fromArrayCodeForPoolReferences += `
-            if (arrayOfData[offset++] === 1) {
-              this.${fullKey} = references.${fullKey} || this.${fullKey} || new ${propertyDefinition.monomorph.name}.Pool();
-              offset = this.${fullKey}.fromArray(arrayOfData, ${propertyDefinition.monomorph.hasReferences ? `references.${fullKey}, ` : ""} offset);
-            } else {
-              this.${fullKey} = null;
-            }
-          `;
-          fromArrayOnlyReferencesCodeForPoolReferences += `
-            if (arrayOfData[offset++] === 1) {
-              this.${fullKey} = references.${fullKey} || this.${fullKey} || new ${propertyDefinition.monomorph.name}.Pool();
-              offset = this.${fullKey}.fromArrayOnlyReferences(arrayOfData, ${propertyDefinition.monomorph.hasReferences ? `references.${fullKey}, ` : ""} offset);
-            } else {
-              this.${fullKey} = null;
-            }
-          `;
-          fromArrayNoReferencesCodeForPoolReferences += `
-            if (arrayOfData[offset++] === 1) {
-              this.${fullKey} = references.${fullKey} || this.${fullKey} || new ${propertyDefinition.monomorph.name}.Pool();
-              offset = this.${fullKey}.fromArrayNoReferences(arrayOfData, ${propertyDefinition.monomorph.hasReferences ? `references.${fullKey}, ` : ""} offset);
-            }
-          `;
-          break;
-      }
-    }
-  }
-  if (hasPoolReferences) {
-    toArrayCodeForPoolReferences += `
-      } else {
-        array[offset++] = 0; // indicates that pool references were skipped
-      }
-    `;
-    fromArrayCodeForPoolReferences += `
-      }
-    `;
-    fromArrayOnlyReferencesCodeForPoolReferences += `
-      }
-    `;
-  }
-  while (previousDepth > 0) {
-    setCode += `
-      }
-    `;
-    previousDepth--;
-  }
-  const code = `
-    ${beforeClassCode}
-
-    function iterateOverPool(pool) {
-      let index = 0;
-      let nonEmpty = 0;
-      const array = pool.array;
-      const maxLength = pool.maxLength;
-      const iteratorResult = {
-        done: false,
-        value: null,
-      };
-
-      return {
-        next() {
-          ${""}
-          while (index < (pool.length + pool.freeIndices.length) && (!array[index] || (array[index].version & 1) === 1)) {
-            index++;
-          }
-
-          ${""}
-          if (index >= maxLength || nonEmpty >= pool.length) {
-            iteratorResult.done = true;
-            iteratorResult.value = null;
-            return iteratorResult;
-          }
-
-          const value = array[index];
-          index++;
-          nonEmpty++;
-          iteratorResult.done = false;
-          iteratorResult.value = value;
-          return iteratorResult;
-        }
-      };
-    }
-
-    function iterateOverReferenceList(referenceList, fixDestroyed = true) {
-      let index = 0;
-      const poolArray = referenceList.pool.array;
-      const arrayOfIndices = referenceList.arrayOfIndices;
-      const arrayOfVersions = referenceList.arrayOfVersions;
-      const iteratorResult = {
-        done: false,
-        value: null,
-      };
-      let poolItem;
-
-      return {
-        next() {
-          if (!arrayOfIndices.length || index >= arrayOfIndices.length) {
-            iteratorResult.done = true;
-            iteratorResult.value = null;
-            return iteratorResult;
-          }
-
-          poolItem = poolArray[arrayOfIndices[index]];
-
-          ${""}
-          while (index < arrayOfIndices.length && (((poolItem.version & 1) === 1) || poolItem.version !== arrayOfVersions[index])) {
-            if (fixDestroyed) {
-              if (index < arrayOfIndices.length - 1) {
-                arrayOfIndices[index] = arrayOfIndices[arrayOfIndices.length - 1];
-                arrayOfVersions[index] = arrayOfVersions[arrayOfVersions.length - 1];
-                poolItem = poolArray[arrayOfIndices[index]];
-              }
-
-              referenceList.length -= 1;
-            } else {
-              index++;
-              if (index < arrayOfIndices.length) {
-                poolItem = poolArray[arrayOfIndices[index]];
-              }
-            }
-          }
-
-          if (index >= arrayOfIndices.length) {
-            iteratorResult.done = true;
-            iteratorResult.value = null;
-            return iteratorResult;
-          }
-
-          index++;
-          iteratorResult.done = false;
-          iteratorResult.value = poolItem;
-          return iteratorResult;
-        }
-      };
-    }
-
-    const theClass = class {
-      static hasDynamicSize = ${hasDynamicSize};
-
-      constructor(data, index, pool) {
-        ${constructorAndResetDataDefaultValueCode}
-        ${constructorCode}
-        ${constructorAndResetDataCode}
-        ${customTypesConstructorCode}
-        this.index = index;
-        this.version = 0; ${""}
-        this.pool = (pool === undefined) ? null : pool;
-        ${options.afterConstructorCode}
-      }
-
-      ${referenceGettersAndSettersCode}
-
-      reset(data) {
-        ${constructorAndResetDataDefaultValueCode}
-        ${onlyResetDataDefaultValueCode}
-        ${constructorAndResetDataCode}
-        ${customTypesOnlyResetCode}
-        return this;
-      }
-
-      set(data) {
-        ${setCode}
-        return this;
-      }
-
-      copy(other) {
-        ${copyCode}
-        return this;
-      }
-
-      destroy() {
-        ${customTypesBeforeDestroyCode}
-        if (this.version & 1 === 1) {
-          ${""}
-          return;
-        }
-        this.version++; // becomes odd, meaning deleted
-        if (this.pool) {
-          this.pool.length--;
-          this.pool.freeIndices.push(this.index);
-        }
-      }
-
-      isDestroyed() {
-        return Boolean(this.version & 1);
-      }
-
-      iterateOverPool() {
-        if (!this.pool) {
-          throw new Error("Pool is not set");
-        }
-        // call the static method
-        return theClass.iterateOverPool(this.pool);
-      }
-
-      createInPool(data) {
-        if (!this.pool) {
-          throw new Error("Pool is not set");
-        }
-        return this.constructor.create(data, this.pool);
-      }
-
-      ${getDynamicSizeMethodCode}
-
-      toArray(array, startOffset = 0${hasPoolReferences ? ", skipPoolReferences = false" : ""}) {
-        ${""}
-        ${setSerializedSizeInstanceCode}
-
-        if (array === undefined) {
-          array = new Array(serializedSize + startOffset);
-        ${""}
-        } else if (ArrayBuffer.isView(array) && array.length < serializedSize + startOffset) {
-          throw new Error("Array is too small to write data into, needed "+(serializedSize + startOffset)+" but typed array is of length "+array.length);
-        }
-
-        let offset = startOffset;
-
-        ${toArrayCode}
-
-        ${toArrayCodeForPoolReferences}
-
-        return offset;
-      }
-
-      fromArray(arrayOfData, ${hasReferences || hasPoolReferences ? "references," : ""} startOffset = 0) {
-        let offset = startOffset;
-
-        ${fromArrayCode}
-
-        ${fromArrayCodeForPoolReferences}
-
-        return offset;
-      }
-
-      fromArrayNoReferences(arrayOfData, startOffset = 0) {
-        let offset = startOffset;
-
-        ${fromArrayNoReferencesCode}
-
-        ${fromArrayNoReferencesCodeForPoolReferences}
-
-        return offset;
-      }
-
-      fromArrayOnlyReferences(arrayOfData, references, startOffset = 0) {
-        let offset = startOffset;
-
-        ${fromArrayOnlyReferencesCode}
-
-        ${fromArrayOnlyReferencesCodeForPoolReferences}
-
-        return offset;
-      }
-
-      static get ReferenceList() {
-        if (!this.DynamicReferenceListClass) {
-          const currentClass = this;
-          this.DynamicReferenceListClass = class {
-            constructor(pool, maxLength = Infinity, data = undefined, classConstructor = currentClass) {
-              this.pool = pool;
-              this.maxLength = maxLength;
-              this.arrayOfIndices = [];
-              this.arrayOfVersions = [];
-              this.classConstructor = classConstructor;
-
-              if (data?.length) {
-                for (const item of data) {
-                  this.create(item);
-                }
-              }
-            }
-
-            get length() {
-              return this.arrayOfIndices.length;
-            }
-
-            set length(v) {
-              this.arrayOfIndices.length = v;
-              this.arrayOfVersions.length = v;
-            }
-
-            push(instance) {
-              if (this.length >= this.maxLength) {
-                throw new Error("Could not add instance to reference list, reference list maxLength of "+this.maxLength+" has been reached");
-              }
-              if (instance.pool !== this.pool) {
-                throw new Error("Could not add instance to reference list, instance does not belong to the same pool as the reference list");
-              }
-              const length = this.length;
-              this.arrayOfIndices[length] = instance.index;
-              this.arrayOfVersions[length] = instance.version;
-              return length;
-            }
-
-            getAtIndex(index, fixDestroyed = true) {
-              if (index < 0 || index >= this.arrayOfIndices.length) {
-                return null;
-              }
-              let poolItem = this.pool.array[this.arrayOfIndices[index]];
-
-              if (fixDestroyed) {
-                while (index < this.arrayOfIndices.length && ((poolItem.version & 1) === 1 || poolItem.version !== this.arrayOfVersions[index])) {
-                  if (index < this.arrayOfIndices.length - 1) {
-                    this.arrayOfIndices[index] = this.arrayOfIndices[this.arrayOfIndices.length - 1];
-                    this.arrayOfVersions[index] = this.arrayOfVersions[this.arrayOfVersions.length - 1];
-                  }
-
-                  this.length -= 1;
-
-                  if (index < this.arrayOfIndices.length) {
-                    poolItem = this.pool.array[this.arrayOfIndices[index]];
-                  } else {
-                    return null;
-                  }
-                }
-              } else if ((poolItem.version & 1) === 1 || poolItem.version !== this.arrayOfVersions[index]) {
-                return null;
-              }
-
-              return poolItem;
-            }
-
-            remove(instance) {
-              for (let i = 0; i < this.arrayOfIndices.length; i++) {
-                if (this.arrayOfIndices[i] === instance.index && this.arrayOfVersions[i] === instance.version) {
-                  if (i < this.arrayOfIndices.length - 1) {
-                    this.arrayOfIndices[i] = this.arrayOfIndices[this.arrayOfIndices.length - 1];
-                    this.arrayOfVersions[i] = this.arrayOfVersions[this.arrayOfVersions.length - 1];
-                  }
-                  this.length -= 1;
-                  return i;
-                }
-              }
-              return -1;
-            }
-
-            removeIndex(index) {
-              if (index < 0 || index >= this.arrayOfIndices.length) {
-                return false;
-              }
-              if (index < this.arrayOfIndices.length - 1) {
-                this.arrayOfIndices[index] = this.arrayOfIndices[this.arrayOfIndices.length - 1];
-                this.arrayOfVersions[index] = this.arrayOfVersions[this.arrayOfVersions.length - 1];
-              }
-              this.length -= 1;
-              return true;
-            }
-
-            clear() {
-              this.length = 0;
-            }
-
-            create(data) {
-              const instance = this.classConstructor.create(data, this.pool);
-              const length = this.length;
-              this.arrayOfIndices[length] = instance.index;
-              this.arrayOfVersions[length] = instance.version;
-              return instance;
-            }
-
-            [Symbol.iterator]() {
-              return iterateOverReferenceList(this, true);
-            }
-
-            get iterateIgnoreEmpty() {
-              const self = this;
-              return {
-                [Symbol.iterator]() {
-                  return iterateOverReferenceList(self, false);
-                }
-              };
-            }
-          }
-        }
-
-        return this.DynamicReferenceListClass;
-      }
-
-      static get Pool() {
-        if (!this.DynamicPoolClass) {
-          const currentClass = this;
-          this.DynamicPoolClass = class {
-            constructor(length = Infinity, classConstructor = currentClass) {
-              this.length = 0;
-              this.maxLength = length;
-              this.array = new Array(isFinite(length) ? length : undefined);
-              this.freeIndices = [1];
-              this.freeIndices.pop();
-              this.classConstructor = classConstructor;
-            }
-
-            [Symbol.iterator]() {
-              return iterateOverPool(this);
-            }
-
-            create(data) {
-              return this.classConstructor.create(data, this);
-            }
-
-            toArray(array, startOffset = 0${hasPoolReferences ? ", skipPoolReferences = false" : ""}) {
-              let offset = startOffset;
-
-              if (this.maxLength > 0 && isFinite(this.length)) {
-                array[offset++] = isFinite(this.maxLength) ? this.maxLength : -1;
-                array[offset++] = this.length + this.freeIndices.length;
-              }
-
-              array[offset++] = this.freeIndices.length;
-              for (let i = 0; i < this.freeIndices.length; i++) {
-                array[offset++] = this.freeIndices[i];
-              }
-
-              ${""}
-
-              for (let i = 0; i < this.length + this.freeIndices.length; i++) {
-                const instance = this.array[i];
-                if (instance === undefined) {
-                  array[offset++] = -1;
-                  continue;
-                }
-                array[offset++] = instance.version;
-                if (instance.version & 1) {${""}
-                  continue;
-                }
-                offset = instance.toArray(array, offset${hasPoolReferences ? ", skipPoolReferences" : ""});
-              }
-
-              return offset;
-            }
-
-            fromArray(arrayOfData, ${hasReferences ? "references," : ""} startOffset = 0, classConstructor = this.classConstructor) {
-              let offset = startOffset;
-
-              this.maxLength = arrayOfData[offset++];
-              if (this.maxLength === -1) {
-                this.maxLength = Infinity;
-              }
-              const usedLength = arrayOfData[offset++];
-              this.length = 0;
-
-              const freeIndicesLength = arrayOfData[offset++];
-              this.freeIndices.length = freeIndicesLength;
-              for (let i = 0; i < freeIndicesLength; i++) {
-                this.freeIndices[i] = arrayOfData[offset++];
-              }
-
-
-              for (let i = 0; i < usedLength; i++) {
-                const version = arrayOfData[offset++];
-
-                if (version & 1) {
-                  if (this.array[i]) {
-                    this.array[i].version = version;
-                  }
-                  continue;
-                }
-
-                this.length++;
-
-                if (this.array[i] === undefined) {
-                  this.array[i] = new classConstructor(undefined, i, this);
-                }
-
-                this.array[i].version = version;
-
-                offset = this.array[i].fromArray(arrayOfData, ${hasReferences ? "references, " : ""} offset);
-              }
-
-              return offset;
-            }
-
-            ${hasReferences ? `
-            fromArrayNoReferences(arrayOfData, startOffset = 0, classConstructor = this.classConstructor) {
-              let offset = startOffset;
-
-              this.maxLength = arrayOfData[offset++];
-              if (this.maxLength === -1) {
-                this.maxLength = Infinity;
-              }
-              const usedLength = arrayOfData[offset++];
-              this.length = 0;
-
-              const freeIndicesLength = arrayOfData[offset++];
-              this.freeIndices.length = freeIndicesLength;
-              for (let i = 0; i < freeIndicesLength; i++) {
-                this.freeIndices[i] = arrayOfData[offset++];
-              }
-
-              for (let i = 0; i < usedLength; i++) {
-                const version = arrayOfData[offset++];
-
-                if (version & 1) {
-                  if (this.array[i]) {
-                    this.array[i].version = version;
-                  }
-                  continue;
-                }
-
-                this.length++;
-
-                if (this.array[i] === undefined) {
-                  this.array[i] = new classConstructor(undefined, i, this);
-                }
-
-                this.array[i].version = version;
-
-                offset = this.array[i].fromArrayNoReferences(arrayOfData, offset);
-              }
-
-              return offset;
-            }
-
-            fromArrayOnlyReferences(arrayOfData, references, startOffset = 0, classConstructor = this.classConstructor) {
-              let offset = startOffset;
-
-              this.maxLength = arrayOfData[offset++];
-              if (this.maxLength === -1) {
-                this.maxLength = Infinity;
-              }
-              const usedLength = arrayOfData[offset++];
-              this.length = 0;
-
-              const freeIndicesLength = arrayOfData[offset++];
-              this.freeIndices.length = freeIndicesLength;
-              for (let i = 0; i < freeIndicesLength; i++) {
-                this.freeIndices[i] = arrayOfData[offset++];
-              }
-
-              for (let i = 0; i < usedLength; i++) {
-                const version = arrayOfData[offset++];
-
-                if (version & 1) {
-                  if (this.array[i]) {
-                    this.array[i].version = version;
-                  }
-                  continue;
-                }
-
-                this.length++;
-
-                if (this.array[i] === undefined) {
-                  this.array[i] = new classConstructor(undefined, i, this);
-                }
-
-                this.array[i].version = version;
-
-                offset = this.array[i].fromArrayOnlyReferences(arrayOfData, references, offset);
-              }
-
-              return offset;
-            }
-            ` : ""}
-          }
-        }
-
-        return this.DynamicPoolClass;
-      }
-    }
-
-    theClass.propertyDefinitionMap = input;
-
-    theClass.create = function(data, pool) {
-      if (pool === undefined) {
-        return new this(data);
-      }
-      if (pool.length >= pool.maxLength) {
-        throw new Error("Could not create instance, pool maxLength of "+pool.maxLength+" has been reached");
-      }
-      if (pool.freeIndices.length) {
-        const index = pool.freeIndices.pop();
-        pool.length++;
-        const instance = pool.array[index];
-        instance.version++; ${""}
-        instance.reset(data);
-        return instance;
-      } else {
-        const instance = new this(data, pool.length, pool);
-        pool.array[pool.length] = instance;
-        pool.length++;
-        return instance;
-      }
-    }
-
-    theClass.createFromArray = function(dataArray, ${hasReferences ? "references," : ""} startOffset = 0, pool) {
-      const instance = this.create(undefined, pool);
-      instance.fromArray(dataArray, ${hasReferences ? "references," : ""} startOffset);
-      return instance;
-    }
-
-    theClass.serializedSize = ${hasDynamicSize ? 0 : totalStaticSize};
-
-    theClass.iterateOverPool = function(pool) {
-      return {
-        [Symbol.iterator]() {
-          return iterateOverPool(pool);
-        },
-      };
-    }
-
-    theClass.Reference = class {
-      constructor(reference) {
-        if (reference && !(reference.version & 1)) {
-          this.reference = reference;
-          this.version = reference.version;
-        } else {
-          this.reference = null;
-          this.version = -1;
-        }
-      }
-    }
-
-    theClass.hasReferences = ${hasReferences};
-
-    return theClass;
-  `;
-  if (options.debug) {
-    console.log("code", code);
-  }
-  return code;
-}
-// @__NO_SIDE_EFFECTS__
-function createClass(props, options = {}) {
-  return new Function("input", /* @__PURE__ */ getClassCode(props, options))(props, options);
-}
+import { createClass, ChildType, NumberType, LazyReferenceListType, BooleanType, LazyReferenceType, ReferenceListType, ReferenceType } from "monomorph";
 const mat3Keys = ["e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8"];
 const mat3Props = {
   e0: 0,
@@ -1283,7 +11,7 @@ const mat3Props = {
   e7: 0,
   e8: 0
 };
-class Mat3 extends (/* @__PURE__ */ createClass(mat3Props)) {
+class Mat3 extends createClass(mat3Props) {
   adjointMatrix(a3) {
     let a00 = a3.e0, a01 = a3.e1, a02 = a3.e2;
     let a10 = a3.e3, a11 = a3.e4, a12 = a3.e5;
@@ -1697,7 +425,7 @@ const vec3Props = {
   y: 0,
   z: 0
 };
-class Vec3 extends (/* @__PURE__ */ createClass(vec3Props)) {
+class Vec3 extends createClass(vec3Props) {
   constructor(data, index, pool) {
     if (Array.isArray(data)) {
       data = {
@@ -2199,7 +927,7 @@ const lineProps = {
   a: Vec3,
   b: Vec3
 };
-class Line extends (/* @__PURE__ */ createClass(lineProps)) {
+class Line extends createClass(lineProps) {
   setFromPointAndDirection(point2, direction2, length) {
     this.a.copy(point2);
     this.b.addScaledToVector(point2, direction2, length);
@@ -2212,7 +940,7 @@ const quatProps = {
   z: 0,
   w: 1
 };
-class Quat extends (/* @__PURE__ */ createClass(quatProps)) {
+class Quat extends createClass(quatProps) {
   constructor(data, index, pool) {
     if (Array.isArray(data)) {
       data = {
@@ -2445,7 +1173,7 @@ const mat4Props = {
   e14: 0,
   e15: 0
 };
-class Mat4 extends (/* @__PURE__ */ createClass(mat4Props)) {
+class Mat4 extends createClass(mat4Props) {
   multiply3x3(out, a3) {
     const x2 = a3.x;
     const y4 = a3.y;
@@ -2909,7 +1637,7 @@ const planeProps = {
   normal: Vec3,
   constant: 0
 };
-class Plane extends (/* @__PURE__ */ createClass(planeProps)) {
+class Plane extends createClass(planeProps) {
   toObject() {
     return {
       normal: this.normal.toObject(),
@@ -2981,7 +1709,7 @@ const segmentProps = {
   pointA: Vec3,
   pointB: Vec3
 };
-class Segment extends (/* @__PURE__ */ createClass(segmentProps)) {
+class Segment extends createClass(segmentProps) {
   computeCenter(out) {
     out.addVectors(this.pointA, this.pointB);
     out.scaleVector(out, 0.5);
@@ -3004,9 +1732,9 @@ const b$1 = /* @__PURE__ */ Vec3.create();
 const aabbProps = {
   min: Vec3,
   max: Vec3,
-  centroid: /* @__PURE__ */ ChildType(Vec3, void 0, true)
+  centroid: ChildType(Vec3, void 0, true)
 };
-class Aabb extends (/* @__PURE__ */ createClass(aabbProps)) {
+class Aabb extends createClass(aabbProps) {
   computeSupport(out, direction2) {
     out.x = direction2.x < 0 ? this.min.x : this.max.x;
     out.y = direction2.y < 0 ? this.min.y : this.max.y;
@@ -3280,20 +2008,20 @@ const aabbHalfExtents = /* @__PURE__ */ Vec3.create();
 const segmentCenter = /* @__PURE__ */ Vec3.create();
 const segmentHalfExtents = /* @__PURE__ */ Vec3.create();
 const triangleProps$1 = {
-  computedBounds: /* @__PURE__ */ ChildType(Aabb, void 0, true),
-  normal: /* @__PURE__ */ ChildType(Vec3, void 0, true),
+  computedBounds: ChildType(Aabb, void 0, true),
+  normal: ChildType(Vec3, void 0, true),
   a: Vec3,
   b: Vec3,
   c: Vec3,
-  subShapeId: /* @__PURE__ */ NumberType(0, true),
-  activeEdges: /* @__PURE__ */ NumberType(0, true)
+  subShapeId: NumberType(0, true),
+  activeEdges: NumberType(0, true)
   // aabb: { struct: Aabb, readOnly: true },
   // activeEdges: { struct: Uint32, optional: true },
   // translation: { struct: Vec3, optional: true },
 };
 const ab$5 = /* @__PURE__ */ Vec3.create();
 const ac$3 = /* @__PURE__ */ Vec3.create();
-let Triangle$1 = class Triangle extends (/* @__PURE__ */ createClass(triangleProps$1)) {
+let Triangle$1 = class Triangle extends createClass(triangleProps$1) {
   // type: ShapeType.triangle = ShapeType.triangle;
   computeNormal(out) {
     ab$5.subtractVectors(this.b, this.a);
@@ -3368,11 +2096,11 @@ let Triangle$1 = class Triangle extends (/* @__PURE__ */ createClass(trianglePro
 };
 const faceProps = {
   numVertices: 0,
-  buffer: /* @__PURE__ */ LazyReferenceListType((() => Vec3))
+  buffer: LazyReferenceListType((() => Vec3))
 };
 const triangle$1 = /* @__PURE__ */ Triangle$1.create();
 const tempVertex = /* @__PURE__ */ Vec3.create();
-class Face extends (/* @__PURE__ */ createClass(faceProps)) {
+class Face extends createClass(faceProps) {
   clear() {
     this.numVertices = 0;
   }
@@ -3470,35 +2198,35 @@ var ConstraintType = /* @__PURE__ */ ((ConstraintType2) => {
 })(ConstraintType || {});
 const baseConstraintProps = {
   // unless we use require here, this file will be imported after it is needed
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  constraintPairNode: /* @__PURE__ */ LazyReferenceType((() => ConstraintPairNode)),
-  referenceFrame: /* @__PURE__ */ NumberType(
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  constraintPairNode: LazyReferenceType((() => ConstraintPairNode)),
+  referenceFrame: NumberType(
     0
     /* local */
   ),
-  isEnabled: /* @__PURE__ */ BooleanType(true)
+  isEnabled: BooleanType(true)
 };
 const localToWorldTransformA$1 = /* @__PURE__ */ Mat4.create();
 const point$1 = /* @__PURE__ */ Vec3.create();
 const contactManifoldProps = {
   // meta data
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
   subShapeIdA: 0,
   subShapeIdB: 0,
-  nextContactManifold: /* @__PURE__ */ LazyReferenceType((() => ContactManifold)),
+  nextContactManifold: LazyReferenceType((() => ContactManifold)),
   // geometric data
   baseTranslation: Vec3,
   firstWorldSpaceNormal: Vec3,
   worldSpaceNormal: Vec3,
   penetrationDepth: 0,
   numContacts: 0,
-  contactPointsA: /* @__PURE__ */ ReferenceListType(Vec3),
-  contactPointsB: /* @__PURE__ */ ReferenceListType(Vec3),
-  lambdas: /* @__PURE__ */ ReferenceListType(Vec3)
+  contactPointsA: ReferenceListType(Vec3),
+  contactPointsB: ReferenceListType(Vec3),
+  lambdas: ReferenceListType(Vec3)
 };
-class ContactManifold extends (/* @__PURE__ */ createClass(contactManifoldProps)) {
+class ContactManifold extends createClass(contactManifoldProps) {
   get maxContacts() {
     return this.contactPointsA.maxLength;
   }
@@ -3619,13 +2347,13 @@ class ContactManifoldPool {
   }
 }
 const contactPairProps = {
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  firstContactManifold: /* @__PURE__ */ ReferenceType(ContactManifold),
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  firstContactManifold: ReferenceType(ContactManifold),
   translationAB: Vec3,
   rotationAB: Quat
 };
-class ContactPair extends (/* @__PURE__ */ createClass(contactPairProps)) {
+class ContactPair extends createClass(contactPairProps) {
   get key() {
     return createContactPairKey(this.bodyA, this.bodyB);
   }
@@ -3652,9 +2380,9 @@ const directionalConstraintProps = {
   softness: 0,
   totalLambda: 0
 };
-class DirectionalConstraint extends (/* @__PURE__ */ createClass(
+class DirectionalConstraint extends createClass(
   directionalConstraintProps
-)) {
+) {
   isSpringActive() {
     return this.softness !== 0;
   }
@@ -3791,9 +2519,9 @@ const contactConstraintProps = {
   localPositionA: Vec3,
   localPositionB: Vec3
 };
-class ContactConstraint extends (/* @__PURE__ */ createClass(
+class ContactConstraint extends createClass(
   contactConstraintProps
-)) {
+) {
   getLambda(out, index) {
     out.x = this.normalConstraint.totalLambda;
     out.y = this.tangentConstraint.totalLambda;
@@ -3816,8 +2544,8 @@ class ContactConstraint extends (/* @__PURE__ */ createClass(
   }
 }
 const manifoldConstraintProps = {
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
   subShapeIdA: 0,
   subShapeIdB: 0,
   friction: 0,
@@ -3827,12 +2555,12 @@ const manifoldConstraintProps = {
   worldSpaceBitangent: Vec3,
   inverseMassA: 0,
   inverseMassB: 0,
-  contactConstraints: /* @__PURE__ */ ReferenceListType(ContactConstraint),
+  contactConstraints: ReferenceListType(ContactConstraint),
   numContacts: 0
 };
-class ManifoldConstraint extends (/* @__PURE__ */ createClass(
+class ManifoldConstraint extends createClass(
   manifoldConstraintProps
-)) {
+) {
   updateTangentDirections() {
     this.worldSpaceTangent.computeNormalizedPerpendicular(this.worldSpaceNormal);
     this.worldSpaceBitangent.crossVectors(this.worldSpaceNormal, this.worldSpaceTangent);
@@ -3939,7 +2667,7 @@ const tempTranslation = /* @__PURE__ */ Vec3.create();
 const tempRotation = /* @__PURE__ */ Quat.create();
 const rotation$2 = /* @__PURE__ */ Mat3.create();
 const inverseMatrix = /* @__PURE__ */ Mat4.create();
-class Isometry extends (/* @__PURE__ */ createClass(isometryProps)) {
+class Isometry extends createClass(isometryProps) {
   fromRotationAndTranslation(rotation2, translation) {
     if (rotation2) {
       tempRotation.copy(rotation2);
@@ -4549,9 +3277,9 @@ const transformedConvexShapeProps = {
   transform: Isometry
 };
 const direction = /* @__PURE__ */ Vec3.create();
-class TransformedConvexShape extends (/* @__PURE__ */ createClass(
+class TransformedConvexShape extends createClass(
   transformedConvexShapeProps
-)) {
+) {
   constructor() {
     super();
     this.object = null;
@@ -4566,9 +3294,9 @@ class TransformedConvexShape extends (/* @__PURE__ */ createClass(
 const convexRadiusObjectProps = {
   radius: 0
 };
-class ConvexRadiusObject extends (/* @__PURE__ */ createClass(
+class ConvexRadiusObject extends createClass(
   convexRadiusObjectProps
-)) {
+) {
   constructor() {
     super();
     this.convexShape = null;
@@ -4618,7 +3346,7 @@ var ShapeType = /* @__PURE__ */ ((ShapeType2) => {
 const sphereNoConvexProps = {
   radius: 0
 };
-class SphereNoConvex extends (/* @__PURE__ */ createClass(sphereNoConvexProps)) {
+class SphereNoConvex extends createClass(sphereNoConvexProps) {
   getConvexRadius() {
     return this.radius;
   }
@@ -4629,7 +3357,7 @@ class SphereNoConvex extends (/* @__PURE__ */ createClass(sphereNoConvexProps))
 const sphereWithConvexProps = {
   radius: 0
 };
-class SphereWithConvex extends (/* @__PURE__ */ createClass(sphereWithConvexProps)) {
+class SphereWithConvex extends createClass(sphereWithConvexProps) {
   getConvexRadius() {
     return 0;
   }
@@ -4643,18 +3371,18 @@ class SphereWithConvex extends (/* @__PURE__ */ createClass(sphereWithConvexProp
   }
 }
 const sphereProps = {
-  computedCenterOfMass: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  computedVolume: /* @__PURE__ */ NumberType(0, true),
-  computedAabb: /* @__PURE__ */ ChildType(Aabb, void 0, true),
+  computedCenterOfMass: ChildType(Vec3, void 0, true),
+  computedVolume: NumberType(0, true),
+  computedAabb: ChildType(Aabb, void 0, true),
   radius: 1,
-  copyForDiff: /* @__PURE__ */ LazyReferenceType((() => Sphere)),
-  sphereNoConvex: /* @__PURE__ */ ChildType(SphereNoConvex, void 0, true),
-  sphereWithConvex: /* @__PURE__ */ ChildType(SphereWithConvex, void 0, true)
+  copyForDiff: LazyReferenceType((() => Sphere)),
+  sphereNoConvex: ChildType(SphereNoConvex, void 0, true),
+  sphereWithConvex: ChildType(SphereWithConvex, void 0, true)
 };
 const afterConstructorCode$a = `
   this.world = null;
 `;
-class Sphere extends (/* @__PURE__ */ createClass(sphereProps, { afterConstructorCode: afterConstructorCode$a })) {
+class Sphere extends createClass(sphereProps, { afterConstructorCode: afterConstructorCode$a }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.sphere;
@@ -4753,9 +3481,9 @@ const defaultConvexRadius = 0.05;
 const boxSupportProps = {
   convexRadius: 0,
   // TODO: cannot used undefined default for this, possibly due to it being used as a deeply nested prop
-  computedAabb: /* @__PURE__ */ ChildType(Aabb, {}, true)
+  computedAabb: ChildType(Aabb, {}, true)
 };
-class BoxSupport extends (/* @__PURE__ */ createClass(boxSupportProps)) {
+class BoxSupport extends createClass(boxSupportProps) {
   computeSupport(out, direction2) {
     this.computedAabb.computeSupport(out, direction2);
   }
@@ -4764,20 +3492,20 @@ class BoxSupport extends (/* @__PURE__ */ createClass(boxSupportProps)) {
   }
 }
 const boxProps = {
-  computedCenterOfMass: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  computedVolume: /* @__PURE__ */ NumberType(0, true),
-  computedAabb: /* @__PURE__ */ ChildType(Aabb, void 0, true),
+  computedCenterOfMass: ChildType(Vec3, void 0, true),
+  computedVolume: NumberType(0, true),
+  computedAabb: ChildType(Aabb, void 0, true),
   convexRadius: 0,
   width: 0,
   height: 0,
   depth: 0,
-  boxSupport: /* @__PURE__ */ ChildType(BoxSupport, void 0, true),
-  copyForDiff: /* @__PURE__ */ LazyReferenceType((() => Box))
+  boxSupport: ChildType(BoxSupport, void 0, true),
+  copyForDiff: LazyReferenceType((() => Box))
 };
 const afterConstructorCode$9 = `
   this.world = null;
 `;
-class Box extends (/* @__PURE__ */ createClass(boxProps, { afterConstructorCode: afterConstructorCode$9 })) {
+class Box extends createClass(boxProps, { afterConstructorCode: afterConstructorCode$9 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.box;
@@ -4895,22 +3623,22 @@ function updateShape$6(shape) {
   updateLocalBounds$6(shape);
 }
 const bodyPairNodeProps = {
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  edgeA: /* @__PURE__ */ LazyReferenceType((() => BodyPairEdge)),
-  edgeB: /* @__PURE__ */ LazyReferenceType((() => BodyPairEdge))
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  edgeA: LazyReferenceType((() => BodyPairEdge)),
+  edgeB: LazyReferenceType((() => BodyPairEdge))
 };
-class BodyPairNode extends (/* @__PURE__ */ createClass(bodyPairNodeProps)) {
+class BodyPairNode extends createClass(bodyPairNodeProps) {
   containsStaticBody() {
     return this.bodyA.type === BodyType.static || this.bodyB.type === BodyType.static;
   }
 }
 const bodyPairEdgeProps = {
-  node: /* @__PURE__ */ LazyReferenceType((() => BodyPairNode)),
-  next: /* @__PURE__ */ LazyReferenceType((() => BodyPairEdge)),
-  prev: /* @__PURE__ */ LazyReferenceType((() => BodyPairEdge))
+  node: LazyReferenceType((() => BodyPairNode)),
+  next: LazyReferenceType((() => BodyPairEdge)),
+  prev: LazyReferenceType((() => BodyPairEdge))
 };
-class BodyPairEdge extends (/* @__PURE__ */ createClass(bodyPairEdgeProps)) {
+class BodyPairEdge extends createClass(bodyPairEdgeProps) {
 }
 class BodyPairsModule {
   constructor(bodyPool, nodesPool, edgesPool) {
@@ -5154,7 +3882,7 @@ const rayProps = {
   direction: Vec3,
   length: 0
 };
-class Ray extends (/* @__PURE__ */ createClass(rayProps)) {
+class Ray extends createClass(rayProps) {
   intersectsAabb(aabb) {
     return aabb.intersectsRay(this);
   }
@@ -5270,14 +3998,14 @@ const halfExtents$2 = /* @__PURE__ */ Vec3.create();
 const nodeBounds$1 = /* @__PURE__ */ Aabb.create();
 const bodyBounds$1 = /* @__PURE__ */ Aabb.create();
 const bvhNodeProps$1 = {
-  parent: /* @__PURE__ */ LazyReferenceType((() => BvhNode)),
-  left: /* @__PURE__ */ LazyReferenceType((() => BvhNode)),
-  right: /* @__PURE__ */ LazyReferenceType((() => BvhNode)),
-  computedBounds: /* @__PURE__ */ ChildType(Aabb, void 0, true),
+  parent: LazyReferenceType((() => BvhNode)),
+  left: LazyReferenceType((() => BvhNode)),
+  right: LazyReferenceType((() => BvhNode)),
+  computedBounds: ChildType(Aabb, void 0, true),
   height: 0,
-  objects: /* @__PURE__ */ LazyReferenceListType((() => Body))
+  objects: LazyReferenceListType((() => Body))
 };
-class BvhNode extends (/* @__PURE__ */ createClass(bvhNodeProps$1)) {
+class BvhNode extends createClass(bvhNodeProps$1) {
   // objects: Body[] = [];
   isLeaf() {
     return this.left === null && this.right === null;
@@ -5793,7 +4521,7 @@ const basicTransformProps = {
   rotation: Quat,
   scale: 1
 };
-class BasicTransform extends (/* @__PURE__ */ createClass(basicTransformProps)) {
+class BasicTransform extends createClass(basicTransformProps) {
   equals(other, tolerance = 1e-6) {
     return this.position.equals(other.position, tolerance) && this.rotation.equals(other.rotation, tolerance) && Math.abs(this.scale - other.scale) < tolerance;
   }
@@ -5801,7 +4529,7 @@ class BasicTransform extends (/* @__PURE__ */ createClass(basicTransformProps))
 const numberValueProps = {
   value: 0
 };
-class NumberValue extends (/* @__PURE__ */ createClass(numberValueProps)) {
+class NumberValue extends createClass(numberValueProps) {
   toObject() {
     return {
       value: this.value
@@ -5868,7 +4596,7 @@ const convexHullPointProps = {
   numFaces: 0,
   faces: Vec3
 };
-class ConvexHullPoint extends (/* @__PURE__ */ createClass(convexHullPointProps)) {
+class ConvexHullPoint extends createClass(convexHullPointProps) {
   toObject() {
     return {
       position: this.position.toObject(),
@@ -5881,7 +4609,7 @@ const convexHullFaceProps = {
   firstVertex: 0,
   numVertices: 0
 };
-class ConvexHullFace extends (/* @__PURE__ */ createClass(convexHullFaceProps)) {
+class ConvexHullFace extends createClass(convexHullFaceProps) {
   toObject() {
     return {
       firstVertex: this.firstVertex,
@@ -5890,24 +4618,24 @@ class ConvexHullFace extends (/* @__PURE__ */ createClass(convexHullFaceProps))
   }
 }
 const convexHullProps = {
-  computedCenterOfMass: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  computedVolume: /* @__PURE__ */ NumberType(0, true),
-  computedAabb: /* @__PURE__ */ ChildType(Aabb, void 0, true),
+  computedCenterOfMass: ChildType(Vec3, void 0, true),
+  computedVolume: NumberType(0, true),
+  computedAabb: ChildType(Aabb, void 0, true),
   convexRadius: 0,
-  innerRadius: /* @__PURE__ */ NumberType(0, true),
-  inertia: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  points: /* @__PURE__ */ ReferenceListType(ConvexHullPoint),
+  innerRadius: NumberType(0, true),
+  inertia: ChildType(Mat3, void 0, true),
+  points: ReferenceListType(ConvexHullPoint),
   // { array: Float64Array(b), itemMaxCount: b / 7, itemSize: 7 } [ConvexHullPoint], points on the convex hull surface
-  faces: /* @__PURE__ */ ReferenceListType(ConvexHullFace),
+  faces: ReferenceListType(ConvexHullFace),
   // { array: Float64Array(c), itemMaxCount: c / 2, itemSize: 2 } [ConvexHullFace], faces of the convex hull surface
-  planes: /* @__PURE__ */ ReferenceListType(Plane),
+  planes: ReferenceListType(Plane),
   // { array: Float64Array(d), itemMaxCount: d / 4, itemSize: 4 } [Plane], planes of the convex hull surface
-  vertexIdx: /* @__PURE__ */ ReferenceListType(NumberValue),
+  vertexIdx: ReferenceListType(NumberValue),
   // { array: Float64Array(e), itemMaxCount: e, itemSize: 1 } [Uint32], vertex indices for each of the faces
-  shapeNoConvexPoints: /* @__PURE__ */ ReferenceListType(Vec3),
+  shapeNoConvexPoints: ReferenceListType(Vec3),
   // { array: Float64Array(f), itemMaxCount: f / 3, itemSize: 3 } [Vec3], transformed points used by ConvexHullNoConvex
-  translation: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 0, z: 0 }),
-  copyForDiff: /* @__PURE__ */ LazyReferenceType((() => ConvexHull))
+  translation: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
+  copyForDiff: LazyReferenceType((() => ConvexHull))
 };
 const afterConstructorCode$8 = `
 this.world = null;
@@ -5915,7 +4643,7 @@ this.shapeNoConvex = null;
 this.shapeWithConvex = null;
 this.type = ${ShapeType.convexHull};
 `;
-class ConvexHull extends (/* @__PURE__ */ createClass(convexHullProps, { afterConstructorCode: afterConstructorCode$8 })) {
+class ConvexHull extends createClass(convexHullProps, { afterConstructorCode: afterConstructorCode$8 }) {
   computeSupportShape(inMode, inScale) {
     if (this.convexRadius === 0) {
       this.shapeWithConvex.shape = this;
@@ -6105,9 +4833,9 @@ const cylinderSupportShapeProps = {
   radius: 0,
   convexRadius: 0
 };
-class CylinderSupportShape extends (/* @__PURE__ */ createClass(
+class CylinderSupportShape extends createClass(
   cylinderSupportShapeProps
-)) {
+) {
   getConvexRadius() {
     return this.convexRadius;
   }
@@ -6131,20 +4859,20 @@ class CylinderSupportShape extends (/* @__PURE__ */ createClass(
   }
 }
 const cylinderProps = {
-  computedCenterOfMass: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  computedVolume: /* @__PURE__ */ NumberType(0, true),
-  computedAabb: /* @__PURE__ */ ChildType(Aabb, void 0, true),
+  computedCenterOfMass: ChildType(Vec3, void 0, true),
+  computedVolume: NumberType(0, true),
+  computedAabb: ChildType(Aabb, void 0, true),
   radius: 0,
   halfHeight: 0,
   convexRadius: 0,
-  translation: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  supportShape: /* @__PURE__ */ ChildType(CylinderSupportShape, void 0, true),
-  copyForDiff: /* @__PURE__ */ LazyReferenceType((() => Cylinder))
+  translation: ChildType(Vec3, void 0, true),
+  supportShape: ChildType(CylinderSupportShape, void 0, true),
+  copyForDiff: LazyReferenceType((() => Cylinder))
 };
 const afterConstructorCode$7 = `
   this.world = null;
 `;
-class Cylinder extends (/* @__PURE__ */ createClass(cylinderProps, { afterConstructorCode: afterConstructorCode$7 })) {
+class Cylinder extends createClass(cylinderProps, { afterConstructorCode: afterConstructorCode$7 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.cylinder;
@@ -6304,7 +5032,7 @@ const capsuleNoConvexProps = {
   halfHeightOfCylinder: Vec3,
   convexRadius: 0
 };
-class CapsuleNoConvex extends (/* @__PURE__ */ createClass(capsuleNoConvexProps)) {
+class CapsuleNoConvex extends createClass(capsuleNoConvexProps) {
   computeSupport(out, direction2) {
     if (direction2.y > 0) {
       out.copy(this.halfHeightOfCylinder);
@@ -6323,9 +5051,9 @@ const capsuleWithConvexProps = {
   halfHeightOfCylinder: Vec3,
   radius: 0
 };
-class CapsuleWithConvex extends (/* @__PURE__ */ createClass(
+class CapsuleWithConvex extends createClass(
   capsuleWithConvexProps
-)) {
+) {
   computeSupport(out, direction2) {
     const len = direction2.length();
     if (len > 0) {
@@ -6347,19 +5075,19 @@ class CapsuleWithConvex extends (/* @__PURE__ */ createClass(
   }
 }
 const capsuleProps = {
-  computedCenterOfMass: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  computedVolume: /* @__PURE__ */ NumberType(0, true),
-  computedAabb: /* @__PURE__ */ ChildType(Aabb, void 0, true),
+  computedCenterOfMass: ChildType(Vec3, void 0, true),
+  computedVolume: NumberType(0, true),
+  computedAabb: ChildType(Aabb, void 0, true),
   radius: 0,
   height: 0,
-  copyForDiff: /* @__PURE__ */ LazyReferenceType((() => Capsule)),
-  capsuleNoConvex: /* @__PURE__ */ ChildType(CapsuleNoConvex, void 0, true),
-  capsuleWithConvex: /* @__PURE__ */ ChildType(CapsuleWithConvex, void 0, true)
+  copyForDiff: LazyReferenceType((() => Capsule)),
+  capsuleNoConvex: ChildType(CapsuleNoConvex, void 0, true),
+  capsuleWithConvex: ChildType(CapsuleWithConvex, void 0, true)
 };
 const afterConstructorCode$6 = `
   this.world = null;
 `;
-class Capsule extends (/* @__PURE__ */ createClass(capsuleProps, { afterConstructorCode: afterConstructorCode$6 })) {
+class Capsule extends createClass(capsuleProps, { afterConstructorCode: afterConstructorCode$6 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.capsule;
@@ -6505,25 +5233,25 @@ function updateShape$3(shape) {
   updateLocalBounds$3(shape);
 }
 const transformedShapeProps = {
-  shapeType: /* @__PURE__ */ NumberType(ShapeType.box),
+  shapeType: NumberType(ShapeType.box),
   // we need to do "as 'shape' ..." otherwise they are just 'string' and not the actual specific keys
-  ["shape" + ShapeType.box]: /* @__PURE__ */ ReferenceType(Box, void 0, true),
-  ["shape" + ShapeType.capsule]: /* @__PURE__ */ ReferenceType(Capsule, void 0, true),
+  ["shape" + ShapeType.box]: ReferenceType(Box, void 0, true),
+  ["shape" + ShapeType.capsule]: ReferenceType(Capsule, void 0, true),
   // compoundShape not supported
-  ["shape" + ShapeType.convexHull]: /* @__PURE__ */ ReferenceType(ConvexHull, void 0, true),
-  ["shape" + ShapeType.cylinder]: /* @__PURE__ */ ReferenceType(Cylinder, void 0, true),
+  ["shape" + ShapeType.convexHull]: ReferenceType(ConvexHull, void 0, true),
+  ["shape" + ShapeType.cylinder]: ReferenceType(Cylinder, void 0, true),
   // heightMap not supported
-  ["shape" + ShapeType.sphere]: /* @__PURE__ */ ReferenceType(Sphere, void 0, true),
+  ["shape" + ShapeType.sphere]: ReferenceType(Sphere, void 0, true),
   // triangleMesh not supported
   transform: BasicTransform
 };
 const afterConstructorCode$5 = `
   this.world = null;
 `;
-class TransformedShape extends (/* @__PURE__ */ createClass(
+class TransformedShape extends createClass(
   transformedShapeProps,
   { afterConstructorCode: afterConstructorCode$5 }
-)) {
+) {
   get shape() {
     return this["shape" + this.shapeType];
   }
@@ -6546,17 +5274,17 @@ const transformSubshapeToCompound = /* @__PURE__ */ Isometry.create();
 const subShapeDirection = /* @__PURE__ */ Vec3.create();
 const subShapeToWorld = /* @__PURE__ */ Isometry.create();
 const compoundShapeProps = {
-  computedCenterOfMass: /* @__PURE__ */ ChildType(Vec3, {}, true),
-  computedVolume: /* @__PURE__ */ NumberType(0, true),
-  computedAabb: /* @__PURE__ */ ChildType(Aabb, {}, true),
-  copyForDiff: /* @__PURE__ */ LazyReferenceType((() => CompoundShape)),
-  shapes: /* @__PURE__ */ ReferenceListType(TransformedShape)
+  computedCenterOfMass: ChildType(Vec3, {}, true),
+  computedVolume: NumberType(0, true),
+  computedAabb: ChildType(Aabb, {}, true),
+  copyForDiff: LazyReferenceType((() => CompoundShape)),
+  shapes: ReferenceListType(TransformedShape)
 };
 const afterConstructorCode$4 = `
   this.world = null;
 `;
 const tempTransform = /* @__PURE__ */ BasicTransform.create();
-class CompoundShape extends (/* @__PURE__ */ createClass(compoundShapeProps, { afterConstructorCode: afterConstructorCode$4 })) {
+class CompoundShape extends createClass(compoundShapeProps, { afterConstructorCode: afterConstructorCode$4 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.compoundShape;
@@ -6761,10 +5489,10 @@ const scale$1 = /* @__PURE__ */ Vec3.create();
 const blockAabb = /* @__PURE__ */ Aabb.create();
 const normal$1 = /* @__PURE__ */ Vec3.create();
 const heightMapProps = {
-  computedCenterOfMass: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  computedVolume: /* @__PURE__ */ NumberType(0, true),
-  computedAabb: /* @__PURE__ */ ChildType(Aabb, {}, true),
-  copyForDiff: /* @__PURE__ */ LazyReferenceType((() => HeightMap)),
+  computedCenterOfMass: ChildType(Vec3, void 0, true),
+  computedVolume: NumberType(0, true),
+  computedAabb: ChildType(Aabb, {}, true),
+  copyForDiff: LazyReferenceType((() => HeightMap)),
   subdivisionsCount: 0,
   scale: Vec3,
   positionOffset: Vec3
@@ -6784,7 +5512,7 @@ this.activeEdges = [];
 this.stack = [];
 this.children = [0, 0, 0, 0];
 `;
-class HeightMap extends (/* @__PURE__ */ createClass(heightMapProps, { afterConstructorCode: afterConstructorCode$3 })) {
+class HeightMap extends createClass(heightMapProps, { afterConstructorCode: afterConstructorCode$3 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.heightMap;
@@ -7016,14 +5744,14 @@ function updateShape$1(shape) {
   updateLocalBounds$1(shape);
 }
 const bvhNodeProps = {
-  parent: /* @__PURE__ */ LazyReferenceType((() => TriangleMeshBvhNode)),
-  left: /* @__PURE__ */ LazyReferenceType((() => TriangleMeshBvhNode)),
-  right: /* @__PURE__ */ LazyReferenceType((() => TriangleMeshBvhNode)),
-  computedBounds: /* @__PURE__ */ ChildType(Aabb, void 0, true),
-  depth: /* @__PURE__ */ NumberType(0, true),
-  objects: /* @__PURE__ */ LazyReferenceListType((() => Triangle$1))
+  parent: LazyReferenceType((() => TriangleMeshBvhNode)),
+  left: LazyReferenceType((() => TriangleMeshBvhNode)),
+  right: LazyReferenceType((() => TriangleMeshBvhNode)),
+  computedBounds: ChildType(Aabb, void 0, true),
+  depth: NumberType(0, true),
+  objects: LazyReferenceListType((() => Triangle$1))
 };
-class TriangleMeshBvhNode extends (/* @__PURE__ */ createClass(bvhNodeProps)) {
+class TriangleMeshBvhNode extends createClass(bvhNodeProps) {
   /**
    * if bvh node is an internal node, this will be an empty list
    * if bvh node is a leaf node, this will contain refs to the objects in the leaf
@@ -7079,11 +5807,11 @@ function splitObjects(objects) {
   return [leftObjects, rightObjects];
 }
 const triangleMeshBvhTreeProps = {
-  nodes: /* @__PURE__ */ ReferenceListType(TriangleMeshBvhNode)
+  nodes: ReferenceListType(TriangleMeshBvhNode)
 };
-class TriangleMeshBvhTree extends (/* @__PURE__ */ createClass(
+class TriangleMeshBvhTree extends createClass(
   triangleMeshBvhTreeProps
-)) {
+) {
   constructor() {
     super(...arguments);
     this.intersectStack = [];
@@ -7279,21 +6007,21 @@ const nodeBounds = /* @__PURE__ */ Aabb.create();
 const bodyBounds = /* @__PURE__ */ Aabb.create();
 const isometry$2 = /* @__PURE__ */ Isometry.create();
 const triangleMeshProps = {
-  computedCenterOfMass: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  computedVolume: /* @__PURE__ */ NumberType(0, true),
-  computedAabb: /* @__PURE__ */ ChildType(Aabb, void 0, true),
+  computedCenterOfMass: ChildType(Vec3, void 0, true),
+  computedVolume: NumberType(0, true),
+  computedAabb: ChildType(Aabb, void 0, true),
   translation: Vec3,
-  inertia: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  vertexPositions: /* @__PURE__ */ ReferenceListType(Vec3),
-  faceIndices: /* @__PURE__ */ ReferenceListType(Vec3),
-  triangles: /* @__PURE__ */ ReferenceListType(Triangle$1),
-  copyForDiff: /* @__PURE__ */ LazyReferenceType((() => TriangleMesh)),
-  bvh: /* @__PURE__ */ LazyReferenceType((() => TriangleMeshBvhTree))
+  inertia: ChildType(Mat3, void 0, true),
+  vertexPositions: ReferenceListType(Vec3),
+  faceIndices: ReferenceListType(Vec3),
+  triangles: ReferenceListType(Triangle$1),
+  copyForDiff: LazyReferenceType((() => TriangleMesh)),
+  bvh: LazyReferenceType((() => TriangleMeshBvhTree))
 };
 const afterConstructorCode$2 = `
   this.world = null;
 `;
-class TriangleMesh extends (/* @__PURE__ */ createClass(triangleMeshProps, { afterConstructorCode: afterConstructorCode$2 })) {
+class TriangleMesh extends createClass(triangleMeshProps, { afterConstructorCode: afterConstructorCode$2 }) {
   constructor() {
     super(...arguments);
     this.type = ShapeType.triangleMesh;
@@ -7395,26 +6123,26 @@ const constraintOptionsProps = {
    */
   strength: 1
 };
-class ConstraintOptions extends (/* @__PURE__ */ createClass(
+class ConstraintOptions extends createClass(
   constraintOptionsProps
-)) {
+) {
 }
 const pointConstraintComponentProps = {
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  options: /* @__PURE__ */ ChildType(ConstraintOptions, {
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  options: ChildType(ConstraintOptions, {
     positionBaumgarte: 0.8,
     velocityBaumgarte: 1,
     strength: 1
   }),
-  momentArmA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  momentArmB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  effectiveMass: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  effectiveInverseInertiaA: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  effectiveInverseInertiaB: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  totalLambda: /* @__PURE__ */ ChildType(Vec3, void 0, true)
+  momentArmA: ChildType(Vec3, void 0, true),
+  momentArmB: ChildType(Vec3, void 0, true),
+  effectiveMass: ChildType(Mat3, void 0, true),
+  effectiveInverseInertiaA: ChildType(Mat3, void 0, true),
+  effectiveInverseInertiaB: ChildType(Mat3, void 0, true),
+  totalLambda: ChildType(Vec3, void 0, true)
 };
-class PointConstraintComponent extends (/* @__PURE__ */ createClass(pointConstraintComponentProps)) {
+class PointConstraintComponent extends createClass(pointConstraintComponentProps) {
   deactivate() {
     this.effectiveMass.zero();
     this.totalLambda.zero();
@@ -7527,11 +6255,11 @@ const pointConstraintProps = {
   ...baseConstraintProps,
   positionA: Vec3,
   positionB: Vec3,
-  localPositionA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localPositionB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
+  localPositionA: ChildType(Vec3, void 0, true),
+  localPositionB: ChildType(Vec3, void 0, true),
   translationComponent: PointConstraintComponent
 };
-class PointConstraint extends (/* @__PURE__ */ createClass(pointConstraintProps)) {
+class PointConstraint extends createClass(pointConstraintProps) {
   constructor() {
     super(...arguments);
     this.type = ConstraintType.pointConstraint;
@@ -7601,21 +6329,21 @@ PointConstraint.create = function() {
   return constraint;
 };
 const rotationEulerComponentProps = {
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  options: /* @__PURE__ */ ChildType(ConstraintOptions, {
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  options: ChildType(ConstraintOptions, {
     positionBaumgarte: 0.8,
     velocityBaumgarte: 1,
     strength: 1
   }),
-  mInvI1: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  mInvI2: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  effectiveMassRotationComponent: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  totalLambdaRotationComponent: /* @__PURE__ */ ChildType(Vec3, void 0, true)
+  mInvI1: ChildType(Mat3, void 0, true),
+  mInvI2: ChildType(Mat3, void 0, true),
+  effectiveMassRotationComponent: ChildType(Mat3, void 0, true),
+  totalLambdaRotationComponent: ChildType(Vec3, void 0, true)
 };
-class RotationEulerComponent extends (/* @__PURE__ */ createClass(
+class RotationEulerComponent extends createClass(
   rotationEulerComponentProps
-)) {
+) {
   deactivate() {
     this.effectiveMassRotationComponent.zero();
     this.totalLambdaRotationComponent.zero();
@@ -7709,25 +6437,25 @@ const transformWorldToLocalB$1 = /* @__PURE__ */ Mat4.create();
 const inverseRotationB = /* @__PURE__ */ Quat.create();
 const fixedConstraintProps = {
   ...baseConstraintProps,
-  positionA: /* @__PURE__ */ ChildType(Vec3),
-  positionB: /* @__PURE__ */ ChildType(Vec3),
-  axisXA: /* @__PURE__ */ ChildType(Vec3, { x: 1, y: 0, z: 0 }),
-  axisXB: /* @__PURE__ */ ChildType(Vec3, { x: 1, y: 0, z: 0 }),
-  axisYA: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 1, z: 0 }),
-  axisYB: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 1, z: 0 }),
-  localPositionA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localPositionB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localAxisXA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localAxisXB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localAxisYA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localAxisYB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localAxisZA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localAxisZB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  inverseInitialRotationAToB: /* @__PURE__ */ ChildType(Quat, void 0, true),
+  positionA: ChildType(Vec3),
+  positionB: ChildType(Vec3),
+  axisXA: ChildType(Vec3, { x: 1, y: 0, z: 0 }),
+  axisXB: ChildType(Vec3, { x: 1, y: 0, z: 0 }),
+  axisYA: ChildType(Vec3, { x: 0, y: 1, z: 0 }),
+  axisYB: ChildType(Vec3, { x: 0, y: 1, z: 0 }),
+  localPositionA: ChildType(Vec3, void 0, true),
+  localPositionB: ChildType(Vec3, void 0, true),
+  localAxisXA: ChildType(Vec3, void 0, true),
+  localAxisXB: ChildType(Vec3, void 0, true),
+  localAxisYA: ChildType(Vec3, void 0, true),
+  localAxisYB: ChildType(Vec3, void 0, true),
+  localAxisZA: ChildType(Vec3, void 0, true),
+  localAxisZB: ChildType(Vec3, void 0, true),
+  inverseInitialRotationAToB: ChildType(Quat, void 0, true),
   translationComponent: PointConstraintComponent,
   rotationComponent: RotationEulerComponent
 };
-class FixedConstraint extends (/* @__PURE__ */ createClass(fixedConstraintProps)) {
+class FixedConstraint extends createClass(fixedConstraintProps) {
   constructor() {
     super(...arguments);
     this.type = ConstraintType.fixedConstraint;
@@ -7861,7 +6589,7 @@ var SpringMode = /* @__PURE__ */ ((SpringMode2) => {
   return SpringMode2;
 })(SpringMode || {});
 const springProps = {
-  mode: /* @__PURE__ */ NumberType(
+  mode: NumberType(
     0
     /* UseFrequency */
   ),
@@ -7869,7 +6597,7 @@ const springProps = {
   frequency: 0,
   stiffness: 0
 };
-class Spring extends (/* @__PURE__ */ createClass(springProps)) {
+class Spring extends createClass(springProps) {
   hasStiffness() {
     return this.frequency > 0;
   }
@@ -7881,7 +6609,7 @@ const springComponentProps = {
   bias: 0,
   softness: 0
 };
-class SpringComponent extends (/* @__PURE__ */ createClass(springComponentProps)) {
+class SpringComponent extends createClass(springComponentProps) {
   getBias(lambda2) {
     return this.softness * lambda2 + this.bias;
   }
@@ -7924,22 +6652,22 @@ const inverseInertiaB$1 = /* @__PURE__ */ Mat3.create();
 const linearImpulse = /* @__PURE__ */ Vec3.create();
 const angularImpulse = /* @__PURE__ */ Vec3.create();
 const axisComponentProps = {
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  options: /* @__PURE__ */ ChildType(ConstraintOptions, {
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  options: ChildType(ConstraintOptions, {
     positionBaumgarte: 0.8,
     velocityBaumgarte: 1,
     strength: 1
   }),
-  mR1PlusUxAxis: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 0, z: 0 }),
-  mR2xAxis: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 0, z: 0 }),
-  mInvI1_R1PlusUxAxis: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 0, z: 0 }),
-  mInvI2_R2xAxis: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 0, z: 0 }),
+  mR1PlusUxAxis: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
+  mR2xAxis: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
+  mInvI1_R1PlusUxAxis: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
+  mInvI2_R2xAxis: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
   effectiveMass: 0,
   totalLambda: 0,
   springComponent: SpringComponent
 };
-class AxisComponent extends (/* @__PURE__ */ createClass(axisComponentProps)) {
+class AxisComponent extends createClass(axisComponentProps) {
   deactivate() {
     this.effectiveMass = 0;
     this.totalLambda = 0;
@@ -8096,21 +6824,21 @@ const armB = /* @__PURE__ */ Vec3.create();
 const vectorAB$5 = /* @__PURE__ */ Vec3.create();
 const distanceConstraintProps = {
   ...baseConstraintProps,
-  positionA: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 0, z: 0 }),
-  positionB: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 0, z: 0 }),
+  positionA: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
+  positionB: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
   minDistance: -1,
   maxDistance: -1,
   spring: Spring,
   axisComponent: AxisComponent,
-  localPositionA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localPositionB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  worldPositionA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  worldPositionB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  worldNormal: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  minLambda: /* @__PURE__ */ NumberType(0, true),
-  maxLambda: /* @__PURE__ */ NumberType(0, true)
+  localPositionA: ChildType(Vec3, void 0, true),
+  localPositionB: ChildType(Vec3, void 0, true),
+  worldPositionA: ChildType(Vec3, void 0, true),
+  worldPositionB: ChildType(Vec3, void 0, true),
+  worldNormal: ChildType(Vec3, void 0, true),
+  minLambda: NumberType(0, true),
+  maxLambda: NumberType(0, true)
 };
-class DistanceConstraint extends (/* @__PURE__ */ createClass(distanceConstraintProps)) {
+class DistanceConstraint extends createClass(distanceConstraintProps) {
   constructor() {
     super(...arguments);
     this.type = ConstraintType.distanceConstraint;
@@ -8258,17 +6986,17 @@ var MotorMode = /* @__PURE__ */ ((MotorMode2) => {
   return MotorMode2;
 })(MotorMode || {});
 const motorProps = {
-  spring: /* @__PURE__ */ ChildType(Spring, { mode: SpringMode.UseFrequency, damping: 1, frequency: 2, stiffness: 2 }),
-  minForce: /* @__PURE__ */ NumberType(-Infinity),
-  maxForce: /* @__PURE__ */ NumberType(Infinity),
-  minTorque: /* @__PURE__ */ NumberType(-Infinity),
-  maxTorque: /* @__PURE__ */ NumberType(Infinity),
-  mode: /* @__PURE__ */ NumberType(
+  spring: ChildType(Spring, { mode: SpringMode.UseFrequency, damping: 1, frequency: 2, stiffness: 2 }),
+  minForce: NumberType(-Infinity),
+  maxForce: NumberType(Infinity),
+  minTorque: NumberType(-Infinity),
+  maxTorque: NumberType(Infinity),
+  mode: NumberType(
     0
     /* Off */
   )
 };
-class Motor extends (/* @__PURE__ */ createClass(motorProps)) {
+class Motor extends createClass(motorProps) {
   isValid() {
     return this.spring.isValid() && this.minForce <= this.maxForce && this.minTorque <= this.maxTorque;
   }
@@ -8281,26 +7009,26 @@ const summedInverseInertia = /* @__PURE__ */ Mat3.create();
 const massBA = /* @__PURE__ */ Vec3.create();
 const massCA = /* @__PURE__ */ Vec3.create();
 const hingeComponentProps = {
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  options: /* @__PURE__ */ ChildType(ConstraintOptions, {
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  options: ChildType(ConstraintOptions, {
     positionBaumgarte: 0.8,
     velocityBaumgarte: 1,
     strength: 1
   }),
-  axisA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  axisB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  axisC: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  crossBA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  crossCA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  effectiveMass00: /* @__PURE__ */ NumberType(0, true),
-  effectiveMass01: /* @__PURE__ */ NumberType(0, true),
-  effectiveMass10: /* @__PURE__ */ NumberType(0, true),
-  effectiveMass11: /* @__PURE__ */ NumberType(0, true),
-  inverseInertiaA: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  inverseInertiaB: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  totalLambdaA: /* @__PURE__ */ NumberType(0, true),
-  totalLambdaB: /* @__PURE__ */ NumberType(0, true)
+  axisA: ChildType(Vec3, void 0, true),
+  axisB: ChildType(Vec3, void 0, true),
+  axisC: ChildType(Vec3, void 0, true),
+  crossBA: ChildType(Vec3, void 0, true),
+  crossCA: ChildType(Vec3, void 0, true),
+  effectiveMass00: NumberType(0, true),
+  effectiveMass01: NumberType(0, true),
+  effectiveMass10: NumberType(0, true),
+  effectiveMass11: NumberType(0, true),
+  inverseInertiaA: ChildType(Mat3, void 0, true),
+  inverseInertiaB: ChildType(Mat3, void 0, true),
+  totalLambdaA: NumberType(0, true),
+  totalLambdaB: NumberType(0, true)
 };
 function getOrthogonalVector(out, a3) {
   if (Math.abs(a3.x) > Math.abs(a3.y)) {
@@ -8309,7 +7037,7 @@ function getOrthogonalVector(out, a3) {
     out.fromArray([0, a3.z, -a3.y]);
   }
 }
-class HingeComponent extends (/* @__PURE__ */ createClass(hingeComponentProps)) {
+class HingeComponent extends createClass(hingeComponentProps) {
   deactivate() {
     this.effectiveMass00 = 0;
     this.effectiveMass01 = 0;
@@ -8428,20 +7156,20 @@ const spinBA = /* @__PURE__ */ Vec3.create();
 const deltaSpin$1 = /* @__PURE__ */ Vec3.create();
 const inverseEffectiveMass = /* @__PURE__ */ Vec3.create();
 const angleComponentProps = {
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  options: /* @__PURE__ */ ChildType(ConstraintOptions, {
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  options: ChildType(ConstraintOptions, {
     positionBaumgarte: 0.8,
     velocityBaumgarte: 1,
     strength: 1
   }),
-  springConstraintPart: /* @__PURE__ */ ChildType(SpringComponent, void 0, true),
-  effectiveMass: /* @__PURE__ */ NumberType(0, true),
-  effectiveInverseInertiaA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  effectiveInverseInertiaB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  totalLambda: /* @__PURE__ */ NumberType(0, true)
+  springConstraintPart: ChildType(SpringComponent, void 0, true),
+  effectiveMass: NumberType(0, true),
+  effectiveInverseInertiaA: ChildType(Vec3, void 0, true),
+  effectiveInverseInertiaB: ChildType(Vec3, void 0, true),
+  totalLambda: NumberType(0, true)
 };
-class AngleComponent extends (/* @__PURE__ */ createClass(angleComponentProps)) {
+class AngleComponent extends createClass(angleComponentProps) {
   deactivate() {
     this.effectiveMass = 0;
     this.totalLambda = 0;
@@ -8597,37 +7325,37 @@ const transformLocalToWorld = /* @__PURE__ */ Mat4.create();
 const hingeConstraintProps = {
   ...baseConstraintProps,
   // init data
-  pointA: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 0, z: 0 }),
-  pointB: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 0, z: 0 }),
-  hingeA: /* @__PURE__ */ ChildType(Vec3, { x: 1, y: 0, z: 0 }),
-  hingeB: /* @__PURE__ */ ChildType(Vec3, { x: 1, y: 0, z: 0 }),
-  normalA: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 1, z: 0 }),
-  normalB: /* @__PURE__ */ ChildType(Vec3, { x: 0, y: 1, z: 0 }),
+  pointA: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
+  pointB: ChildType(Vec3, { x: 0, y: 0, z: 0 }),
+  hingeA: ChildType(Vec3, { x: 1, y: 0, z: 0 }),
+  hingeB: ChildType(Vec3, { x: 1, y: 0, z: 0 }),
+  normalA: ChildType(Vec3, { x: 0, y: 1, z: 0 }),
+  normalB: ChildType(Vec3, { x: 0, y: 1, z: 0 }),
   spring: Spring,
   motor: Motor,
-  minHingeAngle: /* @__PURE__ */ NumberType(-Math.PI),
-  maxHingeAngle: /* @__PURE__ */ NumberType(+Math.PI),
+  minHingeAngle: NumberType(-Math.PI),
+  maxHingeAngle: NumberType(+Math.PI),
   maxFrictionTorque: 0,
   // constraint data
-  localPointA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localPointB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localHingeA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localHingeB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localNormalA: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  localNormalB: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  inverseInitialRotationAB: /* @__PURE__ */ ChildType(Quat, void 0, true),
-  areLimitsEnabled: /* @__PURE__ */ BooleanType(false, true),
+  localPointA: ChildType(Vec3, void 0, true),
+  localPointB: ChildType(Vec3, void 0, true),
+  localHingeA: ChildType(Vec3, void 0, true),
+  localHingeB: ChildType(Vec3, void 0, true),
+  localNormalA: ChildType(Vec3, void 0, true),
+  localNormalB: ChildType(Vec3, void 0, true),
+  inverseInitialRotationAB: ChildType(Quat, void 0, true),
+  areLimitsEnabled: BooleanType(false, true),
   targetAngularSpeed: 0,
   targetAngle: 0,
-  hingeAngle: /* @__PURE__ */ NumberType(0, true),
-  axis1: /* @__PURE__ */ ChildType(Vec3, void 0, true),
+  hingeAngle: NumberType(0, true),
+  axis1: ChildType(Vec3, void 0, true),
   // constraint parts
   pointConstraintPart: PointConstraintComponent,
   rotationConstraintPart: HingeComponent,
   rotationLimitsConstraintPart: AngleComponent,
   motorConstraintPart: AngleComponent
 };
-class HingeConstraint extends (/* @__PURE__ */ createClass(hingeConstraintProps)) {
+class HingeConstraint extends createClass(hingeConstraintProps) {
   constructor() {
     super(...arguments);
     this.type = ConstraintType.hingeConstraint;
@@ -8931,24 +7659,24 @@ HingeConstraint.create = function() {
   return constraint;
 };
 const constraintPairNodeProps = {
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  edgeA: /* @__PURE__ */ LazyReferenceType((() => ConstraintPairEdge)),
-  edgeB: /* @__PURE__ */ LazyReferenceType((() => ConstraintPairEdge)),
-  constraintType: /* @__PURE__ */ NumberType(ConstraintType.pointConstraint),
-  constraintPoint: /* @__PURE__ */ LazyReferenceType((() => PointConstraint)),
-  constraintFixed: /* @__PURE__ */ LazyReferenceType((() => FixedConstraint)),
-  constraintDistance: /* @__PURE__ */ LazyReferenceType((() => DistanceConstraint)),
-  constraintHinge: /* @__PURE__ */ LazyReferenceType((() => HingeConstraint))
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  edgeA: LazyReferenceType((() => ConstraintPairEdge)),
+  edgeB: LazyReferenceType((() => ConstraintPairEdge)),
+  constraintType: NumberType(ConstraintType.pointConstraint),
+  constraintPoint: LazyReferenceType((() => PointConstraint)),
+  constraintFixed: LazyReferenceType((() => FixedConstraint)),
+  constraintDistance: LazyReferenceType((() => DistanceConstraint)),
+  constraintHinge: LazyReferenceType((() => HingeConstraint))
 };
 const afterConstructorCode$1 = `
   this.world = null;
   this.constraints = [null, null, null, null];
 `;
-class ConstraintPairNode extends (/* @__PURE__ */ createClass(
+class ConstraintPairNode extends createClass(
   constraintPairNodeProps,
   { afterConstructorCode: afterConstructorCode$1 }
-)) {
+) {
   containsStaticBody() {
     return this.bodyA.type === BodyType.static || this.bodyB.type === BodyType.static;
   }
@@ -8966,13 +7694,13 @@ class ConstraintPairNode extends (/* @__PURE__ */ createClass(
   }
 }
 const constraintPairEdgeProps = {
-  node: /* @__PURE__ */ LazyReferenceType((() => ConstraintPairNode)),
-  next: /* @__PURE__ */ LazyReferenceType((() => ConstraintPairEdge)),
-  prev: /* @__PURE__ */ LazyReferenceType((() => ConstraintPairEdge))
+  node: LazyReferenceType((() => ConstraintPairNode)),
+  next: LazyReferenceType((() => ConstraintPairEdge)),
+  prev: LazyReferenceType((() => ConstraintPairEdge))
 };
-class ConstraintPairEdge extends (/* @__PURE__ */ createClass(
+class ConstraintPairEdge extends createClass(
   constraintPairEdgeProps
-)) {
+) {
 }
 class ConstraintPairsModule {
   constructor(constraintPairNodePool, constraintPairEdgePool) {
@@ -9214,7 +7942,7 @@ var ColliderType = /* @__PURE__ */ ((ColliderType2) => {
   return ColliderType2;
 })(ColliderType || {});
 const bodyProps = {
-  type: /* @__PURE__ */ NumberType(
+  type: NumberType(
     0
     /* dynamic */
   ),
@@ -9222,55 +7950,55 @@ const bodyProps = {
   orientation: Quat,
   linearVelocity: Vec3,
   angularVelocity: Vec3,
-  computedCenterOfMassPosition: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  computedBounds: /* @__PURE__ */ ChildType(Aabb, void 0, true),
-  previousPosition: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  previousOrientation: /* @__PURE__ */ ChildType(Quat, void 0, true),
-  isSleeping: /* @__PURE__ */ BooleanType(false, true),
-  timeWithoutMoving: /* @__PURE__ */ NumberType(0, true),
+  computedCenterOfMassPosition: ChildType(Vec3, void 0, true),
+  computedBounds: ChildType(Aabb, void 0, true),
+  previousPosition: ChildType(Vec3, void 0, true),
+  previousOrientation: ChildType(Quat, void 0, true),
+  isSleeping: BooleanType(false, true),
+  timeWithoutMoving: NumberType(0, true),
   friction: 0,
   restitution: 0,
-  frictionFunction: /* @__PURE__ */ NumberType(CoefficientFunctionType.average),
-  restitutionFunction: /* @__PURE__ */ NumberType(CoefficientFunctionType.average),
+  frictionFunction: NumberType(CoefficientFunctionType.average),
+  restitutionFunction: NumberType(CoefficientFunctionType.average),
   mass: 0,
   density: 0,
-  inverseMass: /* @__PURE__ */ NumberType(0, true),
-  computedLocalInverseInertia: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  computedWorldInverseInertia: /* @__PURE__ */ ChildType(Mat3, void 0, true),
-  colliderType: /* @__PURE__ */ NumberType(
+  inverseMass: NumberType(0, true),
+  computedLocalInverseInertia: ChildType(Mat3, void 0, true),
+  computedWorldInverseInertia: ChildType(Mat3, void 0, true),
+  colliderType: NumberType(
     2
     /* resolveContact */
   ),
   gravityScale: 1,
-  linearForces: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  angularForces: /* @__PURE__ */ ChildType(Vec3, void 0, true),
-  copyForDiff: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  firstPotentialPairEdge: /* @__PURE__ */ LazyReferenceType((() => BodyPairEdge)),
-  belongsToGroups: /* @__PURE__ */ NumberType(AllFlag),
-  collidesWithGroups: /* @__PURE__ */ NumberType(AllFlag),
-  node: /* @__PURE__ */ LazyReferenceType((() => BvhNode)),
-  shapeType: /* @__PURE__ */ NumberType(ShapeType.box),
+  linearForces: ChildType(Vec3, void 0, true),
+  angularForces: ChildType(Vec3, void 0, true),
+  copyForDiff: LazyReferenceType((() => Body)),
+  firstPotentialPairEdge: LazyReferenceType((() => BodyPairEdge)),
+  belongsToGroups: NumberType(AllFlag),
+  collidesWithGroups: NumberType(AllFlag),
+  node: LazyReferenceType((() => BvhNode)),
+  shapeType: NumberType(ShapeType.box),
   // we need to do "as 'shape' ..." otherwise they are just 'string' and not the actual specific keys
-  ["shape" + ShapeType.box]: /* @__PURE__ */ ReferenceType(Box, void 0, true),
-  ["shape" + ShapeType.capsule]: /* @__PURE__ */ ReferenceType(Capsule, void 0, true),
-  ["shape" + ShapeType.compoundShape]: /* @__PURE__ */ ReferenceType(CompoundShape, void 0, true),
-  ["shape" + ShapeType.convexHull]: /* @__PURE__ */ ReferenceType(ConvexHull, void 0, true),
-  ["shape" + ShapeType.cylinder]: /* @__PURE__ */ ReferenceType(Cylinder, void 0, true),
-  ["shape" + ShapeType.heightMap]: /* @__PURE__ */ ReferenceType(HeightMap, void 0, true),
-  ["shape" + ShapeType.sphere]: /* @__PURE__ */ ReferenceType(Sphere, void 0, true),
-  ["shape" + ShapeType.triangleMesh]: /* @__PURE__ */ ReferenceType(TriangleMesh, void 0, true),
-  isSleepingEnabled: /* @__PURE__ */ BooleanType(true),
+  ["shape" + ShapeType.box]: ReferenceType(Box, void 0, true),
+  ["shape" + ShapeType.capsule]: ReferenceType(Capsule, void 0, true),
+  ["shape" + ShapeType.compoundShape]: ReferenceType(CompoundShape, void 0, true),
+  ["shape" + ShapeType.convexHull]: ReferenceType(ConvexHull, void 0, true),
+  ["shape" + ShapeType.cylinder]: ReferenceType(Cylinder, void 0, true),
+  ["shape" + ShapeType.heightMap]: ReferenceType(HeightMap, void 0, true),
+  ["shape" + ShapeType.sphere]: ReferenceType(Sphere, void 0, true),
+  ["shape" + ShapeType.triangleMesh]: ReferenceType(TriangleMesh, void 0, true),
+  isSleepingEnabled: BooleanType(true),
   linearDamping: -1,
   angularDamping: -1,
-  firstPotentialConstraintPairEdge: /* @__PURE__ */ LazyReferenceType(
+  firstPotentialConstraintPairEdge: LazyReferenceType(
     (() => ConstraintPairEdge)
   ),
-  visitGeneration: /* @__PURE__ */ NumberType(0, true)
+  visitGeneration: NumberType(0, true)
 };
 const afterConstructorCode = `
   this.world = null;
 `;
-class Body extends (/* @__PURE__ */ createClass(bodyProps, { afterConstructorCode })) {
+class Body extends createClass(bodyProps, { afterConstructorCode }) {
   get shape() {
     return this["shape" + this.shapeType];
   }
@@ -9605,11 +8333,11 @@ var CollisionStatus = /* @__PURE__ */ ((CollisionStatus2) => {
   return CollisionStatus2;
 })(CollisionStatus || {});
 const collisionResultProps = {
-  status: /* @__PURE__ */ NumberType(
+  status: NumberType(
     2
     /* Indeterminate */
   ),
-  hasContact: /* @__PURE__ */ BooleanType(false),
+  hasContact: BooleanType(false),
   penetration: 0,
   contactPointA: Vec3,
   contactPointB: Vec3,
@@ -9619,15 +8347,15 @@ const collisionResultProps = {
   momentArmB: Vec3,
   surfaceNormalA: Vec3,
   surfaceNormalB: Vec3,
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
   subShapeIdA: 0,
   subShapeIdB: 0,
-  isBackFace: /* @__PURE__ */ BooleanType(false),
+  isBackFace: BooleanType(false),
   faceA: Face,
   faceB: Face
 };
-class CollisionResult extends (/* @__PURE__ */ createClass(collisionResultProps)) {
+class CollisionResult extends createClass(collisionResultProps) {
   /**
    * swaps the A and B data
    */
@@ -9701,11 +8429,11 @@ function createDefaultCollisionSettings() {
   };
 }
 const castResultProps = {
-  status: /* @__PURE__ */ NumberType(
+  status: NumberType(
     2
     /* Indeterminate */
   ),
-  hasContact: /* @__PURE__ */ BooleanType(false),
+  hasContact: BooleanType(false),
   penetration: 0,
   contactPointA: Vec3,
   contactPointB: Vec3,
@@ -9715,17 +8443,17 @@ const castResultProps = {
   momentArmB: Vec3,
   surfaceNormalA: Vec3,
   surfaceNormalB: Vec3,
-  bodyA: /* @__PURE__ */ LazyReferenceType((() => Body)),
-  bodyB: /* @__PURE__ */ LazyReferenceType((() => Body)),
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
   subShapeIdA: 0,
   subShapeIdB: 0,
-  isBackFace: /* @__PURE__ */ BooleanType(false),
+  isBackFace: BooleanType(false),
   faceA: Face,
   faceB: Face,
   fraction: 0,
-  isBackFaceHit: /* @__PURE__ */ BooleanType(false)
+  isBackFaceHit: BooleanType(false)
 };
-class CastResult extends (/* @__PURE__ */ createClass(castResultProps)) {
+class CastResult extends createClass(castResultProps) {
   /**
    * swaps the A and B data
    */
@@ -9814,17 +8542,17 @@ const closestPointResultProps = {
   point: Vec3,
   pointSet: 0
 };
-class ClosestPointResult extends (/* @__PURE__ */ createClass(
+class ClosestPointResult extends createClass(
   closestPointResultProps
-)) {
+) {
 }
 const barycentricCoordinatesResultProps = {
   u: 0,
   v: 0,
   w: 0,
-  isValid: /* @__PURE__ */ BooleanType(false)
+  isValid: BooleanType(false)
 };
-class BarycentricCoordinatesResult extends (/* @__PURE__ */ createClass(barycentricCoordinatesResultProps)) {
+class BarycentricCoordinatesResult extends createClass(barycentricCoordinatesResultProps) {
 }
 const ab$3 = /* @__PURE__ */ Vec3.create();
 const ac$2 = /* @__PURE__ */ Vec3.create();
@@ -10041,7 +8769,7 @@ const vec4Props = {
   z: 0,
   w: 0
 };
-class Vec4 extends (/* @__PURE__ */ createClass(vec4Props)) {
+class Vec4 extends createClass(vec4Props) {
 }
 const ab$1 = /* @__PURE__ */ Vec3.create();
 const ac = /* @__PURE__ */ Vec3.create();
@@ -10147,11 +8875,11 @@ const closestPointToSimplexProps = {
   point: Vec3,
   squaredDistance: 0,
   pointSet: 0,
-  closestPointFound: /* @__PURE__ */ BooleanType(false)
+  closestPointFound: BooleanType(false)
 };
-class ClosestPointToSimplex extends (/* @__PURE__ */ createClass(
+class ClosestPointToSimplex extends createClass(
   closestPointToSimplexProps
-)) {
+) {
 }
 const gjkClosestPointsProps = {
   squaredDistance: 0,
@@ -10159,7 +8887,7 @@ const gjkClosestPointsProps = {
   pointA: Vec3,
   pointB: Vec3
 };
-class GjkClosestPoints extends (/* @__PURE__ */ createClass(gjkClosestPointsProps)) {
+class GjkClosestPoints extends createClass(gjkClosestPointsProps) {
 }
 const gjkCastShapeResultProps = {
   isHitFound: false,
@@ -10168,7 +8896,7 @@ const gjkCastShapeResultProps = {
   pointA: Vec3,
   pointB: Vec3
 };
-class GjkCastShapeResult extends (/* @__PURE__ */ createClass(gjkCastShapeResultProps)) {
+class GjkCastShapeResult extends createClass(gjkCastShapeResultProps) {
 }
 const transformedConvexObject = /* @__PURE__ */ new TransformedConvexObject();
 const y0 = /* @__PURE__ */ Vec3.create();
@@ -10652,11 +9380,11 @@ class GjkModule {
 }
 const v = /* @__PURE__ */ Vec3.create();
 const edgeProps = {
-  neighbourTriangle: /* @__PURE__ */ LazyReferenceType((() => Triangle2)),
+  neighbourTriangle: LazyReferenceType((() => Triangle2)),
   neighbourEdge: 0,
   startIndex: 0
 };
-class Edge extends (/* @__PURE__ */ createClass(edgeProps)) {
+class Edge extends createClass(edgeProps) {
   //
 }
 const triangleProps = {
@@ -10668,10 +9396,10 @@ const triangleProps = {
   closestLengthSq: Infinity,
   lambda0: 0,
   lambda1: 0,
-  lambdaRelativeTo0: /* @__PURE__ */ BooleanType(false),
-  closestPointInterior: /* @__PURE__ */ BooleanType(false),
-  removed: /* @__PURE__ */ BooleanType(false),
-  inQueue: /* @__PURE__ */ BooleanType(false),
+  lambdaRelativeTo0: BooleanType(false),
+  closestPointInterior: BooleanType(false),
+  removed: BooleanType(false),
+  inQueue: BooleanType(false),
   iteration: 0
 };
 const vectorAB$4 = /* @__PURE__ */ Vec3.create();
@@ -10752,7 +9480,7 @@ function initTriangle(m, inIdx0, inIdx1, inIdx2, inPositions, minTriangleArea, b
     }
   }
 }
-class Triangle2 extends (/* @__PURE__ */ createClass(triangleProps)) {
+class Triangle2 extends createClass(triangleProps) {
   isFacing(inPosition) {
     vectorAB$4.subtractVectors(inPosition, this.centroid);
     return this.normal.dot(vectorAB$4) > 0;
@@ -11268,9 +9996,9 @@ const penetrationDepthProps = {
   pointA: Vec3,
   pointB: Vec3
 };
-class PenetrationDepth extends (/* @__PURE__ */ createClass(
+class PenetrationDepth extends createClass(
   penetrationDepthProps
-)) {
+) {
 }
 const transformed_a = /* @__PURE__ */ new TransformedConvexObject();
 const closest = /* @__PURE__ */ GjkClosestPoints.create();
@@ -12546,6 +11274,14 @@ class CollideShapesModule {
     );
   }
 }
+const estimateCollisionResponseResultProps = {
+  deltaLinearVelocityA: Vec3,
+  deltaAngularVelocityA: Vec3,
+  deltaLinearVelocityB: Vec3,
+  deltaAngularVelocityB: Vec3
+};
+class EstimateCollisionResponseResult extends createClass(estimateCollisionResponseResultProps) {
+}
 function estimateCollisionResponse(result2, manifold, timeStepSizeSeconds) {
   result2.reset();
   const damping = 0.9;
@@ -13213,9 +11949,9 @@ const contactPairCacheCosMaxDeltaRotationDiv2 = Math.cos(degreesToRadians(2) / 2
 const negatedPenetrationAxis = /* @__PURE__ */ Vec3.create();
 const vec3BufferProps = {
   numItems: 0,
-  vec3List: /* @__PURE__ */ ReferenceListType(Vec3)
+  vec3List: ReferenceListType(Vec3)
 };
-class Vec3Buffer extends (/* @__PURE__ */ createClass(vec3BufferProps)) {
+class Vec3Buffer extends createClass(vec3BufferProps) {
   getVec3(out, index) {
     out.copy(this.vec3List.getAtIndex(index));
   }