chordsheetjs 10.10.0 → 10.10.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/lib/bundle.js +944 -790
  2. package/lib/bundle.min.js +118 -118
  3. package/lib/index.js +944 -488
  4. package/lib/index.js.map +1 -1
  5. package/lib/main.d.ts +7 -2
  6. package/lib/main.d.ts.map +1 -1
  7. package/lib/module.js +944 -484
  8. package/lib/module.js.map +1 -1
  9. package/package.json +4 -9
package/lib/bundle.js CHANGED
@@ -5,324 +5,15 @@ var ChordSheetJS = (() => {
5
5
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
6
6
  };
7
7
 
8
- // node_modules/lodash.get/index.js
9
- var require_lodash = __commonJS({
10
- "node_modules/lodash.get/index.js"(exports, module) {
11
- var FUNC_ERROR_TEXT = "Expected a function";
12
- var HASH_UNDEFINED = "__lodash_hash_undefined__";
13
- var INFINITY = 1 / 0;
14
- var funcTag = "[object Function]";
15
- var genTag = "[object GeneratorFunction]";
16
- var symbolTag = "[object Symbol]";
17
- var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
18
- var reIsPlainProp = /^\w*$/;
19
- var reLeadingDot = /^\./;
20
- var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
21
- var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
22
- var reEscapeChar = /\\(\\)?/g;
23
- var reIsHostCtor = /^\[object .+?Constructor\]$/;
24
- var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
25
- var freeSelf = typeof self == "object" && self && self.Object === Object && self;
26
- var root = freeGlobal || freeSelf || Function("return this")();
27
- function getValue(object, key) {
28
- return object == null ? void 0 : object[key];
29
- }
30
- function isHostObject(value) {
31
- var result = false;
32
- if (value != null && typeof value.toString != "function") {
33
- try {
34
- result = !!(value + "");
35
- } catch (e) {
36
- }
37
- }
38
- return result;
39
- }
40
- var arrayProto = Array.prototype;
41
- var funcProto = Function.prototype;
42
- var objectProto = Object.prototype;
43
- var coreJsData = root["__core-js_shared__"];
44
- var maskSrcKey = function() {
45
- var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
46
- return uid ? "Symbol(src)_1." + uid : "";
47
- }();
48
- var funcToString = funcProto.toString;
49
- var hasOwnProperty = objectProto.hasOwnProperty;
50
- var objectToString = objectProto.toString;
51
- var reIsNative = RegExp(
52
- "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
53
- );
54
- var Symbol2 = root.Symbol;
55
- var splice = arrayProto.splice;
56
- var Map = getNative(root, "Map");
57
- var nativeCreate = getNative(Object, "create");
58
- var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
59
- var symbolToString = symbolProto ? symbolProto.toString : void 0;
60
- function Hash(entries) {
61
- var index = -1, length = entries ? entries.length : 0;
62
- this.clear();
63
- while (++index < length) {
64
- var entry = entries[index];
65
- this.set(entry[0], entry[1]);
66
- }
67
- }
68
- function hashClear() {
69
- this.__data__ = nativeCreate ? nativeCreate(null) : {};
70
- }
71
- function hashDelete(key) {
72
- return this.has(key) && delete this.__data__[key];
73
- }
74
- function hashGet(key) {
75
- var data = this.__data__;
76
- if (nativeCreate) {
77
- var result = data[key];
78
- return result === HASH_UNDEFINED ? void 0 : result;
79
- }
80
- return hasOwnProperty.call(data, key) ? data[key] : void 0;
81
- }
82
- function hashHas(key) {
83
- var data = this.__data__;
84
- return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
85
- }
86
- function hashSet(key, value) {
87
- var data = this.__data__;
88
- data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
89
- return this;
90
- }
91
- Hash.prototype.clear = hashClear;
92
- Hash.prototype["delete"] = hashDelete;
93
- Hash.prototype.get = hashGet;
94
- Hash.prototype.has = hashHas;
95
- Hash.prototype.set = hashSet;
96
- function ListCache(entries) {
97
- var index = -1, length = entries ? entries.length : 0;
98
- this.clear();
99
- while (++index < length) {
100
- var entry = entries[index];
101
- this.set(entry[0], entry[1]);
102
- }
103
- }
104
- function listCacheClear() {
105
- this.__data__ = [];
106
- }
107
- function listCacheDelete(key) {
108
- var data = this.__data__, index = assocIndexOf(data, key);
109
- if (index < 0) {
110
- return false;
111
- }
112
- var lastIndex = data.length - 1;
113
- if (index == lastIndex) {
114
- data.pop();
115
- } else {
116
- splice.call(data, index, 1);
117
- }
118
- return true;
119
- }
120
- function listCacheGet(key) {
121
- var data = this.__data__, index = assocIndexOf(data, key);
122
- return index < 0 ? void 0 : data[index][1];
123
- }
124
- function listCacheHas(key) {
125
- return assocIndexOf(this.__data__, key) > -1;
126
- }
127
- function listCacheSet(key, value) {
128
- var data = this.__data__, index = assocIndexOf(data, key);
129
- if (index < 0) {
130
- data.push([key, value]);
131
- } else {
132
- data[index][1] = value;
133
- }
134
- return this;
135
- }
136
- ListCache.prototype.clear = listCacheClear;
137
- ListCache.prototype["delete"] = listCacheDelete;
138
- ListCache.prototype.get = listCacheGet;
139
- ListCache.prototype.has = listCacheHas;
140
- ListCache.prototype.set = listCacheSet;
141
- function MapCache(entries) {
142
- var index = -1, length = entries ? entries.length : 0;
143
- this.clear();
144
- while (++index < length) {
145
- var entry = entries[index];
146
- this.set(entry[0], entry[1]);
147
- }
148
- }
149
- function mapCacheClear() {
150
- this.__data__ = {
151
- "hash": new Hash(),
152
- "map": new (Map || ListCache)(),
153
- "string": new Hash()
154
- };
155
- }
156
- function mapCacheDelete(key) {
157
- return getMapData(this, key)["delete"](key);
158
- }
159
- function mapCacheGet(key) {
160
- return getMapData(this, key).get(key);
161
- }
162
- function mapCacheHas(key) {
163
- return getMapData(this, key).has(key);
164
- }
165
- function mapCacheSet(key, value) {
166
- getMapData(this, key).set(key, value);
167
- return this;
168
- }
169
- MapCache.prototype.clear = mapCacheClear;
170
- MapCache.prototype["delete"] = mapCacheDelete;
171
- MapCache.prototype.get = mapCacheGet;
172
- MapCache.prototype.has = mapCacheHas;
173
- MapCache.prototype.set = mapCacheSet;
174
- function assocIndexOf(array, key) {
175
- var length = array.length;
176
- while (length--) {
177
- if (eq(array[length][0], key)) {
178
- return length;
179
- }
180
- }
181
- return -1;
182
- }
183
- function baseGet(object, path) {
184
- path = isKey(path, object) ? [path] : castPath(path);
185
- var index = 0, length = path.length;
186
- while (object != null && index < length) {
187
- object = object[toKey(path[index++])];
188
- }
189
- return index && index == length ? object : void 0;
190
- }
191
- function baseIsNative(value) {
192
- if (!isObject(value) || isMasked(value)) {
193
- return false;
194
- }
195
- var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
196
- return pattern.test(toSource(value));
197
- }
198
- function baseToString(value) {
199
- if (typeof value == "string") {
200
- return value;
201
- }
202
- if (isSymbol(value)) {
203
- return symbolToString ? symbolToString.call(value) : "";
204
- }
205
- var result = value + "";
206
- return result == "0" && 1 / value == -INFINITY ? "-0" : result;
207
- }
208
- function castPath(value) {
209
- return isArray(value) ? value : stringToPath(value);
210
- }
211
- function getMapData(map, key) {
212
- var data = map.__data__;
213
- return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
214
- }
215
- function getNative(object, key) {
216
- var value = getValue(object, key);
217
- return baseIsNative(value) ? value : void 0;
218
- }
219
- function isKey(value, object) {
220
- if (isArray(value)) {
221
- return false;
222
- }
223
- var type = typeof value;
224
- if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
225
- return true;
226
- }
227
- return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
228
- }
229
- function isKeyable(value) {
230
- var type = typeof value;
231
- return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
232
- }
233
- function isMasked(func) {
234
- return !!maskSrcKey && maskSrcKey in func;
235
- }
236
- var stringToPath = memoize(function(string) {
237
- string = toString(string);
238
- var result = [];
239
- if (reLeadingDot.test(string)) {
240
- result.push("");
241
- }
242
- string.replace(rePropName, function(match, number, quote, string2) {
243
- result.push(quote ? string2.replace(reEscapeChar, "$1") : number || match);
244
- });
245
- return result;
246
- });
247
- function toKey(value) {
248
- if (typeof value == "string" || isSymbol(value)) {
249
- return value;
250
- }
251
- var result = value + "";
252
- return result == "0" && 1 / value == -INFINITY ? "-0" : result;
253
- }
254
- function toSource(func) {
255
- if (func != null) {
256
- try {
257
- return funcToString.call(func);
258
- } catch (e) {
259
- }
260
- try {
261
- return func + "";
262
- } catch (e) {
263
- }
264
- }
265
- return "";
266
- }
267
- function memoize(func, resolver) {
268
- if (typeof func != "function" || resolver && typeof resolver != "function") {
269
- throw new TypeError(FUNC_ERROR_TEXT);
270
- }
271
- var memoized = function() {
272
- var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
273
- if (cache.has(key)) {
274
- return cache.get(key);
275
- }
276
- var result = func.apply(this, args);
277
- memoized.cache = cache.set(key, result);
278
- return result;
279
- };
280
- memoized.cache = new (memoize.Cache || MapCache)();
281
- return memoized;
282
- }
283
- memoize.Cache = MapCache;
284
- function eq(value, other) {
285
- return value === other || value !== value && other !== other;
286
- }
287
- var isArray = Array.isArray;
288
- function isFunction(value) {
289
- var tag = isObject(value) ? objectToString.call(value) : "";
290
- return tag == funcTag || tag == genTag;
291
- }
292
- function isObject(value) {
293
- var type = typeof value;
294
- return !!value && (type == "object" || type == "function");
295
- }
296
- function isObjectLike(value) {
297
- return !!value && typeof value == "object";
298
- }
299
- function isSymbol(value) {
300
- return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
301
- }
302
- function toString(value) {
303
- return value == null ? "" : baseToString(value);
304
- }
305
- function get(object, path, defaultValue) {
306
- var result = object == null ? void 0 : baseGet(object, path);
307
- return result === void 0 ? defaultValue : result;
308
- }
309
- module.exports = get;
310
- }
311
- });
312
-
313
8
  // lib/index.js
314
9
  var require_lib = __commonJS({
315
10
  "lib/index.js"(exports, module) {
316
- var $6FCft$lodashget = require_lodash();
317
11
  function $parcel$defineInteropFlag(a) {
318
12
  Object.defineProperty(a, "__esModule", { value: true, configurable: true });
319
13
  }
320
14
  function $parcel$export(e, n, v, s) {
321
15
  Object.defineProperty(e, n, { get: v, set: s, enumerable: true, configurable: true });
322
16
  }
323
- function $parcel$interopDefault(a) {
324
- return a && a.__esModule ? a.default : a;
325
- }
326
17
  $parcel$defineInteropFlag(module.exports);
327
18
  $parcel$export(module.exports, "default", () => $892913528e7f60f9$export$2e2bcd8739ae039);
328
19
  $parcel$export(module.exports, "Chord", () => $177a605b8569b31c$export$2e2bcd8739ae039);
@@ -13087,11 +12778,11 @@ ${error.stack}`);
13087
12778
  grade,
13088
12779
  minor
13089
12780
  });
13090
- if (!key) throw new Error(`Could not resolve
13091
- type=${type}
13092
- modifier=${modifier}
13093
- grade=${grade}
13094
- preferredModifier=${preferredModifier}
12781
+ if (!key) throw new Error(`Could not resolve
12782
+ type=${type}
12783
+ modifier=${modifier}
12784
+ grade=${grade}
12785
+ preferredModifier=${preferredModifier}
13095
12786
  minor=${minor}
13096
12787
  to a key`);
13097
12788
  if (minor && type === (0, $dce48cb70c4120bb$export$1321df9b16c30c6a)) key = key.toLowerCase();
@@ -14005,46 +13696,74 @@ to a key`);
14005
13696
  text: text()
14006
13697
  };
14007
13698
  };
14008
- const peg$c3 = /^[A-Za-z0-9\/-\u266D()+]/;
14009
- const peg$c4 = peg$classExpectation([
13699
+ const peg$c3 = "/";
13700
+ const peg$c4 = peg$literalExpectation("/", false);
13701
+ const peg$c5 = /^[A-Ga-g]/;
13702
+ const peg$c6 = peg$classExpectation([
14010
13703
  [
14011
13704
  "A",
14012
- "Z"
13705
+ "G"
14013
13706
  ],
13707
+ [
13708
+ "a",
13709
+ "g"
13710
+ ]
13711
+ ], false, false);
13712
+ const peg$c7 = /^[b#\u266D\u266F]/;
13713
+ const peg$c8 = peg$classExpectation([
13714
+ "b",
13715
+ "#",
13716
+ "\u266D",
13717
+ "\u266F"
13718
+ ], false, false);
13719
+ const peg$c9 = "es";
13720
+ const peg$c10 = peg$literalExpectation("es", false);
13721
+ const peg$c11 = "s";
13722
+ const peg$c12 = peg$literalExpectation("s", false);
13723
+ const peg$c13 = "is";
13724
+ const peg$c14 = peg$literalExpectation("is", false);
13725
+ const peg$c15 = /^[a-zA-Z0-9#\u266Fb\u266D()+\-\/\xF8\u0394\u2212]/;
13726
+ const peg$c16 = peg$classExpectation([
14014
13727
  [
14015
13728
  "a",
14016
13729
  "z"
14017
13730
  ],
14018
13731
  [
14019
- "0",
14020
- "9"
13732
+ "A",
13733
+ "Z"
14021
13734
  ],
14022
13735
  [
14023
- "/",
14024
- "\u266D"
13736
+ "0",
13737
+ "9"
14025
13738
  ],
13739
+ "#",
13740
+ "\u266F",
13741
+ "b",
13742
+ "\u266D",
14026
13743
  "(",
14027
13744
  ")",
14028
- "+"
13745
+ "+",
13746
+ "-",
13747
+ "/",
13748
+ "\xF8",
13749
+ "\u0394",
13750
+ "\u2212"
14029
13751
  ], false, false);
14030
- const peg$c5 = function(name) {
14031
- return name;
14032
- };
14033
- const peg$c6 = "base-fret";
14034
- const peg$c7 = peg$literalExpectation("base-fret", false);
14035
- const peg$c8 = function(baseFret) {
13752
+ const peg$c17 = "base-fret";
13753
+ const peg$c18 = peg$literalExpectation("base-fret", false);
13754
+ const peg$c19 = function(baseFret) {
14036
13755
  return baseFret;
14037
13756
  };
14038
- const peg$c9 = "fingers";
14039
- const peg$c10 = peg$literalExpectation("fingers", false);
14040
- const peg$c11 = function(fingers) {
13757
+ const peg$c20 = "fingers";
13758
+ const peg$c21 = peg$literalExpectation("fingers", false);
13759
+ const peg$c22 = function(fingers) {
14041
13760
  return fingers;
14042
13761
  };
14043
- const peg$c12 = function(finger) {
13762
+ const peg$c23 = function(finger) {
14044
13763
  return finger;
14045
13764
  };
14046
- const peg$c13 = /^[\-A-Za-z]/;
14047
- const peg$c14 = peg$classExpectation([
13765
+ const peg$c24 = /^[\-A-Za-z]/;
13766
+ const peg$c25 = peg$classExpectation([
14048
13767
  "-",
14049
13768
  [
14050
13769
  "A",
@@ -14055,18 +13774,18 @@ to a key`);
14055
13774
  "z"
14056
13775
  ]
14057
13776
  ], false, false);
