url-safe-bitpacking 0.1.11 → 0.1.13

package/README.md

@@ -11,16 +11,13 @@ Package for creating definitions of parametric models that can be stored as comp
 | updating model entries                               | ✓  | ✓  |          |
 | re-using data from old model on change in definition | ½ | ¼ |          |
 | flattening and reading of the objects                | ✓  | ✓  | ¿ |
+| arrays (both bit-level as arrays of objects)         | ½ | ¼ |          |
 
 ## concept
 
-The goal of this library is to offer a flexible, minimal and, variable object definition that can be stored in the browser URL. The main imagined use-case is parametric models that have nested and variable sub-object definitions.
+The goal of this library is to offer a flexible, minimal and, variable object definition that can be stored in the browser URL. The main imagined use-case is parametric models that have nested and variable sub-object definitions. The library heavily relies on the bitpacking of custom bitwidth numeric values. Because of that, the biggest trade-off for this library is legibility. Without the related object definition, it would be impossible to reconstruct the state. The big advantage though is the ability to store rather many variables in a very condensed URL, allowing to store all information in rather short urls which then can be used for qr code generation.
 
-The library heavily relies on the bitpacking of custom bitwidth numeric values. Because of that, the biggest trade-off for this library is legibility. Without the related object definition, it would be impossible to reconstruct the state.
-
-The big advantage though is the ability to store rather many variables in a very condensed URL, allowing to store all information in rather short urls which then can be used for qr code generation.
-
-## data types
+## bit-level data types
 
 Currently, there are 4 data types implemented (+1 special case for safety). All data entries have a name that will behave as an attribute name in the object.
 
@@ -64,11 +61,11 @@ There is also a Version object which is a special case of the enum data type and
 DataEntryFactory.createVersion(0, 8, 'version');
 ```
 
-## attribute map
+## nested attribute definitions
 
-On a macro level there are two types of data. Either Single Level array objects or Double Nested array objects.
+More often than not in parametric models, certain data belongs together. It can also happen that the specific state of some values will have an impact on other ones being present (or which ranges are allowed). To be able to deal with this there is the option to nest data. I tried to come with an as concise yet versatile way of defining the object definitions.
 
-Single-level nested objects are arrays in which the entries it contains describe themselves. The Double Nested arrays describe objects that will have a variable size, that depends on the linked data entry that is selected is set in state.
+### single nes
 
 For the Double Nested arrays there are currently two variations: either an Optional type, which only accepts two values of which is an empty array and will be toggle on/off in relation to a certain boolean data entry.
 

package/dist/factory/helperMethod.d.ts

@@ -1,2 +1,5 @@
+import { VersionRangeType } from '../types';
 export declare const getBitsForIntegerNumber: (number: number, maxBits: number) => number;
+export declare const getMinimumBitsForInteger: (v: number) => number;
+export declare const getVersionValueRangeValueForNumber: (v: number) => VersionRangeType;
 export declare const getMaxIntegerValueForGivenBitWidth: (bitCount: number) => number;

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-export { ObjectGenerationOutputStatus, DataType } from './enums';
+export { DataType } from './enums';
 export { DataEntryFactory } from './factory';
-export { createParserObject, parseUrl, updateDataEntry, getURLSafeBase64ForData, getSemanticallyNestedValues, getDefaultObject, getFlatArray, } from './objectmap';
-export {} from './parsers';
-export { SingleLevelContentType, NestedContentDataType, NestedContentType, DoubleLevelContentType, NonEmptyValidEntryArrayType, OptionalEntryDataType, EnumEntryDataType, VersionArrayDefinitionType, PrecisionRangeType, SignificandMaxBits, FloatData, IntegerMaxBits, IntData, VersionRangeType, VersionData, BooleanData, DataEntry, DataEntryArray, SemanticlyNestedDataEntry, ObjectGeneratorMethod, DefinitionGenerationObject, DefinitionNestedArray, DefinitionNestedGenerationObject, DefinitionSubObject, DefinitionArrayObject, VersionDefinitionObject, VersionEnumSemantics, ParserForVersion, ParsersForVersionObject, } from './types';
-export {} from './update';
+export { SingleLevelContentType, NestedContentDataType, NestedContentType, DoubleLevelContentType, NonEmptyValidEntryArrayType, OptionalEntryDataType, EnumEntryDataType, PrecisionRangeType, SignificandMaxBits, FloatData, IntegerMaxBits, IntData, VersionRangeType, VersionData, BooleanData, DataEntry, DataEntryArray, StateDataType, StateValueType, EnumSemantics, } from './types';
+export { createParserObject, getStateValue, getBase64String, getDataEntryArray } from './objectmap';
+export { parseBase64ToBits } from './parsers';
 export { interpolateEntryAt, getRelativeValue } from './utils';

package/dist/index.js

@@ -18,6 +18,14 @@ var ObjectGenerationOutputStatus;
 // 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/factory/helperMethod.ts
 var getBitsForIntegerNumber = (number, maxBits) => {
   const bitCount = Math.ceil(Math.log2(number));
@@ -25,7 +33,14 @@ var getBitsForIntegerNumber = (number, maxBits) => {
     throw new Error(`Cannot get ${maxBits} bits for a number with ${bitCount} bits`);
   return bitCount;
 };
-var getMaxIntegerValueForGivenBitWidth = (bitCount) => 2 ** bitCount - 1;
+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;
+};
 
 // src/factory/floatFactory.ts
 var create = (value, min = 0, max = 1, precision = 2, name = "", index = -1) => {
@@ -46,9 +61,6 @@ var create = (value, min = 0, max = 1, precision = 2, name = "", index = -1) =>
   };
 };
 
-// src/types/intData.ts
-var IntegerMaxBits = 12;
-
 // src/factory/intFactory.ts
 var create2 = (value, min = 0, max = 10, name = "", index = -1) => {
   if (!Number.isInteger(min) || !Number.isInteger(max))
@@ -73,9 +85,6 @@ var create4 = (value, bits = 8, name = "", index = -1) => ({
   index
 });
 
-// src/types/enumData.ts
-var EnumMaxBits = 8;
-
 // src/factory/enumFactory.ts
 var create5 = (value, max = 10, name = "", index = -1) => {
   if (!Number.isInteger(max))
@@ -96,67 +105,8 @@ var DataEntryFactory = {
   createBoolean: create3,
   createVersion: create4
 };
-// src/types/arrayDefinitions.ts
-var NAME_DELIMETER = "_";
-
-// src/objectmap/versionArrayDefinitionToObjectDefintion.ts
-var isSingleLevelContentType = (data) => singleLevelContentTypeIsDataEntry(data[0]) || singleLevelContentTypeIsNestedContentDataType(data[0]);
-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 singleLevelContentTypeIsEnumEntryDataType = (data) => isDoubleLevelContentType(data) && typeof data[0] === "number";
-var singleLevelContentTypeIsOptionalEntryDataType = (data) => isDoubleLevelContentType(data) && typeof data[0] === "boolean";
-var parseSingleLevelContentTypeToDefinitionSubObject = (data, internalPrecedingName) => {
-  if (singleLevelContentTypeIsDataEntry(data))
-    return parseDataEntry(data, internalPrecedingName);
-  else if (singleLevelContentTypeIsNestedContentDataType(data))
-    return parseNestedContentDataTypeToDefinitionNestedArray(data, internalPrecedingName);
-  else {
-    throw new Error("this is an invalid output value, wonder why?");
-  }
-};
-var parseNestedContentDataTypeToDefinitionNestedArray = (data, internalPrecedingName) => {
-  const [attributeName, localData] = data;
-  if (isSingleLevelContentType(localData))
-    return [attributeName, localData.map((v) => parseSingleLevelContentTypeToDefinitionSubObject(v, internalPrecedingName))];
-  else if (singleLevelContentTypeIsEnumEntryDataType(localData))
-    return parseEnumEntryDataTypeToDefinitionNestedGenerationObject(localData, attributeName, internalPrecedingName);
-  else if (singleLevelContentTypeIsOptionalEntryDataType(localData))
-    return parseOptionalEntryDataTypeToDefinitionNestedGenerationObject(localData, attributeName, internalPrecedingName);
-  else {
-    throw new Error("this is an invalid output value, wonder why?");
-  }
-};
-var parseEnumEntryDataTypeToDefinitionNestedGenerationObject = (data, name, internalPrecedingName) => {
-  if (Math.round(data[0]) !== data[0])
-    `given default (${data[0]}) value isn't an integer, rounding it`;
-  if (data.length - 2 < Math.round(data[0]))
-    console.log(`given default value (${data[0]}) was larger than the amount of options available, using the largest value (${data.length - 2}) instead`);
-  if (data[0] < 0)
-    console.log(`given default value (${data[0]}) was negative, using first index (0) instead`);
-  const dataEntry = parseDataEntry(DataEntryFactory.createEnum(Math.max(Math.min(data.length - 2, Math.round(data[0])), 0), data.length - 2, name), internalPrecedingName);
-  const generationMethod = (d) => [
-    d,
-    ...data[d.value + 1].map((v) => parseSingleLevelContentTypeToDefinitionSubObject(v, dataEntry.internalName))
-  ];
-  return [name, dataEntry, generationMethod];
-};
-var parseOptionalEntryDataTypeToDefinitionNestedGenerationObject = (data, name, internalPrecedingName) => {
-  const dataEntry = parseDataEntry(DataEntryFactory.createBoolean(data[0], name), internalPrecedingName);
-  const generationMethod = (d) => [
-    d,
-    ...data[Number(!d.value) + 1].map((v) => parseSingleLevelContentTypeToDefinitionSubObject(v, dataEntry.internalName))
-  ];
-  return [name, dataEntry, generationMethod];
-};
-var parseDataEntry = (d, internalPrecedingName) => internalPrecedingName ? { ...d, internalName: `${internalPrecedingName}${NAME_DELIMETER}${d.name}` } : d;
-var parseVersionArrayDefinitionTypeToVersionDefinitionObject = (v, optionalIndexOverwrite) => [
-  optionalIndexOverwrite ? { ...parseDataEntry(v[0]), value: optionalIndexOverwrite } : parseDataEntry(v[0]),
-  ...v.slice(1).map((d) => parseSingleLevelContentTypeToDefinitionSubObject(d, "_"))
-];
-
 // src/parsers/intParser.ts
