qpdf-compress 0.6.0 → 0.6.2

package/src/qpdf_addon.cc

@@ -1,12 +1,19 @@
 #include <napi.h>
 
+#include <atomic>
 #include <cerrno>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <filesystem>
 #include <memory>
 #include <string>
+#ifdef _WIN32
+#include <io.h>
+#define F_OK 0
+#define access _access
+#else
+#include <unistd.h>
+#endif
 #include <vector>
 
 #include <qpdf/Pl_Flate.hh>
@@ -23,27 +30,45 @@
 
 static std::string writeToFile(const std::string &path, const uint8_t *data,
                                size_t size) {
-  auto closer = [](FILE *fp) {
-    if (fp)
-      fclose(fp);
-  };
-  std::unique_ptr<FILE, decltype(closer)> f(fopen(path.c_str(), "wb"), closer);
+  FILE *f = fopen(path.c_str(), "wb");
   if (!f) {
-    auto parentDir = std::filesystem::path(path).parent_path();
-    if (!parentDir.empty() && !std::filesystem::is_directory(parentDir))
-      return "Parent directory does not exist: " + parentDir.string();
+    auto slash = path.rfind('/');
+    if (slash != std::string::npos) {
+      auto parentDir = path.substr(0, slash);
+      if (access(parentDir.c_str(), F_OK) != 0)
+        return "Parent directory does not exist: " + parentDir;
+    }
     return "Failed to open output file: " + path + " (" +
            std::string(std::strerror(errno)) + ")";
   }
-  if (fwrite(data, 1, size, f.get()) != size)
+  size_t written = fwrite(data, 1, size, f);
+  int closeErr = fclose(f);
+  if (written != size)
     return "Failed to write output file: " + path + " (" +
            std::string(std::strerror(errno)) + ")";
-  if (fflush(f.get()) != 0)
-    return "Failed to flush output file: " + path + " (" +
+  if (closeErr != 0)
+    return "Failed to close output file: " + path + " (" +
            std::string(std::strerror(errno)) + ")";
   return {};
 }
 
+// ---------------------------------------------------------------------------
+// Per-environment alive flag for worker thread safety.
+// When a Node.js worker thread is terminated, the V8 isolate tears down but
+// libuv async callbacks (OnOK/OnError) may still fire. This flag lets workers
+// bail out before touching V8 handles on a torn-down isolate.
+// ---------------------------------------------------------------------------
+
+struct AddonData {
+  std::shared_ptr<std::atomic<bool>> envAlive =
+      std::make_shared<std::atomic<bool>>(true);
+};
+
+static std::shared_ptr<std::atomic<bool>> GetEnvAlive(Napi::Env env) {
+  auto *data = env.GetInstanceData<AddonData>();
+  return data ? data->envAlive : nullptr;
+}
+
 // ---------------------------------------------------------------------------
 // CompressWorker — async PDF compression
 // ---------------------------------------------------------------------------
@@ -54,74 +79,98 @@ public:
   CompressWorker(Napi::Env env, std::vector<uint8_t> data, bool lossy,
                  bool stripMeta, std::string outputPath)
       : Napi::AsyncWorker(env), deferred_(Napi::Promise::Deferred::New(env)),
-        bufferData_(std::move(data)), lossy_(lossy), stripMeta_(stripMeta),
-        useFile_(false), outputPath_(std::move(outputPath)) {}
+        envAlive_(GetEnvAlive(env)), bufferData_(std::move(data)),
+        lossy_(lossy), stripMeta_(stripMeta), useFile_(false),
+        outputPath_(std::move(outputPath)) {}
 
   // file path variant
   CompressWorker(Napi::Env env, std::string path, bool lossy, bool stripMeta,
                  std::string outputPath)
       : Napi::AsyncWorker(env), deferred_(Napi::Promise::Deferred::New(env)),
-        filePath_(std::move(path)), lossy_(lossy), stripMeta_(stripMeta),
-        useFile_(true), outputPath_(std::move(outputPath)) {}
+        envAlive_(GetEnvAlive(env)), filePath_(std::move(path)), lossy_(lossy),
+        stripMeta_(stripMeta), useFile_(true),
+        outputPath_(std::move(outputPath)) {}
 
   Napi::Promise Promise() { return deferred_.Promise(); }
 
