n4s 5.0.4 → 5.0.5

package/dist/cjs/compose.development.js

@@ -54,3 +54,4 @@ function compose(...composites) {
 }
 
 module.exports = compose;
+//# sourceMappingURL=compose.development.js.map

package/dist/cjs/compose.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.development.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/exports/compose.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { ctx } from 'n4s';\nimport { invariant, StringObject, assign, mapFirst } from 'vest-utils';\n\nimport type { ComposeResult, LazyRuleRunners } from 'genEnforceLazy';\nimport { defaultToPassing, RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\n/* eslint-disable max-lines-per-function */\n\nexport default function compose(\n  ...composites: LazyRuleRunners[]\n): ComposeResult {\n  return assign(\n    (value: any) => {\n      const res = run(value);\n\n      invariant(res.pass, StringObject(res.message));\n    },\n    {\n      run,\n      test: (value: any) => run(value).pass,\n    }\n  );\n\n  function run(value: any): RuleDetailedResult {\n    return ctx.run({ value }, () => {\n      return defaultToPassing(\n        mapFirst(\n          composites,\n          (\n            composite: LazyRuleRunners,\n            breakout: (conditional: boolean, res: RuleDetailedResult) => void\n          ) => {\n            /* HACK: Just a small white lie. ~~HELP WANTED~~.\n               The ideal is that instead of `LazyRuleRunners` We would simply use `Lazy` to begin with.\n               The problem is that lazy rules can't really be passed to this function due to some generic hell\n               so we're limiting it to a small set of functions.\n            */\n\n            const res = runLazyRule(composite, value);\n\n            breakout(!res.pass, res);\n          }\n        )\n      );\n    });\n  }\n}\n"],"names":["defaultTo","ruleReturn.failing","assign","invariant","StringObject","ctx","mapFirst"],"mappings":";;;;;AAGc,SAAU,UAAU,CAChC,IAAa,EACb,OAAgB,EAAA;AAEhB,IAAA,MAAM,MAAM,GAAuB,EAAE,IAAI,EAAE,CAAC;AAE5C,IAAA,IAAI,OAAO,EAAE;AACX,QAAA,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC;AAC1B,KAAA;AAED,IAAA,OAAO,MAAM,CAAC;AAChB,CAAC;SAEe,OAAO,GAAA;AACrB,IAAA,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;AAC3B,CAAC;SAEe,OAAO,GAAA;AACrB,IAAA,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAQK,SAAU,gBAAgB,CAC9B,QAAgD,EAAA;AAEhD,IAAA,OAAOA,mBAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;AACxC;;AC9Bc,SAAU,WAAW,CACjC,QAAyB,EACzB,YAAiB,EAAA;IAEjB,IAAI;AACF,QAAA,OAAO,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;AACnC,KAAA;IAAC,OAAM,EAAA,EAAA;AACN,QAAA,OAAOC,OAAkB,EAAE,CAAC;AAC7B,KAAA;AACH;;ACNA;AAEc,SAAU,OAAO,CAC7B,GAAG,UAA6B,EAAA;AAEhC,IAAA,OAAOC,gBAAM,CACX,CAAC,KAAU,KAAI;AACb,QAAA,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC;AAEvB,QAAAC,mBAAS,CAAC,GAAG,CAAC,IAAI,EAAEC,sBAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AACjD,KAAC,EACD;QACE,GAAG;QACH,IAAI,EAAE,CAAC,KAAU,KAAK,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI;AACtC,KAAA,CACF,CAAC;IAEF,SAAS,GAAG,CAAC,KAAU,EAAA;QACrB,OAAOC,OAAG,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,MAAK;YAC7B,OAAO,gBAAgB,CACrBC,kBAAQ,CACN,UAAU,EACV,CACE,SAA0B,EAC1B,QAAiE,KAC/D;AACF;;;;AAIE;gBAEF,MAAM,GAAG,GAAG,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;gBAE1C,QAAQ,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;aAC1B,CACF,CACF,CAAC;AACJ,SAAC,CAAC,CAAC;KACJ;AACH;;;;"}

package/dist/cjs/compose.production.js

@@ -1 +1,2 @@
 "use strict";var t=require("n4s"),n=require("vest-utils");function r(t,n){const r={pass:t};return n&&(r.message=n),r}function s(t){return n.defaultTo(t,r(!0))}function e(t,n){try{return t.run(n)}catch(t){return r(!1)}}module.exports=function(...r){return n.assign((t=>{const r=u(t);n.invariant(r.pass,n.StringObject(r.message))}),{run:u,test:t=>u(t).pass});function u(u){return t.ctx.run({value:u},(()=>s(n.mapFirst(r,((t,n)=>{const r=e(t,u);n(!r.pass,r)})))))}};
+//# sourceMappingURL=compose.production.js.map

package/dist/cjs/compose.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.production.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/exports/compose.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { ctx } from 'n4s';\nimport { invariant, StringObject, assign, mapFirst } from 'vest-utils';\n\nimport type { ComposeResult, LazyRuleRunners } from 'genEnforceLazy';\nimport { defaultToPassing, RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\n/* eslint-disable max-lines-per-function */\n\nexport default function compose(\n  ...composites: LazyRuleRunners[]\n): ComposeResult {\n  return assign(\n    (value: any) => {\n      const res = run(value);\n\n      invariant(res.pass, StringObject(res.message));\n    },\n    {\n      run,\n      test: (value: any) => run(value).pass,\n    }\n  );\n\n  function run(value: any): RuleDetailedResult {\n    return ctx.run({ value }, () => {\n      return defaultToPassing(\n        mapFirst(\n          composites,\n          (\n            composite: LazyRuleRunners,\n            breakout: (conditional: boolean, res: RuleDetailedResult) => void\n          ) => {\n            /* HACK: Just a small white lie. ~~HELP WANTED~~.\n               The ideal is that instead of `LazyRuleRunners` We would simply use `Lazy` to begin with.\n               The problem is that lazy rules can't really be passed to this function due to some generic hell\n               so we're limiting it to a small set of functions.\n            */\n\n            const res = runLazyRule(composite, value);\n\n            breakout(!res.pass, res);\n          }\n        )\n      );\n    });\n  }\n}\n"],"names":["ruleReturn","pass","message","output","defaultToPassing","callback","defaultTo","runLazyRule","lazyRule","currentValue","run","_a","composites","assign","value","res","invariant","StringObject","test","ctx","mapFirst","composite","breakout"],"mappings":"0DAGc,SAAUA,EACtBC,EACAC,GAEA,MAAMC,EAA6B,CAAEF,QAMrC,OAJIC,IACFC,EAAOD,QAAUA,GAGZC,CACT,CAgBM,SAAUC,EACdC,GAEA,OAAOC,YAAUD,EAZVL,GAAW,GAapB,CC9Bc,SAAUO,EACtBC,EACAC,GAEA,IACE,OAAOD,EAASE,IAAID,EAGrB,CAFC,MAAME,GACN,ODMKX,GAAW,ECLjB,CACH,gBCJc,YACTY,GAEH,OAAOC,EAAAA,QACJC,IACC,MAAMC,EAAML,EAAII,GAEhBE,EAASA,UAACD,EAAId,KAAMgB,EAAYA,aAACF,EAAIb,SAAS,GAEhD,CACEQ,MACAQ,KAAOJ,GAAeJ,EAAII,GAAOb,OAIrC,SAASS,EAAII,GACX,OAAOK,MAAIT,IAAI,CAAEI,UAAS,IACjBV,EACLgB,EAAQA,SACNR,GACA,CACES,EACAC,KAQA,MAAMP,EAAMR,EAAYc,EAAWP,GAEnCQ,GAAUP,EAAId,KAAMc,EAAI,MAKjC,CACH"}

package/dist/cjs/compounds.development.js

@@ -74,3 +74,4 @@ function oneOf(value, ...rules) {
 }
 
 n4s.enforce.extend({ allOf, anyOf, noneOf, oneOf });
+//# sourceMappingURL=compounds.development.js.map

package/dist/cjs/compounds.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compounds.development.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/plugins/compounds/allOf.ts","../../src/plugins/compounds/anyOf.ts","../../src/plugins/compounds/noneOf.ts","../../src/rules/equals.ts","../../src/plugins/compounds/oneOf.ts","../../src/exports/compounds.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport * as ruleReturn from 'ruleReturn';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function allOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n      breakout(!res.pass, res);\n    })\n  );\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport * as ruleReturn from 'ruleReturn';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function anyOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToFailing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n      breakout(res.pass, res);\n    })\n  );\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function noneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n\n      breakout(res.pass, ruleReturn.failing());\n    })\n  );\n}\n","import { bindNot } from 'vest-utils';\n\nexport function equals(value: unknown, arg1: unknown): boolean {\n  return value === arg1;\n}\n\nexport const notEquals = bindNot(equals);\n","import { greaterThan } from 'vest-utils';\n\nimport { equals } from 'equals';\nimport type { Lazy } from 'genEnforceLazy';\nimport ruleReturn, { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nconst REQUIRED_COUNT = 1;\n\nexport function oneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  let passingCount = 0;\n  rules.some(rule => {\n    const res = runLazyRule(rule, value);\n\n    if (res.pass) {\n      passingCount++;\n    }\n\n    if (greaterThan(passingCount, REQUIRED_COUNT)) {\n      return false;\n    }\n  });\n\n  return ruleReturn(equals(passingCount, REQUIRED_COUNT));\n}\n","import { enforce } from 'n4s';\n\nimport { allOf } from 'allOf';\nimport { anyOf } from 'anyOf';\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\nimport { Lazy } from 'genEnforceLazy';\nimport { noneOf } from 'noneOf';\nimport { oneOf } from 'oneOf';\nimport { RuleDetailedResult } from 'ruleReturn';\n\nenforce.extend({ allOf, anyOf, noneOf, oneOf });\n\ntype EnforceCompoundRule = (\n  value: unknown,\n  ...rules: Lazy[]\n) => RuleDetailedResult;\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      allOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      anyOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      noneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      oneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n    }\n  }\n}\n"],"names":["defaultTo","ruleReturn.failing","ruleReturn.defaultToPassing","mapFirst","ruleReturn.defaultToFailing","bindNot","greaterThan","enforce"],"mappings":"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"}

package/dist/cjs/compounds.production.js

@@ -1 +1,2 @@
 "use strict";var n=require("n4s"),t=require("vest-utils");function r(n,t){const r={pass:n};return t&&(r.message=t),r}function e(){return r(!1)}function u(n){return t.defaultTo(n,r(!0))}function s(n,t){try{return n.run(t)}catch(n){return e()}}function o(n,t){return n===t}t.bindNot(o);n.enforce.extend({allOf:function(n,...r){return u(t.mapFirst(r,((t,r)=>{const e=s(t,n);r(!e.pass,e)})))},anyOf:function(n,...r){return u=t.mapFirst(r,((t,r)=>{const e=s(t,n);r(e.pass,e)})),t.defaultTo(u,e());var u},noneOf:function(n,...r){return u(t.mapFirst(r,((t,r)=>{r(s(t,n).pass,e())})))},oneOf:function(n,...e){let u=0;return e.some((r=>{if(s(r,n).pass&&u++,t.greaterThan(u,1))return!1})),r(o(u,1))}});
+//# sourceMappingURL=compounds.production.js.map

package/dist/cjs/compounds.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compounds.production.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/rules/equals.ts","../../src/exports/compounds.ts","../../src/plugins/compounds/allOf.ts","../../src/plugins/compounds/anyOf.ts","../../src/plugins/compounds/noneOf.ts","../../src/plugins/compounds/oneOf.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { bindNot } from 'vest-utils';\n\nexport function equals(value: unknown, arg1: unknown): boolean {\n  return value === arg1;\n}\n\nexport const notEquals = bindNot(equals);\n","import { enforce } from 'n4s';\n\nimport { allOf } from 'allOf';\nimport { anyOf } from 'anyOf';\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\nimport { Lazy } from 'genEnforceLazy';\nimport { noneOf } from 'noneOf';\nimport { oneOf } from 'oneOf';\nimport { RuleDetailedResult } from 'ruleReturn';\n\nenforce.extend({ allOf, anyOf, noneOf, oneOf });\n\ntype EnforceCompoundRule = (\n  value: unknown,\n  ...rules: Lazy[]\n) => RuleDetailedResult;\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      allOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      anyOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      noneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      oneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n    }\n  }\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport * as ruleReturn from 'ruleReturn';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function allOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n      breakout(!res.pass, res);\n    })\n  );\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport * as ruleReturn from 'ruleReturn';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function anyOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToFailing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n      breakout(res.pass, res);\n    })\n  );\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function noneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n\n      breakout(res.pass, ruleReturn.failing());\n    })\n  );\n}\n","import { greaterThan } from 'vest-utils';\n\nimport { equals } from 'equals';\nimport type { Lazy } from 'genEnforceLazy';\nimport ruleReturn, { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nconst REQUIRED_COUNT = 1;\n\nexport function oneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  let passingCount = 0;\n  rules.some(rule => {\n    const res = runLazyRule(rule, value);\n\n    if (res.pass) {\n      passingCount++;\n    }\n\n    if (greaterThan(passingCount, REQUIRED_COUNT)) {\n      return false;\n    }\n  });\n\n  return ruleReturn(equals(passingCount, REQUIRED_COUNT));\n}\n"],"names":["ruleReturn","pass","message","output","failing","defaultToPassing","callback","defaultTo","runLazyRule","lazyRule","currentValue","run","_a","ruleReturn.failing","equals","value","arg1","bindNot","enforce","extend","allOf","rules","ruleReturn.defaultToPassing","mapFirst","rule","breakout","res","anyOf","noneOf","oneOf","passingCount","some","greaterThan"],"mappings":"0DAGc,SAAUA,EACtBC,EACAC,GAEA,MAAMC,EAA6B,CAAEF,QAMrC,OAJIC,IACFC,EAAOD,QAAUA,GAGZC,CACT,UAEgBC,IACd,OAAOJ,GAAW,EACpB,CAYM,SAAUK,EACdC,GAEA,OAAOC,YAAUD,EAZVN,GAAW,GAapB,CC9Bc,SAAUQ,EACtBC,EACAC,GAEA,IACE,OAAOD,EAASE,IAAID,EAGrB,CAFC,MAAME,GACN,OAAOC,GACR,CACH,CCXgB,SAAAC,EAAOC,EAAgBC,GACrC,OAAOD,IAAUC,CACnB,CAEyBC,EAAAA,QAAQH,GCIjCI,EAAAA,QAAQC,OAAO,CAAEC,eCHKL,KAAmBM,GACvC,OAAOC,EACLC,EAAQA,SAACF,GAAO,CAACG,EAAMC,KACrB,MAAMC,EAAMlB,EAAYgB,EAAMT,GAC9BU,GAAUC,EAAIzB,KAAMyB,EAAI,IAG9B,EDJwBC,eEHFZ,KAAmBM,GACvC,OLiBAf,EKhBEiB,EAAQA,SAACF,GAAO,CAACG,EAAMC,KACrB,MAAMC,EAAMlB,EAAYgB,EAAMT,GAC9BU,EAASC,EAAIzB,KAAMyB,EAAI,ILgBpBnB,YAAUD,EAAUF,KAHvB,IACJE,CKXF,EFJ+BsB,gBGHRb,KAAmBM,GACxC,OAAOC,EACLC,EAAQA,SAACF,GAAO,CAACG,EAAMC,KAGrBA,EAFYjB,EAAYgB,EAAMT,GAEjBd,KAAMY,IAAqB,IAG9C,EHLuCgB,eIDjBd,KAAmBM,GACvC,IAAIS,EAAe,EAanB,OAZAT,EAAMU,MAAKP,IAOT,GANYhB,EAAYgB,EAAMT,GAEtBd,MACN6B,IAGEE,EAAWA,YAACF,EAXG,GAYjB,OAAO,CACR,IAGI9B,EAAWc,EAAOgB,EAhBJ,GAiBvB"}

