@shotstack/shotstack-canvas 1.4.6 → 1.5.0

package/dist/hb-KXF2MJ2J.js

@@ -0,0 +1,550 @@
+import {
+  __commonJS,
+  __publicField,
+  __require
+} from "./chunk-HYGMWVDX.js";
+
+// node_modules/harfbuzzjs/hb.js
+var require_hb = __commonJS({
+  "node_modules/harfbuzzjs/hb.js"(exports, module) {
+    var createHarfBuzz = (() => {
+      var _scriptName = typeof document != "undefined" ? document.currentScript?.src : void 0;
+      return async function(moduleArg = {}) {
+        var moduleRtn;
+        var Module = moduleArg;
+        var ENVIRONMENT_IS_WEB = typeof window == "object";
+        var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
+        var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions?.node && process.type != "renderer";
+        var arguments_ = [];
+        var thisProgram = "./this.program";
+        var quit_ = (status, toThrow) => {
+          throw toThrow;
+        };
+        if (typeof __filename != "undefined") {
+          _scriptName = __filename;
+        } else if (ENVIRONMENT_IS_WORKER) {
+          _scriptName = self.location.href;
+        }
+        var scriptDirectory = "";
+        function locateFile(path) {
+          if (Module["locateFile"]) {
+            return Module["locateFile"](path, scriptDirectory);
+          }
+          return scriptDirectory + path;
+        }
+        var readAsync, readBinary;
+        if (ENVIRONMENT_IS_NODE) {
+          var fs = __require("fs");
+          scriptDirectory = __dirname + "/";
+          readBinary = (filename) => {
+            filename = isFileURI(filename) ? new URL(filename) : filename;
+            var ret = fs.readFileSync(filename);
+            return ret;
+          };
+          readAsync = async (filename, binary = true) => {
+            filename = isFileURI(filename) ? new URL(filename) : filename;
+            var ret = fs.readFileSync(filename, binary ? void 0 : "utf8");
+            return ret;
+          };
+          if (process.argv.length > 1) {
+            thisProgram = process.argv[1].replace(/\\/g, "/");
+          }
+          arguments_ = process.argv.slice(2);
+          quit_ = (status, toThrow) => {
+            process.exitCode = status;
+            throw toThrow;
+          };
+        } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+          try {
+            scriptDirectory = new URL(".", _scriptName).href;
+          } catch {
+          }
+          {
+            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 = async (url) => {
+              if (isFileURI(url)) {
+                return new Promise((resolve, reject) => {
+                  var xhr = new XMLHttpRequest();
+                  xhr.open("GET", url, true);
+                  xhr.responseType = "arraybuffer";
+                  xhr.onload = () => {
+                    if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+                      resolve(xhr.response);
+                      return;
+                    }
+                    reject(xhr.status);
+                  };
+                  xhr.onerror = reject;
+                  xhr.send(null);
+                });
+              }
+              var response = await fetch(url, { credentials: "same-origin" });
+              if (response.ok) {
+                return response.arrayBuffer();
+              }
+              throw new Error(response.status + " : " + response.url);
+            };
+          }
+        } else {
+        }
+        var out = console.log.bind(console);
+        var err = console.error.bind(console);
+        var wasmBinary;
+        var ABORT = false;
+        var EXITSTATUS;
+        var isFileURI = (filename) => filename.startsWith("file://");
+        var readyPromiseResolve, readyPromiseReject;
+        var wasmMemory;
+        var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+        var HEAP64, HEAPU64;
+        var runtimeInitialized = false;
+        function updateMemoryViews() {
+          var b = wasmMemory.buffer;
+          Module["HEAP8"] = HEAP8 = new Int8Array(b);
+          HEAP16 = new Int16Array(b);
+          Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+          HEAPU16 = new Uint16Array(b);
+          Module["HEAP32"] = HEAP32 = new Int32Array(b);
+          Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
+          Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
+          HEAPF64 = new Float64Array(b);
+          HEAP64 = new BigInt64Array(b);
+          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["__wasm_call_ctors"]();
+        }
+        function postRun() {
+          if (Module["postRun"]) {
+            if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
+            while (Module["postRun"].length) {
+              addOnPostRun(Module["postRun"].shift());
+            }
+          }
+          callRuntimeCallbacks(onPostRuns);
+        }
+        var runDependencies = 0;
+        var dependenciesFulfilled = null;
+        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;
+        }
+        var wasmBinaryFile;
+        function findWasmBinary() {
+          return locateFile("hb.wasm");
+        }
+        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 && !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 { env: wasmImports, wasi_snapshot_preview1: wasmImports };
+        }
+        async function createWasm() {
+          function receiveInstance(instance, module2) {
+            wasmExports = instance.exports;
+            Module["wasmExports"] = wasmExports;
+            wasmMemory = wasmExports["memory"];
+            Module["wasmMemory"] = wasmMemory;
+            updateMemoryViews();
+            wasmTable = wasmExports["__indirect_function_table"];
+            assignWasmExports(wasmExports);
+            removeRunDependency("wasm-instantiate");
+            return wasmExports;
+          }
+          addRunDependency("wasm-instantiate");
+          function receiveInstantiationResult(result2) {
+            return receiveInstance(result2["instance"]);
+          }
+          var info = getWasmImports();
+          if (Module["instantiateWasm"]) {
+            return new Promise((resolve, reject) => {
+              Module["instantiateWasm"](info, (mod, inst) => {
+                resolve(receiveInstance(mod, inst));
+              });
+            });
+          }
+          wasmBinaryFile ?? (wasmBinaryFile = findWasmBinary());
+          var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+          var exports2 = receiveInstantiationResult(result);
+          return exports2;
+        }
+        class ExitStatus {
+          constructor(status) {
+            __publicField(this, "name", "ExitStatus");
+            this.message = `Program terminated with exit(${status})`;
+            this.status = status;
+          }
+        }
+        var callRuntimeCallbacks = (callbacks) => {
+          while (callbacks.length > 0) {
+            callbacks.shift()(Module);
+          }
+        };
+        var onPostRuns = [];
+        var addOnPostRun = (cb) => onPostRuns.push(cb);
+        var onPreRuns = [];
+        var addOnPreRun = (cb) => onPreRuns.push(cb);
+        var noExitRuntime = true;
+        var __abort_js = () => abort("");
+        var runtimeKeepaliveCounter = 0;
+        var __emscripten_runtime_keepalive_clear = () => {
+          noExitRuntime = false;
+          runtimeKeepaliveCounter = 0;
+        };
+        var timers = {};
+        var handleException = (e) => {
+          if (e instanceof ExitStatus || e == "unwind") {
+            return EXITSTATUS;
+          }
+          quit_(1, e);
+        };
+        var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+        var _proc_exit = (code) => {
+          EXITSTATUS = code;
+          if (!keepRuntimeAlive()) {
+            Module["onExit"]?.(code);
+            ABORT = true;
+          }
+          quit_(code, new ExitStatus(code));
+        };
+        var exitJS = (status, implicit) => {
+          EXITSTATUS = status;
+          _proc_exit(status);
+        };
+        var _exit = exitJS;
+        var maybeExit = () => {
+          if (!keepRuntimeAlive()) {
+            try {
+              _exit(EXITSTATUS);
+            } catch (e) {
+              handleException(e);
+            }
+          }
+        };
+        var callUserCallback = (func) => {
+          if (ABORT) {
+            return;
+          }
+          try {
+            func();
+            maybeExit();
+          } catch (e) {
+            handleException(e);
+          }
+        };
+        var _emscripten_get_now = () => performance.now();
+        var __setitimer_js = (which, timeout_ms) => {
+          if (timers[which]) {
+            clearTimeout(timers[which].id);
+            delete timers[which];
+          }
+          if (!timeout_ms) return 0;
+          var id = setTimeout(() => {
+            delete timers[which];
+            callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now()));
+          }, timeout_ms);
+          timers[which] = { id, timeout_ms };
+          return 0;
+        };
+        var getHeapMax = () => 2147483648;
+        var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+        var growMemory = (size) => {
+          var oldHeapSize = wasmMemory.buffer.byteLength;
+          var pages = (size - oldHeapSize + 65535) / 65536 | 0;
+          try {
+            wasmMemory.grow(pages);
+            updateMemoryViews();
+            return 1;
+          } catch (e) {
+          }
+        };
+        var _emscripten_resize_heap = (requestedSize) => {
+          var oldSize = HEAPU8.length;
+          requestedSize >>>= 0;
+          var maxHeapSize = getHeapMax();
+          if (requestedSize > maxHeapSize) {
+            return false;
+          }
+          for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+            var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+            overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+            var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+            var replacement = growMemory(newSize);
+            if (replacement) {
+              return true;
+            }
+          }
+          return false;
+        };
+        var uleb128EncodeWithLen = (arr) => {
+          const n = arr.length;
+          return [n % 128 | 128, n >> 7, ...arr];
+        };
+        var wasmTypeCodes = { i: 127, p: 127, j: 126, f: 125, d: 124, e: 111 };
+        var generateTypePack = (types) => uleb128EncodeWithLen(Array.from(types, (type) => {
+          var code = wasmTypeCodes[type];
+          return code;
+        }));
+        var convertJsFunctionToWasm = (func, sig) => {
+          var bytes = Uint8Array.of(0, 97, 115, 109, 1, 0, 0, 0, 1, ...uleb128EncodeWithLen([1, 96, ...generateTypePack(sig.slice(1)), ...generateTypePack(sig[0] === "v" ? "" : sig[0])]), 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+          var module2 = new WebAssembly.Module(bytes);
+          var instance = new WebAssembly.Instance(module2, { e: { f: func } });
+          var wrappedFunc = instance.exports["f"];
+          return wrappedFunc;
+        };
+        var wasmTable;
+        var getWasmTableEntry = (funcPtr) => wasmTable.get(funcPtr);
+        var updateTableMap = (offset, count) => {
+          if (functionsInTableMap) {
+            for (var i = offset; i < offset + count; i++) {
+              var item = getWasmTableEntry(i);
+              if (item) {
+                functionsInTableMap.set(item, i);
+              }
+            }
+          }
+        };
+        var functionsInTableMap;
+        var getFunctionAddress = (func) => {
+          if (!functionsInTableMap) {
+            functionsInTableMap = /* @__PURE__ */ new WeakMap();
+            updateTableMap(0, wasmTable.length);
+          }
+          return functionsInTableMap.get(func) || 0;
+        };
+        var freeTableIndexes = [];
+        var getEmptyTableSlot = () => {
+          if (freeTableIndexes.length) {
+            return freeTableIndexes.pop();
+          }
+          return wasmTable["grow"](1);
+        };
+        var setWasmTableEntry = (idx, func) => wasmTable.set(idx, func);
+        var addFunction = (func, sig) => {
+          var rtn = getFunctionAddress(func);
+          if (rtn) {
+            return rtn;
+          }
+          var ret = getEmptyTableSlot();
+          try {
+            setWasmTableEntry(ret, func);
+          } catch (err2) {
+            if (!(err2 instanceof TypeError)) {
+              throw err2;
+            }
+            var wrapped = convertJsFunctionToWasm(func, sig);
+            setWasmTableEntry(ret, wrapped);
+          }
+          functionsInTableMap.set(func, ret);
+          return ret;
+        };
+        var removeFunction = (index) => {
+          functionsInTableMap.delete(getWasmTableEntry(index));
+          setWasmTableEntry(index, null);
+          freeTableIndexes.push(index);
+        };
+        {
+          if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
+          if (Module["print"]) out = Module["print"];
+          if (Module["printErr"]) err = Module["printErr"];
+          if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+          if (Module["arguments"]) arguments_ = Module["arguments"];
+          if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+        }
+        Module["wasmMemory"] = wasmMemory;
+        Module["wasmExports"] = wasmExports;
+        Module["addFunction"] = addFunction;
+        Module["removeFunction"] = removeFunction;
+        var _hb_blob_create, _hb_blob_destroy, _hb_blob_get_length, _hb_blob_get_data, _hb_buffer_serialize_glyphs, _hb_buffer_create, _hb_buffer_destroy, _hb_buffer_get_content_type, _hb_buffer_set_direction, _hb_buffer_set_script, _hb_buffer_set_language, _hb_buffer_set_flags, _hb_buffer_set_cluster_level, _hb_buffer_get_length, _hb_buffer_get_glyph_infos, _hb_buffer_get_glyph_positions, _hb_glyph_info_get_glyph_flags, _hb_buffer_guess_segment_properties, _hb_buffer_add_utf8, _hb_buffer_add_utf16, _hb_buffer_set_message_func, _hb_language_from_string, _hb_script_from_string, _hb_version, _hb_version_string, _hb_feature_from_string, _malloc, _free, _hb_draw_funcs_set_move_to_func, _hb_draw_funcs_set_line_to_func, _hb_draw_funcs_set_quadratic_to_func, _hb_draw_funcs_set_cubic_to_func, _hb_draw_funcs_set_close_path_func, _hb_draw_funcs_create, _hb_draw_funcs_destroy, _hb_face_create, _hb_face_destroy, _hb_face_reference_table, _hb_face_get_upem, _hb_face_collect_unicodes, _hb_font_draw_glyph, _hb_font_glyph_to_string, _hb_font_create, _hb_font_set_variations, _hb_font_destroy, _hb_font_set_scale, _hb_set_create, _hb_set_destroy, _hb_ot_var_get_axis_infos, _hb_set_get_population, _hb_set_next_many, _hb_shape, __emscripten_timeout;
+        function assignWasmExports(wasmExports2) {
+          Module["_hb_blob_create"] = _hb_blob_create = wasmExports2["hb_blob_create"];
+          Module["_hb_blob_destroy"] = _hb_blob_destroy = wasmExports2["hb_blob_destroy"];
+          Module["_hb_blob_get_length"] = _hb_blob_get_length = wasmExports2["hb_blob_get_length"];
+          Module["_hb_blob_get_data"] = _hb_blob_get_data = wasmExports2["hb_blob_get_data"];
+          Module["_hb_buffer_serialize_glyphs"] = _hb_buffer_serialize_glyphs = wasmExports2["hb_buffer_serialize_glyphs"];
+          Module["_hb_buffer_create"] = _hb_buffer_create = wasmExports2["hb_buffer_create"];
+          Module["_hb_buffer_destroy"] = _hb_buffer_destroy = wasmExports2["hb_buffer_destroy"];
+          Module["_hb_buffer_get_content_type"] = _hb_buffer_get_content_type = wasmExports2["hb_buffer_get_content_type"];
+          Module["_hb_buffer_set_direction"] = _hb_buffer_set_direction = wasmExports2["hb_buffer_set_direction"];
+          Module["_hb_buffer_set_script"] = _hb_buffer_set_script = wasmExports2["hb_buffer_set_script"];
+          Module["_hb_buffer_set_language"] = _hb_buffer_set_language = wasmExports2["hb_buffer_set_language"];
+          Module["_hb_buffer_set_flags"] = _hb_buffer_set_flags = wasmExports2["hb_buffer_set_flags"];
+          Module["_hb_buffer_set_cluster_level"] = _hb_buffer_set_cluster_level = wasmExports2["hb_buffer_set_cluster_level"];
+          Module["_hb_buffer_get_length"] = _hb_buffer_get_length = wasmExports2["hb_buffer_get_length"];
+          Module["_hb_buffer_get_glyph_infos"] = _hb_buffer_get_glyph_infos = wasmExports2["hb_buffer_get_glyph_infos"];
+          Module["_hb_buffer_get_glyph_positions"] = _hb_buffer_get_glyph_positions = wasmExports2["hb_buffer_get_glyph_positions"];
+          Module["_hb_glyph_info_get_glyph_flags"] = _hb_glyph_info_get_glyph_flags = wasmExports2["hb_glyph_info_get_glyph_flags"];
+          Module["_hb_buffer_guess_segment_properties"] = _hb_buffer_guess_segment_properties = wasmExports2["hb_buffer_guess_segment_properties"];
+          Module["_hb_buffer_add_utf8"] = _hb_buffer_add_utf8 = wasmExports2["hb_buffer_add_utf8"];
+          Module["_hb_buffer_add_utf16"] = _hb_buffer_add_utf16 = wasmExports2["hb_buffer_add_utf16"];
+          Module["_hb_buffer_set_message_func"] = _hb_buffer_set_message_func = wasmExports2["hb_buffer_set_message_func"];
+          Module["_hb_language_from_string"] = _hb_language_from_string = wasmExports2["hb_language_from_string"];
+          Module["_hb_script_from_string"] = _hb_script_from_string = wasmExports2["hb_script_from_string"];
+          Module["_hb_version"] = _hb_version = wasmExports2["hb_version"];
+          Module["_hb_version_string"] = _hb_version_string = wasmExports2["hb_version_string"];
+          Module["_hb_feature_from_string"] = _hb_feature_from_string = wasmExports2["hb_feature_from_string"];
+          Module["_malloc"] = _malloc = wasmExports2["malloc"];
+          Module["_free"] = _free = wasmExports2["free"];
+          Module["_hb_draw_funcs_set_move_to_func"] = _hb_draw_funcs_set_move_to_func = wasmExports2["hb_draw_funcs_set_move_to_func"];
+          Module["_hb_draw_funcs_set_line_to_func"] = _hb_draw_funcs_set_line_to_func = wasmExports2["hb_draw_funcs_set_line_to_func"];
+          Module["_hb_draw_funcs_set_quadratic_to_func"] = _hb_draw_funcs_set_quadratic_to_func = wasmExports2["hb_draw_funcs_set_quadratic_to_func"];
+          Module["_hb_draw_funcs_set_cubic_to_func"] = _hb_draw_funcs_set_cubic_to_func = wasmExports2["hb_draw_funcs_set_cubic_to_func"];
+          Module["_hb_draw_funcs_set_close_path_func"] = _hb_draw_funcs_set_close_path_func = wasmExports2["hb_draw_funcs_set_close_path_func"];
+          Module["_hb_draw_funcs_create"] = _hb_draw_funcs_create = wasmExports2["hb_draw_funcs_create"];
+          Module["_hb_draw_funcs_destroy"] = _hb_draw_funcs_destroy = wasmExports2["hb_draw_funcs_destroy"];
+          Module["_hb_face_create"] = _hb_face_create = wasmExports2["hb_face_create"];
+          Module["_hb_face_destroy"] = _hb_face_destroy = wasmExports2["hb_face_destroy"];
+          Module["_hb_face_reference_table"] = _hb_face_reference_table = wasmExports2["hb_face_reference_table"];
+          Module["_hb_face_get_upem"] = _hb_face_get_upem = wasmExports2["hb_face_get_upem"];
+          Module["_hb_face_collect_unicodes"] = _hb_face_collect_unicodes = wasmExports2["hb_face_collect_unicodes"];
+          Module["_hb_font_draw_glyph"] = _hb_font_draw_glyph = wasmExports2["hb_font_draw_glyph"];
+          Module["_hb_font_glyph_to_string"] = _hb_font_glyph_to_string = wasmExports2["hb_font_glyph_to_string"];
+          Module["_hb_font_create"] = _hb_font_create = wasmExports2["hb_font_create"];
+          Module["_hb_font_set_variations"] = _hb_font_set_variations = wasmExports2["hb_font_set_variations"];
+          Module["_hb_font_destroy"] = _hb_font_destroy = wasmExports2["hb_font_destroy"];
+          Module["_hb_font_set_scale"] = _hb_font_set_scale = wasmExports2["hb_font_set_scale"];
+          Module["_hb_set_create"] = _hb_set_create = wasmExports2["hb_set_create"];
+          Module["_hb_set_destroy"] = _hb_set_destroy = wasmExports2["hb_set_destroy"];
+          Module["_hb_ot_var_get_axis_infos"] = _hb_ot_var_get_axis_infos = wasmExports2["hb_ot_var_get_axis_infos"];
+          Module["_hb_set_get_population"] = _hb_set_get_population = wasmExports2["hb_set_get_population"];
+          Module["_hb_set_next_many"] = _hb_set_next_many = wasmExports2["hb_set_next_many"];
+          Module["_hb_shape"] = _hb_shape = wasmExports2["hb_shape"];
+          __emscripten_timeout = wasmExports2["_emscripten_timeout"];
+        }
+        var wasmImports = { _abort_js: __abort_js, _emscripten_runtime_keepalive_clear: __emscripten_runtime_keepalive_clear, _setitimer_js: __setitimer_js, emscripten_resize_heap: _emscripten_resize_heap, proc_exit: _proc_exit };
+        var wasmExports = await createWasm();
+        function run() {
+          if (runDependencies > 0) {
+            dependenciesFulfilled = run;
+            return;
+          }
+          preRun();
+          if (runDependencies > 0) {
+            dependenciesFulfilled = run;
+            return;
+          }
+          function doRun() {
+            Module["calledRun"] = true;
+            if (ABORT) return;
+            initRuntime();
+            readyPromiseResolve?.(Module);
+            Module["onRuntimeInitialized"]?.();
+            postRun();
+          }
+          if (Module["setStatus"]) {
+            Module["setStatus"]("Running...");
+            setTimeout(() => {
+              setTimeout(() => Module["setStatus"](""), 1);
+              doRun();
+            }, 1);
+          } else {
+            doRun();
+          }
+        }
+        function preInit() {
+          if (Module["preInit"]) {
+            if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
+            while (Module["preInit"].length > 0) {
+              Module["preInit"].shift()();
+            }
+          }
+        }
+        preInit();
+        run();
+        if (runtimeInitialized) {
+          moduleRtn = Module;
+        } else {
+          moduleRtn = new Promise((resolve, reject) => {
+            readyPromiseResolve = resolve;
+            readyPromiseReject = reject;
+          });
+        }
+        ;
+        return moduleRtn;
+      };
+    })();
+    if (typeof exports === "object" && typeof module === "object") {
+      module.exports = createHarfBuzz;
+      module.exports.default = createHarfBuzz;
+    } else if (typeof define === "function" && define["amd"]) define([], () => createHarfBuzz);
+  }
+});
+export default require_hb();