@stencila/schema/dist/index.js

var fs = require('fs');
var path = require('path');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
var path__default = /*#__PURE__*/_interopDefaultLegacy(path);

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

/* eslint-disable */
// This file was automatically generated by `typescript.ts`.
// Do not modify it by hand. Instead, modify the source `.schema.yaml` files
// in the `schema` directory and run `npm run build:ts` to regenerate it.
// Remove properties from an Object if their values is undefined
const compact = o => Object.entries(o).reduce((compactedO, [k, v]) => v === undefined ? compactedO : _extends({}, compactedO, {
  [k]: v
}), {});
/**
 * Create a `Entity` node
 * @param props Object containing Entity schema properties as key/value pairs
 * @returns {Entity} Entity schema node
 */


const entity = (props = {}) => _extends({}, compact(props), {
  type: 'Entity'
});
/**
 * Create a `ArrayValidator` node
 * @param props Object containing ArrayValidator schema properties as key/value pairs
 * @returns {ArrayValidator} ArrayValidator schema node
 */

const arrayValidator = (props = {}) => _extends({}, compact(props), {
  type: 'ArrayValidator'
});
/**
 * Create a `BooleanValidator` node
 * @param props Object containing BooleanValidator schema properties as key/value pairs
 * @returns {BooleanValidator} BooleanValidator schema node
 */

const booleanValidator = (props = {}) => _extends({}, compact(props), {
  type: 'BooleanValidator'
});
/**
 * Create a `Cite` node
 * @param props Object containing Cite schema properties as key/value pairs
 * @returns {Cite} Cite schema node
 */

const cite = props => _extends({}, compact(props), {
  type: 'Cite'
});
/**
 * Create a `CiteGroup` node
 * @param props Object containing CiteGroup schema properties as key/value pairs
 * @returns {CiteGroup} CiteGroup schema node
 */

const citeGroup = props => _extends({}, compact(props), {
  type: 'CiteGroup'
});
/**
 * Create a `Code` node
 * @param props Object containing Code schema properties as key/value pairs
 * @returns {Code} Code schema node
 */

const code = props => _extends({}, compact(props), {
  type: 'Code'
});
/**
 * Create a `CodeBlock` node
 * @param props Object containing CodeBlock schema properties as key/value pairs
 * @returns {CodeBlock} CodeBlock schema node
 */

const codeBlock = props => _extends({}, compact(props), {
  type: 'CodeBlock'
});
/**
 * Create a `CodeChunk` node
 * @param props Object containing CodeChunk schema properties as key/value pairs
 * @returns {CodeChunk} CodeChunk schema node
 */

const codeChunk = props => _extends({}, compact(props), {
  type: 'CodeChunk'
});
/**
 * Create a `CodeFragment` node
 * @param props Object containing CodeFragment schema properties as key/value pairs
 * @returns {CodeFragment} CodeFragment schema node
 */

const codeFragment = props => _extends({}, compact(props), {
  type: 'CodeFragment'
});
/**
 * Create a `CodeExpression` node
 * @param props Object containing CodeExpression schema properties as key/value pairs
 * @returns {CodeExpression} CodeExpression schema node
 */

const codeExpression = props => _extends({}, compact(props), {
  type: 'CodeExpression'
});
/**
 * Create a `CodeError` node
 * @param props Object containing CodeError schema properties as key/value pairs
 * @returns {CodeError} CodeError schema node
 */

const codeError = props => _extends({}, compact(props), {
  type: 'CodeError'
});
/**
 * Create a `ConstantValidator` node
 * @param props Object containing ConstantValidator schema properties as key/value pairs
 * @returns {ConstantValidator} ConstantValidator schema node
 */

const constantValidator = (props = {}) => _extends({}, compact(props), {
  type: 'ConstantValidator'
});
/**
 * Create a `Date` node
 * @param props Object containing Date schema properties as key/value pairs
 * @returns {Date} Date schema node
 */

const date = props => _extends({}, compact(props), {
  type: 'Date'
});
/**
 * Create a `Mark` node
 * @param props Object containing Mark schema properties as key/value pairs
 * @returns {Mark} Mark schema node
 */

const mark = props => _extends({}, compact(props), {
  type: 'Mark'
});
/**
 * Create a `Delete` node
 * @param props Object containing Delete schema properties as key/value pairs
 * @returns {Delete} Delete schema node
 */

const del = props => _extends({}, compact(props), {
  type: 'Delete'
});
/**
 * Create a `Emphasis` node
 * @param props Object containing Emphasis schema properties as key/value pairs
 * @returns {Emphasis} Emphasis schema node
 */

const emphasis = props => _extends({}, compact(props), {
  type: 'Emphasis'
});
/**
 * Create a `Thing` node
 * @param props Object containing Thing schema properties as key/value pairs
 * @returns {Thing} Thing schema node
 */

const thing = (props = {}) => _extends({}, compact(props), {
  type: 'Thing'
});
/**
 * Create a `Brand` node
 * @param props Object containing Brand schema properties as key/value pairs
 * @returns {Brand} Brand schema node
 */

const brand = props => _extends({}, compact(props), {
  type: 'Brand'
});
/**
 * Create a `ContactPoint` node
 * @param props Object containing ContactPoint schema properties as key/value pairs
 * @returns {ContactPoint} ContactPoint schema node
 */

const contactPoint = (props = {}) => _extends({}, compact(props), {
  type: 'ContactPoint'
});
/**
 * Create a `CreativeWork` node
 * @param props Object containing CreativeWork schema properties as key/value pairs
 * @returns {CreativeWork} CreativeWork schema node
 */

const creativeWork = (props = {}) => _extends({}, compact(props), {
  type: 'CreativeWork'
});
/**
 * Create a `Article` node
 * @param props Object containing Article schema properties as key/value pairs
 * @returns {Article} Article schema node
 */

const article = (props = {}) => _extends({}, compact(props), {
  type: 'Article'
});
/**
 * Create a `Collection` node
 * @param props Object containing Collection schema properties as key/value pairs
 * @returns {Collection} Collection schema node
 */