14058
- const peg$c15 = /^[0-9]/;
14059
- const peg$c16 = peg$classExpectation([
13777
+ const peg$c26 = /^[0-9]/;
13778
+ const peg$c27 = peg$classExpectation([
14060
13779
  [
14061
13780
  "0",
14062
13781
  "9"
14063
13782
  ]
14064
13783
  ], false, false);
14065
- const peg$c17 = function(number) {
13784
+ const peg$c28 = function(number) {
14066
13785
  return parseInt(number, 10);
14067
13786
  };
14068
- const peg$c18 = /^[a-zA-Z]/;
14069
- const peg$c19 = peg$classExpectation([
13787
+ const peg$c29 = /^[a-zA-Z]/;
13788
+ const peg$c30 = peg$classExpectation([
14070
13789
  [
14071
13790
  "a",
14072
13791
  "z"
@@ -14076,64 +13795,64 @@ to a key`);
14076
13795
  "Z"
14077
13796
  ]
14078
13797
  ], false, false);
14079
- const peg$c20 = /^[\-NXnx]/;
14080
- const peg$c21 = peg$classExpectation([
13798
+ const peg$c31 = /^[\-NXnx]/;
13799
+ const peg$c32 = peg$classExpectation([
14081
13800
  "-",
14082
13801
  "N",
14083
13802
  "X",
14084
13803
  "n",
14085
13804
  "x"
14086
13805
  ], false, false);
14087
- const peg$c22 = function(fret) {
13806
+ const peg$c33 = function(fret) {
14088
13807
  return fret;
14089
13808
  };
14090
- const peg$c23 = /^[1-9]/;
14091
- const peg$c24 = peg$classExpectation([
13809
+ const peg$c34 = /^[1-9]/;
13810
+ const peg$c35 = peg$classExpectation([
14092
13811
  [
14093
13812
  "1",
14094
13813
  "9"
14095
13814
  ]
14096
13815
  ], false, false);
14097
- const peg$c25 = "0";
14098
- const peg$c26 = peg$literalExpectation("0", false);
14099
- const peg$c27 = function() {
13816
+ const peg$c36 = "0";
13817
+ const peg$c37 = peg$literalExpectation("0", false);
13818
+ const peg$c38 = function() {
14100
13819
  return 0;
14101
13820
  };
14102
- const peg$c28 = "-1";
14103
- const peg$c29 = peg$literalExpectation("-1", false);
14104
- const peg$c30 = /^[NXnx]/;
14105
- const peg$c31 = peg$classExpectation([
13821
+ const peg$c39 = "-1";
13822
+ const peg$c40 = peg$literalExpectation("-1", false);
13823
+ const peg$c41 = /^[NXnx]/;
13824
+ const peg$c42 = peg$classExpectation([
14106
13825
  "N",
14107
13826
  "X",
14108
13827
  "n",
14109
13828
  "x"
14110
13829
  ], false, false);
14111
- const peg$c32 = peg$otherExpectation("whitespace");
14112
- const peg$c33 = peg$otherExpectation("optional whitespace");
14113
- const peg$c34 = /^[ \t\n\r]/;
14114
- const peg$c35 = peg$classExpectation([
13830
+ const peg$c43 = peg$otherExpectation("whitespace");
13831
+ const peg$c44 = peg$otherExpectation("optional whitespace");
13832
+ const peg$c45 = /^[ \t\n\r]/;
13833
+ const peg$c46 = peg$classExpectation([
14115
13834
  " ",
14116
13835
  " ",
14117
13836
  "\n",
14118
13837
  "\r"
14119
13838
  ], false, false);
14120
- const peg$c36 = peg$otherExpectation("space");
14121
- const peg$c37 = /^[ \t]/;
14122
- const peg$c38 = peg$classExpectation([
13839
+ const peg$c47 = peg$otherExpectation("space");
13840
+ const peg$c48 = /^[ \t]/;
13841
+ const peg$c49 = peg$classExpectation([
14123
13842
  " ",
14124
13843
  " "
14125
13844
  ], false, false);
14126
- const peg$c39 = /^[\n\r]/;
14127
- const peg$c40 = peg$classExpectation([
13845
+ const peg$c50 = /^[\n\r]/;
13846
+ const peg$c51 = peg$classExpectation([
14128
13847
  "\n",
14129
13848
  "\r"
14130
13849
  ], false, false);
14131
- const peg$c41 = "\n";
14132
- const peg$c42 = peg$literalExpectation("\n", false);
14133
- const peg$c43 = "\r";
14134
- const peg$c44 = peg$literalExpectation("\r", false);
14135
- const peg$c45 = "\\";
14136
- const peg$c46 = peg$literalExpectation("\\", false);
13850
+ const peg$c52 = "\n";
13851
+ const peg$c53 = peg$literalExpectation("\n", false);
13852
+ const peg$c54 = "\r";
13853
+ const peg$c55 = peg$literalExpectation("\r", false);
13854
+ const peg$c56 = "\\";
13855
+ const peg$c57 = peg$literalExpectation("\\", false);
14137
13856
  let peg$currPos = 0;
14138
13857
  let peg$savedPos = 0;
14139
13858
  const peg$posDetailsCache = [
@@ -14313,43 +14032,185 @@ to a key`);
14313
14032
  let s0, s1, s2, s3;
14314
14033
  s0 = peg$currPos;
14315
14034
  s1 = peg$currPos;
14316
- s2 = [];
14317
- if (peg$c3.test(input.charAt(peg$currPos))) {
14318
- s3 = input.charAt(peg$currPos);
14035
+ s2 = peg$parseChordDefinitionNameBase();
14036
+ if (s2 !== peg$FAILED) {
14037
+ s3 = peg$parseChordDefinitionNameBass();
14038
+ if (s3 === peg$FAILED) s3 = null;
14039
+ if (s3 !== peg$FAILED) {
14040
+ s2 = [
14041
+ s2,
14042
+ s3
14043
+ ];
14044
+ s1 = s2;
14045
+ } else {
14046
+ peg$currPos = s1;
14047
+ s1 = peg$FAILED;
14048
+ }
14049
+ } else {
14050
+ peg$currPos = s1;
14051
+ s1 = peg$FAILED;
14052
+ }
14053
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
14054
+ else s0 = s1;
14055
+ return s0;
14056
+ }
14057
+ function peg$parseChordDefinitionNameBase() {
14058
+ let s0, s1, s2, s3;
14059
+ s0 = peg$currPos;
14060
+ s1 = peg$currPos;
14061
+ s2 = peg$parseChordDefinitionNote();
14062
+ if (s2 !== peg$FAILED) {
14063
+ s3 = peg$parseChordDefinitionSuffix();
14064
+ if (s3 === peg$FAILED) s3 = null;
14065
+ if (s3 !== peg$FAILED) {
14066
+ s2 = [
14067
+ s2,
14068
+ s3
14069
+ ];
14070
+ s1 = s2;
14071
+ } else {
14072
+ peg$currPos = s1;
14073
+ s1 = peg$FAILED;
14074
+ }
14075
+ } else {
14076
+ peg$currPos = s1;
14077
+ s1 = peg$FAILED;
14078
+ }
14079
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
14080
+ else s0 = s1;
14081
+ return s0;
14082
+ }
14083
+ function peg$parseChordDefinitionNameBass() {
14084
+ let s0, s1, s2, s3;
14085
+ s0 = peg$currPos;
14086
+ s1 = peg$currPos;
14087
+ if (input.charCodeAt(peg$currPos) === 47) {
14088
+ s2 = peg$c3;
14319
14089
  peg$currPos++;
14320
14090
  } else {
14321
- s3 = peg$FAILED;
14091
+ s2 = peg$FAILED;
14322
14092
  if (peg$silentFails === 0) peg$fail(peg$c4);
14323
14093
  }
14324
- if (s3 !== peg$FAILED) while (s3 !== peg$FAILED) {
14325
- s2.push(s3);
14326
- if (peg$c3.test(input.charAt(peg$currPos))) {
14094
+ if (s2 !== peg$FAILED) {
14095
+ s3 = peg$parseChordDefinitionNote();
14096
+ if (s3 !== peg$FAILED) {
14097
+ s2 = [
14098
+ s2,
14099
+ s3
14100
+ ];
14101
+ s1 = s2;
14102
+ } else {
14103
+ peg$currPos = s1;
14104
+ s1 = peg$FAILED;
14105
+ }
14106
+ } else {
14107
+ peg$currPos = s1;
14108
+ s1 = peg$FAILED;
14109
+ }
14110
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
14111
+ else s0 = s1;
14112
+ return s0;
14113
+ }
14114
+ function peg$parseChordDefinitionNote() {
14115
+ let s0, s1, s2, s3;
14116
+ s0 = peg$currPos;
14117
+ s1 = peg$currPos;
14118
+ if (peg$c5.test(input.charAt(peg$currPos))) {
14119
+ s2 = input.charAt(peg$currPos);
14120
+ peg$currPos++;
14121
+ } else {
14122
+ s2 = peg$FAILED;
14123
+ if (peg$silentFails === 0) peg$fail(peg$c6);
14124
+ }
14125
+ if (s2 !== peg$FAILED) {
14126
+ if (peg$c7.test(input.charAt(peg$currPos))) {
14327
14127
  s3 = input.charAt(peg$currPos);
14328
14128
  peg$currPos++;
14329
14129
  } else {
14330
14130
  s3 = peg$FAILED;
14331
- if (peg$silentFails === 0) peg$fail(peg$c4);
14131
+ if (peg$silentFails === 0) peg$fail(peg$c8);
14132
+ }
14133
+ if (s3 === peg$FAILED) {
14134
+ if (input.substr(peg$currPos, 2) === peg$c9) {
14135
+ s3 = peg$c9;
14136
+ peg$currPos += 2;
14137
+ } else {
14138
+ s3 = peg$FAILED;
14139
+ if (peg$silentFails === 0) peg$fail(peg$c10);
14140
+ }
14141
+ if (s3 === peg$FAILED) {
14142
+ if (input.charCodeAt(peg$currPos) === 115) {
14143
+ s3 = peg$c11;
14144
+ peg$currPos++;
14145
+ } else {
14146
+ s3 = peg$FAILED;
14147
+ if (peg$silentFails === 0) peg$fail(peg$c12);
14148
+ }
14149
+ if (s3 === peg$FAILED) {
14150
+ if (input.substr(peg$currPos, 2) === peg$c13) {
14151
+ s3 = peg$c13;
14152
+ peg$currPos += 2;
14153
+ } else {
14154
+ s3 = peg$FAILED;
14155
+ if (peg$silentFails === 0) peg$fail(peg$c14);
14156
+ }
14157
+ }
14158
+ }
14159
+ }
14160
+ if (s3 === peg$FAILED) s3 = null;
14161
+ if (s3 !== peg$FAILED) {
14162
+ s2 = [
14163
+ s2,
14164
+ s3
14165
+ ];
14166
+ s1 = s2;
14167
+ } else {
14168
+ peg$currPos = s1;
14169
+ s1 = peg$FAILED;
14332
14170
  }
14171
+ } else {
14172
+ peg$currPos = s1;
14173
+ s1 = peg$FAILED;
14333
14174
  }
14334
- else s2 = peg$FAILED;
14335
- if (s2 !== peg$FAILED) s1 = input.substring(s1, peg$currPos);
14336
- else s1 = s2;
14337
- if (s1 !== peg$FAILED) {
14338
- peg$savedPos = s0;
14339
- s1 = peg$c5(s1);
14175
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
14176
+ else s0 = s1;
14177
+ return s0;
14178
+ }
14179
+ function peg$parseChordDefinitionSuffix() {
14180
+ let s0, s1, s2;
14181
+ s0 = peg$currPos;
14182
+ s1 = [];
14183
+ if (peg$c15.test(input.charAt(peg$currPos))) {
14184
+ s2 = input.charAt(peg$currPos);
14185
+ peg$currPos++;
14186
+ } else {
14187
+ s2 = peg$FAILED;
14188
+ if (peg$silentFails === 0) peg$fail(peg$c16);
14340
14189
  }
14341
- s0 = s1;
14190
+ if (s2 !== peg$FAILED) while (s2 !== peg$FAILED) {
14191
+ s1.push(s2);
14192
+ if (peg$c15.test(input.charAt(peg$currPos))) {
14193
+ s2 = input.charAt(peg$currPos);
14194
+ peg$currPos++;
14195
+ } else {
14196
+ s2 = peg$FAILED;
14197
+ if (peg$silentFails === 0) peg$fail(peg$c16);
14198
+ }
14199
+ }
14200
+ else s1 = peg$FAILED;
14201
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
14202
+ else s0 = s1;
14342
14203
  return s0;
14343
14204
  }
14344
14205
  function peg$parseBaseFret() {
14345
14206
  let s0, s1, s2, s3, s4;
14346
14207
  s0 = peg$currPos;
14347
- if (input.substr(peg$currPos, 9) === peg$c6) {
14348
- s1 = peg$c6;
14208
+ if (input.substr(peg$currPos, 9) === peg$c17) {
14209
+ s1 = peg$c17;
14349
14210
  peg$currPos += 9;
14350
14211
  } else {
14351
14212
  s1 = peg$FAILED;
14352
- if (peg$silentFails === 0) peg$fail(peg$c7);
14213
+ if (peg$silentFails === 0) peg$fail(peg$c18);
14353
14214
  }
14354
14215
  if (s1 !== peg$FAILED) {
14355
14216
  s2 = peg$parse__();
@@ -14359,7 +14220,7 @@ to a key`);
14359
14220
  s4 = peg$parse__();
14360
14221
  if (s4 !== peg$FAILED) {
14361
14222
  peg$savedPos = s0;
14362
- s1 = peg$c8(s3);
14223
+ s1 = peg$c19(s3);
14363
14224
  s0 = s1;
14364
14225
  } else {
14365
14226
  peg$currPos = s0;
@@ -14384,12 +14245,12 @@ to a key`);
14384
14245
  s0 = peg$currPos;
14385
14246
  s1 = peg$parse__();
14386
14247
  if (s1 !== peg$FAILED) {
14387
- if (input.substr(peg$currPos, 7) === peg$c9) {
14388
- s2 = peg$c9;
14248
+ if (input.substr(peg$currPos, 7) === peg$c20) {
14249
+ s2 = peg$c20;
14389
14250
  peg$currPos += 7;
14390
14251
  } else {
14391
14252
  s2 = peg$FAILED;
14392
- if (peg$silentFails === 0) peg$fail(peg$c10);
14253
+ if (peg$silentFails === 0) peg$fail(peg$c21);
14393
14254
  }
14394
14255
  if (s2 !== peg$FAILED) {
14395
14256
  s3 = [];
@@ -14401,7 +14262,7 @@ to a key`);
14401
14262
  else s3 = peg$FAILED;
14402
14263
  if (s3 !== peg$FAILED) {
14403
14264
  peg$savedPos = s0;
14404
- s1 = peg$c11(s3);
14265
+ s1 = peg$c22(s3);
14405
14266
  s0 = s1;
14406
14267
  } else {
14407
14268
  peg$currPos = s0;
@@ -14425,7 +14286,7 @@ to a key`);
14425
14286
  s2 = peg$parseFinger();
14426
14287
  if (s2 !== peg$FAILED) {
14427
14288
  peg$savedPos = s0;
14428
- s1 = peg$c12(s2);
14289
+ s1 = peg$c23(s2);
14429
14290
  s0 = s1;
14430
14291
  } else {
14431
14292
  peg$currPos = s0;
@@ -14441,12 +14302,12 @@ to a key`);
14441
14302
  let s0;
14442
14303
  s0 = peg$parseFingerNumber();
14443
14304
  if (s0 === peg$FAILED) {
14444
- if (peg$c13.test(input.charAt(peg$currPos))) {
14305
+ if (peg$c24.test(input.charAt(peg$currPos))) {
14445
14306
  s0 = input.charAt(peg$currPos);
14446
14307
  peg$currPos++;
14447
14308
  } else {
14448
14309
  s0 = peg$FAILED;
14449
- if (peg$silentFails === 0) peg$fail(peg$c14);
14310
+ if (peg$silentFails === 0) peg$fail(peg$c25);
14450
14311
  }
14451
14312
  }
14452
14313
  return s0;
@@ -14454,39 +14315,39 @@ to a key`);
14454
14315
  function peg$parseFingerNumber() {
14455
14316
  let s0, s1;
14456
14317
  s0 = peg$currPos;
14457
- if (peg$c15.test(input.charAt(peg$currPos))) {
14318
+ if (peg$c26.test(input.charAt(peg$currPos))) {
14458
14319
  s1 = input.charAt(peg$currPos);
14459
14320
  peg$currPos++;
14460
14321
  } else {
14461
14322
  s1 = peg$FAILED;
14462
- if (peg$silentFails === 0) peg$fail(peg$c16);
14323
+ if (peg$silentFails === 0) peg$fail(peg$c27);
14463
14324
  }
14464
14325
  if (s1 !== peg$FAILED) {
14465
14326
  peg$savedPos = s0;
14466
- s1 = peg$c17(s1);
14327
+ s1 = peg$c28(s1);
14467
14328
  }
14468
14329
  s0 = s1;
14469
14330
  return s0;
14470
14331
  }
14471
14332
  function peg$parseFingerLetter() {
14472
14333
  let s0;
14473
- if (peg$c18.test(input.charAt(peg$currPos))) {
14334
+ if (peg$c29.test(input.charAt(peg$currPos))) {
14474
14335
  s0 = input.charAt(peg$currPos);
14475
14336
  peg$currPos++;
14476
14337
  } else {
14477
14338
  s0 = peg$FAILED;
14478
- if (peg$silentFails === 0) peg$fail(peg$c19);
14339
+ if (peg$silentFails === 0) peg$fail(peg$c30);
14479
14340
  }
14480
14341
  return s0;
14481
14342
  }
14482
14343
  function peg$parseNoFingerSetting() {
14483
14344
  let s0;
14484
- if (peg$c20.test(input.charAt(peg$currPos))) {
14345
+ if (peg$c31.test(input.charAt(peg$currPos))) {
14485
14346
  s0 = input.charAt(peg$currPos);
14486
14347
  peg$currPos++;
14487
14348
  } else {
14488
14349
  s0 = peg$FAILED;
14489
- if (peg$silentFails === 0) peg$fail(peg$c21);
14350
+ if (peg$silentFails === 0) peg$fail(peg$c32);
14490
14351
  }
14491
14352
  return s0;
14492
14353
  }
@@ -14498,7 +14359,7 @@ to a key`);
14498
14359
  s2 = peg$parseFret();
14499
14360
  if (s2 !== peg$FAILED) {
14500
14361
  peg$savedPos = s0;
14501
- s1 = peg$c22(s2);
14362
+ s1 = peg$c33(s2);
14502
14363
  s0 = s1;
14503
14364
  } else {
14504
14365
  peg$currPos = s0;
@@ -14522,7 +14383,7 @@ to a key`);
14522
14383
  }
14523
14384
  if (s2 !== peg$FAILED) {
14524
14385
  peg$savedPos = s0;
14525
- s1 = peg$c22(s2);
14386
+ s1 = peg$c33(s2);
14526
14387
  s0 = s1;
14527
14388
  } else {
14528
14389
  peg$currPos = s0;
@@ -14537,16 +14398,16 @@ to a key`);
14537
14398
  function peg$parseFretNumber() {
14538
14399
  let s0, s1;
14539
14400
  s0 = peg$currPos;
14540
- if (peg$c23.test(input.charAt(peg$currPos))) {
14401
+ if (peg$c34.test(input.charAt(peg$currPos))) {
14541
14402
  s1 = input.charAt(peg$currPos);
14542
14403
  peg$currPos++;
14543
14404
  } else {
14544
14405
  s1 = peg$FAILED;
14545
- if (peg$silentFails === 0) peg$fail(peg$c24);
14406
+ if (peg$silentFails === 0) peg$fail(peg$c35);
14546
14407
  }
14547
14408
  if (s1 !== peg$FAILED) {
14548
14409
  peg$savedPos = s0;
14549
- s1 = peg$c17(s1);
14410
+ s1 = peg$c28(s1);
14550
14411
  }
14551
14412
  s0 = s1;
14552
14413
  return s0;
@@ -14555,35 +14416,35 @@ to a key`);
14555
14416
  let s0, s1;
14556
14417
  s0 = peg$currPos;
14557
14418
  if (input.charCodeAt(peg$currPos) === 48) {
14558
- s1 = peg$c25;
14419
+ s1 = peg$c36;
14559
14420
  peg$currPos++;
14560
14421
  } else {
14561
14422
  s1 = peg$FAILED;
14562
- if (peg$silentFails === 0) peg$fail(peg$c26);
14423
+ if (peg$silentFails === 0) peg$fail(peg$c37);
14563
14424
  }
14564
14425
  if (s1 !== peg$FAILED) {
14565
14426
  peg$savedPos = s0;
14566
- s1 = peg$c27();
14427
+ s1 = peg$c38();
14567
14428
  }
14568
14429
  s0 = s1;
14569
14430
  return s0;
14570
14431
  }
14571
14432
  function peg$parseNonSoundingString() {
14572
14433
  let s0;
14573
- if (input.substr(peg$currPos, 2) === peg$c28) {
14574
- s0 = peg$c28;
14434
+ if (input.substr(peg$currPos, 2) === peg$c39) {
14435
+ s0 = peg$c39;
14575
14436
  peg$currPos += 2;
14576
14437
  } else {
14577
14438
  s0 = peg$FAILED;
14578
- if (peg$silentFails === 0) peg$fail(peg$c29);
14439
+ if (peg$silentFails === 0) peg$fail(peg$c40);
14579
14440
  }
14580
14441
  if (s0 === peg$FAILED) {
14581
- if (peg$c30.test(input.charAt(peg$currPos))) {
14442
+ if (peg$c41.test(input.charAt(peg$currPos))) {
14582
14443
  s0 = input.charAt(peg$currPos);
14583
14444
  peg$currPos++;
14584
14445
  } else {
14585
14446
  s0 = peg$FAILED;
14586
- if (peg$silentFails === 0) peg$fail(peg$c31);
14447
+ if (peg$silentFails === 0) peg$fail(peg$c42);
14587
14448
  }
14588
14449
  }
14589
14450
  return s0;
@@ -14601,7 +14462,7 @@ to a key`);
14601
14462
  peg$silentFails--;
14602
14463
  if (s0 === peg$FAILED) {
14603
14464
  s1 = peg$FAILED;
14604
- if (peg$silentFails === 0) peg$fail(peg$c32);
14465
+ if (peg$silentFails === 0) peg$fail(peg$c43);
14605
14466
  }
14606
14467
  return s0;
14607
14468
  }
@@ -14617,18 +14478,18 @@ to a key`);
14617
14478
  peg$silentFails--;
14618
14479
  if (s0 === peg$FAILED) {
14619
14480
  s1 = peg$FAILED;
14620
- if (peg$silentFails === 0) peg$fail(peg$c33);
14481
+ if (peg$silentFails === 0) peg$fail(peg$c44);
14621
14482
  }
14622
14483
  return s0;
14623
14484
  }
14624
14485
  function peg$parseWhitespaceCharacter() {
14625
14486
  let s0;
14626
- if (peg$c34.test(input.charAt(peg$currPos))) {
14487
+ if (peg$c45.test(input.charAt(peg$currPos))) {
14627
14488
  s0 = input.charAt(peg$currPos);
14628
14489
  peg$currPos++;
14629
14490
  } else {
14630
14491
  s0 = peg$FAILED;
14631
- if (peg$silentFails === 0) peg$fail(peg$c35);
14492
+ if (peg$silentFails === 0) peg$fail(peg$c46);
14632
14493
  }
14633
14494
  return s0;
14634
14495
  }
@@ -14637,21 +14498,21 @@ to a key`);
14637
14498
  peg$silentFails++;
14638
14499
  s0 = peg$currPos;
14639
14500
  s1 = [];
14640
- if (peg$c37.test(input.charAt(peg$currPos))) {
14501
+ if (peg$c48.test(input.charAt(peg$currPos))) {
14641
14502
  s2 = input.charAt(peg$currPos);
14642
14503
  peg$currPos++;
14643
14504
  } else {
14644
14505
  s2 = peg$FAILED;
14645
- if (peg$silentFails === 0) peg$fail(peg$c38);
14506
+ if (peg$silentFails === 0) peg$fail(peg$c49);
14646
14507
  }
14647
14508
  if (s2 !== peg$FAILED) while (s2 !== peg$FAILED) {
14648
14509
  s1.push(s2);
14649
- if (peg$c37.test(input.charAt(peg$currPos))) {
14510
+ if (peg$c48.test(input.charAt(peg$currPos))) {
14650
14511
  s2 = input.charAt(peg$currPos);
14651
14512
  peg$currPos++;
14652
14513
  } else {
14653
14514
  s2 = peg$FAILED;
14654
- if (peg$silentFails === 0) peg$fail(peg$c38);
14515
+ if (peg$silentFails === 0) peg$fail(peg$c49);
14655
14516
  }
14656
14517
  }
14657
14518
  else s1 = peg$FAILED;
@@ -14660,18 +14521,18 @@ to a key`);
14660
14521
  peg$silentFails--;
14661
14522
  if (s0 === peg$FAILED) {
14662
14523
  s1 = peg$FAILED;
14663
- if (peg$silentFails === 0) peg$fail(peg$c36);
14524
+ if (peg$silentFails === 0) peg$fail(peg$c47);
14664
14525
  }
14665
14526
  return s0;
14666
14527
  }
14667
14528
  function peg$parseNewLine() {
14668
14529
  let s0;
14669
- if (peg$c39.test(input.charAt(peg$currPos))) {
14530
+ if (peg$c50.test(input.charAt(peg$currPos))) {
14670
14531
  s0 = input.charAt(peg$currPos);
14671
14532
  peg$currPos++;
14672
14533
  } else {
14673
14534
  s0 = peg$FAILED;
14674
- if (peg$silentFails === 0) peg$fail(peg$c40);
14535
+ if (peg$silentFails === 0) peg$fail(peg$c51);
14675
14536
  }
14676
14537
  if (s0 === peg$FAILED) s0 = peg$parseCarriageReturnLineFeed();
14677
14538
  return s0;
@@ -14701,33 +14562,33 @@ to a key`);
14701
14562
  function peg$parseLineFeed() {
14702
14563
  let s0;
14703
14564
  if (input.charCodeAt(peg$currPos) === 10) {
14704
- s0 = peg$c41;
14565
+ s0 = peg$c52;
14705
14566
  peg$currPos++;
14706
14567
  } else {
14707
14568
  s0 = peg$FAILED;
14708
- if (peg$silentFails === 0) peg$fail(peg$c42);
14569
+ if (peg$silentFails === 0) peg$fail(peg$c53);
14709
14570
  }
14710
14571
  return s0;
14711
14572
  }
14712
14573
  function peg$parseCarriageReturn() {
14713
14574
  let s0;
14714
14575
  if (input.charCodeAt(peg$currPos) === 13) {
14715
- s0 = peg$c43;
14576
+ s0 = peg$c54;
14716
14577
  peg$currPos++;
14717
14578
  } else {
14718
14579
  s0 = peg$FAILED;
14719
- if (peg$silentFails === 0) peg$fail(peg$c44);
14580
+ if (peg$silentFails === 0) peg$fail(peg$c55);
14720
14581
  }
14721
14582
  return s0;
14722
14583
  }
14723
14584
  function peg$parseEscape() {
14724
14585
  let s0;
14725
14586
  if (input.charCodeAt(peg$currPos) === 92) {
14726
- s0 = peg$c45;
14587
+ s0 = peg$c56;
14727
14588
  peg$currPos++;
14728
14589
  } else {
14729
14590
  s0 = peg$FAILED;
14730
- if (peg$silentFails === 0) peg$fail(peg$c46);
14591
+ if (peg$silentFails === 0) peg$fail(peg$c57);
14731
14592
  }
14732
14593
  return s0;
14733
14594
  }
@@ -14792,6 +14653,9 @@ to a key`);
14792
14653
  }
14793
14654
  };
14794
14655
  var $1900e9488433afb1$var$Configuration = class {
14656
+ get metadataSeparator() {
14657
+ return this.metadata.separator ?? "";
14658
+ }
14795
14659
  constructor(configuration = $1900e9488433afb1$export$78c0028a34264234) {
14796
14660
  const mergedConfig = {
14797
14661
  ...$1900e9488433afb1$export$78c0028a34264234,
@@ -14812,9 +14676,6 @@ to a key`);
14812
14676
  delegates: this.delegates
14813
14677
  };
14814
14678
  }
14815
- get(key) {
14816
- return (0, $parcel$interopDefault($6FCft$lodashget))(this, key);
14817
- }
14818
14679
  };
14819
14680
  var $1900e9488433afb1$export$2e2bcd8739ae039 = $1900e9488433afb1$var$Configuration;
14820
14681
  var $ed0d9ddbbe7224cd$var$Formatter = class {
@@ -15002,7 +14863,7 @@ to a key`);
15002
14863
  };
15003
14864
  var $7251dad5f4a4c35f$var$Tag = class _$7251dad5f4a4c35f$var$Tag extends (0, $c5ce4fc4f57fe810$export$2e2bcd8739ae039) {
15004
14865
  constructor(name, value = null, traceInfo = null, attributes = {}) {
15005
- super(traceInfo), this._isMetaTag = false, this._originalName = "", this._name = "", this._value = "", /**
14866
+ super(traceInfo), this._isMetaTag = false, this._originalName = "", this._name = "", this._value = "", this.selector = null, /**
15006
14867
  * The tag attributes. For example, section related tags can have a label:
15007
14868
  * `{start_of_verse: label="Verse 1"}`
15008
14869
  * @type {Record<string, string>}
@@ -15321,7 +15182,7 @@ to a key`);
15321
15182
  throw new Error(`Don't know how to format a ${item}`);
15322
15183
  }
15323
15184
  formatOrEvaluateItem(item, metadata) {
15324
- if (this.configuration.evaluate) return item.evaluate(metadata, this.configuration.get("metadata.separator"));
15185
+ if (this.configuration.evaluate) return item.evaluate(metadata, this.configuration.metadataSeparator);
15325
15186
  if (item instanceof (0, $15f1d40e3d1ed3a0$export$2e2bcd8739ae039)) return this.formatTernary(item);
15326
15187
  if (item instanceof (0, $11953cb6035032a3$export$2e2bcd8739ae039)) return item.evaluate();
15327
15188
  throw new Error(`Don't know how to format a ${item.constructor.name}`);
@@ -15406,13 +15267,14 @@ to a key`);
15406
15267
  ])
15407
15268
  ];
15408
15269
  }
15409
- function $51ced2cf8b50f946$export$4478cda40be33ba2(name, value, location) {
15270
+ function $51ced2cf8b50f946$export$4478cda40be33ba2(name, value, selector, location) {
15410
15271
  return {
15411
15272
  type: "tag",
15412
15273
  name,
15413
15274
  location: location.start,
15414
15275
  value: value?.value || "",
15415
- attributes: value?.attributes || {}
15276
+ attributes: value?.attributes || {},
15277
+ selector
15416
15278
  };
15417
15279
  }
15418
15280
  function $51ced2cf8b50f946$export$4bae24da7c5e47c7(string, search, replaceMatch, replaceRest = (subString) => subString) {
@@ -15788,50 +15650,56 @@ to a key`);
15788
15650
  const peg$c62 = peg$literalExpectation("define", false);
15789
15651
  const peg$c63 = ":";
15790
15652
  const peg$c64 = peg$literalExpectation(":", false);
15791
- const peg$c65 = function(name, value) {
15653
+ const peg$c65 = function(name, selector, value) {
15792
15654
  const { text: text2, ...chordDefinition } = value;
15793
15655
  return {
15794
15656
  type: "tag",
15795
15657
  name,
15796
15658
  value: text2,
15797
15659
  chordDefinition,
15798
- location: location().start
15660
+ location: location().start,
15661
+ selector
15799
15662
  };
15800
15663
  };
15801
- const peg$c66 = function(tagName, tagColonWithValue) {
15802
- return $51ced2cf8b50f946$export$4478cda40be33ba2(tagName, tagColonWithValue, location());
15664
+ const peg$c66 = function(tagName, selector, tagColonWithValue) {
15665
+ return $51ced2cf8b50f946$export$4478cda40be33ba2(tagName, tagColonWithValue, selector, location());
15666
+ };
15667
+ const peg$c67 = "-";
15668
+ const peg$c68 = peg$literalExpectation("-", false);
15669
+ const peg$c69 = function(value) {
15670
+ return value;
15803
15671
  };
15804
- const peg$c67 = function(tagValue) {
15672
+ const peg$c70 = function(tagValue) {
15805
15673
  return tagValue;
15806
15674
  };
15807
- const peg$c68 = function(attributes) {
15675
+ const peg$c71 = function(attributes) {
15808
15676
  return {
15809
15677
  attributes
15810
15678
  };
15811
15679
  };
15812
- const peg$c69 = function(value) {
15680
+ const peg$c72 = function(value) {
15813
15681
  return {
15814
15682
  value
15815
15683
  };
15816
15684
  };
15817
- const peg$c70 = function(attributes) {
15685
+ const peg$c73 = function(attributes) {
15818
15686
  const obj = {};
15819
15687
  attributes.forEach((pair) => {
15820
15688
  obj[pair[0]] = pair[1];
15821
15689
  });
15822
15690
  return obj;
15823
15691
  };
15824
- const peg$c71 = function(attribute) {
15692
+ const peg$c74 = function(attribute) {
15825
15693
  return attribute;
15826
15694
  };
15827
- const peg$c72 = function(name, value) {
15695
+ const peg$c75 = function(name, value) {
15828
15696
  return [
15829
15697
  name,
15830
15698
  value
15831
15699
  ];
15832
15700
  };
15833
- const peg$c73 = /^[a-zA-Z\-_]/;
15834
- const peg$c74 = peg$classExpectation([
15701
+ const peg$c76 = /^[a-zA-Z_]/;
15702
+ const peg$c77 = peg$classExpectation([
15835
15703
  [
15836
15704
  "a",
15837
15705
  "z"
@@ -15840,38 +15708,47 @@ to a key`);
15840
15708
  "A",
15841
15709
  "Z"
15842
15710
  ],
15843
- "-",
15844
15711
  "_"
15845
15712
  ], false, false);
15846
- const peg$c75 = function(chars) {
15713
+ const peg$c78 = function(chars) {
15847
15714
  return chars.map((c) => c.char || c).join("");
15848
15715
  };
15849
- const peg$c76 = /^[^}\\\r\n]/;
15850
- const peg$c77 = peg$classExpectation([
15716
+ const peg$c79 = /^[^}\\\r\n]/;
15717
+ const peg$c80 = peg$classExpectation([
15851
15718
  "}",
15852
15719
  "\\",
15853
15720
  "\r",
15854
15721
  "\n"
15855
15722
  ], true, false);
15856
- const peg$c78 = '"';
15857
- const peg$c79 = peg$literalExpectation('"', false);
15858
- const peg$c80 = function(value) {
15859
- return value;
15860
- };
15861
- const peg$c81 = /^[^"}]/;
15723
+ const peg$c81 = /^[a-zA-Z\-_]/;
15862
15724
  const peg$c82 = peg$classExpectation([
15725
+ [
15726
+ "a",
15727
+ "z"
15728
+ ],
15729
+ [
15730
+ "A",
15731
+ "Z"
15732
+ ],
15733
+ "-",
15734
+ "_"
15735
+ ], false, false);
15736
+ const peg$c83 = '"';
15737
+ const peg$c84 = peg$literalExpectation('"', false);
15738
+ const peg$c85 = /^[^"}]/;
15739
+ const peg$c86 = peg$classExpectation([
15863
15740
  '"',
15864
15741
  "}"
15865
15742
  ], true, false);
15866
- const peg$c83 = function() {
15743
+ const peg$c87 = function() {
15867
15744
  return {
15868
15745
  type: "char",
15869
15746
  char: '"'
15870
15747
  };
15871
15748
  };
15872
- const peg$c84 = "frets";
15873
- const peg$c85 = peg$literalExpectation("frets", false);
15874
- const peg$c86 = function(name, baseFret, frets, fingers) {
15749
+ const peg$c88 = "frets";
15750
+ const peg$c89 = peg$literalExpectation("frets", false);
15751
+ const peg$c90 = function(name, baseFret, frets, fingers) {
15875
15752
  return {
15876
15753
  name,
15877
15754
  baseFret: baseFret || 1,
@@ -15880,46 +15757,74 @@ to a key`);
15880
15757
  text: text()
15881
15758
  };
15882
15759
  };
15883
- const peg$c87 = /^[A-Za-z0-9\/-\u266D()+]/;
15884
- const peg$c88 = peg$classExpectation([
15760
+ const peg$c91 = "/";
15761
+ const peg$c92 = peg$literalExpectation("/", false);
15762
+ const peg$c93 = /^[A-Ga-g]/;
15763
+ const peg$c94 = peg$classExpectation([
15885
15764
  [
15886
15765
  "A",
15887
- "Z"
15766
+ "G"
15888
15767
  ],
15768
+ [
15769
+ "a",
15770
+ "g"
15771
+ ]
15772
+ ], false, false);
15773
+ const peg$c95 = /^[b#\u266D\u266F]/;
15774
+ const peg$c96 = peg$classExpectation([
15775
+ "b",
15776
+ "#",
15777
+ "\u266D",
15778
+ "\u266F"
15779
+ ], false, false);
15780
+ const peg$c97 = "es";
15781
+ const peg$c98 = peg$literalExpectation("es", false);
15782
+ const peg$c99 = "s";
15783
+ const peg$c100 = peg$literalExpectation("s", false);
15784
+ const peg$c101 = "is";
15785
+ const peg$c102 = peg$literalExpectation("is", false);
15786
+ const peg$c103 = /^[a-zA-Z0-9#\u266Fb\u266D()+\-\/\xF8\u0394\u2212]/;
15787
+ const peg$c104 = peg$classExpectation([
15889
15788
  [
15890
15789
  "a",
15891
15790
  "z"
15892
15791
  ],
15893
15792
  [
15894
- "0",
15895
- "9"
15793
+ "A",
15794
+ "Z"
15896
15795
  ],
15897
15796
  [
15898
- "/",
15899
- "\u266D"
15797
+ "0",
15798
+ "9"
15900
15799
  ],
15800
+ "#",
15801
+ "\u266F",
15802
+ "b",
15803
+ "\u266D",
15901
15804
  "(",
15902
15805
  ")",
15903
- "+"
15806
+ "+",
15807
+ "-",
15808
+ "/",
15809
+ "\xF8",
15810
+ "\u0394",
15811
+ "\u2212"
15904
15812
  ], false, false);
15905
- const peg$c89 = function(name) {
15906
- return name;
15907
- };
15908
- const peg$c90 = "base-fret";
15909
- const peg$c91 = peg$literalExpectation("base-fret", false);
15910
- const peg$c92 = function(baseFret) {
15813
+ const peg$c105 = "base-fret";
15814
+ const peg$c106 = peg$literalExpectation("base-fret", false);
15815
+ const peg$c107 = function(baseFret) {
15911
15816
  return baseFret;
15912
15817
  };
15913
- const peg$c93 = "fingers";
15914
- const peg$c94 = peg$literalExpectation("fingers", false);
15915
- const peg$c95 = function(fingers) {
15818
+ const peg$c108 = "fingers";
15819
+ const peg$c109 = peg$literalExpectation("fingers", false);
15820
+ const peg$c110 = function(fingers) {
15916
15821
  return fingers;
15917
15822
  };
15918
- const peg$c96 = function(finger) {
15823
+ const peg$c111 = function(finger) {
15919
15824
  return finger;
15920
15825
  };
15921
- const peg$c97 = /^[\-A-Za-z]/;
15922
- const peg$c98 = peg$classExpectation([
15826
+ const peg$c112 = /^[\-A-Za-z]/;
15827
+ const peg$c113 = peg$classExpectation([
15923
15828
  "-",
15924
15829
  [
15925
15830
  "A",
@@ -15930,18 +15835,18 @@ to a key`);
15930
15835
  "z"
15931
15836
  ]
15932
15837
  ], false, false);
15933
- const peg$c99 = /^[0-9]/;
15934
- const peg$c100 = peg$classExpectation([
15838
+ const peg$c114 = /^[0-9]/;
15839
+ const peg$c115 = peg$classExpectation([
15935
15840
  [
15936
15841
  "0",
15937
15842
  "9"
15938
15843
  ]
15939
15844
  ], false, false);
15940
- const peg$c101 = function(number) {
15845
+ const peg$c116 = function(number) {
15941
15846
  return parseInt(number, 10);
15942
15847
  };
15943
- const peg$c102 = /^[a-zA-Z]/;
15944
- const peg$c103 = peg$classExpectation([
15848
+ const peg$c117 = /^[a-zA-Z]/;
15849
+ const peg$c118 = peg$classExpectation([
15945
15850
  [
15946
15851
  "a",
15947
15852
  "z"
@@ -15951,93 +15856,93 @@ to a key`);
15951
15856
  "Z"
15952
15857
  ]
15953
15858
  ], false, false);
15954
- const peg$c104 = /^[\-NXnx]/;
15955
- const peg$c105 = peg$classExpectation([
15859
+ const peg$c119 = /^[\-NXnx]/;
15860
+ const peg$c120 = peg$classExpectation([
15956
15861
  "-",
15957
15862
  "N",
15958
15863
  "X",
15959
15864
  "n",
15960
15865
  "x"
15961
15866
  ], false, false);
15962
- const peg$c106 = function(fret) {
15867
+ const peg$c121 = function(fret) {
15963
15868
  return fret;
15964
15869
  };
15965
- const peg$c107 = /^[1-9]/;
15966
- const peg$c108 = peg$classExpectation([
15870
+ const peg$c122 = /^[1-9]/;
15871
+ const peg$c123 = peg$classExpectation([
15967
15872
  [
15968
15873
  "1",
15969
15874
  "9"
15970
15875
  ]
15971
15876
  ], false, false);
15972
- const peg$c109 = "0";
15973
- const peg$c110 = peg$literalExpectation("0", false);
15974
- const peg$c111 = function() {
15877
+ const peg$c124 = "0";
15878
+ const peg$c125 = peg$literalExpectation("0", false);
15879
+ const peg$c126 = function() {
15975
15880
  return 0;
15976
15881
  };
15977
- const peg$c112 = "-1";
15978
- const peg$c113 = peg$literalExpectation("-1", false);
15979
- const peg$c114 = /^[NXnx]/;
15980
- const peg$c115 = peg$classExpectation([
15882
+ const peg$c127 = "-1";
15883
+ const peg$c128 = peg$literalExpectation("-1", false);
15884
+ const peg$c129 = /^[NXnx]/;
15885
+ const peg$c130 = peg$classExpectation([
15981
15886
  "N",
15982
15887
  "X",
15983
15888
  "n",
15984
15889
  "x"
15985
15890
  ], false, false);
15986
- const peg$c116 = function(startTag, content, endTag) {
15891
+ const peg$c131 = function(startTag, content, endTag) {
15987
15892
  return $51ced2cf8b50f946$export$665e0f4515a68234(startTag, endTag, content);
15988
15893
  };
15989
- const peg$c117 = "start_of_abc";
15990
- const peg$c118 = peg$literalExpectation("start_of_abc", false);
15991
- const peg$c119 = "end_of_abc";
15992
- const peg$c120 = peg$literalExpectation("end_of_abc", false);
15993
- const peg$c121 = function(tagName) {
15994
- return $51ced2cf8b50f946$export$4478cda40be33ba2(tagName, null, location());
15894
+ const peg$c132 = "start_of_abc";
15895
+ const peg$c133 = peg$literalExpectation("start_of_abc", false);
15896
+ const peg$c134 = "end_of_abc";
15897
+ const peg$c135 = peg$literalExpectation("end_of_abc", false);
15898
+ const peg$c136 = function(tagName) {
15899
+ return $51ced2cf8b50f946$export$4478cda40be33ba2(tagName, null, null, location());
15995
15900
  };
15996
- const peg$c122 = "start_of_grid";
15997
- const peg$c123 = peg$literalExpectation("start_of_grid", false);
15998
- const peg$c124 = "sog";
15999
- const peg$c125 = peg$literalExpectation("sog", false);
16000
- const peg$c126 = "end_of_grid";
16001
- const peg$c127 = peg$literalExpectation("end_of_grid", false);
16002
- const peg$c128 = "eog";
16003
- const peg$c129 = peg$literalExpectation("eog", false);
16004
- const peg$c130 = "start_of_ly";
16005
- const peg$c131 = peg$literalExpectation("start_of_ly", false);
16006
- const peg$c132 = "end_of_ly";
16007
- const peg$c133 = peg$literalExpectation("end_of_ly", false);
16008
- const peg$c134 = "start_of_tab";
16009
- const peg$c135 = peg$literalExpectation("start_of_tab", false);
16010
- const peg$c136 = "sot";
16011
- const peg$c137 = peg$literalExpectation("sot", false);
16012
- const peg$c138 = "end_of_tab";
16013
- const peg$c139 = peg$literalExpectation("end_of_tab", false);
16014
- const peg$c140 = "eot";
16015
- const peg$c141 = peg$literalExpectation("eot", false);
16016
- const peg$c142 = peg$anyExpectation();
16017
- const peg$c143 = peg$otherExpectation("whitespace");
16018
- const peg$c144 = peg$otherExpectation("optional whitespace");
16019
- const peg$c145 = /^[ \t\n\r]/;
16020
- const peg$c146 = peg$classExpectation([
15901
+ const peg$c137 = "start_of_grid";
15902
+ const peg$c138 = peg$literalExpectation("start_of_grid", false);
15903
+ const peg$c139 = "sog";
15904
+ const peg$c140 = peg$literalExpectation("sog", false);
15905
+ const peg$c141 = "end_of_grid";
15906
+ const peg$c142 = peg$literalExpectation("end_of_grid", false);
15907
+ const peg$c143 = "eog";
15908
+ const peg$c144 = peg$literalExpectation("eog", false);
15909
+ const peg$c145 = "start_of_ly";
15910
+ const peg$c146 = peg$literalExpectation("start_of_ly", false);
15911
+ const peg$c147 = "end_of_ly";
15912
+ const peg$c148 = peg$literalExpectation("end_of_ly", false);
15913
+ const peg$c149 = "start_of_tab";
15914
+ const peg$c150 = peg$literalExpectation("start_of_tab", false);
15915
+ const peg$c151 = "sot";
15916
+ const peg$c152 = peg$literalExpectation("sot", false);
15917
+ const peg$c153 = "end_of_tab";
15918
+ const peg$c154 = peg$literalExpectation("end_of_tab", false);
15919
+ const peg$c155 = "eot";
15920
+ const peg$c156 = peg$literalExpectation("eot", false);
15921
+ const peg$c157 = peg$anyExpectation();
15922
+ const peg$c158 = peg$otherExpectation("whitespace");
15923
+ const peg$c159 = peg$otherExpectation("optional whitespace");
15924
+ const peg$c160 = /^[ \t\n\r]/;
15925
+ const peg$c161 = peg$classExpectation([
16021
15926
  " ",
16022
15927
  " ",
16023
15928
  "\n",
16024
15929
  "\r"
16025
15930
  ], false, false);
16026
- const peg$c147 = peg$otherExpectation("space");
16027
- const peg$c148 = /^[ \t]/;
16028
- const peg$c149 = peg$classExpectation([
15931
+ const peg$c162 = peg$otherExpectation("space");
15932
+ const peg$c163 = /^[ \t]/;
15933
+ const peg$c164 = peg$classExpectation([
16029
15934
  " ",
16030
15935
  " "
16031
15936
  ], false, false);
16032
- const peg$c150 = /^[\n\r]/;
16033
- const peg$c151 = peg$classExpectation([
15937
+ const peg$c165 = /^[\n\r]/;
15938
+ const peg$c166 = peg$classExpectation([
16034
15939
  "\n",
16035
15940
  "\r"
16036
15941
  ], false, false);
16037
- const peg$c152 = "\n";
16038
- const peg$c153 = peg$literalExpectation("\n", false);
16039
- const peg$c154 = "\r";
16040
- const peg$c155 = peg$literalExpectation("\r", false);
15942
+ const peg$c167 = "\n";
15943
+ const peg$c168 = peg$literalExpectation("\n", false);
15944
+ const peg$c169 = "\r";
15945
+ const peg$c170 = peg$literalExpectation("\r", false);
16041
15946
  let peg$currPos = 0;
16042
15947
  let peg$savedPos = 0;
16043
15948
  const peg$posDetailsCache = [
@@ -17148,7 +17053,7 @@ to a key`);
17148
17053
  return s0;
17149
17054
  }
17150
17055
  function peg$parseChordDefinition() {
17151
- let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
17056
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
17152
17057
  s0 = peg$currPos;
17153
17058
  if (input.charCodeAt(peg$currPos) === 123) {
17154
17059
  s1 = peg$c44;
@@ -17177,33 +17082,40 @@ to a key`);
17177
17082
  }
17178
17083
  }
17179
17084
  if (s3 !== peg$FAILED) {
17180
- s4 = peg$parse_();
17085
+ s4 = peg$parseTagSelector();
17086
+ if (s4 === peg$FAILED) s4 = null;
17181
17087
  if (s4 !== peg$FAILED) {
17182
- if (input.charCodeAt(peg$currPos) === 58) {
17183
- s5 = peg$c63;
17184
- peg$currPos++;
17185
- } else {
17186
- s5 = peg$FAILED;
17187
- if (peg$silentFails === 0) peg$fail(peg$c64);
17188
- }
17088
+ s5 = peg$parse_();
17189
17089
  if (s5 !== peg$FAILED) {
17190
- s6 = peg$parse_();
17090
+ if (input.charCodeAt(peg$currPos) === 58) {
17091
+ s6 = peg$c63;
17092
+ peg$currPos++;
17093
+ } else {
17094
+ s6 = peg$FAILED;
17095
+ if (peg$silentFails === 0) peg$fail(peg$c64);
17096
+ }
17191
17097
  if (s6 !== peg$FAILED) {
17192
- s7 = peg$parseChordDefinitionValue();
17098
+ s7 = peg$parse_();
17193
17099
  if (s7 !== peg$FAILED) {
17194
- s8 = peg$parse_();
17100
+ s8 = peg$parseChordDefinitionValue();
17195
17101
  if (s8 !== peg$FAILED) {
17196
- if (input.charCodeAt(peg$currPos) === 125) {
17197
- s9 = peg$c30;
17198
- peg$currPos++;
17199
- } else {
17200
- s9 = peg$FAILED;
17201
- if (peg$silentFails === 0) peg$fail(peg$c31);
17202
- }
17102
+ s9 = peg$parse_();
17203
17103
  if (s9 !== peg$FAILED) {
17204
- peg$savedPos = s0;
17205
- s1 = peg$c65(s3, s7);
17206
- s0 = s1;
17104
+ if (input.charCodeAt(peg$currPos) === 125) {
17105
+ s10 = peg$c30;
17106
+ peg$currPos++;
17107
+ } else {
17108
+ s10 = peg$FAILED;
17109
+ if (peg$silentFails === 0) peg$fail(peg$c31);
17110
+ }
17111
+ if (s10 !== peg$FAILED) {
17112
+ peg$savedPos = s0;
17113
+ s1 = peg$c65(s3, s4, s8);
17114
+ s0 = s1;
17115
+ } else {
17116
+ peg$currPos = s0;
17117
+ s0 = peg$FAILED;
17118
+ }
17207
17119
  } else {
17208
17120
  peg$currPos = s0;
17209
17121
  s0 = peg$FAILED;
@@ -17243,7 +17155,7 @@ to a key`);
17243
17155
  return s0;
17244
17156
  }
17245
17157
  function peg$parseTag() {
17246
- let s0, s1, s2, s3, s4, s5, s6;
17158
+ let s0, s1, s2, s3, s4, s5, s6, s7;
17247
17159
  s0 = peg$currPos;
17248
17160
  if (input.charCodeAt(peg$currPos) === 123) {
17249
17161
  s1 = peg$c44;
@@ -17260,22 +17172,29 @@ to a key`);
17260
17172
  if (s4 !== peg$FAILED) s3 = input.substring(s3, peg$currPos);
17261
17173
  else s3 = s4;
17262
17174
  if (s3 !== peg$FAILED) {
17263
- s4 = peg$parse_();
17175
+ s4 = peg$parseTagSelector();
17176
+ if (s4 === peg$FAILED) s4 = null;
17264
17177
  if (s4 !== peg$FAILED) {
17265
- s5 = peg$parseTagColonWithValue();
17266
- if (s5 === peg$FAILED) s5 = null;
17178
+ s5 = peg$parse_();
17267
17179
  if (s5 !== peg$FAILED) {
17268
- if (input.charCodeAt(peg$currPos) === 125) {
17269
- s6 = peg$c30;
17270
- peg$currPos++;
17271
- } else {
17272
- s6 = peg$FAILED;
17273
- if (peg$silentFails === 0) peg$fail(peg$c31);
17274
- }
17180
+ s6 = peg$parseTagColonWithValue();
17181
+ if (s6 === peg$FAILED) s6 = null;
17275
17182
  if (s6 !== peg$FAILED) {
17276
- peg$savedPos = s0;
17277
- s1 = peg$c66(s3, s5);
17278
- s0 = s1;
17183
+ if (input.charCodeAt(peg$currPos) === 125) {
17184
+ s7 = peg$c30;
17185
+ peg$currPos++;
17186
+ } else {
17187
+ s7 = peg$FAILED;
17188
+ if (peg$silentFails === 0) peg$fail(peg$c31);
17189
+ }
17190
+ if (s7 !== peg$FAILED) {
17191
+ peg$savedPos = s0;
17192
+ s1 = peg$c66(s3, s4, s6);
17193
+ s0 = s1;
17194
+ } else {
17195
+ peg$currPos = s0;
17196
+ s0 = peg$FAILED;
17197
+ }
17279
17198
  } else {
17280
17199
  peg$currPos = s0;
17281
17200
  s0 = peg$FAILED;
@@ -17302,6 +17221,58 @@ to a key`);
17302
17221
  }
17303
17222
  return s0;
17304
17223
  }
17224
+ function peg$parseTagSelector() {
17225
+ let s0, s1, s2;
17226
+ s0 = peg$currPos;
17227
+ if (input.charCodeAt(peg$currPos) === 45) {
17228
+ s1 = peg$c67;
17229
+ peg$currPos++;
17230
+ } else {
17231
+ s1 = peg$FAILED;
17232
+ if (peg$silentFails === 0) peg$fail(peg$c68);
17233
+ }
17234
+ if (s1 !== peg$FAILED) {
17235
+ s2 = peg$parseTagSelectorValue();
17236
+ if (s2 !== peg$FAILED) {
17237
+ peg$savedPos = s0;
17238
+ s1 = peg$c69(s2);
17239
+ s0 = s1;
17240
+ } else {
17241
+ peg$currPos = s0;
17242
+ s0 = peg$FAILED;
17243
+ }
17244
+ } else {
17245
+ peg$currPos = s0;
17246
+ s0 = peg$FAILED;
17247
+ }
17248
+ return s0;
17249
+ }
17250
+ function peg$parseTagSelectorValue() {
17251
+ let s0, s1, s2;
17252
+ s0 = peg$currPos;
17253
+ s1 = [];
17254
+ if (peg$c40.test(input.charAt(peg$currPos))) {
17255
+ s2 = input.charAt(peg$currPos);
17256
+ peg$currPos++;
17257
+ } else {
17258
+ s2 = peg$FAILED;
17259
+ if (peg$silentFails === 0) peg$fail(peg$c41);
17260
+ }
17261
+ if (s2 !== peg$FAILED) while (s2 !== peg$FAILED) {
17262
+ s1.push(s2);
17263
+ if (peg$c40.test(input.charAt(peg$currPos))) {
17264
+ s2 = input.charAt(peg$currPos);
17265
+ peg$currPos++;
17266
+ } else {
17267
+ s2 = peg$FAILED;
17268
+ if (peg$silentFails === 0) peg$fail(peg$c41);
17269
+ }
17270
+ }
17271
+ else s1 = peg$FAILED;
17272
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
17273
+ else s0 = s1;
17274
+ return s0;
17275
+ }
17305
17276
  function peg$parseTagColonWithValue() {
17306
17277
  let s0, s1, s2;
17307
17278
  s0 = peg$currPos;
@@ -17316,7 +17287,7 @@ to a key`);
17316
17287
  s2 = peg$parseTagValue();
17317
17288
  if (s2 !== peg$FAILED) {
17318
17289
  peg$savedPos = s0;
17319
- s1 = peg$c67(s2);
17290
+ s1 = peg$c70(s2);
17320
17291
  s0 = s1;
17321
17292
  } else {
17322
17293
  peg$currPos = s0;
@@ -17334,7 +17305,7 @@ to a key`);
17334
17305
  s1 = peg$parseTagAttributes();
17335
17306
  if (s1 !== peg$FAILED) {
17336
17307
  peg$savedPos = s0;
17337
- s1 = peg$c68(s1);
17308
+ s1 = peg$c71(s1);
17338
17309
  }
17339
17310
  s0 = s1;
17340
17311
  if (s0 === peg$FAILED) {
@@ -17342,7 +17313,7 @@ to a key`);
17342
17313
  s1 = peg$parseTagSimpleValue();
17343
17314
  if (s1 !== peg$FAILED) {
17344
17315
  peg$savedPos = s0;
17345
- s1 = peg$c69(s1);
17316
+ s1 = peg$c72(s1);
17346
17317
  }
17347
17318
  s0 = s1;
17348
17319
  }
@@ -17360,7 +17331,7 @@ to a key`);
17360
17331
  else s1 = peg$FAILED;
17361
17332
  if (s1 !== peg$FAILED) {
17362
17333
  peg$savedPos = s0;
17363
- s1 = peg$c70(s1);
17334
+ s1 = peg$c73(s1);
17364
17335
  }
17365
17336
  s0 = s1;
17366
17337
  return s0;
@@ -17373,7 +17344,7 @@ to a key`);
17373
17344
  s2 = peg$parseTagAttribute();
17374
17345
  if (s2 !== peg$FAILED) {
17375
17346
  peg$savedPos = s0;
17376
- s1 = peg$c71(s2);
17347
+ s1 = peg$c74(s2);
17377
17348
  s0 = s1;
17378
17349
  } else {
17379
17350
  peg$currPos = s0;
@@ -17405,7 +17376,7 @@ to a key`);
17405
17376
  s5 = peg$parseTagAttributeValue();
17406
17377
  if (s5 !== peg$FAILED) {
17407
17378
  peg$savedPos = s0;
17408
- s1 = peg$c72(s1, s5);
17379
+ s1 = peg$c75(s1, s5);
17409
17380
  s0 = s1;
17410
17381
  } else {
17411
17382
  peg$currPos = s0;
@@ -17432,21 +17403,21 @@ to a key`);
17432
17403
  function peg$parseTagName() {
17433
17404
  let s0, s1;
17434
17405
  s0 = [];
17435
- if (peg$c73.test(input.charAt(peg$currPos))) {
17406
+ if (peg$c76.test(input.charAt(peg$currPos))) {
17436
17407
  s1 = input.charAt(peg$currPos);
17437
17408
  peg$currPos++;
17438
17409
  } else {
17439
17410
  s1 = peg$FAILED;
17440
- if (peg$silentFails === 0) peg$fail(peg$c74);
17411
+ if (peg$silentFails === 0) peg$fail(peg$c77);
17441
17412
  }
17442
17413
  if (s1 !== peg$FAILED) while (s1 !== peg$FAILED) {
17443
17414
  s0.push(s1);
17444
- if (peg$c73.test(input.charAt(peg$currPos))) {
17415
+ if (peg$c76.test(input.charAt(peg$currPos))) {
17445
17416
  s1 = input.charAt(peg$currPos);
17446
17417
  peg$currPos++;
17447
17418
  } else {
17448
17419
  s1 = peg$FAILED;
17449
- if (peg$silentFails === 0) peg$fail(peg$c74);
17420
+ if (peg$silentFails === 0) peg$fail(peg$c77);
17450
17421
  }
17451
17422
  }
17452
17423
  else s0 = peg$FAILED;
@@ -17465,7 +17436,7 @@ to a key`);
17465
17436
  }
17466
17437
  if (s2 !== peg$FAILED) {
17467
17438
  peg$savedPos = s0;
17468
- s1 = peg$c75(s2);
17439
+ s1 = peg$c78(s2);
17469
17440
  s0 = s1;
17470
17441
  } else {
17471
17442
  peg$currPos = s0;
@@ -17479,12 +17450,12 @@ to a key`);
17479
17450
  }
17480
17451
  function peg$parseTagValueChar() {
17481
17452
  let s0, s1, s2, s3;
17482
- if (peg$c76.test(input.charAt(peg$currPos))) {
17453
+ if (peg$c79.test(input.charAt(peg$currPos))) {
17483
17454
  s0 = input.charAt(peg$currPos);
17484
17455
  peg$currPos++;
17485
17456
  } else {
17486
17457
  s0 = peg$FAILED;
17487
- if (peg$silentFails === 0) peg$fail(peg$c77);
17458
+ if (peg$silentFails === 0) peg$fail(peg$c80);
17488
17459
  }
17489
17460
  if (s0 === peg$FAILED) {
17490
17461
  s0 = peg$currPos;
@@ -17552,21 +17523,21 @@ to a key`);
17552
17523
  let s0, s1, s2;
17553
17524
  s0 = peg$currPos;
17554
17525
  s1 = [];
17555
- if (peg$c73.test(input.charAt(peg$currPos))) {
17526
+ if (peg$c81.test(input.charAt(peg$currPos))) {
17556
17527
  s2 = input.charAt(peg$currPos);
17557
17528
  peg$currPos++;
17558
17529
  } else {
17559
17530
  s2 = peg$FAILED;
17560
- if (peg$silentFails === 0) peg$fail(peg$c74);
17531
+ if (peg$silentFails === 0) peg$fail(peg$c82);
17561
17532
  }
17562
17533
  if (s2 !== peg$FAILED) while (s2 !== peg$FAILED) {
17563
17534
  s1.push(s2);
17564
- if (peg$c73.test(input.charAt(peg$currPos))) {
17535
+ if (peg$c81.test(input.charAt(peg$currPos))) {
17565
17536
  s2 = input.charAt(peg$currPos);
17566
17537
  peg$currPos++;
17567
17538
  } else {
17568
17539
  s2 = peg$FAILED;
17569
- if (peg$silentFails === 0) peg$fail(peg$c74);
17540
+ if (peg$silentFails === 0) peg$fail(peg$c82);
17570
17541
  }
17571
17542
  }
17572
17543
  else s1 = peg$FAILED;
@@ -17578,11 +17549,11 @@ to a key`);
17578
17549
  let s0, s1, s2, s3, s4;
17579
17550
  s0 = peg$currPos;
17580
17551
  if (input.charCodeAt(peg$currPos) === 34) {
17581
- s1 = peg$c78;
17552
+ s1 = peg$c83;
17582
17553
  peg$currPos++;
17583
17554
  } else {
17584
17555
  s1 = peg$FAILED;
17585
- if (peg$silentFails === 0) peg$fail(peg$c79);
17556
+ if (peg$silentFails === 0) peg$fail(peg$c84);
17586
17557
  }
17587
17558
  if (s1 !== peg$FAILED) {
17588
17559
  s2 = peg$currPos;
@@ -17596,15 +17567,15 @@ to a key`);
17596
17567
  else s2 = s3;
17597
17568
  if (s2 !== peg$FAILED) {
17598
17569
  if (input.charCodeAt(peg$currPos) === 34) {
17599
- s3 = peg$c78;
17570
+ s3 = peg$c83;
17600
17571
  peg$currPos++;
17601
17572
  } else {
17602
17573
  s3 = peg$FAILED;
17603
- if (peg$silentFails === 0) peg$fail(peg$c79);
17574
+ if (peg$silentFails === 0) peg$fail(peg$c84);
17604
17575
  }
17605
17576
  if (s3 !== peg$FAILED) {
17606
17577
  peg$savedPos = s0;
17607
- s1 = peg$c80(s2);
17578
+ s1 = peg$c69(s2);
17608
17579
  s0 = s1;
17609
17580
  } else {
17610
17581
  peg$currPos = s0;
@@ -17622,12 +17593,12 @@ to a key`);
17622
17593
  }
17623
17594
  function peg$parseTagAttributeValueChar() {
17624
17595
  let s0, s1, s2, s3;
17625
- if (peg$c81.test(input.charAt(peg$currPos))) {
17596
+ if (peg$c85.test(input.charAt(peg$currPos))) {
17626
17597
  s0 = input.charAt(peg$currPos);
17627
17598
  peg$currPos++;
17628
17599
  } else {
17629
17600
  s0 = peg$FAILED;
17630
- if (peg$silentFails === 0) peg$fail(peg$c82);
17601
+ if (peg$silentFails === 0) peg$fail(peg$c86);
17631
17602
  }
17632
17603
  if (s0 === peg$FAILED) {
17633
17604
  s0 = peg$currPos;
@@ -17663,15 +17634,15 @@ to a key`);
17663
17634
  if (s2 === peg$FAILED) {
17664
17635
  s2 = peg$currPos;
17665
17636
  if (input.charCodeAt(peg$currPos) === 34) {
17666
- s3 = peg$c78;
17637
+ s3 = peg$c83;
17667
17638
  peg$currPos++;
17668
17639
  } else {
17669
17640
  s3 = peg$FAILED;
17670
- if (peg$silentFails === 0) peg$fail(peg$c79);
17641
+ if (peg$silentFails === 0) peg$fail(peg$c84);
17671
17642
  }
17672
17643
  if (s3 !== peg$FAILED) {
17673
17644
  peg$savedPos = s2;
17674
- s3 = peg$c83();
17645
+ s3 = peg$c87();
17675
17646
  }
17676
17647
  s2 = s3;
17677
17648
  }
@@ -17701,12 +17672,12 @@ to a key`);
17701
17672
  s3 = peg$parseBaseFret();
17702
17673
  if (s3 === peg$FAILED) s3 = null;
17703
17674
  if (s3 !== peg$FAILED) {
17704
- if (input.substr(peg$currPos, 5) === peg$c84) {
17705
- s4 = peg$c84;
17675
+ if (input.substr(peg$currPos, 5) === peg$c88) {
17676
+ s4 = peg$c88;
17706
17677
  peg$currPos += 5;
17707
17678
  } else {
17708
17679
  s4 = peg$FAILED;
17709
- if (peg$silentFails === 0) peg$fail(peg$c85);
17680
+ if (peg$silentFails === 0) peg$fail(peg$c89);
17710
17681
  }
17711
17682
  if (s4 !== peg$FAILED) {
17712
17683
  s5 = [];
@@ -17721,7 +17692,7 @@ to a key`);
17721
17692
  if (s6 === peg$FAILED) s6 = null;
17722
17693
  if (s6 !== peg$FAILED) {
17723
17694
  peg$savedPos = s0;
17724
- s1 = peg$c86(s1, s3, s5, s6);
17695
+ s1 = peg$c90(s1, s3, s5, s6);
17725
17696
  s0 = s1;
17726
17697
  } else {
17727
17698
  peg$currPos = s0;
@@ -17753,43 +17724,185 @@ to a key`);
17753
17724
  let s0, s1, s2, s3;
17754
17725
  s0 = peg$currPos;
17755
17726
  s1 = peg$currPos;
17756
- s2 = [];
17757
- if (peg$c87.test(input.charAt(peg$currPos))) {
17758
- s3 = input.charAt(peg$currPos);
17727
+ s2 = peg$parseChordDefinitionNameBase();
17728
+ if (s2 !== peg$FAILED) {
17729
+ s3 = peg$parseChordDefinitionNameBass();
17730
+ if (s3 === peg$FAILED) s3 = null;
17731
+ if (s3 !== peg$FAILED) {
17732
+ s2 = [
17733
+ s2,
17734
+ s3
17735
+ ];
17736
+ s1 = s2;
17737
+ } else {
17738
+ peg$currPos = s1;
17739
+ s1 = peg$FAILED;
17740
+ }
17741
+ } else {
17742
+ peg$currPos = s1;
17743
+ s1 = peg$FAILED;
17744
+ }
17745
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
17746
+ else s0 = s1;
17747
+ return s0;
17748
+ }
17749
+ function peg$parseChordDefinitionNameBase() {
17750
+ let s0, s1, s2, s3;
17751
+ s0 = peg$currPos;
17752
+ s1 = peg$currPos;
17753
+ s2 = peg$parseChordDefinitionNote();
17754
+ if (s2 !== peg$FAILED) {
17755
+ s3 = peg$parseChordDefinitionSuffix();
17756
+ if (s3 === peg$FAILED) s3 = null;
17757
+ if (s3 !== peg$FAILED) {
17758
+ s2 = [
17759
+ s2,
17760
+ s3
17761
+ ];
17762
+ s1 = s2;
17763
+ } else {
17764
+ peg$currPos = s1;
17765
+ s1 = peg$FAILED;
17766
+ }
17767
+ } else {
17768
+ peg$currPos = s1;
17769
+ s1 = peg$FAILED;
17770
+ }
17771
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
17772
+ else s0 = s1;
17773
+ return s0;
17774
+ }
17775
+ function peg$parseChordDefinitionNameBass() {
17776
+ let s0, s1, s2, s3;
17777
+ s0 = peg$currPos;
17778
+ s1 = peg$currPos;
17779
+ if (input.charCodeAt(peg$currPos) === 47) {
17780
+ s2 = peg$c91;
17759
17781
  peg$currPos++;
17760
17782
  } else {
17761
- s3 = peg$FAILED;
17762
- if (peg$silentFails === 0) peg$fail(peg$c88);
17783
+ s2 = peg$FAILED;
17784
+ if (peg$silentFails === 0) peg$fail(peg$c92);
17763
17785
  }
17764
- if (s3 !== peg$FAILED) while (s3 !== peg$FAILED) {
17765
- s2.push(s3);
17766
- if (peg$c87.test(input.charAt(peg$currPos))) {
17786
+ if (s2 !== peg$FAILED) {
17787
+ s3 = peg$parseChordDefinitionNote();
17788
+ if (s3 !== peg$FAILED) {
17789
+ s2 = [
17790
+ s2,
17791
+ s3
17792
+ ];
17793
+ s1 = s2;
17794
+ } else {
17795
+ peg$currPos = s1;
17796
+ s1 = peg$FAILED;
17797
+ }
17798
+ } else {
17799
+ peg$currPos = s1;
17800
+ s1 = peg$FAILED;
17801
+ }
17802
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
17803
+ else s0 = s1;
17804
+ return s0;
17805
+ }
17806
+ function peg$parseChordDefinitionNote() {
17807
+ let s0, s1, s2, s3;
17808
+ s0 = peg$currPos;
17809
+ s1 = peg$currPos;
17810
+ if (peg$c93.test(input.charAt(peg$currPos))) {
17811
+ s2 = input.charAt(peg$currPos);
17812
+ peg$currPos++;
17813
+ } else {
17814
+ s2 = peg$FAILED;
17815
+ if (peg$silentFails === 0) peg$fail(peg$c94);
17816
+ }
17817
+ if (s2 !== peg$FAILED) {
17818
+ if (peg$c95.test(input.charAt(peg$currPos))) {
17767
17819
  s3 = input.charAt(peg$currPos);
17768
17820
  peg$currPos++;
17769
17821
  } else {
17770
17822
  s3 = peg$FAILED;
17771
- if (peg$silentFails === 0) peg$fail(peg$c88);
17823
+ if (peg$silentFails === 0) peg$fail(peg$c96);
17772
17824
  }
17825
+ if (s3 === peg$FAILED) {
17826
+ if (input.substr(peg$currPos, 2) === peg$c97) {
17827
+ s3 = peg$c97;
17828
+ peg$currPos += 2;
17829
+ } else {
17830
+ s3 = peg$FAILED;
17831
+ if (peg$silentFails === 0) peg$fail(peg$c98);
17832
+ }
17833
+ if (s3 === peg$FAILED) {
17834
+ if (input.charCodeAt(peg$currPos) === 115) {
17835
+ s3 = peg$c99;
17836
+ peg$currPos++;
17837
+ } else {
17838
+ s3 = peg$FAILED;
17839
+ if (peg$silentFails === 0) peg$fail(peg$c100);
17840
+ }
17841
+ if (s3 === peg$FAILED) {
17842
+ if (input.substr(peg$currPos, 2) === peg$c101) {
17843
+ s3 = peg$c101;
17844
+ peg$currPos += 2;
17845
+ } else {
17846
+ s3 = peg$FAILED;
17847
+ if (peg$silentFails === 0) peg$fail(peg$c102);
17848
+ }
17849
+ }
17850
+ }
17851
+ }
17852
+ if (s3 === peg$FAILED) s3 = null;
17853
+ if (s3 !== peg$FAILED) {
17854
+ s2 = [
17855
+ s2,
17856
+ s3
17857
+ ];
17858
+ s1 = s2;
17859
+ } else {
17860
+ peg$currPos = s1;
17861
+ s1 = peg$FAILED;
17862
+ }
17863
+ } else {
17864
+ peg$currPos = s1;
17865
+ s1 = peg$FAILED;
17773
17866
  }
17774
- else s2 = peg$FAILED;
17775
- if (s2 !== peg$FAILED) s1 = input.substring(s1, peg$currPos);
17776
- else s1 = s2;
17777
- if (s1 !== peg$FAILED) {
17778
- peg$savedPos = s0;
17779
- s1 = peg$c89(s1);
17867
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
17868
+ else s0 = s1;
17869
+ return s0;
17870
+ }
17871
+ function peg$parseChordDefinitionSuffix() {
17872
+ let s0, s1, s2;
17873
+ s0 = peg$currPos;
17874
+ s1 = [];
17875
+ if (peg$c103.test(input.charAt(peg$currPos))) {
17876
+ s2 = input.charAt(peg$currPos);
17877
+ peg$currPos++;
17878
+ } else {
17879
+ s2 = peg$FAILED;
17880
+ if (peg$silentFails === 0) peg$fail(peg$c104);
17780
17881
  }
17781
- s0 = s1;
17882
+ if (s2 !== peg$FAILED) while (s2 !== peg$FAILED) {
17883
+ s1.push(s2);
17884
+ if (peg$c103.test(input.charAt(peg$currPos))) {
17885
+ s2 = input.charAt(peg$currPos);
17886
+ peg$currPos++;
17887
+ } else {
17888
+ s2 = peg$FAILED;
17889
+ if (peg$silentFails === 0) peg$fail(peg$c104);
17890
+ }
17891
+ }
17892
+ else s1 = peg$FAILED;
17893
+ if (s1 !== peg$FAILED) s0 = input.substring(s0, peg$currPos);
17894
+ else s0 = s1;
17782
17895
  return s0;
17783
17896
  }
17784
17897
  function peg$parseBaseFret() {
17785
17898
  let s0, s1, s2, s3, s4;
17786
17899
  s0 = peg$currPos;
17787
- if (input.substr(peg$currPos, 9) === peg$c90) {
17788
- s1 = peg$c90;
17900
+ if (input.substr(peg$currPos, 9) === peg$c105) {
17901
+ s1 = peg$c105;
17789
17902
  peg$currPos += 9;
17790
17903
  } else {
17791
17904
  s1 = peg$FAILED;
17792
- if (peg$silentFails === 0) peg$fail(peg$c91);
17905
+ if (peg$silentFails === 0) peg$fail(peg$c106);
17793
17906
  }
17794
17907
  if (s1 !== peg$FAILED) {
17795
17908
  s2 = peg$parse__();
@@ -17799,7 +17912,7 @@ to a key`);
17799
17912
  s4 = peg$parse__();
17800
17913
  if (s4 !== peg$FAILED) {
17801
17914
  peg$savedPos = s0;
17802
- s1 = peg$c92(s3);
17915
+ s1 = peg$c107(s3);
17803
17916
  s0 = s1;
17804
17917
  } else {
17805
17918
  peg$currPos = s0;
@@ -17824,12 +17937,12 @@ to a key`);
17824
17937
  s0 = peg$currPos;
17825
17938
  s1 = peg$parse__();
17826
17939
  if (s1 !== peg$FAILED) {
17827
- if (input.substr(peg$currPos, 7) === peg$c93) {
17828
- s2 = peg$c93;
17940
+ if (input.substr(peg$currPos, 7) === peg$c108) {
17941
+ s2 = peg$c108;
17829
17942
  peg$currPos += 7;
17830
17943
  } else {
17831
17944
  s2 = peg$FAILED;
17832
- if (peg$silentFails === 0) peg$fail(peg$c94);
17945
+ if (peg$silentFails === 0) peg$fail(peg$c109);
17833
17946
  }
17834
17947
  if (s2 !== peg$FAILED) {
17835
17948
  s3 = [];
@@ -17841,7 +17954,7 @@ to a key`);
17841
17954
  else s3 = peg$FAILED;
17842
17955
  if (s3 !== peg$FAILED) {
17843
17956
  peg$savedPos = s0;
17844
- s1 = peg$c95(s3);
17957
+ s1 = peg$c110(s3);
17845
17958
  s0 = s1;
17846
17959
  } else {
17847
17960
  peg$currPos = s0;
@@ -17865,7 +17978,7 @@ to a key`);
17865
17978
  s2 = peg$parseFinger();
17866
17979
  if (s2 !== peg$FAILED) {
17867
17980
  peg$savedPos = s0;
17868
- s1 = peg$c96(s2);
17981
+ s1 = peg$c111(s2);
17869
17982
  s0 = s1;
17870
17983
  } else {
17871
17984
  peg$currPos = s0;
@@ -17881,12 +17994,12 @@ to a key`);
17881
17994
  let s0;
17882
17995
  s0 = peg$parseFingerNumber();
17883
17996
  if (s0 === peg$FAILED) {
17884
- if (peg$c97.test(input.charAt(peg$currPos))) {
17997
+ if (peg$c112.test(input.charAt(peg$currPos))) {
17885
17998
  s0 = input.charAt(peg$currPos);
17886
17999
  peg$currPos++;
17887
18000
  } else {
17888
18001
  s0 = peg$FAILED;
17889
- if (peg$silentFails === 0) peg$fail(peg$c98);
18002
+ if (peg$silentFails === 0) peg$fail(peg$c113);
17890
18003
  }
17891
18004
  }
17892
18005
  return s0;
@@ -17894,39 +18007,39 @@ to a key`);
17894
18007
  function peg$parseFingerNumber() {
17895
18008
  let s0, s1;
17896
18009
  s0 = peg$currPos;
17897
- if (peg$c99.test(input.charAt(peg$currPos))) {
18010
+ if (peg$c114.test(input.charAt(peg$currPos))) {
17898
18011
  s1 = input.charAt(peg$currPos);
17899
18012
  peg$currPos++;
17900
18013
  } else {
17901
18014
  s1 = peg$FAILED;
17902
- if (peg$silentFails === 0) peg$fail(peg$c100);
18015
+ if (peg$silentFails === 0) peg$fail(peg$c115);
17903
18016
  }
17904
18017
  if (s1 !== peg$FAILED) {
17905
18018
  peg$savedPos = s0;
17906
- s1 = peg$c101(s1);
18019
+ s1 = peg$c116(s1);
17907
18020
  }
17908
18021
  s0 = s1;
17909
18022
  return s0;
17910
18023
  }
17911
18024
  function peg$parseFingerLetter() {
17912
18025
  let s0;
17913
- if (peg$c102.test(input.charAt(peg$currPos))) {
18026
+ if (peg$c117.test(input.charAt(peg$currPos))) {
17914
18027
  s0 = input.charAt(peg$currPos);
17915
18028
  peg$currPos++;
17916
18029
  } else {
17917
18030
  s0 = peg$FAILED;
17918
- if (peg$silentFails === 0) peg$fail(peg$c103);
18031
+ if (peg$silentFails === 0) peg$fail(peg$c118);
17919
18032
  }
17920
18033
  return s0;
17921
18034
  }
17922
18035
  function peg$parseNoFingerSetting() {
17923
18036
  let s0;
17924
- if (peg$c104.test(input.charAt(peg$currPos))) {
18037
+ if (peg$c119.test(input.charAt(peg$currPos))) {
17925
18038
  s0 = input.charAt(peg$currPos);
17926
18039
  peg$currPos++;
17927
18040
  } else {
17928
18041
  s0 = peg$FAILED;
17929
- if (peg$silentFails === 0) peg$fail(peg$c105);
18042
+ if (peg$silentFails === 0) peg$fail(peg$c120);
17930
18043
  }
17931
18044
  return s0;
17932
18045
  }
@@ -17938,7 +18051,7 @@ to a key`);
17938
18051
  s2 = peg$parseFret();
17939
18052
  if (s2 !== peg$FAILED) {
17940
18053
  peg$savedPos = s0;
17941
- s1 = peg$c106(s2);
18054
+ s1 = peg$c121(s2);
17942
18055
  s0 = s1;
17943
18056
  } else {
17944
18057
  peg$currPos = s0;
@@ -17962,7 +18075,7 @@ to a key`);
17962
18075
  }
17963
18076
  if (s2 !== peg$FAILED) {
17964
18077
  peg$savedPos = s0;
17965
- s1 = peg$c106(s2);
18078
+ s1 = peg$c121(s2);
17966
18079
  s0 = s1;
17967
18080
  } else {
17968
18081
  peg$currPos = s0;
@@ -17977,16 +18090,16 @@ to a key`);
17977
18090
  function peg$parseFretNumber() {
17978
18091
  let s0, s1;
17979
18092
  s0 = peg$currPos;
17980
- if (peg$c107.test(input.charAt(peg$currPos))) {
18093
+ if (peg$c122.test(input.charAt(peg$currPos))) {
17981
18094
  s1 = input.charAt(peg$currPos);
17982
18095
  peg$currPos++;
17983
18096
  } else {
17984
18097
  s1 = peg$FAILED;
17985
- if (peg$silentFails === 0) peg$fail(peg$c108);
18098
+ if (peg$silentFails === 0) peg$fail(peg$c123);
17986
18099
  }
17987
18100
  if (s1 !== peg$FAILED) {
17988
18101
  peg$savedPos = s0;
17989
- s1 = peg$c101(s1);
18102
+ s1 = peg$c116(s1);
17990
18103
  }
17991
18104
  s0 = s1;
17992
18105
  return s0;
@@ -17995,35 +18108,35 @@ to a key`);
17995
18108
  let s0, s1;
17996
18109
  s0 = peg$currPos;
17997
18110
  if (input.charCodeAt(peg$currPos) === 48) {
17998
- s1 = peg$c109;
18111
+ s1 = peg$c124;
17999
18112
  peg$currPos++;
18000
18113
  } else {
18001
18114
  s1 = peg$FAILED;
18002
- if (peg$silentFails === 0) peg$fail(peg$c110);
18115
+ if (peg$silentFails === 0) peg$fail(peg$c125);
18003
18116
  }
18004
18117
  if (s1 !== peg$FAILED) {
18005
18118
  peg$savedPos = s0;
18006
- s1 = peg$c111();
18119
+ s1 = peg$c126();
18007
18120
  }
18008
18121
  s0 = s1;
18009
18122
  return s0;
18010
18123
  }
18011
18124
  function peg$parseNonSoundingString() {
18012
18125
  let s0;
18013
- if (input.substr(peg$currPos, 2) === peg$c112) {
18014
- s0 = peg$c112;
18126
+ if (input.substr(peg$currPos, 2) === peg$c127) {
18127
+ s0 = peg$c127;
18015
18128
  peg$currPos += 2;
18016
18129
  } else {
18017
18130
  s0 = peg$FAILED;
18018
- if (peg$silentFails === 0) peg$fail(peg$c113);
18131
+ if (peg$silentFails === 0) peg$fail(peg$c128);
18019
18132
  }
18020
18133
  if (s0 === peg$FAILED) {
18021
- if (peg$c114.test(input.charAt(peg$currPos))) {
18134
+ if (peg$c129.test(input.charAt(peg$currPos))) {
18022
18135
  s0 = input.charAt(peg$currPos);
18023
18136
  peg$currPos++;
18024
18137
  } else {
18025
18138
  s0 = peg$FAILED;
18026
- if (peg$silentFails === 0) peg$fail(peg$c115);
18139
+ if (peg$silentFails === 0) peg$fail(peg$c130);
18027
18140
  }
18028
18141
  }
18029
18142
  return s0;
@@ -18110,7 +18223,7 @@ to a key`);
18110
18223
  s4 = peg$parseAbcEndTag();
18111
18224
  if (s4 !== peg$FAILED) {
18112
18225
  peg$savedPos = s0;
18113
- s1 = peg$c116(s1, s3, s4);
18226
+ s1 = peg$c131(s1, s3, s4);
18114
18227
  s0 = s1;
18115
18228
  } else {
18116
18229
  peg$currPos = s0;
@@ -18131,7 +18244,7 @@ to a key`);
18131
18244
  return s0;
18132
18245
  }
18133
18246
  function peg$parseAbcStartTag() {
18134
- let s0, s1, s2, s3, s4, s5, s6, s7;
18247
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8;
18135
18248
  s0 = peg$currPos;
18136
18249
  if (input.charCodeAt(peg$currPos) === 123) {
18137
18250
  s1 = peg$c44;
@@ -18143,32 +18256,39 @@ to a key`);
18143
18256
  if (s1 !== peg$FAILED) {
18144
18257
  s2 = peg$parse_();
18145
18258
  if (s2 !== peg$FAILED) {
18146
- if (input.substr(peg$currPos, 12) === peg$c117) {
18147
- s3 = peg$c117;
18259
+ if (input.substr(peg$currPos, 12) === peg$c132) {
18260
+ s3 = peg$c132;
18148
18261
  peg$currPos += 12;
18149
18262
  } else {
18150
18263
  s3 = peg$FAILED;
18151
- if (peg$silentFails === 0) peg$fail(peg$c118);
18264
+ if (peg$silentFails === 0) peg$fail(peg$c133);
18152
18265
  }
18153
18266
  if (s3 !== peg$FAILED) {
18154
- s4 = peg$parse_();
18267
+ s4 = peg$parseTagSelector();
18268
+ if (s4 === peg$FAILED) s4 = null;
18155
18269
  if (s4 !== peg$FAILED) {
18156
- s5 = peg$parseTagColonWithValue();
18157
- if (s5 === peg$FAILED) s5 = null;
18270
+ s5 = peg$parse_();
18158
18271
  if (s5 !== peg$FAILED) {
18159
- s6 = peg$parse_();
18272
+ s6 = peg$parseTagColonWithValue();
18273
+ if (s6 === peg$FAILED) s6 = null;
18160
18274
  if (s6 !== peg$FAILED) {
18161
- if (input.charCodeAt(peg$currPos) === 125) {
18162
- s7 = peg$c30;
18163
- peg$currPos++;
18164
- } else {
18165
- s7 = peg$FAILED;
18166
- if (peg$silentFails === 0) peg$fail(peg$c31);
18167
- }
18275
+ s7 = peg$parse_();
18168
18276
  if (s7 !== peg$FAILED) {
18169
- peg$savedPos = s0;
18170
- s1 = peg$c66(s3, s5);
18171
- s0 = s1;
18277
+ if (input.charCodeAt(peg$currPos) === 125) {
18278
+ s8 = peg$c30;
18279
+ peg$currPos++;
18280
+ } else {
18281
+ s8 = peg$FAILED;
18282
+ if (peg$silentFails === 0) peg$fail(peg$c31);
18283
+ }
18284
+ if (s8 !== peg$FAILED) {
18285
+ peg$savedPos = s0;
18286
+ s1 = peg$c66(s3, s4, s6);
18287
+ s0 = s1;
18288
+ } else {
18289
+ peg$currPos = s0;
18290
+ s0 = peg$FAILED;
18291
+ }
18172
18292
  } else {
18173
18293
  peg$currPos = s0;
18174
18294
  s0 = peg$FAILED;
@@ -18212,12 +18332,12 @@ to a key`);
18212
18332
  if (s1 !== peg$FAILED) {
18213
18333
  s2 = peg$parse_();
18214
18334
  if (s2 !== peg$FAILED) {
18215
- if (input.substr(peg$currPos, 10) === peg$c119) {
18216
- s3 = peg$c119;
18335
+ if (input.substr(peg$currPos, 10) === peg$c134) {
18336
+ s3 = peg$c134;
18217
18337
  peg$currPos += 10;
18218
18338
  } else {
18219
18339
  s3 = peg$FAILED;
18220
- if (peg$silentFails === 0) peg$fail(peg$c120);
18340
+ if (peg$silentFails === 0) peg$fail(peg$c135);
18221
18341
  }
18222
18342
  if (s3 !== peg$FAILED) {
18223
18343
  s4 = peg$parse_();
@@ -18231,7 +18351,7 @@ to a key`);
18231
18351
  }
18232
18352
  if (s5 !== peg$FAILED) {
18233
18353
  peg$savedPos = s0;
18234
- s1 = peg$c121(s3);
18354
+ s1 = peg$c136(s3);
18235
18355
  s0 = s1;
18236
18356
  } else {
18237
18357
  peg$currPos = s0;
@@ -18325,7 +18445,7 @@ to a key`);
18325
18445
  s4 = peg$parseGridEndTag();
18326
18446
  if (s4 !== peg$FAILED) {
18327
18447
  peg$savedPos = s0;
18328
- s1 = peg$c116(s1, s3, s4);
18448
+ s1 = peg$c131(s1, s3, s4);
18329
18449
  s0 = s1;
18330
18450
  } else {
18331
18451
  peg$currPos = s0;
@@ -18346,7 +18466,7 @@ to a key`);
18346
18466
  return s0;
18347
18467
  }
18348
18468
  function peg$parseGridStartTag() {
18349
- let s0, s1, s2, s3, s4, s5, s6, s7;
18469
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8;
18350
18470
  s0 = peg$currPos;
18351
18471
  if (input.charCodeAt(peg$currPos) === 123) {
18352
18472
  s1 = peg$c44;
@@ -18358,41 +18478,48 @@ to a key`);
18358
18478
  if (s1 !== peg$FAILED) {
18359
18479
  s2 = peg$parse_();
18360
18480
  if (s2 !== peg$FAILED) {
18361
- if (input.substr(peg$currPos, 13) === peg$c122) {
18362
- s3 = peg$c122;
18481
+ if (input.substr(peg$currPos, 13) === peg$c137) {
18482
+ s3 = peg$c137;
18363
18483
  peg$currPos += 13;
18364
18484
  } else {
18365
18485
  s3 = peg$FAILED;
18366
- if (peg$silentFails === 0) peg$fail(peg$c123);
18486
+ if (peg$silentFails === 0) peg$fail(peg$c138);
18367
18487
  }
18368
18488
  if (s3 === peg$FAILED) {
18369
- if (input.substr(peg$currPos, 3) === peg$c124) {
18370
- s3 = peg$c124;
18489
+ if (input.substr(peg$currPos, 3) === peg$c139) {
18490
+ s3 = peg$c139;
18371
18491
  peg$currPos += 3;
18372
18492
  } else {
18373
18493
  s3 = peg$FAILED;
18374
- if (peg$silentFails === 0) peg$fail(peg$c125);
18494
+ if (peg$silentFails === 0) peg$fail(peg$c140);
18375
18495
  }
18376
18496
  }
18377
18497
  if (s3 !== peg$FAILED) {
18378
- s4 = peg$parse_();
18498
+ s4 = peg$parseTagSelector();
18499
+ if (s4 === peg$FAILED) s4 = null;
18379
18500
  if (s4 !== peg$FAILED) {
18380
- s5 = peg$parseTagColonWithValue();
18381
- if (s5 === peg$FAILED) s5 = null;
18501
+ s5 = peg$parse_();
18382
18502
  if (s5 !== peg$FAILED) {
18383
- s6 = peg$parse_();
18503
+ s6 = peg$parseTagColonWithValue();
18504
+ if (s6 === peg$FAILED) s6 = null;
18384
18505
  if (s6 !== peg$FAILED) {
18385
- if (input.charCodeAt(peg$currPos) === 125) {
18386
- s7 = peg$c30;
18387
- peg$currPos++;
18388
- } else {
18389
- s7 = peg$FAILED;
18390
- if (peg$silentFails === 0) peg$fail(peg$c31);
18391
- }
18506
+ s7 = peg$parse_();
18392
18507
  if (s7 !== peg$FAILED) {
18393
- peg$savedPos = s0;
18394
- s1 = peg$c66(s3, s5);
18395
- s0 = s1;
18508
+ if (input.charCodeAt(peg$currPos) === 125) {
18509
+ s8 = peg$c30;
18510
+ peg$currPos++;
18511
+ } else {
18512
+ s8 = peg$FAILED;
18513
+ if (peg$silentFails === 0) peg$fail(peg$c31);
18514
+ }
18515
+ if (s8 !== peg$FAILED) {
18516
+ peg$savedPos = s0;
18517
+ s1 = peg$c66(s3, s4, s6);
18518
+ s0 = s1;
18519
+ } else {
18520
+ peg$currPos = s0;
18521
+ s0 = peg$FAILED;
18522
+ }
18396
18523
  } else {
18397
18524
  peg$currPos = s0;
18398
18525
  s0 = peg$FAILED;
@@ -18436,20 +18563,20 @@ to a key`);
18436
18563
  if (s1 !== peg$FAILED) {
18437
18564
  s2 = peg$parse_();
18438
18565
  if (s2 !== peg$FAILED) {
18439
- if (input.substr(peg$currPos, 11) === peg$c126) {
18440
- s3 = peg$c126;
18566
+ if (input.substr(peg$currPos, 11) === peg$c141) {
18567
+ s3 = peg$c141;
18441
18568
  peg$currPos += 11;
18442
18569
  } else {
18443
18570
  s3 = peg$FAILED;
18444
- if (peg$silentFails === 0) peg$fail(peg$c127);
18571
+ if (peg$silentFails === 0) peg$fail(peg$c142);
18445
18572
  }
18446
18573
  if (s3 === peg$FAILED) {
18447
- if (input.substr(peg$currPos, 3) === peg$c128) {
18448
- s3 = peg$c128;
18574
+ if (input.substr(peg$currPos, 3) === peg$c143) {
18575
+ s3 = peg$c143;
18449
18576
  peg$currPos += 3;
18450
18577
  } else {
18451
18578
  s3 = peg$FAILED;
18452
- if (peg$silentFails === 0) peg$fail(peg$c129);
18579
+ if (peg$silentFails === 0) peg$fail(peg$c144);
18453
18580
  }
18454
18581
  }
18455
18582
  if (s3 !== peg$FAILED) {
@@ -18464,7 +18591,7 @@ to a key`);
18464
18591
  }
18465
18592
  if (s5 !== peg$FAILED) {
18466
18593
  peg$savedPos = s0;
18467
- s1 = peg$c121(s3);
18594
+ s1 = peg$c136(s3);
18468
18595
  s0 = s1;
18469
18596
  } else {
18470
18597
  peg$currPos = s0;
@@ -18558,7 +18685,7 @@ to a key`);
18558
18685
  s4 = peg$parseLyEndTag();
18559
18686
  if (s4 !== peg$FAILED) {
18560
18687
  peg$savedPos = s0;
18561
- s1 = peg$c116(s1, s3, s4);
18688
+ s1 = peg$c131(s1, s3, s4);
18562
18689
  s0 = s1;
18563
18690
  } else {
18564
18691
  peg$currPos = s0;
@@ -18579,7 +18706,7 @@ to a key`);
18579
18706
  return s0;
18580
18707
  }
18581
18708
  function peg$parseLyStartTag() {
18582
- let s0, s1, s2, s3, s4, s5, s6, s7;
18709
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8;
18583
18710
  s0 = peg$currPos;
18584
18711
  if (input.charCodeAt(peg$currPos) === 123) {
18585
18712
  s1 = peg$c44;
@@ -18591,32 +18718,39 @@ to a key`);
18591
18718
  if (s1 !== peg$FAILED) {
18592
18719
  s2 = peg$parse_();
18593
18720
  if (s2 !== peg$FAILED) {
18594
- if (input.substr(peg$currPos, 11) === peg$c130) {
18595
- s3 = peg$c130;
18721
+ if (input.substr(peg$currPos, 11) === peg$c145) {
18722
+ s3 = peg$c145;
18596
18723
  peg$currPos += 11;
18597
18724
  } else {
18598
18725
  s3 = peg$FAILED;
18599
- if (peg$silentFails === 0) peg$fail(peg$c131);
18726
+ if (peg$silentFails === 0) peg$fail(peg$c146);
18600
18727
  }
18601
18728
  if (s3 !== peg$FAILED) {
18602
- s4 = peg$parse_();
18729
+ s4 = peg$parseTagSelector();
18730
+ if (s4 === peg$FAILED) s4 = null;
18603
18731
  if (s4 !== peg$FAILED) {
18604
- s5 = peg$parseTagColonWithValue();
18605
- if (s5 === peg$FAILED) s5 = null;
18732
+ s5 = peg$parse_();
18606
18733
  if (s5 !== peg$FAILED) {
18607
- s6 = peg$parse_();
18734
+ s6 = peg$parseTagColonWithValue();
18735
+ if (s6 === peg$FAILED) s6 = null;
18608
18736
  if (s6 !== peg$FAILED) {
18609
- if (input.charCodeAt(peg$currPos) === 125) {
18610
- s7 = peg$c30;
18611
- peg$currPos++;
18612
- } else {
18613
- s7 = peg$FAILED;
18614
- if (peg$silentFails === 0) peg$fail(peg$c31);
18615
- }
18737
+ s7 = peg$parse_();
18616
18738
  if (s7 !== peg$FAILED) {
18617
- peg$savedPos = s0;
18618
- s1 = peg$c66(s3, s5);
18619
- s0 = s1;
18739
+ if (input.charCodeAt(peg$currPos) === 125) {
18740
+ s8 = peg$c30;
18741
+ peg$currPos++;
18742
+ } else {
18743
+ s8 = peg$FAILED;
18744
+ if (peg$silentFails === 0) peg$fail(peg$c31);
18745
+ }
18746
+ if (s8 !== peg$FAILED) {
18747
+ peg$savedPos = s0;
18748
+ s1 = peg$c66(s3, s4, s6);
18749
+ s0 = s1;
18750
+ } else {
18751
+ peg$currPos = s0;
18752
+ s0 = peg$FAILED;
18753
+ }
18620
18754
  } else {
18621
18755
  peg$currPos = s0;
18622
18756
  s0 = peg$FAILED;
@@ -18660,12 +18794,12 @@ to a key`);
18660
18794
  if (s1 !== peg$FAILED) {
18661
18795
  s2 = peg$parse_();
18662
18796
  if (s2 !== peg$FAILED) {
18663
- if (input.substr(peg$currPos, 9) === peg$c132) {
18664
- s3 = peg$c132;
18797
+ if (input.substr(peg$currPos, 9) === peg$c147) {
18798
+ s3 = peg$c147;
18665
18799
  peg$currPos += 9;
18666
18800
  } else {
18667
18801
  s3 = peg$FAILED;
18668
- if (peg$silentFails === 0) peg$fail(peg$c133);
18802
+ if (peg$silentFails === 0) peg$fail(peg$c148);
18669
18803
  }
18670
18804
  if (s3 !== peg$FAILED) {
18671
18805
  s4 = peg$parse_();
@@ -18679,7 +18813,7 @@ to a key`);
18679
18813
  }
18680
18814
  if (s5 !== peg$FAILED) {
18681
18815
  peg$savedPos = s0;
18682
- s1 = peg$c121(s3);
18816
+ s1 = peg$c136(s3);
18683
18817
  s0 = s1;
18684
18818
  } else {
18685
18819
  peg$currPos = s0;
@@ -18773,7 +18907,7 @@ to a key`);
18773
18907
  s4 = peg$parseTabEndTag();
18774
18908
  if (s4 !== peg$FAILED) {
18775
18909
  peg$savedPos = s0;
18776
- s1 = peg$c116(s1, s3, s4);
18910
+ s1 = peg$c131(s1, s3, s4);
18777
18911
  s0 = s1;
18778
18912
  } else {
18779
18913
  peg$currPos = s0;
@@ -18794,7 +18928,7 @@ to a key`);
18794
18928
  return s0;
18795
18929
  }
18796
18930
  function peg$parseTabStartTag() {
18797
- let s0, s1, s2, s3, s4, s5, s6, s7;
18931
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8;
18798
18932
  s0 = peg$currPos;
18799
18933
  if (input.charCodeAt(peg$currPos) === 123) {
18800
18934
  s1 = peg$c44;
@@ -18806,41 +18940,48 @@ to a key`);
18806
18940
  if (s1 !== peg$FAILED) {
18807
18941
  s2 = peg$parse_();
18808
18942
  if (s2 !== peg$FAILED) {
18809
- if (input.substr(peg$currPos, 12) === peg$c134) {
18810
- s3 = peg$c134;
18943
+ if (input.substr(peg$currPos, 12) === peg$c149) {
18944
+ s3 = peg$c149;
18811
18945
  peg$currPos += 12;
18812
18946
  } else {
18813
18947
  s3 = peg$FAILED;
18814
- if (peg$silentFails === 0) peg$fail(peg$c135);
18948
+ if (peg$silentFails === 0) peg$fail(peg$c150);
18815
18949
  }
18816
18950
  if (s3 === peg$FAILED) {
18817
- if (input.substr(peg$currPos, 3) === peg$c136) {
18818
- s3 = peg$c136;
18951
+ if (input.substr(peg$currPos, 3) === peg$c151) {
18952
+ s3 = peg$c151;
18819
18953
  peg$currPos += 3;
18820
18954
  } else {
18821
18955
  s3 = peg$FAILED;
18822
- if (peg$silentFails === 0) peg$fail(peg$c137);
18956
+ if (peg$silentFails === 0) peg$fail(peg$c152);
18823
18957
  }
18824
18958
  }
18825
18959
  if (s3 !== peg$FAILED) {
18826
- s4 = peg$parse_();
18960
+ s4 = peg$parseTagSelector();
18961
+ if (s4 === peg$FAILED) s4 = null;
18827
18962
  if (s4 !== peg$FAILED) {
18828
- s5 = peg$parseTagColonWithValue();
18829
- if (s5 === peg$FAILED) s5 = null;
18963
+ s5 = peg$parse_();
18830
18964
  if (s5 !== peg$FAILED) {
18831
- s6 = peg$parse_();
18965
+ s6 = peg$parseTagColonWithValue();
18966
+ if (s6 === peg$FAILED) s6 = null;
18832
18967
  if (s6 !== peg$FAILED) {
18833
- if (input.charCodeAt(peg$currPos) === 125) {
18834
- s7 = peg$c30;
18835
- peg$currPos++;
18836
- } else {
18837
- s7 = peg$FAILED;
18838
- if (peg$silentFails === 0) peg$fail(peg$c31);
18839
- }
18968
+ s7 = peg$parse_();
18840
18969
  if (s7 !== peg$FAILED) {
18841
- peg$savedPos = s0;
18842
- s1 = peg$c66(s3, s5);
18843
- s0 = s1;
18970
+ if (input.charCodeAt(peg$currPos) === 125) {
18971
+ s8 = peg$c30;
18972
+ peg$currPos++;
18973
+ } else {
18974
+ s8 = peg$FAILED;
18975
+ if (peg$silentFails === 0) peg$fail(peg$c31);
18976
+ }
18977
+ if (s8 !== peg$FAILED) {
18978
+ peg$savedPos = s0;
18979
+ s1 = peg$c66(s3, s4, s6);
18980
+ s0 = s1;
18981
+ } else {
18982
+ peg$currPos = s0;
18983
+ s0 = peg$FAILED;
18984
+ }
18844
18985
  } else {
18845
18986
  peg$currPos = s0;
18846
18987
  s0 = peg$FAILED;
@@ -18884,20 +19025,20 @@ to a key`);
18884
19025
  if (s1 !== peg$FAILED) {
18885
19026
  s2 = peg$parse_();
18886
19027
  if (s2 !== peg$FAILED) {
18887
- if (input.substr(peg$currPos, 10) === peg$c138) {
18888
- s3 = peg$c138;
19028
+ if (input.substr(peg$currPos, 10) === peg$c153) {
19029
+ s3 = peg$c153;
18889
19030
  peg$currPos += 10;
18890
19031
  } else {
18891
19032
  s3 = peg$FAILED;
18892
- if (peg$silentFails === 0) peg$fail(peg$c139);
19033
+ if (peg$silentFails === 0) peg$fail(peg$c154);
18893
19034
  }
18894
19035
  if (s3 === peg$FAILED) {
18895
- if (input.substr(peg$currPos, 3) === peg$c140) {
18896
- s3 = peg$c140;
19036
+ if (input.substr(peg$currPos, 3) === peg$c155) {
19037
+ s3 = peg$c155;
18897
19038
  peg$currPos += 3;
18898
19039
  } else {
18899
19040
  s3 = peg$FAILED;
18900
- if (peg$silentFails === 0) peg$fail(peg$c141);
19041
+ if (peg$silentFails === 0) peg$fail(peg$c156);
18901
19042
  }
18902
19043
  }
18903
19044
  if (s3 !== peg$FAILED) {
@@ -18912,7 +19053,7 @@ to a key`);
18912
19053
  }
18913
19054
  if (s5 !== peg$FAILED) {
18914
19055
  peg$savedPos = s0;
18915
- s1 = peg$c121(s3);
19056
+ s1 = peg$c136(s3);
18916
19057
  s0 = s1;
18917
19058
  } else {
18918
19059
  peg$currPos = s0;
@@ -18943,7 +19084,7 @@ to a key`);
18943
19084
  peg$currPos++;
18944
19085
  } else {
18945
19086
  s0 = peg$FAILED;
18946
- if (peg$silentFails === 0) peg$fail(peg$c142);
19087
+ if (peg$silentFails === 0) peg$fail(peg$c157);
18947
19088
  }
18948
19089
  return s0;
18949
19090
  }
@@ -18960,7 +19101,7 @@ to a key`);
18960
19101
  peg$silentFails--;
18961
19102
  if (s0 === peg$FAILED) {
18962
19103
  s1 = peg$FAILED;
18963
- if (peg$silentFails === 0) peg$fail(peg$c143);
19104
+ if (peg$silentFails === 0) peg$fail(peg$c158);
18964
19105
  }
18965
19106
  return s0;
18966
19107
  }
@@ -18976,18 +19117,18 @@ to a key`);
18976
19117
  peg$silentFails--;
18977
19118
  if (s0 === peg$FAILED) {
18978
19119
  s1 = peg$FAILED;
18979
- if (peg$silentFails === 0) peg$fail(peg$c144);
19120
+ if (peg$silentFails === 0) peg$fail(peg$c159);
18980
19121
  }
18981
19122
  return s0;
18982
19123
  }
18983
19124
  function peg$parseWhitespaceCharacter() {
18984
19125
  let s0;
18985
- if (peg$c145.test(input.charAt(peg$currPos))) {
19126
+ if (peg$c160.test(input.charAt(peg$currPos))) {
18986
19127
  s0 = input.charAt(peg$currPos);
18987
19128
  peg$currPos++;
18988
19129
  } else {
18989
19130
  s0 = peg$FAILED;
18990
- if (peg$silentFails === 0) peg$fail(peg$c146);
19131
+ if (peg$silentFails === 0) peg$fail(peg$c161);
18991
19132
  }
18992
19133
  return s0;
18993
19134
  }
@@ -18996,21 +19137,21 @@ to a key`);
18996
19137
  peg$silentFails++;
18997
19138
  s0 = peg$currPos;
18998
19139
  s1 = [];
18999
- if (peg$c148.test(input.charAt(peg$currPos))) {
19140
+ if (peg$c163.test(input.charAt(peg$currPos))) {
19000
19141
  s2 = input.charAt(peg$currPos);
19001
19142
  peg$currPos++;
19002
19143
  } else {
19003
19144
  s2 = peg$FAILED;
19004
- if (peg$silentFails === 0) peg$fail(peg$c149);
19145
+ if (peg$silentFails === 0) peg$fail(peg$c164);
19005
19146
  }
19006
19147
  if (s2 !== peg$FAILED) while (s2 !== peg$FAILED) {
19007
19148
  s1.push(s2);
19008
- if (peg$c148.test(input.charAt(peg$currPos))) {
19149
+ if (peg$c163.test(input.charAt(peg$currPos))) {
19009
19150
  s2 = input.charAt(peg$currPos);
19010
19151
  peg$currPos++;
19011
19152
  } else {
19012
19153
  s2 = peg$FAILED;
19013
- if (peg$silentFails === 0) peg$fail(peg$c149);
19154
+ if (peg$silentFails === 0) peg$fail(peg$c164);
19014
19155
  }
19015
19156
  }
19016
19157
  else s1 = peg$FAILED;
@@ -19019,18 +19160,18 @@ to a key`);
19019
19160
  peg$silentFails--;
19020
19161
  if (s0 === peg$FAILED) {
19021
19162
  s1 = peg$FAILED;
19022
- if (peg$silentFails === 0) peg$fail(peg$c147);
19163
+ if (peg$silentFails === 0) peg$fail(peg$c162);
19023
19164
  }
19024
19165
  return s0;
19025
19166
  }
19026
19167
  function peg$parseNewLine() {
19027
19168
  let s0;
19028
- if (peg$c150.test(input.charAt(peg$currPos))) {
19169
+ if (peg$c165.test(input.charAt(peg$currPos))) {
19029
19170
  s0 = input.charAt(peg$currPos);
19030
19171
  peg$currPos++;
19031
19172
  } else {
19032
19173
  s0 = peg$FAILED;
19033
- if (peg$silentFails === 0) peg$fail(peg$c151);
19174
+ if (peg$silentFails === 0) peg$fail(peg$c166);
19034
19175
  }
19035
19176
  if (s0 === peg$FAILED) s0 = peg$parseCarriageReturnLineFeed();
19036
19177
  return s0;
@@ -19060,22 +19201,22 @@ to a key`);
19060
19201
  function peg$parseLineFeed() {
19061
19202
  let s0;
19062
19203
  if (input.charCodeAt(peg$currPos) === 10) {
19063
- s0 = peg$c152;
19204
+ s0 = peg$c167;
19064
19205
  peg$currPos++;
19065
19206
  } else {
19066
19207
  s0 = peg$FAILED;
19067
- if (peg$silentFails === 0) peg$fail(peg$c153);
19208
+ if (peg$silentFails === 0) peg$fail(peg$c168);
19068
19209
  }
19069
19210
  return s0;
19070
19211
  }
19071
19212
  function peg$parseCarriageReturn() {
19072
19213
  let s0;
19073
19214
  if (input.charCodeAt(peg$currPos) === 13) {
19074
- s0 = peg$c154;
19215
+ s0 = peg$c169;
19075
19216
  peg$currPos++;
19076
19217
  } else {
19077
19218
  s0 = peg$FAILED;
19078
- if (peg$silentFails === 0) peg$fail(peg$c155);
19219
+ if (peg$silentFails === 0) peg$fail(peg$c170);
19079
19220
  }
19080
19221
  return s0;
19081
19222
  }
@@ -19159,6 +19300,7 @@ to a key`);
19159
19300
  this.key = null;
19160
19301
  this.transposeKey = null;
19161
19302
  this.lineNumber = null;
19303
+ this.selector = null;
19162
19304
  this.textFont = new (0, $3b7d86e1e1307736$export$2e2bcd8739ae039)();
19163
19305
  this.chordFont = new (0, $3b7d86e1e1307736$export$2e2bcd8739ae039)();
19164
19306
  this.type = type;
@@ -19298,6 +19440,13 @@ to a key`);
19298
19440
  }
19299
19441
  };
19300
19442
  var $76b2b227aa06e8bf$export$2e2bcd8739ae039 = $76b2b227aa06e8bf$var$Line;
19443
+ function $8906e348466806fd$var$getCommonValue(values, fallback) {
19444
+ const uniqueValues = [
19445
+ ...new Set(values)
19446
+ ];
19447
+ if (uniqueValues.length === 1) return uniqueValues[0];
19448
+ return fallback;
19449
+ }
19301
19450
  var $8906e348466806fd$var$Paragraph = class {
19302
19451
  addLine(line) {
19303
19452
  this.lines.push(line);
@@ -19343,11 +19492,11 @@ to a key`);
19343
19492
  */
19344
19493
  get type() {
19345
19494
  const types = this.lines.map((line) => line.type);
19346
- const uniqueTypes = [
19347
- ...new Set(types)
19348
- ];
19349
- if (uniqueTypes.length === 1) return uniqueTypes[0];
19350
- return 0, $dce48cb70c4120bb$export$c5a6fe907430212e;
19495
+ return $8906e348466806fd$var$getCommonValue(types, (0, $dce48cb70c4120bb$export$c5a6fe907430212e));
19496
+ }
19497
+ get selector() {
19498
+ const selectors = this.lines.map((line) => line.selector).filter((selector) => selector !== null);
19499
+ return $8906e348466806fd$var$getCommonValue(selectors, null);
19351
19500
  }
19352
19501
  /**
19353
19502
  * Indicates whether the paragraph contains lines with renderable items.
@@ -19670,6 +19819,7 @@ to a key`);
19670
19819
  this.lines = [];
19671
19820
  this.metadata = new (0, $5c7afec93ec943b9$export$2e2bcd8739ae039)();
19672
19821
  this.sectionType = (0, $dce48cb70c4120bb$export$c53d0f541b41b88e);
19822
+ this.selector = null;
19673
19823
  this.transposeKey = null;
19674
19824
  this.warnings = [];
19675
19825
  this.song = song;
@@ -19688,15 +19838,16 @@ to a key`);
19688
19838
  this.currentLine = new (0, $76b2b227aa06e8bf$export$2e2bcd8739ae039)();
19689
19839
  this.lines.push(this.currentLine);
19690
19840
  }
19691
- this.setCurrentProperties(this.sectionType);
19841
+ this.setCurrentProperties(this.sectionType, this.selector);
19692
19842
  this.currentLine.transposeKey = this.transposeKey ?? this.currentKey;
19693
19843
  this.currentLine.key = this.currentKey || this.metadata.getSingle((0, $7251dad5f4a4c35f$export$7167c830cefcb6b5));
19694
19844
  this.currentLine.lineNumber = this.lines.length - 1;
19695
19845
  return this.currentLine;
19696
19846
  }
19697
- setCurrentProperties(sectionType) {
19847
+ setCurrentProperties(sectionType, selector = null) {
19698
19848
  if (!this.currentLine) throw new Error("Expected this.currentLine to be present");
19699
19849
  this.currentLine.type = sectionType;
19850
+ this.currentLine.selector = selector;
19700
19851
  this.currentLine.textFont = this.fontStack.textFont.clone();
19701
19852
  this.currentLine.chordFont = this.fontStack.chordFont.clone();
19702
19853
  }
@@ -19750,11 +19901,13 @@ to a key`);
19750
19901
  startSection(sectionType, tag) {
19751
19902
  this.checkCurrentSectionType((0, $dce48cb70c4120bb$export$c53d0f541b41b88e), tag);
19752
19903
  this.sectionType = sectionType;
19753
- this.setCurrentProperties(sectionType);
19904
+ this.selector = tag.selector;
19905
+ this.setCurrentProperties(sectionType, tag.selector);
19754
19906
  }
19755
19907
  endSection(sectionType, tag) {
19756
19908
  this.checkCurrentSectionType(sectionType, tag);
19757
19909
  this.sectionType = (0, $dce48cb70c4120bb$export$c53d0f541b41b88e);
19910
+ this.selector = null;
19758
19911
  }
19759
19912
  checkCurrentSectionType(sectionType, tag) {
19760
19913
  if (this.sectionType !== sectionType) this.addWarning(`Unexpected tag {${tag.originalName}}, current section is: ${this.sectionType}`, tag);
@@ -20286,12 +20439,13 @@ Or set the song key before changing key:
20286
20439
  return new (0, $551a223fc13b5c10$export$2e2bcd8739ae039)(chord ? new (0, $177a605b8569b31c$export$2e2bcd8739ae039)(chord).toString() : chords, lyrics, annotation);
20287
20440
  }
20288
20441
  parseTag(astComponent) {
20289
- const { name, value, location: { offset = null, line = null, column = null } = {}, chordDefinition, attributes } = astComponent;
20442
+ const { name, value, location: { offset = null, line = null, column = null } = {}, chordDefinition, attributes, selector } = astComponent;
20290
20443
  const tag = new (0, $7251dad5f4a4c35f$export$2e2bcd8739ae039)(name, value, {
20291
20444
  line,
20292
20445
  column,
20293
20446
  offset
20294
20447
  }, attributes);
20448
+ tag.selector = selector || null;
20295
20449
  if (chordDefinition) tag.chordDefinition = new (0, $36ec5eba476f1300$export$2e2bcd8739ae039)(chordDefinition.name, chordDefinition.baseFret, chordDefinition.frets, chordDefinition.fingers);
20296
20450
  return tag;
20297
20451
  }
@@ -20600,7 +20754,7 @@ Or set the song key before changing key:
20600
20754
  return classes.join(" ");
20601
20755
  }
20602
20756
  function $f9c5006b26957916$export$fef61f332f2c0afc(item, metadata, configuration) {
20603
- return item.evaluate(metadata, configuration.get("metadata.separator"));
20757
+ return item.evaluate(metadata, configuration.metadataSeparator);
20604
20758
  }
20605
20759
  function $f9c5006b26957916$export$ca030c9435779e4b(font) {
20606
20760
  const cssString = font.toCssString();
@@ -20705,7 +20859,7 @@ Or set the song key before changing key:
20705
20859
  return "";
20706
20860
  }
20707
20861
  formatEvaluatable(item, metadata) {
20708
- return item.evaluate(metadata, this.configuration.get("metadata.separator"));
20862
+ return item.evaluate(metadata, this.configuration.metadataSeparator);
20709
20863
  }
20710
20864
  formatChordLyricsPair(item, line) {
20711
20865
  return (0, $28a2fcb6fb95a147$export$bc3bea8325045070)(item.lyrics || "", this.chordLyricsPairLength(item, line));
@@ -32838,7 +32992,7 @@ Or set the song key before changing key:
32838
32992
  var $1408adfd7317f0b6$export$2e2bcd8739ae039 = ({ configuration, configuration: { key }, song, renderBlankLines = false, song: { title, subtitle, metadata }, bodyParagraphs }) => (0, $f9c5006b26957916$export$6ea1b0eb82ead3f)(`
32839
32993
  ${(0, $f9c5006b26957916$export$a55877ca9db47377)(title, () => `<h1>${title}</h1>`)}
32840
32994
  ${(0, $f9c5006b26957916$export$a55877ca9db47377)(subtitle, () => `<h2>${subtitle}</h2>`)}
32841
-
32995
+
32842
32996
  <div class="chord-sheet">
32843
32997
  ${(0, $f9c5006b26957916$export$79b2f7037acddd43)(bodyParagraphs, (paragraph) => `
32844
32998
  <div class="${(0, $f9c5006b26957916$export$dcd1550c9709312c)(paragraph)}">
@@ -32873,7 +33027,7 @@ Or set the song key before changing key:
32873
33027
  ${(0, $f9c5006b26957916$export$a55877ca9db47377)((0, $f9c5006b26957916$export$3ab01370f5e64ac8)(item), () => `
32874
33028
  <div class="comment">${item.value}</div>
32875
33029
  `)}
32876
-
33030
+
32877
33031
  ${(0, $f9c5006b26957916$export$a55877ca9db47377)(item.hasRenderableLabel(), () => `
32878
33032
  <h3 class="label">${item.label}</h3>
32879
33033
  `)}
@@ -32958,7 +33112,7 @@ Or set the song key before changing key:
32958
33112
  `)}
32959
33113
  </tr>
32960
33114
  `)}
32961
-
33115
+
32962
33116
  ${(0, $f9c5006b26957916$export$a55877ca9db47377)((0, $f9c5006b26957916$export$b8d631d9200974fa)(line), () => `
32963
33117
  <tr>
32964
33118
  ${(0, $f9c5006b26957916$export$79b2f7037acddd43)(line.items, (item) => `
@@ -32968,7 +33122,7 @@ Or set the song key before changing key:
32968
33122
  ${(0, $f9c5006b26957916$export$a55877ca9db47377)((0, $f9c5006b26957916$export$3ab01370f5e64ac8)(item), () => `
32969
33123
  <td class="comment"${(0, $f9c5006b26957916$export$ca030c9435779e4b)(line.textFont)}>${item.value}</td>
32970
33124
  `)}
32971
-
33125
+
32972
33126
  ${(0, $f9c5006b26957916$export$a55877ca9db47377)(item.hasRenderableLabel(), () => `
32973
33127
  <td><h3 class="label"${(0, $f9c5006b26957916$export$ca030c9435779e4b)(line.textFont)}>${item.label}</h3></td>
32974
33128
  `)}
@@ -33110,7 +33264,7 @@ Or set the song key before changing key:
33110
33264
  formatItemBottom(item, metadata, line) {
33111
33265
  if (item instanceof (0, $7251dad5f4a4c35f$export$2e2bcd8739ae039) && item.isRenderable()) return item.label;
33112
33266
  if (item instanceof (0, $551a223fc13b5c10$export$2e2bcd8739ae039)) return (0, $28a2fcb6fb95a147$export$bc3bea8325045070)(item.lyrics || "", this.chordLyricsPairLength(item, line));
33113
- if ("evaluate" in item) return item.evaluate(metadata, this.configuration.get("metadata.separator"));
33267
+ if ("evaluate" in item) return item.evaluate(metadata, this.configuration.metadataSeparator);
33114
33268
  return "";
33115
33269
  }
33116
33270
  constructor(...args) {