@fxhash/params 0.0.12 → 0.0.13

package/dist/utils-Bd4LPrAy.d.ts

@@ -0,0 +1,136 @@
+//#region src/types.d.ts
+type FxParamType = "number" | "bigint" | "boolean" | "color" | "string" | "bytes" | "select";
+type FxParamOptionsMap = { [Type in FxParamType]: {
+  number: {
+    min?: number;
+    max?: number;
+    step?: number;
+  };
+  bigint: {
+    min?: number | bigint;
+    max?: number | bigint;
+  };
+  boolean: undefined;
+  color: undefined;
+  string: {
+    minLength?: number;
+    maxLength?: number;
+  };
+  bytes: {
+    length: number;
+  };
+  select: {
+    options: string[];
+  };
+}[Type] };
+type FxParamTypeMap = { [Type in FxParamType]: {
+  number: number;
+  bigint: bigint;
+  boolean: boolean;
+  color: string;
+  string: string;
+  bytes: Uint8Array;
+  select: string;
+}[Type] };
+type FxParamTransformationTypeMap = { [Type in FxParamType]: {
+  number: number;
+  bigint: bigint;
+  boolean: boolean;
+  color: {
+    hex: {
+      rgb: string;
+      rgba: string;
+    };
+    obj: {
+      rgb: {
+        r: number;
+        g: number;
+        b: number;
+      };
+      rgba: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+      };
+    };
+    arr: {
+      rgb: [number, number, number];
+      rgba: [number, number, number, number];
+    };
+  };
+  string: string;
+  bytes: Uint8Array;
+  select: string;
+}[Type] };
+type FxParamUpdateMode = "page-reload" | "sync" | "code-driven";
+type FxParamValue<Type extends FxParamType> = FxParamTypeMap[Type];
+interface FxParamDefinition<Type extends FxParamType> {
+  id: string;
+  name?: string;
+  type: Type;
+  update?: FxParamUpdateMode;
+  default: FxParamTypeMap[Type];
+  value: FxParamTypeMap[Type];
+  options: FxParamOptionsMap[Type];
+  version?: string;
+}
+type FxParamDefinitions = FxParamDefinition<FxParamType>[];
+type hexString = `#${string}`;
+type FxParamProcessorTransformer<Type extends FxParamType> = (value: FxParamTypeMap[Type], definition?: FxParamDefinition<Type>) => FxParamTransformationTypeMap[Type];
+type FxParamProcessorConstrainer<Type extends FxParamType> = (value: FxParamTypeMap[Type], definition: FxParamDefinition<Type>) => FxParamTypeMap[Type];
+interface FxParamProcessor<Type extends FxParamType> {
+  serialize: (input: FxParamTypeMap[Type], definition: FxParamDefinition<Type>) => string;
+  deserialize: (input: string, definition: FxParamDefinition<Type>) => FxParamTypeMap[Type];
+  bytesLength: (definition: FxParamDefinition<Type>) => number;
+  transform?: FxParamProcessorTransformer<Type>;
+  constrain?: FxParamProcessorConstrainer<Type>;
+  random: (definition: FxParamDefinition<Type>) => FxParamTypeMap[Type];
+}
+type FxParamProcessors = { [T in FxParamType]: FxParamProcessor<T> };
+type FxParamTranformType = "transform" | "constrain";
+type FxParamsData = Record<string, any>;
+type FxParamsRaw = Record<string, FxParamValue<FxParamType>>;
+type FxParamTransformation = FxParamTransformationTypeMap[FxParamType];
+type FxParamsTransformed = Record<string, FxParamTransformation>;
+//#endregion
+//#region src/utils.d.ts
+declare function rgbaToHex(r: number, g: number, b: number, a: number): string;
+declare function hexToRgba(hexCode: hexString): {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+};
+declare const MIN_SAFE_INT64: bigint;
+declare const MAX_SAFE_INT64: bigint;
+declare const ParameterProcessors: FxParamProcessors;
+declare function serializeParams(params: any, definition: FxParamDefinition<any>[]): string;
+declare function serializeParamsOrNull(params: FxParamsData, definition: FxParamDefinition<any>[]): string | null;
+declare function deserializeParams(bytes: string, definition: FxParamDefinition<FxParamType>[], options: {
+  withTransform?: boolean;
+  transformType?: FxParamTranformType;
+}): FxParamsRaw | FxParamsTransformed;
+declare function consolidateParams(params: any, data: any): any[];
+/**
+ * Given a definition and some params data, builds a clean params object where
+ * the values are first found in the data object, then in the definition if a
+ * default value exists, otherwise in randomizes the value using the param
+ * associated processor.
+ *
+ * @param definition an array of parameter definition
+ * @param data the params data used to reconstruct the final values
+ */
+declare function buildParamsObject(definition: FxParamDefinitions, data: FxParamsData | null): FxParamsData;
+declare function getRandomParamValues(params: FxParamDefinition<FxParamType>[], options?: {
+  noTransform?: boolean;
+  randomizeAll?: boolean;
+}): any;
+declare function sumBytesParams(definitions: FxParamDefinition<FxParamType>[]): number;
+declare function stringifyParamsData(data: FxParamsData): string;
+declare function jsonStringifyBigint(data: any): string;
+declare const processParam: (paramId: string, value: FxParamValue<FxParamType>, definitions: FxParamDefinition<FxParamType>[], transformType: FxParamTranformType) => FxParamValue<FxParamType> | FxParamTransformation;
+declare const processParams: (values: FxParamsData, definitions: FxParamDefinition<FxParamType>[], transformType: FxParamTranformType) => Record<string, FxParamValue<FxParamType>>;
+//#endregion
+export { FxParamDefinition, FxParamDefinitions, FxParamOptionsMap, FxParamProcessor, FxParamProcessorConstrainer, FxParamProcessorTransformer, FxParamProcessors, FxParamTranformType, FxParamTransformation, FxParamTransformationTypeMap, FxParamType, FxParamTypeMap, FxParamUpdateMode, FxParamValue, FxParamsData, FxParamsRaw, FxParamsTransformed, MAX_SAFE_INT64 as MAX_SAFE_INT64$1, MIN_SAFE_INT64 as MIN_SAFE_INT64$1, ParameterProcessors as ParameterProcessors$1, buildParamsObject as buildParamsObject$1, consolidateParams as consolidateParams$1, deserializeParams as deserializeParams$1, getRandomParamValues as getRandomParamValues$1, hexString, hexToRgba as hexToRgba$1, jsonStringifyBigint as jsonStringifyBigint$1, processParam as processParam$1, processParams as processParams$1, rgbaToHex as rgbaToHex$1, serializeParams as serializeParams$1, serializeParamsOrNull as serializeParamsOrNull$1, stringifyParamsData as stringifyParamsData$1, sumBytesParams as sumBytesParams$1 };
+//# sourceMappingURL=utils-Bd4LPrAy.d.ts.map