const collection = props => _extends({}, compact(props), {
  type: 'Collection'
});
/**
 * Create a `Comment` node
 * @param props Object containing Comment schema properties as key/value pairs
 * @returns {Comment} Comment schema node
 */

const comment = (props = {}) => _extends({}, compact(props), {
  type: 'Comment'
});
/**
 * Create a `Datatable` node
 * @param props Object containing Datatable schema properties as key/value pairs
 * @returns {Datatable} Datatable schema node
 */

const datatable = props => _extends({}, compact(props), {
  type: 'Datatable'
});
/**
 * Create a `MediaObject` node
 * @param props Object containing MediaObject schema properties as key/value pairs
 * @returns {MediaObject} MediaObject schema node
 */

const mediaObject = props => _extends({}, compact(props), {
  type: 'MediaObject'
});
/**
 * Create a `AudioObject` node
 * @param props Object containing AudioObject schema properties as key/value pairs
 * @returns {AudioObject} AudioObject schema node
 */

const audioObject = props => _extends({}, compact(props), {
  type: 'AudioObject'
});
/**
 * Create a `DatatableColumn` node
 * @param props Object containing DatatableColumn schema properties as key/value pairs
 * @returns {DatatableColumn} DatatableColumn schema node
 */

const datatableColumn = props => _extends({}, compact(props), {
  type: 'DatatableColumn'
});
/**
 * Create a `DefinedTerm` node
 * @param props Object containing DefinedTerm schema properties as key/value pairs
 * @returns {DefinedTerm} DefinedTerm schema node
 */

const definedTerm = props => _extends({}, compact(props), {
  type: 'DefinedTerm'
});
/**
 * Create a `EnumValidator` node
 * @param props Object containing EnumValidator schema properties as key/value pairs
 * @returns {EnumValidator} EnumValidator schema node
 */

const enumValidator = (props = {}) => _extends({}, compact(props), {
  type: 'EnumValidator'
});
/**
 * Create a `Figure` node
 * @param props Object containing Figure schema properties as key/value pairs
 * @returns {Figure} Figure schema node
 */

const figure = (props = {}) => _extends({}, compact(props), {
  type: 'Figure'
});
/**
 * Create a `Function` node
 * @param props Object containing Function schema properties as key/value pairs
 * @returns {Function} Function schema node
 */

const function_ = (props = {}) => _extends({}, compact(props), {
  type: 'Function'
});
/**
 * Create a `Grant` node
 * @param props Object containing Grant schema properties as key/value pairs
 * @returns {Grant} Grant schema node
 */

const grant = (props = {}) => _extends({}, compact(props), {
  type: 'Grant'
});
/**
 * Create a `Heading` node
 * @param props Object containing Heading schema properties as key/value pairs
 * @returns {Heading} Heading schema node
 */

const heading = props => _extends({}, compact(props), {
  type: 'Heading'
});
/**
 * Create a `ImageObject` node
 * @param props Object containing ImageObject schema properties as key/value pairs
 * @returns {ImageObject} ImageObject schema node
 */

const imageObject = props => _extends({}, compact(props), {
  type: 'ImageObject'
});
/**
 * Create a `Include` node
 * @param props Object containing Include schema properties as key/value pairs
 * @returns {Include} Include schema node
 */

const include = props => _extends({}, compact(props), {
  type: 'Include'
});
/**
 * Create a `NumberValidator` node
 * @param props Object containing NumberValidator schema properties as key/value pairs
 * @returns {NumberValidator} NumberValidator schema node
 */

const numberValidator = (props = {}) => _extends({}, compact(props), {
  type: 'NumberValidator'
});
/**
 * Create a `IntegerValidator` node
 * @param props Object containing IntegerValidator schema properties as key/value pairs
 * @returns {IntegerValidator} IntegerValidator schema node
 */

const integerValidator = (props = {}) => _extends({}, compact(props), {
  type: 'IntegerValidator'
});
/**
 * Create a `Link` node
 * @param props Object containing Link schema properties as key/value pairs
 * @returns {Link} Link schema node
 */

const link = props => _extends({}, compact(props), {
  type: 'Link'
});
/**
 * Create a `List` node
 * @param props Object containing List schema properties as key/value pairs
 * @returns {List} List schema node
 */

const list = props => _extends({}, compact(props), {
  type: 'List'
});
/**
 * Create a `ListItem` node
 * @param props Object containing ListItem schema properties as key/value pairs
 * @returns {ListItem} ListItem schema node
 */

const listItem = (props = {}) => _extends({}, compact(props), {
  type: 'ListItem'
});
/**
 * Create a `Math` node
 * @param props Object containing Math schema properties as key/value pairs
 * @returns {Math} Math schema node
 */

const math = props => _extends({}, compact(props), {
  type: 'Math'
});
/**
 * Create a `MathBlock` node
 * @param props Object containing MathBlock schema properties as key/value pairs
 * @returns {MathBlock} MathBlock schema node
 */

const mathBlock = props => _extends({}, compact(props), {
  type: 'MathBlock'
});
/**
 * Create a `MathFragment` node
 * @param props Object containing MathFragment schema properties as key/value pairs
 * @returns {MathFragment} MathFragment schema node
 */

const mathFragment = props => _extends({}, compact(props), {
  type: 'MathFragment'
});
/**
 * Create a `MonetaryGrant` node
 * @param props Object containing MonetaryGrant schema properties as key/value pairs
 * @returns {MonetaryGrant} MonetaryGrant schema node
 */

const monetaryGrant = (props = {}) => _extends({}, compact(props), {
  type: 'MonetaryGrant'
});
/**
 * Create a `NontextualAnnotation` node
 * @param props Object containing NontextualAnnotation schema properties as key/value pairs
 * @returns {NontextualAnnotation} NontextualAnnotation schema node
 */

const nontextualAnnotation = props => _extends({}, compact(props), {
  type: 'NontextualAnnotation'
});
/**
 * Create a `Organization` node
 * @param props Object containing Organization schema properties as key/value pairs
 * @returns {Organization} Organization schema node
 */