-var getBitsCount = (intData2) => intData2.bits;
+var getBitsCount = (intData3) => intData3.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})`);
@@ -167,9 +117,9 @@ var rawValueParser = (stateString, bitCount) => {
     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)
+var rawParser = (stateString, intData3) => {
+  const v = rawValueParser(stateString, intData3.bits) + intData3.min;
+  if (v > intData3.max)
     throw new Error("Value exceeds max");
   return v;
 };
@@ -178,16 +128,16 @@ var rawIntStringifier = (value, bitCount) => {
     throw new Error("Value is not an integer");
   return value.toString(2).padStart(bitCount, "0");
 };
-var rawStringifier = (value, intData2) => {
-  if (value < intData2.min)
+var rawStringifier = (value, intData3) => {
+  if (value < intData3.min)
     throw new Error("Value is below min");
-  if (value > intData2.max)
+  if (value > intData3.max)
     throw new Error("Value exceeds max");
-  return rawIntStringifier(value - intData2.min, intData2.bits);
+  return rawIntStringifier(value - intData3.min, intData3.bits);
 };
 
 // src/parsers/floatParser.ts
-var getBitsCount2 = (floatData2) => floatData2.significand;
+var getBitsCount2 = (floatData3) => floatData3.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})`);
@@ -196,30 +146,30 @@ var rawValueParser2 = (stateString, significandBits, precision) => {
   const significand = rawValueParser(stateString, significandBits);
   return significand * 10 ** -precision;
 };