package/dist/utils.d.ts

@@ -1 +1,2 @@
-export { b as MAX_SAFE_INT64, M as MIN_SAFE_INT64, P as ParameterProcessors, f as buildParamsObject, e as consolidateParams, d as deserializeParams, g as getRandomParamValues, h as hexToRgba, k as jsonStringifyBigint, p as processParam, l as processParams, r as rgbaToHex, s as serializeParams, c as serializeParamsOrNull, j as stringifyParamsData, i as sumBytesParams } from './utils-jEvPb5wq.js';
+import { MAX_SAFE_INT64$1 as MAX_SAFE_INT64, MIN_SAFE_INT64$1 as MIN_SAFE_INT64, ParameterProcessors$1 as ParameterProcessors, buildParamsObject$1 as buildParamsObject, consolidateParams$1 as consolidateParams, deserializeParams$1 as deserializeParams, getRandomParamValues$1 as getRandomParamValues, hexToRgba$1 as hexToRgba, jsonStringifyBigint$1 as jsonStringifyBigint, processParam$1 as processParam, processParams$1 as processParams, rgbaToHex$1 as rgbaToHex, serializeParams$1 as serializeParams, serializeParamsOrNull$1 as serializeParamsOrNull, stringifyParamsData$1 as stringifyParamsData, sumBytesParams$1 as sumBytesParams } from "./utils-Bd4LPrAy.js";
+export { MAX_SAFE_INT64, MIN_SAFE_INT64, ParameterProcessors, buildParamsObject, consolidateParams, deserializeParams, getRandomParamValues, hexToRgba, jsonStringifyBigint, processParam, processParams, rgbaToHex, serializeParams, serializeParamsOrNull, stringifyParamsData, sumBytesParams };