package/dist/cjs/date.development.js

@@ -202,3 +202,4 @@ function isISO8601(str) {
 }
 
 n4s.enforce.extend({ isAfter, isBefore, isDate, isISO8601 });
+//# sourceMappingURL=date.development.js.map

package/dist/cjs/date.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.development.js","sources":["../../src/exports/date.ts"],"sourcesContent":["import { enforce } from 'n4s';\nimport isAfter from 'validator/es/lib/isAfter';\nimport isBefore from 'validator/es/lib/isBefore';\nimport isDate from 'validator/es/lib/isDate';\nimport isISO8601 from 'validator/es/lib/isISO8601';\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\n\nenforce.extend({ isAfter, isBefore, isDate, isISO8601 });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isAfter: EnforceCustomMatcher<typeof isAfter, R>;\n      isBefore: EnforceCustomMatcher<typeof isBefore, R>;\n      isDate: EnforceCustomMatcher<typeof isDate, R>;\n      isISO8601: EnforceCustomMatcher<typeof isISO8601, R>;\n    }\n  }\n}\n"],"names":["enforce"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQAA,WAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;;"}

package/dist/cjs/date.production.js

@@ -1 +1,2 @@
 "use strict";var t=require("n4s");function r(t){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},r(t)}function n(t){if(!("string"==typeof t||t instanceof String)){var n=r(t);throw null===t?n="null":"object"===n&&(n=t.constructor.name),new TypeError("Expected a string but received a ".concat(n))}}function e(t){return n(t),t=Date.parse(t),isNaN(t)?null:new Date(t)}function o(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;for(var n in r)void 0===t[n]&&(t[n]=r[n]);return t}function i(t,r){return function(t){if(Array.isArray(t))return t}(t)||function(t,r){if("undefined"==typeof Symbol||!(Symbol.iterator in Object(t)))return;var n=[],e=!0,o=!1,i=void 0;try{for(var a,u=t[Symbol.iterator]();!(e=(a=u.next()).done)&&(n.push(a.value),!r||n.length!==r);e=!0);}catch(t){o=!0,i=t}finally{try{e||null==u.return||u.return()}finally{if(o)throw i}}return n}(t,r)||a(t,r)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function a(t,r){if(t){if("string"==typeof t)return u(t,r);var n=Object.prototype.toString.call(t).slice(8,-1);return"Object"===n&&t.constructor&&(n=t.constructor.name),"Map"===n||"Set"===n?Array.from(t):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?u(t,r):void 0}}function u(t,r){(null==r||r>t.length)&&(r=t.length);for(var n=0,e=new Array(r);n<r;n++)e[n]=t[n];return e}var c={format:"YYYY/MM/DD",delimiters:["/","-"],strictMode:!1};var f=/^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-3])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/,l=/^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-3])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/,d=function(t){var r=t.match(/^(\d{4})-?(\d{3})([ T]{1}\.*|$)/);if(r){var n=Number(r[1]),e=Number(r[2]);return n%4==0&&n%100!=0||n%400==0?e<=366:e<=365}var o=t.match(/(\d{4})-?(\d{0,2})-?(\d*)/).map(Number),i=o[1],a=o[2],u=o[3],c=a?"0".concat(a).slice(-2):a,f=u?"0".concat(u).slice(-2):u,l=new Date("".concat(i,"-").concat(c||"01","-").concat(f||"01"));return!a||!u||l.getUTCFullYear()===i&&l.getUTCMonth()+1===a&&l.getUTCDate()===u};t.enforce.extend({isAfter:function(t,r){var n=e((null==r?void 0:r.comparisonDate)||r||Date().toString()),o=e(t);return!!(o&&n&&o>n)},isBefore:function(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:String(new Date);n(t);var o=e(r),i=e(t);return!!(i&&o&&i<o)},isDate:function(t,r){if(r=o("string"==typeof r?{format:r}:r,c),"string"==typeof t&&(p=r.format,/(^(y{4}|y{2})[.\/-](m{1,2})[.\/-](d{1,2})$)|(^(m{1,2})[.\/-](d{1,2})[.\/-]((y{4}|y{2})$))|(^(d{1,2})[.\/-](m{1,2})[.\/-]((y{4}|y{2})$))/gi.test(p))){var n,e=r.delimiters.find((function(t){return-1!==r.format.indexOf(t)})),u=r.strictMode?e:r.delimiters.find((function(r){return-1!==t.indexOf(r)})),f=function(t,r){for(var n=[],e=Math.min(t.length,r.length),o=0;o<e;o++)n.push([t[o],r[o]]);return n}(t.split(u),r.format.toLowerCase().split(e)),l={},d=function(t,r){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=a(t))||r&&t&&"number"==typeof t.length){n&&(t=n);var e=0,o=function(){};return{s:o,n:function(){return e>=t.length?{done:!0}:{done:!1,value:t[e++]}},e:function(t){throw t},f:o}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var i,u=!0,c=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return u=t.done,t},e:function(t){c=!0,i=t},f:function(){try{u||null==n.return||n.return()}finally{if(c)throw i}}}}(f);try{for(d.s();!(n=d.n()).done;){var y=i(n.value,2),s=y[0],m=y[1];if(s.length!==m.length)return!1;l[m.charAt(0)]=s}}catch(t){d.e(t)}finally{d.f()}var v=l.y;if(2===l.y.length){var b=parseInt(l.y,10);if(isNaN(b))return!1;v=b<(new Date).getFullYear()%100?"20".concat(l.y):"19".concat(l.y)}return new Date("".concat(v,"-").concat(l.m,"-").concat(l.d)).getDate()===+l.d}var p;return!r.strictMode&&("[object Date]"===Object.prototype.toString.call(t)&&isFinite(t))},isISO8601:function(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};n(t);var e=r.strictSeparator?l.test(t):f.test(t);return e&&r.strict?d(t):e}});
+//# sourceMappingURL=date.production.js.map

package/dist/cjs/date.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.production.js","sources":["../../src/exports/date.ts"],"sourcesContent":["import { enforce } from 'n4s';\nimport isAfter from 'validator/es/lib/isAfter';\nimport isBefore from 'validator/es/lib/isBefore';\nimport isDate from 'validator/es/lib/isDate';\nimport isISO8601 from 'validator/es/lib/isISO8601';\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\n\nenforce.extend({ isAfter, isBefore, isDate, isISO8601 });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isAfter: EnforceCustomMatcher<typeof isAfter, R>;\n      isBefore: EnforceCustomMatcher<typeof isBefore, R>;\n      isDate: EnforceCustomMatcher<typeof isDate, R>;\n      isISO8601: EnforceCustomMatcher<typeof isISO8601, R>;\n    }\n  }\n}\n"],"names":["enforce","extend","isAfter","isBefore","isDate","isISO8601"],"mappings":"qqFAQAA,EAAAA,QAAQC,OAAO,CAAEC,mHAASC,+IAAUC,6mDAAQC"}

package/dist/cjs/email.development.js

@@ -363,3 +363,4 @@ function isEmail(str, options) {
 }
 
 n4s.enforce.extend({ isEmail });
+//# sourceMappingURL=email.development.js.map

package/dist/cjs/email.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.development.js","sources":["../../src/exports/email.ts"],"sourcesContent":["import { enforce } from 'n4s';\nimport isEmail from 'validator/es/lib/isEmail';\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\n\nenforce.extend({ isEmail });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isEmail: EnforceCustomMatcher<typeof isEmail, R>;\n    }\n  }\n}\n"],"names":["enforce"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKAA,WAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;;"}

package/dist/cjs/email.production.js

@@ -1 +1,2 @@
 "use strict";var t=require("n4s");function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},e(t)}function n(t){if(!("string"==typeof t||t instanceof String)){var n=e(t);throw null===t?n="null":"object"===n&&(n=t.constructor.name),new TypeError("Expected a string but received a ".concat(n))}}function r(t){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},r(t)}function o(t,e){var o,i;n(t),"object"===r(e)?(o=e.min||0,i=e.max):(o=arguments[1],i=arguments[2]);var a=encodeURI(t).split(/%..|./).length-1;return a>=o&&(void 0===i||a<=i)}function i(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},e=arguments.length>1?arguments[1]:void 0;for(var n in e)void 0===t[n]&&(t[n]=e[n]);return t}var a={require_tld:!0,allow_underscores:!1,allow_trailing_dot:!1,allow_numeric_tld:!1,allow_wildcard:!1,ignore_max_length:!1};var c="(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])",l="(".concat(c,"[.]){3}").concat(c),u=new RegExp("^".concat(l,"$")),s="(?:[0-9a-fA-F]{1,4})",f=new RegExp("^("+"(?:".concat(s,":){7}(?:").concat(s,"|:)|")+"(?:".concat(s,":){6}(?:").concat(l,"|:").concat(s,"|:)|")+"(?:".concat(s,":){5}(?::").concat(l,"|(:").concat(s,"){1,2}|:)|")+"(?:".concat(s,":){4}(?:(:").concat(s,"){0,1}:").concat(l,"|(:").concat(s,"){1,3}|:)|")+"(?:".concat(s,":){3}(?:(:").concat(s,"){0,2}:").concat(l,"|(:").concat(s,"){1,4}|:)|")+"(?:".concat(s,":){2}(?:(:").concat(s,"){0,3}:").concat(l,"|(:").concat(s,"){1,5}|:)|")+"(?:".concat(s,":){1}(?:(:").concat(s,"){0,4}:").concat(l,"|(:").concat(s,"){1,6}|:)|")+"(?::((?::".concat(s,"){0,5}:").concat(l,"|(?::").concat(s,"){1,7}|:))")+")(%[0-9a-zA-Z-.:]{1,})?$");function _(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"";return n(t),(e=String(e))?"4"===e?u.test(t):"6"===e&&f.test(t):_(t,4)||_(t,6)}var x={allow_display_name:!1,allow_underscores:!1,require_display_name:!1,allow_utf8_local_part:!0,require_tld:!0,blacklisted_chars:"",ignore_max_length:!1,host_blacklist:[],host_whitelist:[]},d=/^([^\x00-\x1F\x7F-\x9F\cX]+)</i,g=/^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~]+$/i,m=/^[a-z\d]+$/,p=/^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f]))*$/i,F=/^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\u00A1-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+$/i,h=/^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))*$/i;t.enforce.extend({isEmail:function(t,e){if(n(t),(e=i(e,x)).require_display_name||e.allow_display_name){var r=t.match(d);if(r){var c=r[1];if(t=t.replace(c,"").replace(/(^<|>$)/g,""),c.endsWith(" ")&&(c=c.slice(0,-1)),!function(t){var e=t.replace(/^"(.+)"$/,"$1");if(!e.trim())return!1;if(/[\.";<>]/.test(e)){if(e===t)return!1;if(e.split('"').length!==e.split('\\"').length)return!1}return!0}(c))return!1}else if(e.require_display_name)return!1}if(!e.ignore_max_length&&t.length>254)return!1;var l=t.split("@"),u=l.pop(),s=u.toLowerCase();if(e.host_blacklist.includes(s))return!1;if(e.host_whitelist.length>0&&!e.host_whitelist.includes(s))return!1;var f=l.join("@");if(e.domain_specific_validation&&("gmail.com"===s||"googlemail.com"===s)){var y=(f=f.toLowerCase()).split("+")[0];if(!o(y.replace(/\./g,""),{min:6,max:30}))return!1;for(var b=y.split("."),w=0;w<b.length;w++)if(!m.test(b[w]))return!1}if(!(!1!==e.ignore_max_length||o(f,{max:64})&&o(u,{max:254})))return!1;if(!function(t,e){n(t),(e=i(e,a)).allow_trailing_dot&&"."===t[t.length-1]&&(t=t.substring(0,t.length-1)),!0===e.allow_wildcard&&0===t.indexOf("*.")&&(t=t.substring(2));var r=t.split("."),o=r[r.length-1];if(e.require_tld){if(r.length<2)return!1;if(!e.allow_numeric_tld&&!/^([a-z\u00A1-\u00A8\u00AA-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}|xn[a-z0-9-]{2,})$/i.test(o))return!1;if(/\s/.test(o))return!1}return!(!e.allow_numeric_tld&&/^\d+$/.test(o))&&r.every((function(t){return!(t.length>63&&!e.ignore_max_length||!/^[a-z_\u00a1-\uffff0-9-]+$/i.test(t)||/[\uff01-\uff5e]/.test(t)||/^-|-$/.test(t)||!e.allow_underscores&&/_/.test(t))}))}(u,{require_tld:e.require_tld,ignore_max_length:e.ignore_max_length,allow_underscores:e.allow_underscores})){if(!e.allow_ip_domain)return!1;if(!_(u)){if(!u.startsWith("[")||!u.endsWith("]"))return!1;var v=u.slice(1,-1);if(0===v.length||!_(v))return!1}}if('"'===f[0])return f=f.slice(1,f.length-1),e.allow_utf8_local_part?h.test(f):p.test(f);for(var $=e.allow_utf8_local_part?F:g,D=f.split("."),S=0;S<D.length;S++)if(!$.test(D[S]))return!1;return!e.blacklisted_chars||-1===f.search(new RegExp("[".concat(e.blacklisted_chars,"]+"),"g"))}});
+//# sourceMappingURL=email.production.js.map

package/dist/cjs/email.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.production.js","sources":["../../src/exports/email.ts"],"sourcesContent":["import { enforce } from 'n4s';\nimport isEmail from 'validator/es/lib/isEmail';\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\n\nenforce.extend({ isEmail });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isEmail: EnforceCustomMatcher<typeof isEmail, R>;\n    }\n  }\n}\n"],"names":["enforce","extend","isEmail"],"mappings":"ksFAKAA,EAAAA,QAAQC,OAAO,CAAEC"}

package/dist/cjs/isURL.development.js

@@ -351,3 +351,4 @@ function isURL(url, options) {
 }
 
 n4s.enforce.extend({ isURL });
+//# sourceMappingURL=isURL.development.js.map

package/dist/cjs/isURL.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isURL.development.js","sources":["../../src/exports/isURL.ts"],"sourcesContent":["import { enforce } from 'n4s';\nimport isURL from 'validator/es/lib/isURL';\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\n\nenforce.extend({ isURL });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isURL: EnforceCustomMatcher<typeof isURL, R>;\n    }\n  }\n}\n"],"names":["enforce"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKAA,WAAO,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;;"}

package/dist/cjs/isURL.production.js

@@ -1 +1,2 @@
 "use strict";var t=require("n4s");function r(t){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},r(t)}function e(t){if(!("string"==typeof t||t instanceof String)){var e=r(t);throw null===t?e="null":"object"===e&&(e=t.constructor.name),new TypeError("Expected a string but received a ".concat(e))}}function n(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;for(var e in r)void 0===t[e]&&(t[e]=r[e]);return t}var o={require_tld:!0,allow_underscores:!1,allow_trailing_dot:!1,allow_numeric_tld:!1,allow_wildcard:!1,ignore_max_length:!1};var i="(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])",l="(".concat(i,"[.]){3}").concat(i),c=new RegExp("^".concat(l,"$")),a="(?:[0-9a-fA-F]{1,4})",u=new RegExp("^("+"(?:".concat(a,":){7}(?:").concat(a,"|:)|")+"(?:".concat(a,":){6}(?:").concat(l,"|:").concat(a,"|:)|")+"(?:".concat(a,":){5}(?::").concat(l,"|(:").concat(a,"){1,2}|:)|")+"(?:".concat(a,":){4}(?:(:").concat(a,"){0,1}:").concat(l,"|(:").concat(a,"){1,3}|:)|")+"(?:".concat(a,":){3}(?:(:").concat(a,"){0,2}:").concat(l,"|(:").concat(a,"){1,4}|:)|")+"(?:".concat(a,":){2}(?:(:").concat(a,"){0,3}:").concat(l,"|(:").concat(a,"){1,5}|:)|")+"(?:".concat(a,":){1}(?:(:").concat(a,"){0,4}:").concat(l,"|(:").concat(a,"){1,6}|:)|")+"(?::((?::".concat(a,"){0,5}:").concat(l,"|(?::").concat(a,"){1,7}|:))")+")(%[0-9a-zA-Z-.:]{1,})?$");function s(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"";return e(t),(r=String(r))?"4"===r?c.test(t):"6"===r&&u.test(t):s(t,4)||s(t,6)}function f(t,r){return function(t){if(Array.isArray(t))return t}(t)||function(t,r){if("undefined"==typeof Symbol||!(Symbol.iterator in Object(t)))return;var e=[],n=!0,o=!1,i=void 0;try{for(var l,c=t[Symbol.iterator]();!(n=(l=c.next()).done)&&(e.push(l.value),!r||e.length!==r);n=!0);}catch(t){o=!0,i=t}finally{try{n||null==c.return||c.return()}finally{if(o)throw i}}return e}(t,r)||function(t,r){if(!t)return;if("string"==typeof t)return _(t,r);var e=Object.prototype.toString.call(t).slice(8,-1);"Object"===e&&t.constructor&&(e=t.constructor.name);if("Map"===e||"Set"===e)return Array.from(t);if("Arguments"===e||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e))return _(t,r)}(t,r)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function _(t,r){(null==r||r>t.length)&&(r=t.length);for(var e=0,n=new Array(r);e<r;e++)n[e]=t[e];return n}var p={protocols:["http","https","ftp"],require_tld:!0,require_protocol:!1,require_host:!0,require_port:!1,require_valid_protocol:!0,allow_underscores:!1,allow_trailing_dot:!1,allow_protocol_relative_urls:!1,allow_fragments:!0,allow_query_components:!0,validate_length:!0},h=/^\[([^\]]+)\](?::([0-9]+))?$/;function d(t,r){for(var e=0;e<r.length;e++){var n=r[e];if(t===n||(o=n,"[object RegExp]"===Object.prototype.toString.call(o)&&n.test(t)))return!0}var o;return!1}t.enforce.extend({isURL:function(t,r){if(e(t),!t||/[\s<>]/.test(t))return!1;if(0===t.indexOf("mailto:"))return!1;if((r=n(r,p)).validate_length&&t.length>=2083)return!1;if(!r.allow_fragments&&t.includes("#"))return!1;if(!r.allow_query_components&&(t.includes("?")||t.includes("&")))return!1;var i,l,c,a,u,_,g,y;if(g=t.split("#"),t=g.shift(),g=t.split("?"),t=g.shift(),(g=t.split("://")).length>1){if(i=g.shift().toLowerCase(),r.require_valid_protocol&&-1===r.protocols.indexOf(i))return!1}else{if(r.require_protocol)return!1;if("//"===t.slice(0,2)){if(!r.allow_protocol_relative_urls)return!1;g[0]=t.slice(2)}}if(""===(t=g.join("://")))return!1;if(g=t.split("/"),""===(t=g.shift())&&!r.require_host)return!0;if((g=t.split("@")).length>1){if(r.disallow_auth)return!1;if(""===g[0])return!1;if((l=g.shift()).indexOf(":")>=0&&l.split(":").length>2)return!1;var v=f(l.split(":"),2),w=v[0],m=v[1];if(""===w&&""===m)return!1}_=null,y=null;var b=(a=g.join("@")).match(h);if(b?(c="",y=b[1],_=b[2]||null):(c=(g=a.split(":")).shift(),g.length&&(_=g.join(":"))),null!==_&&_.length>0){if(u=parseInt(_,10),!/^[0-9]+$/.test(_)||u<=0||u>65535)return!1}else if(r.require_port)return!1;return r.host_whitelist?d(c,r.host_whitelist):""===c&&!r.require_host||!!(s(c)||function(t,r){e(t),(r=n(r,o)).allow_trailing_dot&&"."===t[t.length-1]&&(t=t.substring(0,t.length-1)),!0===r.allow_wildcard&&0===t.indexOf("*.")&&(t=t.substring(2));var i=t.split("."),l=i[i.length-1];if(r.require_tld){if(i.length<2)return!1;if(!r.allow_numeric_tld&&!/^([a-z\u00A1-\u00A8\u00AA-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}|xn[a-z0-9-]{2,})$/i.test(l))return!1;if(/\s/.test(l))return!1}return!(!r.allow_numeric_tld&&/^\d+$/.test(l))&&i.every((function(t){return!(t.length>63&&!r.ignore_max_length||!/^[a-z_\u00a1-\uffff0-9-]+$/i.test(t)||/[\uff01-\uff5e]/.test(t)||/^-|-$/.test(t)||!r.allow_underscores&&/_/.test(t))}))}(c,r)||y&&s(y,6))&&(c=c||y,!r.host_blacklist||!d(c,r.host_blacklist))}});
