@polygonjs/polygonjs
Version:
node-based WebGL 3D engine https://polygonjs.com
1,553 lines (1,551 loc) • 190 kB
JavaScript
var Module = (() => {
var _scriptDir = import.meta.url;
return async function (moduleArg = {}) {
var Module = moduleArg;
var readyPromiseResolve, readyPromiseReject;
Module['ready'] = new Promise((resolve, reject) => {
readyPromiseResolve = resolve;
readyPromiseReject = reject;
});
var _ManifoldInitialized = false;
Module.setup = function () {
if (_ManifoldInitialized) return;
_ManifoldInitialized = true;
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;
}
const CrossSectionCtor = Module.CrossSection;
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;
}
}
Module.CrossSection.prototype.translate = function (...vec) {
return this._Translate(vararg2vec2(vec));
};
Module.CrossSection.prototype.scale = function (vec) {
if (typeof vec == 'number') {
return this._Scale({x: vec, y: vec});
}
return this._Scale(vararg2vec2([vec]));
};
Module.CrossSection.prototype.mirror = function (vec) {
return this._Mirror(vararg2vec2([vec]));
};
Module.CrossSection.prototype.warp = function (func) {
const wasmFuncPtr = addFunction(function (vec2Ptr) {
const x = getValue(vec2Ptr, 'float');
const y = getValue(vec2Ptr + 4, 'float');
const vert = [x, y];
func(vert);
setValue(vec2Ptr, vert[0], 'float');
setValue(vec2Ptr + 4, vert[1], 'float');
}, 'vi');
const out = this._Warp(wasmFuncPtr);
removeFunction(wasmFuncPtr);
return out;
};
Module.CrossSection.prototype.decompose = function () {
const vec = this._Decompose();
const result = fromVec(vec);
vec.delete();
return result;
};
Module.CrossSection.prototype.bounds = function () {
const result = this._Bounds();
return {min: ['x', 'y'].map((f) => result.min[f]), max: ['x', 'y'].map((f) => result.max[f])};
};
Module.CrossSection.prototype.offset = function (
delta,
joinType = 'Square',
miterLimit = 2,
circularSegments = 0
) {
return this._Offset(delta, joinTypeToInt(joinType), miterLimit, circularSegments);
};
Module.CrossSection.prototype.extrude = function (
height,
nDivisions = 0,
twistDegrees = 0,
scaleTop = [1, 1],
center = false
) {
scaleTop = vararg2vec2([scaleTop]);
const man = Module._Extrude(this, height, nDivisions, twistDegrees, scaleTop);
return center ? man.translate([0, 0, -height / 2]) : man;
};
Module.CrossSection.prototype.revolve = function (circularSegments = 0, revolveDegrees = 360) {
return Module._Revolve(this, circularSegments, revolveDegrees);
};
Module.CrossSection.prototype.add = function (other) {
return this._add(cross(other));
};
Module.CrossSection.prototype.subtract = function (other) {
return this._subtract(cross(other));
};
Module.CrossSection.prototype.intersect = function (other) {
return this._intersect(cross(other));
};
Module.CrossSection.prototype.toPolygons = function () {
const vec = this._ToPolygons();
const result = vec2polygons(vec);
vec.delete();
return result;
};
Module.Manifold.prototype.warp = function (func) {
const wasmFuncPtr = addFunction(function (vec3Ptr) {
const x = getValue(vec3Ptr, 'float');
const y = getValue(vec3Ptr + 4, 'float');
const z = getValue(vec3Ptr + 8, 'float');
const vert = [x, y, z];
func(vert);
setValue(vec3Ptr, vert[0], 'float');
setValue(vec3Ptr + 4, vert[1], 'float');
setValue(vec3Ptr + 8, vert[2], 'float');
}, 'vi');
const out = this._Warp(wasmFuncPtr);
removeFunction(wasmFuncPtr);
const status = out.status();
if (status.value !== 0) {
throw new Module.ManifoldError(status.value);
}
return out;
};
Module.Manifold.prototype.setProperties = function (numProp, func) {
const oldNumProp = this.numProp();
const wasmFuncPtr = addFunction(function (newPtr, vec3Ptr, oldPtr) {
const newProp = [];
for (let i = 0; i < numProp; ++i) {
newProp[i] = getValue(newPtr + 4 * i, 'float');
}
const pos = [];
for (let i = 0; i < 3; ++i) {
pos[i] = getValue(vec3Ptr + 4 * i, 'float');
}
const oldProp = [];
for (let i = 0; i < oldNumProp; ++i) {
oldProp[i] = getValue(oldPtr + 4 * i, 'float');
}
func(newProp, pos, oldProp);
for (let i = 0; i < numProp; ++i) {
setValue(newPtr + 4 * i, newProp[i], 'float');
}
}, 'viii');
const out = this._SetProperties(numProp, wasmFuncPtr);
removeFunction(wasmFuncPtr);
return out;
};
Module.Manifold.prototype.translate = function (...vec) {
return this._Translate(vararg2vec3(vec));
};
Module.Manifold.prototype.rotate = function (vec) {
return this._Rotate(...vec);
};
Module.Manifold.prototype.scale = function (vec) {
if (typeof vec == 'number') {
return this._Scale({x: vec, y: vec, z: vec});
}
return this._Scale(vararg2vec3([vec]));
};
Module.Manifold.prototype.mirror = function (vec) {
return this._Mirror(vararg2vec3([vec]));
};
Module.Manifold.prototype.trimByPlane = function (normal, offset = 0) {
return this._TrimByPlane(vararg2vec3([normal]), offset);
};
Module.Manifold.prototype.split = function (manifold) {
const vec = this._split(manifold);
const result = fromVec(vec);
vec.delete();
return result;
};
Module.Manifold.prototype.splitByPlane = function (normal, offset = 0) {
const vec = this._splitByPlane(vararg2vec3([normal]), offset);
const result = fromVec(vec);
vec.delete();
return result;
};
Module.Manifold.prototype.decompose = function () {
const vec = this._Decompose();
const result = fromVec(vec);
vec.delete();
return result;
};
Module.Manifold.prototype.boundingBox = function () {
const result = this._boundingBox();
return {min: ['x', 'y', 'z'].map((f) => result.min[f]), max: ['x', 'y', 'z'].map((f) => result.max[f])};
};
class Mesh {
constructor({
numProp: numProp = 3,
triVerts: triVerts = new Uint32Array(),
vertProperties: vertProperties = new Float32Array(),
mergeFromVert: mergeFromVert,
mergeToVert: mergeToVert,
runIndex: runIndex,
runOriginalID: runOriginalID,
faceID: faceID,
halfedgeTangent: halfedgeTangent,
runTransform: 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;
}
merge() {
const {changed: changed, mesh: 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(numProp * vert, numProp * vert + 3);
}
extras(vert) {
return this.vertProperties.subarray(numProp * vert + 3, 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;
}
}
Module.Mesh = Mesh;
Module.Manifold.prototype.getMesh = function (normalIdx = [0, 0, 0]) {
if (normalIdx instanceof Array) normalIdx = {0: normalIdx[0], 1: normalIdx[1], 2: normalIdx[2]};
return new Mesh(this._GetMeshJS(normalIdx));
};
Module.ManifoldError = function ManifoldError(code, ...args) {
let message = 'Unknown error';
switch (code) {
case Module.status.NonFiniteVertex.value:
message = 'Non-finite vertex';
break;
case Module.status.NotManifold.value:
message = 'Not manifold';
break;
case Module.status.VertexOutOfBounds.value:
message = 'Vertex index out of bounds';
break;
case Module.status.PropertiesWrongLength.value:
message = 'Properties have wrong length';
break;
case Module.status.MissingPositionProperties.value:
message = 'Less than three properties';
break;
case Module.status.MergeVectorsDifferentLengths.value:
message = 'Merge vectors have different lengths';
break;
case Module.status.MergeIndexOutOfBounds.value:
message = 'Merge index out of bounds';
break;
case Module.status.TransformWrongLength.value:
message = 'Transform vector has wrong length';
break;
case Module.status.RunIndexWrongLength.value:
message = 'Run index vector has wrong length';
break;
case Module.status.FaceIDWrongLength.value:
message = 'Face ID vector has wrong length';
case Module.status.InvalidConstruction.value:
message = 'Manifold constructed with invalid parameters';
}
const base = Error.apply(this, [message, ...args]);
base.name = this.name = 'ManifoldError';
this.message = base.message;
this.stack = base.stack;
this.code = code;
};
Module.ManifoldError.prototype = Object.create(Error.prototype, {
constructor: {value: Module.ManifoldError, writable: true, configurable: true},
});
Module.CrossSection = function (polygons, fillRule = 'Positive') {
const polygonsVec = polygons2vec(polygons);
const cs = new CrossSectionCtor(polygonsVec, fillRuleToInt(fillRule));
disposePolygons(polygonsVec);
return cs;
};
Module.CrossSection.ofPolygons = function (polygons, fillRule = 'Positive') {
return new Module.CrossSection(polygons, fillRule);
};
Module.CrossSection.square = function (...args) {
let size = undefined;
if (args.length == 0) size = {x: 1, y: 1};
else if (typeof args[0] == 'number') size = {x: args[0], y: args[0]};
else size = vararg2vec2(args);
const center = args[1] || false;
return Module._Square(size, center);
};
Module.CrossSection.circle = function (radius, circularSegments = 0) {
return Module._Circle(radius, circularSegments);
};
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;
};
}
Module.CrossSection.compose = crossSectionBatchbool('Compose');
Module.CrossSection.union = crossSectionBatchbool('UnionN');
Module.CrossSection.difference = crossSectionBatchbool('DifferenceN');
Module.CrossSection.intersection = crossSectionBatchbool('IntersectionN');
function pushVec2(vec, ps) {
toVec(vec, ps, (p) => {
if (p instanceof Array) return {x: p[0], y: p[1]};
return p;
});
}
Module.CrossSection.hull = function (...args) {
if (args.length == 1) args = args[0];
let pts = new Module.Vector_vec2();
for (const cs of args) {
if (cs instanceof CrossSectionCtor) {
Module._crossSectionCollectVertices(pts, cs);
} else if (cs instanceof Array && cs.length == 2 && typeof cs[0] == 'number') {
pts.push_back({x: cs[0], y: cs[1]});
} else if (cs.x) {
pts.push_back(cs);
} else {
const wrap = (cs[0].length == 2 && typeof cs[0][0] == 'number') || cs[0].x;
const polys = wrap ? [cs] : cs;
for (const poly of polys) pushVec2(pts, poly);
}
}
const result = Module._crossSectionHullPoints(pts);
pts.delete();
return result;
};
Module.CrossSection.prototype = Object.create(CrossSectionCtor.prototype);
Object.defineProperty(Module.CrossSection, Symbol.hasInstance, {
get: () => (t) => t instanceof CrossSectionCtor,
});
const ManifoldCtor = Module.Manifold;
Module.Manifold = function (mesh) {
const manifold = new ManifoldCtor(mesh);
const status = manifold.status();
if (status.value !== 0) {
throw new Module.ManifoldError(status.value);
}
return manifold;
};
Module.Manifold.ofMesh = function (mesh) {
return new Module.Manifold(mesh);
};
Module.Manifold.tetrahedron = function () {
return Module._Tetrahedron();
};
Module.Manifold.cube = function (...args) {
let size = undefined;
if (args.length == 0) size = {x: 1, y: 1, z: 1};
else if (typeof args[0] == 'number') size = {x: args[0], y: args[0], z: args[0]};
else size = vararg2vec3(args);
const center = args[1] || false;
return Module._Cube(size, center);
};
Module.Manifold.cylinder = function (
height,
radiusLow,
radiusHigh = -1,
circularSegments = 0,
center = false
) {
return Module._Cylinder(height, radiusLow, radiusHigh, circularSegments, center);
};
Module.Manifold.sphere = function (radius, circularSegments = 0) {
return Module._Sphere(radius, circularSegments);
};
Module.Manifold.smooth = function (mesh, sharpenedEdges = []) {
const sharp = new Module.Vector_smoothness();
toVec(sharp, sharpenedEdges);
const result = Module._Smooth(mesh, sharp);
sharp.delete();
return result;
};
Module.Manifold.extrude = function (
polygons,
height,
nDivisions = 0,
twistDegrees = 0,
scaleTop = [1, 1],
center = false
) {
const cs = polygons instanceof CrossSectionCtor ? polygons : Module.CrossSection(polygons, 'Positive');
return cs.extrude(height, nDivisions, twistDegrees, scaleTop, center);
};
Module.Manifold.revolve = function (polygons, circularSegments = 0, revolveDegrees = 360) {
const cs = polygons instanceof CrossSectionCtor ? polygons : Module.CrossSection(polygons, 'Positive');
return cs.revolve(circularSegments, revolveDegrees);
};
Module.Manifold.reserveIDs = function (n) {
return Module._ReserveIDs(n);
};
Module.Manifold.compose = function (manifolds) {
const vec = new Module.Vector_manifold();
toVec(vec, manifolds);
const result = Module._manifoldCompose(vec);
vec.delete();
return result;
};
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;
};
}
Module.Manifold.union = manifoldBatchbool('Union');
Module.Manifold.difference = manifoldBatchbool('Difference');
Module.Manifold.intersection = manifoldBatchbool('Intersection');
Module.Manifold.levelSet = function (sdf, bounds, edgeLength, level = 0) {
const bounds2 = {
min: {x: bounds.min[0], y: bounds.min[1], z: bounds.min[2]},
max: {x: bounds.max[0], y: bounds.max[1], z: bounds.max[2]},
};
const wasmFuncPtr = addFunction(function (vec3Ptr) {
const x = getValue(vec3Ptr, 'float');
const y = getValue(vec3Ptr + 4, 'float');
const z = getValue(vec3Ptr + 8, 'float');
const vert = [x, y, z];
return sdf(vert);
}, 'fi');
const out = Module._LevelSet(wasmFuncPtr, bounds2, edgeLength, level);
removeFunction(wasmFuncPtr);
return out;
};
function pushVec3(vec, ps) {
toVec(vec, ps, (p) => {
if (p instanceof Array) return {x: p[0], y: p[1], z: p[2]};
return p;
});
}
Module.Manifold.hull = function (...args) {
if (args.length == 1) args = args[0];
let pts = new Module.Vector_vec3();
for (const m of args) {
if (m instanceof ManifoldCtor) {
Module._manifoldCollectVertices(pts, m);
} else if (m instanceof Array && m.length == 3 && typeof m[0] == 'number') {
pts.push_back({x: m[0], y: m[1], z: m[2]});
} else if (m.x) {
pts.push_back(m);
} else {
pushVec3(pts, m);
}
}
const result = Module._manifoldHullPoints(pts);
pts.delete();
return result;
};
Module.Manifold.prototype = Object.create(ManifoldCtor.prototype);
Object.defineProperty(Module.Manifold, Symbol.hasInstance, {get: () => (t) => t instanceof ManifoldCtor});
Module.triangulate = function (polygons, precision = -1) {
const polygonsVec = polygons2vec(polygons);
const result = fromVec(Module._Triangulate(polygonsVec, precision), (x) => [x[0], x[1], x[2]]);
disposePolygons(polygonsVec);
return result;
};
};
var moduleOverrides = Object.assign({}, Module);
var arguments_ = [];
var thisProgram = './this.program';
var quit_ = (status, toThrow) => {
throw toThrow;
};
var ENVIRONMENT_IS_WEB = typeof window == 'object';
var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';
var ENVIRONMENT_IS_NODE =
typeof process == 'object' &&
typeof process.versions == 'object' &&
typeof process.versions.node == 'string';
var scriptDirectory = '';
function locateFile(path) {
if (Module['locateFile']) {
return Module['locateFile'](path, scriptDirectory);
}
return scriptDirectory + path;
}
var read_, readAsync, readBinary, setWindowTitle;
if (ENVIRONMENT_IS_NODE) {
// const {createRequire: createRequire} = await import('module');
// var require = createRequire(import.meta.url);
// var fs = require('fs');
// var nodePath = require('path');
// if (ENVIRONMENT_IS_WORKER) {
// scriptDirectory = nodePath.dirname(scriptDirectory) + '/';
// } else {
// scriptDirectory = require('url').fileURLToPath(new URL('./', import.meta.url));
// }
// read_ = (filename, binary) => {
// filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
// return fs.readFileSync(filename, binary ? undefined : 'utf8');
// };
// readBinary = (filename) => {
// var ret = read_(filename, true);
// if (!ret.buffer) {
// ret = new Uint8Array(ret);
// }
// return ret;
// };
// readAsync = (filename, onload, onerror, binary = true) => {
// filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
// fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => {
// if (err) onerror(err);
// else onload(binary ? data.buffer : data);
// });
// };
// if (!Module['thisProgram'] && process.argv.length > 1) {
// thisProgram = process.argv[1].replace(/\\/g, '/');
// }
// arguments_ = process.argv.slice(2);
// quit_ = (status, toThrow) => {
// process.exitCode = status;
// throw toThrow;
// };
// Module['inspect'] = () => '[Emscripten Module object]';
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = self.location.href;
} else if (typeof document != 'undefined' && document.currentScript) {
scriptDirectory = document.currentScript.src;
}
if (_scriptDir) {
scriptDirectory = _scriptDir;
}
if (scriptDirectory.indexOf('blob:') !== 0) {
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/') + 1);
} else {
scriptDirectory = '';
}
{
read_ = (url) => {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, false);
xhr.send(null);
return xhr.responseText;
};
if (ENVIRONMENT_IS_WORKER) {
readBinary = (url) => {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, false);
xhr.responseType = 'arraybuffer';
xhr.send(null);
return new Uint8Array(xhr.response);
};
}
readAsync = (url, onload, onerror) => {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, true);
xhr.responseType = 'arraybuffer';
xhr.onload = () => {
if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
onload(xhr.response);
return;
}
onerror();
};
xhr.onerror = onerror;
xhr.send(null);
};
}
setWindowTitle = (title) => (document.title = title);
} else {
}
var out = Module['print'] || console.log.bind(console);
var err = Module['printErr'] || console.error.bind(console);
Object.assign(Module, moduleOverrides);
moduleOverrides = null;
if (Module['arguments']) arguments_ = Module['arguments'];
if (Module['thisProgram']) thisProgram = Module['thisProgram'];
if (Module['quit']) quit_ = Module['quit'];
var wasmBinary;
if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
var noExitRuntime = Module['noExitRuntime'] || true;
if (typeof WebAssembly != 'object') {
abort('no native wasm support detected');
}
var wasmMemory;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) {
if (!condition) {
abort(text);
}
}
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
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);
}
var wasmTable;
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
function preRun() {
if (Module['preRun']) {
if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
while (Module['preRun'].length) {
addOnPreRun(Module['preRun'].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function initRuntime() {
runtimeInitialized = true;
if (!Module['noFSInit'] && !FS.init.initialized) FS.init();
FS.ignorePermissions = false;
TTY.init();
callRuntimeCallbacks(__ATINIT__);
}
function postRun() {
if (Module['postRun']) {
if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
while (Module['postRun'].length) {
addOnPostRun(Module['postRun'].shift());
}
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
function addOnInit(cb) {
__ATINIT__.unshift(cb);
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
function getUniqueRunDependency(id) {
return id;
}
function addRunDependency(id) {
runDependencies++;
if (Module['monitorRunDependencies']) {
Module['monitorRunDependencies'](runDependencies);
}
}
function removeRunDependency(id) {
runDependencies--;
if (Module['monitorRunDependencies']) {
Module['monitorRunDependencies'](runDependencies);
}
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
function abort(what) {
if (Module['onAbort']) {
Module['onAbort'](what);
}
what = 'Aborted(' + what + ')';
err(what);
ABORT = true;
EXITSTATUS = 1;
what += '. Build with -sASSERTIONS for more info.';
var e = new WebAssembly.RuntimeError(what);
readyPromiseReject(e);
throw e;
}
var dataURIPrefix = 'data:application/octet-stream;base64,';
function isDataURI(filename) {
return filename.startsWith(dataURIPrefix);
}
function isFileURI(filename) {
return filename.startsWith('file://');
}
var wasmBinaryFile;
if (Module['locateFile']) {
wasmBinaryFile = 'manifold.wasm';
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile);
}
} else {
// wasmBinaryFile = 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';
}
function getBinaryPromise(binaryFile) {
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
if (typeof fetch == 'function' && !isFileURI(binaryFile)) {
return fetch(binaryFile, {credentials: 'same-origin'})
.then((response) => {
if (!response['ok']) {
throw "failed to load wasm binary file at '" + binaryFile + "'";
}
return response['arrayBuffer']();
})
.catch(() => getBinarySync(binaryFile));
} else if (readAsync) {
return new Promise((resolve, reject) => {
readAsync(binaryFile, (response) => resolve(new Uint8Array(response)), reject);
});
}
}
return Promise.resolve().then(() => getBinarySync(binaryFile));
}
function instantiateArrayBuffer(binaryFile, imports, receiver) {
return getBinaryPromise(binaryFile)
.then((binary) => WebAssembly.instantiate(binary, imports))
.then((instance) => instance)
.then(receiver, (reason) => {
err(`failed to asynchronously prepare wasm: ${reason}`);
abort(reason);
});
}
function instantiateAsync(binary, binaryFile, imports, callback) {
if (
!binary &&
typeof WebAssembly.instantiateStreaming == 'function' &&
!isDataURI(binaryFile) &&
!isFileURI(binaryFile) &&
!ENVIRONMENT_IS_NODE &&
typeof fetch == 'function'
) {
return fetch(binaryFile, {credentials: 'same-origin'}).then((response) => {
var result = WebAssembly.instantiateStreaming(response, imports);
return result.then(callback, function (reason) {
err(`wasm streaming compile failed: ${reason}`);
err('falling back to ArrayBuffer instantiation');
return instantiateArrayBuffer(binaryFile, imports, callback);
});
});
}
return instantiateArrayBuffer(binaryFile, imports, callback);
}
function createWasm() {
var info = {a: wasmImports};
function receiveInstance(instance, module) {
var exports = instance.exports;
wasmExports = exports;
wasmMemory = wasmExports['Na'];
updateMemoryViews();
wasmTable = wasmExports['Pa'];
addOnInit(wasmExports['Oa']);
removeRunDependency('wasm-instantiate');
return exports;
}
addRunDependency('wasm-instantiate');
function receiveInstantiationResult(result) {
receiveInstance(result['instance']);
}
if (Module['instantiateWasm']) {
try {
return Module['instantiateWasm'](info, receiveInstance);
} catch (e) {
err(`Module.instantiateWasm callback failed with error: ${e}`);
readyPromiseReject(e);
}
}
instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
return {};
}
var tempDouble;
var tempI64;
var callRuntimeCallbacks = (callbacks) => {
while (callbacks.length > 0) {
callbacks.shift()(Module);
}
};
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];
case 'i32':
return HEAP32[ptr >> 2];
case 'i64':
abort('to do getValue(i64) use WASM_BIGINT');
case 'float':
return HEAPF32[ptr >> 2];
case 'double':
return HEAPF64[ptr >> 3];
case '*':
return HEAPU32[ptr >> 2];
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] = value;
break;
case 'i32':
HEAP32[ptr >> 2] = value;
break;
case 'i64':
abort('to do setValue(i64) use WASM_BIGINT');
case 'float':
HEAPF32[ptr >> 2] = value;
break;
case 'double':
HEAPF64[ptr >> 3] = value;
break;
case '*':
HEAPU32[ptr >> 2] = value;
break;
default:
abort(`invalid type for setValue: ${type}`);
}
}
var exceptionCaught = [];
var uncaughtExceptionCount = 0;
var ___cxa_begin_catch = (ptr) => {
var info = new ExceptionInfo(ptr);
if (!info.get_caught()) {
info.set_caught(true);
uncaughtExceptionCount--;
}
info.set_rethrown(false);
exceptionCaught.push(info);
___cxa_increment_exception_refcount(info.excPtr);
return info.get_exception_ptr();
};
var exceptionLast = 0;
var ___cxa_end_catch = () => {
_setThrew(0, 0);
var info = exceptionCaught.pop();
___cxa_decrement_exception_refcount(info.excPtr);
exceptionLast = 0;
};
function ExceptionInfo(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - 24;
this.set_type = function (type) {
HEAPU32[(this.ptr + 4) >> 2] = type;
};
this.get_type = function () {
return HEAPU32[(this.ptr + 4) >> 2];
};
this.set_destructor = function (destructor) {
HEAPU32[(this.ptr + 8) >> 2] = destructor;
};
this.get_destructor = function () {
return HEAPU32[(this.ptr + 8) >> 2];
};
this.set_caught = function (caught) {
caught = caught ? 1 : 0;
HEAP8[(this.ptr + 12) >> 0] = caught;
};
this.get_caught = function () {
return HEAP8[(this.ptr + 12) >> 0] != 0;
};
this.set_rethrown = function (rethrown) {
rethrown = rethrown ? 1 : 0;
HEAP8[(this.ptr + 13) >> 0] = rethrown;
};
this.get_rethrown = function () {
return HEAP8[(this.ptr + 13) >> 0] != 0;
};
this.init = function (type, destructor) {
this.set_adjusted_ptr(0);
this.set_type(type);
this.set_destructor(destructor);
};
this.set_adjusted_ptr = function (adjustedPtr) {
HEAPU32[(this.ptr + 16) >> 2] = adjustedPtr;
};
this.get_adjusted_ptr = function () {
return HEAPU32[(this.ptr + 16) >> 2];
};
this.get_exception_ptr = function () {
var isPointer = ___cxa_is_pointer_type(this.get_type());
if (isPointer) {
return HEAPU32[this.excPtr >> 2];
}
var adjusted = this.get_adjusted_ptr();
if (adjusted !== 0) return adjusted;
return this.excPtr;
};
}
var ___resumeException = (ptr) => {
if (!exceptionLast) {
exceptionLast = ptr;
}
throw exceptionLast;
};
var findMatchingCatch = (args) => {
var thrown = exceptionLast;
if (!thrown) {
setTempRet0(0);
return 0;
}
var info = new ExceptionInfo(thrown);
info.set_adjusted_ptr(thrown);
var thrownType = info.get_type();
if (!thrownType) {
setTempRet0(0);
return thrown;
}
for (var arg in args) {
var caughtType = args[arg];
if (caughtType === 0 || caughtType === thrownType) {
break;
}
var adjusted_ptr_addr = info.ptr + 16;
if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
setTempRet0(caughtType);
return thrown;
}
}
setTempRet0(thrownType);
return thrown;
};
var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);
var ___cxa_find_matching_catch_3 = (arg0) => findMatchingCatch([arg0]);
var ___cxa_rethrow = () => {
var info = exceptionCaught.pop();
if (!info) {
abort('no exception to throw');
}
var ptr = info.excPtr;
if (!info.get_rethrown()) {
exceptionCaught.push(info);
info.set_rethrown(true);
info.set_caught(false);
uncaughtExceptionCount++;
}
exceptionLast = ptr;
throw exceptionLast;
};
var ___cxa_throw = (ptr, type, destructor) => {
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = ptr;
uncaughtExceptionCount++;
throw exceptionLast;
};
var ___cxa_uncaught_exceptions = () => uncaughtExceptionCount;
var structRegistrations = {};
var runDestructors = (destructors) => {
while (destructors.length) {
var ptr = destructors.pop();
var del = destructors.pop();
del(ptr);
}
};
function simpleReadValueFromPointer(pointer) {
return this['fromWireType'](HEAP32[pointer >> 2]);
}
var awaitingDependencies = {};
var registeredTypes = {};
var typeDependencies = {};
var InternalError = undefined;
var throwInternalError = (message) => {
throw new InternalError(message);
};
var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
myTypes.forEach(function (type) {
typeDependencies[type] = dependentTypes;
});
function onComplete(typeConverters) {
var myTypeConverters = getTypeConverters(typeConverters);
if (myTypeConverters.length !== myTypes.length) {
throwInternalError('Mismatched type converter count');
}
for (var i = 0; i < myTypes.length; ++i) {
registerType(myTypes[i], myTypeConverters[i]);
}
}
var typeConverters = new Array(dependentTypes.length);
var unregisteredTypes = [];
var registered = 0;
dependentTypes.forEach((dt, i) => {
if (registeredTypes.hasOwnProperty(dt)) {
typeConverters[i] = registeredTypes[dt];
} else {
unregisteredTypes.push(dt);
if (!awaitingDependencies.hasOwnProperty(dt)) {
awaitingDependencies[dt] = [];
}
awaitingDependencies[dt].push(() => {
typeConverters[i] = registeredTypes[dt];
++registered;
if (registered === unregisteredTypes.length) {
onComplete(typeConverters);
}
});
}
});
if (0 === unregisteredTypes.length) {
onComplete(typeConverters);
}
};
var __embind_finalize_value_object = (structType) => {
var reg = structRegistrations[structType];
delete structRegistrations[structType];
var rawConstructor = reg.rawConstructor;
var rawDestructor = reg.rawDestructor;
var fieldRecords = reg.fields;
var fieldTypes = fieldRecords
.map((field) => field.getterReturnType)
.concat(fieldRecords.map((field) => field.setterArgumentType));
whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes) => {
var fields = {};
fieldRecords.forEach((field, i) => {
var fieldName = field.fieldName;
var getterReturnType = fieldTypes[i];
var getter = field.getter;
var getterContext = field.getterContext;
var setterArgumentType = fieldTypes[i + fieldRecords.length];
var setter = field.setter;
var setterContext = field.setterContext;
fields[fieldName] = {
read: (ptr) => getterReturnType['fromWireType'](getter(getterContext, ptr)),
write: (ptr, o) => {
var destructors = [];
setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o));
runDestructors(destructors);
},
};
});
return [
{
name: reg.name,
fromWireType: (ptr) => {
var rv = {};
for (var i in fields) {
rv[i] = fields[i].read(ptr);
}
rawDestructor(ptr);
return rv;
},
toWireType: (destructors, o) => {
for (var fieldName in fields) {
if (!(fieldName in o)) {
throw new TypeError(`Missing field: "${fieldName}"`);
}
}
var ptr = rawConstructor();
for (fieldName in fields) {
fields[fieldName].write(ptr, o[fieldName]);
}
if (destructors !== null) {
destructors.push(rawDestructor, ptr);
}
return ptr;
},
argPackAdvance: GenericWireTypeSize,
readValueFromPointer: simpleReadValueFromPointer,
destructorFunction: rawDestructor,
},
];
});
};
var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {};
var embind_init_charCodes = () => {
var codes = new Array(256);
for (var i = 0; i < 256; ++i) {
codes[i] = String.fromCharCode(i);
}
embind_charCodes = codes;
};
var embind_charCodes = undefined;
var readLatin1String = (ptr) => {
var ret = '';
var c = ptr;
while (HEAPU8[c]) {
ret += embind_charCodes[HEAPU8[c++]];
}
return ret;
};
var BindingError = undefined;
var throwBindingError = (message) => {
throw new BindingError(message);
};
function sharedRegisterType(rawType, registeredInstance, options = {}) {
var name = registeredInstance.name;
if (!rawType) {
throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
}
if (registeredTypes.hasOwnProperty(rawType)) {
if (options.ignoreDuplicateRegistrations) {
return;
} else {
throwBindingError(`Cannot register type '${name}' twice`);
}
}
registeredTypes[rawType] = registeredInstance;
delete typeDependencies[rawType];
if (awaitingDependencies.hasOwnProperty(rawType)) {
var callbacks = awaitingDependencies[rawType];
delete awaitingDependencies[rawType];
callbacks.forEach((cb) => cb());
}
}
function registerType(rawType, registeredInstance, options = {}) {
if (!('argPackAdvance' in registeredInstance)) {
throw new TypeError('registerType registeredInstance requires argPackAdvance');
}
return sharedRegisterType(rawType, registeredInstance, options);
}
var GenericWireTypeSize = 8;
var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
name = readLatin1String(name);
registerType(rawType, {
name: name,
fromWireType: function (wt) {
return !!wt;
},
toWireType: function (destructors, o) {
return o ? trueValue : falseValue;
},
argPackAdvance: GenericWireTypeSize,
readValueFromPointer: function (pointer) {
return this['fromWireType'](HEAPU8[pointer]);
},
destructorFunction: null,
});
};
function ClassHandle_isAliasOf(other) {
if (!(this instanceof ClassHandle)) {
return false;
}
if (!(other instanceof ClassHandle)) {
return false;
}
var leftClass = this.$$.ptrType.registeredClass;
var left = this.$$.ptr;
var rightClass = other.$$.ptrType.registeredClass;
var right = other.$$.ptr;
while (leftClass.baseClass) {
left = leftClass.upcast(left);
leftClass = leftClass.baseClass;
}
while (rightClass.baseClass) {
right = rightClass.upcast(right);
rightClass = rightClass.baseClass;
}
return leftClass === rightClass && left === right;
}
var shallowCopyInternalPointer = (o) => ({
count: o.count,
deleteScheduled: o.deleteScheduled,
preservePointerOnDelete: o.preservePointerOnDelete,
ptr: o.ptr,
ptrType: o.ptrType,
smartPtr: o.smartPtr,
smartPtrType: o.smartPtrType,
});
var throwInstanceAlreadyDeleted = (obj) => {
function getInstanceTypeName(handle) {
return handle.$$.ptrType.registeredClass.name;
}
throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
};
var finalizationRegistry = false;
var detachFinalizer = (handle) => {};
var runDestructor = ($$) => {
if ($$.smartPtr) {
$$.smartPtrType.rawDestructor($$.smartPtr);
} else {
$$.ptrType.registeredClass.rawDestructor($$.ptr);
}
};
var releaseClassHandle = ($$) => {
$$.count.value -= 1;
var toDelete = 0 === $$.count.value;
if (toDelete) {
runDestructor($$);
}
};
var downcastPointer = (ptr, ptrClass, desiredClass) => {
if (ptrClass === desiredClass) {
return ptr;
}
if (undefined === desiredClass.baseClass) {
return null;
}
var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
if (rv === null) {
return null;
}
return desiredClass.downcast(rv);
};
var registeredPointers = {};
var getInheritedInstanceCount = () => Object.keys(registeredInstances).length;
var getLiveInheritedInstances = () => {
var rv = [];
for (var k in registeredInstances) {
if (registeredInstances.hasOwnProperty(k)) {
rv.push(registeredInstances[k]);
}
}
return rv;
};
var deletionQueue = [];
var flushPendingDeletes = () => {
while (deletionQueue.length) {
var obj = deletionQueue.pop();
obj.$$.deleteScheduled = false;
obj['delete']();
}
};
var delayFunction = undefined;
var setDelayFunction = (fn) => {
delayFunction = fn;
if (deletionQueue.length && delayFunction) {
delayFunction(flushPendingDeletes);
}
};
var init_embind = () => {
Module['getInheritedInstanceCount'] = getInheritedInstanceCount;
Module['getLiveInheritedInstances'] = getLiveInheritedInstances;
Module['flushPendingDeletes'] = flushPendingDeletes;
Module['setDelayFunction'] = setDelayFunction;
};
var registeredInstances = {};
var getBasestPointer = (class_, ptr) => {
if (ptr === undefined) {
throwBindingError('ptr should not be undefined');
}
while (class_.baseClass) {
ptr = class_.upcast(ptr);
class_ = class_.baseClass;
}
return ptr;
};
var getInheritedInstance = (class_, ptr) => {
ptr = getBasestPointer(class_, ptr);
return registeredInstances[ptr];
};
var makeClassHandle = (prototype, record) => {
if (!record.ptrType || !record.ptr) {
throwInternalError('makeClassHandle requires ptr and ptrType');
}
var hasSmartPtrType = !!record.smartPtrType;
var hasSmartPtr = !!record.smartPtr;
if (hasSmartPtrType !== hasSmartPtr) {
throwInternalError('Both smartPtrType and smartPtr must be specified');
}
record.count = {value: 1};
return attachFinalizer(Object.create(prototype, {$$: {value: record}}));
};
function RegisteredPointer_fromWireType(ptr) {
var rawPointer = this.getPointee(ptr);
if (!rawPointer) {
this.destructor(ptr);
return null;
}
var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
if (undefined !== registeredInstance) {
if (0 === registeredInstance.$$.count.value) {
registeredInstance.$$.ptr = rawPointer;
registeredInstance.$$.smartPtr = ptr;
return registeredInstance['clone']();
} else {
var rv = registeredInstance['clone']();
this.destructor(ptr);
return rv;
}
}
function makeDefaultHandle() {
if (this.isSmartPointer) {
return makeClassHandle(this.registeredClass.instancePrototype, {
ptrType: this.pointeeType,
ptr: rawPointer,
smartPtrType: this,
smartPtr: ptr,
});
} else {
return makeClassHandle(this.registeredClass.instancePrototype, {ptrType: this, ptr: ptr});
}
}
var actualType = this.registeredClass.getActualType(rawPointer);
var registeredPointerRecord = registeredPointers[actualType];
if (!registeredPointerRecord) {
return makeDefaultHandle.call(this);
}
var toType;
if (this.isConst) {
toType = registeredPointerRecord.constPointerType;
} else {
toType = registeredPointerRecord.pointerType;
}
var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
if (dp === null) {
return makeDefaultHandle.call(this);
}
if (this.isSmartPointer) {
return makeClassHandle(toType.registeredClass.instancePrototype, {
ptrType: toType,
ptr: dp,
smartPtrType: this,
smartPtr: ptr,
});
} else {
return makeClassHandle(toType.registeredClass.instancePrototype, {ptrType: toType, ptr: dp});
}
}
var attachFinalizer = (handle) => {
if ('undefined' === typeof FinalizationRegistry) {
attachFinalizer = (handle) => handle;
return handle;
}
finalizationRegistry = new FinalizationRegistry((info) => {
releaseClassHandle(info.$$);
});
attachFinalizer = (handle) => {
var $$ = handle.$$;
var hasSmartPtr = !!$$.smartPtr;
if (hasSmartPtr) {
var info = {$$: $$};
finalizationRegistry.register(handle, info, handle);
}
return handle;
};
detachFinalizer = (handle) => finalizationRegistry.unregister(handle);
return attachFinalizer(handle);
};
function ClassHandle_clone() {
if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this);
}
if (this.$$.preservePointerOnDelete) {
this.$$.count.value += 1;
return this;
} else {
var clone = attachFinalizer(
Object.create(Object.getPrototypeOf(this), {$$: {value: shallowCopyInternalPointer(this.$$)}})
);
clone.$$.count.value += 1;
clone.$$.deleteScheduled = false;
return clone;
}
}
function ClassHandle_delete() {
if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this);
}
if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
throwBindingError('Object already scheduled for deletion');
}
detachFinalizer(this);
releaseClassHandle(this.$$);
if (!this.$$.preservePointerOnDelete) {
this.$$.smartPtr = undefined;
this.$$.ptr = undefined;
}
}
function ClassHandle_isDeleted() {
return !this.$$.ptr;
}
function ClassHandle_deleteLater() {
if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this);
}
if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
throwBindingError('Object already scheduled for deletion');
}
deletionQueue.push(this);
if (deletionQueue.length === 1 && delayFunction) {
delayFunction(flushPendingDeletes);
}
this.$$.deleteScheduled = true;
return this;
}
var init_ClassHandle = () => {
ClassHandle.prototype['isAliasOf'] = ClassHandle_isAliasOf;
ClassHandle.prototype['clone'] = ClassHandle_clone;
ClassHandle.prototype['delete'] = ClassHandle_delete;
ClassHandle.prototype['isDeleted'] = ClassHandle_isDeleted;
ClassHandle.prototype['deleteLater'] = ClassHandle_deleteLater;
};
function ClassHandle() {}
var char_0 = 48;
var char_9 = 57;
var makeLegalFunctionName = (name) => {
if (undefined === name) {
return '_unknown';
}
name = name.replace(/[^a-zA-Z0-9_]/g, '$');
var f = name.charCodeAt(0);
if (f >= char_0 && f <= char_9) {
return `_${name}`;
}
return name;
};
function createNamedFunction(name, body) {
name = makeLegalFunctionName(name);
return {
[name]: function () {
return body.apply(this, arguments);
},
}[name];
}
var ensureOverloadTable = (proto, methodName, humanName) => {
if (undefined === proto[methodName].overloadTable) {
var prevFunc = proto[methodName];
proto[methodName] = function () {
if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
throwBindingError(
`Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`
);
}
return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
};
proto[methodName].overloadTable = [];
proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
}
};
var exposePublicSymbol = (name, value, numArguments) => {
if (Module.hasOwnProperty(name)) {
if (
undefined === numArguments ||
(undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])
) {
throwBindingError(`Cannot register public name '${name}' twice`);
}
ensureOverloadTable(Module, name, name);
if (Module.hasOwnProperty(numArguments)) {
throwBindingError(
`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`
);
}
Module[name].overloadTable[numArguments] = value;
} else {
Module[name] = value;
if (undefined !== numArguments) {
Module[name].numArguments = numArguments;
}
}
};
function RegisteredClass(
name,
constructor,
instancePrototype,
rawDestructor,
baseClass,
getActualType,
upcast,
downcast