@sleekcms/json-zen 1.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2022, SleekSky LLC, California, USA
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,292 @@
+# JSON Zen
+
+A compact, string-based schema syntax for validating and shaping JSON objects — with far less boilerplate than JSON Schema.
+
+## Installation
+
+```bash
+npm install @sleekcms/json-zen
+```
+
+```js
+// CommonJS
+const { verify, check, shape, toSchema, extendTypes } = require('@sleekcms/json-zen');
+
+// ESM / TypeScript
+import { verify, check, shape, toSchema, extendTypes } from '@sleekcms/json-zen';
+```
+
+## Quick Start
+
+```js
+import { verify, check, shape, toSchema } from '@sleekcms/json-zen';
+
+const data = { name: 'Alice', age: 30, tags: ['admin', 'user'] };
+
+// Validate (throws on failure)
+verify(data, '{name:s, age:n, tags:[s]}'); // true
+// using full type names is equivalent:
+verify(data, '{name:string, age:number, tags:[string]}'); // true
+
+// Safe boolean check
+check(data, '{name:s, age:s}'); // false
+
+// Generate a schema from an existing object
+toSchema(data); // "{name:string,age:number,tags:[string]}"
+
+// Fill in missing fields with typed defaults
+shape({ name: 'Bob' }, '{name:s, age:n, active:b}');
+// { name: 'Bob', age: 0, active: true }
+```
+
+---
+
+## Schema Syntax
+
+Alt schemas are plain strings. Whitespace is ignored.
+
+### Built-in Types
+
+| Shorthand | Full name | Validates            | Default (shape) |
+|-----------|-----------|----------------------|-----------------|
+| `s`       | `string`  | string               | `""`            |
+| `n`       | `number`  | number (incl. floats)| `0`             |
+| `b`       | `boolean` | boolean              | `true`          |
+| —         | `null`    | strictly `null`      | `null`          |
+| `?`       | —         | any value / nullable | `null`          |
+
+Shorthands and full names are interchangeable: `{a:s}` and `{a:string}` behave identically.
+
+### Objects
+
+```
+{key:type, key:type, ...}
+```
+
+```js
+verify({ a: 'hello', b: 42 }, '{a:s, b:n}');           // true — shorthands
+verify({ a: 'hello', b: 42 }, '{a:string, b:number}'); // true — full names
+```
+
+### Arrays
+
+A single type applies to every element. Multiple comma-separated types cycle by index.
+
+```js
+verify([1, 2, 3], '[n]');           // true — all numbers
+verify([1, 'x', 2, 'y'], '[n,s]');  // true — alternating number/string
+```
+
+### Optional fields (`?`)
+
+Prefix a type with `?` to make it optional. A missing or `null` value passes validation.
+
+```js
+verify({ a: 1 }, '{a:n, b:?s}');    // true — b is missing but optional
+verify({ a: 1, b: null }, '{a:n, b:?s}'); // true
+```
+
+### Presence-only validation
+
+Omit the type to require only that a key exists and is not `null`/`undefined`.
+
+```js
+verify({ a: 1, b: false }, '{a, b}'); // true
+verify({ a: 1, b: null }, '{a, b}');  // throws — b is null
+```
+
+### Default values (`type:default`)
+
+Attach a default after the type, used by `shape` to fill missing values.
+
+```js
+shape({}, '{name:s:anonymous, count:n:0}');
+// { name: 'anonymous', count: 0 }
+```
+
+Use quotes for defaults containing spaces:
+
+```js
+shape({}, '{title:s:"Hello World"}');
+// { title: 'Hello World' }
+```
+
+### Wildcard key (`*`)
+
+`*:type` matches any key not already listed in the schema.
+
+```js
+verify({ a: 1, b: 2, c: 3 }, '{*:n}');         // true
+verify({ a: 1, b: '2' }, '{a:n, *:s}');         // true — b matched by wildcard
+shape({ x: 1, y: 2, z: 3 }, '{*:n}');           // { x: 1, y: 2, z: 3 }
+```
+
+### Nested objects and arrays
+
+```js
+const schema = '{user:{name:s, scores:[n]}, active:b}';
+
+verify({ user: { name: 'Alice', scores: [10, 20] }, active: true }, schema); // true
+```
+
+---
+
+## API
+
+### `verify(json, schema, options?)`
+
+Validates `json` against `schema`. Returns `true` on success, throws an `ZenError` on failure.
+
+```js
+verify({ a: 1 }, '{a:s}');
+// throws: "json.a: validation failed"
+```
+
+Access all failures at once via `error.errors`:
+
+```js
+try {
+  verify({}, '{a:n, b:n}');
+} catch (e) {
+  console.log(e.message); // "Validation failed: 2 errors found"
+  console.log(e.errors);  // [['json.a', 'is required'], ['json.b', 'is required']]
+}
+```
+
+**Options:**
+
+| Option  | Type     | Description                                       |
+|---------|----------|---------------------------------------------------|
+| `_path` | `string` | Override the root label in error messages         |
+| _(key)_ | validator | Inline custom type — see [Custom Validators](#custom-validators) |
+
+```js
+verify({ a: 'x' }, '{a:s}', { _path: 'payload' });
+// throws: "payload.a: validation failed"
+```
+
+---
+
+### `check(json, schema, options?)`
+
+Same as `verify` but returns `false` instead of throwing. Schema errors still throw.
+
+```js
+check({ a: 1, b: 'x' }, '{a:n, b:n}'); // false
+check({ a: 1, b: 2 }, '{a:n, b:n}');   // true
+```
+
+---
+
+### `shape(json, schema, options?)`
+
+Returns a new object shaped to the schema. Values from `json` are used when valid; otherwise, typed defaults fill in the gaps. Extra keys in `json` not in the schema are omitted.
+
+```js
+shape({ a: 1, extra: 99 }, '{a:n, b:s, c:b}');
+// { a: 1, b: '', c: true }
+```
+
+Nested structures are shaped recursively:
+
+```js
+shape({ a: {} }, '{a:{x:n, y:s}}');
+// { a: { x: 0, y: '' } }
+```
+
+**Options:**
+
+| Option      | Type      | Description                                                  |
+|-------------|-----------|--------------------------------------------------------------|
+| `_optional` | `boolean` | When `true`, fill optional (`?`) fields with defaults instead of `null` |
+| _(key)_     | validator | Inline custom type                                           |
+
+```js
+shape({}, '{a:?n}');                   // { a: null }
+shape({}, '{a:?n}', { _optional: true }); // { a: 0 }
+```
+
+---
+
+### `toSchema(json)`
+
+Generates a schema string from a JSON object. Useful for bootstrapping a schema from a known-good example.
+
+```js
+toSchema({ a: 'foo', b: 1, c: [1, 2], d: { e: null } });
+// "{a:string,b:number,c:[number],d:{e:?}}"
+```
+
+---
+
+### `extendTypes(validators)`
+
+Registers one or more custom types globally. Once registered, the type name can be used in any schema.
+
+The validator function receives the value when checking, and `undefined` when `shape` needs a default — return the default value in that case.
+
+```js
+import { extendTypes, shape, verify } from '@sleekcms/json-zen';
+
+extendTypes({
+  url: (value) => {
+    if (value === undefined) return 'https://example.com'; // default for shape
+    return typeof value === 'string' && value.startsWith('http');
+  }
+});
+
+verify({ img: 'https://example.com/pic.jpg' }, '{img:url}'); // true
+shape({}, '{img:url}'); // { img: 'https://example.com' }
+```
+
+---
+
+## Custom Validators
+
+Custom validators can be passed inline via `options`, registered globally via `extendTypes`, or provided as enum arrays or RegExp patterns.
+
+### Inline function
+
+```js
+verify({ status: 'active' }, '{status:myType}', {
+  myType: (value) => value === 'active' || value === 'inactive'
+});
+```
+
+### Enum (array)
+
+```js
+verify({ role: 'admin' }, '{role:r}', { r: ['admin', 'user', 'guest'] }); // true
+verify({ role: 'root' },  '{role:r}', { r: ['admin', 'user', 'guest'] }); // throws
+```
+
+### Regex
+
+```js
+verify({ slug: 'hello-world' }, '{slug:sl}', { sl: /^[a-z-]+$/ }); // true
+```
+
+### Context-aware validator
+
+Validators receive `{ path, json, parent }` as a second argument, enabling cross-field validation:
+
+```js
+extendTypes({
+  matchesType: (value, { parent }) => {
+    if (parent.type === 'number') return typeof value === 'number';
+    if (parent.type === 'string') return typeof value === 'string';
+    return false;
+  }
+});
+
+verify(
+  [{ type: 'number', value: 42 }, { type: 'string', value: 'hi' }],
+  '[{type:s, value:matchesType}]'
+); // true
+```
+
+---
+
+## License
+
+MIT © Yusuf Bhabhrawala, SleekSky LLC

package/lib/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Author: Yusuf Bhabhrawala
+ */
+export declare const setEnv: (e: string | null) => void;
+type FlattenResult = [string, string[], string[]];
+export declare const _flatten: (schema: string) => FlattenResult;
+export type TypeShape = string | TypeShape[] | {
+    [key: string]: TypeShape;
+};
+export declare const typeShape: (schema: string) => TypeShape;
+export declare const toSchema: (json: unknown) => string;
+export interface ShapeOptions {
+    _optional?: boolean;
+    [key: string]: unknown;
+}
+export declare const shape: <T = unknown>(json: unknown, schema: string, options?: ShapeOptions) => T;
+export interface VerifyOptions {
+    _path?: string;
+    [key: string]: unknown;
+}
+export declare const verify: (json: unknown, schema: string, options?: VerifyOptions) => boolean | undefined;
+export declare const check: (json: unknown, schema: string, options?: VerifyOptions) => boolean;
+export declare const extendTypes: (types: Record<string, unknown>) => void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAiBH,eAAO,MAAM,MAAM,GAAI,GAAG,MAAM,GAAG,IAAI,KAAG,IAEzC,CAAC;AAEF,KAAK,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;AAElD,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,KAAG,aAqCzC,CAAC;AAQF,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,SAAS,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAG5E,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,KAAG,SAqC1C,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,MAAM,OAAO,KAAG,MAiBxC,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,eAAO,MAAM,KAAK,GAAI,CAAC,GAAG,OAAO,EAAE,MAAM,OAAO,EAAE,QAAQ,MAAM,EAAE,UAAS,YAAiB,KAAG,CAsF9F,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,eAAO,MAAM,MAAM,GAAI,MAAM,OAAO,EAAE,QAAQ,MAAM,EAAE,UAAS,aAAkB,KAAG,OAAO,GAAG,SA6F7F,CAAC;AAGF,eAAO,MAAM,KAAK,GAAI,MAAM,OAAO,EAAE,QAAQ,MAAM,EAAE,UAAU,aAAa,KAAG,OAQ9E,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,IAE5D,CAAC"}

package/lib/index.js

@@ -0,0 +1,326 @@
+"use strict";
+/**
+ * Author: Yusuf Bhabhrawala
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendTypes = exports.check = exports.verify = exports.shape = exports.toSchema = exports.typeShape = exports._flatten = exports.setEnv = void 0;
+const types_1 = __importDefault(require("./types"));
+const zen_error_1 = __importDefault(require("./zen-error"));
+const RX = {
+    FLAT_ARRAY: /(\[([^\[\]\{\}]*)\])/,
+    FLAT_OBJECT: /(\{([^\{\}\[\]]*)\})/,
+    MALFORMED: /[\[\]\{\}]/,
+    FLAT_SCALAR: /^[^\[\]\{\}]*$/,
+    OPTIONAL: /^[\?]/,
+    LOOKUP: /^[0-9]+$/,
+    DEFAULTS: /^\$([0-9]+)$/
+};
+let env = null;
+const setEnv = (e) => {
+    env = e;
+};
+exports.setEnv = setEnv;
+const _flatten = (schema) => {
+    const lookups = [];
+    const default_strings = [];
+    let m;
+    // convert "hello world" to $0. remote " (quotes)
+    while ((m = schema.match(/"([^"]+)"/))) {
+        schema = schema.substr(0, m.index) + `$${default_strings.length}` + schema.substr(m.index + m[0].length);
+        default_strings.push(m[1]);
+    }
+    while ((m = schema.match(/'([^']+)'/))) {
+        schema = schema.substr(0, m.index) + `$${default_strings.length}` + schema.substr(m.index + m[0].length);
+        default_strings.push(m[1]);
+    }
+    if (schema.match(/"/))
+        throw new Error("Missing closing quote");
+    // strip all white spaces
+    schema = schema.replace(/\s/g, "");
+    function reduce(schema) {
+        let m;
+        let found = false;
+        while ((m = schema.match(RX.FLAT_ARRAY)) || (m = schema.match(RX.FLAT_OBJECT))) {
+            schema = schema.substr(0, m.index) + lookups.length + schema.substr(m.index + m[0].length);
+            lookups.push(m[0]);
+            found = true;
+        }
+        if (found)
+            return reduce(schema);
+        if (!found && schema.match(RX.MALFORMED)) {
+            throw new Error("Schema error: probably invalid braces or brackets");
+        }
+        return schema;
+    }
+    schema = reduce(schema);
+    return [schema, lookups, default_strings];
+};
+exports._flatten = _flatten;
+function splitOnce(str, delim) {
+    const parts = str.split(delim);
+    const first = parts.shift();
+    return [first, parts.join(delim)];
+}
+// Set leaf types to format "optional:type:default_value" tuple. Eg. "?:boolean:false" or ":integer:"
+const typeShape = (schema) => {
+    let [sch, lookups, default_strings] = (0, exports._flatten)(schema);
+    function traverse(sch) {
+        if (!sch)
+            return "";
+        let m;
+        if (sch.match(RX.LOOKUP))
+            return traverse(lookups[Number(sch)]);
+        if ((m = sch.match(RX.FLAT_ARRAY))) {
+            sch = m[2];
+            const schema_parts = sch.split(",");
+            return schema_parts.length > 0 ? [traverse(schema_parts[0])] : [traverse("")];
+        }
+        if ((m = sch.match(RX.FLAT_OBJECT))) {
+            sch = m[2];
+            return sch.split(",").reduce((acc, name) => {
+                let [k, v] = splitOnce(name, ":");
+                if (k.match(RX.DEFAULTS))
+                    k = default_strings[Number(k.substr(1))];
+                acc[k] = traverse(v);
+                return acc;
+            }, {});
+        }
+        if (sch.match(RX.FLAT_SCALAR)) {
+            let [type, def] = sch.split(":");
+            if (!def)
+                def = "";
+            if (def && def.match(RX.DEFAULTS))
+                def = default_strings[Number(def.substr(1))];
+            let optional = '';
+            if (type.match(RX.OPTIONAL)) {
+                optional = '?';
+                type = type.substr(1);
+            }
+            const type_lookup = { i: "integer", n: "number", b: "boolean", s: "string" };
+            if (type_lookup[type])
+                type = type_lookup[type];
+            return [optional, type, def].join(':');
+        }
+        return "";
+    }
+    return traverse(sch);
+};
+exports.typeShape = typeShape;
+const toSchema = (json) => {
+    function traverse(obj) {
+        const type = types_1.default.toSchema(obj);
+        if (type === "array") {
+            const arr = obj;
+            const sch = arr.length > 0 ? traverse(arr[0]) : "";
+            return `[${sch}]`;
+        }
+        if (type === "object") {
+            const objRecord = obj;
+            return '{' + Object.keys(objRecord).map((k) => {
+                return `${k}:${traverse(objRecord[k])}`;
+            }).join(",") + '}';
+        }
+        return type;
+    }
+    return traverse(json);
+};
+exports.toSchema = toSchema;
+const shape = (json, schema, options = {}) => {
+    const types = new types_1.default(options);
+    options._optional = options._optional || false;
+    let lookups;
+    let default_strings;
+    [schema, lookups, default_strings] = (0, exports._flatten)(schema);
+    const getValue = (type, value, def) => {
+        let m;
+        if (def && (m = def.match(RX.DEFAULTS)))
+            def = default_strings[Number(m[1])];
+        if (types.has(type)) {
+            return (value && types.check(type, value)) ? value : (def !== undefined) ? types.cast(type, def) : types.sample(type);
+        }
+        return value || def || "Not defined!";
+    };
+    // flat validator value = {k:t:d,..} [t:d,..] t:d
+    function traverse({ value, schema }) {
+        if (!schema)
+            schema = "";
+        let m;
+        let optional = false;
+        if (schema.match(RX.OPTIONAL)) {
+            schema = schema.substr(1);
+            optional = true;
+        }
+        // if lookup, validate further
+        if (schema.match(RX.LOOKUP))
+            return traverse({ value, schema: `${optional ? '?' : ''}${lookups[Number(schema)]}` });
+        if ((value === null || value === undefined) && optional && !options._optional)
+            return null;
+        if (schema.match(RX.FLAT_SCALAR)) {
+            // if scalar
+            let type;
+            let def;
+            [type, def] = schema.split(":");
+            return getValue(type, value, def);
+        }
+        else if ((m = schema.match(RX.FLAT_ARRAY))) {
+            // if array
+            schema = m[2];
+            const schema_parts = schema.split(",");
+            let arr = value;
+            if (!Array.isArray(value))
+                arr = schema_parts.map(() => null);
+            if (arr.length < schema_parts.length) {
+                arr = arr.concat(schema_parts.slice(arr.length).map(() => null));
+            }
+            return arr.map((v, i) => traverse({ value: v, schema: schema_parts[i % schema_parts.length] }));
+        }
+        else if ((m = schema.match(RX.FLAT_OBJECT))) {
+            // if object
+            let obj = value;
+            if (typeof value !== 'object' || Array.isArray(value)) {
+                obj = {};
+            }
+            schema = m[2];
+            if (schema === "")
+                return obj;
+            let wildcard = false;
+            const shp = schema.split(",").reduce((acc, name) => {
+                let [k, t, d] = name.split(":");
+                if (!t)
+                    t = "";
+                if (d)
+                    t += ":" + d;
+                if (k === "*")
+                    wildcard = t;
+                else
+                    acc[k] = traverse({ value: obj[k], schema: t });
+                return acc;
+            }, {});
+            if (wildcard !== false) {
+                for (const k in obj)
+                    if (shp[k] === undefined)
+                        shp[k] = traverse({ value: obj[k], schema: wildcard });
+            }
+            return shp;
+        }
+        return value;
+    }
+    const result = traverse({ value: json, schema });
+    return result;
+};
+exports.shape = shape;
+const verify = (json, schema, options = {}) => {
+    if (env && env !== "development")
+        return undefined;
+    const types = new types_1.default(options);
+    const errors = [];
+    const jsonPath = options._path || 'json';
+    let lookups;
+    [schema, lookups] = (0, exports._flatten)(schema);
+    // flat validator value = {k:t:d,..} [t:d,..] t:d
+    function validate({ path, value, schema, parent = null }) {
+        let m;
+        let optional = false;
+        if (schema.match(RX.OPTIONAL)) {
+            schema = schema.substr(1);
+            if (value === undefined || value === null)
+                return true;
+            optional = true;
+        }
+        // if lookup, validate further
+        if (schema.match(RX.LOOKUP))
+            return validate({ path: `${path}`, value, schema: `${optional ? '?' : ''}${lookups[Number(schema)]}`, parent: parent });
+        if (schema.match(RX.FLAT_SCALAR)) {
+            // if scalar
+            let def;
+            [schema, def] = schema.split(":");
+            if (value === undefined || value === null) {
+                errors.push([path, 'is required']);
+                return false;
+            }
+            if (schema === "")
+                return true; // no validation needed
+            if (!types.has(schema))
+                throw new Error(`Schema error: Validator - ${schema} - not found`);
+            else if (types.check(schema, value, { path, json, parent }))
+                return true;
+            else {
+                errors.push([path, 'validation failed']);
+                return false;
+            }
+        }
+        else if ((m = schema.match(RX.FLAT_ARRAY))) {
+            // if array
+            if (!Array.isArray(value)) {
+                errors.push([path, 'should be array']);
+                return false;
+            }
+            schema = m[2];
+            const schema_parts = schema.split(",");
+            for (const i in value) {
+                validate({ path: `${path}.${i}`, value: value[i], schema: schema_parts[Number(i) % schema_parts.length], parent: value });
+            }
+            return true;
+        }
+        else if ((m = schema.match(RX.FLAT_OBJECT))) {
+            // if object
+            if (typeof value !== 'object' || Array.isArray(value)) {
+                errors.push([path, 'should be object']);
+                return false;
+            }
+            schema = m[2];
+            let wildcard = false;
+            if (schema !== "") {
+                const obj = value;
+                const keys = schema.split(",").reduce((acc, name) => {
+                    let [k, t] = name.split(":");
+                    if (!t)
+                        t = "";
+                    if (k === '*')
+                        wildcard = t;
+                    else
+                        acc[k] = t;
+                    return acc;
+                }, {});
+                if (wildcard !== false) {
+                    for (const k in obj)
+                        if (keys[k] === undefined)
+                            keys[k] = wildcard;
+                }
+                // if object, validate for all k-v
+                for (const k in keys)
+                    validate({ path: `${path}.${k}`, value: obj[k], schema: keys[k], parent: value });
+            }
+            return true;
+        }
+        return true;
+    }
+    validate({ path: jsonPath, value: json, schema });
+    if (errors.length > 0)
+        throw new zen_error_1.default(errors);
+    return true;
+};
+exports.verify = verify;
+// same as verify. returns boolean. won't throw.
+const check = (json, schema, options) => {
+    try {
+        (0, exports.verify)(json, schema, options);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.match(/^Schema error/))
+            throw error;
+        return false;
+    }
+};
+exports.check = check;
+const extendTypes = (types) => {
+    types_1.default.extend(types);
+};
+exports.extendTypes = extendTypes;
+// CommonJS compatibility
+module.exports = { verify: exports.verify, check: exports.check, shape: exports.shape, toSchema: exports.toSchema, _flatten: exports._flatten, typeShape: exports.typeShape, extendTypes: exports.extendTypes, setEnv: exports.setEnv };
+//# sourceMappingURL=index.js.map