@brikka/locations 1.0.4 → 1.0.6

package/index.cjs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var jsxRuntime = require('@soperio/jsx-runtime');
 var admin = require('@compill/admin');
 var form = require('@compill/form');
@@ -27,6 +25,8 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
 
 function __rest(s, e) {
     var t = {};
@@ -45,6 +45,10 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
 /**
  * Based on Kendo UI Core expression code <https://github.com/telerik/kendo-ui-core#license-information>
  */
@@ -341,7 +345,8 @@ function makeNodesHash(arr){
   return res
 }
 
-var toposort$1 = toposort$2.exports;
+var toposortExports = toposort$2.exports;
+var toposort$1 = /*@__PURE__*/getDefaultExportFromCjs(toposortExports);
 
 const toString = Object.prototype.toString;
 const errorToString = Error.prototype.toString;
@@ -380,28 +385,20 @@ function toArray(value) {
   return value == null ? [] : [].concat(value);
 }
 
+let _Symbol$toStringTag, _Symbol$hasInstance, _Symbol$toStringTag2;
 let strReg = /\$\{\s*(\w+)\s*\}/g;
-class ValidationError extends Error {
-  static formatError(message, params) {
-    const path = params.label || params.path || 'this';
-    if (path !== params.path) params = Object.assign({}, params, {
-      path
-    });
-    if (typeof message === 'string') return message.replace(strReg, (_, key) => printValue(params[key]));
-    if (typeof message === 'function') return message(params);
-    return message;
-  }
-  static isError(err) {
-    return err && err.name === 'ValidationError';
-  }
+_Symbol$toStringTag = Symbol.toStringTag;
+class ValidationErrorNoStack {
   constructor(errorOrErrors, value, field, type) {
-    super();
+    this.name = void 0;
+    this.message = void 0;
     this.value = void 0;
     this.path = void 0;
     this.type = void 0;
-    this.errors = void 0;
     this.params = void 0;
+    this.errors = void 0;
     this.inner = void 0;
+    this[_Symbol$toStringTag] = 'Error';
     this.name = 'ValidationError';
     this.value = value;
     this.path = field;
@@ -411,13 +408,60 @@ class ValidationError extends Error {
     toArray(errorOrErrors).forEach(err => {
       if (ValidationError.isError(err)) {
         this.errors.push(...err.errors);
-        this.inner = this.inner.concat(err.inner.length ? err.inner : err);
+        const innerErrors = err.inner.length ? err.inner : [err];
+        this.inner.push(...innerErrors);
       } else {
         this.errors.push(err);
       }
     });
     this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];
-    if (Error.captureStackTrace) Error.captureStackTrace(this, ValidationError);
+  }
+}
+_Symbol$hasInstance = Symbol.hasInstance;
+_Symbol$toStringTag2 = Symbol.toStringTag;
+class ValidationError extends Error {
+  static formatError(message, params) {
+    // Attempt to make the path more friendly for error message interpolation.
+    const path = params.label || params.path || 'this';
+    // Store the original path under `originalPath` so it isn't lost to custom
+    // message functions; e.g., ones provided in `setLocale()` calls.
+    params = Object.assign({}, params, {
+      path,
+      originalPath: params.path
+    });
+    if (typeof message === 'string') return message.replace(strReg, (_, key) => printValue(params[key]));
+    if (typeof message === 'function') return message(params);
+    return message;
+  }
+  static isError(err) {
+    return err && err.name === 'ValidationError';
+  }
+  constructor(errorOrErrors, value, field, type, disableStack) {
+    const errorNoStack = new ValidationErrorNoStack(errorOrErrors, value, field, type);
+    if (disableStack) {
+      return errorNoStack;
+    }
+    super();
+    this.value = void 0;
+    this.path = void 0;
+    this.type = void 0;
+    this.params = void 0;
+    this.errors = [];
+    this.inner = [];
+    this[_Symbol$toStringTag2] = 'Error';
+    this.name = errorNoStack.name;
+    this.message = errorNoStack.message;
+    this.type = errorNoStack.type;
+    this.value = errorNoStack.value;
+    this.path = errorNoStack.path;
+    this.errors = errorNoStack.errors;
+    this.inner = errorNoStack.inner;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ValidationError);
+    }
+  }
+  static [_Symbol$hasInstance](inst) {
+    return ValidationErrorNoStack[Symbol.hasInstance](inst) || super[Symbol.hasInstance](inst);
   }
 }
 
