@reekon-tools/react-native-pdf-canvas 0.1.1 → 0.2.1

package/scripts/fetch-pdfium.mjs

@@ -0,0 +1,559 @@
+#!/usr/bin/env node
+/**
+ * Fetches the pinned PDFium binaries this package renders with.
+ *
+ * ONE SCRIPT, THREE CONSUMERS, ONE MANIFEST.
+ *
+ *   node scripts/fetch-pdfium.mjs android [--abis arm64-v8a,armeabi-v7a,x86,x86_64]
+ *       -> native/.pdfium/android/include/*.h
+ *          native/.pdfium/android/jniLibs/<abi>/libpdfium.so
+ *       Called by android/build.gradle before CMake configures. The ABI list is
+ *       whatever the app asked for (`reactNativeArchitectures`), so the AAR never
+ *       carries an ABI the app does not.
+ *
+ *   node scripts/fetch-pdfium.mjs ios
+ *       -> native/.pdfium/ios/include/*.h
+ *          native/.pdfium/ios/PDFium.xcframework   (device arm64 + simulator arm64/x64)
+ *       Called from PdfCanvas.podspec while CocoaPods evaluates it. Needs macOS:
+ *       the xcframework is assembled with `lipo`, `install_name_tool` and
+ *       `xcodebuild -create-xcframework`, which exist wherever `pod install` runs.
+ *
+ *   node scripts/fetch-pdfium.mjs host [--target win-x64|mac-arm64|mac-x64|linux-x64]
+ *       -> native/.pdfium/host/{include,lib,bin}
+ *       For `native/tests`, the laptop proof of the C++ core. Defaults to the
+ *       machine it runs on.
+ *
+ * EVERY DOWNLOAD IS VERIFIED against the SHA-256 in `pdfium-manifest.json`
+ * before a single byte of it is extracted, and a mismatch deletes the file and
+ * fails the build. The digests come from the release's own SLSA attestation
+ * (`pdfium-attestation.json`), not from a first download — a manifest that
+ * records whatever the network happened to return is a manifest that pins
+ * nothing.
+ *
+ * IDEMPOTENT AND CHEAP WHEN DONE. A `.stamp` file records the release tag each
+ * output was produced from; a run that finds a matching stamp does nothing, so
+ * calling this from every Gradle configure and every `pod install` costs a stat.
+ *
+ * OFFLINE / AIR-GAPPED BUILDS. `PDFCANVAS_PDFIUM_MIRROR` replaces the GitHub
+ * base URL (same file names, e.g. an internal artifact store), and
+ * `PDFCANVAS_PDFIUM_CACHE` names a directory of already-downloaded `.tgz` files
+ * that is consulted before the network. Both still verify the digest.
+ *
+ * NO DEPENDENCIES, by the same rule as the rest of `scripts/`: this runs from a
+ * consumer's install where none of this package's devDependencies exist.
+ */
+
+import {createHash} from 'node:crypto';
+import {
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+  cpSync,
+  readdirSync,
+} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {dirname, join, resolve} from 'node:path';
+import {execFileSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import {pipeline} from 'node:stream/promises';
+import {Readable} from 'node:stream';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const root = resolve(here, '..');
+const manifestPath = join(here, 'pdfium-manifest.json');
+const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+
+/** Where every output lands. Gitignored; the stamp files make it self-healing. */
+const outputRoot =
+  process.env.PDFCANVAS_PDFIUM_OUT ?? join(root, 'native', '.pdfium');
+
+const baseUrl = (
+  process.env.PDFCANVAS_PDFIUM_MIRROR ?? manifest.baseUrl
+).replace(/\/+$/, '');
+
+/* ------------------------------------------------------------------ *
+ * Arguments
+ * ------------------------------------------------------------------ */
+
+const [, , command, ...rest] = process.argv;
+const flags = new Map();
+for (let i = 0; i < rest.length; i++) {
+  const arg = rest[i];
+  if (arg.startsWith('--')) {
+    const key = arg.slice(2);
+    const value =
+      rest[i + 1] !== undefined && !rest[i + 1].startsWith('--')
+        ? rest[++i]
+        : 'true';
+    flags.set(key, value);
+  }
+}
+
+function usage(code) {
+  console.error(
+    'usage: fetch-pdfium.mjs android [--abis a,b] | ios | host [--target t] | print-version',
+  );
+  process.exit(code);
+}
+
+/* ------------------------------------------------------------------ *
+ * Download + verify
+ * ------------------------------------------------------------------ */
+
+function sha256File(path) {
+  const hash = createHash('sha256');
+  hash.update(readFileSync(path));
+  return hash.digest('hex');
+}
+
+function artifactUrl(name) {
+  return `${baseUrl}/${manifest.release}/pdfium-${name}.tgz`;
+}
+
+/**
+ * Returns the path of a verified `.tgz` for `name`, downloading if needed.
+ *
+ * Downloads go to a temp file and are renamed into place only after the digest
+ * matches, so a half-written or tampered file can never be mistaken for a good
+ * one on the next run.
+ */
+async function fetchArtifact(name) {
+  const entry = manifest.artifacts[name];
+  if (!entry) {
+    throw new Error(`pdfium-manifest.json has no artifact named "${name}".`);
+  }
+  const cacheDir =
+    process.env.PDFCANVAS_PDFIUM_CACHE ?? join(outputRoot, 'downloads');
+  mkdirSync(cacheDir, {recursive: true});
+  const fileName = `pdfium-${name}-${manifest.release.replace('/', '-')}.tgz`;
+  const cached = join(cacheDir, fileName);
+
+  if (existsSync(cached)) {
+    const digest = sha256File(cached);
+    if (digest === entry.sha256) return cached;
+    console.warn(
+      `[pdfium] cached ${fileName} has digest ${digest}; re-downloading`,
+    );
+    rmSync(cached);
+  }
+
+  const url = artifactUrl(name);
+  console.log(`[pdfium] downloading ${url}`);
+  const response = await fetch(url, {redirect: 'follow'});
+  if (!response.ok || response.body === null) {
+    throw new Error(`Could not download ${url}: HTTP ${response.status}`);
+  }
+  const partial = `${cached}.part`;
+  await pipeline(Readable.fromWeb(response.body), createWriteStream(partial));
+
+  const digest = sha256File(partial);
+  if (digest !== entry.sha256) {
+    rmSync(partial);
+    throw new Error(
+      `SHA-256 mismatch for ${url}:\n  expected ${entry.sha256}\n  got      ${digest}\n` +
+        'Refusing to use it. If the release was re-uploaded, update ' +
+        'scripts/pdfium-manifest.json from the release attestation.',
+    );
+  }
+  renameSync(partial, cached);
+  return cached;
+}
+
+/**
+ * The tar to extract with.
+ *
+ * On Windows this is ALWAYS the system bsdtar, named by absolute path. A
+ * developer shell here usually has MSYS (Git Bash) tar first on PATH, and GNU
+ * tar reads `C:\...` as `host:path` and tries to connect to a machine called
+ * `C` — the failure reads "Cannot connect to C: resolve failed", which is a
+ * long way from "wrong tar". Windows 10 1803+ ships bsdtar at System32.
+ */
+function tarBinary() {
+  if (process.platform === 'win32') {
+    const system = join(
+      process.env.SystemRoot ?? 'C:\\Windows',
+      'System32',
+      'tar.exe',
+    );
+    if (existsSync(system)) return system;
+  }
+  return 'tar';
+}
+
+function extract(tgz, into) {
+  mkdirSync(into, {recursive: true});
+  // `tar` exists on every platform this runs on: macOS and Linux natively, and
+  // Windows 10+ ships bsdtar. Node has no built-in tar and this script may not
+  // take a dependency.
+  execFileSync(tarBinary(), ['-xzf', tgz, '-C', into], {stdio: 'inherit'});
+}
+
+/* ------------------------------------------------------------------ *
+ * Stamps
+ * ------------------------------------------------------------------ */
+
+function stampPath(dir) {
+  return join(dir, '.stamp');
+}
+
+function isFresh(dir, key) {
+  const stamp = stampPath(dir);
+  return existsSync(stamp) && readFileSync(stamp, 'utf8').trim() === key;
+}
+
+function writeStamp(dir, key) {
+  writeFileSync(stampPath(dir), `${key}\n`);
+}
+
+function resetDir(dir) {
+  rmSync(dir, {recursive: true, force: true});
+  mkdirSync(dir, {recursive: true});
+}
+
+/** Copies PDFium's public headers, dropping the `.orig` file the release carries. */
+function copyHeaders(from, to) {
+  mkdirSync(to, {recursive: true});
+  for (const name of readdirSync(from)) {
+    if (name.endsWith('.orig')) continue;
+    cpSync(join(from, name), join(to, name), {recursive: true});
+  }
+}
+
+/* ------------------------------------------------------------------ *
+ * android
+ * ------------------------------------------------------------------ */
+
+const ANDROID_ARTIFACT_BY_ABI = Object.fromEntries(
+  Object.entries(manifest.artifacts)
+    .filter(([, value]) => typeof value.abi === 'string')
+    .map(([name, value]) => [value.abi, name]),
+);
+
+async function android() {
+  const abis = (
+    flags.get('abis') ?? Object.keys(ANDROID_ARTIFACT_BY_ABI).join(',')
+  )
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
+  for (const abi of abis) {
+    if (!ANDROID_ARTIFACT_BY_ABI[abi]) {
+      throw new Error(
+        `No PDFium build for ABI "${abi}". Known: ${Object.keys(ANDROID_ARTIFACT_BY_ABI).join(', ')}`,
+      );
+    }
+  }
+  const out = join(outputRoot, 'android');
+  const key = `${manifest.release} ${[...abis].sort().join(',')}`;
+  if (isFresh(out, key)) {
+    console.log(
+      `[pdfium] android: ${manifest.release} for ${abis.join(', ')} already present`,
+    );
+    return;
+  }
+  resetDir(out);
+  let headersCopied = false;
+  for (const abi of abis) {
+    const tgz = await fetchArtifact(ANDROID_ARTIFACT_BY_ABI[abi]);
+    const scratch = join(out, `.extract-${abi}`);
+    extract(tgz, scratch);
+    const libDir = join(out, 'jniLibs', abi);
+    mkdirSync(libDir, {recursive: true});
+    cpSync(join(scratch, 'lib', 'libpdfium.so'), join(libDir, 'libpdfium.so'));
+    if (!headersCopied) {
+      copyHeaders(join(scratch, 'include'), join(out, 'include'));
+      cpSync(join(scratch, 'LICENSE'), join(out, 'LICENSE'));
+      cpSync(join(scratch, 'licenses'), join(out, 'licenses'), {
+        recursive: true,
+      });
+      headersCopied = true;
+    }
+    rmSync(scratch, {recursive: true, force: true});
+  }
+  writeStamp(out, key);
+  console.log(`[pdfium] android: ready at ${out}`);
+}
+
+/* ------------------------------------------------------------------ *
+ * ios
+ * ------------------------------------------------------------------ */
+
+/**
+ * The minimum iOS version a Mach-O was built for, read from its LC_BUILD_VERSION
+ * (`minos`) via `vtool`. A fat binary prints one block per architecture; every
+ * slice must agree or the number is meaningless, so disagreement is an error.
+ *
+ * THIS IS THE FLOOR, NOT A GUESS. App Store processing compares the
+ * `MinimumOSVersion` a framework's Info.plist declares against what its binary
+ * was actually built for and rejects the upload (ITMS-90208) when the plist
+ * claims a lower floor. The first PDFium release of this package hardcoded
+ * 13.0 — a number inherited from the CoreGraphics era and from the upstream
+ * xcframework script this mirrors — while the dylib said 17.0, and the very
+ * first TestFlight upload was rejected. The plist is now written from the
+ * binary, and the manifest's declared value is checked against it, so the two
+ * cannot drift apart again.
+ */
+function machOMinimumOS(binary) {
+  const text = execFileSync('xcrun', ['vtool', '-show-build', binary], {
+    encoding: 'utf8',
+  });
+  const found = new Set();
+  for (const line of text.split('\n')) {
+    const m = /^\s*minos\s+(\d+(?:\.\d+)*)\s*$/.exec(line);
+    if (m) found.add(m[1]);
+  }
+  if (found.size === 0) {
+    throw new Error(
+      `${binary} has no LC_BUILD_VERSION minos; cannot determine its iOS floor.`,
+    );
+  }
+  if (found.size > 1) {
+    throw new Error(
+      `${binary} slices disagree about their iOS floor: ${[...found].join(', ')}.`,
+    );
+  }
+  return [...found][0];
+}
+
+/**
+ * Wraps a bare dylib as an iOS `PDFium.framework` (shallow bundle) so it can be
+ * embedded and code-signed like any other framework. Mirrors what
+ * espresso3389/pdfium-xcframework's build.sh does, minus the macOS/Catalyst
+ * slices this package does not ship.
+ */
+function makeIosFramework(
+  dylib,
+  frameworkDir,
+  headersDir,
+  platform,
+  minimumOSVersion,
+) {
+  resetDir(frameworkDir);
+  const binary = join(frameworkDir, 'PDFium');
+  cpSync(dylib, binary);
+  execFileSync('chmod', ['+w', binary]);
+  execFileSync(
+    'install_name_tool',
+    ['-id', '@rpath/PDFium.framework/PDFium', binary],
+    {
+      stdio: 'inherit',
+    },
+  );
+  copyHeaders(headersDir, join(frameworkDir, 'Headers'));
+  const shortVersion = manifest.version.split('.').slice(0, 3).join('.');
+  writeFileSync(
+    join(frameworkDir, 'Info.plist'),
+    `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleExecutable</key>
+  <string>PDFium</string>
+  <key>CFBundleIdentifier</key>
+  <string>tools.reekon.pdfcanvas.PDFium</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>PDFium</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>${shortVersion}</string>
+  <key>CFBundleVersion</key>
+  <string>${manifest.version}</string>
+  <key>CFBundleSupportedPlatforms</key>
+  <array>
+    <string>${platform}</string>
+  </array>
+  <key>MinimumOSVersion</key>
+  <string>${minimumOSVersion}</string>
+</dict>
+</plist>
+`,
+  );
+}
+
+async function ios() {
+  if (process.platform !== 'darwin') {
+    throw new Error(
+      'The iOS target assembles an xcframework with lipo/install_name_tool/xcodebuild ' +
+        'and must run on macOS (it is invoked by `pod install`).',
+    );
+  }
+  const out = join(outputRoot, 'ios');
+  const declaredMinOS = manifest.iosMinimumOSVersion;
+  if (
+    typeof declaredMinOS !== 'string' ||
+    !/^\d+(\.\d+)*$/.test(declaredMinOS)
+  ) {
+    throw new Error(
+      'pdfium-manifest.json must declare iosMinimumOSVersion (e.g. "17.0").',
+    );
+  }
+  // The floor is part of the stamp so an output assembled by an older script
+  // (which wrote a hardcoded plist) is rebuilt rather than trusted.
+  const key = `${manifest.release} ios-min=${declaredMinOS}`;
+  if (isFresh(out, key)) {
+    console.log(`[pdfium] ios: ${manifest.release} already present`);
+    return;
+  }
+  resetDir(out);
+  const work = join(out, '.work');
+  mkdirSync(work, {recursive: true});
+
+  const slices = {};
+  for (const name of [
+    'ios-device-arm64',
+    'ios-simulator-arm64',
+    'ios-simulator-x64',
+  ]) {
+    const dir = join(work, name);
+    extract(await fetchArtifact(name), dir);
+    slices[name] = dir;
+  }
+  // Every slice must have been built for the floor the manifest declares. A
+  // mismatch means the release was bumped without re-reading its args.gn: fix the
+  // manifest (and tell every consumer, whose deployment target must be >= it).
+  for (const name of Object.keys(slices)) {
+    const actual = machOMinimumOS(join(slices[name], 'lib', 'libpdfium.dylib'));
+    if (actual !== declaredMinOS) {
+      throw new Error(
+        `${name} in ${manifest.release} was built for iOS ${actual}, but ` +
+          `pdfium-manifest.json declares iosMinimumOSVersion "${declaredMinOS}". ` +
+          'Update the manifest to the real floor; consumers must raise their ' +
+          'deployment target to match before they can ship this release.',
+      );
+    }
+  }
+  console.log(`[pdfium] ios: every slice is built for iOS ${declaredMinOS}`);
+
+  copyHeaders(
+    join(slices['ios-device-arm64'], 'include'),
+    join(out, 'include'),
+  );
+  cpSync(join(slices['ios-device-arm64'], 'LICENSE'), join(out, 'LICENSE'));
+  cpSync(join(slices['ios-device-arm64'], 'licenses'), join(out, 'licenses'), {
+    recursive: true,
+  });
+
+  // Both simulator architectures have to be ONE fat dylib: an xcframework holds
+  // one library per (platform, variant), so two simulator slices must be lipo'd.
+  const simulatorFat = join(work, 'libpdfium-simulator.dylib');
+  execFileSync(
+    'lipo',
+    [
+      '-create',
+      join(slices['ios-simulator-arm64'], 'lib', 'libpdfium.dylib'),
+      join(slices['ios-simulator-x64'], 'lib', 'libpdfium.dylib'),
+      '-output',
+      simulatorFat,
+    ],
+    {stdio: 'inherit'},
+  );
+
+  const deviceFramework = join(work, 'device', 'PDFium.framework');
+  const simulatorFramework = join(work, 'simulator', 'PDFium.framework');
+  makeIosFramework(
+    join(slices['ios-device-arm64'], 'lib', 'libpdfium.dylib'),
+    deviceFramework,
+    join(out, 'include'),
+    'iPhoneOS',
+    declaredMinOS,
+  );
+  makeIosFramework(
+    simulatorFat,
+    simulatorFramework,
+    join(out, 'include'),
+    'iPhoneSimulator',
+    declaredMinOS,
+  );
+
+  const xcframework = join(out, 'PDFium.xcframework');
+  execFileSync(
+    'xcodebuild',
+    [
+      '-create-xcframework',
+      '-framework',
+      deviceFramework,
+      '-framework',
+      simulatorFramework,
+      '-output',
+      xcframework,
+    ],
+    {stdio: 'inherit'},
+  );
+  rmSync(work, {recursive: true, force: true});
+  writeStamp(out, key);
+  console.log(`[pdfium] ios: ready at ${xcframework}`);
+}
+
+/* ------------------------------------------------------------------ *
+ * host
+ * ------------------------------------------------------------------ */
+
+function defaultHostTarget() {
+  const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+  switch (process.platform) {
+    case 'win32':
+      return 'win-x64';
+    case 'darwin':
+      return `mac-${arch}`;
+    case 'linux':
+      return 'linux-x64';
+    default:
+      throw new Error(
+        `No PDFium host build for ${process.platform}/${process.arch}.`,
+      );
+  }
+}
+
+async function host() {
+  const target = flags.get('target') ?? defaultHostTarget();
+  const out = join(outputRoot, 'host');
+  const key = `${manifest.release} ${target}`;
+  if (isFresh(out, key)) {
+    console.log(`[pdfium] host: ${manifest.release} ${target} already present`);
+    return;
+  }
+  resetDir(out);
+  extract(await fetchArtifact(target), out);
+  // The release's headers dir carries `fpdfview.h.orig`; drop it so an include
+  // path sweep never picks up the wrong one.
+  const orig = join(out, 'include', 'fpdfview.h.orig');
+  if (existsSync(orig)) rmSync(orig);
+  writeStamp(out, key);
+  console.log(`[pdfium] host: ready at ${out}`);
+}
+
+/* ------------------------------------------------------------------ *
+ * main
+ * ------------------------------------------------------------------ */
+
+try {
+  switch (command) {
+    case 'android':
+      await android();
+      break;
+    case 'ios':
+      await ios();
+      break;
+    case 'host':
+      await host();
+      break;
+    case 'print-version':
+      process.stdout.write(`${manifest.version}\n`);
+      break;
+    default:
+      usage(command === undefined ? 1 : 2);
+  }
+} catch (error) {
+  console.error(
+    `[pdfium] ${error instanceof Error ? error.message : String(error)}`,
+  );
+  process.exit(1);
+}

package/scripts/pdfium-manifest.json

@@ -0,0 +1,48 @@
+{
+  "//": "THE ONE PLACE THE PDFIUM BUILD IS NAMED. `scripts/fetch-pdfium.mjs` downloads exactly these artifacts, verifies exactly these digests, and refuses anything else. Bumping PDFium is a one-file change: new tag, new digests (taken from the release's `pdfium-attestation.json` subjects, never from a download you have not verified), then `yarn pdfium:fetch host && yarn native:test` before the bump is trusted. Every platform — Android, iOS, the host test suite — is built from the SAME release, which is what makes a tile byte-identical across all of them rather than merely similar.",
+  "release": "chromium/8044",
+  "version": "144.0.8044.0",
+  "baseUrl": "https://github.com/bblanchon/pdfium-binaries/releases/download",
+  "//iosMinimumOSVersion": "THE iOS FLOOR THIS RELEASE'S DYLIB WAS BUILT FOR (`ios_deployment_target` in the tarball's args.gn, `minos` in the Mach-O LC_BUILD_VERSION). It is declared here, not discovered, so that bumping the release forces whoever bumps it to look: fetch-pdfium.mjs reads the real value out of every iOS slice with `vtool` and refuses to assemble the framework if any slice disagrees with this line. The same value is written into PDFium.framework/Info.plist as MinimumOSVersion — App Store processing rejects a framework whose plist claims a lower floor than its binary (ITMS-90208) — and is the floor PdfCanvas.podspec declares, so a host app whose deployment target is lower fails at `pod install` with a CocoaPods platform error instead of at upload. bblanchon pins 17.0 for non-V8 builds since 2026-08-14; before that the floor tracked Chromium's default and was never below 17.4 in 2025-2026. A host that must ship below this value needs a PDFium built with a lower ios_deployment_target, not a smaller number here.",
+  "iosMinimumOSVersion": "17.0",
+  "//artifacts": "Keyed by the bblanchon artifact name minus the `pdfium-` prefix and `.tgz` suffix. The android/ios/mac/win/linux entries are the plain (non-V8, non-XFA) builds: this package runs no JavaScript inside a PDF and XFA forms are out of scope, and the V8 builds are ~4x the size for nothing.",
+  "artifacts": {
+    "android-arm": {
+      "sha256": "7fba2fd334c9591e659c69263ff6c43b986f3db2200f6c156c848bb625f5364a",
+      "abi": "armeabi-v7a"
+    },
+    "android-arm64": {
+      "sha256": "37686e64fa005484d619550a78805500de4c5a6f4df7aa06d8576145bfbee98f",
+      "abi": "arm64-v8a"
+    },
+    "android-x64": {
+      "sha256": "e7e3072b8ad6f36ef58db999c2d91a22fa165a904d69385f13db4537c233d736",
+      "abi": "x86_64"
+    },
+    "android-x86": {
+      "sha256": "5a7bf631adac4d01c24e234172b8dc98d9e8e611c3d9b52135498d1b8c61e052",
+      "abi": "x86"
+    },
+    "ios-device-arm64": {
+      "sha256": "52be735d07b6c498ed8ce68b7f0cb5a209bbe61593c7a86c556756b80abbb938"
+    },
+    "ios-simulator-arm64": {
+      "sha256": "544537fce5257146e0df501c632d490d1aa95768737770f1912c8e23b1dd238d"
+    },
+    "ios-simulator-x64": {
+      "sha256": "8d4e33e415e29894aa98481bc9a9162a42039a1672796db14c9fed9cd545c881"
+    },
+    "mac-arm64": {
+      "sha256": "61424884d4a7f153b808deba6437848e4400834ce30aaf95d3050da44df8f420"
+    },
+    "mac-x64": {
+      "sha256": "a93d44238e05de20028446561b951d50988b849efbbe56fe40c0d376c05b45e8"
+    },
+    "win-x64": {
+      "sha256": "78a17d9a5f14467631c26a3ac8741b27a0471ecc05bd6a119b523598160a0537"
+    },
+    "linux-x64": {
+      "sha256": "eb142f416aed3a72fc5a02dbd5884868a16cb99dc0cf53e6bdd64afbf67b05f4"
+    }
+  }
+}