@fxhash/params 0.0.5 → 0.0.8

package/dist/chunk-CE3TPOSO.js

@@ -0,0 +1,135 @@
+import {
+  BaseInput
+} from "./chunk-2BHABOFI.js";
+
+// src/Controller/Controller.module.scss
+var Controller_module_default = {
+  "controller": "_controller_1rjbl_1",
+  "inputContainer": "_inputContainer_1rjbl_12",
+  "default": "_default_1rjbl_18",
+  "invert": "_invert_1rjbl_31",
+  "box": "_box_1rjbl_44",
+  "numberInput": "_numberInput_1rjbl_58"
+};
+
+// src/Controller/Controller.tsx
+import cx from "classnames";
+import { jsx, jsxs } from "react/jsx-runtime";
+function BaseParamsInput(props) {
+  const { id } = props;
+  return /* @__PURE__ */ jsx(BaseInput, { name: `${id}-params-search`, autoComplete: "off", ...props });
+}
+function Controller(props) {
+  const {
+    id,
+    label,
+    layout = "default",
+    className,
+    inputContainerProps,
+    isCodeDriven
+  } = props;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cx(Controller_module_default.controller, Controller_module_default[layout], className),
+      title: isCodeDriven ? "This parameter is solely code-driven. Controller is just shown for debugging purposes." : "",
+      children: [
+        id && /* @__PURE__ */ jsx("label", { htmlFor: id, children: label || id }),
+        /* @__PURE__ */ jsx("div", { className: Controller_module_default.inputContainer, ...inputContainerProps, children: props.children })
+      ]
+    }
+  );
+}
+function HTMLInputController(props) {
+  const {
+    label,
+    id,
+    onChange,
+    value,
+    type,
+    className,
+    inputProps,
+    layout = "default",
+    isCodeDriven
+  } = props;
+  return /* @__PURE__ */ jsx(
+    Controller,
+    {
+      id,
+      label,
+      layout,
+      isCodeDriven,
+      children: /* @__PURE__ */ jsx(
+        BaseParamsInput,
+        {
+          className,
+          type,
+          id,
+          onChange,
+          value,
+          disabled: isCodeDriven,
+          ...inputProps
+        }
+      )
+    }
+  );
+}
+function HTMLInputControllerWithTextInput(props) {
+  const {
+    label,
+    id,
+    onChange,
+    value,
+    type,
+    className,
+    inputProps = {},
+    layout = "default",
+    textInputProps,
+    isCodeDriven
+  } = props;
+  return /* @__PURE__ */ jsxs(
+    Controller,
+    {
+      id,
+      label,
+      layout,
+      isCodeDriven,
+      children: [
+        /* @__PURE__ */ jsx(
+          BaseParamsInput,
+          {
+            className,
+            type,
+            id,
+            onChange,
+            value,
+            autoComplete: "off",
+            disabled: isCodeDriven,
+            ...inputProps
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          BaseParamsInput,
+          {
+            type: "text",
+            id: `text-${id}`,
+            onChange,
+            value,
+            autoComplete: "off",
+            disabled: isCodeDriven,
+            ...textInputProps
+          }
+        )
+      ]
+    }
+  );
+}
+
+export {
+  Controller_module_default,
+  BaseParamsInput,
+  Controller,
+  HTMLInputController,
+  HTMLInputControllerWithTextInput
+};
+//# sourceMappingURL=chunk-CE3TPOSO.js.map

package/dist/chunk-CE3TPOSO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Controller/Controller.module.scss","../src/Controller/Controller.tsx"],"sourcesContent":["import 'css-chunk:src/Controller/Controller.module.scss';export default {\n  \"controller\": \"_controller_1rjbl_1\",\n  \"inputContainer\": \"_inputContainer_1rjbl_12\",\n  \"default\": \"_default_1rjbl_18\",\n  \"invert\": \"_invert_1rjbl_31\",\n  \"box\": \"_box_1rjbl_44\",\n  \"numberInput\": \"_numberInput_1rjbl_58\"\n};","import {\n  HTMLInputTypeAttribute,\n  InputHTMLAttributes,\n  ReactNode,\n  RefObject,\n} from \"react\"\nimport { FxParamOptionsMap, FxParamType } from \"../types\"\nimport classes from \"./Controller.module.scss\"\nimport cx from \"classnames\"\nimport { BaseInput } from \"../BaseInput\"\n\n/*\n * Providing a name starting or ending with `search` prevents\n * 1Password extension to appear in the input fields\n * https://1password.community/discussion/comment/606453/#Comment_606453\n */\nexport function BaseParamsInput(props: InputHTMLAttributes<HTMLInputElement>) {\n  const { id } = props\n  return (\n    <BaseInput name={`${id}-params-search`} autoComplete=\"off\" {...props} />\n  )\n}\n\nexport type FxParamInputChangeHandler = (e: any) => void\n\nexport interface ControllerProps {\n  label?: string\n  id?: string\n  children: ReactNode\n  layout?: \"default\" | \"invert\" | \"box\"\n  className?: string\n  inputContainerProps?: {\n    ref: RefObject<HTMLDivElement>\n  }\n  isCodeDriven?: boolean\n}\n\nexport function Controller(props: ControllerProps) {\n  const {\n    id,\n    label,\n    layout = \"default\",\n    className,\n    inputContainerProps,\n    isCodeDriven,\n  } = props\n  return (\n    <div\n      className={cx(classes.controller, classes[layout], className)}\n      title={\n        isCodeDriven\n          ? \"This parameter is solely code-driven. Controller is just shown for debugging purposes.\"\n          : \"\"\n      }\n    >\n      {id && <label htmlFor={id}>{label || id}</label>}\n      <div className={classes.inputContainer} {...inputContainerProps}>\n        {props.children}\n      </div>\n    </div>\n  )\n}\n\nexport interface HTMLInputControllerProps {\n  id: string\n  value: string\n  onChange: FxParamInputChangeHandler\n  type: HTMLInputTypeAttribute\n  inputProps?: InputHTMLAttributes<HTMLInputElement | HTMLSelectElement>\n  className?: string\n  label?: string\n  layout?: \"default\" | \"invert\" | \"box\"\n  isCodeDriven?: boolean\n}\n\nexport type FxParamControllerProps<Type extends FxParamType> = Omit<\n  HTMLInputControllerProps,\n  \"type\"\n> & {\n  value: any\n  options?: FxParamOptionsMap[Type]\n  onChange: FxParamInputChangeHandler\n}\n\nexport function HTMLInputController(props: HTMLInputControllerProps) {\n  const {\n    label,\n    id,\n    onChange,\n    value,\n    type,\n    className,\n    inputProps,\n    layout = \"default\",\n    isCodeDriven,\n  } = props\n  return (\n    <Controller\n      id={id}\n      label={label}\n      layout={layout}\n      isCodeDriven={isCodeDriven}\n    >\n      <BaseParamsInput\n        className={className}\n        type={type}\n        id={id}\n        onChange={onChange}\n        value={value}\n        disabled={isCodeDriven}\n        {...inputProps}\n      />\n    </Controller>\n  )\n}\n\nexport interface HTMLInputControllerWithTextInputProps\n  extends HTMLInputControllerProps {\n  textInputProps?: InputHTMLAttributes<HTMLInputElement>\n}\n\nexport function HTMLInputControllerWithTextInput(\n  props: HTMLInputControllerWithTextInputProps\n) {\n  const {\n    label,\n    id,\n    onChange,\n    value,\n    type,\n    className,\n    inputProps = {},\n    layout = \"default\",\n    textInputProps,\n    isCodeDriven,\n  } = props\n  return (\n    <Controller\n      id={id}\n      label={label}\n      layout={layout}\n      isCodeDriven={isCodeDriven}\n    >\n      <BaseParamsInput\n        className={className}\n        type={type}\n        id={id}\n        onChange={onChange}\n        value={value}\n        autoComplete=\"off\"\n        disabled={isCodeDriven}\n        {...inputProps}\n      />\n      <BaseParamsInput\n        type=\"text\"\n        id={`text-${id}`}\n        onChange={onChange}\n        value={value}\n        autoComplete=\"off\"\n        disabled={isCodeDriven}\n        {...textInputProps}\n      />\n    </Controller>\n  )\n}\n"],"mappings":";;;;;AAAyD,IAAO,4BAAQ;AAAA,EACtE,cAAc;AAAA,EACd,kBAAkB;AAAA,EAClB,WAAW;AAAA,EACX,UAAU;AAAA,EACV,OAAO;AAAA,EACP,eAAe;AACjB;;;ACCA,OAAO,QAAQ;AAWX,cA4BA,YA5BA;AAHG,SAAS,gBAAgB,OAA8C;AAC5E,QAAM,EAAE,GAAG,IAAI;AACf,SACE,oBAAC,aAAU,MAAM,GAAG,oBAAoB,cAAa,OAAO,GAAG,OAAO;AAE1E;AAgBO,SAAS,WAAW,OAAwB;AACjD,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,SACE;AAAA,IAAC;AAAA;AAAA,MACC,WAAW,GAAG,0BAAQ,YAAY,0BAAQ,MAAM,GAAG,SAAS;AAAA,MAC5D,OACE,eACI,2FACA;AAAA,MAGL;AAAA,cAAM,oBAAC,WAAM,SAAS,IAAK,mBAAS,IAAG;AAAA,QACxC,oBAAC,SAAI,WAAW,0BAAQ,gBAAiB,GAAG,qBACzC,gBAAM,UACT;AAAA;AAAA;AAAA,EACF;AAEJ;AAuBO,SAAS,oBAAoB,OAAiC;AACnE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT;AAAA,EACF,IAAI;AACJ,SACE;AAAA,IAAC;AAAA;AAAA,MACC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MAEA;AAAA,QAAC;AAAA;AAAA,UACC;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,UAAU;AAAA,UACT,GAAG;AAAA;AAAA,MACN;AAAA;AAAA,EACF;AAEJ;AAOO,SAAS,iCACd,OACA;AACA,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,aAAa,CAAC;AAAA,IACd,SAAS;AAAA,IACT;AAAA,IACA;AAAA,EACF,IAAI;AACJ,SACE;AAAA,IAAC;AAAA;AAAA,MACC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MAEA;AAAA;AAAA,UAAC;AAAA;AAAA,YACC;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA,cAAa;AAAA,YACb,UAAU;AAAA,YACT,GAAG;AAAA;AAAA,QACN;AAAA,QACA;AAAA,UAAC;AAAA;AAAA,YACC,MAAK;AAAA,YACL,IAAI,QAAQ;AAAA,YACZ;AAAA,YACA;AAAA,YACA,cAAa;AAAA,YACb,UAAU;AAAA,YACT,GAAG;AAAA;AAAA,QACN;AAAA;AAAA;AAAA,EACF;AAEJ;","names":[]}

