@accordproject/concerto-vocabulary 5.0.0 → 5.1.0

package/dist/esm/chunk-BJEPALVN.mjs

@@ -0,0 +1,143 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  __require
+} from "./chunk-M2X75AXU.mjs";
+
+// src/vocabularyvalidator.ts
+import YAML from "yaml";
+var bcp47 = __require("bcp47");
+function isNonEmptyStringScalar(node) {
+  return YAML.isScalar(node) && typeof node.value === "string" && node.value.length > 0;
+}
+function checkValueIsString(value, path, errors) {
+  if (YAML.isAlias(value)) {
+    errors.push({ path, message: `${path} must not use a YAML alias` });
+    return false;
+  }
+  if (!isNonEmptyStringScalar(value)) {
+    errors.push({ path, message: `${path} must be a non-empty string scalar` });
+    return false;
+  }
+  return true;
+}
+function findPair(pairs, key) {
+  return pairs.find((p) => YAML.isScalar(p.key) && p.key.value === key);
+}
+function validateSyntax(yamlStr, errors) {
+  const doc = YAML.parseDocument(yamlStr);
+  for (const err of doc.errors) {
+    errors.push({ path: "", message: `YAML syntax error: ${err.message}` });
+  }
+  return errors.length > 0 ? null : doc;
+}
+function validateNamespace(pairs, errors) {
+  const pair = findPair(pairs, "namespace");
+  if (!pair) {
+    errors.push({ path: "namespace", message: "namespace is required" });
+  } else {
+    checkValueIsString(pair.value, "namespace", errors);
+  }
+}
+var STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["namespace", "locale", "declarations"]);
+function validateTopLevelNonStructuralValues(pairs, errors) {
+  for (const pair of pairs) {
+    const key = YAML.isScalar(pair.key) ? pair.key.value : null;
+    if (!key || STRUCTURAL_KEYS.has(key)) continue;
+    checkValueIsString(pair.value, key, errors);
+  }
+}
+function validatePropertyEntries(seq, declIndex, errors) {
+  seq.items.forEach((item, j) => {
+    const path = `declarations[${declIndex}].properties[${j}]`;
+    if (!YAML.isMap(item)) {
+      errors.push({ path, message: `${path} must be a mapping` });
+      return;
+    }
+    const propPairs = item.items;
+    if (propPairs.length === 0) {
+      errors.push({ path, message: `${path} must not be an empty mapping` });
+      return;
+    }
+    for (const pair of propPairs) {
+      const key = YAML.isScalar(pair.key) ? pair.key.value : null;
+      if (!key) continue;
+      checkValueIsString(pair.value, `${path}.${key}`, errors);
+    }
+  });
+}
+function validateDeclarationEntries(seq, errors) {
+  seq.items.forEach((item, i) => {
+    if (!YAML.isMap(item)) {
+      errors.push({ path: `declarations[${i}]`, message: `declarations[${i}] must be a mapping` });
+      return;
+    }
+    const declPairs = item.items;
+    if (declPairs.length === 0) {
+      errors.push({ path: `declarations[${i}]`, message: `declarations[${i}] must not be an empty mapping` });
+      return;
+    }
+    const primaryPair = declPairs[0];
+    if (primaryPair) {
+      const key = YAML.isScalar(primaryPair.key) ? primaryPair.key.value : null;
+      if (key) checkValueIsString(primaryPair.value, `declarations[${i}].${key}`, errors);
+    }
+    for (const pair of declPairs.slice(1)) {
+      const key = YAML.isScalar(pair.key) ? pair.key.value : null;
+      if (!key) continue;
+      if (key === "properties") {
+        if (!YAML.isSeq(pair.value)) {
+          errors.push({ path: `declarations[${i}].properties`, message: `declarations[${i}].properties must be a sequence` });
+        } else if (pair.value.flow) {
+          errors.push({ path: `declarations[${i}].properties`, message: `declarations[${i}].properties must use block sequence style` });
+        } else {
+          validatePropertyEntries(pair.value, i, errors);
+        }
+        continue;
+      }
+      checkValueIsString(pair.value, `declarations[${i}].${key}`, errors);
+    }
+  });
+}
+function validateDeclarations(pairs, errors) {
+  const pair = findPair(pairs, "declarations");
+  if (!pair) {
+    errors.push({ path: "declarations", message: "declarations is required" });
+  } else if (!YAML.isSeq(pair.value)) {
+    errors.push({ path: "declarations", message: "declarations must be a sequence" });
+  } else if (pair.value.flow) {
+    errors.push({ path: "declarations", message: "declarations must use block sequence style" });
+  } else {
+    validateDeclarationEntries(pair.value, errors);
+  }
+}
+function validateLocale(pairs, errors) {
+  const pair = findPair(pairs, "locale");
+  if (!pair) {
+    errors.push({ path: "locale", message: "locale is required" });
+    return;
+  }
+  if (!checkValueIsString(pair.value, "locale", errors)) return;
+  const val = pair.value.value;
+  if (!bcp47.parse(val)) {
+    errors.push({ path: "locale", message: `locale is not a valid BCP-47 tag: '${val}'` });
+  }
+}
+function validateVocabularyYaml(yamlStr) {
+  const errors = [];
+  const doc = validateSyntax(yamlStr, errors);
+  if (!doc) {
+    return { errors };
+  }
+  const pairs = YAML.isMap(doc.contents) ? doc.contents.items : [];
+  validateNamespace(pairs, errors);
+  validateLocale(pairs, errors);
+  validateDeclarations(pairs, errors);
+  validateTopLevelNonStructuralValues(pairs, errors);
+  return { errors };
+}
+
+export {
+  validateVocabularyYaml
+};
+//# sourceMappingURL=chunk-BJEPALVN.mjs.map