-var rawParser2 = (stateString, floatData2) => {
-  const v = floatData2.min + rawValueParser2(stateString, floatData2.significand, floatData2.precision);
-  if (v > floatData2.max)
+var rawParser2 = (stateString, floatData3) => {
+  const v = floatData3.min + rawValueParser2(stateString, floatData3.significand, floatData3.precision);
+  if (v > floatData3.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 rawStringifier2 = (value, floatData3) => rawIntStringifier(Math.round((value - floatData3.min) * 10 ** floatData3.precision), floatData3.significand);
 
 // src/parsers/enumParser.ts
-var getBitsCount3 = (versionData) => versionData.bits;
-var rawParser3 = (rawString, versionData) => rawValueParser(rawString, versionData.bits);
-var rawStringifier3 = (value, versionData) => {
-  if (value > versionData.max)
+var getBitsCount3 = (versionData2) => versionData2.bits;
+var rawParser3 = (rawString, versionData2) => rawValueParser(rawString, versionData2.bits);
+var rawStringifier3 = (value, versionData2) => {
+  if (value > versionData2.max)
     throw new Error("Version exceeds max");
-  return rawIntStringifier(value, versionData.bits);
+  return rawIntStringifier(value, versionData2.bits);
 };
 
 // src/parsers/versionParser.ts
-var getBitsCount4 = (versionData) => versionData.bits;
-var rawParser4 = (rawString, versionData) => rawValueParser(rawString, versionData.bits);
-var rawStringifier4 = (value, versionData) => {
-  if (value > 2 ** versionData.bits - 1)
+var getBitsCount4 = (versionData2) => versionData2.bits;
+var rawParser4 = (rawString, versionData2) => rawValueParser(rawString, versionData2.bits);
+var rawStringifier4 = (value, versionData2) => {
+  if (value > 2 ** versionData2.bits - 1)
     throw new Error("Version exceeds max");
-  return rawIntStringifier(value, versionData.bits);
+  return rawIntStringifier(value, versionData2.bits);
 };
 
 // src/parsers/booleanParser.ts
@@ -274,15 +224,10 @@ var getBitsCount6 = (mapData) => {
       return getBitsCount3(mapData);
   }
 };
-var dataBitsArrayParser = (bitString, mapDataArray) => {
-  const bitCounts = mapDataArray.map((mapData) => getBitsCount6(mapData));
-  const bitStartEndMap = [];
-  bitCounts.forEach((bitCount, index) => {
-    const start = index === 0 ? 0 : bitStartEndMap[index - 1][1];
-    bitStartEndMap.push([start, start + bitCount]);
-  });
-  return mapDataArray.map((mapData, i) => dataBitsParser(bitString.slice(bitStartEndMap[i][0], bitStartEndMap[i][1]), mapData));
-};
+var dataEntryBitstringParser = (bitstring, dataEntry2) => [
+  dataBitsParser(bitstring.slice(0, getBitsCount6(dataEntry2)), dataEntry2),
+  bitstring.slice(getBitsCount6(dataEntry2))
+];
 var dataBitsStringifier = (data) => {
   switch (data.type) {
     case DataType.BOOLEAN:
@@ -297,7 +242,7 @@ var dataBitsStringifier = (data) => {
       return rawStringifier3(data.value, data);
   }
 };
-var dataEntryCorrecting = (dataEntry) => dataBitsParser(dataBitsStringifier(dataEntry), dataEntry);
+var dataEntryCorrecting = (dataEntry2) => dataBitsParser(dataBitsStringifier(dataEntry2), dataEntry2);
 var base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 var parseBitsToBase64 = (bits) => {
   const chunks = bits.match(/.{1,6}/g);
@@ -312,93 +257,6 @@ var parseBase64ToBits = (base64) => {
 var dataArrayStringifier = (dataEntryArray) => {
   return dataEntryArray.map(dataBitsStringifier).join("");
 };
-
-// src/objectmap/versionReading.ts
-var currentObjectIndex = -1;
-var nestedDataEntryArrayToObject = (definitionArrayObject) => {
-  currentObjectIndex = -1;
-  return internalNestedDataEntryArrayToObject(definitionArrayObject);
-};
-var internalNestedDataEntryArrayToObject = (definitionArrayObject) => {
-  return Object.fromEntries(definitionArrayObject.map((value) => {
-    if (Array.isArray(value)) {
-      if (value.length === 2)
-        return [value[0], internalNestedDataEntryArrayToObject(value[1])];
-      else
-        return [value[0], internalNestedDataEntryArrayToObject(value[2](value[1]))];
-    }
-    return [value.name, { ...value, index: ++currentObjectIndex }];
-  }));
-};
-var definitionArrayObjectParser = (bitString, v) => {
-  const [key, values] = v;
-  const [nestedSemanticObject, objectGenerationStatus, localEndIndex] = parsingDefinitionArrayObject(bitString, values);
-  return [[key, nestedSemanticObject], objectGenerationStatus, localEndIndex];
-};
-var methodParser = (bitString, v) => {
-  const [key, keyDataDescription, methodGenerator] = v;
-  const [keyDataEntry, status] = dataEntryParser(bitString, keyDataDescription, false);
-  const [result, localStatus, localEndIndex] = definitionArrayObjectParser(bitString, [key, methodGenerator(keyDataEntry)]);
-  return [result, localStatus !== ObjectGenerationOutputStatus.PARSED ? localStatus : status, localEndIndex];
-};
-var dataEntryParser = (bitString, v, iterate = true) => {
-  const bitWidth = getBitsCount6(v);
-  const value = iterate ? { ...dataBitsParser(bitString.slice(0, bitWidth), v), index: ++currentObjectIndex } : dataBitsParser(bitString.slice(0, bitWidth), v);
-  return [value, ObjectGenerationOutputStatus.PARSED, bitWidth];
-};
-var parsingDefinitionArrayObject = (bitString, definitionArrayObject) => {
-  let startIndex = 0;
-  let objectGenerationStatus = ObjectGenerationOutputStatus.PARSED;
-  return [
-    Object.fromEntries(definitionArrayObject.map((value) => {
-      if (Array.isArray(value)) {
-        if (value.length === 2) {
-          const [[key, nestedSemanticObject], status, localEndIndex] = definitionArrayObjectParser(bitString.slice(startIndex), value);
-          startIndex += localEndIndex;
-          ObjectGenerationOutputStatus.PARSED;
-          return [key, nestedSemanticObject];
-        } else {
-          const [[key, nestedSemanticObject], status, localEndIndex] = methodParser(bitString.slice(startIndex), value);
-          startIndex += localEndIndex;
-          ObjectGenerationOutputStatus.PARSED;
-          return [key, nestedSemanticObject];
-        }
-      } else {
-        const [dataEntry, status, localEndIndex] = dataEntryParser(bitString.slice(startIndex), value);
-        startIndex += localEndIndex;
-        ObjectGenerationOutputStatus.PARSED;
-        return [dataEntry.name, dataEntry];
-      }
-    })),
-    objectGenerationStatus,
-    startIndex
-  ];
-};
-var parseUrlMethod = (url, parserVersions) => {
-  currentObjectIndex = -1;
-  const bitString = parseBase64ToBits(url);
-  const version = dataBitsArrayParser(bitString, [DataEntryFactory.createVersion(0, parserVersions.versionBitCount)])[0];
-  const versionParser = parserVersions.parsers[version.value];
-  if (!versionParser)
-    throw new Error(`No parser for version ${version.value}`);
-  return parsingDefinitionArrayObject(bitString, versionParser.objectGeneratorParameters)[0];
-};
-var parseDownNestedDataDescription = (nestedDataDescription) => {
-  const dataDescriptions = [];
-  Object.values(nestedDataDescription).forEach((value) => {
-    if (value.hasOwnProperty("type"))
-      dataDescriptions.push(value);
-    else
-      dataDescriptions.push(...parseDownNestedDataDescription(value));
-  });
-  return dataDescriptions.sort();
-};
-var getURLForData = (data) => {
-  const dataEntryArray = parseDownNestedDataDescription(data);
-  const bitstring = dataArrayStringifier(dataEntryArray);
-  return parseBitsToBase64(bitstring);
-};
-
 // src/update/floatUpdate.ts
 var updateValue = (original, update) => {
   const value = Math.max(Math.min(update.value, original.max), original.min);
@@ -458,100 +316,200 @@ var updateValue6 = (original, update) => {
       return updateValue4(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";
 
-// src/objectmap/versionUpdate.ts
-var currentObjectIndex2 = 0;
-var findExistingDataEntry = (dataEntry, dataEntryArray) => {
-  const dataEntryName = dataEntry.internalName ?? dataEntry.name;
-  return dataEntryArray.find((d) => (d.internalName ?? d.name) === dataEntryName);
-};
-var dataEntryUpdating = (dataEntry, dataEntryArray) => {
-  const existingDataEntry = findExistingDataEntry(dataEntry, dataEntryArray);
-  if (!existingDataEntry)
-    return [dataEntry.name, { ...dataEntry, index: currentObjectIndex2++ }];
-  return [dataEntry.name, { ...updateValue6(dataEntry, existingDataEntry), index: currentObjectIndex2++ }];
-};
-var nestedDataEntryArrayUpdating = (definitionNestedArrray, dataEntryArray) => {
-  const [keyString, nestedDefinitionArray] = definitionNestedArrray;
-  return [keyString, updateDataEntryObject(nestedDefinitionArray, dataEntryArray)];
-};
-var generationObjectUpdating = (definitionArrayObject, dataEntryArray) => {
-  const [keyString, keyDataEntry, methodGenerator] = definitionArrayObject;
-  const foundKeyDataEntry = findExistingDataEntry(keyDataEntry, dataEntryArray);
-  const newKeyData = foundKeyDataEntry ? updateValue6(keyDataEntry, foundKeyDataEntry) : keyDataEntry;
-  return [keyString, updateDataEntryObject(methodGenerator(newKeyData), dataEntryArray)];
-};
-var updateDataEntryObject = (definitionArrayObject, dataArray) => {
-  const newNestedObject = {};
-  definitionArrayObject.forEach((value) => {
-    if (Array.isArray(value)) {
-      if (value.length === 2) {
-        const [keyString, nestedDataEntry] = nestedDataEntryArrayUpdating(value, dataArray);
-        newNestedObject[keyString] = nestedDataEntry;
-      } else {
-        const [keyString, nestedDataEntry] = generationObjectUpdating(value, dataArray);
-        newNestedObject[keyString] = nestedDataEntry;
+// 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);
+  }
+  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
       }
-    } else {
-      const [key, dataEntry] = dataEntryUpdating(value, dataArray);
-      newNestedObject[key] = dataEntry;
-    }
-  });
-  return newNestedObject;
-};
-var updateDataEntry = (data, newDataEntry, parsersForVersion) => {
-  currentObjectIndex2 = 0;
-  const version = data.version;
-  const versionParser = parsersForVersion[version.value];
-  if (!versionParser)
-    throw new Error(`No parser for version ${version.value}`);
-  const correctedDataEntry = dataEntryCorrecting(newDataEntry);
-  const dataEntryArray = parseDownNestedDataDescription(data);
-  const virginDataEntryArray = [correctedDataEntry, ...dataEntryArray];
-  return updateDataEntryObject(versionParser.objectGeneratorParameters, virginDataEntryArray);
+    ]
+  ];
 };
-
-// src/objectmap/versionUserMethods.ts
-var createParserObject = (versionArray, versionBitCount, enumSemanticsMapping, attributeSemanticsMapping) => {
-  const maxAllowedParsers = getMaxIntegerValueForGivenBitWidth(versionBitCount);
-  if (versionArray.length > maxAllowedParsers)
-    throw new Error(`Cannot have more than ${maxAllowedParsers} versions`);
+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);
+  }
+  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]);
+  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([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,
-    parsers: versionArray.map((version, index) => ({
-      attributeSemanticsMapping: attributeSemanticsMapping ? Array.isArray(attributeSemanticsMapping) ? attributeSemanticsMapping[index] : attributeSemanticsMapping : undefined,
-      enumSemanticsMapping: enumSemanticsMapping ? Array.isArray(enumSemanticsMapping) ? enumSemanticsMapping[index] : enumSemanticsMapping : undefined,
-      objectGeneratorParameters: parseVersionArrayDefinitionTypeToVersionDefinitionObject(version, index)
-    }))
+    exposedVersions,
+    parser,
+    updater,
+    stringify,
+    enumSemanticsMapping,
+    attributeSemanticsMapping
   };
 };
-var parseUrl = (urlSafeBase64, parserVersions) => parseUrlMethod(urlSafeBase64, parserVersions);
-var updateDataEntry2 = (updatedEntry, currentObject, parserVersions) => updateDataEntry(currentObject, updatedEntry, parserVersions.parsers);
-var getURLSafeBase64ForData = (data) => getURLForData(data);
-var internalParseDataEntry = (data, enumSemanticsMapping) => {
-  if (data.type === DataType.ENUM && enumSemanticsMapping) {
-    const mapping = enumSemanticsMapping[data.name]?.find((entry) => entry.value === data.value);
-    if (mapping)
-      return mapping.label;
-  }
-  return data.value;
-};
-var internalStrictSemanticallyNestedValues = (data, enumSemanticsMapping, attributeSemanticsMapping) => Object.fromEntries(Object.entries(data).map(([key, value]) => [
-  attributeSemanticsMapping ? attributeSemanticsMapping[key] ?? key : key,
-  value.type !== undefined ? internalParseDataEntry(value, enumSemanticsMapping) : internalStrictSemanticallyNestedValues(value, enumSemanticsMapping, attributeSemanticsMapping)
-]));
-var getSemanticallyNestedValues = (data, parserVersions) => {
-  const versionNumber = data.version.value;
-  const enumSemanticsMapping = parserVersions.parsers[versionNumber]?.enumSemanticsMapping;
-  const attributeSemanticsMapping = parserVersions.parsers[versionNumber]?.attributeSemanticsMapping;
-  return internalStrictSemanticallyNestedValues(data, enumSemanticsMapping, attributeSemanticsMapping);
-};
-var getDefaultObject = (parserForVersions, versionindex) => {
-  if (!parserForVersions.parsers[versionindex])
-    throw new Error(`No parser for version ${versionindex} index`);
-  return nestedDataEntryArrayToObject(parserForVersions.parsers[versionindex].objectGeneratorParameters);
-};
-var getFlatArray = (data) => parseDownNestedDataDescription(data);
 // src/utils/interpolateData.ts
 var interpolateEntryAt = (dataEntry2, t) => {
   const localT = Math.max(Math.min(1, t), 0);
@@ -585,17 +543,14 @@ var getRelativeValue = (dataEntry2) => {
   }
 };
 export {
-  updateDataEntry2 as updateDataEntry,
-  parseUrl,
+  parseBase64ToBits,
   interpolateEntryAt,
-  getURLSafeBase64ForData,
-  getSemanticallyNestedValues,
+  getStateValue,
   getRelativeValue,
-  getFlatArray,
-  getDefaultObject,
+  getDataEntryArray,
+  getBase64String,
   createParserObject,
   SignificandMaxBits,
-  ObjectGenerationOutputStatus,
   IntegerMaxBits,
   DataType,
   DataEntryFactory

package/dist/objectmap/index.d.ts

@@ -1 +1,4 @@
-export * from './versionUserMethods';
+export * from './stateDataModel';
+export * from './userMethods';
+export * from './userMethods';
+export * from './stateValueHelperMethods';

package/dist/objectmap/stateDataModel.d.ts

@@ -0,0 +1,19 @@
+import { DataEntry, DataEntryArray, NestedContentType, SingleLevelContentType, DoubleLevelContentType, ArrayEntryDataType, EnumEntryDataType, OptionalEntryDataType, DataEntryParsingReturnType, DerivativeStateDataType, InternalStateDataGenerationMethod, StateDataGenerationMethod, StateDataType } from '../types';
+/**
+ * Helper method for finding an existing data entry in case there was a previous object
+ * @param dataEntry - new DataEntry
+ * @param dataEntryArray - existing DataEntryArray
+ */
+export declare const findExistingDataEntry: (dataEntry: DataEntry, dataEntryArray: DataEntryArray) => DataEntry | undefined;
+export declare const readDataEntry: (dataEntry: DataEntry, bitString: string) => DataEntryParsingReturnType;
+export declare const updateDataEntry: (dataEntry: DataEntry, existingData: DataEntryArray) => DataEntryParsingReturnType;
+export declare const internalGetDataEntry: (dataEntry: DataEntry, prefix: string, additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DataEntry]];
+export declare const getStateFromOptionalEntryDataType: (oedt: OptionalEntryDataType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
+export declare const getStateFromEnumEntryDataType: (eedt: EnumEntryDataType, prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, StateDataType]];
+export declare const getStateFromArrayEntryDataType: (aedt: ArrayEntryDataType, prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DerivativeStateDataType]];
+export declare const getStateDataFromDoubleLevelContentType: (dct: DoubleLevelContentType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
+export declare const getStateDateFromSingleLevelContentTypeArray: (slcta: SingleLevelContentType[], prefix: string, attributeName: string) => (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, StateDataType]];
+export declare const getStateDataFromNestedContentType: (nct: NestedContentType, prefix: string, attributeName: string) => InternalStateDataGenerationMethod;
+export declare const getStateDataFromSingleLevelContentType: (slct: SingleLevelContentType, prefix: string) => InternalStateDataGenerationMethod;
+export declare const getGenerationMethodForSingleLevelContentTypeArray: (slct: SingleLevelContentType[]) => StateDataGenerationMethod;
+export declare const testOnlyResetCurrentDataEntryIndex: () => number;

package/dist/objectmap/stateValueHelperMethods.d.ts

@@ -0,0 +1,13 @@
+import { DataEntryArray, NestedContentType, SingleLevelContentType } from '../types';
+import { StateDataType, StateValueType } from '../types/stateValueModel';
+export declare const getStateValue: (stateValue: StateDataType) => StateValueType;
+export declare const getDataEntryArray: (stateValue: StateDataType) => DataEntryArray;
+export declare const getBase64String: (stateValue: StateDataType) => string;
+export declare const isSingleLevelContentType: (data: NestedContentType) => boolean;
+export declare const isDoubleLevelContentType: (data: NestedContentType) => boolean;
+export declare const singleLevelContentTypeIsDataEntry: (data: SingleLevelContentType) => boolean;
+export declare const singleLevelContentTypeIsNestedContentDataType: (data: SingleLevelContentType) => boolean;
+export declare const doubleLevelContentTypeIsEnumEntryDataType: (data: NestedContentType) => boolean;
+export declare const doubleLevelContentTypeIsOptionalEntryDataType: (data: NestedContentType) => boolean;
+export declare const doubleLevelContentTypeIsArrayDefinitionType: (data: NestedContentType) => boolean;
+export declare const isDataEntry: (v: any) => boolean;

package/dist/objectmap/userMethods.d.ts

@@ -0,0 +1,12 @@
+import { EnumSemantics, VersionHandler, VersionContentDefinition } from '../types';
+/**
+ * Method to create version definition objects
+ * @param {VersionArrayDefinitionType[]} versionContent  - version definition array
+ * @param {number} maximumExpectedVersions - maximum expected versions to define
+ * @param {number} defaultVersion - number - optional, default it is the first,
+ * @param {EnumSemantics[] | EnumSemantics} enumSemanticsMapping - optional - UI semantics mapping for enums. If not given, values will be numbers
+ * @param {undefined | Record<string, string> | Record<string, string>[]} attributeSemanticsMapping - optional - UI semantics mapping, if nothing given no semantics will be mapped
+ * @param {number[]} exposedVersions?: number[] - optional - UI semantics, masks which objects to show and hide
+ * @returns ParsersForVersionObject
+ */
+export declare const createParserObject: (versionContent: VersionContentDefinition, maximumExpectedVersions: number, defaultVersion?: number, enumSemanticsMapping?: EnumSemantics | EnumSemantics[], attributeSemanticsMapping?: Record<string, string> | Record<string, string>[], exposedVersions?: number[]) => VersionHandler;

package/dist/parsers/parsers.d.ts

@@ -2,6 +2,7 @@ import { DataEntryArray, DataEntry } from '../types/dataEntry';
 export declare const valueBitsParser: (bitString: string, mapData: DataEntry) => number | boolean;
 export declare const dataBitsParser: (rawString: string, mapData: DataEntry) => DataEntry;
 export declare const getBitsCount: (mapData: DataEntry) => number;
+export declare const dataEntryBitstringParser: (bitstring: string, dataEntry: DataEntry) => [DataEntry, string];
 /**
  * Method to convert a bitstring into an array of data entries
  * @param bitString bitstring to parse into bits and then data entries

package/dist/types/arrayDefinitions.d.ts

@@ -1,10 +1,10 @@
-import { DataEntry, VersionDataEntry } from './dataEntry';
+import { DataEntry } from './dataEntry';
 export type SingleLevelContentType = DataEntry | NestedContentDataType;
 export type NestedContentDataType = [string, NestedContentType];
 export type NestedContentType = SingleLevelContentType[] | DoubleLevelContentType;
-export type DoubleLevelContentType = OptionalEntryDataType | EnumEntryDataType;
+export type DoubleLevelContentType = OptionalEntryDataType | EnumEntryDataType | ArrayEntryDataType;
 export type NonEmptyValidEntryArrayType = [SingleLevelContentType, ...SingleLevelContentType[]];
 export type OptionalEntryDataType = [boolean, NonEmptyValidEntryArrayType, []] | [boolean, [], NonEmptyValidEntryArrayType];
 export type EnumEntryDataType = [number, NonEmptyValidEntryArrayType, NonEmptyValidEntryArrayType, ...SingleLevelContentType[][]];
-export type VersionArrayDefinitionType = [VersionDataEntry, ...SingleLevelContentType[]];
-export declare const NAME_DELIMETER = "_";
+export type ArrayEntryDataType = [[number, number], NonEmptyValidEntryArrayType];
+export declare const PREFIX_SEPERATOR_DELIMETER = "_";

package/dist/types/index.d.ts

@@ -1,9 +1,9 @@
+export * from './arrayDefinitions';
 export * from './booleanData';
 export * from './dataEntry';
 export * from './enumData';
 export * from './floatData';
 export * from './intData';
-export * from './semanticlyNestedDataEntry';
+export * from './semanticMapping';
+export * from './stateValueModel';
 export * from './versionData';
-export * from './versionParser';
-export * from './arrayDefinitions';

package/dist/types/semanticMapping.d.ts

@@ -0,0 +1,6 @@
+export type EnumSemantics = {
+    [dataEntryName: string]: {
+        value: number;
+        label: string;
+    }[];
+};

package/dist/types/stateValueModel.d.ts

@@ -0,0 +1,33 @@
+import { SingleLevelContentType } from './arrayDefinitions';
+import { DataEntry, DataEntryArray } from './dataEntry';
+import { EnumSemantics } from './semanticMapping';
+export type StateDataType = {
+    [attribute: string]: DataEntry | StateDataType | DerivativeStateDataType;
+};
+export type DerivativeStateDataType = {
+    s: DataEntry;
+    v: StateDataType | StateDataType[];
+};
+export type StateValueType = {
+    [attribute: string]: boolean | number | string | StateValueType | DerivativeStateValueType;
+};
+export type DerivativeStateValueType = {
+    s: boolean | number | string;
+    v: StateValueType | StateValueType[];
+};
+export type StateDataGenerationMethod = (additionalData?: DataEntryArray | string) => StateDataType;
+export type DataEntryParsingReturnType = [DataEntryArray | string | undefined, [string, DataEntry]];
+export type InternalStateDataGenerationMethod = (additionalData?: DataEntryArray | string) => [DataEntryArray | string | undefined, [string, DataEntry | StateDataType | DerivativeStateDataType]];
+export type ExposedParserStateDataMethod = (additionalData?: StateDataType | DataEntryArray | string) => StateDataType;
+export type UpdateStateDataMethod = (state: StateDataType, entryToUpdate: DataEntry) => StateDataType;
+export type StringifyStateDataMethod = (data: StateDataType | DataEntryArray) => string;
+export type VersionContentDefinition = SingleLevelContentType[][];
+export type VersionHandler = {
+    versionBitCount: number;
+    exposedVersions?: number[];
+    enumSemanticsMapping?: EnumSemantics | EnumSemantics[];
+    attributeSemanticsMapping?: Record<string, string> | Record<string, string>[];
+    parser: ExposedParserStateDataMethod;
+    updater: UpdateStateDataMethod;
+    stringify: StringifyStateDataMethod;
+};

package/dist/types/versionData.d.ts

@@ -1,5 +1,6 @@
 import { DataType } from '../enums/dataTypes';
 export type VersionRangeType = 4 | 6 | 8 | 10;
+export declare const VersionRange: VersionRangeType[];
 export type VersionData = {
     type: DataType.VERSION;
     value: number;

package/package.json

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

package/dist/objectmap/versionArrayDefinitionToObjectDefintion.d.ts

@@ -1,14 +0,0 @@
-import { DataEntry, DefinitionNestedArray, DefinitionNestedGenerationObject, DefinitionSubObject, VersionDefinitionObject } from '../types';
-import { EnumEntryDataType, OptionalEntryDataType, NestedContentType, NestedContentDataType, SingleLevelContentType, VersionArrayDefinitionType } from '../types/arrayDefinitions';
-export declare const isSingleLevelContentType: (data: NestedContentType) => boolean;
-export declare const isDoubleLevelContentType: (data: NestedContentType) => boolean;
-export declare const singleLevelContentTypeIsDataEntry: (data: SingleLevelContentType) => boolean;
-export declare const singleLevelContentTypeIsNestedContentDataType: (data: SingleLevelContentType) => boolean;
-export declare const singleLevelContentTypeIsEnumEntryDataType: (data: NestedContentType) => boolean;
-export declare const singleLevelContentTypeIsOptionalEntryDataType: (data: NestedContentType) => boolean;
-export declare const parseSingleLevelContentTypeToDefinitionSubObject: (data: SingleLevelContentType, internalPrecedingName?: string) => DefinitionSubObject;
-export declare const parseNestedContentDataTypeToDefinitionNestedArray: (data: NestedContentDataType, internalPrecedingName?: string) => DefinitionNestedArray | DefinitionNestedGenerationObject;
-export declare const parseEnumEntryDataTypeToDefinitionNestedGenerationObject: (data: EnumEntryDataType, name: string, internalPrecedingName?: string) => DefinitionNestedGenerationObject;
-export declare const parseOptionalEntryDataTypeToDefinitionNestedGenerationObject: (data: OptionalEntryDataType, name: string, internalPrecedingName?: string) => DefinitionNestedGenerationObject;
-export declare const parseDataEntry: (d: DataEntry, internalPrecedingName?: string) => DataEntry;
-export declare const parseVersionArrayDefinitionTypeToVersionDefinitionObject: (v: VersionArrayDefinitionType, optionalIndexOverwrite?: number) => VersionDefinitionObject;

package/dist/objectmap/versionReading.d.ts

@@ -1,36 +0,0 @@
-import { DataEntry } from '../types/dataEntry';
-import { SemanticlyNestedDataEntry } from '../types/semanticlyNestedDataEntry';
-import { DefinitionArrayObject, ParsersForVersionObject } from '../types/versionParser';
-/**
- * Method for finding the names of the variable data entries in the DefinitionArrayObject
- * @param definitionArrayObject - DefinitionArrayObject
- * @returns string[] - the key strings
- */
-export declare const getVariableStrings: (definitionArrayObject: DefinitionArrayObject) => string[];
-/**
- * Method that translates a DefinitionArrayObject into a SemanticlyNestedDataEntry
- * @param definitionArrayObject [DataEntry | [string, DefinitionArrayObject]]
- * @returns
- */
-export declare const nestedDataEntryArrayToObject: (definitionArrayObject: DefinitionArrayObject) => SemanticlyNestedDataEntry;
-/**
- * Method to parse a url into a SemanticlyNestedDataEntry.
- * @param url - the url to parse
- * @param parserVersions - the object containing the version parsers
- * @returns the parsed SemanticlyNestedDataEntry
- */
-export declare const parseUrlMethod: (url: string, parserVersions: ParsersForVersionObject) => SemanticlyNestedDataEntry;
-export declare const parseDownNestedDataDescription: (nestedDataDescription: SemanticlyNestedDataEntry) => DataEntry[];
-/**
- * Method to get an URL descriptor from a SemanticlyNestedDataEntry
- * @param data: SemanticlyNestedDataEntry
- * @returns base64 string
- */
-export declare const getURLForData: (data: SemanticlyNestedDataEntry) => string;
-export declare const getTestStringValues: (data: SemanticlyNestedDataEntry) => {
-    bitsString: string;
-    base64BitString: string;
-    base64SplitString: string;
-    base64String: string;
-    raw: string;
-};

package/dist/objectmap/versionUpdate.d.ts

@@ -1,26 +0,0 @@
-import { DataEntry, DataEntryArray } from '../types/dataEntry';
-import { SemanticlyNestedDataEntry } from '../types/semanticlyNestedDataEntry';
-import { DefinitionArrayObject, ParserForVersion, ParsersForVersionObject } from '../types/versionParser';
-/**
- * Method to parse a definitionArrayObject according to a given dataArray
- * @param definitionArrayObject
- * @param dataArray
- * @returns - new SemanticlyNestedDataEntry
- */
-export declare const updateDataEntryObject: (definitionArrayObject: DefinitionArrayObject, dataArray: DataEntryArray) => SemanticlyNestedDataEntry;
-/**
- * Get the default object for a given version
- * @param versionParser - The parsers for all versions
- * @param versionindex - The index of the version for which to get the default object
- * @returns - The default object for the given version
- * @throws - Error if no parser for the given version index
- */
-export declare const getDefaultObject: (versionParser: ParsersForVersionObject, versionindex: number) => SemanticlyNestedDataEntry;
-/**
- * Method that handles the updating of a single value in a SemanticlyNestedDataEntry object
- * @param data SemanticlyNestedDataEntry
- * @param newDataEntry updated DataEntry
- * @param parsersForVersion version object
- * @returns a newly created object in case of a key data description, otherwise the same object with just the new Data Entry value updated
- */
-export declare const updateDataEntry: (data: SemanticlyNestedDataEntry, newDataEntry: DataEntry, parsersForVersion: ParserForVersion[]) => SemanticlyNestedDataEntry;

package/dist/objectmap/versionUserMethods.d.ts

@@ -1,56 +0,0 @@
-import { VersionArrayDefinitionType, VersionRangeType, VersionEnumSemantics, ParsersForVersionObject, SemanticlyNestedDataEntry, DataEntry, SemanticlyNestedValues, DataEntryArray } from '../types';
-/**
- * Method to create version definition objects
- * @param {VersionArrayDefinitionType[]} versionArray  - version definition array
- * @param {VersionRangeType} versionBitCount - bit count
- * @param {VersionEnumSemantics[] | VersionEnumSemantics} enumSemanticsMapping - optional semantics mapping for enums. If not given, values will be numbers
- * @param {undefined | Record<string, string> | Record<string, string>[]} attributeSemanticsMapping - optional semantics mapping, if nothing given no semantics will be mapped
- * @returns ParsersForVersionObject
- */
-export declare const createParserObject: (versionArray: VersionArrayDefinitionType[], versionBitCount: VersionRangeType, enumSemanticsMapping?: VersionEnumSemantics[] | VersionEnumSemantics, attributeSemanticsMapping?: Record<string, string>[] | Record<string, string>) => ParsersForVersionObject;
-/** the data object needs to be accesible in 3 versions.
- *
- * 1. As a semanticly nested object (primary data structure, also used for UI)
- * 2. As an array of entries (derived from semanticly nested object, to translate and from to bitstream)
- * 3. As an object with all the data entry information stripped (derived from semanticly nested object, read only)
- */
-/**
- * Construct SemanticlyNestedDataEntry
- * @param urlSafeBase64 - the url to parse
- * @param parserVersions - the object containing the version parsers
- * @returns the parsed SemanticlyNestedDataEntry
- */
-export declare const parseUrl: (urlSafeBase64: string, parserVersions: ParsersForVersionObject) => SemanticlyNestedDataEntry;
-/**
- * Update a data entry in a SemanticlyNestedDataEntry
- * @param {DataEntry} updatedEntry - the updated data entry
- * @param {SemanticlyNestedDataEntry} currentObject - the current Data Object
- * @param {ParsersForVersionObject} parserVersions - the object containing the version parsers
- * @returns {SemanticlyNestedDataEntry} - the updated SemanticlyNestedDataEntry
- */
-export declare const updateDataEntry: (updatedEntry: DataEntry, currentObject: SemanticlyNestedDataEntry, parserVersions: ParsersForVersionObject) => SemanticlyNestedDataEntry;
-/**
- * Method to get the URLSafeBase64 representation of a SemanticlyNestedDataEntry
- * @param {SemanticlyNestedDataEntry} data - the data object
- * @returns {string} - the urlSafeBase64 representation
- */
-export declare const getURLSafeBase64ForData: (data: SemanticlyNestedDataEntry) => string;
-/**
- * Method for getting the basic object for a given semanticly nested data entry
- * @param {SemanticlyNestedDataEntry} data - the data object
- * @returns {SemanticlyNestedDataEntry} - the basic object
- */
-export declare const getSemanticallyNestedValues: (data: SemanticlyNestedDataEntry, parserVersions: ParsersForVersionObject) => SemanticlyNestedValues;
-/**
- * Method to get the default object for a given version
- * @param {ParsersForVersionObject} parserForVersions - the object containing the version parsers
- * @param {number} versionindex - number of the version you want to generate the default object for
- * @returns SemanticlyNestedDataEntry
- */
-export declare const getDefaultObject: (parserForVersions: ParsersForVersionObject, versionindex: number) => SemanticlyNestedDataEntry;
-/**
- * Method to get the get a (sorted by index) flat array of a SemanticallyNestedDataEntry
- * @param {SemanticlyNestedDataEntry} data - the semanticly nested data entry to flatten
- * @returns DataEntryArray
- */
-export declare const getFlatArray: (data: SemanticlyNestedDataEntry) => DataEntryArray;

package/dist/test/arrayDefinition.example.d.ts

@@ -1,14 +0,0 @@
-import { ParsersForVersionObject } from '../types';
-import { NestedContentDataType, OptionalEntryDataType, EnumEntryDataType, VersionArrayDefinitionType, NestedContentType } from '../types/arrayDefinitions';
-export declare const nestedContentDataType: NestedContentDataType;
-export declare const validOptionalEntryType: OptionalEntryDataType;
-export declare const anotherValidOptionalEntryType: OptionalEntryDataType;
-export declare const validEnumEntryType: EnumEntryDataType;
-export declare const generalNestedContentDataType: NestedContentDataType;
-export declare const exampleVersion: VersionArrayDefinitionType;
-export declare const lucernaeTuricumArcExamples: EnumEntryDataType;
-export declare const footprintDefinition: EnumEntryDataType;
-export declare const heightParsingDefinition: NestedContentType;
-export declare const shapePreProcessingDefinition: EnumEntryDataType;
-export declare const lucernaeTurici: VersionArrayDefinitionType;
-export declare const lucernaeTuriciVersions: ParsersForVersionObject;

package/dist/test/boolean.test.d.ts

@@ -1 +0,0 @@
-export declare const values: [boolean, string][];

package/dist/test/dataParser.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/enum.test.d.ts

@@ -1 +0,0 @@
-export declare const values: [number, number, string][];

package/dist/test/float.test.d.ts

@@ -1,2 +0,0 @@
-import { PrecisionRangeType } from '../types';
-export declare const values: [number, number, number, PrecisionRangeType, string][];

package/dist/test/int.test.d.ts

@@ -1 +0,0 @@
-export declare const values: [number, number, number, string][];

package/dist/test/parsingArrayDefinition.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/realLifeExample.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/updating.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/version.test.d.ts

@@ -1,2 +0,0 @@
-import { VersionRangeType } from '../types';
-export declare const values: [number, VersionRangeType, string][];

package/dist/types/semanticlyNestedDataEntry.d.ts

@@ -1,7 +0,0 @@
-import { DataEntry } from './dataEntry';
-export type SemanticlyNestedDataEntry = {
-    [key: string]: SemanticlyNestedDataEntry | DataEntry;
-};
-export type SemanticlyNestedValues = {
-    [key: string]: SemanticlyNestedValues | boolean | number | string;
-};

package/dist/types/versionParser.d.ts

@@ -1,32 +0,0 @@
-import { ObjectGenerationOutputStatus } from '../enums/objectGenerationTypes';
-import { DataEntry, VersionDataEntry } from './dataEntry';
-import { SemanticlyNestedDataEntry } from './semanticlyNestedDataEntry';
-import { VersionRangeType } from './versionData';
-/**
- * A method that generates a nested object based on a set of values
- * @param s - url bit string (optional)
- * @param v - The values to be used to generate the object, can be either a valid value for a dataentry, a bitstring (only 0 or 1 chars) or undefined (default value)
- * @returns [The generated object, the generation status, the index end bit of the bit url (-1 if)]
- */
-export type ObjectGeneratorMethod = (s?: string, ...v: (DataEntry | undefined)[]) => [SemanticlyNestedDataEntry, ObjectGenerationOutputStatus, number];
-export type DefinitionGenerationObject = (v: DataEntry) => DefinitionArrayObject;
-export type DefinitionNestedArray = [string, DefinitionArrayObject];
-export type DefinitionNestedGenerationObject = [string, DataEntry, DefinitionGenerationObject];
-export type DefinitionSubObject = DataEntry | DefinitionNestedArray | DefinitionNestedGenerationObject;
-export type DefinitionArrayObject = DefinitionSubObject[];
-export type VersionDefinitionObject = [VersionDataEntry, ...DefinitionArrayObject];
-export type VersionEnumSemantics = {
-    [key: string]: {
-        value: number;
-        label: string;
-    }[];
-};
-export type ParserForVersion = {
-    enumSemanticsMapping?: VersionEnumSemantics;
-    attributeSemanticsMapping?: Record<string, string>;
-    objectGeneratorParameters: VersionDefinitionObject;
-};
-export type ParsersForVersionObject = {
-    versionBitCount: VersionRangeType;
-    parsers: ParserForVersion[];
-};