url-safe-bitpacking 0.3.3 → 0.3.5

package/README.md

@@ -29,10 +29,10 @@ From a memory footprint perspective there are two types of attributes in an obje
 | Predefined Bitwidth      | **✓** | **✓** | **✓** | **✓** | **✓** | ✗        | ✗      | ✗          | ✗     | ✗     |
 | Has State Bit            | ✗     | ✗     | ✗     | ✗     | ✗     | **✓**    | **✓**  | **✓**      | **✓** | ✗     |
 | Min Bitwidth             | `4`         | `1`         | `1`         | `0`         | `0`         | `1`            | –            | –                | –           | –           |
-| Max Bitwidth             | `10`        | `1`         | `10`        | `21`        | `21`        | `10`           | –            | –                | –           | –           |
+| Max Bitwidth             | `10`        | `1`         | `8`        | `10`        | `21`        | `8`           | –            | –                | –           | –           |
 | Min State Bitwidth       | –           | –           | –           | –           | –           | `0`            | `1`          | `1`              | `0`         | –           |
 | Max State Bitwidth       | –           | –           | –           | –           | –           | `10`           | `1`          | `10`             | `10`        | –           |
-| Max Available States     | `1024`      | `2`         | `1024`      | `2097152`   | `2097152`   | `1024 x 1024`  | `2`          | `1024`           | `1024`      | `0`         |
+| Max Available States     | `1024`      | `2`         | `256`      | `1024`   | `2097152`   | `1024 x 256`  | `2`          | `256`           | `1024`      | -         |
 | Has Mapping              | ✗     | ✗     | **✓** | ✗     | ✗     | **✓**    | ✗      | **✓**      | ✗     | ✗     |
 | Has Nested Objects       | ✗     | ✗     | ✗     | ✗     | ✗     | ✗        | **✓**  | **✓**      | **✓** | **✓** |
 | **UPDATING**             | **VERSION** | **BOOLEAN** | **ENUM**    | **INT**     | **FLOAT**   | **ENUM_ARRAY** | **OPTIONAL** | **ENUM_OPTIONS** | **ARRAY**   | **OBJECT**  |

package/dist/factory/enumOptionsFactory.d.ts

@@ -1,3 +1,3 @@
-import { DataEntry, EnumOptionsDataEntry, EnumOptionsType } from '../types';
-export type EnumOptionsFactory = (descriptor: (DataEntry | null)[], defaultState?: number, name?: string, options?: EnumOptionsType) => EnumOptionsDataEntry;
+import { EnumOptionsDataEntry, EnumOptionsType, ObjectDataEntry } from '../types';
+export type EnumOptionsFactory = (descriptor: (ObjectDataEntry | null)[], defaultState?: number, name?: string, options?: EnumOptionsType) => EnumOptionsDataEntry;
 export declare const create: EnumOptionsFactory;

package/dist/factory/intFactory.d.ts

@@ -1,3 +1,10 @@
 import { IntDataEntry } from '../types';
 export type IntFactory = (value: number, min?: number, max?: number, name?: string) => IntDataEntry;
+/**
+ * Method to create an int data entry
+ * @param value - `number` default value, should be between `min` and `max`
+ * @param min - `number` (default: 0), should be smaller than `max`
+ * @param max - `number` (default: 10), should be larger than `min` will be swapped if `min` is larger, the delta between min and max should not be greater than 1023 (max value representable in 10 bits)
+ * @param name - `string`
+ */
 export declare const create: IntFactory;

package/dist/factory/utils.d.ts

