url-safe-bitpacking 0.2.1 → 0.3.1

package/dist/index.js

@@ -1,10 +1,11 @@
 // src/enums/dataTypes.ts
-var DataTypeValues = ["VERSION", "BOOLEAN", "ENUM", "INT", "FLOAT", "ENUM_ARRAY"];
-var ComplexDataValues = ["OPTIONAL", "ENUM_OPTIONS", "ARRAY"];
-// src/types/floatData.ts
-var SignificandMaxBits = 20;
+var ConstantBitWidthDataTypes = ["VERSION", "BOOLEAN", "ENUM", "INT", "FLOAT"];
+var VariableBitWidthDataTypes = ["ENUM_ARRAY", "OPTIONAL", "ENUM_OPTIONS", "ARRAY", "OBJECT"];
+var HasStateBitsDataTypes = ["ENUM_ARRAY", "OPTIONAL", "ENUM_OPTIONS", "ARRAY"];
 // src/types/enumData.ts
 var EnumMaxBits = 8;
+// src/types/floatData.ts
+var SignificandMaxBits = 20;
 // src/types/intData.ts
 var IntegerMaxBits = 12;
 // src/types/dataEntry.ts
@@ -26,240 +27,64 @@ var PROTECTED_ATTRIBUTE_NAMES = [
   "descriptor",
   "mapping"
 ];
-// src/factory/helperMethod.ts
-var getBitsForIntegerNumber = (number, maxBits) => {
-  const bitCount = Math.ceil(Math.log2(number));
-  if (bitCount > maxBits)
-    throw new Error(`Cannot get ${maxBits} bits for a number with ${bitCount} bits`);
-  return bitCount;
-};
-var getMinimumBitsForInteger = (v) => Math.ceil(Math.log2(v + 1));
-
-// src/factory/floatFactory.ts
-var create = (value, min = 0, max = 1, precision = 2, name = "", index = -1) => {
-  const precisionMultiplier = 10 ** precision;
-  const roundedMin = Math.floor(min * precisionMultiplier);
-  const roundedMax = Math.ceil(max * precisionMultiplier);
-  const delta = roundedMax - roundedMin;
-  const significand = Math.max(1, getBitsForIntegerNumber(delta, SignificandMaxBits));
-  return {
-    value,
-    type: "FLOAT",
-    min: roundedMin / precisionMultiplier,
-    max: roundedMax / precisionMultiplier,
-    precision,
-    significand,
-    name,
-    index
-  };
-};
-
-// src/factory/intFactory.ts
-var create2 = (value, min = 0, max = 10, name = "", index = -1) => {
-  if (!Number.isInteger(min) || !Number.isInteger(max))
-    throw new Error("min and max must be integers");
-  if (max - min < 1)
-    throw new Error("max must be at least one");
-  if (Math.abs(max - min) > 2 ** IntegerMaxBits - 1)
-    throw new Error("max - min must be less than 1024");
-  const bits = getBitsForIntegerNumber(max - min + 1, IntegerMaxBits);
-  return { value, type: "INT", min, max, bits, name, index };
-};
-
-// src/factory/booleanFactory.ts
-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: "VERSION",
-  bits,
-  name,
-  index
-});
-
-// src/factory/utils.ts
-var getEnumMaxAndMappingFromOptions = (options) => {
-  if (typeof options === "string")
-    return { max: options.length - 1, mapping: options.split("") };
-  if (typeof options === "number")
-    return { max: options, mapping: Array.from({ length: options + 1 }, (_, i) => i) };
-  return { max: options.length - 1, mapping: options };
-};
-var getOptionsFromMaxAndMapping = (v) => {
-  if (v.mapping.every((option) => typeof option === "string" && option.length === 1))
-    return v.mapping.join("");
-  if (Array.from({ length: v.max + 1 }, (_, i) => i).every((option, i) => option === v.mapping[i]))
-    return v.max;
-  return v.mapping;
-};
-
-// src/factory/enumFactory.ts
-var create5 = (value, options, name = "", index = -1) => {
-  const { max, mapping } = getEnumMaxAndMappingFromOptions(options);
-  if (!Number.isInteger(max))
-    throw new Error(`max must be integers, you have given ${max}`);
-  if (max < 1)
-    throw new Error("max must be at least one");
-  if (max > 2 ** EnumMaxBits - 1)
-    throw new Error("max - min must be less than 256");
-  const bits = getBitsForIntegerNumber(max + 1, EnumMaxBits);
-  return { value, type: "ENUM", max, bits, name, index, mapping };
-};
-
-// src/factory/enumArrayFactory.ts
-var create6 = (value, options, minCount = 1, maxCount = 10, name = "", index = -1) => {
-  const { max, mapping } = getEnumMaxAndMappingFromOptions(options);
-  if (!Number.isInteger(max))
-    throw new Error(`max must be integers, you have given ${max}`);
-  if (!Number.isInteger(minCount) || !Number.isInteger(maxCount))
-    throw new Error("minCount and maxCount must be integers");
-  if (max < 1)
-    throw new Error("must have at least 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/types/updateType.ts
+var ComplexDataTypes = ["ENUM_OPTIONS", "OPTIONAL", "ARRAY"];
+// src/parsers/parserUtils.ts
+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;
 };
-
-// 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
-  };
+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;
 };
-
-// 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
-  };
+var parseBitsToBase64 = (bits) => {
+  const chunks = bits.match(/.{1,6}/g);
+  const numbers = chunks?.map((c) => Number.parseInt(c.padEnd(6, "0"), 2)) ?? [];
+  return numbers.map((n) => base64url.charAt(n)).join("");
 };
-
-// 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
-  };
+var parseBase64ToBits = (base64) => {
+  const numbers = base64.split("").map((c) => base64url.indexOf(c));
+  const chunks = numbers.map((n) => n.toString(2).padStart(6, "0"));
+  return chunks.join("");
 };
