url-safe-bitpacking 0.1.13 → 0.1.15

package/README.md

@@ -11,7 +11,9 @@ Package for creating definitions of parametric models that can be stored as comp
 | updating model entries                               | ✓  | ✓  |          |
 | re-using data from old model on change in definition | ½ | ¼ |          |
 | flattening and reading of the objects                | ✓  | ✓  | ¿ |
-| arrays (both bit-level as arrays of objects)         | ½ | ¼ |          |
+| arrays (both bit-level as arrays of objects)         | ½ | ½ |          |
+| utility to create StateValueType                     |          |          |          |
+| ability to migrate one version to another            |          |          |          |
 
 ## concept
 
@@ -53,6 +55,14 @@ Floating points work very much like the integer type, with the main difference t
 DataEntryFactory.createFloat(20, 10, 200, -1, 'shapePreProcessingWarptotal');
 ```
 
+### enum array
+
+Enum arrays are a special type of arrays where integer values are intepreted as being values of a **specific base** to then be transformed to base 2. The base is derived from the delta of the max `and` the `min` value of the enums. Besides that, there is also a `minCount` and `maxCount` value (which can be the same value, but `minCount` is at least 1). This only offers a compression rate of upto 22% vis-a-vis an array of `IntDataEntry` (worst case its 0% percent, it never takes up more space), so sometimes questionable whether it makese sense to use ^^.
+
+```typescript
+DataEntryFactory.createEnumArray([0, 1, 2], 0, 10, 3, 5, 'enumArrayA')    
+```
+
 ### version
 
 There is also a Version object which is a special case of the enum data type and has a bitwidth of 4, 6, 8 or, 10 and always occupies the first bits of the bitarray.

package/dist/enums/dataTypes.d.ts

@@ -3,6 +3,7 @@ export declare enum DataType {
     BOOLEAN = 1,
     ENUM = 2,
     INT = 3,
-    FLOAT = 4
+    FLOAT = 4,
+    ENUM_ARRAY = 5
 }
 export declare const getDataTypeName: (type: DataType) => string;

package/dist/factory/enumArrayFactory.d.ts

@@ -0,0 +1,2 @@
+import { EnumArrayDataEntry } from '@/types';
+export declare const create: (value: number[], min?: number, max?: number, minCount?: number, maxCount?: number, name?: string, index?: number) => EnumArrayDataEntry;

package/dist/factory/factory.d.ts

@@ -3,10 +3,15 @@ import { create as createInt } from './intFactory';
 import { create as createBoolean } from './booleanFactory';
 import { create as createVersion } from './versionFactory';
 import { create as createEnum } from './enumFactory';
+import { create as createEnumArray } from './enumArrayFactory';
+/**
+ * Record containing all the factory methods for the different data entry objects
+ */
 export declare const DataEntryFactory: {
     createFloat: typeof createFloat;
     createInt: typeof createInt;
     createEnum: typeof createEnum;
     createBoolean: typeof createBoolean;
     createVersion: typeof createVersion;
+    createEnumArray: typeof createEnumArray;
 };

package/dist/factory/floatFactory.d.ts

@@ -1,3 +1,12 @@
 import { FloatDataEntry } from '../types';
 import { PrecisionRangeType } from '../types/floatData';
+/**
+ * Method to create a float 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: 1), should be larger than `min`
+ * @param precision - `PrecisionRangeType` (default: 2 -> .01),
+ * @param name - `string`
+ * @param index - `number`
+ */
 export declare const create: (value: number, min?: number, max?: number, precision?: PrecisionRangeType, name?: string, index?: number) => FloatDataEntry;

package/dist/factory/helperMethod.d.ts

@@ -1,5 +1,24 @@
 import { VersionRangeType } from '../types';
+/**
+ * Helper method to get the minimum bits required to store a given integer value
+ * @param number - `number` value to get the minimum bits for
+ * @param maxBits - `number` maximum bits allowed
+ */
 export declare const getBitsForIntegerNumber: (number: number, maxBits: number) => number;
+/**
+ * Helper method to get the minimum bits required to store a given integer value
+ * @param v - `number` value to get the minimum bits for
+ */
 export declare const getMinimumBitsForInteger: (v: number) => number;
+/**
+ * Helper method to get the version value range value for a given number
+ * @param v - `number` value to get the version value range value for
+ * @returns `VersionRangeType` the version value range value
+ */
 export declare const getVersionValueRangeValueForNumber: (v: number) => VersionRangeType;
+/**
+ * Helper method to get the maximum integer value for a given bit count
+ * @param bitCount - `number` bit width to get the maximum integer value for
+ * @returns `number` the maximum integer value
+ */
 export declare const getMaxIntegerValueForGivenBitWidth: (bitCount: number) => number;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { DataType } from './enums';
 export { DataEntryFactory } from './factory';
-export { SingleLevelContentType, NestedContentDataType, NestedContentType, DoubleLevelContentType, NonEmptyValidEntryArrayType, OptionalEntryDataType, EnumEntryDataType, PrecisionRangeType, SignificandMaxBits, FloatData, IntegerMaxBits, IntData, VersionRangeType, VersionData, BooleanData, DataEntry, DataEntryArray, StateDataType, StateValueType, EnumSemantics, } from './types';
-export { createParserObject, getStateValue, getBase64String, getDataEntryArray } from './objectmap';
-export { parseBase64ToBits } from './parsers';
+export { SingleLevelContentType, NestedContentDataType, NestedContentType, DoubleLevelContentType, NonEmptyValidEntryArrayType, ArrayEntryDataType, OptionalEntryDataType, EnumEntryDataType, PrecisionRangeType, SignificandMaxBits, FloatDataEntry, IntegerMaxBits, IntDataEntry, EnumDataEntry, EnumArrayDataEntry, VersionRangeType, VersionDataEntry, BooleanDataEntry, DataEntry, DataEntryArray, StateDataType, StateValueType, EnumSemantics, DerivativeStateDataType, VersionContentDefinition, PREFIX_SEPERATOR_DELIMETER, PROTECTED_ATTRIBUTE_NAMES } from './types';
+export { createParserObject, getStateValue, getBase64String, getDataEntryArray, isDataEntry, isDoubleLevelContentType, isSingleLevelContentType, doubleLevelContentTypeIsEnumEntryDataType, doubleLevelContentTypeIsOptionalEntryDataType, doubleLevelContentTypeIsArrayDefinitionType } from './objectmap';
+export { parseBase64ToBits, getBitsCount, valueBitsParser, dataBitsParser, dataEntryBitstringParser, dataBitsStringifier, dataEntryCorrecting } from './parsers';
 export { interpolateEntryAt, getRelativeValue } from './utils';

package/dist/index.js

@@ -1,25 +1,33 @@
 // src/enums/dataTypes.ts
 var DataType;
-(function(DataType2) {
+((DataType2) => {
   DataType2[DataType2["VERSION"] = 0] = "VERSION";
   DataType2[DataType2["BOOLEAN"] = 1] = "BOOLEAN";
   DataType2[DataType2["ENUM"] = 2] = "ENUM";
   DataType2[DataType2["INT"] = 3] = "INT";
   DataType2[DataType2["FLOAT"] = 4] = "FLOAT";
-})(DataType || (DataType = {}));
-// src/enums/objectGenerationTypes.ts
-var ObjectGenerationOutputStatus;
-(function(ObjectGenerationOutputStatus2) {
-  ObjectGenerationOutputStatus2[ObjectGenerationOutputStatus2["DEFAULT"] = 0] = "DEFAULT";
-  ObjectGenerationOutputStatus2[ObjectGenerationOutputStatus2["FROM_TYPE"] = 1] = "FROM_TYPE";
-  ObjectGenerationOutputStatus2[ObjectGenerationOutputStatus2["PARSED"] = 2] = "PARSED";
-  ObjectGenerationOutputStatus2[ObjectGenerationOutputStatus2["ERROR_PARSING"] = 3] = "ERROR_PARSING";
-})(ObjectGenerationOutputStatus || (ObjectGenerationOutputStatus = {}));
+  DataType2[DataType2["ENUM_ARRAY"] = 5] = "ENUM_ARRAY";
+})(DataType ||= {});
 // src/types/floatData.ts
 var SignificandMaxBits = 20;
 
 // src/types/arrayDefinitions.ts
 var PREFIX_SEPERATOR_DELIMETER = "_";
+// src/types/dataEntry.ts
+var PROTECTED_ATTRIBUTE_NAMES = [
+  "type",
+  "value",
+  "name",
+  "internalName",
+  "index",
+  "min",
+  "max",
+  "bits",
+  "precision",
+  "significand",
+  "minCount",
+  "maxCount"
+];
 // src/types/enumData.ts
 var EnumMaxBits = 8;
 // src/types/intData.ts
@@ -51,7 +59,7 @@ var create = (value, min = 0, max = 1, precision = 2, name = "", index = -1) =>
   const significand = Math.max(1, getBitsForIntegerNumber(delta, SignificandMaxBits));
   return {
     value,
-    type: DataType.FLOAT,
+    type: 4 /* FLOAT */,
     min: roundedMin / precisionMultiplier,
     max: roundedMax / precisionMultiplier,
     precision,
@@ -70,16 +78,16 @@ var create2 = (value, min = 0, max = 10, name = "", index = -1) => {
   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: DataType.INT, min, max, bits, name, index };
+  return { value, type: 3 /* INT */, min, max, bits, name, index };
 };
 
 // src/factory/booleanFactory.ts
-var create3 = (value, name = "", index = -1) => ({ value, type: DataType.BOOLEAN, name, index });
+var create3 = (value, name = "", index = -1) => ({ value, type: 1 /* BOOLEAN */, name, index });
 
 // src/factory/versionFactory.ts
 var create4 = (value, bits = 8, name = "", index = -1) => ({
   value,
-  type: DataType.VERSION,
+  type: 0 /* VERSION */,
   bits,
   name,
   index
@@ -94,7 +102,38 @@ var create5 = (value, max = 10, name = "", index = -1) => {
   if (max > 2 ** EnumMaxBits - 1)
     throw new Error("max - min must be less than 256");
   const bits = getBitsForIntegerNumber(max + 1, EnumMaxBits);
-  return { value, type: DataType.ENUM, max, bits, name, index };
+  return { value, type: 2 /* ENUM */, max, bits, name, index };
+};
+
+// src/factory/enumArrayFactory.ts
+var create6 = (value, min = 0, max = 10, minCount = 1, maxCount = 10, name = "", index = -1) => {
+  if (!Number.isInteger(min) || !Number.isInteger(max))
+    throw new Error("min and max must be integers");
+  if (!Number.isInteger(minCount) || !Number.isInteger(maxCount))
+    throw new Error("minCount and maxCount must be integers");
+  min = Math.min(min, max);
+  max = Math.max(min, max);
+  if (max - min < 1)
+    throw new Error("range length must be at least one");
+  if (Math.abs(max - min) > 2 ** IntegerMaxBits - 1)
+    throw new Error("range length must be less than 1024");
+  minCount = Math.min(minCount, maxCount);
+  maxCount = Math.max(minCount, maxCount);
+  if (minCount < 1)
+    throw new Error("minCount must be at least one");
+  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 < min || v > max)
+      throw new Error(`all entries must be within the range ${min} - ${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}`);
+  return { type: 5 /* ENUM_ARRAY */, minCount, maxCount, value, min, max, name, index };
 };
 
 // src/factory/factory.ts
@@ -103,10 +142,11 @@ var DataEntryFactory = {
   createInt: create2,
   createEnum: create5,
   createBoolean: create3,
-  createVersion: create4
+  createVersion: create4,
+  createEnumArray: create6
 };
 // src/parsers/intParser.ts
-var getBitsCount = (intData3) => intData3.bits;
+var getBitsCount = (intData2) => intData2.bits;
 var rawValueParser = (stateString, bitCount) => {
   if (stateString.length < bitCount)
     throw new Error(`To few bits for this int bit string (${stateString.length} instead of ${bitCount})`);
@@ -117,9 +157,9 @@ var rawValueParser = (stateString, bitCount) => {
     throw new Error("Invalid int state string");
   return parsed;
 };
-var rawParser = (stateString, intData3) => {
-  const v = rawValueParser(stateString, intData3.bits) + intData3.min;
-  if (v > intData3.max)
+var rawParser = (stateString, intData2) => {
+  const v = rawValueParser(stateString, intData2.bits) + intData2.min;
+  if (v > intData2.max)
     throw new Error("Value exceeds max");
   return v;
 };
@@ -128,16 +168,16 @@ var rawIntStringifier = (value, bitCount) => {
     throw new Error("Value is not an integer");
   return value.toString(2).padStart(bitCount, "0");
 };
-var rawStringifier = (value, intData3) => {
-  if (value < intData3.min)
+var rawStringifier = (value, intData2) => {
+  if (value < intData2.min)
     throw new Error("Value is below min");
-  if (value > intData3.max)
+  if (value > intData2.max)
     throw new Error("Value exceeds max");
-  return rawIntStringifier(value - intData3.min, intData3.bits);
+  return rawIntStringifier(value - intData2.min, intData2.bits);
 };
 
 // src/parsers/floatParser.ts
-var getBitsCount2 = (floatData3) => floatData3.significand;
+var getBitsCount2 = (floatData2) => floatData2.significand;
 var rawValueParser2 = (stateString, significandBits, precision) => {
   if (stateString.length < significandBits)
     throw new Error(`To few bits for this float bit string (${stateString.length} instead of ${significandBits})`);
@@ -146,13 +186,13 @@ var rawValueParser2 = (stateString, significandBits, precision) => {
   const significand = rawValueParser(stateString, significandBits);
   return significand * 10 ** -precision;
 };
-var rawParser2 = (stateString, floatData3) => {
-  const v = floatData3.min + rawValueParser2(stateString, floatData3.significand, floatData3.precision);
-  if (v > floatData3.max)
+var rawParser2 = (stateString, floatData2) => {
+  const v = floatData2.min + rawValueParser2(stateString, floatData2.significand, floatData2.precision);
+  if (v > floatData2.max)
     throw new Error("Float value exceeds max");
   return v;
 };
-var rawStringifier2 = (value, floatData3) => rawIntStringifier(Math.round((value - floatData3.min) * 10 ** floatData3.precision), floatData3.significand);
+var rawStringifier2 = (value, floatData2) => rawIntStringifier(Math.round((value - floatData2.min) * 10 ** floatData2.precision), floatData2.significand);
 
 // src/parsers/enumParser.ts
 var getBitsCount3 = (versionData2) => versionData2.bits;
@@ -184,66 +224,131 @@ var rawValueParser3 = (stateString) => {
 var rawParser5 = (stateString) => rawValueParser3(stateString);
 var rawStringifier5 = (value) => value ? "1" : "0";
 
+// src/parsers/enumArrayParser.ts
+var getCountBitsCount = (enumArrayData) => getBitsForIntegerNumber(enumArrayData.maxCount - enumArrayData.minCount + 1, IntegerMaxBits);
+var getNumberBitsCountForBase = (count, base) => getBitsForEnumArrayCountOfBase(count, base);
+var getEnumArrayBase = (enumArrayData) => enumArrayData.max - enumArrayData.min + 1;
+var getCount = (enumArrayData, bitString) => {
+  const countBits = getCountBitsCount(enumArrayData);
+  if (countBits === 0)
+    return enumArrayData.minCount;
+  return rawValueParser(bitString.slice(0, countBits), countBits) + enumArrayData.minCount;
+};
+var getBitsCount6 = (enumArrayData, bitString) => {
+  const countBits = getCountBitsCount(enumArrayData);
+  const count = getCount(enumArrayData, bitString);
+  const valuesBitCount = getNumberBitsCountForBase(count, getEnumArrayBase(enumArrayData));
+  return countBits + valuesBitCount;
+};
+var rawParser6 = (bitString, enumArrayData) => {
+  const countBits = getCountBitsCount(enumArrayData);
+  const count = getCount(enumArrayData, bitString);
+  const base = getEnumArrayBase(enumArrayData);
+  const valuesBitCount = getNumberBitsCountForBase(count, base);
+  const value = convertBitStringToArbitraryBase(bitString.slice(countBits, countBits + valuesBitCount), base, count);
+  return value.map((v) => v + enumArrayData.min);
+};
+var rawStringifier6 = (value, enumArrayData) => {
+  const countBits = getCountBitsCount(enumArrayData);
+  const count = value.length;
+  const base = getEnumArrayBase(enumArrayData);
+  const countBitstring = countBits ? rawIntStringifier(count - enumArrayData.minCount, countBits) : "";
+  const enumArrayBitstring = convertArbitraryBaseToBitString(value.map((v) => v - enumArrayData.min), base);
+  return countBitstring + enumArrayBitstring;
+};
+
 // src/parsers/parsers.ts
 var valueBitsParser = (bitString, mapData) => {
   switch (mapData.type) {
-    case DataType.BOOLEAN:
+    case 1 /* BOOLEAN */:
       return rawParser5(bitString);
-    case DataType.INT:
+    case 3 /* INT */:
       return rawParser(bitString, mapData);
-    case DataType.ENUM:
+    case 2 /* ENUM */:
       return rawParser3(bitString, mapData);
-    case DataType.FLOAT:
+    case 4 /* FLOAT */:
       return rawParser2(bitString, mapData);
-    case DataType.VERSION:
+    case 0 /* VERSION */:
       return rawParser4(bitString, mapData);
+    case 5 /* ENUM_ARRAY */:
+      return rawParser6(bitString, mapData);
   }
 };
 var dataBitsParser = (rawString, mapData) => {
   switch (mapData.type) {
-    case DataType.BOOLEAN:
+    case 1 /* BOOLEAN */:
       return { ...mapData, value: valueBitsParser(rawString, mapData) };
-    case DataType.ENUM:
-    case DataType.INT:
-    case DataType.FLOAT:
-    case DataType.VERSION:
+    case 2 /* ENUM */:
+    case 3 /* INT */:
+    case 4 /* FLOAT */:
+    case 0 /* VERSION */:
+      return { ...mapData, value: valueBitsParser(rawString, mapData) };
+    case 5 /* ENUM_ARRAY */:
       return { ...mapData, value: valueBitsParser(rawString, mapData) };
   }
 };
-var getBitsCount6 = (mapData) => {
+var getBitsCount7 = (mapData, bitString) => {
   switch (mapData.type) {
-    case DataType.BOOLEAN:
+    case 1 /* BOOLEAN */:
       return getBitsCount5();
-    case DataType.INT:
+    case 3 /* INT */:
       return getBitsCount(mapData);
-    case DataType.FLOAT:
+    case 4 /* FLOAT */:
       return getBitsCount2(mapData);
-    case DataType.VERSION:
+    case 0 /* VERSION */:
       return getBitsCount4(mapData);
-    case DataType.ENUM:
+    case 2 /* ENUM */:
       return getBitsCount3(mapData);
+    case 5 /* ENUM_ARRAY */:
+      return getBitsCount6(mapData, bitString);
   }
 };
 var dataEntryBitstringParser = (bitstring, dataEntry2) => [
-  dataBitsParser(bitstring.slice(0, getBitsCount6(dataEntry2)), dataEntry2),
-  bitstring.slice(getBitsCount6(dataEntry2))
+  dataBitsParser(bitstring.slice(0, getBitsCount7(dataEntry2, bitstring)), dataEntry2),
+  bitstring.slice(getBitsCount7(dataEntry2, bitstring))
 ];
 var dataBitsStringifier = (data) => {
   switch (data.type) {
-    case DataType.BOOLEAN:
+    case 1 /* BOOLEAN */:
       return rawStringifier5(data.value);
-    case DataType.INT:
+    case 3 /* INT */:
       return rawStringifier(data.value, data);
-    case DataType.FLOAT:
+    case 4 /* FLOAT */:
       return rawStringifier2(data.value, data);
-    case DataType.VERSION:
+    case 0 /* VERSION */:
       return rawStringifier4(data.value, data);
-    case DataType.ENUM:
+    case 2 /* ENUM */:
       return rawStringifier3(data.value, data);
+    case 5 /* ENUM_ARRAY */:
+      return rawStringifier6(data.value, data);
   }
 };
 var dataEntryCorrecting = (dataEntry2) => dataBitsParser(dataBitsStringifier(dataEntry2), dataEntry2);
 var base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var getBitsForEnumArrayCountOfBase = (count, base) => Math.ceil(Math.log2(base) * count);
+var convertArbitraryBaseToBitString = (input, fromBase) => {
+  const expectedOutputLength = getBitsForEnumArrayCountOfBase(input.length, fromBase);
+  const fromBaseBigInt = BigInt(fromBase);
+  let decimalValue = BigInt(0);
+  for (let i = input.length - 1;i >= 0; i--)
+    decimalValue = decimalValue * fromBaseBigInt + BigInt(input[i]);
+  const s = decimalValue.toString(2).padStart(expectedOutputLength, "0");
+  return s;
+};
+var convertBitStringToArbitraryBase = (input, toBase, expectedOutputLength) => {
+  let decimalValue = BigInt(`0b${input}`);
+  const toBaseBigInt = BigInt(toBase);
+  const result = [];
+  while (decimalValue > 0) {
+    const remainder = decimalValue % toBaseBigInt;
+    result.push(Number(remainder));
+    decimalValue = decimalValue / toBaseBigInt;
+  }
+  if (expectedOutputLength !== undefined && result.length !== expectedOutputLength)
+    for (let i = result.length;i < expectedOutputLength; i++)
+      result.push(0);
+  return result;
+};
 var parseBitsToBase64 = (bits) => {
   const chunks = bits.match(/.{1,6}/g);
   const numbers = chunks?.map((c) => Number.parseInt(c.padEnd(6, "0"), 2)) ?? [];
@@ -299,21 +404,32 @@ var updateValue5 = (original, update) => ({
   value: update.value
 });
 
-// src/update/updateValues.ts
+// src/update/enumArrayUpdate.ts
 var updateValue6 = (original, update) => {
+  const value = update.value.map((v) => Math.max(Math.min(original.max, v), original.min));
+  return {
+    ...original,
+    value
+  };
+};
+
+// src/update/updateValues.ts
+var updateValue7 = (original, update) => {
   if (original.type !== update.type)
     throw new Error("Types do not match");
   switch (original.type) {
-    case DataType.FLOAT:
+    case 4 /* FLOAT */:
       return updateValue(original, update);
-    case DataType.INT:
+    case 3 /* INT */:
       return updateValue2(original, update);
-    case DataType.ENUM:
+    case 2 /* ENUM */:
       return updateValue3(original, update);
-    case DataType.BOOLEAN:
+    case 1 /* BOOLEAN */:
       return updateValue5(original, update);
-    case DataType.VERSION:
+    case 0 /* VERSION */:
       return updateValue4(original, update);
+    case 5 /* ENUM_ARRAY */:
+      return updateValue6(original, update);
   }
 };
 // src/objectmap/stateValueHelperMethods.ts
@@ -350,6 +466,7 @@ var singleLevelContentTypeIsNestedContentDataType = (data) => Array.isArray(data
 var doubleLevelContentTypeIsEnumEntryDataType = (data) => isDoubleLevelContentType(data) && typeof data[0] === "number";
 var doubleLevelContentTypeIsOptionalEntryDataType = (data) => isDoubleLevelContentType(data) && typeof data[0] === "boolean";
 var doubleLevelContentTypeIsArrayDefinitionType = (data) => Array.isArray(data[0]) && data[0].length === 2 && typeof data[0][0] === "number" && typeof data[0][1] === "number";
+var isDataEntry = (v) => typeof v === "object" && !Array.isArray(v) && v?.type !== undefined && v?.value !== undefined;
 
 // src/objectmap/stateDataModel.ts
 var currentDataEntryIndex = 0;
@@ -362,7 +479,13 @@ var readDataEntry = (dataEntry2, bitString) => {
 var updateDataEntry = (dataEntry2, existingData) => {
   const existingDataEntry = findExistingDataEntry(dataEntry2, existingData);
   currentDataEntryIndex++;
-  return [existingData, [dataEntry2.name, { ...existingDataEntry ? updateValue6(dataEntry2, existingDataEntry) : dataEntry2, index: currentDataEntryIndex }]];
+  return [
+    existingData,
+    [
+      dataEntry2.name,
+      { ...existingDataEntry ? updateValue7(dataEntry2, existingDataEntry) : dataEntry2, index: currentDataEntryIndex }
+    ]
+  ];
 };
 var internalGetDataEntry = (dataEntry2, prefix, additionalData) => {
   const internalName = `${prefix}${PREFIX_SEPERATOR_DELIMETER}${dataEntry2.name}`;
@@ -394,9 +517,9 @@ var getStateFromEnumEntryDataType = (eedt, prefix, attributeName) => (additional
   if (Math.round(eedt[0]) !== eedt[0])
     `given default (${eedt[0]}) value isn't an integer, rounding it`;
   if (eedt.length - 2 < Math.round(eedt[0]))