const organization = (props = {}) => _extends({}, compact(props), {
  type: 'Organization'
});
/**
 * Create a `Paragraph` node
 * @param props Object containing Paragraph schema properties as key/value pairs
 * @returns {Paragraph} Paragraph schema node
 */

const paragraph = props => _extends({}, compact(props), {
  type: 'Paragraph'
});
/**
 * Create a `Variable` node
 * @param props Object containing Variable schema properties as key/value pairs
 * @returns {Variable} Variable schema node
 */

const variable = props => _extends({}, compact(props), {
  type: 'Variable'
});
/**
 * Create a `Parameter` node
 * @param props Object containing Parameter schema properties as key/value pairs
 * @returns {Parameter} Parameter schema node
 */

const parameter = props => _extends({}, compact(props), {
  type: 'Parameter'
});
/**
 * Create a `Periodical` node
 * @param props Object containing Periodical schema properties as key/value pairs
 * @returns {Periodical} Periodical schema node
 */

const periodical = (props = {}) => _extends({}, compact(props), {
  type: 'Periodical'
});
/**
 * Create a `Person` node
 * @param props Object containing Person schema properties as key/value pairs
 * @returns {Person} Person schema node
 */

const person = (props = {}) => _extends({}, compact(props), {
  type: 'Person'
});
/**
 * Create a `PostalAddress` node
 * @param props Object containing PostalAddress schema properties as key/value pairs
 * @returns {PostalAddress} PostalAddress schema node
 */

const postalAddress = (props = {}) => _extends({}, compact(props), {
  type: 'PostalAddress'
});
/**
 * Create a `Product` node
 * @param props Object containing Product schema properties as key/value pairs
 * @returns {Product} Product schema node
 */

const product = (props = {}) => _extends({}, compact(props), {
  type: 'Product'
});
/**
 * Create a `PropertyValue` node
 * @param props Object containing PropertyValue schema properties as key/value pairs
 * @returns {PropertyValue} PropertyValue schema node
 */

const propertyValue = props => _extends({}, compact(props), {
  type: 'PropertyValue'
});
/**
 * Create a `PublicationIssue` node
 * @param props Object containing PublicationIssue schema properties as key/value pairs
 * @returns {PublicationIssue} PublicationIssue schema node
 */

const publicationIssue = (props = {}) => _extends({}, compact(props), {
  type: 'PublicationIssue'
});
/**
 * Create a `PublicationVolume` node
 * @param props Object containing PublicationVolume schema properties as key/value pairs
 * @returns {PublicationVolume} PublicationVolume schema node
 */

const publicationVolume = (props = {}) => _extends({}, compact(props), {
  type: 'PublicationVolume'
});
/**
 * Create a `Quote` node
 * @param props Object containing Quote schema properties as key/value pairs
 * @returns {Quote} Quote schema node
 */

const quote = props => _extends({}, compact(props), {
  type: 'Quote'
});
/**
 * Create a `QuoteBlock` node
 * @param props Object containing QuoteBlock schema properties as key/value pairs
 * @returns {QuoteBlock} QuoteBlock schema node
 */

const quoteBlock = props => _extends({}, compact(props), {
  type: 'QuoteBlock'
});
/**
 * Create a `Review` node
 * @param props Object containing Review schema properties as key/value pairs
 * @returns {Review} Review schema node
 */

const review = (props = {}) => _extends({}, compact(props), {
  type: 'Review'
});
/**
 * Create a `SoftwareApplication` node
 * @param props Object containing SoftwareApplication schema properties as key/value pairs
 * @returns {SoftwareApplication} SoftwareApplication schema node
 */

const softwareApplication = (props = {}) => _extends({}, compact(props), {
  type: 'SoftwareApplication'
});
/**
 * Create a `SoftwareEnvironment` node
 * @param props Object containing SoftwareEnvironment schema properties as key/value pairs
 * @returns {SoftwareEnvironment} SoftwareEnvironment schema node
 */

const softwareEnvironment = props => _extends({}, compact(props), {
  type: 'SoftwareEnvironment'
});
/**
 * Create a `SoftwareSession` node
 * @param props Object containing SoftwareSession schema properties as key/value pairs
 * @returns {SoftwareSession} SoftwareSession schema node
 */

const softwareSession = (props = {}) => _extends({}, compact(props), {
  type: 'SoftwareSession'
});
/**
 * Create a `SoftwareSourceCode` node
 * @param props Object containing SoftwareSourceCode schema properties as key/value pairs
 * @returns {SoftwareSourceCode} SoftwareSourceCode schema node
 */

const softwareSourceCode = (props = {}) => _extends({}, compact(props), {
  type: 'SoftwareSourceCode'
});
/**
 * Create a `StringValidator` node
 * @param props Object containing StringValidator schema properties as key/value pairs
 * @returns {StringValidator} StringValidator schema node
 */

const stringValidator = (props = {}) => _extends({}, compact(props), {
  type: 'StringValidator'
});
/**
 * Create a `Strong` node
 * @param props Object containing Strong schema properties as key/value pairs
 * @returns {Strong} Strong schema node
 */

const strong = props => _extends({}, compact(props), {
  type: 'Strong'
});
/**
 * Create a `Subscript` node
 * @param props Object containing Subscript schema properties as key/value pairs
 * @returns {Subscript} Subscript schema node
 */

const subscript = props => _extends({}, compact(props), {
  type: 'Subscript'
});
/**
 * Create a `Superscript` node
 * @param props Object containing Superscript schema properties as key/value pairs
 * @returns {Superscript} Superscript schema node
 */

const superscript = props => _extends({}, compact(props), {
  type: 'Superscript'
});
/**
 * Create a `Table` node
 * @param props Object containing Table schema properties as key/value pairs
 * @returns {Table} Table schema node
 */

const table = props => _extends({}, compact(props), {
  type: 'Table'
});
/**
 * Create a `TableCell` node
 * @param props Object containing TableCell schema properties as key/value pairs
 * @returns {TableCell} TableCell schema node
 */

const tableCell = props => _extends({}, compact(props), {
  type: 'TableCell'
});
/**
 * Create a `TableRow` node
 * @param props Object containing TableRow schema properties as key/value pairs
 * @returns {TableRow} TableRow schema node
 */