-
-// src/factory/factory.ts
-var DescriptorFactory = {
-  FLOAT: create,
-  INT: create2,
-  ENUM: create5,
-  BOOLEAN: create3,
-  VERSION: create4,
-  ENUM_ARRAY: create6,
-  OPTIONAL: create7,
-  ENUM_OPTIONS: create8,
-  ARRAY: create9
+var rawIntStringifier = (value, bitCount) => {
+  if (Number.isInteger(value) === false)
+    throw new Error("Value is not an integer");
+  return value.toString(2).padStart(bitCount, "0");
 };
-// src/parsers/intParser.ts
-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})`);
   if (stateString.length > bitCount)
     throw new Error(`To many bits for this int bit string (${stateString.length} instead of ${bitCount})`);
+  if (bitCount === 0)
+    return 0;
   const parsed = parseInt(stateString, 2);
   if (isNaN(parsed))
     throw new Error("Invalid int state string");
   return parsed;
 };
-var rawParser = (stateString, intData2) => {
-  const v = rawValueParser(stateString, intData2.bits) + intData2.min;
-  if (v > intData2.max)
-    throw new Error("Value exceeds max");
-  return v;
-};
-var rawIntStringifier = (value, bitCount) => {
-  if (Number.isInteger(value) === false)
-    throw new Error("Value is not an integer");
-  return value.toString(2).padStart(bitCount, "0");
-};
-var rawStringifier = (value, intData2) => {
-  if (value < intData2.min)
-    throw new Error("Value is below min");
-  if (value > intData2.max)
-    throw new Error("Value exceeds max");
-  return rawIntStringifier(value - intData2.min, intData2.bits);
-};
 
 // src/parsers/floatParser.ts
-var getBitsCount2 = (floatData2) => floatData2.significand;
+var getBitsCount = (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})`);
@@ -268,13 +93,29 @@ var rawValueParser2 = (stateString, significandBits, precision) => {
   const significand = rawValueParser(stateString, significandBits);
   return significand * 10 ** -precision;
 };
-var rawParser2 = (stateString, floatData2) => {
+var rawParser = (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, floatData2) => rawIntStringifier(Math.round((value - floatData2.min) * 10 ** floatData2.precision), floatData2.significand);
+var rawStringifier = (value, floatData2) => rawIntStringifier(Math.round((value - floatData2.min) * 10 ** floatData2.precision), floatData2.significand);
+
+// src/parsers/intParser.ts
+var getBitsCount2 = (intData2) => intData2.bits;
+var rawParser2 = (stateString, intData2) => {
+  const v = rawValueParser(stateString, intData2.bits) + intData2.min;
+  if (v > intData2.max)
+    throw new Error("Value exceeds max");
+  return v;
+};
+var rawStringifier2 = (value, intData2) => {
+  if (value < intData2.min)
+    throw new Error("Value is below min");
+  if (value > intData2.max)
+    throw new Error("Value exceeds max");
+  return rawIntStringifier(value - intData2.min, intData2.bits);
+};
 
 // src/parsers/enumParser.ts
 var getBitsCount3 = (versionData2) => versionData2.bits;
@@ -307,310 +148,270 @@ 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);
+var getCount = (enumArrayData2, bitString) => rawValueParser(bitString.slice(0, enumArrayData2.stateBits), enumArrayData2.stateBits) + enumArrayData2.minCount;
+var rawParser6 = (enumArrayData2, bitString) => {
   const count = getCount(enumArrayData2, bitString);
   const base = getEnumArrayBase(enumArrayData2);
   const valuesBitCount = getNumberBitsCountForBase(count, base);
-  return convertBitStringToArbitraryBase(bitString.slice(countBits, countBits + valuesBitCount), base, count);
+  const value = convertBitStringToArbitraryBase(bitString.slice(enumArrayData2.stateBits, enumArrayData2.stateBits + valuesBitCount), base, count);
+  return [{ ...enumArrayData2, value }, bitString.slice(enumArrayData2.stateBits + valuesBitCount)];
 };
+var rawStateStringifier = (value, minCount, stateBits) => stateBits ? rawIntStringifier(value.length - minCount, stateBits) : "";
 var rawStringifier6 = (value, enumArrayData2) => {
-  const countBits = getCountBitsCount(enumArrayData2);
-  const count = value.length;
+  const countBitstring = rawStateStringifier(value, enumArrayData2.minCount, enumArrayData2.stateBits);
   const base = getEnumArrayBase(enumArrayData2);
-  const countBitstring = countBits ? rawIntStringifier(count - enumArrayData2.minCount, countBits) : "";
   const enumArrayBitstring = convertArbitraryBaseToBitString(value, base);
   return countBitstring + enumArrayBitstring;
 };
 
+// src/parsers/parserNestedDataUtils.ts
+var nestedDataStringifier = (nestedData) => nestedData.map(dataEntryBitsStringifier).join("");
+var nestedDataBitstringParser = (bitstring, descriptor) => {
+  const resultingNestedData = descriptor.map((data) => {
+    const [resultingData, remainingBitstring] = dataEntryBitstringParser(data, bitstring);
+    bitstring = remainingBitstring;
+    return resultingData;
+  });
+  return [resultingNestedData, bitstring];
+};
+
 // 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) => {
+var rawParser7 = (arrayData2, bitString) => {
   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);
+    const [entry, remainingBitstring] = dataEntryBitstringParser(arrayData2.descriptor, bitString);
+    value.push(entry);
     bitString = remainingBitstring;
   }
   return [{ ...arrayData2, value, state }, bitString];
 };
-var rawStateStringifier = (arrayData2) => arrayData2.stateBits ? rawIntStringifier(arrayData2.value.length - arrayData2.minCount, arrayData2.stateBits) : "";
+var rawStateStringifier2 = (state, minCount, stateBits) => stateBits ? rawIntStringifier(state - minCount, stateBits) : "";
 var rawStringifier7 = (arrayData2) => {
-  return rawStateStringifier(arrayData2) + arrayData2.value.map(nestedDataStringifier).join("");
+  return rawStateStringifier2(arrayData2.state, arrayData2.minCount, arrayData2.stateBits) + nestedDataStringifier(arrayData2.value);
 };
 
 // src/parsers/optionalParser.ts
 var getState = (bitString) => Number(bitString.slice(0, 1));
