url-safe-bitpacking 0.1.14 → 0.2.0

package/dist/index.js

@@ -1,31 +1,31 @@
 // src/enums/dataTypes.ts
-var DataType;
-(function(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 = {}));
+var DataTypeValues = ["VERSION", "BOOLEAN", "ENUM", "INT", "FLOAT", "ENUM_ARRAY"];
+var ComplexDataValues = ["OPTIONAL", "ENUM_OPTIONS", "ARRAY"];
 // src/types/floatData.ts
 var SignificandMaxBits = 20;
-
-// src/types/arrayDefinitions.ts
-var PREFIX_SEPERATOR_DELIMETER = "_";
 // src/types/enumData.ts
 var EnumMaxBits = 8;
 // src/types/intData.ts
 var IntegerMaxBits = 12;
-// src/types/versionData.ts
-var VersionRange = [4, 6, 8, 10];
+// src/types/dataEntry.ts
+var PROTECTED_ATTRIBUTE_NAMES = [
+  "type",
+  "value",
+  "name",
+  "internalName",
+  "index",
+  "min",
+  "max",
+  "bits",
+  "precision",
+  "significand",
+  "minCount",
+  "maxCount",
+  "state",
+  "stateBits",
+  "descriptor",
+  "mapping"
+];
 // src/factory/helperMethod.ts
 var getBitsForIntegerNumber = (number, maxBits) => {
   const bitCount = Math.ceil(Math.log2(number));
@@ -33,14 +33,7 @@ var getBitsForIntegerNumber = (number, maxBits) => {
     throw new Error(`Cannot get ${maxBits} bits for a number with ${bitCount} bits`);
   return bitCount;
 };
-var getMinimumBitsForInteger = (v) => Math.ceil(Math.log2(v));
-var getVersionValueRangeValueForNumber = (v) => {
-  const minBits = getMinimumBitsForInteger(v);
-  const versionBits = VersionRange.find((x) => x >= minBits);
-  if (versionBits === undefined)
-    throw new Error(`Cannot find version range for ${v}, max amount of versions allowed is ${2 ** VersionRange[VersionRange.length - 1]}`);
-  return versionBits;
-};
+var getMinimumBitsForInteger = (v) => Math.ceil(Math.log2(v + 1));
 
 // src/factory/floatFactory.ts
 var create = (value, min = 0, max = 1, precision = 2, name = "", index = -1) => {
@@ -51,7 +44,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: "FLOAT",
     min: roundedMin / precisionMultiplier,
     max: roundedMax / precisionMultiplier,
     precision,
@@ -70,31 +63,149 @@ 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: "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: "BOOLEAN",
+  name,
+  index
+});
 
 // src/factory/versionFactory.ts
 var create4 = (value, bits = 8, name = "", index = -1) => ({
   value,
-  type: DataType.VERSION,
+  type: "VERSION",
   bits,
   name,
   index
 });
 
+// src/factory/utils.ts
+var getOptionsFromEnumOptions = (options) => {
+  if (typeof options === "string")
+    return { max: options.length - 1, mapping: options.split(",").map(Number) };
+  if (typeof options === "number")
+    return { max: options, mapping: Array.from({ length: options + 1 }, (_, i) => i) };
+  return { max: options.length - 1, mapping: options };
+};
+
 // src/factory/enumFactory.ts
