next-banner
Version:
Generate Open Graph images for Next.js on build
1,397 lines (1,394 loc) • 1.21 MB
JavaScript
#!/usr/bin/env node
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __commonJS = (cb2, mod) => function __require() {
return mod || (0, cb2[__getOwnPropNames(cb2)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to2, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key2 of __getOwnPropNames(from))
if (!__hasOwnProp.call(to2, key2) && key2 !== except)
__defProp(to2, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
}
return to2;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key2, value) => {
__defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);
return value;
};
// ../../node_modules/yoga-layout-prebuilt/yoga-layout/dist/YGEnums.js
var require_YGEnums = __commonJS({
"../../node_modules/yoga-layout-prebuilt/yoga-layout/dist/YGEnums.js"(exports2, module2) {
"use strict";
var CONSTANTS = {
ALIGN_COUNT: 8,
ALIGN_AUTO: 0,
ALIGN_FLEX_START: 1,
ALIGN_CENTER: 2,
ALIGN_FLEX_END: 3,
ALIGN_STRETCH: 4,
ALIGN_BASELINE: 5,
ALIGN_SPACE_BETWEEN: 6,
ALIGN_SPACE_AROUND: 7,
DIMENSION_COUNT: 2,
DIMENSION_WIDTH: 0,
DIMENSION_HEIGHT: 1,
DIRECTION_COUNT: 3,
DIRECTION_INHERIT: 0,
DIRECTION_LTR: 1,
DIRECTION_RTL: 2,
DISPLAY_COUNT: 2,
DISPLAY_FLEX: 0,
DISPLAY_NONE: 1,
EDGE_COUNT: 9,
EDGE_LEFT: 0,
EDGE_TOP: 1,
EDGE_RIGHT: 2,
EDGE_BOTTOM: 3,
EDGE_START: 4,
EDGE_END: 5,
EDGE_HORIZONTAL: 6,
EDGE_VERTICAL: 7,
EDGE_ALL: 8,
EXPERIMENTAL_FEATURE_COUNT: 1,
EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS: 0,
FLEX_DIRECTION_COUNT: 4,
FLEX_DIRECTION_COLUMN: 0,
FLEX_DIRECTION_COLUMN_REVERSE: 1,
FLEX_DIRECTION_ROW: 2,
FLEX_DIRECTION_ROW_REVERSE: 3,
JUSTIFY_COUNT: 6,
JUSTIFY_FLEX_START: 0,
JUSTIFY_CENTER: 1,
JUSTIFY_FLEX_END: 2,
JUSTIFY_SPACE_BETWEEN: 3,
JUSTIFY_SPACE_AROUND: 4,
JUSTIFY_SPACE_EVENLY: 5,
LOG_LEVEL_COUNT: 6,
LOG_LEVEL_ERROR: 0,
LOG_LEVEL_WARN: 1,
LOG_LEVEL_INFO: 2,
LOG_LEVEL_DEBUG: 3,
LOG_LEVEL_VERBOSE: 4,
LOG_LEVEL_FATAL: 5,
MEASURE_MODE_COUNT: 3,
MEASURE_MODE_UNDEFINED: 0,
MEASURE_MODE_EXACTLY: 1,
MEASURE_MODE_AT_MOST: 2,
NODE_TYPE_COUNT: 2,
NODE_TYPE_DEFAULT: 0,
NODE_TYPE_TEXT: 1,
OVERFLOW_COUNT: 3,
OVERFLOW_VISIBLE: 0,
OVERFLOW_HIDDEN: 1,
OVERFLOW_SCROLL: 2,
POSITION_TYPE_COUNT: 2,
POSITION_TYPE_RELATIVE: 0,
POSITION_TYPE_ABSOLUTE: 1,
PRINT_OPTIONS_COUNT: 3,
PRINT_OPTIONS_LAYOUT: 1,
PRINT_OPTIONS_STYLE: 2,
PRINT_OPTIONS_CHILDREN: 4,
UNIT_COUNT: 4,
UNIT_UNDEFINED: 0,
UNIT_POINT: 1,
UNIT_PERCENT: 2,
UNIT_AUTO: 3,
WRAP_COUNT: 3,
WRAP_NO_WRAP: 0,
WRAP_WRAP: 1,
WRAP_WRAP_REVERSE: 2
};
module2.exports = CONSTANTS;
}
});
// ../../node_modules/yoga-layout-prebuilt/yoga-layout/dist/entry-common.js
var require_entry_common = __commonJS({
"../../node_modules/yoga-layout-prebuilt/yoga-layout/dist/entry-common.js"(exports2, module2) {
"use strict";
var _extends = Object.assign || function(target) {
for (var i2 = 1; i2 < arguments.length; i2++) {
var source = arguments[i2];
for (var key2 in source) {
if (Object.prototype.hasOwnProperty.call(source, key2)) {
target[key2] = source[key2];
}
}
}
return target;
};
var _createClass = function() {
function defineProperties(target, props) {
for (var i2 = 0; i2 < props.length; i2++) {
var descriptor = props[i2];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor)
descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
return function(Constructor, protoProps, staticProps) {
if (protoProps)
defineProperties(Constructor.prototype, protoProps);
if (staticProps)
defineProperties(Constructor, staticProps);
return Constructor;
};
}();
function _defineProperty(obj, key2, value) {
if (key2 in obj) {
Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true });
} else {
obj[key2] = value;
}
return obj;
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
var CONSTANTS = require_YGEnums();
var Layout = function() {
function Layout2(left, right, top, bottom, width, height) {
_classCallCheck(this, Layout2);
this.left = left;
this.right = right;
this.top = top;
this.bottom = bottom;
this.width = width;
this.height = height;
}
_createClass(Layout2, [{
key: "fromJS",
value: function fromJS(expose) {
expose(this.left, this.right, this.top, this.bottom, this.width, this.height);
}
}, {
key: "toString",
value: function toString() {
return "<Layout#" + this.left + ":" + this.right + ";" + this.top + ":" + this.bottom + ";" + this.width + ":" + this.height + ">";
}
}]);
return Layout2;
}();
var Size = function() {
_createClass(Size2, null, [{
key: "fromJS",
value: function fromJS(_ref) {
var width = _ref.width, height = _ref.height;
return new Size2(width, height);
}
}]);
function Size2(width, height) {
_classCallCheck(this, Size2);
this.width = width;
this.height = height;
}
_createClass(Size2, [{
key: "fromJS",
value: function fromJS(expose) {
expose(this.width, this.height);
}
}, {
key: "toString",
value: function toString() {
return "<Size#" + this.width + "x" + this.height + ">";
}
}]);
return Size2;
}();
var Value = function() {
function Value2(unit, value) {
_classCallCheck(this, Value2);
this.unit = unit;
this.value = value;
}
_createClass(Value2, [{
key: "fromJS",
value: function fromJS(expose) {
expose(this.unit, this.value);
}
}, {
key: "toString",
value: function toString() {
switch (this.unit) {
case CONSTANTS.UNIT_POINT:
return String(this.value);
case CONSTANTS.UNIT_PERCENT:
return this.value + "%";
case CONSTANTS.UNIT_AUTO:
return "auto";
default: {
return this.value + "?";
}
}
}
}, {
key: "valueOf",
value: function valueOf() {
return this.value;
}
}]);
return Value2;
}();
module2.exports = function(bind, lib) {
function patch(prototype, name, fn2) {
var original = prototype[name];
prototype[name] = function() {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return fn2.call.apply(fn2, [this, original].concat(args));
};
}
var _arr = ["setPosition", "setMargin", "setFlexBasis", "setWidth", "setHeight", "setMinWidth", "setMinHeight", "setMaxWidth", "setMaxHeight", "setPadding"];
var _loop = function _loop2() {
var _methods;
var fnName = _arr[_i2];
var methods = (_methods = {}, _defineProperty(_methods, CONSTANTS.UNIT_POINT, lib.Node.prototype[fnName]), _defineProperty(_methods, CONSTANTS.UNIT_PERCENT, lib.Node.prototype[fnName + "Percent"]), _defineProperty(_methods, CONSTANTS.UNIT_AUTO, lib.Node.prototype[fnName + "Auto"]), _methods);
patch(lib.Node.prototype, fnName, function(original) {
for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
var value = args.pop();
var unit = void 0, asNumber = void 0;
if (value === "auto") {
unit = CONSTANTS.UNIT_AUTO;
asNumber = void 0;
} else if (value instanceof Value) {
unit = value.unit;
asNumber = value.valueOf();
} else {
unit = typeof value === "string" && value.endsWith("%") ? CONSTANTS.UNIT_PERCENT : CONSTANTS.UNIT_POINT;
asNumber = parseFloat(value);
if (!Number.isNaN(value) && Number.isNaN(asNumber)) {
throw new Error("Invalid value " + value + " for " + fnName);
}
}
if (!methods[unit])
throw new Error('Failed to execute "' + fnName + `": Unsupported unit '` + value + "'");
if (asNumber !== void 0) {
var _methods$unit;
return (_methods$unit = methods[unit]).call.apply(_methods$unit, [this].concat(args, [asNumber]));
} else {
var _methods$unit2;
return (_methods$unit2 = methods[unit]).call.apply(_methods$unit2, [this].concat(args));
}
});
};
for (var _i2 = 0; _i2 < _arr.length; _i2++) {
_loop();
}
patch(lib.Config.prototype, "free", function() {
lib.Config.destroy(this);
});
patch(lib.Node, "create", function(_, config) {
return config ? lib.Node.createWithConfig(config) : lib.Node.createDefault();
});
patch(lib.Node.prototype, "free", function() {
lib.Node.destroy(this);
});
patch(lib.Node.prototype, "freeRecursive", function() {
for (var t = 0, T = this.getChildCount(); t < T; ++t) {
this.getChild(0).freeRecursive();
}
this.free();
});
patch(lib.Node.prototype, "setMeasureFunc", function(original, measureFunc) {
if (measureFunc) {
return original.call(this, function() {
return Size.fromJS(measureFunc.apply(void 0, arguments));
});
} else {
return this.unsetMeasureFunc();
}
});
patch(lib.Node.prototype, "calculateLayout", function(original) {
var width = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : NaN;
var height = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : NaN;
var direction = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : CONSTANTS.DIRECTION_LTR;
return original.call(this, width, height, direction);
});
return _extends({
Config: lib.Config,
Node: lib.Node,
Layout: bind("Layout", Layout),
Size: bind("Size", Size),
Value: bind("Value", Value),
getInstanceCount: function getInstanceCount() {
return lib.getInstanceCount.apply(lib, arguments);
}
}, CONSTANTS);
};
}
});
// ../../node_modules/yoga-layout-prebuilt/yoga-layout/build/Release/nbind.js
var require_nbind = __commonJS({
"../../node_modules/yoga-layout-prebuilt/yoga-layout/build/Release/nbind.js"(exports, module) {
(function(root, wrapper) {
if (typeof define == "function" && define.amd)
define([], function() {
return wrapper;
});
else if (typeof module == "object" && module.exports)
module.exports = wrapper;
else
(root.nbind = root.nbind || {}).init = wrapper;
})(exports, function(Module, cb) {
if (typeof Module == "function") {
cb = Module;
Module = {};
}
Module.onRuntimeInitialized = function(init, cb2) {
return function() {
if (init)
init.apply(this, arguments);
try {
Module.ccall("nbind_init");
} catch (err2) {
cb2(err2);
return;
}
cb2(null, { bind: Module._nbind_value, reflect: Module.NBind.reflect, queryType: Module.NBind.queryType, toggleLightGC: Module.toggleLightGC, lib: Module });
};
}(Module.onRuntimeInitialized, cb);
var Module;
if (!Module)
Module = (typeof Module !== "undefined" ? Module : null) || {};
var moduleOverrides = {};
for (var key in Module) {
if (Module.hasOwnProperty(key)) {
moduleOverrides[key] = Module[key];
}
}
var ENVIRONMENT_IS_WEB = false;
var ENVIRONMENT_IS_WORKER = false;
var ENVIRONMENT_IS_NODE = false;
var ENVIRONMENT_IS_SHELL = false;
if (Module["ENVIRONMENT"]) {
if (Module["ENVIRONMENT"] === "WEB") {
ENVIRONMENT_IS_WEB = true;
} else if (Module["ENVIRONMENT"] === "WORKER") {
ENVIRONMENT_IS_WORKER = true;
} else if (Module["ENVIRONMENT"] === "NODE") {
ENVIRONMENT_IS_NODE = true;
} else if (Module["ENVIRONMENT"] === "SHELL") {
ENVIRONMENT_IS_SHELL = true;
} else {
throw new Error("The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.");
}
} else {
ENVIRONMENT_IS_WEB = typeof window === "object";
ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
ENVIRONMENT_IS_NODE = typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
}
if (ENVIRONMENT_IS_NODE) {
if (!Module["print"])
Module["print"] = console.log;
if (!Module["printErr"])
Module["printErr"] = console.warn;
var nodeFS;
var nodePath;
Module["read"] = function shell_read(filename, binary) {
if (!nodeFS)
nodeFS = {}("");
if (!nodePath)
nodePath = {}("");
filename = nodePath["normalize"](filename);
var ret = nodeFS["readFileSync"](filename);
return binary ? ret : ret.toString();
};
Module["readBinary"] = function readBinary(filename) {
var ret = Module["read"](filename, true);
if (!ret.buffer) {
ret = new Uint8Array(ret);
}
assert(ret.buffer);
return ret;
};
Module["load"] = function load(f) {
globalEval(read(f));
};
if (!Module["thisProgram"]) {
if (process["argv"].length > 1) {
Module["thisProgram"] = process["argv"][1].replace(/\\/g, "/");
} else {
Module["thisProgram"] = "unknown-program";
}
}
Module["arguments"] = process["argv"].slice(2);
if (typeof module !== "undefined") {
module["exports"] = Module;
}
process["on"]("uncaughtException", function(ex) {
if (!(ex instanceof ExitStatus)) {
throw ex;
}
});
Module["inspect"] = function() {
return "[Emscripten Module object]";
};
} else if (ENVIRONMENT_IS_SHELL) {
if (!Module["print"])
Module["print"] = print;
if (typeof printErr != "undefined")
Module["printErr"] = printErr;
if (typeof read != "undefined") {
Module["read"] = read;
} else {
Module["read"] = function shell_read() {
throw "no read() available";
};
}
Module["readBinary"] = function readBinary(f) {
if (typeof readbuffer === "function") {
return new Uint8Array(readbuffer(f));
}
var data = read(f, "binary");
assert(typeof data === "object");
return data;
};
if (typeof scriptArgs != "undefined") {
Module["arguments"] = scriptArgs;
} else if (typeof arguments != "undefined") {
Module["arguments"] = arguments;
}
if (typeof quit === "function") {
Module["quit"] = function(status, toThrow) {
quit(status);
};
}
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
Module["read"] = function shell_read(url) {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText;
};
if (ENVIRONMENT_IS_WORKER) {
Module["readBinary"] = function readBinary(url) {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(xhr.response);
};
}
Module["readAsync"] = function readAsync(url, onload, onerror) {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = function xhr_onload() {
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
onload(xhr.response);
} else {
onerror();
}
};
xhr.onerror = onerror;
xhr.send(null);
};
if (typeof arguments != "undefined") {
Module["arguments"] = arguments;
}
if (typeof console !== "undefined") {
if (!Module["print"])
Module["print"] = function shell_print(x) {
console.log(x);
};
if (!Module["printErr"])
Module["printErr"] = function shell_printErr(x) {
console.warn(x);
};
} else {
var TRY_USE_DUMP = false;
if (!Module["print"])
Module["print"] = TRY_USE_DUMP && typeof dump !== "undefined" ? function(x) {
dump(x);
} : function(x) {
};
}
if (ENVIRONMENT_IS_WORKER) {
Module["load"] = importScripts;
}
if (typeof Module["setWindowTitle"] === "undefined") {
Module["setWindowTitle"] = function(title) {
document.title = title;
};
}
} else {
throw "Unknown runtime environment. Where are we?";
}
function globalEval(x) {
eval.call(null, x);
}
if (!Module["load"] && Module["read"]) {
Module["load"] = function load(f) {
globalEval(Module["read"](f));
};
}
if (!Module["print"]) {
Module["print"] = function() {
};
}
if (!Module["printErr"]) {
Module["printErr"] = Module["print"];
}
if (!Module["arguments"]) {
Module["arguments"] = [];
}
if (!Module["thisProgram"]) {
Module["thisProgram"] = "./this.program";
}
if (!Module["quit"]) {
Module["quit"] = function(status, toThrow) {
throw toThrow;
};
}
Module.print = Module["print"];
Module.printErr = Module["printErr"];
Module["preRun"] = [];
Module["postRun"] = [];
for (var key in moduleOverrides) {
if (moduleOverrides.hasOwnProperty(key)) {
Module[key] = moduleOverrides[key];
}
}
moduleOverrides = void 0;
var Runtime = { setTempRet0: function(value) {
tempRet0 = value;
return value;
}, getTempRet0: function() {
return tempRet0;
}, stackSave: function() {
return STACKTOP;
}, stackRestore: function(stackTop) {
STACKTOP = stackTop;
}, getNativeTypeSize: function(type2) {
switch (type2) {
case "i1":
case "i8":
return 1;
case "i16":
return 2;
case "i32":
return 4;
case "i64":
return 8;
case "float":
return 4;
case "double":
return 8;
default: {
if (type2[type2.length - 1] === "*") {
return Runtime.QUANTUM_SIZE;
} else if (type2[0] === "i") {
var bits = parseInt(type2.substr(1));
assert(bits % 8 === 0);
return bits / 8;
} else {
return 0;
}
}
}
}, getNativeFieldSize: function(type2) {
return Math.max(Runtime.getNativeTypeSize(type2), Runtime.QUANTUM_SIZE);
}, STACK_ALIGN: 16, prepVararg: function(ptr2, type2) {
if (type2 === "double" || type2 === "i64") {
if (ptr2 & 7) {
assert((ptr2 & 7) === 4);
ptr2 += 4;
}
} else {
assert((ptr2 & 3) === 0);
}
return ptr2;
}, getAlignSize: function(type2, size, vararg) {
if (!vararg && (type2 == "i64" || type2 == "double"))
return 8;
if (!type2)
return Math.min(size, 8);
return Math.min(size || (type2 ? Runtime.getNativeFieldSize(type2) : 0), Runtime.QUANTUM_SIZE);
}, dynCall: function(sig, ptr2, args) {
if (args && args.length) {
return Module["dynCall_" + sig].apply(null, [ptr2].concat(args));
} else {
return Module["dynCall_" + sig].call(null, ptr2);
}
}, functionPointers: [], addFunction: function(func2) {
for (var i2 = 0; i2 < Runtime.functionPointers.length; i2++) {
if (!Runtime.functionPointers[i2]) {
Runtime.functionPointers[i2] = func2;
return 2 * (1 + i2);
}
}
throw "Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.";
}, removeFunction: function(index) {
Runtime.functionPointers[(index - 2) / 2] = null;
}, warnOnce: function(text) {
if (!Runtime.warnOnce.shown)
Runtime.warnOnce.shown = {};
if (!Runtime.warnOnce.shown[text]) {
Runtime.warnOnce.shown[text] = 1;
Module.printErr(text);
}
}, funcWrappers: {}, getFuncWrapper: function(func2, sig) {
if (!func2)
return;
assert(sig);
if (!Runtime.funcWrappers[sig]) {
Runtime.funcWrappers[sig] = {};
}
var sigCache = Runtime.funcWrappers[sig];
if (!sigCache[func2]) {
if (sig.length === 1) {
sigCache[func2] = function dynCall_wrapper() {
return Runtime.dynCall(sig, func2);
};
} else if (sig.length === 2) {
sigCache[func2] = function dynCall_wrapper(arg2) {
return Runtime.dynCall(sig, func2, [arg2]);
};
} else {
sigCache[func2] = function dynCall_wrapper() {
return Runtime.dynCall(sig, func2, Array.prototype.slice.call(arguments));
};
}
}
return sigCache[func2];
}, getCompilerSetting: function(name) {
throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work";
}, stackAlloc: function(size) {
var ret = STACKTOP;
STACKTOP = STACKTOP + size | 0;
STACKTOP = STACKTOP + 15 & -16;
return ret;
}, staticAlloc: function(size) {
var ret = STATICTOP;
STATICTOP = STATICTOP + size | 0;
STATICTOP = STATICTOP + 15 & -16;
return ret;
}, dynamicAlloc: function(size) {
var ret = HEAP32[DYNAMICTOP_PTR >> 2];
var end = (ret + size + 15 | 0) & -16;
HEAP32[DYNAMICTOP_PTR >> 2] = end;
if (end >= TOTAL_MEMORY) {
var success = enlargeMemory();
if (!success) {
HEAP32[DYNAMICTOP_PTR >> 2] = ret;
return 0;
}
}
return ret;
}, alignMemory: function(size, quantum) {
var ret = size = Math.ceil(size / (quantum ? quantum : 16)) * (quantum ? quantum : 16);
return ret;
}, makeBigInt: function(low, high, unsigned) {
var ret = unsigned ? +(low >>> 0) + +(high >>> 0) * 4294967296 : +(low >>> 0) + +(high | 0) * 4294967296;
return ret;
}, GLOBAL_BASE: 8, QUANTUM_SIZE: 4, __dummy__: 0 };
Module["Runtime"] = Runtime;
var ABORT = 0;
var EXITSTATUS = 0;
function assert(condition, text) {
if (!condition) {
abort("Assertion failed: " + text);
}
}
function getCFunc(ident) {
var func = Module["_" + ident];
if (!func) {
try {
func = eval("_" + ident);
} catch (e) {
}
}
assert(func, "Cannot call unknown function " + ident + " (perhaps LLVM optimizations or closure removed it?)");
return func;
}
var cwrap, ccall;
(function() {
var JSfuncs = { "stackSave": function() {
Runtime.stackSave();
}, "stackRestore": function() {
Runtime.stackRestore();
}, "arrayToC": function(arr) {
var ret = Runtime.stackAlloc(arr.length);
writeArrayToMemory(arr, ret);
return ret;
}, "stringToC": function(str) {
var ret = 0;
if (str !== null && str !== void 0 && str !== 0) {
var len = (str.length << 2) + 1;
ret = Runtime.stackAlloc(len);
stringToUTF8(str, ret, len);
}
return ret;
} };
var toC = { "string": JSfuncs["stringToC"], "array": JSfuncs["arrayToC"] };
ccall = function ccallFunc(ident2, returnType2, argTypes2, args, opts) {
var func2 = getCFunc(ident2);
var cArgs = [];
var stack = 0;
if (args) {
for (var i2 = 0; i2 < args.length; i2++) {
var converter = toC[argTypes2[i2]];
if (converter) {
if (stack === 0)
stack = Runtime.stackSave();
cArgs[i2] = converter(args[i2]);
} else {
cArgs[i2] = args[i2];
}
}
}
var ret = func2.apply(null, cArgs);
if (returnType2 === "string")
ret = Pointer_stringify(ret);
if (stack !== 0) {
if (opts && opts.async) {
EmterpreterAsync.asyncFinalizers.push(function() {
Runtime.stackRestore(stack);
});
return;
}
Runtime.stackRestore(stack);
}
return ret;
};
var sourceRegex = /^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
function parseJSFunc(jsfunc) {
var parsed = jsfunc.toString().match(sourceRegex).slice(1);
return { arguments: parsed[0], body: parsed[1], returnValue: parsed[2] };
}
var JSsource = null;
function ensureJSsource() {
if (!JSsource) {
JSsource = {};
for (var fun in JSfuncs) {
if (JSfuncs.hasOwnProperty(fun)) {
JSsource[fun] = parseJSFunc(JSfuncs[fun]);
}
}
}
}
cwrap = function cwrap(ident, returnType, argTypes) {
argTypes = argTypes || [];
var cfunc = getCFunc(ident);
var numericArgs = argTypes.every(function(type2) {
return type2 === "number";
});
var numericRet = returnType !== "string";
if (numericRet && numericArgs) {
return cfunc;
}
var argNames = argTypes.map(function(x, i2) {
return "$" + i2;
});
var funcstr = "(function(" + argNames.join(",") + ") {";
var nargs = argTypes.length;
if (!numericArgs) {
ensureJSsource();
funcstr += "var stack = " + JSsource["stackSave"].body + ";";
for (var i = 0; i < nargs; i++) {
var arg = argNames[i], type = argTypes[i];
if (type === "number")
continue;
var convertCode = JSsource[type + "ToC"];
funcstr += "var " + convertCode.arguments + " = " + arg + ";";
funcstr += convertCode.body + ";";
funcstr += arg + "=(" + convertCode.returnValue + ");";
}
}
var cfuncname = parseJSFunc(function() {
return cfunc;
}).returnValue;
funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");";
if (!numericRet) {
var strgfy = parseJSFunc(function() {
return Pointer_stringify;
}).returnValue;
funcstr += "ret = " + strgfy + "(ret);";
}
if (!numericArgs) {
ensureJSsource();
funcstr += JSsource["stackRestore"].body.replace("()", "(stack)") + ";";
}
funcstr += "return ret})";
return eval(funcstr);
};
})();
Module["ccall"] = ccall;
Module["cwrap"] = cwrap;
function setValue(ptr2, value, type2, noSafe) {
type2 = type2 || "i8";
if (type2.charAt(type2.length - 1) === "*")
type2 = "i32";
switch (type2) {
case "i1":
HEAP8[ptr2 >> 0] = value;
break;
case "i8":
HEAP8[ptr2 >> 0] = value;
break;
case "i16":
HEAP16[ptr2 >> 1] = value;
break;
case "i32":
HEAP32[ptr2 >> 2] = value;
break;
case "i64":
tempI64 = [value >>> 0, (tempDouble = value, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[ptr2 >> 2] = tempI64[0], HEAP32[ptr2 + 4 >> 2] = tempI64[1];
break;
case "float":
HEAPF32[ptr2 >> 2] = value;
break;
case "double":
HEAPF64[ptr2 >> 3] = value;
break;
default:
abort("invalid type for setValue: " + type2);
}
}
Module["setValue"] = setValue;
function getValue(ptr2, type2, noSafe) {
type2 = type2 || "i8";
if (type2.charAt(type2.length - 1) === "*")
type2 = "i32";
switch (type2) {
case "i1":
return HEAP8[ptr2 >> 0];
case "i8":
return HEAP8[ptr2 >> 0];
case "i16":
return HEAP16[ptr2 >> 1];
case "i32":
return HEAP32[ptr2 >> 2];
case "i64":
return HEAP32[ptr2 >> 2];
case "float":
return HEAPF32[ptr2 >> 2];
case "double":
return HEAPF64[ptr2 >> 3];
default:
abort("invalid type for setValue: " + type2);
}
return null;
}
Module["getValue"] = getValue;
var ALLOC_NORMAL = 0;
var ALLOC_STACK = 1;
var ALLOC_STATIC = 2;
var ALLOC_DYNAMIC = 3;
var ALLOC_NONE = 4;
Module["ALLOC_NORMAL"] = ALLOC_NORMAL;
Module["ALLOC_STACK"] = ALLOC_STACK;
Module["ALLOC_STATIC"] = ALLOC_STATIC;
Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC;
Module["ALLOC_NONE"] = ALLOC_NONE;
function allocate(slab, types, allocator, ptr2) {
var zeroinit, size;
if (typeof slab === "number") {
zeroinit = true;
size = slab;
} else {
zeroinit = false;
size = slab.length;
}
var singleType = typeof types === "string" ? types : null;
var ret;
if (allocator == ALLOC_NONE) {
ret = ptr2;
} else {
ret = [typeof _malloc === "function" ? _malloc : Runtime.staticAlloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === void 0 ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
}
if (zeroinit) {
var ptr2 = ret, stop;
assert((ret & 3) == 0);
stop = ret + (size & ~3);
for (; ptr2 < stop; ptr2 += 4) {
HEAP32[ptr2 >> 2] = 0;
}
stop = ret + size;
while (ptr2 < stop) {
HEAP8[ptr2++ >> 0] = 0;
}
return ret;
}
if (singleType === "i8") {
if (slab.subarray || slab.slice) {
HEAPU8.set(slab, ret);
} else {
HEAPU8.set(new Uint8Array(slab), ret);
}
return ret;
}
var i2 = 0, type2, typeSize, previousType;
while (i2 < size) {
var curr = slab[i2];
if (typeof curr === "function") {
curr = Runtime.getFunctionIndex(curr);
}
type2 = singleType || types[i2];
if (type2 === 0) {
i2++;
continue;
}
if (type2 == "i64")
type2 = "i32";
setValue(ret + i2, curr, type2);
if (previousType !== type2) {
typeSize = Runtime.getNativeTypeSize(type2);
previousType = type2;
}
i2 += typeSize;
}
return ret;
}
Module["allocate"] = allocate;
function getMemory(size) {
if (!staticSealed)
return Runtime.staticAlloc(size);
if (!runtimeInitialized)
return Runtime.dynamicAlloc(size);
return _malloc(size);
}
Module["getMemory"] = getMemory;
function Pointer_stringify(ptr2, length) {
if (length === 0 || !ptr2)
return "";
var hasUtf = 0;
var t;
var i2 = 0;
while (1) {
t = HEAPU8[ptr2 + i2 >> 0];
hasUtf |= t;
if (t == 0 && !length)
break;
i2++;
if (length && i2 == length)
break;
}
if (!length)
length = i2;
var ret = "";
if (hasUtf < 128) {
var MAX_CHUNK = 1024;
var curr;
while (length > 0) {
curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr2, ptr2 + Math.min(length, MAX_CHUNK)));
ret = ret ? ret + curr : curr;
ptr2 += MAX_CHUNK;
length -= MAX_CHUNK;
}
return ret;
}
return Module["UTF8ToString"](ptr2);
}
Module["Pointer_stringify"] = Pointer_stringify;
function AsciiToString(ptr2) {
var str = "";
while (1) {
var ch = HEAP8[ptr2++ >> 0];
if (!ch)
return str;
str += String.fromCharCode(ch);
}
}
Module["AsciiToString"] = AsciiToString;
function stringToAscii(str, outPtr) {
return writeAsciiToMemory(str, outPtr, false);
}
Module["stringToAscii"] = stringToAscii;
var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : void 0;
function UTF8ArrayToString(u8Array, idx) {
var endPtr = idx;
while (u8Array[endPtr])
++endPtr;
if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
} else {
var u0, u1, u2, u3, u4, u5;
var str = "";
while (1) {
u0 = u8Array[idx++];
if (!u0)
return str;
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
u1 = u8Array[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode((u0 & 31) << 6 | u1);
continue;
}
u2 = u8Array[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = (u0 & 15) << 12 | u1 << 6 | u2;
} else {
u3 = u8Array[idx++] & 63;
if ((u0 & 248) == 240) {
u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3;
} else {
u4 = u8Array[idx++] & 63;
if ((u0 & 252) == 248) {
u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4;
} else {
u5 = u8Array[idx++] & 63;
u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5;
}
}
}
if (u0 < 65536) {
str += String.fromCharCode(u0);
} else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
}
}
}
}
Module["UTF8ArrayToString"] = UTF8ArrayToString;
function UTF8ToString(ptr2) {
return UTF8ArrayToString(HEAPU8, ptr2);
}
Module["UTF8ToString"] = UTF8ToString;
function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
if (!(maxBytesToWrite > 0))
return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i2 = 0; i2 < str.length; ++i2) {
var u = str.charCodeAt(i2);
if (u >= 55296 && u <= 57343)
u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i2) & 1023;
if (u <= 127) {
if (outIdx >= endIdx)
break;
outU8Array[outIdx++] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx)
break;
outU8Array[outIdx++] = 192 | u >> 6;
outU8Array[outIdx++] = 128 | u & 63;
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx)
break;
outU8Array[outIdx++] = 224 | u >> 12;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63;
} else if (u <= 2097151) {
if (outIdx + 3 >= endIdx)
break;
outU8Array[outIdx++] = 240 | u >> 18;
outU8Array[outIdx++] = 128 | u >> 12 & 63;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63;
} else if (u <= 67108863) {
if (outIdx + 4 >= endIdx)
break;
outU8Array[outIdx++] = 248 | u >> 24;
outU8Array[outIdx++] = 128 | u >> 18 & 63;
outU8Array[outIdx++] = 128 | u >> 12 & 63;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63;
} else {
if (outIdx + 5 >= endIdx)
break;
outU8Array[outIdx++] = 252 | u >> 30;
outU8Array[outIdx++] = 128 | u >> 24 & 63;
outU8Array[outIdx++] = 128 | u >> 18 & 63;
outU8Array[outIdx++] = 128 | u >> 12 & 63;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63;
}
}
outU8Array[outIdx] = 0;
return outIdx - startIdx;
}
Module["stringToUTF8Array"] = stringToUTF8Array;
function stringToUTF8(str, outPtr, maxBytesToWrite) {
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}
Module["stringToUTF8"] = stringToUTF8;
function lengthBytesUTF8(str) {
var len = 0;
for (var i2 = 0; i2 < str.length; ++i2) {
var u = str.charCodeAt(i2);
if (u >= 55296 && u <= 57343)
u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i2) & 1023;
if (u <= 127) {
++len;
} else if (u <= 2047) {
len += 2;
} else if (u <= 65535) {
len += 3;
} else if (u <= 2097151) {
len += 4;
} else if (u <= 67108863) {
len += 5;
} else {
len += 6;
}
}
return len;
}
Module["lengthBytesUTF8"] = lengthBytesUTF8;
var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : void 0;
function demangle(func2) {
var __cxa_demangle_func = Module["___cxa_demangle"] || Module["__cxa_demangle"];
if (__cxa_demangle_func) {
try {
var s = func2.substr(1);
var len = lengthBytesUTF8(s) + 1;
var buf = _malloc(len);
stringToUTF8(s, buf, len);
var status = _malloc(4);
var ret = __cxa_demangle_func(buf, 0, 0, status);
if (getValue(status, "i32") === 0 && ret) {
return Pointer_stringify(ret);
}
} catch (e) {
} finally {
if (buf)
_free(buf);
if (status)
_free(status);
if (ret)
_free(ret);
}
return func2;
}
Runtime.warnOnce("warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling");
return func2;
}
function demangleAll(text) {
var regex = /__Z[\w\d_]+/g;
return text.replace(regex, function(x) {
var y = demangle(x);
return x === y ? x : x + " [" + y + "]";
});
}
function jsStackTrace() {
var err2 = new Error();
if (!err2.stack) {
try {
throw new Error(0);
} catch (e) {
err2 = e;
}
if (!err2.stack) {
return "(no stack trace available)";
}
}
return err2.stack.toString();
}
function stackTrace() {
var js2 = jsStackTrace();
if (Module["extraStackTrace"])
js2 += "\n" + Module["extraStackTrace"]();
return demangleAll(js2);
}
Module["stackTrace"] = stackTrace;
var HEAP, buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
function updateGlobalBufferViews() {
Module["HEAP8"] = HEAP8 = new Int8Array(buffer);
Module["HEAP16"] = HEAP16 = new Int16Array(buffer);
Module["HEAP32"] = HEAP32 = new Int32Array(buffer);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(buffer);
Module["HEAPU16"] = HEAPU16 = new Uint16Array(buffer);
Module["HEAPU32"] = HEAPU32 = new Uint32Array(buffer);
Module["HEAPF32"] = HEAPF32 = new Float32Array(buffer);
Module["HEAPF64"] = HEAPF64 = new Float64Array(buffer);
}
var STATIC_BASE, STATICTOP, staticSealed;
var STACK_BASE, STACKTOP, STACK_MAX;
var DYNAMIC_BASE, DYNAMICTOP_PTR;
STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;
staticSealed = false;
function abortOnCannotGrowMemory() {
abort("Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value " + TOTAL_MEMORY + ", (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime but prevents some optimizations, (3) set Module.TOTAL_MEMORY to a higher value before the program runs, or (4) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 ");
}
function enlargeMemory() {
abortOnCannotGrowMemory();
}
var TOTAL_STACK = Module["TOTAL_STACK"] || 5242880;
var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 134217728;
if (TOTAL_MEMORY < TOTAL_STACK)
Module.printErr("TOTAL_MEMORY should be larger than TOTAL_STACK, was " + TOTAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
if (Module["buffer"]) {
buffer = Module["buffer"];
} else {
{
buffer = new ArrayBuffer(TOTAL_MEMORY);
}
}
updateGlobalBufferViews();
function getTotalMemory() {
return TOTAL_MEMORY;
}
HEAP32[0] = 1668509029;
HEAP16[1] = 25459;
if (HEAPU8[2] !== 115 || HEAPU8[3] !== 99)
throw "Runtime error: expected the system to be little-endian!";
Module["HEAP"] = HEAP;
Module["buffer"] = buffer;
Module["HEAP8"] = HEAP8;
Module["HEAP16"] = HEAP16;
Module["HEAP32"] = HEAP32;
Module["HEAPU8"] = HEAPU8;
Module["HEAPU16"] = HEAPU16;
Module["HEAPU32"] = HEAPU32;
Module["HEAPF32"] = HEAPF32;
Module["HEAPF64"] = HEAPF64;
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
var callback = callbacks.shift();
if (typeof callback == "function") {
callback();
continue;
}
var func2 = callback.func;
if (typeof func2 === "number") {
if (callback.arg === void 0) {
Module["dynCall_v"](func2);
} else {
Module["dynCall_vi"](func2, callback.arg);
}
} else {
func2(callback.arg === void 0 ? null : callback.arg);
}
}
}
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATMAIN__ = [];
var __ATEXIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
var runtimeExited = 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 ensureInitRuntime() {
if (runtimeInitialized)
return;
runtimeInitialized = true;
callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__);
}
function exitRuntime() {
callRuntimeCallbacks(__ATEXIT__);
runtimeExited = true;
}
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(cb2) {
__ATPRERUN__.unshift(cb2);
}
Module["addOnPreRun"] = addOnPreRun;
function addOnInit(cb2) {
__ATINIT__.unshift(cb2);
}
Module["addOnInit"] = addOnInit;
function addOnPreMain(cb2) {
__ATMAIN__.unshift(cb2);
}
Module["addOnPreMain"] = addOnPreMain;
function addOnExit(cb2) {
__ATEXIT__.unshift(cb2);
}
Module["addOnExit"] = addOnExit;
function addOnPostRun(cb2) {
__ATPOSTRUN__.unshift(cb2);
}
Module["addOnPostRun"] = addOnPostRun;
function intArrayFromString(stringy, dontAddNull, length) {
var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
var u8array = new Array(len);
var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
if (dontAddNull)
u8array.length = numBytesWritten;
return u8array;
}
Module["intArrayFromString"] = intArrayFromString;
function intArrayToString(array) {
var ret = [];
for (var i2 = 0; i2 < array.length; i2++) {
var chr = array[i2];
if (chr > 255) {
chr &= 255;
}
ret.push(String.fromCharCode(chr));
}
return ret.join("");
}
Module["intArrayToString"] = intArrayToString;
function writeStringToMemory(string, buffer2, dontAddNull) {
Runtime.warnOnce("writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!");
var lastChar, end;
if (dontAddNull) {
end = buffer2 + lengthBytesUTF8(string);
lastChar = HEAP8[end];
}
stringToUTF8(string, buffer2, Infinity);
if (dontAddNull)
HEAP8[end] = lastChar;
}
Module["writeStringToMemory"] = writeStringToMemory;
function writeArrayToMemory(array, buffer2) {
HEAP8.set(array, buffer2);
}
Module["writeArrayToMemory"] = writeArrayToMemory;
function writeAsciiToMemory(str, buffer2, dontAddNull) {
for (var i2 = 0; i2 < str.length; ++i2) {
HEAP8[buffer2++ >> 0] = str.charCodeAt(i2);
}
if (!dontAddNull)
HEAP8[buffer2 >> 0] = 0;
}
Module["writeAsciiToMemory"]