@@ -446,6 +490,9 @@ let string = {
   email: '${path} must be a valid email',
   url: '${path} must be a valid URL',
   uuid: '${path} must be a valid UUID',
+  datetime: '${path} must be a valid ISO date-time',
+  datetime_precision: '${path} must be a valid ISO date-time with a sub-second precision of exactly ${precision} digits',
+  datetime_offset: '${path} must be a valid ISO date-time with UTC "Z" timezone',
   trim: '${path} must be a trimmed string',
   lowercase: '${path} must be a lowercase string',
   uppercase: '${path} must be a upper case string'
@@ -467,13 +514,29 @@ let boolean = {
   isValue: '${path} field must be ${value}'
 };
 let object = {
-  noUnknown: '${path} field has unspecified keys: ${unknown}'
+  noUnknown: '${path} field has unspecified keys: ${unknown}',
+  exact: '${path} object contains unknown properties: ${properties}'
 };
 let array = {
   min: '${path} field must have at least ${min} items',
   max: '${path} field must have less than or equal to ${max} items',
   length: '${path} must have ${length} items'
 };
+let tuple = {
+  notType: params => {
+    const {
+      path,
+      value,
+      spec
+    } = params;
+    const typeLen = spec.types.length;
+    if (Array.isArray(value)) {
+      if (value.length < typeLen) return `${path} tuple value has too few items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+      if (value.length > typeLen) return `${path} tuple value has too many items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+    }
+    return ValidationError.formatError(mixed.notType, params);
+  }
+};
 Object.assign(Object.create(null), {
   mixed,
   string,
@@ -481,7 +544,8 @@ Object.assign(Object.create(null), {
   date,
   object,
   array,
-  boolean
+  boolean,
+  tuple
 });
 
 const isSchema = obj => obj && obj.__isYupSchema__;
@@ -603,21 +667,24 @@ function createValidation(config) {
     let {
       parent,
       context,
-      abortEarly = schema.spec.abortEarly
+      abortEarly = schema.spec.abortEarly,
+      disableStackTrace = schema.spec.disableStackTrace
     } = options;
-    function resolve(item) {
-      return Reference.isRef(item) ? item.getValue(value, parent, context) : item;
-    }
+    const resolveOptions = {
+      value,
+      parent,
+      context
+    };
     function createError(overrides = {}) {
-      const nextParams = Object.assign({
+      const nextParams = resolveParams(Object.assign({
         value,
         originalValue,
         label: schema.spec.label,
         path: overrides.path || path,
-        spec: schema.spec
-      }, params, overrides.params);
-      for (const key of Object.keys(nextParams)) nextParams[key] = resolve(nextParams[key]);
-      const error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name);
+        spec: schema.spec,
+        disableStackTrace: overrides.disableStackTrace || disableStackTrace
+      }, params, overrides.params), resolveOptions);
+      const error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name, nextParams.disableStackTrace);
       error.params = nextParams;
       return error;
     }
@@ -628,7 +695,9 @@ function createValidation(config) {
       type: name,
       from: options.from,
       createError,
-      resolve,
+      resolve(item) {
+        return resolveMaybeRef(item, resolveOptions);
+      },
       options,
       originalValue,
       schema
@@ -640,20 +709,18 @@ function createValidation(config) {
       if (ValidationError.isError(err)) invalid(err);else panic(err);
     };
     const shouldSkip = skipAbsent && isAbsent(value);
-    if (!options.sync) {
-      try {
-        Promise.resolve(!shouldSkip ? test.call(ctx, value, ctx) : true).then(handleResult, handleError);
-      } catch (err) {
-        handleError(err);
-      }
-      return;
+    if (shouldSkip) {
+      return handleResult(true);
     }
     let result;
     try {
       var _result;
-      result = !shouldSkip ? test.call(ctx, value, ctx) : true;
+      result = test.call(ctx, value, ctx);
       if (typeof ((_result = result) == null ? void 0 : _result.then) === 'function') {
-        throw new Error(`Validation test of type: "${ctx.type}" returned a Promise during a synchronous validate. ` + `This test will finish after the validate call has returned`);
+        if (options.sync) {
+          throw new Error(`Validation test of type: "${ctx.type}" returned a Promise during a synchronous validate. ` + `This test will finish after the validate call has returned`);
+        }
+        return Promise.resolve(result).then(handleResult, handleError);
       }
     } catch (err) {
       handleError(err);
@@ -665,6 +732,18 @@ function createValidation(config) {
   return validate;
 }
 
+// Warning: mutates the input
+function resolveParams(params, options) {
+  if (!params) return params;
+  for (const key of Object.keys(params)) {
+    params[key] = resolveMaybeRef(params[key], options);
+  }
+  return params;
+}
+function resolveMaybeRef(item, options) {
+  return Reference.isRef(item) ? item.getValue(options.value, options.parent, options.context) : item;
+}
+
 function getIn(schema, path, value, context = value) {
   let parent, lastPart, lastPartDebug;
 
@@ -778,6 +857,89 @@ function clone(src, seen = new Map()) {
   return copy;
 }
 
+/**
+ * Copied from @standard-schema/spec to avoid having a dependency on it.
+ * https://github.com/standard-schema/standard-schema/blob/main/packages/spec/src/index.ts
+ */
+
+function createStandardPath(path) {
+  if (!(path != null && path.length)) {
+    return undefined;
+  }
+
+  // Array to store the final path segments
+  const segments = [];
+  // Buffer for building the current segment
+  let currentSegment = '';
+  // Track if we're inside square brackets (array/property access)
+  let inBrackets = false;
+  // Track if we're inside quotes (for property names with special chars)
+  let inQuotes = false;
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    if (char === '[' && !inQuotes) {
+      // When entering brackets, push any accumulated segment after splitting on dots
+      if (currentSegment) {
+        segments.push(...currentSegment.split('.').filter(Boolean));
+        currentSegment = '';
+      }
+      inBrackets = true;
+      continue;
+    }
+    if (char === ']' && !inQuotes) {
+      if (currentSegment) {
+        // Handle numeric indices (e.g. arr[0])
+        if (/^\d+$/.test(currentSegment)) {
+          segments.push(currentSegment);
+        } else {
+          // Handle quoted property names (e.g. obj["foo.bar"])
+          segments.push(currentSegment.replace(/^"|"$/g, ''));
+        }
+        currentSegment = '';
+      }
+      inBrackets = false;
+      continue;
+    }
+    if (char === '"') {
+      // Toggle quote state for handling quoted property names
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (char === '.' && !inBrackets && !inQuotes) {
+      // On dots outside brackets/quotes, push current segment
+      if (currentSegment) {
+        segments.push(currentSegment);
+        currentSegment = '';
+      }
+      continue;
+    }
+    currentSegment += char;
+  }
+
+  // Push any remaining segment after splitting on dots
+  if (currentSegment) {
+    segments.push(...currentSegment.split('.').filter(Boolean));
+  }
+  return segments;
+}
+function createStandardIssues(error, parentPath) {
+  const path = parentPath ? `${parentPath}.${error.path}` : error.path;
+  return error.errors.map(err => ({
+    message: err,
+    path: createStandardPath(path)
+  }));
+}
+function issuesFromValidationError(error, parentPath) {
+  var _error$inner;
+  if (!((_error$inner = error.inner) != null && _error$inner.length) && error.errors.length) {
+    return createStandardIssues(error, parentPath);
+  }
+  const path = parentPath ? `${parentPath}.${error.path}` : error.path;
+  return error.inner.flatMap(err => issuesFromValidationError(err, path));
+}
+
+// If `CustomSchemaMeta` isn't extended with any keys, we'll fall back to a
+// loose Record definition allowing free form usage.
 class Schema {
   constructor(options) {
     this.type = void 0;
@@ -804,6 +966,7 @@ class Schema {
       strict: false,
       abortEarly: true,
       recursive: true,
+      disableStackTrace: false,
       nullable: false,
       optional: true,
       coerce: true
@@ -909,12 +1072,13 @@ class Schema {
     return schema;
   }
   resolveOptions(options) {
-    var _options$strict, _options$abortEarly, _options$recursive;
+    var _options$strict, _options$abortEarly, _options$recursive, _options$disableStack;
     return Object.assign({}, options, {
       from: options.from || [],
       strict: (_options$strict = options.strict) != null ? _options$strict : this.spec.strict,
       abortEarly: (_options$abortEarly = options.abortEarly) != null ? _options$abortEarly : this.spec.abortEarly,
-      recursive: (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive
+      recursive: (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive,
+      disableStackTrace: (_options$disableStack = options.disableStackTrace) != null ? _options$disableStack : this.spec.disableStackTrace
     });
   }
 
@@ -923,9 +1087,12 @@ class Schema {
    */
 
   cast(value, options = {}) {
-    let resolvedSchema = this.resolve(Object.assign({
+    let resolvedSchema = this.resolve(Object.assign({}, options, {
       value
-    }, options));
+      // parent: options.parent,
+      // context: options.context,
+    }));
+
     let allowOptionality = options.assert === 'ignore-optionality';
     let result = resolvedSchema._cast(value, options);
     if (options.assert !== false && !resolvedSchema.isType(result)) {
@@ -939,7 +1106,7 @@ class Schema {
     return result;
   }
   _cast(rawValue, options) {
-    let value = rawValue === undefined ? rawValue : this.transforms.reduce((prevValue, fn) => fn.call(this, prevValue, rawValue, this), rawValue);
+    let value = rawValue === undefined ? rawValue : this.transforms.reduce((prevValue, fn) => fn.call(this, prevValue, rawValue, this, options), rawValue);
     if (value === undefined) {
       value = this.getDefault(options);
     }
@@ -1019,7 +1186,7 @@ class Schema {
       const test = tests[i];
       test(args, panicOnce, function finishTestRun(err) {
         if (err) {
-          nestedErrors = nestedErrors.concat(err);
+          Array.isArray(err) ? nestedErrors.push(...err) : nestedErrors.push(err);
         }
         if (--count <= 0) {
           nextOnce(nestedErrors);
@@ -1054,33 +1221,37 @@ class Schema {
       key: undefined,
       // index: undefined,
       [isIndex ? 'index' : 'key']: k,
-      path: isIndex || k.includes('.') ? `${parentPath || ''}[${value ? k : `"${k}"`}]` : (parentPath ? `${parentPath}.` : '') + key
+      path: isIndex || k.includes('.') ? `${parentPath || ''}[${isIndex ? k : `"${k}"`}]` : (parentPath ? `${parentPath}.` : '') + key
     });
     return (_, panic, next) => this.resolve(testOptions)._validate(value, testOptions, panic, next);
   }
   validate(value, options) {
+    var _options$disableStack2;
     let schema = this.resolve(Object.assign({}, options, {
       value
     }));
+    let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema.spec.disableStackTrace;
     return new Promise((resolve, reject) => schema._validate(value, options, (error, parsed) => {
       if (ValidationError.isError(error)) error.value = parsed;
       reject(error);
     }, (errors, validated) => {
-      if (errors.length) reject(new ValidationError(errors, validated));else resolve(validated);
+      if (errors.length) reject(new ValidationError(errors, validated, undefined, undefined, disableStackTrace));else resolve(validated);
     }));
   }
   validateSync(value, options) {
+    var _options$disableStack3;
     let schema = this.resolve(Object.assign({}, options, {
       value
     }));
     let result;
+    let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema.spec.disableStackTrace;
     schema._validate(value, Object.assign({}, options, {
       sync: true
     }), (error, parsed) => {
       if (ValidationError.isError(error)) error.value = parsed;
       throw error;
     }, (errors, validated) => {
-      if (errors.length) throw new ValidationError(errors, value);
+      if (errors.length) throw new ValidationError(errors, value, undefined, undefined, disableStackTrace);
       result = validated;
     });
     return result;
@@ -1337,13 +1508,41 @@ class Schema {
       type: next.type,
       oneOf: next._whitelist.describe(),
       notOneOf: next._blacklist.describe(),
-      tests: next.tests.map(fn => ({
-        name: fn.OPTIONS.name,
-        params: fn.OPTIONS.params
-      })).filter((n, idx, list) => list.findIndex(c => c.name === n.name) === idx)
+      tests: next.tests.filter((n, idx, list) => list.findIndex(c => c.OPTIONS.name === n.OPTIONS.name) === idx).map(fn => {
+        const params = fn.OPTIONS.params && options ? resolveParams(Object.assign({}, fn.OPTIONS.params), options) : fn.OPTIONS.params;
+        return {
+          name: fn.OPTIONS.name,
+          params
+        };
+      })
     };
     return description;
   }
+  get ['~standard']() {
+    const schema = this;
+    const standard = {
+      version: 1,
+      vendor: 'yup',
+      async validate(value) {
+        try {
+          const result = await schema.validate(value, {
+            abortEarly: false
+          });
+          return {
+            value: result
+          };
+        } catch (err) {
+          if (err instanceof ValidationError) {
+            return {
+              issues: issuesFromValidationError(err)
+            };
+          }
+          throw err;
+        }
+      }
+    };
+    return standard;
+  }
 }
 // @ts-expect-error
 Schema.prototype.__isYupSchema__ = true;
@@ -1361,50 +1560,64 @@ for (const method of ['validate', 'validateSync']) Schema.prototype[`${method}At
 for (const alias of ['equals', 'is']) Schema.prototype[alias] = Schema.prototype.oneOf;
 for (const alias of ['not', 'nope']) Schema.prototype[alias] = Schema.prototype.notOneOf;
 
-//
-// Number Interfaces
-//
-
-/* eslint-disable */
 /**
- *
+ * This file is a modified version of the file from the following repository:
  * Date.parse with progressive enhancement for ISO 8601 <https://github.com/csnover/js-iso8601>
  * NON-CONFORMANT EDITION.
  * © 2011 Colin Snover <http://zetafleet.com>
  * Released under MIT license.
  */
 
-//              1 YYYY                 2 MM        3 DD              4 HH     5 mm        6 ss            7 msec         8 Z 9 ±    10 tzHH    11 tzmm
-var isoReg = /^(\d{4}|[+\-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,\.](\d{1,}))?)?(?:(Z)|([+\-])(\d{2})(?::?(\d{2}))?)?)?$/;
+// prettier-ignore
+//                1 YYYY                2 MM        3 DD              4 HH     5 mm        6 ss           7 msec         8 Z 9 ±   10 tzHH    11 tzmm
+const isoReg = /^(\d{4}|[+-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,.](\d{1,}))?)?(?:(Z)|([+-])(\d{2})(?::?(\d{2}))?)?)?$/;
 function parseIsoDate(date) {
-  var numericKeys = [1, 4, 5, 6, 7, 10, 11],
-    minutesOffset = 0,
-    timestamp,
-    struct;
-  if (struct = isoReg.exec(date)) {
-    // avoid NaN timestamps caused by “undefined” values being passed to Date.UTC
-    for (var i = 0, k; k = numericKeys[i]; ++i) struct[k] = +struct[k] || 0;
-
-    // allow undefined days and months
-    struct[2] = (+struct[2] || 1) - 1;
-    struct[3] = +struct[3] || 1;
+  const struct = parseDateStruct(date);
+  if (!struct) return Date.parse ? Date.parse(date) : Number.NaN;
 
-    // allow arbitrary sub-second precision beyond milliseconds
-    struct[7] = struct[7] ? String(struct[7]).substr(0, 3) : 0;
+  // timestamps without timezone identifiers should be considered local time
+  if (struct.z === undefined && struct.plusMinus === undefined) {
+    return new Date(struct.year, struct.month, struct.day, struct.hour, struct.minute, struct.second, struct.millisecond).valueOf();
+  }
+  let totalMinutesOffset = 0;
+  if (struct.z !== 'Z' && struct.plusMinus !== undefined) {
+    totalMinutesOffset = struct.hourOffset * 60 + struct.minuteOffset;
+    if (struct.plusMinus === '+') totalMinutesOffset = 0 - totalMinutesOffset;
+  }
+  return Date.UTC(struct.year, struct.month, struct.day, struct.hour, struct.minute + totalMinutesOffset, struct.second, struct.millisecond);
+}
+function parseDateStruct(date) {
+  var _regexResult$7$length, _regexResult$;
+  const regexResult = isoReg.exec(date);
+  if (!regexResult) return null;
 
-    // timestamps without timezone identifiers should be considered local time
-    if ((struct[8] === undefined || struct[8] === '') && (struct[9] === undefined || struct[9] === '')) timestamp = +new Date(struct[1], struct[2], struct[3], struct[4], struct[5], struct[6], struct[7]);else {
-      if (struct[8] !== 'Z' && struct[9] !== undefined) {
-        minutesOffset = struct[10] * 60 + struct[11];
-        if (struct[9] === '+') minutesOffset = 0 - minutesOffset;
-      }
-      timestamp = Date.UTC(struct[1], struct[2], struct[3], struct[4], struct[5] + minutesOffset, struct[6], struct[7]);
-    }
-  } else timestamp = Date.parse ? Date.parse(date) : NaN;
-  return timestamp;
+  // use of toNumber() avoids NaN timestamps caused by “undefined”
+  // values being passed to Date constructor
+  return {
+    year: toNumber(regexResult[1]),
+    month: toNumber(regexResult[2], 1) - 1,
+    day: toNumber(regexResult[3], 1),
+    hour: toNumber(regexResult[4]),
+    minute: toNumber(regexResult[5]),
+    second: toNumber(regexResult[6]),
+    millisecond: regexResult[7] ?
+    // allow arbitrary sub-second precision beyond milliseconds
+    toNumber(regexResult[7].substring(0, 3)) : 0,
+    precision: (_regexResult$7$length = (_regexResult$ = regexResult[7]) == null ? void 0 : _regexResult$.length) != null ? _regexResult$7$length : undefined,
+    z: regexResult[8] || undefined,
+    plusMinus: regexResult[9] || undefined,
+    hourOffset: toNumber(regexResult[10]),
+    minuteOffset: toNumber(regexResult[11])
+  };
+}
+function toNumber(str, defaultValue = 0) {
+  return Number(str) || defaultValue;
 }
 
-// @ts-ignore
+//
+// Number Interfaces
+//
+
 let invalidDate = new Date('');
 let isDate = obj => Object.prototype.toString.call(obj) === '[object Date]';
 class DateSchema extends Schema {
@@ -1416,10 +1629,10 @@ class DateSchema extends Schema {
       }
     });
     this.withMutation(() => {
-      this.transform((value, _raw, ctx) => {
+      this.transform((value, _raw) => {
         // null -> InvalidDate isn't useful; treat all nulls as null and let it fail on
         // nullability check vs TypeErrors
-        if (!ctx.spec.coerce || ctx.isType(value) || value === null) return value;
+        if (!this.spec.coerce || this.isType(value) || value === null) return value;
         value = parseIsoDate(value);
 
         // 0 is a valid timestamp equivalent to 1970-01-01T00:00:00Z(unix epoch) or before.
@@ -1470,7 +1683,6 @@ class DateSchema extends Schema {
   }
 }
 DateSchema.INVALID_DATE = invalidDate;
-DateSchema.prototype;
 
 // @ts-expect-error
 function sortFields(fields, excludedEdges = []) {
@@ -1507,7 +1719,7 @@ function sortByKeyOrder(keys) {
   };
 }
 
-const parseJson = (value, _, ctx) => {
+const parseJson = (value, _, schema) => {
   if (typeof value !== 'string') {
     return value;
   }
@@ -1517,7 +1729,7 @@ const parseJson = (value, _, ctx) => {
   } catch (err) {
     /* */
   }
-  return ctx.isType(parsed) ? parsed : value;
+  return schema.isType(parsed) ? parsed : value;
 };
 
 // @ts-ignore
@@ -1597,9 +1809,9 @@ class ObjectSchema extends Schema {
     for (const prop of props) {
       let field = fields[prop];
       let exists = (prop in value);
+      let inputValue = value[prop];
       if (field) {
         let fieldValue;
-        let inputValue = value[prop];
 
         // safe to mutate since this is fired in sequence
         innerOptions.path = (options.path ? `${options.path}.` : '') + prop;
@@ -1614,16 +1826,14 @@ class ObjectSchema extends Schema {
           isChanged = isChanged || prop in value;
           continue;
         }
-        fieldValue = !options.__validating || !strict ?
-        // TODO: use _cast, this is double resolving
-        field.cast(value[prop], innerOptions) : value[prop];
+        fieldValue = !options.__validating || !strict ? field.cast(inputValue, innerOptions) : inputValue;
         if (fieldValue !== undefined) {
           intermediateValue[prop] = fieldValue;
         }
       } else if (exists && !strip) {
-        intermediateValue[prop] = value[prop];
+        intermediateValue[prop] = inputValue;
       }
-      if (exists !== prop in intermediateValue || intermediateValue[prop] !== value[prop]) {
+      if (exists !== prop in intermediateValue || intermediateValue[prop] !== inputValue) {
         isChanged = true;
       }
     }
@@ -1753,14 +1963,15 @@ class ObjectSchema extends Schema {
     for (const key of keys) {
       if (this.fields[key]) picked[key] = this.fields[key];
     }
-    return this.setFields(picked);
+    return this.setFields(picked, this._excludedEdges.filter(([a, b]) => keys.includes(a) && keys.includes(b)));
   }
   omit(keys) {
-    const fields = Object.assign({}, this.fields);
-    for (const key of keys) {
-      delete fields[key];
+    const remaining = [];
+    for (const key of Object.keys(this.fields)) {
+      if (keys.includes(key)) continue;
+      remaining.push(key);
     }
-    return this.setFields(fields);
+    return this.pick(remaining);
   }
   from(from, to, alias) {
     let fromGetter = propertyExpr.getter(from, true);
@@ -1780,6 +1991,31 @@ class ObjectSchema extends Schema {
   json() {
     return this.transform(parseJson);
   }
+
+  /**
+   * Similar to `noUnknown` but only validates that an object is the right shape without stripping the unknown keys
+   */
+  exact(message) {
+    return this.test({
+      name: 'exact',
+      exclusive: true,
+      message: message || object.exact,
+      test(value) {
+        if (value == null) return true;
+        const unknownKeys = unknown(this.schema, value);
+        return unknownKeys.length === 0 || this.createError({
+          params: {
+            properties: unknownKeys.join(', ')
+          }
+        });
+      }
+    });
+  }
+  stripUnknown() {
+    return this.clone({
+      noUnknown: true
+    });
+  }
   noUnknown(noAllow = true, message = object.noUnknown) {
     if (typeof noAllow !== 'boolean') {
       message = noAllow;
@@ -1823,9 +2059,10 @@ class ObjectSchema extends Schema {
     return this.transformKeys(key => tinyCase.snakeCase(key).toUpperCase());
   }
   describe(options) {
-    let base = super.describe(options);
+    const next = (options ? this.resolve(options) : this).clone();
+    const base = super.describe(options);
     base.fields = {};
-    for (const [key, value] of Object.entries(this.fields)) {
+    for (const [key, value] of Object.entries(next.fields)) {
       var _innerOptions2;
       let innerOptions = options;
       if ((_innerOptions2 = innerOptions) != null && _innerOptions2.value) {