@hyperjump/json-schema 0.20.0 → 0.23.0

package/dist/json-schema-system.js

@@ -1914,7 +1914,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  return pointer.split("/").slice(1).map(unescape);
 			};
 
-			const get$1 = (pointer, value = undefined) => {
+			const get$2 = (pointer, value = undefined) => {
 			  const ptr = compile$P(pointer);
 
 			  const fn = (value) => ptr.reduce(([value, pointer], segment) => {
@@ -2033,7 +2033,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			const isScalar = (value) => value === null || typeof value !== "object";
 
-			var lib$3 = { nil: nil$2, append, get: get$1, set, assign, unset, remove };
+			var lib$3 = { nil: nil$2, append, get: get$2, set, assign, unset, remove };
 
 			const $__value = Symbol("$__value");
 			const $__href = Symbol("$__href");
@@ -2057,6 +2057,15 @@ System.register('JsonSchema', [], (function (exports) {
 
 			const nil$1 = Object.freeze({ id: "", pointer: "", instance: undefined, value: undefined });
 			const cons = (instance, id = "") => Object.freeze({ ...nil$1, id: resolveUrl$2(id, ""), instance, value: instance });
+
+			const get$1 = (url, instance = nil$1) => {
+			  if (!url.startsWith("#")) {
+			    throw Error(`No JSON document found at '${url.split("#")[0]}'`);
+			  }
+
+			  return Object.freeze({ ...instance, pointer: url.substr(1) });
+			};
+
 			const uri$1 = (doc) => `${doc.id}#${encodeURI(doc.pointer)}`;
 			const value$1 = (doc) => Reference$2.isReference(doc.value) ? Reference$2.value(doc.value) : doc.value;
 			const has$1 = (key, doc) => key in value$1(doc);
@@ -2076,6 +2085,9 @@ System.register('JsonSchema', [], (function (exports) {
 			const map$4 = curry$8((fn, doc) => value$1(doc)
 			  .map((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
 
+			const forEach = curry$8((fn, doc) => value$1(doc)
+			  .forEach((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
+
 			const filter$1 = curry$8((fn, doc) => value$1(doc)
 			  .map((item, ndx, array, thisArg) => step$1(ndx, doc))
 			  .filter((item, ndx, array, thisArg) => fn(item, ndx, array, thisArg)));
@@ -2091,7 +2103,92 @@ System.register('JsonSchema', [], (function (exports) {
 
 			const length$1 = (doc) => value$1(doc).length;
 
-			var instance = { nil: nil$1, cons, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, step: step$1, entries: entries$3, keys: keys$1, map: map$4, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1, length: length$1 };
+			var instance = {
+			  nil: nil$1, cons, get: get$1, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, length: length$1,
+			  step: step$1, entries: entries$3, keys: keys$1, map: map$4, forEach, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1
+			};
+
+			var entries$2 = async (doc) => Object.entries(await doc);
+
+			const curry$7 = justCurryIt;
+
+
+			var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
+
+			const curry$6 = justCurryIt;
+
+
+			var reduce$2 = curry$6(async (fn, acc, doc) => {
+			  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
+			});
+
+			const curry$5 = justCurryIt;
+			const reduce$1 = reduce$2;
+
+
+			var filter = curry$5(async (fn, doc, options = {}) => {
+			  return reduce$1(async (acc, item) => {
+			    return (await fn(item)) ? acc.concat([item]) : acc;
+			  }, [], doc, options);
+			});
+
+			const curry$4 = justCurryIt;
+			const map$2 = map$3;
+
+
+			var some = curry$4(async (fn, doc) => {
+			  const results = await map$2(fn, doc);
+			  return (await Promise.all(results))
+			    .some((a) => a);
+			});
+
+			const curry$3 = justCurryIt;
+			const map$1 = map$3;
+
+
+			var every = curry$3(async (fn, doc) => {
+			  const results = await map$1(fn, doc);
+			  return (await Promise.all(results))
+			    .every((a) => a);
+			});
+
+			const curry$2 = justCurryIt;
+
+
+			var pipeline$1 = curry$2((fns, doc) => {
+			  return fns.reduce(async (acc, fn) => fn(await acc), doc);
+			});
+
+			var all = (doc) => Promise.all(doc);
+
+			const pipeline = pipeline$1;
+			const entries$1 = entries$2;
+			const reduce = reduce$2;
+
+
+			var allValues = (doc) => {
+			  return pipeline([
+			    entries$1,
+			    reduce(async (acc, [propertyName, propertyValue]) => {
+			      acc[propertyName] = await propertyValue;
+			      return acc;
+			    }, {})
+			  ], doc);
+			};
+
+			var lib$2 = {
+			  entries: entries$2,
+			  map: map$3,
+			  filter: filter,
+			  reduce: reduce$2,
+			  some: some,
+			  every: every,
+			  pipeline: pipeline$1,
+			  all: all,
+			  allValues: allValues
+			};
+
+			var fetch_browser = fetch;
 
 			var contentType = {};
 
@@ -2147,7 +2244,7 @@ System.register('JsonSchema', [], (function (exports) {
 			 */
 
 			contentType.format = format$1;
-			contentType.parse = parse;
+			contentType.parse = parse$1;
 
 			/**
 			 * Format object to media type.
@@ -2198,7 +2295,7 @@ System.register('JsonSchema', [], (function (exports) {
 			 * @public
 			 */
 
-			function parse (string) {
+			function parse$1 (string) {
 			  if (!string) {
 			    throw new TypeError('argument string is required')
 			  }
@@ -2316,102 +2413,54 @@ System.register('JsonSchema', [], (function (exports) {
 			  this.type = type;
 			}
 
-			var entries$2 = async (doc) => Object.entries(await doc);
-
-			const curry$7 = justCurryIt;
-
-
-			var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
-
-			const curry$6 = justCurryIt;
-
-
-			var reduce$2 = curry$6(async (fn, acc, doc) => {
-			  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
-			});
-
-			const curry$5 = justCurryIt;
-			const reduce$1 = reduce$2;
-
-
-			var filter = curry$5(async (fn, doc, options = {}) => {
-			  return reduce$1(async (acc, item) => {
-			    return (await fn(item)) ? acc.concat([item]) : acc;
-			  }, [], doc, options);
-			});
-
-			const curry$4 = justCurryIt;
-			const map$2 = map$3;
-
-
-			var some = curry$4(async (fn, doc) => {
-			  const results = await map$2(fn, doc);
-			  return (await Promise.all(results))
-			    .some((a) => a);
-			});
-
-			const curry$3 = justCurryIt;
-			const map$1 = map$3;
-
-
-			var every = curry$3(async (fn, doc) => {
-			  const results = await map$1(fn, doc);
-			  return (await Promise.all(results))
-			    .every((a) => a);
-			});
-
-			const curry$2 = justCurryIt;
-
+			const contentTypeParser = contentType;
 
-			var pipeline$1 = curry$2((fns, doc) => {
-			  return fns.reduce(async (acc, fn) => fn(await acc), doc);
-			});
 
-			var all = (doc) => Promise.all(doc);
-
-			const pipeline = pipeline$1;
-			const entries$1 = entries$2;
-			const reduce = reduce$2;
+			const mediaTypePlugins = {};
 
+			const addPlugin = (contentType, plugin) => {
+			  mediaTypePlugins[contentType] = plugin;
+			};
 
-			var allValues = (doc) => {
-			  return pipeline([
-			    entries$1,
-			    reduce(async (acc, [propertyName, propertyValue]) => {
-			      acc[propertyName] = await propertyValue;
-			      return acc;
-			    }, {})
-			  ], doc);
+			const parse = (response) => {
+			  const contentType = contentTypeParser.parse(response.headers.get("content-type"));
+			  if (!(contentType.type in mediaTypePlugins)) {
+			    throw Error(`${response.url} is not a schema. Found a document with media type: ${contentType.type}`);
+			  }
+			  return mediaTypePlugins[contentType.type].parse(response, contentType.parameters);
 			};
 
-			var lib$2 = {
-			  entries: entries$2,
-			  map: map$3,
-			  filter: filter,
-			  reduce: reduce$2,
-			  some: some,
-			  every: every,
-			  pipeline: pipeline$1,
-			  all: all,
-			  allValues: allValues
+			const getContentType = (path) => {
+			  for (const contentType in mediaTypePlugins) {
+			    if (mediaTypePlugins[contentType].matcher(path)) {
+			      return contentType;
+			    }
+			  }
+
+			  return "application/octet-stream";
 			};
 
-			var fetch_browser = fetch;
+			var mediaTypes = { addPlugin, parse, getContentType };
 
-			const contentTypeParser = contentType;
 			const curry$1 = justCurryIt;
 			const Pact$a = lib$2;
 			const JsonPointer = lib$3;
 			const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
 			const fetch$1 = fetch_browser;
 			const Reference$1 = reference;
+			const MediaTypes$1 = mediaTypes;
+
 
+			const core201909Id = "https://json-schema.org/draft/2019-09/vocab/core";
+			const core202012Id = "https://json-schema.org/draft/2020-12/vocab/core";
 
 			// Config
 			const config = {};
 			const dialectJsonSchemaVersion = {};
 
 			const setConfig = (jsonSchemaVersion, key, value) => {
+			  dialectJsonSchemaVersion[jsonSchemaVersion] = jsonSchemaVersion;
+
 			  if (!config[jsonSchemaVersion]) {
 			    config[jsonSchemaVersion] = {};
 			  }
@@ -2419,10 +2468,8 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			const getConfig = (dialectId, key) => {
-			  const jsonSchemaVersion = dialectJsonSchemaVersion[dialectId] || dialectId;
-			  if (jsonSchemaVersion in config) {
-			    return config[jsonSchemaVersion][key];
-			  }
+			  const jsonSchemaVersion = dialectJsonSchemaVersion[dialectId];
+			  return config[jsonSchemaVersion]?.[key];
 			};
 
 			// Schema Management
@@ -2431,6 +2478,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
 			  schema = JSON.parse(JSON.stringify(schema));
+			  const externalId = resolveUrl$1(url, "");
 
 			  // Dialect / JSON Schema Version
 			  const dialectId = resolveUrl$1(schema["$schema"] || defaultSchemaVersion, "");
@@ -2439,35 +2487,45 @@ System.register('JsonSchema', [], (function (exports) {
 			  }
 			  delete schema["$schema"];
 
-			  let jsonSchemaVersion;
-			  if (schema.$vocabulary?.["https://json-schema.org/draft/2019-09/vocab/core"] === true) {
-			    jsonSchemaVersion = "https://json-schema.org/draft/2019-09/vocab/core";
-			  } else if (schema.$vocabulary?.["https://json-schema.org/draft/2020-12/vocab/core"] === true) {
-			    jsonSchemaVersion = "https://json-schema.org/draft/2020-12/vocab/core";
-			  } else {
-			    jsonSchemaVersion = dialectJsonSchemaVersion[dialectId] || dialectId;
+			  // Determine JSON Schema version
+			  if (!(dialectId in dialectJsonSchemaVersion)) {
+			    if (schema?.$vocabulary?.[core201909Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core201909Id)[0]) {
+			      // Self describing 2019-09 meta-schema
+			      dialectJsonSchemaVersion[dialectId] = core201909Id;
+			    } else if (schema?.$vocabulary?.[core202012Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core202012Id)[0]) {
+			      // Self describing 2020-12 meta-schema
+			      dialectJsonSchemaVersion[dialectId] = core202012Id;
+			    } else {
+			      // Need to look at meta-schema to determine version
+			      const metaSchema = schemaStore[dialectId];
+			      if (!metaSchema) {
+			        throw Error(`Couldn't determine JSON Schema version for dialect: '${dialectId}'`);
+			      } else if (metaSchema.vocabulary[core201909Id] === true) {
+			        dialectJsonSchemaVersion[dialectId] = core201909Id;
+			      } else if (metaSchema.vocabulary[core202012Id] === true) {
+			        dialectJsonSchemaVersion[dialectId] = core202012Id;
+			      } else {
+			        // Assume the jsonSchemaVersion is the meta-schema's dialectId (non-standard behavior)
+			        dialectJsonSchemaVersion[dialectId] = dialectJsonSchemaVersion[metaSchema.dialectId];
+			      }
+			    }
 			  }
 
-			  // Identifier
-			  const baseToken = getConfig(jsonSchemaVersion, "baseToken");
-			  const anchorToken = getConfig(jsonSchemaVersion, "anchorToken");
-			  const externalId = resolveUrl$1(url, "");
-			  if (!externalId && !resolveUrl$1(schema[baseToken] || "", "")) {
+			  // Internal Identifier
+			  const [id, fragment] = getSchemaIdentifier(schema, externalId, dialectJsonSchemaVersion[dialectId]);
+			  if (!id) {
 			    throw Error("Couldn't determine an identifier for the schema");
 			  }
-			  const internalUrl = resolveUrl$1(externalId, schema[baseToken] || "");
-			  const id = resolveUrl$1(internalUrl, "");
-			  const fragment = urlFragment(internalUrl);
+			  const baseToken = getConfig(dialectId, "baseToken");
 			  delete schema[baseToken];
-			  if (fragment && baseToken === anchorToken) {
-			    schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
-			  }
 			  if (externalId) {
 			    schemaStoreAlias[externalId] = id;
 			  }
 
-			  // JSON Schema version
-			  dialectJsonSchemaVersion[id] = jsonSchemaVersion;
+			  const anchorToken = getConfig(dialectId, "anchorToken");
+			  if (fragment && baseToken === anchorToken) {
+			    schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
+			  }
 
 			  // recursiveAnchor
 			  const dynamicAnchors = {};
@@ -2503,6 +2561,12 @@ System.register('JsonSchema', [], (function (exports) {
 			  return id;
 			};
 
+			const getSchemaIdentifier = (schema, externalId, jsonSchemaVersion) => {
+			  const baseToken = config[jsonSchemaVersion]?.["baseToken"];
+			  const internalUrl = resolveUrl$1(externalId, schema[baseToken] || "");
+			  return [resolveUrl$1(internalUrl, ""), urlFragment(internalUrl)];
+			};
+
 			const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors) => {
 			  if (jsonTypeOf(subject, "object")) {
 			    const embeddedSchemaDialectId = typeof subject.$schema === "string" ? resolveUrl$1(subject.$schema, "") : dialectId;
@@ -2580,14 +2644,15 @@ System.register('JsonSchema', [], (function (exports) {
 			      throw Error(`Failed to retrieve schema with id: ${id}`);
 			    }
 
-			    if (response.headers.has("content-type")) {
-			      const contentType = contentTypeParser.parse(response.headers.get("content-type")).type;
-			      if (contentType !== "application/schema+json") {
-			        throw Error(`${id} is not a schema. Found a document with media type: ${contentType}`);
-			      }
+			    const [schema, defaultDialectId] = await MediaTypes$1.parse(response);
+
+			    // Make sure the meta-schema is loaded if this isn't a known dialect
+			    const dialectId = resolveUrl$1(schema.$schema, "") || defaultDialectId;
+			    if (id !== dialectId && !(dialectId in dialectJsonSchemaVersion)) {
+			      await get(dialectId);
 			    }
 
-			    add$1(await response.json(), id);
+			    add$1(schema, id);
 			  }
 
 			  const storedSchema = getStoredSchema(id);
@@ -2724,12 +2789,22 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var invalidSchemaError = InvalidSchemaError$3;
 
+			const Schema$R = schema$5;
+
+
+			const compile$O = (schema) => Schema$R.value(schema);
+			const interpret$O = () => true;
+
+			var metaData$4 = { compile: compile$O, interpret: interpret$O };
+
 			const curry = justCurryIt;
 			const PubSub$1 = pubsub.exports;
 			const { resolveUrl } = common$1;
 			const Instance$E = instance;
-			const Schema$R = schema$5;
+			const Schema$Q = schema$5;
 			const InvalidSchemaError$2 = invalidSchemaError;
+			const MediaTypes = mediaTypes;
+			const metaData$3 = metaData$4;
 
 
 			const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE";
@@ -2737,20 +2812,28 @@ System.register('JsonSchema', [], (function (exports) {
 			let metaOutputFormat = DETAILED;
 			let shouldMetaValidate = true;
 
+			MediaTypes.addPlugin("application/schema+json", {
+			  parse: async (response, contentTypeParameters) => [
+			    await response.json(),
+			    contentTypeParameters.schema || contentTypeParameters.profile
+			  ],
+			  matcher: (path) => path.endsWith(".schema.json")
+			});
+
 			const validate$2 = async (schema, value = undefined, outputFormat = undefined) => {
-			  const compiled = await compile$O(schema);
-			  const interpretAst = (value, outputFormat) => interpret$O(compiled, Instance$E.cons(value), outputFormat);
+			  const compiled = await compile$N(schema);
+			  const interpretAst = (value, outputFormat) => interpret$N(compiled, Instance$E.cons(value), outputFormat);
 
 			  return value === undefined ? interpretAst : interpretAst(value, outputFormat);
 			};
 
-			const compile$O = async (schema) => {
+			const compile$N = async (schema) => {
 			  const ast = { metaData: {} };
 			  const schemaUri = await compileSchema(schema, ast);
 			  return { ast, schemaUri };
 			};
 
-			const interpret$O = curry(({ ast, schemaUri }, value, outputFormat = FLAG) => {
+			const interpret$N = curry(({ ast, schemaUri }, value, outputFormat = FLAG) => {
 			  if (![FLAG, BASIC, DETAILED, VERBOSE].includes(outputFormat)) {
 			    throw Error(`The '${outputFormat}' error format is not supported`);
 			  }
@@ -2804,7 +2887,7 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			const _keywords = {};
-			const getKeyword = (id) => _keywords[id];
+			const getKeyword = (id) => _keywords[id] || metaData$3;
 			const hasKeyword = (id) => id in _keywords;
 			const addKeyword = (id, keywordHandler) => {
 			  _keywords[id] = {
@@ -2825,10 +2908,10 @@ System.register('JsonSchema', [], (function (exports) {
 
 			  // Vocabularies
 			  if (!hasKeyword(`${schema.dialectId}#validate`)) {
-			    const metaSchema = await Schema$R.get(schema.dialectId);
+			    const metaSchema = await Schema$Q.get(schema.dialectId);
 
 			    // Check for mandatory vocabularies
-			    const mandatoryVocabularies = Schema$R.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
+			    const mandatoryVocabularies = Schema$Q.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
 			    mandatoryVocabularies.forEach((vocabularyId) => {
 			      if (!metaSchema.vocabulary[vocabularyId]) {
 			        throw Error(`Vocabulary '${vocabularyId}' must be explicitly declared and required`);
@@ -2851,13 +2934,13 @@ System.register('JsonSchema', [], (function (exports) {
 
 			  // Meta validation
 			  if (shouldMetaValidate && !schema.validated) {
-			    Schema$R.markValidated(schema.id);
+			    Schema$Q.markValidated(schema.id);
 
 			    // Compile
 			    if (!(schema.dialectId in metaValidators)) {
-			      const metaSchema = await Schema$R.get(schema.dialectId);
-			      const compiledSchema = await compile$O(metaSchema);
-			      metaValidators[metaSchema.id] = interpret$O(compiledSchema);
+			      const metaSchema = await Schema$Q.get(schema.dialectId);
+			      const compiledSchema = await compile$N(metaSchema);
+			      metaValidators[metaSchema.id] = interpret$N(compiledSchema);
 			    }
 
 			    // Interpret
@@ -2880,7 +2963,7 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			const followReferences = async (doc) => {
-			  return Schema$R.typeOf(doc, "string") ? followReferences(await Schema$R.get(Schema$R.value(doc), doc)) : doc;
+			  return Schema$Q.typeOf(doc, "string") ? followReferences(await Schema$Q.get(Schema$Q.value(doc), doc)) : doc;
 			};
 
 			const interpretSchema = (schemaUri, instance, ast, dynamicAnchors) => {
@@ -2908,25 +2991,18 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			const add = (schema, url = "", defaultSchemaVersion = "") => {
-			  const id = Schema$R.add(schema, url, defaultSchemaVersion);
+			  const id = Schema$Q.add(schema, url, defaultSchemaVersion);
 			  delete metaValidators[id];
 			};
 
 			var core$2 = {
-			  validate: validate$2, compile: compile$O, interpret: interpret$O,
+			  validate: validate$2, compile: compile$N, interpret: interpret$N,
 			  setMetaOutputFormat, setShouldMetaValidate, FLAG, BASIC, DETAILED, VERBOSE,
 			  add, getKeyword, hasKeyword, defineVocabulary,
-			  compileSchema, interpretSchema, collectEvaluatedProperties: collectEvaluatedProperties$e, collectEvaluatedItems: collectEvaluatedItems$f
+			  compileSchema, interpretSchema, collectEvaluatedProperties: collectEvaluatedProperties$e, collectEvaluatedItems: collectEvaluatedItems$f,
+			  addMediaTypePlugin: MediaTypes.addPlugin
 			};
 
-			const Schema$Q = schema$5;
-
-
-			const compile$N = (schema) => Schema$Q.value(schema);
-			const interpret$N = () => true;
-
-			var metaData$3 = { compile: compile$N, interpret: interpret$N };
-
 			const Pact$9 = lib$2;
 			const PubSub = pubsub.exports;
 			const Core$x = core$2;
@@ -2950,7 +3026,7 @@ System.register('JsonSchema', [], (function (exports) {
 			      typeof schemaValue === "boolean" ? schemaValue : await Pact$9.pipeline([
 			        Schema$P.entries,
 			        Pact$9.map(([keyword, keywordSchema]) => [`${schema.dialectId}#${keyword}`, keywordSchema]),
-			        Pact$9.filter(([keywordId]) => Core$x.hasKeyword(keywordId) && keywordId !== `${schema.dialectId}#validate`),
+			        Pact$9.filter(([keywordId]) => keywordId !== `${schema.dialectId}#validate`),
 			        Pact$9.map(async ([keywordId, keywordSchema]) => {
 			          const keywordAst = await Core$x.getKeyword(keywordId).compile(keywordSchema, ast, schema);
 			          return [keywordId, Schema$P.uri(keywordSchema), keywordAst];
@@ -3026,7 +3102,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var validate$1 = { compile: compile$M, interpret: interpret$M, collectEvaluatedProperties: collectEvaluatedProperties$d, collectEvaluatedItems: collectEvaluatedItems$e };
 
-			const metaData$2 = metaData$3;
+			const metaData$2 = metaData$4;
 			const validate = validate$1;
 
 
@@ -5630,6 +5706,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  interpret: Core.interpret,
 			  setMetaOutputFormat: Core.setMetaOutputFormat,
 			  setShouldMetaValidate: Core.setShouldMetaValidate,
+			  addMediaTypePlugin: Core.addMediaTypePlugin,
 			  FLAG: Core.FLAG,
 			  BASIC: Core.BASIC,
 			  DETAILED: Core.DETAILED,