@shotstack/shotstack-canvas 1.4.6 → 1.5.0

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,62 +1,62 @@
-{
-  "name": "@shotstack/shotstack-canvas",
-  "version": "1.4.6",
-  "description": "Text layout & animation engine (HarfBuzz) for Node & Web - fully self-contained.",
-  "type": "module",
-  "main": "./dist/entry.node.cjs",
-  "module": "./dist/entry.node.js",
-  "browser": "./dist/entry.web.js",
-  "types": "./dist/entry.node.d.ts",
-  "exports": {
-    ".": {
-      "node": {
-        "import": "./dist/entry.node.js",
-        "require": "./dist/entry.node.cjs"
-      },
-      "browser": "./dist/entry.web.js",
-      "default": "./dist/entry.web.js"
-    }
-  },
-  "files": [
-    "dist/**",
-    "scripts/postinstall.js",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "dev": "tsup --watch",
-    "build": "tsup",
-    "postinstall": "node scripts/postinstall.js",
-    "vendor:harfbuzz": "node scripts/vendor-harfbuzz.js",
-    "example:node": "node examples/node-example.mjs",
-    "example:video": "node examples/node-video.mjs",
-    "example:web": "vite dev examples/web-example",
-    "prepublishOnly": "npm run build"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "sideEffects": false,
-  "dependencies": {
-    "canvas": "npm:@napi-rs/canvas@^0.1.54",
-    "ffmpeg-static": "^5.2.0",
-    "fontkit": "^2.0.4",
-    "harfbuzzjs": "0.4.12",
-    "joi": "^17.13.3",
-    "opentype.js": "^1.3.4"
-  },
-  "devDependencies": {
-    "@types/fluent-ffmpeg": "2.1.27",
-    "@types/node": "^20.14.10",
-    "fluent-ffmpeg": "^2.1.3",
-    "tsup": "^8.2.3",
-    "typescript": "^5.5.3",
-    "vite": "^5.3.3",
-    "vite-plugin-top-level-await": "1.6.0",
-    "vite-plugin-wasm": "3.5.0"
-  }
-}
+{
+  "name": "@shotstack/shotstack-canvas",
+  "version": "1.5.0",
+  "description": "Text layout & animation engine (HarfBuzz) for Node & Web - fully self-contained.",
+  "type": "module",
+  "main": "./dist/entry.node.cjs",
+  "module": "./dist/entry.node.js",
+  "browser": "./dist/entry.web.js",
+  "types": "./dist/entry.node.d.ts",
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./dist/entry.node.js",
+        "require": "./dist/entry.node.cjs"
+      },
+      "browser": "./dist/entry.web.js",
+      "default": "./dist/entry.web.js"
+    }
+  },
+  "files": [
+    "dist/**",
+    "scripts/postinstall.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "postinstall": "node scripts/postinstall.js",
+    "vendor:harfbuzz": "node scripts/vendor-harfbuzz.js",
+    "example:node": "node examples/node-example.mjs",
+    "example:video": "node examples/node-video.mjs",
+    "example:web": "vite dev examples/web-example",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "canvas": "npm:@napi-rs/canvas@^0.1.54",
+    "ffmpeg-static": "^5.2.0",
+    "fontkit": "^2.0.4",
+    "harfbuzzjs": "0.4.12",
+    "joi": "^17.13.3",
+    "opentype.js": "^1.3.4"
+  },
+  "devDependencies": {
+    "@types/fluent-ffmpeg": "2.1.27",
+    "@types/node": "^20.14.10",
+    "fluent-ffmpeg": "^2.1.3",
+    "tsup": "^8.2.3",
+    "typescript": "^5.5.3",
+    "vite": "^5.3.3",
+    "vite-plugin-top-level-await": "1.6.0",
+    "vite-plugin-wasm": "3.5.0"
+  }
+}