package/dist/chunk-D4RVVQC7.cjs

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkHJBHIE5Tcjs = require('./chunk-HJBHIE5T.cjs');
+
+// src/Controller/Boolean.tsx
+var _jsxruntime = require('react/jsx-runtime');
+function BooleanController(props) {
+  const { ...rest } = props;
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _chunkHJBHIE5Tcjs.HTMLInputController,
+    {
+      type: "checkbox",
+      layout: "box",
+      inputProps: { checked: props.value },
+      ...rest
+    }
+  );
+}
+
+
+
+exports.BooleanController = BooleanController;
+//# sourceMappingURL=chunk-D4RVVQC7.cjs.map

package/dist/chunk-D4RVVQC7.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Controller/Boolean.tsx"],"names":[],"mappings":";;;;;AAMI;AAHG,SAAS,kBAAkB,OAA0C;AAC1E,QAAM,EAAE,GAAG,KAAK,IAAI;AACpB,SACE;AAAA,IAAC;AAAA;AAAA,MACC,MAAK;AAAA,MACL,QAAO;AAAA,MACP,YAAY,EAAE,SAAS,MAAM,MAAM;AAAA,MAClC,GAAG;AAAA;AAAA,EACN;AAEJ","sourcesContent":["import { FxParamControllerProps, HTMLInputController } from \"./Controller\"\nimport classes from \"./Controller.module.scss\"\n\nexport function BooleanController(props: FxParamControllerProps<\"boolean\">) {\n  const { ...rest } = props\n  return (\n    <HTMLInputController\n      type=\"checkbox\"\n      layout=\"box\"\n      inputProps={{ checked: props.value }}\n      {...rest}\n    />\n  )\n}\n"]}

