@conform-to/dom 1.8.2 → 1.9.1

package/dist/formdata.mjs

@@ -1,4 +1,8 @@
-import { INTENT } from './submission.mjs';
+import { objectSpread2 as _objectSpread2 } from './_virtual/_rollupPluginBabelHelpers.mjs';
+import { isSubmitter, isGlobalInstance } from './dom.mjs';
+import { isPlainObject, stripFiles, deepEqual } from './util.mjs';
+
+var DEFAULT_INTENT_NAME = '__INTENT__';
 
 /**
  * Construct a form data with the submitter value.
@@ -9,253 +13,231 @@ import { INTENT } from './submission.mjs';
  */
 function getFormData(form, submitter) {
   var payload = new FormData(form, submitter);
-  if (submitter && submitter.type === 'submit' && submitter.name !== '') {
-    var entries = payload.getAll(submitter.name);
+  if (submitter) {
+    if (!isSubmitter(submitter)) {
+      throw new TypeError('The submitter must be an input or button element with type submit.');
+    }
+    if (submitter.name) {
+      var entries = payload.getAll(submitter.name);
 
-    // This assumes the submitter value to be always unique, which should be fine in most cases
-    if (!entries.includes(submitter.value)) {
-      payload.append(submitter.name, submitter.value);
+      // This assumes the submitter value to be always unique, which should be fine in most cases
+      if (!entries.includes(submitter.value)) {
+        payload.append(submitter.name, submitter.value);
+      }
     }
   }
   return payload;
 }
 
 /**
- * Returns the paths from a name based on the JS syntax convention
+ * Convert a string path into an array of segments.
+ *
  * @example
  * ```js
- * const paths = getPaths('todos[0].content'); // ['todos', 0, 'content']
+ * getPathSegments("object.key");       // → ['object', 'key']
+ * getPathSegments("array[0].content"); // → ['array', 0, 'content']
+ * getPathSegments("todos[]");          // → ['todos', '']
  * ```
  */
-function getPaths(name) {
-  if (!name) {
-    return [];
-  }
-  return name.split(/\.|(\[\d*\])/).reduce((result, segment) => {
-    if (typeof segment !== 'undefined' && segment !== '' && segment !== '__proto__' && segment !== 'constructor' && segment !== 'prototype') {
-      if (segment.startsWith('[') && segment.endsWith(']')) {
-        var index = segment.slice(1, -1);
-        result.push(Number(index));
-      } else {
-        result.push(segment);
+function getPathSegments(path) {
+  if (!path) return [];
+  var tokenRegex = /([^.[\]]+)|\[(\d*)\]/g;
+  var segments = [];
+  var lastIndex = 0,
+    match;
+  while (match = tokenRegex.exec(path)) {
+    // allow a single “.” between tokens
+    if (match.index !== lastIndex) {
+      if (!(match.index === lastIndex + 1 && path[lastIndex] === '.')) {
+        throw new Error("Invalid path syntax at position ".concat(lastIndex, " in \"").concat(path, "\""));
       }
     }
-    return result;
-  }, []);
+    var [, key, index] = match;
+    if (key !== undefined) {
+      if (key === '__proto__' || key === 'constructor') {
+        throw new Error("Invalid path segment \"".concat(key, "\""));
+      }
+      segments.push(key);
+    } else if (index === '') {
+      segments.push('');
+    } else {
+      var number = Number(index);
+      if (!Number.isInteger(number) || number < 0) {
+        throw new Error("Invalid path segment: array index must be a non-negative integer, got ".concat(number));
+      }
+      segments.push(number);
+    }
+    lastIndex = tokenRegex.lastIndex;
+  }
+  if (lastIndex !== path.length) {
+    throw new Error("Invalid path syntax at position ".concat(lastIndex, " in \"").concat(path, "\""));
+  }
+  return segments;
 }
 
 /**
- * Returns a formatted name from the paths based on the JS syntax convention
+ * Returns a formatted name from the path segments based on the dot and bracket notation.
+ *
  * @example
  * ```js
- * const name = formatPaths(['todos', 0, 'content']); // "todos[0].content"
+ * formatPathSegments(['object', 'key']); // → "object.key"
+ * formatPathSegments(['array', 0, 'content']); // → "array[0].content"
+ * formatPathSegments(['todos', '']); // → "todos[]"
  * ```
  */
-function formatPaths(paths) {
-  return paths.reduce((name, path) => {
-    if (typeof path === 'number') {
-      return "".concat(name, "[").concat(Number.isNaN(path) ? '' : path, "]");
-    }
-    if (name === '' || path === '') {
-      return [name, path].join('');
-    }
-    return [name, path].join('.');
-  }, '');
+function formatPathSegments(segments) {
+  return segments.reduce((path, segment) => appendPathSegment(path, segment), '');
 }
 
 /**
- * Format based on a prefix and a path
- */
-function formatName(prefix, path) {
-  return typeof path !== 'undefined' ? formatPaths([...getPaths(prefix), path]) : prefix !== null && prefix !== void 0 ? prefix : '';
-}
-
-/**
- * Check if a name match the prefix paths
- */
-function isPrefix(name, prefix) {
-  var paths = getPaths(name);
-  var prefixPaths = getPaths(prefix);
-  return paths.length >= prefixPaths.length && prefixPaths.every((path, index) => paths[index] === path);
-}
-
-/**
- * Compare the parent and child paths to get the relative paths
- * Returns null if the child paths do not start with the parent paths
+ * Append one more segment onto an existing path string.
+ *
+ * - segment = `undefined`  ⇒ no-op
+ * - segment = `""`         ⇒ empty brackets "[]"
+ * - segment = `number`     ⇒ bracket notation "[n]"
+ * - segment = `string`     ⇒ dot-notation ".prop"
  */
-function getChildPaths(parentNameOrPaths, childName) {
-  var parentPaths = typeof parentNameOrPaths === 'string' ? getPaths(parentNameOrPaths) : parentNameOrPaths;
-  var childPaths = getPaths(childName);
-  if (childPaths.length >= parentPaths.length && parentPaths.every((path, index) => childPaths[index] === path)) {
-    return childPaths.slice(parentPaths.length);
+function appendPathSegment(path, segment) {
+  // 1) nothing to append
+  if (typeof segment === 'undefined') {
+    return path !== null && path !== void 0 ? path : '';
   }
-  return null;
-}
 
-/**
- * Assign a value to a target object by following the paths
- */
-function setValue(target, name, valueFn) {
-  var paths = getPaths(name);
-  var length = paths.length;
-  var lastIndex = length - 1;
-  var index = -1;
-  var pointer = target;
-  while (pointer != null && ++index < length) {
-    var _key = paths[index];
-    var nextKey = paths[index + 1];
-    var newValue = index != lastIndex ? Object.prototype.hasOwnProperty.call(pointer, _key) && pointer[_key] !== null ? pointer[_key] : typeof nextKey === 'number' ? [] : {} : valueFn(pointer[_key]);
-    pointer[_key] = newValue;
-    pointer = pointer[_key];
+  // 2) explicit empty-segment => empty bracket
+  if (segment === '') {
+    // even as first segment, "[]" is valid
+    return "".concat(path, "[]");
   }
-}
 
-/**
- * Retrive the value from a target object by following the paths
- */
-function getValue(target, name) {
-  var pointer = target;
-  for (var path of getPaths(name)) {
-    if (typeof pointer === 'undefined' || pointer == null) {
-      break;
-    }
-    if (!Object.prototype.hasOwnProperty.call(pointer, path)) {
-      return;
-    }
-    if (isPlainObject(pointer) && typeof path === 'string') {
-      pointer = pointer[path];
-    } else if (Array.isArray(pointer) && typeof path === 'number') {
-      pointer = pointer[path];
-    } else {
-      return;
-    }
+  // 3) numeric index => [n]
+  if (typeof segment === 'number') {
+    return "".concat(path, "[").concat(segment, "]");
   }
-  return pointer;
+
+  // 4) non-empty string => .prop (no leading dot if no base)
+  return path ? "".concat(path, ".").concat(segment) : segment;
 }
 
 /**
- * Check if the value is a plain object
+ * Returns true if `prefix` is a valid leading path of `name`.
+ *
+ * @example
+ * ```js
+ * isPrefix("foo.bar.baz", "foo.bar")        // → true
+ * isPrefix("foo.bar[3].baz", "foo.bar[3]")  // → true
+ * isPrefix("foo.bar[3].baz", "foo.bar")     // → true
+ * isPrefix("foo.bar[3].baz", "foo.baz")     // → false
+ * isPrefix("foo", "foo.bar")                // → false
+ * ```
  */
-function isPlainObject(obj) {
-  return !!obj && obj.constructor === Object && Object.getPrototypeOf(obj) === Object.prototype;
-}
-function isGlobalInstance(obj, className) {
-  var Ctor = globalThis[className];
-  return typeof Ctor === 'function' && obj instanceof Ctor;
+function isPrefix(name, prefix) {
+  return getRelativePath(name, getPathSegments(prefix)) !== null;
 }
 
 /**
- * Normalize value by removing empty object or array, empty string and null values
+ * Return the segments of `fullPathStr` that come after the `baseSegments` prefix.
+ *
+ * @param fullPathStr     Full path as a dot/bracket string
+ * @param basePath    Base path, already parsed into segments
+ * @returns               The “tail” segments, or `null` if `fullPathStr` isn’t nested under `baseSegments`
+ *
+ * @example
+ * ```js
+ * getRelativePath("foo.bar[0].qux", ["foo","bar"])  // → [0, "qux"]
+ * getRelativePath("a.b.c.d", ["a","b"])             // → ["c","d"]
+ * getRelativePath("foo", ["foo","bar"])             // → null
+ * ```
  */
+function getRelativePath(name, basePath) {
+  var fullPath = getPathSegments(name);
 
-function normalize(value) {
-  var acceptFile = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  if (isPlainObject(value)) {
-    var obj = Object.keys(value).sort().reduce((result, key) => {
-      var data = normalize(value[key], acceptFile);
-      if (typeof data !== 'undefined') {
-        result[key] = data;
-      }
-      return result;
-    }, {});
-    if (Object.keys(obj).length === 0) {
-      return;
-    }
-    return obj;
+  // if full is at least as long *and* starts with the base…
+  if (fullPath.length >= basePath.length && basePath.every((segment, i) => segment === fullPath[i])) {
+    return fullPath.slice(basePath.length);
   }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return undefined;
-    }
-    return value.map(item => normalize(item, acceptFile));
-  }
-  if (typeof value === 'string' && value === '' || value === null || isGlobalInstance(value, 'File') && (!acceptFile || value.size === 0)) {
-    return;
-  }
-  return value;
+  return null;
 }
 
 /**
- * Flatten a tree into a dictionary
+ * Assign a value to a target object by following the path segments.
  */
-function flatten(data) {
-  var _options$resolve;
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var result = {};
-  var resolve = (_options$resolve = options.resolve) !== null && _options$resolve !== void 0 ? _options$resolve : data => data;
-  function process(data, prefix) {
-    var value = normalize(resolve(data));
-    if (typeof value !== 'undefined') {
-      result[prefix] = value;
+function setValueAtPath(target, pathOrSegments, valueOrFn) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  try {
+    // 1) normalize + validate path
+    var segments = typeof pathOrSegments === 'string' ? getPathSegments(pathOrSegments) : pathOrSegments;
+    if (segments.length === 0) {
+      throw new Error('Cannot set value at the object root');
     }
-    if (Array.isArray(data)) {
-      for (var i = 0; i < data.length; i++) {
-        process(data[i], "".concat(prefix, "[").concat(i, "]"));
-      }
-    } else if (isPlainObject(data)) {
-      for (var [_key2, _value] of Object.entries(data)) {
-        process(_value, prefix ? "".concat(prefix, ".").concat(_key2) : _key2);
-      }
+    if (segments.some((segment, i) => segment === '' && i < segments.length - 1)) {
+      throw new Error("Empty brackets '[]' only allowed at end of path (\"".concat(pathOrSegments, "\")"));
     }
-  }
-  if (data) {
-    var _options$prefix;
-    process(data, (_options$prefix = options.prefix) !== null && _options$prefix !== void 0 ? _options$prefix : '');
-  }
-  return result;
-}
-function deepEqual(left, right) {
-  if (Object.is(left, right)) {
-    return true;
-  }
-  if (left == null || right == null) {
-    return false;
-  }
 
-  // Compare plain objects
-  if (isPlainObject(left) && isPlainObject(right)) {
-    var prevKeys = Object.keys(left);
-    var nextKeys = Object.keys(right);
-    if (prevKeys.length !== nextKeys.length) {
-      return false;
-    }
-    for (var _key3 of prevKeys) {
-      if (!Object.prototype.hasOwnProperty.call(right, _key3) || !deepEqual(left[_key3], right[_key3])) {
-        return false;
+    // 2) clone root if needed
+    var result = options.clone ? _objectSpread2({}, target) : target;
+    var pointer = result;
+
+    // 3) drill down, cloning ancestors
+    for (var i = 0; i < segments.length - 1; i++) {
+      var currentSegment = segments[i];
+      var nextSegment = segments[i + 1];
+      var child = pointer[currentSegment];
+      if (Array.isArray(child)) {
+        child = options.clone ? child.slice() : child;
+      } else if (isPlainObject(child)) {
+        child = options.clone ? _objectSpread2({}, child) : child;
+      } else {
+        child = typeof nextSegment === 'number' || nextSegment === '' ? [] : {};
       }
+      pointer[currentSegment] = child;
+      pointer = child;
     }
-    return true;
-  }
 
-  // Compare arrays
-  if (Array.isArray(left) && Array.isArray(right)) {
-    if (left.length !== right.length) {
-      return false;
-    }
-    for (var i = 0; i < left.length; i++) {
-      if (!deepEqual(left[i], right[i])) {
-        return false;
+    // 4) final set or push
+    var last = segments[segments.length - 1];
+    var oldValue = pointer[last];
+    var newValue = typeof valueOrFn === 'function' ? valueOrFn(oldValue) : valueOrFn;
+    if (last === '') {
+      if (!Array.isArray(pointer)) {
+        throw new Error("Cannot push to non-array at \"".concat(pathOrSegments, "\""));
       }
+      pointer.push(newValue);
+    } else {
+      pointer[last] = newValue;
+    }
+    return result;
+  } catch (err) {
+    if (options !== null && options !== void 0 && options.silent) {
+      return target;
     }
-    return true;
+    throw err;
   }
-  return false;
 }
 
 /**
- * The form value of a submission. This is usually constructed from a FormData or URLSearchParams.
- * It may contains JSON primitives if the value is updated based on a form intent.
- */
-
-/**
- * The data of a form submission.
+ * Retrive the value from a target object by following the path segments.
  */
+function getValueAtPath(target, pathOrSegments) {
+  var pointer = target;
+  var segments = typeof pathOrSegments === 'string' ? getPathSegments(pathOrSegments) : pathOrSegments;
+  for (var segment of segments) {
+    if (segment === '') {
+      throw new Error("Cannot access empty segment \"[]\" in \"".concat(pathOrSegments, "\""));
+    }
+    if (pointer == null || !Object.prototype.hasOwnProperty.call(pointer, segment)) {
+      return undefined;
+    }
+    pointer = pointer[segment];
+  }
+  return pointer;
+}
 
 /**
  * Parse `FormData` or `URLSearchParams` into a submission object.
  * This function structures the form values based on the naming convention.
- * It also includes all the field names and the intent if the `intentName` option is provided.
+ * It also includes all the field names and extracts the intent from the submission.
  *
+ * @see https://conform.guide/api/react/future/parseSubmission
  * @example
  * ```ts
  * const formData = new FormData();
@@ -265,7 +247,7 @@ function deepEqual(left, right) {
  *
  * parseSubmission(formData)
  * // {
- * //   value: { email: 'test@example.com', password: 'secret' },
+ * //   payload: { email: 'test@example.com', password: 'secret' },
  * //   fields: ['email', 'password'],
  * //   intent: null,
  * // }
@@ -274,7 +256,7 @@ function deepEqual(left, right) {
  * formData.append('intent', 'login');
  * parseSubmission(formData, { intentName: 'intent' })
  * // {
- * //   value: { email: 'test@example.com', password: 'secret' },
+ * //   payload: { email: 'test@example.com', password: 'secret' },
  * //   fields: ['email', 'password'],
  * //   intent: 'login',
  * // }
@@ -282,22 +264,21 @@ function deepEqual(left, right) {
  */
 function parseSubmission(formData, options) {
   var _options$intentName;
-  var intentName = (_options$intentName = options === null || options === void 0 ? void 0 : options.intentName) !== null && _options$intentName !== void 0 ? _options$intentName : INTENT;
+  var intentName = (_options$intentName = options === null || options === void 0 ? void 0 : options.intentName) !== null && _options$intentName !== void 0 ? _options$intentName : DEFAULT_INTENT_NAME;
   var submission = {
-    value: {},
+    payload: {},
     fields: [],
     intent: null
   };
-  var _loop = function _loop() {
+  for (var _name of new Set(formData.keys())) {
     var _options$skipEntry;
     if (_name !== intentName && !(options !== null && options !== void 0 && (_options$skipEntry = options.skipEntry) !== null && _options$skipEntry !== void 0 && _options$skipEntry.call(options, _name))) {
-      var _value2 = formData.getAll(_name);
-      setValue(submission.value, _name, () => _value2.length > 1 ? _value2 : _value2[0]);
+      var _value = formData.getAll(_name);
+      setValueAtPath(submission.payload, _name, _value.length > 1 ? _value : _value[0], {
+        silent: true // Avoid errors if the path is invalid
+      });
       submission.fields.push(_name);
     }
-  };
-  for (var _name of new Set(formData.keys())) {
-    _loop();
   }
   if (intentName) {
     // We take the first value of the intent field if it exists.
@@ -308,17 +289,63 @@ function parseSubmission(formData, options) {
   }
   return submission;
 }
-function defaultSerialize(value) {
-  if (typeof value === 'string' || isGlobalInstance(value, 'File')) {
-    return value;
-  }
-  if (typeof value === 'boolean') {
-    return value ? 'on' : undefined;
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
+
+/**
+ * Creates a SubmissionResult object from a submission, adding validation results and intended values.
+ * This function will remove all files in the submission payload by default since
+ * file inputs cannot be initialized with files.
+ * You can specify `keepFiles: true` to keep the files if needed.
+ *
+ * @see https://conform.guide/api/react/future/report
+ * @example
+ * ```ts
+ * // Report the submission with the field errors
+ * report(submission, {
+ *  error: {
+ *    fieldErrors: {
+ *      email: ['Invalid email format'],
+ *      password: ['Password is required'],
+ *    },
+ * })
+ *
+ * // Report the submission with a form error
+ * report(submission, {
+ *   error: {
+ *     formErrors: ['Invalid credentials'],
+ *   },
+ * })
+ *
+ * // Reset the form
+ * report(submission, {
+ *   reset: true,
+ * })
+ * ```
+ */
+
+function report(submission) {
+  var _options$error$formEr, _options$error$fieldE;
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var intendedValue = options.reset ? null : typeof options.intendedValue === 'undefined' || submission.payload === options.intendedValue ? undefined : options.intendedValue && !options.keepFiles ? stripFiles(options.intendedValue) : options.intendedValue;
+  var error = !options.error ? options.error : {
+    formErrors: (_options$error$formEr = options.error.formErrors) !== null && _options$error$formEr !== void 0 ? _options$error$formEr : [],
+    fieldErrors: (_options$error$fieldE = options.error.fieldErrors) !== null && _options$error$fieldE !== void 0 ? _options$error$fieldE : {}
+  };
+  if (options.hideFields) {
+    for (var _name2 of options.hideFields) {
+      var path = getPathSegments(_name2);
+      setValueAtPath(submission.payload, path, undefined);
+      if (intendedValue) {
+        setValueAtPath(intendedValue, path, undefined);
+      }
+    }
   }
-  return value === null || value === void 0 ? void 0 : value.toString();
+  return {
+    submission: options.keepFiles ? submission : _objectSpread2(_objectSpread2({}, submission), {}, {
+      payload: stripFiles(submission.payload)
+    }),
+    intendedValue,
+    error
+  };
 }
 
 /**
@@ -349,17 +376,37 @@ function isDirty(
  * - A plain object that was parsed from form data (i.e. `submission.payload`)
  */
 formData, options) {
-  var _options$serialize;
   if (!formData) {
     return;
   }
   var formValue = formData instanceof FormData || formData instanceof URLSearchParams ? parseSubmission(formData, {
     intentName: options === null || options === void 0 ? void 0 : options.intentName,
     skipEntry: options === null || options === void 0 ? void 0 : options.skipEntry
-  }).value : formData;
+  }).payload : formData;
   var defaultValue = options === null || options === void 0 ? void 0 : options.defaultValue;
-  var serialize = (_options$serialize = options === null || options === void 0 ? void 0 : options.serialize) !== null && _options$serialize !== void 0 ? _options$serialize : defaultSerialize;
-  function normalize(value) {
+  var serializeData = value => {
+    if (options !== null && options !== void 0 && options.serialize) {
+      return options.serialize(value, serialize);
+    }
+    return serialize(value);
+  };
+  function normalize(data) {
+    var _serializeData;
+    var value = (_serializeData = serializeData(data)) !== null && _serializeData !== void 0 ? _serializeData : data;
+
+    // Removes empty strings, so that bpth empty string and undefined are treated as the same
+    if (value === '') {
+      return undefined;
+    }
+    if (isGlobalInstance(value, 'File')) {
+      // Remove empty File as well, which happens if no File was selected
+      if (value.name === '' && value.size === 0) {
+        return undefined;
+      }
+
+      // If the value is a File, no need to serialize it
+      return value;
+    }
     if (Array.isArray(value)) {
       if (value.length === 0) {
         return undefined;
@@ -384,24 +431,80 @@ formData, options) {
       }
       return Object.fromEntries(entries);
     }
+    return value;
+  }
+  return !deepEqual(normalize(formValue), normalize(defaultValue));
+}
 
-    // If the value is null or undefined, treat it as undefined
-    if (value == null) {
-      return undefined;
+/**
+ * Convert an unknown value into something acceptable for HTML form submission.
+ * Returns `undefined` when the value cannot be represented in form data.
+ *
+ * Input -> Output:
+ * - string -> string
+ * - null -> '' (empty string)
+ * - boolean -> 'on' | '' (checked semantics)
+ * - number | bigint -> value.toString()
+ * - Date -> value.toISOString()
+ * - File -> File
+ * - FileList -> File[]
+ * - Array -> string[] or File[] if all items serialize to the same kind; otherwise undefined
+ * - anything else -> undefined
+ */
+function serialize(value) {
+  function serializePrimitive(value) {
+    if (typeof value === 'string') {
+      return value;
     }
-
-    // Removes empty strings, so that bpth empty string and undefined are treated as the same
-    if (typeof value === 'string' && value === '') {
-      return undefined;
+    if (value === null) {
+      return '';
     }
-
-    // Remove empty File as well, which happens if no File was selected
-    if (isGlobalInstance(value, 'File') && value.name === '' && value.size === 0) {
-      return undefined;
+    if (typeof value === 'boolean') {
+      return value ? 'on' : '';
+    }
+    if (typeof value === 'number' || typeof value === 'bigint') {
+      return value.toString();
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (isGlobalInstance(value, 'File')) {
+      return value;
     }
-    return serialize(value, defaultSerialize);
   }
-  return !deepEqual(normalize(formValue), normalize(defaultValue));
+  if (Array.isArray(value)) {
+    var _options = [];
+    var files = [];
+    for (var item of value) {
+      var serialized = serializePrimitive(item);
+      if (typeof serialized === 'undefined') {
+        return;
+      }
+      if (typeof serialized === 'string') {
+        if (files.length > 0) {
+          return;
+        }
+        _options.push(serialized);
+      } else {
+        if (_options.length > 0) {
+          return;
+        }
+        files.push(serialized);
+      }
+    }
+    if (_options.length === value.length) {
+      return _options;
+    }
+    if (files.length === value.length) {
+      return files;
+    }
+
+    // If not all items are strings or files, return nothing
+  }
+  if (isGlobalInstance(value, 'FileList')) {
+    return Array.from(value);
+  }
+  return serializePrimitive(value);
 }
 
-export { deepEqual, defaultSerialize, flatten, formatName, formatPaths, getChildPaths, getFormData, getPaths, getValue, isDirty, isGlobalInstance, isPlainObject, isPrefix, normalize, parseSubmission, setValue };
+export { DEFAULT_INTENT_NAME, appendPathSegment, formatPathSegments, getFormData, getPathSegments, getRelativePath, getValueAtPath, isDirty, isPrefix, parseSubmission, report, serialize, setValueAtPath };