@trkyshorty/node-lzf 1.0.0 → 1.2.0

package/src/lzf.cc

@@ -1,95 +1,301 @@
 /* node-lzf (C) 2011 Ian Babrou <ibobrik@gmail.com>  */
 /* node-lzf (C) 2025 Maintained Türkay Tanrikulu <trky.shorty@gmail.com>  */
 
-#include <node_buffer.h>
-#include <stdlib.h>
+#include <napi.h>
 
-#ifdef __APPLE__
-#include <malloc/malloc.h>
-#endif
+#include <cerrno>
+#include <climits>
+#include <cstdlib>
+#include <string>
 
-#include "nan.h"
 #include "lzf/lzf.h"
 
-using namespace v8;
-using namespace node;
+namespace {
 
-NAN_METHOD(compress) {
-    if (info.Length() < 1 || !info[0]->IsObject() || !node::Buffer::HasInstance(info[0])) {
-        return Nan::ThrowTypeError("First argument must be a Buffer");
+/* Hard caps so a bogus length argument can never trigger a multi-GB
+ * allocation. 1 GiB is far above any realistic LZF payload. */
+constexpr size_t kMaxInputLength = 1024u * 1024u * 1024u;
+constexpr size_t kMaxOutputLength = 1024u * 1024u * 1024u;
+
+/* Worst-case compressed size for an input of n bytes (same formula the
+ * original node-lzf used; slightly above the theoretical n + n/32 + 1). */
+inline size_t CompressBound(size_t n) {
+    return n + (n / 16) + 64 + 3;
+}
+
+struct RawResult {
+    char* data = nullptr;
+    size_t length = 0;
+};
+
+/* Compresses into a malloc'd buffer shrunk to the exact result size.
+ * Returns false and fills `error` on failure (buffer already freed). */
+bool DoCompress(const char* input, size_t inputLength, RawResult* out, std::string* error) {
+    size_t bound = CompressBound(inputLength);
+    char* buffer = static_cast<char*>(malloc(bound));
+    if (buffer == nullptr) {
+        *error = "Failed to allocate output buffer";
+        return false;
     }
 
-    Local<Object> inBuf = Nan::To<Object>(info[0]).ToLocalChecked();
-    char* dataIn = node::Buffer::Data(inBuf);
-    size_t lenIn = node::Buffer::Length(inBuf);
+    unsigned int compressedLength = lzf_compress(
+        input, static_cast<unsigned int>(inputLength),
+        buffer, static_cast<unsigned int>(bound));
 
-    size_t maxCompressedLen = lenIn + (lenIn / 16) + 64 + 3;
-    auto maybeBuf = Nan::NewBuffer(maxCompressedLen);
-    if (maybeBuf.IsEmpty()) {
-        return Nan::ThrowError("Failed to allocate output buffer");
+    if (compressedLength == 0) {
+        free(buffer);
+        *error = "Compression failed";
+        return false;
     }
 
-    Local<Object> outBuf = maybeBuf.ToLocalChecked();
-    char* outData = node::Buffer::Data(outBuf);
+    char* shrunk = static_cast<char*>(realloc(buffer, compressedLength));
+    out->data = shrunk != nullptr ? shrunk : buffer;
+    out->length = compressedLength;
+    return true;
+}
 
-    unsigned int compressedLen = lzf_compress(dataIn, lenIn, outData, maxCompressedLen);
-    if (compressedLen == 0) {
-        return Nan::ThrowError("Compression failed");
+/* Decompresses into a malloc'd buffer of expectedLength, shrunk to the
+ * actual result size. Distinguishes "expected length too small" (E2BIG)
+ * from corrupted input via errno set by lzf_decompress. */
+bool DoDecompress(const char* input, size_t inputLength, size_t expectedLength, RawResult* out,
+                  std::string* error) {
+    char* buffer = static_cast<char*>(malloc(expectedLength));
+    if (buffer == nullptr) {
+        *error = "Failed to allocate output buffer";
+        return false;
     }
 
-    // Avoid .Get + .Call + new[]
-    Local<Function> sliceFn = outBuf->Get(Nan::GetCurrentContext(), Nan::New("slice").ToLocalChecked())
-        .ToLocalChecked().As<Function>();
-    Local<Value> args[] = {
-        Nan::New(0),
-        Nan::New((uint32_t)compressedLen)
-    };
-    Local<Value> sliced = sliceFn->Call(Nan::GetCurrentContext(), outBuf, 2, args).ToLocalChecked();
+    errno = 0;
+    unsigned int decompressedLength = lzf_decompress(
+        input, static_cast<unsigned int>(inputLength),
+        buffer, static_cast<unsigned int>(expectedLength));
+
+    if (decompressedLength == 0) {
+        int cause = errno;
+        free(buffer);
+        *error = cause == E2BIG ? "Decompression failed: expected length too small"
+                                : "Decompression failed: corrupted input";
+        return false;
+    }
+
+    if (decompressedLength < expectedLength) {
+        char* shrunk = static_cast<char*>(realloc(buffer, decompressedLength));
+        if (shrunk != nullptr) buffer = shrunk;
+    }
+    out->data = buffer;
+    out->length = decompressedLength;
+    return true;
+}
+
+/* Wraps a malloc'd result as a Buffer without copying when the runtime
+ * supports external buffers (plain Node does); falls back to copy+free. */
+Napi::Value WrapResult(Napi::Env env, RawResult* result) {
+    return Napi::Buffer<char>::NewOrCopy(
+        env, result->data, result->length,
+        [](Napi::Env, char* data) { free(data); });
+}
+
+/* ---- argument validation ------------------------------------------------ */
 
-    info.GetReturnValue().Set(sliced);
+bool ValidateInputBuffer(const Napi::CallbackInfo& info, std::string* error) {
+    if (info.Length() < 1 || !info[0].IsBuffer()) {
+        *error = "First argument must be a Buffer";
+        return false;
+    }
+    size_t length = info[0].As<Napi::Buffer<char>>().Length();
+    if (length == 0) {
+        *error = "Input buffer must not be empty";
+        return false;
+    }
+    if (length > kMaxInputLength) {
+        *error = "Input buffer exceeds 1 GiB limit";
+        return false;
+    }
+    return true;
 }
 
-NAN_METHOD(decompress) {
-    if (info.Length() < 1 || !info[0]->IsObject() || !node::Buffer::HasInstance(info[0])) {
-        return Nan::ThrowTypeError("First argument must be a Buffer");
+/* expectedLength is required: the legacy default silently allocated a
+ * 999 MB buffer per call, which is a footgun rather than a feature. */
+bool ValidateExpectedLength(const Napi::CallbackInfo& info, size_t* expectedLength,
+                            std::string* error, bool* rangeError) {
+    *rangeError = false;
+    if (info.Length() < 2 || !info[1].IsNumber()) {
+        *error = "Second argument (expectedLength) must be a number";
+        return false;
+    }
+    double raw = info[1].As<Napi::Number>().DoubleValue();
+    if (raw != raw /* NaN */ || raw != static_cast<double>(static_cast<int64_t>(raw))) {
+        *rangeError = true;
+        *error = "expectedLength must be an integer";
+        return false;
+    }
+    int64_t value = static_cast<int64_t>(raw);
+    if (value <= 0 || static_cast<uint64_t>(value) > kMaxOutputLength) {
+        *rangeError = true;
+        *error = "expectedLength must be between 1 and 1 GiB";
+        return false;
+    }
+    *expectedLength = static_cast<size_t>(value);
+    return true;
+}
+
+/* ---- async workers ------------------------------------------------------ */
+
+class CompressWorker : public Napi::AsyncWorker {
+  public:
+    CompressWorker(Napi::Env env, Napi::Buffer<char> input)
+        : Napi::AsyncWorker(env),
+          deferred_(Napi::Promise::Deferred::New(env)),
+          inputRef_(Napi::Persistent(input.As<Napi::Object>())),
+          data_(input.Data()),
+          length_(input.Length()) {}
+
+    Napi::Promise Promise() { return deferred_.Promise(); }
+
+  protected:
+    void Execute() override {
+        std::string error;
+        if (!DoCompress(data_, length_, &result_, &error)) SetError(error);
+    }
+
+    void OnOK() override { deferred_.Resolve(WrapResult(Env(), &result_)); }
+
+    void OnError(const Napi::Error& e) override { deferred_.Reject(e.Value()); }
+
+  private:
+    Napi::Promise::Deferred deferred_;
+    Napi::ObjectReference inputRef_;  // keeps the input buffer alive while the worker runs
+    const char* data_;
+    size_t length_;
+    RawResult result_;
+};
+
+class DecompressWorker : public Napi::AsyncWorker {
+  public:
+    DecompressWorker(Napi::Env env, Napi::Buffer<char> input, size_t expectedLength)
+        : Napi::AsyncWorker(env),
+          deferred_(Napi::Promise::Deferred::New(env)),
+          inputRef_(Napi::Persistent(input.As<Napi::Object>())),
+          data_(input.Data()),
+          length_(input.Length()),
+          expectedLength_(expectedLength) {}
+
+    Napi::Promise Promise() { return deferred_.Promise(); }
+
+  protected:
+    void Execute() override {
+        std::string error;
+        if (!DoDecompress(data_, length_, expectedLength_, &result_, &error)) SetError(error);
+    }
+
+    void OnOK() override { deferred_.Resolve(WrapResult(Env(), &result_)); }
+
+    void OnError(const Napi::Error& e) override { deferred_.Reject(e.Value()); }
+
+  private:
+    Napi::Promise::Deferred deferred_;
+    Napi::ObjectReference inputRef_;
+    const char* data_;
+    size_t length_;
+    size_t expectedLength_;
+    RawResult result_;
+};
+
+/* ---- sync API ----------------------------------------------------------- */
+
+Napi::Value Compress(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    std::string error;
+    if (!ValidateInputBuffer(info, &error)) {
+        Napi::TypeError::New(env, error).ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    Napi::Buffer<char> input = info[0].As<Napi::Buffer<char>>();
+    RawResult result;
+    if (!DoCompress(input.Data(), input.Length(), &result, &error)) {
+        Napi::Error::New(env, error).ThrowAsJavaScriptException();
+        return env.Undefined();
     }
+    return WrapResult(env, &result);
+}
 
-    Local<Object> inBuf = Nan::To<Object>(info[0]).ToLocalChecked();
-    char* dataIn = node::Buffer::Data(inBuf);
-    size_t lenIn = node::Buffer::Length(inBuf);
+Napi::Value Decompress(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
 
-    size_t expectedOutLen = 999 * 1024 * 1024;
-    if (info.Length() > 1 && info[1]->IsNumber()) {
-        expectedOutLen = Nan::To<uint32_t>(info[1]).FromJust();
+    std::string error;
+    bool rangeError = false;
+    size_t expectedLength = 0;
+    if (!ValidateInputBuffer(info, &error)) {
+        Napi::TypeError::New(env, error).ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    if (!ValidateExpectedLength(info, &expectedLength, &error, &rangeError)) {
+        if (rangeError) Napi::RangeError::New(env, error).ThrowAsJavaScriptException();
+        else Napi::TypeError::New(env, error).ThrowAsJavaScriptException();
+        return env.Undefined();
     }
 
-    auto maybeBuf = Nan::NewBuffer(expectedOutLen);
-    if (maybeBuf.IsEmpty()) {
-        return Nan::ThrowError("Failed to allocate output buffer");
+    Napi::Buffer<char> input = info[0].As<Napi::Buffer<char>>();
+    RawResult result;
+    if (!DoDecompress(input.Data(), input.Length(), expectedLength, &result, &error)) {
+        Napi::Error::New(env, error).ThrowAsJavaScriptException();
+        return env.Undefined();
     }
+    return WrapResult(env, &result);
+}
+
+/* ---- async API (libuv thread pool; never blocks the event loop) --------- */
+
+Napi::Value RejectedPromise(Napi::Env env, const Napi::Error& error) {
+    auto deferred = Napi::Promise::Deferred::New(env);
+    deferred.Reject(error.Value());
+    return deferred.Promise();
+}
 
-    Local<Object> outBuf = maybeBuf.ToLocalChecked();
-    char* outData = node::Buffer::Data(outBuf);
+Napi::Value CompressAsync(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
 
-    unsigned int decompressedLen = lzf_decompress(dataIn, lenIn, outData, expectedOutLen);
-    if (decompressedLen == 0) {
-        return Nan::ThrowError("Decompression failed");
+    std::string error;
+    if (!ValidateInputBuffer(info, &error)) {
+        return RejectedPromise(env, Napi::TypeError::New(env, error));
     }
 
-    Local<Function> sliceFn = outBuf->Get(Nan::GetCurrentContext(), Nan::New("slice").ToLocalChecked())
-        .ToLocalChecked().As<Function>();
-    Local<Value> args[] = {
-        Nan::New(0),
-        Nan::New((uint32_t)decompressedLen)
-    };
-    Local<Value> sliced = sliceFn->Call(Nan::GetCurrentContext(), outBuf, 2, args).ToLocalChecked();
+    auto* worker = new CompressWorker(env, info[0].As<Napi::Buffer<char>>());
+    Napi::Promise promise = worker->Promise();
+    worker->Queue();
+    return promise;
+}
+
+Napi::Value DecompressAsync(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    std::string error;
+    bool rangeError = false;
+    size_t expectedLength = 0;
+    if (!ValidateInputBuffer(info, &error)) {
+        return RejectedPromise(env, Napi::TypeError::New(env, error));
+    }
+    if (!ValidateExpectedLength(info, &expectedLength, &error, &rangeError)) {
+        if (rangeError) return RejectedPromise(env, Napi::RangeError::New(env, error));
+        return RejectedPromise(env, Napi::TypeError::New(env, error));
+    }
 
-    info.GetReturnValue().Set(sliced);
+    auto* worker = new DecompressWorker(env, info[0].As<Napi::Buffer<char>>(), expectedLength);
+    Napi::Promise promise = worker->Promise();
+    worker->Queue();
+    return promise;
 }
 
-NAN_MODULE_INIT(init) {
-    Nan::SetMethod(target, "compress", compress);
-    Nan::SetMethod(target, "decompress", decompress);
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    exports.Set("compress", Napi::Function::New(env, Compress));
+    exports.Set("decompress", Napi::Function::New(env, Decompress));
+    exports.Set("compressAsync", Napi::Function::New(env, CompressAsync));
+    exports.Set("decompressAsync", Napi::Function::New(env, DecompressAsync));
+    return exports;
 }
 
-NODE_MODULE(lzf, init)
+}  // namespace
+
+NODE_API_MODULE(lzf, Init)

package/benchmark/benchmark.js

@@ -1,69 +0,0 @@
-var lzf  = require("../index.js");
-var zlib = require("compress-buffer");
-var fs   = require("fs");
-var path = require("path");
-
-
-var Benchmark = require('benchmark');
-
-
-function testCompression(length) {
-    var data  = fs.readFileSync(path.join(__dirname, "data", length + ".txt"));
-    var suite = new Benchmark.Suite();
-
-    console.log("Testing compression at " + length + " bytes");
-
-    suite.add('lzf-compress', function() {
-        lzf.compress(data);
-    });
-
-    suite.add('zlib-compress', function() {
-        zlib.compress(data);
-    })
-
-    suite.on('cycle', function(event, bench) {
-        console.log(String(bench));
-    });
-
-    suite.on('complete', function() {
-        console.log('Fastest is ' + this.filter('fastest').pluck('name'));
-        console.log();
-    });
-
-    suite.run();
-}
-
-function testDecompression(length) {
-    var data           = fs.readFileSync(path.join(__dirname, "data", length + ".txt"));
-    var suite          = new Benchmark.Suite();
-    var lzfCompressed  = lzf.compress(data);
-    var zlibCompressed = zlib.compress(data);
-
-    console.log("Testing decompression at " + length + " bytes");
-
-    suite.add('lzf-decompress', function() {
-        lzf.decompress(lzfCompressed);
-    });
-
-    suite.add('zlib-decompress', function() {
-        zlib.uncompress(zlibCompressed);
-    })
-
-    suite.on('cycle', function(event, bench) {
-        console.log(String(bench));
-    });
-
-    suite.on('complete', function() {
-        console.log('Fastest is ' + this.filter('fastest').pluck('name'));
-        console.log();
-    });
-
-    suite.run();
-}
-
-for (var i = 0; i < 4; i++) {
-    var length = Math.pow(10, i + 2);
-    testCompression(length);
-    testDecompression(length);
-}
-

package/benchmark/data/100.txt

@@ -1 +0,0 @@
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur vitae eros lorem. Duis cras amet.

package/benchmark/data/1000.txt

@@ -1,3 +0,0 @@
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum congue sem sed arcu fermentum suscipit. Cras eleifend purus sollicitudin enim condimentum molestie. Aliquam elementum arcu libero. Sed blandit quam luctus sapien ultricies dignissim. Aliquam blandit congue lorem at suscipit. Nulla eleifend volutpat mauris nec cursus. Sed sit amet lectus lorem. Sed tincidunt nunc nec dolor pulvinar imperdiet. Cras tincidunt lectus in orci sodales id congue felis condimentum. In ultricies, magna at viverra volutpat, tortor ante semper mauris, dignissim suscipit nisi risus a nulla.
-
-Quisque nec urna nibh, ut molestie eros. Nunc lobortis pharetra vestibulum. Mauris facilisis tincidunt turpis, nec condimentum nisi vestibulum ac. Nullam sed odio sed arcu malesuada scelerisque. In hac habitasse platea dictumst. Phasellus risus odio, mollis sed interdum nec, commodo vel est. In porta euismod urna in pulvinar. Fusce suscipit vulputate odio vel venenatis. Vestibulum ante ipsum primis in cras amet.

package/benchmark/data/10000.txt

@@ -1,39 +0,0 @@
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed nec augue nibh, vitae sagittis mi. Suspendisse elementum dapibus eros nec varius. Ut mollis varius sapien, eget vehicula ipsum ultrices non. Nullam ac erat lectus. Quisque ultricies iaculis ipsum, eget suscipit eros venenatis non. Duis mattis justo in erat volutpat varius. Sed vitae lobortis odio.
-
-Vestibulum posuere risus quis nisl vehicula adipiscing. Ut vitae mi et urna ultricies egestas ut ut est. Nam lobortis placerat dui, et imperdiet lacus aliquet imperdiet. Sed dapibus nisl ipsum, ac dignissim erat. Nam et nisl vitae nisl egestas vehicula. Vestibulum eget lobortis justo. Etiam laoreet pretium accumsan. Proin dapibus nisi vitae erat dapibus quis ultrices enim sollicitudin.
-
-Mauris eu sem dui. Integer dignissim mollis massa, ac pharetra enim bibendum ut. Sed tempor quam vitae est aliquam rutrum. Duis aliquet cursus nisi non vestibulum. Sed ac sapien tortor, sed scelerisque enim. Suspendisse odio velit, dapibus nec posuere non, faucibus non nisl. Etiam dignissim sodales nibh ut commodo. Pellentesque non est sed mi elementum sagittis et eget odio.
-
-Morbi feugiat dictum mollis. Pellentesque ultricies diam quis nisi auctor vitae tristique risus euismod. Sed condimentum feugiat leo sed euismod. Quisque pretium nunc porta arcu viverra convallis quis fringilla arcu. Nam facilisis, lorem a aliquet faucibus, neque elit bibendum erat, eget bibendum ipsum ante et purus. Cras est tellus, vestibulum vitae rutrum vel, ultrices quis sapien. Donec fringilla vehicula eros ac tincidunt. Nulla imperdiet, neque eget posuere aliquam, tortor magna tempus tortor, nec sodales libero turpis eget risus.
-
-Vivamus auctor ligula nec turpis consectetur euismod. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Curabitur turpis tellus, pharetra in lobortis ac, semper sit amet turpis. Quisque dolor est, pulvinar a porttitor non, suscipit ut magna. Suspendisse eget arcu id urna eleifend ullamcorper sit amet id eros. Praesent tincidunt rhoncus tristique. Cras tempor adipiscing arcu eu posuere. Proin vulputate, enim sit amet volutpat facilisis, mi quam venenatis nulla, vitae varius ligula nibh non massa. Sed feugiat nibh et ipsum mollis ac porta urna auctor. Donec mauris mauris, elementum a sodales in, ultricies at tortor. Aenean commodo facilisis euismod. Integer sed urna at tortor cursus ultricies id a ante. In aliquam velit sit amet diam consequat egestas.
-
-Vivamus ut dui ante, ut posuere turpis. Sed ornare risus quam. Aliquam sit amet ligula felis, ultrices sagittis mauris. Aenean faucibus molestie quam sodales molestie. Cras tincidunt sagittis purus, sed convallis sapien semper ut. Suspendisse luctus dapibus ante at ultricies. Nam at lacus orci. Aliquam mattis, velit in accumsan mattis, metus nisl mattis est, ut tincidunt sapien elit sit amet eros. Cras tempus ultrices feugiat.
-
-In rhoncus lectus id lorem feugiat eu pulvinar metus scelerisque. Etiam a erat eget dolor facilisis luctus. Pellentesque at odio pretium nisi adipiscing laoreet. Etiam non justo ligula. Nunc mauris sapien, dictum tempor sodales non, pharetra congue mi. Mauris at lacus eu arcu scelerisque varius et ut augue. In consequat justo vitae ante condimentum euismod.
-
-Aliquam molestie bibendum malesuada. Curabitur scelerisque, augue a bibendum vestibulum, justo massa mattis est, a ullamcorper velit ligula faucibus ligula. Donec sit amet nibh sed nibh malesuada dictum ut ut lectus. Fusce adipiscing urna felis, sed pharetra sapien. Suspendisse potenti. Aenean auctor orci commodo tellus sollicitudin dignissim. Donec posuere venenatis vulputate.
-
-Mauris non ipsum turpis. Cras euismod, lectus sed commodo vulputate, lacus mi sodales risus, non sodales lorem justo sed erat. Mauris non adipiscing lorem. Phasellus at est quis metus auctor hendrerit. Cras sed purus erat, id dignissim elit. In sed est diam. Fusce id diam lorem, vel auctor nunc. Pellentesque mattis sollicitudin blandit. Phasellus vitae justo non sem gravida iaculis. Etiam cursus nisl nec sem mollis ac congue sapien pellentesque. In eu est urna.
-
-Cras luctus bibendum feugiat. Sed varius, libero ornare dictum tempor, turpis quam mattis purus, nec pulvinar tellus odio nec metus. Pellentesque tempus vulputate fermentum. Proin porttitor viverra pretium. Donec interdum magna et augue vehicula non faucibus quam vehicula. Ut euismod, turpis eu vehicula gravida, augue ligula auctor nisl, non interdum felis mauris at nisi. Sed vulputate eleifend nisl, et consectetur sapien dignissim sit amet.
-
-Proin elit est, congue vel sollicitudin ac, molestie sed justo. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Nulla facilisi. Duis est odio, sollicitudin a feugiat a, blandit eget felis. Vivamus vitae pharetra nisi. Vestibulum condimentum dui et ligula aliquam pretium. Nulla non dapibus metus. Suspendisse potenti. Aenean molestie hendrerit nulla, vel posuere nisi eleifend non. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed mauris dui, adipiscing quis vestibulum a, vestibulum ut lectus. Ut sit amet est nisl, a aliquam nulla. Nullam libero ipsum, consequat id pharetra sit amet, commodo at neque. Donec eget bibendum est.
-
-Cras fermentum porttitor massa, nec convallis massa consequat at. Morbi eu vehicula orci. Aenean ultricies faucibus sapien eget dapibus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Nunc in quam id leo interdum consectetur vitae interdum quam. Donec scelerisque purus et metus posuere eget viverra justo facilisis. Nam at eros sit amet sapien vehicula bibendum ut id enim. Vivamus rhoncus malesuada justo at ultricies. Nulla congue leo iaculis erat tempor tempor. Vivamus sagittis, elit ac faucibus tristique, leo odio adipiscing lorem, a volutpat lacus mi ac erat. Nulla facilisi. Nullam scelerisque auctor gravida. Proin a magna dolor. Morbi congue, nunc nec volutpat dictum, lorem odio consequat neque, vulputate egestas tortor elit eu neque.
-
-Duis a nisi condimentum sem laoreet condimentum. Curabitur malesuada felis eget velit rutrum tincidunt. Nulla placerat laoreet placerat. Aliquam suscipit consequat elementum. Etiam pellentesque porttitor aliquam. Mauris non massa ut dui tincidunt sodales varius vitae eros. Quisque imperdiet aliquam orci, et suscipit metus facilisis vel.
-
-Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Vestibulum in massa eu augue lobortis volutpat non sit amet enim. Vestibulum quis ante tellus. Curabitur in arcu a ipsum commodo cursus. Pellentesque id lorem odio. Vivamus consequat purus in magna aliquet at tincidunt turpis varius. Praesent sed nunc quam, vel varius sem. Aenean eget vehicula massa. Aliquam posuere, massa non placerat molestie, magna orci aliquam justo, luctus ullamcorper ligula leo a quam.
-
-Donec id leo sit amet nisl sollicitudin ultricies. Suspendisse blandit rutrum risus vel dictum. Duis tempus metus et risus ornare ut volutpat ligula ultrices. Proin accumsan tellus id felis elementum ornare. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Duis consequat justo at enim interdum a pretium justo suscipit. Nullam sit amet sapien placerat risus ultrices tincidunt.
-
-Maecenas dignissim lacus non tortor scelerisque fringilla. Nulla facilisis diam non augue faucibus elementum. Maecenas vel magna lacus. Aliquam pretium semper dui, a fringilla ligula bibendum et. Pellentesque commodo metus id lectus lobortis eget feugiat enim scelerisque. Praesent accumsan iaculis ligula, et hendrerit sapien ultricies quis. In congue mauris a odio facilisis porttitor. Fusce vitae facilisis magna. Nam urna erat, feugiat at bibendum a, pretium a massa.
-
-Suspendisse arcu lectus, sollicitudin nec ultrices eu, venenatis sit amet nulla. Quisque consequat tortor sed ligula tempor tristique. Cras ipsum dolor, congue vitae hendrerit eget, ornare eget metus. Suspendisse potenti. Morbi rhoncus rhoncus velit, et ultrices mi condimentum sed. Nullam metus justo, tempor a vestibulum eu, pellentesque in enim. Curabitur scelerisque, est non congue iaculis, magna lorem pretium nisl, ac aliquet nibh neque eu augue. Etiam vel arcu ut urna rutrum imperdiet. Aliquam semper nulla eget mi vulputate ac ornare tellus suscipit. Nunc vitae risus ac elit rutrum sodales vitae et velit. Duis in nibh a mi pharetra pulvinar. Nunc egestas, turpis vel ullamcorper luctus, nulla ligula ullamcorper dolor, accumsan egestas quam purus nec nisi. Donec sit amet dolor non dui semper euismod vitae non lectus. Vestibulum vel urna vel diam dignissim bibendum. Sed non justo in urna dignissim laoreet. Nulla rhoncus auctor blandit.
-
-Suspendisse leo enim, dictum ut malesuada in, tempus sed purus. Integer commodo rutrum nisl id ullamcorper. Fusce imperdiet felis vel mauris imperdiet eget volutpat nibh pretium. Integer sit amet ipsum id nunc ullamcorper gravida ac facilisis purus. Etiam non enim purus, vel sagittis felis. Aliquam erat volutpat. Nunc eget ante eu magna egestas fringilla. Vivamus vel sem felis. Nullam tincidunt sapien vel nunc ullamcorper non feugiat turpis molestie.
-
-Donec mattis faucibus quam non fermentum. Aenean volutpat leo et metus gravida accumsan. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Donec eleifend dui et ipsum tempus dictum. Sed eget nisl sit amet nisi sollicitudin adipiscing nec ac turpis. Suspendisse potenti. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Fusce laoreet lacus vel mi tempor convallis. Aenean viverra auctor lobortis.
-
-Nunc consectetur mattis dui, quis fermentum lectus feugiat tincidunt. Fusce tempus quam in dui malesuada quis semper ante tempus. Aliquam eget turpis et neque facilisis ornare. Sed rutrum, sem et euismod aliquam, arcu dolor bibendum erat, quis rutrum elit leo vel massa. Nam felis ipsum, varius in posuere id, interdum vel posuere.