package/dist/utils.js

@@ -1,3 +1,3 @@
-export { MAX_SAFE_INT64, MIN_SAFE_INT64, ParameterProcessors, buildParamsObject, consolidateParams, deserializeParams, getRandomParamValues, hexToRgba, jsonStringifyBigint, processParam, processParams, rgbaToHex, serializeParams, serializeParamsOrNull, stringifyParamsData, sumBytesParams } from './chunk-B3N473DY.js';
-//# sourceMappingURL=utils.js.map
-//# sourceMappingURL=utils.js.map
+import { MAX_SAFE_INT64, MIN_SAFE_INT64, ParameterProcessors, buildParamsObject, consolidateParams, deserializeParams, getRandomParamValues, hexToRgba, jsonStringifyBigint, processParam, processParams, rgbaToHex, serializeParams, serializeParamsOrNull, stringifyParamsData, sumBytesParams } from "./utils-BXUz-G9x.js";
+
+export { MAX_SAFE_INT64, MIN_SAFE_INT64, ParameterProcessors, buildParamsObject, consolidateParams, deserializeParams, getRandomParamValues, hexToRgba, jsonStringifyBigint, processParam, processParams, rgbaToHex, serializeParams, serializeParamsOrNull, stringifyParamsData, sumBytesParams };

package/package.json

@@ -1,19 +1,15 @@
 {
   "name": "@fxhash/params",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "author": "fxhash",
   "dependencies": {
-    "sha1": "1.1.1",
     "zod": "3.24.3"
   },
   "devDependencies": {
-    "@types/lodash.debounce": "4.0.7",
-    "@types/sha1": "1.1.3",
-    "tslib": "2.6.2",
-    "tsup": "8.4.0",
+    "tsdown": "0.12.2",
     "typescript": "5.8.2",
-    "@fxhash/eslint-config": "1.0.4",
-    "@fxhash/tsconfig": "0.0.2"
+    "@fxhash/eslint-config": "1.0.5",
+    "@fxhash/tsconfig": "0.0.3"
   },
   "exports": {
     ".": {
@@ -35,6 +31,7 @@
     "access": "public"
   },
   "repository": "fxhash/fxhash-package",
+  "sideEffects": false,
   "type": "module",
   "types": "dist/index.d.ts",
   "typesVersions": {
@@ -45,7 +42,7 @@
     }
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch"
+    "build": "tsdown && tsc --noEmit",
+    "dev": "tsdown --watch"
   }
 }

package/dist/chunk-B3N473DY.js