package/dist/esm/chunk-BJEPALVN.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/vocabularyvalidator.ts"],
+  "sourcesContent": ["/*\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport YAML from 'yaml';\n// eslint-disable-next-line @typescript-eslint/no-var-requires\nconst bcp47 = require('bcp47') as { parse: (tag: string) => object | null };\n\nexport interface VocabularyValidationError {\n    path: string;\n    message: string;\n}\n\ntype Pairs = YAML.Pair[];\n\nfunction isNonEmptyStringScalar(node: unknown): boolean {\n    return YAML.isScalar(node) && typeof (node as YAML.Scalar).value === 'string' && ((node as YAML.Scalar).value as string).length > 0;\n}\n\nfunction checkValueIsString(value: unknown, path: string, errors: VocabularyValidationError[]): boolean {\n    if (YAML.isAlias(value as YAML.Node)) {\n        errors.push({ path, message: `${path} must not use a YAML alias` });\n        return false;\n    }\n    if (!isNonEmptyStringScalar(value)) {\n        errors.push({ path, message: `${path} must be a non-empty string scalar` });\n        return false;\n    }\n    return true;\n}\n\nfunction findPair(pairs: Pairs, key: string): YAML.Pair | undefined {\n    return pairs.find(p => YAML.isScalar(p.key) && (p.key as YAML.Scalar).value === key) as YAML.Pair | undefined;\n}\n\n// checks parse errors only \u2014 structurally valid YAML (e.g. sequence or mapping keys) can still pass this\nfunction validateSyntax(yamlStr: string, errors: VocabularyValidationError[]): YAML.Document | null {\n    const doc = YAML.parseDocument(yamlStr);\n    for (const err of doc.errors) {\n        errors.push({ path: '', message: `YAML syntax error: ${err.message}` });\n    }\n    return errors.length > 0 ? null : doc;\n}\n\nfunction validateNamespace(pairs: Pairs, errors: VocabularyValidationError[]): void {\n    const pair = findPair(pairs, 'namespace');\n    if (!pair) {\n        errors.push({ path: 'namespace', message: 'namespace is required' });\n    } else {\n        checkValueIsString(pair.value, 'namespace', errors);\n    }\n}\n\nconst STRUCTURAL_KEYS = new Set(['namespace', 'locale', 'declarations']);\n\n// validates any top-level key outside namespace/locale/declarations \u2014 these are namespace-level terms (e.g. tooltip, description)\n// each must be a non-empty string scalar; sequences, mappings, booleans, numbers, and null are all invalid\nfunction validateTopLevelNonStructuralValues(pairs: Pairs, errors: VocabularyValidationError[]): void {\n    for (const pair of pairs) {\n        const key = YAML.isScalar(pair.key) ? (pair.key as YAML.Scalar).value as string : null;\n        if (!key || STRUCTURAL_KEYS.has(key)) continue;\n        checkValueIsString(pair.value, key, errors);\n    }\n}\n\n// validates each item in a declaration's properties sequence\n// entries must be mappings; all values (primary term and extras like tooltip) must be non-empty string scalars\nfunction validatePropertyEntries(seq: YAML.YAMLSeq, declIndex: number, errors: VocabularyValidationError[]): void {\n    seq.items.forEach((item, j) => {\n        const path = `declarations[${declIndex}].properties[${j}]`;\n        if (!YAML.isMap(item)) {\n            errors.push({ path, message: `${path} must be a mapping` });\n            return;\n        }\n        const propPairs = (item as YAML.YAMLMap).items as YAML.Pair[];\n        if (propPairs.length === 0) {\n            errors.push({ path, message: `${path} must not be an empty mapping` });\n            return;\n        }\n        for (const pair of propPairs) {\n            const key = YAML.isScalar(pair.key) ? (pair.key as YAML.Scalar).value as string : null;\n            if (!key) continue;\n            checkValueIsString(pair.value, `${path}.${key}`, errors);\n        }\n    });\n}\n\n// validates each declaration entry: primary term (first key, e.g. Vehicle) must be a string scalar,\n// extra named terms (e.g. tooltip, description) must be string scalars,\n// properties if present must be a block sequence\nfunction validateDeclarationEntries(seq: YAML.YAMLSeq, errors: VocabularyValidationError[]): void {\n    seq.items.forEach((item, i) => {\n        if (!YAML.isMap(item)) {\n            errors.push({ path: `declarations[${i}]`, message: `declarations[${i}] must be a mapping` });\n            return;\n        }\n        const declPairs = (item as YAML.YAMLMap).items as YAML.Pair[];\n        if (declPairs.length === 0) {\n            errors.push({ path: `declarations[${i}]`, message: `declarations[${i}] must not be an empty mapping` });\n            return;\n        }\n        const primaryPair = declPairs[0];\n        if (primaryPair) {\n            const key = YAML.isScalar(primaryPair.key) ? (primaryPair.key as YAML.Scalar).value as string : null;\n            if (key) checkValueIsString(primaryPair.value, `declarations[${i}].${key}`, errors);\n        }\n        for (const pair of declPairs.slice(1)) {\n            const key = YAML.isScalar(pair.key) ? (pair.key as YAML.Scalar).value as string : null;\n            if (!key) continue;\n            if (key === 'properties') {\n                if (!YAML.isSeq(pair.value)) {\n                    errors.push({ path: `declarations[${i}].properties`, message: `declarations[${i}].properties must be a sequence` });\n                } else if ((pair.value as YAML.YAMLSeq).flow) {\n                    errors.push({ path: `declarations[${i}].properties`, message: `declarations[${i}].properties must use block sequence style` });\n                } else {\n                    validatePropertyEntries(pair.value, i, errors);\n                }\n                continue;\n            }\n            checkValueIsString(pair.value, `declarations[${i}].${key}`, errors);\n        }\n    });\n}\n\n// entry point for declarations validation \u2014 checks the field exists, is a block sequence, then delegates to entry validation\nfunction validateDeclarations(pairs: Pairs, errors: VocabularyValidationError[]): void {\n    const pair = findPair(pairs, 'declarations');\n    if (!pair) {\n        errors.push({ path: 'declarations', message: 'declarations is required' });\n    } else if (!YAML.isSeq(pair.value)) {\n        errors.push({ path: 'declarations', message: 'declarations must be a sequence' });\n    } else if ((pair.value as YAML.YAMLSeq).flow) {\n        errors.push({ path: 'declarations', message: 'declarations must use block sequence style' });\n    } else {\n        validateDeclarationEntries(pair.value, errors);\n    }\n}\n\nfunction validateLocale(pairs: Pairs, errors: VocabularyValidationError[]): void {\n    const pair = findPair(pairs, 'locale');\n    if (!pair) {\n        errors.push({ path: 'locale', message: 'locale is required' });\n        return;\n    }\n    if (!checkValueIsString(pair.value, 'locale', errors)) return;\n    const val = (pair.value as YAML.Scalar).value as string;\n    if (!bcp47.parse(val)) {\n        errors.push({ path: 'locale', message: `locale is not a valid BCP-47 tag: '${val}'` });\n    }\n}\n\n/**\n * Validates vocabulary YAML, collecting all structural and type errors without coercing values.\n * @param {string} yamlStr the YAML string to validate\n * @returns {{ errors: VocabularyValidationError[] }}\n */\nexport function validateVocabularyYaml(yamlStr: string): { errors: VocabularyValidationError[] } {\n    const errors: VocabularyValidationError[] = [];\n\n    const doc = validateSyntax(yamlStr, errors);\n    if (!doc) {\n        return { errors };\n    }\n\n    const pairs: Pairs = YAML.isMap(doc.contents) ? doc.contents.items : [];\n\n    validateNamespace(pairs, errors);\n    validateLocale(pairs, errors);\n    validateDeclarations(pairs, errors);\n    validateTopLevelNonStructuralValues(pairs, errors);\n\n    return { errors };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/chunk-M2X75AXU.mjs

@@ -0,0 +1,13 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};
+//# sourceMappingURL=chunk-M2X75AXU.mjs.map

