discombobulator 1.0.1 → 1.0.2

package/src/test/symmetricdifference.mjs

@@ -1,495 +0,0 @@
-// symmetricdifference.mjs
-//
-// Tests for symmetricdifference.
-
-import { expect, expectException } from "./testing.mjs";
-
-import { Instruments } from "../instrument.mjs";
-import { Set } from "../set.mjs";
-import { InstrumentSet } from "../instrumentset.mjs";
-
-export const test = {
-  tests: [
-    {
-      title: "default constructor results in correct set",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet();
-
-        let operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.isAbstract, true);
-        expect(operator.allowDuplicates, false);
-        expect(operator.isStrict, true);
-      },
-    },
-
-    {
-      title: "add element fails because symmetric difference is an immutable set",
-      test: () => {
-        const set1 = new InstrumentSet();
-        const set2 = new InstrumentSet();
-
-        let operator = new Set.SymmetricDifference(set1, set2);
-
-        expectException(() => {
-          operator.add(Instruments.Snare);
-        }, Error);
-      },
-    },
-
-    {
-      title: "iterator yields nothing for an empty set",
-      test: () => {
-        const set1 = new InstrumentSet({ add: Instruments.Snare });
-        const set2 = new InstrumentSet({ add: Instruments.Snare });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        let count = 0;
-
-        for (const e of operator) { ++count; }
-
-        expect(count, 0);
-      },
-    },
-    {
-      title: "iterator yields correct results for a non-empty set",
-      test: () => {
-        const instruments = [
-          Instruments.Snare,
-          Instruments.Crash,
-          Instruments.Claves,
-          Instruments.Bass1,
-        ];
-        const set1 = new InstrumentSet({
-          add: instruments,
-        });
-        const set2 = new InstrumentSet({
-          add: [Instruments.Snare, Instruments.Bass1],
-        });
-
-        const operator = new Set.Difference(set1, set2);
-        let count = 0;
-
-        for (const e of operator) {
-          expect(e, (result) => { return result === instruments[1+count++]; });
-        }
-
-        expect(count, 2);
-      },
-    },
-
-    {
-      title: "size returns correct size with no different elements",
-      test: () => {
-        const set1 = new InstrumentSet({ add: Instruments.Snare });
-        const set2 = new InstrumentSet({ add: Instruments.Snare });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 0, true);
-      },
-    },
-    {
-      title: "size returns correct size with a single different element",
-      test: () => {
-        const set1 = new InstrumentSet({
-          add: [Instruments.Snare, Instruments.Bass1],
-        });
-        const set2 = new InstrumentSet({ add: Instruments.Snare });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 1, true);
-      },
-    },
-    {
-      title: "size returns correct size with multiple different elements",
-      test: () => {
-        const set1 = new InstrumentSet({
-          add: [
-            Instruments.Snare,
-            Instruments.Crash,
-            Instruments.Claves,
-            Instruments.Bass1,
-          ],
-        });
-        const set2 = new InstrumentSet({
-          add: [Instruments.Snare, Instruments.Bass1],
-        });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 2, true);
-      },
-    },
-
-    {
-      title: "has fails when empty",
-      test: () => {
-        const set1 = new InstrumentSet({ add: Instruments.Snare });
-        const set2 = new InstrumentSet({ add: Instruments.Snare });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 0, true);
-        expect(operator.has(Instruments.Snare), false);
-      },
-    },
-    {
-      title: "has succeeds for element that is in difference",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1 ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 1, true);
-        expect(operator.has(Instruments.Snare), true);
-      },
-    },
-    {
-      title: "has fails for element that is not in difference",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Bass1 ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 1, true);
-        expect(operator.has(Instruments.Bass1), false);
-      },
-    },
-    {
-      title: "has succeeds for set that is in difference",
-      test: () => {
-        let subset = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Snare ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expect(operator.has(subset), true);
-      },
-    },
-    {
-      title: "has fails for other set that is not in difference",
-      test: () => {
-        let subset = new InstrumentSet({ add: [ Instruments.Claves, Instruments.Crash ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expect(operator.has(subset), false);
-      },
-    },
-
-    {
-      title: "indexOf throws error for undefined element",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expectException(() => { operator.indexOf(); }, Error);
-      },
-    },
-    {
-      title: "indexOf throws error for argument not derived from Element",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expectException(() => { operator.indexOf(new Error()); }, Error);
-      },
-    },
-    {
-      title: "indexOf fails to find non-existant element",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expect(operator.indexOf(Instruments.Claves), -1);
-      },
-    },
-    {
-      title: "indexOf fails for empty set",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Claves, Instruments.Crash ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 0, true);
-        expect(operator.indexOf(Instruments.Bass1), -1);
-      },
-    },
-    {
-      title: "indexOf succeeds for element in the set",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expect(operator.indexOf(Instruments.Snare), 0);
-        expect(operator.indexOf(Instruments.Bass1), 1);
-        expect(operator.indexOf(Instruments.Crash), 2);
-      },
-    },
-    {
-      title: "indexOf fails for element in the set prior to after",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expect(operator.indexOf(Instruments.Snare, 0), -1);
-      },
-    },
-    {
-      title: "indexOf succeeds for element in the set later than after",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expect(operator.indexOf(Instruments.Bass1, 0), 1);
-      },
-    },
-    {
-      title: "indexOf fails if after >= size-1",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expect(operator.indexOf(Instruments.Bass1, 1), -1);
-        expect(operator.indexOf(Instruments.Bass1, 2), -1);
-        expect(operator.indexOf(Instruments.Bass1, 3), -1);
-      },
-    },
-
-    {
-      title: "elementAt throws error for index < 0",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expectException(() => { operator.elementAt(-1); }, Error);
-      },
-    },
-    {
-      title: "elementAt throws error for empty set",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Claves, Instruments.Crash ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 0, true);
-        expectException(() => { operator.elementAt(0); }, Error);
-      },
-    },
-    {
-      title: "elementAt throws error for index >= set size",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expectException(() => { operator.elementAt(3); }, Error);
-      },
-    },
-    {
-      title: "elementAt succeeds for element in valid index",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-        expect(operator.elementAt(0), (result) => { return result === Instruments.Snare; });
-        expect(operator.elementAt(1), (result) => { return result === Instruments.Bass1; });
-        expect(operator.elementAt(2), (result) => { return result === Instruments.Crash; });
-      },
-    },
-
-    {
-      title: "clone succeeds on a difference operator (Shallow)",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-
-        const clone = operator.clone();
-
-        expect(clone.isAbstract, true);
-        expect(clone.allowDuplicates, false);
-        expect(clone.isStrict, true);
-        expect(clone.skipValidation, false);
-        expect(clone.elements[0] === set1, true);
-        expect(clone.elements[1] === set2, true);
-
-        let index = 0;
-
-        for (let e of operator) {
-          expect(e.isEqual(clone.elementAt(index++)), true);
-        }
-      },
-    },
-    {
-      title: "clone succeeds on a difference operator (Deep)",
-      test: () => {
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.size === 3, true);
-
-        const clone = operator.clone(true);
-
-        expect(clone.isAbstract, true);
-        expect(clone.allowDuplicates, false);
-        expect(clone.isStrict, true);
-        expect(clone.skipValidation, false);
-        expect(clone.elements[0] !== set1, true);
-        expect(clone.elements[1] !== set2, true);
-
-        let index = 0;
-
-        for (let e of operator) {
-          expect(e.isEqual(clone.elementAt(index++)), true);
-        }
-      },
-    },
-
-    {
-      title: "isDisjointFrom fails for difference set that is not disjoint from another set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Crash ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.isDisjointFrom(set), false);
-      },
-    },
-    {
-      title: "isDisjointFrom succeeds for difference set that is disjoint from another set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Claves, Instruments.Crash ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.China, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.isDisjointFrom(set), true);
-      },
-    },
-    {
-      title: "isDisjointFrom fails for a set that is not disjoint from a difference set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Crash ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(set.isDisjointFrom(operator), false);
-      },
-    },
-    {
-      title: "isDisjointFrom succeeds for a set that is disjoint from a difference set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.China ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Crash, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(set.isDisjointFrom(operator), true);
-      },
-    },
-
-    {
-      title: "isSubsetOf fails for difference set that is not a subset of another set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Crash ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.isSubsetOf(set), false);
-      },
-    },
-    {
-      title: "isSubsetOf succeeds for difference set that is subset of another set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1, Instruments.Crash, Instruments.Bass1 ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(operator.isSubsetOf(set), true);
-      },
-    },
-    {
-      title: "isSubsetOf fails for a set that is not a subset of a difference set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Crash ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Crash, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(set.isSubsetOf(operator), false);
-      },
-    },
-    {
-      title: "isSubsetOf succeeds for a set that is a subset of a difference set",
-      test: () => {
-        let set = new InstrumentSet({ add: [ Instruments.Bass1, Instruments.Crash ]});
-        let set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Crash, Instruments.Bass1 ] });
-        let set2 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Claves ] });
-
-        const operator = new Set.SymmetricDifference(set1, set2);
-
-        expect(set.isSubsetOf(operator), true);
-      },
-    },
-
-  ],
-};