+  // guard against worker-thread teardown: if the env is being destroyed
+  // (e.g. worker.terminate()), skip all V8 API calls — the JS promise will
+  // never settle, but there is no listener for the result anyway.
+  void OnWorkComplete(Napi::Env env, napi_status status) override {
+    if (envAlive_ && !envAlive_->load())
+      return;
+
+    // probe whether V8 is still accessible (raw C call, no throw on failure)
+    napi_handle_scope scope = nullptr;
+    if (napi_open_handle_scope(env, &scope) != napi_ok)
+      return;
+    napi_close_handle_scope(env, scope);
+
+    try {
+      Napi::AsyncWorker::OnWorkComplete(env, status);
+    } catch (const Napi::Error &) {
+      // env tore down between probe and base class call
+    }
+  }
+
 protected:
   void Execute() override {
+    // heap-allocate QPDF so we control destruction order — if processFile/
+    // processMemoryFile throws, the QPDF destructor may also throw (broken
+    // internal state), which during stack unwinding would call std::terminate.
+    auto qpdf = std::make_unique<QPDF>();
     try {
-      QPDF qpdf;
-      qpdf.setAttemptRecovery(true);
+      qpdf->setAttemptRecovery(true);
+      qpdf->setSuppressWarnings(true);
 
       if (useFile_) {
-        if (!std::filesystem::exists(filePath_)) {
+        if (access(filePath_.c_str(), F_OK) != 0) {
           SetError("Input file not found: " + filePath_);
           return;
         }
-        qpdf.processFile(filePath_.c_str());
+        qpdf->processFile(filePath_.c_str());
       } else {
-        // validate PDF header to prevent QPDF from aborting on garbage input
-        if (bufferData_.size() < 5 ||
-            memcmp(bufferData_.data(), "%PDF-", 5) != 0) {
-          SetError("Input is not a valid PDF (missing %PDF- header)");
-          return;
-        }
-        qpdf.processMemoryFile(
+        qpdf->processMemoryFile(
             "input.pdf", reinterpret_cast<const char *>(bufferData_.data()),
             bufferData_.size());
       }
 
-      deduplicateImages(qpdf);
-      convertGrayscaleImages(qpdf);
-      convertBitonalImages(qpdf);
-      flattenPageTree(qpdf);
+      // --- structural simplification ---
+      flattenPageTree(*qpdf);
+      flattenForms(*qpdf);
+      stripDocumentOverhead(*qpdf);
+
+      // --- image optimization ---
+      deduplicateImages(*qpdf);
+      optimizeColorSpaces(*qpdf);
 
       if (lossy_) {
-        // lossy: re-encode high-quality JPEGs at lower quality
         CompressOptions opts;
         opts.skipThreshold = 65;
         opts.targetQuality = 75;
-        optimizeImages(qpdf, opts);
-        downscaleImages(qpdf, 72, 75);
+        optimizeImages(*qpdf, opts);
+        downscaleImages(*qpdf, 72, 75);
       }
 
-      // lossless Huffman optimization for all existing JPEGs
-      optimizeExistingJpegs(qpdf);
-      optimizeSoftMasks(qpdf);
-      removeUnusedFonts(qpdf);
-      subsetFonts(qpdf);
-      stripIccProfiles(qpdf);
-      flattenForms(qpdf);
-      coalesceContentStreams(qpdf);
-      minifyContentStreams(qpdf);
-      deduplicateStreams(qpdf);
-      stripEmbeddedFiles(qpdf);
-      stripJavaScript(qpdf);
+      optimizeExistingJpegs(*qpdf);
+      optimizeSoftMasks(*qpdf);
+
+      // --- font optimization ---
+      optimizeFonts(*qpdf);
+
+      // --- cleanup ---
+      removeUnusedResources(*qpdf);
+      coalesceContentStreams(*qpdf);
+      minifyContentStreams(*qpdf);
+      deduplicateStreams(*qpdf);
+      stripEmbeddedFiles(*qpdf);
+      stripJavaScript(*qpdf);
       if (stripMeta_)
-        stripMetadata(qpdf);
+        stripMetadata(*qpdf);
 
       Pl_Flate::setCompressionLevel(9);
 
-      QPDFWriter writer(qpdf);
+      QPDFWriter writer(*qpdf);
       writer.setOutputMemory();
       writer.setLinearization(false);
       writer.setStreamDataMode(qpdf_s_compress);
@@ -134,26 +183,50 @@ protected:
       writer.setPreserveUnreferencedObjects(false);
       writer.write();
 
-      auto buf = writer.getBufferSharedPointer();
-      result_.assign(buf->getBuffer(), buf->getBuffer() + buf->getSize());
+      writerBuf_ = writer.getBufferSharedPointer();
+
+      // release QPDF before file I/O — no longer needed
+      qpdf.reset();
 
       if (!outputPath_.empty()) {
-        auto err = writeToFile(outputPath_, result_.data(), result_.size());
+        auto err = writeToFile(outputPath_, writerBuf_->getBuffer(),
+                               writerBuf_->getSize());
         if (!err.empty()) {
           SetError(err);
           return;
         }
-        result_.clear();
+        writerBuf_.reset();
       }
     } catch (std::exception &e) {
+      // destroy QPDF inside the catch so its destructor can't cause
+      // std::terminate via a double exception during stack unwinding
+      try {
+        qpdf.reset();
+      } catch (...) {
+      }
       SetError(e.what());
+    } catch (...) {
+      // on macOS/libc++, catch(std::exception&) may fail to match QPDFExc
+      // due to typeinfo visibility mismatch between the static library and
+      // our addon compiled with -fvisibility=hidden
+      try {
+        qpdf.reset();
+      } catch (...) {
+      }
+      SetError("PDF compression failed");
     }
   }
 
   void OnOK() override {
     if (outputPath_.empty()) {
-      deferred_.Resolve(
-          Napi::Buffer<uint8_t>::Copy(Env(), result_.data(), result_.size()));
+      // zero-copy: transfer QPDFWriter's buffer directly to JS, preventing
+      // a redundant full-copy of the compressed PDF
+      auto *prevent_copy = new std::shared_ptr<Buffer>(std::move(writerBuf_));
+      deferred_.Resolve(Napi::Buffer<uint8_t>::New(
+          Env(), prevent_copy->get()->getBuffer(),
+          prevent_copy->get()->getSize(),
+          [](Napi::Env, uint8_t *, std::shared_ptr<Buffer> *p) { delete p; },
+          prevent_copy));
     } else {
       deferred_.Resolve(Env().Undefined());
     }
@@ -165,13 +238,14 @@ protected:
 
 private:
   Napi::Promise::Deferred deferred_;
+  std::shared_ptr<std::atomic<bool>> envAlive_;
   std::vector<uint8_t> bufferData_;
   std::string filePath_;
   bool lossy_;
   bool stripMeta_;
   bool useFile_;
   std::string outputPath_;
-  std::vector<uint8_t> result_;
+  std::shared_ptr<Buffer> writerBuf_;
 };
 
 // ---------------------------------------------------------------------------
@@ -231,6 +305,14 @@ static Napi::Value Compress(const Napi::CallbackInfo &info) {
 // ---------------------------------------------------------------------------
 
 static Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  auto *addonData = new AddonData();
+  env.SetInstanceData(addonData);
+  auto envAlive = addonData->envAlive;
+  env.AddCleanupHook([addonData]() {
+    addonData->envAlive->store(false);
+    delete addonData;
+  });
+
   exports.Set("compress", Napi::Function::New(env, Compress));
   return exports;
 }

package/src/strip.cc

@@ -0,0 +1,391 @@
+#include "strip.h"
+
+#include <set>
+#include <string>
+
+#include <qpdf/QPDFObjectHandle.hh>
+#include <qpdf/QPDFPageDocumentHelper.hh>
+#include <qpdf/QPDFPageObjectHelper.hh>
+
+// ---------------------------------------------------------------------------
+// Metadata stripping
+// ---------------------------------------------------------------------------
+
+void stripMetadata(QPDF &qpdf) {
+  auto root = qpdf.getRoot();
+
+  // remove XMP metadata stream
+  if (root.hasKey("/Metadata"))
+    root.removeKey("/Metadata");
+
+  // remove document info dictionary
+  auto trailer = qpdf.getTrailer();
+  if (trailer.hasKey("/Info"))
+    trailer.removeKey("/Info");
+
+  // remove page-level metadata and PieceInfo
+  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
+    auto pageObj = page.getObjectHandle();
+    if (pageObj.hasKey("/Metadata"))
+      pageObj.removeKey("/Metadata");
+    if (pageObj.hasKey("/PieceInfo"))
+      pageObj.removeKey("/PieceInfo");
+  }
+
+  // remove embedded thumbnails
+  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
+    auto pageObj = page.getObjectHandle();
+    if (pageObj.hasKey("/Thumb"))
+      pageObj.removeKey("/Thumb");
+  }
+
+  // remove MarkInfo and page labels (optional metadata)
+  if (root.hasKey("/MarkInfo"))
+    root.removeKey("/MarkInfo");
+}
+
+// ---------------------------------------------------------------------------
+// Embedded file stripping — remove /EmbeddedFiles from the name tree
+// ---------------------------------------------------------------------------
+
+void stripEmbeddedFiles(QPDF &qpdf) {
+  auto root = qpdf.getRoot();
+  if (!root.hasKey("/Names"))
+    return;
+
+  auto names = root.getKey("/Names");
+  if (!names.isDictionary())
+    return;
+
+  if (names.hasKey("/EmbeddedFiles"))
+    names.removeKey("/EmbeddedFiles");
+
+  // if /Names is now empty, remove it too
+  if (names.getKeys().empty())
+    root.removeKey("/Names");
+}
+
+// ---------------------------------------------------------------------------
+// JavaScript and action removal — strip JS, open actions, and additional
+// actions from the catalog and all pages
+// ---------------------------------------------------------------------------
+
+void stripJavaScript(QPDF &qpdf) {
+  auto root = qpdf.getRoot();
+
+  // remove document-level open action only if it is JavaScript
+  if (root.hasKey("/OpenAction")) {
+    auto action = root.getKey("/OpenAction");
+    if (action.isDictionary()) {
+      auto s = action.getKey("/S");
+      if (s.isName() && s.getName() == "/JavaScript")
+        root.removeKey("/OpenAction");
+    }
+  }
+
+  // remove document-level additional actions
+  if (root.hasKey("/AA"))
+    root.removeKey("/AA");
+
+  // remove /JavaScript name tree
+  if (root.hasKey("/Names")) {
+    auto names = root.getKey("/Names");
+    if (names.isDictionary() && names.hasKey("/JavaScript"))
+      names.removeKey("/JavaScript");
+  }
+
+  // remove page-level actions and annotations with JS
+  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
+    auto pageObj = page.getObjectHandle();
+
+    if (pageObj.hasKey("/AA"))
+      pageObj.removeKey("/AA");
+
+    // strip JS actions from annotations
+    if (!pageObj.hasKey("/Annots"))
+      continue;
+
+    auto annots = pageObj.getKey("/Annots");
+    if (!annots.isArray())
+      continue;
+
+    for (int i = 0; i < annots.getArrayNItems(); ++i) {
+      auto annot = annots.getArrayItem(i);
+      if (!annot.isDictionary())
+        continue;
+      if (annot.hasKey("/AA"))
+        annot.removeKey("/AA");
+      if (annot.hasKey("/A")) {
+        auto action = annot.getKey("/A");
+        if (action.isDictionary()) {
+          auto s = action.getKey("/S");
+          if (s.isName() && s.getName() == "/JavaScript")
+            annot.removeKey("/A");
+        }
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Document overhead stripping — remove structural and navigational data
+// that does not affect visual rendering
+// ---------------------------------------------------------------------------
+
+void stripDocumentOverhead(QPDF &qpdf) {
+  auto root = qpdf.getRoot();
+
+  // remove structure tree (tagged PDF accessibility info)
+  if (root.hasKey("/StructTreeRoot"))
+    root.removeKey("/StructTreeRoot");
+
+  // remove output intents (PDF/A color management metadata)
+  if (root.hasKey("/OutputIntents"))
+    root.removeKey("/OutputIntents");
+
+  // remove viewer preferences
+  if (root.hasKey("/ViewerPreferences"))
+    root.removeKey("/ViewerPreferences");
+
+  // remove article threads
+  if (root.hasKey("/Threads"))
+    root.removeKey("/Threads");
+
+  // remove web capture info
+  if (root.hasKey("/SpiderInfo"))
+    root.removeKey("/SpiderInfo");
+
+  // remove page display mode (single page, outlines, etc.)
+  if (root.hasKey("/PageMode"))
+    root.removeKey("/PageMode");
+
+  // remove page layout preference
+  if (root.hasKey("/PageLayout"))
+    root.removeKey("/PageLayout");
+
+  // remove named destinations
+  if (root.hasKey("/Dests"))
+    root.removeKey("/Dests");
+
+  // remove page-level structure keys and obsolete /ProcSet
+  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
+    auto pageObj = page.getObjectHandle();
+
+    // structure tree references
+    if (pageObj.hasKey("/StructParents"))
+      pageObj.removeKey("/StructParents");
+    if (pageObj.hasKey("/StructParent"))
+      pageObj.removeKey("/StructParent");
+
+    // tab order (tied to structure tree)
+    if (pageObj.hasKey("/Tabs"))
+      pageObj.removeKey("/Tabs");
+
+    // presentation steps
+    if (pageObj.hasKey("/PresSteps"))
+      pageObj.removeKey("/PresSteps");
+
+    // remove /ProcSet from resources (obsolete since PDF 1.4)
+    auto resources = pageObj.getKey("/Resources");
+    if (resources.isDictionary() && resources.hasKey("/ProcSet"))
+      resources.removeKey("/ProcSet");
+  }
+
+  // remove /Metadata from non-root objects (XObjects, fonts, etc.)
+  // root /Metadata is handled separately by stripMetadata()
+  for (auto &obj : qpdf.getAllObjects()) {
+    if (!obj.isDictionary())
+      continue;
+    if (!obj.hasKey("/Metadata"))
+      continue;
+    // skip the document catalog itself
+    if (obj.getObjGen() == root.getObjGen())
+      continue;
+    obj.removeKey("/Metadata");
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Unused resource removal — remove XObject, ExtGState, ColorSpace, Pattern,
+// Shading, and Properties entries not referenced by any content stream
+// ---------------------------------------------------------------------------
+
+class ResourceCollector : public QPDFObjectHandle::ParserCallbacks {
+public:
+  std::set<std::string> usedNames;
+
+  void handleObject(QPDFObjectHandle obj) override {
+    if (obj.isOperator()) {
+      std::string op = obj.getOperatorValue();
+
+      // Do (XObject), gs (ExtGState), sh (Shading)
+      if ((op == "Do" || op == "gs" || op == "sh") && !operands.empty() &&
+          operands.back().isName())
+        usedNames.insert(operands.back().getName());
+
+      // cs/CS (set color space)
+      if ((op == "cs" || op == "CS") && !operands.empty() &&
+          operands.back().isName())
+        usedNames.insert(operands.back().getName());
+
+      // scn/SCN (set color with pattern)
+      if (op == "scn" || op == "SCN") {
+        for (auto &operand : operands) {
+          if (operand.isName())
+            usedNames.insert(operand.getName());
+        }
+      }
+
+      // Tf (font — for completeness, though fonts are handled separately)
+      if (op == "Tf" && operands.size() >= 2 &&
+          operands[operands.size() - 2].isName())
+        usedNames.insert(operands[operands.size() - 2].getName());
+
+      // BDC (marked content with properties)
+      if (op == "BDC") {
+        for (auto &operand : operands) {
+          if (operand.isName())
+            usedNames.insert(operand.getName());
+        }
+      }
+
+      operands.clear();
+    } else {
+      operands.push_back(obj);
+    }
+  }
+  void handleEOF() override {}
+
+private:
+  std::vector<QPDFObjectHandle> operands;
+};
+
+void removeUnusedResources(QPDF &qpdf) {
+  for (auto &page : QPDFPageDocumentHelper(qpdf).getAllPages()) {
+    auto pageObj = page.getObjectHandle();
+    auto inheritedRes = pageObj.getKey("/Resources");
+    if (!inheritedRes.isDictionary())
+      continue;
+
+    // make a page-local copy so we don't modify shared (inherited) dicts
+    auto resources = inheritedRes.shallowCopy();
+    pageObj.replaceKey("/Resources", resources);
+
+    // collect all resource names used in content streams
+    ResourceCollector collector;
+
+    // scan page content
+    try {
+      auto contents = pageObj.getKey("/Contents");
+      QPDFObjectHandle::parseContentStream(contents, &collector);
+    } catch (...) {
+      continue;
+    }
+
+    // scan Form XObjects
+    auto xobjects = resources.getKey("/XObject");
+    if (xobjects.isDictionary()) {
+      for (auto &key : xobjects.getKeys()) {
+        auto xobj = xobjects.getKey(key);
+        if (!xobj.isStream())
+          continue;
+        auto xobjDict = xobj.getDict();
+        auto st = xobjDict.getKey("/Subtype");
+        if (!st.isName() || st.getName() != "/Form")
+          continue;
+        try {
+          QPDFObjectHandle::parseContentStream(xobj, &collector);
+        } catch (...) {
+        }
+      }
+    }
+
+    // remove unused entries from resource categories
+    // shallow-copy sub-dicts before modifying to avoid corrupting shared
+    // (inherited) resources that may be referenced by other pages
+    static const char *categories[] = {"/ExtGState", "/ColorSpace", "/Pattern",
+                                       "/Shading", "/Properties"};
+
+    for (auto category : categories) {
+      auto dict = resources.getKey(category);
+      if (!dict.isDictionary())
+        continue;
+
+      std::vector<std::string> toRemove;
+      for (auto &key : dict.getKeys()) {
+        if (collector.usedNames.find(key) == collector.usedNames.end())
+          toRemove.push_back(key);
+      }
+
+      if (toRemove.empty())
+        continue;
+
+      // copy the sub-dict so we don't modify a shared parent
+      auto copy = dict.shallowCopy();
+      for (auto &key : toRemove)
+        copy.removeKey(key);
+
+      if (copy.getKeys().empty())
+        resources.removeKey(category);
+      else
+        resources.replaceKey(category, copy);
+    }
+
+    // remove unused XObjects, preserving indirect dependencies (e.g. SMask)
+    if (xobjects.isDictionary()) {
+      // build a map from object ID to XObject name for dependency resolution
+      std::map<QPDFObjGen, std::string> objToName;
+      for (auto &key : xobjects.getKeys()) {
+        auto xobj = xobjects.getKey(key);
+        if (xobj.isIndirect())
+          objToName[xobj.getObjGen()] = key;
+      }
+
+      // mark XObjects that are dependencies of used XObjects (e.g. SMask)
+      bool changed = true;
+      while (changed) {
+        changed = false;
+        for (auto &key : xobjects.getKeys()) {
+          if (collector.usedNames.find(key) == collector.usedNames.end())
+            continue;
+          auto xobj = xobjects.getKey(key);
+          if (!xobj.isStream())
+            continue;
+          auto dict = xobj.getDict();
+          // check /SMask and /Mask references
+          for (auto &depKey : {"/SMask", "/Mask"}) {
+            auto dep = dict.getKey(depKey);
+            if (!dep.isIndirect())
+              continue;
+            auto it = objToName.find(dep.getObjGen());
+            if (it != objToName.end() &&
+                collector.usedNames.find(it->second) ==
+                    collector.usedNames.end()) {
+              collector.usedNames.insert(it->second);
+              changed = true;
+            }
+          }
+        }
+      }
+
+      auto keys = xobjects.getKeys();
+      std::vector<std::string> toRemove;
+      for (auto &key : keys) {
+        if (collector.usedNames.find(key) == collector.usedNames.end())
+          toRemove.push_back(key);
+      }
+
+      if (!toRemove.empty()) {
+        // copy the sub-dict so we don't modify a shared parent
+        auto copy = xobjects.shallowCopy();
+        for (auto &key : toRemove)
+          copy.removeKey(key);
+
+        if (copy.getKeys().empty())
+          resources.removeKey("/XObject");
+        else
+          resources.replaceKey("/XObject", copy);
+      }
+    }
+  }
+}