package/dist/esm/chunk-M2X75AXU.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/esm/{chunk-3VH3UOGB.mjs → chunk-X3NNESEP.mjs}

@@ -2,7 +2,10 @@ import { createRequire as __createRequire } from "module";
 const require = __createRequire(import.meta.url);
 import {
   vocabulary_default
-} from "./chunk-7RW3VXN4.mjs";
+} from "./chunk-ZZFBMCTJ.mjs";
+import {
+  validateVocabularyYaml
+} from "./chunk-BJEPALVN.mjs";
 import {
   parseVocabularyYaml
 } from "./chunk-TA74NV57.mjs";
@@ -19,14 +22,16 @@ function camelCaseToSentence(text) {
 var VocabularyManager = class _VocabularyManager {
   /**
    * Create the VocabularyManager
-   * @param {*} [options] options to configure vocabulary lookup
-   * @param {*} [options.missingTermGenerator] A function to call for missing terms. The function
+   * @param {VocabularyManagerOptions} [options] options to configure vocabulary lookup
+   * @param {Function} [options.missingTermGenerator] A function to call for missing terms. The function
    * should accept namespace, locale, declarationName, propertyName as arguments
+   * @param {boolean} [options.enableVocValidator] When true, validates vocabulary YAML before parsing
    * @constructor
    */
   constructor(options) {
     this.vocabularies = {};
-    this.missingTermGenerator = options ? options.missingTermGenerator : null;
+    this.missingTermGenerator = options?.missingTermGenerator ?? null;
+    this.options = options ?? {};
   }
   /**
    * Computes a term in English based on declaration and property name.
@@ -68,7 +73,15 @@ var VocabularyManager = class _VocabularyManager {
     if (!contents) {
       throw new Error("Vocabulary contents must be specified");
     }
-    const voc = new vocabulary_default(this, options?.enableSafeVocabParsing ? parseVocabularyYaml(contents) : YAML.parse(contents));
+    if (this.options.enableVocValidator) {
+      const { errors } = validateVocabularyYaml(contents);
+      if (errors.length > 0) {
+        throw new Error(errors.map((e) => e.message).join(", "));
+      }
+    }
+    const useRawParse = this.options.enableVocValidator || !options?.enableSafeVocabParsing;
+    const parsed = useRawParse ? YAML.parse(contents) : parseVocabularyYaml(contents);
+    const voc = new vocabulary_default(this, parsed, { skipLocaleValidation: !!this.options.enableVocValidator });
     if (this.vocabularies[voc.getIdentifier()]) {
       throw new Error("Vocabulary has already been added.");
     }
@@ -395,4 +408,4 @@ export {
   VocabularyManager,
   vocabularymanager_default
 };
-//# sourceMappingURL=chunk-3VH3UOGB.mjs.map
+//# sourceMappingURL=chunk-X3NNESEP.mjs.map

package/dist/esm/chunk-X3NNESEP.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/vocabularymanager.ts"],
+  "sourcesContent": ["/*\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport YAML from 'yaml';\nimport { MetaModelNamespace } from '@accordproject/concerto-metamodel';\nimport Vocabulary from './vocabulary';\nimport { ModelUtil, ModelManager } from '@accordproject/concerto-core';\nimport { parseVocabularyYaml } from './yamlparser';\nimport { validateVocabularyYaml } from './vocabularyvalidator';\n\n\nconst DC_NAMESPACE = 'org.accordproject.decoratorcommands@0.4.0';\n\n/**\n * Converts a camel case string to a sentence\n * @param {string} text input\n * @returns {string} modified string\n */\nfunction camelCaseToSentence(text: string): string {\n    const result = text.replace(/([A-Z]+)/g, ' $1').trim();\n    return result.charAt(0).toUpperCase() + result.slice(1);\n}\n\n/**\n* A vocabulary manager for concerto models. The vocabulary manager\n* stores and provides API access to a set of vocabulary files, where each file\n* is associated with a BCP-47 language tag and a Concerto namespace.\n* @see https://datatracker.ietf.org/doc/html/rfc5646#section-2\n* @class\n* @memberof module:concerto-vocabulary\n*/\nclass VocabularyManager {\n    public vocabularies: Record<string, Vocabulary>;\n    public missingTermGenerator: any;\n    private options: any;\n\n    /**\n     * Create the VocabularyManager\n     * @param {VocabularyManagerOptions} [options] options to configure vocabulary lookup\n     * @param {Function} [options.missingTermGenerator] A function to call for missing terms. The function\n     * should accept namespace, locale, declarationName, propertyName as arguments\n     * @param {boolean} [options.enableVocValidator] When true, validates vocabulary YAML before parsing\n     * @constructor\n     */\n    constructor(options?: any) {\n        this.vocabularies = {}; // key is namespace/locale, value is a Vocabulary object\n        this.missingTermGenerator = options?.missingTermGenerator ?? null;\n        this.options = options ?? {};\n    }\n\n    /**\n     * Computes a term in English based on declaration and property name.\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @returns {string} the term or null if it does not exist\n     */\n    static englishMissingTermGenerator(namespace: string, locale: string, declarationName: string, propertyName?: string): string {\n        if(!declarationName){\n            return camelCaseToSentence(ModelUtil.parseNamespace(namespace).name);\n        }\n        const firstPart = propertyName ? propertyName.replace('$', '') + ' of the' : '';\n        return camelCaseToSentence(firstPart + declarationName);\n    }\n\n    /**\n     * Removes all vocabularies\n     */\n    clear() {\n        this.vocabularies = {};\n    }\n\n    /**\n     * Removes a vocabulary from the vocabulary manager\n     * @param {string} namespace the namespace for the vocabulary\n     * @param {string} locale the BCP-47 locale identifier\n     */\n    removeVocabulary(namespace: string, locale: string) {\n        delete this.vocabularies[`${namespace}/${locale}`];\n    }\n\n    /**\n     * Adds a vocabulary to the vocabulary manager\n     * @param {string} contents the YAML string for the vocabulary\n     * @param {*} [options] options to configure vocabulary parsing\n     * @param {boolean} [options.enableSafeVocabParsing] When true, ensures vocabulary values are resolved correctly as strings\n     * @returns {Vocabulary} the vocabulary the was added\n     */\n    addVocabulary(contents: any, options?: any): Vocabulary {\n        if (!contents) {\n            throw new Error('Vocabulary contents must be specified');\n        }\n        if (this.options.enableVocValidator) {\n            const { errors } = validateVocabularyYaml(contents);\n            if (errors.length > 0) {\n                throw new Error(errors.map(e => e.message).join(', '));\n            }\n        }\n        // when the validator has run, input is guaranteed to be structurally clean \u2014 all values are\n        // explicit strings, no flow collections, no aliases \u2014 so parseVocabularyYaml's defensive\n        // coercions are unnecessary and YAML.parse produces identical output at lower cost.\n        // when the validator is off, preserve the existing parse behaviour.\n        const useRawParse = this.options.enableVocValidator || !options?.enableSafeVocabParsing;\n        const parsed = useRawParse ? YAML.parse(contents) : parseVocabularyYaml(contents);\n        const voc = new Vocabulary(this, parsed, { skipLocaleValidation: !!this.options.enableVocValidator });\n\n        if (this.vocabularies[voc.getIdentifier()]) {\n            throw new Error('Vocabulary has already been added.');\n        }\n        this.vocabularies[voc.getIdentifier()] = voc;\n        return voc;\n    }\n\n    /**\n     * Finds the vocabulary for a requested locale, removing language\n     * identifiers from the locale until the locale matches, or if no\n     * vocabulary is found, null is returned\n     * @param {string} requestedLocale the BCP-47 locale identifier\n     * @param {Vocabulary[]} vocabularies the vocabularies to match against\n     * @param {*} [options] options to configure vocabulary lookup\n     * @param {*} [options.localeMatcher] Pass 'lookup' to find a general vocabulary, if available\n     * @returns {Vocabulary} the most specific vocabulary, or null\n     */\n    static findVocabulary(requestedLocale: string, vocabularies: Vocabulary[], options?: any): Vocabulary | null {\n        let locale = requestedLocale;\n        let done = false;\n        do {\n            const voc = vocabularies.find(v => v.getLocale() === locale);\n            if (voc) {\n                return voc;\n            }\n\n            if (options?.localeMatcher !== 'lookup') {\n                done = true;\n                break;\n            }\n\n            const pos = locale.lastIndexOf('-');\n            if (pos === -1) {\n                done = true;\n                break;\n            }\n            locale = locale.substring(0, pos);\n        } while (!done);\n        return null;\n    }\n\n    /**\n     * Gets a vocabulary for a given namespace plus locale\n     * @param {string} namespace the namespace for the vocabulary\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {*} [options] options to configure vocabulary lookup\n     * @param {*} [options.localeMatcher] Pass 'lookup' to find a general vocabulary, if available\n     * @returns {Vocabulary} the vocabulary or null if no vocabulary exists for the locale\n     */\n    getVocabulary(namespace: string, locale: string, options?: any): Vocabulary | null {\n        const loc = locale.toLowerCase();\n        const voc = this.vocabularies[`${namespace}/${loc}`];\n        if (voc) {\n            return voc;\n        }\n        if (options?.localeMatcher === 'lookup') {\n            const vocs = this.getVocabulariesForNamespace(namespace);\n            return VocabularyManager.findVocabulary(loc, vocs, options);\n        }\n        return null;\n    }\n\n    /**\n     * Gets all the vocabulary files for a given namespace\n     * @param {string} namespace the namespace\n     * @returns {Vocabulary[]} the array of vocabularies\n     */\n    getVocabulariesForNamespace(namespace: string): Vocabulary[] {\n        return Object.values(this.vocabularies).filter(v => v.getNamespace() === namespace);\n    }\n\n    /**\n     * Gets all the vocabulary files for a given locale\n     * @param {string} locale the BCP-47 locale identifier\n     * @returns {Vocabulary[]} the array of vocabularies\n     */\n    getVocabulariesForLocale(locale: string): Vocabulary[] {\n        return Object.values(this.vocabularies).filter(v => v.getLocale() === locale.toLowerCase());\n    }\n\n    /**\n     * Resolve the term for a property, looking up terms from a more general vocabulary\n     * if required, and resolving properties using an object manager, allowing terms defined\n     * on super types to be automatically resolved.\n     * @param {ModelManager} modelManager the model manager\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @param {string} [identifier] the identifier of the term (optional)\n     * @returns {string|number|boolean|null} the term or null if it does not exist\n     */\n    resolveTerm(modelManager: ModelManager, namespace: string, locale: string, declarationName: string, propertyName?: string, identifier?: string): string | number | boolean | null {\n        const modelFile = modelManager.getModelFile(namespace);\n        // @ts-ignore\n        const classDecl = modelFile ? (modelFile as any).getType(declarationName) : null;\n        const property = propertyName ? classDecl ? classDecl.getProperty(propertyName) : null : null;\n        return this.getTerm(property ? property.getNamespace() : namespace, locale, property ? (property.getParent() as any).getName() : declarationName, propertyName, identifier);\n    }\n\n    /**\n     * Resolve the terms for a property, looking up terms from a more general vocabulary\n     * if required, and resolving properties using an object manager, allowing terms defined\n     * on super types to be automatically resolved.\n     * @param {ModelManager} modelManager the model manager\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @param {*} [options] options to configure term resolution\n     * @param {boolean} [options.generateMissing=true] whether to synthesize missing terms\n     * @returns {*} the terms or null if it does not exist\n     */\n    resolveTerms(modelManager: ModelManager, namespace: string, locale: string, declarationName: string, propertyName?: string, options?: any) {\n        const modelFile = modelManager.getModelFile(namespace);\n        // @ts-ignore\n        const classDecl = modelFile ? (modelFile as any).getType(declarationName) : null;\n        let property;\n        if(classDecl && !classDecl.isScalarDeclaration()) {\n            if(classDecl.isMapDeclaration()) {\n                if(propertyName === 'KEY') {\n                    property = classDecl.getKey();\n                } else if(propertyName === 'VALUE') {\n                    property = classDecl.getValue();\n                }\n            } else {\n                property = propertyName ? classDecl ? classDecl.getProperty(propertyName) : null : null;\n            }\n        }\n        return this.getTerms(property ? property.getNamespace() : namespace, locale, property ? (property.getParent() as any).getName() : declarationName, propertyName, options);\n    }\n\n    /**\n     * Gets the term for a concept, enum or property, looking up terms\n     * from a more general vocabulary if required\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @param {string} [identifier] the identifier of the term (optional)\n     * @returns {string|number|boolean|null} the term or null if it does not exist\n     */\n    getTerm(namespace: string, locale: string, declarationName: string, propertyName?: string, identifier?: string): string | number | boolean | null {\n        const voc = this.getVocabulary(namespace, locale);\n        let term = null;\n        if (voc) {\n            term = voc.getTerm(declarationName, propertyName, identifier);\n        }\n        if (term != null) {\n            return term;\n        }\n        else {\n            const dashIndex = locale.lastIndexOf('-');\n            if (dashIndex >= 0) {\n                return this.getTerm(namespace, locale.substring(0, dashIndex), declarationName, propertyName, identifier);\n            }\n            else {\n                return this.missingTermGenerator ? this.missingTermGenerator(namespace, locale, declarationName, propertyName) : null;\n            }\n        }\n    }\n\n    /**\n     * Gets the term for a concept, enum or property, looking up terms\n     * from a more general vocabulary if required\n     * @param {string} namespace the namespace\n     * @param {string} locale the BCP-47 locale identifier\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @param {*} [options] options to configure term resolution\n     * @param {boolean} [options.generateMissing=true] whether to synthesize missing terms\n     * @returns {*} the terms or null if it does not exist\n     */\n    getTerms(namespace: string, locale: string, declarationName: string, propertyName?: string, options?: any): any {\n        const voc = this.getVocabulary(namespace, locale);\n        let term = null;\n        if (voc) {\n            term = voc.getElementTerms(declarationName, propertyName);\n        }\n        if (term != null) {\n            return term;\n        }\n        else {\n            const dashIndex = locale.lastIndexOf('-');\n            if (dashIndex >= 0) {\n                return this.getTerms(namespace, locale.substring(0, dashIndex), declarationName, propertyName, options);\n            }\n            else {\n                if (options?.generateMissing === false) {\n                    return;\n                }\n                let missingKey = propertyName ? propertyName : declarationName;\n                missingKey = missingKey? missingKey : 'term';\n                return this.missingTermGenerator ? { [missingKey]: this.missingTermGenerator(namespace, locale, declarationName, propertyName) } : null;\n            }\n        }\n    }\n\n    /**\n     * Creates a DecoractorCommandSet with @Term decorators\n     * to decorate all model elements based on the vocabulary for a locale.\n     * Pass the return value to the DecoratorManager.decorateModel to apply\n     * the decorators to a ModelManager.\n     * @param {ModelManager} modelManager - the Model Manager\n     * @param {string} locale the BCP-47 locale identifier\n     * @returns {*} the decorator command set used to decorate the model.\n     */\n    generateDecoratorCommands(modelManager: ModelManager, locale: string): any {\n        const commands: any[] = [];\n\n        const CLASS_COMMAND = `${DC_NAMESPACE}.Command`;\n        const CLASS_TARGET = `${DC_NAMESPACE}.CommandTarget`;\n        const CLASS_DECORATOR = `${MetaModelNamespace}.Decorator`;\n        const CLASS_DECORATOR_STRING = `${MetaModelNamespace}.DecoratorString`;\n\n        const makeCommand = (target: any, decoratorName: string, value: string) => ({\n            '$class': CLASS_COMMAND,\n            'type': 'UPSERT',\n            'target': target,\n            'decorator': {\n                '$class': CLASS_DECORATOR,\n                'name': decoratorName,\n                'arguments': [{ '$class': CLASS_DECORATOR_STRING, 'value': value }]\n            }\n        });\n\n        // @ts-ignore\n        (modelManager as any).getModelFiles().forEach((model: any) => {\n            const namespace = model.getNamespace();\n\n            const nsTerms = this.getTerms(namespace, locale, '', undefined, { generateMissing: false });\n            if (nsTerms) {\n                const keys = Object.keys(nsTerms);\n                for (let i = 0; i < keys.length; i++) {\n                    const term = keys[i];\n                    if (term === 'term') {\n                        commands.push(makeCommand(\n                            { '$class': CLASS_TARGET, 'namespace': namespace },\n                            'Term', nsTerms[term]\n                        ));\n                    } else if (term !== 'declarations' && term !== 'namespace' && term !== 'locale') {\n                        commands.push(makeCommand(\n                            { '$class': CLASS_TARGET, 'namespace': namespace },\n                            `Term_${term}`, nsTerms[term]\n                        ));\n                    }\n                }\n            }\n\n            model.getAllDeclarations().forEach((decl: any) => {\n                const declName = decl.getName();\n\n                const declTerms = this.getTerms(namespace, locale, declName);\n                if (declTerms) {\n                    const keys = Object.keys(declTerms);\n                    for (let i = 0; i < keys.length; i++) {\n                        const term = keys[i];\n                        if (term === declName) {\n                            commands.push(makeCommand(\n                                { '$class': CLASS_TARGET, 'namespace': namespace, 'declaration': declName },\n                                'Term', declTerms[term]\n                            ));\n                        } else if (term !== 'properties') {\n                            commands.push(makeCommand(\n                                { '$class': CLASS_TARGET, 'namespace': namespace, 'declaration': declName },\n                                `Term_${term}`, declTerms[term]\n                            ));\n                        }\n                    }\n                }\n\n                let propertyNames: string[] = [];\n                if (decl.getProperties) {\n                    propertyNames = decl.getProperties().map((p: any) => p.getName());\n                } else if (decl.isMapDeclaration?.()) {\n                    propertyNames = ['KEY', 'VALUE'];\n                } else {\n                    return;\n                }\n\n                for (let p = 0; p < propertyNames.length; p++) {\n                    const propertyName = propertyNames[p];\n                    const propertyTerms = this.resolveTerms(modelManager, namespace, locale, declName, propertyName);\n                    if (propertyTerms) {\n                        const propertyType = propertyName === 'KEY' || propertyName === 'VALUE' ? 'mapElement' : 'property';\n                        const keys = Object.keys(propertyTerms);\n                        for (let i = 0; i < keys.length; i++) {\n                            const term = keys[i];\n                            commands.push(makeCommand(\n                                { '$class': CLASS_TARGET, 'namespace': namespace, 'declaration': declName, [propertyType]: propertyName },\n                                term === propertyName ? 'Term' : `Term_${term}`, propertyTerms[term]\n                            ));\n                        }\n                    }\n                }\n            });\n        });\n\n        return {\n            '$class': `${DC_NAMESPACE}.DecoratorCommandSet`,\n            'name': `terms-${locale}`,\n            'version': '1.0.0',\n            'commands': commands\n        };\n    }\n\n    /**\n     * Validates the terms in the vocabulary against the namespaces and declarations\n     * within a ModelManager\n     * @param {ModelManager} modelManager - the Model Manager\n     * @param {string} locale the BCP-47 locale identifier\n     * @returns {*} the result of validation\n     */\n    validate(modelManager: ModelManager): any {\n        // missing vocabularies\n        // @ts-ignore\n        const missingVocabularies = (modelManager as any).getModelFiles()\n            .map((m: any) => this.getVocabulariesForNamespace(m.getNamespace()).length === 0 ? m.getNamespace() : null)\n            .filter((m: any) => m !== null);\n\n        // additional vocabularies\n        const additionalVocabularies = Object.values(this.vocabularies)\n            .filter(v => !modelManager.getModelFile(v.getNamespace()));\n\n        const result: any = {\n            missingVocabularies,\n            additionalVocabularies,\n            vocabularies: {}\n        };\n\n        // validate the models against the vocs\n        Object.values(this.vocabularies)\n            .forEach(voc => {\n                const vocResult: any = {\n                    locale: voc.getLocale(),\n                    namespace: voc.getNamespace(),\n                    missingTerms: [],\n                    additionalTerms: []\n                };\n\n                const model = modelManager.getModelFile(voc.getNamespace());\n                if (model) {\n                    const errors = voc.validate(model);\n                    if (errors.missingTerms) {\n                        vocResult.missingTerms = vocResult.missingTerms.concat(errors.missingTerms);\n                    }\n                    if (errors.additionalTerms) {\n                        vocResult.additionalTerms = vocResult.additionalTerms.concat(errors.additionalTerms);\n                    }\n\n                    result.vocabularies[`${vocResult.namespace}/${vocResult.locale}`] = vocResult;\n                }\n            });\n        return result;\n    }\n}\n\nexport { VocabularyManager };\nexport default VocabularyManager;\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/{chunk-7RW3VXN4.mjs → chunk-ZZFBMCTJ.mjs}

@@ -9,7 +9,7 @@ var Vocabulary = class _Vocabulary {
    * @param {VocabularyManager} vocabularyManager - the manager for this vocabulary
    * @param {object} voc - the JSON representation of the vocabulary
    */
-  constructor(vocabularyManager, voc) {
+  constructor(vocabularyManager, voc, options) {
     if (!vocabularyManager) {
       throw new Error("VocabularyManager must be specified");
     }
@@ -25,7 +25,9 @@ var Vocabulary = class _Vocabulary {
     if (!voc.locale) {
       throw new Error("A vocabulary must specify a locale");
     }
-    _Vocabulary.validateLocale(voc.locale);
+    if (!options?.skipLocaleValidation) {
+      _Vocabulary.validateLocale(voc.locale);
+    }
     this.vocabularyManager = vocabularyManager;
     this.content = voc;
   }
@@ -182,4 +184,4 @@ export {
   Vocabulary,
   vocabulary_default
 };
-//# sourceMappingURL=chunk-7RW3VXN4.mjs.map
+//# sourceMappingURL=chunk-ZZFBMCTJ.mjs.map

package/dist/esm/chunk-ZZFBMCTJ.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/vocabulary.ts"],
+  "sourcesContent": ["/*\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ModelFile, ClassDeclaration, Declaration, Property } from '@accordproject/concerto-core';\nimport type VocabularyManager from './vocabularymanager';\n\n/**\n* A vocabulary for a concerto model\n* @class\n* @memberof module:concerto-vocabulary\n*/\nclass Vocabulary {\n    public vocabularyManager: VocabularyManager;\n    public content: any;\n\n    /**\n     * Create the Vocabulary\n     * @constructor\n     * @param {VocabularyManager} vocabularyManager - the manager for this vocabulary\n     * @param {object} voc - the JSON representation of the vocabulary\n     */\n    constructor(vocabularyManager: VocabularyManager, voc: any, options?: { skipLocaleValidation?: boolean }) {\n        if(!vocabularyManager) {\n            throw new Error('VocabularyManager must be specified');\n        }\n        if(!voc) {\n            throw new Error('Vocabulary object must be specified');\n        }\n\n        if(!voc.declarations) {\n            throw new Error('Vocabulary object must have declarations');\n        }\n\n        if(!voc.namespace) {\n            throw new Error('A vocabulary must specify a namespace');\n        }\n\n        if(!voc.locale) {\n            throw new Error('A vocabulary must specify a locale');\n        }\n\n        if (!options?.skipLocaleValidation) {\n            Vocabulary.validateLocale(voc.locale);\n        }\n\n        this.vocabularyManager = vocabularyManager;\n        this.content = voc;\n    }\n\n    /**\n     * Returns the namespace for the vocabulary\n     * @returns {string} the namespace for this vocabulary\n     */\n    getNamespace(): string {\n        return this.content.namespace;\n    }\n\n    /**\n     * Validates a locale\n     * @param {string} locale the locale to validate\n     * @throws {Error} if the locale is invalid\n     */\n    static validateLocale(locale: string) {\n        // @ts-ignore\n        new Intl.Locale(locale);\n        if(locale !== locale.toLowerCase()) {\n            throw new Error('Locale should be lowercase with dashes');\n        }\n    }\n\n    /**\n     * Returns the locale for the vocabulary\n     * @returns {string} the locale for this vocabulary\n     */\n    getLocale(): string {\n        return this.content.locale;\n    }\n\n    /**\n     * Returns the identifier for the vocabulary, composed of the namespace plus the locale\n     * @returns {string} the identifier for this vocabulary\n     */\n    getIdentifier(): string {\n        return `${this.getNamespace()}/${this.content.locale}`;\n    }\n\n    /**\n     * Returns all the declarations for this vocabulary\n     * @returns {Array} an array of objects\n     */\n    getTerms(): any[] {\n        return this.content.declarations;\n    }\n\n    /**\n     * Gets the terms of Namespace\n     * @returns {string} the term or null if it does not exist\n     * @private\n     */\n    getNamespaceTerms(): any {\n        const namespaceTerms = Object.entries(this.content).filter(([key]) => key !== 'namespace' && key !== 'locale' && key !== 'declarations');\n        return namespaceTerms.length > 0 ? Object.fromEntries(namespaceTerms) : null;\n    }\n\n    /**\n     * Gets the term for a concept, enum or property\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @param {string} [identifier] the identifier of the term (optional)\n     * @returns {string|number|boolean|null} the term or null if it does not exist\n     */\n    getTerm(declarationName?: string, propertyName?: string, identifier?: string): string | number | boolean | null {\n        if(!declarationName){\n            const namespaceTerms = this.getNamespaceTerms();\n            return identifier ? namespaceTerms?.[identifier]:namespaceTerms?.term;\n        }\n        const decl = this.content.declarations.find((d: any) => Object.keys(d)[0] === declarationName);\n        if(!decl) {\n            return null;\n        }\n        if(!propertyName) {\n            return identifier ? decl[identifier] : decl[declarationName];\n        }\n        else {\n            const property = decl.properties ? decl.properties.find((d: any) => propertyName in d) : null;\n            return property ? identifier ? property[identifier] : property[propertyName] : null;\n        }\n    }\n\n    /**\n     * Gets the terms for a concept, enum or property\n     * @param {string} declarationName the name of a concept or enum\n     * @param {string} [propertyName] the name of a property (optional)\n     * @returns {string} the term or null if it does not exist\n     */\n    getElementTerms(declarationName: string, propertyName?: string): any {\n        if(!declarationName){\n            return this.getNamespaceTerms();\n        }\n        const decl = this.content.declarations.find((d: any) => Object.keys(d)[0] === declarationName);\n        if(!decl) {\n            return null;\n        }\n        if(!propertyName) {\n            return decl;\n        }\n        else {\n            const property = decl.properties ? decl.properties.find((d: any) => propertyName in d) : null;\n            return property;\n        }\n    }\n\n    /**\n     * Validates a vocabulary against a ModelFile, returning errors for\n     * missing and additional terms.\n     * @param {ModelFile} modelFile the model file for this vocabulary\n     * @returns {*} an object with missingTerms and additionalTerms properties\n     */\n    validate(modelFile: ModelFile): any {\n        const getOwnProperties = (declaration: any) => {\n            // ensures we have a valid return, even for scalars and map-declarations\n            if(declaration.isMapDeclaration()) {\n                return [declaration.getKey(), declaration.getValue()];\n            } else {\n                return declaration.getOwnProperties?.() ? declaration.getOwnProperties?.() : [];\n            }\n        };\n\n        const getPropertyName = (property: any) => {\n            if(property.isKey?.()) {\n                return 'KEY';\n            } else if(property.isValue?.()) {\n                return 'VALUE';\n            } else {\n                return property.getName();\n            }\n        };\n\n        const checkPropertyExists = (k: any, p: any) => {\n            // only reached for keys that getLocalType has already resolved\n            const declaration = modelFile.getLocalType(Object.keys(k)[0]) as ClassDeclaration;\n            const property = Object.keys(p)[0];\n            if(declaration.isMapDeclaration()) {\n                if (property === 'KEY') {\n                    return true;\n                } else if(property === 'VALUE') {\n                    return true;\n                } else {\n                    return false;\n                }\n            } else {\n                return declaration.getOwnProperty(Object.keys(p)[0]);\n            }\n        };\n\n        const result = {\n            missingTerms: modelFile.getAllDeclarations().flatMap( (d: Declaration) => this.getTerm(d.getName())\n                ? getOwnProperties(d).flatMap( (p: Property) => this.getTerm(d.getName(), getPropertyName(p)) ? null : `${d.getName()}.${getPropertyName(p)}`)\n                : d.getName() ).filter( (i: any) => i !== null),\n            additionalTerms: this.content.declarations.flatMap( (k: any) => modelFile.getLocalType(Object.keys(k)[0])\n                ? Array.isArray(k.properties) ? k.properties.flatMap( (p: any) => checkPropertyExists(k, p) ? null : `${Object.keys(k)[0]}.${Object.keys(p)[0]}`) : null\n                : k ).filter( (i: any) => i !== null)\n        };\n\n        if(!this.content.term){\n            result.missingTerms.push('namespace');\n        }\n\n        return result;\n    }\n\n    /**\n     * Converts the object to JSON\n     * @returns {*} the contens of this vocabulary\n     */\n    toJSON() {\n        return this.content;\n    }\n}\n\nexport { Vocabulary };\nexport default Vocabulary;\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/index.mjs

@@ -2,11 +2,13 @@ import { createRequire as __createRequire } from "module";
 const require = __createRequire(import.meta.url);
 import {
   vocabularymanager_default
-} from "./chunk-3VH3UOGB.mjs";
+} from "./chunk-X3NNESEP.mjs";
 import {
   vocabulary_default
-} from "./chunk-7RW3VXN4.mjs";
+} from "./chunk-ZZFBMCTJ.mjs";
+import "./chunk-BJEPALVN.mjs";
 import "./chunk-TA74NV57.mjs";
+import "./chunk-M2X75AXU.mjs";
 export {
   vocabulary_default as Vocabulary,
   vocabularymanager_default as VocabularyManager

package/dist/esm/vocabulary.mjs

@@ -3,7 +3,8 @@ const require = __createRequire(import.meta.url);
 import {
   Vocabulary,
   vocabulary_default
-} from "./chunk-7RW3VXN4.mjs";
+} from "./chunk-ZZFBMCTJ.mjs";
+import "./chunk-M2X75AXU.mjs";
 export {
   Vocabulary,
   vocabulary_default as default

package/dist/esm/vocabularymanager.mjs

@@ -3,9 +3,11 @@ const require = __createRequire(import.meta.url);
 import {
   VocabularyManager,
   vocabularymanager_default
-} from "./chunk-3VH3UOGB.mjs";
-import "./chunk-7RW3VXN4.mjs";
+} from "./chunk-X3NNESEP.mjs";
+import "./chunk-ZZFBMCTJ.mjs";
+import "./chunk-BJEPALVN.mjs";
 import "./chunk-TA74NV57.mjs";
+import "./chunk-M2X75AXU.mjs";
 export {
   VocabularyManager,
   vocabularymanager_default as default

package/dist/esm/vocabularyvalidator.mjs

@@ -0,0 +1,10 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  validateVocabularyYaml
+} from "./chunk-BJEPALVN.mjs";
+import "./chunk-M2X75AXU.mjs";
+export {
+  validateVocabularyYaml
+};
+//# sourceMappingURL=vocabularyvalidator.mjs.map

package/dist/esm/vocabularyvalidator.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/esm/yamlparser.mjs

@@ -3,6 +3,7 @@ const require = __createRequire(import.meta.url);
 import {
   parseVocabularyYaml
 } from "./chunk-TA74NV57.mjs";
+import "./chunk-M2X75AXU.mjs";
 export {
   parseVocabularyYaml
 };

package/dist/esm-browser/{chunk-DSN2E4MW.mjs → chunk-CSZFRMP7.mjs}

@@ -3,9 +3,6 @@ import {
   init_browser_process_shim
 } from "./chunk-K2X7J5YP.mjs";
 
-// src/yamlparser.ts
-init_browser_process_shim();
-
 // node_modules/yaml/browser/index.js
 init_browser_process_shim();
 
@@ -6710,38 +6707,7 @@ function stringify3(value, replacer, options) {
 // node_modules/yaml/browser/index.js
 var browser_default = dist_exports;
 
-// src/yamlparser.ts
-function parseVocabularyYaml(yamlStr) {
-  const doc = browser_default.parseDocument(yamlStr);
-  if (doc.errors.length > 0) {
-    throw doc.errors[0];
-  }
-  browser_default.visit(doc, {
-    Pair(_, pair) {
-      const key = pair.key.value;
-      const value = pair.value;
-      if (key === "declarations" || key === "properties") {
-        return;
-      }
-      if (browser_default.isScalar(value) && typeof value.value !== "string") {
-        pair.value = new browser_default.Scalar(String(value.value));
-        return;
-      }
-      if (browser_default.isCollection(value)) {
-        if (value.range) {
-          const [start, end] = value.range;
-          pair.value = new browser_default.Scalar(yamlStr.substring(start, end));
-        } else {
-          pair.value = new browser_default.Scalar(JSON.stringify(value.toJSON()));
-        }
-      }
-    }
-  });
-  return doc.toJSON();
-}
-
 export {
-  browser_default,
-  parseVocabularyYaml
+  browser_default
 };
-//# sourceMappingURL=chunk-DSN2E4MW.mjs.map
+//# sourceMappingURL=chunk-CSZFRMP7.mjs.map