+//# sourceMappingURL=isURL.production.js.map

package/dist/cjs/isURL.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isURL.production.js","sources":["../../src/exports/isURL.ts"],"sourcesContent":["import { enforce } from 'n4s';\nimport isURL from 'validator/es/lib/isURL';\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\n\nenforce.extend({ isURL });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isURL: EnforceCustomMatcher<typeof isURL, R>;\n    }\n  }\n}\n"],"names":["enforce","extend","isURL"],"mappings":"kkGAKAA,EAAAA,QAAQC,OAAO,CAAEC"}

package/dist/cjs/n4s.development.js

@@ -418,3 +418,4 @@ const enforce = genEnforce();
 
 exports.ctx = ctx;
 exports.enforce = enforce;
+//# sourceMappingURL=n4s.development.js.map

package/dist/cjs/n4s.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"n4s.development.js","sources":["../../src/runtime/enforceContext.ts","../../src/rules/endsWith.ts","../../src/rules/equals.ts","../../src/rules/greaterThanOrEquals.ts","../../src/rules/inside.ts","../../src/rules/lessThan.ts","../../src/rules/lessThanOrEquals.ts","../../src/rules/isBetween.ts","../../src/rules/isBlank.ts","../../src/rules/isBoolean.ts","../../src/rules/isEven.ts","../../src/rules/isKeyOf.ts","../../src/rules/isNaN.ts","../../src/rules/isNegative.ts","../../src/rules/isNumber.ts","../../src/rules/isOdd.ts","../../src/rules/isString.ts","../../src/rules/isTruthy.ts","../../src/rules/isValueOf.ts","../../src/rules/longerThanOrEquals.ts","../../src/rules/matches.ts","../../src/rules/ruleCondition.ts","../../src/rules/shorterThan.ts","../../src/rules/shorterThanOrEquals.ts","../../src/rules/startsWith.ts","../../src/runtime/rules.ts","../../src/runtime/runtimeRules.ts","../../src/lib/ruleReturn.ts","../../src/lib/transformResult.ts","../../src/runtime/enforceEager.ts","../../src/runtime/genEnforceLazy.ts","../../src/runtime/enforce.ts"],"sourcesContent":["import { createCascade } from 'context';\nimport { assign, Nullable } from 'vest-utils';\n\nexport const ctx = createCascade<CTXType>((ctxRef, parentContext): CTXType => {\n  const base = {\n    value: ctxRef.value,\n    meta: ctxRef.meta || {},\n  };\n\n  if (!parentContext) {\n    return assign(base, {\n      parent: emptyParent,\n    });\n  } else if (ctxRef.set) {\n    return assign(base, {\n      parent: (): EnforceContext => stripContext(parentContext),\n    });\n  }\n\n  return parentContext;\n});\n\nfunction stripContext(ctx: CTXType): EnforceContext {\n  return {\n    value: ctx.value,\n    meta: ctx.meta,\n    parent: ctx.parent,\n  };\n}\n\ntype CTXType = {\n  meta: Record<string, any>;\n  value: any;\n  set?: boolean;\n  parent: () => Nullable<CTXType>;\n};\n\nexport type EnforceContext = Nullable<{\n  meta: Record<string, any>;\n  value: any;\n  parent: () => EnforceContext;\n}>;\n\nfunction emptyParent(): null {\n  return null;\n}\n","import { isStringValue as isString, bindNot } from 'vest-utils';\n\nexport function endsWith(value: string, arg1: string): boolean {\n  return isString(value) && isString(arg1) && value.endsWith(arg1);\n}\n\nexport const doesNotEndWith = bindNot(endsWith);\n","import { bindNot } from 'vest-utils';\n\nexport function equals(value: unknown, arg1: unknown): boolean {\n  return value === arg1;\n}\n\nexport const notEquals = bindNot(equals);\n","import { greaterThan, numberEquals } from 'vest-utils';\n\nexport function greaterThanOrEquals(\n  value: string | number,\n  gte: string | number\n): boolean {\n  return numberEquals(value, gte) || greaterThan(value, gte);\n}\n","import { isStringValue as isString, bindNot, isArray } from 'vest-utils';\n\nexport function inside(value: unknown, arg1: string | unknown[]): boolean {\n  if (isArray(arg1)) {\n    return arg1.indexOf(value) !== -1;\n  }\n\n  // both value and arg1 are strings\n  if (isString(arg1) && isString(value)) {\n    return arg1.indexOf(value) !== -1;\n  }\n\n  return false;\n}\n\nexport const notInside = bindNot(inside);\n","import { isNumeric } from 'vest-utils';\n\nexport function lessThan(value: string | number, lt: string | number): boolean {\n  return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);\n}\n","import { numberEquals } from 'vest-utils';\n\nimport { lessThan } from 'lessThan';\n\nexport function lessThanOrEquals(\n  value: string | number,\n  lte: string | number\n): boolean {\n  return numberEquals(value, lte) || lessThan(value, lte);\n}\n","import { bindNot } from 'vest-utils';\n\nimport { greaterThanOrEquals as gte } from 'greaterThanOrEquals';\nimport { lessThanOrEquals as lte } from 'lessThanOrEquals';\n\nexport function isBetween(\n  value: number | string,\n  min: number | string,\n  max: number | string\n): boolean {\n  return gte(value, min) && lte(value, max);\n}\n\nexport const isNotBetween = bindNot(isBetween);\n","import { isStringValue, bindNot, isNullish, BlankValue } from 'vest-utils';\n\nexport function isBlank(value: unknown): value is BlankValue {\n  return isNullish(value) || (isStringValue(value) && !value.trim());\n}\n\nexport const isNotBlank = bindNot(isBlank);\n","import { bindNot, isBoolean } from 'vest-utils';\n\nexport const isNotBoolean = bindNot(isBoolean);\nexport { isBoolean };\n","import { isNumeric } from 'vest-utils';\n\nimport type { RuleValue } from 'runtimeRules';\n\n/**\n * Validates that a given value is an even number\n */\nexport const isEven = (value: RuleValue): boolean => {\n  if (isNumeric(value)) {\n    return value % 2 === 0;\n  }\n  return false;\n};\n","import { bindNot } from 'vest-utils';\n\nexport function isKeyOf(key: string | symbol | number, obj: any): boolean {\n  return key in obj;\n}\n\nexport const isNotKeyOf = bindNot(isKeyOf);\n","import { bindNot } from 'vest-utils';\n\nexport function isNaN(value: unknown): boolean {\n  return Number.isNaN(value);\n}\n\nexport const isNotNaN = bindNot(isNaN);\n","import { lessThan } from 'lessThan';\n\nexport function isNegative(value: number | string): boolean {\n  return lessThan(value, 0);\n}\n","import { bindNot } from 'vest-utils';\n\nexport function isNumber(value: unknown): value is number {\n  return Boolean(typeof value === 'number');\n}\n\nexport const isNotNumber = bindNot(isNumber);\n","import { isNumeric } from 'vest-utils';\n\nimport type { RuleValue } from 'runtimeRules';\n/**\n * Validates that a given value is an odd number\n */\nexport const isOdd = (value: RuleValue): boolean => {\n  if (isNumeric(value)) {\n    return value % 2 !== 0;\n  }\n\n  return false;\n};\n","import { isStringValue as isString, bindNot } from 'vest-utils';\n\nexport const isNotString = bindNot(isString);\nexport { isString };\n","import { bindNot } from 'vest-utils';\n\nexport function isTruthy(value: unknown): boolean {\n  return !!value;\n}\n\nexport const isFalsy = bindNot(isTruthy);\n","import { bindNot, isNullish } from 'vest-utils';\n\nexport function isValueOf(value: any, objectToCheck: any): boolean {\n  if (isNullish(objectToCheck)) {\n    return false;\n  }\n\n  for (const key in objectToCheck) {\n    if (objectToCheck[key] === value) {\n      return true;\n    }\n  }\n\n  return false;\n}\nexport const isNotValueOf = bindNot(isValueOf);\n","import { greaterThanOrEquals } from 'greaterThanOrEquals';\n\nexport function longerThanOrEquals(\n  value: string | unknown[],\n  arg1: string | number\n): boolean {\n  return greaterThanOrEquals(value.length, arg1);\n}\n","import { isStringValue as isString, bindNot } from 'vest-utils';\n\nexport function matches(value: string, regex: RegExp | string): boolean {\n  if (regex instanceof RegExp) {\n    return regex.test(value);\n  } else if (isString(regex)) {\n    return new RegExp(regex).test(value);\n  }\n  return false;\n}\n\nexport const notMatches = bindNot(matches);\n","import type { RuleReturn } from 'ruleReturn';\n\nexport function condition(\n  value: any,\n  callback: (value: any) => RuleReturn\n): RuleReturn {\n  try {\n    return callback(value);\n  } catch {\n    return false;\n  }\n}\n","import { lessThan } from 'lessThan';\n\nexport function shorterThan(\n  value: string | unknown[],\n  arg1: string | number\n): boolean {\n  return lessThan(value.length, arg1);\n}\n","import { lessThanOrEquals } from 'lessThanOrEquals';\n\nexport function shorterThanOrEquals(\n  value: string | unknown[],\n  arg1: string | number\n): boolean {\n  return lessThanOrEquals(value.length, arg1);\n}\n","import { isStringValue as isString, bindNot } from 'vest-utils';\n\nexport function startsWith(value: string, arg1: string): boolean {\n  return isString(value) && isString(arg1) && value.startsWith(arg1);\n}\n\nexport const doesNotStartWith = bindNot(startsWith);\n","import {\n  greaterThan,\n  isNull,\n  isNotNull,\n  isNullish,\n  isNotNullish,\n  isNumeric,\n  isNotNumeric,\n  isUndefined,\n  isNotUndefined,\n  lengthEquals,\n  lengthNotEquals,\n  longerThan,\n  numberEquals,\n  numberNotEquals,\n  isArray,\n  isNotArray,\n  isPositive,\n  isEmpty,\n  isNotEmpty,\n} from 'vest-utils';\n\nimport { endsWith, doesNotEndWith } from 'endsWith';\nimport { equals, notEquals } from 'equals';\nimport { greaterThanOrEquals } from 'greaterThanOrEquals';\nimport { inside, notInside } from 'inside';\nimport { isBetween, isNotBetween } from 'isBetween';\nimport { isBlank, isNotBlank } from 'isBlank';\nimport { isBoolean, isNotBoolean } from 'isBoolean';\nimport { isEven } from 'isEven';\nimport { isKeyOf, isNotKeyOf } from 'isKeyOf';\nimport { isNaN, isNotNaN } from 'isNaN';\nimport { isNegative } from 'isNegative';\nimport { isNumber, isNotNumber } from 'isNumber';\nimport { isOdd } from 'isOdd';\nimport { isString, isNotString } from 'isString';\nimport { isTruthy, isFalsy } from 'isTruthy';\nimport { isValueOf, isNotValueOf } from 'isValueOf';\nimport { lessThan } from 'lessThan';\nimport { lessThanOrEquals } from 'lessThanOrEquals';\nimport { longerThanOrEquals } from 'longerThanOrEquals';\nimport { matches, notMatches } from 'matches';\nimport { condition } from 'ruleCondition';\nimport { shorterThan } from 'shorterThan';\nimport { shorterThanOrEquals } from 'shorterThanOrEquals';\nimport { startsWith, doesNotStartWith } from 'startsWith';\n\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, max-lines-per-function\nexport default function rules() {\n  return {\n    condition,\n    doesNotEndWith,\n    doesNotStartWith,\n    endsWith,\n    equals,\n    greaterThan,\n    greaterThanOrEquals,\n    gt: greaterThan,\n    gte: greaterThanOrEquals,\n    inside,\n    isArray,\n    isBetween,\n    isBlank,\n    isBoolean,\n    isEmpty,\n    isEven,\n    isFalsy,\n    isKeyOf,\n    isNaN,\n    isNegative,\n    isNotArray,\n    isNotBetween,\n    isNotBlank,\n    isNotBoolean,\n    isNotEmpty,\n    isNotKeyOf,\n    isNotNaN,\n    isNotNull,\n    isNotNullish,\n    isNotNumber,\n    isNotNumeric,\n    isNotString,\n    isNotUndefined,\n    isNotValueOf,\n    isNull,\n    isNullish,\n    isNumber,\n    isNumeric,\n    isOdd,\n    isPositive,\n    isString,\n    isTruthy,\n    isUndefined,\n    isValueOf,\n    lengthEquals,\n    lengthNotEquals,\n    lessThan,\n    lessThanOrEquals,\n    longerThan,\n    longerThanOrEquals,\n    lt: lessThan,\n    lte: lessThanOrEquals,\n    matches,\n    notEquals,\n    notInside,\n    notMatches,\n    numberEquals,\n    numberNotEquals,\n    shorterThan,\n    shorterThanOrEquals,\n    startsWith,\n  };\n}\n","import type { DropFirst } from 'vest-utils';\n\nimport type { RuleReturn } from 'ruleReturn';\nimport rules from 'rules';\n\nexport type Args = any[];\n\nexport type RuleValue = any;\n\nexport type RuleBase = (value: RuleValue, ...args: Args) => RuleReturn;\n\nexport type Rule = Record<string, RuleBase>;\n\ntype BaseRules = typeof baseRules;\ntype KBaseRules = keyof BaseRules;\n\nconst baseRules = rules();\n\nfunction getRule(ruleName: string): RuleBase {\n  return baseRules[ruleName as KBaseRules];\n}\n\nexport { baseRules, getRule };\n\ntype Rules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<\n  Rules<E> & E\n> &\n  Record<string, (...args: Args) => Rules<E> & E> & {\n    [P in KBaseRules]: (\n      ...args: DropFirst<Parameters<BaseRules[P]>> | Args\n    ) => Rules<E> & E;\n  };\n\n/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */\ndeclare global {\n  namespace n4s {\n    interface IRules<E> extends Rules<E> {}\n  }\n}\n","import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import { invariant, optionalFunctionValue, isBoolean } from 'vest-utils';\n\nimport ruleReturn, { RuleReturn, RuleDetailedResult } from 'ruleReturn';\nimport type { RuleValue, Args } from 'runtimeRules';\n\n/**\n * Transform the result of a rule into a standard format\n */\nexport function transformResult(\n  result: RuleReturn,\n  ruleName: string,\n  value: RuleValue,\n  ...args: Args\n): RuleDetailedResult {\n  validateResult(result);\n\n  // if result is boolean\n  if (isBoolean(result)) {\n    return ruleReturn(result);\n  }\n  return ruleReturn(\n    result.pass,\n    optionalFunctionValue(result.message, ruleName, value, ...args)\n  );\n}\n\nfunction validateResult(result: RuleReturn): void {\n  // if result is boolean, or if result.pass is boolean\n  invariant(\n    isBoolean(result) || (result && isBoolean(result.pass)),\n    'Incorrect return value for rule: ' + JSON.stringify(result)\n  );\n}\n","import { invariant, StringObject, isNullish, Maybe } from 'vest-utils';\n\nimport { ctx } from 'enforceContext';\nimport { getRule, RuleValue, Args, RuleBase } from 'runtimeRules';\nimport { transformResult } from 'transformResult';\n\ntype IRules = n4s.IRules<Record<string, any>>;\ntype TModifiers = {\n  message: (input: string) => EnforceEagerReturn;\n};\n\ntype EnforceEagerReturn = IRules & TModifiers;\n\n// eslint-disable-next-line max-lines-per-function\nexport default function enforceEager(value: RuleValue): EnforceEagerReturn {\n  const target = {\n    message,\n  } as EnforceEagerReturn;\n  let customMessage: Maybe<string> = undefined;\n\n  // We create a proxy intercepting access to the target object (which is empty).\n  const proxy: EnforceEagerReturn = new Proxy(target, {\n    get: (_, key: string) => {\n      // On property access, we identify if it is a rule or not.\n      const rule = getRule(key);\n\n      // If it is a rule, we wrap it with `genRuleCall` that adds the base enforce behavior\n      if (rule) {\n        return genRuleCall(proxy, rule, key);\n      }\n      return target[key];\n    },\n  });\n\n  return proxy;\n\n  // This function is used to wrap a rule with the base enforce behavior\n  // It takes the target object, the rule function, and the rule name\n  // It then returns the rule, in a manner that can be used by enforce\n  function genRuleCall(\n    target: EnforceEagerReturn,\n    rule: RuleBase,\n    ruleName: string\n  ) {\n    return function ruleCall(...args: Args) {\n      // Order of operation:\n      // 1. Create a context with the value being enforced\n      // 2. Call the rule within the context, and pass over the arguments passed to it\n      // 3. Transform the result to the correct output format\n      const transformedResult = ctx.run({ value }, () => {\n        return transformResult(rule(value, ...args), ruleName, value, ...args);\n      });\n\n      function enforceMessage() {\n        if (!isNullish(customMessage)) return StringObject(customMessage);\n        if (isNullish(transformedResult.message)) {\n          return `enforce/${ruleName} failed with ${JSON.stringify(value)}`;\n        }\n        return StringObject(transformedResult.message);\n      }\n\n      // On rule failure (the result is false), we either throw an error\n      // or throw a string value if the rule has a message defined in it.\n      invariant(transformedResult.pass, enforceMessage());\n\n      return target;\n    };\n  }\n\n  function message(input: string): EnforceEagerReturn {\n    customMessage = input;\n    return proxy;\n  }\n}\n\nexport type EnforceEager = (value: RuleValue) => EnforceEagerReturn;\n","import {\n  mapFirst,\n  optionalFunctionValue,\n  CB,\n  Stringable,\n  Maybe,\n  DynamicValue,\n} from 'vest-utils';\n\nimport { ctx } from 'enforceContext';\nimport ruleReturn, { defaultToPassing, RuleDetailedResult } from 'ruleReturn';\nimport { RuleValue, Args, getRule } from 'runtimeRules';\nimport { transformResult } from 'transformResult';\n\n// eslint-disable-next-line max-lines-per-function\nexport default function genEnforceLazy(key: string) {\n  const registeredRules: RegisteredRules = [];\n  let lazyMessage: Maybe<LazyMessage>;\n\n  return addLazyRule(key);\n\n  // eslint-disable-next-line max-lines-per-function\n  function addLazyRule(ruleName: string) {\n    // eslint-disable-next-line max-lines-per-function\n    return (...args: Args): Lazy => {\n      const rule = getRule(ruleName);\n\n      registeredRules.push((value: RuleValue) =>\n        transformResult(rule(value, ...args), ruleName, value, ...args)\n      );\n\n      let proxy = {\n        run: (value: RuleValue): RuleDetailedResult => {\n          return defaultToPassing(\n            mapFirst(registeredRules, (rule, breakout) => {\n              const res = ctx.run({ value }, () => rule(value));\n\n              breakout(\n                !res.pass,\n                ruleReturn(\n                  !!res.pass,\n                  optionalFunctionValue(lazyMessage, value, res.message) ??\n                    res.message\n                )\n              );\n            })\n          );\n        },\n        test: (value: RuleValue): boolean => proxy.run(value).pass,\n        message: (message: Stringable): Lazy => {\n          if (message) {\n            lazyMessage = message;\n          }\n\n          return proxy;\n        },\n      } as Lazy;\n\n      // reassigning the proxy here is not pretty\n      // but it's a cleaner way of getting `run` and `test` for free\n      proxy = new Proxy(proxy, {\n        get: (target, key: string) => {\n          if (getRule(key)) {\n            return addLazyRule(key);\n          }\n\n          return target[key]; // already has `run` and `test` on it\n        },\n      });\n      return proxy;\n    };\n  }\n}\n\nexport type LazyRules = n4s.IRules<LazyRuleMethods>;\n\nexport type Lazy = LazyRules &\n  LazyRuleMethods &\n  // This is a \"catch all\" hack to make TS happy while not\n  // losing type hints\n  Record<string, CB>;\n\ntype LazyRuleMethods = LazyRuleRunners & {\n  message: (message: LazyMessage) => Lazy;\n};\n\nexport type LazyRuleRunners = {\n  test: (value: unknown) => boolean;\n  run: (value: unknown) => RuleDetailedResult;\n};\n\nexport type ComposeResult = LazyRuleRunners & ((value: any) => void);\n\ntype RegisteredRules = Array<(value: RuleValue) => RuleDetailedResult>;\ntype LazyMessage = DynamicValue<\n  string,\n  [value: unknown, originalMessage?: Stringable]\n>;\n","import { assign } from 'vest-utils';\n\nimport { ctx, EnforceContext } from 'enforceContext';\nimport enforceEager, { EnforceEager } from 'enforceEager';\nimport genEnforceLazy, { LazyRules } from 'genEnforceLazy';\nimport { Rule, baseRules, getRule } from 'runtimeRules';\n/**\n * Enforce is quite complicated, I want to explain it in detail.\n * It is dynamic in nature, so a lot of proxy objects are involved.\n *\n * Enforce has two main interfaces\n * 1. eager\n * 2. lazy\n *\n * The eager interface is the most commonly used, and the easier to understand.\n * It throws an error when a rule is not satisfied.\n * The eager interface is declared in enforceEager.ts and it is quite simple to understand.\n * enforce is called with a value, and the return value is a proxy object that points back to all the rules.\n * When a rule is called, the value is mapped as its first argument, and if the rule passes, the same\n * proxy object is returned. Otherwise, an error is thrown.\n *\n * The lazy interface works quite differently. It is declared in genEnforceLazy.ts.\n * Rather than calling enforce directly, the lazy interface has all the rules as \"methods\" (only by proxy).\n * Calling the first function in the chain will initialize an array of calls. It stores the different rule calls\n * and the parameters passed to them. None of the rules are called yet.\n * The rules are only invoked in sequence once either of these chained functions are called:\n * 1. test(value)\n * 2. run(value)\n *\n * Calling run or test will call all the rules in sequence, with the difference that test will only return a boolean value,\n * while run will return an object with the validation result and an optional message created by the rule.\n */\n\nfunction genEnforce(): Enforce {\n  const target = {\n    context: () => ctx.useX(),\n    extend: (customRules: Rule) => {\n      assign(baseRules, customRules);\n    },\n  } as Enforce;\n\n  return new Proxy(assign(enforceEager, target) as Enforce, {\n    get: (target: Enforce, key: string) => {\n      if (key in target) {\n        return target[key];\n      }\n\n      if (!getRule(key)) {\n        return;\n      }\n\n      // Only on the first rule access - start the chain of calls\n      return genEnforceLazy(key);\n    },\n  });\n}\n\nexport const enforce = genEnforce();\n\ntype Enforce = EnforceMethods & LazyRules & EnforceEager;\n\ntype EnforceMethods = {\n  context: () => EnforceContext;\n  extend: (customRules: Rule) => void;\n};\n"],"names":["createCascade","assign","isString","bindNot","numberEquals","greaterThan","isArray","isNumeric","gte","lte","isNullish","isStringValue","isBoolean","isEmpty","isNotArray","isNotEmpty","isNotNull","isNotNullish","isNotNumeric","isNotUndefined","isNull","isPositive","isUndefined","lengthEquals","lengthNotEquals","longerThan","numberNotEquals","defaultTo","optionalFunctionValue","invariant","StringObject","mapFirst"],"mappings":"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"}

