Function bodies 165 total

      function toVec(vec, list, f = (x => x)) {
        if (list) {
          for (let x of list) {
            vec.push_back(f(x))
          }
        }
        return vec
      }

      function fromVec(vec, f = (x => x)) {
        const result = [];
        const size = vec.size();
        for (let i = 0; i < size; i++) result.push(f(vec.get(i)));
        return result
      }

      function vec2polygons(vec, f = (x => x)) {
        const result = [];
        const nPoly = vec.size();
        for (let i = 0; i < nPoly; i++) {
          const v = vec.get(i);
          const nPts = v.size();
          const poly = [];
          for (let j = 0; j < nPts; j++) {
            poly.push(f(v.get(j)))
          }
          result.push(poly)
        }
        return result
      }

      function polygons2vec(polygons) {
        if (polygons[0].length < 3) {
          polygons = [polygons]
        }
        return toVec(
            new Module.Vector2_vec2, polygons,
            poly => toVec(new Module.Vector_vec2, poly, p => {
              if (p instanceof Array) return {x: p[0], y: p[1]};
              return p
            }))
      }

      function disposePolygons(polygonsVec) {
        for (let i = 0; i < polygonsVec.size(); i++)
          polygonsVec.get(i).delete();
        polygonsVec.delete()
      }

      function vararg2vec2(vec) {
        if (vec[0] instanceof Array) return {x: vec[0][0], y: vec[0][1]};
        if (typeof vec[0] == 'number') return {x: vec[0] || 0, y: vec[1] || 0};
        return vec[0]
      }

      function vararg2vec3(vec) {
        if (vec[0] instanceof Array)
          return {x: vec[0][0], y: vec[0][1], z: vec[0][2]};
        if (typeof vec[0] == 'number')
          return {x: vec[0] || 0, y: vec[1] || 0, z: vec[2] || 0};
        return vec[0]
      }

      function fillRuleToInt(fillRule) {
        return fillRule == 'EvenOdd' ? 0 :
            fillRule == 'NonZero'    ? 1 :
            fillRule == 'Negative'   ? 3 :
                                       2
      }

      function joinTypeToInt(joinType) {
        return joinType == 'Round' ? 1 : joinType == 'Miter' ? 2 : 0
      }

      function cross(polygons, fillRule = 'Positive') {
        if (polygons instanceof CrossSectionCtor) {
          return polygons
        } else {
          const polygonsVec = polygons2vec(polygons);
          const cs = new CrossSectionCtor(polygonsVec, fillRuleToInt(fillRule));
          disposePolygons(polygonsVec);
          return cs
        }
      }

      class Mesh {
        constructor({
          numProp = 3,
          triVerts = new Uint32Array,
          vertProperties = new Float32Array,
          mergeFromVert,
          mergeToVert,
          runIndex,
          runOriginalID,
          faceID,
          halfedgeTangent,
          runTransform
        } = {}) {
          this.numProp = numProp;
          this.triVerts = triVerts;
          this.vertProperties = vertProperties;
          this.mergeFromVert = mergeFromVert;
          this.mergeToVert = mergeToVert;
          this.runIndex = runIndex;
          this.runOriginalID = runOriginalID;
          this.faceID = faceID;
          this.halfedgeTangent = halfedgeTangent;
          this.runTransform = runTransform
        }
        get numTri() {
          return this.triVerts.length / 3
        }
        get numVert() {
          return this.vertProperties.length / this.numProp
        }
        get numRun() {
          return this.runOriginalID.length
        }
       

        constructor({
          numProp = 3,
          triVerts = new Uint32Array,
          vertProperties = new Float32Array,
          mergeFromVert,
          mergeToVert,
          runIndex,
          runOriginalID,
          faceID,
          halfedgeTangent,
          runTransform
        } = {}) {
          this.numProp = numProp;
          this.triVerts = triVerts;
          this.vertProperties = vertProperties;
          this.mergeFromVert = mergeFromVert;
          this.mergeToVert = mergeToVert;
          this.runIndex = runIndex;
          this.runOriginalID = runOriginalID;
          this.faceID = faceID;
          this.halfedgeTangent = halfedgeTangent;
          this.runTransform = runTransform
        }

        merge() {
          const {changed, mesh} = Module._Merge(this);
          Object.assign(this, {...mesh});
          return changed
        }

        verts(tri) {
          return this.triVerts.subarray(3 * tri, 3 * (tri + 1))
        }

        position(vert) {
          return this.vertProperties.subarray(
              this.numProp * vert, this.numProp * vert + 3)
        }

        extras(vert) {
          return this.vertProperties.subarray(
              this.numProp * vert + 3, this.numProp * (vert + 1))
        }

        tangent(halfedge) {
          return this.halfedgeTangent.subarray(4 * halfedge, 4 * (halfedge + 1))
        }

        transform(run) {
          const mat4 = new Array(16);
          for (const col of [0, 1, 2, 3]) {
            for (const row of [0, 1, 2]) {
              mat4[4 * col + row] = this.runTransform[12 * run + 3 * col + row]
            }
          }
          mat4[15] = 1;
          return mat4
        }

      function crossSectionBatchbool(name) {
        return function(...args) {
          if (args.length == 1) args = args[0];
          const v = new Module.Vector_crossSection;
          for (const cs of args) v.push_back(cross(cs));
          const result = Module['_crossSection' + name](v);
          v.delete();
          return result
        }
      }

      function pushVec2(vec, ps) {
        toVec(vec, ps, p => {
          if (p instanceof Array) return {x: p[0], y: p[1]};
          return p
        })
      }

      function manifoldBatchbool(name) {
        return function(...args) {
          if (args.length == 1) args = args[0];
          const v = new Module.Vector_manifold;
          for (const m of args) v.push_back(m);
          const result = Module['_manifold' + name + 'N'](v);
          v.delete();
          return result
        }
      }

      function pushVec3(vec, ps) {
        toVec(vec, ps, p => {
          if (p instanceof Array) return {x: p[0], y: p[1], z: p[2]};
          return p
        })
      }

    function locateFile(path) {
      if (Module['locateFile']) {
        return Module['locateFile'](path, scriptDirectory)
      }
      return scriptDirectory + path
    }

    function updateMemoryViews() {
      var b = wasmMemory.buffer;
      Module['HEAP8'] = HEAP8 = new Int8Array(b);
      Module['HEAP16'] = HEAP16 = new Int16Array(b);
      Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);
      Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);
      Module['HEAP32'] = HEAP32 = new Int32Array(b);
      Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);
      Module['HEAPF32'] = HEAPF32 = new Float32Array(b);
      Module['HEAPF64'] = HEAPF64 = new Float64Array(b);
      Module['HEAP64'] = HEAP64 = new BigInt64Array(b);
      Module['HEAPU64'] = HEAPU64 = new BigUint64Array(b)
    }

    function preRun() {
      if (Module['preRun']) {
        if (typeof Module['preRun'] == 'function')
          Module['preRun'] = [Module['preRun']];
        while (Module['preRun'].length) {
          addOnPreRun(Module['preRun'].shift())
        }
      }
      callRuntimeCallbacks(onPreRuns)
    }

    function initRuntime() {
      runtimeInitialized = true;
      wasmExports['J']()
    }

    function postRun() {
      if (Module['postRun']) {
        if (typeof Module['postRun'] == 'function')
          Module['postRun'] = [Module['postRun']];
        while (Module['postRun'].length) {
          addOnPostRun(Module['postRun'].shift())
        }
      }
      callRuntimeCallbacks(onPostRuns)
    }

    function addRunDependency(id) {
      runDependencies++;
      Module['monitorRunDependencies']?.(runDependencies)
    }

    function removeRunDependency(id) {
      runDependencies--;
      Module['monitorRunDependencies']?.(runDependencies);
      if (runDependencies == 0) {
        if (dependenciesFulfilled) {
          var callback = dependenciesFulfilled;
          dependenciesFulfilled = null;
          callback()
        }
      }
    }

    function abort(what) {
      Module['onAbort']?.(what);
      what = 'Aborted(' + what + ')';
      err(what);
      ABORT = true;
      what += '. Build with -sASSERTIONS for more info.';
      var e = new WebAssembly.RuntimeError(what);
      readyPromiseReject(e);
      throw e
    }

    function findWasmBinary() {
      if (Module['locateFile']) {
        return locateFile('manifold.wasm')
      }
      return new URL('manifold.wasm', import.meta.url).href
    }

    function getBinarySync(file) {
      if (file == wasmBinaryFile && wasmBinary) {
        return new Uint8Array(wasmBinary)
      }
      if (readBinary) {
        return readBinary(file)
      }
      throw 'both async and sync fetching of the wasm failed'
    }

    async function getWasmBinary(binaryFile) {
      if (!wasmBinary) {
        try {
          var response = await readAsync(binaryFile);
          return new Uint8Array(response)
        } catch {
        }
      }
      return getBinarySync(binaryFile)
    }

    async function instantiateArrayBuffer(binaryFile, imports) {
      try {
        var binary = await getWasmBinary(binaryFile);
        var instance = await WebAssembly.instantiate(binary, imports);
        return instance
      } catch (reason) {
        err(`failed to asynchronously prepare wasm: ${reason}`);
        abort(reason)
      }
    }

    async function instantiateAsync(binary, binaryFile, imports) {
      if (!binary && typeof WebAssembly.instantiateStreaming == 'function' &&
          !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
        try {
          var response = fetch(binaryFile, {credentials: 'same-origin'});
          var instantiationResult =
              await WebAssembly.instantiateStreaming(response, imports);
          return instantiationResult
        } catch (reason) {
          err(`wasm streaming compile failed: ${reason}`);
          err('falling back to ArrayBuffer instantiation')
        }
      }
      return instantiateArrayBuffer(binaryFile, imports)
    }

    function getWasmImports() {
      return {
        a: wasmImports
      }
    }

    async function createWasm() {
      function receiveInstance(instance, module) {
        wasmExports = instance.exports;
        wasmExports = applySignatureConversions(wasmExports);
        wasmMemory = wasmExports['I'];
        updateMemoryViews();
        wasmTable = wasmExports['L'];
        removeRunDependency('wasm-instantiate');
        return wasmExports
      }
      addRunDependency('wasm-instantiate');
      function receiveInstantiationResult(result) {
        return receiveInstance(result['instance'])
      }
      var info = getWasmImports();
      if (Module['instantiateWasm']) {
        return new Promise(
            (resolve,
             reject) => {Module['instantiateWasm'](info, (mod, inst) => {
              receiveInstance(mod, inst);
              resolve(mod.exports)
            })})
      }
      wasmBinaryFile ??= findWasmBinary();
      try {
        var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
        var exports = receiveInsta

      function receiveInstance(instance, module) {
        wasmExports = instance.exports;
        wasmExports = applySignatureConversions(wasmExports);
        wasmMemory = wasmExports['I'];
        updateMemoryViews();
        wasmTable = wasmExports['L'];
        removeRunDependency('wasm-instantiate');
        return wasmExports
      }

      function receiveInstantiationResult(result) {
        return receiveInstance(result['instance'])
      }

    class ExitStatus {
      name = 'ExitStatus';
      constructor(status) {
        this.message = `Program terminated with exit(${status})`;
        this.status = status
      }
    }

      constructor(status) {
        this.message = `Program terminated with exit(${status})`;
        this.status = status
      }

    function getValue(ptr, type = 'i8') {
      if (type.endsWith('*')) type = '*';
      switch (type) {
        case 'i1':
          return HEAP8[ptr >>> 0];
        case 'i8':
          return HEAP8[ptr >>> 0];
        case 'i16':
          return HEAP16[ptr >>> 1 >>> 0];
        case 'i32':
          return HEAP32[ptr >>> 2 >>> 0];
        case 'i64':
          return HEAP64[ptr >>> 3];
        case 'float':
          return HEAPF32[ptr >>> 2 >>> 0];
        case 'double':
          return HEAPF64[ptr >>> 3 >>> 0];
        case '*':
          return HEAPU32[ptr >>> 2 >>> 0];
        default:
          abort(`invalid type for getValue: ${type}`)
      }
    }

    function setValue(ptr, value, type = 'i8') {
      if (type.endsWith('*')) type = '*';
      switch (type) {
        case 'i1':
          HEAP8[ptr >>> 0] = value;
          break;
        case 'i8':
          HEAP8[ptr >>> 0] = value;
          break;
        case 'i16':
          HEAP16[ptr >>> 1 >>> 0] = value;
          break;
        case 'i32':
          HEAP32[ptr >>> 2 >>> 0] = value;
          break;
        case 'i64':
          HEAP64[ptr >>> 3] = BigInt(value);
          break;
        case 'float':
          HEAPF32[ptr >>> 2 >>> 0] = value;
          break;
        case 'double':
          HEAPF64[ptr >>> 3 >>> 0] = value;
          break;
        case '*':
          HEAPU32[ptr >>> 2 >>> 0] = value;
          break;
        default:
          abort(`invalid type for setValue: ${type}`)
      }
    }

    class ExceptionInfo {
      constructor(excPtr) {
        this.excPtr = excPtr;
        this.ptr = excPtr - 24
      }
      set_type(type) {
        HEAPU32[this.ptr + 4 >>> 2 >>> 0] = type
      }
      get_type() {
        return HEAPU32[this.ptr + 4 >>> 2 >>> 0]
      }
      set_destructor(destructor) {
        HEAPU32[this.ptr + 8 >>> 2 >>> 0] = destructor
      }
      get_destructor() {
        return HEAPU32[this.ptr + 8 >>> 2 >>> 0]
      }
      set_caught(caught) {
        caught = caught ? 1 : 0;
        HEAP8[this.ptr + 12 >>> 0] = caught
      }
      get_caught() {
        return HEAP8[this.ptr + 12 >>> 0] != 0
      }
      set_rethrown(rethrown) {
        rethrown = rethrown ? 1 : 0;
        HEAP8[this.ptr + 13 >>> 0] = rethrown
      }
      get_rethrown() {
        return HEAP8[this.ptr + 13 >>> 0] != 0
      }
      init(type, destructor) {
        this.set_adjusted_ptr(0);
        this.set_type(type);
        this.set_destructor(destructor)
      }
      set_a

      constructor(excPtr) {
        this.excPtr = excPtr;
        this.ptr = excPtr - 24
      }

      set_type(type) {
        HEAPU32[this.ptr + 4 >>> 2 >>> 0] = type
      }

      get_type() {
        return HEAPU32[this.ptr + 4 >>> 2 >>> 0]
      }

      set_destructor(destructor) {
        HEAPU32[this.ptr + 8 >>> 2 >>> 0] = destructor
      }

      get_destructor() {
        return HEAPU32[this.ptr + 8 >>> 2 >>> 0]
      }

      set_caught(caught) {
        caught = caught ? 1 : 0;
        HEAP8[this.ptr + 12 >>> 0] = caught
      }