-var create5 = (value, max = 10, name = "", index = -1) => {
+var create5 = (value, options, name = "", index = -1) => {
+  const { max, mapping } = getOptionsFromEnumOptions(options);
   if (!Number.isInteger(max))
-    throw new Error("min and max must be integers");
+    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: DataType.ENUM, max, bits, name, index };
+  return { value, type: "ENUM", max, bits, name, index, mapping };
+};
+
+// src/factory/enumArrayFactory.ts
+var create6 = (value, options, minCount = 1, maxCount = 10, name = "", index = -1) => {
+  const { max, mapping } = getOptionsFromEnumOptions(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 two options");
+  if (max > 2 ** IntegerMaxBits - 1)
+    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 < 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 > 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}`);
+  return {
+    type: "ENUM_ARRAY",
+    minCount,
+    maxCount,
+    value: JSON.parse(JSON.stringify(value)),
+    max,
+    name,
+    index,
+    mapping
+  };
+};
+
+// src/factory/optionalFactory.ts
+var create7 = (descriptor, defaultState = false, name = "", index = -1) => {
+  if (descriptor[0] === null && descriptor[1] === null)
+    throw new Error("descriptor must have at least one non-null value");
+  if (descriptor[0] !== null && descriptor[1] !== null)
+    throw new Error("descriptor must have only one non-null value");
+  return {
+    type: "OPTIONAL",
+    state: defaultState,
+    descriptor,
+    value: JSON.parse(JSON.stringify(defaultState ? descriptor[1] : descriptor[0])),
+    name,
+    index
+  };
+};
+
+// src/factory/enumOptionsFactory.ts
+var maxEnumOptions = 64;
+var maxEnumOptionsBits = getMinimumBitsForInteger(maxEnumOptions);
+var create8 = (descriptor, defaultState = 0, name = "", index = -1) => {
+  if (descriptor.length < 2)
+    throw new Error("descriptor must have at least two entries");
+  if (descriptor.length - 1 < defaultState)
+    throw new Error("defaultState must be less than the length of the descriptor");
+  return {
+    value: JSON.parse(JSON.stringify(descriptor[defaultState])),
+    descriptor,
+    name,
+    index,
+    type: "ENUM_OPTIONS",
+    stateBits: getBitsForIntegerNumber(descriptor.length, maxEnumOptionsBits),
+    state: defaultState
+  };
+};
+
+// src/factory/arrayFactory.ts
+var maxArrayCount = 64;
+var create9 = (descriptor, defaultState = 0, minCount = 0, maxCount = 10, name = "", index = -1) => {
+  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);
+  return {
+    value: [...Array(defaultState)].map(() => JSON.parse(JSON.stringify(descriptor))),
+    descriptor,
+    type: "ARRAY",
+    minCount,
+    maxCount,
+    stateBits,
+    state: defaultState,
+    name,
+    index
+  };
 };
 
 // src/factory/factory.ts
@@ -103,10 +214,16 @@ var DataEntryFactory = {
   createInt: create2,
   createEnum: create5,
   createBoolean: create3,
-  createVersion: create4
+  createVersion: create4,
+  createEnumArray: create6
+};
+var ComplexDataEntryFactory = {
+  createOptional: create7,
+  createEnumOptions: create8,
+  createArray: create9
 };
 // 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 +234,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 +245,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 +263,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 +301,202 @@ var rawValueParser3 = (stateString) => {
 var rawParser5 = (stateString) => rawValueParser3(stateString);
 var rawStringifier5 = (value) => value ? "1" : "0";
 
+// src/parsers/enumArrayParser.ts
+var getCountBitsCount = (enumArrayData2) => getBitsForIntegerNumber(enumArrayData2.maxCount - enumArrayData2.minCount + 1, IntegerMaxBits);
+var getNumberBitsCountForBase = (count, base) => getBitsForEnumArrayCountOfBase(count, base);
+var getEnumArrayBase = (enumArrayData2) => enumArrayData2.max + 1;
+var getCount = (enumArrayData2, bitString) => {
+  const countBits = getCountBitsCount(enumArrayData2);
+  if (countBits === 0)
+    return enumArrayData2.minCount;
+  return rawValueParser(bitString.slice(0, countBits), countBits) + enumArrayData2.minCount;
+};
+var getBitsCount6 = (enumArrayData2, bitString) => {
+  const countBits = getCountBitsCount(enumArrayData2);
+  const count = getCount(enumArrayData2, bitString);
+  const valuesBitCount = getNumberBitsCountForBase(count, getEnumArrayBase(enumArrayData2));
+  return countBits + valuesBitCount;
+};
+var rawParser6 = (bitString, enumArrayData2) => {
+  const countBits = getCountBitsCount(enumArrayData2);
+  const count = getCount(enumArrayData2, bitString);
+  const base = getEnumArrayBase(enumArrayData2);
+  const valuesBitCount = getNumberBitsCountForBase(count, base);
+  return convertBitStringToArbitraryBase(bitString.slice(countBits, countBits + valuesBitCount), base, count);
+};
+var rawStringifier6 = (value, enumArrayData2) => {
+  const countBits = getCountBitsCount(enumArrayData2);
+  const count = value.length;
+  const base = getEnumArrayBase(enumArrayData2);
+  const countBitstring = countBits ? rawIntStringifier(count - enumArrayData2.minCount, countBits) : "";
+  const enumArrayBitstring = convertArbitraryBaseToBitString(value, base);
+  return countBitstring + enumArrayBitstring;
+};
+
+// src/parsers/arrayParser.ts
+var getCount2 = (arrayData2, bitString) => {
+  if (arrayData2.stateBits === 0)
+    return arrayData2.minCount;
+  return rawValueParser(bitString.slice(0, arrayData2.stateBits), arrayData2.stateBits) + arrayData2.minCount;
+};
+var rawParser7 = (bitString, arrayData2) => {
+  const state = getCount2(arrayData2, bitString);
+  bitString = bitString.slice(arrayData2.stateBits);
+  const value = [];
+  for (let i = 0;i < state; i++) {
+    const [nestedData, remainingBitstring] = nestedDataBitstringParser(bitString, arrayData2.descriptor);
+    value.push(nestedData);
+    bitString = remainingBitstring;
+  }
+  return [{ ...arrayData2, value, state }, bitString];
+};
+var rawStateStringifier = (arrayData2) => arrayData2.stateBits ? rawIntStringifier(arrayData2.value.length - arrayData2.minCount, arrayData2.stateBits) : "";
+
+// src/parsers/optionalParser.ts
+var getState = (bitString) => Number(bitString.slice(0, 1));
+var rawParser8 = (bitString, optionalData2) => {
+  const descriptorIndex = getState(bitString);
+  bitString = bitString.slice(1);
+  const [value, remainingBitstring] = optionalData2.descriptor[descriptorIndex] ? nestedDataBitstringParser(bitString, optionalData2.descriptor[descriptorIndex]) : [null, bitString];
+  const state = Boolean(descriptorIndex);
+  return [{ ...optionalData2, value, state }, remainingBitstring];
+};
+var rawStateStringifier2 = (optionalData2) => optionalData2.state ? "1" : "0";
+
+// src/parsers/enumOptionsFactory.ts
+var getStateIndex = (enumOptionsData2, bitString) => {
+  if (enumOptionsData2.stateBits === 0)
+    return 0;
+  return rawValueParser(bitString.slice(0, enumOptionsData2.stateBits), enumOptionsData2.stateBits);
+};
+var rawParser9 = (bitString, enumOptionsData2) => {
+  const state = getStateIndex(enumOptionsData2, bitString);
+  bitString = bitString.slice(enumOptionsData2.stateBits);
+  const [value, remainingBitstring] = nestedDataBitstringParser(bitString, enumOptionsData2.descriptor[state]);
+  return [{ ...enumOptionsData2, value, state }, remainingBitstring];
+};
+var rawStateStringifier3 = (enumOptionsData2) => rawIntStringifier(enumOptionsData2.state, enumOptionsData2.stateBits);
+
 // src/parsers/parsers.ts
 var valueBitsParser = (bitString, mapData) => {
   switch (mapData.type) {
-    case DataType.BOOLEAN:
+    case "BOOLEAN":
       return rawParser5(bitString);
-    case DataType.INT:
+    case "INT":
       return rawParser(bitString, mapData);
-    case DataType.ENUM:
+    case "ENUM":
       return rawParser3(bitString, mapData);
-    case DataType.FLOAT:
+    case "FLOAT":
       return rawParser2(bitString, mapData);
-    case DataType.VERSION:
+    case "VERSION":
       return rawParser4(bitString, mapData);
+    case "ENUM_ARRAY":
+      return rawParser6(bitString, mapData);
   }
 };
 var dataBitsParser = (rawString, mapData) => {
   switch (mapData.type) {
-    case DataType.BOOLEAN:
+    case "BOOLEAN":
+      return { ...mapData, value: valueBitsParser(rawString, mapData) };
+    case "ENUM":
+    case "INT":
+    case "FLOAT":
+    case "VERSION":
       return { ...mapData, value: valueBitsParser(rawString, mapData) };
-    case DataType.ENUM:
-    case DataType.INT:
-    case DataType.FLOAT:
-    case DataType.VERSION:
+    case "ENUM_ARRAY":
       return { ...mapData, value: valueBitsParser(rawString, mapData) };
   }
 };
-var getBitsCount6 = (mapData) => {
+var getBitsCount7 = (mapData, bitString) => {
   switch (mapData.type) {
-    case DataType.BOOLEAN:
+    case "BOOLEAN":
       return getBitsCount5();
-    case DataType.INT:
+    case "INT":
       return getBitsCount(mapData);
-    case DataType.FLOAT:
+    case "FLOAT":
       return getBitsCount2(mapData);
-    case DataType.VERSION:
+    case "VERSION":
       return getBitsCount4(mapData);
-    case DataType.ENUM:
+    case "ENUM":
       return getBitsCount3(mapData);
+    case "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 nestedDataBitstringParser = (bitstring, descriptor) => {
+  const resultingNestedData = descriptor.map((data) => {
+    const [resultingData, remainingBitstring] = ComplexDataValues.includes(data.type) ? complexDataEntryBitstringParser(bitstring, data) : dataEntryBitstringParser(bitstring, data);
+    bitstring = remainingBitstring;
+    return resultingData;
+  });
+  return [resultingNestedData, bitstring];
+};
+var complexDataEntryBitstringParser = (bitstring, complexDataEntry) => {
+  switch (complexDataEntry.type) {
+    case "ARRAY":
+      return rawParser7(bitstring, complexDataEntry);
+    case "OPTIONAL":
+      return rawParser8(bitstring, complexDataEntry);
+    case "ENUM_OPTIONS":
+      return rawParser9(bitstring, complexDataEntry);
+  }
+};
 var dataBitsStringifier = (data) => {
   switch (data.type) {
-    case DataType.BOOLEAN:
+    case "BOOLEAN":
       return rawStringifier5(data.value);
-    case DataType.INT:
+    case "INT":
       return rawStringifier(data.value, data);
-    case DataType.FLOAT:
+    case "FLOAT":
       return rawStringifier2(data.value, data);
-    case DataType.VERSION:
+    case "VERSION":
       return rawStringifier4(data.value, data);
-    case DataType.ENUM:
+    case "ENUM":
       return rawStringifier3(data.value, data);
+    case "ENUM_ARRAY":
+      return rawStringifier6(data.value, data);
+  }
+};
+var complexDataStateStringifier = (complexDataEntry) => {
+  switch (complexDataEntry.type) {
+    case "ARRAY":
+      return rawStateStringifier(complexDataEntry);
+    case "OPTIONAL":
+      return rawStateStringifier2(complexDataEntry);
+    case "ENUM_OPTIONS":
+      return rawStateStringifier3(complexDataEntry);
   }
 };
 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)) ?? [];
@@ -254,34 +507,22 @@ var parseBase64ToBits = (base64) => {
   const chunks = numbers.map((n) => n.toString(2).padStart(6, "0"));
   return chunks.join("");
 };
-var dataArrayStringifier = (dataEntryArray) => {
-  return dataEntryArray.map(dataBitsStringifier).join("");
-};
 // src/update/floatUpdate.ts
 var updateValue = (original, update) => {
-  const value = Math.max(Math.min(update.value, original.max), original.min);
-  return {
-    ...original,
-    value
-  };
+  original.value = Math.max(Math.min(update.value, original.max), original.min);
+  return original;
 };
 
 // src/update/intUpdate.ts
 var updateValue2 = (original, update) => {
-  const value = Math.max(Math.min(update.value, original.max), original.min);
-  return {
-    ...original,
-    value
-  };
+  original.value = Math.max(Math.min(update.value, original.max), original.min);
+  return original;
 };
 
 // src/update/enumUpdate.ts
 var updateValue3 = (original, update) => {
-  const value = Math.min(original.max, update.value);
-  return {
-    ...original,
-    value
-  };
+  original.value = Math.min(original.max, update.value);
+  return original;
 };
 
 // src/update/versionUpdate.ts
@@ -294,264 +535,253 @@ var updateValue4 = (original, update) => {
 };
 
 // src/update/booleanUpdate.ts
-var updateValue5 = (original, update) => ({
-  ...original,
-  value: update.value
-});
+var updateValue5 = (original, update) => {
+  original.value = update.value;
+  return original;
+};
 
-// src/update/updateValues.ts
+// src/update/enumArrayUpdate.ts
 var updateValue6 = (original, update) => {
+  const count = Math.max(Math.min(update.value.length, original.maxCount), original.minCount);
+  original.value = [...new Array(count)].map((_, i) => Math.min(update.value[i] ?? 0, original.max));
+  return original;
+};
+
+// src/update/nestedDataMatching.ts
+var updateNestedData = (original, descriptor) => {
+  const descriptorClone = JSON.parse(JSON.stringify(descriptor));
+  if (!original)
+    return descriptorClone;
+  return descriptorClone.map((d, i) => original[i]?.type === d.type && original[i]?.name === d.name ? DataTypeValues.includes(original[i].type) ? updateValue7(d, original[i]) : updateComplexValue(d, original[i]) : d);
+};
+
+// src/update/optionalUpdate.ts
+var updateComplexValue2 = (original, update) => {
+  if (update.descriptor[Number(original.state)] !== null && original.value !== null) {
+    original.state = update.state;
+    original.value.length = 0;
+    original.value.push(...updateNestedData(update.value, original.descriptor[Number(update.state)]));
+  }
+  return original;
+};
+
+// src/update/enumOptionsUpdate.ts
+var updateComplexValue3 = (original, update) => {
+  if (update.state <= original.descriptor.length - 1) {
+    original.value.length = 0;
+    original.value.push(...updateNestedData(update.value, original.descriptor[update.state]));
+    original.state = update.state;
+  }
+  return original;
+};
+
+// src/update/arrayUpdate.ts
+var updateComplexValue4 = (original, update) => {
+  if (update.state >= original.minCount && update.state <= original.maxCount) {
+    original.state = update.state;
+    original.value.length = 0;
+    for (let i = 0;i < original.state; i++)
+      original.value.push(updateNestedData(update.value[i], original.descriptor));
+  }
+  return original;
+};
+
+// 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 "FLOAT":
       return updateValue(original, update);
-    case DataType.INT:
+    case "INT":
       return updateValue2(original, update);
-    case DataType.ENUM:
+    case "ENUM":
       return updateValue3(original, update);
-    case DataType.BOOLEAN:
+    case "BOOLEAN":
       return updateValue5(original, update);
-    case DataType.VERSION:
+    case "VERSION":
       return updateValue4(original, update);
+    case "ENUM_ARRAY":
+      return updateValue6(original, update);
   }
 };
-// src/objectmap/stateValueHelperMethods.ts
-var flattenDerivativeStateDataType = (stateValue) => [
-  stateValue.s,
-  ...Array.isArray(stateValue.v) ? stateValue.v.map(getDataEntryArray).flat() : getDataEntryArray(stateValue.v)
-];
-var internalGetDataEntryArray = (stateValue) => Object.values(stateValue).map((content) => {
-  if (content.type !== undefined)
-    return content;
-  else if (content.s !== undefined && content.v !== undefined) {
-    return flattenDerivativeStateDataType(content);
-  } else
-    return internalGetDataEntryArray(content);
-}).flat();
-var getStateValueHelperMethod = (stateValue) => {
-  if (stateValue.type !== undefined)
-    return stateValue.value;
-  else if (stateValue.s !== undefined && stateValue.v !== undefined)
-    return {
-      s: stateValue.s.value,
-      v: Array.isArray(stateValue.v) ? stateValue.v.map(getStateValue) : getStateValue(stateValue.v)
-    };
-  else
-    return getStateValue(stateValue);
-};
-var getStateValue = (stateValue) => Object.fromEntries(Object.entries(stateValue).map(([key, value]) => [key, getStateValueHelperMethod(value)]));
-var getDataEntryArray = (stateValue) => internalGetDataEntryArray(stateValue).sort((a, b) => a.index - b.index);
-var getBase64String = (stateValue) => parseBitsToBase64(dataArrayStringifier(getDataEntryArray(stateValue)));
-var isSingleLevelContentType = (data) => singleLevelContentTypeIsDataEntry(data[0]) || singleLevelContentTypeIsNestedContentDataType(data[0]) && !doubleLevelContentTypeIsArrayDefinitionType(data);
-var isDoubleLevelContentType = (data) => !isSingleLevelContentType(data);
-var singleLevelContentTypeIsDataEntry = (data) => !Array.isArray(data) && typeof data === "object";
-var singleLevelContentTypeIsNestedContentDataType = (data) => Array.isArray(data) && typeof data[0] === "string";
-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 updateComplexValue = (original, update) => {
+  if (original.type !== update.type)
+    throw new Error("Types do not match");
+  switch (original.type) {
+    case "OPTIONAL":
+      return updateComplexValue2(original, update);
+    case "ENUM_OPTIONS":
+      return updateComplexValue3(original, update);
+    case "ARRAY":
+      return updateComplexValue4(original, update);
+  }
+};
+// src/stateHandling/stateData.ts
+var getStateData = (state) => {
+  const object = {};
+  state.forEach((item) => {
+    switch (item.type) {
+      case "BOOLEAN":
+        object[item.name] = item.value;
+        break;
+      case "INT":
+        object[item.name] = item.value;
+        break;
+      case "ENUM":
+        object[item.name] = item.mapping[item.value];
+        break;
+      case "FLOAT":
+        object[item.name] = item.value;
+        break;
+      case "VERSION":
+        object[item.name] = item.value;
+        break;
+      case "ENUM_ARRAY":
+        object[item.name] = item.value.map((v) => item.mapping[v]);
+        break;
+      case "OPTIONAL":
+        object[item.name] = item.value === null ? null : getStateData(item.value);
+        break;
+      case "ENUM_OPTIONS":
+        object[item.name] = {
+          ...getStateData(item.value),
+          state: item.state
+        };
+        break;
+      case "ARRAY":
+        object[item.name] = item.value.map(getStateData);
+        break;
+    }
+  });
+  return object;
+};
 
-// src/objectmap/stateDataModel.ts
-var currentDataEntryIndex = 0;
-var findExistingDataEntry = (dataEntry2, dataEntryArray) => dataEntryArray.find((d) => (d.internalName ?? d.name) === (dataEntry2.internalName ?? dataEntry2.name));
-var readDataEntry = (dataEntry2, bitString) => {
-  const [d, slicedBitstring] = dataEntryBitstringParser(bitString, dataEntry2);
-  currentDataEntryIndex++;
-  return [slicedBitstring, [d.name, { ...d, index: currentDataEntryIndex }]];
-};
-var updateDataEntry = (dataEntry2, existingData) => {
-  const existingDataEntry = findExistingDataEntry(dataEntry2, existingData);
-  currentDataEntryIndex++;
-  return [existingData, [dataEntry2.name, { ...existingDataEntry ? updateValue6(dataEntry2, existingDataEntry) : dataEntry2, index: currentDataEntryIndex }]];
-};
-var internalGetDataEntry = (dataEntry2, prefix, additionalData) => {
-  const internalName = `${prefix}${PREFIX_SEPERATOR_DELIMETER}${dataEntry2.name}`;
-  const localDataEntry = { ...dataEntry2, internalName };
-  if (additionalData) {
-    if (typeof additionalData === "string")
-      return readDataEntry(localDataEntry, additionalData);
-    else
-      return updateDataEntry(localDataEntry, additionalData);
+// src/stateHandling/stateDataObject.ts
+var getBitstringForStateDataEntry = (stateDataEntry2) => {
+  switch (stateDataEntry2.type) {
+    case "BOOLEAN":
+    case "INT":
+    case "ENUM":
+    case "FLOAT":
+    case "VERSION":
+    case "ENUM_ARRAY":
+      return stateDataEntry2.bitstring = stateDataEntry2.bitstring ?? dataBitsStringifier(stateDataEntry2);
+    case "OPTIONAL":
+      return stateDataEntry2.value === null ? complexDataStateStringifier(stateDataEntry2) : complexDataStateStringifier(stateDataEntry2) + getBitstringForStateNestedData(stateDataEntry2.value);
+    case "ENUM_OPTIONS":
+      return complexDataStateStringifier(stateDataEntry2) + getBitstringForStateNestedData(stateDataEntry2.value);
+    case "ARRAY":
+      return complexDataStateStringifier(stateDataEntry2) + stateDataEntry2.value.map((vs) => getBitstringForStateNestedData(vs)).join("");
   }
-  currentDataEntryIndex++;
-  return [undefined, [localDataEntry.name, { ...localDataEntry, index: currentDataEntryIndex }]];
-};
-var getStateFromOptionalEntryDataType = (oedt, prefix, attributeName) => (additionalData) => {
-  const [updatedLocalAdditionalData, [__, s]] = internalGetDataEntry(DataEntryFactory.createBoolean(oedt[0], attributeName), prefix, additionalData);
-  const [localAdditionalData, [_, v]] = getStateDateFromSingleLevelContentTypeArray(oedt[Number(s.value) + 1], s.internalName, attributeName)(updatedLocalAdditionalData);
-  return [
-    localAdditionalData,
-    [
-      attributeName,
-      {
-        s,
-        v
-      }
-    ]
-  ];
-};
-var getStateFromEnumEntryDataType = (eedt, prefix, attributeName) => (additionalData) => {
-  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`);
-  if (eedt[0] < 0)
-    console.log(`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 [
-    nestedAdditionalData,
-    [
-      attributeName,
-      {
-        s,
-        v
-      }
-    ]
-  ];
-};
-var getStateFromArrayEntryDataType = (aedt, prefix, attributeName) => (additionalData) => {
-  const [min, max] = [aedt[0][0], aedt[0][1]].sort((a, b) => a - b);
-  const [updatedAdditionalData, [__, s]] = internalGetDataEntry(DataEntryFactory.createInt(min, min, max, attributeName), prefix, additionalData);
-  const v = [];
-  let localAdditionalData = updatedAdditionalData;
-  for (let i = 0;i < s.value; i++) {
-    const [updateAdditionalData, [_, localStateData]] = getStateDateFromSingleLevelContentTypeArray(aedt[1], `${s.internalName}${PREFIX_SEPERATOR_DELIMETER}${i}`, attributeName)(localAdditionalData);
-    localAdditionalData = updateAdditionalData;
-    v.push(localStateData);
+};
+var getBitstringForStateNestedData = (nestedData) => nestedData.map(getBitstringForStateDataEntry).join("");
+var setComplexDataEntryValuesAsStateDataEntry = (currenEntry, updateCallback) => {
+  switch (currenEntry.type) {
+    case "OPTIONAL":
+      currenEntry.value = currenEntry.value === null ? null : currenEntry.value.map((v) => getStateDataEntry(v, updateCallback));
+      break;
+    case "ARRAY":
+      currenEntry.value = currenEntry.value.map((vs) => vs.map((v) => getStateDataEntry(v, updateCallback)));
+      break;
+    case "ENUM_OPTIONS":
+      currenEntry.value = currenEntry.value.map((v) => getStateDataEntry(v, updateCallback));
+      break;
   }
-  return [
-    localAdditionalData,
-    [
-      attributeName,
-      {
-        s,
-        v
-      }
-    ]
-  ];
-};
-var getStateDataFromDoubleLevelContentType = (dct, prefix, attributeName) => {
-  if (doubleLevelContentTypeIsEnumEntryDataType(dct))
-    return getStateFromEnumEntryDataType(dct, prefix, attributeName);
-  else if (doubleLevelContentTypeIsOptionalEntryDataType(dct))
-    return getStateFromOptionalEntryDataType(dct, prefix, attributeName);
-  else if (doubleLevelContentTypeIsArrayDefinitionType(dct))
-    return getStateFromArrayEntryDataType(dct, prefix, attributeName);
-  throw new Error("this is an invalid output value, wonder why?");
-};
-var getStateDateFromSingleLevelContentTypeArray = (slcta, prefix, attributeName) => (additionalData) => {
-  const outputDataObject = {};
-  let intermediateAdditionalData = additionalData;
-  slcta.forEach((slct) => {
-    const [localAdditionalData, [localAttributeName, nestedData]] = getStateDataFromSingleLevelContentType(slct, prefix)(intermediateAdditionalData);
-    intermediateAdditionalData = localAdditionalData;
-    outputDataObject[localAttributeName] = nestedData;
-  });
-  return [intermediateAdditionalData, [attributeName, outputDataObject]];
-};
-var getStateDataFromNestedContentType = (nct, prefix, attributeName) => {
-  if (isDoubleLevelContentType(nct))
-    return getStateDataFromDoubleLevelContentType(nct, `${prefix}${PREFIX_SEPERATOR_DELIMETER}${attributeName}`, attributeName);
-  return getStateDateFromSingleLevelContentTypeArray(nct, prefix, attributeName);
-};
-var getStateDataFromSingleLevelContentType = (slct, prefix) => {
-  if (singleLevelContentTypeIsDataEntry(slct))
-    return (additionalData) => internalGetDataEntry(slct, prefix, additionalData);
-  else if (singleLevelContentTypeIsNestedContentDataType(slct))
-    return getStateDataFromNestedContentType(slct[1], `${prefix}_${slct[0]}`, slct[0]);
-  throw new Error("this is an invalid output value, wonder why?");
-};
-var getGenerationMethodForSingleLevelContentTypeArray = (slct) => {
-  currentDataEntryIndex = -1;
-  return (additionalData) => getStateDateFromSingleLevelContentTypeArray(slct, "", "")(additionalData)[1][1];
-};
-// src/objectmap/userMethods.ts
-var getParsedAdditionalData = (additionalData) => {
-  if (typeof additionalData === "string")
-    return parseBase64ToBits(additionalData);
-  if (additionalData && !Array.isArray(additionalData))
-    return getDataEntryArray(additionalData);
-  return additionalData;
-};
-var getVersionindex = (additionalData, versionMask, defaultIndex) => {
-  if (typeof additionalData === "string")
-    return readDataEntry(versionMask, additionalData)[1][1].value;
-  if (!additionalData)
-    return defaultIndex || 0;
-  return additionalData.find((d) => d.name === "version")?.value ?? defaultIndex ?? 0;
-};
-var getParserMethodForVersionDefinition = (vadt, versionBits, defaultVersion) => (state) => {
-  const additionalData = getParsedAdditionalData(state);
-  const versionIndex = getVersionindex(additionalData, DataEntryFactory.createVersion(0, versionBits, "version"), defaultVersion);
-  const versionDefinition = vadt[versionIndex];
-  const versionEntry = DataEntryFactory.createVersion(versionIndex, versionBits, "version");
-  return getGenerationMethodForSingleLevelContentTypeArray([versionEntry, ...versionDefinition])(additionalData);
-};
-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);
-  const localDefaultVersion = Math.max(0, Math.min(versionContent.length - 1, defaultVersion ?? 0));
-  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}`);
-  const parser = getParserMethodForVersionDefinition(versionContent, versionBitCount, localDefaultVersion);
-  const updater = getUpdaterMethodForVersionDefinition(parser);
-  const stringify = getStringifyMethodForVersionDefinition(parser);
-  return {
-    versionBitCount,
-    exposedVersions,
-    parser,
-    updater,
-    stringify,
-    enumSemanticsMapping,
-    attributeSemanticsMapping
+  const newBitString = getBitstringForStateDataEntry(currenEntry);
+  currenEntry.bitstring = newBitString;
+};
+var updateStateDataEntry = (currenEntry, newEntry, updateCallback) => {
+  if (currenEntry.type !== newEntry.type || currenEntry.name !== newEntry.name)
+    throw new Error(`Types (${currenEntry.type} & ${newEntry.type}) or names (${currenEntry.name} & ${newEntry.name}) do not match`);
+  if (ComplexDataValues.includes(currenEntry.type)) {
+    if (currenEntry.state !== newEntry.state) {
+      const currentBitString = currenEntry.bitstring;
+      const updatedCurrentEntry = updateComplexValue(currenEntry, newEntry);
+      setComplexDataEntryValuesAsStateDataEntry(updatedCurrentEntry, updateCallback);
+      if (currentBitString !== updatedCurrentEntry.bitstring)
+        updateCallback();
+    }
+  } else {
+    const currentBitString = currenEntry.bitstring;
+    const updatedCurrentEntry = updateValue7(currenEntry, newEntry);
+    updatedCurrentEntry.bitstring = dataBitsStringifier(updatedCurrentEntry);
+    if (currentBitString !== updatedCurrentEntry.bitstring)
+      updateCallback();
+  }
+  return currenEntry;
+};
+var getStateDataEntry = (entry, updateCallback) => {
+  entry.bitstring = getBitstringForStateDataEntry(entry);
+  entry.updateValue = (newEntry) => updateStateDataEntry(entry, newEntry, updateCallback);
+  return entry;
+};
+var createStateDataObject = (initialState, updateCallback) => {
+  const stateObject = {};
+  const wrappedUpdateCallback = () => {
+    stateObject.bitstring = getBitstringForStateNestedData(stateObject.state);
+    stateObject.base64 = parseBitsToBase64(stateObject.bitstring);
+    stateObject.data = getStateData(stateObject.state);
+    updateCallback(stateObject);
   };
+  stateObject.state = initialState.map((item) => getStateDataEntry(item, wrappedUpdateCallback));
+  wrappedUpdateCallback();
+  return stateObject;
 };
