zodbridge 0.2.0

package/dist/index.cjs

@@ -0,0 +1,786 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/map/rules.ts
+function fromResolver(field) {
+  return { __kind: "fromResolver", field };
+}
+function withDefault(value, source) {
+  return { __kind: "default", value, source };
+}
+function isStringRule(rule) {
+  return typeof rule === "string";
+}
+function isFromResolverRule(rule) {
+  return typeof rule === "object" && rule !== null && rule.__kind === "fromResolver";
+}
+function isPairRule(rule) {
+  return typeof rule === "object" && rule !== null && typeof rule.to === "function" && typeof rule.from === "function";
+}
+function isDefaultRule(rule) {
+  return typeof rule === "object" && rule !== null && rule.__kind === "default";
+}
+function isFnRule(rule) {
+  return typeof rule === "function";
+}
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function isForbidden(key) {
+  return FORBIDDEN_KEYS.has(key);
+}
+function splitPath(path) {
+  return path.split(".");
+}
+function getPath(source, path) {
+  let current = source;
+  for (const segment of splitPath(path)) {
+    if (isForbidden(segment)) return void 0;
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    if (!Object.prototype.hasOwnProperty.call(current, segment)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function setPath(target, path, value) {
+  const segments = splitPath(path);
+  let current = target;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (isForbidden(segment)) return;
+    if (i === segments.length - 1) {
+      current[segment] = value;
+      return;
+    }
+    const next = current[segment];
+    if (typeof next !== "object" || next === null) {
+      const fresh = {};
+      current[segment] = fresh;
+      current = fresh;
+    } else {
+      current = next;
+    }
+  }
+}
+
+// src/resolver/context.ts
+var EMPTY_ANCESTORS = /* @__PURE__ */ new Set();
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+var GraphContext = class {
+  adapter;
+  seed;
+  resolvers;
+  schemas;
+  onResolve;
+  /** Durable promise-cache: every attempted field lives here. */
+  cache = /* @__PURE__ */ new Map();
+  /** Synchronously-readable settled values, for `get`/`path` peeks. */
+  settled = /* @__PURE__ */ new Map();
+  /** Fields with an in-flight resolver; transient cycle guard. */
+  inProgress = /* @__PURE__ */ new Set();
+  /** Fields explicitly invalidated: prefer the resolver over seed on next resolve. */
+  invalidated = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.adapter = config.adapter;
+    this.seed = config.seed ?? {};
+    this.resolvers = config.resolvers ?? {};
+    this.schemas = config.schemas ?? {};
+    this.onResolve = config.onResolve;
+  }
+  /** Synchronous peek of seed first, then any settled resolved value. */
+  peek(field) {
+    const seeded = this.seed[field];
+    if (seeded !== void 0) return seeded;
+    return this.settled.get(field);
+  }
+  get(field) {
+    return this.peek(field);
+  }
+  path(field, keyPath) {
+    const base = this.peek(field);
+    if (base === void 0) return void 0;
+    if (keyPath.length === 0) return base;
+    return getPath(base, keyPath.join("."));
+  }
+  /** Public entry: a fresh resolution chain with no ancestors. */
+  resolve(field) {
+    return this.resolveWithin(field, EMPTY_ANCESTORS);
+  }
+  /**
+   * Resolve `field` within a chain whose currently-resolving fields are
+   * `ancestors`. If `field` is itself an ancestor, this is a dependency cycle
+   * (mutual A<->B, longer A->B->C->A, or self x->x): return `undefined` so the
+   * caller (e.g. a `strategies` candidate) falls through to its next route,
+   * instead of awaiting its own still-pending promise (which would deadlock).
+   *
+   * The ancestor check runs BEFORE the `cache.has` short-circuit, so a CONCURRENT
+   * caller (a parallel `Promise.all` chain — `field` is in-flight but NOT its
+   * ancestor) still receives the shared pending promise and dedups normally.
+   */
+  resolveWithin(field, ancestors) {
+    if (ancestors.has(field)) {
+      return Promise.resolve(void 0);
+    }
+    const cached = this.cache.get(field);
+    if (cached !== void 0) return cached;
+    const resolver = this.resolvers[field];
+    const preferResolver = this.invalidated.has(field) && resolver !== void 0;
+    const seeded = this.seed[field];
+    if (seeded !== void 0 && !preferResolver) {
+      const p2 = Promise.resolve(seeded);
+      this.cache.set(field, p2);
+      return p2;
+    }
+    if (resolver) {
+      this.invalidated.delete(field);
+      const deferred = defer();
+      this.cache.set(field, deferred.promise);
+      this.inProgress.add(field);
+      const childAncestors = new Set(ancestors).add(field);
+      this.runResolver(field, resolver, deferred, childAncestors);
+      return deferred.promise;
+    }
+    const p = Promise.resolve(void 0);
+    this.cache.set(field, p);
+    return p;
+  }
+  /**
+   * A context bound to `self` and the chain's `ancestors`: identical to the
+   * top-level context except `resolve`/`fallback` carry the chain so cycles
+   * break (see {@link resolveWithin}) and `fallback` retries the right field.
+   * Binding per invocation (not shared instance state) keeps concurrent
+   * resolutions from contaminating each other.
+   */
+  boundContext(self, ancestors) {
+    return {
+      adapter: this.adapter,
+      resolve: (field) => this.resolveWithin(field, ancestors),
+      resolveMany: (...fields) => this.resolveMany(...fields),
+      get: (field) => this.get(field),
+      path: (field, keyPath) => this.path(field, keyPath),
+      fallback: (deps) => this.fallbackFor(self, deps, ancestors),
+      invalidate: (...fields) => this.invalidate(...fields),
+      refresh: (field) => this.refresh(field)
+    };
+  }
+  invalidate(...fields) {
+    for (const field of fields) {
+      this.cache.delete(field);
+      this.settled.delete(field);
+      if (this.resolvers[field] !== void 0) this.invalidated.add(field);
+    }
+    return this;
+  }
+  refresh(field) {
+    this.invalidate(field);
+    return this.resolve(field);
+  }
+  /** Fire the best-effort `onResolve` observer; never let it break resolution. */
+  emitResolved(field, value) {
+    if (!this.onResolve) return;
+    try {
+      this.onResolve(field, value);
+    } catch {
+    }
+  }
+  runResolver(field, resolver, deferred, ancestors) {
+    const ctx = this.boundContext(field, ancestors);
+    Promise.resolve().then(() => resolver(ctx)).then((value) => this.validate(field, value)).then(
+      (value) => {
+        this.settled.set(field, value);
+        this.inProgress.delete(field);
+        this.emitResolved(field, value);
+        deferred.resolve(value);
+      },
+      (error) => {
+        this.cache.delete(field);
+        this.inProgress.delete(field);
+        deferred.reject(error);
+      }
+    );
+  }
+  /**
+   * Validate a resolver's output against its field schema (if any). A defined
+   * value is parsed (unknown keys stripped); a parse failure throws the ZodError,
+   * which the reject branch turns into an eviction. `undefined` is the forgiving
+   * absence terminal and is never validated.
+   */
+  async validate(field, value) {
+    const schema = this.schemas[field];
+    if (schema === void 0 || value === void 0) return value;
+    return await schema.parseAsync(value);
+  }
+  /** Resolve untouched `deps`, then retry `self`'s resolver if any produced a value. */
+  async fallbackFor(self, deps, ancestors) {
+    let resolvedAny = false;
+    for (const dep of deps) {
+      if (this.cache.has(dep) || this.inProgress.has(dep)) continue;
+      const value = await this.resolveWithin(dep, ancestors);
+      if (value) resolvedAny = true;
+    }
+    if (!resolvedAny) return void 0;
+    const resolver = this.resolvers[self];
+    return resolver(this.boundContext(self, ancestors));
+  }
+  /**
+   * Top-level `fallback` has no calling field, so there is nothing to retry.
+   * Resolvers always receive a field-bound context whose `fallback` does retry;
+   * this entry exists only to satisfy the public {@link ResolverContext} shape.
+   */
+  fallback(_deps) {
+    return Promise.resolve(void 0);
+  }
+  async resolveMany(...fields) {
+    const out = {};
+    for (const field of fields) {
+      const value = await this.resolve(field);
+      if (value !== void 0) out[field] = value;
+    }
+    return out;
+  }
+};
+
+// src/resolver/createResolver.ts
+function createResolver(config) {
+  const schemas = config.maps ? buildSchemas(config.maps, config.fields) : config.schemas;
+  return new GraphContext({
+    adapter: config.adapter,
+    seed: config.seed,
+    resolvers: config.resolvers,
+    schemas,
+    onResolve: config.onResolve
+  });
+}
+function buildSchemas(maps, fields) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(maps)) {
+    out[key] = maps[key].schema;
+  }
+  if (fields) {
+    const shape = fields.shape;
+    for (const key of Object.keys(shape)) {
+      out[key] = shape[key];
+    }
+  }
+  return out;
+}
+
+// src/map/case-convert.ts
+var FORBIDDEN_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function splitWords(key) {
+  return key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Za-z])(\d)/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter((w) => w.length > 0).map((w) => w.toLowerCase());
+}
+function toSnakeKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.join("_");
+}
+function toCamelKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.map((word, i) => i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function convert(value, keyFn) {
+  if (Array.isArray(value)) {
+    return value.map((item) => convert(item, keyFn));
+  }
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const key of Object.keys(value)) {
+      const converted = keyFn(key);
+      if (FORBIDDEN_KEYS2.has(converted)) continue;
+      out[converted] = convert(value[key], keyFn);
+    }
+    return out;
+  }
+  return value;
+}
+function toSnakeCase(value) {
+  return convert(value, toSnakeKey);
+}
+function toCamelCase(value) {
+  return convert(value, toCamelKey);
+}
+var capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+function toKebabKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.join("-");
+}
+function toPascalKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.map(capitalize).join("");
+}
+function toConstantKey(key) {
+  const words = splitWords(key);
+  if (words.length === 0) return key;
+  return words.join("_").toUpperCase();
+}
+function toKebabCase(value) {
+  return convert(value, toKebabKey);
+}
+function toPascalCase(value) {
+  return convert(value, toPascalKey);
+}
+function toConstantCase(value) {
+  return convert(value, toConstantKey);
+}
+
+// src/map/map-ops.ts
+function forwardMany(map, sources) {
+  return sources.map((s) => map.forward(s));
+}
+function reverseMany(map, dtos) {
+  return dtos.map((d) => map.reverse(d));
+}
+function safeForward(map, source) {
+  try {
+    return { success: true, data: map.forward(source) };
+  } catch (err) {
+    if (isZodError(err)) return { success: false, error: err };
+    throw err;
+  }
+}
+function isZodError(err) {
+  return typeof err === "object" && err !== null && err.name === "ZodError" && Array.isArray(err.issues);
+}
+
+// src/map/createMap.ts
+var OneWayRuleError = class extends Error {
+  key;
+  constructor(key) {
+    super(
+      `Cannot reverse dest key "${key}": it is mapped by a one-way function rule. Use a { to, from } pair rule to make it reversible.`
+    );
+    this.name = "OneWayRuleError";
+    this.key = key;
+  }
+};
+var MapHasNoResolversError = class extends Error {
+  constructor() {
+    super(
+      "createMap.toResolver requires a resolver graph: pass `createMap(schema, rules, { resolvers })`."
+    );
+    this.name = "MapHasNoResolversError";
+  }
+};
+var ReverseKeyCollisionError = class extends Error {
+  constructor(sourceKey, a, b) {
+    super(
+      `Reverse-key collision: dest keys "${a}" and "${b}" both map back to source key "${sourceKey}". Disambiguate one of them.`
+    );
+    this.name = "ReverseKeyCollisionError";
+  }
+};
+function applyForwardRule(rule, destKey, source) {
+  if (rule === void 0) {
+    return getPath(source, destKey);
+  }
+  if (isStringRule(rule)) {
+    return getPath(source, rule);
+  }
+  if (isPairRule(rule)) {
+    return rule.to(source);
+  }
+  if (isDefaultRule(rule)) {
+    const read = getPath(source, rule.source ?? destKey);
+    return read === void 0 ? rule.value : read;
+  }
+  if (isFnRule(rule)) {
+    return rule(source);
+  }
+  return void 0;
+}
+function createMap(schema, rules = {}, options = {}) {
+  const shape = schema.shape;
+  const destKeys = Object.keys(shape);
+  const mapResolvers = options.resolvers;
+  const reverseTargets = /* @__PURE__ */ new Map();
+  for (const destKey of Object.keys(rules)) {
+    const rule = rules[destKey];
+    if (rule !== void 0 && isStringRule(rule)) {
+      const existing = reverseTargets.get(rule);
+      if (existing) throw new ReverseKeyCollisionError(rule, existing, destKey);
+      reverseTargets.set(rule, destKey);
+    }
+  }
+  function forward(source) {
+    const out = {};
+    for (const destKey of destKeys) {
+      const rule = rules[destKey];
+      if (isFromResolverRule(rule)) continue;
+      const value = applyForwardRule(rule, destKey, source);
+      if (value !== void 0) setPath(out, destKey, value);
+    }
+    return schema.parse(out);
+  }
+  function reverse(dto) {
+    const out = {};
+    const dtoObj = dto;
+    for (const destKey of Object.keys(rules)) {
+      const rule = rules[destKey];
+      if (rule === void 0) continue;
+      const destValue = getPath(dtoObj, destKey);
+      if (isStringRule(rule)) {
+        setPath(out, rule, destValue);
+      } else if (isPairRule(rule)) {
+        setPath(out, destKey, rule.from(destValue));
+      } else if (isDefaultRule(rule)) {
+        setPath(out, rule.source ?? destKey, destValue);
+      } else if (isFromResolverRule(rule)) {
+        continue;
+      } else {
+        throw new OneWayRuleError(destKey);
+      }
+    }
+    return out;
+  }
+  function toResolver(adapter, seed) {
+    if (!mapResolvers) {
+      throw new MapHasNoResolversError();
+    }
+    const schemas = {};
+    for (const key of Object.keys(shape)) {
+      schemas[key] = shape[key];
+    }
+    return createResolver({
+      adapter,
+      seed,
+      resolvers: mapResolvers,
+      schemas
+    });
+  }
+  const mapper = {
+    forward,
+    reverse,
+    forwardMany: (sources) => forwardMany(mapper, sources),
+    reverseMany: (dtos) => reverseMany(mapper, dtos),
+    safeForward: (source) => safeForward(mapper, source),
+    toSnakeCase,
+    toCamelCase,
+    toResolver,
+    schema,
+    rules: Object.freeze({ ...rules }),
+    shape,
+    resolvers: mapResolvers
+  };
+  return mapper;
+}
+function subObject(schema, keys) {
+  const shape = schema.shape;
+  const picked = {};
+  for (const key of keys) {
+    const field = shape[key];
+    if (field !== void 0) picked[key] = field;
+  }
+  return zod.z.object(picked);
+}
+function pick(map, keys) {
+  return createMap(subObject(map.schema, keys));
+}
+function omit(map, keys) {
+  const drop = new Set(keys);
+  const remaining = Object.keys(map.schema.shape).filter((k) => !drop.has(k));
+  return createMap(subObject(map.schema, remaining));
+}
+function compose(a, b) {
+  const base = createMap(b.schema);
+  const composed = { ...base };
+  composed.forward = (source) => b.forward(a.forward(source));
+  composed.reverse = (dto) => a.reverse(b.reverse(dto));
+  composed.forwardMany = (sources) => forwardMany(composed, sources);
+  composed.reverseMany = (dtos) => reverseMany(composed, dtos);
+  composed.safeForward = (source) => safeForward(composed, source);
+  return composed;
+}
+
+// src/serialize/json-types.ts
+var CodecError = class extends Error {
+  /** Path to the offending value, e.g. `user.createdAt`. */
+  path;
+  constructor(message, path = []) {
+    const where = path.length ? ` (at ${path.join(".")})` : "";
+    super(`${message}${where}`);
+    this.name = "CodecError";
+    this.path = path;
+  }
+};
+var AsyncSchemaError = class extends Error {
+  constructor() {
+    super(
+      "deserialize is sync-only; this schema has async refinements. Remove async .refine()/.superRefine() or validate separately with parseAsync."
+    );
+    this.name = "AsyncSchemaError";
+  }
+};
+var LIMITS = {
+  /** Max characters in a BigInt wire string (sign + digits). */
+  bigintStringLength: 4096,
+  /** Max entries when rebuilding a Map from a wire array. */
+  mapEntries: 1e5
+};
+function dateToIso(value, path) {
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+    throw new CodecError("expected a valid Date", path);
+  }
+  return value.toISOString();
+}
+function isoToDate(value, path) {
+  if (typeof value !== "string") {
+    throw new CodecError("expected an ISO date string", path);
+  }
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) {
+    throw new CodecError("invalid ISO date string", path);
+  }
+  return new Date(ms);
+}
+function bigintToString(value, path) {
+  if (typeof value !== "bigint") {
+    throw new CodecError("expected a bigint", path);
+  }
+  return value.toString();
+}
+function stringToBigint(value, path) {
+  if (typeof value !== "string") {
+    throw new CodecError("expected a bigint string", path);
+  }
+  if (value.length > LIMITS.bigintStringLength) {
+    throw new CodecError(
+      `bigint string exceeds ${LIMITS.bigintStringLength} chars`,
+      path
+    );
+  }
+  if (!/^-?\d+$/.test(value)) {
+    throw new CodecError("malformed bigint string", path);
+  }
+  return BigInt(value);
+}
+function mapToEntries(value, path) {
+  if (!(value instanceof Map)) {
+    throw new CodecError("expected a Map", path);
+  }
+  return Array.from(value.entries());
+}
+function entriesToArray(value, path) {
+  if (!Array.isArray(value)) {
+    throw new CodecError("expected a Map entries array", path);
+  }
+  if (value.length > LIMITS.mapEntries) {
+    throw new CodecError(`Map entries exceed ${LIMITS.mapEntries}`, path);
+  }
+  for (const entry of value) {
+    if (!Array.isArray(entry) || entry.length !== 2) {
+      throw new CodecError("malformed Map entry (expected [key, value])", path);
+    }
+  }
+  return value;
+}
+function setToArray(value, path) {
+  if (!(value instanceof Set)) {
+    throw new CodecError("expected a Set", path);
+  }
+  return Array.from(value.values());
+}
+function arrayToSetItems(value, path) {
+  if (!Array.isArray(value)) {
+    throw new CodecError("expected a Set values array", path);
+  }
+  if (value.length > LIMITS.mapEntries) {
+    throw new CodecError(`Set values exceed ${LIMITS.mapEntries}`, path);
+  }
+  return value;
+}
+
+// src/serialize/codec.ts
+function defOf(schema) {
+  return schema._zod.def;
+}
+function unwrap(schema) {
+  let current = schema;
+  for (; ; ) {
+    const def = defOf(current);
+    switch (def.type) {
+      case "optional":
+      case "nullable":
+      case "default":
+      case "nonoptional":
+      case "readonly":
+      case "catch":
+        current = def.innerType;
+        break;
+      case "pipe":
+        current = def.in;
+        break;
+      case "lazy":
+        current = def.getter();
+        break;
+      default:
+        return current;
+    }
+  }
+}
+function walk(schema, value, dir, path) {
+  if (value === null || value === void 0) return value;
+  const node = unwrap(schema);
+  const def = defOf(node);
+  switch (def.type) {
+    case "object": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        throw new CodecError("expected an object", path);
+      }
+      const shape = def.shape;
+      const src = value;
+      const out = {};
+      for (const key of Object.keys(shape)) {
+        if (Object.prototype.hasOwnProperty.call(src, key)) {
+          out[key] = walk(shape[key], src[key], dir, [...path, key]);
+        }
+      }
+      return out;
+    }
+    case "array": {
+      if (!Array.isArray(value)) throw new CodecError("expected an array", path);
+      const element = def.element;
+      return value.map((item, i) => walk(element, item, dir, [...path, i]));
+    }
+    case "map": {
+      const keyType = def.keyType;
+      const valueType = def.valueType;
+      if (dir === "serialize") {
+        const entries2 = mapToEntries(value, path);
+        return entries2.map(([k, v], i) => [
+          walk(keyType, k, dir, [...path, i, "key"]),
+          walk(valueType, v, dir, [...path, i, "value"])
+        ]);
+      }
+      const entries = entriesToArray(value, path);
+      const out = /* @__PURE__ */ new Map();
+      entries.forEach(([k, v], i) => {
+        out.set(
+          walk(keyType, k, dir, [...path, i, "key"]),
+          walk(valueType, v, dir, [...path, i, "value"])
+        );
+      });
+      return out;
+    }
+    case "set": {
+      const valueType = def.valueType;
+      if (dir === "serialize") {
+        const items2 = setToArray(value, path);
+        return items2.map((item, i) => walk(valueType, item, dir, [...path, i]));
+      }
+      const items = arrayToSetItems(value, path);
+      return new Set(items.map((item, i) => walk(valueType, item, dir, [...path, i])));
+    }
+    case "union": {
+      const options = def.options;
+      let lastError = new CodecError("no union member matched", path);
+      for (const option of options) {
+        try {
+          return walk(option, value, dir, path);
+        } catch (err) {
+          if (!(err instanceof CodecError)) throw err;
+          lastError = err;
+        }
+      }
+      throw lastError;
+    }
+    case "date":
+      return dir === "serialize" ? dateToIso(value, path) : isoToDate(value, path);
+    case "bigint":
+      return dir === "serialize" ? bigintToString(value, path) : stringToBigint(value, path);
+    // Scalars and explicit escape hatches pass through untouched.
+    case "string":
+    case "number":
+    case "boolean":
+    case "nan":
+    case "null":
+    case "undefined":
+    case "literal":
+    case "enum":
+    case "any":
+    case "unknown":
+    case "void":
+    case "custom":
+      return value;
+    default:
+      throw new CodecError(`unsupported schema node "${def.type}"`, path);
+  }
+}
+function serialize(value, schema) {
+  return walk(schema, value, "serialize", []);
+}
+function isZodAsyncError(err) {
+  const name = err?.constructor?.name;
+  return name === "$ZodAsyncError";
+}
+function deserialize(json, schema) {
+  const rebuilt = walk(schema, json, "deserialize", []);
+  try {
+    return schema.parse(rebuilt);
+  } catch (err) {
+    if (isZodAsyncError(err)) throw new AsyncSchemaError();
+    throw err;
+  }
+}
+async function deserializeAsync(json, schema) {
+  const rebuilt = walk(schema, json, "deserialize", []);
+  return await schema.parseAsync(rebuilt);
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+exports.AsyncSchemaError = AsyncSchemaError;
+exports.CodecError = CodecError;
+exports.MapHasNoResolversError = MapHasNoResolversError;
+exports.OneWayRuleError = OneWayRuleError;
+exports.ReverseKeyCollisionError = ReverseKeyCollisionError;
+exports.VERSION = VERSION;
+exports.compose = compose;
+exports.createMap = createMap;
+exports.deserialize = deserialize;
+exports.deserializeAsync = deserializeAsync;
+exports.forwardMany = forwardMany;
+exports.fromResolver = fromResolver;
+exports.getPath = getPath;
+exports.isDefaultRule = isDefaultRule;
+exports.isFnRule = isFnRule;
+exports.isFromResolverRule = isFromResolverRule;
+exports.isPairRule = isPairRule;
+exports.isStringRule = isStringRule;
+exports.omit = omit;
+exports.pick = pick;
+exports.reverseMany = reverseMany;
+exports.safeForward = safeForward;
+exports.serialize = serialize;
+exports.setPath = setPath;
+exports.splitWords = splitWords;
+exports.toCamelCase = toCamelCase;
+exports.toCamelKey = toCamelKey;
+exports.toConstantCase = toConstantCase;
+exports.toConstantKey = toConstantKey;
+exports.toKebabCase = toKebabCase;
+exports.toKebabKey = toKebabKey;
+exports.toPascalCase = toPascalCase;
+exports.toPascalKey = toPascalKey;
+exports.toSnakeCase = toSnakeCase;
+exports.toSnakeKey = toSnakeKey;
+exports.withDefault = withDefault;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map