@shopify/react-native-skia 2.2.21 → 2.3.4

package/cpp/skia/src/base/SkTLazy.h

@@ -13,6 +13,14 @@
 #include <optional>
 #include <utility>
 
+template <typename T> T* SkOptAddressOrNull(std::optional<T>& object) {
+    return object.has_value() ? &object.value() :  nullptr;
+}
+
+template <typename T> const T* SkOptAddressOrNull(const std::optional<T>& object) {
+    return object.has_value() ? &object.value() :  nullptr;
+}
+
 /**
  *  Efficient way to defer allocating/initializing a class until it is needed
  *  (if ever).

package/cpp/skia/src/core/SkLRUCache.h

@@ -24,11 +24,12 @@ template <typename K, typename V, typename HashK = SkGoodHash, typename PurgeCB
 class SkLRUCache {
 private:
     struct Entry {
-        Entry(const K& key, V&& value)
-            : fKey(key)
-            , fValue(std::move(value)) {}
+        template<typename K1, typename V1>
+        Entry(K1&& key, V1&& value)
+            : fKey(std::forward<K1>(key))
+            , fValue(std::forward<V1>(value)) {}
 
-        K fKey;
+        const K fKey;
         V fValue;
 
         SK_DECLARE_INTERNAL_LLIST_INTERFACE(Entry);
@@ -66,10 +67,7 @@ public:
         return &entry->fValue;
     }
 
-    V* insert(const K& key, V value) {
-        SkASSERT(!this->find(key));
-
-        Entry* entry = new Entry(key, std::move(value));
+    V* insert(Entry* entry) {
         fMap.set(entry);
         fLRU.addToHead(entry);
         while (fMap.count() > fMaxCount) {
@@ -78,20 +76,26 @@ public:
         return &entry->fValue;
     }
 
-    V* insert_or_update(const K& key, V value) {
+    template<typename K1, typename V1>
+    V* insert(K1&& key, V1&& value) {
+        SkASSERT(!this->find(key));
+        return this->insert(new Entry(std::forward<K1>(key), std::forward<V1>(value)));
+    }
+
+    template<typename K1, typename V1>
+    V* insert_or_update(K1&& key, V1&& value) {
         if (V* found = this->find(key)) {
-            *found = std::move(value);
+            *found = std::forward<V1>(value);
             return found;
-        } else {
-            return this->insert(key, std::move(value));
         }
+        return this->insert(new Entry(std::forward<K1>(key), std::forward<V1>(value)));
     }
 
     int count() const {
         return fMap.count();
     }
 
-    template <typename Fn>  // f(K*, V*)
+    template <typename Fn>  // f(const K*, V*)
     void foreach(Fn&& fn) {
         typename SkTInternalLList<Entry>::Iter iter;
         for (Entry* e = iter.init(fLRU, SkTInternalLList<Entry>::Iter::kHead_IterStart); e;

package/lib/commonjs/skia/types/SVG/SVGFactory.d.ts

@@ -1,6 +1,7 @@
 import type { SkData } from "../Data";
+import type { SkFontMgr } from "../Font/FontMgr";
 import type { SkSVG } from "./SVG";
 export interface SVGFactory {
-    MakeFromData(data: SkData): SkSVG | null;
-    MakeFromString(str: string): SkSVG | null;
+    MakeFromData(data: SkData, fontMgr?: SkFontMgr | null, assets?: Record<string, SkData | null>): SkSVG | null;
+    MakeFromString(str: string, fontMgr?: SkFontMgr | null, assets?: Record<string, SkData | null>): SkSVG | null;
 }

package/lib/commonjs/skia/types/SVG/SVGFactory.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["SVGFactory.ts"],"sourcesContent":["import type { SkData } from \"../Data\";\n\nimport type { SkSVG } from \"./SVG\";\n\nexport interface SVGFactory {\n  MakeFromData(data: SkData): SkSVG | null;\n  MakeFromString(str: string): SkSVG | null;\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["SVGFactory.ts"],"sourcesContent":["import type { SkData } from \"../Data\";\nimport type { SkFontMgr } from \"../Font/FontMgr\";\n\nimport type { SkSVG } from \"./SVG\";\n\nexport interface SVGFactory {\n  MakeFromData(\n    data: SkData,\n    fontMgr?: SkFontMgr | null,\n    assets?: Record<string, SkData | null>\n  ): SkSVG | null;\n  MakeFromString(\n    str: string,\n    fontMgr?: SkFontMgr | null,\n    assets?: Record<string, SkData | null>\n  ): SkSVG | null;\n}\n"],"mappings":"","ignoreList":[]}

package/lib/module/skia/types/SVG/SVGFactory.d.ts

@@ -1,6 +1,7 @@
 import type { SkData } from "../Data";
+import type { SkFontMgr } from "../Font/FontMgr";
 import type { SkSVG } from "./SVG";
 export interface SVGFactory {
-    MakeFromData(data: SkData): SkSVG | null;
-    MakeFromString(str: string): SkSVG | null;
+    MakeFromData(data: SkData, fontMgr?: SkFontMgr | null, assets?: Record<string, SkData | null>): SkSVG | null;
+    MakeFromString(str: string, fontMgr?: SkFontMgr | null, assets?: Record<string, SkData | null>): SkSVG | null;
 }

package/lib/module/skia/types/SVG/SVGFactory.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["SVGFactory.ts"],"sourcesContent":["import type { SkData } from \"../Data\";\n\nimport type { SkSVG } from \"./SVG\";\n\nexport interface SVGFactory {\n  MakeFromData(data: SkData): SkSVG | null;\n  MakeFromString(str: string): SkSVG | null;\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["SVGFactory.ts"],"sourcesContent":["import type { SkData } from \"../Data\";\nimport type { SkFontMgr } from \"../Font/FontMgr\";\n\nimport type { SkSVG } from \"./SVG\";\n\nexport interface SVGFactory {\n  MakeFromData(\n    data: SkData,\n    fontMgr?: SkFontMgr | null,\n    assets?: Record<string, SkData | null>\n  ): SkSVG | null;\n  MakeFromString(\n    str: string,\n    fontMgr?: SkFontMgr | null,\n    assets?: Record<string, SkData | null>\n  ): SkSVG | null;\n}\n"],"mappings":"","ignoreList":[]}

package/lib/typescript/src/skia/types/SVG/SVGFactory.d.ts

@@ -1,6 +1,7 @@
 import type { SkData } from "../Data";
+import type { SkFontMgr } from "../Font/FontMgr";
 import type { SkSVG } from "./SVG";
 export interface SVGFactory {
-    MakeFromData(data: SkData): SkSVG | null;
-    MakeFromString(str: string): SkSVG | null;
+    MakeFromData(data: SkData, fontMgr?: SkFontMgr | null, assets?: Record<string, SkData | null>): SkSVG | null;
+    MakeFromString(str: string, fontMgr?: SkFontMgr | null, assets?: Record<string, SkData | null>): SkSVG | null;
 }

package/package.json

@@ -8,31 +8,32 @@
     "setup-skia-web": "scripts/setup-canvaskit.js"
   },
   "title": "React Native Skia",
-  "version": "2.2.21",
+  "version": "2.3.4",
+  "skiaVersion": "m142",
   "description": "High-performance React Native Graphics using Skia",
   "main": "lib/module/index.js",
   "react-native": "src/index.ts",
   "module": "lib/module/index.js",
   "types": "lib/typescript/index.d.ts",
   "files": [
+    "scripts/install-skia.mjs",
+    "scripts/setup-canvaskit.js",
     "src/**",
     "lib/**",
+    "!**/__tests__/**",
     "README.md",
     "LICENSE.md",
     "android/build.gradle",
     "android/CMakeLists.txt",
     "android/cpp/**",
     "android/src/**",
-    "libs/android/**",
     "index.js",
     "jestSetup.js",
     "jestSetup.mjs",
     "jestEnv.js",
     "cpp/**/*.{h,cpp}",
     "apple/**",
