@based/schema 2.2.10 → 2.2.12

package/dist/{set → src/set}/fields/string.js

@@ -1,73 +1,67 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.text = exports.string = void 0;
-const error_1 = require("../../error");
-const validator_1 = __importDefault(require("validator"));
+import { ParseError } from '../../error.js';
+import validators from 'validator';
 const formatPatterns = {
-    email: validator_1.default.isEmail,
-    URL: validator_1.default.isURL,
-    MACAddress: validator_1.default.isMACAddress,
-    IP: validator_1.default.isIP,
-    IPRange: validator_1.default.isIPRange,
-    FQDN: validator_1.default.isFQDN,
-    IBAN: validator_1.default.isIBAN,
-    BIC: validator_1.default.isBIC,
-    alpha: validator_1.default.isAlpha,
-    alphaLocales: validator_1.default.isAlphaLocales,
-    alphanumeric: validator_1.default.isAlphanumeric,
-    alphanumericLocales: validator_1.default.isAlphanumericLocales,
-    passportNumber: validator_1.default.isPassportNumber,
-    port: validator_1.default.isPort,
-    lowercase: validator_1.default.isLowercase,
-    uppercase: validator_1.default.isUppercase,
-    ascii: validator_1.default.isAscii,
-    semVer: validator_1.default.isSemVer,
-    surrogatePair: validator_1.default.isSurrogatePair,
-    IMEI: validator_1.default.isIMEI,
-    hexadecimal: validator_1.default.isHexadecimal,
-    octal: validator_1.default.isOctal,
-    hexColor: validator_1.default.isHexColor,
-    rgbColor: validator_1.default.isRgbColor,
-    HSL: validator_1.default.isHSL,
-    ISRC: validator_1.default.isISRC,
-    MD5: validator_1.default.isMD5,
-    JWT: validator_1.default.isJWT,
-    UUID: validator_1.default.isUUID,
-    luhnNumber: validator_1.default.isLuhnNumber,
-    creditCard: validator_1.default.isCreditCard,
-    identityCard: validator_1.default.isIdentityCard,
-    EAN: validator_1.default.isEAN,
-    ISIN: validator_1.default.isISIN,
-    ISBN: validator_1.default.isISBN,
-    ISSN: validator_1.default.isISSN,
-    mobilePhone: validator_1.default.isMobilePhone,
-    mobilePhoneLocales: validator_1.default.isMobilePhoneLocales,
-    postalCode: validator_1.default.isPostalCode,
-    postalCodeLocales: validator_1.default.isPostalCodeLocales,
-    ethereumAddress: validator_1.default.isEthereumAddress,
-    currency: validator_1.default.isCurrency,
-    btcAddress: validator_1.default.isBtcAddress,
-    ISO6391: validator_1.default.isISO6391,
-    ISO8601: validator_1.default.isISO8601,
-    RFC3339: validator_1.default.isRFC3339,
-    ISO31661Alpha2: validator_1.default.isISO31661Alpha2,
-    ISO31661Alpha3: validator_1.default.isISO31661Alpha3,
-    ISO4217: validator_1.default.isISO4217,
-    base32: validator_1.default.isBase32,
-    base58: validator_1.default.isBase58,
-    base64: validator_1.default.isBase64,
-    dataURI: validator_1.default.isDataURI,
-    magnetURI: validator_1.default.isMagnetURI,
-    mimeType: validator_1.default.isMimeType,
-    latLong: validator_1.default.isLatLong,
-    slug: validator_1.default.isSlug,
-    strongPassword: validator_1.default.isStrongPassword,
-    taxID: validator_1.default.isTaxID,
-    licensePlate: validator_1.default.isLicensePlate,
-    VAT: validator_1.default.isVAT,
+    email: validators.isEmail,
+    URL: validators.isURL,
+    MACAddress: validators.isMACAddress,
+    IP: validators.isIP,
+    IPRange: validators.isIPRange,
+    FQDN: validators.isFQDN,
+    IBAN: validators.isIBAN,
+    BIC: validators.isBIC,
+    alpha: validators.isAlpha,
+    alphaLocales: validators.isAlphaLocales,
+    alphanumeric: validators.isAlphanumeric,
+    alphanumericLocales: validators.isAlphanumericLocales,
+    passportNumber: validators.isPassportNumber,
+    port: validators.isPort,
+    lowercase: validators.isLowercase,
+    uppercase: validators.isUppercase,
+    ascii: validators.isAscii,
+    semVer: validators.isSemVer,
+    surrogatePair: validators.isSurrogatePair,
+    IMEI: validators.isIMEI,
+    hexadecimal: validators.isHexadecimal,
+    octal: validators.isOctal,
+    hexColor: validators.isHexColor,
+    rgbColor: validators.isRgbColor,
+    HSL: validators.isHSL,
+    ISRC: validators.isISRC,
+    MD5: validators.isMD5,
+    JWT: validators.isJWT,
+    UUID: validators.isUUID,
+    luhnNumber: validators.isLuhnNumber,
+    creditCard: validators.isCreditCard,
+    identityCard: validators.isIdentityCard,
+    EAN: validators.isEAN,
+    ISIN: validators.isISIN,
+    ISBN: validators.isISBN,
+    ISSN: validators.isISSN,
+    mobilePhone: validators.isMobilePhone,
+    mobilePhoneLocales: validators.isMobilePhoneLocales,
+    postalCode: validators.isPostalCode,
+    postalCodeLocales: validators.isPostalCodeLocales,
+    ethereumAddress: validators.isEthereumAddress,
+    currency: validators.isCurrency,
+    btcAddress: validators.isBtcAddress,
+    ISO6391: validators.isISO6391,
+    ISO8601: validators.isISO8601,
+    RFC3339: validators.isRFC3339,
+    ISO31661Alpha2: validators.isISO31661Alpha2,
+    ISO31661Alpha3: validators.isISO31661Alpha3,
+    ISO4217: validators.isISO4217,
+    base32: validators.isBase32,
+    base58: validators.isBase58,
+    base64: validators.isBase64,
+    dataURI: validators.isDataURI,
+    magnetURI: validators.isMagnetURI,
+    mimeType: validators.isMimeType,
+    latLong: validators.isLatLong,
+    slug: validators.isSlug,
+    strongPassword: validators.isStrongPassword,
+    taxID: validators.isTaxID,
+    licensePlate: validators.isLicensePlate,
+    VAT: validators.isVAT,
     code: () => true,
     javascript: () => true,
     typescript: () => true,
@@ -81,58 +75,57 @@ const formatPatterns = {
 };
 const validateString = (args, value) => {
     if (typeof value !== 'string') {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return false;
     }
     if (args.fieldSchema.minLength && value.length < args.fieldSchema.minLength) {
-        args.error(error_1.ParseError.subceedsMinimum);
+        args.error(ParseError.subceedsMinimum);
         return false;
     }
     if (args.fieldSchema.maxLength && value.length > args.fieldSchema.maxLength) {
-        args.error(error_1.ParseError.exceedsMaximum);
+        args.error(ParseError.exceedsMaximum);
         return false;
     }
     if (args.fieldSchema.pattern) {
         const re = new RegExp(args.fieldSchema.pattern);
         if (!re.test(value)) {
-            args.error(error_1.ParseError.incorrectFormat);
+            args.error(ParseError.incorrectFormat);
             return false;
         }
     }
     if (args.fieldSchema.format &&
         !formatPatterns[args.fieldSchema.format](value)) {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return false;
     }
     return true;
 };
-const string = async (args) => {
+export const string = async (args) => {
     if (!validateString(args, args.value)) {
         return;
     }
     args.collect();
 };
-exports.string = string;
 // --- bla
 // if typeof === string
-const text = async (args) => {
+export const text = async (args) => {
     const value = args.value;
     args.stop();
     if (value === null) {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return;
     }
     if (typeof value === 'object') {
         for (const key in value) {
             if (key === '$merge') {
                 if (typeof value.$merge !== 'boolean') {
-                    args.error(error_1.ParseError.incorrectFormat);
+                    args.error(ParseError.incorrectFormat);
                     return;
                 }
             }
             else if (key === '$delete') {
                 if (value[key] !== true) {
-                    args.error(error_1.ParseError.incorrectFormat);
+                    args.error(ParseError.incorrectFormat);
                     return;
                 }
                 args.collect({ $delete: true });
@@ -148,13 +141,13 @@ const text = async (args) => {
             }
             else if (key === '$default') {
                 if (value[key] === null) {
-                    args.error(error_1.ParseError.incorrectFormat);
+                    args.error(ParseError.incorrectFormat);
                     return;
                 }
                 if (typeof value[key] === 'object') {
                     for (const k in value[key]) {
                         if (!validateString(args, args.value[key][k])) {
-                            args.error(error_1.ParseError.incorrectFormat);
+                            args.error(ParseError.incorrectFormat);
                             return;
                         }
                         args
@@ -167,15 +160,15 @@ const text = async (args) => {
                     }
                 }
                 else if (typeof value[key] !== 'string') {
-                    args.error(error_1.ParseError.incorrectFormat);
+                    args.error(ParseError.incorrectFormat);
                     return;
                 }
                 else if (!args.target.$language) {
-                    args.error(error_1.ParseError.noLanguageFound);
+                    args.error(ParseError.noLanguageFound);
                     return;
                 }
                 else if (!validateString(args, value[key])) {
-                    args.error(error_1.ParseError.incorrectFormat);
+                    args.error(ParseError.incorrectFormat);
                     return;
                 }
                 else {
@@ -195,7 +188,7 @@ const text = async (args) => {
                     for (const k in value[key]) {
                         if (k === '$delete') {
                             if (value[key].$delete !== true) {
-                                args.error(error_1.ParseError.incorrectFormat);
+                                args.error(ParseError.incorrectFormat);
                                 return;
                             }
                             args
@@ -208,7 +201,7 @@ const text = async (args) => {
                         }
                         else if (k === '$value') {
                             if (!validateString(args, value[key].$value)) {
-                                args.create({ key }).error(error_1.ParseError.incorrectFormat);
+                                args.create({ key }).error(ParseError.incorrectFormat);
                             }
                             else {
                                 args
@@ -222,7 +215,7 @@ const text = async (args) => {
                         }
                         else if (k === '$default') {
                             if (!validateString(args, value[key].$default)) {
-                                args.create({ key }).error(error_1.ParseError.incorrectFormat);
+                                args.create({ key }).error(ParseError.incorrectFormat);
                             }
                             else {
                                 args
@@ -237,14 +230,14 @@ const text = async (args) => {
                         else {
                             args
                                 .create({ path: [...args.path, key, k] })
-                                .error(error_1.ParseError.fieldDoesNotExist);
+                                .error(ParseError.fieldDoesNotExist);
                             return;
                         }
                     }
                 }
                 else {
                     if (!validateString(args, args.value[key])) {
-                        args.error(error_1.ParseError.incorrectFormat);
+                        args.error(ParseError.incorrectFormat);
                         return;
                     }
                     args
@@ -257,7 +250,7 @@ const text = async (args) => {
                 }
             }
             else {
-                args.create({ key }).error(error_1.ParseError.languageNotSupported);
+                args.create({ key }).error(ParseError.languageNotSupported);
             }
         }
         if (!args._stopObject) {
@@ -266,15 +259,15 @@ const text = async (args) => {
         return;
     }
     if (typeof value !== 'string') {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return;
     }
     if (!args.target.$language) {
-        args.error(error_1.ParseError.noLanguageFound);
+        args.error(ParseError.noLanguageFound);
         return;
     }
     if (!validateString(args, args.value)) {
-        args.error(error_1.ParseError.incorrectFormat);
+        args.error(ParseError.incorrectFormat);
         return;
     }
     args
@@ -290,5 +283,4 @@ const text = async (args) => {
         });
     }
 };
-exports.text = text;
 //# sourceMappingURL=string.js.map

package/dist/{set → src/set}/index.d.ts

@@ -1,3 +1,3 @@
-import { BasedSchema, BasedSetTarget } from '../types';
-import { AsyncOperation } from '../walker';
+import { BasedSchema, BasedSetTarget } from '../types.js';
+import { AsyncOperation } from '../walker/index.js';
 export declare const setWalker: (schema: BasedSchema, value: any, asyncOperationHandler?: AsyncOperation<BasedSetTarget>) => Promise<BasedSetTarget>;

package/dist/{set → src/set}/index.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setWalker = void 0;
-const error_1 = require("../error");
-const walker_1 = require("../walker");
-const fields_1 = require("./fields");
-const isValidId_1 = require("./isValidId");
+import { ParseError } from '../error.js';
+import { walk } from '../walker/index.js';
+import { fields } from './fields/index.js';
+import { isValidId } from './isValidId.js';
 const opts = {
     parsers: {
         keys: {
             $delete: async (args) => {
                 if (args.prev === args.root) {
-                    args.error(error_1.ParseError.cannotDeleteNodeFromModify);
+                    args.error(ParseError.cannotDeleteNodeFromModify);
                     return;
                 }
                 if (args.value === true) {
@@ -24,19 +21,19 @@ const opts = {
                 if (Array.isArray(args.value)) {
                     for (const field of args.value) {
                         if (typeof field !== 'string') {
-                            args.error(error_1.ParseError.incorrectFormat);
+                            args.error(ParseError.incorrectFormat);
                             return;
                         }
                     }
                     return;
                 }
                 if (typeof args.value !== 'string') {
-                    args.error(error_1.ParseError.incorrectFormat);
+                    args.error(ParseError.incorrectFormat);
                 }
             },
             $merge: async (args) => {
                 if (typeof args.value !== 'boolean') {
-                    args.error(error_1.ParseError.incorrectFormat);
+                    args.error(ParseError.incorrectFormat);
                     return;
                 }
                 if (args.prev !== args.root) {
@@ -45,8 +42,8 @@ const opts = {
                 return;
             },
             $id: async (args) => {
-                if (!(0, isValidId_1.isValidId)(args.schema, args.value)) {
-                    args.error(error_1.ParseError.incorrectFormat);
+                if (!isValidId(args.schema, args.value)) {
+                    args.error(ParseError.incorrectFormat);
                     return;
                 }
             },
@@ -54,7 +51,7 @@ const opts = {
                 if (!(args.schema.translations || [])
                     .concat(args.schema.language)
                     .includes(args.value)) {
-                    args.error(error_1.ParseError.languageNotSupported);
+                    args.error(ParseError.languageNotSupported);
                     return;
                 }
             },
@@ -66,7 +63,7 @@ const opts = {
                 args.prev.stop();
                 args.stop();
                 if (args.prev.value.$default) {
-                    args.error(error_1.ParseError.valueAndDefault);
+                    args.error(ParseError.valueAndDefault);
                     return;
                 }
                 return {
@@ -109,14 +106,14 @@ const opts = {
                 }
                 for (const key in args.prev.value) {
                     if (key !== '$default') {
-                        args.prev.create({ key }).error(error_1.ParseError.fieldDoesNotExist);
+                        args.prev.create({ key }).error(ParseError.fieldDoesNotExist);
                     }
                 }
             },
         },
-        fields: fields_1.fields,
+        fields,
         catch: async (args) => {
-            args.error(error_1.ParseError.fieldDoesNotExist);
+            args.error(ParseError.fieldDoesNotExist);
         },
     },
     init: async (value, schema, error) => {
@@ -136,7 +133,7 @@ const opts = {
                 type = schema.prefixToTypeMapping[value.$id.slice(0, 2)];
             }
             if (!type) {
-                error(error_1.ParseError.incorrectFieldType, { target });
+                error(ParseError.incorrectFieldType, { target });
                 return { target };
             }
         }
@@ -145,14 +142,14 @@ const opts = {
         }
         if (value.type) {
             if (type && value.type !== type) {
-                error(error_1.ParseError.incorrectNodeType, { target });
+                error(ParseError.incorrectNodeType, { target });
                 return { target };
             }
             type = value.type;
         }
         const typeSchema = type === 'root' ? schema.root : schema.types[type];
         if (!typeSchema) {
-            error(error_1.ParseError.incorrectNodeType, { target });
+            error(ParseError.incorrectNodeType, { target });
             return { target };
         }
         target.type = type;
@@ -160,7 +157,7 @@ const opts = {
         target.$id = value.$id;
         if ('$merge' in value) {
             if (typeof value.$merge !== 'boolean') {
-                error(error_1.ParseError.incorrectFormat, { target });
+                error(ParseError.incorrectFormat, { target });
             }
             target.$merge = value.$merge;
         }
@@ -176,8 +173,7 @@ const opts = {
         args.root.target.collected.push(args);
     },
 };
-const setWalker = (schema, value, asyncOperationHandler) => {
-    return (0, walker_1.walk)(schema, opts, value, asyncOperationHandler);
+export const setWalker = (schema, value, asyncOperationHandler) => {
+    return walk(schema, opts, value, asyncOperationHandler);
 };
-exports.setWalker = setWalker;
 //# sourceMappingURL=index.js.map

package/dist/{set → src/set}/isValidId.d.ts

@@ -1,2 +1,2 @@
-import { BasedSchema } from '../types';
+import { BasedSchema } from '../types.js';
 export declare const isValidId: (schema: BasedSchema, id: any) => boolean;

package/dist/{set → src/set}/isValidId.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidId = void 0;
-const isValidId = (schema, id) => {
+export const isValidId = (schema, id) => {
     if (typeof id !== 'string') {
         return false;
     }
@@ -17,5 +14,4 @@ const isValidId = (schema, id) => {
     }
     return true;
 };
-exports.isValidId = isValidId;
 //# sourceMappingURL=isValidId.js.map

package/dist/{types.d.ts → src/types.d.ts}

@@ -1,10 +1,10 @@
-import type { Language } from './languages';
+import type { Language } from './languages.js';
 import type { PartialDeep } from 'type-fest';
-import { ParseError } from './error';
-import { ArgsClass, Path } from './walker';
-import { StringFormat } from './display/string';
-import { NumberFormat } from './display/number';
-import { DateFormat } from './display/timestamp';
+import { ParseError } from './error.js';
+import { ArgsClass, Path } from './walker/index.js';
+import { StringFormat } from './display/string.js';
+import { NumberFormat } from './display/number.js';
+import { DateFormat } from './display/timestamp.js';
 export type AllowedTypes = (string | {
     type?: string;
     $filter: any | any[];
@@ -121,6 +121,7 @@ export type BasedSchemaFieldReference = {
     bidirectional?: {
         fromField: string;
     };
+    sortable?: boolean;
     allowedTypes?: AllowedTypes;
 } & BasedSchemaFieldShared;
 export type BasedSchemaFieldReferences = {

package/dist/src/types.js

@@ -0,0 +1,23 @@
+import { languages as allLanguages } from './languages.js';
+export const basedSchemaFieldTypes = [
+    'array',
+    'object',
+    'record',
+    'set',
+    'string',
+    'boolean',
+    'number',
+    'json',
+    'integer',
+    'timestamp',
+    'reference',
+    'references',
+    'text',
+    'enum',
+    'cardinality',
+];
+export const isCollection = (type) => {
+    return type === 'array' || type === 'object' || type === 'record';
+};
+export const languages = Object.keys(allLanguages);
+//# sourceMappingURL=types.js.map

package/dist/src/updateSchema.d.ts

@@ -0,0 +1,2 @@
+import { BasedSchema, BasedSchemaPartial } from './types.js';
+export declare const updateSchema: (_newSchema: BasedSchemaPartial, oldSchema?: BasedSchema) => Promise<BasedSchema>;

package/dist/src/updateSchema.js

@@ -0,0 +1,12 @@
+export const updateSchema = async (_newSchema, oldSchema = {
+    $defs: {},
+    types: {},
+    language: 'en',
+    root: { fields: {} },
+    prefixToTypeMapping: {},
+}) => {
+    // add sha
+    // put isRequired on the new schema in REQUIRED arrays
+    return oldSchema;
+};
+//# sourceMappingURL=updateSchema.js.map

package/dist/src/validateSchema.d.ts

@@ -0,0 +1,4 @@
+import { BasedSchemaPartial, BasedSchemaFieldPartial, BasedSchemaTypePartial } from './types.js';
+export declare const validateType: (_fromSchema: BasedSchemaPartial, typeName: string, type: BasedSchemaTypePartial) => void;
+export declare const validateField: (_fromSchema: BasedSchemaPartial, _path: string[], _field: BasedSchemaFieldPartial) => void;
+export declare const validateSchema: (schema: BasedSchemaPartial) => BasedSchemaPartial;

package/dist/{validateSchema.js → src/validateSchema.js}

@@ -1,19 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSchema = exports.validateField = exports.validateType = void 0;
 // gaurd in the schema for refs in arrays
-const validateType = (fromSchema, typeName, type) => {
+export const validateType = (_fromSchema, typeName, type) => {
     if (type.prefix &&
         (typeof type.prefix !== 'string' || type.prefix.length !== 2)) {
         throw new Error(`Incorrect prefix "${type.prefix}" for type "${typeName}" has to be a string of 2 alphanumerical characters e.g. "Az", "ab", "cc", "10"`);
     }
 };
-exports.validateType = validateType;
-const validateField = (fromSchema, path, field) => {
+export const validateField = (_fromSchema, _path, _field) => {
     //
 };
-exports.validateField = validateField;
-const validateSchema = (schema) => {
+export const validateSchema = (schema) => {
     // rewrite schema things like required / required: []
     if (typeof schema !== 'object') {
         throw new Error('Schema is not an object');
@@ -28,14 +23,13 @@ const validateSchema = (schema) => {
         // first defs ofc
     }
     if (schema.root) {
-        (0, exports.validateType)(schema, 'root', schema.root);
+        validateType(schema, 'root', schema.root);
     }
     if (schema.types) {
         for (const type in schema.types) {
-            (0, exports.validateType)(schema, type, schema.types[type]);
+            validateType(schema, type, schema.types[type]);
         }
     }
     return schema;
 };
-exports.validateSchema = validateSchema;
 //# sourceMappingURL=validateSchema.js.map

package/dist/{walker → src/walker}/args.d.ts

@@ -1,7 +1,7 @@
-import { BasedSchema } from '../types';
-import { BasedSchemaType, BasedSchemaFields } from '../types';
-import { ArgsOpts, Path, Opts, Stopped, Collect } from './types';
-import { ParseError } from '../error';
+import { BasedSchema } from '../types.js';
+import { BasedSchemaType, BasedSchemaFields } from '../types.js';
+import { ArgsOpts, Path, Opts, Stopped, Collect } from './types.js';
+import { ParseError } from '../error.js';
 export declare class ArgsClass<T, K extends keyof BasedSchemaFields = keyof BasedSchemaFields> {
     errors: any[];
     id: number;

package/dist/{walker → src/walker}/args.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgsClass = void 0;
-const types_1 = require("./types");
-const parse_1 = require("./parse");
-const utils_1 = require("@saulx/utils");
+import { Stopped } from './types.js';
+import { parse } from './parse.js';
+import { deepEqual } from '@saulx/utils';
 let id = 0;
-class ArgsClass {
+export class ArgsClass {
     constructor(opts, prev) {
         this.id = ++id;
         this.fromBackTrack = [];
@@ -81,10 +78,10 @@ class ArgsClass {
     stop(onllyStopFieldSchemaParser) {
         const target = this;
         if (onllyStopFieldSchemaParser) {
-            target.stopped = types_1.Stopped.onlyStopFieldParser;
+            target.stopped = Stopped.onlyStopFieldParser;
         }
         else {
-            target.stopped = types_1.Stopped.stopAll;
+            target.stopped = Stopped.stopAll;
         }
     }
     create(opts) {
@@ -102,7 +99,7 @@ class ArgsClass {
     }
     async parse(opts) {
         if (!opts) {
-            return (0, parse_1.parse)(this);
+            return parse(this);
         }
         else {
             const newArgs = new ArgsClass(opts, this);
@@ -126,7 +123,7 @@ class ArgsClass {
         let p = this;
         while (p) {
             if (p.prev) {
-                if ((0, utils_1.deepEqual)(p.prev.path, p.path)) {
+                if (deepEqual(p.prev.path, p.path)) {
                     p = p.prev;
                 }
                 else {
@@ -158,5 +155,4 @@ class ArgsClass {
         this.root._opts.error(code, this);
     }
 }
-exports.ArgsClass = ArgsClass;
 //# sourceMappingURL=args.js.map