densing 0.1.0

package/dist/index.js

@@ -0,0 +1,870 @@
+// src/schema/builder.ts
+var bool = (name, defaultValue = false) => ({
+  type: "bool",
+  name,
+  defaultValue
+});
+var int = (name, min, max, defaultValue) => {
+  if (max < min)
+    throw new Error(`int "${name}": max < min`);
+  return { type: "int", name, min, max, defaultValue: defaultValue ?? min };
+};
+var enumeration = (name, options, defaultValue) => {
+  if (options.length < 2)
+    throw new Error(`enum "${name}": must have at least 2 values`);
+  if (new Set(options).size !== options.length)
+    throw new Error(`enum "${name}": duplicate values`);
+  return { type: "enum", name, options, defaultValue: defaultValue ?? options[0] };
+};
+var fixed = (name, min, max, precision, defaultValue) => {
+  if (precision <= 0) {
+    throw new Error(`fixed "${name}": precision must be > 0`);
+  }
+  const scale = 1 / precision;
+  if (!Number.isInteger(scale)) {
+    throw new Error(`fixed "${name}": 1 / precision must be an integer`);
+  }
+  if (max < min) {
+    throw new Error(`fixed "${name}": max < min`);
+  }
+  return { type: "fixed", name, min, max, precision, defaultValue: defaultValue ?? min };
+};
+var minMaxValidation = (type, name, minLength, maxLength) => {
+  if (!Number.isInteger(minLength) || minLength < 0)
+    throw new Error(`fixedArray ${type} "${name}": minLength (${minLength}) must be a positive integer`);
+  if (!Number.isInteger(maxLength) || maxLength <= 0)
+    throw new Error(`fixedArray ${type} "${name}": maxLength (${maxLength}) must be a positive integer`);
+  if (maxLength < minLength)
+    throw new Error(`fixedArray ${type} "${name}": maxLength (${maxLength}) must be larger than minLength (${minLength})`);
+};
+var array = (name, minLength, maxLength, items) => {
+  minMaxValidation("array", name, minLength, maxLength);
+  return {
+    type: "array",
+    name,
+    minLength,
+    maxLength,
+    items
+  };
+};
+var discriminatorValidation = (name, discriminator, variants) => {
+  for (const value of discriminator.options)
+    if (!variants[value])
+      throw new Error(`union "${name}": missing variant definition for "${value}"`);
+};
+var union = (name, discriminator, variants) => {
+  discriminatorValidation(name, discriminator, variants);
+  return {
+    type: "union",
+    name,
+    discriminator,
+    variants
+  };
+};
+var enumArray = (name, enumDef, minLength, maxLength, defaultValue) => {
+  minMaxValidation("enum_array", name, minLength, maxLength);
+  return {
+    type: "enum_array",
+    name,
+    enum: enumDef,
+    minLength,
+    maxLength,
+    defaultValue: defaultValue ?? []
+  };
+};
+var optional = (name, field, defaultValue) => {
+  return {
+    type: "optional",
+    name,
+    field,
+    defaultValue
+  };
+};
+var object = (name, ...fields) => {
+  return {
+    type: "object",
+    name,
+    fields
+  };
+};
+var schema = (...fields) => ({
+  fields
+});
+// src/schema/default-data.ts
+var getDefaultData = (schema2) => {
+  const result = {};
+  schema2.fields.forEach((field) => {
+    result[field.name] = getDefaultValueForField(field);
+  });
+  return result;
+};
+var getDefaultValueForField = (field) => {
+  switch (field.type) {
+    case "bool":
+    case "int":
+    case "enum":
+    case "fixed":
+    case "enum_array":
+      return field.defaultValue;
+    case "optional":
+      return field.defaultValue !== undefined ? field.defaultValue : null;
+    case "array":
+      return Array.from({ length: field.minLength }, () => getDefaultValueForField(field.items));
+    case "object":
+      return Object.fromEntries(field.fields.map((f) => [f.name, getDefaultValueForField(f)]));
+    case "union": {
+      const defaultDiscriminatorValue = field.discriminator.defaultValue;
+      const result = {
+        [field.discriminator.name]: defaultDiscriminatorValue
+      };
+      const variantFields = field.variants[defaultDiscriminatorValue];
+      if (variantFields) {
+        variantFields.forEach((variantField) => {
+          result[variantField.name] = getDefaultValueForField(variantField);
+        });
+      }
+      return result;
+    }
+  }
+};
+// src/schema/recursive-builder-helper.ts
+var createRecursiveUnion = (name, discriminatorOptions, createVariants, maxDepth, currentDepth = 0) => {
+  if (currentDepth >= maxDepth) {
+    const terminalVariants = createVariants((fieldName) => {
+      return union(fieldName, enumeration("type", ["end", "dummy"]), {
+        end: [],
+        dummy: []
+      });
+    });
+    return union(name, enumeration("type", discriminatorOptions), terminalVariants);
+  }
+  const recursiveVariants = createVariants((fieldName, depth = currentDepth + 1) => {
+    return createRecursiveUnion(fieldName, discriminatorOptions, createVariants, maxDepth, depth);
+  });
+  return union(name, enumeration("type", discriminatorOptions), recursiveVariants);
+};
+// src/schema/type-generator.ts
+import { writeFileSync } from "fs";
+import { resolve } from "path";
+var generateTypes = (schema2, rootTypeName = "SchemaData") => {
+  const types = [];
+  const processedTypes = new Set;
+  const rootFields = schema2.fields.map((field) => {
+    const fieldType = getFieldType(field, types, processedTypes);
+    return `  ${field.name}: ${fieldType};`;
+  }).join(`
+`);
+  const rootType = `export interface ${rootTypeName} {
+${rootFields}
+}`;
+  return [...types, rootType].join(`
+
+`);
+};
+var generateTypesFile = (schema2, outputPath, rootTypeName = "SchemaData") => {
+  const types = generateTypes(schema2, rootTypeName);
+  const fullPath = resolve(outputPath);
+  writeFileSync(fullPath, types, "utf-8");
+  console.log(`Types written to: ${fullPath}`);
+};
+var getFieldType = (field, types, processedTypes) => {
+  switch (field.type) {
+    case "bool":
+      return "boolean";
+    case "int":
+    case "fixed":
+      return "number";
+    case "enum":
+      return field.options.map((opt) => `'${opt}'`).join(" | ");
+    case "enum_array":
+      return `(${field.enum.options.map((opt) => `'${opt}'`).join(" | ")})[]`;
+    case "array": {
+      const itemType = getFieldType(field.items, types, processedTypes);
+      return `${itemType}[]`;
+    }
+    case "optional": {
+      const innerType = getFieldType(field.field, types, processedTypes);
+      return `${innerType} | null`;
+    }
+    case "object": {
+      const typeName = capitalize(field.name);
+      if (!processedTypes.has(typeName)) {
+        processedTypes.add(typeName);
+        const objectFields = field.fields.map((f) => {
+          const fieldType = getFieldType(f, types, processedTypes);
+          return `  ${f.name}: ${fieldType};`;
+        }).join(`
+`);
+        types.push(`export interface ${typeName} {
+${objectFields}
+}`);
+      }
+      return typeName;
+    }
+    case "union": {
+      const typeName = capitalize(field.name);
+      if (!processedTypes.has(typeName)) {
+        processedTypes.add(typeName);
+        const options = field.discriminator.options;
+        const variants = options.map((option) => {
+          const variantTypeName = `${typeName}_${capitalize(option)}`;
+          const variantFields = field.variants[option] || [];
+          const fields = [
+            `  ${field.discriminator.name}: '${option}';`,
+            ...variantFields.map((f) => {
+              const fieldType = getFieldType(f, types, processedTypes);
+              return `  ${f.name}: ${fieldType};`;
+            })
+          ].join(`
+`);
+          types.push(`export interface ${variantTypeName} {
+${fields}
+}`);
+          return variantTypeName;
+        });
+        types.push(`export type ${typeName} = ${variants.join(" | ")};`);
+      }
+      return typeName;
+    }
+    default:
+      return "unknown";
+  }
+};
+var capitalize = (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var printTypes = (schema2, rootTypeName = "SchemaData") => {
+  console.log(generateTypes(schema2, rootTypeName));
+};
+// src/schema/validation.ts
+var validate = (schema2, data) => {
+  const errors = [];
+  for (const field of schema2.fields) {
+    validateField(field, data[field.name], field.name, errors);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+var validateField = (field, value, path, errors) => {
+  if (field.type === "optional") {
+    if (value === undefined || value === null) {
+      return;
+    }
+    validateField(field.field, value, path, errors);
+    return;
+  }
+  if (value === undefined) {
+    errors.push({
+      path,
+      message: "missing value"
+    });
+    return;
+  }
+  switch (field.type) {
+    case "bool":
+      if (typeof value !== "boolean") {
+        errors.push({ path, message: "expected boolean" });
+      }
+      return;
+    case "int":
+      if (!Number.isInteger(value)) {
+        errors.push({ path, message: "expected integer" });
+        return;
+      }
+      if (value < field.min || value > field.max) {
+        errors.push({
+          path,
+          message: `value ${value} out of range [${field.min}, ${field.max}]`
+        });
+      }
+      return;
+    case "fixed": {
+      if (typeof value !== "number") {
+        errors.push({ path, message: "expected number" });
+        return;
+      }
+      const scale = 1 / field.precision;
+      const scaled = (value - field.min) * scale;
+      if (value < field.min || value > field.max) {
+        errors.push({
+          path,
+          message: `value ${value} out of range [${field.min}, ${field.max}]`
+        });
+      } else if (!Number.isInteger(Math.round(scaled))) {
+        errors.push({
+          path,
+          message: `value ${value} does not align with precision ${field.precision}`
+        });
+      }
+      return;
+    }
+    case "enum":
+      if (typeof value !== "string") {
+        errors.push({ path, message: "expected string for enum value" });
+        return;
+      }
+      if (!field.options.includes(value)) {
+        const optionsStr = field.options.join(", ");
+        errors.push({
+          path,
+          message: `invalid enum value ${value}, expected one of [${optionsStr}]`
+        });
+      }
+      return;
+    case "array":
+      if (!Array.isArray(value)) {
+        errors.push({ path, message: "expected array" });
+        return;
+      }
+      if (value.length < field.minLength) {
+        errors.push({
+          path,
+          message: `array length ${value.length} is less than minLength ${field.minLength}`
+        });
+      }
+      if (value.length > field.maxLength) {
+        errors.push({
+          path,
+          message: `array length ${value.length} exceeds maxLength ${field.maxLength}`
+        });
+      }
+      value.forEach((item, i) => validateField(field.items, item, `${path}[${i}]`, errors));
+      return;
+    case "union": {
+      if (typeof value !== "object" || value === null) {
+        errors.push({ path, message: "expected object" });
+        return;
+      }
+      const discName = field.discriminator.name;
+      const discValue = value[discName];
+      if (typeof discValue !== "string" || !field.discriminator.options.includes(discValue)) {
+        errors.push({
+          path: `${path}.${discName}`,
+          message: `invalid discriminator "${discValue}", expected one of [${field.discriminator.options.join(", ")}]`
+        });
+        return;
+      }
+      const variantFields = field.variants[discValue];
+      if (!variantFields) {
+        errors.push({
+          path: `${path}.${discName}`,
+          message: `no variant definition for discriminator "${discValue}"`
+        });
+        return;
+      }
+      for (const f of variantFields) {
+        validateField(f, value[f.name], `${path}.${f.name}`, errors);
+      }
+      return;
+    }
+    case "enum_array":
+      if (!Array.isArray(value)) {
+        errors.push({ path, message: "expected an array" });
+        return;
+      }
+      if (value.length < field.minLength) {
+        errors.push({
+          path,
+          message: `array length ${value.length} is less than minLength ${field.minLength}`
+        });
+      }
+      if (value.length > field.maxLength) {
+        errors.push({
+          path,
+          message: `array length ${value.length} exceeds maxLength ${field.maxLength}`
+        });
+      }
+      value.forEach((v, i) => {
+        if (typeof v !== "string" || !field.enum.options.includes(v)) {
+          const optionsStr = field.enum.options.join(", ");
+          errors.push({
+            path: `${path}[${i}]`,
+            message: `invalid enum value ${v}, expected one of [${optionsStr}]`
+          });
+        }
+      });
+      return;
+    case "object": {
+      if (typeof value !== "object" || value === null) {
+        errors.push({ path, message: "expected object" });
+        return;
+      }
+      for (const f of field.fields) {
+        validateField(f, value[f.name], `${path}.${f.name}`, errors);
+      }
+      return;
+    }
+  }
+};
+// src/helpers.ts
+var BaseTypes = ["base64url", "baseQRCode45UrlSafe", "binary"];
+var base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var baseQRCode45UrlSafe = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-.";
+var binary = "01";
+var baseCharTypes = {
+  base64url,
+  baseQRCode45UrlSafe,
+  binary
+};
+var getMinRequiredCharsForBase = (bitWidth, baseChars) => Math.ceil(bitWidth / Math.log2(baseChars.length));
+var getMaxBitWidthForBase = (baseString, baseChars) => Math.floor(baseString.length * Math.log2(baseChars.length));
+var getBaseStringFromBigInt = (bigInt, baseChars, bitWidth) => {
+  const minChars = bitWidth ? getMinRequiredCharsForBase(bitWidth, baseChars) : 0;
+  const maxBits = Math.floor(minChars * Math.log2(baseChars.length));
+  let adjustedBigInt = bigInt;
+  if (bitWidth && maxBits > bitWidth)
+    adjustedBigInt = bigInt << BigInt(maxBits - bitWidth);
+  const base = BigInt(baseChars.length);
+  const acc = [];
+  while (adjustedBigInt > 0)
+    acc.push(Number(adjustedBigInt % base)), adjustedBigInt = adjustedBigInt / base;
+  while (minChars > 0 && acc.length < minChars)
+    acc.push(0);
+  return acc.reverse().map((n) => baseChars.charAt(n)).join("");
+};
+var getCharsForBase = (base) => BaseTypes.includes(base) ? baseCharTypes[base] : base;
+var getBigIntFromBaseString = (baseString, baseChars) => {
+  const base = BigInt(baseChars.length);
+  return baseString.split("").map((c) => baseChars.indexOf(c)).reduce((acc, n) => acc * base + BigInt(n), 0n);
+};
+var getBigIntFromBase64 = (base64) => getBigIntFromBaseString(base64, base64url);
+var getBase64FromBigInt = (bigInt, bitWidth) => getBaseStringFromBigInt(bigInt, base64url, bitWidth);
+var getbaseQRCode45UrlSafeFromBigInt = (bigInt, bitWidth) => getBaseStringFromBigInt(bigInt, baseQRCode45UrlSafe, bitWidth);
+var getBigIntFrombaseQRCode45UrlSafe = (baseQRCode45UrlSafe2) => getBigIntFromBaseString(baseQRCode45UrlSafe2, baseQRCode45UrlSafe2);
+
+class BitWriter {
+  buffer;
+  bitsWritten;
+  constructor() {
+    this.buffer = 0n;
+    this.bitsWritten = 0;
+  }
+  writeUInt = (value, bitWidth) => {
+    if (bitWidth <= 0)
+      return;
+    const bw = BigInt(bitWidth);
+    const v = BigInt(value);
+    const masked = v & (1n << bw) - 1n;
+    this.buffer = this.buffer << bw | masked;
+    this.bitsWritten += bitWidth;
+  };
+  getBigInt = () => this.buffer;
+  getBitLength = () => Number(this.bitsWritten);
+  getFromBase = (base = "base64url") => getBaseStringFromBigInt(this.buffer, getCharsForBase(base), this.bitsWritten);
+}
+
+class BitReader {
+  buffer;
+  bitsLeft;
+  constructor(bigInt, totalBits) {
+    this.buffer = bigInt;
+    this.bitsLeft = totalBits;
+  }
+  readUInt = (bitWidth) => {
+    if (bitWidth === 0)
+      return 0;
+    if (bitWidth > 32)
+      throw new Error("Cannot read more than 32 bits into a UInt at a time");
+    return Number(this.readUBigInt(bitWidth));
+  };
+  readUBigInt = (bitWidth) => {
+    if (bitWidth === 0)
+      return 0n;
+    if (bitWidth > this.bitsLeft)
+      throw new Error(`Not enough bits left (${this.bitsLeft}) when trying to get ${bitWidth}`);
+    this.bitsLeft -= bitWidth;
+    const shift = BigInt(this.bitsLeft);
+    const bw = BigInt(bitWidth);
+    const mask = (1n << bw) - 1n;
+    const value = this.buffer >> shift & mask;
+    return value;
+  };
+  static getFromBase = (baseString, base) => new BitReader(getBigIntFromBaseString(baseString, getCharsForBase(base)), getMaxBitWidthForBase(baseString, getCharsForBase(base)));
+}
+
+// src/densing.ts
+var bitsForRange = (range) => range <= 1 ? 0 : Math.ceil(Math.log2(range));
+var scaleForPrecision = (precision) => Math.round(1 / precision);
+var bitsForInt = (min, max) => bitsForRange(Math.round(max - min) + 1);
+var bitsForFixed = (min, max, precision) => bitsForRange(Math.round((max - min) * scaleForPrecision(precision)) + 1);
+var uIntForRange = (value) => Math.round(value);
+var uIntForInt = (value, min) => uIntForRange(value - min);
+var uIntForFixed = (value, min, precision) => uIntForRange((value - min) * scaleForPrecision(precision));
+var intFromUint = (uInt, min) => uIntForRange(uInt) + min;
+var fixedFromUint = (uInt, min, precision) => uIntForRange(uInt) * precision + min;
+var bitsForMinMaxLength = (minLength, maxLength) => bitsForRange(maxLength - minLength + 1);
+var uIntForMinMaxLength = (value, minLength) => value - minLength;
+var lengthForUIntMinMaxLength = (uInt, minLength) => uInt + minLength;
+var bitsForEnumArrayContent = (length, base) => length < 1 ? 0 : Math.ceil(length * Math.log2(base));
+var bitsForOptions = (options) => bitsForRange(options.length);
+var sizeForOptions = (options) => options.length;
+var densing = (denseSchema, data, base = "base64url") => {
+  const w = new BitWriter;
+  denseSchema.fields.forEach((f) => densingField(w, f, data[f.name]));
+  return w.getFromBase(base);
+};
+var getUIntForConstantBitWidthField = (field, value) => {
+  switch (field.type) {
+    case "bool":
+      return value ? 1 : 0;
+    case "int":
+      return uIntForInt(value, field.min);
+    case "enum":
+      return field.options.indexOf(value);
+    case "fixed":
+      return uIntForFixed(value, field.min, field.precision);
+  }
+};
+var getBitWidthForContantBitWidthFields = (field) => {
+  switch (field.type) {
+    case "bool":
+      return 1;
+    case "int":
+      return bitsForInt(field.min, field.max);
+    case "enum":
+      return bitsForOptions(field.options);
+    case "fixed":
+      return bitsForFixed(field.min, field.max, field.precision);
+  }
+};
+var densingField = (w, field, value) => {
+  switch (field.type) {
+    case "bool":
+    case "int":
+    case "enum":
+    case "fixed":
+      w.writeUInt(getUIntForConstantBitWidthField(field, value), getBitWidthForContantBitWidthFields(field));
+      break;
+    case "array": {
+      if (!Array.isArray(value))
+        throw new Error("value of `array` is not an array");
+      const arrayLengthBits = bitsForMinMaxLength(field.minLength, field.maxLength);
+      if (arrayLengthBits !== 0)
+        w.writeUInt(uIntForMinMaxLength(value.length, field.minLength), arrayLengthBits);
+      value.forEach((v) => densingField(w, field.items, v));
+      break;
+    }
+    case "union": {
+      const discValue = value[field.discriminator.name];
+      const discIdx = field.discriminator.options.indexOf(discValue);
+      if (discIdx === -1)
+        throw new Error(`Invalid union discriminator value: ${discValue}`);
+      w.writeUInt(discIdx, bitsForOptions(field.discriminator.options));
+      field.variants[discValue].forEach((f) => densingField(w, f, value[f.name]));
+      break;
+    }
+    case "enum_array": {
+      if (!Array.isArray(value))
+        throw new Error("value of `enum_array` is not an array");
+      const arrayLengthBits = bitsForMinMaxLength(field.minLength, field.maxLength);
+      if (arrayLengthBits !== 0)
+        w.writeUInt(uIntForMinMaxLength(value.length, field.minLength), arrayLengthBits);
+      const base = BigInt(sizeForOptions(field.enum.options));
+      const result = value.reduce((acc, c) => {
+        const idx = field.enum.options.indexOf(c);
+        if (idx === -1)
+          throw new Error(`Invalid enum value in array: ${c}`);
+        return acc * base + BigInt(idx);
+      }, 0n);
+      const contentBits = bitsForEnumArrayContent(value.length, sizeForOptions(field.enum.options));
+      w.writeUInt(result, contentBits);
+      break;
+    }
+    case "optional": {
+      const isPresent = value !== undefined && value !== null;
+      w.writeUInt(isPresent ? 1 : 0, 1);
+      if (isPresent) {
+        densingField(w, field.field, value);
+      }
+      break;
+    }
+    case "object": {
+      if (typeof value !== "object" || value === null)
+        throw new Error("value of `object` is not an object");
+      field.fields.forEach((f) => densingField(w, f, value[f.name]));
+      break;
+    }
+  }
+};
+var undensing = (denseSchema, baseString, base = "base64url") => {
+  const r = BitReader.getFromBase(baseString, base);
+  const obj = {};
+  denseSchema.fields.forEach((f) => obj[f.name] = undensingField(r, f));
+  return obj;
+};
+var undensingDataForConstantBitWidthField = (field, unsignedInt) => {
+  switch (field.type) {
+    case "bool":
+      return Boolean(unsignedInt);
+    case "int":
+      return intFromUint(unsignedInt, field.min);
+    case "enum":
+      return field.options[unsignedInt];
+    case "fixed":
+      return fixedFromUint(unsignedInt, field.min, field.precision);
+  }
+};
+var undensingField = (r, denseField) => {
+  switch (denseField.type) {
+    case "bool":
+    case "int":
+    case "enum":
+    case "fixed":
+      return undensingDataForConstantBitWidthField(denseField, r.readUInt(getBitWidthForContantBitWidthFields(denseField)));
+    case "array": {
+      const length2 = lengthForUIntMinMaxLength(r.readUInt(bitsForMinMaxLength(denseField.minLength, denseField.maxLength)), denseField.minLength);
+      return Array.from({ length: length2 }, () => undensingField(r, denseField.items));
+    }
+    case "union": {
+      const idx = r.readUInt(bitsForOptions(denseField.discriminator.options));
+      const key = denseField.discriminator.options[idx];
+      const obj = { [denseField.discriminator.name]: key };
+      denseField.variants[key].forEach((f) => obj[f.name] = undensingField(r, f));
+      return obj;
+    }
+    case "enum_array":
+      const base = BigInt(sizeForOptions(denseField.enum.options));
+      const arrayLengthBits = bitsForMinMaxLength(denseField.minLength, denseField.maxLength);
+      const length = lengthForUIntMinMaxLength(r.readUInt(arrayLengthBits), denseField.minLength);
+      const contentBits = bitsForEnumArrayContent(length, sizeForOptions(denseField.enum.options));
+      let bigIntValue = r.readUBigInt(contentBits);
+      const result = [];
+      for (let i = 0;i < length; i++) {
+        const idx = Number(bigIntValue % base);
+        result.unshift(denseField.enum.options[idx]);
+        bigIntValue = bigIntValue / base;
+      }
+      return result;
+    case "optional":
+      return Boolean(r.readUInt(1)) ? undensingField(r, denseField.field) : denseField.defaultValue !== undefined ? denseField.defaultValue : null;
+    case "object":
+      return Object.fromEntries(denseField.fields.map((f) => [f.name, undensingField(r, f)]));
+  }
+};
+// src/api.ts
+var getDenseFieldBitWidthRange = (field) => {
+  switch (field.type) {
+    case "bool":
+    case "int":
+    case "fixed":
+    case "enum":
+      const bits = getBitWidthForContantBitWidthFields(field);
+      return { min: bits, max: bits };
+    case "optional": {
+      const innerRange = getDenseFieldBitWidthRange(field.field);
+      return {
+        min: 1,
+        max: 1 + innerRange.max
+      };
+    }
+    case "array": {
+      const lengthBits = bitsForMinMaxLength(field.minLength, field.maxLength);
+      const itemRange = getDenseFieldBitWidthRange(field.items);
+      return {
+        min: lengthBits + field.minLength * itemRange.min,
+        max: lengthBits + field.maxLength * itemRange.max
+      };
+    }
+    case "enum_array": {
+      const lengthBits = bitsForMinMaxLength(field.minLength, field.maxLength);
+      const base = field.enum.options.length;
+      const minContentBits = field.minLength === 0 ? 0 : Math.ceil(field.minLength * Math.log2(base));
+      const maxContentBits = field.maxLength === 0 ? 0 : Math.ceil(field.maxLength * Math.log2(base));
+      return {
+        min: lengthBits + minContentBits,
+        max: lengthBits + maxContentBits
+      };
+    }
+    case "object": {
+      return field.fields.reduce((acc, f) => {
+        const range = getDenseFieldBitWidthRange(f);
+        return { min: acc.min + range.min, max: acc.max + range.max };
+      }, { min: 0, max: 0 });
+    }
+    case "union": {
+      const discriminatorBits = bitsForOptions(field.discriminator.options);
+      const variantRanges = Object.values(field.variants).map((fields) => fields.reduce((sum, f) => {
+        const range = getDenseFieldBitWidthRange(f);
+        return { min: sum.min + range.min, max: sum.max + range.max };
+      }, { min: 0, max: 0 }));
+      return {
+        min: discriminatorBits + Math.min(...variantRanges.map((r) => r.min)),
+        max: discriminatorBits + Math.max(...variantRanges.map((r) => r.max))
+      };
+    }
+    default:
+      return { min: 0, max: 0 };
+  }
+};
+var calculateDenseFieldBitWidth = (field, value) => {
+  switch (field.type) {
+    case "bool":
+    case "int":
+    case "fixed":
+    case "enum":
+      return getBitWidthForContantBitWidthFields(field);
+    case "optional": {
+      const isPresent = value !== null && value !== undefined;
+      return 1 + (isPresent ? calculateDenseFieldBitWidth(field.field, value) : 0);
+    }
+    case "array": {
+      if (!Array.isArray(value))
+        return 0;
+      const lengthBits = bitsForMinMaxLength(field.minLength, field.maxLength);
+      const contentBits = value.reduce((sum, item) => sum + calculateDenseFieldBitWidth(field.items, item), 0);
+      return lengthBits + contentBits;
+    }
+    case "enum_array": {
+      if (!Array.isArray(value))
+        return 0;
+      const lengthBits = bitsForMinMaxLength(field.minLength, field.maxLength);
+      const base = field.enum.options.length;
+      const contentBits = value.length === 0 ? 0 : Math.ceil(value.length * Math.log2(base));
+      return lengthBits + contentBits;
+    }
+    case "object": {
+      return field.fields.reduce((sum, f) => sum + calculateDenseFieldBitWidth(f, value?.[f.name]), 0);
+    }
+    case "union": {
+      const discriminatorBits = bitsForOptions(field.discriminator.options);
+      const variantType = value?.[field.discriminator.name];
+      if (!variantType)
+        return discriminatorBits;
+      const variantFields = field.variants[variantType] || [];
+      const variantBits = variantFields.reduce((sum, f) => sum + calculateDenseFieldBitWidth(f, value), 0);
+      return discriminatorBits + variantBits;
+    }
+    default:
+      return 0;
+  }
+};
+var analyzeDenseSchemaSize = (schema2) => {
+  const fieldRanges = {};
+  let totalMin = 0;
+  let totalMax = 0;
+  schema2.fields.forEach((field) => {
+    const range = getDenseFieldBitWidthRange(field);
+    fieldRanges[field.name] = range;
+    totalMin += range.min;
+    totalMax += range.max;
+  });
+  return {
+    staticRange: {
+      minBits: totalMin,
+      maxBits: totalMax,
+      minBytes: Math.ceil(totalMin / 8),
+      maxBytes: Math.ceil(totalMax / 8),
+      minBase64Chars: Math.ceil(totalMin / 6),
+      maxBase64Chars: Math.ceil(totalMax / 6)
+    },
+    fieldRanges
+  };
+};
+var calculateDenseDataSize = (schema2, data) => {
+  const schemaAnalysis = analyzeDenseSchemaSize(schema2);
+  const fieldSizes = {};
+  let totalBits = 0;
+  schema2.fields.forEach((field) => {
+    const bits = calculateDenseFieldBitWidth(field, data[field.name]);
+    fieldSizes[field.name] = bits;
+    totalBits += bits;
+  });
+  const minBits = schemaAnalysis.staticRange.minBits;
+  const maxBits = schemaAnalysis.staticRange.maxBits;
+  const utilizationPercent = maxBits === minBits ? 100 : (totalBits - minBits) / (maxBits - minBits) * 100;
+  return {
+    totalBits,
+    totalBytes: Math.ceil(totalBits / 8),
+    base64Length: Math.ceil(totalBits / 6),
+    fieldSizes,
+    efficiency: {
+      usedBits: totalBits,
+      minPossibleBits: minBits,
+      maxPossibleBits: maxBits,
+      utilizationPercent
+    }
+  };
+};
+var getFieldByPath = (schema2, path) => {
+  const parts = path.split(".");
+  let current = null;
+  for (let i = 0;i < parts.length; i++) {
+    const part = parts[i];
+    const fields = i === 0 ? schema2.fields : current?.fields;
+    if (!fields)
+      return null;
+    current = fields.find((f) => f.name === part) || null;
+    if (!current)
+      return null;
+    if (current.type === "array" && i < parts.length - 1) {
+      current = current.items;
+    }
+  }
+  return current;
+};
+var walkDenseSchema = (schema2, callback, prefix = "") => {
+  schema2.fields.forEach((field) => {
+    const fieldPath = prefix ? `${prefix}.${field.name}` : field.name;
+    callback(field, fieldPath);
+    if (field.type === "object") {
+      walkDenseSchema({ fields: field.fields }, callback, fieldPath);
+    } else if (field.type === "array" && field.items.type === "object") {
+      walkDenseSchema({ fields: field.items.fields }, callback, `${fieldPath}[]`);
+    } else if (field.type === "optional" && field.field.type === "object") {
+      walkDenseSchema({ fields: field.field.fields }, callback, fieldPath);
+    }
+  });
+};
+var getAllDenseSchemaPaths = (schema2) => {
+  const paths = [];
+  walkDenseSchema(schema2, (field, path) => paths.push(path));
+  return paths;
+};
+export {
+  walkDenseSchema,
+  validate,
+  union,
+  undensingField,
+  undensingDataForConstantBitWidthField,
+  undensing,
+  schema,
+  printTypes,
+  optional,
+  object,
+  lengthForUIntMinMaxLength,
+  int,
+  getbaseQRCode45UrlSafeFromBigInt,
+  getUIntForConstantBitWidthField,
+  getFieldByPath,
+  getDenseFieldBitWidthRange,
+  getDefaultData,
+  getBitWidthForContantBitWidthFields,
+  getBigIntFrombaseQRCode45UrlSafe,
+  getBigIntFromBase64,
+  getBase64FromBigInt,
+  getAllDenseSchemaPaths,
+  generateTypesFile,
+  generateTypes,
+  fixed,
+  enumeration,
+  enumArray,
+  densingField,
+  densing,
+  createRecursiveUnion,
+  calculateDenseFieldBitWidth,
+  calculateDenseDataSize,
+  bool,
+  bitsForRange,
+  bitsForOptions,
+  bitsForMinMaxLength,
+  binary,
+  baseQRCode45UrlSafe,
+  base64url,
+  array,
+  analyzeDenseSchemaSize,
+  BitWriter,
+  BitReader,
+  BaseTypes
+};