@shotstack/shotstack-canvas 1.4.6 → 1.4.7

package/dist/chunk-HYGMWVDX.js

@@ -0,0 +1,19 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __require,
+  __commonJS,
+  __publicField
+};

package/dist/entry.node.cjs

@@ -293,6 +293,23 @@ function setupWasmInterceptors(wasmBinary) {
     }
     return originalFetch.apply(this, [input, init]);
   };
+  const originalInstantiate = WebAssembly.instantiate;
+  WebAssembly.instantiate = async function(bufferSourceOrModule, importObject) {
+    console.log(
+      `\u{1F504} WebAssembly.instantiate called, type: ${bufferSourceOrModule instanceof WebAssembly.Module ? "Module" : "BufferSource"}`
+    );
+    if (bufferSourceOrModule instanceof WebAssembly.Module) {
+      return originalInstantiate.call(WebAssembly, bufferSourceOrModule, importObject);
+    }
+    console.log(`\u{1F504} Intercepted WebAssembly.instantiate, using pre-loaded WASM binary`);
+    const module2 = await WebAssembly.compile(wasmBinary);
+    const instance = await originalInstantiate.call(
+      WebAssembly,
+      module2,
+      importObject
+    );
+    return { module: module2, instance };
+  };
   const originalInstantiateStreaming = WebAssembly.instantiateStreaming;
   if (originalInstantiateStreaming) {
     WebAssembly.instantiateStreaming = async function(source, importObject) {
@@ -330,21 +347,25 @@ async function initHB(wasmBaseURL) {
     console.log(`\u2705 WASM binary loaded successfully (${wasmBinary.byteLength} bytes)`);
     if (!isNode()) {
       setupWasmInterceptors(wasmBinary);
-    }
-    const mod = await import("harfbuzzjs");
-    let hb;
-    const candidate = mod.default || mod;
-    if (typeof candidate === "function") {
-      hb = await candidate({
-        wasmBinary
-      });
-    } else if (candidate && typeof candidate.then === "function") {
-      hb = await candidate;
-    } else if (candidate && typeof candidate.createBuffer === "function") {
-      hb = candidate;
-    } else {
-      throw new Error(`Unexpected harfbuzzjs export type: ${typeof candidate}`);
-    }
+      window.Module = {
+        wasmBinary,
+        locateFile: (path) => {
+          console.log(`\u{1F50D} locateFile called for: ${path}`);
+          return path;
+        }
+      };
+      console.log(`\u{1F30D} Set global Module.wasmBinary (${wasmBinary.byteLength} bytes)`);
+    }
+    console.log("\u{1F504} Importing harfbuzzjs/hb.js (factory)");
+    const hbModule = await import("harfbuzzjs/hb.js");
+    const hbFactory = hbModule.default || hbModule;
+    console.log("\u{1F504} Calling hb factory with wasmBinary");
+    const hbInstance = await hbFactory({ wasmBinary });
+    console.log("\u{1F504} Importing harfbuzzjs/hbjs.js (wrapper)");
+    const hbjsModule = await import("harfbuzzjs/hbjs.js");
+    const hbjsWrapper = hbjsModule.default || hbjsModule;
+    console.log("\u{1F504} Wrapping hb instance");
+    const hb = hbjsWrapper(hbInstance);
     if (!hb || typeof hb.createBuffer !== "function" || typeof hb.createFont !== "function") {
       throw new Error("Failed to initialize HarfBuzz: unexpected export shape from 'harfbuzzjs'.");
     }

package/dist/entry.node.js

@@ -254,6 +254,23 @@ function setupWasmInterceptors(wasmBinary) {
     }
     return originalFetch.apply(this, [input, init]);
   };
+  const originalInstantiate = WebAssembly.instantiate;
+  WebAssembly.instantiate = async function(bufferSourceOrModule, importObject) {
+    console.log(
+      `\u{1F504} WebAssembly.instantiate called, type: ${bufferSourceOrModule instanceof WebAssembly.Module ? "Module" : "BufferSource"}`
+    );
+    if (bufferSourceOrModule instanceof WebAssembly.Module) {
+      return originalInstantiate.call(WebAssembly, bufferSourceOrModule, importObject);
+    }
+    console.log(`\u{1F504} Intercepted WebAssembly.instantiate, using pre-loaded WASM binary`);
+    const module = await WebAssembly.compile(wasmBinary);
+    const instance = await originalInstantiate.call(
+      WebAssembly,
+      module,
+      importObject
+    );
+    return { module, instance };
+  };
   const originalInstantiateStreaming = WebAssembly.instantiateStreaming;
   if (originalInstantiateStreaming) {
     WebAssembly.instantiateStreaming = async function(source, importObject) {
@@ -291,21 +308,25 @@ async function initHB(wasmBaseURL) {
     console.log(`\u2705 WASM binary loaded successfully (${wasmBinary.byteLength} bytes)`);
     if (!isNode()) {
       setupWasmInterceptors(wasmBinary);
-    }
-    const mod = await import("harfbuzzjs");
-    let hb;
-    const candidate = mod.default || mod;
-    if (typeof candidate === "function") {
-      hb = await candidate({
-        wasmBinary
-      });
-    } else if (candidate && typeof candidate.then === "function") {
-      hb = await candidate;
-    } else if (candidate && typeof candidate.createBuffer === "function") {
-      hb = candidate;
-    } else {
-      throw new Error(`Unexpected harfbuzzjs export type: ${typeof candidate}`);
-    }
+      window.Module = {
+        wasmBinary,
+        locateFile: (path) => {
+          console.log(`\u{1F50D} locateFile called for: ${path}`);
+          return path;
+        }
+      };
+      console.log(`\u{1F30D} Set global Module.wasmBinary (${wasmBinary.byteLength} bytes)`);
+    }
+    console.log("\u{1F504} Importing harfbuzzjs/hb.js (factory)");
+    const hbModule = await import("harfbuzzjs/hb.js");
+    const hbFactory = hbModule.default || hbModule;
+    console.log("\u{1F504} Calling hb factory with wasmBinary");
+    const hbInstance = await hbFactory({ wasmBinary });
+    console.log("\u{1F504} Importing harfbuzzjs/hbjs.js (wrapper)");
+    const hbjsModule = await import("harfbuzzjs/hbjs.js");
+    const hbjsWrapper = hbjsModule.default || hbjsModule;
+    console.log("\u{1F504} Wrapping hb instance");
+    const hb = hbjsWrapper(hbInstance);
     if (!hb || typeof hb.createBuffer !== "function" || typeof hb.createFont !== "function") {
       throw new Error("Failed to initialize HarfBuzz: unexpected export shape from 'harfbuzzjs'.");
     }

package/dist/entry.web.js

@@ -1,6 +1,6 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import {
+  __publicField
+} from "./chunk-HYGMWVDX.js";
 
 // src/schema/asset-schema.ts
 import Joi from "joi";
@@ -258,6 +258,23 @@ function setupWasmInterceptors(wasmBinary) {
     }
     return originalFetch.apply(this, [input, init]);
   };
+  const originalInstantiate = WebAssembly.instantiate;
+  WebAssembly.instantiate = async function(bufferSourceOrModule, importObject) {
+    console.log(
+      `\u{1F504} WebAssembly.instantiate called, type: ${bufferSourceOrModule instanceof WebAssembly.Module ? "Module" : "BufferSource"}`
+    );
+    if (bufferSourceOrModule instanceof WebAssembly.Module) {
+      return originalInstantiate.call(WebAssembly, bufferSourceOrModule, importObject);
+    }
+    console.log(`\u{1F504} Intercepted WebAssembly.instantiate, using pre-loaded WASM binary`);
+    const module = await WebAssembly.compile(wasmBinary);
+    const instance = await originalInstantiate.call(
+      WebAssembly,
+      module,
+      importObject
+    );
+    return { module, instance };
+  };
   const originalInstantiateStreaming = WebAssembly.instantiateStreaming;
   if (originalInstantiateStreaming) {
     WebAssembly.instantiateStreaming = async function(source, importObject) {
@@ -295,21 +312,25 @@ async function initHB(wasmBaseURL) {
     console.log(`\u2705 WASM binary loaded successfully (${wasmBinary.byteLength} bytes)`);
     if (!isNode()) {
       setupWasmInterceptors(wasmBinary);
-    }
-    const mod = await import("harfbuzzjs");
-    let hb;
-    const candidate = mod.default || mod;
-    if (typeof candidate === "function") {
-      hb = await candidate({
-        wasmBinary
-      });
-    } else if (candidate && typeof candidate.then === "function") {
-      hb = await candidate;
-    } else if (candidate && typeof candidate.createBuffer === "function") {
-      hb = candidate;
-    } else {
-      throw new Error(`Unexpected harfbuzzjs export type: ${typeof candidate}`);
-    }
+      window.Module = {
+        wasmBinary,
+        locateFile: (path) => {
+          console.log(`\u{1F50D} locateFile called for: ${path}`);
+          return path;
+        }
+      };
+      console.log(`\u{1F30D} Set global Module.wasmBinary (${wasmBinary.byteLength} bytes)`);
+    }
+    console.log("\u{1F504} Importing harfbuzzjs/hb.js (factory)");
+    const hbModule = await import("./hb-KXF2MJ2J.js");
+    const hbFactory = hbModule.default || hbModule;
+    console.log("\u{1F504} Calling hb factory with wasmBinary");
+    const hbInstance = await hbFactory({ wasmBinary });
+    console.log("\u{1F504} Importing harfbuzzjs/hbjs.js (wrapper)");
+    const hbjsModule = await import("./hbjs-ZTRARROF.js");
+    const hbjsWrapper = hbjsModule.default || hbjsModule;
+    console.log("\u{1F504} Wrapping hb instance");
+    const hb = hbjsWrapper(hbInstance);
     if (!hb || typeof hb.createBuffer !== "function" || typeof hb.createFont !== "function") {
       throw new Error("Failed to initialize HarfBuzz: unexpected export shape from 'harfbuzzjs'.");
     }

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();

package/dist/hbjs-ZTRARROF.js

@@ -0,0 +1,499 @@
+import {
+  __commonJS
+} from "./chunk-HYGMWVDX.js";
+
+// node_modules/harfbuzzjs/hbjs.js
+var require_hbjs = __commonJS({
+  "node_modules/harfbuzzjs/hbjs.js"(exports, module) {
+    function hbjs(Module) {
+      "use strict";
+      var exports2 = Module.wasmExports;
+      var utf8Decoder = new TextDecoder("utf8");
+      let addFunction = Module.addFunction;
+      let removeFunction = Module.removeFunction;
+      var freeFuncPtr = addFunction(function(ptr) {
+        exports2.free(ptr);
+      }, "vi");
+      var HB_MEMORY_MODE_WRITABLE = 2;
+      var HB_SET_VALUE_INVALID = -1;
+      var HB_BUFFER_CONTENT_TYPE_GLYPHS = 2;
+      var DONT_STOP = 0;
+      var GSUB_PHASE = 1;
+      var GPOS_PHASE = 2;
+      function hb_tag(s) {
+        return (s.charCodeAt(0) & 255) << 24 | (s.charCodeAt(1) & 255) << 16 | (s.charCodeAt(2) & 255) << 8 | (s.charCodeAt(3) & 255) << 0;
+      }
+      var HB_BUFFER_SERIALIZE_FORMAT_JSON = hb_tag("JSON");
+      var HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES = 4;
+      function _hb_untag(tag) {
+        return [
+          String.fromCharCode(tag >> 24 & 255),
+          String.fromCharCode(tag >> 16 & 255),
+          String.fromCharCode(tag >> 8 & 255),
+          String.fromCharCode(tag >> 0 & 255)
+        ].join("");
+      }
+      function _buffer_flag(s) {
+        if (s == "BOT") {
+          return 1;
+        }
+        if (s == "EOT") {
+          return 2;
+        }
+        if (s == "PRESERVE_DEFAULT_IGNORABLES") {
+          return 4;
+        }
+        if (s == "REMOVE_DEFAULT_IGNORABLES") {
+          return 8;
+        }
+        if (s == "DO_NOT_INSERT_DOTTED_CIRCLE") {
+          return 16;
+        }
+        if (s == "PRODUCE_UNSAFE_TO_CONCAT") {
+          return 64;
+        }
+        return 0;
+      }
+      function createBlob(blob) {
+        var blobPtr = exports2.malloc(blob.byteLength);
+        Module.HEAPU8.set(new Uint8Array(blob), blobPtr);
+        var ptr = exports2.hb_blob_create(blobPtr, blob.byteLength, HB_MEMORY_MODE_WRITABLE, blobPtr, freeFuncPtr);
+        return {
+          ptr,
+          /**
+          * Free the object.
+          */
+          destroy: function() {
+            exports2.hb_blob_destroy(ptr);
+          }
+        };
+      }
+      function typedArrayFromSet(setPtr) {
+        const setCount = exports2.hb_set_get_population(setPtr);
+        const arrayPtr = exports2.malloc(setCount << 2);
+        const arrayOffset = arrayPtr >> 2;
+        const array = Module.HEAPU32.subarray(arrayOffset, arrayOffset + setCount);
+        Module.HEAPU32.set(array, arrayOffset);
+        exports2.hb_set_next_many(setPtr, HB_SET_VALUE_INVALID, arrayPtr, setCount);
+        return array;
+      }
+      function createFace(blob, index) {
+        var ptr = exports2.hb_face_create(blob.ptr, index);
+        const upem = exports2.hb_face_get_upem(ptr);
+        return {
+          ptr,
+          upem,
+          /**
+           * Return the binary contents of an OpenType table.
+           * @param {string} table Table name
+           */
+          reference_table: function(table) {
+            var blob2 = exports2.hb_face_reference_table(ptr, hb_tag(table));
+            var length = exports2.hb_blob_get_length(blob2);
+            if (!length) {
+              return;
+            }
+            var blobptr = exports2.hb_blob_get_data(blob2, null);
+            var table_string = Module.HEAPU8.subarray(blobptr, blobptr + length);
+            return table_string;
+          },
+          /**
+           * Return variation axis infos
+           */
+          getAxisInfos: function() {
+            var axis = exports2.malloc(64 * 32);
+            var c = exports2.malloc(4);
+            Module.HEAPU32[c / 4] = 64;
+            exports2.hb_ot_var_get_axis_infos(ptr, 0, c, axis);
+            var result = {};
+            Array.from({ length: Module.HEAPU32[c / 4] }).forEach(function(_, i) {
+              result[_hb_untag(Module.HEAPU32[axis / 4 + i * 8 + 1])] = {
+                min: Module.HEAPF32[axis / 4 + i * 8 + 4],
+                default: Module.HEAPF32[axis / 4 + i * 8 + 5],
+                max: Module.HEAPF32[axis / 4 + i * 8 + 6]
+              };
+            });
+            exports2.free(c);
+            exports2.free(axis);
+            return result;
+          },
+          /**
+           * Return unicodes the face supports
+           */
+          collectUnicodes: function() {
+            var unicodeSetPtr = exports2.hb_set_create();
+            exports2.hb_face_collect_unicodes(ptr, unicodeSetPtr);
+            var result = typedArrayFromSet(unicodeSetPtr);
+            exports2.hb_set_destroy(unicodeSetPtr);
+            return result;
+          },
+          /**
+           * Free the object.
+           */
+          destroy: function() {
+            exports2.hb_face_destroy(ptr);
+          }
+        };
+      }
+      var pathBuffer = "";
+      var nameBufferSize = 256;
+      var nameBuffer = exports2.malloc(nameBufferSize);
+      function createFont(face) {
+        var ptr = exports2.hb_font_create(face.ptr);
+        var drawFuncsPtr = null;
+        var moveToPtr = null;
+        var lineToPtr = null;
+        var cubicToPtr = null;
+        var quadToPtr = null;
+        var closePathPtr = null;
+        function glyphToPath(glyphId) {
+          if (!drawFuncsPtr) {
+            var moveTo = function(dfuncs, draw_data, draw_state, to_x, to_y, user_data) {
+              pathBuffer += `M${to_x},${to_y}`;
+            };
+            var lineTo = function(dfuncs, draw_data, draw_state, to_x, to_y, user_data) {
+              pathBuffer += `L${to_x},${to_y}`;
+            };
+            var cubicTo = function(dfuncs, draw_data, draw_state, c1_x, c1_y, c2_x, c2_y, to_x, to_y, user_data) {
+              pathBuffer += `C${c1_x},${c1_y} ${c2_x},${c2_y} ${to_x},${to_y}`;
+            };
+            var quadTo = function(dfuncs, draw_data, draw_state, c_x, c_y, to_x, to_y, user_data) {
+              pathBuffer += `Q${c_x},${c_y} ${to_x},${to_y}`;
+            };
+            var closePath = function(dfuncs, draw_data, draw_state, user_data) {
+              pathBuffer += "Z";
+            };
+            moveToPtr = addFunction(moveTo, "viiiffi");
+            lineToPtr = addFunction(lineTo, "viiiffi");
+            cubicToPtr = addFunction(cubicTo, "viiiffffffi");
+            quadToPtr = addFunction(quadTo, "viiiffffi");
+            closePathPtr = addFunction(closePath, "viiii");
+            drawFuncsPtr = exports2.hb_draw_funcs_create();
+            exports2.hb_draw_funcs_set_move_to_func(drawFuncsPtr, moveToPtr, 0, 0);
+            exports2.hb_draw_funcs_set_line_to_func(drawFuncsPtr, lineToPtr, 0, 0);
+            exports2.hb_draw_funcs_set_cubic_to_func(drawFuncsPtr, cubicToPtr, 0, 0);
+            exports2.hb_draw_funcs_set_quadratic_to_func(drawFuncsPtr, quadToPtr, 0, 0);
+            exports2.hb_draw_funcs_set_close_path_func(drawFuncsPtr, closePathPtr, 0, 0);
+          }
+          pathBuffer = "";
+          exports2.hb_font_draw_glyph(ptr, glyphId, drawFuncsPtr, 0);
+          return pathBuffer;
+        }
+        function glyphName(glyphId) {
+          exports2.hb_font_glyph_to_string(
+            ptr,
+            glyphId,
+            nameBuffer,
+            nameBufferSize
+          );
+          var array = Module.HEAPU8.subarray(nameBuffer, nameBuffer + nameBufferSize);
+          return utf8Decoder.decode(array.slice(0, array.indexOf(0)));
+        }
+        return {
+          ptr,
+          glyphName,
+          glyphToPath,
+          /**
+          * Return a glyph as a JSON path string
+          * based on format described on https://svgwg.org/specs/paths/#InterfaceSVGPathSegment
+          * @param {number} glyphId ID of the requested glyph in the font.
+          **/
+          glyphToJson: function(glyphId) {
+            var path = glyphToPath(glyphId);
+            return path.replace(/([MLQCZ])/g, "|$1 ").split("|").filter(function(x) {
+              return x.length;
+            }).map(function(x) {
+              var row = x.split(/[ ,]/g);
+              return { type: row[0], values: row.slice(1).filter(function(x2) {
+                return x2.length;
+              }).map(function(x2) {
+                return +x2;
+              }) };
+            });
+          },
+          /**
+          * Set the font's scale factor, affecting the position values returned from
+          * shaping.
+          * @param {number} xScale Units to scale in the X dimension.
+          * @param {number} yScale Units to scale in the Y dimension.
+          **/
+          setScale: function(xScale, yScale) {
+            exports2.hb_font_set_scale(ptr, xScale, yScale);
+          },
+          /**
+           * Set the font's variations.
+           * @param {object} variations Dictionary of variations to set
+           **/
+          setVariations: function(variations) {
+            var entries = Object.entries(variations);
+            var vars = exports2.malloc(8 * entries.length);
+            entries.forEach(function(entry, i) {
+              Module.HEAPU32[vars / 4 + i * 2 + 0] = hb_tag(entry[0]);
+              Module.HEAPF32[vars / 4 + i * 2 + 1] = entry[1];
+            });
+            exports2.hb_font_set_variations(ptr, vars, entries.length);
+            exports2.free(vars);
+          },
+          /**
+          * Free the object.
+          */
+          destroy: function() {
+            exports2.hb_font_destroy(ptr);
+            if (drawFuncsPtr) {
+              exports2.hb_draw_funcs_destroy(drawFuncsPtr);
+              drawFuncsPtr = null;
+              removeFunction(moveToPtr);
+              removeFunction(lineToPtr);
+              removeFunction(cubicToPtr);
+              removeFunction(quadToPtr);
+              removeFunction(closePathPtr);
+            }
+          }
+        };
+      }
+      function createAsciiString(text) {
+        var ptr = exports2.malloc(text.length + 1);
+        for (let i = 0; i < text.length; ++i) {
+          const char = text.charCodeAt(i);
+          if (char > 127) throw new Error("Expected ASCII text");
+          Module.HEAPU8[ptr + i] = char;
+        }
+        Module.HEAPU8[ptr + text.length] = 0;
+        return {
+          ptr,
+          length: text.length,
+          free: function() {
+            exports2.free(ptr);
+          }
+        };
+      }
+      function createJsString(text) {
+        const ptr = exports2.malloc(text.length * 2);
+        const words = new Uint16Array(Module.wasmMemory.buffer, ptr, text.length);
+        for (let i = 0; i < words.length; ++i) words[i] = text.charCodeAt(i);
+        return {
+          ptr,
+          length: words.length,
+          free: function() {
+            exports2.free(ptr);
+          }
+        };
+      }
+      function createBuffer() {
+        var ptr = exports2.hb_buffer_create();
+        return {
+          ptr,
+          /**
+          * Add text to the buffer.
+          * @param {string} text Text to be added to the buffer.
+          **/
+          addText: function(text) {
+            const str = createJsString(text);
+            exports2.hb_buffer_add_utf16(ptr, str.ptr, str.length, 0, str.length);
+            str.free();
+          },
+          /**
+          * Set buffer script, language and direction.
+          *
+          * This needs to be done before shaping.
+          **/
+          guessSegmentProperties: function() {
+            return exports2.hb_buffer_guess_segment_properties(ptr);
+          },
+          /**
+          * Set buffer direction explicitly.
+          * @param {string} direction: One of "ltr", "rtl", "ttb" or "btt"
+          */
+          setDirection: function(dir) {
+            exports2.hb_buffer_set_direction(ptr, {
+              ltr: 4,
+              rtl: 5,
+              ttb: 6,
+              btt: 7
+            }[dir] || 0);
+          },
+          /**
+          * Set buffer flags explicitly.
+          * @param {string[]} flags: A list of strings which may be either:
+          * "BOT"
+          * "EOT"
+          * "PRESERVE_DEFAULT_IGNORABLES"
+          * "REMOVE_DEFAULT_IGNORABLES"
+          * "DO_NOT_INSERT_DOTTED_CIRCLE"
+          * "PRODUCE_UNSAFE_TO_CONCAT"
+          */
+          setFlags: function(flags) {
+            var flagValue = 0;
+            flags.forEach(function(s) {
+              flagValue |= _buffer_flag(s);
+            });
+            exports2.hb_buffer_set_flags(ptr, flagValue);
+          },
+          /**
+          * Set buffer language explicitly.
+          * @param {string} language: The buffer language
+          */
+          setLanguage: function(language) {
+            var str = createAsciiString(language);
+            exports2.hb_buffer_set_language(ptr, exports2.hb_language_from_string(str.ptr, -1));
+            str.free();
+          },
+          /**
+          * Set buffer script explicitly.
+          * @param {string} script: The buffer script
+          */
+          setScript: function(script) {
+            var str = createAsciiString(script);
+            exports2.hb_buffer_set_script(ptr, exports2.hb_script_from_string(str.ptr, -1));
+            str.free();
+          },
+          /**
+          * Set the Harfbuzz clustering level.
+          *
+          * Affects the cluster values returned from shaping.
+          * @param {number} level: Clustering level. See the Harfbuzz manual chapter
+          * on Clusters.
+          **/
+          setClusterLevel: function(level) {
+            exports2.hb_buffer_set_cluster_level(ptr, level);
+          },
+          /**
+          * Return the buffer contents as a JSON object.
+          *
+          * After shaping, this function will return an array of glyph information
+          * objects. Each object will have the following attributes:
+          *
+          *   - g: The glyph ID
+          *   - cl: The cluster ID
+          *   - ax: Advance width (width to advance after this glyph is painted)
+          *   - ay: Advance height (height to advance after this glyph is painted)
+          *   - dx: X displacement (adjustment in X dimension when painting this glyph)
+          *   - dy: Y displacement (adjustment in Y dimension when painting this glyph)
+          *   - flags: Glyph flags like `HB_GLYPH_FLAG_UNSAFE_TO_BREAK` (0x1)
+          **/
+          json: function() {
+            var length = exports2.hb_buffer_get_length(ptr);
+            var result = [];
+            var infosPtr = exports2.hb_buffer_get_glyph_infos(ptr, 0);
+            var infosPtr32 = infosPtr / 4;
+            var positionsPtr32 = exports2.hb_buffer_get_glyph_positions(ptr, 0) / 4;
+            var infos = Module.HEAPU32.subarray(infosPtr32, infosPtr32 + 5 * length);
+            var positions = Module.HEAP32.subarray(positionsPtr32, positionsPtr32 + 5 * length);
+            for (var i = 0; i < length; ++i) {
+              result.push({
+                g: infos[i * 5 + 0],
+                cl: infos[i * 5 + 2],
+                ax: positions[i * 5 + 0],
+                ay: positions[i * 5 + 1],
+                dx: positions[i * 5 + 2],
+                dy: positions[i * 5 + 3],
+                flags: exports2.hb_glyph_info_get_glyph_flags(infosPtr + i * 20)
+              });
+            }
+            return result;
+          },
+          /**
+          * Free the object.
+          */
+          destroy: function() {
+            exports2.hb_buffer_destroy(ptr);
+          }
+        };
+      }
+      function shape(font, buffer, features) {
+        var featuresPtr = 0;
+        var featuresLen = 0;
+        if (features) {
+          features = features.split(",");
+          featuresPtr = exports2.malloc(16 * features.length);
+          features.forEach(function(feature, i) {
+            var str = createAsciiString(feature);
+            if (exports2.hb_feature_from_string(str.ptr, -1, featuresPtr + featuresLen * 16))
+              featuresLen++;
+            str.free();
+          });
+        }
+        exports2.hb_shape(font.ptr, buffer.ptr, featuresPtr, featuresLen);
+        if (featuresPtr)
+          exports2.free(featuresPtr);
+      }
+      function shapeWithTrace(font, buffer, features, stop_at, stop_phase) {
+        var trace = [];
+        var currentPhase = DONT_STOP;
+        var stopping = false;
+        var failure = false;
+        var traceBufLen = 1024 * 1024;
+        var traceBufPtr = exports2.malloc(traceBufLen);
+        var traceFunc = function(bufferPtr, fontPtr, messagePtr, user_data) {
+          var message = utf8Decoder.decode(Module.HEAPU8.subarray(messagePtr, Module.HEAPU8.indexOf(0, messagePtr)));
+          if (message.startsWith("start table GSUB"))
+            currentPhase = GSUB_PHASE;
+          else if (message.startsWith("start table GPOS"))
+            currentPhase = GPOS_PHASE;
+          if (currentPhase != stop_phase)
+            stopping = false;
+          if (failure)
+            return 1;
+          if (stop_phase != DONT_STOP && currentPhase == stop_phase && message.startsWith("end lookup " + stop_at))
+            stopping = true;
+          if (stopping)
+            return 0;
+          exports2.hb_buffer_serialize_glyphs(
+            bufferPtr,
+            0,
+            exports2.hb_buffer_get_length(bufferPtr),
+            traceBufPtr,
+            traceBufLen,
+            0,
+            fontPtr,
+            HB_BUFFER_SERIALIZE_FORMAT_JSON,
+            HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES
+          );
+          trace.push({
+            m: message,
+            t: JSON.parse(utf8Decoder.decode(Module.HEAPU8.subarray(traceBufPtr, Module.HEAPU8.indexOf(0, traceBufPtr)))),
+            glyphs: exports2.hb_buffer_get_content_type(bufferPtr) == HB_BUFFER_CONTENT_TYPE_GLYPHS
+          });
+          return 1;
+        };
+        var traceFuncPtr = addFunction(traceFunc, "iiiii");
+        exports2.hb_buffer_set_message_func(buffer.ptr, traceFuncPtr, 0, 0);
+        shape(font, buffer, features, 0);
+        exports2.free(traceBufPtr);
+        removeFunction(traceFuncPtr);
+        return trace;
+      }
+      function version() {
+        var versionPtr = exports2.malloc(12);
+        exports2.hb_version(versionPtr, versionPtr + 4, versionPtr + 8);
+        var version2 = {
+          major: Module.HEAPU32[versionPtr / 4],
+          minor: Module.HEAPU32[(versionPtr + 4) / 4],
+          micro: Module.HEAPU32[(versionPtr + 8) / 4]
+        };
+        exports2.free(versionPtr);
+        return version2;
+      }
+      function version_string() {
+        var versionPtr = exports2.hb_version_string();
+        var version2 = utf8Decoder.decode(Module.HEAPU8.subarray(versionPtr, Module.HEAPU8.indexOf(0, versionPtr)));
+        return version2;
+      }
+      return {
+        createBlob,
+        createFace,
+        createFont,
+        createBuffer,
+        shape,
+        shapeWithTrace,
+        version,
+        version_string
+      };
+    }
+    try {
+      module.exports = hbjs;
+    } catch (e) {
+    }
+  }
+});
+export default require_hbjs();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shotstack/shotstack-canvas",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "Text layout & animation engine (HarfBuzz) for Node & Web - fully self-contained.",
   "type": "module",
   "main": "./dist/entry.node.cjs",