@@ -1,4 +1,32 @@
-import { EnumMappingType, EnumOptionsType } from '../types';
+import { DataType } from '@/enums';
+import { EnumMappingType, EnumOptionsType, PrecisionRangeType } from '../types';
+/**
+ * Method to validate the state of an unsigned int
+ */
+export declare const validateUnsignedInt: (min: number | undefined, max: number, defaultValue: number, name: string, type: DataType, maxBits: number) => {
+    min: number;
+    value: number;
+    max: number;
+    bitwidth: number;
+};
+/**
+ * Method to validate the state of a signed int
+ */
+export declare const validateSignedInt: (min: number, max: number, defaultValue: number, name: string, type: DataType, maxBits: number) => {
+    min: number;
+    value: number;
+    max: number;
+    bitwidth: number;
+};
+/**
+ * Method to validate FLOAT
+ */
+export declare const validateFloat: (min: number, max: number, defaultValue: number, precision: PrecisionRangeType, name: string, type: DataType, maxBits: number) => {
+    min: number;
+    value: number;
+    max: number;
+    bitwidth: number;
+};
 /**
  * Method to get the max and mapping from the options
  * @param options - `any[] | string | number` the options to get the max and mapping from

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { DataType, HasMappingDataTypes, HasStateBitsDataTypes, HasChildDataTypes, HasChildrenDataTypes, HasNestedDataTypes, ValueUpdateDataTypes, StateUpdateDataTypes } from './enums';
-export { VersionDataEntry, BooleanDataEntry, EnumDataEntry, IntDataEntry, FloatDataEntry, EnumArrayDataEntry, ObjectDataEntry, OptionalDataEntry, EnumOptionsDataEntry, ArrayDataEntry, PrecisionRangeType, SignificandMaxBits, IntegerMaxBits, VersionRangeType, DataEntry, ProtectedAttributeNames, EnumOptionsType, EnumMappingType, PROTECTED_ATTRIBUTE_NAMES, StateDataObject, StateDataObjectValue } from './types';
+export { VersionDataEntry, BooleanDataEntry, EnumDataEntry, IntDataEntry, FloatDataEntry, EnumArrayDataEntry, ObjectDataEntry, OptionalDataEntry, EnumOptionsDataEntry, ArrayDataEntry, PrecisionRange, PrecisionRangeType, SignificandMaxBits, IntegerMaxBits, VersionRangeType, DataEntry, ProtectedAttributeNames, EnumOptionsType, EnumMappingType, PROTECTED_ATTRIBUTE_NAMES, StateDataObject, StateDataObjectValue } from './types';
 export { getBitsCount, dataEntryBitstringParser, dataEntryCorrecting, dataEntryBitsStringifier, parseBase64ToBits } from './parsers';
 export { SpecificTypeNode, NodeFactory, GetStateNodeTree, FromState, VersionNode, ArrayNode, BooleanNode, EnumNode, IntNode, FloatNode, EnumArrayNode, OptionalNode, EnumOptionsNode, ObjectNode, StateNode, getStateData } from './stateHandling';
 export { interpolateEntryAt, getRelativeValue } from './utils';

package/dist/index.js

@@ -9,6 +9,7 @@ var StateUpdateDataTypes = ["OPTIONAL", "ENUM_OPTIONS", "ARRAY"];
 // src/types/enumData.ts
 var EnumMaxBits = 8;
 // src/types/floatData.ts
+var PrecisionRange = [-3, -2, -1, 0, 1, 2, 3, 4];
 var SignificandMaxBits = 20;
 // src/types/intData.ts
 var IntegerMaxBits = 12;
@@ -271,10 +272,6 @@ var simpleFromValueParser = (bitString, entry) => {
   }
 };
 var dataEntryBitstringParser = (entry, bitString) => {
-  const result = _dataEntryBitstringParser(entry, bitString);
-  return result;
-};
-var _dataEntryBitstringParser = (entry, bitString) => {
   switch (entry.type) {
     case "BOOLEAN":
     case "INT":
@@ -459,43 +456,74 @@ var updateStateEntry = (original, update) => {
       return updateState3(original, update);
   }
 };
-// src/factory/helperMethod.ts
-var getBitsForIntegerNumber = (number, maxBits) => {
-  const bitCount = Math.ceil(Math.log2(number));
-  if (bitCount > maxBits)
-    throw new Error(`Cannot get ${maxBits} bits for a number with ${bitCount} bits`);
-  return bitCount;
+// src/factory/utils.ts
+var validateBitsCount = (stateCount, maxBitWidth, name, type) => {
+  const bitCountForStateCount = Math.ceil(Math.log2(stateCount));
+  if (bitCountForStateCount > maxBitWidth)
+    throw new Error(`Cannot store ${stateCount} state in ${maxBitWidth} bits for ${name} ${type} you would need ${bitCountForStateCount} bits`);
+  return bitCountForStateCount;
+};
+var validateUnsignedInt = (min, max, defaultValue, name, type, maxBits) => {
+  if (min === undefined || min < 0)
+    min = 0;
+  if (!Number.isInteger(min))
+    min = Math.floor(min);
+  if (!Number.isInteger(max))
+    max = Math.floor(max);
+  [min, max] = [min, max].sort((a, b) => a - b);
+  const bitwidth = validateBitsCount(max - min + 1, maxBits, name, type);
+  if (!Number.isInteger(defaultValue))
+    defaultValue = Math.floor(defaultValue);
+  return { min, value: Math.max(min, Math.min(defaultValue, max)), max, bitwidth };
+};
+var validateSignedInt = (min, max, defaultValue, name, type, maxBits) => {
+  if (!Number.isInteger(min))
+    min = Math.floor(min);
+  if (!Number.isInteger(max))
+    max = Math.floor(max);
+  if (!Number.isInteger(defaultValue))
+    defaultValue = Math.floor(defaultValue);
+  [min, max] = [min, max].sort((a, b) => a - b);
+  const bitwidth = validateBitsCount(max - min + 1, maxBits, name, type);
+  return { min, value: Math.max(min, Math.min(Math.round(defaultValue), max)), max, bitwidth };
+};
+var validateFloat = (min, max, defaultValue, precision, name, type, maxBits) => {
+  if (!PrecisionRange.includes(precision))
+    throw new Error(`Precision ${precision} is not valid for ${name} ${type}`);
+  const precisionMultiplier = 10 ** precision;
+  min = Math.floor(min * precisionMultiplier);
+  max = Math.floor(max * precisionMultiplier);
+  [min, max] = [min, max].sort((a, b) => a - b);
+  const bitwidth = validateBitsCount(max - min + 1, maxBits, name, type);
+  [min, max] = [min, max].map((v) => v / precisionMultiplier);
+  const value = Math.max(min, Math.min(Math.round(defaultValue * precisionMultiplier) / precisionMultiplier, max));
+  return { min, value, max, bitwidth };
+};
+var getEnumMaxAndMappingFromOptions = (options) => {
+  if (typeof options === "string")
+    return { max: options.length - 1, mapping: options.split("") };
+  if (typeof options === "number")
+    return { max: options, mapping: Array.from({ length: options + 1 }, (_, i) => i) };
+  return { max: options.length - 1, mapping: options };
+};
+var getOptionsFromMaxAndMapping = (v) => {
+  if (v.mapping.every((option) => typeof option === "string" && option.length === 1))
+    return v.mapping.join("");
+  if (Array.from({ length: v.max + 1 }, (_, i) => i).every((option, i) => option === v.mapping[i]))
+    return v.max;
+  return v.mapping;
 };
-var getMinimumBitsForInteger = (v) => Math.ceil(Math.log2(v + 1));
 
 // src/factory/floatFactory.ts
 var create = (value, min = 0, max = 1, precision = 2, name = "a float") => {
-  const precisionMultiplier = 10 ** precision;
-  const roundedMin = Math.floor(min * precisionMultiplier);
-  const roundedMax = Math.ceil(max * precisionMultiplier);
-  const delta = roundedMax - roundedMin;
-  const significand = Math.max(1, getBitsForIntegerNumber(delta, SignificandMaxBits));
-  return {
-    value,
-    type: "FLOAT",
-    min: roundedMin / precisionMultiplier,
-    max: roundedMax / precisionMultiplier,
-    precision,
-    significand,
-    name
-  };
+  const r = validateFloat(min, max, value, precision, name, "FLOAT", SignificandMaxBits);
+  return { value: r.value, type: "FLOAT", min: r.min, max: r.max, precision, significand: r.bitwidth, name };
 };
 
 // src/factory/intFactory.ts
 var create2 = (value, min = 0, max = 10, name = "an int") => {
-  if (!Number.isInteger(min) || !Number.isInteger(max))
-    throw new Error("min and max must be integers");
-  if (max - min < 1)
-    throw new Error("max must be at least one");
-  if (Math.abs(max - min) > 2 ** IntegerMaxBits - 1)
-    throw new Error("max - min must be less than 1024");
-  const bits = getBitsForIntegerNumber(max - min + 1, IntegerMaxBits);
-  return { value, type: "INT", min, max, bits, name };
+  const r = validateSignedInt(min, max, value, name, "INT", IntegerMaxBits);
+  return { value, type: "INT", min: r.min, max: r.max, bits: r.bitwidth, name };
 };
 
 // src/factory/booleanFactory.ts
@@ -506,82 +534,31 @@ var create3 = (value, name = "a boolean") => ({
 });
 
 // src/factory/versionFactory.ts
-var create4 = (value, bits = 8, name = "a version") => ({
-  value,
-  type: "VERSION",
-  bits,
-  name
-});
-
-// src/factory/utils.ts
-var getEnumMaxAndMappingFromOptions = (options) => {
-  if (typeof options === "string")
-    return { max: options.length - 1, mapping: options.split("") };
-  if (typeof options === "number")
-    return { max: options, mapping: Array.from({ length: options + 1 }, (_, i) => i) };
-  return { max: options.length - 1, mapping: options };
-};
-var getOptionsFromMaxAndMapping = (v) => {
-  if (v.mapping.every((option) => typeof option === "string" && option.length === 1))
-    return v.mapping.join("");
-  if (Array.from({ length: v.max + 1 }, (_, i) => i).every((option, i) => option === v.mapping[i]))
-    return v.max;
-  return v.mapping;
+var create4 = (value, bits = 8, name = "a version") => {
+  if (!Number.isInteger(value))
+    value = Math.floor(value);
+  value = Math.max(0, Math.min(2 ** bits - 1, value));
+  return {
+    value,
+    type: "VERSION",
+    bits,
+    name
+  };
 };
 
 // src/factory/enumFactory.ts
 var create5 = (value, options, name = "an enum") => {
   const { max, mapping } = getEnumMaxAndMappingFromOptions(options);
-  if (!Number.isInteger(max))
-    throw new Error(`max must be integers, you have given ${max}`);
-  if (max < 1)
-    throw new Error("max must be at least one");
-  if (max > 2 ** EnumMaxBits - 1)
-    throw new Error("max - min must be less than 256");
-  const bits = getBitsForIntegerNumber(max + 1, EnumMaxBits);
-  return { value, type: "ENUM", max, bits, name, mapping };
+  const r = validateUnsignedInt(0, max, value, name, "ENUM", EnumMaxBits);
+  return { value: r.value, type: "ENUM", max: r.max, bits: r.bitwidth, name, mapping };
 };
 
 // src/factory/enumArrayFactory.ts
-var minEnumArrayCount = 0;
-var maxOptionsCount = 1024;
-var create6 = (value, options, minCount = minEnumArrayCount, maxCount = 10, name = "enum array") => {
+var create6 = (value, options, minCount = 0, maxCount = 10, name = "enum array") => {
   const { max, mapping } = getEnumMaxAndMappingFromOptions(options);
-  if (!Number.isInteger(max))
-    throw new Error(`max must be integers, you have given ${max}`);
-  if (!Number.isInteger(minCount) || !Number.isInteger(maxCount))
-    throw new Error("minCount and maxCount must be integers");
-  if (max < 1)
-    throw new Error("must have at least one option");
-  if (max > maxOptionsCount)
-    throw new Error(`maximum allowed options is 1024, you have given ${max + 1} options`);
-  minCount = Math.min(minCount, maxCount);
-  maxCount = Math.max(minCount, maxCount);
-  if (minCount < 0)
-    throw new Error("minCount can't be negative");
-  if (maxCount - minCount < 0)
-    throw new Error(`count range length must be positive, given count range length is ${Math.abs(maxCount - minCount)}`);
-  if (Math.abs(maxCount - minCount) > 2 ** IntegerMaxBits - 1)
-    throw new Error(`count range length must be less than 1024, given count range length is ${Math.abs(maxCount - minCount)}`);
-  value.forEach((v, i) => {
-    if (!Number.isInteger(v))
-      throw new Error(`all entries must be integers, index ${i} (${v}) is not`);
-    if (v > max)
-      throw new Error(`all entries must be within the range ${0} - ${max}, index ${i} (${v}) is not`);
-  });
-  if (value.length < minCount || value.length > maxCount)
-    throw new Error(`value length must be between minCount and maxCount, ${value.length} is not between ${minCount} and ${maxCount}`);
-  const stateBits = getBitsForIntegerNumber(maxCount - minCount + 1, IntegerMaxBits);
-  return {
-    type: "ENUM_ARRAY",
-    minCount,
-    maxCount,
-    value: JSON.parse(JSON.stringify(value)),
-    max,
-    name,
-    mapping,
-    stateBits
-  };
+  const r = validateUnsignedInt(minCount, maxCount, value.length, name, "ENUM_ARRAY", IntegerMaxBits);
+  value = Array.from({ length: r.value }, (_, i) => validateUnsignedInt(0, max, value[i] ?? 0, `${name}[${i}]`, "ENUM_ARRAY", EnumMaxBits).value);
+  return { type: "ENUM_ARRAY", minCount: r.min, maxCount: r.max, value, max, name, mapping, stateBits: r.bitwidth };
 };
 
 // src/factory/optionalFactory.ts
@@ -600,6 +577,15 @@ var create7 = (descriptor, defaultState = false, name = "an optional") => {
   };
 };
 
+// src/factory/helperMethod.ts
+var getBitsForIntegerNumber = (number, maxBits) => {
+  const bitCount = Math.ceil(Math.log2(number));
+  if (bitCount > maxBits)
+    throw new Error(`Cannot get ${maxBits} bits for a number with ${bitCount} bits`);
+  return bitCount;
+};
+var getMinimumBitsForInteger = (v) => Math.ceil(Math.log2(v + 1));
+
 // src/factory/enumOptionsFactory.ts
 var maxEnumOptions = 64;
 var maxEnumOptionsBits = getMinimumBitsForInteger(maxEnumOptions);
@@ -628,29 +614,16 @@ var create8 = (descriptor, defaultState = 0, name = "enum options", options) =>
 };
 
 // src/factory/arrayFactory.ts
-var maxArrayCount = 1024;
 var create9 = (descriptor, defaultState = 0, minCount = 0, maxCount = 10, name = "an array") => {
-  if (!Number.isInteger(minCount) || !Number.isInteger(maxCount))
-    throw new Error("minCount and maxCount must be integers");
-  if (minCount < 0)
-    throw new Error("minCount must be at least 0");
-  if (maxCount < 0)
-    throw new Error("maxCount must be at least 0");
-  if (maxCount - minCount < 0)
-    throw new Error("maxCount must be greater than or equal to minCount");
-  if (maxCount - minCount > maxArrayCount)
-    throw new Error(`maxCount (${maxCount}) - minCount (${minCount}) = ${maxCount - minCount} must be less than or equal to maxArrayCount (${maxArrayCount})`);
-  if (defaultState < minCount || defaultState > maxCount)
-    throw new Error(`defaultState must be between minCount (${minCount}) and maxCount (${maxCount}), given defaultState is ${defaultState}`);
-  const stateBits = getMinimumBitsForInteger(maxCount - minCount);
+  const r = validateUnsignedInt(minCount, maxCount, defaultState, name, "ARRAY", IntegerMaxBits);
   return {
-    value: [...Array(defaultState)].map(() => JSON.parse(JSON.stringify(descriptor))),
+    value: [...Array(r.value)].map(() => JSON.parse(JSON.stringify(descriptor))),
     descriptor,
     type: "ARRAY",
-    minCount,
-    maxCount,
-    stateBits,
-    state: defaultState,
+    minCount: r.min,
+    maxCount: r.max,
+    stateBits: r.bitwidth,
+    state: r.value,
     name
   };
 };
@@ -661,8 +634,7 @@ var create10 = (descriptor, name = "an object") => {
     type: "OBJECT",
     descriptor,
     value: descriptor,
-    name,
-    stateBits: 0
+    name
   };
 };
 
@@ -841,7 +813,10 @@ class EnumOptionsNode extends ComplexStateNodes {
   getChildren = () => [this.child];
   getStateBits = () => rawStateStringifier4(this.state, this.descriptor.stateBits);
   getValueBits = () => this.child ? this.child.bitstring : "";
-  initializedChild = () => this.descriptor.descriptor[this.state] ? NodeFactory(this.descriptor.descriptor[this.state], this) : null;
+  initializedChild = () => {
+    const validatedEntry = validateDataEntry(this.descriptor.descriptor[this.state], this.descriptor.value);
+    return validatedEntry ? NodeFactory(validatedEntry, this) : null;
+  };
   updateState = (newState) => {
     const constrainedNewState = constrainState2(this.descriptor.descriptor.length, newState);
     if (constrainedNewState === this.state)
@@ -872,7 +847,7 @@ class ArrayNode extends ComplexStateNodes {
     this.children = this.initializedChildren();
     this.bitstring = this.getBitString();
   }
-  initializedChildren = () => this.descriptor.value.map((child) => NodeFactory(child, this));
+  initializedChildren = () => this.descriptor.value.map((entry) => NodeFactory(validateDataEntry(this.descriptor.descriptor, entry), this));
   getChildren = () => this.children;
   getStateBits = () => rawStateStringifier2(this.state, this.descriptor.minCount, this.descriptor.stateBits);
   getValueBits = () => this.children.map((child) => child.bitstring).join("");
@@ -954,6 +929,7 @@ var getObjectForDataEntries = (entries) => {
   });
   return object;
 };
+var getStringForDataEntries = (values) => Array.isArray(values) && values.every((v) => typeof v === "string" && v.length === 1) ? values.join("") : values;
 var getStateData = (entry) => {
   switch (entry.type) {
     case "BOOLEAN":
@@ -964,7 +940,7 @@ var getStateData = (entry) => {
     case "ENUM":
       return entry.mapping[entry.value];
     case "ENUM_ARRAY":
-      return entry.value.map((v) => entry.mapping[v]);
+      return getStringForDataEntries(entry.value.map((v) => entry.mapping[v]));
     case "OPTIONAL":
       return entry.value === null ? null : getStateData(entry.value);
     case "ENUM_OPTIONS":
@@ -973,7 +949,7 @@ var getStateData = (entry) => {
         switch (entry.value.type) {
           case "OBJECT":
             return {
-              ...getStateData(entry.value),
+              ...getObjectForDataEntries(entry.value.value),
               state
             };
           default:
@@ -984,7 +960,7 @@ var getStateData = (entry) => {
     case "OBJECT":
       return getObjectForDataEntries(entry.value);
     case "ARRAY":
-      return entry.value.map((v) => getStateData(v));
+      return getStringForDataEntries(entry.value.map(getStateData));
   }
 };
 // src/utils/interpolateData.ts
@@ -1035,6 +1011,7 @@ export {
   StateUpdateDataTypes,
   StateNode,
   SignificandMaxBits,
+  PrecisionRange,
   PROTECTED_ATTRIBUTE_NAMES,
   OptionalNode,
   ObjectNode,

package/dist/parsers/parsers.d.ts

@@ -9,6 +9,13 @@ export declare const getStateBitsForDataEntry: (entry: DataEntry & {
  * @param entry - `DataEntry`
  */
 export declare const getContentBitsCountForDataEntry: (entry: DataEntry) => number;