const tableRow = props => _extends({}, compact(props), {
  type: 'TableRow'
});
/**
 * Create a `ThematicBreak` node
 * @param props Object containing ThematicBreak schema properties as key/value pairs
 * @returns {ThematicBreak} ThematicBreak schema node
 */

const thematicBreak = (props = {}) => _extends({}, compact(props), {
  type: 'ThematicBreak'
});
/**
 * Create a `TupleValidator` node
 * @param props Object containing TupleValidator schema properties as key/value pairs
 * @returns {TupleValidator} TupleValidator schema node
 */

const tupleValidator = (props = {}) => _extends({}, compact(props), {
  type: 'TupleValidator'
});
/**
 * Create a `VideoObject` node
 * @param props Object containing VideoObject schema properties as key/value pairs
 * @returns {VideoObject} VideoObject schema node
 */

const videoObject = props => _extends({}, compact(props), {
  type: 'VideoObject'
});
/**
 * Create a `VolumeMount` node
 * @param props Object containing VolumeMount schema properties as key/value pairs
 * @returns {VolumeMount} VolumeMount schema node
 */

const volumeMount = props => _extends({}, compact(props), {
  type: 'VolumeMount'
});
const codeBlockTypes = {
  CodeBlock: 'CodeBlock',
  CodeChunk: 'CodeChunk'
};
const codeFragmentTypes = {
  CodeFragment: 'CodeFragment',
  CodeExpression: 'CodeExpression'
};
const codeTypes = {
  Code: 'Code',
  CodeBlock: 'CodeBlock',
  CodeChunk: 'CodeChunk',
  CodeExpression: 'CodeExpression',
  CodeFragment: 'CodeFragment'
};
const contactPointTypes = {
  ContactPoint: 'ContactPoint',
  PostalAddress: 'PostalAddress'
};
const creativeWorkTypes = {
  CreativeWork: 'CreativeWork',
  Article: 'Article',
  AudioObject: 'AudioObject',
  Collection: 'Collection',
  Comment: 'Comment',
  Datatable: 'Datatable',
  Figure: 'Figure',
  ImageObject: 'ImageObject',
  MediaObject: 'MediaObject',
  Periodical: 'Periodical',
  PublicationIssue: 'PublicationIssue',
  PublicationVolume: 'PublicationVolume',
  Review: 'Review',
  SoftwareApplication: 'SoftwareApplication',
  SoftwareSourceCode: 'SoftwareSourceCode',
  Table: 'Table',
  VideoObject: 'VideoObject'
};
const entityTypes = {
  Entity: 'Entity',
  ArrayValidator: 'ArrayValidator',
  Article: 'Article',
  AudioObject: 'AudioObject',
  BooleanValidator: 'BooleanValidator',
  Brand: 'Brand',
  Cite: 'Cite',
  CiteGroup: 'CiteGroup',
  Code: 'Code',
  CodeBlock: 'CodeBlock',
  CodeChunk: 'CodeChunk',
  CodeError: 'CodeError',
  CodeExpression: 'CodeExpression',
  CodeFragment: 'CodeFragment',
  Collection: 'Collection',
  Comment: 'Comment',
  ConstantValidator: 'ConstantValidator',
  ContactPoint: 'ContactPoint',
  CreativeWork: 'CreativeWork',
  Datatable: 'Datatable',
  DatatableColumn: 'DatatableColumn',
  Date: 'Date',
  DefinedTerm: 'DefinedTerm',
  Delete: 'Delete',
  Emphasis: 'Emphasis',
  EnumValidator: 'EnumValidator',
  Figure: 'Figure',
  Function: 'Function',
  Grant: 'Grant',
  Heading: 'Heading',
  ImageObject: 'ImageObject',
  Include: 'Include',
  IntegerValidator: 'IntegerValidator',
  Link: 'Link',
  List: 'List',
  ListItem: 'ListItem',
  Mark: 'Mark',
  Math: 'Math',
  MathBlock: 'MathBlock',
  MathFragment: 'MathFragment',
  MediaObject: 'MediaObject',
  MonetaryGrant: 'MonetaryGrant',
  NontextualAnnotation: 'NontextualAnnotation',
  NumberValidator: 'NumberValidator',
  Organization: 'Organization',
  Paragraph: 'Paragraph',
  Parameter: 'Parameter',
  Periodical: 'Periodical',
  Person: 'Person',
  PostalAddress: 'PostalAddress',
  Product: 'Product',
  PropertyValue: 'PropertyValue',
  PublicationIssue: 'PublicationIssue',
  PublicationVolume: 'PublicationVolume',
  Quote: 'Quote',
  QuoteBlock: 'QuoteBlock',
  Review: 'Review',
  SoftwareApplication: 'SoftwareApplication',
  SoftwareEnvironment: 'SoftwareEnvironment',
  SoftwareSession: 'SoftwareSession',
  SoftwareSourceCode: 'SoftwareSourceCode',
  StringValidator: 'StringValidator',
  Strong: 'Strong',
  Subscript: 'Subscript',
  Superscript: 'Superscript',
  Table: 'Table',
  TableCell: 'TableCell',
  TableRow: 'TableRow',
  ThematicBreak: 'ThematicBreak',
  Thing: 'Thing',
  TupleValidator: 'TupleValidator',
  Variable: 'Variable',
  VideoObject: 'VideoObject',
  VolumeMount: 'VolumeMount'
};
const grantTypes = {
  Grant: 'Grant',
  MonetaryGrant: 'MonetaryGrant'
};
const markTypes = {
  Mark: 'Mark',
  Delete: 'Delete',
  Emphasis: 'Emphasis',
  NontextualAnnotation: 'NontextualAnnotation',
  Quote: 'Quote',
  Strong: 'Strong',
  Subscript: 'Subscript',
  Superscript: 'Superscript'
};
const mathTypes = {
  Math: 'Math',
  MathBlock: 'MathBlock',
  MathFragment: 'MathFragment'
};
const mediaObjectTypes = {
  MediaObject: 'MediaObject',
  AudioObject: 'AudioObject',
  ImageObject: 'ImageObject',
  VideoObject: 'VideoObject'
};
const numberValidatorTypes = {
  NumberValidator: 'NumberValidator',
  IntegerValidator: 'IntegerValidator'
};
const thingTypes = {
  Thing: 'Thing',
  Article: 'Article',
  AudioObject: 'AudioObject',
  Brand: 'Brand',
  Collection: 'Collection',
  Comment: 'Comment',
  ContactPoint: 'ContactPoint',
  CreativeWork: 'CreativeWork',
  Datatable: 'Datatable',
  DatatableColumn: 'DatatableColumn',
  DefinedTerm: 'DefinedTerm',
  Figure: 'Figure',
  Grant: 'Grant',
  ImageObject: 'ImageObject',
  ListItem: 'ListItem',
  MediaObject: 'MediaObject',
  MonetaryGrant: 'MonetaryGrant',
  Organization: 'Organization',
  Periodical: 'Periodical',
  Person: 'Person',
  PostalAddress: 'PostalAddress',
  Product: 'Product',
  PropertyValue: 'PropertyValue',
  PublicationIssue: 'PublicationIssue',
  PublicationVolume: 'PublicationVolume',
  Review: 'Review',
  SoftwareApplication: 'SoftwareApplication',
  SoftwareEnvironment: 'SoftwareEnvironment',
  SoftwareSession: 'SoftwareSession',
  SoftwareSourceCode: 'SoftwareSourceCode',
  Table: 'Table',
  VideoObject: 'VideoObject',
  VolumeMount: 'VolumeMount'
};
const validatorTypes = {
  ConstantValidator: 'ConstantValidator',
  EnumValidator: 'EnumValidator',
  BooleanValidator: 'BooleanValidator',
  NumberValidator: 'NumberValidator',
  IntegerValidator: 'IntegerValidator',
  StringValidator: 'StringValidator',
  ArrayValidator: 'ArrayValidator',
  TupleValidator: 'TupleValidator'
};
const variableTypes = {
  Variable: 'Variable',
  Parameter: 'Parameter'
};
const blockContentTypes = {
  CodeBlock: 'CodeBlock',
  CodeChunk: 'CodeChunk',
  Collection: 'Collection',
  Figure: 'Figure',
  Heading: 'Heading',
  List: 'List',
  ListItem: 'ListItem',
  MathBlock: 'MathBlock',
  Paragraph: 'Paragraph',
  QuoteBlock: 'QuoteBlock',
  Table: 'Table',
  ThematicBreak: 'ThematicBreak'
};
const inlineContentTypes = {
  CodeFragment: 'CodeFragment',
  CodeExpression: 'CodeExpression',
  Delete: 'Delete',
  Emphasis: 'Emphasis',
  ImageObject: 'ImageObject',
  Link: 'Link',
  MathFragment: 'MathFragment',
  NontextualAnnotation: 'NontextualAnnotation',
  Quote: 'Quote',
  Strong: 'Strong',
  Subscript: 'Subscript',
  Superscript: 'Superscript',
  Cite: 'Cite',
  CiteGroup: 'CiteGroup'
};

