schema-markdown 1.3.0 → 1.3.1

package/lib/encode.js

@@ -108,9 +108,14 @@ export function decodeQueryString(paramStr) {
                     parent[keyParent] = obj;
                 }
 
-                // Create the index for this key
-                if (!(key in obj)) {
-                    obj[key] = null;
+                // Create the index for this key - check own properties only, and define "__proto__"
+                // directly since assignment would invoke the prototype setter
+                if (!Object.hasOwn(obj, key)) {
+                    if (key === '__proto__') {
+                        Object.defineProperty(obj, key, {'value': null, 'enumerable': true, 'writable': true, 'configurable': true});
+                    } else {
+                        obj[key] = null;
+                    }
                 }
             }
 

package/lib/parser.js

@@ -49,6 +49,7 @@ const rValue = new RegExp(`^\\s+(?<id>${rPartId})\\s*$`);
 const rValueQuoted = /^\s+"(?<id>.*?)"\s*$/;
 const rURL = /^\s+(?<method>[A-Za-z]+|\*)(?:\s+(?<path>\/\S*))?/;
 const rLineSplit = /\r?\n/;
+const rIndent = /^\s/;
 
 
 /**
@@ -107,7 +108,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
         linenum += 1;
 
         // Line continuation?
-        const linePartNoContinuation = linePart.replace(rLineCont, '');
+        const linePartNoContinuation = linePart.includes('\\') ? linePart.replace(rLineCont, '') : linePart;
         if (lineContinuation.length || linePartNoContinuation !== linePart) {
             lineContinuation.push(linePartNoContinuation);
         }
@@ -122,47 +123,49 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             line = linePart;
         }
 
-        // Match syntax
+        // Match syntax - each regex is guarded by a cheap string test that only skips it when it cannot match
+        const lineIndented = rIndent.test(line);
+        const lineTrimmed = line.trim();
         let matchName = 'comment';
-        let match = line.match(rComment);
+        let match = (lineTrimmed === '' || lineTrimmed.startsWith('#')) ? line.match(rComment) : null;
         if (match === null) {
             matchName = 'group';
-            match = line.match(rGroup);
+            match = line.startsWith('group') ? line.match(rGroup) : null;
         }
         if (match === null) {
             matchName = 'action';
-            match = line.match(rAction);
+            match = line.startsWith('action') ? line.match(rAction) : null;
         }
         if (match === null) {
             matchName = 'definition';
-            match = line.match(rDefinition);
+            match = (line.startsWith('struct') || line.startsWith('union') || line.startsWith('enum')) ? line.match(rDefinition) : null;
         }
-        if (match === null && action !== null) {
+        if (match === null && action !== null && lineIndented) {
             matchName = 'section';
             match = line.match(rSection);
         }
-        if (match === null && action !== null) {
+        if (match === null && action !== null && lineIndented) {
             matchName = 'sectionPlain';
             match = line.match(rSectionPlain);
         }
-        if (match === null && userType !== null && 'enum' in userType) {
+        if (match === null && userType !== null && 'enum' in userType && lineIndented) {
             matchName = 'value';
             match = line.match(rValue);
             if (match === null) {
                 match = line.match(rValueQuoted);
             }
         }
-        if (match === null && userType !== null && 'struct' in userType) {
+        if (match === null && userType !== null && 'struct' in userType && lineIndented) {
             matchName = 'member';
             match = line.match(rMember);
         }
-        if (match === null && urls !== null) {
+        if (match === null && urls !== null && lineIndented) {
             matchName = 'urls';
             match = line.match(rURL);
         }
         if (match === null) {
             matchName = 'typedef';
-            match = line.match(rTypedef);
+            match = line.startsWith('typedef') ? line.match(rTypedef) : null;
         }
         if (match === null) {
             matchName = null;
@@ -189,7 +192,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             const actionId = match.groups.id;
 
             // Action already defined?
-            if (actionId in types) {
+            if (Object.hasOwn(types, actionId)) {
                 addError(`Redefinition of action '${actionId}'`, filename, linenum);
             }
 
@@ -215,7 +218,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             const definitionBaseIds = match.groups.baseIds;
 
             // Type already defined?
-            if (builtinTypes.has(definitionId) || definitionId in builtinDeprecated || definitionId in types) {
+            if (builtinTypes.has(definitionId) || Object.hasOwn(builtinDeprecated, definitionId) || Object.hasOwn(types, definitionId)) {
                 addError(`Redefinition of type '${definitionId}'`, filename, linenum);
             }
 
@@ -394,7 +397,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
             const definitionId = match.groups.id;
 
             // Type already defined?
-            if (builtinTypes.has(definitionId) || definitionId in builtinDeprecated || definitionId in types) {
+            if (builtinTypes.has(definitionId) || Object.hasOwn(builtinDeprecated, definitionId) || Object.hasOwn(types, definitionId)) {
                 addError(`Redefinition of type '${definitionId}'`, filename, linenum);
             }
 
@@ -449,7 +452,7 @@ export function parseSchemaMarkdown(text, {types = {}, filename = '', validate =
                 errorLinenum = filepos[`${typeName}.${memberName}`] ?? null;
             }
             if (errorLinenum === null) {
-                errorLinenum = filepos[typeName] ?? null;
+                errorLinenum = Object.hasOwn(filepos, typeName) ? filepos[typeName] : null;
             }
             if (errorLinenum === null) {
                 errorFilename = '';
@@ -527,7 +530,7 @@ function parseTypedef(matchTypedef) {
 
 // Helper function to create a type model
 function createType(typeName) {
-    if (typeName in builtinDeprecated) {
+    if (Object.hasOwn(builtinDeprecated, typeName)) {
         return {'builtin': builtinDeprecated[typeName]};
     }
     if (builtinTypes.has(typeName)) {

package/lib/schema.js

@@ -39,9 +39,9 @@ function getReferencedTypesHelper(types, type, referencedTypes) {
         const typeName = type.user;
 
         // Already encountered?
-        if (!(typeName in referencedTypes)) {
-            const userType = types[typeName];
-            referencedTypes[typeName] = userType;
+        if (!Object.hasOwn(referencedTypes, typeName)) {
+            const userType = getUserType(types, typeName);
+            setValue(referencedTypes, typeName, userType);
 
             // Struct?
             if ('struct' in userType) {
@@ -116,6 +116,27 @@ export class ValidationError extends Error {
 }
 
 
+// Helper to look up a user type by name - throws ValidationError for unknown type names
+function getUserType(types, typeName) {
+    const userType = Object.hasOwn(types, typeName) ? types[typeName] : null;
+    if (userType === null) {
+        throw new ValidationError(`Unknown type "${typeName}"`);
+    }
+    return userType;
+}
+
+
+// Helper to set an own property on a plain-object copy - the "__proto__" key is defined directly
+// since assignment would invoke the inherited prototype setter instead of creating an own property
+function setValue(obj, key, value) {
+    if (key === '__proto__') {
+        Object.defineProperty(obj, key, {'value': value, 'enumerable': true, 'writable': true, 'configurable': true});
+    } else {
+        obj[key] = value;
+    }
+}
+
+
 /**
  * Type-validate a value using a user type model. Container values are duplicated since some member types are
  * transformed during validation.
@@ -134,9 +155,6 @@ export class ValidationError extends Error {
  * @throws [ValidationError]{@link module:lib/schema.ValidationError}
  */
 export function validateType(types, typeName, value, memberFqn = null) {
-    if (!(typeName in types)) {
-        throw new ValidationError(`Unknown type "${typeName}"`);
-    }
     return validateTypeHelper(types, {'user': typeName}, value, memberFqn);
 }
 
