@andrew_l/toolkit 0.3.3 → 0.3.4

package/dist/index.cjs

@@ -941,7 +941,7 @@ function fn(value, message) {
   }
 }
 function greaterThan(value, target, message) {
-  if (!isNumber(value) || value < target) {
+  if (!isNumber(value) || value <= target) {
     throw toError$1(
       greaterThan,
       value,
@@ -1733,6 +1733,433 @@ function bigIntFromBytes(bytes) {
   return decoded;
 }
 
+function toError(value, unknownMessage = "Unknown error") {
+  if (isError(value)) {
+    return value;
+  }
+  const error = new Error(unknownMessage, { cause: value });
+  Error.captureStackTrace(error, toError);
+  return error;
+}
+
+function createFunction(fnName, code, ...args) {
+  try {
+    const fn = new Function(...args, code);
+    fn.code = code;
+    return fn;
+  } catch (err) {
+    throw new Error(
+      `failed to create bitPack.${fnName}()
+Error: ${toError(err).message}
+-- CODE START --
+${code}
+-- CODE END--`
+    );
+  }
+}
+
+function bitPack(options) {
+  notEmpty(options.fields, "fields cannot be empty");
+  greaterThan(options.totalBits, 0, "totalBits must be greater than 0");
+  const fields = buildFieldsInfo$1(options.fields, options.totalBits);
+  const plan = buildPlan(fields);
+  const containersCount = Math.ceil(options.totalBits / 32);
+  const buf = new Uint8Array(containersCount * 4);
+  const baseCode = [
+    "\n// Field init",
+    initFields(fields),
+    "\n// Plan",
+    compilePlan(plan, options.optimize)
+  ];
+  const fnBufferCode = [
+    ...baseCode,
+    "\n// Return result",
+    buildBufferResult(containersCount)
+  ].join("\n");
+  const fnBuffer = createFunction(
+    "buffer",
+    fnBufferCode,
+    "data"
+  );
+  const fnBigIntCode = [
+    ...baseCode,
+    "\n// Return result",
+    buildBigIntResult(containersCount)
+  ].join("\n");
+  const fnBigInt = createFunction(
+    "bigint",
+    fnBigIntCode,
+    "data"
+  );
+  const fnNumberCode = [
+    ...baseCode,
+    "\n// Return result",
+    buildNumberResult()
+  ].join("\n");
+  const fnNumber = createFunction(
+    "number",
+    fnNumberCode,
+    "data"
+  );
+  const fnBitsCode = [
+    ...baseCode,
+    "\n// Return result",
+    buildBitsResult(containersCount, options.totalBits)
+  ].join("\n");
+  const fnBits = createFunction("bits", fnBitsCode, "data");
+  if (!options.debug) {
+    def(fnBuffer, "code", void 0);
+    def(fnBigInt, "code", void 0);
+    def(fnNumber, "code", void 0);
+    def(fnBits, "code", void 0);
+  }
+  return {
+    buffer: fnBuffer,
+    bigint: fnBigInt,
+    number: fnNumber,
+    bits: fnBits,
+    plan: options.debug ? plan : void 0,
+    __buf: buf
+  };
+}
+function initFields(fields) {
+  return fields.map((field) => {
+    if (field.bits > 32) {
+      return [
+        `var ${field.id}_high = (data['${field.name}'] / 0x100000000) | 0;`,
+        `var ${field.id}_low = (data['${field.name}'] >>> 0);`
+      ].join("\n");
+    }
+    if (field.take === "high") {
+      return `var ${field.id} = (data['${field.name}'] / 0x100000000) | 0;`;
+    }
+    return `var ${field.id} = (data['${field.name}'] & 0x${field.mask.toString(16)}) >>> 0;`;
+  }).join("\n");
+}
+function buildBufferResult(containersCount) {
+  const lines = [`var buf = this.__buf;`];
+  for (let i = 0; i < containersCount; i++) {
+    const containerIndex = containersCount - 1 - i;
+    lines.push(
+      `buf[${i * 4}] = c_${containerIndex} >>> 24;`,
+      `buf[${i * 4 + 1}] = c_${containerIndex} >>> 16;`,
+      `buf[${i * 4 + 2}] = c_${containerIndex} >>> 8;`,
+      `buf[${i * 4 + 3}] = c_${containerIndex};`
+    );
+  }
+  lines.push("return buf;");
+  return lines.join("\n");
+}
+function buildBigIntResult(containersCount) {
+  const parts = [];
+  for (let i = 0; i < containersCount; i++) {
+    const containerIndex = containersCount - 1 - i;
+    if (containerIndex > 0) {
+      parts.push(
+        `(BigInt(c_${containerIndex} >>> 0) << ${containerIndex * 32}n)`
+      );
+    } else {
+      parts.push(`BigInt(c_${containerIndex} >>> 0)`);
+    }
+  }
+  return `return (
+  ${parts.join(" |\n  ")}
+);`;
+}
+function buildNumberResult(containersCount) {
+  return `return c_0;`;
+}
+function buildBitsResult(containersCount, totalBits) {
+  const parts = [];
+  for (let i = 0; i < containersCount; i++) {
+    const containerIndex = containersCount - 1 - i;
+    if (containerIndex > 0) {
+      parts.push(
+        `(BigInt(c_${containerIndex} >>> 0) << ${containerIndex * 32}n)`
+      );
+    } else {
+      parts.push(`BigInt(c_${containerIndex} >>> 0)`);
+    }
+  }
+  return `return (
+  ${parts.join(" |\n  ")}
+).toString(2).padStart(${totalBits}, '0');`;
+}
+function compilePlan(plan, optimize) {
+  if (optimize) {
+    plan = optimizePlan(plan);
+  }
+  const assigned = /* @__PURE__ */ new Set();
+  return plan.map((item) => compilePlanItem(item, assigned)).join("\n");
+}
+function optimizePlan(plan) {
+  return plan.reduce((result, item) => {
+    const prev = result.at(-1);
+    if (canMergeSetOperations(prev, item)) {
+      result.pop();
+      result.push({
+        object: "set",
+        container: item.container,
+        child: {
+          object: "value",
+          value: [
+            compilePlanItem(prev.child),
+            compilePlanItem(item.child)
+          ].join(" |\n  ")
+        }
+      });
+    } else {
+      result.push(item);
+    }
+    return result;
+  }, []);
+}
+function canMergeSetOperations(prev, current) {
+  return prev?.object === "set" && current.object === "set" && prev.container === current.container;
+}
+function compilePlanItem(plan, assigned) {
+  switch (plan.object) {
+    case "set":
+      if (assigned && !assigned.has(plan.container)) {
+        assigned.add(plan.container);
+        return `var c_${plan.container} = ${compilePlanItem(plan.child)};`;
+      }
+      return `c_${plan.container} |= ${compilePlanItem(plan.child)};`;
+    case "value":
+      const offset = plan.offset ?? 0;
+      return offset > 0 ? `(${plan.value}) << ${offset}` : `(${plan.value})`;
+    default:
+      throw new Error(`Unknown plan object: ${plan.object}`);
+  }
+}
+function buildPlan(fields) {
+  const result = [];
+  for (const field of fields) {
+    const startContainer = Math.floor(field.startBit / 32);
+    const endContainer = Math.floor(field.endBit / 32);
+    if (startContainer === endContainer) {
+      addSingleContainerField(field, result);
+    } else if (field.bits <= 32) {
+      addSpanningField(field, result);
+    } else {
+      addLargeField(field, result);
+    }
+  }
+  return result;
+}
+function addSingleContainerField(field, result) {
+  result.push({
+    object: "set",
+    container: Math.floor(field.startBit / 32),
+    child: {
+      object: "value",
+      offset: field.startBit % 32,
+      value: field.id
+    }
+  });
+}
+function addSpanningField(field, result) {
+  const startContainer = Math.floor(field.startBit / 32);
+  const endContainer = Math.floor(field.endBit / 32);
+  const firstContainerBits = 32 - field.startBit % 32;
+  result.push({
+    object: "set",
+    container: startContainer,
+    child: {
+      object: "value",
+      offset: field.startBit % 32,
+      value: `(${field.id}) & ${(1 << firstContainerBits) - 1}`
+    }
+  });
+  result.push({
+    object: "set",
+    container: endContainer,
+    child: {
+      object: "value",
+      value: `(${field.id}) >>> ${firstContainerBits}`
+    }
+  });
+}
+function addLargeField(field, result) {
+  const startContainer = Math.floor(field.startBit / 32);
+  const endContainer = Math.floor(field.endBit / 32);
+  const startOffset = field.startBit % 32;
+  ok(
+    startContainer !== endContainer,
+    `Large field ${field.name} fits in single container - logic error`
+  );
+  ok(
+    endContainer - startContainer === 1,
+    `Fields spanning more than 2 containers (${field.bits} bits) not yet supported`
+  );
+  const bitsInLowerContainer = 32 - startOffset;
+  result.push({
+    object: "set",
+    container: endContainer,
+    child: {
+      object: "value",
+      offset: startOffset,
+      value: `${field.id}_high`
+    }
+  });
+  if (bitsInLowerContainer < 32) {
+    result.push({
+      object: "set",
+      container: endContainer,
+      child: {
+        object: "value",
+        value: `${field.id}_low >>> ${bitsInLowerContainer}`
+      }
+    });
+  }
+  if (field.bits > 32) {
+    result.push({
+      object: "set",
+      container: startContainer,
+      child: {
+        object: "value",
+        offset: startOffset,
+        value: `${field.id}_low`
+      }
+    });
+  }
+}
+function buildFieldsInfo$1(fields, totalBits) {
+  const result = [];
+  let currentBitPosition = totalBits;
+  fields.forEach((field, idx) => {
+    const startBit = currentBitPosition - field.bits;
+    const endBit = currentBitPosition - 1;
+    result.push({
+      id: `f_${idx}`,
+      ...field,
+      startBit,
+      endBit,
+      mask: Math.pow(2, field.bits) - 1
+    });
+    currentBitPosition -= field.bits;
+  });
+  return result;
+}
+
+function bitUnpack(options) {
+  notEmpty(options.fields, "fields cannot be empty");
+  greaterThan(options.totalBits, 0, "totalBits must be greater than 0");
+  const fields = buildFieldsInfo(options.fields, options.totalBits);
+  const fnBigIntCode = [`return ${compileFields(fields)};`].join("\n");
+  const fnBigInt = createFunction(
+    "bigint",
+    fnBigIntCode,
+    "data"
+  );
+  const fnNumberCode = [
+    "\n// Extract container from number",
+    "data = BigInt(data);",
+    "\n// Return result",
+    `return ${compileFields(fields)};`
+  ].join("\n");
+  const fnNumber = createFunction(
+    "number",
+    fnNumberCode,
+    "data"
+  );
+  const fnBufferCode = [
+    "\n// Extract bytes from buffer (big-endian)",
+    extractBigIntFromBuffer(options.totalBits),
+    "\n// Return result",
+    `return ${compileFields(fields)};`
+  ].join("\n");
+  const fnBuffer = createFunction(
+    "buffer",
+    fnBufferCode,
+    "data"
+  );
+  const fnBitsCode = [
+    "\n// Convert bits string to bigint",
+    'var data = BigInt("0b" + bits);',
+    "\n// Return result",
+    `return ${compileFields(fields)};`
+  ].join("\n");
+  const fnBits = createFunction("bits", fnBitsCode, "bits");
+  if (!options.debug) {
+    def(fnBuffer, "code", void 0);
+    def(fnBigInt, "code", void 0);
+    def(fnNumber, "code", void 0);
+    def(fnBits, "code", void 0);
+  }
+  return {
+    buffer: fnBuffer,
+    bigint: fnBigInt,
+    number: fnNumber,
+    bits: fnBits
+  };
+}
+function compileFields(fields) {
+  const lines = ["{"];
+  for (const field of fields) {
+    if (field.startBit === 0) {
+      lines.push(
+        `  ['${field.name}']: Number(data & 0x${field.mask.toString(16)}n),`
+      );
+    } else {
+      lines.push(
+        `  ['${field.name}']: Number((data >> ${field.startBit}n) & 0x${field.mask.toString(16)}n),`
+      );
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function extractBigIntFromBuffer(totalBits) {
+  const totalBytes = Math.ceil(totalBits / 8);
+  const chunks = [];
+  let byteIndex = 0;
+  let remainingBytes = totalBytes;
+  while (remainingBytes > 0) {
+    if (remainingBytes >= 4) {
+      const shift = (remainingBytes - 4) * 8;
+      const chunk = `((data[${byteIndex}] << 24) | (data[${byteIndex + 1}] << 16) | (data[${byteIndex + 2}] << 8) | data[${byteIndex + 3}]) >>> 0`;
+      if (shift === 0) {
+        chunks.push(`BigInt(${chunk})`);
+      } else {
+        chunks.push(`(BigInt(${chunk}) << ${shift}n)`);
+      }
+      byteIndex += 4;
+      remainingBytes -= 4;
+    } else {
+      let chunk;
+      if (remainingBytes === 3) {
+        chunk = `(data[${byteIndex}] << 16) | (data[${byteIndex + 1}] << 8) | data[${byteIndex + 2}]`;
+      } else if (remainingBytes === 2) {
+        chunk = `(data[${byteIndex}] << 8) | data[${byteIndex + 1}]`;
+      } else {
+        chunk = `data[${byteIndex}]`;
+      }
+      chunks.push(`BigInt(${chunk})`);
+      remainingBytes = 0;
+    }
+  }
+  return `data =
+    ${chunks.join("\n  | ")};`;
+}
+function buildFieldsInfo(fields, totalBits) {
+  const result = [];
+  let currentBitPosition = totalBits;
+  fields.forEach((field, idx) => {
+    const startBit = currentBitPosition - field.bits;
+    const endBit = currentBitPosition - 1;
+    result.push({
+      id: `f_${idx}`,
+      ...field,
+      mask: (1n << BigInt(field.bits)) - 1n,
+      startBit,
+      endBit
+    });
+    currentBitPosition -= field.bits;
+  });
+  return result;
+}
+
 function bytesToBase64(data, { encoding = "base64", padding } = {}) {
   if (encoding === "base64") {
     return base64.encode(data, { includePadding: padding ?? true });
@@ -2865,15 +3292,6 @@ function captureStackTrace(till) {
   return (err.stack || "").slice(6);
 }
 
-function toError(value, unknownMessage = "Unknown error") {
-  if (isError(value)) {
-    return value;
-  }
-  const error = new Error(unknownMessage, { cause: value });
-  Error.captureStackTrace(error, toError);
-  return error;
-}
-
 function catchError(fn) {
   try {
     const res = fn();
@@ -5623,6 +6041,8 @@ exports.base64url = base64url;
 exports.basex = basex;
 exports.bigIntBytes = bigIntBytes;
 exports.bigIntFromBytes = bigIntFromBytes;
+exports.bitPack = bitPack;
+exports.bitUnpack = bitUnpack;
 exports.blendColors = blendColors;
 exports.buildCssColor = buildCssColor;
 exports.bytesToBase64 = bytesToBase64;
@@ -5656,6 +6076,7 @@ exports.createDeepCloneWith = createDeepCloneWith;
 exports.createEJSON = createEJSON;
 exports.createEJSONStream = createEJSONStream;
 exports.createEnvParser = createEnvParser;
+exports.createFunction = createFunction;
 exports.createRandomizer = createRandomizer;
 exports.createSecureCustomizer = createSecureCustomizer;
 exports.createTimeObject = createTimeObject;