package/dist/chunk-EACKNC6C.cjs

@@ -0,0 +1,103 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/validation.ts
+var _zod = require('zod');
+var ControllerTypeSchema = _zod.z.enum([
+  "number",
+  "bigint",
+  "color",
+  "string",
+  "bytes",
+  "boolean",
+  "select"
+]);
+var FxParamOptions_bigintSchema = _zod.z.object({
+  min: _zod.z.number().or(_zod.z.bigint()).optional(),
+  max: _zod.z.number().or(_zod.z.bigint()).optional()
+});
+var FxParamOptions_numberSchema = _zod.z.object({
+  min: _zod.z.number().gte(Number.MIN_SAFE_INTEGER).optional(),
+  max: _zod.z.number().lte(Number.MAX_SAFE_INTEGER).optional(),
+  step: _zod.z.number().optional()
+});
+var FxParamOptions_stringSchema = _zod.z.object({
+  minLength: _zod.z.number().gte(0).optional(),
+  maxLength: _zod.z.number().optional()
+});
+var FxParamOptions_bytesSchema = _zod.z.object({
+  length: _zod.z.number().gt(0)
+});
+var FxParamOptions_selectSchema = _zod.z.object({
+  options: _zod.z.string().array().nonempty()
+});
+var BaseControllerDefinitionSchema = _zod.z.object({
+  id: _zod.z.string(),
+  name: _zod.z.string().optional(),
+  exposedAsFeature: _zod.z.boolean().optional()
+});
+var StringControllerSchema = BaseControllerDefinitionSchema.extend({
+  type: _zod.z.literal(ControllerTypeSchema.enum.string),
+  options: FxParamOptions_stringSchema.optional(),
+  default: _zod.z.string().optional()
+});
+var BytesControllerSchema = BaseControllerDefinitionSchema.extend({
+  type: _zod.z.literal(ControllerTypeSchema.enum.bytes),
+  options: FxParamOptions_bytesSchema,
+  default: _zod.z.any().optional(),
+  update: _zod.z.literal("code-driven", {
+    invalid_type_error: "Bytes parameters must be code-driven",
+    required_error: "Bytes parameters must be code-driven"
+  })
+});
+var NumberControllerSchema = BaseControllerDefinitionSchema.extend({
+  type: _zod.z.literal(ControllerTypeSchema.enum.number),
+  options: FxParamOptions_numberSchema.optional(),
+  default: _zod.z.number().gte(Number.MIN_SAFE_INTEGER).lte(Number.MAX_SAFE_INTEGER).optional()
+});
+var BigIntControllerSchema = BaseControllerDefinitionSchema.extend({
+  type: _zod.z.literal(ControllerTypeSchema.enum.bigint),
+  options: FxParamOptions_bigintSchema.optional(),
+  default: _zod.z.bigint().optional()
+});
+var SelectControllerSchema = BaseControllerDefinitionSchema.extend({
+  type: _zod.z.literal(ControllerTypeSchema.enum.select),
+  options: FxParamOptions_selectSchema,
+  default: _zod.z.string().optional()
+});
+var BooleanControllerSchema = BaseControllerDefinitionSchema.extend({
+  type: _zod.z.literal(ControllerTypeSchema.enum.boolean),
+  options: _zod.z.undefined(),
+  default: _zod.z.boolean().optional()
+});
+var ColorControllerSchema = BaseControllerDefinitionSchema.extend({
+  type: _zod.z.literal(ControllerTypeSchema.enum.color),
+  options: _zod.z.undefined(),
+  default: _zod.z.string().optional()
+});
+var ControllerDefinitionSchema = _zod.z.union([
+  StringControllerSchema,
+  NumberControllerSchema,
+  BigIntControllerSchema,
+  SelectControllerSchema,
+  BytesControllerSchema,
+  BooleanControllerSchema,
+  ColorControllerSchema
+]);
+var controllerSchema = {
+  number: NumberControllerSchema,
+  bigint: BigIntControllerSchema,
+  color: ColorControllerSchema,
+  string: StringControllerSchema,
+  bytes: BytesControllerSchema,
+  boolean: BooleanControllerSchema,
+  select: SelectControllerSchema
+};
+function validateParameterDefinition(parameterDefinition) {
+  return _optionalChain([controllerSchema, 'access', _ => _[parameterDefinition.type], 'optionalAccess', _2 => _2.safeParse, 'call', _3 => _3(
+    parameterDefinition
+  )]);
+}
+
+
+
+
+exports.BaseControllerDefinitionSchema = BaseControllerDefinitionSchema; exports.validateParameterDefinition = validateParameterDefinition;
+//# sourceMappingURL=chunk-EACKNC6C.cjs.map