@@ -147,6 +165,10 @@ const rDatetime = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T\d{2}:\d{2}(?::
 const rUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 
+// Default dict key type used by validateTypeHelper
+const defaultDictKeyType = {'builtin': 'string'};
+
+
 function validateTypeHelper(types, type, value, memberFqn) {
     let valueNew = value;
 
@@ -161,15 +183,6 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 throwMemberError(type, value, memberFqn);
             }
 
-        // uuid?
-        } else if (builtin === 'uuid') {
-            if (typeof value !== 'string') {
-                throwMemberError(type, value, memberFqn);
-            }
-            if (!rUuid.test(value)) {
-                throwMemberError(type, value, memberFqn);
-            }
-
         // int or float?
         } else if (builtin === 'int' || builtin === 'float') {
             // Convert string?
@@ -253,6 +266,15 @@ function validateTypeHelper(types, type, value, memberFqn) {
             } else if (!(value instanceof Date)) {
                 throwMemberError(type, value, memberFqn);
             }
+
+        // uuid?
+        } else if (builtin === 'uuid') {
+            if (typeof value !== 'string') {
+                throwMemberError(type, value, memberFqn);
+            }
+            if (!rUuid.test(value)) {
+                throwMemberError(type, value, memberFqn);
+            }
         }
 
     // array?