-    console.log(`given default value (${eedt[0]}) was larger than the amount of options available, using the largest value (${eedt.length - 2}) instead`);
+    throw new Error(`given default value (${eedt[0]}) was larger than the amount of options available, using the largest value (${eedt.length - 2}) instead`);
   if (eedt[0] < 0)
-    console.log(`given default value (${eedt[0]}) was negative, using first index (0) instead`);
+    throw new Error(`given default value (${eedt[0]}) was negative, using first index (0) instead`);
   const [updatedLocalAdditionalData, [__, s]] = internalGetDataEntry(DataEntryFactory.createEnum(Math.max(Math.min(eedt.length - 2, Math.round(eedt[0])), 0), eedt.length - 1, attributeName), prefix, additionalData);
   const [nestedAdditionalData, [_, v]] = getStateDateFromSingleLevelContentTypeArray(eedt[1 + s.value], s.internalName, attributeName)(updatedLocalAdditionalData);
   return [
@@ -459,7 +582,7 @@ var getStateDataFromSingleLevelContentType = (slct, prefix) => {
   if (singleLevelContentTypeIsDataEntry(slct))
     return (additionalData) => internalGetDataEntry(slct, prefix, additionalData);
   else if (singleLevelContentTypeIsNestedContentDataType(slct))
-    return getStateDataFromNestedContentType(slct[1], prefix, slct[0]);
+    return getStateDataFromNestedContentType(slct[1], `${prefix}_${slct[0]}`, slct[0]);
   throw new Error("this is an invalid output value, wonder why?");
 };
 var getGenerationMethodForSingleLevelContentTypeArray = (slct) => {
@@ -488,7 +611,7 @@ var getParserMethodForVersionDefinition = (vadt, versionBits, defaultVersion) =>
   const versionEntry = DataEntryFactory.createVersion(versionIndex, versionBits, "version");
   return getGenerationMethodForSingleLevelContentTypeArray([versionEntry, ...versionDefinition])(additionalData);
 };
-var getUpdaterMethodForVersionDefinition = (parser) => (state, entryToUpdate) => parser([entryToUpdate, ...getDataEntryArray(state)]);
+var getUpdaterMethodForVersionDefinition = (parser) => (state, entryToUpdate) => parser([...Array.isArray(entryToUpdate) ? entryToUpdate : [entryToUpdate], ...getDataEntryArray(state)]);
 var getStringifyMethodForVersionDefinition = (parser) => (data) => getBase64String(parser(data));
 var createParserObject = (versionContent, maximumExpectedVersions, defaultVersion, enumSemanticsMapping, attributeSemanticsMapping, exposedVersions) => {
   const versionBitCount = getVersionValueRangeValueForNumber(maximumExpectedVersions);
@@ -496,7 +619,7 @@ var createParserObject = (versionContent, maximumExpectedVersions, defaultVersio
   if (versionContent.length > maximumExpectedVersions)
     throw new Error(`Cannot have more than ${maximumExpectedVersions} versions`);
   if (localDefaultVersion !== (defaultVersion ?? 0))
-    console.log(`Default version must be between 0 and ${versionContent.length - 1}, instead of ${defaultVersion} will be using ${localDefaultVersion}`);
+    throw new Error(`Default version must be between 0 and ${versionContent.length - 1}.`);
   const parser = getParserMethodForVersionDefinition(versionContent, versionBitCount, localDefaultVersion);
   const updater = getUpdaterMethodForVersionDefinition(parser);
   const stringify = getStringifyMethodForVersionDefinition(parser);
@@ -515,42 +638,60 @@ var interpolateEntryAt = (dataEntry2, t) => {
   const localT = Math.max(Math.min(1, t), 0);
   const cosT = Math.cos(localT * 2 * Math.PI) * 0.5 + 0.5;
   switch (dataEntry2.type) {
-    case DataType.BOOLEAN:
+    case 1 /* BOOLEAN */:
       return { ...dataEntry2, value: Boolean(Math.round(localT)) };
-    case DataType.VERSION:
+    case 0 /* VERSION */:
       return { ...dataEntry2, value: Math.floor(localT * (dataEntry2.bits ** 2 - 0.001)) };
-    case DataType.ENUM:
+    case 2 /* ENUM */:
       return { ...dataEntry2, value: Math.floor(localT * (dataEntry2.max + 0.999)) };
-    case DataType.INT:
+    case 3 /* INT */:
       return { ...dataEntry2, value: dataEntry2.min + Math.floor(cosT * (dataEntry2.max - dataEntry2.min + 0.999)) };
-    case DataType.FLOAT:
+    case 4 /* FLOAT */:
       const v = dataEntry2.min + cosT * (dataEntry2.max - dataEntry2.min);
       return dataEntryCorrecting({ ...dataEntry2, value: Math.min(dataEntry2.max, Math.max(v, dataEntry2.min)) });
+    case 5 /* ENUM_ARRAY */:
+      return { ...dataEntry2, value: dataEntry2.value.map((v2) => Math.floor(localT * (v2 + 0.999))) };
   }
 };
 // src/utils/relativeValue.ts
 var getRelativeValue = (dataEntry2) => {
   switch (dataEntry2.type) {
-    case DataType.BOOLEAN:
+    case 1 /* BOOLEAN */:
       return Number(dataEntry2.value);
-    case DataType.INT:
-    case DataType.FLOAT:
+    case 3 /* INT */:
+    case 4 /* FLOAT */:
       return (dataEntry2.value - dataEntry2.min) / (dataEntry2.max - dataEntry2.min);
-    case DataType.VERSION:
+    case 0 /* VERSION */:
       return dataEntry2.value / (2 ** dataEntry2.bits - 1);
-    case DataType.ENUM:
+    case 2 /* ENUM */:
       return dataEntry2.value / dataEntry2.max;
+    case 5 /* ENUM_ARRAY */:
+      return dataEntry2.value.reduce((acc, v) => acc + v, 0) / dataEntry2.value.length;
   }
 };
 export {
+  valueBitsParser,
   parseBase64ToBits,
+  isSingleLevelContentType,
+  isDoubleLevelContentType,
+  isDataEntry,
   interpolateEntryAt,
   getStateValue,
   getRelativeValue,
   getDataEntryArray,
+  getBitsCount7 as getBitsCount,
   getBase64String,
+  doubleLevelContentTypeIsOptionalEntryDataType,
+  doubleLevelContentTypeIsEnumEntryDataType,
+  doubleLevelContentTypeIsArrayDefinitionType,
+  dataEntryCorrecting,
+  dataEntryBitstringParser,
+  dataBitsStringifier,
+  dataBitsParser,
   createParserObject,
   SignificandMaxBits,
+  PROTECTED_ATTRIBUTE_NAMES,
+  PREFIX_SEPERATOR_DELIMETER,
   IntegerMaxBits,
   DataType,
   DataEntryFactory

package/dist/objectmap/stateDataModel.d.ts

@@ -7,9 +7,23 @@ import { DataEntry, DataEntryArray, NestedContentType, SingleLevelContentType, D
 export declare const findExistingDataEntry: (dataEntry: DataEntry, dataEntryArray: DataEntryArray) => DataEntry | undefined;
 export declare const readDataEntry: (dataEntry: DataEntry, bitString: string) => DataEntryParsingReturnType;
 export declare const updateDataEntry: (dataEntry: DataEntry, existingData: DataEntryArray) => DataEntryParsingReturnType;
+/**
+ * Method that extracts the data for a data entry from the given data
+ * @param dataEntry - `DataEntry` object that represents the data entry to extract the data for
+ * @param prefix - `string` that represents the prefix of the data internam name of the `DataEntry` object
+ * @param additionalData - `DataEntryArray` or `string` that represents the additional data to extract the data from, if not provided, the default value will be returned
+ * @returns `[DataEntryArray | string | undefined, [string, DataEntry]]` tuple that represents the updated additional data and the extracted data entry
+ */
 export declare const internalGetDataEntry: (dataEntry: DataEntry, prefix: string, additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DataEntry]];
 export declare const getStateFromOptionalEntryDataType: (oedt: OptionalEntryDataType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
 export declare const getStateFromEnumEntryDataType: (eedt: EnumEntryDataType, prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, StateDataType]];
+/**
+ * Helper method to get the method to parse, initiliaze, or update the state data for an array entry data type
+ * @param aedt - `ArrayEntryDataType` object that represents the array entry data type
+ * @param prefix - `string` that represents the prefix of the data internam name of the `DataEntry` object
+ * @param attributeName - `string` that represents the name of the attribute to extract the data from
+ * @returns `InternalStateDataGenerationMethod` object that represents the method to parse, initiliaze, or update the state data for an array entry data type
+ */
 export declare const getStateFromArrayEntryDataType: (aedt: ArrayEntryDataType, prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DerivativeStateDataType]];
 export declare const getStateDataFromDoubleLevelContentType: (dct: DoubleLevelContentType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
 export declare const getStateDateFromSingleLevelContentTypeArray: (slcta: SingleLevelContentType[], prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, StateDataType]];

package/dist/parsers/enumArrayParser.d.ts

@@ -0,0 +1,4 @@
+import { EnumArrayData } from '../types/enumArrayData';
+export declare const getBitsCount: (enumArrayData: EnumArrayData, bitString: string) => number;
+export declare const rawParser: (bitString: string, enumArrayData: EnumArrayData) => number[];
+export declare const rawStringifier: (value: number[], enumArrayData: EnumArrayData) => string;

package/dist/parsers/intParser.d.ts

@@ -1,5 +1,11 @@
 import { IntData } from '../types/intData';
 export declare const getBitsCount: (intData: IntData) => number;
+/**
+ * Method that parses a state bitstring into a raw positive int
+ * @param stateString - `string` 0 | 1
+ * @param bitCount - `number` amount of bits to consider
+ * @returns number
+ */
 export declare const rawValueParser: (stateString: string, bitCount: number) => number;
 export declare const rawParser: (stateString: string, intData: IntData) => number;
 export declare const rawIntStringifier: (value: number, bitCount: number) => string;

package/dist/parsers/parsers.d.ts

@@ -1,7 +1,31 @@
 import { DataEntryArray, DataEntry } from '../types/dataEntry';
-export declare const valueBitsParser: (bitString: string, mapData: DataEntry) => number | boolean;
+/**
+ * Method that parses a bitstring into a value
+ * @param bitString - `string` of 0 | 1
+ * @param mapData - `DataEntry` that represents the data entry to parse
+ * @returns `number` | `boolean` that represents the parsed value
+ */
+export declare const valueBitsParser: (bitString: string, mapData: DataEntry) => number | boolean | number[];
+/**
+ * Method that parses a bitstring into a data entry
+ * @param rawString - `string` of 0 | 1
+ * @param mapData - `DataEntry` that represents the data entry to parse
+ * @returns `DataEntry` that represents the parsed data entry
+ */
 export declare const dataBitsParser: (rawString: string, mapData: DataEntry) => DataEntry;
-export declare const getBitsCount: (mapData: DataEntry) => number;
+/**
+ * Method that returns the amount of bits required for a given data entry
+ * @param mapData - `DataEntry` that represents the data entry to get the bits count for
+ * @param bitString - `string` 0 | 1
+ * @returns `number` that represents the bits count for the given data entry
+ */
+export declare const getBitsCount: (mapData: DataEntry, bitString: string) => number;
+/**
+ * Method that parses a bitstring into a data entry and returns the remaining bitstring
+ * @param bitstring - `string` of 0 | 1
+ * @param dataEntry - `DataEntry` that represents the data entry to parse
+ * @returns `[DataEntry, string]` that represents the data entry and the remaining bitstring
+ */
 export declare const dataEntryBitstringParser: (bitstring: string, dataEntry: DataEntry) => [DataEntry, string];
 /**
  * Method to convert a bitstring into an array of data entries
@@ -9,10 +33,50 @@ export declare const dataEntryBitstringParser: (bitstring: string, dataEntry: Da
  * @param mapDataArray Data descriptions to map the bits to data entries
  * @returns array of data entries
  */
-export declare const dataBitsArrayParser: (bitString: string, mapDataArray: DataEntry[]) => DataEntryArray;
+export declare const dataBitsArrayParser: (bitString: string, mapDataArray: DataEntryArray) => DataEntryArray;
 export declare const dataBitsStringifier: (data: DataEntry) => string;
 export declare const dataEntryCorrecting: (dataEntry: DataEntry) => DataEntry;
+export declare const base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+/**
+ * Method that returns the bits required for a given amount of numners for a specific base
+ * @param count - `number` amount of numbers
+ * @param base - `number` max value of the numbers
+ */
+export declare const getBitsForEnumArrayCountOfBase: (count: number, base: number) => number;
+/**
+ * Method to convert an array of numbers to a bit string
+ * @param input - `number[]` the input array of numbers to convert to a bit string
+ * @param fromBase - `number` that represents the base of the input numbers
+ * @returns `string` that represents the bit string of the input numbers
+ * @returns 0 | 1 bit string
+ */
+export declare const convertArbitraryBaseToBitString: (input: number[], fromBase: number) => string;
+/**
+ * Method to convert a bit string to an array of numbers of a specific base
+ * @param input - `string` that represents the bit string to convert to an array of numbers
+ * @param toBase - `number` that represents the base of the output numbers
+ * @param expectedOutputLength - `number` that represents the expected length of the output array
+ */
+export declare const convertBitStringToArbitraryBase: (input: string, toBase: number, expectedOutputLength: number) => number[];
+/**
+ * Unused method to convert an array of numbers from an arbitrary base to an arbitrary base
+ * @param input - `number[]` the input array of numbers to convert to a bit string
+ * @param fromBase - `number` that represents the base of the input numbers
+ * @param toBase - `number` that represents the base of the output numbers
+ * @param expectedOutputLength - `number` | optional, should be given when you should find a specific amount of output numbers
+ */
+export declare const convertArbitraryBaseToArbitraryBase: (input: number[], fromBase: number, toBase: number, expectedOutputLength?: number) => number[];
+/**
+ * Method that convists a bitstring to a url safe base64 string
+ * @param bits - `string` of 0 | 1
+ * @returns `string` that represents the url safe base64 string
+ */
 export declare const parseBitsToBase64: (bits: string) => string;
+/**
+ * Method that convists a url safe base64 string to a bitstring
+ * @param base64 - `string` that represents the url safe base64 string
+ * @returns `string` of 0 | 1
+ */
 export declare const parseBase64ToBits: (base64: string) => string;
 /**
  * Method to convert an array of data entries into a base64 string

package/dist/typeFactory/dataEntryTyping.d.ts

@@ -0,0 +1,6 @@
+import { DataEntry } from '../types';
+export declare const getDataEntryTypeString: (d: DataEntry, withLibraryInformation?: boolean, retainValue?: boolean) => string;
+export declare const getStateDataContentType: (d: DataEntry) => string;
+export declare const getStateValueContentType: (d: DataEntry) => string;
+export declare const getSafeName: (name: string) => string;
+export declare const getDateEntryTypeNamedString: (d: DataEntry, withLibraryInformation?: boolean) => string;

package/dist/typeFactory/index.d.ts

@@ -0,0 +1 @@
+export * from './dataEntryTyping';

package/dist/typeFactory/stateDataTyping.d.ts

@@ -0,0 +1,9 @@
+import { ArrayEntryDataType, DoubleLevelContentType, EnumEntryDataType, NestedContentType, OptionalEntryDataType, SingleLevelContentType, VersionContentDefinition } from '../types';
+export declare const getVersionContentTypeFile: (versionContent: VersionContentDefinition) => string;
+export declare const getStateDataTypeForSingleLevelContentTypeArray: (slcta: SingleLevelContentType[]) => string;
+export declare const getStateDataTypeForSingleLevelContentType: (slct: SingleLevelContentType) => string;
+export declare const getStateDataTypeNestedContentType: (ncdt: NestedContentType, attributeName: string) => string;
+export declare const getStateDataTypeForDoubleLevelContentType: (dncdt: DoubleLevelContentType, attributeName: string) => string;
+export declare const getStateDataTypeForOptionalEntryDataType: (oedt: OptionalEntryDataType, attributeName: string) => string;
+export declare const getStateDataTypeForEnumEntryDataType: (eedt: EnumEntryDataType, attributeName: string) => string;
+export declare const getStateDataTypeForArrayEntryDataType: (aedt: ArrayEntryDataType, attributeName: string) => string;

package/dist/types/arrayDefinitions.d.ts

@@ -1,10 +1,58 @@
 import { DataEntry } from './dataEntry';
-export type SingleLevelContentType = DataEntry | NestedContentDataType;
+/**
+ * Nested Content Type
+ * content type that does nothing more than provide a name to an entry so that the data can be read from a key-value pair object
+ */
 export type NestedContentDataType = [string, NestedContentType];
+/**
+ * Single Level Content Type
+ * data that can be behind a string in an object definition
+ */
+export type SingleLevelContentType = DataEntry | NestedContentDataType;
+/**
+ * Content Type Union
+ */
 export type NestedContentType = SingleLevelContentType[] | DoubleLevelContentType;
+/**
+ * Double Level Content Type
+ * is a data model array definition for which the first entry describes relevant data for the datamodel content type, but data model definition in of itself
+ *
+ * this additional state data is represented in the object model with a boolean for the OptionalEntryDataType, an Enum for the EnumEntryDataType and an array for the ArrayEntryDataType+++++++++
+ */
 export type DoubleLevelContentType = OptionalEntryDataType | EnumEntryDataType | ArrayEntryDataType;
+/**
+ * Non Empty Valid Entry Array Type
+ * is a data model array definition that is not empty
+ */
 export type NonEmptyValidEntryArrayType = [SingleLevelContentType, ...SingleLevelContentType[]];
+/**
+ * Optional Entry
+ * An optional entry is where the user can choose between two data model options
+ *
+ * the first value of the array is whether the user by default chooses the first option or the second option
+ *
+ * the two options should always be present!
+ */
 export type OptionalEntryDataType = [boolean, NonEmptyValidEntryArrayType, []] | [boolean, [], NonEmptyValidEntryArrayType];
+/**
+ * Enum Entry
+ * An enum defintion is where the user is offered a list of optional data models to choose from
+ *
+ * the first value of the arrea the default option available
+ * all the other values are the option definitions
+ *
+ * the first value can't be bigger than the amount of options defined
+ * there should be at least two options given!
+ */
 export type EnumEntryDataType = [number, NonEmptyValidEntryArrayType, NonEmptyValidEntryArrayType, ...SingleLevelContentType[][]];
+/**
+ * Array Entry
+ * An array definition is where the user is offered a list data models
+ *
+ * the first value of the array is the min and max count of the array
+ * the second value is the data model that is expected
+ *
+ * the delta of min and max count can't be less than 1 (and larger than 1024)
+ */
 export type ArrayEntryDataType = [[number, number], NonEmptyValidEntryArrayType];
 export declare const PREFIX_SEPERATOR_DELIMETER = "_";

package/dist/types/dataEntry.d.ts

@@ -3,6 +3,7 @@ import { EnumData } from './enumData';
 import { FloatData } from './floatData';
 import { IntData } from './intData';
 import { VersionData } from './versionData';
+import { EnumArrayData } from './enumArrayData.ts';
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 };
@@ -11,12 +12,62 @@ type DataDescription = {
     internalName?: string;
     index: number;
 };
+/**
+ * Boolean object
+ *
+ * Boolean objects are a simple `true` or `false`, 1 or 0 - one bitwidth object.
+ */
 export type BooleanDataEntry = Prettify<BooleanData & DataDescription>;
-export type IntDataEntry = Prettify<IntData & DataDescription>;
+/**
+ * Enum object
+ *
+ * An enum object is a continious range of integer values, starting at 0 upto its max.
+ * The maximum acceptable value for the max is `255` (8 bits)
+ */
 export type EnumDataEntry = Prettify<EnumData & DataDescription>;
+/**
+ * Int object
+ *
+ * Int objects are a simple integer value, starting at its min upto its max.
+ * The maximum and minimum value can be any integar values represntabled as a double yet,
+ * the maximum acceptable delta between min and max is `4095` (12 bits).
+ */
+export type IntDataEntry = Prettify<IntData & DataDescription>;
+/**
+ * Float object
+ *
+ * Float objects are a fixed point extension of the int object, with a larger available precision range.
+ * Dispite a `min` and a `max` value, they also have a `precision` and a `significand` attribute.
+ * The precision defines where the point is located and can be an integer value between -3 and 3 (-3 meaning **divided** by 1e-3 -> multiplied by 1000, 3 meaning **divided** by 1e3 -> multiplied by 1e-3 -> multiplied by .001)
+ * The significand defines the amount of bits that are used to store the numeric value of the number and is derived from the `min` and `max` values in relationship to the precision.
+ * Maximum value for the significand is `20` bits, which allows for a maximum of 1048576 possible values.
+ */
 export type FloatDataEntry = Prettify<FloatData & DataDescription>;
+/**
+ * Version object
+ *
+ * Version objects are a special type of the enum object, which have a fixed amount of bits assigned to them (and therefore a fixed amount of optional values)
+ * They are only used as the beginning of a DataStateDefinition to be able to find out which version of the data is actually being used
+ *
+ * Acceptable bitwidths are: `4 | 6 | 8 | 10`, giving a total of respectively 16, 64, 256 and 1024 possible versions
+ * Choose wisely, as it is not possible to increase this value later on (that would require the inclusion of an additional version object)
+ */
 export type VersionDataEntry = Prettify<VersionData & DataDescription>;
-export type DataEntry = BooleanDataEntry | IntDataEntry | EnumDataEntry | FloatDataEntry | VersionDataEntry;
-export type ProtectedAttributeNames = Prettify<keyof BooleanDataEntry | keyof IntDataEntry | keyof EnumDataEntry | keyof FloatDataEntry | keyof VersionDataEntry>;
+/**
+ * Enum Array object
+ *
+ * enum arrays are as the name implies an array of enums.
+ * This object interprets the enums as being a number of a specific base and translates them to base 2.
+ * Besides the base, which is derived from the min and max (integer) values (its delta)
+ * There is also a given min and max count of values.
+ * The count itself is stored as the first bits, like for an Int object.
+ * The value itself is implied by the length of the value array.
+ *
+ * Note: the partical maximum benefit of using this versus using a `ArrayEntryDataType` with only enums is only about 22% for base_5
+ */
+export type EnumArrayDataEntry = Prettify<EnumArrayData & DataDescription>;
+export type DataEntry = BooleanDataEntry | IntDataEntry | EnumDataEntry | FloatDataEntry | VersionDataEntry | EnumArrayDataEntry;
+export type ProtectedAttributeNames = Prettify<keyof BooleanDataEntry | keyof IntDataEntry | keyof EnumDataEntry | keyof FloatDataEntry | keyof VersionDataEntry | keyof EnumArrayDataEntry>;
+export declare const PROTECTED_ATTRIBUTE_NAMES: readonly ["type", "value", "name", "internalName", "index", "min", "max", "bits", "precision", "significand", "minCount", "maxCount"];
 export type DataEntryArray = DataEntry[];
 export {};

package/dist/types/enumArrayData.d.ts

@@ -0,0 +1,21 @@
+import { DataType } from '../enums/dataTypes';
+/**
+ * Enum Array object
+ *
+ * enum arrays are as the name implies an array of enums.
+ * This object interprets the enums as being a number of a specific base and translates them to base 2.
+ * Besides the base, which is derived from the min and max (integer) values (its delta)
+ * There is also a given min and max count of values.
+ * The count itself is stored as the first bits, like for an Int object.
+ * The value itself is implied by the length of the value array.
+ *
+ * Note: the partical maximum benefit of using this versus using a `ArrayEntryDataType` with only enums is only about 22% for base_5
+ */
+export type EnumArrayData = {
+    type: DataType.ENUM_ARRAY;
+    minCount: number;
+    maxCount: number;
+    value: number[];
+    min: number;
+    max: number;
+};

package/dist/types/enumData.d.ts

@@ -1,5 +1,11 @@
 import { DataType } from '../enums/dataTypes';
 export declare const EnumMaxBits = 8;
+/**
+ * Enum object
+ *
+ * An enum object is a continious range of integer values, starting at 0 upto its max.
+ * The maximum acceptable value for the max is `255` (8 bits)
+ */
 export type EnumData = {
     type: DataType.ENUM;
     value: number;

package/dist/types/floatData.d.ts

@@ -1,6 +1,15 @@
 import { DataType } from '../enums/dataTypes';
 export type PrecisionRangeType = -3 | -2 | -1 | 0 | 1 | 2 | 3;
 export declare const SignificandMaxBits = 20;
+/**
+ * Float object
+ *
+ * Float objects are a fixed point extension of the int object, with a larger available precision range.
+ * Dispite a `min` and a `max` value, they also have a `precision` and a `significand` attribute.
+ * The precision defines where the point is located and can be an integer value between -3 and 3 (-3 meaning **divided** by 1e-3 -> multiplied by 1000, 3 meaning **divided** by 1e3 -> multiplied by 1e-3 -> multiplied by .001)
+ * The significand defines the amount of bits that are used to store the numeric value of the number and is derived from the `min` and `max` values in relationship to the precision.
+ * Maximum value for the significand is `20` bits, which allows for a maximum of 1048576 possible values.
+ */
 export type FloatData = {
     type: DataType.FLOAT;
     value: number;

package/dist/types/intData.d.ts

@@ -1,5 +1,12 @@
 import { DataType } from '../enums/dataTypes';
 export declare const IntegerMaxBits = 12;
+/**
+ * Int object
+ *
+ * Int objects are a simple integer value, starting at its min upto its max.
+ * The maximum and minimum value can be any integar values represntabled as a double yet,
+ * the maximum acceptable delta between min and max is `4095` (12 bits).
+ */
 export type IntData = {
     type: DataType.INT;
     value: number;

package/dist/types/stateValueModel.d.ts

@@ -9,17 +9,17 @@ export type DerivativeStateDataType = {
     v: StateDataType | StateDataType[];
 };
 export type StateValueType = {
-    [attribute: string]: boolean | number | string | StateValueType | DerivativeStateValueType;
+    [attribute: string]: boolean | number | number[] | string | StateValueType | DerivativeStateValueType;
 };
 export type DerivativeStateValueType = {
-    s: boolean | number | string;
+    s: boolean | number | string | number[];
     v: StateValueType | StateValueType[];
 };
 export type StateDataGenerationMethod = (additionalData?: DataEntryArray | string) => StateDataType;
 export type DataEntryParsingReturnType = [DataEntryArray | string | undefined, [string, DataEntry]];
 export type InternalStateDataGenerationMethod = (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DataEntry | StateDataType | DerivativeStateDataType]];
 export type ExposedParserStateDataMethod = (additionalData?: StateDataType | DataEntryArray | string) => StateDataType;
-export type UpdateStateDataMethod = (state: StateDataType, entryToUpdate: DataEntry) => StateDataType;
+export type UpdateStateDataMethod = (state: StateDataType, entryToUpdate: DataEntry | DataEntry[]) => StateDataType;
 export type StringifyStateDataMethod = (data: StateDataType | DataEntryArray) => string;
 export type VersionContentDefinition = SingleLevelContentType[][];
 export type VersionHandler = {

package/dist/update/enumArrayUpdate.d.ts

@@ -0,0 +1,2 @@
+import { EnumArrayDataEntry } from '@/types';
+export declare const updateValue: (original: EnumArrayDataEntry, update: EnumArrayDataEntry) => EnumArrayDataEntry;

package/dist/update/updateValues.d.ts

@@ -1,2 +1,8 @@
 import { DataEntry } from '../types/dataEntry';
+/**
+ * Method to update the value of a data entry
+ * @param original - the original data entry
+ * @param update - the update data entry
+ * @returns the updated data entry
+ */
 export declare const updateValue: (original: DataEntry, update: DataEntry) => DataEntry;

package/package.json

@@ -6,7 +6,7 @@
     "dist/*"
   ],
   "type": "module",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "author": "Jonas Ward",
   "description": "Library for creating web safe base64 objects with custom bith widths and dynamic values.",
   "scripts": {
@@ -17,6 +17,7 @@
   "devDependencies": {
     "bun-types": "latest",
     "rimraf": "^6.0.1",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "@types/bun": "latest"
   }
 }