qrloop - npm Package Compare versions

Comparing version 1.0.1 to 1.0.2

lib/__tests__/basic.js

 "use strict";
 
-var _exporter = require("../exporter");
+var _2 = require("..");
 
-var _importer = require("../importer");
-
 test("empty data", () => {
   const str = "";
-  const framesExport = (0, _exporter.dataToFrames)(str);
-  const framesImport = framesExport.reduce(_importer.parseFramesReducer, undefined);
-  expect((0, _importer.areFramesComplete)(framesImport)).toBe(true);
-  expect((0, _importer.progressOfFrames)(framesImport)).toBe(1);
-  expect((0, _importer.currentNumberOfFrames)(framesImport)).toBe((0, _importer.totalNumberOfFrames)(framesImport));
-  expect((0, _importer.framesToData)(framesImport).toString()).toBe(str);
+  const framesExport = (0, _2.dataToFrames)(str);
+  const framesImport = framesExport.reduce(_2.parseFramesReducer, undefined);
+  expect((0, _2.areFramesComplete)(framesImport)).toBe(true);
+  expect((0, _2.progressOfFrames)(framesImport)).toBe(1);
+  expect((0, _2.currentNumberOfFrames)(framesImport)).toBe((0, _2.totalNumberOfFrames)(framesImport));
+  expect((0, _2.framesToData)(framesImport).toString()).toBe(str);
 });
 test("'hello world'", () => {
   const str = "hello world";
-  const framesExport = (0, _exporter.dataToFrames)(str);
-  const framesImport = framesExport.reduce(_importer.parseFramesReducer, undefined);
-  expect((0, _importer.areFramesComplete)(framesImport)).toBe(true);
-  expect((0, _importer.progressOfFrames)(framesImport)).toBe(1);
-  expect((0, _importer.currentNumberOfFrames)(framesImport)).toBe((0, _importer.totalNumberOfFrames)(framesImport));
-  expect((0, _importer.framesToData)(framesImport).toString()).toBe(str);
+  const framesExport = (0, _2.dataToFrames)(str);
+  const framesImport = framesExport.reduce(_2.parseFramesReducer, undefined);
+  expect((0, _2.areFramesComplete)(framesImport)).toBe(true);
+  expect((0, _2.progressOfFrames)(framesImport)).toBe(1);
+  expect((0, _2.currentNumberOfFrames)(framesImport)).toBe((0, _2.totalNumberOfFrames)(framesImport));
+  expect((0, _2.framesToData)(framesImport).toString()).toBe(str);
 });
 test("'hello world' x1000", () => {
   let str = Array(1000).fill("hello world").join(" ");
-  const framesExport = (0, _exporter.dataToFrames)(Buffer.from(str), 50);
+  const framesExport = (0, _2.dataToFrames)(Buffer.from(str), 50);
   let framesImport = null;
@@ -34,8 +32,8 @@ let frameLength = -1;
   for (let i = 0; i < framesExport.length; i++) {
-    expect((0, _importer.progressOfFrames)(framesImport)).toBeGreaterThanOrEqual(frameProgress);
-    frameProgress = (0, _importer.progressOfFrames)(framesImport);
+    expect((0, _2.progressOfFrames)(framesImport)).toBeGreaterThanOrEqual(frameProgress);
+    frameProgress = (0, _2.progressOfFrames)(framesImport);
     expect(frameProgress).toBeGreaterThanOrEqual(0);
     expect(frameProgress).toBeLessThanOrEqual(1);
 
-    if ((0, _importer.areFramesComplete)(framesImport)) {
+    if ((0, _2.areFramesComplete)(framesImport)) {
       frameCompleteReached = true;
@@ -46,21 +44,21 @@ } else {
 
-    framesImport = (0, _importer.parseFramesReducer)(framesImport, framesExport[i]);
-    if (frameLength === -1) frameLength = (0, _importer.totalNumberOfFrames)(framesImport);
-    expect((0, _importer.totalNumberOfFrames)(framesImport)).toBe(frameLength);
+    framesImport = (0, _2.parseFramesReducer)(framesImport, framesExport[i]);
+    if (frameLength === -1) frameLength = (0, _2.totalNumberOfFrames)(framesImport);
+    expect((0, _2.totalNumberOfFrames)(framesImport)).toBe(frameLength);
   }
 
-  expect((0, _importer.areFramesComplete)(framesImport)).toBe(true);
-  expect((0, _importer.progressOfFrames)(framesImport)).toBe(1);
-  expect((0, _importer.currentNumberOfFrames)(framesImport)).toBe((0, _importer.totalNumberOfFrames)(framesImport));
-  expect((0, _importer.framesToData)(framesImport).toString()).toBe(str);
+  expect((0, _2.areFramesComplete)(framesImport)).toBe(true);
+  expect((0, _2.progressOfFrames)(framesImport)).toBe(1);
+  expect((0, _2.currentNumberOfFrames)(framesImport)).toBe((0, _2.totalNumberOfFrames)(framesImport));
+  expect((0, _2.framesToData)(framesImport).toString()).toBe(str);
 });
 test("binary", () => {
   const data = Buffer.from(Array(10000).fill(null).map((_, i) => i % 256));
-  const framesExport = (0, _exporter.dataToFrames)(data, 200);
+  const framesExport = (0, _2.dataToFrames)(data, 200);
   expect(framesExport).toMatchSnapshot();
-  const framesImport = framesExport.reduce(_importer.parseFramesReducer, undefined);
-  expect((0, _importer.areFramesComplete)(framesImport)).toBe(true);
-  expect((0, _importer.progressOfFrames)(framesImport)).toBe(1);
-  expect((0, _importer.currentNumberOfFrames)(framesImport)).toBe((0, _importer.totalNumberOfFrames)(framesImport));
-  expect((0, _importer.framesToData)(framesImport).toString("hex")).toBe(data.toString("hex"));
+  const framesImport = framesExport.reduce(_2.parseFramesReducer, undefined);
+  expect((0, _2.areFramesComplete)(framesImport)).toBe(true);
+  expect((0, _2.progressOfFrames)(framesImport)).toBe(1);
+  expect((0, _2.currentNumberOfFrames)(framesImport)).toBe((0, _2.totalNumberOfFrames)(framesImport));
+  expect((0, _2.framesToData)(framesImport).toString("hex")).toBe(data.toString("hex"));
 });
@@ -70,6 +68,6 @@ test("binary test many size", () => {
     const data = Buffer.from(Array(i).fill(null).map((_, i) => i % 256));
-    const framesExport = (0, _exporter.dataToFrames)(data, 200);
-    const framesImport = framesExport.reduce(_importer.parseFramesReducer, undefined);
-    expect((0, _importer.framesToData)(framesImport).toString("hex")).toBe(data.toString("hex"));
+    const framesExport = (0, _2.dataToFrames)(data, 200);
+    const framesImport = framesExport.reduce(_2.parseFramesReducer, undefined);
+    expect((0, _2.framesToData)(framesImport).toString("hex")).toBe(data.toString("hex"));
   }
 });

lib/__tests__/errors.js

 "use strict";
 
-var _exporter = require("../exporter");
+var _2 = require("..");
 
-var _importer = require("../importer");
-
 test("premature framesToData should throw", () => {
-  expect(() => (0, _importer.framesToData)()).toThrow();
-  expect(() => (0, _importer.framesToData)(null)).toThrow();
+  expect(() => (0, _2.framesToData)()).toThrow();
+  expect(() => (0, _2.framesToData)(null)).toThrow();
   const data = Buffer.from(Array(1000).fill(null).map((_, i) => i % 256));
-  const framesExport = (0, _exporter.dataToFrames)(data, 200);
+  const framesExport = (0, _2.dataToFrames)(data, 200);
   expect(framesExport.length).toBeGreaterThan(2);
-  const framesImport = (0, _importer.parseFramesReducer)((0, _importer.parseFramesReducer)(null, framesExport[0]), framesExport[1]);
-  expect((0, _importer.areFramesComplete)(framesImport)).toBe(false);
-  expect((0, _importer.currentNumberOfFrames)(framesImport)).toBeLessThan((0, _importer.totalNumberOfFrames)(framesImport));
-  expect(() => (0, _importer.framesToData)(framesImport)).toThrow();
+  const framesImport = (0, _2.parseFramesReducer)((0, _2.parseFramesReducer)(null, framesExport[0]), framesExport[1]);
+  expect((0, _2.areFramesComplete)(framesImport)).toBe(false);
+  expect((0, _2.currentNumberOfFrames)(framesImport)).toBeLessThan((0, _2.totalNumberOfFrames)(framesImport));
+  expect(() => (0, _2.framesToData)(framesImport)).toThrow();
 });
 test("corrupted data through framesToData should throw", () => {
   const data = Buffer.from(Array(1000).fill(null).map((_, i) => i % 256));
-  const framesExport = (0, _exporter.dataToFrames)(data, 200);
-  const framesImport = framesExport.reduce(_importer.parseFramesReducer, null);
+  const framesExport = (0, _2.dataToFrames)(data, 200);
+  const framesImport = framesExport.reduce(_2.parseFramesReducer, null);
   framesImport.frames[1].data[10]++; // corrupt one bit of the second frame
 
-  expect(() => (0, _importer.framesToData)(framesImport)).toThrow();
+  expect(() => (0, _2.framesToData)(framesImport)).toThrow();
 });
 test("corrupted data can be recoverable", () => {
   const data = Buffer.from(Array(1000).fill(null).map((_, i) => i % 256));
-  const framesExport = (0, _exporter.dataToFrames)(data, 200);
-  const framesImport = framesExport.reduce(_importer.parseFramesReducer, null);
+  const framesExport = (0, _2.dataToFrames)(data, 200);
+  const framesImport = framesExport.reduce(_2.parseFramesReducer, null);
   framesImport.frames[1].data[10]++; // corrupt one bit of the second frame
 
-  expect(() => (0, _importer.framesToData)(framesImport)).toThrow();
-  const framesImport2 = framesExport.reduce(_importer.parseFramesReducer, framesImport);
-  expect((0, _importer.framesToData)(framesImport2)).toMatchObject(data);
+  expect(() => (0, _2.framesToData)(framesImport)).toThrow();
+  const framesImport2 = framesExport.reduce(_2.parseFramesReducer, framesImport);
+  expect((0, _2.framesToData)(framesImport2)).toMatchObject(data);
 });
 test("extra frames added to data should throw", () => {
-  expect(() => (0, _importer.framesToData)((0, _exporter.dataToFrames)(Buffer.from(Array(1000).fill(null).map((_, i) => i % 256)), 200).reduce(_importer.parseFramesReducer, null).concat((0, _exporter.dataToFrames)(Buffer.from("foo"), 100)))).toThrow();
+  expect(() => (0, _2.framesToData)((0, _2.dataToFrames)(Buffer.from(Array(1000).fill(null).map((_, i) => i % 256)), 200).reduce(_2.parseFramesReducer, null).concat((0, _2.dataToFrames)(Buffer.from("foo"), 100)))).toThrow();
 });

lib/__tests__/fountain.js

 "use strict";
 
-var _exporter = require("../exporter");
+var _2 = require("..");
 
-var _importer = require("../importer");
-
 var _Buffer = require("../Buffer");
@@ -12,7 +10,7 @@
     const data = Buffer.from(Array(size).fill(null).map((_, i) => i % 256));
-    const framesExport = (0, _exporter.dataToFrames)(data, 200, 4);
+    const framesExport = (0, _2.dataToFrames)(data, 200, 4);
     let acc = null;
 
     for (let i = 0; i < framesExport.length; i++) {
-      acc = (0, _importer.parseFramesReducer)(acc, framesExport[i]);
+      acc = (0, _2.parseFramesReducer)(acc, framesExport[i]);
     }
@@ -26,5 +24,5 @@
   const data = Buffer.from(Array(2000).fill(null).map((_, i) => i % 256));
-  const wrappedData = (0, _exporter.wrapData)(data);
+  const wrappedData = (0, _2.wrapData)(data);
   const buffers = (0, _Buffer.cutAndPad)(wrappedData, 200);
-  const frames = buffers.map((data, frameIndex) => (0, _exporter.makeDataFrame)({
+  const frames = buffers.map((data, frameIndex) => (0, _2.makeDataFrame)({
     data,
@@ -35,12 +33,12 @@ nonce: 0,
   }));
-  const r = frames.reduce(_importer.parseFramesReducer, null);
-  expect((0, _importer.areFramesComplete)(r)).toBe(true);
-  expect((0, _importer.framesToData)(r).toString("hex")).toBe(data.toString("hex"));
+  const r = frames.reduce(_2.parseFramesReducer, null);
+  expect((0, _2.areFramesComplete)(r)).toBe(true);
+  expect((0, _2.framesToData)(r).toString("hex")).toBe(data.toString("hex"));
 });
 test("a fountain can recover one missing frame", () => {
   const data = Buffer.from(Array(2000).fill(null).map((_, i) => i % 256));
-  const wrappedData = (0, _exporter.wrapData)(data);
+  const wrappedData = (0, _2.wrapData)(data);
   const buffers = (0, _Buffer.cutAndPad)(wrappedData, 200);
   const frames = buffers.map((data, frameIndex) => ({
-    frame: (0, _exporter.makeDataFrame)({
+    frame: (0, _2.makeDataFrame)({
       data,
@@ -56,10 +54,10 @@ nonce: 0,
     const framesMissingOne = frames.slice(0, i).concat(frames.slice(i + 1));
-    const fountainFrame = (0, _exporter.makeFountainFrame)(buffers, frames.map(o => o.frameIndex));
-    const missingOne = framesMissingOne.map(o => o.frame).reduce(_importer.parseFramesReducer, null);
-    expect((0, _importer.areFramesComplete)(missingOne)).toBe(false);
-    expect((0, _importer.currentNumberOfFrames)(missingOne)).toBe(buffers.length - 1);
-    const withFountains = (0, _importer.parseFramesReducer)(missingOne, fountainFrame);
-    expect((0, _importer.areFramesComplete)(withFountains)).toBe(true);
-    expect((0, _importer.currentNumberOfFrames)(withFountains)).toBe(buffers.length);
-    expect((0, _importer.framesToData)(withFountains).toString("hex")).toBe(data.toString("hex"));
+    const fountainFrame = (0, _2.makeFountainFrame)(buffers, frames.map(o => o.frameIndex));
+    const missingOne = framesMissingOne.map(o => o.frame).reduce(_2.parseFramesReducer, null);
+    expect((0, _2.areFramesComplete)(missingOne)).toBe(false);
+    expect((0, _2.currentNumberOfFrames)(missingOne)).toBe(buffers.length - 1);
+    const withFountains = (0, _2.parseFramesReducer)(missingOne, fountainFrame);
+    expect((0, _2.areFramesComplete)(withFountains)).toBe(true);
+    expect((0, _2.currentNumberOfFrames)(withFountains)).toBe(buffers.length);
+    expect((0, _2.framesToData)(withFountains).toString("hex")).toBe(data.toString("hex"));
   }
@@ -69,6 +67,6 @@ });
   const data = Buffer.from(Array(2000).fill(null).map((_, i) => i % 256));
-  const wrappedData = (0, _exporter.wrapData)(data);
+  const wrappedData = (0, _2.wrapData)(data);
   const buffers = (0, _Buffer.cutAndPad)(wrappedData, 200);
   const frames = buffers.map((data, frameIndex) => ({
-    frame: (0, _exporter.makeDataFrame)({
+    frame: (0, _2.makeDataFrame)({
       data,
@@ -82,14 +80,14 @@ nonce: 0,
   const framesMissingThree = frames.slice(2, frames.length - 1);
-  const fountain1Frame = (0, _exporter.makeFountainFrame)(buffers, frames.map(o => o.frameIndex).slice(0, frames.length / 2));
-  const fountainAllFrame = (0, _exporter.makeFountainFrame)(buffers, frames.map(o => o.frameIndex));
-  const missingThree = framesMissingThree.map(o => o.frame).reduce(_importer.parseFramesReducer, null);
-  expect((0, _importer.areFramesComplete)(missingThree)).toBe(false);
-  expect((0, _importer.currentNumberOfFrames)(missingThree)).toBe(buffers.length - 3);
-  const withFountains = [fountain1Frame, fountainAllFrame].reduce(_importer.parseFramesReducer, missingThree);
-  expect((0, _importer.areFramesComplete)(withFountains)).toBe(false);
-  expect((0, _importer.currentNumberOfFrames)(withFountains)).toBe(buffers.length - 3);
-  const withOneMoreFrame = (0, _importer.parseFramesReducer)(withFountains, frames[0].frame);
-  expect((0, _importer.areFramesComplete)(withOneMoreFrame)).toBe(true);
-  expect((0, _importer.currentNumberOfFrames)(withOneMoreFrame)).toBe(buffers.length);
-  expect((0, _importer.framesToData)(withOneMoreFrame).toString("hex")).toBe(data.toString("hex"));
+  const fountain1Frame = (0, _2.makeFountainFrame)(buffers, frames.map(o => o.frameIndex).slice(0, frames.length / 2));
+  const fountainAllFrame = (0, _2.makeFountainFrame)(buffers, frames.map(o => o.frameIndex));
+  const missingThree = framesMissingThree.map(o => o.frame).reduce(_2.parseFramesReducer, null);
+  expect((0, _2.areFramesComplete)(missingThree)).toBe(false);
+  expect((0, _2.currentNumberOfFrames)(missingThree)).toBe(buffers.length - 3);
+  const withFountains = [fountain1Frame, fountainAllFrame].reduce(_2.parseFramesReducer, missingThree);
+  expect((0, _2.areFramesComplete)(withFountains)).toBe(false);
+  expect((0, _2.currentNumberOfFrames)(withFountains)).toBe(buffers.length - 3);
+  const withOneMoreFrame = (0, _2.parseFramesReducer)(withFountains, frames[0].frame);
+  expect((0, _2.areFramesComplete)(withOneMoreFrame)).toBe(true);
+  expect((0, _2.currentNumberOfFrames)(withOneMoreFrame)).toBe(buffers.length);
+  expect((0, _2.framesToData)(withOneMoreFrame).toString("hex")).toBe(data.toString("hex"));
 });

lib/__tests__/replicas.js

 "use strict";
 
-var _exporter = require("../exporter");
+var _2 = require("..");
 
-var _importer = require("../importer");
-
 test("'hello world' with 4 replicas", () => {
   const str = "hello world";
-  const framesExport = (0, _exporter.dataToFrames)(Buffer.from(str), 200, 4);
-  const firstScanned = (0, _importer.parseFramesReducer)(null, framesExport[0]);
-  expect((0, _importer.areFramesComplete)(firstScanned)).toBe(true);
-  expect((0, _importer.progressOfFrames)(firstScanned)).toBe(1);
-  expect((0, _importer.currentNumberOfFrames)(firstScanned)).toBe((0, _importer.totalNumberOfFrames)(firstScanned));
-  expect((0, _importer.framesToData)(firstScanned).toString()).toBe(str);
-  const secondScanned = (0, _importer.parseFramesReducer)(null, framesExport[1]);
-  expect((0, _importer.areFramesComplete)(secondScanned)).toBe(true);
-  expect((0, _importer.progressOfFrames)(secondScanned)).toBe(1);
-  expect((0, _importer.currentNumberOfFrames)(secondScanned)).toBe((0, _importer.totalNumberOfFrames)(secondScanned));
-  expect((0, _importer.framesToData)(secondScanned).toString()).toBe(str);
-  const allScanned = framesExport.reduce(_importer.parseFramesReducer, undefined);
-  expect((0, _importer.areFramesComplete)(allScanned)).toBe(true);
-  expect((0, _importer.progressOfFrames)(allScanned)).toBe(1);
-  expect((0, _importer.currentNumberOfFrames)(allScanned)).toBe((0, _importer.totalNumberOfFrames)(allScanned));
-  expect((0, _importer.framesToData)(allScanned).toString()).toBe(str);
+  const framesExport = (0, _2.dataToFrames)(Buffer.from(str), 200, 4);
+  const firstScanned = (0, _2.parseFramesReducer)(null, framesExport[0]);
+  expect((0, _2.areFramesComplete)(firstScanned)).toBe(true);
+  expect((0, _2.progressOfFrames)(firstScanned)).toBe(1);
+  expect((0, _2.currentNumberOfFrames)(firstScanned)).toBe((0, _2.totalNumberOfFrames)(firstScanned));
+  expect((0, _2.framesToData)(firstScanned).toString()).toBe(str);
+  const secondScanned = (0, _2.parseFramesReducer)(null, framesExport[1]);
+  expect((0, _2.areFramesComplete)(secondScanned)).toBe(true);
+  expect((0, _2.progressOfFrames)(secondScanned)).toBe(1);
+  expect((0, _2.currentNumberOfFrames)(secondScanned)).toBe((0, _2.totalNumberOfFrames)(secondScanned));
+  expect((0, _2.framesToData)(secondScanned).toString()).toBe(str);
+  const allScanned = framesExport.reduce(_2.parseFramesReducer, undefined);
+  expect((0, _2.areFramesComplete)(allScanned)).toBe(true);
+  expect((0, _2.progressOfFrames)(allScanned)).toBe(1);
+  expect((0, _2.currentNumberOfFrames)(allScanned)).toBe((0, _2.totalNumberOfFrames)(allScanned));
+  expect((0, _2.framesToData)(allScanned).toString()).toBe(str);
 });
@@ -30,11 +28,11 @@ test("1/3 of the frames dropped in the middle is enough to recover with at least 3 replicas", () => {
   for (let replicas = 3; replicas < 10; replicas++) {
-    let framesExport = (0, _exporter.dataToFrames)(data, 40, replicas); // drop 1/3 of the frames in the middle
+    let framesExport = (0, _2.dataToFrames)(data, 40, replicas); // drop 1/3 of the frames in the middle
 
     framesExport = framesExport.slice(0, Math.ceil(framesExport.length / 3)).concat(framesExport.slice(Math.floor(2 * framesExport.length / 3)));
-    const framesImport = framesExport.reduce(_importer.parseFramesReducer, undefined);
-    expect((0, _importer.areFramesComplete)(framesImport)).toBe(true);
-    expect((0, _importer.progressOfFrames)(framesImport)).toBe(1);
-    expect((0, _importer.currentNumberOfFrames)(framesImport)).toBe((0, _importer.totalNumberOfFrames)(framesImport));
-    expect((0, _importer.framesToData)(framesImport).toString("hex")).toBe(data.toString("hex"));
+    const framesImport = framesExport.reduce(_2.parseFramesReducer, undefined);
+    expect((0, _2.areFramesComplete)(framesImport)).toBe(true);
+    expect((0, _2.progressOfFrames)(framesImport)).toBe(1);
+    expect((0, _2.currentNumberOfFrames)(framesImport)).toBe((0, _2.totalNumberOfFrames)(framesImport));
+    expect((0, _2.framesToData)(framesImport).toString("hex")).toBe(data.toString("hex"));
   }
 });

package.json

 {
   "name": "qrloop",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Envelop big blob of data into frames that can be displayed in series of QR Codes",
@@ -5,0 +5,0 @@ "keywords": [

src/__tests__/basic.js

@@ -1,3 +0,3 @@
-import { dataToFrames } from "../exporter";
 import {
+  dataToFrames,
   parseFramesReducer,
@@ -9,3 +9,3 @@ areFramesComplete,
   framesToData
-} from "../importer";
+} from "..";
 
@@ -12,0 +12,0 @@ test("empty data", () => {

src/__tests__/errors.js

@@ -1,3 +0,3 @@
-import { dataToFrames } from "../exporter";
 import {
+  dataToFrames,
   parseFramesReducer,
@@ -8,3 +8,3 @@ areFramesComplete,
   framesToData
-} from "../importer";
+} from "..";
 
@@ -11,0 +11,0 @@ test("premature framesToData should throw", () => {

src/__tests__/fountain.js

@@ -5,5 +5,3 @@ import {
   makeDataFrame,
-  wrapData
-} from "../exporter";
-import {
+  wrapData,
   parseFramesReducer,
@@ -13,3 +11,3 @@ areFramesComplete,
   framesToData
-} from "../importer";
+} from "..";
 import { cutAndPad } from "../Buffer";
@@ -16,0 +14,0 @@

src/__tests__/replicas.js

@@ -1,3 +0,3 @@
-import { dataToFrames } from "../exporter";
 import {
+  dataToFrames,
   parseFramesReducer,
@@ -9,3 +9,3 @@ areFramesComplete,
   framesToData
-} from "../importer";
+} from "..";
 
@@ -12,0 +12,0 @@ test("'hello world' with 4 replicas", () => {

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

92969

decreased by-1.41%

Lines of code

1245

decreased by-0.48%

No dependency changes