/**
 * Returns a function which returns true is the type is a member
 * of the type map.
 *
 * @param {TypeMap} typeMap An object containing schema type values
 */

const typeIs = typeMap => type => Object.keys(typeMap).includes(type);
/**
 * Returns a type guard to determine whether a node belongs to a set
 * of types.
 * Returns a boolean value and narrows the TypeScript inferred type to
 * the type.
 *
 * @template {TypeMap} T
 * @param {T} typeMap
 * @param {Node} node A Stencila schema node object
 */

const nodeIs = typeMap => node => {
  return isEntity(node) ? typeIs(typeMap)(node.type) : false;
};
/**
 * Returns a type guard to determine whether a node is of a particular type.
 * Returns a boolean value and narrows the TypeScript inferred type to
 * the type.
 *
 * @param type The type to test for
 */
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type

const is = type => {
  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
  // @ts-ignore
  const typeMap = {
    [type]: type
  };
  return nodeIs(typeMap);
};
/**
 * A type guard to determine whether a node is of a specific type.
 * Returns a boolean value and narrows the TypeScript inferred type to
 * the type.
 *
 * e.g. `isA('Paragraph', node)`
 *
 * @param type The name of the type to test for
 * @param node The node being tested
 */

const isA = (type, node) => {
  return isEntity(node) && node.type === type;
};
const isInstanceOf = (typeMap, node) => {
  return isEntity(node) && Object.keys(typeMap).includes(node.type);
};
/**
 * Returns a type guard to determine whether a node is of a specific type.
 * Returns a boolean value and narrows the TypeScript inferred type to
 * the type.
 *
 * e.g. `article.content.filter(isType('Paragraph'))`
 *
 * @param type The type to test for
 */

const isType = type => node => {
  return node !== undefined && isA(type, node);
};
/**
 * Type guard to determine whether a node is a primitive type.
 * Returns a boolean value and narrows the TypeScript inferred type.
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is null | boolean | number | string)} Returns true if node is one of `null`, `boolean`, `string`, or `number`
 */

const isPrimitive = node => {
  const type = typeof node;
  if (node === null) return true;
  if (type === 'boolean') return true;
  if (type === 'number') return true;
  if (type === 'string') return true;
  return false;
};
/**
 * Type guard to determine whether a node is an `Entity`
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is Entity)} Returns true if node is an `Entity` or derived type
 */

const isEntity = node => {
  if (node === null || node === undefined) return false;
  return Object.prototype.hasOwnProperty.call(node, 'type');
};
/**
 * Type guard to determine whether a node is both `InlineContent` and
 * and an `Entity`.
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is InlineContent)}
 */

const isInlineEntity = node => {
  return typeof node === 'object' && isEntity(node) ? typeIs(inlineContentTypes)(node.type) : false;
};
/**
 * Type guard to determine whether a node is `InlineContent`.
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is InlineContent)}
 */

