@schemashift/zod-valibot 0.7.0

package/README.md

@@ -0,0 +1,200 @@
+# @schemashift/zod-valibot
+
+Zod to Valibot transformer for SchemaShift. Converts Zod's fluent method chain API to Valibot's pipe-based API with AST-based transformations.
+
+**Tier:** Pro
+
+## Installation
+
+```bash
+npm install @schemashift/zod-valibot
+```
+
+## Usage
+
+```typescript
+import { createZodToValibotHandler } from '@schemashift/zod-valibot';
+import { TransformEngine } from '@schemashift/core';
+
+const engine = new TransformEngine();
+engine.registerHandler('zod', 'valibot', createZodToValibotHandler());
+```
+
+## API Model Difference
+
+Zod uses a fluent **method chain** API:
+
+```typescript
+z.string().email().min(5).max(100)
+```
+
+Valibot uses a **pipe-based** API where validations are arguments to `v.pipe()`:
+
+```typescript
+v.pipe(v.string(), v.email(), v.minLength(5), v.maxLength(100))
+```
+
+Modifiers like `.optional()` and `.nullable()` become wrapping functions:
+
+```typescript
+// Zod
+z.string().optional()
+
+// Valibot
+v.optional(v.string())
+```
+
+## Transformation Mappings
+
+### Imports
+
+| Zod | Valibot |
+|-----|---------|
+| `import { z } from 'zod'` | `import * as v from 'valibot'` |
+| `import * as z from 'zod'` | `import * as v from 'valibot'` |
+
+### Factory Methods
+
+| Zod | Valibot |
+|-----|---------|
+| `z.string()` | `v.string()` |
+| `z.number()` | `v.number()` |
+| `z.boolean()` | `v.boolean()` |
+| `z.date()` | `v.date()` |
+| `z.bigint()` | `v.bigint()` |
+| `z.symbol()` | `v.symbol()` |
+| `z.undefined()` | `v.undefined_()` |
+| `z.null()` | `v.null_()` |
+| `z.void()` | `v.void_()` |
+| `z.any()` | `v.any()` |
+| `z.unknown()` | `v.unknown()` |
+| `z.never()` | `v.never()` |
+| `z.nan()` | `v.nan()` |
+| `z.literal(val)` | `v.literal(val)` |
+| `z.enum([...])` | `v.picklist([...])` |
+| `z.nativeEnum(E)` | `v.enum_(E)` |
+| `z.array(s)` | `v.array(s)` |
+| `z.object({...})` | `v.object({...})` |
+| `z.record(k, v)` | `v.record(k, v)` |
+| `z.tuple([...])` | `v.tuple([...])` |
+| `z.union([...])` | `v.union([...])` |
+| `z.discriminatedUnion(d, [...])` | `v.variant(d, [...])` |
+| `z.intersection(a, b)` | `v.intersect(a, b)` |
+| `z.lazy(() => s)` | `v.lazy(() => s)` |
+| `z.promise(s)` | `v.promise(s)` |
+| `z.instanceof(C)` | `v.instance(C)` |
+
+### String Validations (Pipe)
+
+| Zod | Valibot |
+|-----|---------|
+| `.email()` | `v.email()` |
+| `.url()` | `v.url()` |
+| `.uuid()` | `v.uuid()` |
+| `.regex(r)` | `v.regex(r)` |
+| `.ip()` | `v.ip()` |
+| `.min(n)` | `v.minLength(n)` |
+| `.max(n)` | `v.maxLength(n)` |
+| `.length(n)` | `v.length(n)` |
+| `.trim()` | `v.trim()` |
+| `.toLowerCase()` | `v.toLowerCase()` |
+| `.toUpperCase()` | `v.toUpperCase()` |
+| `.includes(s)` | `v.includes(s)` |
+| `.startsWith(s)` | `v.startsWith(s)` |
+| `.endsWith(s)` | `v.endsWith(s)` |
+| `.datetime()` | `v.isoDateTime()` |
+| `.date()` | `v.isoDate()` |
+| `.time()` | `v.isoTime()` |
+| `.emoji()` | `v.emoji()` |
+
+### Number Validations (Pipe)
+
+| Zod | Valibot |
+|-----|---------|
+| `.min(n)` | `v.minValue(n)` |
+| `.max(n)` | `v.maxValue(n)` |
+| `.gt(n)` | `v.minValue(n + 1)` |
+| `.lt(n)` | `v.maxValue(n - 1)` |
+| `.gte(n)` | `v.minValue(n)` |
+| `.lte(n)` | `v.maxValue(n)` |
+| `.int()` | `v.integer()` |
+| `.positive()` | `v.minValue(1)` |
+| `.negative()` | `v.maxValue(-1)` |
+| `.nonnegative()` | `v.minValue(0)` |
+| `.nonpositive()` | `v.maxValue(0)` |
+| `.multipleOf(n)` | `v.multipleOf(n)` |
+| `.finite()` | `v.finite()` |
+| `.safe()` | `v.safeInteger()` |
+
+### Array Validations
+
+| Zod | Valibot |
+|-----|---------|
+| `.min(n)` | `v.minLength(n)` |
+| `.max(n)` | `v.maxLength(n)` |
+| `.nonempty()` | `v.nonEmpty()` |
+
+### Modifiers (Wrapping)
+
+| Zod | Valibot |
+|-----|---------|
+| `.optional()` | `v.optional(schema)` |
+| `.nullable()` | `v.nullable(schema)` |
+| `.nullish()` | `v.nullish(schema)` |
+| `.default(val)` | `v.optional(schema, val)` |
+| `.catch(val)` | `v.fallback(schema, val)` |
+| `.readonly()` | `v.readonly(schema)` |
+| `.transform(fn)` | `v.pipe(schema, v.transform(fn))` |
+| `.refine(fn, msg)` | `v.pipe(schema, v.check(fn, msg))` |
+| `.brand(name)` | `v.pipe(schema, v.brand(name))` |
+| `.describe(msg)` | (removed — Valibot has no equivalent) |
+
+### Object Methods (Wrapping)
+
+| Zod | Valibot |
+|-----|---------|
+| `.partial()` | `v.partial(schema)` |
+| `.required()` | `v.required(schema)` |
+| `.pick({...})` | `v.pick(schema, {...})` |
+| `.omit({...})` | `v.omit(schema, {...})` |
+| `.extend(other)` | `v.merge([schema, other])` |
+| `.merge(other)` | `v.merge([schema, other])` |
+| `.strict()` | `v.strict(schema)` |
+| `.passthrough()` | (no-op — Valibot objects are loose by default) |
+| `.strip()` | (no-op — Valibot strips unknown by default with v.object) |
+
+### Type Helpers
+
+| Zod | Valibot |
+|-----|---------|
+| `z.infer<typeof s>` | `v.InferOutput<typeof s>` |
+| `z.input<typeof s>` | `v.InferInput<typeof s>` |
+| `z.output<typeof s>` | `v.InferOutput<typeof s>` |
+
+## Patterns Requiring Manual Review
+
+### `.superRefine()`
+
+`.superRefine()` is converted with a warning since Valibot's custom validation has a different API:
+
+```typescript
+// Zod
+z.object({...}).superRefine((data, ctx) => {
+  ctx.addIssue({ code: 'custom', message: '...' });
+});
+
+// Valibot (needs manual conversion)
+v.pipe(v.object({...}), /* TODO: superRefine -> custom validation */ v.check(...))
+```
+
+### `.catchall()`
+
+Zod's `.catchall()` for extra properties requires manual conversion to Valibot's `v.record()` or custom validation.
+
+### `.keyof()`
+
+Zod's `.keyof()` requires manual conversion to `v.picklist(Object.keys(...))`.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,487 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FACTORY_MAPPINGS: () => FACTORY_MAPPINGS,
+  MODIFIER_METHODS: () => MODIFIER_METHODS,
+  NUMBER_VALIDATION_MAPPINGS: () => NUMBER_VALIDATION_MAPPINGS,
+  OBJECT_METHODS: () => OBJECT_METHODS,
+  VALIDATION_MAPPINGS: () => VALIDATION_MAPPINGS,
+  ZodToValibotTransformer: () => ZodToValibotTransformer,
+  createZodToValibotHandler: () => createZodToValibotHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/transformer.ts
+var import_core = require("@schemashift/core");
+var import_ts_morph = require("ts-morph");
+
+// src/mappings.ts
+var FACTORY_MAPPINGS = {
+  string: "v.string",
+  number: "v.number",
+  boolean: "v.boolean",
+  date: "v.date",
+  bigint: "v.bigint",
+  symbol: "v.symbol",
+  undefined: "v.undefined_",
+  null: "v.null_",
+  void: "v.void_",
+  any: "v.any",
+  unknown: "v.unknown",
+  never: "v.never",
+  nan: "v.nan",
+  literal: "v.literal",
+  enum: "v.picklist",
+  nativeEnum: "v.enum_",
+  array: "v.array",
+  object: "v.object",
+  record: "v.record",
+  tuple: "v.tuple",
+  union: "v.union",
+  discriminatedUnion: "v.variant",
+  intersection: "v.intersect",
+  lazy: "v.lazy",
+  promise: "v.promise",
+  instanceof: "v.instance"
+};
+var VALIDATION_MAPPINGS = {
+  // String validations
+  email: "v.email",
+  url: "v.url",
+  uuid: "v.uuid",
+  cuid: "v.cuid2",
+  cuid2: "v.cuid2",
+  ulid: "v.ulid",
+  regex: "v.regex",
+  ip: "v.ip",
+  datetime: "v.isoDateTime",
+  date: "v.isoDate",
+  time: "v.isoTime",
+  emoji: "v.emoji",
+  includes: "v.includes",
+  startsWith: "v.startsWith",
+  endsWith: "v.endsWith",
+  trim: "v.trim",
+  toLowerCase: "v.toLowerCase",
+  toUpperCase: "v.toUpperCase",
+  // Shared validations (string/number/array/date)
+  min: "v.minLength",
+  // Will be context-sensitive
+  max: "v.maxLength",
+  // Will be context-sensitive
+  length: "v.length",
+  // Number validations
+  gt: "v.minValue",
+  gte: "v.minValue",
+  lt: "v.maxValue",
+  lte: "v.maxValue",
+  int: "v.integer",
+  positive: "v.minValue",
+  negative: "v.maxValue",
+  nonnegative: "v.minValue",
+  nonpositive: "v.maxValue",
+  multipleOf: "v.multipleOf",
+  finite: "v.finite",
+  safe: "v.safeInteger",
+  // Array validations
+  nonempty: "v.nonEmpty",
+  // Schema modifiers (not pipe validators)
+  optional: null,
+  // Handled specially
+  nullable: null,
+  // Handled specially
+  nullish: null,
+  // Handled specially
+  default: null,
+  // Handled specially
+  catch: null,
+  // Handled specially
+  transform: null,
+  // Handled specially
+  refine: null,
+  // Handled specially
+  superRefine: null,
+  // Handled specially
+  brand: null,
+  // Handled specially
+  readonly: null,
+  // Handled specially
+  pipe: null,
+  // Handled specially
+  describe: null,
+  // Handled specially
+  // Object methods
+  partial: null,
+  // Handled specially
+  required: null,
+  // Handled specially
+  pick: null,
+  // Handled specially
+  omit: null,
+  // Handled specially
+  extend: null,
+  // Handled specially
+  merge: null,
+  // Handled specially
+  passthrough: null,
+  // Handled specially
+  strict: null,
+  // Handled specially
+  strip: null,
+  // Handled specially
+  catchall: null,
+  // Handled specially
+  keyof: null,
+  // Handled specially
+  // Array methods
+  element: null
+  // Part of factory
+};
+var NUMBER_VALIDATION_MAPPINGS = {
+  min: { name: "v.minValue", args: (a) => a },
+  max: { name: "v.maxValue", args: (a) => a },
+  gt: { name: "v.minValue", args: (a) => a.length > 0 ? [String(Number(a[0]) + 1)] : a },
+  lt: { name: "v.maxValue", args: (a) => a.length > 0 ? [String(Number(a[0]) - 1)] : a },
+  gte: { name: "v.minValue", args: (a) => a },
+  lte: { name: "v.maxValue", args: (a) => a },
+  positive: { name: "v.minValue", args: () => ["1"] },
+  negative: { name: "v.maxValue", args: () => ["-1"] },
+  nonnegative: { name: "v.minValue", args: () => ["0"] },
+  nonpositive: { name: "v.maxValue", args: () => ["0"] }
+};
+var MODIFIER_METHODS = /* @__PURE__ */ new Set([
+  "optional",
+  "nullable",
+  "nullish",
+  "default",
+  "catch",
+  "readonly",
+  "brand",
+  "describe",
+  "transform",
+  "refine",
+  "superRefine",
+  "pipe"
+]);
+var OBJECT_METHODS = /* @__PURE__ */ new Set([
+  "partial",
+  "required",
+  "pick",
+  "omit",
+  "extend",
+  "merge",
+  "passthrough",
+  "strict",
+  "strip",
+  "catchall",
+  "keyof"
+]);
+
+// src/transformer.ts
+var ZodToValibotTransformer = class {
+  errors = [];
+  warnings = [];
+  transform(sourceFile) {
+    this.errors = [];
+    this.warnings = [];
+    const filePath = sourceFile.getFilePath();
+    const originalCode = sourceFile.getFullText();
+    try {
+      this.updateImports(sourceFile);
+      this.transformTypeHelpers(sourceFile);
+      this.transformSchemaExpressions(sourceFile);
+      return {
+        success: this.errors.length === 0,
+        filePath,
+        originalCode,
+        transformedCode: sourceFile.getFullText(),
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    } catch (error) {
+      this.errors.push({
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+      return {
+        success: false,
+        filePath,
+        originalCode,
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    }
+  }
+  updateImports(sourceFile) {
+    const zodImports = sourceFile.getImportDeclarations().filter((imp) => imp.getModuleSpecifierValue() === "zod");
+    for (const imp of zodImports) {
+      imp.setModuleSpecifier("valibot");
+      const namespaceImport = imp.getNamespaceImport();
+      const defaultImport = imp.getDefaultImport();
+      const namedImports = imp.getNamedImports();
+      if (namespaceImport) imp.removeNamespaceImport();
+      if (defaultImport) imp.removeDefaultImport();
+      if (namedImports.length > 0) imp.removeNamedImports();
+      imp.setNamespaceImport("v");
+    }
+  }
+  transformTypeHelpers(sourceFile) {
+    const fullText = sourceFile.getFullText();
+    let newText = fullText;
+    newText = newText.replace(/\bz\.infer</g, "v.InferOutput<");
+    newText = newText.replace(/\bz\.input</g, "v.InferInput<");
+    newText = newText.replace(/\bz\.output</g, "v.InferOutput<");
+    if (newText !== fullText) {
+      sourceFile.replaceWithText(newText);
+    }
+  }
+  transformSchemaExpressions(sourceFile) {
+    const nodesToTransform = [];
+    sourceFile.forEachDescendant((node) => {
+      if (import_ts_morph.Node.isCallExpression(node)) {
+        if ((0, import_core.isInsideStringLiteral)(node)) return;
+        const text = node.getText();
+        if (text.startsWith("z.")) {
+          nodesToTransform.push(node);
+        }
+      }
+    });
+    const outermost = this.filterOutermostNodes(nodesToTransform);
+    outermost.sort((a, b) => b.getStart() - a.getStart());
+    for (const node of outermost) {
+      this.transformCallChain(node);
+    }
+  }
+  filterOutermostNodes(nodes) {
+    const result = [];
+    for (const node of nodes) {
+      let isChild = false;
+      for (const other of nodes) {
+        if (other === node) continue;
+        if (other.getStart() <= node.getStart() && other.getEnd() >= node.getEnd()) {
+          isChild = true;
+          break;
+        }
+      }
+      if (!isChild) result.push(node);
+    }
+    return result;
+  }
+  transformCallChain(node) {
+    const chain = (0, import_core.parseCallChain)(node);
+    if (!chain) {
+      this.transformCallChainFallback(node);
+      return;
+    }
+    if (chain.base !== "z") return;
+    const filePath = node.getSourceFile().getFilePath();
+    const lineNumber = node.getStartLineNumber();
+    const factoryMapping = FACTORY_MAPPINGS[chain.factoryMethod];
+    if (!factoryMapping) {
+      this.warnings.push(
+        `${filePath}:${lineNumber}: Unknown Zod factory z.${chain.factoryMethod}() \u2014 kept as-is`
+      );
+      return;
+    }
+    const factoryType = chain.factoryMethod;
+    const pipeValidators = [];
+    const modifiers = [];
+    const objectMethods = [];
+    for (const method of chain.methods) {
+      const result2 = this.categorizeMethod(method, factoryType, filePath, lineNumber);
+      if (result2.type === "pipe") {
+        pipeValidators.push(result2.code);
+      } else if (result2.type === "modifier") {
+        modifiers.push({ name: result2.name, args: result2.args });
+      } else if (result2.type === "object") {
+        objectMethods.push({ name: result2.name, args: result2.args });
+      }
+    }
+    let result;
+    const factoryCall = `${factoryMapping}(${chain.factoryArgs.join(", ")})`;
+    if (pipeValidators.length > 0) {
+      result = `v.pipe(${factoryCall}, ${pipeValidators.join(", ")})`;
+    } else {
+      result = factoryCall;
+    }
+    for (const objMethod of objectMethods) {
+      result = this.applyObjectMethod(objMethod.name, objMethod.args, result, filePath, lineNumber);
+    }
+    for (const modifier of modifiers) {
+      result = this.applyModifier(modifier.name, modifier.args, result, filePath, lineNumber);
+    }
+    result = this.transformNestedZodReferences(result);
+    node.replaceWithText(result);
+  }
+  transformNestedZodReferences(text) {
+    let result = text;
+    for (const [zodName, valibotName] of Object.entries(FACTORY_MAPPINGS)) {
+      const regex = new RegExp(`\\bz\\.${zodName}\\(`, "g");
+      result = result.replace(regex, `${valibotName}(`);
+    }
+    return result;
+  }
+  categorizeMethod(method, factoryType, filePath, lineNumber) {
+    const { name, args } = method;
+    if (MODIFIER_METHODS.has(name)) {
+      return { type: "modifier", name, args };
+    }
+    if (OBJECT_METHODS.has(name)) {
+      return { type: "object", name, args };
+    }
+    if ((factoryType === "number" || factoryType === "bigint") && NUMBER_VALIDATION_MAPPINGS[name]) {
+      const mapping = NUMBER_VALIDATION_MAPPINGS[name];
+      if (!mapping) return { type: "skip" };
+      const mappedArgs = mapping.args(args);
+      return { type: "pipe", code: `${mapping.name}(${mappedArgs.join(", ")})` };
+    }
+    if (factoryType === "string" || factoryType === "array") {
+      if (name === "min") {
+        const vName = factoryType === "string" ? "v.minLength" : "v.minLength";
+        return { type: "pipe", code: `${vName}(${args.join(", ")})` };
+      }
+      if (name === "max") {
+        const vName = factoryType === "string" ? "v.maxLength" : "v.maxLength";
+        return { type: "pipe", code: `${vName}(${args.join(", ")})` };
+      }
+    }
+    const validationMapping = VALIDATION_MAPPINGS[name];
+    if (validationMapping === null) {
+      return { type: "skip" };
+    }
+    if (validationMapping) {
+      return { type: "pipe", code: `${validationMapping}(${args.join(", ")})` };
+    }
+    this.warnings.push(
+      `${filePath}:${lineNumber}: Unknown Zod method .${name}() \u2014 kept as-is in pipe`
+    );
+    return { type: "pipe", code: `/* TODO: .${name}(${args.join(", ")}) */` };
+  }
+  applyModifier(name, args, inner, filePath, lineNumber) {
+    switch (name) {
+      case "optional":
+        return `v.optional(${inner})`;
+      case "nullable":
+        return `v.nullable(${inner})`;
+      case "nullish":
+        return `v.nullish(${inner})`;
+      case "default":
+        return `v.optional(${inner}, ${args.join(", ")})`;
+      case "catch":
+        return `v.fallback(${inner}, ${args.join(", ")})`;
+      case "readonly":
+        return `v.readonly(${inner})`;
+      case "transform":
+        return `v.pipe(${inner}, v.transform(${args.join(", ")}))`;
+      case "refine":
+        if (args.length >= 2) {
+          return `v.pipe(${inner}, v.check(${args[0]}, ${args.slice(1).join(", ")}))`;
+        }
+        return `v.pipe(${inner}, v.check(${args.join(", ")}))`;
+      case "superRefine":
+        this.warnings.push(
+          `${filePath}:${lineNumber}: .superRefine() requires manual conversion to Valibot custom validation`
+        );
+        return `v.pipe(${inner}, /* TODO: superRefine -> custom validation */ v.check(${args.join(", ")}))`;
+      case "brand":
+        return `v.pipe(${inner}, v.brand(${args.join(", ")}))`;
+      case "describe":
+        return inner;
+      case "pipe":
+        return `v.pipe(${inner}, ${args.join(", ")})`;
+      default:
+        return inner;
+    }
+  }
+  applyObjectMethod(name, args, inner, filePath, lineNumber) {
+    switch (name) {
+      case "partial":
+        return `v.partial(${inner})`;
+      case "required":
+        return `v.required(${inner})`;
+      case "pick":
+        return `v.pick(${inner}, ${args.join(", ")})`;
+      case "omit":
+        return `v.omit(${inner}, ${args.join(", ")})`;
+      case "extend":
+      case "merge":
+        return `v.merge([${inner}, ${args.join(", ")}])`;
+      case "passthrough":
+        this.warnings.push(
+          `${filePath}:${lineNumber}: .passthrough() \u2014 Valibot objects are loose by default, no action needed`
+        );
+        return inner;
+      case "strict":
+        return `v.strict(${inner})`;
+      case "strip":
+        return inner;
+      // Valibot strips unknown by default when using v.object
+      case "catchall":
+        this.warnings.push(
+          `${filePath}:${lineNumber}: .catchall() requires manual conversion to Valibot record or custom validation`
+        );
+        return inner;
+      case "keyof":
+        this.warnings.push(
+          `${filePath}:${lineNumber}: .keyof() requires manual conversion to v.picklist(Object.keys(...))`
+        );
+        return inner;
+      default:
+        return inner;
+    }
+  }
+  transformCallChainFallback(node) {
+    const text = node.getText();
+    const filePath = node.getSourceFile().getFilePath();
+    const lineNumber = node.getStartLineNumber();
+    let transformed = text;
+    transformed = transformed.replace(/^z\./, "v.");
+    for (const [zodName, valibotName] of Object.entries(FACTORY_MAPPINGS)) {
+      const regex = new RegExp(`\\bv\\.${zodName}\\(`, "g");
+      transformed = transformed.replace(regex, `${valibotName}(`);
+    }
+    this.warnings.push(
+      `${filePath}:${lineNumber}: Complex Zod expression used fallback conversion \u2014 manual review recommended`
+    );
+    node.replaceWithText(transformed);
+  }
+};
+
+// src/handler.ts
+function createZodToValibotHandler() {
+  const transformer = new ZodToValibotTransformer();
+  return {
+    transform(sourceFile, _options) {
+      return transformer.transform(sourceFile);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FACTORY_MAPPINGS,
+  MODIFIER_METHODS,
+  NUMBER_VALIDATION_MAPPINGS,
+  OBJECT_METHODS,
+  VALIDATION_MAPPINGS,
+  ZodToValibotTransformer,
+  createZodToValibotHandler
+});
+//# sourceMappingURL=index.cjs.map