@@ -271,13 +293,15 @@ function validateTypeHelper(types, type, value, memberFqn) {
         const valueCopy = [];
         const arrayValueNullable = arrayAttr !== null && 'nullable' in arrayAttr && arrayAttr.nullable;
         for (let ixArrayValue = 0; ixArrayValue < valueNew.length; ixArrayValue++) {
-            const memberFqnValue = memberFqn !== null ? `${memberFqn}.${ixArrayValue}` : `${ixArrayValue}`;
+            const memberFqnValue = [memberFqn, ixArrayValue];
             let arrayValue = valueNew[ixArrayValue];
             if (arrayValueNullable && (arrayValue === null || arrayValue === 'null')) {
                 arrayValue = null;
             } else {
                 arrayValue = validateTypeHelper(types, arrayType, arrayValue, memberFqnValue);
-                validateAttr(arrayType, arrayAttr, arrayValue, memberFqnValue);
+                if (arrayAttr !== null) {
+                    validateAttr(arrayType, arrayAttr, arrayValue, memberFqnValue);
+                }
             }
             valueCopy.push(arrayValue);
         }
@@ -291,7 +315,7 @@ function validateTypeHelper(types, type, value, memberFqn) {
         const {dict} = type;
         const dictType = dict.type;
         const dictAttr = 'attr' in dict ? dict.attr : null;
-        const dictKeyType = 'keyType' in dict ? dict.keyType : {'builtin': 'string'};
+        const dictKeyType = 'keyType' in dict ? dict.keyType : defaultDictKeyType;
         const dictKeyAttr = 'keyAttr' in dict ? dict.keyAttr : null;
         if (value === '') {
             valueNew = {};
@@ -300,18 +324,21 @@ function validateTypeHelper(types, type, value, memberFqn) {
         }
 
         // Validate the dict key/value pairs
-        const valueCopy = valueNew instanceof Map ? new Map() : {};
+        const isMap = valueNew instanceof Map;
+        const valueCopy = isMap ? new Map() : {};
         const dictKeyNullable = dictKeyAttr !== null && 'nullable' in dictKeyAttr && dictKeyAttr.nullable;
         const dictValueNullable = dictAttr !== null && 'nullable' in dictAttr && dictAttr.nullable;
-        for (let [dictKey, dictValue] of (valueNew instanceof Map ? valueNew.entries() : Object.entries(valueNew))) {
-            const memberFqnKey = memberFqn !== null ? `${memberFqn}.${dictKey}` : `${dictKey}`;
+        for (let [dictKey, dictValue] of (isMap ? valueNew.entries() : Object.entries(valueNew))) {
+            const memberFqnKey = [memberFqn, dictKey];
 
             // Validate the key
             if (dictKeyNullable && (dictKey === null || dictKey === 'null')) {
                 dictKey = null;
             } else {
                 dictKey = validateTypeHelper(types, dictKeyType, dictKey, memberFqn);
-                validateAttr(dictKeyType, dictKeyAttr, dictKey, memberFqn);
+                if (dictKeyAttr !== null) {
+                    validateAttr(dictKeyType, dictKeyAttr, dictKey, memberFqn);
+                }
             }
 
             // Validate the value
@@ -319,14 +346,16 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 dictValue = null;
             } else {
                 dictValue = validateTypeHelper(types, dictType, dictValue, memberFqnKey);
-                validateAttr(dictType, dictAttr, dictValue, memberFqnKey);
+                if (dictAttr !== null) {
+                    validateAttr(dictType, dictAttr, dictValue, memberFqnKey);
+                }
             }
 
             // Copy the key/value
-            if (valueCopy instanceof Map) {
+            if (isMap) {
                 valueCopy.set(dictKey, dictValue);
             } else {
-                valueCopy[dictKey] = dictValue;
+                setValue(valueCopy, dictKey, dictValue);
             }
         }
 
@@ -335,7 +364,7 @@ function validateTypeHelper(types, type, value, memberFqn) {
 
     // User type?
     } else if ('user' in type) {
-        const userType = types[type.user];
+        const userType = getUserType(types, type.user);
 
         // action?
         if ('action' in userType) {
@@ -353,7 +382,9 @@ function validateTypeHelper(types, type, value, memberFqn) {
                 valueNew = null;
             } else {
                 valueNew = validateTypeHelper(types, typedef.type, value, memberFqn);
-                validateAttr(type, typedefAttr, valueNew, memberFqn);
+                if (typedefAttr !== null) {
+                    validateAttr(type, typedefAttr, valueNew, memberFqn);
+                }
             }
 
         // enum?
@@ -377,52 +408,58 @@ function validateTypeHelper(types, type, value, memberFqn) {
             }
 
             // Valid union?
+            const isMap = valueNew instanceof Map;
             const isUnion = 'union' in struct ? struct.union : false;
             if (isUnion) {
-                if (Object.keys(value).length !== 1) {
+                if ((isMap ? valueNew.size : Object.keys(valueNew).length) !== 1) {
                     throwMemberError({'user': struct.name}, value, memberFqn);
                 }
             }
 
             // Validate the struct members
-            const valueCopy = valueNew instanceof Map ? new Map() : {};
+            const valueCopy = isMap ? new Map() : {};
             for (const member of getStructMembers(types, struct)) {
                 const memberName = member.name;
-                const memberFqnMember = memberFqn !== null ? `${memberFqn}.${memberName}` : `${memberName}`;
+                const memberFqnMember = [memberFqn, memberName];
                 const memberOptional = 'optional' in member && member.optional;
-                const memberNullable = 'attr' in member && 'nullable' in member.attr && member.attr.nullable;
+                const memberAttr = 'attr' in member ? member.attr : null;
+                const memberNullable = memberAttr !== null && 'nullable' in memberAttr && memberAttr.nullable;
 
-                // Missing non-optional member?
-                if (!(valueNew instanceof Map ? valueNew.has(memberName) : memberName in valueNew)) {
+                // Missing non-optional member? Check own properties only - "in" matches inherited
+                // Object.prototype properties for member names like "constructor"
+                if (!(isMap ? valueNew.has(memberName) : Object.hasOwn(valueNew, memberName))) {
                     if (!memberOptional && !isUnion) {
-                        throw new ValidationError(`Required member "${memberFqnMember}" missing`);
+                        throw new ValidationError(`Required member "${memberFqnStr(memberFqnMember)}" missing`);
                     }
                 } else {
                     // Validate the member value
-                    let memberValue = valueNew instanceof Map ? valueNew.get(memberName) : valueNew[memberName];
+                    let memberValue = isMap ? valueNew.get(memberName) : valueNew[memberName];
                     if (memberNullable && (memberValue === null || memberValue === 'null')) {
                         memberValue = null;
                     } else {
                         memberValue = validateTypeHelper(types, member.type, memberValue, memberFqnMember);
-                        validateAttr(member.type, 'attr' in member ? member.attr : null, memberValue, memberFqnMember);
+                        if (memberAttr !== null) {
+                            validateAttr(member.type, memberAttr, memberValue, memberFqnMember);
+                        }
                     }
 
                     // Copy the validated member
-                    if (valueCopy instanceof Map) {
+                    if (isMap) {
                         valueCopy.set(memberName, memberValue);
                     } else {
-                        valueCopy[memberName] = memberValue;
+                        setValue(valueCopy, memberName, memberValue);
                     }
                 }
             }
 
             // Any unknown members?
-            const valueCopyKeys = valueCopy instanceof Map ? Array.from(valueCopy.keys()) : Object.keys(valueCopy);
-            const valueNewKeys = valueNew instanceof Map ? Array.from(valueNew.keys()) : Object.keys(valueNew);
-            if (valueCopyKeys.length !== valueNewKeys.length) {
+            const valueCopyCount = isMap ? valueCopy.size : Object.keys(valueCopy).length;
+            const valueNewCount = isMap ? valueNew.size : Object.keys(valueNew).length;
+            if (valueCopyCount !== valueNewCount) {
                 const memberSet = new Set(getStructMembers(types, struct).map((member) => member.name));
+                const valueNewKeys = isMap ? Array.from(valueNew.keys()) : Object.keys(valueNew);
                 const [unknownKey] = valueNewKeys.filter((key) => !memberSet.has(key));
-                const unknownFqn = memberFqn !== null ? `${memberFqn}.${unknownKey}` : `${unknownKey}`;
+                const unknownFqn = memberFqnStr([memberFqn, unknownKey]);
                 throw new ValidationError(`Unknown member "${unknownFqn.slice(0, 100)}"`);
             }
 
@@ -435,36 +472,56 @@ function validateTypeHelper(types, type, value, memberFqn) {
 }
 
 
+// Helper to materialize a member's fully-qualified name string. For performance, member FQNs are
+// built lazily as [parent, key] pairs and only converted to strings on error.
+function memberFqnStr(memberFqn) {
+    if (memberFqn === null || typeof memberFqn === 'string') {
+        return memberFqn;
+    }
+    const parts = [];
+    let fqnPart = memberFqn;
+    while (Array.isArray(fqnPart)) {
+        parts.push(`${fqnPart[1]}`);
+        [fqnPart] = fqnPart;
+    }
+    if (fqnPart !== null) {
+        parts.push(`${fqnPart}`);
+    }
+    parts.reverse();
+    return parts.join('.');
+}
+
+
 function throwMemberError(type, value, memberFqn, attr = null) {
-    const memberPart = memberFqn !== null ? ` for member "${memberFqn}"` : '';
+    const memberFqnValue = memberFqnStr(memberFqn);
+    const memberPart = memberFqnValue ? ` for member "${memberFqnValue}"` : '';
     const typeName = 'builtin' in type ? type.builtin : ('array' in type ? 'array' : ('dict' in type ? 'dict' : type.user));
     const attrPart = attr !== null ? ` [${attr}]` : '';
     const valueStr = `${JSON.stringify(value)}`;
     const msg = `Invalid value ${valueStr.slice(0, 100)} (type "${typeof value}")${memberPart}, expected type "${typeName}"${attrPart}`;
-    throw new ValidationError(msg, memberFqn);
+    throw new ValidationError(msg, memberFqnValue);
 }
 
 
 function validateAttr(type, attr, value, memberFqn) {
-    if (attr !== null) {
+    if ('eq' in attr && !(value === attr.eq)) {
+        throwMemberError(type, value, memberFqn, `== ${attr.eq}`);
+    }
+    if ('lt' in attr && !(value < attr.lt)) {
+        throwMemberError(type, value, memberFqn, `< ${attr.lt}`);
+    }
+    if ('lte' in attr && !(value <= attr.lte)) {
+        throwMemberError(type, value, memberFqn, `<= ${attr.lte}`);
+    }
+    if ('gt' in attr && !(value > attr.gt)) {
+        throwMemberError(type, value, memberFqn, `> ${attr.gt}`);
+    }
+    if ('gte' in attr && !(value >= attr.gte)) {
+        throwMemberError(type, value, memberFqn, `>= ${attr.gte}`);
+    }
+    if ('lenEq' in attr || 'lenLT' in attr || 'lenLTE' in attr || 'lenGT' in attr || 'lenGTE' in attr) {
         const length = Array.isArray(value) || typeof value === 'string' ? value.length
-            : (typeof value === 'object' ? Object.keys(value).length : null);
-
-        if ('eq' in attr && !(value === attr.eq)) {
-            throwMemberError(type, value, memberFqn, `== ${attr.eq}`);
-        }
-        if ('lt' in attr && !(value < attr.lt)) {
-            throwMemberError(type, value, memberFqn, `< ${attr.lt}`);
-        }
-        if ('lte' in attr && !(value <= attr.lte)) {
-            throwMemberError(type, value, memberFqn, `<= ${attr.lte}`);
-        }
-        if ('gt' in attr && !(value > attr.gt)) {
-            throwMemberError(type, value, memberFqn, `> ${attr.gt}`);
-        }
-        if ('gte' in attr && !(value >= attr.gte)) {
-            throwMemberError(type, value, memberFqn, `>= ${attr.gte}`);
-        }
+            : (value instanceof Map ? value.size : (typeof value === 'object' ? Object.keys(value).length : null));
         if ('lenEq' in attr && !(length === attr.lenEq)) {
             throwMemberError(type, value, memberFqn, `len == ${attr.lenEq}`);
         }
@@ -501,9 +558,9 @@ export function getStructMembers(types, struct) {
     // Get base struct members
     const members = [];
     for (const base of struct.bases) {
-        let baseUserType = types[base];
+        let baseUserType = getUserType(types, base);
         while ('typedef' in baseUserType) {
-            baseUserType = types[baseUserType.typedef.type.user];
+            baseUserType = getUserType(types, baseUserType.typedef.type.user);
         }
         members.push(...getStructMembers(types, baseUserType.struct));
     }
@@ -534,9 +591,9 @@ export function getEnumValues(types, enum_) {
     // Get base enum values
     const values = [];
     for (const base of enum_.bases) {
-        let baseUserType = types[base];
+        let baseUserType = getUserType(types, base);
         while ('typedef' in baseUserType) {
-            baseUserType = types[baseUserType.typedef.type.user];
+            baseUserType = getUserType(types, baseUserType.typedef.type.user);
         }
         values.push(...getEnumValues(types, baseUserType.enum));
     }

package/lib/schemaUtil.js

@@ -43,13 +43,13 @@ export function validateTypeModelErrors(types) {
 
             // Iterate the members
             try {
-                const members = {};
+                const members = new Set();
                 for (const member of getStructMembers(types, struct)) {
                     const memberName = member.name;
 
                     // Duplicate member?
-                    if (!(memberName in members)) {
-                        members[memberName] = true;
+                    if (!members.has(memberName)) {
+                        members.add(memberName);
                     } else {
                         errors.push([typeName, memberName, `Redefinition of "${typeName}" member "${memberName}"`]);
                     }
@@ -82,13 +82,13 @@ export function validateTypeModelErrors(types) {
 
             // Get the enumeration values
             try {
-                const values = {};
+                const values = new Set();
                 for (const value of getEnumValues(types, enum_)) {
                     const valueName = value.name;
 
                     // Duplicate value?
-                    if (!(valueName in values)) {
-                        values[valueName] = true;
+                    if (!values.has(valueName)) {
+                        values.add(valueName);
                     } else {
                         errors.push([typeName, valueName, `Redefinition of "${typeName}" value "${valueName}"`]);
                     }
@@ -129,11 +129,11 @@ export function validateTypeModelErrors(types) {
             }
 
             // Compute effective input member counts
-            const memberSections = {};
+            const memberSections = new Map();
             for (const section of ['path', 'query', 'input']) {
                 if (section in action) {
                     const sectionTypeName = action[section];
-                    if (sectionTypeName in types) {
+                    if (Object.hasOwn(types, sectionTypeName)) {
                         const sectionUserType = getEffectiveUserType(types, sectionTypeName);
                         if (sectionUserType !== null && 'struct' in sectionUserType) {
                             const sectionStruct = sectionUserType.struct;
@@ -142,10 +142,10 @@ export function validateTypeModelErrors(types) {
                             try {
                                 for (const member of getStructMembers(types, sectionStruct)) {
                                     const memberName = member.name;
-                                    if (!(memberName in memberSections)) {
-                                        memberSections[memberName] = [];
+                                    if (!memberSections.has(memberName)) {
+                                        memberSections.set(memberName, []);
                                     }
-                                    memberSections[memberName].push(sectionStruct.name);
+                                    memberSections.get(memberName).push(sectionStruct.name);
                                 }
                             } catch {
                                 // Do nothing
@@ -156,7 +156,7 @@ export function validateTypeModelErrors(types) {
             }
 
             // Check for duplicate input members
-            for (const [memberName, memberSectionNames] of Object.entries(memberSections)) {
+            for (const [memberName, memberSectionNames] of memberSections.entries()) {
                 if (memberSectionNames.length > 1) {
                     for (const sectionType of memberSectionNames.sort()) {
                         errors.push([sectionType, memberName, `Redefinition of "${sectionType}" member "${memberName}"`]);
@@ -171,7 +171,7 @@ export function validateTypeModelErrors(types) {
 
 
 function getEffectiveType(types, type) {
-    if ('user' in type && type.user in types) {
+    if ('user' in type && Object.hasOwn(types, type.user)) {
         const userType = types[type.user];
         if ('typedef' in userType) {
             return getEffectiveType(types, userType.typedef.type);
@@ -182,24 +182,24 @@ function getEffectiveType(types, type) {
 
 
 function getEffectiveUserType(types, userTypeName) {
-    const userType = userTypeName in types ? types[userTypeName] : null;
+    const userType = Object.hasOwn(types, userTypeName) ? types[userTypeName] : null;
     if (userType !== null && 'typedef' in userType) {
         const typeEffective = getEffectiveType(types, userType.typedef.type);
         if (!('user' in typeEffective)) {
             return null;
         }
-        return typeEffective.user in types ? types[typeEffective.user] : null;
+        return Object.hasOwn(types, typeEffective.user) ? types[typeEffective.user] : null;
     }
     return userType;
 }
 
 
-function getStructMembers(types, struct, visited = {}) {
+function getStructMembers(types, struct, visited = new Set()) {
     return getTypeItems(types, struct, visited, 'struct', 'members');
 }
 
 
-function getEnumValues(types, enum_, visited = {}) {
+function getEnumValues(types, enum_, visited = new Set()) {
     return getTypeItems(types, enum_, visited, 'enum', 'values');
 }
 
@@ -211,8 +211,8 @@ function getTypeItems(types, type, visited, defName, memberName) {
             const userType = getEffectiveUserType(types, base);
             if (userType !== null && defName in userType) {
                 const userTypeName = userType[defName].name;
-                if (!(userTypeName in visited)) {
-                    visited[userTypeName] = true;
+                if (!visited.has(userTypeName)) {
+                    visited.add(userTypeName);
                     items.push(...getTypeItems(types, userType[defName], visited, defName, memberName));
                 } else {
                     throw new TypeError();
@@ -285,7 +285,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
 
             // Valid dict key type (string or enum)
             if (!('builtin' in dictKeyType && dictKeyType.builtin === 'string') &&
-                !('user' in dictKeyType && dictKeyType.user in types && 'enum' in types[dictKeyType.user])) {
+                !('user' in dictKeyType && Object.hasOwn(types, dictKeyType.user) && 'enum' in types[dictKeyType.user])) {
                 error('Invalid dictionary key type');
             }
         }
@@ -295,7 +295,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
         const userTypeName = type.user;
 
         // Unknown user type?
-        if (!(userTypeName in types)) {
+        if (!Object.hasOwn(types, userTypeName)) {
             error(`Unknown type "${userTypeName}"`);
         } else {
             const userType = types[userTypeName];
@@ -312,7 +312,7 @@ function validateTypeModelType(errors, types, type, attr, typeName, memberName)
         const typeEffective = getEffectiveType(types, type);
         const [typeKey] = Object.keys(typeEffective);
         const typeAttrKey = typeKey === 'builtin' ? typeEffective[typeKey] : typeKey;
-        const allowedAttr = typeAttrKey in typeToAllowedAttr ? typeToAllowedAttr[typeAttrKey] : null;
+        const allowedAttr = Object.hasOwn(typeToAllowedAttr, typeAttrKey) ? typeToAllowedAttr[typeAttrKey] : null;
         const disallowedAttr = Object.fromEntries(Object.keys(attr).map((attrKey) => [attrKey, null]));
         delete disallowedAttr.nullable;
         if (allowedAttr !== null) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "schema-markdown",
-    "version": "1.3.0",
+    "version": "1.3.1",
     "description": "A schema definition and validation library",
     "keywords": [
         "schema",