package/dist/chunk-EACKNC6C.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/validation.ts"],"names":[],"mappings":"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","sourcesContent":["import { SafeParseError, SafeParseSuccess, z } from \"zod\"\nimport { FxParamDefinition, FxParamType } from \"./types\"\n\nconst ControllerTypeSchema = z.enum([\n  \"number\",\n  \"bigint\",\n  \"color\",\n  \"string\",\n  \"bytes\",\n  \"boolean\",\n  \"select\",\n])\n\nconst FxParamOptions_bigintSchema = z.object({\n  min: z.number().or(z.bigint()).optional(),\n  max: z.number().or(z.bigint()).optional(),\n})\n\nconst FxParamOptions_numberSchema = z.object({\n  min: z.number().gte(Number.MIN_SAFE_INTEGER).optional(),\n  max: z.number().lte(Number.MAX_SAFE_INTEGER).optional(),\n  step: z.number().optional(),\n})\n\nconst FxParamOptions_stringSchema = z.object({\n  minLength: z.number().gte(0).optional(),\n  maxLength: z.number().optional(),\n})\n\nconst FxParamOptions_bytesSchema = z.object({\n  length: z.number().gt(0),\n})\n\nconst FxParamOptions_selectSchema = z.object({\n  options: z.string().array().nonempty(),\n})\n\nexport const BaseControllerDefinitionSchema = z.object({\n  id: z.string(),\n  name: z.string().optional(),\n  exposedAsFeature: z.boolean().optional(),\n})\n\nconst StringControllerSchema = BaseControllerDefinitionSchema.extend({\n  type: z.literal(ControllerTypeSchema.enum.string),\n  options: FxParamOptions_stringSchema.optional(),\n  default: z.string().optional(),\n})\n\nconst BytesControllerSchema = BaseControllerDefinitionSchema.extend({\n  type: z.literal(ControllerTypeSchema.enum.bytes),\n  options: FxParamOptions_bytesSchema,\n  default: z.any().optional(),\n  update: z.literal(\"code-driven\", {\n    invalid_type_error: \"Bytes parameters must be code-driven\",\n    required_error: \"Bytes parameters must be code-driven\",\n  }),\n})\n\nconst NumberControllerSchema = BaseControllerDefinitionSchema.extend({\n  type: z.literal(ControllerTypeSchema.enum.number),\n  options: FxParamOptions_numberSchema.optional(),\n  default: z\n    .number()\n    .gte(Number.MIN_SAFE_INTEGER)\n    .lte(Number.MAX_SAFE_INTEGER)\n    .optional(),\n})\n\nconst BigIntControllerSchema = BaseControllerDefinitionSchema.extend({\n  type: z.literal(ControllerTypeSchema.enum.bigint),\n  options: FxParamOptions_bigintSchema.optional(),\n  default: z.bigint().optional(),\n})\n\nconst SelectControllerSchema = BaseControllerDefinitionSchema.extend({\n  type: z.literal(ControllerTypeSchema.enum.select),\n  options: FxParamOptions_selectSchema,\n  default: z.string().optional(),\n})\n\nconst BooleanControllerSchema = BaseControllerDefinitionSchema.extend({\n  type: z.literal(ControllerTypeSchema.enum.boolean),\n  options: z.undefined(),\n  default: z.boolean().optional(),\n})\n\nconst ColorControllerSchema = BaseControllerDefinitionSchema.extend({\n  type: z.literal(ControllerTypeSchema.enum.color),\n  options: z.undefined(),\n  default: z.string().optional(),\n})\n\nconst ControllerDefinitionSchema = z.union([\n  StringControllerSchema,\n  NumberControllerSchema,\n  BigIntControllerSchema,\n  SelectControllerSchema,\n  BytesControllerSchema,\n  BooleanControllerSchema,\n  ColorControllerSchema,\n])\n\nexport type ControllerDefinitionSchemaType = z.infer<\n  typeof ControllerDefinitionSchema\n>\n\nconst controllerSchema = {\n  number: NumberControllerSchema,\n  bigint: BigIntControllerSchema,\n  color: ColorControllerSchema,\n  string: StringControllerSchema,\n  bytes: BytesControllerSchema,\n  boolean: BooleanControllerSchema,\n  select: SelectControllerSchema,\n}\n\nexport function validateParameterDefinition(\n  parameterDefinition: FxParamDefinition<FxParamType>\n):\n  | SafeParseError<ControllerDefinitionSchemaType>\n  | SafeParseSuccess<ControllerDefinitionSchemaType>\n  | undefined {\n  return controllerSchema[parameterDefinition.type]?.safeParse(\n    parameterDefinition\n  )\n}\n"]}

package/dist/chunk-FZWZHHQ2.js

@@ -0,0 +1,398 @@
+// 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 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 getRandomParamValues(params, options) {
+  return params.reduce((acc, definition) => {
+    const processor = ParameterProcessors[definition.type];
+    const v = processor.random(definition);
+    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);
+  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 {
+  rgbaToHex,
+  hexToRgba,
+  MIN_SAFE_INT64,
+  MAX_SAFE_INT64,
+  ParameterProcessors,
+  serializeParams,
+  deserializeParams,
+  consolidateParams,
+  getRandomParamValues,
+  sumBytesParams,
+  stringifyParamsData,
+  jsonStringifyBigint,
+  processParam,
+  processParams
+};
+//# sourceMappingURL=chunk-FZWZHHQ2.js.map