const isInlineContent = node => {
  return isPrimitive(node) || isInlineEntity(node);
};
/**
 * Type guard to determine whether a node is `BlockContent`.
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is BlockContent)}
 */

const isBlockContent = nodeIs(blockContentTypes);
/**
 * Type guard to determine whether a node is a `CreativeWork`.
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is CreativeWork)}
 */

const isCreativeWork = nodeIs(creativeWorkTypes);
/**
 * Type guard to determine whether a node is a `Code`.
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is Code)}
 */

const isCode = nodeIs(codeTypes);
/**
 * Type guard to determine whether a node is an `Article`.
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is Article)}
 */

const isArticle = is('Article');
/**
 * Type guard to determine whether a node is an `Paragraph`.
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is Paragraph)}
 */

const isParagraph = is('Paragraph');
/**
 * Type guard to determine whether a node is an `ListItem`.
 *
 * @param {Node} node The node to get the type for
 * @returns {(node is ListItem)}
 */

const isListItem = is('ListItem');

var version = "0.47.2";

/**
 * Get the version string (e.g "1.2.3") for this package
 */

const version$1 = version;
/**
 * Get the major version string (e.g "1") for this package
 */

const versionMajor = version$1.split('.')[0];
/**
 * Get the minor version string (e.g "1.2") for this package
 */

const versionMinor = version$1.split('.').slice(0, 2).join('.');

// between Stencila Schema type and property names
// and URLs

let CONTEXT; // Maps between vocabulary terms (Stencila Schema types and
// property names) and their compact IRIs ('@id's) and vice-versa.

const termToId = {};
const idToTerm = {}; // Initialize maps. Called once, lazily.

function initMaps() {
  const context = jsonLdContext();

  for (const [term, value] of Object.entries(context)) {
    if (typeof value === 'string' && !term.startsWith('@')) {
      termToId[term] = value;
      idToTerm[value] = term;
    } else if (typeof value === 'object') {
      const id = value['@id'];
      termToId[term] = id;
      idToTerm[id] = term;
    }
  }
}
/**
 * Get the URL of Stencila Schema's JSON-LD `@context` or
 * for a specific `stencila:` term e.g. `CodeChunk`, `outputs`.
 *
 * The `@context`'s URL needs to have a trailing slash because
 * it gets prefixed to all keys during JSON-LD expansion.
 * e.g. the term `CodeChunk` gets expanded to `http://schema.stenci.la/v0/jsonld/CodeChunk`
 * (which in gets redirected to `https://unpkg.com/@stencila/schema@0.32.1/dist/CodeChunk.jsonld`)
 *
 * @param term The Stencila term (type or property) to generate the
 *             URL for. Defaults to empty string i.e. the context.
 */


function jsonLdUrl(term = '') {
  return `http://schema.stenci.la/v${versionMajor}/jsonld/${term}`;
}
/**
 * Get Stencila Schema's JSON-LD `@context` as an object.
 */

function jsonLdContext() {
  if (CONTEXT === undefined) {
    const json = fs__default['default'].readFileSync(path__default['default'].join(__dirname, ...(__filename.endsWith('.ts') ? ['..', '..', 'public'] : []), 'stencila.jsonld'), 'utf8');
    CONTEXT = JSON.parse(json)['@context'];
  }

  return CONTEXT;
}
/**
 * Get the URL for a term in the Stencila Schema's JSON-LD `@context`
 * from it's name.
 *
 * This uses the JSON-LD `@context` in `stencila.jsonld` (which
 * provides a mapping between vocabularies) to translate
 * type names used in the Stencila Schema
 * to those used in other schemas (e.g. Schema.org, Bioschemas).
 * The [compact IRIs](https://www.w3.org/TR/json-ld11/#compact-iris)
 * in the `@context` e.g. `schema:Person` are expanded to a URL
 * e.g. `http://schema.org/Person` suitable for the `itemtype` attribute.
 *
 * @param term A term in the JSON-LD `@context`. May, or may not be in
 *             the `stencila` namespace
 */

function jsonLdTermUrl(term) {
  if (Object.keys(termToId).length === 0) initMaps();
  const id = termToId[term];
  if (id === undefined) return undefined;
  const [prefix, name] = id.split(':');
  const context = jsonLdContext();
  const base = context[prefix];
  if (base === undefined) return undefined;
  return `${base}${name}`;
}
/**
 * Get the name of a term in the Stencila Schema's JSON-LD `@context`
 * from a URL.
 *
 * This is the inverse of `jsonLdTermUrl`.
 *
 * @param url A url to resolve into a term
 */

function jsonLdTermName(url) {
  if (Object.keys(idToTerm).length === 0) initMaps(); // Parse the url into a base URL / term pair

  const {
    hash,
    pathname
  } = new URL(url);
  const term = hash !== '' ? hash.slice(1) : pathname.split('/').pop();
  const baseUrl = url.replace(new RegExp(`${term}$`), ''); // Resolve the URL into a prefix

  const prefix = idToTerm[baseUrl];
  if (prefix === undefined) return undefined; // Resolve the `@id` to the term name

  return idToTerm[`${prefix}:${term}`];
}

let SCHEMAS = {}; // Lazily populated set properties across all schemas

let PROPERTIES = {};
/**
 * Get all Stencila Schema's JSON Schemas.
 */

async function jsonSchemas() {
  if (Object.keys(SCHEMAS).length === 0) {
    const dir = path__default['default'].join(__dirname, ...(__filename.endsWith('.ts') ? ['..', '..', 'public'] : []));
    const files = await new Promise((resolve, reject) => fs__default['default'].readdir(dir, 'utf8', (error, files) => error !== null ? reject(error) : resolve(files)));
    const schemaFiles = files.filter(filename => filename.endsWith('.schema.json'));
    const promises = schemaFiles.map(async file => {
      const json = await new Promise((resolve, reject) => fs__default['default'].readFile(path__default['default'].join(dir, file), 'utf8', (error, content) => error !== null ? reject(error) : resolve(content)));
      return JSON.parse(json);
    });
    const schemas = await Promise.all(promises);
    SCHEMAS = schemas.reduce((prev, schema) => {
      const {
        title
      } = schema;
      return title === undefined ? prev : _extends({}, prev, {
        [title]: schema
      });
    }, {});
  }

  return SCHEMAS;
}
/**
 * Get all the names of all types in the Stencila Schema.
 */