-    "libs/apple/*.xcframework/**",
     "react-native-skia.podspec",
-    "scripts/setup-canvaskit.js",
     "dist/**"
   ],
   "scripts": {
@@ -45,13 +46,14 @@
     "clean-skia": "yarn rimraf ./libs && yarn rimraf ../../externals/skia/out",
     "build-skia": "tsx ./scripts/build-skia.ts",
     "copy-skia-headers": "tsx ./scripts/copy-skia-headers.ts",
-    "install-skia": "tsx ./scripts/download-artifacts.ts && yarn copy-skia-headers",
+    "install-skia": "node ./scripts/install-skia.mjs && yarn copy-skia-headers",
     "clang-format": "yarn clang-format-ios && yarn clang-format-android && yarn clang-format-common",
     "clang-format-ios": "find apple/ -iname '*.h' -o -iname '*.mm' -o -iname '*.cpp' | xargs clang-format -i",
     "clang-format-android": "find android/cpp/ -iname '*.h' -o -iname '*.m' -o -iname '*.cpp' | xargs clang-format -i",
     "clang-format-common": "find cpp/ \\( -path 'cpp//skia' -prune \\) -o \\( -iname '*.h' -o -iname '*.m' -o -iname '*.cpp' \\) -print | xargs clang-format -i",
     "workflow-copy-libs": "tsx ./scripts/workflow-copy-libs.ts",
-    "cpplint": "cpplint --linelength=230 --filter=-legal/copyright,-whitespace/indent,-whitespace/comments,-whitespace/ending_newline,-build/include_order,-runtime/references,-readability/todo,-whitespace/blank_line,-whitespace/todo,-runtime/int,-build/c++11,-whitespace/parens --exclude=package/cpp/skia --exclude=package/ios --exclude=package/android/build --exclude=package/node_modules --recursive package"
+    "cpplint": "cpplint --linelength=230 --filter=-legal/copyright,-whitespace/indent,-whitespace/comments,-whitespace/ending_newline,-build/include_order,-runtime/references,-readability/todo,-whitespace/blank_line,-whitespace/todo,-runtime/int,-build/c++11,-whitespace/parens --exclude=package/cpp/skia --exclude=package/ios --exclude=package/android/build --exclude=package/node_modules --recursive package",
+    "postinstall": "node ./scripts/install-skia.mjs"
   },
   "repository": {
     "type": "git",
@@ -91,12 +93,12 @@
   "devDependencies": {
     "@babel/plugin-proposal-nullish-coalescing-operator": "7.18.6",
     "@babel/plugin-transform-explicit-resource-management": "^7.28.0",
+    "@blazediff/core": "^1.4.0",
     "@semantic-release/commit-analyzer": "^13.0.0",
     "@semantic-release/exec": "^7.0.3",
     "@semantic-release/github": "^10.3.3",
     "@semantic-release/release-notes-generator": "^14.0.1",
     "@types/jest": "30.0.0",
-    "@types/pixelmatch": "5.2.4",
     "@types/pngjs": "6.0.1",
     "@types/react": "^19.0.0",
     "@types/react-reconciler": "0.28.9",
@@ -108,7 +110,6 @@
     "jest": "30.0.0",
     "jest-diff": "29.7.0",
     "merge-dirs": "0.2.1",
-    "pixelmatch": "5.3.0",
     "pngjs": "6.0.0",
     "prettier": "2.8.7",
     "react": "19.0.0",

package/react-native-skia.podspec

@@ -60,8 +60,7 @@ base_frameworks = ['libs/apple/libskia.xcframework',
 'libs/apple/libskunicode_core.xcframework',
 'libs/apple/libskunicode_libgrapheme.xcframework',
 'libs/apple/libskottie.xcframework',
-'libs/apple/libsksg.xcframework',
-'libs/apple/libpathops.xcframework',]
+'libs/apple/libsksg.xcframework',]
 
 Pod::Spec.new do |s|
   s.name         = "react-native-skia"

package/scripts/install-skia.mjs

@@ -0,0 +1,360 @@
+import fs from "fs";
+import https from "https";
+import path from "path";
+import os from "os";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const repo = "shopify/react-native-skia";
+
+const getSkiaVersion = () => {
+  const packageJsonPath = path.join(__dirname, "..", "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  return packageJson.skiaVersion;
+};
+
+const GRAPHITE = !!process.env.SK_GRAPHITE;
+const prefix = GRAPHITE ? "skia-graphite" : "skia";
+const names = [
+  `${prefix}-android-arm`,
+  `${prefix}-android-arm-64`,
+  `${prefix}-android-arm-x64`,
+  `${prefix}-android-arm-x86`,
+  `${prefix}-apple-xcframeworks`,
+];
+if (GRAPHITE) {
+  names.push("skia-graphite-headers");
+}
+
+const skiaVersion = getSkiaVersion();
+const releaseTag = `skia-${skiaVersion}`;
+console.log(
+  `📦 Downloading Skia prebuilt binaries for version: ${skiaVersion}`
+);
+
+const runCommand = (command, args) => {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "inherit", "inherit"],
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command ${command} exited with code ${code}`));
+      }
+    });
+  });
+};
+
+const downloadToFile = (url, destPath) => {
+  fs.mkdirSync(path.dirname(destPath), { recursive: true });
+  return new Promise((resolve, reject) => {
+    const request = (currentUrl) => {
+      https
+        .get(currentUrl, { headers: { "User-Agent": "node" } }, (res) => {
+          if (
+            res.statusCode &&
+            [301, 302, 303, 307, 308].includes(res.statusCode)
+          ) {
+            const { location } = res.headers;
+            if (location) {
+              res.resume();
+              request(location);
+            } else {
+              reject(new Error(`Redirect without location for ${currentUrl}`));
+            }
+            return;
+          }
+
+          if (res.statusCode !== 200) {
+            reject(
+              new Error(
+                `Failed to download: ${res.statusCode} ${res.statusMessage}`
+              )
+            );
+            res.resume();
+            return;
+          }
+
+          const fileStream = fs.createWriteStream(destPath);
+          res.pipe(fileStream);
+
+          fileStream.on("finish", () => {
+            fileStream.close((err) => {
+              if (err) {
+                // If closing the stream errors, perform the same cleanup and reject.
+                fileStream.destroy();
+                fs.unlink(destPath, () => reject(err));
+              } else {
+                resolve();
+              }
+            });
+          });
+
+          const cleanup = (error) => {
+            fileStream.destroy();
+            fs.unlink(destPath, () => reject(error));
+          };
+
+          res.on("error", cleanup);
+          fileStream.on("error", cleanup);
+        })
+        .on("error", reject);
+    };
+
+    request(url);
+  });
+};
+
+// On Windows, convert paths to avoid tar misinterpreting paths like C:\path
+// as remote host connection specs (C: as hostname)
+const normalizePathForTar = (filePath) => {
+  if (process.platform !== "win32") {
+    return filePath;
+  }
+
+  // Convert backslashes to forward slashes
+  let normalized = filePath.replace(/\\/g, "/");
+
+  // Convert C:/path to /c/path for Git Bash tar compatibility
+  normalized = normalized.replace(
+    /^([A-Za-z]):\//,
+    (_, drive) => `/${drive.toLowerCase()}/`
+  );
+
+  return normalized;
+};
+
+const extractTarGz = async (archivePath, destDir) => {
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const args = [
+    "-xzf",
+    normalizePathForTar(archivePath),
+    "-C",
+    normalizePathForTar(destDir),
+  ];
+  const candidates =
+    process.platform === "win32"
+      ? [
+          "tar.exe",
+          path.join(
+            process.env.SystemRoot ?? "C:\\Windows",
+            "System32",
+            "tar.exe"
+          ),
+          "bsdtar.exe",
+          "bsdtar",
+        ]
+      : ["tar"];
+
+  let lastError;
+  for (const candidate of candidates) {
+    try {
+      await runCommand(candidate, args);
+      return;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        lastError = new Error(`Command ${candidate} not found`);
+        continue;
+      }
+      lastError = err;
+    }
+  }
+
+  throw new Error(
+    `Failed to extract ${path.basename(
+      archivePath
+    )}. Please install a compatible tar binary. Last error: ${
+      lastError?.message ?? "unknown error"
+    }`
+  );
+};
+
+// Helper function to download and extract a tar.gz file
+const downloadAndExtract = async (url, destDir, tempDir) => {
+  const archivePath = path.join(tempDir, path.basename(url));
+  await downloadToFile(url, archivePath);
+  try {
+    await extractTarGz(archivePath, destDir);
+  } finally {
+    if (fs.existsSync(archivePath)) {
+      fs.unlinkSync(archivePath);
+    }
+  }
+};
+
+const artifactsDir = path.resolve(
+  __dirname,
+  "../../../packages/skia/artifacts"
+);
+
+const libsDir = path.resolve(__dirname, "../libs");
+
+// Function to check if prebuilt binaries are already installed
+const areBinariesInstalled = () => {
+  if (!fs.existsSync(libsDir)) {
+    return false;
+  }
+
+  // Check for Android libraries
+  const androidDir = path.join(libsDir, "android");
+  const androidArchs = ["armeabi-v7a", "arm64-v8a", "x86", "x86_64"];
+  for (const arch of androidArchs) {
+    const archDir = path.join(androidDir, arch);
+    if (!fs.existsSync(archDir) || fs.readdirSync(archDir).length === 0) {
+      return false;
+    }
+  }
+
+  // Check for Apple frameworks
+  const appleDir = path.join(libsDir, "apple");
+  if (!fs.existsSync(appleDir) || fs.readdirSync(appleDir).length === 0) {
+    return false;
+  }
+
+  return true;
+};
+
+// Function to clear directory contents
+const clearDirectory = (directory) => {
+  if (fs.existsSync(directory)) {
+    fs.readdirSync(directory).forEach((file) => {
+      const curPath = path.join(directory, file);
+      if (fs.lstatSync(curPath).isDirectory()) {
+        clearDirectory(curPath);
+        fs.rmdirSync(curPath);
+      } else {
+        fs.unlinkSync(curPath);
+      }
+    });
+    //console.log(`❌ ${directory}`);
+  } else {
+    console.log(`Directory ${directory} does not exist, creating it...`);
+    fs.mkdirSync(directory, { recursive: true });
+  }
+};
+
+const main = async () => {
+  const forceReinstall = process.argv.includes("--force");
+
+  // Check if binaries are already installed
+  if (!forceReinstall && areBinariesInstalled()) {
+    console.log("✅ Prebuilt binaries already installed, skipping download");
+    console.log("   Use --force to reinstall");
+    return;
+  }
+
+  if (forceReinstall) {
+    console.log("🔄 Force reinstall requested");
+  }
+
+  console.log("🧹 Clearing existing artifacts...");
+  clearDirectory(artifactsDir);
+
+  console.log(`⬇️  Downloading release assets to ${artifactsDir}`);
+  const tempDownloadDir = fs.mkdtempSync(
+    path.join(os.tmpdir(), "skia-download-")
+  );
+
+  for (const artifactName of names) {
+    const assetName = `${artifactName}-${releaseTag}.tar.gz`;
+    const extractDir = path.join(artifactsDir, artifactName);
+    const downloadUrl = `https://github.com/${repo}/releases/download/${releaseTag}/${assetName}`;
+
+    console.log(`   Downloading ${assetName}...`);
+    try {
+      await downloadAndExtract(downloadUrl, extractDir, tempDownloadDir);
+      console.log(`   ✓ ${assetName} extracted`);
+    } catch (error) {
+      console.error(`   ✗ Failed to download ${assetName}:`, error);
+      fs.rmSync(tempDownloadDir, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  fs.rmSync(tempDownloadDir, { recursive: true, force: true });
+
+  // Copy artifacts to libs folder in the required structure
+  console.log("📦 Copying artifacts to libs folder...");
+  clearDirectory(libsDir);
+
+  // Create android directory structure
+  const androidDir = path.join(libsDir, "android");
+  fs.mkdirSync(androidDir, { recursive: true });
+
+  // Copy android artifacts
+  const androidArchs = [
+    { src: "skia-android-arm", dest: "armeabi-v7a" },
+    { src: "skia-android-arm-64", dest: "arm64-v8a" },
+    { src: "skia-android-arm-x86", dest: "x86" },
+    { src: "skia-android-arm-x64", dest: "x86_64" },
+  ];
+
+  androidArchs.forEach(({ src, dest }) => {
+    // The tar file extracts to artifactName/dest (e.g., skia-android-arm/armeabi-v7a)
+    const srcDir = path.join(artifactsDir, src, dest);
+    const destDir = path.join(androidDir, dest);
+    if (fs.existsSync(srcDir)) {
+      fs.mkdirSync(destDir, { recursive: true });
+      fs.readdirSync(srcDir).forEach((file) => {
+        fs.copyFileSync(path.join(srcDir, file), path.join(destDir, file));
+      });
+    }
+  });
+
+  // Create apple directory structure
+  const appleDir = path.join(libsDir, "apple");
+  // The tar file extracts to skia-apple-xcframeworks/apple
+  const appleSrcDir = path.join(
+    artifactsDir,
+    "skia-apple-xcframeworks",
+    "apple"
+  );
+  if (fs.existsSync(appleSrcDir)) {
+    fs.mkdirSync(appleDir, { recursive: true });
+
+    // Copy all xcframeworks
+    fs.readdirSync(appleSrcDir).forEach((item) => {
+      const srcPath = path.join(appleSrcDir, item);
+      const destPath = path.join(appleDir, item);
+
+      if (fs.lstatSync(srcPath).isDirectory()) {
+        // Copy directory recursively
+        const copyDir = (src, dest) => {
+          fs.mkdirSync(dest, { recursive: true });
+          fs.readdirSync(src).forEach((file) => {
+            const srcFile = path.join(src, file);
+            const destFile = path.join(dest, file);
+            if (fs.lstatSync(srcFile).isDirectory()) {
+              copyDir(srcFile, destFile);
+            } else {
+              fs.copyFileSync(srcFile, destFile);
+            }
+          });
+        };
+        copyDir(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    });
+  }
+
+  console.log("✅ Done");
+
+  // Clean up artifacts directory
+  console.log("🗑️  Cleaning up artifacts directory...");
+  clearDirectory(artifactsDir);
+  fs.rmdirSync(artifactsDir);
+};
+
+// Run the main function
+main().catch((error) => {
+  console.error("❌ Error:", error);
+  process.exit(1);
+});

package/src/skia/types/SVG/SVGFactory.ts

@@ -1,8 +1,17 @@
 import type { SkData } from "../Data";
+import type { SkFontMgr } from "../Font/FontMgr";
 
 import type { SkSVG } from "./SVG";
 
 export interface SVGFactory {
-  MakeFromData(data: SkData): SkSVG | null;
-  MakeFromString(str: string): SkSVG | null;
+  MakeFromData(
+    data: SkData,
+    fontMgr?: SkFontMgr | null,
+    assets?: Record<string, SkData | null>
+  ): SkSVG | null;
+  MakeFromString(
+    str: string,
+    fontMgr?: SkFontMgr | null,
+    assets?: Record<string, SkData | null>
+  ): SkSVG | null;
 }

package/cpp/skia/include/android/SkHeifDecoder.h

@@ -1,50 +0,0 @@
-/*
- * Copyright 2023 Google LLC
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-#ifndef SkHeifDecoder_DEFINED
-#define SkHeifDecoder_DEFINED
-
-#include "include/codec/SkCodec.h"
-#include "include/core/SkRefCnt.h"
-
-class SkData;
-class SkStream;
-
-#include <memory>
-
-// This codec depends on heif libraries that are only part of the Android framework.
-// It will not work on other platforms currently.
-//
-// For historical reasons, this codec also decodes AVIF images.
-// There is a newer, dedicated SkAvifDecoder which could be used instead.
-namespace SkHeifDecoder {
-
-/** Returns true if this data claims to be a HEIF (or AVIF) image. */
-SK_API bool IsHeif(const void*, size_t);
-
-/**
- *  Attempts to decode the given bytes as a HEIF (or AVIF).
- *
- *  If the bytes are not a HEIF (or AVIF), returns nullptr.
- *
- *  DecodeContext is treated as a SkCodec::SelectionPolicy*
- */
-SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
-                                       SkCodec::Result*,
-                                       SkCodecs::DecodeContext = nullptr);
-SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
-                                       SkCodec::Result*,
-                                       SkCodecs::DecodeContext = nullptr);
-
-// Do not register this codec using "avif" as the key (even though it can handle that type).
-// Doing so would cause internal codec sniffing to choose the wrong sampler.
-inline SkCodecs::Decoder Decoder() {
-    return { "heif", IsHeif, Decode };
-}
-
-}  // namespace SkHeifDecoder
-
-#endif  // SkHeifDecoder_DEFINED

package/lib/commonjs/__tests__/globalSetup.d.ts

@@ -1,9 +0,0 @@
-import type { Server, WebSocket } from "ws";
-declare global {
-    var testServer: Server;
-    var testClient: WebSocket;
-    var testOS: "ios" | "android" | "web" | "node" | "macos";
-    var testArch: "paper" | "fabric";
-}
-declare const globalSetup: () => Promise<void>;
-export default globalSetup;

package/lib/commonjs/__tests__/globalTeardown.d.ts

@@ -1,2 +0,0 @@
-declare const globalTeardown: () => void;
-export default globalTeardown;