package/src/test/test.mjs

@@ -1,208 +0,0 @@
-// test.mjs
-//
-// Script to run test suite.
-
-import { program } from "commander";
-
-import con from "./concolour.mjs";
-import { TestExpectationFailed, TestExceptionFailed } from "./testing.mjs";
-
-program
-  .version("1.0.0")
-  .description("Run test harness for DISCOmbobulator")
-  .option("-s, --skip-slow", "skip slow tests", false)
-  .option("-S, --slow", "only perform slow tests", false)
-  .option("-v, --verbose", "verbose output instead of just summary", false)
-  .option("-i, --ignore-skipped", "ignores skipped tests in verbose output", false)
-  .option("-m, --modules <modules...>", "test specified module(s) only");
-
-program.parse();
-
-const options = program.opts();
-
-const log = {
-  message: (message, options = {}) =>
-    con.log(message, con.fg.white, "", options),
-  error: (message, options = {}) =>
-    con.log(message, con.fg.gray, con.bg.red, options),
-  warning: (message, options = {}) =>
-    con.log(message, con.fg.yellow, "", options),
-  title: (message, options = {}) =>
-    con.log(message, con.fg.magenta, "", options),
-  heading1: (message, options = {}) =>
-    con.log(message, con.fg.brightblue, con.bg.blue, options),
-  heading2: (message, options = {}) =>
-    con.log(message, con.fg.blue, "", options),
-  success: (message, options = {}) =>
-    con.log(message, con.fg.brightgreen, "", options),
-  failure: (message, options = {}) => con.log(message, con.fg.red, "", options),
-  skipped: (message, options = {}) =>
-    con.log(message, con.fg.brightmagenta, "", options),
-};
-
-function pad(num) {
-  return String(num).padStart(2, "0");
-}
-
-(async (defs) => {
-  const start = new Date();
-
-  let moduleCount = 0;
-  let testCount = 0;
-  let testID = 0;
-  let failCount = 0;
-  let skipCount = 0;
-  let testPrefix = "";
-
-  let failedTests = [];
-
-  log.title(`Discombobulator test suite started`);
-  console.log(defs);
-
-  for (let module of defs) {
-    if (options.modules === undefined || options.modules.includes(module)) {
-      const path = `./${module}.mjs`;
-
-      if (options.verbose) log.heading1(`Starting module ${++moduleCount}: ${module}`);
-
-      try {
-        const testModule = (await import(path))["test"];
-        const tests = testModule.tests;
-
-        if (tests === undefined || !Array.isArray(tests) || tests.length < 1) {
-          log.warning("No tests found");
-        } else {
-          // Got the array of tests, process them individually.
-          for (let testdef of tests) {
-            const { title, test, slow, skip } = testdef;
-            
-            testPrefix = `Test ${++testID}: `;
-            testPrefix = title !== undefined
-              ? `${testPrefix}${title}...`
-              : `${testPrefix}Untitled test...`;
-
-            if (options.skipSlow && slow !== undefined && slow) {
-              if (options.verbose && !options.ignoreSkipped) {
-                log.heading2(testPrefix, { prefix: true });
-                log.skipped("Skipped - slow", { suffix: true });
-              }
-
-              ++skipCount;
-            } else if (options.slow && (slow === undefined || !slow)) {
-              if (options.verbose && !options.ignoreSkipped) {
-                log.heading2(testPrefix, { prefix: true });
-                log.skipped("Skipped - not slow", { suffix: true });
-              }
-
-              ++skipCount;
-            } else if (skip !== undefined && skip) {
-              if (options.verbose && !options.ignoreSkipped) {
-                log.heading2(testPrefix, { prefix: true });
-                log.skipped("Skipped - explicitly skipped at source", { suffix: true });
-              }
-
-              ++skipCount;
-            } else {
-              if (options.verbose) log.heading2(testPrefix, { prefix: true });
-              ++testCount;
-
-              try {
-                test();
-
-                if (options.verbose) log.success("OK", { suffix: true });
-              } catch (e) {
-                ++failCount;
-
-                let message = "";
-
-                if (e instanceof TestExpectationFailed) {
-                  message = e;
-                } else if (e instanceof TestExceptionFailed) {
-                  message = e;
-                } else {
-                  message = `Unknown Exception: ${e}`;
-                }
-
-                if (failedTests[module] === undefined) {
-                  failedTests[module] = [ `${testPrefix}${message}` ];
-                } else {
-                  failedTests[module].push(`${testPrefix}${message}`);
-                }
-
-                if (options.verbose) log.failure(message, { suffix: true });
-              }
-            }
-          }
-        }
-      } catch (e) {
-        console.log(`FAILED: ${module} - ${path}`);
-        console.log(e);
-
-        log.error("Module not found");
-      }
-    }
-  }
-
-  const elapsed = Date.now() - start;
-
-  const hours = Math.floor(elapsed / 3600000);
-  const minutes = Math.floor(elapsed / 60000);
-  const seconds = Math.floor(elapsed / 1000);
-
-  log.title(`Discombobulator test suite finished`);
-  log.title(`Test duration: ${hours}:${pad(minutes)}:${pad(seconds)}`);
-  log.title(`Modules tested: ${moduleCount}`);
-  log.title(`Tests performed: ${testCount}`);
-
-  if (skipCount > 0) {
-    log.title(`Tests skipped: ${skipCount}`);
-  }
-
-  if (failCount > 0) {
-    log.failure(`Failed tests: ${failCount}`);
-  } else if (testCount > 0) {
-    log.success("All tests passed!");
-  } else {
-    log.warning("No tests performed");
-  }
-
-  if (failCount > 0) {
-    log.failure('Failure summary:');
-
-    for (let module in failedTests) {
-      log.heading1(`Module: ${module}`);
-
-      for (let failure of failedTests[module]) {
-        log.failure(failure);
-      }
-    }
-  }
-})([
-  // moduleName of the test modules to be run.
-
-  "element",
-  "instrument",
-  "articulation",
-  "group",
-  "set",
-  "instrumentset",
-  "articulationset",
-  "note",
-  "patternsource",
-  "noteset",
-  "chord",
-  "pattern",
-  "patternset",
-  "groupset",
-  "regulargroupset",
-  "irregulargroupset",
-  "schedule",
-  "schema",
-  "operator",
-  "binaryoperator",
-  "difference",
-  "intersection",
-  "rotation",
-  "symmetricdifference",
-  "union",
-]);