async function jsonSchemaTypes() {
  const schemas = await jsonSchemas();
  return Object.keys(schemas);
}
/**
 * Get all the properties in all types in the Stencila Schema.
 *
 * Returns a alphabetically sorted `Record` with information on
 * each property, including the types that it occurs on,
 * and whether or not it is an array property.
 */

async function jsonSchemaProperties() {
  if (Object.keys(PROPERTIES).length === 0) {
    const schemas = await jsonSchemas(); // Accumulate properties across types

    const props = Object.values(schemas).reduce((prev, type) => {
      const {
        title = '',
        properties = {}
      } = type;
      Object.entries(properties).forEach(([name, prop]) => {
        const {
          '@id': id = '',
          isArray = false,
          isPlural = false
        } = prop;
        const existing = prev[name];

        if (existing === undefined) {
          prev[name] = {
            name,
            id,
            domainIncludes: [title],
            isArray,
            isPlural
          };
        } else {
          // Check that there is consistency in the property
          // Most of these checks are done in `../schema.ts` when the
          // JSON Schema files are generated. These checks may be moved
          // to elsewhere.
          const message = `${title}.${name} differs to that on ${existing.domainIncludes}`;
          if (id !== existing.id) throw new Error(`${message}: @id ${id}`);
          if (isArray !== existing.isArray) throw new Error(`${message}: isArray ${isArray}`);
          if (isPlural !== existing.isPlural) throw new Error(`${message}: isPlural ${isPlural}`); // Add the type...

          existing.domainIncludes.push(title);
        }
      });
      return prev;
    }, {}); // Sort by key

    PROPERTIES = Object.keys(props).sort().reduce((prev, key) => _extends({}, prev, {
      [key]: props[key]
    }), {});
  }

  return PROPERTIES;
}

/**
 * Get the type of a node
 *
 * @param {Node} node The schema node to get the type for
 */

const nodeType = node => {
  if (node === null) return 'Null';
  if (typeof node === 'boolean') return 'Boolean';
  if (typeof node === 'number') return 'Number';
  if (typeof node === 'string') return 'Text';
  if (Array.isArray(node)) return 'Array';
  if (isEntity(node)) return node.type;
  return 'Object';
};

/**
 * Get the URL used in Microdata attributes.
 *
 * This is used to normalize the versioned URL from the
 * JSON-LD context.
 */

function microdataUrl(type = '') {
  return `http://schema.stenci.la/${type}`;
}
/**
 * Create `MicrodataItem` attributes for a node.
 *
 * Does not create the `itemscope` and `itemtype` attributes for nodes that
 * are primitive (and therefore which do not represent a "scope" having
 * `itemprop`s nested within it). Instead, for primitive nodes, other than `Text`
 * add the `data-itemtype` attribute, do they can be styled if so desired.
 *
 * @param node The node to create Microdata attributes for
 * @param id Id of the Microdata item. Used to link to this node using the `itemref` property.
 */

function microdataItem(node, id) {
  const itemtype = microdataItemtype(nodeType(node));
  const itemidAttr = id !== undefined ? {
    itemid: `#${id}`
  } : {};
  if (itemtype !== undefined && !isPrimitive(node)) return _extends({
    itemscope: '',
    itemtype
  }, itemidAttr);else if (typeof node !== 'string') return _extends({
    'data-itemtype': itemtype
  }, itemidAttr);else return itemidAttr;
}
/**
 * Get the HTML Microdata `itemtype` for a Stencila Schema type
 *
 * @see {@link https://www.w3.org/TR/microdata/#dfn-itemtype}
 */

function microdataItemtype(type) {
  var _jsonLdTermUrl;

  return (_jsonLdTermUrl = jsonLdTermUrl(type)) == null ? void 0 : _jsonLdTermUrl.replace(jsonLdUrl(), microdataUrl());
}
/**
 * Get the Stencila Schema type from a HTML Microdata `itemtype`.
 *
 * This is the inverse of `microdataItemtype`.
 */

function microdataType(itemtype) {
  return jsonLdTermName(itemtype.replace(microdataUrl(), jsonLdUrl()));
}
/**
 * Create `MicrodataProperty` attributes for a node property.
 *
 * @param property The name of the property
 * @param isItem Is the node for which attributes are being generated
 *                    an item within an array property? e.g. a `Person` in `authors`.
 * @param id Id of another Microdata item to link to using the `itemref` property.
 */

function microdataProperty(property, role, id) {
  const [prefix, name = ''] = microdataItemprop(property, role);
  const key = prefix === 'schema' ? 'itemprop' : 'data-itemprop';
  const itemrefAttr = id !== undefined ? {
    itemref: id
  } : {};
  return _extends({
    [key]: name
  }, itemrefAttr);
}
/**
 * Get the HTML Microdata `itemprop` for a Stencila Schema property.
 *
 * The `itemprop` attribute is normally just the name of the property
 * i.e. it is not prefixed by a base URL. This function returns the
 * `[prefix, name]` pair e.g. `["schema", "author"]`,
 * `["codemeta", "maintainer"]` because you may only want to encode
 * `itemprop`s for well known schemas e.g. schema.org
 *
 * @see {@link https://www.w3.org/TR/microdata/#dfn-attr-itemprop}
 *
 * @param property The name of the property
 * @param role Is the node for which attributes are being generated
 *               an item within an array property? e.g. a `Person` in `authors`.
 */