package/dist/cjs/n4s.production.js

@@ -1 +1,2 @@
 "use strict";var n=require("vest-utils");const t=require("context").createCascade(((t,i)=>{const s={value:t.value,meta:t.meta||{}};return i?t.set?n.assign(s,{parent:()=>function(n){return{value:n.value,meta:n.meta,parent:n.parent}}(i)}):i:n.assign(s,{parent:e})}));function e(){return null}function i(t,e){return n.isStringValue(t)&&n.isStringValue(e)&&t.endsWith(e)}const s=n.bindNot(i);function r(n,t){return n===t}const u=n.bindNot(r);function o(t,e){return n.numberEquals(t,e)||n.greaterThan(t,e)}function a(t,e){return(n.isArray(e)||!(!n.isStringValue(e)||!n.isStringValue(t)))&&-1!==e.indexOf(t)}const l=n.bindNot(a);function c(t,e){return n.isNumeric(t)&&n.isNumeric(e)&&Number(t)<Number(e)}function N(t,e){return n.numberEquals(t,e)||c(t,e)}function f(n,t,e){return o(n,t)&&N(n,e)}const g=n.bindNot(f);function h(t){return n.isNullish(t)||n.isStringValue(t)&&!t.trim()}const d=n.bindNot(h),m=n.bindNot(n.isBoolean),b=t=>!!n.isNumeric(t)&&t%2==0;function p(n,t){return n in t}const E=n.bindNot(p);function y(n){return Number.isNaN(n)}const q=n.bindNot(y);function v(n){return c(n,0)}function S(n){return Boolean("number"==typeof n)}const O=n.bindNot(S),T=t=>!!n.isNumeric(t)&&t%2!=0,V=n.bindNot(n.isStringValue);function x(n){return!!n}const B=n.bindNot(x);function w(t,e){if(n.isNullish(e))return!1;for(const n in e)if(e[n]===t)return!0;return!1}const W=n.bindNot(w);function A(n,t){return o(n.length,t)}function P(t,e){return e instanceof RegExp?e.test(t):!!n.isStringValue(e)&&new RegExp(e).test(t)}const F=n.bindNot(P);function U(n,t){try{return t(n)}catch(n){return!1}}function j(n,t){return c(n.length,t)}function k(n,t){return N(n.length,t)}function I(t,e){return n.isStringValue(t)&&n.isStringValue(e)&&t.startsWith(e)}const J=n.bindNot(I);const K={condition:U,doesNotEndWith:s,doesNotStartWith:J,endsWith:i,equals:r,greaterThan:n.greaterThan,greaterThanOrEquals:o,gt:n.greaterThan,gte:o,inside:a,isArray:n.isArray,isBetween:f,isBlank:h,isBoolean:n.isBoolean,isEmpty:n.isEmpty,isEven:b,isFalsy:B,isKeyOf:p,isNaN:y,isNegative:v,isNotArray:n.isNotArray,isNotBetween:g,isNotBlank:d,isNotBoolean:m,isNotEmpty:n.isNotEmpty,isNotKeyOf:E,isNotNaN:q,isNotNull:n.isNotNull,isNotNullish:n.isNotNullish,isNotNumber:O,isNotNumeric:n.isNotNumeric,isNotString:V,isNotUndefined:n.isNotUndefined,isNotValueOf:W,isNull:n.isNull,isNullish:n.isNullish,isNumber:S,isNumeric:n.isNumeric,isOdd:T,isPositive:n.isPositive,isString:n.isStringValue,isTruthy:x,isUndefined:n.isUndefined,isValueOf:w,lengthEquals:n.lengthEquals,lengthNotEquals:n.lengthNotEquals,lessThan:c,lessThanOrEquals:N,longerThan:n.longerThan,longerThanOrEquals:A,lt:c,lte:N,matches:P,notEquals:u,notInside:l,notMatches:F,numberEquals:n.numberEquals,numberNotEquals:n.numberNotEquals,shorterThan:j,shorterThanOrEquals:k,startsWith:I};function R(n){return K[n]}function $(n,t){const e={pass:n};return t&&(e.message=t),e}function C(t){return n.defaultTo(t,$(!0))}function M(t,e,i,...s){return function(t){n.invariant(n.isBoolean(t)||t&&n.isBoolean(t.pass),"Incorrect return value for rule: "+JSON.stringify(t))}(t),n.isBoolean(t)?$(t):$(t.pass,n.optionalFunctionValue(t.message,e,i,...s))}function X(e){const i={message:function(n){return s=n,r}};let s;const r=new Proxy(i,{get:(u,o)=>{const a=R(o);return a?function(i,r,u){return function(...o){const a=t.run({value:e},(()=>M(r(e,...o),u,e,...o)));function l(){return n.isNullish(s)?n.isNullish(a.message)?`enforce/${u} failed with ${JSON.stringify(e)}`:n.StringObject(a.message):n.StringObject(s)}return n.invariant(a.pass,l()),i}}(r,a,o):i[o]}});return r}const z=function(){const e={context:()=>t.useX(),extend:t=>{n.assign(K,t)}};return new Proxy(n.assign(X,e),{get:(e,i)=>i in e?e[i]:R(i)?function(e){const i=[];let s;return function e(r){return(...u)=>{const o=R(r);i.push((n=>M(o(n,...u),r,n,...u)));let a={run:e=>C(n.mapFirst(i,((i,r)=>{var u;const o=t.run({value:e},(()=>i(e)));r(!o.pass,$(!!o.pass,null!==(u=n.optionalFunctionValue(s,e,o.message))&&void 0!==u?u:o.message))}))),test:n=>a.run(n).pass,message:n=>(n&&(s=n),a)};return a=new Proxy(a,{get:(n,t)=>R(t)?e(t):n[t]}),a}}(e)}(i):void 0})}();exports.ctx=t,exports.enforce=z;