@@ -1,412 +0,0 @@
-// src/utils.ts
-function rgbaToHex(r, g, b, a) {
-  const outParts = [
-    r.toString(16),
-    g.toString(16),
-    b.toString(16),
-    Math.round(a * 255).toString(16).substring(0, 2)
-  ];
-  outParts.forEach(function(part, i) {
-    if (part.length === 1) {
-      outParts[i] = "0" + part;
-    }
-  });
-  return "#" + outParts.join("");
-}
-function completeHexColor(hexCode) {
-  let hex = hexCode.replace("#", "");
-  if (hex.length === 6) {
-    hex = `${hex}ff`;
-  }
-  if (hex.length === 3) {
-    hex = `${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}ff`;
-  }
-  return hex;
-}
-function hexToRgba(hexCode) {
-  const hex = completeHexColor(hexCode);
-  const r = parseInt(hex.substring(0, 2), 16);
-  const g = parseInt(hex.substring(2, 4), 16);
-  const b = parseInt(hex.substring(4, 6), 16);
-  const a = Math.round(
-    (parseInt(hex.substring(6, 8), 16) / 255 + Number.EPSILON) * 100
-  ) / 100;
-  return { r, g, b, a };
-}
-var stringToHex = function(s) {
-  let rtn = "";
-  for (let i = 0; i < s.length; i++) {
-    rtn += s.charCodeAt(i).toString(16).padStart(4, "0");
-  }
-  return rtn;
-};
-var hexToString = function(h) {
-  const hx = h.match(/.{1,4}/g) || [];
-  let rtn = "";
-  for (let i = 0; i < hx.length; i++) {
-    const int = parseInt(hx[i], 16);
-    if (int === 0) break;
-    rtn += String.fromCharCode(int);
-  }
-  return rtn;
-};
-var MIN_SAFE_INT64 = BigInt("-9223372036854775808");
-var MAX_SAFE_INT64 = BigInt("9223372036854775807");
-var ParameterProcessors = {
-  number: {
-    serialize: (input) => {
-      const view = new DataView(new ArrayBuffer(8));
-      view.setFloat64(0, input);
-      return view.getBigUint64(0).toString(16).padStart(16, "0");
-    },
-    deserialize: (input) => {
-      const view = new DataView(new ArrayBuffer(8));
-      for (let i = 0; i < 8; i++) {
-        view.setUint8(i, parseInt(input.substring(i * 2, i * 2 + 2), 16));
-      }
-      return view.getFloat64(0);
-    },
-    bytesLength: () => 8,
-    constrain: (value, definition) => {
-      let min = Number.MIN_SAFE_INTEGER;
-      if (typeof definition.options?.min !== "undefined")
-        min = Number(definition.options.min);
-      let max = Number.MAX_SAFE_INTEGER;
-      if (typeof definition.options?.max !== "undefined")
-        max = Number(definition.options.max);
-      max = Math.min(max, Number.MAX_SAFE_INTEGER);
-      min = Math.max(min, Number.MIN_SAFE_INTEGER);
-      const v = Math.min(Math.max(value, min), max);
-      if (definition?.options?.step) {
-        const t = 1 / definition?.options?.step;
-        return Math.round(v * t) / t;
-      }
-      return v;
-    },
-    random: (definition) => {
-      let min = Number.MIN_SAFE_INTEGER;
-      if (typeof definition.options?.min !== "undefined")
-        min = Number(definition.options.min);
-      let max = Number.MAX_SAFE_INTEGER;
-      if (typeof definition.options?.max !== "undefined")
-        max = Number(definition.options.max);
-      max = Math.min(max, Number.MAX_SAFE_INTEGER);
-      min = Math.max(min, Number.MIN_SAFE_INTEGER);
-      const v = Math.random() * (max - min) + min;
-      if (definition?.options?.step) {
-        const t = 1 / definition?.options?.step;
-        return Math.round(v * t) / t;
-      }
-      return v;
-    }
-  },
-  bigint: {
-    serialize: (input) => {
-      const view = new DataView(new ArrayBuffer(8));
-      view.setBigInt64(0, BigInt(input));
-      return view.getBigUint64(0).toString(16).padStart(16, "0");
-    },
-    deserialize: (input) => {
-      const view = new DataView(new ArrayBuffer(8));
-      for (let i = 0; i < 8; i++) {
-        view.setUint8(i, parseInt(input.substring(i * 2, i * 2 + 2), 16));
-      }
-      return view.getBigInt64(0);
-    },
-    bytesLength: () => 8,
-    random: (definition) => {
-      let min = MIN_SAFE_INT64;
-      let max = MAX_SAFE_INT64;
-      if (typeof definition.options?.min !== "undefined")
-        min = BigInt(definition.options.min);
-      if (typeof definition.options?.max !== "undefined")
-        max = BigInt(definition.options.max);
-      const range = max - min;
-      const bits = range.toString(2).length;
-      let random;
-      do {
-        random = BigInt(
-          "0b" + Array.from(
-            crypto.getRandomValues(new Uint8Array(Math.ceil(bits / 8)))
-          ).map((b) => b.toString(2).padStart(8, "0")).join("")
-        );
-      } while (random > range);
-      return random + min;
-    }
-  },
-  boolean: {
-    serialize: (input) => {
-      return typeof input === "boolean" ? input ? "01" : "00" : typeof input === "string" ? input === "true" ? "01" : "00" : "00";
-    },
-    deserialize: (input) => {
-      return input === "00" ? false : true;
-    },
-    bytesLength: () => 1,
-    random: () => Math.random() < 0.5
-  },
-  color: {
-    serialize: (input) => {
-      return completeHexColor(input);
-    },
-    deserialize: (input) => {
-      return input;
-    },
-    bytesLength: () => 4,
-    transform: (input) => {
-      const color = completeHexColor(input);
-      const r = parseInt(color.slice(0, 2), 16);
-      const g = parseInt(color.slice(2, 4), 16);
-      const b = parseInt(color.slice(4, 6), 16);
-      const a = parseInt(color.slice(6, 8), 16);
-      return {
-        hex: {
-          rgb: "#" + input.slice(0, 6),
-          rgba: "#" + input
-        },
-        obj: {
-          rgb: { r, g, b },
-          rgba: { r, g, b, a }
-        },
-        arr: {
-          rgb: [r, g, b],
-          rgba: [r, g, b, a]
-        }
-      };
-    },
-    constrain: (value) => {
-      const hex = value.replace("#", "");
-      return hex.slice(0, 8).padEnd(8, "f");
-    },
-    random: () => `${[...Array(8)].map(() => Math.floor(Math.random() * 16).toString(16)).join("")}`
-  },
-  string: {
-    serialize: (input, def) => {
-      if (!def.version) {
-        let hex2 = stringToHex(input.substring(0, 64));
-        hex2 = hex2.padEnd(64 * 4, "0");
-        return hex2;
-      }
-      let max = 64;
-      if (typeof def.options?.maxLength !== "undefined")
-        max = Number(def.options.maxLength);
-      let hex = stringToHex(input.substring(0, max));
-      hex = hex.padEnd(max * 4, "0");
-      return hex;
-    },
-    deserialize: (input) => {
-      return hexToString(input);
-    },
-    bytesLength: (def) => {
-      if (!def.version) {
-        return 64 * 2;
-      }
-      if (typeof def.options?.maxLength !== "undefined")
-        return Number(def.options.maxLength) * 2;
-      return 64 * 2;
-    },
-    random: (definition) => {
-      let min = 0;
-      if (typeof definition.options?.minLength !== "undefined")
-        min = definition.options.minLength;
-      let max = 64;
-      if (typeof definition.options?.maxLength !== "undefined")
-        max = definition.options.maxLength;
-      const length = Math.round(Math.random() * (max - min) + min);
-      return [...Array(length)].map((i) => (~~(Math.random() * 36)).toString(36)).join("");
-    },
-    constrain: (value, definition) => {
-      let min = 0;
-      if (typeof definition.options?.minLength !== "undefined")
-        min = definition.options.minLength;
-      let max = 64;
-      if (typeof definition.options?.maxLength !== "undefined")
-        max = definition.options.maxLength;
-      const v = value.slice(0, max);
-      if (v.length < min) {
-        return v.padEnd(min);
-      }
-      return v;
-    }
-  },
-  bytes: {
-    serialize: (input, def) => {
-      return Array.from(input).map((i) => i.toString(16).padStart(2, "0")).join("");
-    },
-    deserialize: (input, def) => {
-      const len = input.length / 2;
-      const uint8 = new Uint8Array(len);
-      let idx;
-      for (let i = 0; i < len; i++) {
-        idx = i * 2;
-        uint8[i] = parseInt(`${input[idx]}${input[idx + 1]}`, 16);
-      }
-      return uint8;
-    },
-    bytesLength: (def) => def.options.length,
-    random: (def) => {
-      const len = def.options?.length || 0;
-      const uint8 = new Uint8Array(len);
-      for (let i = 0; i < len; i++) {
-        uint8[i] = Math.random() * 255 | 0;
-      }
-      return uint8;
-    }
-  },
-  select: {
-    serialize: (input, def) => {
-      return Math.min(255, def.options?.options?.indexOf(input) || 0).toString(16).padStart(2, "0");
-    },
-    deserialize: (input, def) => {
-      const idx = parseInt(input, 16);
-      return def.options?.options?.[idx] || def.options?.options?.[0] || "";
-    },
-    bytesLength: () => 1,
-    // index between 0 and 255
-    constrain: (value, definition) => {
-      if (definition.options.options.includes(value)) {
-        return value;
-      }
-      return definition.options.options[0];
-    },
-    random: (definition) => {
-      const index = Math.round(
-        Math.random() * (definition.options.options.length - 1) + 0
-      );
-      return definition?.options?.options[index];
-    }
-  }
-};
-function serializeParams(params, definition) {
-  let bytes = "";
-  if (!definition) return bytes;
-  for (const def of definition) {
-    const { id, type } = def;
-    const processor = ParameterProcessors[type];
-    const v = params[id];
-    const val = typeof v !== "undefined" ? v : typeof def.default !== "undefined" ? def.default : processor.random(def);
-    const serialized = processor.serialize(val, def);
-    bytes += serialized;
-  }
-  return bytes;
-}
-function serializeParamsOrNull(params, definition) {
-  const serialized = serializeParams(params, definition || []);
-  if (serialized.length === 0) return null;
-  return serialized;
-}
-function deserializeParams(bytes, definition, options) {
-  const params = {};
-  for (const def of definition) {
-    const processor = ParameterProcessors[def.type];
-    const transformer = options.withTransform && processor[options.transformType || "transform"];
-    if (!bytes) {
-      let v;
-      if (typeof def.default === "undefined") v = processor.random(def);
-      else v = def.default;
-      params[def.id] = transformer ? transformer(v, def) : v;
-      continue;
-    }
-    const bytesLen = processor.bytesLength(def);
-    const valueBytes = bytes.substring(0, bytesLen * 2);
-    bytes = bytes.substring(bytesLen * 2);
-    const val = processor.deserialize(
-      valueBytes,
-      def
-    );
-    params[def.id] = transformer ? transformer(val, def) : val;
-  }
-  return params;
-}
-function consolidateParams(params, data) {
-  if (!params) return [];
-  const rtn = [...params];
-  for (const p in rtn) {
-    const definition = rtn[p];
-    const { id, type, default: def } = definition;
-    if (data && data.hasOwnProperty(id)) {
-      rtn[p].value = data[id];
-    } else {
-      const processor = ParameterProcessors[type];
-      let v;
-      if (typeof def === "undefined") v = processor.random(definition);
-      else v = def;
-      rtn[p].value = processor.transform?.(v) || v;
-    }
-  }
-  return rtn;
-}
-function buildParamsObject(definition, data) {
-  if (!definition) return {};
-  const out = {};
-  for (const def of definition) {
-    if (data?.hasOwnProperty(def.id)) {
-      out[def.id] = data[def.id];
-      continue;
-    }
-    if (def.hasOwnProperty("default")) {
-      out[def.id] = def.default;
-      continue;
-    }
-    const processor = ParameterProcessors[def.type];
-    const rand = processor.random(def);
-    out[def.id] = processor.transform?.(rand) || rand;
-  }
-  return out;
-}
-function getRandomParamValues(params, options) {
-  return params.reduce(
-    (acc, definition) => {
-      const processor = ParameterProcessors[definition.type];
-      let v = definition.value || definition.default;
-      if (definition.update !== "code-driven" || options?.randomizeAll) {
-        v = processor.random(definition);
-      }
-      if (v) {
-        acc[definition.id] = options?.noTransform ? v : processor.transform?.(v) || v;
-      }
-      return acc;
-    },
-    {}
-  );
-}
-function sumBytesParams(definitions) {
-  return definitions?.reduce(
-    (acc, def) => acc + ParameterProcessors[def.type].bytesLength(def),
-    0
-  ) || 0;
-}
-function stringifyParamsData(data) {
-  return JSON.stringify(data, (key, value) => {
-    if (typeof value === "bigint") return value.toString();
-    return value;
-  });
-}
-function jsonStringifyBigint(data) {
-  return JSON.stringify(data, (key, value) => {
-    if (typeof value === "bigint") return value.toString();
-    return value;
-  });
-}
-var processParam = (paramId, value, definitions, transformType) => {
-  const definition = definitions.find((d) => d.id === paramId);
-  if (!definition) {
-    throw new Error(`No definition found for param ${paramId}`);
-  }
-  const processor = ParameterProcessors[definition.type];
-  const transformer = processor[transformType];
-  return transformer?.(value, definition) || value;
-};
-var processParams = (values, definitions, transformType) => {
-  const paramValues = {};
-  for (const definition of definitions) {
-    const processor = ParameterProcessors[definition.type];
-    const value = values[definition.id];
-    const transformer = processor[transformType];
-    paramValues[definition.id] = transformer?.(value, definition) || value;
-  }
-  return paramValues;
-};
-
-export { MAX_SAFE_INT64, MIN_SAFE_INT64, ParameterProcessors, buildParamsObject, consolidateParams, deserializeParams, getRandomParamValues, hexToRgba, jsonStringifyBigint, processParam, processParams, rgbaToHex, serializeParams, serializeParamsOrNull, stringifyParamsData, sumBytesParams };
-//# sourceMappingURL=chunk-B3N473DY.js.map
-//# sourceMappingURL=chunk-B3N473DY.js.map