+/**
+ * Method that parses a bitstring into a value
+ *
+ * @param bitString - `string` of 0 | 1
+ * @param entry - `DataEntry` that represents the data entry to parse
+ * @returns `number` | `boolean` that represents the parsed value
+ */
 export declare const dataEntryBitstringParser: <T extends DataEntry>(entry: T, bitString: string) => [T, string];
 /**
  * Method that returns the amount of bits required for a given data entry

package/dist/types/enumOptionsData.d.ts

@@ -1,10 +1,10 @@
-import { DataEntry } from './dataEntry';
+import { ObjectDataEntry } from './dataEntry';
 import { EnumMappingType } from './enumData';
 export type EnumOptionsData = {
     type: 'ENUM_OPTIONS';
     stateBits: number;
     state: number;
-    descriptor: (DataEntry | null)[];
+    descriptor: (ObjectDataEntry | null)[];
     mapping: EnumMappingType;
-    value: DataEntry | null;
+    value: ObjectDataEntry | null;
 };

package/dist/types/floatData.d.ts

@@ -1,4 +1,5 @@
-export type PrecisionRangeType = -3 | -2 | -1 | 0 | 1 | 2 | 3;
+export declare const PrecisionRange: readonly [-3, -2, -1, 0, 1, 2, 3, 4];
+export type PrecisionRangeType = (typeof PrecisionRange)[number];
 export declare const SignificandMaxBits = 20;
 /**
  * Float object

package/package.json

@@ -6,7 +6,7 @@
     "dist/*"
   ],
   "type": "module",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "author": "Jonas Ward",
   "description": "Library for creating web safe base64 objects with custom bith widths and dynamic values.",
   "scripts": {