+//# sourceMappingURL=n4s.production.js.map

package/dist/cjs/n4s.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"n4s.production.js","sources":["../../src/runtime/enforceContext.ts","../../src/rules/endsWith.ts","../../src/rules/equals.ts","../../src/rules/greaterThanOrEquals.ts","../../src/rules/inside.ts","../../src/rules/lessThan.ts","../../src/rules/lessThanOrEquals.ts","../../src/rules/isBetween.ts","../../src/rules/isBlank.ts","../../src/rules/isBoolean.ts","../../src/rules/isEven.ts","../../src/rules/isKeyOf.ts","../../src/rules/isNaN.ts","../../src/rules/isNegative.ts","../../src/rules/isNumber.ts","../../src/rules/isOdd.ts","../../src/rules/isString.ts","../../src/rules/isTruthy.ts","../../src/rules/isValueOf.ts","../../src/rules/longerThanOrEquals.ts","../../src/rules/matches.ts","../../src/rules/ruleCondition.ts","../../src/rules/shorterThan.ts","../../src/rules/shorterThanOrEquals.ts","../../src/rules/startsWith.ts","../../src/runtime/runtimeRules.ts","../../src/runtime/rules.ts","../../src/lib/ruleReturn.ts","../../src/lib/transformResult.ts","../../src/runtime/enforceEager.ts","../../src/runtime/enforce.ts","../../src/runtime/genEnforceLazy.ts"],"sourcesContent":["import { createCascade } from 'context';\nimport { assign, Nullable } from 'vest-utils';\n\nexport const ctx = createCascade<CTXType>((ctxRef, parentContext): CTXType => {\n  const base = {\n    value: ctxRef.value,\n    meta: ctxRef.meta || {},\n  };\n\n  if (!parentContext) {\n    return assign(base, {\n      parent: emptyParent,\n    });\n  } else if (ctxRef.set) {\n    return assign(base, {\n      parent: (): EnforceContext => stripContext(parentContext),\n    });\n  }\n\n  return parentContext;\n});\n\nfunction stripContext(ctx: CTXType): EnforceContext {\n  return {\n    value: ctx.value,\n    meta: ctx.meta,\n    parent: ctx.parent,\n  };\n}\n\ntype CTXType = {\n  meta: Record<string, any>;\n  value: any;\n  set?: boolean;\n  parent: () => Nullable<CTXType>;\n};\n\nexport type EnforceContext = Nullable<{\n  meta: Record<string, any>;\n  value: any;\n  parent: () => EnforceContext;\n}>;\n\nfunction emptyParent(): null {\n  return null;\n}\n","import { isStringValue as isString, bindNot } from 'vest-utils';\n\nexport function endsWith(value: string, arg1: string): boolean {\n  return isString(value) && isString(arg1) && value.endsWith(arg1);\n}\n\nexport const doesNotEndWith = bindNot(endsWith);\n","import { bindNot } from 'vest-utils';\n\nexport function equals(value: unknown, arg1: unknown): boolean {\n  return value === arg1;\n}\n\nexport const notEquals = bindNot(equals);\n","import { greaterThan, numberEquals } from 'vest-utils';\n\nexport function greaterThanOrEquals(\n  value: string | number,\n  gte: string | number\n): boolean {\n  return numberEquals(value, gte) || greaterThan(value, gte);\n}\n","import { isStringValue as isString, bindNot, isArray } from 'vest-utils';\n\nexport function inside(value: unknown, arg1: string | unknown[]): boolean {\n  if (isArray(arg1)) {\n    return arg1.indexOf(value) !== -1;\n  }\n\n  // both value and arg1 are strings\n  if (isString(arg1) && isString(value)) {\n    return arg1.indexOf(value) !== -1;\n  }\n\n  return false;\n}\n\nexport const notInside = bindNot(inside);\n","import { isNumeric } from 'vest-utils';\n\nexport function lessThan(value: string | number, lt: string | number): boolean {\n  return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);\n}\n","import { numberEquals } from 'vest-utils';\n\nimport { lessThan } from 'lessThan';\n\nexport function lessThanOrEquals(\n  value: string | number,\n  lte: string | number\n): boolean {\n  return numberEquals(value, lte) || lessThan(value, lte);\n}\n","import { bindNot } from 'vest-utils';\n\nimport { greaterThanOrEquals as gte } from 'greaterThanOrEquals';\nimport { lessThanOrEquals as lte } from 'lessThanOrEquals';\n\nexport function isBetween(\n  value: number | string,\n  min: number | string,\n  max: number | string\n): boolean {\n  return gte(value, min) && lte(value, max);\n}\n\nexport const isNotBetween = bindNot(isBetween);\n","import { isStringValue, bindNot, isNullish, BlankValue } from 'vest-utils';\n\nexport function isBlank(value: unknown): value is BlankValue {\n  return isNullish(value) || (isStringValue(value) && !value.trim());\n}\n\nexport const isNotBlank = bindNot(isBlank);\n","import { bindNot, isBoolean } from 'vest-utils';\n\nexport const isNotBoolean = bindNot(isBoolean);\nexport { isBoolean };\n","import { isNumeric } from 'vest-utils';\n\nimport type { RuleValue } from 'runtimeRules';\n\n/**\n * Validates that a given value is an even number\n */\nexport const isEven = (value: RuleValue): boolean => {\n  if (isNumeric(value)) {\n    return value % 2 === 0;\n  }\n  return false;\n};\n","import { bindNot } from 'vest-utils';\n\nexport function isKeyOf(key: string | symbol | number, obj: any): boolean {\n  return key in obj;\n}\n\nexport const isNotKeyOf = bindNot(isKeyOf);\n","import { bindNot } from 'vest-utils';\n\nexport function isNaN(value: unknown): boolean {\n  return Number.isNaN(value);\n}\n\nexport const isNotNaN = bindNot(isNaN);\n","import { lessThan } from 'lessThan';\n\nexport function isNegative(value: number | string): boolean {\n  return lessThan(value, 0);\n}\n","import { bindNot } from 'vest-utils';\n\nexport function isNumber(value: unknown): value is number {\n  return Boolean(typeof value === 'number');\n}\n\nexport const isNotNumber = bindNot(isNumber);\n","import { isNumeric } from 'vest-utils';\n\nimport type { RuleValue } from 'runtimeRules';\n/**\n * Validates that a given value is an odd number\n */\nexport const isOdd = (value: RuleValue): boolean => {\n  if (isNumeric(value)) {\n    return value % 2 !== 0;\n  }\n\n  return false;\n};\n","import { isStringValue as isString, bindNot } from 'vest-utils';\n\nexport const isNotString = bindNot(isString);\nexport { isString };\n","import { bindNot } from 'vest-utils';\n\nexport function isTruthy(value: unknown): boolean {\n  return !!value;\n}\n\nexport const isFalsy = bindNot(isTruthy);\n","import { bindNot, isNullish } from 'vest-utils';\n\nexport function isValueOf(value: any, objectToCheck: any): boolean {\n  if (isNullish(objectToCheck)) {\n    return false;\n  }\n\n  for (const key in objectToCheck) {\n    if (objectToCheck[key] === value) {\n      return true;\n    }\n  }\n\n  return false;\n}\nexport const isNotValueOf = bindNot(isValueOf);\n","import { greaterThanOrEquals } from 'greaterThanOrEquals';\n\nexport function longerThanOrEquals(\n  value: string | unknown[],\n  arg1: string | number\n): boolean {\n  return greaterThanOrEquals(value.length, arg1);\n}\n","import { isStringValue as isString, bindNot } from 'vest-utils';\n\nexport function matches(value: string, regex: RegExp | string): boolean {\n  if (regex instanceof RegExp) {\n    return regex.test(value);\n  } else if (isString(regex)) {\n    return new RegExp(regex).test(value);\n  }\n  return false;\n}\n\nexport const notMatches = bindNot(matches);\n","import type { RuleReturn } from 'ruleReturn';\n\nexport function condition(\n  value: any,\n  callback: (value: any) => RuleReturn\n): RuleReturn {\n  try {\n    return callback(value);\n  } catch {\n    return false;\n  }\n}\n","import { lessThan } from 'lessThan';\n\nexport function shorterThan(\n  value: string | unknown[],\n  arg1: string | number\n): boolean {\n  return lessThan(value.length, arg1);\n}\n","import { lessThanOrEquals } from 'lessThanOrEquals';\n\nexport function shorterThanOrEquals(\n  value: string | unknown[],\n  arg1: string | number\n): boolean {\n  return lessThanOrEquals(value.length, arg1);\n}\n","import { isStringValue as isString, bindNot } from 'vest-utils';\n\nexport function startsWith(value: string, arg1: string): boolean {\n  return isString(value) && isString(arg1) && value.startsWith(arg1);\n}\n\nexport const doesNotStartWith = bindNot(startsWith);\n","import type { DropFirst } from 'vest-utils';\n\nimport type { RuleReturn } from 'ruleReturn';\nimport rules from 'rules';\n\nexport type Args = any[];\n\nexport type RuleValue = any;\n\nexport type RuleBase = (value: RuleValue, ...args: Args) => RuleReturn;\n\nexport type Rule = Record<string, RuleBase>;\n\ntype BaseRules = typeof baseRules;\ntype KBaseRules = keyof BaseRules;\n\nconst baseRules = rules();\n\nfunction getRule(ruleName: string): RuleBase {\n  return baseRules[ruleName as KBaseRules];\n}\n\nexport { baseRules, getRule };\n\ntype Rules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<\n  Rules<E> & E\n> &\n  Record<string, (...args: Args) => Rules<E> & E> & {\n    [P in KBaseRules]: (\n      ...args: DropFirst<Parameters<BaseRules[P]>> | Args\n    ) => Rules<E> & E;\n  };\n\n/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */\ndeclare global {\n  namespace n4s {\n    interface IRules<E> extends Rules<E> {}\n  }\n}\n","import {\n  greaterThan,\n  isNull,\n  isNotNull,\n  isNullish,\n  isNotNullish,\n  isNumeric,\n  isNotNumeric,\n  isUndefined,\n  isNotUndefined,\n  lengthEquals,\n  lengthNotEquals,\n  longerThan,\n  numberEquals,\n  numberNotEquals,\n  isArray,\n  isNotArray,\n  isPositive,\n  isEmpty,\n  isNotEmpty,\n} from 'vest-utils';\n\nimport { endsWith, doesNotEndWith } from 'endsWith';\nimport { equals, notEquals } from 'equals';\nimport { greaterThanOrEquals } from 'greaterThanOrEquals';\nimport { inside, notInside } from 'inside';\nimport { isBetween, isNotBetween } from 'isBetween';\nimport { isBlank, isNotBlank } from 'isBlank';\nimport { isBoolean, isNotBoolean } from 'isBoolean';\nimport { isEven } from 'isEven';\nimport { isKeyOf, isNotKeyOf } from 'isKeyOf';\nimport { isNaN, isNotNaN } from 'isNaN';\nimport { isNegative } from 'isNegative';\nimport { isNumber, isNotNumber } from 'isNumber';\nimport { isOdd } from 'isOdd';\nimport { isString, isNotString } from 'isString';\nimport { isTruthy, isFalsy } from 'isTruthy';\nimport { isValueOf, isNotValueOf } from 'isValueOf';\nimport { lessThan } from 'lessThan';\nimport { lessThanOrEquals } from 'lessThanOrEquals';\nimport { longerThanOrEquals } from 'longerThanOrEquals';\nimport { matches, notMatches } from 'matches';\nimport { condition } from 'ruleCondition';\nimport { shorterThan } from 'shorterThan';\nimport { shorterThanOrEquals } from 'shorterThanOrEquals';\nimport { startsWith, doesNotStartWith } from 'startsWith';\n\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, max-lines-per-function\nexport default function rules() {\n  return {\n    condition,\n    doesNotEndWith,\n    doesNotStartWith,\n    endsWith,\n    equals,\n    greaterThan,\n    greaterThanOrEquals,\n    gt: greaterThan,\n    gte: greaterThanOrEquals,\n    inside,\n    isArray,\n    isBetween,\n    isBlank,\n    isBoolean,\n    isEmpty,\n    isEven,\n    isFalsy,\n    isKeyOf,\n    isNaN,\n    isNegative,\n    isNotArray,\n    isNotBetween,\n    isNotBlank,\n    isNotBoolean,\n    isNotEmpty,\n    isNotKeyOf,\n    isNotNaN,\n    isNotNull,\n    isNotNullish,\n    isNotNumber,\n    isNotNumeric,\n    isNotString,\n    isNotUndefined,\n    isNotValueOf,\n    isNull,\n    isNullish,\n    isNumber,\n    isNumeric,\n    isOdd,\n    isPositive,\n    isString,\n    isTruthy,\n    isUndefined,\n    isValueOf,\n    lengthEquals,\n    lengthNotEquals,\n    lessThan,\n    lessThanOrEquals,\n    longerThan,\n    longerThanOrEquals,\n    lt: lessThan,\n    lte: lessThanOrEquals,\n    matches,\n    notEquals,\n    notInside,\n    notMatches,\n    numberEquals,\n    numberNotEquals,\n    shorterThan,\n    shorterThanOrEquals,\n    startsWith,\n  };\n}\n","import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import { invariant, optionalFunctionValue, isBoolean } from 'vest-utils';\n\nimport ruleReturn, { RuleReturn, RuleDetailedResult } from 'ruleReturn';\nimport type { RuleValue, Args } from 'runtimeRules';\n\n/**\n * Transform the result of a rule into a standard format\n */\nexport function transformResult(\n  result: RuleReturn,\n  ruleName: string,\n  value: RuleValue,\n  ...args: Args\n): RuleDetailedResult {\n  validateResult(result);\n\n  // if result is boolean\n  if (isBoolean(result)) {\n    return ruleReturn(result);\n  }\n  return ruleReturn(\n    result.pass,\n    optionalFunctionValue(result.message, ruleName, value, ...args)\n  );\n}\n\nfunction validateResult(result: RuleReturn): void {\n  // if result is boolean, or if result.pass is boolean\n  invariant(\n    isBoolean(result) || (result && isBoolean(result.pass)),\n    'Incorrect return value for rule: ' + JSON.stringify(result)\n  );\n}\n","import { invariant, StringObject, isNullish, Maybe } from 'vest-utils';\n\nimport { ctx } from 'enforceContext';\nimport { getRule, RuleValue, Args, RuleBase } from 'runtimeRules';\nimport { transformResult } from 'transformResult';\n\ntype IRules = n4s.IRules<Record<string, any>>;\ntype TModifiers = {\n  message: (input: string) => EnforceEagerReturn;\n};\n\ntype EnforceEagerReturn = IRules & TModifiers;\n\n// eslint-disable-next-line max-lines-per-function\nexport default function enforceEager(value: RuleValue): EnforceEagerReturn {\n  const target = {\n    message,\n  } as EnforceEagerReturn;\n  let customMessage: Maybe<string> = undefined;\n\n  // We create a proxy intercepting access to the target object (which is empty).\n  const proxy: EnforceEagerReturn = new Proxy(target, {\n    get: (_, key: string) => {\n      // On property access, we identify if it is a rule or not.\n      const rule = getRule(key);\n\n      // If it is a rule, we wrap it with `genRuleCall` that adds the base enforce behavior\n      if (rule) {\n        return genRuleCall(proxy, rule, key);\n      }\n      return target[key];\n    },\n  });\n\n  return proxy;\n\n  // This function is used to wrap a rule with the base enforce behavior\n  // It takes the target object, the rule function, and the rule name\n  // It then returns the rule, in a manner that can be used by enforce\n  function genRuleCall(\n    target: EnforceEagerReturn,\n    rule: RuleBase,\n    ruleName: string\n  ) {\n    return function ruleCall(...args: Args) {\n      // Order of operation:\n      // 1. Create a context with the value being enforced\n      // 2. Call the rule within the context, and pass over the arguments passed to it\n      // 3. Transform the result to the correct output format\n      const transformedResult = ctx.run({ value }, () => {\n        return transformResult(rule(value, ...args), ruleName, value, ...args);\n      });\n\n      function enforceMessage() {\n        if (!isNullish(customMessage)) return StringObject(customMessage);\n        if (isNullish(transformedResult.message)) {\n          return `enforce/${ruleName} failed with ${JSON.stringify(value)}`;\n        }\n        return StringObject(transformedResult.message);\n      }\n\n      // On rule failure (the result is false), we either throw an error\n      // or throw a string value if the rule has a message defined in it.\n      invariant(transformedResult.pass, enforceMessage());\n\n      return target;\n    };\n  }\n\n  function message(input: string): EnforceEagerReturn {\n    customMessage = input;\n    return proxy;\n  }\n}\n\nexport type EnforceEager = (value: RuleValue) => EnforceEagerReturn;\n","import { assign } from 'vest-utils';\n\nimport { ctx, EnforceContext } from 'enforceContext';\nimport enforceEager, { EnforceEager } from 'enforceEager';\nimport genEnforceLazy, { LazyRules } from 'genEnforceLazy';\nimport { Rule, baseRules, getRule } from 'runtimeRules';\n/**\n * Enforce is quite complicated, I want to explain it in detail.\n * It is dynamic in nature, so a lot of proxy objects are involved.\n *\n * Enforce has two main interfaces\n * 1. eager\n * 2. lazy\n *\n * The eager interface is the most commonly used, and the easier to understand.\n * It throws an error when a rule is not satisfied.\n * The eager interface is declared in enforceEager.ts and it is quite simple to understand.\n * enforce is called with a value, and the return value is a proxy object that points back to all the rules.\n * When a rule is called, the value is mapped as its first argument, and if the rule passes, the same\n * proxy object is returned. Otherwise, an error is thrown.\n *\n * The lazy interface works quite differently. It is declared in genEnforceLazy.ts.\n * Rather than calling enforce directly, the lazy interface has all the rules as \"methods\" (only by proxy).\n * Calling the first function in the chain will initialize an array of calls. It stores the different rule calls\n * and the parameters passed to them. None of the rules are called yet.\n * The rules are only invoked in sequence once either of these chained functions are called:\n * 1. test(value)\n * 2. run(value)\n *\n * Calling run or test will call all the rules in sequence, with the difference that test will only return a boolean value,\n * while run will return an object with the validation result and an optional message created by the rule.\n */\n\nfunction genEnforce(): Enforce {\n  const target = {\n    context: () => ctx.useX(),\n    extend: (customRules: Rule) => {\n      assign(baseRules, customRules);\n    },\n  } as Enforce;\n\n  return new Proxy(assign(enforceEager, target) as Enforce, {\n    get: (target: Enforce, key: string) => {\n      if (key in target) {\n        return target[key];\n      }\n\n      if (!getRule(key)) {\n        return;\n      }\n\n      // Only on the first rule access - start the chain of calls\n      return genEnforceLazy(key);\n    },\n  });\n}\n\nexport const enforce = genEnforce();\n\ntype Enforce = EnforceMethods & LazyRules & EnforceEager;\n\ntype EnforceMethods = {\n  context: () => EnforceContext;\n  extend: (customRules: Rule) => void;\n};\n","import {\n  mapFirst,\n  optionalFunctionValue,\n  CB,\n  Stringable,\n  Maybe,\n  DynamicValue,\n} from 'vest-utils';\n\nimport { ctx } from 'enforceContext';\nimport ruleReturn, { defaultToPassing, RuleDetailedResult } from 'ruleReturn';\nimport { RuleValue, Args, getRule } from 'runtimeRules';\nimport { transformResult } from 'transformResult';\n\n// eslint-disable-next-line max-lines-per-function\nexport default function genEnforceLazy(key: string) {\n  const registeredRules: RegisteredRules = [];\n  let lazyMessage: Maybe<LazyMessage>;\n\n  return addLazyRule(key);\n\n  // eslint-disable-next-line max-lines-per-function\n  function addLazyRule(ruleName: string) {\n    // eslint-disable-next-line max-lines-per-function\n    return (...args: Args): Lazy => {\n      const rule = getRule(ruleName);\n\n      registeredRules.push((value: RuleValue) =>\n        transformResult(rule(value, ...args), ruleName, value, ...args)\n      );\n\n      let proxy = {\n        run: (value: RuleValue): RuleDetailedResult => {\n          return defaultToPassing(\n            mapFirst(registeredRules, (rule, breakout) => {\n              const res = ctx.run({ value }, () => rule(value));\n\n              breakout(\n                !res.pass,\n                ruleReturn(\n                  !!res.pass,\n                  optionalFunctionValue(lazyMessage, value, res.message) ??\n                    res.message\n                )\n              );\n            })\n          );\n        },\n        test: (value: RuleValue): boolean => proxy.run(value).pass,\n        message: (message: Stringable): Lazy => {\n          if (message) {\n            lazyMessage = message;\n          }\n\n          return proxy;\n        },\n      } as Lazy;\n\n      // reassigning the proxy here is not pretty\n      // but it's a cleaner way of getting `run` and `test` for free\n      proxy = new Proxy(proxy, {\n        get: (target, key: string) => {\n          if (getRule(key)) {\n            return addLazyRule(key);\n          }\n\n          return target[key]; // already has `run` and `test` on it\n        },\n      });\n      return proxy;\n    };\n  }\n}\n\nexport type LazyRules = n4s.IRules<LazyRuleMethods>;\n\nexport type Lazy = LazyRules &\n  LazyRuleMethods &\n  // This is a \"catch all\" hack to make TS happy while not\n  // losing type hints\n  Record<string, CB>;\n\ntype LazyRuleMethods = LazyRuleRunners & {\n  message: (message: LazyMessage) => Lazy;\n};\n\nexport type LazyRuleRunners = {\n  test: (value: unknown) => boolean;\n  run: (value: unknown) => RuleDetailedResult;\n};\n\nexport type ComposeResult = LazyRuleRunners & ((value: any) => void);\n\ntype RegisteredRules = Array<(value: RuleValue) => RuleDetailedResult>;\ntype LazyMessage = DynamicValue<\n  string,\n  [value: unknown, originalMessage?: Stringable]\n>;\n"],"names":["ctx","createCascade","ctxRef","parentContext","base","value","meta","set","assign","parent","stripContext","emptyParent","endsWith","arg1","isString","isStringValue","doesNotEndWith","bindNot","equals","notEquals","greaterThanOrEquals","gte","numberEquals","greaterThan","inside","isArray","indexOf","notInside","lessThan","lt","isNumeric","Number","lessThanOrEquals","lte","isBetween","min","max","isNotBetween","isBlank","isNullish","trim","isNotBlank","isNotBoolean","isBoolean","isEven","isKeyOf","key","obj","isNotKeyOf","isNaN","isNotNaN","isNegative","isNumber","Boolean","isNotNumber","isOdd","isNotString","isTruthy","isFalsy","isValueOf","objectToCheck","isNotValueOf","longerThanOrEquals","length","matches","regex","RegExp","test","notMatches","condition","callback","_a","shorterThan","shorterThanOrEquals","startsWith","doesNotStartWith","baseRules","gt","isEmpty","isNotArray","isNotEmpty","isNotNull","isNotNullish","isNotNumeric","isNotUndefined","isNull","isPositive","isUndefined","lengthEquals","lengthNotEquals","longerThan","numberNotEquals","getRule","ruleName","ruleReturn","pass","message","output","defaultToPassing","defaultTo","transformResult","result","args","invariant","JSON","stringify","validateResult","optionalFunctionValue","enforceEager","target","input","customMessage","proxy","Proxy","get","_","rule","transformedResult","run","enforceMessage","StringObject","genRuleCall","enforce","context","useX","extend","customRules","registeredRules","lazyMessage","addLazyRule","push","mapFirst","breakout","res","genEnforceLazy","genEnforce"],"mappings":"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"}

