web-music-score 0.0.1 → 6.0.0-pre.1

package/dist/theory/index.js

@@ -0,0 +1,4842 @@
+/* WebMusicScore v6.0.0-pre.1 | (c) 2023-2025 Stefan Brockmann | MIT License | Includes: Tone.js (MIT License), Color Name to Code (MIT License) */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod3) => __copyProps(__defProp({}, "__esModule", { value: true }), mod3);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+
+// src/theory/index.ts
+var theory_exports = {};
+__export(theory_exports, {
+  AccidentalType: () => AccidentalType,
+  BeamGrouping: () => BeamGrouping,
+  Chord: () => Chord,
+  DefaultGuitarNoteLabel: () => DefaultGuitarNoteLabel,
+  DefaultPitchNotation: () => DefaultPitchNotation,
+  DefaultTuningName: () => DefaultTuningName,
+  GuitarNoteLabel: () => GuitarNoteLabel,
+  GuitarNoteLabelList: () => GuitarNoteLabelList,
+  Interval: () => Interval,
+  KeySignature: () => KeySignature,
+  Mode: () => Mode,
+  Note: () => Note,
+  NoteLength: () => NoteLength,
+  NoteLengthProps: () => NoteLengthProps,
+  PitchNotation: () => PitchNotation,
+  PitchNotationList: () => PitchNotationList,
+  RhythmProps: () => RhythmProps,
+  Scale: () => Scale,
+  ScaleFactory: () => ScaleFactory,
+  ScaleType: () => ScaleType,
+  SymbolSet: () => SymbolSet,
+  TimeSignature: () => TimeSignature,
+  TimeSignatures: () => TimeSignatures,
+  TuningNameList: () => TuningNameList,
+  Tuplet: () => Tuplet,
+  alterTempoSpeed: () => alterTempoSpeed,
+  getDefaultKeySignature: () => getDefaultKeySignature,
+  getDefaultScale: () => getDefaultScale,
+  getDefaultTempo: () => getDefaultTempo,
+  getDefaultTimeSignature: () => getDefaultTimeSignature,
+  getPitchNotationName: () => getPitchNotationName,
+  getScale: () => getScale,
+  getScaleFactory: () => getScaleFactory,
+  getScaleFactoryList: () => getScaleFactoryList,
+  getTempoString: () => getTempoString,
+  getTuningStrings: () => getTuningStrings,
+  isNoteLength: () => isNoteLength,
+  isTupletRatio: () => isTupletRatio,
+  validateGuitarNoteLabel: () => validateGuitarNoteLabel,
+  validateIntervalQuality: () => validateIntervalQuality,
+  validateNoteLength: () => validateNoteLength,
+  validatePitchNotation: () => validatePitchNotation,
+  validateScaleType: () => validateScaleType,
+  validateTuningName: () => validateTuningName,
+  validateTupletRatio: () => validateTupletRatio
+});
+module.exports = __toCommonJS(theory_exports);
+
+// node_modules/@tspro/ts-utils-lib/dist/index.mjs
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var assert_exports = {};
+__export2(assert_exports, {
+  assert: () => assert,
+  doesNotThrow: () => doesNotThrow2,
+  doesThrow: () => doesThrow2,
+  fail: () => fail,
+  isArray: () => isArray2,
+  isArrayOrUndefined: () => isArrayOrUndefined2,
+  isBigInt: () => isBigInt2,
+  isBoolean: () => isBoolean2,
+  isBooleanOrUndefined: () => isBooleanOrUndefined2,
+  isDeepEqual: () => isDeepEqual2,
+  isDefined: () => isDefined2,
+  isEmptyArray: () => isEmptyArray2,
+  isEmptyArrayOrUndefined: () => isEmptyArrayOrUndefined2,
+  isEmptyObject: () => isEmptyObject2,
+  isEmptyString: () => isEmptyString2,
+  isEmptyStringOrUndefined: () => isEmptyStringOrUndefined2,
+  isEnumValue: () => isEnumValue2,
+  isEnumValueOrUndefined: () => isEnumValueOrUndefined2,
+  isEven: () => isEven2,
+  isFalse: () => isFalse2,
+  isFalseOrUndefined: () => isFalseOrUndefined2,
+  isFinite: () => isFinite3,
+  isFloat: () => isFloat2,
+  isFunction: () => isFunction2,
+  isFunctionOrUndefined: () => isFunctionOrUndefined2,
+  isIncluded: () => isIncluded2,
+  isIndex: () => isIndex2,
+  isInfinity: () => isInfinity2,
+  isInteger: () => isInteger2,
+  isIntegerBetween: () => isIntegerBetween2,
+  isIntegerBetweenExclusive: () => isIntegerBetweenExclusive2,
+  isIntegerEq: () => isIntegerEq2,
+  isIntegerGt: () => isIntegerGt2,
+  isIntegerGte: () => isIntegerGte2,
+  isIntegerLt: () => isIntegerLt2,
+  isIntegerLte: () => isIntegerLte2,
+  isIntegerOrUndefined: () => isIntegerOrUndefined2,
+  isMultipleOf: () => isMultipleOf2,
+  isNaNValue: () => isNaNValue2,
+  isNeg: () => isNeg2,
+  isNegInfinity: () => isNegInfinity2,
+  isNegZero: () => isNegZero2,
+  isNonEmptyArray: () => isNonEmptyArray2,
+  isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined2,
+  isNonEmptyString: () => isNonEmptyString2,
+  isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined2,
+  isNonNeg: () => isNonNeg2,
+  isNonNull: () => isNonNull2,
+  isNonPos: () => isNonPos2,
+  isNull: () => isNull2,
+  isNullish: () => isNullish2,
+  isNumber: () => isNumber2,
+  isNumberBetween: () => isNumberBetween2,
+  isNumberBetweenExclusive: () => isNumberBetweenExclusive2,
+  isNumberEq: () => isNumberEq2,
+  isNumberGt: () => isNumberGt2,
+  isNumberGte: () => isNumberGte2,
+  isNumberLt: () => isNumberLt2,
+  isNumberLte: () => isNumberLte2,
+  isNumberOrUndefined: () => isNumberOrUndefined2,
+  isNumericString: () => isNumericString2,
+  isObject: () => isObject2,
+  isObjectOrUndefined: () => isObjectOrUndefined2,
+  isOdd: () => isOdd2,
+  isPlainObject: () => isPlainObject2,
+  isPos: () => isPos2,
+  isPosInfinity: () => isPosInfinity2,
+  isPosZero: () => isPosZero2,
+  isPowerOfTwo: () => isPowerOfTwo2,
+  isSafeInteger: () => isSafeInteger2,
+  isSafeNumber: () => isSafeNumber2,
+  isStrictEqual: () => isStrictEqual2,
+  isString: () => isString2,
+  isStringOrUndefined: () => isStringOrUndefined2,
+  isTrue: () => isTrue2,
+  isTrueOrUndefined: () => isTrueOrUndefined2,
+  isTypedObject: () => isTypedObject2,
+  isUndefined: () => isUndefined2,
+  isZero: () => isZero2,
+  require: () => require2,
+  requireDefined: () => requireDefined,
+  requireElement: () => requireElement,
+  setErrorClass: () => setErrorClass
+});
+var str_exports = {};
+__export2(str_exports, {
+  charCount: () => charCount,
+  chunkString: () => chunkString,
+  insertAt: () => insertAt,
+  isString: () => isString,
+  makeSentenceFromPascal: () => makeSentenceFromPascal,
+  removeAt: () => removeAt,
+  repeatString: () => repeatString,
+  replaceAt: () => replaceAt,
+  splitByCaps: () => splitByCaps,
+  splitByChars: () => splitByChars,
+  splitByStrings: () => splitByStrings,
+  stringify: () => stringify,
+  toCharArray: () => toCharArray
+});
+var obj_exports = {};
+__export2(obj_exports, {
+  deepEqual: () => deepEqual,
+  getCtorName: () => getCtorName,
+  hasProperties: () => hasProperties,
+  isObject: () => isObject
+});
+var guard_exports = {};
+__export2(guard_exports, {
+  doesNotThrow: () => doesNotThrow,
+  doesThrow: () => doesThrow,
+  isArray: () => isArray,
+  isArrayOrUndefined: () => isArrayOrUndefined,
+  isBigInt: () => isBigInt,
+  isBoolean: () => isBoolean,
+  isBooleanOrUndefined: () => isBooleanOrUndefined,
+  isDeepEqual: () => isDeepEqual,
+  isDefined: () => isDefined,
+  isEmptyArray: () => isEmptyArray,
+  isEmptyArrayOrUndefined: () => isEmptyArrayOrUndefined,
+  isEmptyObject: () => isEmptyObject,
+  isEmptyString: () => isEmptyString,
+  isEmptyStringOrUndefined: () => isEmptyStringOrUndefined,
+  isEnumValue: () => isEnumValue,
+  isEnumValueOrUndefined: () => isEnumValueOrUndefined,
+  isEven: () => isEven,
+  isFalse: () => isFalse,
+  isFalseOrUndefined: () => isFalseOrUndefined,
+  isFinite: () => isFinite2,
+  isFloat: () => isFloat,
+  isFunction: () => isFunction,
+  isFunctionOrUndefined: () => isFunctionOrUndefined,
+  isIncluded: () => isIncluded,
+  isIndex: () => isIndex,
+  isInfinity: () => isInfinity,
+  isInteger: () => isInteger,
+  isIntegerBetween: () => isIntegerBetween,
+  isIntegerBetweenExclusive: () => isIntegerBetweenExclusive,
+  isIntegerEq: () => isIntegerEq,
+  isIntegerGt: () => isIntegerGt,
+  isIntegerGte: () => isIntegerGte,
+  isIntegerLt: () => isIntegerLt,
+  isIntegerLte: () => isIntegerLte,
+  isIntegerOrUndefined: () => isIntegerOrUndefined,
+  isMultipleOf: () => isMultipleOf,
+  isNaNValue: () => isNaNValue,
+  isNeg: () => isNeg,
+  isNegInfinity: () => isNegInfinity,
+  isNegZero: () => isNegZero,
+  isNonEmptyArray: () => isNonEmptyArray,
+  isNonEmptyArrayOrUndefined: () => isNonEmptyArrayOrUndefined,
+  isNonEmptyString: () => isNonEmptyString,
+  isNonEmptyStringOrUndefined: () => isNonEmptyStringOrUndefined,
+  isNonNeg: () => isNonNeg,
+  isNonNull: () => isNonNull,
+  isNonPos: () => isNonPos,
+  isNull: () => isNull,
+  isNullish: () => isNullish,
+  isNumber: () => isNumber,
+  isNumberBetween: () => isNumberBetween,
+  isNumberBetweenExclusive: () => isNumberBetweenExclusive,
+  isNumberEq: () => isNumberEq,
+  isNumberGt: () => isNumberGt,
+  isNumberGte: () => isNumberGte,
+  isNumberLt: () => isNumberLt,
+  isNumberLte: () => isNumberLte,
+  isNumberOrUndefined: () => isNumberOrUndefined,
+  isNumericString: () => isNumericString,
+  isObject: () => isObject,
+  isObjectOrUndefined: () => isObjectOrUndefined,
+  isOdd: () => isOdd,
+  isPlainObject: () => isPlainObject,
+  isPos: () => isPos,
+  isPosInfinity: () => isPosInfinity,
+  isPosZero: () => isPosZero,
+  isPowerOfTwo: () => isPowerOfTwo,
+  isSafeInteger: () => isSafeInteger,
+  isSafeNumber: () => isSafeNumber,
+  isStrictEqual: () => isStrictEqual,
+  isString: () => isString,
+  isStringOrUndefined: () => isStringOrUndefined,
+  isTrue: () => isTrue,
+  isTrueOrUndefined: () => isTrueOrUndefined,
+  isTypedObject: () => isTypedObject,
+  isUndefined: () => isUndefined,
+  isZero: () => isZero,
+  tryOr: () => tryOr
+});
+var enum_exports = {};
+__export2(enum_exports, {
+  forEachEnum: () => forEachEnum,
+  getEnumEntries: () => getEnumEntries,
+  getEnumKey: () => getEnumKey,
+  getEnumKeys: () => getEnumKeys,
+  getEnumValues: () => getEnumValues
+});
+function getEnumKeys(e) {
+  return Object.keys(e).filter((k) => isNaN(Number(k)));
+}
+function getEnumValues(e) {
+  return getEnumKeys(e).map((k) => e[k]);
+}
+function getEnumEntries(e) {
+  return getEnumKeys(e).map((k) => [k, e[k]]);
+}
+function getEnumKey(e, value) {
+  return getEnumKeys(e).find((k) => e[k] === value);
+}
+function forEachEnum(e, callback) {
+  for (const [k, v] of getEnumEntries(e)) callback(k, v);
+}
+function isStrictEqual(val1, val2) {
+  return val1 === val2;
+}
+function isDeepEqual(val1, val2) {
+  return deepEqual(val1, val2);
+}
+function isUndefined(val) {
+  return val === void 0;
+}
+function isNull(val) {
+  return val === null;
+}
+function isNullish(val) {
+  return val === void 0 || val === null;
+}
+function isDefined(val) {
+  return val !== void 0;
+}
+function isNonNull(val) {
+  return val !== null;
+}
+function isObject(val) {
+  return typeof val === "object" && val !== null && !isArray(val);
+}
+function isEmptyObject(val) {
+  return isObject(val) && Object.keys(val).length === 0;
+}
+function isObjectOrUndefined(val) {
+  return val === void 0 || isObject(val);
+}
+function isPlainObject(val) {
+  if (!isObject(val)) return false;
+  const proto = Object.getPrototypeOf(val);
+  return proto === Object.prototype || proto === null;
+}
+function isTypedObject(val, keys) {
+  return isObject(val) && keys.every((k) => k in val);
+}
+function isSet(val) {
+  return val instanceof Set;
+}
+function isArray(arr) {
+  return !!arr && Object.prototype.toString.call(arr) === "[object Array]";
+}
+function isArrayOrUndefined(arr) {
+  return arr === void 0 || isArray(arr);
+}
+function isEmptyArray(arr) {
+  return isArray(arr) && arr.length === 0;
+}
+function isNonEmptyArray(arr) {
+  return isArray(arr) && arr.length > 0;
+}
+function isEmptyArrayOrUndefined(arr) {
+  return isArray(arr) && arr.length === 0 || arr === void 0;
+}
+function isNonEmptyArrayOrUndefined(arr) {
+  return isArray(arr) && arr.length > 0 || arr === void 0;
+}
+function isString(val) {
+  return typeof val === "string";
+}
+function isEmptyString(val) {
+  return typeof val === "string" && val.length === 0;
+}
+function isNonEmptyString(val) {
+  return typeof val === "string" && val.length > 0;
+}
+function isStringOrUndefined(val) {
+  return val === void 0 || typeof val === "string";
+}
+function isEmptyStringOrUndefined(val) {
+  return typeof val === "string" && val.length === 0 || val === void 0;
+}
+function isNonEmptyStringOrUndefined(val) {
+  return typeof val === "string" && val.length > 0 || val === void 0;
+}
+function isBoolean(val) {
+  return typeof val === "boolean";
+}
+function isBooleanOrUndefined(val) {
+  return val === void 0 || typeof val === "boolean";
+}
+function isTrue(val) {
+  return val === true;
+}
+function isTrueOrUndefined(val) {
+  return val === true || val === void 0;
+}
+function isFalse(val) {
+  return val === false;
+}
+function isFalseOrUndefined(val) {
+  return val === false || val === void 0;
+}
+function isFunction(val) {
+  return typeof val === "function";
+}
+function isFunctionOrUndefined(val) {
+  return val === void 0 || typeof val === "function";
+}
+function isEnumValue(val, enumObj) {
+  return getEnumValues(enumObj).some((v) => v === val);
+}
+function isEnumValueOrUndefined(val, enumObj) {
+  return val === void 0 || getEnumValues(enumObj).some((v) => v === val);
+}
+function isNumericString(val) {
+  if (typeof val !== "string" || val.trim() === "") return false;
+  const n = +val;
+  return Number.isFinite(n);
+}
+function isBigInt(val) {
+  return typeof val === "bigint";
+}
+function isNumber(val) {
+  return typeof val === "number";
+}
+function isSafeNumber(val) {
+  return isNumber(val) && Number.isSafeInteger(val);
+}
+function isNumberOrUndefined(val) {
+  return typeof val === "number" || val === void 0;
+}
+function isNumberEq(val, ref) {
+  return isNumber(val) && val === ref;
+}
+function isNumberGt(val, ref) {
+  return isNumber(val) && isNumber(ref) && val > ref;
+}
+function isNumberGte(val, ref) {
+  return isNumber(val) && isNumber(ref) && val >= ref;
+}
+function isNumberLt(val, ref) {
+  return isNumber(val) && isNumber(ref) && val < ref;
+}
+function isNumberLte(val, ref) {
+  return isNumber(val) && isNumber(ref) && val <= ref;
+}
+function isNumberBetween(val, min, max) {
+  return isNumber(val) && isNumber(min) && isNumber(max) && val >= min && val <= max;
+}
+function isNumberBetweenExclusive(val, min, max) {
+  return isNumber(val) && isNumber(min) && isNumber(max) && val > min && val < max;
+}
+function isFinite2(val) {
+  return typeof val === "number" && Number.isFinite(val);
+}
+function isFloat(val) {
+  return isFinite2(val) && !isInteger(val);
+}
+function isInteger(val) {
+  return typeof val === "number" && isFinite2(val) && val === Math.trunc(val);
+}
+function isSafeInteger(val) {
+  return isInteger(val) && Number.isSafeInteger(val);
+}
+function isIntegerOrUndefined(val) {
+  return typeof val === "number" && isFinite2(val) && val === Math.trunc(val) || val === void 0;
+}
+function isIntegerEq(val, ref) {
+  return isInteger(val) && val === ref;
+}
+function isIntegerGt(val, ref) {
+  return isInteger(val) && isNumber(ref) && val > ref;
+}
+function isIntegerGte(val, ref) {
+  return isInteger(val) && isNumber(ref) && val >= ref;
+}
+function isIntegerLt(val, ref) {
+  return isInteger(val) && isNumber(ref) && val < ref;
+}
+function isIntegerLte(val, ref) {
+  return isInteger(val) && isNumber(ref) && val <= ref;
+}
+function isIntegerBetween(val, min, max) {
+  return isInteger(val) && isNumber(min) && isNumber(max) && val >= min && val <= max;
+}
+function isIntegerBetweenExclusive(val, min, max) {
+  return isInteger(val) && isNumber(min) && isNumber(max) && val > min && val < max;
+}
+function isNaNValue(val) {
+  return typeof val === "number" && Number.isNaN(val);
+}
+function isInfinity(val) {
+  return val === Infinity || val === -Infinity;
+}
+function isPosInfinity(val) {
+  return val === Infinity;
+}
+function isNegInfinity(val) {
+  return val === -Infinity;
+}
+function isPos(val) {
+  return typeof val === "number" && val > 0;
+}
+function isNeg(val) {
+  return typeof val === "number" && val < 0;
+}
+function isNonPos(val) {
+  return typeof val === "number" && val <= 0;
+}
+function isNonNeg(val) {
+  return typeof val === "number" && val >= 0;
+}
+function isZero(val) {
+  return typeof val === "number" && val === 0;
+}
+function isPosZero(val) {
+  return typeof val === "number" && val === 0 && 1 / val === Infinity;
+}
+function isNegZero(val) {
+  return typeof val === "number" && val === 0 && 1 / val === -Infinity;
+}
+function isOdd(val) {
+  return isInteger(val) && Math.abs(val) % 2 === 1;
+}
+function isEven(val) {
+  return isInteger(val) && val % 2 === 0;
+}
+function isMultipleOf(val, base) {
+  return typeof val === "number" && typeof base === "number" && val % base === 0;
+}
+function isPowerOfTwo(val) {
+  return isInteger(val) && val > 0 && (val & val - 1) === 0;
+}
+function isIncluded(val, container) {
+  if (isArray(container)) {
+    return container.includes(val);
+  }
+  if (isSet(container)) {
+    return container.has(val);
+  }
+  return false;
+}
+function isIndex(index, array) {
+  return isArray(array) ? isIntegerBetween(index, 0, array.length - 1) : isIntegerGte(index, 0);
+}
+function doesThrow(throwTestFn) {
+  try {
+    throwTestFn();
+    return false;
+  } catch (err) {
+    return true;
+  }
+}
+function doesNotThrow(throwTestFn) {
+  try {
+    throwTestFn();
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+function tryOr(tryFn, orVal) {
+  try {
+    return tryFn();
+  } catch (err) {
+    return isFunction(orVal) ? orVal() : orVal;
+  }
+}
+function hasProperties(obj, props) {
+  return isObject(obj) && props.every((p) => p in obj);
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i) => deepEqual(val, b[i]));
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+function getCtorName(obj) {
+  if (obj === null) return "null";
+  if (isArray(obj)) return "Array";
+  if (typeof obj !== "object") return typeof obj;
+  const tag = Object.prototype.toString.call(obj).slice(8, -1);
+  return tag || "Object";
+}
+function toCharArray(str2) {
+  return str2.split("");
+}
+function repeatString(repeatString2, repeatCount) {
+  if (!isInteger(repeatCount) || repeatCount < 0) {
+    throw new Error("repeatStr: Invalid repeatCount = " + repeatCount);
+  }
+  return new Array(repeatCount + 1).join(repeatString2);
+}
+function chunkString(str2, chunkSize) {
+  if (!isInteger(chunkSize) || chunkSize < 1) {
+    throw new Error("chunckString: Invalid chuckSize = " + chunkSize);
+  }
+  let result = [];
+  for (let i = 0; i < str2.length; i += chunkSize) {
+    result.push(str2.slice(i, i + chunkSize));
+  }
+  return result;
+}
+function replaceAt(str2, pos, removeCount, insert) {
+  if (!isInteger(removeCount) || removeCount < 0) {
+    throw new Error("replaceAt: Invalid removeCount = " + removeCount);
+  } else if (!isInteger(pos) || pos < 0 || pos + removeCount > str2.length) {
+    throw new Error("replaceAt: Invalid pos = " + pos + ", removeCount = " + removeCount + ", str.length = " + str2.length);
+  } else {
+    return str2.substring(0, pos) + insert + str2.substring(pos + removeCount);
+  }
+}
+function insertAt(str2, pos, insertStr) {
+  return replaceAt(str2, pos, 0, insertStr);
+}
+function removeAt(str2, pos, removeCount) {
+  return replaceAt(str2, pos, removeCount, "");
+}
+function charCount(str2, ch) {
+  if (ch.length !== 1 || str2.length === 0) return 0;
+  let count = 0;
+  for (let i = 0; i < str2.length; i++) {
+    if (str2[i] === ch) count++;
+  }
+  return count;
+}
+function makeSentenceFromPascal(PascalString) {
+  if (PascalString === "") {
+    return "";
+  }
+  let word = PascalString.charAt(0);
+  let sentence = "";
+  const addWord = () => {
+    if (word !== "") {
+      if (sentence === "") {
+        sentence += word.charAt(0).toUpperCase() + word.substring(1);
+      } else {
+        sentence += " " + word;
+      }
+      word = "";
+    }
+  };
+  const isLetterAndCapital = (c) => {
+    return c.toUpperCase() !== c.toLowerCase() && c === c.toUpperCase();
+  };
+  for (let i = 1; i < PascalString.length; i++) {
+    let c = PascalString.charAt(i);
+    if (isLetterAndCapital(c)) {
+      addWord();
+    }
+    word += c.toLowerCase();
+  }
+  addWord();
+  return sentence;
+}
+function stringify(value, maxDepth = 5, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const t = typeof value;
+  switch (t) {
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (isNaNValue(value)) return "NaN";
+      if (!isFinite2(value))
+        return value < 0 ? "-Infinity" : "Infinity";
+      return value.toString();
+    case "bigint":
+      return `${value}n`;
+    case "string":
+      return `"${value}"`;
+    case "symbol":
+      return value.description ? `Symbol(${value.description})` : "Symbol()";
+    case "function":
+      return `[Function${value.name ? ` ${value.name}` : ""}]`;
+  }
+  if (seen.has(value))
+    return "[Circular]";
+  if (maxDepth <= 0)
+    return "[Depth limit]";
+  maxDepth--;
+  seen.add(value);
+  const strfy = (v) => stringify(v, maxDepth, seen);
+  if (isArray(value)) {
+    const inner = value.map((v) => strfy(v)).join(", ");
+    return inner.length === 0 ? "[ ]" : `[ ${inner} ]`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    if (value instanceof DataView)
+      return `DataView(${value.byteLength})`;
+    const inner = Array.from(value).map((v) => strfy(v)).join(", ");
+    return `${value.constructor.name}[ ${inner} ]`;
+  }
+  if (value instanceof ArrayBuffer)
+    return `ArrayBuffer(${value.byteLength})`;
+  if (value instanceof Map) {
+    const entries = Array.from(value.entries()).map(([k, v]) => `${strfy(k)} => ${strfy(v)}`).join(", ");
+    return entries.length === 0 ? `Map(${value.size}){ }` : `Map(${value.size}){ ${entries} }`;
+  }
+  if (value instanceof Set) {
+    const entries = Array.from(value.values()).map((v) => strfy(v)).join(", ");
+    return entries.length === 0 ? `Set(${value.size}){ }` : `Set(${value.size}){ ${entries} }`;
+  }
+  if (value instanceof WeakMap)
+    return "WeakMap{ ? }";
+  if (value instanceof WeakSet)
+    return "WeakSet{ ? }";
+  if (value instanceof Date)
+    return `Date("${value.toISOString()}")`;
+  if (value instanceof RegExp)
+    return value.toString();
+  if (value instanceof Error)
+    return `${value.name}("${value.message}")`;
+  if (value instanceof Promise)
+    return "Promise{ ? }";
+  if (value instanceof URL)
+    return `URL("${value.href}")`;
+  if (value instanceof URLSearchParams)
+    return `URLSearchParams("${value.toString()}")`;
+  if (value === Math) return "Math";
+  if (value === JSON) return "JSON";
+  if (value === Reflect) return "Reflect";
+  if (value === Intl) return "Intl";
+  const hasCustomToString = typeof (value == null ? void 0 : value.toString) === "function" && value.toString !== Object.prototype.toString;
+  if (hasCustomToString) {
+    try {
+      const str2 = value.toString();
+      if (!/^\[object .+\]$/.test(str2)) return str2;
+    } catch (e) {
+    }
+  }
+  if (t === "object") {
+    const ctorName = getCtorName(value);
+    const entries = Object.entries(value).map(
+      ([key, val]) => `${strfy(key)}: ${strfy(val)}`
+    );
+    if (entries.length === 0) return `${ctorName}{ }`;
+    return `${ctorName}{ ${entries.join(", ")} }`;
+  }
+  return String(value);
+}
+function splitByCaps(str2) {
+  return str2.split(/(?=[A-Z])/).filter((x) => !!x);
+}
+function splitByStrings(str2, ...splitters) {
+  if (splitters.length === 0) return [str2];
+  const escaped = splitters.map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const regex = new RegExp(escaped.join("|"), "g");
+  return str2.split(regex);
+}
+function splitByChars(str2, splitters) {
+  return splitByStrings(str2, ...splitters.split(""));
+}
+var fmt = stringify;
+var errorConstructor = Error;
+function setErrorClass(errorClass) {
+  errorConstructor = errorClass != null ? errorClass : Error;
+}
+function _fail(...msgs) {
+  let msg = msgs.join(", ");
+  throw new errorConstructor("Assertion Failed!" + (msg === "" ? "" : " " + msg));
+}
+function assert(condition, msg) {
+  if (!condition) {
+    _fail(msg);
+  }
+}
+function require2(val, msg) {
+  if (val == null) {
+    _fail(`Expected ${fmt(val)} not to be nullish`, msg);
+  }
+  return val;
+}
+function requireDefined(val, msg) {
+  if (val === void 0) {
+    _fail(`Expected ${fmt(val)} not to be undefined`, msg);
+  }
+  return val;
+}
+function requireElement(index, array, msg) {
+  if (!guard_exports.isIndex(index, array))
+    _fail(`Expected ${index} to be index for array ${fmt(array)}`, msg);
+  return array[index];
+}
+function fail(msg) {
+  _fail(msg);
+}
+function isStrictEqual2(val1, val2, msg) {
+  if (!guard_exports.isStrictEqual(val1, val2))
+    _fail(`Expected ${fmt(val1)} to ne strict equal to ${val2}`, msg);
+  return val1;
+}
+function isDeepEqual2(val1, val2, msg) {
+  if (!guard_exports.isDeepEqual(val1, val2))
+    _fail(`Expected ${fmt(val1)} to deep equal with ${fmt(val2)}`, msg);
+  return val1;
+}
+function isUndefined2(val, msg) {
+  if (!guard_exports.isUndefined(val))
+    _fail(`Expected ${fmt(val)} to be undefined`, msg);
+  return val;
+}
+function isNull2(val, msg) {
+  if (!guard_exports.isNull(val))
+    _fail(`Expected ${fmt(val)} to be null`, msg);
+  return val;
+}
+function isNullish2(val, msg) {
+  if (!guard_exports.isNullish(val))
+    _fail(`Expected ${fmt(val)} to be null or undefined`, msg);
+  return val;
+}
+function isDefined2(val, msg) {
+  if (!guard_exports.isDefined(val)) {
+    _fail(`Expected ${fmt(val)} to be defined`, msg);
+  }
+  return val;
+}
+function isNonNull2(val, msg) {
+  if (!guard_exports.isNonNull(val)) {
+    _fail(`Expected ${fmt(val)} to be defined`, msg);
+  }
+  return val;
+}
+function isObject2(val, msg) {
+  if (!guard_exports.isObject(val))
+    _fail(`Expected ${fmt(val)} to be object`, msg);
+  return val;
+}
+function isEmptyObject2(val, msg) {
+  if (!guard_exports.isEmptyObject(val))
+    _fail(`Expected ${fmt(val)} to be empty object`, msg);
+  return val;
+}
+function isPlainObject2(val, msg) {
+  if (!guard_exports.isPlainObject(val))
+    _fail(`Expected ${fmt(val)} to be plain object`, msg);
+  return val;
+}
+function isObjectOrUndefined2(val, msg) {
+  if (!guard_exports.isObjectOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be object or undefined`, msg);
+  return val;
+}
+function isTypedObject2(val, keys, msg) {
+  if (!guard_exports.isTypedObject(val, keys))
+    _fail(`Expected ${fmt(val)} to have keys ${fmt(keys)}`, msg);
+  return val;
+}
+function isArray2(val, msg) {
+  if (!guard_exports.isArray(val))
+    _fail(`Expected ${fmt(val)} to be array`, msg);
+  return val;
+}
+function isArrayOrUndefined2(val, msg) {
+  if (!guard_exports.isArrayOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be array or undefined`, msg);
+  return true;
+}
+function isEmptyArray2(val, msg) {
+  if (!guard_exports.isEmptyArray(val))
+    _fail(`Expected ${fmt(val)} to be empty array`, msg);
+}
+function isNonEmptyArray2(val, msg) {
+  if (!guard_exports.isNonEmptyArray(val))
+    _fail(`Expected ${fmt(val)} to be non-empty array`, msg);
+}
+function isEmptyArrayOrUndefined2(val, msg) {
+  if (!guard_exports.isEmptyArrayOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be empty array or undefined`, msg);
+}
+function isNonEmptyArrayOrUndefined2(val, msg) {
+  if (!guard_exports.isNonEmptyArrayOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be non-empty array or undefined`, msg);
+}
+function isString2(val, msg) {
+  if (!guard_exports.isString(val))
+    _fail(`Expected ${fmt(val)} to be string`, msg);
+  return val;
+}
+function isEmptyString2(val, msg) {
+  if (!guard_exports.isEmptyString(val))
+    _fail(`Expected ${fmt(val)} to be empty string`, msg);
+  return val;
+}
+function isNonEmptyString2(val, msg) {
+  if (!guard_exports.isNonEmptyString(val))
+    _fail(`Expected ${fmt(val)} to be non-empty string`, msg);
+  return val;
+}
+function isStringOrUndefined2(val, msg) {
+  if (!guard_exports.isStringOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be string or undefined`, msg);
+  return val;
+}
+function isEmptyStringOrUndefined2(val, msg) {
+  if (!guard_exports.isEmptyStringOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be empty string or undefined`, msg);
+  return val;
+}
+function isNonEmptyStringOrUndefined2(val, msg) {
+  if (!guard_exports.isNonEmptyStringOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be non-empty string or undefined`, msg);
+  return val;
+}
+function isBoolean2(val, msg) {
+  if (!guard_exports.isBoolean(val))
+    _fail(`Expected ${fmt(val)} to be boolean`, msg);
+  return val;
+}
+function isBooleanOrUndefined2(val, msg) {
+  if (!guard_exports.isBooleanOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be boolean or undefined`, msg);
+  return val;
+}
+function isTrue2(val, msg) {
+  if (!guard_exports.isTrue(val))
+    _fail(`Expected ${fmt(val)} to be true`, msg);
+  return val;
+}
+function isTrueOrUndefined2(val, msg) {
+  if (!guard_exports.isTrueOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be true or undefined`, msg);
+  return val;
+}
+function isFalse2(val, msg) {
+  if (!guard_exports.isFalse(val))
+    _fail(`Expected ${fmt(val)} to be false`, msg);
+  return val;
+}
+function isFalseOrUndefined2(val, msg) {
+  if (!guard_exports.isFalseOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be false or undefined`, msg);
+  return val;
+}
+function isFunction2(val, msg) {
+  if (!guard_exports.isFunction(val))
+    _fail(`Expected ${fmt(val)} to be function`, msg);
+  return val;
+}
+function isFunctionOrUndefined2(val, msg) {
+  if (!guard_exports.isFunctionOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be function or undefined`, msg);
+  return val;
+}
+function isEnumValue2(val, enumObject, msg) {
+  if (!guard_exports.isEnumValue(val, enumObject))
+    _fail(`Expected ${fmt(val)} to be enum val`, msg);
+  return val;
+}
+function isEnumValueOrUndefined2(val, enumObject, msg) {
+  if (!guard_exports.isEnumValueOrUndefined(val, enumObject))
+    _fail(`Expected ${fmt(val)} to be enum val or undefined`, msg);
+  return val;
+}
+function isNumericString2(val, msg) {
+  if (!guard_exports.isNumericString(val))
+    _fail(`Expected ${fmt(val)} to be numeric string`, msg);
+  return val;
+}
+function isBigInt2(val, msg) {
+  if (!guard_exports.isBigInt(val))
+    _fail(`Expected ${fmt(val)} to be BigInt`, msg);
+  return val;
+}
+function isNumber2(val, msg) {
+  if (!guard_exports.isNumber(val))
+    _fail(`Expected ${fmt(val)} to be number`, msg);
+  return val;
+}
+function isSafeNumber2(val, msg) {
+  if (!guard_exports.isSafeNumber(val))
+    _fail(`Expected ${fmt(val)} to be safe number`, msg);
+  return val;
+}
+function isNumberOrUndefined2(val, msg) {
+  if (!guard_exports.isNumberOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be number or undefined`, msg);
+  return val;
+}
+function isNumberEq2(val, ref, msg) {
+  if (!guard_exports.isNumberEq(val, ref))
+    _fail(`Expected ${fmt(val)} to be number equal to ${fmt(ref)}`, msg);
+  return val;
+}
+function isNumberGt2(val, ref, msg) {
+  if (!guard_exports.isNumberGt(val, ref))
+    _fail(`Expected ${fmt(val)} to be number > ${fmt(ref)}`, msg);
+  return val;
+}
+function isNumberGte2(val, ref, msg) {
+  if (!guard_exports.isNumberGte(val, ref))
+    _fail(`Expected ${fmt(val)} to be number >= ${fmt(ref)}`, msg);
+  return val;
+}
+function isNumberLt2(val, ref, msg) {
+  if (!guard_exports.isNumberLt(val, ref))
+    _fail(`Expected ${fmt(val)} to be number < ${fmt(ref)}`, msg);
+  return val;
+}
+function isNumberLte2(val, ref, msg) {
+  if (!guard_exports.isNumberLte(val, ref))
+    _fail(`Expected ${fmt(val)} to be number <= ${fmt(ref)}`, msg);
+  return val;
+}
+function isNumberBetween2(val, min, max, msg) {
+  if (!guard_exports.isNumberBetween(val, min, max))
+    _fail(`Expected number ${fmt(min)} <= ${fmt(val)} <= ${fmt(max)}`, msg);
+  return val;
+}
+function isNumberBetweenExclusive2(val, min, max, msg) {
+  if (!guard_exports.isNumberBetweenExclusive(val, min, max))
+    _fail(`Expected number ${fmt(min)} < ${fmt(val)} < ${fmt(max)}`, msg);
+  return val;
+}
+function isFinite3(val, msg) {
+  if (!guard_exports.isFinite(val))
+    _fail(`Expected ${fmt(val)} to be finite`, msg);
+  return val;
+}
+function isFloat2(val, msg) {
+  if (!guard_exports.isFloat(val))
+    _fail(`Expected ${fmt(val)} to be float`, msg);
+  return val;
+}
+function isInteger2(val, msg) {
+  if (!guard_exports.isInteger(val))
+    _fail(`Expected ${fmt(val)} to be integer`, msg);
+  return val;
+}
+function isSafeInteger2(val, msg) {
+  if (!guard_exports.isSafeInteger(val))
+    _fail(`Expected ${fmt(val)} to be safe integer`, msg);
+  return val;
+}
+function isIntegerOrUndefined2(val, msg) {
+  if (!guard_exports.isIntegerOrUndefined(val))
+    _fail(`Expected ${fmt(val)} to be integer or undefined`, msg);
+  return val;
+}
+function isIntegerEq2(val, ref, msg) {
+  if (!guard_exports.isIntegerEq(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer equal to ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerGt2(val, ref, msg) {
+  if (!guard_exports.isIntegerGt(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer > ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerGte2(val, ref, msg) {
+  if (!guard_exports.isIntegerGte(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer >= ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerLt2(val, ref, msg) {
+  if (!guard_exports.isIntegerLt(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer < ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerLte2(val, ref, msg) {
+  if (!guard_exports.isIntegerLte(val, ref))
+    _fail(`Expected ${fmt(val)} to be integer <= ${fmt(ref)}`, msg);
+  return val;
+}
+function isIntegerBetween2(val, min, max, msg) {
+  if (!guard_exports.isIntegerBetween(val, min, max))
+    _fail(`Expected integer ${fmt(min)} <= ${fmt(val)} <= ${fmt(max)}`, msg);
+  return val;
+}
+function isIntegerBetweenExclusive2(val, min, max, msg) {
+  if (!guard_exports.isIntegerBetweenExclusive(val, min, max))
+    _fail(`Expected integer ${fmt(min)} < ${fmt(val)} < ${fmt(max)}`, msg);
+  return val;
+}
+function isNaNValue2(val, msg) {
+  if (!guard_exports.isNaNValue(val))
+    _fail(`Expected ${fmt(val)} to be NaN`, msg);
+  return NaN;
+}
+function isInfinity2(val, msg) {
+  if (!guard_exports.isInfinity(val))
+    _fail(`Expected ${fmt(val)} to be +-Infinity`, msg);
+  return val;
+}
+function isPosInfinity2(val, msg) {
+  if (!guard_exports.isPosInfinity(val))
+    _fail(`Expected ${fmt(val)} to be +Infinity`, msg);
+  return val;
+}
+function isNegInfinity2(val, msg) {
+  if (!guard_exports.isNegInfinity(val))
+    _fail(`Expected ${fmt(val)} to be -Infinity`, msg);
+  return val;
+}
+function isPos2(val, msg) {
+  if (!guard_exports.isPos(val))
+    _fail(`Expected ${fmt(val)} to be positive (> 0)`, msg);
+  return val;
+}
+function isNeg2(val, msg) {
+  if (!guard_exports.isNeg(val))
+    _fail(`Expected ${fmt(val)} to be negative (< 0)`, msg);
+  return val;
+}
+function isNonPos2(val, msg) {
+  if (!guard_exports.isNonPos(val))
+    _fail(`Expected ${fmt(val)} to be non-positive (<= 0)`, msg);
+  return val;
+}
+function isNonNeg2(val, msg) {
+  if (!guard_exports.isNonNeg(val))
+    _fail(`Expected ${fmt(val)} to be non-negative (>= 0)`, msg);
+  return val;
+}
+function isZero2(val, msg) {
+  if (!guard_exports.isZero(val))
+    _fail(`Expected ${fmt(val)} to be 0`, msg);
+  return val;
+}
+function isPosZero2(val, msg) {
+  if (!guard_exports.isPosZero(val))
+    _fail(`Expected ${fmt(val)} to be +0`, msg);
+  return val;
+}
+function isNegZero2(val, msg) {
+  if (!guard_exports.isNegZero(val))
+    _fail(`Expected ${fmt(val)} to be -0`, msg);
+  return val;
+}
+function isOdd2(val, msg) {
+  if (!guard_exports.isOdd(val))
+    _fail(`Expected ${fmt(val)} to odd`, msg);
+  return val;
+}
+function isEven2(val, msg) {
+  if (!guard_exports.isEven(val))
+    _fail(`Expected ${fmt(val)} to even`, msg);
+  return val;
+}
+function isMultipleOf2(val, base, msg) {
+  if (!guard_exports.isMultipleOf(val, base))
+    _fail(`Expected ${fmt(val)} to be divisble bu ${fmt(base)}`, msg);
+  return val;
+}
+function isPowerOfTwo2(val, msg) {
+  if (!guard_exports.isPowerOfTwo(val))
+    _fail(`Expected ${fmt(val)} to be power of two`, msg);
+  return val;
+}
+function isIncluded2(val, arr, msg) {
+  if (!guard_exports.isIncluded(val, arr))
+    _fail(`Expected ${fmt(val)} to be included in ${fmt(arr)}`, msg);
+  return val;
+}
+function isIndex2(...args) {
+  const index = args.shift();
+  const msg = guard_exports.isString(args[args.length - 1]) ? args.pop() : void 0;
+  const arr = guard_exports.isArray(args[0]) ? args.shift() : void 0;
+  if (!guard_exports.isIndex(index, arr)) {
+    if (arr === void 0)
+      _fail(`Expected ${index} to be index`, msg);
+    else
+      _fail(`Expected ${index} to be index for ${fmt(arr)}`, msg);
+  }
+  return index;
+}
+function doesThrow2(throwTestFn, msg) {
+  if (!guard_exports.doesThrow(throwTestFn))
+    _fail(`Expected to throw`, msg);
+  return true;
+}
+function doesNotThrow2(throwTestFn, msg) {
+  if (!guard_exports.doesNotThrow(throwTestFn))
+    _fail(`Expected to throw`, msg);
+  return true;
+}
+var cookies_exports = {};
+__export2(cookies_exports, {
+  accept: () => accept,
+  decline: () => decline,
+  erase: () => erase,
+  eraseAll: () => eraseAll,
+  isConsentPending: () => isConsentPending,
+  read: () => read,
+  readBool: () => readBool,
+  readInt: () => readInt,
+  save: () => save,
+  setExpireDays: () => setExpireDays
+});
+var ConsentCookieName = "ConsentCookie";
+var _consent;
+var _expires;
+var str = _read(ConsentCookieName);
+_consent = str === "accept" || str === "decline" ? str : void 0;
+function _getCookieList() {
+  if (typeof document === "undefined")
+    return [];
+  let s = document.cookie;
+  return s.split(";").map((c) => c.trim());
+}
+function _save(name, value) {
+  let cookie = name + "=" + value.toString() + ";sameSite=Lax;";
+  if (_expires) {
+    cookie += "expires=" + _expires.toUTCString() + ";";
+  }
+  if (typeof document !== "undefined")
+    document.cookie = cookie;
+  return value;
+}
+function _read(name, defaultValue) {
+  let str2 = _getCookieList().find((c) => c.startsWith(name + "="));
+  return str2 === void 0 ? defaultValue : str2.substring(name.length + 1);
+}
+function _erase(name) {
+  if (typeof document !== "undefined")
+    document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 UTC;";
+}
+function setExpireDays(days) {
+  _expires = /* @__PURE__ */ new Date();
+  _expires.setDate(_expires.getDate() + days);
+}
+function isConsentPending() {
+  return _consent === void 0;
+}
+function accept() {
+  _consent = "accept";
+  _save(ConsentCookieName, _consent);
+}
+function decline() {
+  _consent = "decline";
+  _save(ConsentCookieName, _consent);
+}
+function save(name, value) {
+  if (_consent === "accept")
+    _save(name, value);
+  return value;
+}
+function read(name, defaultValue) {
+  var _a;
+  if (_consent === "accept")
+    return (_a = _read(name, defaultValue)) != null ? _a : defaultValue;
+  else
+    return defaultValue;
+}
+function readInt(name, defaultValue) {
+  if (_consent === "accept") {
+    let str2 = _read(name);
+    return str2 === void 0 ? defaultValue : parseInt(str2);
+  } else {
+    return defaultValue;
+  }
+}
+function readBool(name, defaultValue) {
+  if (_consent === "accept") {
+    let str2 = _read(name);
+    return str2 === void 0 ? defaultValue : /true|1/i.test(str2);
+  } else {
+    return defaultValue;
+  }
+}
+function erase(name) {
+  if (_consent === "accept" || name === ConsentCookieName)
+    _erase(name);
+}
+function eraseAll() {
+  if (typeof document !== "undefined")
+    document.cookie.split(";").forEach((c) => erase(c.trim().split("=")[0]));
+}
+var device_exports = {};
+__export2(device_exports, {
+  DPI: () => DPI,
+  FontSize: () => FontSize,
+  HostAddress: () => HostAddress,
+  IsMobileDevice: () => IsMobileDevice,
+  IsTouchDevice: () => IsTouchDevice,
+  PxPerMm: () => PxPerMm,
+  ScrollbarWidth: () => ScrollbarWidth,
+  mmToPx: () => mmToPx,
+  pxToMm: () => pxToMm,
+  toPx: () => toPx
+});
+function getDPI() {
+  try {
+    let el = document.createElement("div");
+    el.style.width = "1in";
+    document.body.appendChild(el);
+    let dpi = el.offsetWidth;
+    el.remove();
+    return dpi || 96;
+  } catch (e) {
+    return 96;
+  }
+}
+function getScrollBarWidth() {
+  try {
+    let outer = document.createElement("div");
+    outer.style.visibility = "hidden";
+    outer.style.width = "100px";
+    document.body.appendChild(outer);
+    let widthNoScroll = outer.offsetWidth;
+    outer.style.overflow = "scroll";
+    let inner = document.createElement("div");
+    inner.style.width = "100%";
+    outer.appendChild(inner);
+    let widthWithScroll = inner.offsetWidth;
+    if (outer.parentNode) {
+      outer.parentNode.removeChild(outer);
+    }
+    return widthNoScroll - widthWithScroll;
+  } catch (e) {
+    return 0;
+  }
+}
+function getSystemFontSize() {
+  try {
+    let tmpDiv = document.createElement("div");
+    tmpDiv.style.cssText = "display:inline-block; padding:0; line-height:1; position:absolute; visibility:hidden; font-size:1em";
+    tmpDiv.appendChild(document.createTextNode("M"));
+    document.body.appendChild(tmpDiv);
+    let fontsize = tmpDiv.offsetHeight;
+    document.body.removeChild(tmpDiv);
+    return fontsize;
+  } catch (e) {
+    return 16;
+  }
+}
+function getIsTouchDevice() {
+  if (typeof window === "undefined")
+    return false;
+  if ("ontouchstart" in window || "DocumentTouch" in window || "createTouch" in document && "createTouchList" in document)
+    return true;
+  var prefixes = " -webkit- -moz- -o- -ms- ".split(" ");
+  var mq = function(query2) {
+    return window.matchMedia(query2).matches;
+  };
+  var query = ["(", prefixes.join("touch-enabled),("), "heartz", ")"].join("");
+  return mq(query);
+}
+function getIsMobileDevice() {
+  let a = navigator.userAgent || navigator.vendor || window.opera;
+  return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4));
+}
+function getHostAddress() {
+  if (typeof location === "undefined" || !location.host) {
+    return "localhost";
+  }
+  return `${location.protocol}//${location.host}`;
+}
+var UnitRegExp = /^(mm|cm|in|inch|px|em)$/;
+var ValueUnitRegExp = /^([0-9\\.]+)(.*)$/;
+var DPI = getDPI();
+var PxPerMm = DPI / 25.4;
+var ScrollbarWidth = getScrollBarWidth();
+var FontSize = getSystemFontSize();
+var IsTouchDevice = getIsTouchDevice();
+var IsMobileDevice = getIsMobileDevice();
+var HostAddress = getHostAddress();
+function pxToMm(px) {
+  return px / PxPerMm;
+}
+function mmToPx(mm) {
+  return mm * PxPerMm;
+}
+function toPx(input) {
+  if (typeof input === "number") {
+    return input;
+  }
+  let value = NaN;
+  let unit = void 0;
+  let match = input.toString().match(ValueUnitRegExp);
+  if (match && match[1]) {
+    value = parseFloat(match[1]);
+    let unitStr = match[2] ? match[2].toLowerCase() : "undefined";
+    let unitStrOk = UnitRegExp.test(unitStr);
+    unit = unitStrOk ? unitStr : void 0;
+    if (!unit) {
+      console.log("Unknown unit '" + unitStr + "' => using 'px'.");
+    }
+  } else {
+    value = parseFloat(input);
+  }
+  assert_exports.isFinite(value, "value in function toPx");
+  switch (unit) {
+    case "mm":
+      return mmToPx(value);
+    case "cm":
+      return mmToPx(value) * 10;
+    case "in":
+    case "inch":
+      return mmToPx(value) * 25.4;
+    case "em":
+      return FontSize * value;
+    default:
+    case "px":
+      return value;
+  }
+}
+var utils_exports = {};
+__export2(utils_exports, {
+  Arr: () => arr_exports,
+  Dom: () => dom_exports,
+  Enum: () => enum_exports,
+  Math: () => math_exports,
+  Obj: () => obj_exports,
+  Str: () => str_exports
+});
+var arr_exports = {};
+__export2(arr_exports, {
+  arrayContains: () => arrayContains,
+  chunckArray: () => chunckArray,
+  duplicate: () => duplicate,
+  fillArray: () => fillArray,
+  getRangeArray: () => getRangeArray,
+  getSequenceArray: () => getSequenceArray,
+  isArray: () => isArray,
+  mapRangeArray: () => mapRangeArray,
+  mapSequenceArray: () => mapSequenceArray,
+  removeDuplicates: () => removeDuplicates,
+  toArray: () => toArray
+});
+function toArray(a) {
+  return isArray(a) ? a : [a];
+}
+function duplicate(a) {
+  var _a;
+  return (_a = a == null ? void 0 : a.slice()) != null ? _a : [];
+}
+function removeDuplicates(arr, compareFn) {
+  return compareFn !== void 0 ? arr.filter((a, id, self) => id === self.findIndex((b) => compareFn(a, b))) : arr.filter((a, id, self) => id === self.indexOf(a));
+}
+function fillArray(fillValue, fillCount) {
+  if (!isInteger(fillCount) || fillCount < 0) {
+    throw new Error("fillArray: Invalid fillCount = " + fillCount);
+  }
+  return new Array(fillCount).fill(fillValue);
+}
+function mapSequenceArray(len, fn) {
+  if (!isInteger(len) || len < 0) {
+    throw new Error("mapSequenceArray: Invalid len = " + len);
+  }
+  let arr = new Array(len);
+  for (let i = 0; i < len; i++) {
+    arr[i] = fn(i);
+  }
+  return arr;
+}
+function getSequenceArray(len) {
+  return mapSequenceArray(len, (i) => i);
+}
+function mapRangeArray(start, end, fn) {
+  if (!isInteger(start)) {
+    throw new Error("mapRangeArray: Invalid start = " + end);
+  }
+  if (!isInteger(end)) {
+    throw new Error("mapRangeArray: Invalid end = " + end);
+  }
+  let len = Math.abs(end - start) + 1;
+  let arr = new Array(len);
+  for (let i = 0, s = start, inc = Math.sign(end - start); i < len; s += inc, i++) {
+    arr[i] = fn(s);
+  }
+  return arr;
+}
+function getRangeArray(start, end) {
+  return mapRangeArray(start, end, (i) => i);
+}
+function arrayContains(arg, item) {
+  return arg.indexOf(item) >= 0;
+}
+function chunckArray(arr, chunckSize) {
+  if (!isInteger(chunckSize) || chunckSize < 1) {
+    throw new Error("chunckArray: Invalid chunckSize = " + chunckSize);
+  }
+  let result = [];
+  for (let i = 0; i < arr.length; i += chunckSize) {
+    result.push(arr.slice(i, i + chunckSize));
+  }
+  return result;
+}
+var dom_exports = {};
+__export2(dom_exports, {
+  addClass: () => addClass,
+  appendTo: () => appendTo,
+  getButton: () => getButton,
+  getCanvas: () => getCanvas,
+  getCanvasTextWidth: () => getCanvasTextWidth,
+  getDimension: () => getDimension,
+  getHeight: () => getHeight,
+  getOffset: () => getOffset,
+  getPadding: () => getPadding,
+  getWidth: () => getWidth,
+  hasClass: () => hasClass,
+  removeClass: () => removeClass,
+  removeFromParent: () => removeFromParent,
+  setHeight: () => setHeight,
+  setOffset: () => setOffset,
+  setRect: () => setRect,
+  setVisibility: () => setVisibility,
+  setWidth: () => setWidth,
+  styleLayoutChanged: () => styleLayoutChanged
+});
+function _getElemById(id) {
+  var _a;
+  return typeof document === "undefined" ? void 0 : (_a = document.getElementById(id)) != null ? _a : void 0;
+}
+function toPx2(value) {
+  return value === void 0 ? void 0 : device_exports.toPx(value);
+}
+function hasClass(el, className) {
+  if (className.length === 0) {
+    return false;
+  } else if (el.classList) {
+    return el.classList.contains(className);
+  } else {
+    return !!el.className.match(new RegExp("(\\s|^)" + className + "(\\s|$)"));
+  }
+}
+function addClass(el, className) {
+  if (className.length === 0) {
+    return;
+  } else if (el.classList) {
+    el.classList.add(className);
+  } else if (!hasClass(el, className)) {
+    el.className += " " + className;
+  }
+}
+function removeClass(el, className) {
+  if (className.length === 0) {
+    return;
+  } else if (el.classList) {
+    el.classList.remove(className);
+  } else if (hasClass(el, className)) {
+    var reg = new RegExp("(\\s|^)" + className + "(\\s|$)");
+    el.className = el.className.replace(reg, " ");
+  }
+}
+function setOffset(el, left, top, unit = "px") {
+  el.style.left = left + unit;
+  el.style.top = top + unit;
+}
+function getOffset(el) {
+  let { left, top } = el.getBoundingClientRect();
+  if (typeof window !== "undefined") {
+    left += window.pageXOffset;
+    top += window.pageYOffset;
+  }
+  if (typeof document !== "undefined") {
+    let de = document.documentElement;
+    left -= de.clientLeft;
+    top -= de.clientTop;
+  }
+  return { left, top };
+}
+function getWidth(el) {
+  if (el instanceof Window) {
+    return el.innerWidth;
+  } else {
+    let w = parseFloat(getComputedStyle(el, null).width.replace("px", ""));
+    return isNaN(w) ? 0 : w;
+  }
+}
+function setWidth(el, val) {
+  el.style.width = val + "px";
+}
+function getHeight(el) {
+  if (el instanceof Window) {
+    return el.innerHeight;
+  } else {
+    let h = parseFloat(getComputedStyle(el, null).height.replace("px", ""));
+    return isNaN(h) ? 0 : h;
+  }
+}
+function setHeight(el, val) {
+  el.style.height = val + "px";
+}
+function appendTo(el, to) {
+  to.appendChild(el);
+}
+function removeFromParent(el) {
+  el.remove();
+}
+function setVisibility(el, visible) {
+  el.style.display = visible ? "block" : "none";
+}
+function setRect(el, left, top, width, height, unit = "px") {
+  el.style.left = left + unit;
+  el.style.top = top + unit;
+  el.style.width = width + unit;
+  el.style.height = height + unit;
+}
+function getButton(btn) {
+  let el = typeof btn === "string" ? _getElemById(btn) : btn;
+  return el instanceof HTMLButtonElement ? el : void 0;
+}
+function getCanvas(canvas2) {
+  let el = typeof canvas2 === "string" ? _getElemById(canvas2) : canvas2;
+  return el instanceof HTMLCanvasElement ? el : void 0;
+}
+function getPadding(style) {
+  var _a;
+  if (!style) {
+    return { top: 0, right: 0, bottom: 0, left: 0 };
+  }
+  let top = toPx2(style.paddingTop);
+  let right = toPx2(style.paddingRight);
+  let bottom = toPx2(style.paddingBottom);
+  let left = toPx2(style.paddingLeft);
+  let padding = ((_a = style.padding) != null ? _a : "").toString().split(" ").filter((s) => s.length > 0);
+  switch (padding.length) {
+    case 0:
+      break;
+    case 1:
+      top != null ? top : top = toPx2(padding[0]);
+      right != null ? right : right = toPx2(padding[0]);
+      bottom != null ? bottom : bottom = toPx2(padding[0]);
+      left != null ? left : left = toPx2(padding[0]);
+      break;
+    case 2:
+      top != null ? top : top = toPx2(padding[0]);
+      right != null ? right : right = toPx2(padding[1]);
+      bottom != null ? bottom : bottom = toPx2(padding[0]);
+      left != null ? left : left = toPx2(padding[1]);
+      break;
+    case 3:
+      top != null ? top : top = toPx2(padding[0]);
+      right != null ? right : right = toPx2(padding[1]);
+      bottom != null ? bottom : bottom = toPx2(padding[2]);
+      left != null ? left : left = toPx2(padding[1]);
+      break;
+    case 4:
+    default:
+      top != null ? top : top = toPx2(padding[0]);
+      right != null ? right : right = toPx2(padding[1]);
+      bottom != null ? bottom : bottom = toPx2(padding[2]);
+      left != null ? left : left = toPx2(padding[3]);
+      break;
+  }
+  top != null ? top : top = 0;
+  right != null ? right : right = 0;
+  bottom != null ? bottom : bottom = 0;
+  left != null ? left : left = 0;
+  return { top, right, bottom, left };
+}
+function getDimension(style) {
+  let left = toPx2(style == null ? void 0 : style.left);
+  let right = toPx2(style == null ? void 0 : style.right);
+  let top = toPx2(style == null ? void 0 : style.top);
+  let bottom = toPx2(style == null ? void 0 : style.bottom);
+  let width = toPx2(style == null ? void 0 : style.width);
+  let height = toPx2(style == null ? void 0 : style.height);
+  if (width === void 0 && left !== void 0 && right !== void 0) {
+    width = right - left;
+  }
+  if (height === void 0 && top !== void 0 && bottom !== void 0) {
+    height = bottom - top;
+  }
+  return { left, top, width, height };
+}
+function styleLayoutChanged(style1, style2) {
+  if (!style1 && !style2) {
+    return false;
+  } else if (!style1 || !style2) {
+    return true;
+  } else {
+    return style1.left !== style2.left || style1.top !== style2.top || style1.right !== style2.right || style1.bottom !== style2.bottom || style1.width !== style2.width || style1.height !== style2.height;
+  }
+}
+var canvas;
+function getCanvasTextWidth(text, font) {
+  if (!canvas && typeof document !== "undefined")
+    canvas = document.createElement("canvas");
+  let ctx = canvas == null ? void 0 : canvas.getContext("2d");
+  if (!ctx)
+    return 0;
+  ctx.font = font;
+  return ctx.measureText(text).width;
+}
+var math_exports = {};
+__export2(math_exports, {
+  avg: () => avg,
+  calcNormal: () => calcNormal,
+  clamp: () => clamp,
+  cmp: () => cmp,
+  interpolateCoord: () => interpolateCoord,
+  interpolateY: () => interpolateY,
+  isInteger: () => isInteger,
+  isNumber: () => isNumber,
+  linearToDecibels: () => linearToDecibels,
+  mod: () => mod,
+  romanize: () => romanize,
+  sum: () => sum,
+  toOrdinalNumber: () => toOrdinalNumber
+});
+function linearToDecibels(linearVolume) {
+  if (!isFinite(linearVolume)) {
+    throw new Error("linearToDecibel: Invalid linearVolume = " + linearVolume);
+  } else if (linearVolume <= 0) {
+    return -Infinity;
+  } else {
+    return 20 * Math.log10(linearVolume);
+  }
+}
+function mod(m, n) {
+  return (m % n + n) % n;
+}
+function romanize(n) {
+  if (!isInteger(n) || n < 0) {
+    throw new Error("romanize: Invalid n = " + n);
+  }
+  var digits = String(+n).split("");
+  var key = [
+    "",
+    "C",
+    "CC",
+    "CCC",
+    "CD",
+    "D",
+    "DC",
+    "DCC",
+    "DCCC",
+    "CM",
+    "",
+    "X",
+    "XX",
+    "XXX",
+    "XL",
+    "L",
+    "LX",
+    "LXX",
+    "LXXX",
+    "XC",
+    "",
+    "I",
+    "II",
+    "III",
+    "IV",
+    "V",
+    "VI",
+    "VII",
+    "VIII",
+    "IX"
+  ];
+  var roman = "", i = 3;
+  while (i--) roman = (key[+digits.pop() + i * 10] || "") + roman;
+  return Array(+digits.join("") + 1).join("M") + roman;
+}
+function toOrdinalNumber(n) {
+  if (!isInteger(n)) {
+    throw new Error("toOrdinalNumber: Invalid n = " + n);
+  }
+  const nStr = n.toString();
+  const lastDigit = Number(nStr.charAt(nStr.length - 1));
+  if (n === 1 || n >= 20 && lastDigit === 1) {
+    return nStr + "st";
+  } else if (n === 2 || n >= 20 && lastDigit === 2) {
+    return nStr + "nd";
+  } else if (n === 3 || n >= 20 && lastDigit === 3) {
+    return nStr + "rd";
+  } else {
+    return nStr + "th";
+  }
+}
+function interpolateCoord(startX, startY, endX, endY, t) {
+  return {
+    x: startX + (endX - startX) * t,
+    y: startY + (endY - startY) * t
+  };
+}
+function interpolateY(startX, startY, endX, endY, x) {
+  let t = (x - startX) / (endX - startX);
+  return startY + (endY - startY) * t;
+}
+function clamp(num, min, max) {
+  return Math.min(Math.max(num, min), max);
+}
+function calcNormal(x1, y1, x2, y2) {
+  let dx = x2 - x1;
+  let dy = y2 - y1;
+  let nx = -dy;
+  let ny = dx;
+  let len = Math.sqrt(nx * nx + ny * ny);
+  if (len > 0) {
+    nx /= len;
+    ny /= len;
+  } else {
+    nx = 0;
+    ny = 1;
+  }
+  return { nx, ny };
+}
+function sum(arr) {
+  return arr.reduce((prev, cur) => cur + prev, 0);
+}
+function avg(...values) {
+  return sum(values) / values.length;
+}
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var DefaultEqualityFn = (a, b) => a === b;
+var BaseContainer = class {
+};
+var LRUCache = class extends BaseContainer {
+  // Maximum key length.
+  constructor(maxSize, maxKeyLength = Infinity) {
+    super();
+    __publicField2(this, "cache");
+    __publicField2(this, "next");
+    __publicField2(this, "prev");
+    __publicField2(this, "head");
+    __publicField2(this, "tail");
+    __publicField2(this, "capacity");
+    __publicField2(this, "size");
+    __publicField2(this, "maxKeyLength");
+    this.cache = /* @__PURE__ */ Object.create(null);
+    this.next = /* @__PURE__ */ Object.create(null);
+    this.prev = /* @__PURE__ */ Object.create(null);
+    this.head = null;
+    this.tail = null;
+    this.capacity = maxSize;
+    this.size = 0;
+    this.maxKeyLength = maxKeyLength;
+  }
+  // Retrieves a value from the cache
+  get(key) {
+    if (key.length > this.maxKeyLength) return void 0;
+    if (this.cache[key] !== void 0) {
+      this.touch(key);
+      return this.cache[key];
+    }
+    return void 0;
+  }
+  set(key, value) {
+    if (key.length > this.maxKeyLength) {
+      return;
+    }
+    if (this.cache[key] !== void 0) {
+      this.cache[key] = value;
+      this.touch(key);
+      return;
+    }
+    if (this.size >= this.capacity) {
+      this.evict();
+    }
+    this.cache[key] = value;
+    this.addToTail(key);
+    this.size++;
+  }
+  // Marks a key as most recently used
+  touch(key) {
+    if (this.tail === key) return;
+    this.removeKey(key);
+    this.addToTail(key);
+  }
+  // Evicts the least recently used item (at the head)
+  evict() {
+    if (this.head !== null) {
+      const oldestKey = this.head;
+      this.removeKey(oldestKey);
+      delete this.cache[oldestKey];
+      this.size--;
+    }
+  }
+  // Removes a key from the linked list
+  removeKey(key) {
+    const prevKey = this.prev[key];
+    const nextKey = this.next[key];
+    if (prevKey !== void 0) {
+      this.next[prevKey] = nextKey;
+    } else {
+      this.head = nextKey != null ? nextKey : null;
+    }
+    if (nextKey !== void 0) {
+      this.prev[nextKey] = prevKey;
+    } else {
+      this.tail = prevKey != null ? prevKey : null;
+    }
+    delete this.prev[key];
+    delete this.next[key];
+  }
+  // Adds a key to the tail (most recently used position)
+  addToTail(key) {
+    if (this.tail !== null) {
+      this.next[this.tail] = key;
+      this.prev[key] = this.tail;
+    } else {
+      this.head = key;
+    }
+    this.tail = key;
+  }
+  *keys() {
+    for (let key = this.head; key != null; key = this.next[key])
+      yield key;
+  }
+  *values() {
+    for (let key = this.head; key != null; key = this.next[key])
+      yield this.cache[key];
+  }
+  *entries() {
+    for (let key = this.head; key != null; key = this.next[key])
+      yield [key, this.cache[key]];
+  }
+  *[Symbol.iterator]() {
+    yield* __yieldStar(this.entries());
+  }
+  toString() {
+    const entries = [...this.entries()];
+    return entries.length === 0 ? `LRUCache(0){ }` : `LRUCache(${entries.length}){ ${entries.map((e) => `${stringify(e[0])}: ${stringify(e[1])}`).join(", ")} }`;
+  }
+};
+var IndexArray = class _IndexArray extends BaseContainer {
+  constructor(entries) {
+    super();
+    __publicField2(this, "posVal");
+    __publicField2(this, "hasPos");
+    __publicField2(this, "valCount");
+    if (entries instanceof _IndexArray) {
+      this.posVal = entries.posVal.slice();
+      this.hasPos = entries.hasPos.slice();
+      this.valCount = entries.valCount;
+    } else {
+      this.posVal = [];
+      this.hasPos = [];
+      this.valCount = 0;
+      if (entries) {
+        for (const [id, value] of entries) {
+          this.set(id, value);
+        }
+      }
+    }
+  }
+  static validateIndex(id) {
+    if (!isIntegerGte(id, 0)) throw new Error(`Invalid index ${id} - must be an integer >= 0!`);
+    return id;
+  }
+  get posLen() {
+    return this.hasPos.length;
+  }
+  get size() {
+    return this.valCount;
+  }
+  get length() {
+    return this.hasPos.length;
+  }
+  trimRight() {
+    let newLength = this.length;
+    while (newLength > 0 && this.hasPos[newLength - 1] !== true) newLength--;
+    if (newLength < this.length) this.posVal.length = this.hasPos.length = newLength;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  has(id) {
+    _IndexArray.validateIndex(id);
+    return this.hasPos[id] === true;
+  }
+  set(id, value) {
+    _IndexArray.validateIndex(id);
+    if (this.hasPos[id] !== true) this.valCount++;
+    this.posVal[id] = value;
+    this.hasPos[id] = true;
+  }
+  get(id) {
+    _IndexArray.validateIndex(id);
+    return this.hasPos[id] ? this.posVal[id] : void 0;
+  }
+  getOrDefault(id, defaultValue) {
+    var _a;
+    return (_a = this.get(id)) != null ? _a : defaultValue;
+  }
+  getOrCreate(id, creatorOrValue) {
+    if (!this.has(id)) {
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(id, value);
+      return value;
+    }
+    return this.get(id);
+  }
+  delete(id) {
+    _IndexArray.validateIndex(id);
+    if (!this.hasPos[id]) return false;
+    this.posVal[id] = void 0;
+    this.hasPos[id] = false;
+    this.valCount--;
+    this.trimRight();
+    return true;
+  }
+  clear() {
+    this.posVal = [];
+    this.hasPos = [];
+    this.valCount = 0;
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [id, value] of this.entries()) {
+      callbackfn.call(thisArg, value, id, this);
+    }
+  }
+  *indices() {
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield id;
+    }
+  }
+  *values() {
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield this.posVal[id];
+    }
+  }
+  *entries() {
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield [id, this.posVal[id]];
+    }
+  }
+  indicesArray() {
+    return [...this.indices()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const id of this.indices()) {
+      yield [id];
+    }
+  }
+  *kvValues() {
+    for (const value of this.values()) {
+      yield value;
+    }
+  }
+  *kvEntries() {
+    for (const [id, value] of this.entries()) {
+      yield [[id], value];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* __yieldStar(this.entries());
+  }
+  clone() {
+    return new _IndexArray(this);
+  }
+  merge(other, conflictResolver) {
+    for (const [id, value] of other.entries()) {
+      if (this.has(id) && conflictResolver) {
+        this.set(id, conflictResolver(this.get(id), value, id));
+      } else {
+        this.set(id, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [id, value] of this.entries()) {
+      if (fn(value, id)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [id, value] of this.entries()) {
+      if (!fn(value, id)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = new this.constructor();
+    for (const [id, value] of this.entries()) {
+      if (predicate(value, id, this)) result.set(id, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty IndexArray with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[1];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [id, value] = current.value;
+      acc = fn(acc, value, id);
+    }
+    return acc;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const [id, value] of this.entries()) {
+      result.push(fn(value, id));
+    }
+    return result;
+  }
+  map(fn) {
+    let result = new _IndexArray();
+    for (const [id, value] of this.entries()) {
+      result.set(id, fn(value, id));
+    }
+    return result;
+  }
+  equals(other, eq) {
+    if (this.size !== other.size) return false;
+    eq != null ? eq : eq = (a, b) => a === b;
+    const posLen = Math.max(this.posLen, other.posLen);
+    for (let i = 0; i < posLen; ++i) {
+      const hasA = this.hasPos[i];
+      const hasB = other.hasPos[i];
+      if (hasA !== hasB) return false;
+      if (hasA && !eq(this.posVal[i], other.posVal[i])) return false;
+    }
+    return true;
+  }
+  toArray() {
+    return this.valuesArray();
+  }
+  toString() {
+    let isRegularArray = true;
+    for (let i = 0; i < this.hasPos.length && isRegularArray; i++)
+      if (!this.hasPos[i]) isRegularArray = false;
+    if (isRegularArray)
+      return stringify(this.posVal.slice(0, this.hasPos.length));
+    const entries = this.entriesArray().map(([id, v]) => `${stringify(id)}: ${stringify(v)}`).join(", ");
+    return entries.length === 0 ? `[ ]` : `[ ${entries} ]`;
+  }
+};
+var SignedIndexArray = class _SignedIndexArray extends BaseContainer {
+  constructor(entries) {
+    super();
+    __publicField2(this, "posVal");
+    __publicField2(this, "hasPos");
+    __publicField2(this, "negVal");
+    __publicField2(this, "hasNeg");
+    __publicField2(this, "valCount");
+    if (entries instanceof _SignedIndexArray) {
+      this.negVal = entries.negVal.slice();
+      this.hasNeg = entries.hasNeg.slice();
+      this.posVal = entries.posVal.slice();
+      this.hasPos = entries.hasPos.slice();
+      this.valCount = entries.valCount;
+    } else {
+      this.negVal = [];
+      this.hasNeg = [];
+      this.posVal = [];
+      this.hasPos = [];
+      this.valCount = 0;
+      if (entries) {
+        for (const [id, value] of entries) {
+          this.set(id, value);
+        }
+      }
+    }
+  }
+  static toNegIndex(id) {
+    return -id - 1;
+  }
+  static validateIndex(id) {
+    if (!isInteger(id)) throw new Error(`Invalid index ${id} - must be an integer!`);
+    return id;
+  }
+  get size() {
+    return this.valCount;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  get posLen() {
+    return this.hasPos.length;
+  }
+  get negLen() {
+    return this.hasNeg.length;
+  }
+  has(id) {
+    _SignedIndexArray.validateIndex(id);
+    if (id >= 0) {
+      return this.hasPos[id] === true;
+    } else {
+      return this.hasNeg[_SignedIndexArray.toNegIndex(id)] === true;
+    }
+  }
+  set(id, value) {
+    _SignedIndexArray.validateIndex(id);
+    if (id >= 0) {
+      if (this.hasPos[id] !== true) this.valCount++;
+      this.posVal[id] = value;
+      this.hasPos[id] = true;
+    } else {
+      let negId = _SignedIndexArray.toNegIndex(id);
+      if (this.hasNeg[negId] !== true) this.valCount++;
+      this.negVal[negId] = value;
+      this.hasNeg[negId] = true;
+    }
+  }
+  get(id) {
+    _SignedIndexArray.validateIndex(id);
+    if (id >= 0) {
+      return this.hasPos[id] ? this.posVal[id] : void 0;
+    } else {
+      let negId = _SignedIndexArray.toNegIndex(id);
+      return this.hasNeg[negId] ? this.negVal[negId] : void 0;
+    }
+  }
+  getOrDefault(id, defaultValue) {
+    var _a;
+    return (_a = this.get(id)) != null ? _a : defaultValue;
+  }
+  getOrCreate(id, creatorOrValue) {
+    if (!this.has(id)) {
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(id, value);
+      return value;
+    }
+    return this.get(id);
+  }
+  delete(id) {
+    _SignedIndexArray.validateIndex(id);
+    const isPos3 = id >= 0;
+    const arr = isPos3 ? this.posVal : this.negVal;
+    const has = isPos3 ? this.hasPos : this.hasNeg;
+    const idx = isPos3 ? id : _SignedIndexArray.toNegIndex(id);
+    if (!has[idx]) return false;
+    arr[idx] = void 0;
+    has[idx] = false;
+    this.valCount--;
+    return true;
+  }
+  clear() {
+    this.negVal = [];
+    this.hasNeg = [];
+    this.posVal = [];
+    this.hasPos = [];
+    this.valCount = 0;
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [id, value] of this.entries()) {
+      callbackfn.call(thisArg, value, id, this);
+    }
+  }
+  *indices() {
+    for (let id = this.negLen - 1; id >= 0; id--) {
+      if (this.hasNeg[id]) yield _SignedIndexArray.toNegIndex(id);
+    }
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield id;
+    }
+  }
+  *values() {
+    for (let id = this.negLen - 1; id >= 0; id--) {
+      if (this.hasNeg[id]) yield this.negVal[id];
+    }
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield this.posVal[id];
+    }
+  }
+  *entries() {
+    for (let id = this.negLen - 1; id >= 0; id--) {
+      if (this.hasNeg[id]) yield [_SignedIndexArray.toNegIndex(id), this.negVal[id]];
+    }
+    for (let id = 0; id < this.posLen; id++) {
+      if (this.hasPos[id]) yield [id, this.posVal[id]];
+    }
+  }
+  indicesArray() {
+    return [...this.indices()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const id of this.indices()) {
+      yield [id];
+    }
+  }
+  *kvValues() {
+    for (const value of this.values()) {
+      yield value;
+    }
+  }
+  *kvEntries() {
+    for (const [id, value] of this.entries()) {
+      yield [[id], value];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* __yieldStar(this.entries());
+  }
+  clone() {
+    return new _SignedIndexArray(this);
+  }
+  merge(other, conflictResolver) {
+    for (const [id, value] of other.entries()) {
+      if (this.has(id) && conflictResolver) {
+        this.set(id, conflictResolver(this.get(id), value, id));
+      } else {
+        this.set(id, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [id, value] of this.entries()) {
+      if (fn(value, id)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [id, value] of this.entries()) {
+      if (!fn(value, id)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = new this.constructor();
+    for (const [id, value] of this.entries()) {
+      if (predicate(value, id, this)) result.set(id, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty SignedIndexArray with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[1];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [id, value] = current.value;
+      acc = fn(acc, value, id);
+    }
+    return acc;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const [id, value] of this.entries()) {
+      result.push(fn(value, id));
+    }
+    return result;
+  }
+  map(fn) {
+    let result = new _SignedIndexArray();
+    for (const [id, value] of this.entries()) {
+      result.set(id, fn(value, id));
+    }
+    return result;
+  }
+  equals(other, eq) {
+    if (this.size !== other.size) return false;
+    eq != null ? eq : eq = (a, b) => a === b;
+    const posLen = Math.max(this.posLen, other.posLen);
+    for (let i = 0; i < posLen; ++i) {
+      const hasA = this.hasPos[i];
+      const hasB = other.hasPos[i];
+      if (hasA !== hasB) return false;
+      if (hasA && !eq(this.posVal[i], other.posVal[i])) return false;
+    }
+    const negLen = Math.max(this.negLen, other.negLen);
+    for (let i = 0; i < negLen; ++i) {
+      const hasA = this.hasNeg[i];
+      const hasB = other.hasNeg[i];
+      if (hasA !== hasB) return false;
+      if (hasA && !eq(this.negVal[i], other.negVal[i])) return false;
+    }
+    return true;
+  }
+  toArray() {
+    return this.valuesArray();
+  }
+  toString() {
+    let isRegularArray = this.hasNeg.length === 0;
+    for (let i = 0; i < this.hasPos.length && isRegularArray; i++)
+      if (!this.hasPos[i]) isRegularArray = false;
+    if (isRegularArray)
+      return stringify(this.posVal.slice(0, this.hasPos.length));
+    const entries = this.entriesArray().map(([id, v]) => `${stringify(id)}: ${stringify(v)}`).join(", ");
+    return entries.length === 0 ? `[ ]` : `[ ${entries} ]`;
+  }
+};
+var UniMap = class _UniMap extends BaseContainer {
+  constructor(...args) {
+    super();
+    __publicField2(this, "map");
+    __publicField2(this, "keyEquals");
+    const maybeEquals = args.at(-1);
+    this.keyEquals = isFunction(maybeEquals) ? args.pop() : DefaultEqualityFn;
+    const entries = args[0];
+    this.map = new Map(entries);
+  }
+  static createDeep(arg) {
+    return arg ? new _UniMap(arg, isDeepEqual) : new _UniMap(isDeepEqual);
+  }
+  has(key) {
+    if (this.keyEquals === DefaultEqualityFn || this.map.has(key))
+      return this.map.has(key);
+    for (const [k, v] of this.map)
+      if (this.keyEquals(k, key))
+        return true;
+    return false;
+  }
+  set(key, value) {
+    if (this.keyEquals === DefaultEqualityFn || this.map.has(key)) {
+      this.map.set(key, value);
+      return value;
+    }
+    for (const key2 of this.map.keys())
+      if (this.keyEquals(key2, key)) {
+        this.map.set(key2, value);
+        return value;
+      }
+    this.map.set(key, value);
+    return value;
+  }
+  get(key) {
+    if (this.keyEquals === DefaultEqualityFn || this.map.has(key))
+      return this.map.get(key);
+    for (const [k, v] of this.map)
+      if (this.keyEquals(k, key))
+        return v;
+    return void 0;
+  }
+  delete(key) {
+    if (this.keyEquals === DefaultEqualityFn || this.map.has(key))
+      return this.map.delete(key);
+    for (const k of this.map.keys())
+      if (this.keyEquals(k, key))
+        return this.map.delete(k);
+    return this.map.delete(key);
+  }
+  getOrDefault(key, defaultValue) {
+    var _a;
+    return (_a = this.get(key)) != null ? _a : defaultValue;
+  }
+  getOrCreate(key, creatorOrValue) {
+    if (!this.has(key)) {
+      const value = isFunction(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      return this.set(key, value);
+    }
+    return this.get(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.map.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
+  }
+  *keys() {
+    yield* __yieldStar(this.map.keys());
+  }
+  *values() {
+    yield* __yieldStar(this.map.values());
+  }
+  *entries() {
+    for (const [key, value] of this.map)
+      yield [key, value];
+  }
+  keysArray() {
+    return [...this.keys()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const key of this.keys()) {
+      yield [key];
+    }
+  }
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
+  }
+  *kvEntries() {
+    for (const [key, el] of this.entries()) {
+      yield [[key], el];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* __yieldStar(this.entries());
+  }
+  clone() {
+    return new _UniMap(this, this.keyEquals);
+  }
+  merge(other, conflictResolver) {
+    for (const [key, value] of other.entries()) {
+      if (this.has(key) && conflictResolver) {
+        this.set(key, conflictResolver(this.get(key), value, key));
+      } else {
+        this.set(key, value);
+      }
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [key, value] of this.map) {
+      if (fn(value, key)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [key, value] of this.map) {
+      if (!fn(value, key)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = new this.constructor();
+    for (const [key, value] of this.map) {
+      if (predicate(value, key, this)) result.set(key, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty UniMap with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[1];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [key, value] = current.value;
+      acc = fn(acc, value, key);
+    }
+    return acc;
+  }
+  mapEntries(fn) {
+    let result = [];
+    for (const [key, value] of this.map) {
+      result.push(fn(value, key));
+    }
+    return result;
+  }
+  mapValues(fn) {
+    let result = new _UniMap();
+    for (const [key, value] of this.map) {
+      result.set(key, fn(value, key));
+    }
+    return result;
+  }
+  toMap() {
+    return new Map(this.map);
+  }
+  toString() {
+    const entries = [...this.map].map(([k, v]) => `${stringify(k)} => ${stringify(v)}`).join(", ");
+    return entries.length === 0 ? `Map(${this.size}){ }` : `Map(${this.size}){ ${entries} }`;
+  }
+};
+
+// src/theory/types.ts
+var import_core = require("web-music-score/core");
+var SymbolSet = /* @__PURE__ */ ((SymbolSet2) => {
+  SymbolSet2[SymbolSet2["Ascii"] = 0] = "Ascii";
+  SymbolSet2[SymbolSet2["Unicode"] = 1] = "Unicode";
+  return SymbolSet2;
+})(SymbolSet || {});
+var PitchNotation = /* @__PURE__ */ ((PitchNotation2) => {
+  PitchNotation2[PitchNotation2["Scientific"] = 0] = "Scientific";
+  PitchNotation2[PitchNotation2["Helmholtz"] = 1] = "Helmholtz";
+  return PitchNotation2;
+})(PitchNotation || {});
+var PitchNotationList = utils_exports.Enum.getEnumValues(PitchNotation);
+var DefaultPitchNotation = 0 /* Scientific */;
+function validatePitchNotation(pn) {
+  if (guard_exports.isEnumValue(pn, PitchNotation)) {
+    return pn;
+  } else {
+    throw new import_core.MusicError(import_core.MusicErrorType.InvalidArg, `Invalid pitchNotation: ${pn}`);
+  }
+}
+function getPitchNotationName(pn) {
+  return PitchNotation[validatePitchNotation(pn)];
+}
+var GuitarNoteLabel = /* @__PURE__ */ ((GuitarNoteLabel2) => {
+  GuitarNoteLabel2["Default"] = "Default";
+  GuitarNoteLabel2["OmitOctave"] = "Omit Octave";
+  GuitarNoteLabel2["Interval"] = "Interval";
+  return GuitarNoteLabel2;
+})(GuitarNoteLabel || {});
+var DefaultGuitarNoteLabel = "Default" /* Default */;
+var GuitarNoteLabelList = utils_exports.Enum.getEnumValues(GuitarNoteLabel);
+function validateGuitarNoteLabel(label) {
+  if (guard_exports.isEnumValue(label, GuitarNoteLabel)) {
+    return label;
+  } else {
+    throw new import_core.MusicError(import_core.MusicErrorType.Timesignature, `Invalid guitarNoteLabel: ${label}`);
+  }
+}
+
+// src/theory/note.ts
+var import_core2 = require("web-music-score/core");
+function mod2(n, m) {
+  return (n % m + m) % m;
+}
+var C0_chromaticId = 12;
+var C0_diatonicId = 7;
+var AccidentalAsciiSymbolMap = /* @__PURE__ */ new Map([[-2, "bb"], [-1, "b"], [0, ""], [1, "#"], [2, "x"]]);
+var AccidentalUnicodeSymbolMap = /* @__PURE__ */ new Map([[-2, "\u{1D12B}"], [-1, "\u266D"], [0, ""], [1, "\u266F"], [2, "\u{1D12A}"]]);
+var AccidentalMap = /* @__PURE__ */ new Map([["", 0], ["bb", -2], ["b", -1], ["#", 1], ["x", 2], ["\u{1D12B}", -2], ["\u266D", -1], ["\u266F", 1], ["\u{1D12A}", 2]]);
+var NoteLetters = ["C", "D", "E", "F", "G", "A", "B"];
+var DiatonicToChromaticMap = [0, 2, 4, 5, 7, 9, 11];
+var NoteNameRegex = /^([A-G])((?:bb|𝄫|♭|b|#|♯|x|𝄪)?)?(-?\d+)?$/;
+var _Note = class _Note {
+  constructor(arg, accidental, octave) {
+    /** Diatonic class */
+    __publicField(this, "diatonicClass");
+    /** Accidental. */
+    __publicField(this, "accidental");
+    /** Octave. */
+    __publicField(this, "octave");
+    if (typeof arg === "number" && typeof accidental === "number" && octave === void 0) {
+      _Note.validateDiatonicId(arg);
+      this.diatonicClass = _Note.getDiatonicClass(arg);
+      this.accidental = _Note.validateAccidental(accidental);
+      this.octave = _Note.getOctaveFromDiatonicId(arg);
+    } else if (typeof arg === "number" && typeof accidental === "number" && typeof octave === "number") {
+      this.diatonicClass = _Note.validateDiatonicClass(arg);
+      this.accidental = _Note.validateAccidental(accidental);
+      this.octave = _Note.validateOctave(octave);
+    } else if (typeof arg === "string" && typeof accidental === "number" && typeof octave === "number") {
+      this.diatonicClass = _Note.getDiatonicClass(arg);
+      this.accidental = _Note.validateAccidental(accidental);
+      this.octave = _Note.validateOctave(octave);
+    } else {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid args: ${arg}, ${accidental}, ${octave}`);
+    }
+  }
+  /** Diatonic id getter. */
+  get diatonicId() {
+    return _Note.getDiatonicIdInOctave(this.diatonicClass, this.octave);
+  }
+  /** Chromatic id getter. */
+  get chromaticId() {
+    return _Note.getChromaticIdInOctave(DiatonicToChromaticMap[this.diatonicClass] + this.accidental, this.octave);
+  }
+  /** Midi number getter (implemented same as chromatic id). */
+  get midiNumber() {
+    return this.chromaticId;
+  }
+  /** Chromatic class getter. */
+  get chromaticClass() {
+    return _Note.getChromaticClass(DiatonicToChromaticMap[this.diatonicClass] + this.accidental);
+  }
+  /** Note letter getter. */
+  get noteLetter() {
+    return NoteLetters[this.diatonicClass];
+  }
+  /**
+   * Format note to string presentation.
+   * @param pitchNotation - Pitchy notation.
+   * @param symbolSet - Symbol set.
+   * @returns - String presentation of note.
+   */
+  format(pitchNotation, symbolSet) {
+    let { noteLetter, octave } = this;
+    let accidentalSymbol = _Note.getAccidentalSymbol(this.accidental, symbolSet);
+    if (pitchNotation === 1 /* Helmholtz */) {
+      if (octave >= 3) {
+        return noteLetter.toLowerCase() + accidentalSymbol + "\u2032".repeat(octave - 3);
+      } else {
+        return noteLetter.toUpperCase() + accidentalSymbol + "\u0375".repeat(2 - octave);
+      }
+    } else {
+      return noteLetter + accidentalSymbol + octave;
+    }
+  }
+  /**
+   * Format note to string presentation without octave number.
+   * @param symbolSet - Symbol set.
+   * @returns - String presentation of note without octave number.
+   */
+  formatOmitOctave(symbolSet) {
+    let noteLetter = NoteLetters[this.diatonicClass];
+    let accidental = _Note.getAccidentalSymbol(this.accidental, symbolSet);
+    return noteLetter + accidental;
+  }
+  /**
+   * Get note.
+   * @param noteName - Note name (e.g. "C4").
+   * @returns - Note.
+   */
+  static getNote(noteName) {
+    return this.noteCache.getOrCreate(noteName, () => {
+      let p = _Note.parseNote(noteName);
+      if (!p)
+        throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid note "${noteName}".`);
+      if (p.octave === void 0)
+        throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid note "${noteName}" (missing octave).`);
+      return new _Note(p.noteLetter, p.accidental, p.octave);
+    });
+  }
+  /**
+   * Test if given note name valid.
+   * @param noteName - Note name.
+   * @returns - True/false.
+   */
+  static isNote(noteName) {
+    let p = _Note.parseNote(noteName);
+    return p !== void 0 && p.octave !== void 0;
+  }
+  /**
+   * Validate given note name.
+   * @param noteName - Note name.
+   * @returns - True or throws.
+   */
+  static validateNote(noteName) {
+    if (this.isNote(noteName)) return true;
+    throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid note "${noteName}"`);
+  }
+  /**
+   * Get chromatic note. There are number of alternatives, this function uses simple logic to choose one.
+   * @param chromaticId - Chromatic id.
+   * @returns - Note.
+   */
+  static getChromaticNote(chromaticId) {
+    return this.chromaticNoteCache.getOrCreate(chromaticId, () => {
+      const NoteNameList = ["C/B#", "C#/Db", "D", "D#/Eb", "E/Fb", "F/E#", "F#/Gb", "G", "G#/Ab", "A", "A#/Bb", "B/Cb"];
+      let noteName = NoteNameList[_Note.getChromaticClass(chromaticId)].split("/")[0] + _Note.getOctaveFromChromaticId(chromaticId);
+      return _Note.getNote(noteName);
+    });
+  }
+  static getDiatonicClass(arg) {
+    if (typeof arg === "number") {
+      return mod2(arg, 7);
+    } else if (typeof arg === "string" && arg.length > 0) {
+      return NoteLetters.indexOf(_Note.validateNoteLetter(arg[0]));
+    } else {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid arg: ${arg}`);
+    }
+  }
+  /**
+   * Get octave from diatonic id.
+   * @param diatonicId - Diatonic id.
+   * @returns - Octave.
+   */
+  static getOctaveFromDiatonicId(diatonicId) {
+    return Math.floor((diatonicId - C0_diatonicId) / 7);
+  }
+  /**
+   * Get diatonic id in given octave (transposes diatonic id to given octave).
+   * @param diatonicId - Original diatonic id.
+   * @param octave - Octave.
+   * @returns - Transposed diatonic id.
+   */
+  static getDiatonicIdInOctave(diatonicId, octave) {
+    return _Note.getDiatonicClass(diatonicId) + octave * 7 + C0_diatonicId;
+  }
+  /**
+   * Get chromatic class from chromatic id.
+   * @param chromaticId - Chromatic id.
+   * @returns - Chromatic class.
+   */
+  static getChromaticClass(chromaticId) {
+    return mod2(chromaticId, 12);
+  }
+  /**
+   * Get octave from chromatic id.
+   * @param chromaticId - Chromatic id.
+   * @returns - Octave.
+   */
+  static getOctaveFromChromaticId(chromaticId) {
+    return Math.floor((chromaticId - C0_chromaticId) / 12);
+  }
+  /**
+   * Get chromatic id in given octave (transposes chromatic id to given octave).
+   * @param chromaticId - Original chromatic id.
+   * @param octave - Octave.
+   * @returns - Transpose chromatic id.
+   */
+  static getChromaticIdInOctave(chromaticId, octave) {
+    return _Note.getChromaticClass(chromaticId) + octave * 12 + C0_chromaticId;
+  }
+  /**
+   * Test if given two notes are equal.
+   * @param a - Note a.
+   * @param b - Note b.
+   * @returns - True/false.
+   */
+  static equals(a, b) {
+    if (a == null && b == null) {
+      return true;
+    } else if (a == null || b == null) {
+      return false;
+    } else {
+      return a === b || a.diatonicId === b.diatonicId && a.accidental === b.accidental;
+    }
+  }
+  /**
+   * Replace accidental symbols in given string to givn symbol set (ascii/unicode).
+   * @param str - String to replace.
+   * @param symbolSet - Symbol set.
+   * @returns - String with updated accidental symbols.
+   */
+  static replaceAccidentalSymbols(str2, symbolSet) {
+    if (symbolSet === 1 /* Unicode */) {
+      return str2.replace("bb", "\u{1D12B}").replace("b", "\u266D").replace("#", "\u266F").replace("x", "\u{1D12A}");
+    } else {
+      return str2.replace("\u{1D12B}", "bb").replace("\u266D", "b").replace("\u266F", "#").replace("\u{1D12A}", "x");
+    }
+  }
+  /**
+   * Test if given string is valid note name.
+   * @param noteName - Note name to validate.
+   * @returns - True/false.
+   */
+  static isValidNoteName(noteName) {
+    return NoteNameRegex.test(noteName);
+  }
+  /**
+   * Parse note name string to note props.
+   * @param noteName - Note name to parse.
+   * @returns - Parsed note props or undefined if parsing error.
+   */
+  static parseNote(noteName) {
+    var _a;
+    let m = NoteNameRegex.exec(noteName);
+    if (!m) {
+      return void 0;
+    }
+    let noteLetter = _Note.validateNoteLetter(m[1]);
+    let accidentalStr = m[2];
+    let accidental = _Note.validateAccidental((_a = AccidentalMap.get(accidentalStr)) != null ? _a : 0);
+    let octaveStr = m[3];
+    let octave = octaveStr ? _Note.validateOctave(+octaveStr) : void 0;
+    return { noteLetter, accidental, octave };
+  }
+  /**
+   * Get scientific note name from given note name.
+   * @param noteName - Note name.
+   * @param symbolSet - Symbol set (ascii/unicode) for scientific note name.
+   * @returns - Scientific note name.
+   */
+  static getScientificNoteName(noteName, symbolSet) {
+    let p = _Note.parseNote(noteName);
+    if (!p) {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid noteName: ${noteName}`);
+    }
+    let { noteLetter, accidental, octave } = p;
+    return noteLetter + _Note.getAccidentalSymbol(accidental, symbolSet) + (octave != null ? octave : "");
+  }
+  /**
+   * Get symbol of given accidental in given symbol set (ascii/unicide).
+   * @param accidental - Accidental.
+   * @param symbolsSet - Symbol set.
+   * @returns - Accidental symbol or undefined (invalid accidental).
+   */
+  static getAccidentalSymbol(accidental, symbolsSet) {
+    return symbolsSet === 1 /* Unicode */ ? AccidentalUnicodeSymbolMap.get(accidental) : AccidentalAsciiSymbolMap.get(accidental);
+  }
+  /**
+   * Get accidental value from given accidental symbol.
+   * @param accidentalSymbol - Accidental symbol (e.g. "#").
+   * @returns - Accidental vlaue.
+   */
+  static getAccidental(accidentalSymbol) {
+    let accidental = AccidentalMap.get(accidentalSymbol);
+    if (accidental === void 0) {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid accidental: ${accidentalSymbol}`);
+    }
+    return accidental;
+  }
+  /**
+   * Get note letter from given diatonic id.
+   * @param diatonicId - Diatonic id.
+   * @returns - Note letter.
+   */
+  static getNoteLetter(diatonicId) {
+    return NoteLetters[_Note.getDiatonicClass(diatonicId)];
+  }
+  /**
+   * Find next lowest possible diatonic id that is above given bottom level.
+   * @param diatonicId - Diatonic id to begin with.
+   * @param bottomDiatonicId - Bottom diatonic id.
+   * @param addOctaveIfEqual - If true then add one octave if diatonic id would equal to bottom diatonic id.
+   * @returns - Diatonic id.
+   */
+  static findNextDiatonicIdAbove(diatonicId, bottomDiatonicId, addOctaveIfEqual) {
+    let diatonicClass = _Note.getDiatonicClass(diatonicId);
+    let bottomDiatonicClass = _Note.getDiatonicClass(bottomDiatonicId);
+    let addOctave = addOctaveIfEqual ? diatonicClass <= bottomDiatonicClass ? 1 : 0 : diatonicClass < bottomDiatonicClass ? 1 : 0;
+    return _Note.getDiatonicIdInOctave(diatonicClass, _Note.getOctaveFromDiatonicId(bottomDiatonicId) + addOctave);
+  }
+  /**
+   * Validate if given argument is diatonic id.
+   * @param diatonicId - Diatonic id to validate.
+   * @returns - Valid diatonic id or throws.
+   */
+  static validateDiatonicId(diatonicId) {
+    if (guard_exports.isInteger(diatonicId)) {
+      return diatonicId;
+    } else {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid diatonicId: ${diatonicId}`);
+    }
+  }
+  /**
+   * Validate if given argument is diatonic class.
+   * @param diatonicClass - Diatonic class to validate.
+   * @returns - Valid diatonic class or throws.
+   */
+  static validateDiatonicClass(diatonicClass) {
+    if (guard_exports.isIntegerBetween(diatonicClass, 0, 6)) {
+      return diatonicClass;
+    } else {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid diatonicClass: ${diatonicClass}`);
+    }
+  }
+  /**
+   * Validate if given argument is chromatic id.
+   * @param chromaticId - Chromatic id to validate.
+   * @returns - Valid chromatic id, or throws.
+   */
+  static validateChromaticId(chromaticId) {
+    if (guard_exports.isInteger(chromaticId)) {
+      return chromaticId;
+    } else {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid chromaticId: ${chromaticId}`);
+    }
+  }
+  /**
+   * Validate if given argument is chromatic class.
+   * @param chromaticClass - Chromatic class to validate.
+   * @returns - Valid chromatic class, or throws.
+   */
+  static validatechromaticClass(chromaticClass) {
+    if (guard_exports.isIntegerBetween(chromaticClass, 0, 11)) {
+      return chromaticClass;
+    } else {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid chromaticClass: ${chromaticClass}`);
+    }
+  }
+  /**
+   * Validate if given argument if note letter.
+   * @param noteLetter - Note letter to validate.
+   * @returns - Valid note letter or throws.
+   */
+  static validateNoteLetter(noteLetter) {
+    if (NoteLetters.some((n) => n === noteLetter)) {
+      return noteLetter;
+    } else {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid note: ${noteLetter}`);
+    }
+  }
+  /**
+   * Validate if given argument is octave.
+   * @param octave - Octave to validate.
+   * @returns - Valid octave or throws.
+   */
+  static validateOctave(octave) {
+    if (guard_exports.isInteger(octave)) {
+      return octave;
+    } else {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid octave: ${octave}`);
+    }
+  }
+  /**
+   * Validate if given argument is valid accidental.
+   * @param acc - Accidental to validate.
+   * @returns - Valid accidental or thorws.
+   */
+  static validateAccidental(acc) {
+    if (guard_exports.isIntegerBetween(acc, -2, 2)) {
+      return acc;
+    } else {
+      throw new import_core2.MusicError(import_core2.MusicErrorType.Note, `Invalid accidental: ${acc}`);
+    }
+  }
+  /**
+   * Sort notes by diatonicId in ascending order.
+   * @param notes - Array of notes.
+   * @returns Sorted array of notes.
+   */
+  static sort(notes) {
+    return notes.slice().sort(_Note.compareFunc);
+  }
+  /**
+   * Remove duplicate notes.
+   * @param notes - Array of notes.
+   * @returns Sorted set of notes.
+   */
+  static removeDuplicates(notes) {
+    let uniqueSet = [];
+    notes.forEach((note) => {
+      if (uniqueSet.find((n) => _Note.equals(note, n)) === void 0) {
+        uniqueSet.push(note);
+      }
+    });
+    return uniqueSet;
+  }
+  /**
+   * Function to compare two notes using diatonic id and accidental properties of notes.
+   * @param a - Note a.
+   * @param b - Note b.
+   * @returns - -1, 0 or 1.
+   */
+  static compareFunc(a, b) {
+    if (a.diatonicId < b.diatonicId) {
+      return -1;
+    } else if (a.diatonicId > b.diatonicId) {
+      return 1;
+    } else {
+      if (a.accidental < b.accidental) {
+        return -1;
+      } else if (a.accidental > b.accidental) {
+        return 1;
+      } else {
+        return 0;
+      }
+    }
+  }
+};
+__publicField(_Note, "noteCache", new UniMap());
+__publicField(_Note, "chromaticNoteCache", new UniMap());
+var Note = _Note;
+
+// src/theory/key-signature.ts
+var import_core3 = require("web-music-score/core");
+function getAccidental(chromaticId, diatonicId) {
+  let a = Note.getChromaticClass(chromaticId) - new Note(diatonicId, 0).chromaticClass;
+  while (a > 2) {
+    a -= 12;
+  }
+  while (a < -2) {
+    a += 12;
+  }
+  return Note.validateAccidental(a);
+}
+var DegreeRule = /^(bb?|b?|#?|x?)([0-9]*)$/;
+function parseDegree(degree) {
+  var _a, _b;
+  let m = DegreeRule.exec("" + degree);
+  if (!m) {
+    throw new import_core3.MusicError(import_core3.MusicErrorType.KeySignature, `Invalid degree: ${degree}`);
+  }
+  let acc = (_b = Note.getAccidental((_a = m[1]) != null ? _a : "")) != null ? _b : 0;
+  let deg = +m[2];
+  if (!guard_exports.isInteger(acc) || acc < -2 || acc > 2 || !guard_exports.isInteger(deg) || deg < 1) {
+    throw new import_core3.MusicError(import_core3.MusicErrorType.KeySignature, `Invalid degree: ${degree}`);
+  } else {
+    return { deg, acc };
+  }
+}
+var Mode = /* @__PURE__ */ ((Mode2) => {
+  Mode2[Mode2["Ionian"] = 1] = "Ionian";
+  Mode2[Mode2["Dorian"] = 2] = "Dorian";
+  Mode2[Mode2["Phrygian"] = 3] = "Phrygian";
+  Mode2[Mode2["Lydian"] = 4] = "Lydian";
+  Mode2[Mode2["Mixolydian"] = 5] = "Mixolydian";
+  Mode2[Mode2["Aeolian"] = 6] = "Aeolian";
+  Mode2[Mode2["Locrian"] = 7] = "Locrian";
+  return Mode2;
+})(Mode || {});
+var AccidentalType = /* @__PURE__ */ ((AccidentalType2) => {
+  AccidentalType2[AccidentalType2["Natural"] = 0] = "Natural";
+  AccidentalType2[AccidentalType2["Flats"] = 1] = "Flats";
+  AccidentalType2[AccidentalType2["Sharps"] = 2] = "Sharps";
+  return AccidentalType2;
+})(AccidentalType || {});
+function getDefaultKeySignature() {
+  return getScale("C", "Major" /* Major */);
+}
+var _KeySignature = class _KeySignature {
+  /**
+   * @param tonic - Tonic/root note.
+   * @param mode - Mode: Ionian/Major = 1, Dorian = 2, ..., Locrian = 7
+   */
+  constructor(tonic, mode) {
+    this.tonic = tonic;
+    this.mode = mode;
+    __publicField(this, "naturalScaleNotes");
+    __publicField(this, "accidentalByDiatonicClass");
+    __publicField(this, "orderedAccidentedNotes");
+    if (!guard_exports.isEnumValue(mode, Mode)) {
+      throw new import_core3.MusicError(import_core3.MusicErrorType.KeySignature, `Invalid mode: ${mode}`);
+    }
+    let intervals = [2, 2, 1, 2, 2, 2, 1];
+    for (let i = 1; i < mode; i++) {
+      intervals.push(intervals.shift());
+    }
+    this.naturalScaleNotes = [];
+    this.accidentalByDiatonicClass = [];
+    let diatonicId = Note.getDiatonicClass(tonic[0]);
+    let chromaticId = Note.getNote(tonic + "0").chromaticId;
+    for (let id = 0; id < 7; diatonicId++, chromaticId += intervals[id], id++) {
+      let note = new Note(Note.getDiatonicClass(diatonicId), getAccidental(chromaticId, diatonicId));
+      if (Math.abs(note.accidental) >= 2) {
+        throw new import_core3.MusicError(import_core3.MusicErrorType.KeySignature, "Key signature contains double accidental.");
+      }
+      this.naturalScaleNotes[id] = note;
+      this.accidentalByDiatonicClass[note.diatonicClass] = note.accidental;
+    }
+    let sharps = this.naturalScaleNotes.filter((n) => n.accidental > 0).sort((a, b) => {
+      let ai = _KeySignature.OrderOfSharps.indexOf(a.noteLetter);
+      let bi = _KeySignature.OrderOfSharps.indexOf(b.noteLetter);
+      if (ai === -1 || bi === -1) {
+        throw new import_core3.MusicError(import_core3.MusicErrorType.KeySignature, "Unexpected note in key signature.");
+      }
+      return ai - bi;
+    });
+    let flats = this.naturalScaleNotes.filter((n) => n.accidental < 0).sort((a, b) => {
+      let ai = _KeySignature.OrderOfFlats.indexOf(a.noteLetter);
+      let bi = _KeySignature.OrderOfFlats.indexOf(b.noteLetter);
+      if (ai === -1 || bi === -1) {
+        throw new import_core3.MusicError(import_core3.MusicErrorType.KeySignature, "Unexpected note in key signature.");
+      }
+      return ai - bi;
+    });
+    if (sharps.length !== 0 && flats.length !== 0) {
+      throw new import_core3.MusicError(import_core3.MusicErrorType.KeySignature, "Key Signature has both sharps and flats.");
+    }
+    this.orderedAccidentedNotes = flats.length > 0 ? flats : sharps;
+  }
+  /**
+   * Get accidental type sharps, flats, or natural (without accidentals).
+   * @returns - Accidental type.
+   */
+  getAccidentalType() {
+    if (this.orderedAccidentedNotes.length === 0) {
+      return 0 /* Natural */;
+    } else if (this.orderedAccidentedNotes[0].accidental < 0) {
+      return 1 /* Flats */;
+    } else {
+      return 2 /* Sharps */;
+    }
+  }
+  /**
+   * Get natural scale notes of this key signature, natural scale has 7 steps (e.g. Major scale: W, W, H, W, W, W, H).
+   * @returns - Array of notes.
+   */
+  getNaturalScaleNotes() {
+    return this.naturalScaleNotes;
+  }
+  /**
+   * Get accidental for given diatonic id.
+   * @param diatonicId - Diatonic id.
+   * @returns - Accidental -2, -1, 0, 1 or 2.
+   */
+  getAccidental(diatonicId) {
+    var _a;
+    return (_a = this.accidentalByDiatonicClass[Note.getDiatonicClass(diatonicId)]) != null ? _a : 0;
+  }
+  /**
+   * Get number of accidentals this key signature has.
+   * @returns - Number of accidentals.
+   */
+  getNumAccidentals() {
+    return this.orderedAccidentedNotes.length;
+  }
+  /**
+   * Get accidental notes in correct order.
+   * @returns - Array of accidental notes.
+   */
+  getOrderedAccidentalNotes() {
+    return this.orderedAccidentedNotes;
+  }
+  /**
+   * Get note of key signature by degree value.
+   * @param degree - Degree number in range [1, 7] or string e.g "b5" or "#4".
+   * @returns - Note.
+   */
+  getNoteByDegree(degree) {
+    let { deg, acc } = parseDegree(degree);
+    if (acc === 0) {
+      return this.naturalScaleNotes[(deg - 1) % 7];
+    } else {
+      let note = this.naturalScaleNotes[(deg - 1) % 7];
+      return new Note(note.diatonicId, note.accidental + acc);
+    }
+  }
+  /**
+   * Test equality of given key signatures.
+   * @param a - Key signature a.
+   * @param b - Key signature b.
+   * @returns - True/false.
+   */
+  static equals(a, b) {
+    if (a == null && b == null) {
+      return true;
+    } else if (a == null || b == null) {
+      return false;
+    } else {
+      return a === b || a.tonic === b.tonic && a.mode === b.mode;
+    }
+  }
+};
+__publicField(_KeySignature, "OrderOfSharps", "FCGDAEB");
+__publicField(_KeySignature, "OrderOfFlats", "BEADGCF");
+var KeySignature = _KeySignature;
+
+// src/theory/interval.ts
+var import_core4 = require("web-music-score/core");
+var IntervalQualityAbbrMap = new UniMap([
+  ["Major", "M"],
+  ["minor", "m"],
+  ["Perfect", "P"],
+  ["diminished", "d"],
+  ["Augmented", "A"],
+  ["doubly diminished", "dd"],
+  ["Doubly Augmented", "AA"]
+]);
+var IntervalQualities = {
+  "1": {
+    // Unison
+    "0": "Perfect",
+    "1": "Augmented",
+    "-1": "diminished",
+    "2": "Doubly Augmented",
+    "-2": "doubly diminished"
+  },
+  "2": {
+    // Second
+    "2": "Major",
+    "1": "minor",
+    "3": "Augmented",
+    "0": "diminished",
+    "4": "Doubly Augmented",
+    "-1": "doubly diminished"
+  },
+  "3": {
+    // Third
+    "4": "Major",
+    "3": "minor",
+    "5": "Augmented",
+    "2": "diminished",
+    "6": "Doubly Augmented",
+    "1": "doubly diminished"
+  },
+  "4": {
+    // Fourth
+    "5": "Perfect",
+    "6": "Augmented",
+    "4": "diminished",
+    "7": "Doubly Augmented",
+    "3": "doubly diminished"
+  },
+  "5": {
+    // Fifth
+    "7": "Perfect",
+    "8": "Augmented",
+    "6": "diminished",
+    "9": "Doubly Augmented",
+    "5": "doubly diminished"
+  },
+  "6": {
+    // Sixth
+    "9": "Major",
+    "8": "minor",
+    "10": "Augmented",
+    "7": "diminished",
+    "11": "Doubly Augmented",
+    "6": "doubly diminished"
+  },
+  "7": {
+    // Seventh
+    "11": "Major",
+    "10": "minor",
+    "12": "Augmented",
+    "9": "diminished",
+    "13": "Doubly Augmented",
+    "8": "doubly diminished"
+  },
+  "8": {
+    // Octave
+    "12": "Perfect",
+    "13": "Augmented",
+    "11": "diminished",
+    "14": "Doubly Augmented",
+    "10": "doubly diminished"
+  }
+};
+function getIntervalQuality(diatonicInterval, chromaticInterval) {
+  while (diatonicInterval < 1) {
+    diatonicInterval += 7;
+    chromaticInterval += 12;
+  }
+  while (diatonicInterval > 8) {
+    diatonicInterval -= 7;
+    chromaticInterval -= 12;
+  }
+  const qualities = IntervalQualities[diatonicInterval];
+  if (qualities) {
+    return qualities[chromaticInterval];
+  } else {
+    return void 0;
+  }
+}
+function validateIntervalQuality(q) {
+  if (!(q === "Perfect" || q === "Major" || q === "minor" || q === "Augmented" || q === "diminished" || q === "Doubly Augmented" || q === "doubly diminished")) {
+    throw new import_core4.MusicError(import_core4.MusicErrorType.InvalidArg, `Invalid interval quality: ${q}`);
+  } else {
+    return q;
+  }
+}
+function formatQuantity(q) {
+  if (!guard_exports.isIntegerGte(q, 1)) {
+    throw new import_core4.MusicError(import_core4.MusicErrorType.InvalidArg, `Invalid interval quantity: ${q}`);
+  } else {
+    return utils_exports.Math.toOrdinalNumber(q);
+  }
+}
+var InvalidIntervalException = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.msg = msg;
+    this.name = "InvalidInterval";
+  }
+};
+var Interval = class _Interval {
+  constructor(note1, note2) {
+    this.note1 = note1;
+    this.note2 = note2;
+    /** Interval direction. */
+    __publicField(this, "direction");
+    /** Number of semitones. */
+    __publicField(this, "semitones");
+    /** Interval quantity. */
+    __publicField(this, "quantity");
+    /** Interval quality. */
+    __publicField(this, "quality");
+    if (note2.diatonicId >= note1.diatonicId) {
+      this.direction = note2.diatonicId === note1.diatonicId ? "Unison" : "Ascending";
+      this.quantity = note2.diatonicId - note1.diatonicId + 1;
+      this.semitones = note2.chromaticId - note1.chromaticId;
+    } else {
+      this.direction = "Descending";
+      this.quantity = note1.diatonicId - note2.diatonicId + 1;
+      this.semitones = note1.chromaticId - note2.chromaticId;
+    }
+    let quality = getIntervalQuality(this.quantity, this.semitones);
+    if (quality) {
+      this.quality = quality;
+    } else {
+      throw new InvalidIntervalException("Unknown interval quality");
+    }
+  }
+  /**
+   * Get interval between given two notes.
+   * @param note1 - First note.
+   * @param note2 - Second note.
+   * @returns - Interval if valid, or undefined.
+   */
+  static get(note1, note2) {
+    try {
+      return new _Interval(note1, note2);
+    } catch (err) {
+      if (err instanceof InvalidIntervalException) {
+        return void 0;
+      } else {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Get string presentation of interval (e.g. "Descending Major 2").
+   * @returns - Interval string.
+   */
+  toString() {
+    let direction = this.direction === "Unison" ? "" : this.direction + " ";
+    let quality = this.quality + " ";
+    let quantity = this.direction === "Unison" ? "Unison" : formatQuantity(this.quantity);
+    return direction + quality + quantity;
+  }
+  /**
+   * Get abbrevated string presentation of interval (e.g. "↓M2").
+   * @returns - Interval abbrevated string.
+   */
+  toAbbrString() {
+    let direction = this.direction === "Descending" ? "\u2193" : "";
+    let quality = IntervalQualityAbbrMap.getOrDefault(this.quality, "?");
+    let quantity = this.quantity;
+    return direction + quality + quantity;
+  }
+};
+
+// src/theory/scale.ts
+var import_core5 = require("web-music-score/core");
+function getNaturalDiatonicId(chromaticId) {
+  let diatonicClass = Note.getDiatonicClass("CCDDEFFGGAAB"[Note.getChromaticClass(chromaticId)]);
+  let octave = Note.getOctaveFromChromaticId(chromaticId);
+  return Note.getDiatonicIdInOctave(diatonicClass, octave);
+}
+var FullTonicList = [
+  "Cb",
+  "C",
+  "C#",
+  "Db",
+  "D",
+  "D#",
+  "Eb",
+  "E",
+  "E#",
+  "Fb",
+  "F",
+  "F#",
+  "Gb",
+  "G",
+  "G#",
+  "Ab",
+  "A",
+  "A#",
+  "Bb",
+  "B",
+  "B#"
+];
+var ScaleType = /* @__PURE__ */ ((ScaleType2) => {
+  ScaleType2["Major"] = "Major";
+  ScaleType2["NaturalMinor"] = "Natural Minor";
+  ScaleType2["HarmonicMinor"] = "Harmonic Minor";
+  ScaleType2["Ionian"] = "Ionian";
+  ScaleType2["Dorian"] = "Dorian";
+  ScaleType2["Phrygian"] = "Phrygian";
+  ScaleType2["Lydian"] = "Lydian";
+  ScaleType2["Mixolydian"] = "Mixolydian";
+  ScaleType2["Aeolian"] = "Aeolian";
+  ScaleType2["Locrian"] = "Locrian";
+  ScaleType2["MajorPentatonic"] = "Major Pentatonic";
+  ScaleType2["MinorPentatonic"] = "Minor Pentatonic";
+  ScaleType2["MajorHexatonicBlues"] = "Major Hexatonic Blues";
+  ScaleType2["MinorHexatonicBlues"] = "Minor Hexatonic Blues";
+  ScaleType2["HeptatonicBlues"] = "Heptatonic Blues";
+  return ScaleType2;
+})(ScaleType || {});
+function getMode(scaleType) {
+  switch (scaleType) {
+    case "Major" /* Major */:
+      return 1;
+    case "Natural Minor" /* NaturalMinor */:
+      return 6;
+    case "Harmonic Minor" /* HarmonicMinor */:
+      return 6;
+    case "Ionian" /* Ionian */:
+      return 1;
+    case "Dorian" /* Dorian */:
+      return 2;
+    case "Phrygian" /* Phrygian */:
+      return 3;
+    case "Lydian" /* Lydian */:
+      return 4;
+    case "Mixolydian" /* Mixolydian */:
+      return 5;
+    case "Aeolian" /* Aeolian */:
+      return 6;
+    case "Locrian" /* Locrian */:
+      return 7;
+    case "Major Pentatonic" /* MajorPentatonic */:
+      return 1;
+    case "Minor Pentatonic" /* MinorPentatonic */:
+      return 6;
+    case "Major Hexatonic Blues" /* MajorHexatonicBlues */:
+      return 1;
+    case "Minor Hexatonic Blues" /* MinorHexatonicBlues */:
+      return 6;
+    case "Heptatonic Blues" /* HeptatonicBlues */:
+      return 1;
+    default:
+      throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid scaleType: ${scaleType}`);
+  }
+}
+var Scale = class extends KeySignature {
+  /**
+   * Create nev scale object instance.
+   * @param tonic - Tonic (e.g. "C" in "C Major").
+   * @param scaleType - Scale typo ("e.g. "Major" in "C Major").
+   */
+  constructor(tonic, scaleType) {
+    super(tonic, getMode(scaleType));
+    this.tonic = tonic;
+    this.scaleType = scaleType;
+    /** Degrees of scale notes. */
+    __publicField(this, "scaleDegrees");
+    /** Scale notes. */
+    __publicField(this, "scaleNotes");
+    /** Degrees (or undefined) of chromatic classes. */
+    __publicField(this, "chromaticClassDegree");
+    __publicField(this, "preferredChromaticIdNoteCache", new SignedIndexArray());
+    switch (scaleType) {
+      case "Harmonic Minor" /* HarmonicMinor */:
+        this.scaleDegrees = [1, 2, 3, 4, 5, 6, "#7"];
+        break;
+      case "Major Pentatonic" /* MajorPentatonic */:
+        this.scaleDegrees = [1, 2, 3, 5, 6];
+        break;
+      case "Minor Pentatonic" /* MinorPentatonic */:
+        this.scaleDegrees = [1, 3, 4, 5, 7];
+        break;
+      case "Major Hexatonic Blues" /* MajorHexatonicBlues */:
+        this.scaleDegrees = [1, 2, "b3", 3, 5, 6];
+        break;
+      case "Minor Hexatonic Blues" /* MinorHexatonicBlues */:
+        this.scaleDegrees = [1, 3, 4, "b5", 5, 7];
+        break;
+      case "Heptatonic Blues" /* HeptatonicBlues */:
+        this.scaleDegrees = [1, 2, "b3", 4, "b5", 6, "b7"];
+        break;
+      default:
+        this.scaleDegrees = [1, 2, 3, 4, 5, 6, 7];
+        break;
+    }
+    this.scaleNotes = this.scaleDegrees.map((d) => this.getNoteByDegree(d));
+    this.chromaticClassDegree = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].map((chromaticClass) => {
+      let id = this.scaleNotes.findIndex((scaleNote) => scaleNote.chromaticClass === chromaticClass);
+      return id >= 0 ? this.scaleDegrees[id] : void 0;
+    });
+  }
+  /**
+   * Compare if two scales equals.
+   * @param a - Scale a.
+   * @param b - Scale b.
+   * @returns - Boolean equality of given scales.
+   */
+  static equals(a, b) {
+    if (a == null && b == null) {
+      return true;
+    } else if (a == null || b == null) {
+      return false;
+    } else {
+      return a === b || a.getScaleName() === b.getScaleName();
+    }
+  }
+  /**
+   * Get scale name.
+   * @param symbolSet - Symbol set to format scale name in ascii or unicode.
+   * @returns - Scale name string.
+   */
+  getScaleName(symbolSet) {
+    switch (symbolSet) {
+      case 1 /* Unicode */:
+        return Note.getScientificNoteName(this.tonic, symbolSet) + " " + this.scaleType;
+      default:
+        return this.tonic + " " + this.scaleType;
+    }
+  }
+  /**
+   * Get scale notes.
+   * @param bottomNote - Computed scale notes begin no lower than this note.
+   * @param numOctaves - How many octaves?
+   * @returns - Array of scale notes.
+   */
+  getScaleNotes(bottomNote, numOctaves) {
+    if (!guard_exports.isIntegerGte(numOctaves, 1)) {
+      throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid numOctaves: ${numOctaves}`);
+    }
+    let scaleNoteList = [];
+    for (let o = 1; o <= numOctaves; o++) {
+      scaleNoteList = [...scaleNoteList, ...this.scaleNotes];
+    }
+    scaleNoteList.push(this.scaleNotes[0]);
+    let diatonicId = Note.getNote(bottomNote).diatonicId;
+    return scaleNoteList.map((note) => {
+      diatonicId = Note.findNextDiatonicIdAbove(note.diatonicId, diatonicId, false);
+      return new Note(diatonicId, note.accidental);
+    });
+  }
+  /**
+   * Get scale overview (e.g. "C - D - E - F - G - A - B" for "C Major" scale).
+   * @returns - Scale overview string.
+   */
+  getScaleOverview() {
+    return this.getScaleNotes("C4", 1).map((note) => note.formatOmitOctave(1 /* Unicode */)).join(" - ");
+  }
+  /**
+   * Get scale steps, array of 1 (half step) and 2 (whole step), (e.g. [2, 2, 1, 2, 2, 2, 1] for Major scale).
+   * @returns - Array of scale steps.
+   */
+  getScaleSteps() {
+    let chromaticIds = this.getScaleNotes("C4", 1).map((note) => note.chromaticId);
+    let steps = [];
+    for (let i = 0; i < chromaticIds.length - 1; i++) {
+      steps.push(utils_exports.Math.mod(chromaticIds[i + 1] - chromaticIds[i], 12));
+    }
+    return steps;
+  }
+  /**
+   * Get scale steps string presentation, array of "H" (half step) and "W" (whole step), (e.g. ["W", "W", "H", "W", "W", "W", "H"] for Major scale).
+   * @returns - Array of scale steps string presentation.
+   */
+  getScaleStringSteps() {
+    return this.getScaleSteps().map((step) => step === 1 ? "H" : step === 2 ? "W" : step.toString() + "H");
+  }
+  /**
+   * Test if given note is scale note.
+   * @param note - Note to test.
+   * @returns - True/false.
+   */
+  isScaleNote(note) {
+    return this.chromaticClassDegree[note.chromaticClass] !== void 0;
+  }
+  /**
+   * Test if given note is scale root note.
+   * @param note - Note to test.
+   * @returns - True/false.
+   */
+  isScaleRootNote(note) {
+    return String(this.chromaticClassDegree[note.chromaticClass]) === "1";
+  }
+  /**
+   * Get interval value between scale root note and given note.
+   * @param note - Note.
+   * @returns - Interval.
+   */
+  getIntervalFromRootNote(note) {
+    let rootNote = this.getScaleNotes("C0", 1)[0];
+    while (note.chromaticId >= rootNote.chromaticId + 12) {
+      note = new Note(note.diatonicClass, note.accidental, note.octave - 1);
+    }
+    if (note.chromaticId < rootNote.chromaticId) {
+      throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Note is below rootNote.`);
+    }
+    let interval = Interval.get(rootNote, note);
+    if (interval === void 0) {
+      throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Interval is undefined.`);
+    } else {
+      return interval;
+    }
+  }
+  // Can it be negative case?
+  /**
+   * Get preferred chromatic note from given chromatic id.
+   * @param chromaticId - Chromatic id.
+   * @returns - Note.
+   */
+  getPreferredChromaticNote(chromaticId) {
+    Note.validateChromaticId(chromaticId);
+    let note = this.preferredChromaticIdNoteCache.get(chromaticId);
+    if (note) {
+      return note;
+    }
+    let octave = Note.getOctaveFromChromaticId(chromaticId);
+    let scaleNotes = this.scaleNotes.map((accNote) => {
+      if (accNote.noteLetter === "C" && accNote.accidental < 0) {
+        return new Note(accNote.diatonicClass, accNote.accidental, octave + 1);
+      } else if (accNote.noteLetter === "B" && accNote.accidental > 0) {
+        return new Note(accNote.diatonicClass, accNote.accidental, octave - 1);
+      } else {
+        return new Note(accNote.diatonicClass, accNote.accidental, octave);
+      }
+    });
+    note = scaleNotes.find((note2) => Note.getChromaticClass(chromaticId) === note2.chromaticClass);
+    if (note) {
+      this.preferredChromaticIdNoteCache.set(chromaticId, note);
+      return note;
+    }
+    let diatonicIdMid = getNaturalDiatonicId(chromaticId);
+    let diatonicIdStart = diatonicIdMid - 2;
+    let diatonicIdEnd = diatonicIdMid + 2;
+    let preferFlat = this.getAccidentalType() === 1 /* Flats */;
+    let preferredAccs = preferFlat ? [0, -1, 1, -2, 2] : [0, 1, -1, 2, -2];
+    for (let ai = 0; ai < preferredAccs.length; ai++) {
+      let acc = preferredAccs[ai];
+      for (let diatonicId = Math.max(0, diatonicIdStart); diatonicId <= diatonicIdEnd; diatonicId++) {
+        note = new Note(diatonicId, acc);
+        if (chromaticId === note.chromaticId) {
+          this.preferredChromaticIdNoteCache.set(chromaticId, note);
+          return note;
+        }
+      }
+    }
+    note = Note.getChromaticNote(chromaticId);
+    this.preferredChromaticIdNoteCache.set(chromaticId, note);
+    return note;
+  }
+};
+var ScaleFactory = class {
+  /**
+   * Create new scale factory object instance.
+   * @param type - Scale type.
+   */
+  constructor(type) {
+    this.type = type;
+    __publicField(this, "tonicList", []);
+    __publicField(this, "scaleMap", /* @__PURE__ */ new Map());
+    let naturalScales = [];
+    let sharpScales = [];
+    let flatScales = [];
+    FullTonicList.forEach((tonic) => {
+      try {
+        let scale = new Scale(tonic, this.type);
+        switch (scale.getAccidentalType()) {
+          case 0 /* Natural */:
+            naturalScales.push(scale);
+            break;
+          case 2 /* Sharps */:
+            if (tonic.endsWith("b")) {
+              return;
+            } else {
+              sharpScales.push(scale);
+              break;
+            }
+          case 1 /* Flats */:
+            if (tonic.endsWith("#")) {
+              return;
+            } else {
+              flatScales.push(scale);
+              break;
+            }
+        }
+        this.scaleMap.set(tonic, scale);
+      } catch (err) {
+      }
+    });
+    if (naturalScales.length === 0) {
+      throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Expected natural scale.`);
+    }
+    const SortByAccidentalCountFunc = (a, b) => a.getNumAccidentals() - b.getNumAccidentals();
+    this.tonicList = [
+      ...naturalScales.sort(SortByAccidentalCountFunc).map((scale) => scale.tonic),
+      "- Sharps -",
+      ...sharpScales.sort(SortByAccidentalCountFunc).map((scale) => scale.tonic),
+      "- Flats -",
+      ...flatScales.sort(SortByAccidentalCountFunc).map((scale) => scale.tonic)
+    ];
+  }
+  /**
+   * Get list of tonics (e.g. "C", "C#", ... for Major scale type).
+   * @returns - Array of tonics.
+   */
+  getTonicList() {
+    return this.tonicList;
+  }
+  /**
+   * Get default tonic.
+   * @returns - Default tonic.
+   */
+  getDefaultTonic() {
+    return this.tonicList[0];
+  }
+  /**
+   * Get scale type.
+   * @returns - SCale type.
+   */
+  getType() {
+    return this.type;
+  }
+  /**
+   * Get scale by given tonic.
+   * @param tonic - Tonic (e.g. "C").
+   * @returns - Scale.
+   */
+  getScale(tonic) {
+    let scale = this.scaleMap.get(tonic);
+    if (!scale) {
+      throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid scale: ${tonic} ${this.type}`);
+    } else {
+      return scale;
+    }
+  }
+  /**
+   * Test if this scale factory has scale for given tonic value.
+   * @param tonic - Tonic.
+   * @returns - True/false.
+   */
+  hasScale(tonic) {
+    return this.scaleMap.get(tonic) !== void 0;
+  }
+};
+var ScaleFactoryList = [
+  new ScaleFactory("Major" /* Major */),
+  new ScaleFactory("Natural Minor" /* NaturalMinor */),
+  new ScaleFactory("Harmonic Minor" /* HarmonicMinor */),
+  "- Modes -",
+  new ScaleFactory("Ionian" /* Ionian */),
+  new ScaleFactory("Dorian" /* Dorian */),
+  new ScaleFactory("Phrygian" /* Phrygian */),
+  new ScaleFactory("Lydian" /* Lydian */),
+  new ScaleFactory("Mixolydian" /* Mixolydian */),
+  new ScaleFactory("Aeolian" /* Aeolian */),
+  new ScaleFactory("Locrian" /* Locrian */),
+  "- Pentatonic -",
+  new ScaleFactory("Major Pentatonic" /* MajorPentatonic */),
+  new ScaleFactory("Minor Pentatonic" /* MinorPentatonic */),
+  "- Blues -",
+  new ScaleFactory("Major Hexatonic Blues" /* MajorHexatonicBlues */),
+  new ScaleFactory("Minor Hexatonic Blues" /* MinorHexatonicBlues */),
+  new ScaleFactory("Heptatonic Blues" /* HeptatonicBlues */)
+];
+function getScaleFactoryList() {
+  return ScaleFactoryList;
+}
+var ScaleFactoryMap = new UniMap();
+ScaleFactoryList.forEach((factory) => {
+  if (factory instanceof ScaleFactory) {
+    ScaleFactoryMap.set(factory.getType(), factory);
+  }
+});
+function getScaleFactory(scaleType) {
+  let f = ScaleFactoryMap.get(scaleType);
+  if (!f) {
+    throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid scaleType: ${scaleType}`);
+  } else {
+    return f;
+  }
+}
+function validateScaleType(scaleType) {
+  if (guard_exports.isEnumValue(scaleType, ScaleType)) {
+    return scaleType;
+  } else {
+    throw new import_core5.MusicError(import_core5.MusicErrorType.Scale, `Invalid scaleType: "${scaleType}"`);
+  }
+}
+function getScale(arg0, arg1) {
+  let tonic;
+  let scaleType;
+  if (arg1 !== void 0) {
+    tonic = arg0;
+    scaleType = validateScaleType(arg1);
+  } else {
+    tonic = arg0.split(" ")[0];
+    scaleType = validateScaleType(arg0.substring(tonic.length + 1));
+  }
+  return getScaleFactory(scaleType).getScale(tonic);
+}
+var DefaultScale = getScale("C", "Major" /* Major */);
+function getDefaultScale() {
+  return DefaultScale;
+}
+
+// src/theory/chord.ts
+var import_core6 = require("web-music-score/core");
+var isEqualNote = (n1, n2) => n1.chromaticClass === n2.chromaticClass;
+var OkayRootNoteList = [
+  "C",
+  "C#",
+  "Db",
+  // Same id, first one always gets found
+  "D",
+  "Eb",
+  "E",
+  "F",
+  "F#",
+  "Gb",
+  "G",
+  "Ab",
+  "A",
+  "Bb",
+  "B",
+  "Cb"
+].map((noteName) => Note.getNote(noteName + "0"));
+var okayRootNoteCache = new IndexArray();
+function getOkayRootNote(wantedRootNote) {
+  return okayRootNoteCache.getOrCreate(wantedRootNote.chromaticClass, () => {
+    let rootNote = OkayRootNoteList.find((note) => isEqualNote(note, wantedRootNote));
+    if (!rootNote) {
+      throw new import_core6.MusicError(import_core6.MusicErrorType.InvalidArg, `Invalid chord root note: ${wantedRootNote.formatOmitOctave(1 /* Unicode */)}`);
+    }
+    return rootNote;
+  });
+}
+function getChordNoteByDegree(chordRootNote, degree) {
+  let chordRootNoteStr = chordRootNote.formatOmitOctave(0 /* Ascii */);
+  let ks = getScale(chordRootNoteStr, "Major" /* Major */);
+  return ks.getNoteByDegree(degree);
+}
+function removeNoteDuplicates(notes) {
+  return utils_exports.Arr.removeDuplicates(notes, isEqualNote);
+}
+var ChordInfoList = [
+  // Power chord
+  { name: "5", degrees: [1, 5] },
+  // Triads
+  { name: "", degrees: [1, 3, 5] },
+  { name: "m", degrees: [1, "b3", 5] },
+  { name: "dim", degrees: [1, "b3", "b5"] },
+  { name: "aug", degrees: [1, 3, "#5"] },
+  { name: "sus2", degrees: [1, 2, 5] },
+  { name: "sus4", degrees: [1, 4, 5] },
+  // Four-part chords
+  { name: "6", degrees: [1, 3, 5, 6] },
+  { name: "m6", degrees: [1, "b3", 5, 6] },
+  { name: "m(maj7)", degrees: [1, "b3", 5, 7] },
+  { name: "7", degrees: [1, 3, 5, "b7"] },
+  { name: "7\u266D5", degrees: [1, 3, "b5", "b7"] },
+  { name: "7\u266F5", degrees: [1, 3, "#5", "b7"] },
+  { name: "7sus2", degrees: [1, 2, 5, "b7"] },
+  { name: "7sus4", degrees: [1, 4, 5, "b7"] },
+  { name: "dim7", degrees: [1, "b3", "b5", "bb7"] },
+  { name: "maj7", degrees: [1, 3, 5, 7] },
+  { name: "maj7\u266D5", degrees: [1, 3, "b5", 7] },
+  { name: "maj7\u266F5", degrees: [1, 3, "#5", 7] },
+  { name: "m7", degrees: [1, "b3", 5, "b7"] },
+  { name: "m7\u266D5", degrees: [1, "b3", "b5", "b7"] },
+  { name: "m7\u266F5", degrees: [1, "b3", "#5", "b7"] },
+  // Five-part chords
+  { name: "9", degrees: [1, 3, 5, "b7", 9] },
+  { name: "m9", degrees: [1, "b3", 5, "b7", 9] },
+  { name: "7\u266F9", degrees: [1, 3, 5, "b7", "#9"] },
+  { name: "7\u266D9", degrees: [1, 3, 5, "b7", "b9"] },
+  // Six-part chords
+  { name: "11", degrees: [1, 3, 5, "b7", 9, 11] },
+  { name: "m11", degrees: [1, "b3", 5, "b7", 9, 11] },
+  // Seven-part chords
+  { name: "13", degrees: [1, 3, 5, "b7", 9, 11, 13] },
+  { name: "m13", degrees: [1, "b3", 5, "b7", 9, 11, 13] }
+];
+function canOmitDegree(chordInfo, degree) {
+  if (chordInfo.degrees.every((c) => c !== degree)) {
+    return true;
+  }
+  return chordInfo.degrees.length >= 4 && degree === 5 || // Four (and higher) part chord can exclude 5th degree
+  chordInfo.degrees.length >= 6 && degree === 9 || // Six (and higher) part chord can exclude 9th degree
+  chordInfo.degrees.length >= 7 && degree === 11;
+}
+var InvalidChordException = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.msg = msg;
+    this.name = "InvalidChordException";
+  }
+};
+var Chord = class _Chord {
+  constructor(chordInfo, chordNotes, rootNote, bassNote) {
+    this.chordInfo = chordInfo;
+    this.rootNote = rootNote;
+    /** Chord name. */
+    __publicField(this, "name");
+    /** Notes of this chord. */
+    __publicField(this, "notes");
+    /** Notes that are omitted in this chord (partial chord). */
+    __publicField(this, "omitNotes");
+    /** Bass note if not chord root note (e.g. "B" in "C/B"). */
+    __publicField(this, "slashBassNote");
+    this.name = chordInfo.name;
+    let notesLeft = chordNotes.slice();
+    let outOfChordBass = !notesLeft.some((note) => isEqualNote(note, bassNote));
+    if (outOfChordBass) {
+      notesLeft.push(bassNote);
+    }
+    this.notes = new Array(this.chordInfo.degrees.length);
+    this.omitNotes = new Array(this.chordInfo.degrees.length);
+    for (let i = 0; i < chordInfo.degrees.length; i++) {
+      let degree = chordInfo.degrees[i];
+      let degreeNote = this.notes[i] = getChordNoteByDegree(this.rootNote, degree);
+      let noteIndex = notesLeft.findIndex((note) => isEqualNote(note, degreeNote));
+      if (noteIndex >= 0) {
+        this.omitNotes[i] = false;
+        notesLeft.splice(noteIndex, 1);
+      } else if (canOmitDegree(chordInfo, degree)) {
+        this.omitNotes[i] = true;
+      } else {
+        throw new InvalidChordException("Missing chord note!");
+      }
+      if (isEqualNote(bassNote, degreeNote)) {
+        bassNote = degreeNote;
+      }
+    }
+    if (notesLeft.length > 0) {
+      if (notesLeft.every((note) => isEqualNote(note, bassNote))) {
+        this.slashBassNote = bassNote;
+      } else {
+        throw new InvalidChordException("Got some extra notes that are not bass note!");
+      }
+    } else {
+      this.slashBassNote = isEqualNote(bassNote, this.rootNote) ? void 0 : bassNote;
+    }
+    if (chordInfo.name === "5" && this.slashBassNote) {
+      throw new InvalidChordException("Power chord no bass note allowed!");
+    }
+  }
+  /**
+   * Get all chords that can be made up with given notes.
+   * @param notes - Array of notes.
+   * @returns - Array of chords.
+   */
+  static getChords(notes) {
+    let chords = [];
+    let chordNotes = Note.sort(notes);
+    let bassNote = chordNotes[0];
+    let uniqueNotes = removeNoteDuplicates(chordNotes);
+    for (let inversion = 0; inversion < uniqueNotes.length; inversion++) {
+      let rootNote = getOkayRootNote(uniqueNotes[inversion]);
+      ChordInfoList.forEach((chordInfo) => {
+        try {
+          let newChord = new _Chord(chordInfo, uniqueNotes, rootNote, bassNote);
+          let replaceIndex = chords.findIndex((chord) => chord.replaceWith(newChord));
+          if (replaceIndex >= 0) {
+            chords[replaceIndex] = newChord;
+          } else {
+            chords.push(newChord);
+          }
+        } catch (err) {
+          if (!(err instanceof InvalidChordException)) {
+            throw err;
+          }
+        }
+      });
+    }
+    return chords;
+  }
+  replaceWith(arg) {
+    if (arg.notes.length < this.notes.length) {
+      return false;
+    } else if (arg.slashBassNote && this.slashBassNote && !isEqualNote(arg.slashBassNote, this.slashBassNote) || arg.slashBassNote && !this.slashBassNote || !arg.slashBassNote && this.slashBassNote) {
+      return false;
+    }
+    for (let i = 0; i < this.notes.length; i++) {
+      if (!isEqualNote(arg.notes[i], this.notes[i]) || arg.omitNotes[i] !== this.omitNotes[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get chord string presentation.
+   * @returns Chord string presentation (e.g. "C/B").
+   */
+  toString() {
+    let symbolSet = 1 /* Unicode */;
+    let rootNoteStr = this.rootNote.formatOmitOctave(symbolSet);
+    let slashBassStr = this.slashBassNote ? "/" + this.slashBassNote.formatOmitOctave(symbolSet) : "";
+    return rootNoteStr + this.name + slashBassStr;
+  }
+  /**
+   * Get degree notation string (e.g. "E - 1(C) - 3(E) - 5(G)").
+   * @returns Degree notation string.
+   */
+  getDegreeNotationString() {
+    let symbolSet = 1 /* Unicode */;
+    let bassNoteStr = this.slashBassNote ? this.slashBassNote.formatOmitOctave(symbolSet) + " - " : "";
+    let degreeNoteStr = this.omitNotes.map((omitNote, i) => {
+      return this.getDegreeStr(i) + "(" + (omitNote ? "-" : this.getNoteStr(i)) + ")";
+    }).join(" - ");
+    return bassNoteStr + degreeNoteStr;
+  }
+  /**
+   * Get string presentation of omitted degrees (e.g. "Omits 5(G), 9(D)").
+   * @returns - String presentation of omitted degrees.
+   */
+  getOmittedDegreesString() {
+    let omittedStrList = this.omitNotes.map((omit, i) => {
+      return omit ? this.getDegreeStr(i) + "(" + this.getNoteStr(i) + ")" : void 0;
+    }).filter((str2) => str2 !== void 0);
+    return omittedStrList.length > 0 ? "Omits " + omittedStrList.join(", ") : "";
+  }
+  /**
+   * Degree index for given degree index (e.g. "3").
+   * @param i - Chord degree index (e.g. 0 is first note degree of chord).
+   * @returns Degree string.
+   */
+  getDegreeStr(i) {
+    return Note.replaceAccidentalSymbols("" + this.chordInfo.degrees[i], 1 /* Unicode */);
+  }
+  /**
+   * Get note name for given degree index (e.g. "E").
+   * @param i - Chord degree index (e.g. 0 is first note degree of chord).
+   * @returns - Note name string.
+   */
+  getNoteStr(i) {
+    return this.notes[i].formatOmitOctave(1 /* Unicode */);
+  }
+};
+
+// src/theory/assets/tunings.json
+var tunings_default = {
+  list: [
+    {
+      name: "Standard",
+      strings: [
+        "E2",
+        "A2",
+        "D3",
+        "G3",
+        "B3",
+        "E4"
+      ]
+    },
+    {
+      name: "B Standard",
+      strings: [
+        "B1",
+        "E2",
+        "A2",
+        "D3",
+        "F#3",
+        "B3"
+      ]
+    },
+    {
+      name: "C Standard",
+      strings: [
+        "C2",
+        "F2",
+        "A#2",
+        "D#3",
+        "G3",
+        "C4"
+      ]
+    },
+    {
+      name: "D Modal",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "G3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "D Standard",
+      strings: [
+        "D2",
+        "G2",
+        "C3",
+        "F3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "D# Standard",
+      strings: [
+        "D#2",
+        "G#2",
+        "C#3",
+        "F#3",
+        "A#3",
+        "D#4"
+      ]
+    },
+    {
+      name: "Double Drop D",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "G3",
+        "B3",
+        "D4"
+      ]
+    },
+    {
+      name: "Drop B",
+      strings: [
+        "B1",
+        "F#2",
+        "B2",
+        "E3",
+        "G#3",
+        "C#4"
+      ]
+    },
+    {
+      name: "Drop C",
+      strings: [
+        "C2",
+        "G2",
+        "C3",
+        "F3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "Drop D",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "G3",
+        "B3",
+        "E4"
+      ]
+    },
+    {
+      name: "Low C",
+      strings: [
+        "C2",
+        "G2",
+        "D3",
+        "G3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "New Standard",
+      strings: [
+        "C2",
+        "G2",
+        "D3",
+        "A3",
+        "E4",
+        "G4"
+      ]
+    },
+    {
+      name: "Open A",
+      strings: [
+        "E2",
+        "A2",
+        "C#3",
+        "E3",
+        "A3",
+        "E4"
+      ]
+    },
+    {
+      name: "Open A Minor",
+      strings: [
+        "E2",
+        "A2",
+        "E3",
+        "A3",
+        "C4",
+        "E4"
+      ]
+    },
+    {
+      name: "Open C",
+      strings: [
+        "C2",
+        "G2",
+        "C3",
+        "G3",
+        "C4",
+        "E4"
+      ]
+    },
+    {
+      name: "Open C Minor",
+      strings: [
+        "C2",
+        "G2",
+        "C3",
+        "G3",
+        "C4",
+        "D#4"
+      ]
+    },
+    {
+      name: "Open D",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "F#3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "Open D Minor",
+      strings: [
+        "D2",
+        "A2",
+        "D3",
+        "F3",
+        "A3",
+        "D4"
+      ]
+    },
+    {
+      name: "Open E",
+      strings: [
+        "E2",
+        "B2",
+        "E3",
+        "G#3",
+        "B3",
+        "E4"
+      ]
+    },
+    {
+      name: "Open E Minor",
+      strings: [
+        "E2",
+        "B2",
+        "E3",
+        "G3",
+        "B3",
+        "E4"
+      ]
+    },
+    {
+      name: "Open G",
+      strings: [
+        "D2",
+        "G2",
+        "D3",
+        "G3",
+        "B3",
+        "D4"
+      ]
+    },
+    {
+      name: "Open G Minor",
+      strings: [
+        "D2",
+        "G2",
+        "D3",
+        "G3",
+        "A#3",
+        "D4"
+      ]
+    }
+  ]
+};
+
+// src/theory/guitar.ts
+var import_core7 = require("web-music-score/core");
+var TuningNameList = tunings_default.list.map((data) => data.name);
+var DefaultTuningName = TuningNameList[0];
+function validateTuningName(tuningName) {
+  if (TuningNameList.indexOf(tuningName) < 0) {
+    throw new import_core7.MusicError(import_core7.MusicErrorType.InvalidArg, `Invalid tuning name: ${tuningName}`);
+  } else {
+    return tuningName;
+  }
+}
+var TuningStringsCache = new LRUCache(100);
+function getTuningStrings(tuningName) {
+  let tuningStrings = TuningStringsCache.get(tuningName);
+  if (!tuningStrings) {
+    let tuningData = tunings_default.list.find((data) => data.name === tuningName);
+    if (!tuningData) {
+      throw new import_core7.MusicError(import_core7.MusicErrorType.InvalidArg, `Invalid tuningName: ${tuningName}`);
+    }
+    tuningStrings = tuningData.strings.slice().reverse().map((noteName) => Note.getNote(noteName));
+    if (!guard_exports.isIntegerEq(tuningStrings.length, 6)) {
+      throw new import_core7.MusicError(import_core7.MusicErrorType.Unknown, `Tuning has ${tuningStrings.length} strings.`);
+    }
+    TuningStringsCache.set(tuningName, tuningStrings);
+  }
+  return tuningStrings;
+}
+
+// src/theory/rhythm.ts
+var import_core8 = require("web-music-score/core");
+var MaxTupletRatioValue = 12;
+var TicksMultiplier = 12 * 11 * 9 * 7 * 5;
+var NoteLength = /* @__PURE__ */ ((NoteLength3) => {
+  NoteLength3["Whole"] = "1n";
+  NoteLength3["WholeTriplet"] = "1t";
+  NoteLength3["WholeDot"] = "1.";
+  NoteLength3["Whole2Dots"] = "1..";
+  NoteLength3["Whole3Dots"] = "1...";
+  NoteLength3["Whole4Dots"] = "1....";
+  NoteLength3["Whole5Dots"] = "1.....";
+  NoteLength3["Whole6Dots"] = "1......";
+  NoteLength3["Half"] = "2n";
+  NoteLength3["HalfTriplet"] = "2t";
+  NoteLength3["HalfDot"] = "2.";
+  NoteLength3["Half2Dots"] = "2..";
+  NoteLength3["Half3Dots"] = "2...";
+  NoteLength3["Half4Dots"] = "2....";
+  NoteLength3["Half5Dots"] = "2.....";
+  NoteLength3["Quarter"] = "4n";
+  NoteLength3["QuarterTriplet"] = "4t";
+  NoteLength3["QuarterDot"] = "4.";
+  NoteLength3["Quarter2Dots"] = "4..";
+  NoteLength3["Quarter3Dots"] = "4...";
+  NoteLength3["Quarter4Dots"] = "4....";
+  NoteLength3["Eighth"] = "8n";
+  NoteLength3["EighthTriplet"] = "8t";
+  NoteLength3["EighthDot"] = "8.";
+  NoteLength3["Eighth2Dots"] = "8..";
+  NoteLength3["Eighth3Dots"] = "8...";
+  NoteLength3["Sixteenth"] = "16n";
+  NoteLength3["SixteenthTriplet"] = "16t";
+  NoteLength3["SixteenthDot"] = "16.";
+  NoteLength3["Sixteenth2Dots"] = "16..";
+  NoteLength3["ThirtySecond"] = "32n";
+  NoteLength3["ThirtySecondTriplet"] = "32t";
+  NoteLength3["ThirtySecondDot"] = "32.";
+  NoteLength3["SixtyFourth"] = "64n";
+  NoteLength3["SixtyFourthTriplet"] = "64t";
+  return NoteLength3;
+})(NoteLength || {});
+function isNoteLength(noteLength) {
+  return guard_exports.isEnumValue(noteLength, NoteLength);
+}
+function validateNoteLength(noteLength) {
+  if (isNoteLength(noteLength)) {
+    return noteLength;
+  } else {
+    throw new import_core8.MusicError(import_core8.MusicErrorType.InvalidArg, `Invalid noteLength: ${noteLength}`);
+  }
+}
+var _NoteLengthProps = class _NoteLengthProps {
+  constructor(noteLength) {
+    /** Note length. */
+    __publicField(this, "noteLength");
+    /** Note size (whole=1, half=2, quarter=4, ...). */
+    __publicField(this, "noteSize");
+    /** Number of ticks (not altered by isTriplet). */
+    __publicField(this, "ticks");
+    /** Flag count. */
+    __publicField(this, "flagCount");
+    /** Dot count. */
+    __publicField(this, "dotCount");
+    /** Max dot count. */
+    __publicField(this, "maxDotCount");
+    /** Is triplet? */
+    __publicField(this, "isTriplet");
+    /** Has note stem. */
+    __publicField(this, "hasStem");
+    /** Is note head solid (black)? */
+    __publicField(this, "isSolid");
+    this.noteLength = validateNoteLength(noteLength);
+    this.noteSize = parseInt(noteLength);
+    this.isTriplet = noteLength.endsWith("t");
+    this.maxDotCount = this.isTriplet ? 0 : Math.floor(Math.log2(_NoteLengthProps.ShortestNoteSize / this.noteSize));
+    this.dotCount = utils_exports.Str.charCount(noteLength, ".");
+    this.flagCount = this.noteSize > 4 ? Math.floor(Math.log2(this.noteSize / 4)) : 0;
+    this.ticks = TicksMultiplier * _NoteLengthProps.ShortestNoteSize / this.noteSize;
+    this.hasStem = this.noteSize > 1;
+    this.isSolid = this.noteSize > 2;
+    if (this.dotCount > this.maxDotCount) {
+      throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `dotCount ${this.dotCount} > maxDotCount ${this.maxDotCount}, for noteLength "${this.noteLength}".`);
+    } else if (this.isTriplet && this.dotCount > 0) {
+      throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `noteLength "${this.noteLength}" is both triplet and dotted!`);
+    }
+  }
+  /**
+   * Get note length props.
+   * @param noteLength - Note length.
+   * @returns - Note length props.
+   */
+  static get(noteLength) {
+    return this.cache.getOrCreate(noteLength, () => new _NoteLengthProps(noteLength));
+  }
+  /**
+   * Create note length props.
+   * @param noteLength - Note length or note size.
+   * @param dotCount - Dot count.
+   * @returns - Note length props.
+   */
+  static create(noteLength, dotCount = 0) {
+    let noteSize = typeof noteLength === "number" ? noteLength : this.get(noteLength).noteSize;
+    return this.get(noteSize + (guard_exports.isIntegerGte(dotCount, 1) ? ".".repeat(dotCount) : "n"));
+  }
+  /**
+   * Compare note lengths/sizes. Whole (1) > half (2) > quarter (4), etc.
+   * Ignores possible triplet property of note length.
+   * @param a - NoteLengthProps, NoteLength/Str or noteSize
+   * @param b - NoteLengthProps, NoteLength/Str or noteSize
+   * @returns - -1: a < b, 0: a === b, +1: a > b (note length/size comparisons)
+   */
+  static cmp(a, b) {
+    let aNoteSize = a instanceof _NoteLengthProps ? a.noteSize : typeof a === "number" ? a : _NoteLengthProps.get(a).noteSize;
+    let bNoteSize = b instanceof _NoteLengthProps ? b.noteSize : typeof b === "number" ? b : _NoteLengthProps.get(b).noteSize;
+    return utils_exports.Math.cmp(bNoteSize, aNoteSize);
+  }
+  /**
+   * Compare note lengths/sizes for equality.
+   * Ignores possible triplet property of note length.
+   * @param a - NoteLengthProps, NoteLength/Str or noteSize
+   * @param b - NoteLengthProps, NoteLength/Str or noteSize
+   * @returns - true: a === b, false: a !== b (note length/size comparisons)
+   */
+  static equals(a, b) {
+    let aNoteSize = a instanceof _NoteLengthProps ? a.noteSize : typeof a === "number" ? a : _NoteLengthProps.get(a).noteSize;
+    let bNoteSize = b instanceof _NoteLengthProps ? b.noteSize : typeof b === "number" ? b : _NoteLengthProps.get(b).noteSize;
+    return aNoteSize === bNoteSize;
+  }
+};
+/** Longest note size (e.g. 1 = whole note). */
+__publicField(_NoteLengthProps, "LongestNoteSize", Math.min(...utils_exports.Enum.getEnumValues(NoteLength).map((noteLength) => parseInt(noteLength))));
+/** Shortest note size (e.g. 64 = sixtyfourth note). */
+__publicField(_NoteLengthProps, "ShortestNoteSize", Math.max(...utils_exports.Enum.getEnumValues(NoteLength).map((noteLength) => parseInt(noteLength))));
+__publicField(_NoteLengthProps, "cache", new UniMap());
+var NoteLengthProps = _NoteLengthProps;
+function isTupletRatio(tupletRatio) {
+  return guard_exports.isObject(tupletRatio) && guard_exports.isIntegerBetween(tupletRatio.parts, 2, MaxTupletRatioValue) && guard_exports.isIntegerBetween(tupletRatio.inTimeOf, 2, MaxTupletRatioValue);
+}
+function validateTupletRatio(tupletRatio) {
+  if (isTupletRatio(tupletRatio)) {
+    return tupletRatio;
+  } else {
+    throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `Invalid tupletRatio ${JSON.stringify(tupletRatio)}`);
+  }
+}
+var Tuplet = {
+  /** Duplet: 2 in the time of 3 */
+  Duplet: { parts: 2, inTimeOf: 3 },
+  /** Triplet: 3 in the time of 2 */
+  Triplet: { parts: 3, inTimeOf: 2 },
+  /** Quadruplet: 4 in the time of 3 */
+  Quadruplet: { parts: 4, inTimeOf: 3 }
+};
+var _RhythmProps = class _RhythmProps {
+  constructor(noteLength, dotCount, tupletRatio) {
+    /** Note length. */
+    __publicField(this, "noteLength");
+    /** Note size (whole=1, half=2, quarter=4, ...). */
+    __publicField(this, "noteSize");
+    /** Dot count. */
+    __publicField(this, "dotCount");
+    /** Tuplet ratio. */
+    __publicField(this, "tupletRatio");
+    /** Number of ticks. */
+    __publicField(this, "ticks");
+    /** Flag count. */
+    __publicField(this, "flagCount");
+    /** Has note stem. */
+    __publicField(this, "hasStem");
+    /** Is note head solid (black)? */
+    __publicField(this, "isSolidNoteHead");
+    this.noteLength = validateNoteLength(noteLength);
+    let p = NoteLengthProps.get(noteLength);
+    this.noteSize = p.noteSize;
+    this.ticks = p.ticks;
+    this.flagCount = p.flagCount;
+    this.dotCount = dotCount != null ? dotCount : p.dotCount;
+    this.hasStem = p.hasStem;
+    this.isSolidNoteHead = p.isSolid;
+    if (guard_exports.isObject(tupletRatio)) {
+      this.tupletRatio = validateTupletRatio(tupletRatio);
+    } else if (p.isTriplet) {
+      this.tupletRatio = Tuplet.Triplet;
+    } else {
+      this.tupletRatio = void 0;
+    }
+    if (this.dotCount > 0 && this.tupletRatio !== void 0) {
+      throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `Note cannot be both dotted and tuplet!`);
+    } else if (this.dotCount > p.maxDotCount) {
+      throw new import_core8.MusicError(import_core8.MusicErrorType.Note, `Too big dot count ${this.dotCount} for note length ${this.noteLength}.`);
+    }
+    for (let add = this.ticks / 2, i = 1; i <= this.dotCount; i++, add /= 2) {
+      this.ticks += add;
+    }
+    if (this.tupletRatio) {
+      this.ticks *= this.tupletRatio.inTimeOf / this.tupletRatio.parts;
+    }
+  }
+  /**
+   * Get string presentation of rhythm props.
+   * @returns - String presentation.
+   */
+  toString() {
+    let sym = _RhythmProps.NoteSymbolMap.get(this.noteSize);
+    let dots = ".".repeat(this.dotCount);
+    return sym ? sym + dots : "" + this.noteSize + (dots.length > 0 ? dots : "n");
+  }
+  /**
+   * Get rhythm props with given arguments.
+   * @param noteLength - Note length.
+   * @param dotCount - Dot count.
+   * @param tupletRatio - Tuplet ratio.
+   * @returns - Rhythm props.
+   */
+  static get(noteLength, dotCount, tupletRatio) {
+    if (dotCount !== void 0 || tupletRatio !== void 0) {
+      return new _RhythmProps(noteLength, dotCount, tupletRatio);
+    } else {
+      return this.cache.getOrCreate(noteLength, () => new _RhythmProps(noteLength));
+    }
+  }
+  /**
+   * Compare duration of rhythm props.
+   * @param a - RhythmProps
+   * @param b - RhythmProps
+   * @returns - -1: a < b, 0: a === b, +1: a > b (duration comparisons)
+   */
+  static cmp(a, b) {
+    return utils_exports.Math.cmp(a.ticks, b.ticks);
+  }
+  /**
+   * Compare duration equality of rhythm props.
+   * @param a - RhythmProps
+   * @param b - RhythmProps
+   * @returns - true: a === b, false: a !== b (duration comparisons)
+   */
+  static equals(a, b) {
+    return a.ticks === b.ticks;
+  }
+};
+__publicField(_RhythmProps, "NoteSymbolMap", new IndexArray([[1, "\u{1D15D}"], [2, "\u{1D15E}"], [4, "\u{1D15F}"], [8, "\u{1D160}"], [16, "\u{1D161}"], [32, "\u{1D162}"], [64, "\u{1D163}"], [128, "\u{1D164}"]]));
+__publicField(_RhythmProps, "cache", new UniMap());
+var RhythmProps = _RhythmProps;
+
+// src/theory/time-signature.ts
+var import_core9 = require("web-music-score/core");
+var TimeSignatures = /* @__PURE__ */ ((TimeSignatures2) => {
+  TimeSignatures2["_2_4"] = "2/4";
+  TimeSignatures2["_3_4"] = "3/4";
+  TimeSignatures2["_4_4"] = "4/4";
+  TimeSignatures2["_3_8"] = "3/8";
+  TimeSignatures2["_5_8"] = "5/8";
+  TimeSignatures2["_6_8"] = "6/8";
+  TimeSignatures2["_7_8"] = "7/8";
+  TimeSignatures2["_9_8"] = "9/8";
+  TimeSignatures2["_12_8"] = "12/8";
+  return TimeSignatures2;
+})(TimeSignatures || {});
+var BeamGrouping = /* @__PURE__ */ ((BeamGrouping2) => {
+  BeamGrouping2["_2_3"] = "2-3";
+  BeamGrouping2["_3_2"] = "3-2";
+  BeamGrouping2["_2_2_3"] = "2-2-3";
+  BeamGrouping2["_3_2_2"] = "3-2-2";
+  return BeamGrouping2;
+})(BeamGrouping || {});
+var TimeSignature = class {
+  constructor(...args) {
+    /** Number of beats in measure, upper value (e.g. "3" in "3/4"). */
+    __publicField(this, "beatCount");
+    /** Beat size of time signature, lower value (e.g. "4" in "3/4"). */
+    __publicField(this, "beatSize");
+    /** Beat length. */
+    __publicField(this, "beatLength");
+    /** Number of ticks in measure. */
+    __publicField(this, "measureTicks");
+    /** Beam groups (e.g. [[2], [2]] or [[2, 2], [2, 2]] (first try as [[4], [4]])). */
+    __publicField(this, "beamGroupSizes", []);
+    let beamGrouping;
+    if (guard_exports.isEnumValue(args[0], TimeSignatures)) {
+      let parts = args[0].split("/");
+      this.beatCount = +parts[0];
+      this.beatSize = +parts[1];
+      if (guard_exports.isEnumValue(args[1], BeamGrouping)) {
+        beamGrouping = args[1];
+      }
+    } else if (guard_exports.isIntegerGte(args[0], 2) && guard_exports.isIntegerGte(args[1], 2)) {
+      this.beatCount = args[0];
+      this.beatSize = args[1];
+      if (guard_exports.isEnumValue(args[2], BeamGrouping)) {
+        beamGrouping = args[2];
+      }
+    } else {
+      throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid args: ${args}`);
+    }
+    if (!guard_exports.isIntegerGte(this.beatCount, 1)) {
+      throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beatCount: ${this.beatCount}`);
+    } else if (!guard_exports.isIntegerGte(this.beatSize, 1)) {
+      throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beatSize: ${this.beatSize}`);
+    }
+    let { noteLength, ticks } = NoteLengthProps.create(this.beatSize);
+    this.beatLength = noteLength;
+    this.measureTicks = this.beatCount * ticks;
+    if (this.is(2, 4)) {
+      this.beamGroupSizes = [[2], [2]];
+    } else if (this.is(3, 4)) {
+      this.beamGroupSizes = [[2], [2], [2]];
+    } else if (this.is(4, 4)) {
+      this.beamGroupSizes = [[2, 2], [2, 2]];
+    } else if (this.is(3, 8)) {
+      this.beamGroupSizes = [[3]];
+    } else if (this.is(5, 8)) {
+      if (!guard_exports.isUndefined(beamGrouping) && beamGrouping !== "2-3" /* _2_3 */ && beamGrouping !== "3-2" /* _3_2 */) {
+        throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beam grouping "${beamGrouping}" for time signature "${this.toString()}".`);
+      } else {
+        this.beamGroupSizes = beamGrouping === "3-2" /* _3_2 */ ? [[3], [2]] : [[2], [3]];
+        beamGrouping = void 0;
+      }
+    } else if (this.is(6, 8)) {
+      this.beamGroupSizes = [[3], [3]];
+    } else if (this.is(7, 8)) {
+      if (!guard_exports.isUndefined(beamGrouping) && beamGrouping !== "2-2-3" /* _2_2_3 */ && beamGrouping !== "3-2-2" /* _3_2_2 */) {
+        throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beam grouping "${beamGrouping}" for time signature "${this.toString()}".`);
+      } else {
+        this.beamGroupSizes = beamGrouping === "3-2-2" /* _3_2_2 */ ? [[3], [2], [2]] : [[2], [2], [3]];
+        beamGrouping = void 0;
+      }
+    } else if (this.is(9, 8)) {
+      this.beamGroupSizes = [[3], [3], [3]];
+    } else if (this.is(12, 8)) {
+      this.beamGroupSizes = [[3], [3], [3], [3]];
+    }
+    if (this.beamGroupSizes.length === 0) {
+      throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Unimplemented time signature "${this.toString()}".`);
+    } else if (beamGrouping !== void 0) {
+      throw new import_core9.MusicError(import_core9.MusicErrorType.Timesignature, `Invalid beam grouping "${beamGrouping}" for time signature "${this.toString()}".`);
+    }
+  }
+  /**
+   * Test whether this time signature has given beat count and size.
+   * @param beatCount - Beat count.
+   * @param beatSize - Beat size.
+   * @returns - Boolean whether this time signature match given beat count and size.
+   */
+  is(beatCount, beatSize) {
+    return this.beatCount === beatCount && this.beatSize === beatSize;
+  }
+  /**
+   * Get string representation of this time signature (e.g. "3/4").
+   * @returns - String representation.
+   */
+  toString() {
+    return this.beatCount + "/" + this.beatSize;
+  }
+};
+var defaultTimeSignature;
+function getDefaultTimeSignature() {
+  if (!defaultTimeSignature) {
+    defaultTimeSignature = new TimeSignature(4, 4);
+  }
+  return defaultTimeSignature;
+}
+
+// src/theory/tempo.ts
+var defaultTempo;
+function getDefaultTempo() {
+  if (!defaultTempo) {
+    defaultTempo = { beatsPerMinute: 120, options: { beatLength: "4n" /* Quarter */, dotCount: 0 } };
+  }
+  return defaultTempo;
+}
+function getTempoString(tempo) {
+  return RhythmProps.get(tempo.options.beatLength, tempo.options.dotCount).toString() + "=" + tempo.beatsPerMinute;
+}
+function alterTempoSpeed(tempo, speed) {
+  return {
+    beatsPerMinute: tempo.beatsPerMinute * speed,
+    options: { beatLength: tempo.options.beatLength, dotCount: tempo.options.dotCount }
+  };
+}
+
+// src/theory/index.ts
+var import_core10 = require("web-music-score/core");
+(0, import_core10.init)();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccidentalType,
+  BeamGrouping,
+  Chord,
+  DefaultGuitarNoteLabel,
+  DefaultPitchNotation,
+  DefaultTuningName,
+  GuitarNoteLabel,
+  GuitarNoteLabelList,
+  Interval,
+  KeySignature,
+  Mode,
+  Note,
+  NoteLength,
+  NoteLengthProps,
+  PitchNotation,
+  PitchNotationList,
+  RhythmProps,
+  Scale,
+  ScaleFactory,
+  ScaleType,
+  SymbolSet,
+  TimeSignature,
+  TimeSignatures,
+  TuningNameList,
+  Tuplet,
+  alterTempoSpeed,
+  getDefaultKeySignature,
+  getDefaultScale,
+  getDefaultTempo,
+  getDefaultTimeSignature,
+  getPitchNotationName,
+  getScale,
+  getScaleFactory,
+  getScaleFactoryList,
+  getTempoString,
+  getTuningStrings,
+  isNoteLength,
+  isTupletRatio,
+  validateGuitarNoteLabel,
+  validateIntervalQuality,
+  validateNoteLength,
+  validatePitchNotation,
+  validateScaleType,
+  validateTuningName,
+  validateTupletRatio
+});
+/*! Bundled license information:
+
+@tspro/ts-utils-lib/dist/index.mjs:
+  (*!
+   * TsUtilsLib v2.2.1 (esm)
+   * (c) 2023-2025 PahkaSoft
+   * Licensed under the MIT License
+   *)
+*/
+//# sourceMappingURL=index.js.map