+var getInitialStateFromBase64 = (base64, descriptor) => nestedDataBitstringParser(parseBase64ToBits(base64), descriptor)[0];
 // src/utils/interpolateData.ts
 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 "BOOLEAN":
       return { ...dataEntry2, value: Boolean(Math.round(localT)) };
-    case DataType.VERSION:
+    case "VERSION":
       return { ...dataEntry2, value: Math.floor(localT * (dataEntry2.bits ** 2 - 0.001)) };
-    case DataType.ENUM:
+    case "ENUM":
       return { ...dataEntry2, value: Math.floor(localT * (dataEntry2.max + 0.999)) };
-    case DataType.INT:
+    case "INT":
       return { ...dataEntry2, value: dataEntry2.min + Math.floor(cosT * (dataEntry2.max - dataEntry2.min + 0.999)) };
-    case DataType.FLOAT:
+    case "FLOAT":
       const v = dataEntry2.min + cosT * (dataEntry2.max - dataEntry2.min);
       return dataEntryCorrecting({ ...dataEntry2, value: Math.min(dataEntry2.max, Math.max(v, dataEntry2.min)) });
+    case "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 "BOOLEAN":
       return Number(dataEntry2.value);
-    case DataType.INT:
-    case DataType.FLOAT:
+    case "INT":
+    case "FLOAT":
       return (dataEntry2.value - dataEntry2.min) / (dataEntry2.max - dataEntry2.min);
-    case DataType.VERSION:
+    case "VERSION":
       return dataEntry2.value / (2 ** dataEntry2.bits - 1);
-    case DataType.ENUM:
+    case "ENUM":
       return dataEntry2.value / dataEntry2.max;
+    case "ENUM_ARRAY":
+      return dataEntry2.value.reduce((acc, v) => acc + v, 0) / dataEntry2.value.length;
   }
 };
 export {
+  valueBitsParser,
   parseBase64ToBits,
   interpolateEntryAt,
-  getStateValue,
   getRelativeValue,
-  getDataEntryArray,
-  getBase64String,
-  createParserObject,
+  getInitialStateFromBase64,
+  getBitsCount7 as getBitsCount,
+  dataEntryCorrecting,
+  dataEntryBitstringParser,
+  dataBitsStringifier,
+  dataBitsParser,
+  createStateDataObject,
   SignificandMaxBits,
+  PROTECTED_ATTRIBUTE_NAMES,
   IntegerMaxBits,
-  DataType,
-  DataEntryFactory
+  DataTypeValues,
+  DataEntryFactory,
+  ComplexDataValues,
+  ComplexDataEntryFactory
 };