package/dist/cjs/schema.development.js

@@ -81,3 +81,4 @@ function partial(shapeObject) {
 n4s.enforce.extend({ isArrayOf, loose, optional, shape });
 
 exports.partial = partial;
+//# sourceMappingURL=schema.development.js.map

package/dist/cjs/schema.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.development.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/plugins/schema/isArrayOf.ts","../../src/plugins/schema/loose.ts","../../src/plugins/schema/optional.ts","../../src/plugins/schema/shape.ts","../../src/plugins/schema/partial.ts","../../src/exports/schema.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { ctx } from 'n4s';\nimport { mapFirst } from 'vest-utils';\n\nimport type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function isArrayOf(\n  inputArray: any[],\n  currentRule: LazyRuleRunners\n): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(inputArray, (currentValue, breakout, index) => {\n      const res = ctx.run(\n        { value: currentValue, set: true, meta: { index } },\n        () => runLazyRule(currentRule, currentValue)\n      );\n\n      breakout(!res.pass, res);\n    })\n  );\n}\n","import { ctx } from 'n4s';\n\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\nimport type { ShapeObject } from 'schemaTypes';\n\nexport function loose(\n  inputObject: Record<string, any>,\n  shapeObject: ShapeObject\n): RuleDetailedResult {\n  for (const key in shapeObject) {\n    const currentValue = inputObject[key];\n    const currentRule = shapeObject[key];\n\n    const res = ctx.run({ value: currentValue, set: true, meta: { key } }, () =>\n      runLazyRule(currentRule, currentValue)\n    );\n\n    if (!res.pass) {\n      return res;\n    }\n  }\n\n  return ruleReturn.passing();\n}\n","import { isNullish } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function optional(value: any, ruleChain: Lazy): RuleDetailedResult {\n  if (isNullish(value)) {\n    return ruleReturn.passing();\n  }\n  return runLazyRule(ruleChain, value);\n}\n","import { hasOwnProperty } from 'vest-utils';\n\nimport { loose } from 'loose';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport type { ShapeObject } from 'schemaTypes';\n\nexport function shape(\n  inputObject: Record<string, any>,\n  shapeObject: ShapeObject\n): RuleDetailedResult {\n  const baseRes = loose(inputObject, shapeObject);\n  if (!baseRes.pass) {\n    return baseRes;\n  }\n  for (const key in inputObject) {\n    if (!hasOwnProperty(shapeObject, key)) {\n      return ruleReturn.failing();\n    }\n  }\n\n  return ruleReturn.passing();\n}\n","import { enforce } from 'n4s';\n\n// Help needed improving the typings of this file.\n// Ideally, we'd be able to extend ShapeObject, but that's not possible.\nexport function partial<T extends Record<any, any>>(shapeObject: T): T {\n  const output = {} as T;\n  for (const key in shapeObject) {\n    output[key] = enforce.optional(shapeObject[key]) as T[Extract<\n      keyof T,\n      string\n    >];\n  }\n  return output;\n}\n","import { enforce } from 'n4s';\n\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\nimport { isArrayOf } from 'isArrayOf';\nimport { loose } from 'loose';\nimport { optional } from 'optional';\nimport { shape } from 'shape';\n\nexport { partial } from 'partial';\n\nenforce.extend({ isArrayOf, loose, optional, shape });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isArrayOf: EnforceCustomMatcher<typeof isArrayOf, R>;\n      loose: EnforceCustomMatcher<typeof loose, R>;\n      shape: EnforceCustomMatcher<typeof shape, R>;\n      optional: EnforceCustomMatcher<typeof optional, R>;\n    }\n  }\n}\n"],"names":["defaultTo","ruleReturn.failing","ruleReturn.defaultToPassing","mapFirst","ctx","ruleReturn.passing","isNullish","hasOwnProperty","enforce"],"mappings":"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"}

package/dist/cjs/schema.production.js

@@ -1 +1,2 @@
 "use strict";var n=require("n4s"),t=require("vest-utils");function r(n,t){const r={pass:n};return t&&(r.message=t),r}function e(){return r(!1)}function s(){return r(!0)}function u(n,t){try{return n.run(t)}catch(n){return e()}}function o(t,r){for(const e in r){const s=t[e],o=r[e],i=n.ctx.run({value:s,set:!0,meta:{key:e}},(()=>u(o,s)));if(!i.pass)return i}return s()}n.enforce.extend({isArrayOf:function(r,e){return o=t.mapFirst(r,((t,r,s)=>{const o=n.ctx.run({value:t,set:!0,meta:{index:s}},(()=>u(e,t)));r(!o.pass,o)})),t.defaultTo(o,s());var o},loose:o,optional:function(n,r){return t.isNullish(n)?s():u(r,n)},shape:function(n,r){const u=o(n,r);if(!u.pass)return u;for(const s in n)if(!t.hasOwnProperty(r,s))return e();return s()}}),exports.partial=function(t){const r={};for(const e in t)r[e]=n.enforce.optional(t[e]);return r};