-var rawParser8 = (bitString, optionalData2) => {
+var rawParser8 = (optionalData2, bitString) => {
   const descriptorIndex = getState(bitString);
-  bitString = bitString.slice(1);
-  const [value, remainingBitstring] = optionalData2.descriptor[descriptorIndex] ? nestedDataBitstringParser(bitString, optionalData2.descriptor[descriptorIndex]) : [null, bitString];
+  bitString = bitString.slice(optionalData2.stateBits);
+  const [value, remainingBitstring] = optionalData2.descriptor[descriptorIndex] ? dataEntryBitstringParser(optionalData2.descriptor[descriptorIndex], bitString) : [null, bitString];
   const state = Boolean(descriptorIndex);
   return [{ ...optionalData2, value, state }, remainingBitstring];
 };
-var rawStateStringifier2 = (optionalData2) => optionalData2.state ? "1" : "0";
-var rawStringifier8 = (optionalData2) => optionalData2.value === null ? rawStateStringifier2(optionalData2) : rawStateStringifier2(optionalData2) + nestedDataStringifier(optionalData2.value);
+var rawStateStringifier3 = (state) => state ? "1" : "0";
+var rawStringifier8 = (optionalData2) => optionalData2.value === null ? rawStateStringifier3(optionalData2.state) : rawStateStringifier3(optionalData2.state) + dataEntryBitsStringifier(optionalData2.value);
 
-// src/parsers/enumOptionsFactory.ts
+// src/parsers/enumOptionsParser.ts
 var getStateIndex = (enumOptionsData2, bitString) => {
   if (enumOptionsData2.stateBits === 0)
     return 0;
   return rawValueParser(bitString.slice(0, enumOptionsData2.stateBits), enumOptionsData2.stateBits);
 };
-var rawParser9 = (bitString, enumOptionsData2) => {
+var rawParser9 = (enumOptionsData2, bitString) => {
   const state = getStateIndex(enumOptionsData2, bitString);
   bitString = bitString.slice(enumOptionsData2.stateBits);
-  const [value, remainingBitstring] = nestedDataBitstringParser(bitString, enumOptionsData2.descriptor[state]);
+  const [value, remainingBitstring] = enumOptionsData2.descriptor[state] ? dataEntryBitstringParser(enumOptionsData2.descriptor[state], bitString) : [null, bitString];
   return [{ ...enumOptionsData2, value, state }, remainingBitstring];
 };
-var rawStateStringifier3 = (enumOptionsData2) => rawIntStringifier(enumOptionsData2.state, enumOptionsData2.stateBits);
-var rawStringifier9 = (enumOptionsData2) => rawStateStringifier3(enumOptionsData2) + nestedDataStringifier(enumOptionsData2.value);
+var rawStateStringifier4 = (state, stateBits) => rawIntStringifier(state, stateBits);
+var rawStringifier9 = (enumOptionsData2) => rawStateStringifier4(enumOptionsData2.state, enumOptionsData2.stateBits) + (enumOptionsData2.value ? dataEntryBitsStringifier(enumOptionsData2.value) : "");
+
+// src/parsers/objectParser.ts
+var rawParser10 = (objectData2, bitString) => {
+  const [value, remainingBitstring] = nestedDataBitstringParser(bitString, objectData2.descriptor);
+  return [{ ...objectData2, value }, remainingBitstring];
+};
+var rawStringifier10 = (objectData2) => nestedDataStringifier(objectData2.value);
 
 // src/parsers/parsers.ts
-var valueBitsParser = (bitString, mapData) => {
-  switch (mapData.type) {
+var simpleContentBitsCountForDataEntry = (entry) => {
+  switch (entry.type) {
     case "BOOLEAN":
-      return rawParser5(bitString);
+      return getBitsCount5();
     case "INT":
-      return rawParser(bitString, mapData);
+      return getBitsCount2(entry);
     case "ENUM":
-      return rawParser3(bitString, mapData);
+      return getBitsCount3(entry);
     case "FLOAT":
-      return rawParser2(bitString, mapData);
+      return getBitsCount(entry);
     case "VERSION":
-      return rawParser4(bitString, mapData);
-    case "ENUM_ARRAY":
-      return rawParser6(bitString, mapData);
+      return getBitsCount4(entry);
   }
 };
-var dataBitsParser = (rawString, mapData) => {
-  switch (mapData.type) {
+var helperSimpleParserWrapper = (entry, bitstring) => [
+  { ...entry, value: simpleFromValueParser(bitstring.slice(0, simpleContentBitsCountForDataEntry(entry)), entry) },
+  bitstring.slice(simpleContentBitsCountForDataEntry(entry))
+];
+var simpleFromValueParser = (bitString, entry) => {
+  switch (entry.type) {
     case "BOOLEAN":
-      return { ...mapData, value: valueBitsParser(rawString, mapData) };
+      return rawParser5(bitString);
+    case "INT":
+      return rawParser2(bitString, entry);
     case "ENUM":
+      return rawParser3(bitString, entry);
+    case "FLOAT":
+      return rawParser(bitString, entry);
+    case "VERSION":
+      return rawParser4(bitString, entry);
+  }
+};
+var dataEntryBitstringParser = (entry, bitString) => {
+  const result = _dataEntryBitstringParser(entry, bitString);
+  return result;
+};
+var _dataEntryBitstringParser = (entry, bitString) => {
+  switch (entry.type) {
+    case "BOOLEAN":
     case "INT":
+    case "ENUM":
     case "FLOAT":
     case "VERSION":
-      return { ...mapData, value: valueBitsParser(rawString, mapData) };
+      return helperSimpleParserWrapper(entry, bitString);
     case "ENUM_ARRAY":
-      return { ...mapData, value: valueBitsParser(rawString, mapData) };
+      return rawParser6(entry, bitString);
+    case "ARRAY":
+      return rawParser7(entry, bitString);
+    case "OPTIONAL":
+      return rawParser8(entry, bitString);
+    case "ENUM_OPTIONS":
+      return rawParser9(entry, bitString);
+    case "OBJECT":
+      return rawParser10(entry, bitString);
   }
 };
-var getBitsCount7 = (mapData, bitString) => {
+var getBitsCount6 = (mapData) => {
   switch (mapData.type) {
     case "BOOLEAN":
       return getBitsCount5();
     case "INT":
-      return getBitsCount(mapData);
-    case "FLOAT":
       return getBitsCount2(mapData);
+    case "FLOAT":
+      return getBitsCount(mapData);
     case "VERSION":
       return getBitsCount4(mapData);
     case "ENUM":
       return getBitsCount3(mapData);
-    case "ENUM_ARRAY":
-      return getBitsCount6(mapData, bitString);
-  }
-};
-var dataEntryBitstringParser = (bitstring, 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) {
+var dataEntryBitsStringifier = (entry) => {
+  switch (entry.type) {
     case "BOOLEAN":
-      return rawStringifier5(data.value);
+      return rawStringifier5(entry.value);
     case "INT":
-      return rawStringifier(data.value, data);
+      return rawStringifier2(entry.value, entry);
     case "FLOAT":
-      return rawStringifier2(data.value, data);
+      return rawStringifier(entry.value, entry);
     case "VERSION":
-      return rawStringifier4(data.value, data);
+      return rawStringifier4(entry.value, entry);
     case "ENUM":
-      return rawStringifier3(data.value, data);
+      return rawStringifier3(entry.value, entry);
     case "ENUM_ARRAY":
-      return rawStringifier6(data.value, data);
-  }
-};
-var complexDataStringifier = (complexDataEntry) => {
-  switch (complexDataEntry.type) {
+      return rawStringifier6(entry.value, entry);
     case "ARRAY":
-      return rawStringifier7(complexDataEntry);
+      return rawStringifier7(entry);
     case "OPTIONAL":
-      return rawStringifier8(complexDataEntry);
+      return rawStringifier8(entry);
     case "ENUM_OPTIONS":
-      return rawStringifier9(complexDataEntry);
+      return rawStringifier9(entry);
+    case "OBJECT":
+      return rawStringifier10(entry);
   }
 };
-var complexDataStateStringifier = (complexDataEntry) => {
-  switch (complexDataEntry.type) {
-    case "ARRAY":
-      return rawStateStringifier(complexDataEntry);
-    case "OPTIONAL":
-      return rawStateStringifier2(complexDataEntry);
-    case "ENUM_OPTIONS":
-      return rawStateStringifier3(complexDataEntry);
-  }
-};
-var nestedDataStringifier = (nestedData) => nestedData.map((d) => ComplexDataValues.includes(d.type) ? complexDataStringifier(d) : dataBitsStringifier(d)).join("");
-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)) ?? [];
-  return numbers.map((n) => base64url.charAt(n)).join("");
-};
-var parseBase64ToBits = (base64) => {
-  const numbers = base64.split("").map((c) => base64url.indexOf(c));
-  const chunks = numbers.map((n) => n.toString(2).padStart(6, "0"));
-  return chunks.join("");
+var dataEntryCorrecting = (dataEntry2) => dataEntryBitstringParser(dataEntry2, dataEntryBitsStringifier(dataEntry2))[0];
+// src/update/updateUtils.ts
+var getStepForPrecision = (precision) => 10 ** -precision;
+var constrainUnsignedInt = (value, maxValue) => Math.max(0, Math.min(Math.round(value), maxValue));
+var constrainSignedInt = (value, minValue, maxValue) => constrainUnsignedInt(Math.round(value - minValue), Math.floor(maxValue - minValue)) + minValue;
+var constrainFloat = (value, minValue, maxValue, precision) => {
+  const step = getStepForPrecision(precision);
+  const multi = 1 / step;
+  return constrainSignedInt(value * multi, minValue * multi, maxValue * multi) * step;
 };
+
 // src/update/floatUpdate.ts
-var updateValue = (original, update) => {
-  original.value = Math.max(Math.min(update.value, original.max), original.min);
-  return original;
-};
+var constrainValue = (original, update) => constrainFloat(update, original.min, original.max, original.precision);
+var updateValue = (original, update) => (original.value = constrainValue(original, update), original);
 
 // src/update/intUpdate.ts
-var updateValue2 = (original, update) => {
-  original.value = Math.max(Math.min(update.value, original.max), original.min);
-  return original;
-};
+var constrainValue2 = (original, update) => constrainSignedInt(update, original.min, original.max);
+var updateValue2 = (original, update) => (original.value = constrainValue2(original, update), original);
 
 // src/update/enumUpdate.ts
-var updateValue3 = (original, update) => {
-  original.value = Math.min(original.max, update.value);
-  return original;
-};
+var constrainValue3 = (original, update) => constrainUnsignedInt(update, original.max);
+var updateValue3 = (original, update) => (original.value = constrainValue3(original, update), original);
 
 // src/update/versionUpdate.ts
-var updateValue4 = (original, update) => {
-  const value = Math.min(original.bits ** 2 - 1, update.value);
-  return {
-    ...original,
-    value
-  };
-};
+var constrainValue4 = (original, update) => constrainUnsignedInt(update, original.bits ** 2 - 1);
+var updateValue4 = (original, update) => (original.value = constrainValue4(original, update), original);
 
 // src/update/booleanUpdate.ts
-var updateValue5 = (original, update) => {
-  original.value = update.value;
-  return original;
-};
+var constrainValue5 = (original, update) => update === true ? true : false;
+var updateValue5 = (original, update) => (original.value = constrainValue5(original, update), original);
 
 // 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;
+var constrainValue6 = (original, update) => {
+  const count = constrainUnsignedInt(update.length, original.maxCount);
+  return [...new Array(count)].map((_, i) => constrainUnsignedInt(update[i] ?? 0, original.max));
 };
+var updateValue6 = (original, update) => (original.value = constrainValue6(original, update), 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/validateUtils.ts
+var validateDataEntry = (descriptorValue, differentValue) => {
+  if (descriptorValue === null)
+    return null;
+  if (differentValue === null)
+    return descriptorValue;
+  if (descriptorValue.type === differentValue.type)
+    if (ComplexDataTypes.includes(descriptorValue.type))
+      return updateStateEntry(descriptorValue, differentValue.state);
+    else
+      return updateValueEntry(descriptorValue, differentValue.value);
+  return descriptorValue;
 };
 
 // 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)]));
-  }
+var constrainState = (state) => state === true ? true : false;
+var updateState = (original, state) => {
+  original.state = constrainState(state);
+  original.value = validateDataEntry(original.descriptor[Number(state)], original.value);
   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;
-  }
+var constrainState2 = (descriptorLength, state) => constrainUnsignedInt(state, descriptorLength - 1);
+var updateState2 = (original, state) => {
+  original.state = constrainState2(original.descriptor.length, state);
+  original.value = validateDataEntry(original.descriptor[original.state], original.value);
   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));
-  }
+var constrainState3 = (state, minCount, maxCount) => constrainSignedInt(state, minCount, maxCount);
+var updateState3 = (original, state) => {
+  original.state = constrainState3(state, original.minCount, original.maxCount);
+  original.value = [...new Array(original.state)].map((_, i) => original.value[i] ? validateDataEntry(original.descriptor, original.value[i] ?? null) : original.descriptor);
+  return original;
+};
+
+// src/update/objectUpdate.ts
+var updateValue7 = (original, value) => {
+  original.value = original.descriptor.map((v, i) => validateDataEntry(v, value[i] ?? null));
   return original;
 };
 
 // src/update/updateValues.ts
-var updateValue7 = (original, update) => {
-  if (original.type !== update.type)
-    throw new Error("Types do not match");
+var updateValueEntry = (original, update) => {
   switch (original.type) {
     case "FLOAT":
       return updateValue(original, update);
@@ -624,132 +425,562 @@ var updateValue7 = (original, update) => {
       return updateValue4(original, update);
     case "ENUM_ARRAY":
       return updateValue6(original, update);
+    case "OBJECT":
+      return updateValue7(original, update);
   }
 };
-var updateComplexValue = (original, update) => {
-  if (original.type !== update.type)
-    throw new Error("Types do not match");
+var constrainValue7 = (original, update) => {
+  switch (original.type) {
+    case "FLOAT":
+      return constrainValue(original, update);
+    case "INT":
+      return constrainValue2(original, update);
+    case "ENUM":
+      return constrainValue3(original, update);
+    case "BOOLEAN":
+      return constrainValue5(original, update);
+    case "VERSION":
+      return constrainValue4(original, update);
+    case "ENUM_ARRAY":
+      return constrainValue6(original, update);
+  }
+};
+var updateStateEntry = (original, update) => {
   switch (original.type) {
     case "OPTIONAL":
-      return updateComplexValue2(original, update);
+      return updateState(original, update);
     case "ENUM_OPTIONS":
-      return updateComplexValue3(original, update);
+      return updateState2(original, update);
     case "ARRAY":
-      return updateComplexValue4(original, update);
+      return updateState3(original, update);
   }
 };
+// src/factory/helperMethod.ts
+var getBitsForIntegerNumber = (number, maxBits) => {
+  const bitCount = Math.ceil(Math.log2(number));
+  if (bitCount > maxBits)
+    throw new Error(`Cannot get ${maxBits} bits for a number with ${bitCount} bits`);
+  return bitCount;
+};
+var getMinimumBitsForInteger = (v) => Math.ceil(Math.log2(v + 1));
+
+// src/factory/floatFactory.ts
+var create = (value, min = 0, max = 1, precision = 2, name = "a float") => {
+  const precisionMultiplier = 10 ** precision;
+  const roundedMin = Math.floor(min * precisionMultiplier);
+  const roundedMax = Math.ceil(max * precisionMultiplier);
+  const delta = roundedMax - roundedMin;
+  const significand = Math.max(1, getBitsForIntegerNumber(delta, SignificandMaxBits));
+  return {
+    value,
+    type: "FLOAT",
+    min: roundedMin / precisionMultiplier,
+    max: roundedMax / precisionMultiplier,
+    precision,
+    significand,
+    name
+  };
+};
+
+// src/factory/intFactory.ts
+var create2 = (value, min = 0, max = 10, name = "an int") => {
+  if (!Number.isInteger(min) || !Number.isInteger(max))
+    throw new Error("min and max must be integers");
+  if (max - min < 1)
+    throw new Error("max must be at least one");
+  if (Math.abs(max - min) > 2 ** IntegerMaxBits - 1)
+    throw new Error("max - min must be less than 1024");
+  const bits = getBitsForIntegerNumber(max - min + 1, IntegerMaxBits);
+  return { value, type: "INT", min, max, bits, name };
+};
+
+// src/factory/booleanFactory.ts
+var create3 = (value, name = "a boolean") => ({
+  value,
+  type: "BOOLEAN",
+  name
+});
+
+// src/factory/versionFactory.ts
+var create4 = (value, bits = 8, name = "a version") => ({
+  value,
+  type: "VERSION",
+  bits,
+  name
+});
+
+// src/factory/utils.ts
+var getEnumMaxAndMappingFromOptions = (options) => {
+  if (typeof options === "string")
+    return { max: options.length - 1, mapping: options.split("") };
+  if (typeof options === "number")
+    return { max: options, mapping: Array.from({ length: options + 1 }, (_, i) => i) };
+  return { max: options.length - 1, mapping: options };
+};
+var getOptionsFromMaxAndMapping = (v) => {
+  if (v.mapping.every((option) => typeof option === "string" && option.length === 1))
+    return v.mapping.join("");
+  if (Array.from({ length: v.max + 1 }, (_, i) => i).every((option, i) => option === v.mapping[i]))
+    return v.max;
+  return v.mapping;
+};
+
+// src/factory/enumFactory.ts
+var create5 = (value, options, name = "an enum") => {
+  const { max, mapping } = getEnumMaxAndMappingFromOptions(options);
+  if (!Number.isInteger(max))
+    throw new Error(`max must be integers, you have given ${max}`);
+  if (max < 1)
+    throw new Error("max must be at least one");
+  if (max > 2 ** EnumMaxBits - 1)
+    throw new Error("max - min must be less than 256");
+  const bits = getBitsForIntegerNumber(max + 1, EnumMaxBits);
+  return { value, type: "ENUM", max, bits, name, mapping };
+};
+
+// src/factory/enumArrayFactory.ts
+var minEnumArrayCount = 0;
+var maxOptionsCount = 1024;
+var create6 = (value, options, minCount = minEnumArrayCount, maxCount = 10, name = "enum array") => {
+  const { max, mapping } = getEnumMaxAndMappingFromOptions(options);
+  if (!Number.isInteger(max))
+    throw new Error(`max must be integers, you have given ${max}`);
+  if (!Number.isInteger(minCount) || !Number.isInteger(maxCount))
+    throw new Error("minCount and maxCount must be integers");
+  if (max < 1)
+    throw new Error("must have at least one option");
+  if (max > maxOptionsCount)
+    throw new Error(`maximum allowed options is 1024, you have given ${max + 1} options`);
+  minCount = Math.min(minCount, maxCount);
+  maxCount = Math.max(minCount, maxCount);
+  if (minCount < 0)
+    throw new Error("minCount can't be negative");
+  if (maxCount - minCount < 0)
+    throw new Error(`count range length must be positive, given count range length is ${Math.abs(maxCount - minCount)}`);
+  if (Math.abs(maxCount - minCount) > 2 ** IntegerMaxBits - 1)
+    throw new Error(`count range length must be less than 1024, given count range length is ${Math.abs(maxCount - minCount)}`);
+  value.forEach((v, i) => {
+    if (!Number.isInteger(v))
+      throw new Error(`all entries must be integers, index ${i} (${v}) is not`);
+    if (v > max)
+      throw new Error(`all entries must be within the range ${0} - ${max}, index ${i} (${v}) is not`);
+  });
+  if (value.length < minCount || value.length > maxCount)
+    throw new Error(`value length must be between minCount and maxCount, ${value.length} is not between ${minCount} and ${maxCount}`);
+  const stateBits = getBitsForIntegerNumber(maxCount - minCount + 1, IntegerMaxBits);
+  return {
+    type: "ENUM_ARRAY",
+    minCount,
+    maxCount,
+    value: JSON.parse(JSON.stringify(value)),
+    max,
+    name,
+    mapping,
+    stateBits
+  };
+};
+
+// src/factory/optionalFactory.ts
+var create7 = (descriptor, defaultState = false, name = "an optional") => {
+  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,
+    stateBits: 1
+  };
+};
+
+// src/factory/enumOptionsFactory.ts
+var maxEnumOptions = 64;
+var maxEnumOptionsBits = getMinimumBitsForInteger(maxEnumOptions);
+var create8 = (descriptor, defaultState = 0, name = "enum options", options) => {
+  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");
+  const mapping = [];
+  if (options) {
+    const { max, mapping: mapping2 } = getEnumMaxAndMappingFromOptions(options);
+    if (max !== descriptor.length - 1)
+      throw new Error("max must be equal to the length of the descriptor - 1");
+    mapping2.push(...mapping2);
+  } else
+    mapping.push(...descriptor.map((_, i) => i));
+  return {
+    value: JSON.parse(JSON.stringify(descriptor[defaultState])),
+    descriptor,
+    name,
+    mapping,
+    type: "ENUM_OPTIONS",
+    stateBits: getBitsForIntegerNumber(descriptor.length, maxEnumOptionsBits),
+    state: defaultState
+  };
+};
+
+// src/factory/arrayFactory.ts
+var maxArrayCount = 1024;
+var create9 = (descriptor, defaultState = 0, minCount = 0, maxCount = 10, name = "an array") => {
+  if (!Number.isInteger(minCount) || !Number.isInteger(maxCount))
+    throw new Error("minCount and maxCount must be integers");
+  if (minCount < 0)
+    throw new Error("minCount must be at least 0");
+  if (maxCount < 0)
+    throw new Error("maxCount must be at least 0");
+  if (maxCount - minCount < 0)
+    throw new Error("maxCount must be greater than or equal to minCount");
+  if (maxCount - minCount > maxArrayCount)
+    throw new Error(`maxCount (${maxCount}) - minCount (${minCount}) = ${maxCount - minCount} must be less than or equal to maxArrayCount (${maxArrayCount})`);
+  if (defaultState < minCount || defaultState > maxCount)
+    throw new Error(`defaultState must be between minCount (${minCount}) and maxCount (${maxCount}), given defaultState is ${defaultState}`);
+  const stateBits = getMinimumBitsForInteger(maxCount - minCount);
+  return {
+    value: [...Array(defaultState)].map(() => JSON.parse(JSON.stringify(descriptor))),
+    descriptor,
+    type: "ARRAY",
+    minCount,
+    maxCount,
+    stateBits,
+    state: defaultState,
+    name
+  };
+};
+
+// src/factory/objectFactory.ts
+var create10 = (descriptor, name = "an object") => {
+  return {
+    type: "OBJECT",
+    descriptor,
+    value: descriptor,
+    name,
+    stateBits: 0
+  };
+};
+
+// src/factory/factory.ts
+var DataEntryFactory = {
+  FLOAT: create,
+  INT: create2,
+  ENUM: create5,
+  BOOLEAN: create3,
+  VERSION: create4,
+  ENUM_ARRAY: create6,
+  OPTIONAL: create7,
+  ENUM_OPTIONS: create8,
+  ARRAY: create9,
+  OBJECT: create10
+};
+var StateDescriptorFactoryMethod = create10;
+// src/stateHandling/stateNode.ts
+class StateNode {
+  parent;
+  root;
+  type;
+  name;
+  bitstring = "";
+  constructor(entry, parent) {
+    this.parent = parent;
+    this.root = parent ? parent.root : this;
+    this.type = entry.type;
+    this.name = entry.name;
+  }
+  updateUpstream = () => {
+    const newBitstring = this.getBitString();
+    if (newBitstring !== this.bitstring)
+      this.bitstring = newBitstring, this.parent && this.parent.updateUpstream();
+  };
+  getStateBits = () => {
+    throw new Error("not implemented for " + this.type);
+  };
+  getValueBits = () => dataEntryBitsStringifier(this.toDataEntry());
+  getBitString = () => {
+    if (HasStateBitsDataTypes.includes(this.type))
+      return this.getStateBits() + this.getValueBits();
+    return this.getValueBits();
+  };
+  getBase64String = () => parseBitsToBase64(this.bitstring);
+  getParentString = () => {
+    if (this.parent)
+      return `${this.parent.name}
+↳${this.name}`;
+    else
+      return `root:"${this.getDescription()} - ${this.getBase64String()}"`;
+  };
+  getChildren = () => {
+    throw new Error("not implemented for " + this.type);
+  };
+  getDescription = () => this.name;
+  getChildrenStrings = () => {
+    const children = this.getChildren();
+    if (children.length === 0)
+      return [];
+    const strings = [];
+    children.forEach((child, level) => {
+      const indent = level < children.length - 1 ? "|   " : "    ";
+      if (child) {
+        strings.push(`|→"${child.getDescription()}"`);
+        for (const grandchild of child.getChildrenStrings())
+          strings.push(indent + grandchild);
+      } else
+        strings.push(`|→null`);
+    });
+    return strings;
+  };
+  toDataEntry = () => {
+    throw new Error("not implemented for " + this.type);
+  };
+  toString() {
+    return `${this.getParentString()}
+${this.getChildrenStrings().join(`
+`)}`;
+  }
+}
+
+class SimpleStateNodes extends StateNode {
+  value;
+  descriptor;
+  constructor(entry, parent) {
+    super(entry, parent);
+    this.value = entry.value;
+    this.descriptor = entry;
+    this.bitstring = this.getBitString();
+  }
+  getChildren = () => [];
+  getDescription = () => `${this.name}: ${this.value}`;
+  updateValue = (value) => {
+    this.value = constrainValue7(this.descriptor, value);
+    this.updateUpstream();
+  };
+  toDataEntry = () => ({
+    ...this.descriptor,
+    name: this.name,
+    value: this.value
+  });
+}
+
+class VersionNode extends SimpleStateNodes {
+}
+
+class BooleanNode extends SimpleStateNodes {
+}
+
+class EnumNode extends SimpleStateNodes {
+}
+
+class IntNode extends SimpleStateNodes {
+}
+
+class FloatNode extends SimpleStateNodes {
+}
+
+class EnumArrayNode extends SimpleStateNodes {
+  getStateBits = () => rawStateStringifier(this.value, this.descriptor.minCount, this.descriptor.stateBits);
+  getDescription = () => `${this.name}: [${this.value.map((v) => this.descriptor.mapping[v]).join(", ")}]`;
+}
+
+class OptionalNode extends StateNode {
+  state;
+  stateBits;
+  descriptor;
+  child = null;
+  constructor(entry, parent) {
+    super(entry, parent);
+    this.state = entry.state;
+    this.stateBits = entry.stateBits;
+    this.descriptor = entry["descriptor"];
+    this.bitstring = this.getBitString();
+  }
+  getChildren = () => [this.child];
+  getStateBits = () => rawStateStringifier3(this.state);
+  getValueBits = () => this.child ? this.child.bitstring : "";
+  updateState = (newState) => {
+    this.state = constrainState(newState);
+    if (this.state === this.state)
+      return;
+    this.child = this.descriptor[this.state ? 1 : 0] ? NodeFactory(this.descriptor[this.state ? 1 : 0], this) : null;
+    this.updateUpstream();
+  };
+  toDataEntry = () => ({
+    type: "OPTIONAL",
+    name: this.name,
+    state: this.state,
+    stateBits: this.stateBits,
+    descriptor: this.descriptor,
+    value: this.child ? this.child.toDataEntry() : null
+  });
+  getDescription = () => `${this.name}: ${this.state}`;
+}
+
+class EnumOptionsNode extends StateNode {
+  state;
+  stateBits;
+  descriptor;
+  mapping;
+  child = null;
+  constructor(entry, parent) {
+    super(entry, parent);
+    this.state = entry.state;
+    this.stateBits = entry.stateBits;
+    this.descriptor = entry["descriptor"];
+    this.mapping = entry["mapping"];
+    this.child = entry["value"] ? NodeFactory(entry["value"], this) : null;
+    this.bitstring = this.getBitString();
+  }
+  getChildren = () => [this.child];
+  getStateBits = () => rawStateStringifier4(this.state, this.stateBits);
+  getValueBits = () => this.child ? this.child.bitstring : "";
+  updateState = (newState) => {
+    const constrainedNewState = constrainState2(this.descriptor.length, newState);
+    if (constrainedNewState === this.state)
+      return;
+    const validationResult = validateDataEntry(this.descriptor[constrainedNewState], this.child ? this.child.toDataEntry() : null);
+    this.child = validationResult ? NodeFactory(validationResult, this) : null;
+    this.state = constrainedNewState;
+    this.updateUpstream();
+  };
+  toDataEntry = () => ({
+    type: "ENUM_OPTIONS",
+    name: this.name,
+    state: this.state,
+    stateBits: this.stateBits,
+    descriptor: this.descriptor,
+    mapping: this.mapping,
+    value: this.child ? this.child.toDataEntry() : null
+  });
+  getDescription = () => `${this.name}: ${this.state} of ${this.mapping.length} options`;
+}
+
+class ArrayNode extends StateNode {
+  descriptor;
+  children;
+  minCount;
+  maxCount;
+  stateBits;
+  state;
+  constructor(entry, parent) {
+    super(entry, parent);
+    this.descriptor = entry["descriptor"];
+    this.children = entry["value"].map((child) => NodeFactory(child, this));
+    this.minCount = entry["minCount"];
+    this.maxCount = entry["maxCount"];
+    this.stateBits = entry["stateBits"];
+    this.state = entry["state"];
+    this.bitstring = this.getBitString();
+  }
+  getChildren = () => this.children;
+  getStateBits = () => rawStateStringifier2(this.state, this.minCount, this.stateBits);
+  getValueBits = () => this.children.map((child) => child.bitstring).join("");
+  updateState = (newState) => {
+    const constrainedNewState = constrainState3(newState, this.minCount, this.maxCount);
+    if (constrainedNewState === this.state)
+      return;
+    if (constrainedNewState < this.state)
+      this.children = this.children.slice(0, constrainedNewState);
+    else
+      for (let i = this.state;i < constrainedNewState; i++)
+        this.children.push(NodeFactory(this.descriptor, this));
+    this.state = constrainedNewState;
+    this.updateUpstream();
+  };
+  toDataEntry = () => ({
+    type: "ARRAY",
+    name: this.name,
+    value: this.children.map((child) => child.toDataEntry()),
+    minCount: this.minCount,
+    maxCount: this.maxCount,
+    stateBits: this.stateBits,
+    state: this.state,
+    descriptor: this.descriptor
+  });
+  getDescription = () => `${this.name}: ${this.state} of (${this.minCount}, ${this.maxCount})`;
+}
+
+class ObjectNode extends StateNode {
+  descriptor;
+  children;
+  constructor(entry, parent) {
+    super(entry, parent);
+    this.descriptor = entry["descriptor"];
+    this.children = entry["value"].map((child) => NodeFactory(child, this));
+    this.bitstring = this.getBitString();
+  }
+  getChildren = () => this.children;
+  getStateBits = () => "";
+  getValueBits = () => this.children.map((child) => child.bitstring).join("");
+  toDataEntry = () => ({
+    type: "OBJECT",
+    name: this.name,
+    value: this.children.map((child) => child.toDataEntry()),
+    descriptor: this.descriptor,
+    stateBits: 0
+  });
+}
+var StateNodeMap = {
+  VERSION: VersionNode,
+  BOOLEAN: BooleanNode,
+  ENUM: EnumNode,
+  INT: IntNode,
+  FLOAT: FloatNode,
+  ENUM_ARRAY: EnumArrayNode,
+  OPTIONAL: OptionalNode,
+  ENUM_OPTIONS: EnumOptionsNode,
+  ARRAY: ArrayNode,
+  OBJECT: ObjectNode
+};
+var NodeFactory = (entry, parent) => new StateNodeMap[entry.type](entry, parent);
+var GetStateNodeTree = (entries, name) => new ObjectNode(StateDescriptorFactoryMethod(entries, name), null);
+var FromState = (stateDescriptor, name, base64String) => {
+  const bitstring = parseBase64ToBits(base64String);
+  const dataObject = StateDescriptorFactoryMethod(stateDescriptor, name);
+  const [parsedObject] = dataEntryBitstringParser(dataObject, bitstring);
+  return new ObjectNode(parsedObject, null);
+};
 // src/stateHandling/stateData.ts
-var getStateData = (state) => {
+var getObjectForDataEntries = (entries) => {
   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;
-    }
+  entries.forEach((item) => {
+    object[item.name] = getStateData(item);
   });
   return object;
 };
-
-// src/stateHandling/stateDataObject.ts
-var getBitstringForStateDataEntry = (stateDataEntry2) => {
-  switch (stateDataEntry2.type) {
+var getStateData = (entry) => {
+  switch (entry.type) {
     case "BOOLEAN":
     case "INT":
-    case "ENUM":
     case "FLOAT":
     case "VERSION":
+      return entry.value;
+    case "ENUM":
+      return entry.mapping[entry.value];
     case "ENUM_ARRAY":
-      return stateDataEntry2.bitstring = stateDataEntry2.bitstring ?? dataBitsStringifier(stateDataEntry2);
+      return entry.value.map((v) => entry.mapping[v]);
     case "OPTIONAL":
-      return stateDataEntry2.value === null ? complexDataStateStringifier(stateDataEntry2) : complexDataStateStringifier(stateDataEntry2) + getBitstringForStateNestedData(stateDataEntry2.value);
+      return entry.value === null ? null : getStateData(entry.value);
     case "ENUM_OPTIONS":
-      return complexDataStateStringifier(stateDataEntry2) + getBitstringForStateNestedData(stateDataEntry2.value);
-    case "ARRAY":
-      return complexDataStateStringifier(stateDataEntry2) + stateDataEntry2.value.map((vs) => getBitstringForStateNestedData(vs)).join("");
-  }
-};
-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;
+      const state = entry.mapping[entry.state];
+      if (entry.value) {
+        switch (entry.value.type) {
+          case "OBJECT":
+            return {
+              ...getStateData(entry.value),
+              state
+            };
+          default:
+            return { state, value: getStateData(entry.value) };
+        }
+      } else
+        return { state };
+    case "OBJECT":
+      return getObjectForDataEntries(entry.value);
     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;
-  }
-  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 entry.value.map((v) => getStateData(v));
   }
-  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);
@@ -766,8 +997,6 @@ var interpolateEntryAt = (dataEntry2, t) => {
     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
@@ -782,30 +1011,36 @@ var getRelativeValue = (dataEntry2) => {
       return dataEntry2.value / (2 ** dataEntry2.bits - 1);
     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,
+  getStateData,
   getRelativeValue,
   getOptionsFromMaxAndMapping,
-  getInitialStateFromBase64,
   getEnumMaxAndMappingFromOptions,
-  getBitsCount7 as getBitsCount,
+  getBitsCount6 as getBitsCount,
   dataEntryCorrecting,
   dataEntryBitstringParser,
-  dataBitsStringifier,
-  dataBitsParser,
-  createStateDataObject,
-  complexDataStringifier,
-  complexDataStateStringifier,
+  dataEntryBitsStringifier,
+  VariableBitWidthDataTypes,
+  StateNode,
   SignificandMaxBits,
   PROTECTED_ATTRIBUTE_NAMES,
+  OptionalNode,
+  ObjectNode,
+  NodeFactory,
   IntegerMaxBits,
-  DescriptorFactory,
-  DataTypeValues,
-  ComplexDataValues
+  IntNode,
+  GetStateNodeTree,
+  FromState,
+  FloatNode,
+  EnumOptionsNode,
+  EnumNode,
+  EnumArrayNode,
+  DataEntryFactory,
+  ConstantBitWidthDataTypes,
+  BooleanNode,
+  ArrayNode
 };