function microdataItemprop(property, role) {
  if (role === 'array') return ['stencila', property];
  const context = jsonLdContext();
  const mapping = context[property];
  if (mapping === undefined) return [undefined, undefined];
  if (typeof mapping === 'string') return [undefined, mapping];
  const id = mapping['@id'];
  let [prefix, name] = id.split(':'); // If this is an item in an array property and the
  // name is a plural, then return a singular name.
  // For external vocabs the `@id` is usually a singular already e.g.
  //   schema:author
  //   codemeta:maintainer

  if (role === 'item' && prefix === 'stencila' && name.endsWith('s')) name = name.slice(0, -1);
  return [prefix, name];
}
/**
 * Create all Microdata attributes for a Stencila `Node`.
 *
 * @param node The node e.g. a `Person` node
 * @param property The name of the property that this node is part of e.g `authors`
 * @param role Is this an item within an array property e.g a `Person` within `authors`
 * @param id The id used to link to / from this Microdata item
 */

function microdata(node, property, role, id) {
  return _extends({}, role !== 'array' ? microdataItem(node, property === undefined ? id : undefined) : {}, property !== undefined ? microdataProperty(property, role, id) : {});
}
/**
 * Get the 'pseudo' HTML Microdata attribute for the root element.
 *
 * This attribute name / value pair is used to scope CSS variables to
 * the root Stencila node in an HML document. It is used by Encoda when
 * encoding to HTML, it is in Thema to scope CSS variable thereby
 * avoiding variable name clashes from using the CSS `:root` pseudo-class.
 *
 * Although not directly related to Microdata, given it is used in both
 * of those projects, this appears to be the best place for it.
 */

function microdataRoot() {
  return {
    'data-itemscope': 'root'
  };
}

exports.arrayValidator = arrayValidator;
exports.article = article;
exports.audioObject = audioObject;
exports.blockContentTypes = blockContentTypes;
exports.booleanValidator = booleanValidator;
exports.brand = brand;
exports.cite = cite;
exports.citeGroup = citeGroup;
exports.code = code;
exports.codeBlock = codeBlock;
exports.codeBlockTypes = codeBlockTypes;
exports.codeChunk = codeChunk;
exports.codeError = codeError;
exports.codeExpression = codeExpression;
exports.codeFragment = codeFragment;
exports.codeFragmentTypes = codeFragmentTypes;
exports.codeTypes = codeTypes;
exports.collection = collection;
exports.comment = comment;
exports.constantValidator = constantValidator;
exports.contactPoint = contactPoint;
exports.contactPointTypes = contactPointTypes;
exports.creativeWork = creativeWork;
exports.creativeWorkTypes = creativeWorkTypes;
exports.datatable = datatable;
exports.datatableColumn = datatableColumn;
exports.date = date;
exports.definedTerm = definedTerm;
exports.del = del;
exports.emphasis = emphasis;
exports.entity = entity;
exports.entityTypes = entityTypes;
exports.enumValidator = enumValidator;
exports.figure = figure;
exports.function_ = function_;
exports.grant = grant;
exports.grantTypes = grantTypes;
exports.heading = heading;
exports.imageObject = imageObject;
exports.include = include;
exports.inlineContentTypes = inlineContentTypes;
exports.integerValidator = integerValidator;
exports.is = is;
exports.isA = isA;
exports.isArticle = isArticle;
exports.isBlockContent = isBlockContent;
exports.isCode = isCode;
exports.isCreativeWork = isCreativeWork;
exports.isEntity = isEntity;
exports.isInlineContent = isInlineContent;
exports.isInlineEntity = isInlineEntity;
exports.isInstanceOf = isInstanceOf;
exports.isListItem = isListItem;
exports.isParagraph = isParagraph;
exports.isPrimitive = isPrimitive;
exports.isType = isType;
exports.jsonLdContext = jsonLdContext;
exports.jsonLdTermName = jsonLdTermName;
exports.jsonLdTermUrl = jsonLdTermUrl;
exports.jsonLdUrl = jsonLdUrl;
exports.jsonSchemaProperties = jsonSchemaProperties;
exports.jsonSchemaTypes = jsonSchemaTypes;
exports.jsonSchemas = jsonSchemas;
exports.link = link;
exports.list = list;
exports.listItem = listItem;
exports.mark = mark;
exports.markTypes = markTypes;
exports.math = math;
exports.mathBlock = mathBlock;
exports.mathFragment = mathFragment;
exports.mathTypes = mathTypes;
exports.mediaObject = mediaObject;
exports.mediaObjectTypes = mediaObjectTypes;
exports.microdata = microdata;
exports.microdataItem = microdataItem;
exports.microdataItemprop = microdataItemprop;
exports.microdataItemtype = microdataItemtype;
exports.microdataProperty = microdataProperty;
exports.microdataRoot = microdataRoot;
exports.microdataType = microdataType;
exports.microdataUrl = microdataUrl;
exports.monetaryGrant = monetaryGrant;
exports.nodeIs = nodeIs;
exports.nodeType = nodeType;
exports.nontextualAnnotation = nontextualAnnotation;
exports.numberValidator = numberValidator;
exports.numberValidatorTypes = numberValidatorTypes;
exports.organization = organization;
exports.paragraph = paragraph;
exports.parameter = parameter;
exports.periodical = periodical;
exports.person = person;
exports.postalAddress = postalAddress;
exports.product = product;
exports.propertyValue = propertyValue;
exports.publicationIssue = publicationIssue;
exports.publicationVolume = publicationVolume;
exports.quote = quote;
exports.quoteBlock = quoteBlock;
exports.review = review;
exports.softwareApplication = softwareApplication;
exports.softwareEnvironment = softwareEnvironment;
exports.softwareSession = softwareSession;
exports.softwareSourceCode = softwareSourceCode;
exports.stringValidator = stringValidator;
exports.strong = strong;
exports.subscript = subscript;
exports.superscript = superscript;
exports.table = table;
exports.tableCell = tableCell;
exports.tableRow = tableRow;
exports.thematicBreak = thematicBreak;
exports.thing = thing;
exports.thingTypes = thingTypes;
exports.tupleValidator = tupleValidator;
exports.typeIs = typeIs;
exports.validatorTypes = validatorTypes;
exports.variable = variable;
exports.variableTypes = variableTypes;
exports.version = version$1;
exports.versionMajor = versionMajor;
exports.versionMinor = versionMinor;
exports.videoObject = videoObject;
exports.volumeMount = volumeMount;
//# sourceMappingURL=index.js.map