+//# sourceMappingURL=schema.production.js.map

package/dist/cjs/schema.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.production.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/plugins/schema/loose.ts","../../src/exports/schema.ts","../../src/plugins/schema/isArrayOf.ts","../../src/plugins/schema/optional.ts","../../src/plugins/schema/shape.ts","../../src/plugins/schema/partial.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { ctx } from 'n4s';\n\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\nimport type { ShapeObject } from 'schemaTypes';\n\nexport function loose(\n  inputObject: Record<string, any>,\n  shapeObject: ShapeObject\n): RuleDetailedResult {\n  for (const key in shapeObject) {\n    const currentValue = inputObject[key];\n    const currentRule = shapeObject[key];\n\n    const res = ctx.run({ value: currentValue, set: true, meta: { key } }, () =>\n      runLazyRule(currentRule, currentValue)\n    );\n\n    if (!res.pass) {\n      return res;\n    }\n  }\n\n  return ruleReturn.passing();\n}\n","import { enforce } from 'n4s';\n\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\nimport { isArrayOf } from 'isArrayOf';\nimport { loose } from 'loose';\nimport { optional } from 'optional';\nimport { shape } from 'shape';\n\nexport { partial } from 'partial';\n\nenforce.extend({ isArrayOf, loose, optional, shape });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isArrayOf: EnforceCustomMatcher<typeof isArrayOf, R>;\n      loose: EnforceCustomMatcher<typeof loose, R>;\n      shape: EnforceCustomMatcher<typeof shape, R>;\n      optional: EnforceCustomMatcher<typeof optional, R>;\n    }\n  }\n}\n","import { ctx } from 'n4s';\nimport { mapFirst } from 'vest-utils';\n\nimport type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function isArrayOf(\n  inputArray: any[],\n  currentRule: LazyRuleRunners\n): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(inputArray, (currentValue, breakout, index) => {\n      const res = ctx.run(\n        { value: currentValue, set: true, meta: { index } },\n        () => runLazyRule(currentRule, currentValue)\n      );\n\n      breakout(!res.pass, res);\n    })\n  );\n}\n","import { isNullish } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function optional(value: any, ruleChain: Lazy): RuleDetailedResult {\n  if (isNullish(value)) {\n    return ruleReturn.passing();\n  }\n  return runLazyRule(ruleChain, value);\n}\n","import { hasOwnProperty } from 'vest-utils';\n\nimport { loose } from 'loose';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport type { ShapeObject } from 'schemaTypes';\n\nexport function shape(\n  inputObject: Record<string, any>,\n  shapeObject: ShapeObject\n): RuleDetailedResult {\n  const baseRes = loose(inputObject, shapeObject);\n  if (!baseRes.pass) {\n    return baseRes;\n  }\n  for (const key in inputObject) {\n    if (!hasOwnProperty(shapeObject, key)) {\n      return ruleReturn.failing();\n    }\n  }\n\n  return ruleReturn.passing();\n}\n","import { enforce } from 'n4s';\n\n// Help needed improving the typings of this file.\n// Ideally, we'd be able to extend ShapeObject, but that's not possible.\nexport function partial<T extends Record<any, any>>(shapeObject: T): T {\n  const output = {} as T;\n  for (const key in shapeObject) {\n    output[key] = enforce.optional(shapeObject[key]) as T[Extract<\n      keyof T,\n      string\n    >];\n  }\n  return output;\n}\n"],"names":["ruleReturn","pass","message","output","failing","passing","runLazyRule","lazyRule","currentValue","run","_a","ruleReturn.failing","loose","inputObject","shapeObject","key","currentRule","res","ctx","value","set","meta","ruleReturn.passing","enforce","extend","isArrayOf","inputArray","callback","mapFirst","breakout","index","defaultTo","optional","ruleChain","isNullish","shape","baseRes","hasOwnProperty"],"mappings":"0DAGc,SAAUA,EACtBC,EACAC,GAEA,MAAMC,EAA6B,CAAEF,QAMrC,OAJIC,IACFC,EAAOD,QAAUA,GAGZC,CACT,UAEgBC,IACd,OAAOJ,GAAW,EACpB,UAEgBK,IACd,OAAOL,GAAW,EACpB,CClBc,SAAUM,EACtBC,EACAC,GAEA,IACE,OAAOD,EAASE,IAAID,EAGrB,CAFC,MAAME,GACN,OAAOC,GACR,CACH,CCNgB,SAAAC,EACdC,EACAC,GAEA,IAAK,MAAMC,KAAOD,EAAa,CAC7B,MAAMN,EAAeK,EAAYE,GAC3BC,EAAcF,EAAYC,GAE1BE,EAAMC,EAAAA,IAAIT,IAAI,CAAEU,MAAOX,EAAcY,KAAK,EAAMC,KAAM,CAAEN,SAAS,IACrET,EAAYU,EAAaR,KAG3B,IAAKS,EAAIhB,KACP,OAAOgB,CAEV,CAED,OAAOK,GACT,CCdAC,EAAAA,QAAQC,OAAO,CAAEC,UCHD,SACdC,EACAV,GAEA,OJmBAW,EIlBEC,EAAAA,SAASF,GAAY,CAAClB,EAAcqB,EAAUC,KAC5C,MAAMb,EAAMC,EAAAA,IAAIT,IACd,CAAEU,MAAOX,EAAcY,KAAK,EAAMC,KAAM,CAAES,WAC1C,IAAMxB,EAAYU,EAAaR,KAGjCqB,GAAUZ,EAAIhB,KAAMgB,EAAI,IJcrBc,YAAUJ,EAAUtB,KAHvB,IACJsB,CITF,EDX4Bf,QAAOoB,SEJnB,SAASb,EAAYc,GACnC,OAAIC,EAAAA,UAAUf,GACLG,IAEFhB,EAAY2B,EAAWd,EAChC,EFD6CgB,MGJ7B,SACdtB,EACAC,GAEA,MAAMsB,EAAUxB,EAAMC,EAAaC,GACnC,IAAKsB,EAAQnC,KACX,OAAOmC,EAET,IAAK,MAAMrB,KAAOF,EAChB,IAAKwB,EAAcA,eAACvB,EAAaC,GAC/B,OAAOJ,IAIX,OAAOW,GACT,oBClBM,SAA8CR,GAClD,MAAMX,EAAS,CAAA,EACf,IAAK,MAAMY,KAAOD,EAChBX,EAAOY,GAAOQ,EAAOA,QAACS,SAASlB,EAAYC,IAK7C,OAAOZ,CACT"}

package/dist/es/compose.development.js

@@ -52,3 +52,4 @@ function compose(...composites) {
 }
 
 export { compose as default };
+//# sourceMappingURL=compose.development.js.map

package/dist/es/compose.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.development.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/exports/compose.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { ctx } from 'n4s';\nimport { invariant, StringObject, assign, mapFirst } from 'vest-utils';\n\nimport type { ComposeResult, LazyRuleRunners } from 'genEnforceLazy';\nimport { defaultToPassing, RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\n/* eslint-disable max-lines-per-function */\n\nexport default function compose(\n  ...composites: LazyRuleRunners[]\n): ComposeResult {\n  return assign(\n    (value: any) => {\n      const res = run(value);\n\n      invariant(res.pass, StringObject(res.message));\n    },\n    {\n      run,\n      test: (value: any) => run(value).pass,\n    }\n  );\n\n  function run(value: any): RuleDetailedResult {\n    return ctx.run({ value }, () => {\n      return defaultToPassing(\n        mapFirst(\n          composites,\n          (\n            composite: LazyRuleRunners,\n            breakout: (conditional: boolean, res: RuleDetailedResult) => void\n          ) => {\n            /* HACK: Just a small white lie. ~~HELP WANTED~~.\n               The ideal is that instead of `LazyRuleRunners` We would simply use `Lazy` to begin with.\n               The problem is that lazy rules can't really be passed to this function due to some generic hell\n               so we're limiting it to a small set of functions.\n            */\n\n            const res = runLazyRule(composite, value);\n\n            breakout(!res.pass, res);\n          }\n        )\n      );\n    });\n  }\n}\n"],"names":["ruleReturn.failing"],"mappings":";;;AAGc,SAAU,UAAU,CAChC,IAAa,EACb,OAAgB,EAAA;AAEhB,IAAA,MAAM,MAAM,GAAuB,EAAE,IAAI,EAAE,CAAC;AAE5C,IAAA,IAAI,OAAO,EAAE;AACX,QAAA,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC;AAC1B,KAAA;AAED,IAAA,OAAO,MAAM,CAAC;AAChB,CAAC;SAEe,OAAO,GAAA;AACrB,IAAA,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;AAC3B,CAAC;SAEe,OAAO,GAAA;AACrB,IAAA,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAQK,SAAU,gBAAgB,CAC9B,QAAgD,EAAA;AAEhD,IAAA,OAAO,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;AACxC;;AC9Bc,SAAU,WAAW,CACjC,QAAyB,EACzB,YAAiB,EAAA;IAEjB,IAAI;AACF,QAAA,OAAO,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;AACnC,KAAA;IAAC,OAAM,EAAA,EAAA;AACN,QAAA,OAAOA,OAAkB,EAAE,CAAC;AAC7B,KAAA;AACH;;ACNA;AAEc,SAAU,OAAO,CAC7B,GAAG,UAA6B,EAAA;AAEhC,IAAA,OAAO,MAAM,CACX,CAAC,KAAU,KAAI;AACb,QAAA,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC;AAEvB,QAAA,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AACjD,KAAC,EACD;QACE,GAAG;QACH,IAAI,EAAE,CAAC,KAAU,KAAK,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI;AACtC,KAAA,CACF,CAAC;IAEF,SAAS,GAAG,CAAC,KAAU,EAAA;QACrB,OAAO,GAAG,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,MAAK;YAC7B,OAAO,gBAAgB,CACrB,QAAQ,CACN,UAAU,EACV,CACE,SAA0B,EAC1B,QAAiE,KAC/D;AACF;;;;AAIE;gBAEF,MAAM,GAAG,GAAG,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;gBAE1C,QAAQ,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;aAC1B,CACF,CACF,CAAC;AACJ,SAAC,CAAC,CAAC;KACJ;AACH;;;;"}

package/dist/es/compose.production.js

@@ -1 +1,2 @@
 import{ctx as t}from"n4s";import{defaultTo as n,assign as r,invariant as s,StringObject as u,mapFirst as e}from"vest-utils";function o(t,n){const r={pass:t};return n&&(r.message=n),r}function a(t){return n(t,o(!0))}function c(t,n){try{return t.run(n)}catch(t){return o(!1)}}function f(...n){return r((t=>{const n=o(t);s(n.pass,u(n.message))}),{run:o,test:t=>o(t).pass});function o(r){return t.run({value:r},(()=>a(e(n,((t,n)=>{const s=c(t,r);n(!s.pass,s)})))))}}export{f as default};
+//# sourceMappingURL=compose.production.js.map

package/dist/es/compose.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.production.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/exports/compose.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { ctx } from 'n4s';\nimport { invariant, StringObject, assign, mapFirst } from 'vest-utils';\n\nimport type { ComposeResult, LazyRuleRunners } from 'genEnforceLazy';\nimport { defaultToPassing, RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\n/* eslint-disable max-lines-per-function */\n\nexport default function compose(\n  ...composites: LazyRuleRunners[]\n): ComposeResult {\n  return assign(\n    (value: any) => {\n      const res = run(value);\n\n      invariant(res.pass, StringObject(res.message));\n    },\n    {\n      run,\n      test: (value: any) => run(value).pass,\n    }\n  );\n\n  function run(value: any): RuleDetailedResult {\n    return ctx.run({ value }, () => {\n      return defaultToPassing(\n        mapFirst(\n          composites,\n          (\n            composite: LazyRuleRunners,\n            breakout: (conditional: boolean, res: RuleDetailedResult) => void\n          ) => {\n            /* HACK: Just a small white lie. ~~HELP WANTED~~.\n               The ideal is that instead of `LazyRuleRunners` We would simply use `Lazy` to begin with.\n               The problem is that lazy rules can't really be passed to this function due to some generic hell\n               so we're limiting it to a small set of functions.\n            */\n\n            const res = runLazyRule(composite, value);\n\n            breakout(!res.pass, res);\n          }\n        )\n      );\n    });\n  }\n}\n"],"names":["ruleReturn","pass","message","output","defaultToPassing","callback","defaultTo","runLazyRule","lazyRule","currentValue","run","_a","compose","composites","assign","value","res","invariant","StringObject","test","ctx","mapFirst","composite","breakout"],"mappings":"4HAGc,SAAUA,EACtBC,EACAC,GAEA,MAAMC,EAA6B,CAAEF,QAMrC,OAJIC,IACFC,EAAOD,QAAUA,GAGZC,CACT,CAgBM,SAAUC,EACdC,GAEA,OAAOC,EAAUD,EAZVL,GAAW,GAapB,CC9Bc,SAAUO,EACtBC,EACAC,GAEA,IACE,OAAOD,EAASE,IAAID,EAGrB,CAFC,MAAME,GACN,ODMKX,GAAW,ECLjB,CACH,CCJc,SAAUY,KACnBC,GAEH,OAAOC,GACJC,IACC,MAAMC,EAAMN,EAAIK,GAEhBE,EAAUD,EAAIf,KAAMiB,EAAaF,EAAId,SAAS,GAEhD,CACEQ,MACAS,KAAOJ,GAAeL,EAAIK,GAAOd,OAIrC,SAASS,EAAIK,GACX,OAAOK,EAAIV,IAAI,CAAEK,UAAS,IACjBX,EACLiB,EACER,GACA,CACES,EACAC,KAQA,MAAMP,EAAMT,EAAYe,EAAWP,GAEnCQ,GAAUP,EAAIf,KAAMe,EAAI,MAKjC,CACH"}

package/dist/es/compounds.development.js

@@ -72,3 +72,4 @@ function oneOf(value, ...rules) {
 }
 
 enforce.extend({ allOf, anyOf, noneOf, oneOf });
+//# sourceMappingURL=compounds.development.js.map

package/dist/es/compounds.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compounds.development.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/plugins/compounds/allOf.ts","../../src/plugins/compounds/anyOf.ts","../../src/plugins/compounds/noneOf.ts","../../src/rules/equals.ts","../../src/plugins/compounds/oneOf.ts","../../src/exports/compounds.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport * as ruleReturn from 'ruleReturn';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function allOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n      breakout(!res.pass, res);\n    })\n  );\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport * as ruleReturn from 'ruleReturn';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function anyOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToFailing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n      breakout(res.pass, res);\n    })\n  );\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function noneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n\n      breakout(res.pass, ruleReturn.failing());\n    })\n  );\n}\n","import { bindNot } from 'vest-utils';\n\nexport function equals(value: unknown, arg1: unknown): boolean {\n  return value === arg1;\n}\n\nexport const notEquals = bindNot(equals);\n","import { greaterThan } from 'vest-utils';\n\nimport { equals } from 'equals';\nimport type { Lazy } from 'genEnforceLazy';\nimport ruleReturn, { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nconst REQUIRED_COUNT = 1;\n\nexport function oneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  let passingCount = 0;\n  rules.some(rule => {\n    const res = runLazyRule(rule, value);\n\n    if (res.pass) {\n      passingCount++;\n    }\n\n    if (greaterThan(passingCount, REQUIRED_COUNT)) {\n      return false;\n    }\n  });\n\n  return ruleReturn(equals(passingCount, REQUIRED_COUNT));\n}\n","import { enforce } from 'n4s';\n\nimport { allOf } from 'allOf';\nimport { anyOf } from 'anyOf';\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\nimport { Lazy } from 'genEnforceLazy';\nimport { noneOf } from 'noneOf';\nimport { oneOf } from 'oneOf';\nimport { RuleDetailedResult } from 'ruleReturn';\n\nenforce.extend({ allOf, anyOf, noneOf, oneOf });\n\ntype EnforceCompoundRule = (\n  value: unknown,\n  ...rules: Lazy[]\n) => RuleDetailedResult;\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      allOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      anyOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      noneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      oneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n    }\n  }\n}\n"],"names":["ruleReturn.failing","ruleReturn.defaultToPassing","ruleReturn.defaultToFailing"],"mappings":"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"}

package/dist/es/compounds.production.js

@@ -1 +1,2 @@
 import{enforce as n}from"n4s";import{defaultTo as t,mapFirst as r,bindNot as u,greaterThan as e}from"vest-utils";function o(n,t){const r={pass:n};return t&&(r.message=t),r}function s(){return o(!1)}function f(n){return t(n,o(!0))}function c(n,t){try{return n.run(t)}catch(n){return s()}}function i(n,t){return n===t}u(i);n.extend({allOf:function(n,...t){return f(r(t,((t,r)=>{const u=c(t,n);r(!u.pass,u)})))},anyOf:function(n,...u){return e=r(u,((t,r)=>{const u=c(t,n);r(u.pass,u)})),t(e,s());var e},noneOf:function(n,...t){return f(r(t,((t,r)=>{r(c(t,n).pass,s())})))},oneOf:function(n,...t){let r=0;return t.some((t=>{if(c(t,n).pass&&r++,e(r,1))return!1})),o(i(r,1))}});
+//# sourceMappingURL=compounds.production.js.map

package/dist/es/compounds.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compounds.production.js","sources":["../../src/lib/ruleReturn.ts","../../src/lib/runLazyRule.ts","../../src/rules/equals.ts","../../src/exports/compounds.ts","../../src/plugins/compounds/allOf.ts","../../src/plugins/compounds/anyOf.ts","../../src/plugins/compounds/noneOf.ts","../../src/plugins/compounds/oneOf.ts"],"sourcesContent":["import type { Stringable } from 'vest-utils';\nimport { defaultTo } from 'vest-utils';\n\nexport default function ruleReturn(\n  pass: boolean,\n  message?: string\n): RuleDetailedResult {\n  const output: RuleDetailedResult = { pass };\n\n  if (message) {\n    output.message = message;\n  }\n\n  return output;\n}\n\nexport function failing(): RuleDetailedResult {\n  return ruleReturn(false);\n}\n\nexport function passing(): RuleDetailedResult {\n  return ruleReturn(true);\n}\n\nexport function defaultToFailing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, failing());\n}\n\nexport function defaultToPassing(\n  callback: (...args: any[]) => RuleDetailedResult\n): RuleDetailedResult {\n  return defaultTo(callback, passing());\n}\n\nexport type RuleReturn =\n  | boolean\n  | {\n      pass: boolean;\n      message?: Stringable;\n    };\n\nexport type RuleDetailedResult = { pass: boolean; message?: string };\n","import type { LazyRuleRunners } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\n\nexport default function runLazyRule(\n  lazyRule: LazyRuleRunners,\n  currentValue: any\n): RuleDetailedResult {\n  try {\n    return lazyRule.run(currentValue);\n  } catch {\n    return ruleReturn.failing();\n  }\n}\n","import { bindNot } from 'vest-utils';\n\nexport function equals(value: unknown, arg1: unknown): boolean {\n  return value === arg1;\n}\n\nexport const notEquals = bindNot(equals);\n","import { enforce } from 'n4s';\n\nimport { allOf } from 'allOf';\nimport { anyOf } from 'anyOf';\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\nimport { Lazy } from 'genEnforceLazy';\nimport { noneOf } from 'noneOf';\nimport { oneOf } from 'oneOf';\nimport { RuleDetailedResult } from 'ruleReturn';\n\nenforce.extend({ allOf, anyOf, noneOf, oneOf });\n\ntype EnforceCompoundRule = (\n  value: unknown,\n  ...rules: Lazy[]\n) => RuleDetailedResult;\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      allOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      anyOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      noneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n      oneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;\n    }\n  }\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport * as ruleReturn from 'ruleReturn';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function allOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n      breakout(!res.pass, res);\n    })\n  );\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport * as ruleReturn from 'ruleReturn';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function anyOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToFailing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n      breakout(res.pass, res);\n    })\n  );\n}\n","import { mapFirst } from 'vest-utils';\n\nimport type { Lazy } from 'genEnforceLazy';\nimport type { RuleDetailedResult } from 'ruleReturn';\nimport * as ruleReturn from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nexport function noneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  return ruleReturn.defaultToPassing(\n    mapFirst(rules, (rule, breakout) => {\n      const res = runLazyRule(rule, value);\n\n      breakout(res.pass, ruleReturn.failing());\n    })\n  );\n}\n","import { greaterThan } from 'vest-utils';\n\nimport { equals } from 'equals';\nimport type { Lazy } from 'genEnforceLazy';\nimport ruleReturn, { RuleDetailedResult } from 'ruleReturn';\nimport runLazyRule from 'runLazyRule';\n\nconst REQUIRED_COUNT = 1;\n\nexport function oneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {\n  let passingCount = 0;\n  rules.some(rule => {\n    const res = runLazyRule(rule, value);\n\n    if (res.pass) {\n      passingCount++;\n    }\n\n    if (greaterThan(passingCount, REQUIRED_COUNT)) {\n      return false;\n    }\n  });\n\n  return ruleReturn(equals(passingCount, REQUIRED_COUNT));\n}\n"],"names":["ruleReturn","pass","message","output","failing","defaultToPassing","callback","defaultTo","runLazyRule","lazyRule","currentValue","run","_a","ruleReturn.failing","equals","value","arg1","bindNot","enforce","extend","allOf","rules","ruleReturn.defaultToPassing","mapFirst","rule","breakout","res","anyOf","noneOf","oneOf","passingCount","some","greaterThan"],"mappings":"iHAGc,SAAUA,EACtBC,EACAC,GAEA,MAAMC,EAA6B,CAAEF,QAMrC,OAJIC,IACFC,EAAOD,QAAUA,GAGZC,CACT,UAEgBC,IACd,OAAOJ,GAAW,EACpB,CAYM,SAAUK,EACdC,GAEA,OAAOC,EAAUD,EAZVN,GAAW,GAapB,CC9Bc,SAAUQ,EACtBC,EACAC,GAEA,IACE,OAAOD,EAASE,IAAID,EAGrB,CAFC,MAAME,GACN,OAAOC,GACR,CACH,CCXgB,SAAAC,EAAOC,EAAgBC,GACrC,OAAOD,IAAUC,CACnB,CAEyBC,EAAQH,GCIjCI,EAAQC,OAAO,CAAEC,eCHKL,KAAmBM,GACvC,OAAOC,EACLC,EAASF,GAAO,CAACG,EAAMC,KACrB,MAAMC,EAAMlB,EAAYgB,EAAMT,GAC9BU,GAAUC,EAAIzB,KAAMyB,EAAI,IAG9B,EDJwBC,eEHFZ,KAAmBM,GACvC,OLiBAf,EKhBEiB,EAASF,GAAO,CAACG,EAAMC,KACrB,MAAMC,EAAMlB,EAAYgB,EAAMT,GAC9BU,EAASC,EAAIzB,KAAMyB,EAAI,ILgBpBnB,EAAUD,EAAUF,KAHvB,IACJE,CKXF,EFJ+BsB,gBGHRb,KAAmBM,GACxC,OAAOC,EACLC,EAASF,GAAO,CAACG,EAAMC,KAGrBA,EAFYjB,EAAYgB,EAAMT,GAEjBd,KAAMY,IAAqB,IAG9C,EHLuCgB,eIDjBd,KAAmBM,GACvC,IAAIS,EAAe,EAanB,OAZAT,EAAMU,MAAKP,IAOT,GANYhB,EAAYgB,EAAMT,GAEtBd,MACN6B,IAGEE,EAAYF,EAXG,GAYjB,OAAO,CACR,IAGI9B,EAAWc,EAAOgB,EAhBJ,GAiBvB"}

package/dist/es/date.development.js

@@ -200,3 +200,4 @@ function isISO8601(str) {
 }
 
 enforce.extend({ isAfter, isBefore, isDate, isISO8601 });
+//# sourceMappingURL=date.development.js.map

package/dist/es/date.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.development.js","sources":["../../src/exports/date.ts"],"sourcesContent":["import { enforce } from 'n4s';\nimport isAfter from 'validator/es/lib/isAfter';\nimport isBefore from 'validator/es/lib/isBefore';\nimport isDate from 'validator/es/lib/isDate';\nimport isISO8601 from 'validator/es/lib/isISO8601';\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\n\nenforce.extend({ isAfter, isBefore, isDate, isISO8601 });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isAfter: EnforceCustomMatcher<typeof isAfter, R>;\n      isBefore: EnforceCustomMatcher<typeof isBefore, R>;\n      isDate: EnforceCustomMatcher<typeof isDate, R>;\n      isISO8601: EnforceCustomMatcher<typeof isISO8601, R>;\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC"}

package/dist/es/date.production.js

@@ -1 +1,2 @@
 import{enforce as t}from"n4s";function r(t){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},r(t)}function n(t){if(!("string"==typeof t||t instanceof String)){var n=r(t);throw null===t?n="null":"object"===n&&(n=t.constructor.name),new TypeError("Expected a string but received a ".concat(n))}}function e(t){return n(t),t=Date.parse(t),isNaN(t)?null:new Date(t)}function o(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;for(var n in r)void 0===t[n]&&(t[n]=r[n]);return t}function i(t,r){return function(t){if(Array.isArray(t))return t}(t)||function(t,r){if("undefined"==typeof Symbol||!(Symbol.iterator in Object(t)))return;var n=[],e=!0,o=!1,i=void 0;try{for(var a,u=t[Symbol.iterator]();!(e=(a=u.next()).done)&&(n.push(a.value),!r||n.length!==r);e=!0);}catch(t){o=!0,i=t}finally{try{e||null==u.return||u.return()}finally{if(o)throw i}}return n}(t,r)||a(t,r)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function a(t,r){if(t){if("string"==typeof t)return u(t,r);var n=Object.prototype.toString.call(t).slice(8,-1);return"Object"===n&&t.constructor&&(n=t.constructor.name),"Map"===n||"Set"===n?Array.from(t):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?u(t,r):void 0}}function u(t,r){(null==r||r>t.length)&&(r=t.length);for(var n=0,e=new Array(r);n<r;n++)e[n]=t[n];return e}var c={format:"YYYY/MM/DD",delimiters:["/","-"],strictMode:!1};var f=/^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-3])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/,l=/^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-3])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/,d=function(t){var r=t.match(/^(\d{4})-?(\d{3})([ T]{1}\.*|$)/);if(r){var n=Number(r[1]),e=Number(r[2]);return n%4==0&&n%100!=0||n%400==0?e<=366:e<=365}var o=t.match(/(\d{4})-?(\d{0,2})-?(\d*)/).map(Number),i=o[1],a=o[2],u=o[3],c=a?"0".concat(a).slice(-2):a,f=u?"0".concat(u).slice(-2):u,l=new Date("".concat(i,"-").concat(c||"01","-").concat(f||"01"));return!a||!u||l.getUTCFullYear()===i&&l.getUTCMonth()+1===a&&l.getUTCDate()===u};t.extend({isAfter:function(t,r){var n=e((null==r?void 0:r.comparisonDate)||r||Date().toString()),o=e(t);return!!(o&&n&&o>n)},isBefore:function(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:String(new Date);n(t);var o=e(r),i=e(t);return!!(i&&o&&i<o)},isDate:function(t,r){if(r=o("string"==typeof r?{format:r}:r,c),"string"==typeof t&&(p=r.format,/(^(y{4}|y{2})[.\/-](m{1,2})[.\/-](d{1,2})$)|(^(m{1,2})[.\/-](d{1,2})[.\/-]((y{4}|y{2})$))|(^(d{1,2})[.\/-](m{1,2})[.\/-]((y{4}|y{2})$))/gi.test(p))){var n,e=r.delimiters.find((function(t){return-1!==r.format.indexOf(t)})),u=r.strictMode?e:r.delimiters.find((function(r){return-1!==t.indexOf(r)})),f=function(t,r){for(var n=[],e=Math.min(t.length,r.length),o=0;o<e;o++)n.push([t[o],r[o]]);return n}(t.split(u),r.format.toLowerCase().split(e)),l={},d=function(t,r){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=a(t))||r&&t&&"number"==typeof t.length){n&&(t=n);var e=0,o=function(){};return{s:o,n:function(){return e>=t.length?{done:!0}:{done:!1,value:t[e++]}},e:function(t){throw t},f:o}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var i,u=!0,c=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return u=t.done,t},e:function(t){c=!0,i=t},f:function(){try{u||null==n.return||n.return()}finally{if(c)throw i}}}}(f);try{for(d.s();!(n=d.n()).done;){var y=i(n.value,2),s=y[0],m=y[1];if(s.length!==m.length)return!1;l[m.charAt(0)]=s}}catch(t){d.e(t)}finally{d.f()}var v=l.y;if(2===l.y.length){var b=parseInt(l.y,10);if(isNaN(b))return!1;v=b<(new Date).getFullYear()%100?"20".concat(l.y):"19".concat(l.y)}return new Date("".concat(v,"-").concat(l.m,"-").concat(l.d)).getDate()===+l.d}var p;return!r.strictMode&&("[object Date]"===Object.prototype.toString.call(t)&&isFinite(t))},isISO8601:function(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};n(t);var e=r.strictSeparator?l.test(t):f.test(t);return e&&r.strict?d(t):e}});
+//# sourceMappingURL=date.production.js.map

package/dist/es/date.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.production.js","sources":["../../src/exports/date.ts"],"sourcesContent":["import { enforce } from 'n4s';\nimport isAfter from 'validator/es/lib/isAfter';\nimport isBefore from 'validator/es/lib/isBefore';\nimport isDate from 'validator/es/lib/isDate';\nimport isISO8601 from 'validator/es/lib/isISO8601';\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\n\nenforce.extend({ isAfter, isBefore, isDate, isISO8601 });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isAfter: EnforceCustomMatcher<typeof isAfter, R>;\n      isBefore: EnforceCustomMatcher<typeof isBefore, R>;\n      isDate: EnforceCustomMatcher<typeof isDate, R>;\n      isISO8601: EnforceCustomMatcher<typeof isISO8601, R>;\n    }\n  }\n}\n"],"names":["enforce","extend","isAfter","isBefore","isDate","isISO8601"],"mappings":"iqFAQAA,EAAQC,OAAO,CAAEC,mHAASC,+IAAUC,6mDAAQC"}

package/dist/es/email.development.js

@@ -361,3 +361,4 @@ function isEmail(str, options) {
 }
 
 enforce.extend({ isEmail });
+//# sourceMappingURL=email.development.js.map

package/dist/es/email.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.development.js","sources":["../../src/exports/email.ts"],"sourcesContent":["import { enforce } from 'n4s';\nimport isEmail from 'validator/es/lib/isEmail';\n\nimport { EnforceCustomMatcher } from 'enforceUtilityTypes';\n\nenforce.extend({ isEmail });\n\n/* eslint-disable @typescript-eslint/no-namespace */\ndeclare global {\n  namespace n4s {\n    interface EnforceCustomMatchers<R> {\n      isEmail: EnforceCustomMatcher<typeof isEmail, R>;\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC"}